Merge vlc_threads.h and vlc_threads_funcs.h
authorRémi Denis-Courmont <rem@videolan.org>
Thu, 8 May 2008 19:07:35 +0000 (22:07 +0300)
committerRémi Denis-Courmont <rem@videolan.org>
Thu, 8 May 2008 19:08:13 +0000 (22:08 +0300)
include/vlc_common.h
include/vlc_threads.h
include/vlc_threads_funcs.h [deleted file]
src/Makefile.am

index 439c61f..ed8d5f8 100644 (file)
@@ -930,7 +930,6 @@ VLC_EXPORT( const char *, VLC_Changeset, ( void ) );
 #include "vlc_variables.h"
 #include "vlc_objects.h"
 #include "vlc_mtime.h"
-#include "vlc_threads_funcs.h"
 #include "vlc_modules.h"
 #include "vlc_main.h"
 #include "vlc_configuration.h"
index 43bfe9b..bb57941 100644 (file)
  * Type definitions
  *****************************************************************************/
 
-#if defined( WIN32 ) || defined( UNDER_CE )
+#if defined (LIBVLC_USE_PTHREAD)
+typedef pthread_t       vlc_thread_t;
+typedef pthread_mutex_t vlc_mutex_t;
+typedef pthread_cond_t  vlc_cond_t;
+typedef pthread_key_t   vlc_threadvar_t;
+
+#elif defined( WIN32 ) || defined( UNDER_CE )
 typedef struct
 {
     /* thread id */
@@ -159,13 +165,439 @@ typedef struct
 {
 } vlc_threadvar_t;
 
+#endif
+
+#if defined( WIN32 ) && !defined ETIMEDOUT
+#  define ETIMEDOUT 10060 /* This is the value in winsock.h. */
+#endif
+
+/*****************************************************************************
+ * Function definitions
+ *****************************************************************************/
+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_mutex_lock: lock a mutex
+ *****************************************************************************/
+#define vlc_mutex_lock( P_MUTEX )                                           \
+    __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
+
+#if defined(LIBVLC_USE_PTHREAD)
+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
-typedef pthread_t       vlc_thread_t;
-typedef pthread_mutex_t vlc_mutex_t;
-typedef pthread_cond_t  vlc_cond_t;
-typedef pthread_key_t   vlc_threadvar_t;
+# define VLC_THREAD_ASSERT (void)0
+#endif
+
+static inline void __vlc_mutex_lock( const char * psz_file, int i_line,
+                                    vlc_mutex_t * p_mutex )
+{
+#if defined(LIBVLC_USE_PTHREAD)
+#   define vlc_assert_locked( m ) \
+           assert (pthread_mutex_lock (m) == EDEADLK)
+    int val = pthread_mutex_lock( p_mutex );
+    VLC_THREAD_ASSERT ("locking mutex");
+
+#elif defined( UNDER_CE )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    EnterCriticalSection( &p_mutex->csection );
+
+#elif defined( WIN32 )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    WaitForSingleObject( *p_mutex, INFINITE );
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    acquire_sem( p_mutex->lock );
+
+#endif
+}
+
+#ifndef vlc_assert_locked
+# define vlc_assert_locked( m ) (void)0
+#endif
+
+/*****************************************************************************
+ * vlc_mutex_unlock: unlock a mutex
+ *****************************************************************************/
+#define vlc_mutex_unlock( P_MUTEX )                                         \
+    __vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX )
+
+static inline void __vlc_mutex_unlock( const char * psz_file, int i_line,
+                                      vlc_mutex_t *p_mutex )
+{
+#if defined(LIBVLC_USE_PTHREAD)
+    int val = pthread_mutex_unlock( p_mutex );
+    VLC_THREAD_ASSERT ("unlocking mutex");
+
+#elif defined( UNDER_CE )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    LeaveCriticalSection( &p_mutex->csection );
+
+#elif defined( WIN32 )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    ReleaseMutex( *p_mutex );
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    release_sem( p_mutex->lock );
+
+#endif
+}
+
+/*****************************************************************************
+ * 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( 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 void __vlc_cond_signal( const char * psz_file, int i_line,
+                                      vlc_cond_t *p_condvar )
+{
+#if defined(LIBVLC_USE_PTHREAD)
+    int val = pthread_cond_signal( p_condvar );
+    VLC_THREAD_ASSERT ("signaling condition variable");
+
+#elif defined( UNDER_CE ) || defined( WIN32 )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    /* 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 */
+    /* 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 )
+    {
+        thread_info info;
+        if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
+            return;
+
+        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 );
+        }
+    }
+
+#endif
+}
+
+/*****************************************************************************
+ * 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 void __vlc_cond_wait( const char * psz_file, int i_line,
+                                    vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
+{
+#if defined(LIBVLC_USE_PTHREAD)
+    int val = pthread_cond_wait( p_condvar, p_mutex );
+    VLC_THREAD_ASSERT ("waiting on condition");
+
+#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 );
+
+#elif defined( WIN32 )
+    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+    /* 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 );
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    /* 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 );
+
+#endif
+}
+
+
+/*****************************************************************************
+ * vlc_cond_timedwait: wait until condition completion or expiration
+ *****************************************************************************
+ * Returns 0 if object signaled, an error code in case of timeout or error.
+ *****************************************************************************/
+#define vlc_cond_timedwait( P_COND, P_MUTEX, DEADLINE )                      \
+    __vlc_cond_timedwait( __FILE__, __LINE__, P_COND, P_MUTEX, DEADLINE  )
+
+static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
+                                        vlc_cond_t *p_condvar,
+                                        vlc_mutex_t *p_mutex,
+                                        mtime_t deadline )
+{
+#if defined(LIBVLC_USE_PTHREAD)
+    lldiv_t d = lldiv( deadline, 1000000 );
+    struct timespec ts = { d.quot, d.rem * 1000 };
+
+    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");
+
+#elif defined( UNDER_CE )
+    mtime_t delay_ms = (deadline - mdate())/1000;
+
+    DWORD result;
+    if( delay_ms < 0 )
+        delay_ms = 0;
+
+    p_condvar->i_waiting_threads++;
+    LeaveCriticalSection( &p_mutex->csection );
+    result = WaitForSingleObject( p_condvar->event, delay_ms );
+    p_condvar->i_waiting_threads--;
+
+    /* Reacquire the mutex before returning. */
+    vlc_mutex_lock( p_mutex );
+
+    if(result == WAIT_TIMEOUT)
+       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;
+
+    /* 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 ETIMEDOUT; /* this error is perfectly normal */
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+#   error Unimplemented
 
 #endif
 
+    return 0;
+}
+
+/*****************************************************************************
+ * vlc_cond_destroy: destroy a condition
+ *****************************************************************************/
+#define vlc_cond_destroy( P_COND )                                          \
+    __vlc_cond_destroy( __FILE__, __LINE__, P_COND )
+
+/*****************************************************************************
+ * vlc_threadvar_create: create a thread-local variable
+ *****************************************************************************/
+#define vlc_threadvar_create( PTHIS, P_TLS )                                 \
+   __vlc_threadvar_create( P_TLS )
+
+/*****************************************************************************
+ * vlc_threadvar_set: create: set the value of a thread-local variable
+ *****************************************************************************/
+static inline int vlc_threadvar_set( vlc_threadvar_t * p_tls, void *p_value )
+{
+    int i_ret;
+
+#if defined(LIBVLC_USE_PTHREAD)
+    i_ret = pthread_setspecific( *p_tls, p_value );
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    i_ret = EINVAL;
+
+#elif defined( UNDER_CE ) || defined( WIN32 )
+    i_ret = TlsSetValue( *p_tls, p_value ) ? EINVAL : 0;
+
+#endif
+
+    return i_ret;
+}
+
+/*****************************************************************************
+ * vlc_threadvar_get: create: get the value of a thread-local variable
+ *****************************************************************************/
+static inline void* vlc_threadvar_get( vlc_threadvar_t * p_tls )
+{
+    void *p_ret;
+
+#if defined(LIBVLC_USE_PTHREAD)
+    p_ret = pthread_getspecific( *p_tls );
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+    p_ret = NULL;
+
+#elif defined( UNDER_CE ) || defined( WIN32 )
+    p_ret = TlsGetValue( *p_tls );
+
+#endif
+
+    return p_ret;
+}
+
+# if defined (_POSIX_SPIN_LOCKS) && ((_POSIX_SPIN_LOCKS - 0) > 0)
+typedef pthread_spinlock_t vlc_spinlock_t;
+
+/**
+ * Initializes a spinlock.
+ */
+static inline int vlc_spin_init (vlc_spinlock_t *spin)
+{
+    return pthread_spin_init (spin, PTHREAD_PROCESS_PRIVATE);
+}
+
+/**
+ * Acquires a spinlock.
+ */
+static inline void vlc_spin_lock (vlc_spinlock_t *spin)
+{
+    pthread_spin_lock (spin);
+}
+
+/**
+ * Releases a spinlock.
+ */
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
+{
+    pthread_spin_unlock (spin);
+}
+
+/**
+ * Deinitializes a spinlock.
+ */
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
+{
+    pthread_spin_destroy (spin);
+}
+
+#elif defined( WIN32 )
+
+typedef CRITICAL_SECTION vlc_spinlock_t;
+
+/**
+ * Initializes a spinlock.
+ */
+static inline int vlc_spin_init (vlc_spinlock_t *spin)
+{
+    return !InitializeCriticalSectionAndSpinCount(spin, 4000);
+}
+
+/**
+ * Acquires a spinlock.
+ */
+static inline void vlc_spin_lock (vlc_spinlock_t *spin)
+{
+    EnterCriticalSection(spin);
+}
+
+/**
+ * Releases a spinlock.
+ */
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
+{
+    LeaveCriticalSection(spin);
+}
+
+/**
+ * Deinitializes a spinlock.
+ */
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
+{
+    DeleteCriticalSection(spin);
+}
+
+#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 (spin);
+}
+
+# define vlc_spin_lock    vlc_mutex_lock
+# define vlc_spin_unlock  vlc_mutex_unlock
+# define vlc_spin_destroy vlc_mutex_destroy
+#endif
+
+/*****************************************************************************
+ * 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__ )
+
 #endif /* !_VLC_THREADS_H */
