2000-02-13 05:31:35 +01:00
|
|
|
/*****************************************************************************
|
2002-08-30 01:53:22 +02:00
|
|
|
* vlc_threads.h : threads implementation for the VideoLAN client
|
|
|
|
* This header provides portable declarations for mutexes & conditions
|
2000-03-03 08:03:34 +01:00
|
|
|
*****************************************************************************
|
2005-07-09 08:17:09 +02:00
|
|
|
* Copyright (C) 1999, 2002 the VideoLAN team
|
2005-02-15 22:21:17 +01:00
|
|
|
* $Id$
|
2000-03-03 08:03:34 +01:00
|
|
|
*
|
2000-03-09 13:30:15 +01:00
|
|
|
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
|
|
|
|
* Samuel Hocevar <sam@via.ecp.fr>
|
2002-04-28 00:11:22 +02:00
|
|
|
* Gildas Bazin <gbazin@netcourrier.com>
|
2002-08-30 01:53:22 +02:00
|
|
|
* Christophe Massiot <massiot@via.ecp.fr>
|
2000-03-03 08:03:34 +01:00
|
|
|
*
|
|
|
|
* 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.
|
2003-11-22 01:41:07 +01:00
|
|
|
*
|
2000-03-03 08:03:34 +01:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2000-05-25 00:39:44 +02:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2000-03-03 08:03:34 +01:00
|
|
|
*
|
2000-05-25 00:39:44 +02:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2006-01-13 00:10:04 +01:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
|
2000-02-13 05:31:35 +01:00
|
|
|
*****************************************************************************/
|
2000-03-03 08:03:34 +01:00
|
|
|
|
2008-08-11 18:13:10 +02:00
|
|
|
#ifndef VLC_THREADS_H_
|
|
|
|
#define VLC_THREADS_H_
|
Add facilities to report and enrich error messages.
The idea is that a given error should be reported only once to the user.
At the moment, for example, we can get:
- "no suitable access module" (printed by module_Need)
- "unable to create access" (printed by input/access)
- "unable to open stream" (printed by input/input)
- ...
The facilities provided here are:
* msg_StackSet( code, message ) : "throw" a new error
* msg_StackAdd( message ) : Append a message allowing to trace the message
* msg_StackMsg() : Retrieve the message
So, in the previous example, module_Need would msg_StackSet( code, "no
suitable access module"), then input/input would add "unable to create
access" and finally, input/input can print the "unable to open stream:
unable to create access: no suitable module" message.
The three functions are context-free, you don't need a vlc_object, so
that we can add verbose error reporting everywhere.
2006-12-22 22:14:11 +01:00
|
|
|
|
2008-01-22 17:17:33 +01:00
|
|
|
#if defined( UNDER_CE )
|
2002-11-10 19:04:24 +01:00
|
|
|
/* WinCE API */
|
2002-11-11 15:39:12 +01:00
|
|
|
#elif defined( WIN32 )
|
|
|
|
# include <process.h> /* Win32 API */
|
2008-04-23 20:53:10 +02:00
|
|
|
# include <errno.h>
|
2002-04-05 05:27:27 +02:00
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS ) /* BeOS */
|
2003-11-22 01:41:07 +01:00
|
|
|
# include <kernel/OS.h>
|
|
|
|
# include <kernel/scheduler.h>
|
|
|
|
# include <byteorder.h>
|
|
|
|
|
2008-01-27 16:56:24 +01:00
|
|
|
#else /* pthreads (like Linux & BSD) */
|
2006-09-07 21:23:03 +02:00
|
|
|
# define LIBVLC_USE_PTHREAD 1
|
2007-03-01 18:52:11 +01:00
|
|
|
# define _APPLE_C_SOURCE 1 /* Proper pthread semantics on OSX */
|
2006-09-07 21:23:03 +02:00
|
|
|
|
2008-05-27 13:02:01 +02:00
|
|
|
# include <stdlib.h> /* lldiv_t definition (only in C99) */
|
2008-01-21 20:24:25 +01:00
|
|
|
# include <unistd.h> /* _POSIX_SPIN_LOCKS */
|
2001-06-14 03:49:44 +02:00
|
|
|
# include <pthread.h>
|
2007-09-17 16:21:14 +02:00
|
|
|
/* Needed for pthread_cond_timedwait */
|
|
|
|
# include <errno.h>
|
2008-02-09 09:21:21 +01:00
|
|
|
# include <time.h>
|
2008-01-24 17:38:25 +01:00
|
|
|
|
2000-03-03 01:59:56 +01:00
|
|
|
#endif
|
1999-12-08 16:22:59 +01:00
|
|
|
|
2000-02-13 05:31:35 +01:00
|
|
|
/*****************************************************************************
|
2000-01-11 00:36:06 +01:00
|
|
|
* Constants
|
2000-02-13 05:31:35 +01:00
|
|
|
*****************************************************************************/
|
2000-01-11 00:36:06 +01:00
|
|
|
|
2002-08-30 01:53:22 +02:00
|
|
|
/* Thread priorities */
|
2006-02-01 14:01:06 +01:00
|
|
|
#ifdef __APPLE__
|
2008-06-06 18:34:03 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_LOW 0
|
|
|
|
# define VLC_THREAD_PRIORITY_INPUT 22
|
|
|
|
# define VLC_THREAD_PRIORITY_AUDIO 22
|
|
|
|
# define VLC_THREAD_PRIORITY_VIDEO 0
|
|
|
|
# define VLC_THREAD_PRIORITY_OUTPUT 22
|
|
|
|
# define VLC_THREAD_PRIORITY_HIGHEST 22
|
2000-01-11 00:36:06 +01:00
|
|
|
|
2003-11-22 01:41:07 +01:00
|
|
|
#elif defined(SYS_BEOS)
|
|
|
|
# define VLC_THREAD_PRIORITY_LOW 5
|
|
|
|
# define VLC_THREAD_PRIORITY_INPUT 10
|
|
|
|
# define VLC_THREAD_PRIORITY_AUDIO 10
|
|
|
|
# define VLC_THREAD_PRIORITY_VIDEO 5
|
|
|
|
# define VLC_THREAD_PRIORITY_OUTPUT 15
|
2005-06-10 18:12:29 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_HIGHEST 15
|
2003-11-22 01:41:07 +01:00
|
|
|
|
2008-01-27 16:56:24 +01:00
|
|
|
#elif defined(LIBVLC_USE_PTHREAD)
|
2008-06-06 16:48:48 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_LOW 0
|
|
|
|
# define VLC_THREAD_PRIORITY_INPUT 10
|
|
|
|
# define VLC_THREAD_PRIORITY_AUDIO 5
|
|
|
|
# define VLC_THREAD_PRIORITY_VIDEO 0
|
|
|
|
# define VLC_THREAD_PRIORITY_OUTPUT 15
|
|
|
|
# define VLC_THREAD_PRIORITY_HIGHEST 20
|
2003-11-07 20:30:28 +01:00
|
|
|
|
2002-11-11 15:39:12 +01:00
|
|
|
#elif defined(WIN32) || defined(UNDER_CE)
|
2002-12-30 18:36:01 +01:00
|
|
|
/* Define different priorities for WinNT/2K/XP and Win9x/Me */
|
2002-08-30 01:53:22 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_LOW 0
|
2002-12-30 18:36:01 +01:00
|
|
|
# define VLC_THREAD_PRIORITY_INPUT \
|
2004-03-01 13:50:39 +01:00
|
|
|
(IS_WINNT ? THREAD_PRIORITY_ABOVE_NORMAL : 0)
|
2002-12-30 18:36:01 +01:00
|
|
|
# define VLC_THREAD_PRIORITY_AUDIO \
|
|
|
|
(IS_WINNT ? THREAD_PRIORITY_HIGHEST : 0)
|
2003-01-29 15:03:07 +01:00
|
|
|
# define VLC_THREAD_PRIORITY_VIDEO \
|
|
|
|
(IS_WINNT ? 0 : THREAD_PRIORITY_BELOW_NORMAL )
|
2002-12-30 18:36:01 +01:00
|
|
|
# define VLC_THREAD_PRIORITY_OUTPUT \
|
|
|
|
(IS_WINNT ? THREAD_PRIORITY_ABOVE_NORMAL : 0)
|
|
|
|
# define VLC_THREAD_PRIORITY_HIGHEST \
|
|
|
|
(IS_WINNT ? THREAD_PRIORITY_TIME_CRITICAL : 0)
|
1999-12-08 16:22:59 +01:00
|
|
|
|
2002-08-30 01:53:22 +02:00
|
|
|
#else
|
|
|
|
# define VLC_THREAD_PRIORITY_LOW 0
|
|
|
|
# define VLC_THREAD_PRIORITY_INPUT 0
|
|
|
|
# define VLC_THREAD_PRIORITY_AUDIO 0
|
2002-09-01 23:20:29 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_VIDEO 0
|
2002-08-30 01:53:22 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_OUTPUT 0
|
2005-06-10 18:12:29 +02:00
|
|
|
# define VLC_THREAD_PRIORITY_HIGHEST 0
|
2000-01-11 00:36:06 +01:00
|
|
|
|
2002-08-30 01:53:22 +02:00
|
|
|
#endif
|
2000-01-11 00:36:06 +01:00
|
|
|
|
2000-02-13 05:31:35 +01:00
|
|
|
/*****************************************************************************
|
2002-04-28 00:11:22 +02:00
|
|
|
* Type definitions
|
2000-02-13 05:31:35 +01:00
|
|
|
*****************************************************************************/
|
2000-03-03 01:59:56 +01:00
|
|
|
|
2008-05-08 21:07:35 +02:00
|
|
|
#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 )
|
2008-05-08 21:33:21 +02:00
|
|
|
typedef HANDLE vlc_thread_t;
|
2002-06-02 15:38:03 +02:00
|
|
|
typedef BOOL (WINAPI *SIGNALOBJECTANDWAIT) ( HANDLE, HANDLE, DWORD, BOOL );
|
2008-04-23 21:24:45 +02:00
|
|
|
typedef HANDLE vlc_mutex_t;
|
2008-08-09 18:28:24 +02:00
|
|
|
typedef HANDLE vlc_cond_t;
|
2008-04-23 20:53:10 +02:00
|
|
|
typedef DWORD vlc_threadvar_t;
|
2006-12-18 22:40:12 +01:00
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2003-11-22 01:41:07 +01:00
|
|
|
/* This is the BeOS implementation of the vlc threads, note that the mutex is
|
|
|
|
* not a real mutex and the cond_var is not like a pthread cond_var but it is
|
2007-08-16 21:14:10 +02:00
|
|
|
* enough for what we need */
|
2003-11-22 01:41:07 +01:00
|
|
|
|
|
|
|
typedef thread_id vlc_thread_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
int32_t init;
|
|
|
|
sem_id lock;
|
|
|
|
} vlc_mutex_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
int32_t init;
|
|
|
|
thread_id thread;
|
|
|
|
} vlc_cond_t;
|
|
|
|
|
2006-12-18 22:40:12 +01:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
} vlc_threadvar_t;
|
|
|
|
|
2008-05-08 21:07:35 +02:00
|
|
|
#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 * ) );
|
2008-05-10 22:22:13 +02:00
|
|
|
VLC_EXPORT( int, vlc_threadvar_create, (vlc_threadvar_t * , void (*) (void *) ) );
|
|
|
|
VLC_EXPORT( void, vlc_threadvar_delete, (vlc_threadvar_t *) );
|
2008-08-03 17:03:07 +02:00
|
|
|
VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( vlc_object_t * ), int, bool ) );
|
2008-05-08 21:07:35 +02:00
|
|
|
VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, const char *, int, int ) );
|
|
|
|
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) );
|
|
|
|
|
2008-07-10 21:29:56 +02:00
|
|
|
#define vlc_thread_ready vlc_object_signal
|
|
|
|
|
2008-05-08 21:07:35 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* vlc_mutex_lock: lock a mutex
|
|
|
|
*****************************************************************************/
|
|
|
|
#define vlc_mutex_lock( P_MUTEX ) \
|
|
|
|
__vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
|
|
|
|
|
|
|
|
VLC_EXPORT(void, vlc_pthread_fatal, (const char *action, int error, const char *file, unsigned line));
|
2006-12-18 22:40:12 +01:00
|
|
|
|
2008-05-28 18:51:44 +02:00
|
|
|
#if defined(LIBVLC_USE_PTHREAD)
|
2008-05-08 21:07:35 +02:00
|
|
|
# define VLC_THREAD_ASSERT( action ) \
|
|
|
|
if (val) \
|
|
|
|
vlc_pthread_fatal (action, val, psz_file, i_line)
|
2008-01-27 16:56:24 +01:00
|
|
|
#else
|
2008-07-24 20:09:31 +02:00
|
|
|
# define VLC_THREAD_ASSERT ((void)(val))
|
2008-05-08 21:07:35 +02:00
|
|
|
#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 )
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
EnterCriticalSection( &p_mutex->csection );
|
|
|
|
|
|
|
|
#elif defined( WIN32 )
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
WaitForSingleObject( *p_mutex, INFINITE );
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
acquire_sem( p_mutex->lock );
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef vlc_assert_locked
|
2008-08-13 01:22:17 +02:00
|
|
|
# define vlc_assert_locked( m ) (void)m
|
2008-05-08 21:07:35 +02:00
|
|
|
#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 )
|
2008-05-26 18:23:50 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
LeaveCriticalSection( &p_mutex->csection );
|
|
|
|
|
|
|
|
#elif defined( WIN32 )
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
ReleaseMutex( *p_mutex );
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
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 )
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* 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/ */
|
2008-08-09 18:28:24 +02:00
|
|
|
PulseEvent( *p_condvar );
|
2008-05-08 21:07:35 +02:00
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
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 )
|
|
|
|
LeaveCriticalSection( &p_mutex->csection );
|
2008-08-09 18:28:24 +02:00
|
|
|
WaitForSingleObject( *p_condvar, INFINITE );
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* Reacquire the mutex before returning. */
|
|
|
|
vlc_mutex_lock( p_mutex );
|
|
|
|
|
|
|
|
#elif defined( WIN32 )
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* Increase our wait count */
|
2008-08-09 18:28:24 +02:00
|
|
|
SignalObjectAndWait( *p_mutex, *p_condvar, INFINITE, FALSE );
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* Reacquire the mutex before returning. */
|
|
|
|
vlc_mutex_lock( p_mutex );
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
LeaveCriticalSection( &p_mutex->csection );
|
2008-08-09 18:28:24 +02:00
|
|
|
result = WaitForSingleObject( *p_condvar, delay_ms );
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* Reacquire the mutex before returning. */
|
|
|
|
vlc_mutex_lock( p_mutex );
|
|
|
|
|
|
|
|
if(result == WAIT_TIMEOUT)
|
|
|
|
return ETIMEDOUT; /* this error is perfectly normal */
|
|
|
|
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
2008-05-08 21:33:21 +02:00
|
|
|
#elif defined( WIN32 )
|
2008-08-10 14:12:41 +02:00
|
|
|
mtime_t total = (deadline - mdate())/1000;
|
2008-05-08 21:33:21 +02:00
|
|
|
DWORD result;
|
2008-08-10 14:12:41 +02:00
|
|
|
if( total < 0 )
|
|
|
|
total = 0;
|
2008-05-08 21:07:35 +02:00
|
|
|
|
2008-08-10 14:12:41 +02:00
|
|
|
do
|
|
|
|
{
|
|
|
|
DWORD delay = (total > 0x7fffffff) ? 0x7fffffff : total;
|
|
|
|
result = SignalObjectAndWait( *p_mutex, *p_condvar,
|
|
|
|
delay, FALSE );
|
|
|
|
total -= delay;
|
2008-08-10 14:16:23 +02:00
|
|
|
vlc_mutex_lock (p_mutex);
|
2008-08-10 14:12:41 +02:00
|
|
|
}
|
|
|
|
while (total);
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/* Reacquire the mutex before returning. */
|
|
|
|
if(result == WAIT_TIMEOUT)
|
|
|
|
return ETIMEDOUT; /* this error is perfectly normal */
|
|
|
|
|
2008-05-08 21:33:21 +02:00
|
|
|
(void)psz_file; (void)i_line;
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
# error Unimplemented
|
2006-12-18 22:40:12 +01:00
|
|
|
|
2002-06-02 15:38:03 +02:00
|
|
|
#endif
|
|
|
|
|
2008-05-08 21:07:35 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* vlc_cond_destroy: destroy a condition
|
|
|
|
*****************************************************************************/
|
|
|
|
#define vlc_cond_destroy( P_COND ) \
|
|
|
|
__vlc_cond_destroy( __FILE__, __LINE__, P_COND )
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* 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 );
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
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 );
|
|
|
|
|
2008-05-26 18:23:30 +02:00
|
|
|
#elif defined( SYS_BEOS )
|
2008-05-08 21:07:35 +02:00
|
|
|
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
|
|
|
|
|
2008-07-05 13:07:45 +02:00
|
|
|
/**
|
|
|
|
* Issues a full memory barrier.
|
|
|
|
*/
|
2008-07-05 14:27:46 +02:00
|
|
|
#if defined (__APPLE__)
|
|
|
|
# include <libkern/OSAtomic.h> /* OSMemoryBarrier() */
|
|
|
|
#endif
|
2008-07-05 13:07:45 +02:00
|
|
|
static inline void barrier (void)
|
|
|
|
{
|
2008-07-05 21:27:00 +02:00
|
|
|
#if defined (__GNUC__) && (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
|
2008-07-05 13:07:45 +02:00
|
|
|
__sync_synchronize ();
|
2008-07-05 21:27:00 +02:00
|
|
|
#elif defined(__APPLE__)
|
|
|
|
OSMemoryBarrier ();
|
|
|
|
#elif defined(__powerpc__)
|
|
|
|
asm volatile ("sync":::"memory");
|
|
|
|
#elif defined(__i386__)
|
|
|
|
asm volatile ("mfence":::"memory");
|
2008-07-05 13:07:45 +02:00
|
|
|
#else
|
2008-08-10 20:55:10 +02:00
|
|
|
vlc_spin_t spin;
|
|
|
|
vlc_spin_init (&spin);
|
|
|
|
vlc_spin_lock (&spin);
|
|
|
|
vlc_spin_unlock (&spin);
|
|
|
|
vlc_spin_destroy (&spin);
|
2008-07-05 13:07:45 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-05-08 21:07:35 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* vlc_thread_create: create a thread
|
|
|
|
*****************************************************************************/
|
|
|
|
#define vlc_thread_create( P_THIS, PSZ_NAME, FUNC, PRIORITY, WAIT ) \
|
2008-08-03 17:03:07 +02:00
|
|
|
__vlc_thread_create( VLC_OBJECT(P_THIS), __FILE__, __LINE__, PSZ_NAME, FUNC, PRIORITY, WAIT )
|
2008-05-08 21:07:35 +02:00
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* 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_join: wait until a thread exits
|
|
|
|
*****************************************************************************/
|
|
|
|
#define vlc_thread_join( P_THIS ) \
|
|
|
|
__vlc_thread_join( VLC_OBJECT(P_THIS), __FILE__, __LINE__ )
|
|
|
|
|
2008-01-22 17:25:57 +01:00
|
|
|
#endif /* !_VLC_THREADS_H */
|