VLC_EXPORT( int, __vlc_cond_init, ( vlc_cond_t * ) );
VLC_EXPORT( void, __vlc_cond_destroy, ( const char *, int, vlc_cond_t * ) );
VLC_EXPORT( int, __vlc_threadvar_create, (vlc_threadvar_t * ) );
-VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( void * ), int, vlc_bool_t ) );
+VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( void * ), int, bool ) );
VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, const char *, int, int ) );
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const 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 ) \
+#define vlc_mutex_init( P_MUTEX ) \
__vlc_mutex_init( P_MUTEX )
/*****************************************************************************
* vlc_mutex_init: initialize a recursive mutex (Don't use it)
*****************************************************************************/
-#define vlc_mutex_init_recursive( P_THIS, P_MUTEX ) \
+#define vlc_mutex_init_recursive( P_MUTEX ) \
__vlc_mutex_init_recursive( P_MUTEX )
/*****************************************************************************
vlc_mutex_t * p_mutex )
{
#if defined( UNDER_CE )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
EnterCriticalSection( &p_mutex->csection );
#elif defined( WIN32 )
- if( p_mutex->mutex )
- WaitForSingleObject( p_mutex->mutex, INFINITE );
- else
- EnterCriticalSection( &p_mutex->csection );
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+ WaitForSingleObject( *p_mutex, INFINITE );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
acquire_sem( p_mutex->lock );
#elif defined(LIBVLC_USE_PTHREAD)
# define vlc_assert_locked( m ) \
- assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK)
- int val = pthread_mutex_lock( &p_mutex->mutex );
+ assert (pthread_mutex_lock (m) == EDEADLK)
+ int val = pthread_mutex_lock( p_mutex );
VLC_THREAD_ASSERT ("locking mutex");
#endif
vlc_mutex_t *p_mutex )
{
#if defined( UNDER_CE )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
LeaveCriticalSection( &p_mutex->csection );
#elif defined( WIN32 )
- if( p_mutex->mutex )
- ReleaseMutex( p_mutex->mutex );
- else
- LeaveCriticalSection( &p_mutex->csection );
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+ ReleaseMutex( *p_mutex );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
release_sem( p_mutex->lock );
#elif defined(LIBVLC_USE_PTHREAD)
- int val = pthread_mutex_unlock( &p_mutex->mutex );
+ int val = pthread_mutex_unlock( p_mutex );
VLC_THREAD_ASSERT ("unlocking mutex");
#endif
static inline void __vlc_cond_signal( const char * psz_file, int i_line,
vlc_cond_t *p_condvar )
{
-#if defined( UNDER_CE )
- PulseEvent( p_condvar->event );
+#if defined( UNDER_CE ) || defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-#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() only works if none of the waiting threads is suspended.
- * This is particularily problematic under a debug session.
- * as documented in http://support.microsoft.com/kb/q173260/ */
- 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 );
- }
- }
+ /* PulseEvent() only works if none of the waiting threads is suspended.
+ * This is particularily problematic under a debug session.
+ * as documented in http://support.microsoft.com/kb/q173260/ */
+ PulseEvent( p_condvar->event );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
while( p_condvar->thread != -1 )
}
#elif defined(LIBVLC_USE_PTHREAD)
- int val = pthread_cond_signal( &p_condvar->cond );
+ int val = pthread_cond_signal( p_condvar );
VLC_THREAD_ASSERT ("signaling condition variable");
#endif
vlc_mutex_lock( p_mutex );
#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;
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
- LeaveCriticalSection( &p_condvar->csection );
-
- /* Signal that the last waiting thread just went through */
- if( !i_waiting_threads )
- SetEvent( p_condvar->event );
- }
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
+ SignalObjectAndWait( *p_mutex, p_condvar->event, INFINITE, FALSE );
+ p_condvar->i_waiting_threads--;
/* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex );
vlc_mutex_lock( p_mutex );
#elif defined(LIBVLC_USE_PTHREAD)
- int val = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
+ int val = pthread_cond_wait( p_condvar, p_mutex );
VLC_THREAD_ASSERT ("waiting on condition");
#endif
return ETIMEDOUT; /* this error is perfectly normal */
#elif defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
DWORD result;
mtime_t delay_ms = (deadline - mdate())/1000;
if( delay_ms < 0 )
delay_ms = 0;
- 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(). */
- result = p_condvar->SignalObjectAndWait( p_mutex->mutex,
- p_condvar->event,
- delay_ms, FALSE );
- }
- else
- {
- LeaveCriticalSection( &p_mutex->csection );
- result = WaitForSingleObject( p_condvar->event, delay_ms );
- }
-
- p_condvar->i_waiting_threads--;
- }
- else if( p_condvar->i_win9x_cv == 1 )
- {
- int i_waiting_threads;
-
- /* Wait for the gate to be open */
- result = WaitForSingleObject( p_condvar->event, delay_ms );
-
- /* Increase our wait count */
- p_condvar->i_waiting_threads++;
-
- LeaveCriticalSection( &p_mutex->csection );
- if( !result )
- {
- /* recaculate remaining delay */
- delay_ms = (deadline - mdate())/1000;
- if( delay_ms < 0 )
- delay_ms = 0;
-
- result = WaitForSingleObject( p_condvar->semaphore, delay_ms );
- }
-
- /* 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 );
- result = WaitForSingleObject( p_condvar->semaphore, delay_ms );
-
- /* 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 );
- }
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
+ result = SignalObjectAndWait( *p_mutex, p_condvar->event,
+ delay_ms, FALSE );
+ p_condvar->i_waiting_threads--;
/* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex );
lldiv_t d = lldiv( deadline, 1000000 );
struct timespec ts = { d.quot, d.rem * 1000 };
- int val = pthread_cond_timedwait (&p_condvar->cond, &p_mutex->mutex, &ts);
+ int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
if (val == ETIMEDOUT)
return ETIMEDOUT; /* this error is perfectly normal */
VLC_THREAD_ASSERT ("timed-waiting on condition");
int i_ret;
#if defined( HAVE_KERNEL_SCHEDULER_H )
- return -1;
+ i_ret = EINVAL;
#elif defined( UNDER_CE ) || defined( WIN32 )
- i_ret = ( TlsSetValue( p_tls->handle, p_value ) != 0 );
+ i_ret = TlsSetValue( *p_tls, p_value ) ? EINVAL : 0;
#elif defined(LIBVLC_USE_PTHREAD)
- i_ret = pthread_setspecific( p_tls->handle, p_value );
+ i_ret = pthread_setspecific( *p_tls, p_value );
#endif
*****************************************************************************/
static inline void* vlc_threadvar_get( vlc_threadvar_t * p_tls )
{
- void* p_ret;
+ void *p_ret;
#if defined( HAVE_KERNEL_SCHEDULER_H )
p_ret = NULL;
+
#elif defined( UNDER_CE ) || defined( WIN32 )
- p_ret = TlsGetValue( p_tls->handle );
+ p_ret = TlsGetValue( *p_tls );
#elif defined(LIBVLC_USE_PTHREAD)
- p_ret = pthread_getspecific( p_tls->handle );
+ p_ret = pthread_getspecific( *p_tls );
#endif
{
int val = pthread_spin_lock (&spin->spin);
assert (val == 0);
+ (void)val;
}
/**
{
int val = pthread_spin_unlock (&spin->spin);
assert (val == 0);
+ (void)val;
}
/**
{
int val = pthread_spin_destroy (&spin->spin);
assert (val == 0);
+ (void)val;
}
#elif defined( WIN32 )
projects / vlc / blobdiff