X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=include%2Fvlc_threads_funcs.h;h=b144d759fc1b133cea690c0bcd1527adc9bbdfd7;hb=6b42b421710760b88561364ecc585b93aee7790a;hp=f99ff3305a533edf50bd4b0eb0001d749ffa1cf0;hpb=9403fcee68290b70f41dcb2aa6efc1093f837657;p=vlc

diff --git a/include/vlc_threads_funcs.h b/include/vlc_threads_funcs.h
index f99ff3305a..b144d759fc 100644
--- a/include/vlc_threads_funcs.h
+++ b/include/vlc_threads_funcs.h
@@ -32,52 +32,24 @@
 #ifndef _VLC_THREADFUNCS_H_
 #define _VLC_THREADFUNCS_H_
 
+#if defined( WIN32 ) && !defined ETIMEDOUT
+#  define ETIMEDOUT 10060 /* This is the value in winsock.h. */
+#endif
+
 /*****************************************************************************
  * Function definitions
  *****************************************************************************/
-VLC_EXPORT( void, vlc_threads_error, ( vlc_object_t *) );
-VLC_EXPORT( int,  __vlc_mutex_init,    ( vlc_object_t *, vlc_mutex_t * ) );
-VLC_EXPORT( int,  __vlc_mutex_init_recursive, ( vlc_object_t *, vlc_mutex_t * ) );
-VLC_EXPORT( int,  __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) );
-VLC_EXPORT( int,  __vlc_cond_init,     ( vlc_object_t *, vlc_cond_t * ) );
-VLC_EXPORT( int,  __vlc_cond_destroy,  ( const char *, int, vlc_cond_t * ) );
-VLC_EXPORT( int, __vlc_threadvar_create, (vlc_object_t *, 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_mutex_init,    ( vlc_mutex_t * ) );
+VLC_EXPORT( int,  vlc_mutex_init_recursive, ( vlc_mutex_t * ) );
+VLC_EXPORT( void,  __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) );
+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, 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_error: Signalize an error in the threading system
- *****************************************************************************/
-#ifdef NDEBUG
-# define vlc_threads_error( P_THIS ) (void)0
-#endif
-
-/*****************************************************************************
- * 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_init: initialize a recursive mutex (Don't use it)
- *****************************************************************************/
-#define vlc_mutex_init_recursive( P_THIS, P_MUTEX )                         \
-    __vlc_mutex_init_recursive( VLC_OBJECT(P_THIS), P_MUTEX )
-
 /*****************************************************************************
  * vlc_mutex_lock: lock a mutex
  *****************************************************************************/
@@ -85,71 +57,38 @@ VLC_EXPORT( void, __vlc_thread_join,   ( vlc_object_t *, const char *, int ) );
     __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
 
 #if defined(LIBVLC_USE_PTHREAD)
-static inline unsigned long int CAST_PTHREAD_TO_INT (pthread_t th)
-{
-     union { pthread_t th; unsigned long int i; } v = { };
-     v.th = th;
-     return v.i;
-}
+VLC_EXPORT(void, vlc_pthread_fatal, (const char *action, int error, const char *file, unsigned line));
+
+# define VLC_THREAD_ASSERT( action ) \
+    if (val) \
+        vlc_pthread_fatal (action, val, psz_file, i_line)
+#else
+# define VLC_THREAD_ASSERT (void)0
 #endif
 
-static inline int __vlc_mutex_lock( const char * psz_file, int i_line,
+static inline void __vlc_mutex_lock( const char * psz_file, int i_line,
                                     vlc_mutex_t * p_mutex )
 {
-    int i_result;
-    /* In case of error : */
-    unsigned long int i_thread = 0;
-
 #if defined( UNDER_CE )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
     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;
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    WaitForSingleObject( *p_mutex, INFINITE );
 
 #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 );
-    }
+    acquire_sem( p_mutex->lock );
 
 #elif defined(LIBVLC_USE_PTHREAD)
 #   define vlc_assert_locked( m ) \
-           assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK)
-
-    i_result = pthread_mutex_lock( &p_mutex->mutex );
-    if ( i_result )
-    {
-        i_thread = CAST_PTHREAD_TO_INT(pthread_self());
-        errno = i_result;
-    }
+           assert (pthread_mutex_lock (m) == EDEADLK)
+    int val = pthread_mutex_lock( p_mutex );
+    VLC_THREAD_ASSERT ("locking mutex");
 
 #endif
-
-    if( i_result )
-    {
-        msg_Err( p_mutex->p_this,
-                 "thread %li: mutex_lock failed at %s:%d (%d:%m)",
-                 i_thread, psz_file, i_line, i_result );
-        vlc_threads_error( p_mutex->p_this );
-    }
-    return i_result;
 }
 
 #ifndef vlc_assert_locked