diff --git a/include/vlc_threads_funcs.h b/include/vlc_threads_funcs.h
deleted file mode 100644 (file)
index dc55218..0000000
+++ /dev/null
@@ -1,478 +0,0 @@
-/*****************************************************************************
- * vlc_threads_funcs.h : threads implementation for the VideoLAN client
- * This header provides a portable threads implementation.
- *****************************************************************************
- * Copyright (C) 1999-2007 the VideoLAN team
- * $Id$
- *
- * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
- *          Samuel Hocevar <sam@via.ecp.fr>
- *          Gildas Bazin <gbazin@netcourrier.com>
- *          Christophe Massiot <massiot@via.ecp.fr>
- *
- * 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.
- *****************************************************************************/
-
-#if !defined( __LIBVLC__ )
-  #error You are not libvlc or one of its plugins. You cannot include this file
-#endif
-
-#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( 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_mutex_lock: lock a mutex
- *****************************************************************************/
-#define vlc_mutex_lock( P_MUTEX )                                           \
-    __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
-
-#if defined(LIBVLC_USE_PTHREAD)
-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 void __vlc_mutex_lock( const char * psz_file, int i_line,
-                                    vlc_mutex_t * p_mutex )
-{
-#if defined( UNDER_CE )
-    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
-    EnterCriticalSection( &p_mutex->csection );
-
-#elif defined( WIN32 )
-    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) == EDEADLK)
-    int val = pthread_mutex_lock( p_mutex );
-    VLC_THREAD_ASSERT ("locking mutex");
-
-#endif
-}
-
-#ifndef vlc_assert_locked
-# define vlc_assert_locked( m ) (void)0
-#endif
-
-/*****************************************************************************
- * vlc_mutex_unlock: unlock a mutex
- *****************************************************************************/
-#define vlc_mutex_unlock( P_MUTEX )                                         \
-    __vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX )
-
-static inline void __vlc_mutex_unlock( const char * psz_file, int i_line,
-                                      vlc_mutex_t *p_mutex )
-{
-#if defined( UNDER_CE )
-    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
-    LeaveCriticalSection( &p_mutex->csection );
-
-#elif defined( WIN32 )
-    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 );
-    VLC_THREAD_ASSERT ("unlocking mutex");
-
-#endif
-}
-
-/*****************************************************************************
- * 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( 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 void __vlc_cond_signal( const char * psz_file, int i_line,
-                                      vlc_cond_t *p_condvar )
-{
-#if defined( UNDER_CE ) || defined( WIN32 )
-    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
-    /* 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 */
-    /* 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 )
-    {
-        thread_info info;
-        if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
-            return;
-
-        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 );
-        }
-    }
-
-#elif defined(LIBVLC_USE_PTHREAD)
-    int val = pthread_cond_signal( p_condvar );
-    VLC_THREAD_ASSERT ("signaling condition variable");
-
-#endif
-}
-
-/*****************************************************************************
- * 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 void __vlc_cond_wait( const char * psz_file, int i_line,
-                                    vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
-{
-#if 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 );
-
-#elif defined( WIN32 )
-    VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-
-    /* 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 );
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
-    /* 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 );
-
-#elif defined(LIBVLC_USE_PTHREAD)
-    int val = pthread_cond_wait( p_condvar, p_mutex );
-    VLC_THREAD_ASSERT ("waiting on condition");
-
-#endif
-}
-
-
-/*****************************************************************************
- * vlc_cond_timedwait: wait until condition completion or expiration
- *****************************************************************************
- * Returns 0 if object signaled, an error code in case of timeout or error.
- *****************************************************************************/
-#define vlc_cond_timedwait( P_COND, P_MUTEX, DEADLINE )                      \
-    __vlc_cond_timedwait( __FILE__, __LINE__, P_COND, P_MUTEX, DEADLINE  )
-
-static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
-                                        vlc_cond_t *p_condvar,
-                                        vlc_mutex_t *p_mutex,
-                                        mtime_t deadline )
-{
-#if defined( UNDER_CE )
-    mtime_t delay_ms = (deadline - mdate())/1000;
-
-    DWORD result;
-    if( delay_ms < 0 )
-        delay_ms = 0;
-
-    p_condvar->i_waiting_threads++;
-    LeaveCriticalSection( &p_mutex->csection );
-    result = WaitForSingleObject( p_condvar->event, delay_ms );
-    p_condvar->i_waiting_threads--;
-
-    /* Reacquire the mutex before returning. */
-    vlc_mutex_lock( p_mutex );
-
-    if(result == WAIT_TIMEOUT)
-       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;
-
-    /* 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 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 };
-
-    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");
-
-#endif
-
-    return 0;
-}
-
-/*****************************************************************************
- * vlc_cond_destroy: destroy a condition
- *****************************************************************************/
-#define vlc_cond_destroy( P_COND )                                          \
-    __vlc_cond_destroy( __FILE__, __LINE__, P_COND )
-
-/*****************************************************************************
- * vlc_threadvar_create: create a thread-local variable
- *****************************************************************************/
-#define vlc_threadvar_create( PTHIS, P_TLS )                                 \
-   __vlc_threadvar_create( P_TLS )
-
-/*****************************************************************************
- * vlc_threadvar_set: create: set the value of a thread-local variable
- *****************************************************************************/
-static inline int vlc_threadvar_set( vlc_threadvar_t * p_tls, void *p_value )
-{
-    int i_ret;
-
-#if defined( HAVE_KERNEL_SCHEDULER_H )
-    i_ret = EINVAL;
-
-#elif defined( UNDER_CE ) || defined( WIN32 )
-    i_ret = TlsSetValue( *p_tls, p_value ) ? EINVAL : 0;
-
-#elif defined(LIBVLC_USE_PTHREAD)
-    i_ret = pthread_setspecific( *p_tls, p_value );
-
-#endif
-
-    return i_ret;
-}
-
-/*****************************************************************************
- * vlc_threadvar_get: create: get the value of a thread-local variable
- *****************************************************************************/
-static inline void* vlc_threadvar_get( vlc_threadvar_t * p_tls )
-{
-    void *p_ret;
-
-#if defined( HAVE_KERNEL_SCHEDULER_H )
-    p_ret = NULL;
-
-#elif defined( UNDER_CE ) || defined( WIN32 )
-    p_ret = TlsGetValue( *p_tls );
-
-#elif defined(LIBVLC_USE_PTHREAD)
-    p_ret = pthread_getspecific( *p_tls );
-
-#endif
-
-    return p_ret;
-}
-
-# if defined (_POSIX_SPIN_LOCKS) && ((_POSIX_SPIN_LOCKS - 0) > 0)
-typedef struct
-{
-    pthread_spinlock_t  spin;
-} vlc_spinlock_t;
-
-/**
- * Initializes a spinlock.
- */
-static inline int vlc_spin_init (vlc_spinlock_t *spin)
-{
-    return pthread_spin_init (&spin->spin, PTHREAD_PROCESS_PRIVATE);
-}
-
-/**
- * Acquires a spinlock.
- */
-static inline void vlc_spin_lock (vlc_spinlock_t *spin)
-{
-    int val = pthread_spin_lock (&spin->spin);
-    assert (val == 0);
-    (void)val;
-}
-
-/**
- * Releases a spinlock.
- */
-static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
-{
-    int val = pthread_spin_unlock (&spin->spin);
-    assert (val == 0);
-    (void)val;
-}
-
-/**
- * Deinitializes a spinlock.
- */
-static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
-{
-    int val = pthread_spin_destroy (&spin->spin);
-    assert (val == 0);
-    (void)val;
-}
-
-#elif defined( WIN32 )
-
-typedef CRITICAL_SECTION vlc_spinlock_t;
-
-/**
- * Initializes a spinlock.
- */
-static inline int vlc_spin_init (vlc_spinlock_t *spin)
-{
-    return !InitializeCriticalSectionAndSpinCount(spin, 4000);
-}
-
-/**
- * Acquires a spinlock.
- */
-static inline void vlc_spin_lock (vlc_spinlock_t *spin)
-{
-    EnterCriticalSection(spin);
-}
-
-/**
- * Releases a spinlock.
- */
-static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
-{
-    LeaveCriticalSection(spin);
-}
-
-/**
- * Deinitializes a spinlock.
- */
-static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
-{
-    DeleteCriticalSection(spin);
-}
-
-
-#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 (spin);
-}
-
-# define vlc_spin_lock    vlc_mutex_lock
-# define vlc_spin_unlock  vlc_mutex_unlock
-# define vlc_spin_destroy vlc_mutex_destroy
-#endif
-
-/*****************************************************************************
- * 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__ )
-
-#endif
index ebe3864..7d25a7c 100644 (file)
@@ -47,7 +47,6 @@ pluginsinclude_HEADERS = \
        ../include/vlc_objects.h \
        ../include/vlc_plugin.h \
        ../include/vlc_threads.h \
-       ../include/vlc_threads_funcs.h \
        ../include/vlc_variables.h \
        $(NULL)