/*****************************************************************************
- * threads.h : threads implementation for the VideoLAN client
- * This header provides a portable threads implementation.
+ * vlc_threads.h : threads implementation for the VideoLAN client
+ * This header provides portable declarations for mutexes & conditions
*****************************************************************************
- * Copyright (C) 1999, 2000 VideoLAN
- * $Id: vlc_threads.h,v 1.4 2002/07/05 11:18:56 sam Exp $
+ * Copyright (C) 1999, 2002 VideoLAN
+ * $Id: vlc_threads.h,v 1.17 2002/11/10 18:04:22 sam Exp $
*
* 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
#include <stdio.h>
#if defined(GPROF) || defined(DEBUG)
-# include <sys/time.h>
+# ifdef HAVE_SYS_TIME_H
+# include <sys/time.h>
+# endif
#endif
#if defined( PTH_INIT_IN_PTH_H ) /* GNU Pth */
#elif defined( ST_INIT_IN_ST_H ) /* State threads */
# include <st.h>
-#elif defined( WIN32 ) /* Win32 API */
-# include <process.h>
+#elif defined( WIN32 )
+# if defined( UNDER_CE )
+ /* WinCE API */
+# else
+# include <process.h> /* Win32 API */
+# endif
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H ) /* pthreads (like Linux & BSD) */
# include <pthread.h>
/*****************************************************************************
* Constants
- *****************************************************************************
- * These constants are used by all threads in *_CreateThread() and
- * *_DestroyThreads() functions. Since those calls are non-blocking, an integer
- * value is used as a shared flag to represent the status of the thread.
*****************************************************************************/
-/* Void status - this value can be used to make sure no operation is currently
- * in progress on the concerned thread in an array of recorded threads */
-#define THREAD_NOP 0 /* nothing happened */
+/* Thread priorities */
+#ifdef SYS_DARWIN
+# define VLC_THREAD_PRIORITY_LOW 31
+# define VLC_THREAD_PRIORITY_INPUT 37
+# define VLC_THREAD_PRIORITY_AUDIO 38
+# define VLC_THREAD_PRIORITY_VIDEO 31
+# define VLC_THREAD_PRIORITY_OUTPUT 31
-/* Creation status */
-#define THREAD_CREATE 10 /* thread is initializing */
-#define THREAD_START 11 /* thread has forked */
-#define THREAD_READY 19 /* thread is ready */
+#elif defined(WIN32)
+# define VLC_THREAD_PRIORITY_LOW 0
+# define VLC_THREAD_PRIORITY_INPUT THREAD_PRIORITY_TIME_CRITICAL
+# define VLC_THREAD_PRIORITY_AUDIO THREAD_PRIORITY_HIGHEST
+# define VLC_THREAD_PRIORITY_VIDEO 0
+# define VLC_THREAD_PRIORITY_OUTPUT THREAD_PRIORITY_ABOVE_NORMAL
-/* Destructions status */
-#define THREAD_DESTROY 20 /* destruction order has been sent */
-#define THREAD_END 21 /* destruction order has been received */
-#define THREAD_OVER 29 /* thread does not exist any more */
+#else
+# define VLC_THREAD_PRIORITY_LOW 0
+# define VLC_THREAD_PRIORITY_INPUT 0
+# define VLC_THREAD_PRIORITY_AUDIO 0
+# define VLC_THREAD_PRIORITY_VIDEO 0
+# define VLC_THREAD_PRIORITY_OUTPUT 0
-/* Error status */
-#define THREAD_ERROR 30 /* an error occured */
-#define THREAD_FATAL 31 /* an fatal error occured - program must end */
+#endif
/*****************************************************************************
* Type definitions
#if defined( PTH_INIT_IN_PTH_H )
typedef pth_t vlc_thread_t;
-typedef pth_mutex_t vlc_mutex_t;
-typedef pth_cond_t vlc_cond_t;
+typedef struct
+{
+ pth_mutex_t mutex;
+ vlc_object_t * p_this;
+} vlc_mutex_t;
+typedef struct
+{
+ pth_cond_t cond;
+ vlc_object_t * p_this;
+} vlc_cond_t;
#elif defined( ST_INIT_IN_ST_H )
-typedef st_thread_t * vlc_thread_t;
-typedef st_mutex_t * vlc_mutex_t;
-typedef st_cond_t * vlc_cond_t;
+typedef st_thread_t vlc_thread_t;
+typedef struct
+{
+ st_mutex_t mutex;
+ vlc_object_t * p_this;
+} vlc_mutex_t;
+typedef struct
+{
+ st_cond_t cond;
+ vlc_object_t * p_this;
+} vlc_cond_t;
#elif defined( WIN32 )
typedef HANDLE vlc_thread_t;
HANDLE mutex;
/* Win95/98/ME implementation */
CRITICAL_SECTION csection;
+
+ vlc_object_t * p_this;
} vlc_mutex_t;
typedef struct
{
- int i_waiting_threads;
+ volatile int i_waiting_threads;
/* WinNT/2K/XP implementation */
- HANDLE semaphore;
- HANDLE signal;
- vlc_bool_t b_broadcast;
+ HANDLE event;
SIGNALOBJECTANDWAIT SignalObjectAndWait;
/* Win95/98/ME implementation */
- HANDLE p_events[2];
+ HANDLE semaphore;
+ CRITICAL_SECTION csection;
+ int i_win9x_cv;
+
+ vlc_object_t * p_this;
} vlc_cond_t;
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
-typedef pthread_t vlc_thread_t;
-typedef pthread_mutex_t vlc_mutex_t;
-typedef pthread_cond_t vlc_cond_t;
+typedef pthread_t vlc_thread_t;
+typedef struct
+{
+ pthread_mutex_t mutex;
+ vlc_object_t * p_this;
+} vlc_mutex_t;
+typedef struct
+{
+ pthread_cond_t cond;
+ vlc_object_t * p_this;
+} vlc_cond_t;
#elif defined( HAVE_CTHREADS_H )
-typedef cthread_t vlc_thread_t;
+typedef cthread_t vlc_thread_t;
/* Those structs are the ones defined in /include/cthreads.h but we need
* to handle (&foo) where foo is a (mutex_t) while they handle (foo) where
spin_lock_t lock;
char *name;
struct cthread_queue queue;
+
+ vlc_object_t * p_this;
} vlc_mutex_t;
typedef struct
struct cthread_queue queue;
char *name;
struct cond_imp *implications;
+
+ vlc_object_t * p_this;
} vlc_cond_t;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
{
int32 init;
sem_id lock;
+
+ vlc_object_t * p_this;
} vlc_mutex_t;
typedef struct
{
int32 init;
thread_id thread;
-} vlc_cond_t;
-
-#endif
-
-/*****************************************************************************
- * Function definitions
- *****************************************************************************/
-VLC_EXPORT( int, __vlc_threads_init, ( vlc_object_t * ) );
-VLC_EXPORT( int, vlc_threads_end, ( void ) );
-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 * ), vlc_bool_t ) );
-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( CAST_TO_VLC_OBJECT(P_THIS) )
-
-/*****************************************************************************
- * vlc_mutex_init: initialize a mutex
- *****************************************************************************/
-#define vlc_mutex_init( P_THIS, P_MUTEX ) \
- __vlc_mutex_init( CAST_TO_VLC_OBJECT(P_THIS), P_MUTEX )
-
-/*****************************************************************************
- * vlc_mutex_lock: lock a mutex
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_mutex_lock( P_MUTEX ) \
- __vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
-#else
-# define vlc_mutex_lock( P_MUTEX ) \
- __vlc_mutex_lock( "(unknown)", 0, P_MUTEX )
-#endif
-
-static inline int __vlc_mutex_lock( char * psz_file, int i_line,
- vlc_mutex_t *p_mutex )
-{
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_mutex_acquire( p_mutex, TRUE, NULL );
-
-#elif defined( ST_INIT_IN_ST_H )
- return st_mutex_lock( *p_mutex );
-
-#elif defined( WIN32 )
- if( p_mutex->mutex )
- {
- WaitForSingleObject( p_mutex->mutex, INFINITE );
- }
- else
- {
- EnterCriticalSection( &p_mutex->csection );
- }
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- int i_return = pthread_mutex_lock( p_mutex );
- if( i_return )
- {
-// msg_Err( "thread %d: mutex_lock failed at %s:%d (%s)",
-// pthread_self(), psz_file, i_line, strerror(i_return) );
- }
- return i_return;
-
-#elif defined( HAVE_CTHREADS_H )
- mutex_lock( p_mutex );
- return 0;
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- status_t err;
-
- if( !p_mutex )
- {
- return B_BAD_VALUE;
- }
-
- if( p_mutex->init < 2000 )
- {
- return B_NO_INIT;
- }
-
- err = acquire_sem( p_mutex->lock );
- return err;
-
-#endif
-}
-
-/*****************************************************************************
- * vlc_mutex_unlock: unlock a mutex
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_mutex_unlock( P_MUTEX ) \
- __vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX )
-#else
-# define vlc_mutex_unlock( P_MUTEX ) \
- __vlc_mutex_unlock( "(unknown)", 0, P_MUTEX )
-#endif
-
-static inline int __vlc_mutex_unlock( char * psz_file, int i_line,
- vlc_mutex_t *p_mutex )
-{
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_mutex_release( p_mutex );
-
-#elif defined( ST_INIT_IN_ST_H )
- return st_mutex_unlock( *p_mutex );
-
-#elif defined( WIN32 )
- if( p_mutex->mutex )
- {
- ReleaseMutex( p_mutex->mutex );
- }
- else
- {
- LeaveCriticalSection( &p_mutex->csection );
- }
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- int i_return = pthread_mutex_unlock( p_mutex );
- if( i_return )
- {
-// msg_Err( "thread %d: mutex_unlock failed at %s:%d (%s)",
-// pthread_self(), psz_file, i_line, strerror(i_return) );
- }
- return i_return;
-
-#elif defined( HAVE_CTHREADS_H )
- mutex_unlock( p_mutex );
- return 0;
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( !p_mutex)
- {
- return B_BAD_VALUE;
- }
- if( p_mutex->init < 2000 )
- {
- return B_NO_INIT;
- }
-
- release_sem( p_mutex->lock );
- return B_OK;
-
-#endif
-}
-
-/*****************************************************************************
- * vlc_mutex_destroy: destroy a mutex
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_mutex_destroy( P_MUTEX ) \
- __vlc_mutex_destroy( __FILE__, __LINE__, P_MUTEX )
-#else
-# define vlc_mutex_destroy( P_MUTEX ) \
- __vlc_mutex_destroy( "(unknown)", 0, P_MUTEX )
-#endif
-
-/*****************************************************************************
- * vlc_cond_init: initialize a condition
- *****************************************************************************/
-#define vlc_cond_init( P_THIS, P_COND ) \
- __vlc_cond_init( CAST_TO_VLC_OBJECT(P_THIS), P_COND )
-
-/*****************************************************************************
- * vlc_cond_signal: start a thread on condition completion
- *****************************************************************************/
-static inline int vlc_cond_signal( vlc_cond_t *p_condvar )
-{
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_cond_notify( p_condvar, FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- return st_cond_signal( *p_condvar );
-
-#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->i_waiting_threads )
- {
- if( p_condvar->signal )
- {
- ReleaseSemaphore( p_condvar->semaphore, 1, 0 );
- }
- else
- {
- SetEvent( p_condvar->p_events[0/*signal*/] );
- }
- }
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- return pthread_cond_signal( p_condvar );
-
-#elif defined( HAVE_CTHREADS_H )
- /* condition_signal() */
- if ( p_condvar->queue.head || p_condvar->implications )
- {
- cond_signal( (condition_t)p_condvar );
- }
- return 0;
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( !p_condvar )
- {
- return B_BAD_VALUE;
- }
-
- if( p_condvar->init < 2000 )
- {
- return B_NO_INIT;
- }
-
- 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;
- }
- }
- return 0;
-
-#endif
-}
-
-/*****************************************************************************
- * vlc_cond_broadcast: start all threads waiting on condition completion
- *****************************************************************************/
-/*
- * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
- * Only works with pthreads, you need to adapt it for others
- * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
- */
-static inline int vlc_cond_broadcast( vlc_cond_t *p_condvar )
-{
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_cond_notify( p_condvar, FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- return st_cond_broadcast( p_condvar );
-
-#elif defined( WIN32 )
- /* Release all waiting threads. */
- if( p_condvar->i_waiting_threads )
- {
- if( p_condvar->signal )
- {
- p_condvar->b_broadcast = 1;
- /* This call is atomic */
- ReleaseSemaphore( p_condvar->semaphore,
- p_condvar->i_waiting_threads, 0 );
- /* Wait for all threads to get the semaphore */
- WaitForSingleObject( p_condvar->signal, INFINITE );
- p_condvar->b_broadcast = 0;
- }
- else
- {
- SetEvent( p_condvar->p_events[1/*broadcast*/] );
- }
- }
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- return pthread_cond_broadcast( p_condvar );
-
-#elif defined( HAVE_CTHREADS_H )
- /* condition_signal() */
- if ( p_condvar->queue.head || p_condvar->implications )
- {
- cond_signal( (condition_t)p_condvar );
- }
- return 0;
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( !p_condvar )
- {
- return B_BAD_VALUE;
- }
-
- if( p_condvar->init < 2000 )
- {
- return B_NO_INIT;
- }
-
- 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;
- }
- }
- return 0;
-
-#endif
-}
-
-/*****************************************************************************
- * vlc_cond_wait: wait until condition completion
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_cond_wait( P_COND, P_MUTEX ) \
- __vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX )
-#else
-# define vlc_cond_wait( P_COND, P_MUTEX ) \
- __vlc_cond_wait( "(unknown)", 0, P_COND, P_MUTEX )
-#endif
-
-static inline int __vlc_cond_wait( char * psz_file, int i_line,
- vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
-{
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_cond_await( p_condvar, p_mutex, NULL );
-
-#elif defined( ST_INIT_IN_ST_H )
- int i_ret;
-
- st_mutex_unlock( *p_mutex );
- i_ret = st_cond_wait( *p_condvar );
- st_mutex_lock( *p_mutex );
-
- return i_ret;
-
-#elif defined( WIN32 )
- /* Increase our wait count */
- p_condvar->i_waiting_threads++;
-
- if( p_condvar->signal )
- {
- /* 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->semaphore,
- INFINITE, FALSE );
- /* XXX: we should protect i_waiting_threads with a mutex, but
- * is it really worth it ? */
- p_condvar->i_waiting_threads--;
-
- if( p_condvar->b_broadcast
- && p_condvar->i_waiting_threads == 0 )
- {
- p_condvar->SignalObjectAndWait( p_condvar->signal, p_mutex->mutex,
- INFINITE, FALSE );
- }
- else
- {
- /* Just take back the lock */
- WaitForSingleObject( p_mutex->mutex, INFINITE );
- }
- return 0;
- }
- else
- {
- int i_ret;
-
- /* Release the mutex, wait, and reacquire. */
- LeaveCriticalSection( &p_mutex->csection );
- i_ret = WaitForMultipleObjects( 2, p_condvar->p_events,
- FALSE, INFINITE );
- EnterCriticalSection( &p_mutex->csection );
-
- /* Decrease our wait count */
- p_condvar->i_waiting_threads--;
-
- /* If we are the last waiter and it was a broadcast signal, reset
- * the broadcast event. */
- if( i_ret == WAIT_OBJECT_0 + 1/*broadcast*/
- && p_condvar->i_waiting_threads == 0 )
- {
- ResetEvent( p_condvar->p_events[1/*broadcast*/] );
- }
-
- return( i_ret == WAIT_FAILED );
- }
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
-
-# ifdef DEBUG
- /* In debug mode, timeout */
- struct timeval now;
- struct timespec timeout;
- int i_result;
-
- for( ; ; )
- {
- 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, p_mutex, &timeout );
-
- if( i_result == ETIMEDOUT )
- {
-//X msg_Warn( "thread %d: possible deadlock detected "
-//X "in cond_wait at %s:%d (%s)", pthread_self(),
-//X psz_file, i_line, strerror(i_result) );
- continue;
- }
-
- if( i_result )
- {
-//X msg_Err( "thread %d: cond_wait failed at %s:%d (%s)",
-//X pthread_self(), psz_file, i_line, strerror(i_result) );
- }
- return( i_result );
- }
-# else
- return pthread_cond_wait( p_condvar, p_mutex );
-# endif
-
-#elif defined( HAVE_CTHREADS_H )
- condition_wait( (condition_t)p_condvar, (mutex_t)p_mutex );
- return 0;
-
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( !p_condvar )
- {
- return B_BAD_VALUE;
- }
-
- if( !p_mutex )
- {
- return B_BAD_VALUE;
- }
-
- if( p_condvar->init < 2000 )
- {
- return 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 );
- return 0;
-
-#endif
-}
+ vlc_object_t * p_this;
+} vlc_cond_t;
-/*****************************************************************************
- * vlc_cond_destroy: destroy a condition
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_cond_destroy( P_COND ) \
- __vlc_cond_destroy( __FILE__, __LINE__, P_COND )
-#else
-# define vlc_cond_destroy( P_COND ) \
- __vlc_cond_destroy( "(unknown)", 0, P_COND )
#endif
-/*****************************************************************************
- * vlc_thread_create: create a thread
- *****************************************************************************/
-# define vlc_thread_create( P_THIS, PSZ_NAME, FUNC, WAIT ) \
- __vlc_thread_create( CAST_TO_VLC_OBJECT(P_THIS), __FILE__, __LINE__, PSZ_NAME, (void * ( * ) ( void * ))FUNC, WAIT )
-
-/*****************************************************************************
- * vlc_thread_ready: tell the parent thread we were successfully spawned
- *****************************************************************************/
-# define vlc_thread_ready( P_THIS ) \
- __vlc_thread_ready( CAST_TO_VLC_OBJECT(P_THIS) )
-
-/*****************************************************************************
- * vlc_thread_join: wait until a thread exits
- *****************************************************************************/
-#ifdef DEBUG
-# define vlc_thread_join( P_THIS ) \
- __vlc_thread_join( CAST_TO_VLC_OBJECT(P_THIS), __FILE__, __LINE__ )
-#else
-# define vlc_thread_join( P_THIS ) \
- __vlc_thread_join( CAST_TO_VLC_OBJECT(P_THIS), "(unknown)", 0 )
-#endif
projects / vlc / blobdiff