* Global mutex for lazy initialization of the threads system
*****************************************************************************/
static volatile unsigned i_initializations = 0;
-static volatile int i_status = VLC_THREADS_UNINITIALIZED;
-static vlc_object_t *p_root;
#if defined( UNDER_CE )
#elif defined( WIN32 )
static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif
+/**
+ * Global process-wide VLC object.
+ * Contains inter-instance data, such as the module cache and global mutexes.
+ */
+static vlc_object_t *p_root;
+static libvlc_global_data_t libvlc_global;
+
+libvlc_global_data_t *vlc_global( void )
+{
+ assert( i_initializations > 0 );
+ return &libvlc_global;
+}
+
+
vlc_threadvar_t msg_context_global_key;
#if defined(LIBVLC_USE_PTHREAD)
* keep the library really thread-safe. Some architectures don't support this
* and thus do not guarantee the complete reentrancy.
*****************************************************************************/
-int __vlc_threads_init( vlc_object_t *p_this )
+int vlc_threads_init( void )
{
- libvlc_global_data_t *p_libvlc_global = (libvlc_global_data_t *)p_this;
int i_ret = VLC_SUCCESS;
/* If we have lazy mutex initialization, use it. Otherwise, we just
pthread_mutex_lock( &once_mutex );
#endif
- if( i_status == VLC_THREADS_UNINITIALIZED )
+ if( i_initializations == 0 )
{
- i_status = VLC_THREADS_PENDING;
-
/* We should be safe now. Do all the initialization stuff we want. */
- p_libvlc_global->b_ready = false;
+ libvlc_global.b_ready = false;
- p_root = vlc_custom_create( VLC_OBJECT(p_libvlc_global), 0,
+ p_root = vlc_custom_create( VLC_OBJECT(&libvlc_global), 0,
VLC_OBJECT_GLOBAL, "global" );
if( p_root == NULL )
- i_ret = VLC_ENOMEM;
-
- if( i_ret )
- {
- i_status = VLC_THREADS_ERROR;
- }
- else
{
- i_initializations++;
- i_status = VLC_THREADS_READY;
+ i_ret = VLC_ENOMEM;
+ goto out;
}
-
vlc_threadvar_create( p_root, &msg_context_global_key );
}
- else
- {
- /* Just increment the initialization count */
- i_initializations++;
- }
+ i_initializations++;
- /* If we have lazy mutex initialization support, unlock the mutex;
- * otherwize, do a naive wait loop. */
+out:
+ /* If we have lazy mutex initialization support, unlock the mutex.
+ * Otherwize, we are screwed. */
#if defined( UNDER_CE )
- while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( WIN32 )
- while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( LIBVLC_USE_PTHREAD )
pthread_mutex_unlock( &once_mutex );
#endif
- if( i_status != VLC_THREADS_READY )
- {
- return VLC_ETHREAD;
- }
-
return i_ret;
}
*****************************************************************************
* FIXME: This function is far from being threadsafe.
*****************************************************************************/
-int __vlc_threads_end( vlc_object_t *p_this )
+void vlc_threads_end( void )
{
- (void)p_this;
#if defined( UNDER_CE )
#elif defined( WIN32 )
#elif defined( HAVE_KERNEL_SCHEDULER_H )
pthread_mutex_lock( &once_mutex );
#endif
- if( i_initializations == 0 )
- return VLC_EGENERIC;
-
- i_initializations--;
- if( i_initializations == 0 )
- {
- i_status = VLC_THREADS_UNINITIALIZED;
+ assert( i_initializations > 0 );
+ if( --i_initializations == 0 )
vlc_object_release( p_root );
- }
#if defined( UNDER_CE )
#elif defined( WIN32 )
#elif defined( LIBVLC_USE_PTHREAD )
pthread_mutex_unlock( &once_mutex );
#endif
- return VLC_SUCCESS;
}
#ifdef __linux__
return 0;
#elif defined( WIN32 )
- p_mutex->mutex = CreateMutex( 0, FALSE, 0 );
- return ( p_mutex->mutex != NULL ? 0 : 1 );
+ *p_mutex = CreateMutex( 0, FALSE, 0 );
+ return (*p_mutex != NULL) ? 0 : ENOMEM;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
/* check the arguments and whether it's already been initialized */
{
#if defined( WIN32 )
/* Create mutex returns a recursive mutex */
- p_mutex->mutex = CreateMutex( 0, FALSE, 0 );
- return ( p_mutex->mutex != NULL ? 0 : 1 );
+ *p_mutex = CreateMutex( 0, FALSE, 0 );
+ return (*p_mutex != NULL) ? 0 : ENOMEM;
#elif defined( LIBVLC_USE_PTHREAD )
pthread_mutexattr_t attr;
int i_result;
#elif defined( WIN32 )
VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
- CloseHandle( p_mutex->mutex );
+ CloseHandle( *p_mutex );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex->init == 9999 )
#if defined( HAVE_KERNEL_SCHEDULER_H )
# error Unimplemented!
-#elif defined( UNDER_CE ) || defined( WIN32 )
+#elif defined( UNDER_CE )
#elif defined( WIN32 )
*p_tls = TlsAlloc();
i_ret = (*p_tls == INVALID_HANDLE_VALUE) ? EAGAIN : 0;
{
int i_ret;
void *p_data = (void *)p_this;
- vlc_object_internals_t *p_priv = p_this->p_internals;
+ vlc_object_internals_t *p_priv = vlc_internals( p_this );
vlc_mutex_lock( &p_this->object_lock );
int __vlc_thread_set_priority( vlc_object_t *p_this, const char * psz_file,
int i_line, int i_priority )
{
- vlc_object_internals_t *p_priv = p_this->p_internals;
+ vlc_object_internals_t *p_priv = vlc_internals( p_this );
#if defined( WIN32 ) || defined( UNDER_CE )
VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
*****************************************************************************/
void __vlc_thread_join( vlc_object_t *p_this, const char * psz_file, int i_line )
{
- vlc_object_internals_t *p_priv = p_this->p_internals;
+ vlc_object_internals_t *p_priv = vlc_internals( p_this );
#if defined( UNDER_CE ) || defined( WIN32 )
HMODULE hmodule;
user_ft.dwLowDateTime) / 10;
msg_Dbg( p_this, "thread times: "
- "real "I64Fd"m%fs, kernel "I64Fd"m%fs, user "I64Fd"m%fs",
+ "real %"PRId64"m%fs, kernel %"PRId64"m%fs, user %"PRId64"m%fs",
real_time/60/1000000,
(double)((real_time%(60*1000000))/1000000.0),
kernel_time/60/1000000,
projects / vlc / blobdiff