@@ -162,62 +101,27 @@ static inline int __vlc_mutex_lock( const char * psz_file, int i_line,
 #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,
+static inline void __vlc_mutex_unlock( const char * psz_file, int i_line,
                                       vlc_mutex_t *p_mutex )
 {
-    int i_result;
-    /* In case of error : */
-    unsigned long int i_thread = 0;
-
 #if defined( UNDER_CE )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
     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;
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    ReleaseMutex( *p_mutex );
 
 #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;
-    }
+    release_sem( p_mutex->lock );
 
 #elif defined(LIBVLC_USE_PTHREAD)
-    i_result = pthread_mutex_unlock( &p_mutex->mutex );
-    if ( i_result )
-    {
-        i_thread = CAST_PTHREAD_TO_INT(pthread_self());
-        errno = i_result;
-    }
+    int val = pthread_mutex_unlock( p_mutex );
+    VLC_THREAD_ASSERT ("unlocking mutex");
 
 #endif
-
-    if( i_result )
-    {
-        msg_Err( p_mutex->p_this,
-                 "thread %li: mutex_unlock failed at %s:%d (%d:%m)",
-                 i_thread, psz_file, i_line, i_result );
-        vlc_threads_error( p_mutex->p_this );
-    }
-
-    return i_result;
 }
 
 /*****************************************************************************
@@ -230,7 +134,7 @@ static inline int __vlc_mutex_unlock( const char * psz_file, int i_line,
  * 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_init( P_COND )
 
 /*****************************************************************************
  * vlc_cond_signal: start a thread on condition completion
@@ -238,119 +142,47 @@ static inline int __vlc_mutex_unlock( const char * psz_file, int i_line,
 #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 )
+static inline void __vlc_cond_signal( const char * psz_file, int i_line,
+                                      vlc_cond_t *p_condvar )
 {
-    int i_result;
-    /* In case of error : */
-    unsigned long int i_thread = 0;
+#if defined( UNDER_CE ) || defined( WIN32 )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
 
-#if 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() 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 );
+    /* 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 );
 
-        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
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    while( p_condvar->thread != -1 )
     {
-        if( p_condvar->i_waiting_threads )
-        {
-            ReleaseSemaphore( p_condvar->semaphore, 1, 0 );
+        thread_info info;
+        if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
+            return;
 
-            /* Wait for the last thread to be awakened */
-            WaitForSingleObject( p_condvar->event, INFINITE );
+        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 );
         }
-    }
-    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 )
+        else
         {
-            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;
-            }
+            /* Ok, we have to wake up that thread */
+            resume_thread( p_condvar->thread );
         }
-        i_result = 0;
     }
 
 #elif defined(LIBVLC_USE_PTHREAD)
-    i_result = pthread_cond_signal( &p_condvar->cond );
-    if ( i_result )
-    {
-        i_thread = CAST_PTHREAD_TO_INT(pthread_self());
-        errno = i_result;
-    }
+    int val = pthread_cond_signal( p_condvar );
+    VLC_THREAD_ASSERT ("signaling condition variable");
 
 #endif
-
-    if( i_result )
-    {
-        msg_Err( p_condvar->p_this,
-                 "thread %li: cond_signal failed at %s:%d (%d:%m)",
-                 i_thread, psz_file, i_line, i_result );
-        vlc_threads_error( p_condvar->p_this );
-    }
-
-    return i_result;
 }
 
 /*****************************************************************************
@@ -359,13 +191,9 @@ static inline int __vlc_cond_signal( const char * psz_file, int i_line,
 #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 )
+static inline void __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 : */
-    unsigned long int i_thread = 0;
-
 #if defined( UNDER_CE )
     p_condvar->i_waiting_threads++;
     LeaveCriticalSection( &p_mutex->csection );
@@ -375,98 +203,18 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line,
     /* 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 );
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
 
-        /* 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++;
+    SignalObjectAndWait( *p_mutex, p_condvar->event, INFINITE, FALSE );
+    p_condvar->i_waiting_threads--;
 
     /* 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 */
@@ -476,27 +224,12 @@ static inline int __vlc_cond_wait( const char * psz_file, int i_line,
     p_condvar->thread = -1;
 
     vlc_mutex_lock( p_mutex );
-    i_result = 0;
 
 #elif defined(LIBVLC_USE_PTHREAD)
-    i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
-    if ( i_result )
-    {
-        i_thread = CAST_PTHREAD_TO_INT(pthread_self());
-        errno = i_result;
-    }
+    int val = pthread_cond_wait( p_condvar, p_mutex );
+    VLC_THREAD_ASSERT ("waiting on condition");
 
 #endif
-
-    if( i_result )
-    {
-        msg_Err( p_condvar->p_this,
-                 "thread %li: cond_wait failed at %s:%d (%d:%m)",
-                 i_thread, psz_file, i_line, i_result );
-        vlc_threads_error( p_condvar->p_this );
-    }
-
-    return i_result;
 }
 
 
