From owner-freebsd-multimedia@FreeBSD.ORG Thu Jun 21 23:05:00 2007 Return-Path: X-Original-To: multimedia@freebsd.org Delivered-To: freebsd-multimedia@FreeBSD.ORG Received: from mx1.freebsd.org (mx1.freebsd.org [69.147.83.52]) by hub.freebsd.org (Postfix) with ESMTP id 85BF116A400 for ; Thu, 21 Jun 2007 23:05:00 +0000 (UTC) (envelope-from andrewter@comcast.net) Received: from alnrmhc13.comcast.net (alnrmhc13.comcast.net [206.18.177.53]) by mx1.freebsd.org (Postfix) with ESMTP id 572BE13C44C for ; Thu, 21 Jun 2007 23:05:00 +0000 (UTC) (envelope-from andrewter@comcast.net) Received: from [10.94.3.60] (unknown[204.13.59.250]) by comcast.net (alnrmhc13) with ESMTP id <20070621225032b1300ne9rre>; Thu, 21 Jun 2007 22:50:32 +0000 Message-ID: <467B00B7.2070900@comcast.net> Date: Thu, 21 Jun 2007 15:50:31 -0700 From: Andrew Terekhov User-Agent: Thunderbird 1.5.0.12 (Windows/20070509) MIME-Version: 1.0 To: multimedia@FreeBSD.org Content-Type: multipart/mixed; boundary="------------070506010508000504070105" Cc: Subject: vlc fails to compile on gcc 4.2 (patch included) X-BeenThere: freebsd-multimedia@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: Multimedia discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 21 Jun 2007 23:05:00 -0000 This is a multi-part message in MIME format. --------------070506010508000504070105 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit The error is caused by converting variable of type pthread_t to int type. I attached the fixed file, patch is here: --- ./work/vlc-0.8.6c/include/vlc_threads_funcs.h-orig Thu Jun 21 15:19:07 2007 +++ /usr/ports/vlc_threads_funcs.h Thu Jun 21 15:34:47 2007 @@ -69,7 +69,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -111,7 +111,7 @@ i_result = pthread_mutex_lock( &p_mutex->mutex ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -124,8 +124,8 @@ if( i_result ) { msg_Err( p_mutex->p_this, - "thread %u: mutex_lock failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: mutex_lock failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } @@ -141,7 +141,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -184,7 +184,7 @@ i_result = pthread_mutex_unlock( &p_mutex->mutex ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -197,8 +197,8 @@ if( i_result ) { msg_Err( p_mutex->p_this, - "thread %u: mutex_unlock failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: mutex_unlock failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; @@ -227,7 +227,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -322,7 +322,7 @@ i_result = pthread_cond_signal( &p_condvar->cond ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -339,8 +339,8 @@ if( i_result ) { msg_Err( p_condvar->p_this, - "thread %u: cond_signal failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: cond_signal failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; @@ -357,7 +357,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -499,8 +499,8 @@ { /* People keep pissing me off with this. --Meuuh */ msg_Dbg( p_condvar->p_this, - "thread %u: secret message triggered " - "at %s:%d (%s)", (int)pthread_self(), + "thread %p: secret message triggered " + "at %s:%d (%s)", pthread_self(), psz_file, i_line, strerror(i_result) ); i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex ); @@ -512,7 +512,7 @@ if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -525,8 +525,8 @@ if( i_result ) { msg_Err( p_condvar->p_this, - "thread %u: cond_wait failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: cond_wait failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; Thanks, Andrew --------------070506010508000504070105 Content-Type: text/plain; name="patch.diff" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="patch.diff" --- ./work/vlc-0.8.6c/include/vlc_threads_funcs.h-orig Thu Jun 21 15:19:07 2007 +++ /usr/ports/vlc_threads_funcs.h Thu Jun 21 15:34:47 2007 @@ -69,7 +69,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -111,7 +111,7 @@ i_result = pthread_mutex_lock( &p_mutex->mutex ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -124,8 +124,8 @@ if( i_result ) { msg_Err( p_mutex->p_this, - "thread %u: mutex_lock failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: mutex_lock failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } @@ -141,7 +141,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -184,7 +184,7 @@ i_result = pthread_mutex_unlock( &p_mutex->mutex ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -197,8 +197,8 @@ if( i_result ) { msg_Err( p_mutex->p_this, - "thread %u: mutex_unlock failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: mutex_unlock failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; @@ -227,7 +227,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -322,7 +322,7 @@ i_result = pthread_cond_signal( &p_condvar->cond ); if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -339,8 +339,8 @@ if( i_result ) { msg_Err( p_condvar->p_this, - "thread %u: cond_signal failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: cond_signal failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; @@ -357,7 +357,7 @@ { int i_result; /* In case of error : */ - int i_thread = -1; + pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) @@ -499,8 +499,8 @@ { /* People keep pissing me off with this. --Meuuh */ msg_Dbg( p_condvar->p_this, - "thread %u: secret message triggered " - "at %s:%d (%s)", (int)pthread_self(), + "thread %p: secret message triggered " + "at %s:%d (%s)", pthread_self(), psz_file, i_line, strerror(i_result) ); i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex ); @@ -512,7 +512,7 @@ if ( i_result ) { - i_thread = (int)pthread_self(); + p_thread = pthread_self(); psz_error = strerror(i_result); } @@ -525,8 +525,8 @@ if( i_result ) { msg_Err( p_condvar->p_this, - "thread %u: cond_wait failed at %s:%d (%d:%s)", - i_thread, psz_file, i_line, i_result, psz_error ); + "thread %p: cond_wait failed at %s:%d (%d:%s)", + p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; --------------070506010508000504070105 Content-Type: text/plain; name="vlc_threads_funcs.h" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="vlc_threads_funcs.h" /***************************************************************************** * vlc_threads_funcs.h : threads implementation for the VideoLAN client * This header provides a portable threads implementation. ***************************************************************************** * Copyright (C) 1999, 2002 the VideoLAN team * $Id: vlc_threads_funcs.h 14644 2006-03-05 15:32:01Z courmisch $ * * Authors: Jean-Marc Dressler * Samuel Hocevar * Gildas Bazin * Christophe Massiot * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Function definitions *****************************************************************************/ VLC_EXPORT( int, __vlc_threads_init, ( vlc_object_t * ) ); VLC_EXPORT( int, __vlc_threads_end, ( vlc_object_t * ) ); VLC_EXPORT( int, __vlc_mutex_init, ( vlc_object_t *, vlc_mutex_t * ) ); VLC_EXPORT( int, __vlc_mutex_destroy, ( char *, int, vlc_mutex_t * ) ); VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, vlc_cond_t * ) ); VLC_EXPORT( int, __vlc_cond_destroy, ( char *, int, vlc_cond_t * ) ); VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, char *, int, char *, void * ( * ) ( void * ), int, vlc_bool_t ) ); VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, char *, int, int ) ); VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) ); VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, char *, int ) ); /***************************************************************************** * vlc_threads_init: initialize threads system *****************************************************************************/ #define vlc_threads_init( P_THIS ) \ __vlc_threads_init( VLC_OBJECT(P_THIS) ) /***************************************************************************** * vlc_threads_end: deinitialize threads system *****************************************************************************/ #define vlc_threads_end( P_THIS ) \ __vlc_threads_end( VLC_OBJECT(P_THIS) ) /***************************************************************************** * vlc_mutex_init: initialize a mutex *****************************************************************************/ #define vlc_mutex_init( P_THIS, P_MUTEX ) \ __vlc_mutex_init( VLC_OBJECT(P_THIS), P_MUTEX ) /***************************************************************************** * vlc_mutex_lock: lock a mutex *****************************************************************************/ #define vlc_mutex_lock( P_MUTEX ) \ __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX ) static inline int __vlc_mutex_lock( const char * psz_file, int i_line, vlc_mutex_t * p_mutex ) { int i_result; /* In case of error : */ pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) i_result = ( pth_mutex_acquire( &p_mutex->mutex, FALSE, NULL ) == FALSE ); #elif defined( ST_INIT_IN_ST_H ) i_result = st_mutex_lock( p_mutex->mutex ); #elif defined( UNDER_CE ) EnterCriticalSection( &p_mutex->csection ); i_result = 0; #elif defined( WIN32 ) if( p_mutex->mutex ) { WaitForSingleObject( p_mutex->mutex, INFINITE ); } else { EnterCriticalSection( &p_mutex->csection ); } i_result = 0; #elif defined( HAVE_KERNEL_SCHEDULER_H ) if( p_mutex == NULL ) { i_result = B_BAD_VALUE; } else if( p_mutex->init < 2000 ) { i_result = B_NO_INIT; } else { i_result = acquire_sem( p_mutex->lock ); } #elif defined( PTHREAD_COND_T_IN_PTHREAD_H ) i_result = pthread_mutex_lock( &p_mutex->mutex ); if ( i_result ) { p_thread = pthread_self(); psz_error = strerror(i_result); } #elif defined( HAVE_CTHREADS_H ) mutex_lock( p_mutex->mutex ); i_result = 0; #endif if( i_result ) { msg_Err( p_mutex->p_this, "thread %p: mutex_lock failed at %s:%d (%d:%s)", p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } /***************************************************************************** * vlc_mutex_unlock: unlock a mutex *****************************************************************************/ #define vlc_mutex_unlock( P_MUTEX ) \ __vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX ) static inline int __vlc_mutex_unlock( const char * psz_file, int i_line, vlc_mutex_t *p_mutex ) { int i_result; /* In case of error : */ pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) i_result = ( pth_mutex_release( &p_mutex->mutex ) == FALSE ); #elif defined( ST_INIT_IN_ST_H ) i_result = st_mutex_unlock( p_mutex->mutex ); #elif defined( UNDER_CE ) LeaveCriticalSection( &p_mutex->csection ); i_result = 0; #elif defined( WIN32 ) if( p_mutex->mutex ) { ReleaseMutex( p_mutex->mutex ); } else { LeaveCriticalSection( &p_mutex->csection ); } i_result = 0; #elif defined( HAVE_KERNEL_SCHEDULER_H ) if( p_mutex == NULL ) { i_result = B_BAD_VALUE; } else if( p_mutex->init < 2000 ) { i_result = B_NO_INIT; } else { release_sem( p_mutex->lock ); return B_OK; } #elif defined( PTHREAD_COND_T_IN_PTHREAD_H ) i_result = pthread_mutex_unlock( &p_mutex->mutex ); if ( i_result ) { p_thread = pthread_self(); psz_error = strerror(i_result); } #elif defined( HAVE_CTHREADS_H ) mutex_unlock( p_mutex ); i_result = 0; #endif if( i_result ) { msg_Err( p_mutex->p_this, "thread %p: mutex_unlock failed at %s:%d (%d:%s)", p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } /***************************************************************************** * vlc_mutex_destroy: destroy a mutex *****************************************************************************/ #define vlc_mutex_destroy( P_MUTEX ) \ __vlc_mutex_destroy( __FILE__, __LINE__, P_MUTEX ) /***************************************************************************** * vlc_cond_init: initialize a condition *****************************************************************************/ #define vlc_cond_init( P_THIS, P_COND ) \ __vlc_cond_init( VLC_OBJECT(P_THIS), P_COND ) /***************************************************************************** * vlc_cond_signal: start a thread on condition completion *****************************************************************************/ #define vlc_cond_signal( P_COND ) \ __vlc_cond_signal( __FILE__, __LINE__, P_COND ) static inline int __vlc_cond_signal( const char * psz_file, int i_line, vlc_cond_t *p_condvar ) { int i_result; /* In case of error : */ pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) i_result = ( pth_cond_notify( &p_condvar->cond, FALSE ) == FALSE ); #elif defined( ST_INIT_IN_ST_H ) i_result = st_cond_signal( p_condvar->cond ); #elif defined( UNDER_CE ) PulseEvent( p_condvar->event ); i_result = 0; #elif defined( WIN32 ) /* Release one waiting thread if one is available. */ /* For this trick to work properly, the vlc_cond_signal must be surrounded * by a mutex. This will prevent another thread from stealing the signal */ if( !p_condvar->semaphore ) { PulseEvent( p_condvar->event ); } else if( p_condvar->i_win9x_cv == 1 ) { /* Wait for the gate to be open */ WaitForSingleObject( p_condvar->event, INFINITE ); if( p_condvar->i_waiting_threads ) { /* Using a semaphore exposes us to a race condition. It is * possible for another thread to start waiting on the semaphore * just after we signaled it and thus steal the signal. * We have to prevent new threads from entering the cond_wait(). */ ResetEvent( p_condvar->event ); /* A semaphore is used here because Win9x doesn't have * SignalObjectAndWait() and thus a race condition exists * during the time we release the mutex and the time we start * waiting on the event (more precisely, the signal can sometimes * be missed by the waiting thread if we use PulseEvent()). */ ReleaseSemaphore( p_condvar->semaphore, 1, 0 ); } } else { if( p_condvar->i_waiting_threads ) { ReleaseSemaphore( p_condvar->semaphore, 1, 0 ); /* Wait for the last thread to be awakened */ WaitForSingleObject( p_condvar->event, INFINITE ); } } i_result = 0; #elif defined( HAVE_KERNEL_SCHEDULER_H ) if( p_condvar == NULL ) { i_result = B_BAD_VALUE; } else if( p_condvar->init < 2000 ) { i_result = B_NO_INIT; } else { while( p_condvar->thread != -1 ) { thread_info info; if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE ) { return 0; } if( info.state != B_THREAD_SUSPENDED ) { /* The waiting thread is not suspended so it could * have been interrupted beetwen the unlock and the * suspend_thread line. That is why we sleep a little * before retesting p_condver->thread. */ snooze( 10000 ); } else { /* Ok, we have to wake up that thread */ resume_thread( p_condvar->thread ); return 0; } } i_result = 0; } #elif defined( PTHREAD_COND_T_IN_PTHREAD_H ) i_result = pthread_cond_signal( &p_condvar->cond ); if ( i_result ) { p_thread = pthread_self(); psz_error = strerror(i_result); } #elif defined( HAVE_CTHREADS_H ) /* condition_signal() */ if ( p_condvar->queue.head || p_condvar->implications ) { cond_signal( (condition_t)p_condvar ); } i_result = 0; #endif if( i_result ) { msg_Err( p_condvar->p_this, "thread %p: cond_signal failed at %s:%d (%d:%s)", p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } /***************************************************************************** * vlc_cond_wait: wait until condition completion *****************************************************************************/ #define vlc_cond_wait( P_COND, P_MUTEX ) \ __vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX ) static inline int __vlc_cond_wait( const char * psz_file, int i_line, vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex ) { int i_result; /* In case of error : */ pthread_t p_thread = NULL; const char * psz_error = ""; #if defined( PTH_INIT_IN_PTH_H ) i_result = ( pth_cond_await( &p_condvar->cond, &p_mutex->mutex, NULL ) == FALSE ); #elif defined( ST_INIT_IN_ST_H ) st_mutex_unlock( p_mutex->mutex ); i_result = st_cond_wait( p_condvar->cond ); st_mutex_lock( p_mutex->mutex ); #elif defined( UNDER_CE ) p_condvar->i_waiting_threads++; LeaveCriticalSection( &p_mutex->csection ); WaitForSingleObject( p_condvar->event, INFINITE ); p_condvar->i_waiting_threads--; /* Reacquire the mutex before returning. */ vlc_mutex_lock( p_mutex ); i_result = 0; #elif defined( WIN32 ) if( !p_condvar->semaphore ) { /* Increase our wait count */ p_condvar->i_waiting_threads++; if( p_mutex->mutex ) { /* It is only possible to atomically release the mutex and * initiate the waiting on WinNT/2K/XP. Win9x doesn't have * SignalObjectAndWait(). */ p_condvar->SignalObjectAndWait( p_mutex->mutex, p_condvar->event, INFINITE, FALSE ); } else { LeaveCriticalSection( &p_mutex->csection ); WaitForSingleObject( p_condvar->event, INFINITE ); } p_condvar->i_waiting_threads--; } else if( p_condvar->i_win9x_cv == 1 ) { int i_waiting_threads; /* Wait for the gate to be open */ WaitForSingleObject( p_condvar->event, INFINITE ); /* Increase our wait count */ p_condvar->i_waiting_threads++; LeaveCriticalSection( &p_mutex->csection ); WaitForSingleObject( p_condvar->semaphore, INFINITE ); /* Decrement and test must be atomic */ EnterCriticalSection( &p_condvar->csection ); /* Decrease our wait count */ i_waiting_threads = --p_condvar->i_waiting_threads; LeaveCriticalSection( &p_condvar->csection ); /* Reopen the gate if we were the last waiting thread */ if( !i_waiting_threads ) SetEvent( p_condvar->event ); } else { int i_waiting_threads; /* Increase our wait count */ p_condvar->i_waiting_threads++; LeaveCriticalSection( &p_mutex->csection ); WaitForSingleObject( p_condvar->semaphore, INFINITE ); /* Decrement and test must be atomic */ EnterCriticalSection( &p_condvar->csection ); /* Decrease our wait count */ i_waiting_threads = --p_condvar->i_waiting_threads; LeaveCriticalSection( &p_condvar->csection ); /* Signal that the last waiting thread just went through */ if( !i_waiting_threads ) SetEvent( p_condvar->event ); } /* Reacquire the mutex before returning. */ vlc_mutex_lock( p_mutex ); i_result = 0; #elif defined( HAVE_KERNEL_SCHEDULER_H ) if( p_condvar == NULL ) { i_result = B_BAD_VALUE; } else if( p_mutex == NULL ) { i_result = B_BAD_VALUE; } else if( p_condvar->init < 2000 ) { i_result = B_NO_INIT; } /* The p_condvar->thread var is initialized before the unlock because * it enables to identify when the thread is interrupted beetwen the * unlock line and the suspend_thread line */ p_condvar->thread = find_thread( NULL ); vlc_mutex_unlock( p_mutex ); suspend_thread( p_condvar->thread ); p_condvar->thread = -1; vlc_mutex_lock( p_mutex ); i_result = 0; #elif defined( PTHREAD_COND_T_IN_PTHREAD_H ) # ifdef DEBUG /* In debug mode, timeout */ struct timeval now; struct timespec timeout; gettimeofday( &now, NULL ); timeout.tv_sec = now.tv_sec + THREAD_COND_TIMEOUT; timeout.tv_nsec = now.tv_usec * 1000; i_result = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex, &timeout ); if( i_result == ETIMEDOUT ) { /* People keep pissing me off with this. --Meuuh */ msg_Dbg( p_condvar->p_this, "thread %p: secret message triggered " "at %s:%d (%s)", pthread_self(), psz_file, i_line, strerror(i_result) ); i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex ); } # else i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex ); # endif if ( i_result ) { p_thread = pthread_self(); psz_error = strerror(i_result); } #elif defined( HAVE_CTHREADS_H ) condition_wait( (condition_t)p_condvar, (mutex_t)p_mutex ); i_result = 0; #endif if( i_result ) { msg_Err( p_condvar->p_this, "thread %p: cond_wait failed at %s:%d (%d:%s)", p_thread, psz_file, i_line, i_result, psz_error ); } return i_result; } /***************************************************************************** * vlc_cond_destroy: destroy a condition *****************************************************************************/ #define vlc_cond_destroy( P_COND ) \ __vlc_cond_destroy( __FILE__, __LINE__, P_COND ) /***************************************************************************** * vlc_thread_create: create a thread *****************************************************************************/ #define vlc_thread_create( P_THIS, PSZ_NAME, FUNC, PRIORITY, WAIT ) \ __vlc_thread_create( VLC_OBJECT(P_THIS), __FILE__, __LINE__, PSZ_NAME, (void * ( * ) ( void * ))FUNC, PRIORITY, WAIT ) /***************************************************************************** * vlc_thread_set_priority: set the priority of the calling thread *****************************************************************************/ #define vlc_thread_set_priority( P_THIS, PRIORITY ) \ __vlc_thread_set_priority( VLC_OBJECT(P_THIS), __FILE__, __LINE__, PRIORITY ) /***************************************************************************** * vlc_thread_ready: tell the parent thread we were successfully spawned *****************************************************************************/ #define vlc_thread_ready( P_THIS ) \ __vlc_thread_ready( VLC_OBJECT(P_THIS) ) /***************************************************************************** * vlc_thread_join: wait until a thread exits *****************************************************************************/ #define vlc_thread_join( P_THIS ) \ __vlc_thread_join( VLC_OBJECT(P_THIS), __FILE__, __LINE__ ) --------------070506010508000504070105--