* ./src/misc/objects.c: structure_lock is now local.
* ./src/misc/threads.c: implemented named mutexes which provide a handy
way to protect data across plugins which might be sharing the same
resources. Thread-unsafe libraries come to mind, but we can imagine
using a named mutex for configuration files, or special devices.
* ./include/main.h: removed global_lock because of vlc_mutex_need, removed
p_global_data because it was never used, removed structure_lock because
it did not belong here.
SYS=mingw32
AC_CHECK_TOOL(WINDRES, windres, :)
CPPFLAGS_save="${CPPFLAGS_save} -D_OFF_T_ -D_off_t=long"; CPPFLAGS="${CPPFLAGS_save}"
- LDFLAGS_vlc="${LDFLAGS_vlc} -lws2_32 -lnetapi32 -mwindows -Xlinker --force-exe-suffix"
+ LDFLAGS_vlc="${LDFLAGS_vlc} -lws2_32 -lnetapi32 -mwindows"
LDFLAGS_ipv4="${LDFLAGS_ipv4} -lws2_32"
LDFLAGS_ipv6="${LDFLAGS_ipv6} -lws2_32"
LDFLAGS_access_http="${LDFLAGS_http} -lws2_32"
* Declaration and extern access to global program object.
*****************************************************************************
* Copyright (C) 1999, 2000, 2001, 2002 VideoLAN
- * $Id: main.h,v 1.47 2002/10/03 18:56:09 sam Exp $
+ * $Id: main.h,v 1.48 2002/10/04 18:07:21 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
*
int i_objects; /* Attached objects count */
vlc_object_t ** pp_objects; /* Array of all objects */
- /* The big, evil global lock */
- vlc_mutex_t global_lock;
- void * p_global_data;
-
- /* Locks */
- vlc_mutex_t structure_lock; /* lock for the p_vlc tree */
-
/* The message bank */
msg_bank_t msg_bank;
* This header provides a portable threads implementation.
*****************************************************************************
* Copyright (C) 1999, 2002 VideoLAN
- * $Id: vlc_threads_funcs.h,v 1.4 2002/10/03 17:01:59 gbazin Exp $
+ * $Id: vlc_threads_funcs.h,v 1.5 2002/10/04 18:07:21 sam Exp $
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@via.ecp.fr>
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, char *, int ) );
+VLC_EXPORT( vlc_mutex_t *, __vlc_mutex_need, ( vlc_object_t *, char * ) );
+VLC_EXPORT( void , __vlc_mutex_unneed, ( vlc_object_t *, char * ) );
+
/*****************************************************************************
* vlc_threads_init: initialize threads system
*****************************************************************************/
#define vlc_mutex_init( P_THIS, P_MUTEX ) \
__vlc_mutex_init( VLC_OBJECT(P_THIS), P_MUTEX )
+/*****************************************************************************
+ * vlc_mutex_need: create a global mutex from its name
+ *****************************************************************************/
+#define vlc_mutex_need( P_THIS, P_NAME ) \
+ __vlc_mutex_need( VLC_OBJECT(P_THIS), P_NAME )
+
/*****************************************************************************
* vlc_mutex_lock: lock a mutex
*****************************************************************************/
return i_result;
}
+/*****************************************************************************
+ * vlc_mutex_unneed: destroycreate a global mutex from its name
+ *****************************************************************************/
+#define vlc_mutex_unneed( P_THIS, P_NAME ) \
+ __vlc_mutex_unneed( VLC_OBJECT(P_THIS), P_NAME )
+
/*****************************************************************************
* vlc_mutex_destroy: destroy a mutex
*****************************************************************************/
* vcd.c : VCD input module for vlc
*****************************************************************************
* Copyright (C) 2000 VideoLAN
- * $Id: vcd.c,v 1.5 2002/08/29 23:53:22 massiot Exp $
+ * $Id: vcd.c,v 1.6 2002/10/04 18:07:21 sam Exp $
*
* Author: Johan Bilien <jobi@via.ecp.fr>
*
if( p_vcd->i_handle == -1 )
{
- msg_Err( p_input, "could not open %s\n", psz_source );
+ msg_Err( p_input, "could not open %s", psz_source );
free (p_vcd);
return -1;
}
* arts.c : aRts module
*****************************************************************************
* Copyright (C) 2001-2002 VideoLAN
- * $Id: arts.c,v 1.12 2002/09/30 11:05:35 sam Exp $
+ * $Id: arts.c,v 1.13 2002/10/04 18:07:21 sam Exp $
*
* Authors: Emmanuel Blindauer <manu@agat.net>
* Samuel Hocevar <sam@zoy.org>
* (mtime_t)arts_stream_get( p_sys->stream, ARTS_P_SERVER_LATENCY );
p_sys->i_size = arts_stream_get( p_sys->stream, ARTS_P_PACKET_SIZE );
- msg_Dbg( p_aout, "aRts initialized, latency %i000, %i packets of size %i\n",
+ msg_Dbg( p_aout, "aRts initialized, latency %i000, %i packets of size %i",
arts_stream_get( p_sys->stream, ARTS_P_SERVER_LATENCY ),
arts_stream_get( p_sys->stream, ARTS_P_PACKET_COUNT ),
arts_stream_get( p_sys->stream, ARTS_P_PACKET_SIZE ) );
* gtk.c : Gtk+ plugin for vlc
*****************************************************************************
* Copyright (C) 2000-2001 VideoLAN
- * $Id: gtk.c,v 1.4 2002/10/04 12:01:40 gbazin Exp $
+ * $Id: gtk.c,v 1.5 2002/10/04 18:07:21 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
int i_args = 1;
int i_dummy;
- /* gtk_init will register stuff with g_atexit, so we need to take
- * the global lock if we want to be able to intercept the calls */
- vlc_mutex_lock( &p_intf->p_libvlc->global_lock );
gtk_init( &i_args, &pp_args );
- vlc_mutex_unlock( &p_intf->p_libvlc->global_lock );
#endif
/* Create some useful widgets that will certainly be used */
* gtk_main.c : Gtk+ wrapper for gtk_main
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: gtk_main.c,v 1.8 2002/10/04 13:13:54 sam Exp $
+ * $Id: gtk_main.c,v 1.9 2002/10/04 18:07:21 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
/*****************************************************************************
* Local variables (mutex-protected).
*****************************************************************************/
+static vlc_mutex_t * p_gtklock;
static int i_refcount = 0;
static gtk_main_t * p_gtk_main = NULL;
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_libvlc->global_lock );
+ /* FIXME: put this in the module (de)initialization ASAP */
+ p_gtklock = vlc_mutex_need( p_this, "gtk" );
+
+ vlc_mutex_lock( p_gtklock );
if( i_refcount > 0 )
{
i_refcount++;
- vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_unlock( p_gtklock );
return VLC_SUCCESS;
}
{
vlc_object_destroy( p_gtk_main );
i_refcount--;
- vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_unlock( p_gtklock );
+ vlc_mutex_unneed( p_this, "gtk" );
return VLC_ETHREAD;
}
i_refcount++;
- vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_unlock( p_gtklock );
return VLC_SUCCESS;
}
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_lock( p_gtklock );
i_refcount--;
if( i_refcount > 0 )
{
- vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_unlock( p_gtklock );
+ vlc_mutex_unneed( p_this, "gtk" );
return;
}
vlc_object_destroy( p_gtk_main );
p_gtk_main = NULL;
- vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
+ vlc_mutex_unlock( p_gtklock );
+ vlc_mutex_unneed( p_this, "gtk" );
}
static gint foo( gpointer bar ) { return TRUE; }
* qte.cpp : QT Embedded plugin for vlc
*****************************************************************************
* Copyright (C) 1998-2002 VideoLAN
- * $Id: qte.cpp,v 1.3 2002/09/23 21:44:23 jpsaman Exp $
+ * $Id: qte.cpp,v 1.4 2002/10/04 18:07:21 sam Exp $
*
* Authors: Gerald Hansink <gerald.hansink@ordain.nl>
* Jean-Paul Saman <jpsaman@wxs.nl>
CreateQtWindow(p_vout);
- //msg_Err(p_vout, "-vout_Create::qte\n" );
+ //msg_Err(p_vout, "-vout_Create::qte" );
return( 0 );
}
{
vout_thread_t * p_vout = (vout_thread_t *)p_this;
- //msg_Err( p_vout, "+vout_Destroy::qte\n" );
+ //msg_Err( p_vout, "+vout_Destroy::qte" );
DestroyQtWindow(p_vout);
free(p_vout->p_sys);
}
int dd = QPixmap::defaultDepth();
- //msg_Err( p_vout,"+vout_Init::qte\n" );
+ //msg_Err( p_vout,"+vout_Init::qte" );
I_OUTPUTPICTURES = 0;
I_OUTPUTPICTURES++;
}
- //msg_Err(p_vout, "-vout_Init::qte %d output pictures\n", I_OUTPUTPICTURES);
+ //msg_Err(p_vout, "-vout_Init::qte %d output pictures", I_OUTPUTPICTURES);
return( 0 );
}
*****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
- //msg_Err(p_vout, "+vout_Render::qte\n" );
+ //msg_Err(p_vout, "+vout_Render::qte" );
;
}
*****************************************************************************/
static int Manage( vout_thread_t *p_vout )
{
- //msg_Err(p_vout, "+vout_Manage::qte\n" );
+ //msg_Err(p_vout, "+vout_Manage::qte" );
return 0;
}
{
int i_index;
- //msg_Err(p_vout, "+vout_End::qte\n" );
+ //msg_Err(p_vout, "+vout_End::qte" );
/* Free the direct buffers we allocated */
for( i_index = I_OUTPUTPICTURES ; i_index ; )
{
int dd = QPixmap::defaultDepth();
- //msg_Err(p_vout, "+NewPicture::dd = %d\n",dd );
+ //msg_Err(p_vout, "+NewPicture::dd = %d",dd );
p_pic->p_sys = (picture_sys_t*) malloc( sizeof( picture_sys_t ) );
}
/*
- msg_Err(p_vout, "NewPicture: %d %d %d\n",p_vout->output.i_width,
+ msg_Err(p_vout, "NewPicture: %d %d %d",p_vout->output.i_width,
p_vout->output.i_height,
p_vout->output.i_chroma );
*/
* input.c : internal management of input streams for the audio output
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: input.c,v 1.14 2002/09/27 23:38:04 massiot Exp $
+ * $Id: input.c,v 1.15 2002/10/04 18:07:22 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
mdate() - p_buffer->start_date );
aout_BufferFree( p_buffer );
- vlc_mutex_unlock( &p_input->lock );
return 0;
}
* libvlc.c: main libvlc source
*****************************************************************************
* Copyright (C) 1998-2002 VideoLAN
- * $Id: libvlc.c,v 1.35 2002/10/03 18:56:09 sam Exp $
+ * $Id: libvlc.c,v 1.36 2002/10/04 18:07:22 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
{
int i_ret;
vlc_t * p_vlc = NULL;
+ vlc_mutex_t * p_libvlc_lock;
/* vlc_threads_init *must* be the first internal call! No other call is
* allowed before the thread system has been initialized. */
}
/* Now that the thread system is initialized, we don't have much, but
- * at least we have libvlc.global_lock */
- vlc_mutex_lock( &libvlc.global_lock );
+ * at least we have vlc_mutex_need */
+ p_libvlc_lock = vlc_mutex_need( &libvlc, "libvlc" );
+ vlc_mutex_lock( p_libvlc_lock );
if( !libvlc.b_ready )
{
char *psz_env;
- vlc_mutex_init( &libvlc, &libvlc.structure_lock );
- libvlc.p_global_data = NULL;
- libvlc.b_ready = VLC_TRUE;
-
/* Guess what CPU we have */
libvlc.i_cpu = CPUCapabilities();
msg_Dbg( &libvlc, COPYRIGHT_MESSAGE );
msg_Dbg( &libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
- /* Initialize the module bank and and load the configuration of the
+ /* Initialize the module bank and load the configuration of the
* main module. We need to do this at this stage to be able to display
* a short help if required by the user. (short help == main module
* options) */
module_InitBank( &libvlc );
module_LoadMain( &libvlc );
+
+ libvlc.b_ready = VLC_TRUE;
}
- vlc_mutex_unlock( &libvlc.global_lock );
+ vlc_mutex_unlock( p_libvlc_lock );
+ vlc_mutex_unneed( &libvlc, "libvlc" );
/* Allocate a vlc object */
p_vlc = vlc_object_create( &libvlc, VLC_OBJECT_VLC );
else
{
int i_tmp = config_GetInt( p_vlc, "verbose" );
- if( i_tmp >= 0 && i_tmp <= 4 )
+ if( i_tmp >= 0 )
{
- libvlc.i_verbose = i_tmp;
+ libvlc.i_verbose = __MIN( i_tmp, 4 );
}
}
libvlc.b_color = libvlc.b_color || config_GetInt( p_vlc, "color" );
* objects.c: vlc_object_t handling
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: objects.c,v 1.22 2002/10/03 18:56:10 sam Exp $
+ * $Id: objects.c,v 1.23 2002/10/04 18:07:22 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
static vlc_list_t * NewList ( void );
static vlc_list_t * ListAppend ( vlc_list_t *, vlc_object_t * );
+/*****************************************************************************
+ * Local structure lock
+ *****************************************************************************/
+static vlc_mutex_t structure_lock;
+
/*****************************************************************************
* vlc_object_create: initialize a vlc object
*****************************************************************************
p_new->b_dead = VLC_FALSE;
p_new->b_attached = VLC_FALSE;
- /* If i_type is root, then p_new is our own p_libvlc */
if( i_type == VLC_OBJECT_ROOT )
{
- /* We are the first object ... no need to lock. */
+ /* If i_type is root, then p_new is actually p_libvlc */
p_new->p_libvlc = (libvlc_t*)p_new;
p_new->p_vlc = NULL;
p_new->p_vlc = ( i_type == VLC_OBJECT_VLC ) ? (vlc_t*)p_new
: p_this->p_vlc;
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
p_new->p_libvlc->i_counter++;
p_new->i_object_id = p_new->p_libvlc->i_counter;
p_new->p_libvlc->i_objects * sizeof(vlc_object_t *) );
p_new->p_libvlc->pp_objects[ p_new->p_libvlc->i_objects - 1 ] = p_new;
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
p_new->p_parent = NULL;
p_new->p_private = NULL;
+ /* Initialize mutexes and condvars */
vlc_mutex_init( p_new, &p_new->object_lock );
vlc_cond_init( p_new, &p_new->object_wait );
+ if( i_type == VLC_OBJECT_ROOT )
+ {
+ vlc_mutex_init( p_new, &structure_lock );
+ }
+
return p_new;
}
msleep( 100000 );
}
- /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
- * useless to try and recover anything if pp_objects gets smashed. */
- if( p_this->i_object_type != VLC_OBJECT_ROOT )
+ if( p_this->i_object_type == VLC_OBJECT_ROOT )
+ {
+ /* We are the root object ... no need to lock. */
+ free( p_this->p_libvlc->pp_objects );
+ p_this->p_libvlc->pp_objects = NULL;
+
+ vlc_mutex_destroy( &structure_lock );
+ }
+ else
{
int i_index;
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
+ /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
+ * useless to try and recover anything if pp_objects gets smashed. */
i_index = FindIndex( p_this, p_this->p_libvlc->pp_objects,
p_this->p_libvlc->i_objects );
memmove( p_this->p_libvlc->pp_objects + i_index,
realloc( p_this->p_libvlc->pp_objects,
(p_this->p_libvlc->i_objects - 1) * sizeof(vlc_object_t *) );
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
- }
- else
- {
- /* We are the root object ... no need to lock. */
- free( p_this->p_libvlc->pp_objects );
- p_this->p_libvlc->pp_objects = NULL;
+ vlc_mutex_unlock( &structure_lock );
}
p_this->p_libvlc->i_objects--;
{
vlc_object_t *p_found;
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
/* If we are of the requested type ourselves, don't look further */
if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type )
{
p_this->i_refcount++;
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
return p_this;
}
p_found = FindObject( p_this, i_type, i_mode );
}
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
return p_found;
}
*****************************************************************************/
void __vlc_object_yield( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
p_this->i_refcount++;
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_release( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
p_this->i_refcount--;
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent )
{
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
/* Attach the parent to its child */
p_this->p_parent = p_parent;
SetAttachment( p_this, VLC_TRUE );
}
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_detach( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
if( !p_this->p_parent )
{
msg_Err( p_this, "object is not attached" );
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
return;
}
}
DetachObject( p_this );
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
{
vlc_list_t *p_list = NewList();
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
/* Look for the objects */
if( (i_mode & 0x000f) == FIND_ANYWHERE )
msg_Err( p_this, "unimplemented!" );
}
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
return p_list;
}
{
vlc_object_t **pp_current, **pp_end;
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
pp_current = p_this->p_libvlc->pp_objects;
pp_end = pp_current + p_this->p_libvlc->i_objects;
}
}
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
{
char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1];
- vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
psz_foo[0] = '|';
DumpStructure( p_this, 0, psz_foo );
- vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
/*****************************************************************************
{
if( p_list->i_count )
{
- libvlc_t * p_libvlc = p_list->pp_objects[0]->p_libvlc;
vlc_object_t ** pp_current = p_list->pp_objects;
- vlc_mutex_lock( &p_libvlc->structure_lock );
+ vlc_mutex_lock( &structure_lock );
while( pp_current[0] )
{
pp_current++;
}
- vlc_mutex_unlock( &p_libvlc->structure_lock );
+ vlc_mutex_unlock( &structure_lock );
}
free( p_list );
* threads.c : threads implementation for the VideoLAN client
*****************************************************************************
* Copyright (C) 1999, 2000, 2001, 2002 VideoLAN
- * $Id: threads.c,v 1.20 2002/10/04 12:01:40 gbazin Exp $
+ * $Id: threads.c,v 1.21 2002/10/04 18:07:22 sam Exp $
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
#include <vlc/vlc.h>
+#include <stdlib.h>
+
#define VLC_THREADS_UNINITIALIZED 0
#define VLC_THREADS_PENDING 1
#define VLC_THREADS_ERROR 2
#elif defined( HAVE_KERNEL_SCHEDULER_H )
#endif
+/*****************************************************************************
+ * Global variable for named mutexes
+ *****************************************************************************/
+typedef struct vlc_namedmutex_t vlc_namedmutex_t;
+struct vlc_namedmutex_t
+{
+ vlc_mutex_t lock;
+
+ char *psz_name;
+ int i_usage;
+ vlc_namedmutex_t *p_next;
+};
+
+static vlc_namedmutex_t *p_named_list = NULL;
+static vlc_mutex_t named_lock;
+
/*****************************************************************************
* vlc_threads_init: initialize threads system
*****************************************************************************
#elif defined( HAVE_KERNEL_SCHEDULER_H )
#endif
- vlc_mutex_init( p_libvlc, &p_libvlc->global_lock );
+ vlc_mutex_init( p_libvlc, &named_lock );
if( i_ret )
{
#endif
}
+/*****************************************************************************
+ * vlc_mutex_need: create a global mutex from its name
+ *****************************************************************************/
+vlc_mutex_t * __vlc_mutex_need( vlc_object_t *p_this, char *psz_name )
+{
+ vlc_namedmutex_t *p_named;
+
+ vlc_mutex_lock( &named_lock );
+
+ p_named = p_named_list;
+ while( p_named )
+ {
+ if( !strcmp( psz_name, p_named->psz_name ) )
+ {
+ break;
+ }
+ p_named = p_named->p_next;
+ }
+
+ if( p_named )
+ {
+ p_named->i_usage++;
+ }
+ else
+ {
+ p_named = malloc( sizeof( vlc_namedmutex_t ) );
+ vlc_mutex_init( p_this, &p_named->lock );
+ p_named->psz_name = strdup( psz_name );
+ p_named->i_usage = 1;
+ p_named->p_next = p_named_list;
+ p_named_list = p_named;
+ }
+
+ vlc_mutex_unlock( &named_lock );
+
+ return &p_named->lock;
+}
+
+/*****************************************************************************
+ * vlc_mutex_unneed: destroy a global mutex from its name
+ *****************************************************************************/
+void __vlc_mutex_unneed( vlc_object_t *p_this, char *psz_name )
+{
+ vlc_namedmutex_t *p_named, *p_prev;
+
+ vlc_mutex_lock( &named_lock );
+
+ p_named = p_named_list;
+ p_prev = NULL;
+ while( p_named )
+ {
+ if( !strcmp( psz_name, p_named->psz_name ) )
+ {
+ break;
+ }
+ p_prev = p_named;
+ p_named = p_named->p_next;
+ }
+
+ if( p_named )
+ {
+ p_named->i_usage--;
+
+ if( p_named->i_usage <= 0 )
+ {
+ /* Unlink named mutex */
+ if( p_prev )
+ {
+ p_prev->p_next = p_named->p_next;
+ }
+ else
+ {
+ p_named_list = p_named->p_next;
+ }
+
+ /* Release this lock as soon as possible */
+ vlc_mutex_unlock( &named_lock );
+
+ vlc_mutex_destroy( &p_named->lock );
+ free( p_named->psz_name );
+ free( p_named );
+
+ return;
+ }
+ }
+ else
+ {
+ msg_Err( p_this, "no named mutex called %s", psz_name );
+ }
+
+ vlc_mutex_unlock( &named_lock );
+}
+
/*****************************************************************************
* vlc_mutex_destroy: destroy a mutex, inner version
*****************************************************************************/
projects / vlc / commitdiff