@@ -513,9 +246,6 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
                                         vlc_mutex_t *p_mutex,
                                         mtime_t deadline )
 {
-    int i_res;
-    unsigned long int i_thread = 0;
-
 #if defined( UNDER_CE )
     mtime_t delay_ms = (deadline - mdate())/1000;
 
@@ -531,129 +261,44 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
     /* Reacquire the mutex before returning. */
     vlc_mutex_lock( p_mutex );
 
-    i_res = (int)result;
     if(result == WAIT_TIMEOUT)
-       return WAIT_TIMEOUT; /* this error is perfectly normal */
+       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 );
     if(result == WAIT_TIMEOUT)
-       return WAIT_TIMEOUT; /* this error is perfectly normal */
-
-    i_res = (int)result;
+       return ETIMEDOUT; /* this error is perfectly normal */
 
 #elif defined( HAVE_KERNEL_SCHEDULER_H )
 #   error Unimplemented
+
 #elif defined(LIBVLC_USE_PTHREAD)
     lldiv_t d = lldiv( deadline, 1000000 );
     struct timespec ts = { d.quot, d.rem * 1000 };
 
-    i_res = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex, &ts );
-    if( i_res == ETIMEDOUT )
+    int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
+    if (val == ETIMEDOUT)
         return ETIMEDOUT; /* this error is perfectly normal */
-    else
-    if ( i_res ) /* other errors = bug */
-    {
-        i_thread = CAST_PTHREAD_TO_INT(pthread_self());
-        errno = i_res;
-    }
+    VLC_THREAD_ASSERT ("timed-waiting on condition");
 
 #endif
 
-    if( i_res )
-    {
-        msg_Err( p_condvar->p_this,
-                 "thread %li: cond_wait failed at %s:%d (%d:%m)",
-                 i_thread, psz_file, i_line, i_res );
-        vlc_threads_error( p_condvar->p_this );
-    }
-
-    return i_res;
+    return 0;
 }
 
 /*****************************************************************************
@@ -666,7 +311,7 @@ static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
  * vlc_threadvar_create: create a thread-local variable
  *****************************************************************************/
 #define vlc_threadvar_create( PTHIS, P_TLS )                                 \
-   __vlc_threadvar_create( PTHIS, P_TLS )
+   __vlc_threadvar_create( P_TLS )
 
 /*****************************************************************************
  * vlc_threadvar_set: create: set the value of a thread-local variable
@@ -676,13 +321,13 @@ static inline int vlc_threadvar_set( vlc_threadvar_t * p_tls, void *p_value )
     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
 
@@ -694,15 +339,16 @@ static inline int vlc_threadvar_set( vlc_threadvar_t * p_tls, void *p_value )
  *****************************************************************************/
 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
 
@@ -726,25 +372,31 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin)
 /**
  * Acquires a spinlock.
  */
-static inline int vlc_spin_lock (vlc_spinlock_t *spin)
+static inline void vlc_spin_lock (vlc_spinlock_t *spin)
 {
-    return pthread_spin_lock (&spin->spin);
+    int val = pthread_spin_lock (&spin->spin);
+    assert (val == 0);
+    (void)val;
 }
 
 /**
  * Releases a spinlock.
  */
-static inline int vlc_spin_unlock (vlc_spinlock_t *spin)
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
 {
-    return pthread_spin_unlock (&spin->spin);
+    int val = pthread_spin_unlock (&spin->spin);
+    assert (val == 0);
+    (void)val;
 }
 
 /**
  * Deinitializes a spinlock.
  */
-static inline int vlc_spin_destroy (vlc_spinlock_t *spin)
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
 {
-    return pthread_spin_destroy (&spin->spin);
+    int val = pthread_spin_destroy (&spin->spin);
+    assert (val == 0);
+    (void)val;
 }
 
 #elif defined( WIN32 )
@@ -762,40 +414,36 @@ static inline int vlc_spin_init (vlc_spinlock_t *spin)
 /**
  * Acquires a spinlock.
  */
-static inline int vlc_spin_lock (vlc_spinlock_t *spin)
+static inline void vlc_spin_lock (vlc_spinlock_t *spin)
 {
     EnterCriticalSection(spin);
-    return 0;
 }
 
 /**
  * Releases a spinlock.
  */
-static inline int vlc_spin_unlock (vlc_spinlock_t *spin)
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
 {
     LeaveCriticalSection(spin);
-    return 0;
 }
 
 /**
  * Deinitializes a spinlock.
  */
-static inline int vlc_spin_destroy (vlc_spinlock_t *spin)
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
 {
     DeleteCriticalSection(spin);
-    return 0;
 }
 
 
 #else
 
-
 /* Fallback to plain mutexes if spinlocks are not available */
 typedef vlc_mutex_t vlc_spinlock_t;
 
 static inline int vlc_spin_init (vlc_spinlock_t *spin)
 {
-    return __vlc_mutex_init (NULL, spin);
+    return __vlc_mutex_init (spin);
 }
 
 # define vlc_spin_lock    vlc_mutex_lock