X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=da386566fe4f2742ec769b2601e584768e7d81ce;hb=048d2ad16972042be038dc52ec9a891e1b247432;hp=0bfca7c2272f6392ecb4f29cebdfee05a657e281;hpb=5b3a2948fe225056508a3420fff1da95a373e7af;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 0bfca7c227..da386566fe 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -2,7 +2,6 @@ * objects.c: vlc_object_t handling ***************************************************************************** * Copyright (C) 2004-2008 the VideoLAN team - * $Id$ * * Authors: Samuel Hocevar * @@ -24,6 +23,9 @@ /** * \file * This file contains the functions to handle the vlc_object_t type + * + * Unless otherwise stated, functions in this file are not cancellation point. + * All functions in this file are safe w.r.t. deferred cancellation. */ @@ -34,23 +36,14 @@ # include "config.h" #endif -#include +#include #include "../libvlc.h" -#include #include #include "audio_output/aout_internal.h" -#include -#include -#include - -#include -#include "stream_output/stream_output.h" - #include "vlc_interface.h" #include "vlc_codec.h" -#include "vlc_filter.h" #include "variables.h" #ifndef WIN32 @@ -60,13 +53,14 @@ # include # include /* ENOSYS */ #endif + #include -/***************************************************************************** - * Constants - *****************************************************************************/ +#if defined (HAVE_SYS_EVENTFD_H) +# include +# define HAVE_EVENTFD 1 +#endif -const vlc_destructor_t kVLCDestructor = NULL; /***************************************************************************** * Local prototypes @@ -76,11 +70,8 @@ static int DumpCommand( vlc_object_t *, char const *, static vlc_object_t * FindObject ( vlc_object_t *, int, int ); static vlc_object_t * FindObjectName( vlc_object_t *, const char *, int ); -static void DetachObject ( vlc_object_t * ); static void PrintObject ( vlc_object_t *, const char * ); static void DumpStructure ( vlc_object_t *, int, char * ); -static int FindIndex ( vlc_object_t *, vlc_object_t **, int ); -static void SetAttachment ( vlc_object_t *, vlc_bool_t ); static vlc_list_t * NewList ( int ); static void ListReplace ( vlc_list_t *, vlc_object_t *, int ); @@ -89,49 +80,61 @@ static int CountChildren ( vlc_object_t *, int ); static void ListChildren ( vlc_list_t *, vlc_object_t *, int ); static void vlc_object_destroy( vlc_object_t *p_this ); -static void vlc_object_yield_locked( vlc_object_t *p_this ); +static void vlc_object_detach_unlocked (vlc_object_t *p_this); +#ifndef NDEBUG +static void vlc_object_dump( vlc_object_t *p_this ); +#endif /***************************************************************************** * Local structure lock *****************************************************************************/ -static vlc_mutex_t structure_lock; +static void libvlc_lock (libvlc_int_t *p_libvlc) +{ + vlc_mutex_lock (&(libvlc_priv (p_libvlc)->structure_lock)); +} + +static void libvlc_unlock (libvlc_int_t *p_libvlc) +{ + vlc_mutex_unlock (&(libvlc_priv (p_libvlc)->structure_lock)); +} -void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, - int i_type, const char *psz_type ) +void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, + int i_type, const char *psz_type ) { vlc_object_t *p_new; vlc_object_internals_t *p_priv; + /* NOTE: + * VLC objects are laid out as follow: + * - first the LibVLC-private per-object data, + * - then VLC_COMMON members from vlc_object_t, + * - finally, the type-specific data (if any). + * + * This function initializes the LibVLC and common data, + * and zeroes the rest. + */ p_priv = calloc( 1, sizeof( *p_priv ) + i_size ); if( p_priv == NULL ) return NULL; - if( i_type == VLC_OBJECT_GLOBAL ) - p_new = p_this; - else - { - assert (i_size >= sizeof (vlc_object_t)); - p_new = (vlc_object_t *)(p_priv + 1); - } + assert (i_size >= sizeof (vlc_object_t)); + p_new = (vlc_object_t *)(p_priv + 1); - p_new->p_internals = p_priv; - p_new->i_object_type = i_type; + p_priv->i_object_type = i_type; p_new->psz_object_type = psz_type; + p_priv->psz_object_name = NULL; - p_new->psz_object_name = NULL; - - p_new->b_die = VLC_FALSE; - p_new->b_error = VLC_FALSE; - p_new->b_dead = VLC_FALSE; - p_priv->b_attached = VLC_FALSE; - p_new->b_force = VLC_FALSE; + p_new->b_die = false; + p_new->b_error = false; + p_new->b_force = false; p_new->psz_header = NULL; - p_new->i_flags |= p_this->i_flags - & (OBJECT_FLAGS_NODBG|OBJECT_FLAGS_QUIET|OBJECT_FLAGS_NOINTERACT); + if (p_this) + p_new->i_flags = p_this->i_flags + & (OBJECT_FLAGS_NODBG|OBJECT_FLAGS_QUIET|OBJECT_FLAGS_NOINTERACT); - p_priv->p_vars = calloc( sizeof( variable_t ), 16 ); + p_priv->p_vars = calloc( 16, sizeof( variable_t ) ); if( !p_priv->p_vars ) { @@ -139,71 +142,48 @@ void *vlc_custom_create( vlc_object_t *p_this, size_t i_size, return NULL; } - if( i_type == VLC_OBJECT_GLOBAL ) + if( p_this == NULL ) { - /* If i_type is global, then p_new is actually p_libvlc_global */ - libvlc_global_data_t *p_libvlc_global = (libvlc_global_data_t *)p_new; - p_new->p_libvlc = NULL; - - p_libvlc_global->i_counter = 0; - p_new->i_object_id = 0; - - p_libvlc_global->i_objects = 1; - p_libvlc_global->pp_objects = malloc( sizeof(vlc_object_t *) ); - p_libvlc_global->pp_objects[0] = p_new; - p_priv->b_attached = VLC_TRUE; - vlc_mutex_init( p_new, &structure_lock ); + libvlc_int_t *self = (libvlc_int_t*)p_new; + p_new->p_libvlc = self; + vlc_mutex_init (&(libvlc_priv (self)->structure_lock)); + p_this = p_priv->next = p_priv->prev = p_new; } else - { - libvlc_global_data_t *p_libvlc_global = vlc_global(); - if( i_type == VLC_OBJECT_LIBVLC ) - { - p_new->p_libvlc = (libvlc_int_t*)p_new; - p_priv->b_attached = VLC_TRUE; - } - else - { - p_new->p_libvlc = p_this->p_libvlc; - } - - vlc_mutex_lock( &structure_lock ); - - p_libvlc_global->i_counter++; - p_new->i_object_id = p_libvlc_global->i_counter; - - /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's - * useless to try and recover anything if pp_objects gets smashed. */ - TAB_APPEND( p_libvlc_global->i_objects, p_libvlc_global->pp_objects, - p_new ); - - vlc_mutex_unlock( &structure_lock ); - } + p_new->p_libvlc = p_this->p_libvlc; + vlc_spin_init( &p_priv->ref_spin ); p_priv->i_refcount = 1; - p_priv->pf_destructor = kVLCDestructor; - p_priv->b_thread = VLC_FALSE; + p_priv->pf_destructor = NULL; + p_priv->b_thread = false; p_new->p_parent = NULL; - p_new->pp_children = NULL; - p_new->i_children = 0; + p_priv->pp_children = NULL; + p_priv->i_children = 0; 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 ); - vlc_mutex_init( p_new, &p_priv->var_lock ); - vlc_spin_init( &p_priv->spin ); + vlc_mutex_init( &p_priv->var_lock ); + vlc_cond_init( &p_priv->var_wait ); p_priv->pipes[0] = p_priv->pipes[1] = -1; - if( i_type == VLC_OBJECT_LIBVLC ) - { + p_priv->next = p_this; + libvlc_lock (p_new->p_libvlc); + p_priv->prev = vlc_internals (p_this)->prev; + vlc_internals (p_this)->prev = p_new; + vlc_internals (p_priv->prev)->next = p_new; + libvlc_unlock (p_new->p_libvlc); + + if (p_new == VLC_OBJECT(p_new->p_libvlc)) + { /* TODO: should be in src/libvlc.c */ + int canc = vlc_savecancel (); var_Create( p_new, "list", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_new, "list", DumpCommand, NULL ); var_Create( p_new, "tree", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_new, "tree", DumpCommand, NULL ); var_Create( p_new, "vars", VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); var_AddCallback( p_new, "vars", DumpCommand, NULL ); + vlc_restorecancel (canc); } return p_new; @@ -225,69 +205,17 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) switch( i_type ) { - case VLC_OBJECT_LIBVLC: - i_size = sizeof(libvlc_int_t); - psz_type = "libvlc"; - break; - case VLC_OBJECT_INTF: - i_size = sizeof(intf_thread_t); - psz_type = "interface"; - break; - case VLC_OBJECT_DIALOGS: - i_size = sizeof(intf_thread_t); - psz_type = "dialogs"; - break; - case VLC_OBJECT_DEMUX: - i_size = sizeof(demux_t); - psz_type = "demux"; - break; - case VLC_OBJECT_ACCESS: - i_size = sizeof(access_t); - psz_type = "access"; - break; case VLC_OBJECT_DECODER: i_size = sizeof(decoder_t); psz_type = "decoder"; break; - case VLC_OBJECT_PACKETIZER: - i_size = sizeof(decoder_t); - psz_type = "packetizer"; - break; - case VLC_OBJECT_ENCODER: - i_size = sizeof(encoder_t); - psz_type = "encoder"; - break; - case VLC_OBJECT_FILTER: - i_size = sizeof(filter_t); - psz_type = "filter"; - break; - case VLC_OBJECT_VOUT: - i_size = sizeof(vout_thread_t); - psz_type = "video output"; - break; case VLC_OBJECT_AOUT: i_size = sizeof(aout_instance_t); psz_type = "audio output"; break; - case VLC_OBJECT_SOUT: - i_size = sizeof(sout_instance_t); - psz_type = "stream output"; - break; - case VLC_OBJECT_OPENGL: - i_size = sizeof( vout_thread_t ); - psz_type = "opengl"; - break; - case VLC_OBJECT_ANNOUNCE: - i_size = sizeof( announce_handler_t ); - psz_type = "announce"; - break; - case VLC_OBJECT_INTERACTION: - i_size = sizeof( interaction_t ); - psz_type = "interaction"; - break; default: - i_size = i_type > (int)sizeof(vlc_object_t) - ? i_type : (int)sizeof(vlc_object_t); + assert( i_type > 0 ); /* unknown type?! */ + i_size = i_type; i_type = VLC_OBJECT_GENERIC; psz_type = "generic"; break; @@ -310,9 +238,9 @@ void __vlc_object_set_destructor( vlc_object_t *p_this, { vlc_object_internals_t *p_priv = vlc_internals(p_this ); - vlc_mutex_lock( &structure_lock ); + vlc_spin_lock( &p_priv->ref_spin ); p_priv->pf_destructor = pf_destructor; - vlc_mutex_unlock( &structure_lock ); + vlc_spin_unlock( &p_priv->ref_spin ); } /** @@ -322,48 +250,25 @@ void __vlc_object_set_destructor( vlc_object_t *p_this, * This function destroys an object that has been previously allocated with * vlc_object_create. The object's refcount must be zero and it must not be * attached to other objects in any way. + * + * This function must be called with cancellation disabled (currently). *****************************************************************************/ static void vlc_object_destroy( vlc_object_t *p_this ) { vlc_object_internals_t *p_priv = vlc_internals( p_this ); - /* Automatically detach the object from its parents */ - if( p_this->p_parent ) vlc_object_detach( p_this ); - + /* Objects are always detached beforehand */ + assert( !p_this->p_parent ); /* Send a kill to the object's thread if applicable */ vlc_object_kill( p_this ); - /* If we are running on a thread, wait until it ends */ - if( p_priv->b_thread ) - vlc_thread_join( p_this ); - /* Call the custom "subclass" destructor */ if( p_priv->pf_destructor ) p_priv->pf_destructor( p_this ); - /* Sanity checks */ - if( p_this->i_children ) - { - int i; - - fprintf( stderr, - "ERROR: cannot delete object (%i, %s) with %d children\n", - p_this->i_object_id, p_this->psz_object_name, - p_this->i_children ); - - for( i = 0; i < p_this->i_children; i++ ) - { - fprintf( stderr, - "ERROR: Remaining children object " - "(id:%i, type:%s, name:%s)\n", - p_this->pp_children[i]->i_object_id, - p_this->pp_children[i]->psz_object_type, - p_this->pp_children[i]->psz_object_name ); - } - fflush(stderr); - abort(); - } + /* Any thread must have been cleaned up at this point. */ + assert( !p_priv->b_thread ); /* Destroy the associated variables, starting from the end so that * no memmove calls have to be done. */ @@ -373,70 +278,25 @@ static void vlc_object_destroy( vlc_object_t *p_this ) } free( p_priv->p_vars ); + vlc_cond_destroy( &p_priv->var_wait ); vlc_mutex_destroy( &p_priv->var_lock ); free( p_this->psz_header ); - if( p_this->i_object_type == VLC_OBJECT_GLOBAL ) - { - libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this; - - /* Test for leaks */ - if( p_global->i_objects > 0 ) - { - int i; - for( i = 0; i < p_global->i_objects; i++ ) - { - /* We are leaking this object */ - fprintf( stderr, - "ERROR: leaking object (id:%i, type:%s, name:%s)\n", - p_global->pp_objects[i]->i_object_id, - p_global->pp_objects[i]->psz_object_type, - p_global->pp_objects[i]->psz_object_name ); - fflush(stderr); - } - /* Strongly abort, cause we want these to be fixed */ - abort(); - } - - /* We are the global object ... no need to lock. */ - free( p_global->pp_objects ); - p_global->pp_objects = NULL; - - vlc_mutex_destroy( &structure_lock ); - } - -#if defined(WIN32) || defined(UNDER_CE) - /* if object has an associated thread, close it now */ - if( p_priv->thread_id.hThread ) - CloseHandle(p_priv->thread_id.hThread); -#endif + free( p_priv->psz_object_name ); - vlc_mutex_destroy( &p_this->object_lock ); - vlc_cond_destroy( &p_this->object_wait ); - vlc_spin_destroy( &p_priv->spin ); - if( p_priv->pipes[1] != -1 ) + vlc_spin_destroy( &p_priv->ref_spin ); + if( p_priv->pipes[1] != -1 && p_priv->pipes[1] != p_priv->pipes[0] ) close( p_priv->pipes[1] ); if( p_priv->pipes[0] != -1 ) close( p_priv->pipes[0] ); + if( VLC_OBJECT(p_this->p_libvlc) == p_this ) + vlc_mutex_destroy (&(libvlc_priv ((libvlc_int_t *)p_this)->structure_lock)); free( p_priv ); } -/** Inter-object signaling */ - -void __vlc_object_lock( vlc_object_t *obj ) -{ - vlc_mutex_lock( &obj->object_lock ); -} - -void __vlc_object_unlock( vlc_object_t *obj ) -{ - vlc_assert_locked( &obj->object_lock ); - vlc_mutex_unlock( &obj->object_lock ); -} - #ifdef WIN32 # include # include @@ -490,6 +350,8 @@ error: #define close( a ) closesocket (a) #endif /* WIN32 */ +static vlc_mutex_t pipe_lock = VLC_STATIC_MUTEX; + /** * Returns the readable end of a pipe that becomes readable once termination * of the object is requested (vlc_object_kill()). @@ -502,233 +364,69 @@ error: * @param obj object that would be "killed" * @return a readable pipe descriptor, or -1 on error. */ -int __vlc_object_waitpipe( vlc_object_t *obj ) +int vlc_object_waitpipe( vlc_object_t *obj ) { - int pfd[2] = { -1, -1 }; - struct vlc_object_internals_t *internals = obj->p_internals; - vlc_bool_t killed = VLC_FALSE; + vlc_object_internals_t *internals = vlc_internals( obj ); - vlc_spin_lock (&internals->spin); + vlc_mutex_lock (&pipe_lock); if (internals->pipes[0] == -1) { /* This can only ever happen if someone killed us without locking: */ assert (internals->pipes[1] == -1); - vlc_spin_unlock (&internals->spin); - - if (pipe (pfd)) - return -1; - vlc_spin_lock (&internals->spin); +#ifdef HAVE_EVENTFD + internals->pipes[0] = internals->pipes[1] = eventfd (0, 0); if (internals->pipes[0] == -1) +#endif { - internals->pipes[0] = pfd[0]; - internals->pipes[1] = pfd[1]; - pfd[0] = pfd[1] = -1; + if (pipe (internals->pipes)) + internals->pipes[0] = internals->pipes[1] = -1; } - killed = obj->b_die; - } - vlc_spin_unlock (&internals->spin); - - if (killed) - { - /* Race condition: vlc_object_kill() already invoked! */ - int fd; - - vlc_spin_lock (&internals->spin); - fd = internals->pipes[1]; - internals->pipes[1] = -1; - vlc_spin_unlock (&internals->spin); - msg_Dbg (obj, "waitpipe: object already dying"); - if (fd != -1) - close (fd); + if (internals->pipes[0] != -1 && obj->b_die) + { /* Race condition: vlc_object_kill() already invoked! */ + msg_Dbg (obj, "waitpipe: object already dying"); + write (internals->pipes[1], &(uint64_t){ 1 }, sizeof (uint64_t)); + } } - - /* Race condition: two threads call pipe() - unlikely */ - if (pfd[0] != -1) - close (pfd[0]); - if (pfd[1] != -1) - close (pfd[1]); - + vlc_mutex_unlock (&pipe_lock); return internals->pipes[0]; } /** - * Waits for the object to be signaled (using vlc_object_signal()). - * If the object already has a signal pending, this function will return - * immediately. It is asserted that the caller holds the object lock. - * - * @return true if the object is dying and should terminate. - */ -vlc_bool_t __vlc_object_wait( vlc_object_t *obj ) -{ - vlc_assert_locked( &obj->object_lock ); - vlc_cond_wait( &obj->object_wait, &obj->object_lock ); - return obj->b_die; -} - - -/** - * Waits for the object to be signaled (using vlc_object_signal()), or for - * a timer to expire. - * If the object already has a signal pending, this function will return - * immediately. It is asserted that the caller holds the object lock. - * - * @return negative if the object is dying and should terminate, - * positive if the the object has been signaled but is not dying, - * 0 if timeout has been reached. - */ -int __vlc_object_timedwait( vlc_object_t *obj, mtime_t deadline ) -{ - int v; - - vlc_assert_locked( &obj->object_lock ); - v = vlc_cond_timedwait( &obj->object_wait, &obj->object_lock, deadline ); - if( v == 0 ) /* signaled */ - return obj->b_die ? -1 : 1; - return 0; -} - - -/** - * Checks whether an object has been "killed". - * The object lock must be held. - * - * Typical code for an object thread could be: - * - vlc_object_lock (self); - ...initialization... - while (vlc_object_alive (self)) - { - ...preprocessing... - - if (vlc_object_wait (self)) - continue; - - ...postprocessing... - } - ...deinitialization... - vlc_object_unlock (self); - * - * - * @return true iff the object has not been killed yet - */ -vlc_bool_t __vlc_object_alive( vlc_object_t *obj ) -{ - vlc_assert_locked( &obj->object_lock ); - return !obj->b_die; -} - - -/** - * Signals an object for which the lock is held. - */ -void __vlc_object_signal_unlocked( vlc_object_t *obj ) -{ - vlc_assert_locked (&obj->object_lock); - vlc_cond_signal( &obj->object_wait ); -} - - -/** - * Requests termination of an object. - * If the object is LibVLC, also request to terminate all its children. + * Requests termination of an object, cancels the object thread, and make the + * object wait pipe (if it exists) readable. Not a cancellation point. */ void __vlc_object_kill( vlc_object_t *p_this ) { - struct vlc_object_internals_t *internals = p_this->p_internals; - int fd; - - vlc_mutex_lock( &p_this->object_lock ); - p_this->b_die = VLC_TRUE; - - vlc_spin_lock (&internals->spin); - fd = internals->pipes[1]; - internals->pipes[1] = -1; - vlc_spin_unlock (&internals->spin); + vlc_object_internals_t *priv = vlc_internals( p_this ); + int fd = -1; - if( fd != -1 ) + vlc_thread_cancel( p_this ); + vlc_mutex_lock( &pipe_lock ); + if( !p_this->b_die ) { - msg_Dbg (p_this, "waitpipe: object killed"); - close (fd); + fd = priv->pipes[1]; + p_this->b_die = true; } - if( p_this->i_object_type == VLC_OBJECT_LIBVLC ) - for( int i = 0; i < p_this->i_children ; i++ ) - vlc_object_kill( p_this->pp_children[i] ); - - vlc_object_signal_unlocked( p_this ); - vlc_mutex_unlock( &p_this->object_lock ); -} - + /* This also serves as a memory barrier toward vlc_object_alive(): */ + vlc_mutex_unlock( &pipe_lock ); -/** - * find an object given its ID - * - * This function looks for the object whose i_object_id field is i_id. We - * use a dichotomy so that lookups are in log2(n). - *****************************************************************************/ -void * vlc_object_get( int i_id ) -{ - int i_max, i_middle; - vlc_object_t **pp_objects; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - vlc_mutex_lock( &structure_lock ); - - pp_objects = p_libvlc_global->pp_objects; - - /* Perform our dichotomy */ - for( i_max = p_libvlc_global->i_objects - 1 ; ; ) + if (fd != -1) { - i_middle = i_max / 2; - - if( pp_objects[i_middle]->i_object_id > i_id ) - { - i_max = i_middle; - } - else if( pp_objects[i_middle]->i_object_id < i_id ) - { - if( i_middle ) - { - pp_objects += i_middle; - i_max -= i_middle; - } - else - { - /* This happens when there are only two remaining objects */ - if( pp_objects[i_middle+1]->i_object_id == i_id - && pp_objects[i_middle+1]->p_internals->i_refcount > 0 ) - { - vlc_object_yield_locked( pp_objects[i_middle+1] ); - vlc_mutex_unlock( &structure_lock ); - return pp_objects[i_middle+1]; - } - break; - } - } - else if( pp_objects[i_middle]->p_internals->i_refcount > 0 ) - { - vlc_object_yield_locked( pp_objects[i_middle] ); - vlc_mutex_unlock( &structure_lock ); - return pp_objects[i_middle]; - } + int canc = vlc_savecancel (); - if( i_max == 0 ) - { - /* this means that i_max == i_middle, and since we have already - * tested pp_objects[i_middle]), p_found is properly set. */ - break; - } + /* write _after_ setting b_die, so vlc_object_alive() returns false */ + write (fd, &(uint64_t){ 1 }, sizeof (uint64_t)); + msg_Dbg (p_this, "waitpipe: object killed"); + vlc_restorecancel (canc); } - - vlc_mutex_unlock( &structure_lock ); - return NULL; } -/** - **************************************************************************** + +/***************************************************************************** * find a typed object and increment its refcount ***************************************************************************** * This function recursively looks for a given object type. i_mode can be one @@ -738,74 +436,61 @@ void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) { vlc_object_t *p_found; - 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->p_internals->i_refcount > 0 ) + if( !(i_mode & FIND_STRICT) + && vlc_internals (p_this)->i_object_type == i_type ) { - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); + vlc_object_hold( p_this ); return p_this; } /* Otherwise, recursively look for the object */ - if( (i_mode & 0x000f) == FIND_ANYWHERE ) - { - vlc_object_t *p_root = p_this; - - /* Find the root */ - while( p_root->p_parent != NULL && - p_root != VLC_OBJECT( p_this->p_libvlc ) ) - { - p_root = p_root->p_parent; - } - - p_found = FindObject( p_root, i_type, (i_mode & ~0x000f)|FIND_CHILD ); - if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) ) - { - p_found = FindObject( VLC_OBJECT( p_this->p_libvlc ), - i_type, (i_mode & ~0x000f)|FIND_CHILD ); - } - } - else - { - p_found = FindObject( p_this, i_type, i_mode ); - } - - vlc_mutex_unlock( &structure_lock ); + if ((i_mode & 0x000f) == FIND_ANYWHERE) + return vlc_object_find (p_this->p_libvlc, i_type, + (i_mode & ~0x000f)|FIND_CHILD); + libvlc_lock (p_this->p_libvlc); + p_found = FindObject( p_this, i_type, i_mode ); + libvlc_unlock (p_this->p_libvlc); return p_found; } +#undef vlc_object_find_name /** - **************************************************************************** - * find a named object and increment its refcount - ***************************************************************************** - * This function recursively looks for a given object name. i_mode can be one - * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. - *****************************************************************************/ -void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name, - int i_mode ) + * Finds a named object and increment its reference count. + * Beware that objects found in this manner can be "owned" by another thread, + * be of _any_ type, and be attached to any module (if any). With such an + * object reference, you can set or get object variables, emit log messages, + * and read write-once object parameters (psz_object_type, etc). + * You CANNOT cast the object to a more specific object type, and you + * definitely cannot invoke object type-specific callbacks with this. + * + * @param p_this object to search from + * @param psz_name name of the object to search for + * @param i_mode search direction: FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. + * + * @return a matching object (must be released by the caller), + * or NULL on error. + */ +vlc_object_t *vlc_object_find_name( vlc_object_t *p_this, + const char *psz_name, int i_mode ) { vlc_object_t *p_found; - vlc_mutex_lock( &structure_lock ); - - /* Avoid obvious freed object uses */ - assert( p_this->p_internals->i_refcount > 0 ); - + /* Reading psz_object_name from a separate inhibits thread-safety. + * Use a libvlc address variable instead for that sort of things! */ + msg_Warn( p_this, "%s(%s) is not safe!", __func__, psz_name ); /* If have the requested name ourselves, don't look further */ if( !(i_mode & FIND_STRICT) - && p_this->psz_object_name - && !strcmp( p_this->psz_object_name, psz_name ) - && p_this->p_internals->i_refcount > 0 ) + && vlc_internals(p_this)->psz_object_name + && !strcmp( vlc_internals(p_this)->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); + vlc_object_hold( p_this ); return p_this; } + libvlc_lock (p_this->p_libvlc); + /* Otherwise, recursively look for the object */ if( (i_mode & 0x000f) == FIND_ANYWHERE ) { @@ -831,70 +516,109 @@ void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name, p_found = FindObjectName( p_this, psz_name, i_mode ); } - vlc_mutex_unlock( &structure_lock ); - + libvlc_unlock (p_this->p_libvlc); return p_found; } /** - **************************************************************************** - * increment an object refcount - *****************************************************************************/ - -/* When the structure_lock is locked */ -static void vlc_object_yield_locked( vlc_object_t *p_this ) + * Increment an object reference counter. + */ +void * __vlc_object_hold( vlc_object_t *p_this ) { - vlc_assert_locked (&structure_lock); + vlc_object_internals_t *internals = vlc_internals( p_this ); + vlc_spin_lock( &internals->ref_spin ); /* Avoid obvious freed object uses */ - assert( p_this->p_internals->i_refcount > 0 ); - + assert( internals->i_refcount > 0 ); /* Increment the counter */ - p_this->p_internals->i_refcount++; + internals->i_refcount++; + vlc_spin_unlock( &internals->ref_spin ); + return p_this; } -/* Public function */ -void __vlc_object_yield( vlc_object_t *p_this ) -{ - vlc_mutex_lock( &structure_lock ); - vlc_object_yield_locked( p_this ); - vlc_mutex_unlock( &structure_lock ); -} - - /***************************************************************************** - * decrement an object refcount + * Decrement an object refcount * And destroy the object if its refcount reach zero. *****************************************************************************/ void __vlc_object_release( vlc_object_t *p_this ) { - vlc_bool_t b_should_destroy; + vlc_object_internals_t *internals = vlc_internals( p_this ); + vlc_object_t *parent = NULL; + bool b_should_destroy; - vlc_mutex_lock( &structure_lock ); + vlc_spin_lock( &internals->ref_spin ); + assert( internals->i_refcount > 0 ); + + if( internals->i_refcount > 1 ) + { + /* Fast path */ + /* There are still other references to the object */ + internals->i_refcount--; + vlc_spin_unlock( &internals->ref_spin ); + return; + } + vlc_spin_unlock( &internals->ref_spin ); - assert( p_this->p_internals->i_refcount > 0 ); - p_this->p_internals->i_refcount--; - b_should_destroy = (p_this->p_internals->i_refcount == 0); + /* Slow path */ + /* Remember that we cannot hold the spin while waiting on the mutex */ + libvlc_lock (p_this->p_libvlc); + /* Take the spin again. Note that another thread may have held the + * object in the (very short) mean time. */ + vlc_spin_lock( &internals->ref_spin ); + b_should_destroy = --internals->i_refcount == 0; + vlc_spin_unlock( &internals->ref_spin ); if( b_should_destroy ) { - /* Make sure this object can't be obtained via vlc_find_object now that - * it is freed */ - libvlc_global_data_t *p_libvlc_global = vlc_global(); - int i_index; - - /* 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_libvlc_global->pp_objects, - p_libvlc_global->i_objects ); - REMOVE_ELEM( p_libvlc_global->pp_objects, - p_libvlc_global->i_objects, i_index ); - } + parent = p_this->p_parent; + +#ifndef NDEBUG + if( VLC_OBJECT(p_this->p_libvlc) == p_this ) + { + /* Test for leaks */ + vlc_object_t *leaked = internals->next; + while( leaked != p_this ) + { + /* We are leaking this object */ + fprintf( stderr, + "ERROR: leaking object (%p, type:%s, name:%s)\n", + leaked, leaked->psz_object_type, + vlc_internals(leaked)->psz_object_name ); + /* Dump object to ease debugging */ + vlc_object_dump( leaked ); + fflush(stderr); + leaked = vlc_internals (leaked)->next; + } + + if( internals->next != p_this ) + /* Dump libvlc object to ease debugging */ + vlc_object_dump( p_this ); + } +#endif + /* Remove the object from object list + * so that it cannot be encountered by vlc_object_get() */ + vlc_internals (internals->next)->prev = internals->prev; + vlc_internals (internals->prev)->next = internals->next; + + if (parent) + /* Detach from parent to protect against FIND_CHILDREN */ + vlc_object_detach_unlocked (p_this); - vlc_mutex_unlock( &structure_lock ); + /* We have no children */ + assert (internals->i_children == 0); + } + libvlc_unlock (p_this->p_libvlc); if( b_should_destroy ) + { + int canc; + + canc = vlc_savecancel (); vlc_object_destroy( p_this ); + vlc_restorecancel (canc); + if (parent) + vlc_object_release (parent); + } } /** @@ -908,27 +632,61 @@ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) { if( !p_this ) return; - vlc_mutex_lock( &structure_lock ); - - /* Avoid obvious freed object uses */ - assert( p_this->p_internals->i_refcount > 0 ); + vlc_object_hold (p_parent); + libvlc_lock (p_this->p_libvlc); /* Attach the parent to its child */ + assert (!p_this->p_parent); p_this->p_parent = p_parent; /* Attach the child to its parent */ - INSERT_ELEM( p_parent->pp_children, p_parent->i_children, - p_parent->i_children, p_this ); + vlc_object_internals_t *priv = vlc_internals( p_parent ); + INSERT_ELEM( priv->pp_children, priv->i_children, priv->i_children, + p_this ); + libvlc_unlock (p_this->p_libvlc); +} + - /* Climb up the tree to see whether we are connected with the root */ - if( p_parent->p_internals->b_attached ) +static void vlc_object_detach_unlocked (vlc_object_t *p_this) +{ + if (p_this->p_parent == NULL) + return; + + vlc_object_internals_t *priv = vlc_internals( p_this->p_parent ); + + int i_index, i; + + /* Remove p_this's parent */ + p_this->p_parent = NULL; + + /* Remove all of p_parent's children which are p_this */ + for( i_index = priv->i_children ; i_index-- ; ) { - SetAttachment( p_this, VLC_TRUE ); + if( priv->pp_children[i_index] == p_this ) + { + priv->i_children--; + for( i = i_index ; i < priv->i_children ; i++ ) + priv->pp_children[i] = priv->pp_children[i+1]; + } } - vlc_mutex_unlock( &structure_lock ); + if( priv->i_children ) + { + vlc_object_t **pp_children = (vlc_object_t **) + realloc( priv->pp_children, + priv->i_children * sizeof(vlc_object_t *) ); + if( pp_children ) + priv->pp_children = pp_children; + } + else + { + /* Special case - don't realloc() to zero to avoid leaking */ + free( priv->pp_children ); + priv->pp_children = NULL; + } } + /** **************************************************************************** * detach object from its parent @@ -937,28 +695,20 @@ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) *****************************************************************************/ void __vlc_object_detach( vlc_object_t *p_this ) { + vlc_object_t *p_parent; if( !p_this ) return; - vlc_mutex_lock( &structure_lock ); - - if( !p_this->p_parent ) - { - msg_Err( p_this, "object is not attached" ); - vlc_mutex_unlock( &structure_lock ); - return; - } - - /* Climb up the tree to see whether we are connected with the root */ - if( p_this->p_parent->p_internals->b_attached ) - { - SetAttachment( p_this, VLC_FALSE ); - } + libvlc_lock (p_this->p_libvlc); + p_parent = p_this->p_parent; + if (p_parent) + vlc_object_detach_unlocked( p_this ); + libvlc_unlock (p_this->p_libvlc); - DetachObject( p_this ); - vlc_mutex_unlock( &structure_lock ); - p_this = NULL; + if (p_parent) + vlc_object_release (p_parent); } + /** **************************************************************************** * find a list typed objects and increment their refcount @@ -966,59 +716,33 @@ void __vlc_object_detach( vlc_object_t *p_this ) * This function recursively looks for a given object type. i_mode can be one * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. *****************************************************************************/ -vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) +vlc_list_t * vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) { vlc_list_t *p_list; - vlc_object_t **pp_current, **pp_end; - int i_count = 0, i_index = 0; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - vlc_mutex_lock( &structure_lock ); + int i_count = 0; /* Look for the objects */ switch( i_mode & 0x000f ) { case FIND_ANYWHERE: - pp_current = p_libvlc_global->pp_objects; - pp_end = pp_current + p_libvlc_global->i_objects; - - for( ; pp_current < pp_end ; pp_current++ ) - { - if( (*pp_current)->p_internals->b_attached - && (*pp_current)->i_object_type == i_type ) - { - i_count++; - } - } - - p_list = NewList( i_count ); - pp_current = p_libvlc_global->pp_objects; - - for( ; pp_current < pp_end ; pp_current++ ) - { - if( (*pp_current)->p_internals->b_attached - && (*pp_current)->i_object_type == i_type ) - { - ListReplace( p_list, *pp_current, i_index ); - if( i_index < i_count ) i_index++; - } - } - break; + return vlc_list_find (VLC_OBJECT(p_this->p_libvlc), i_type, FIND_CHILD); case FIND_CHILD: + libvlc_lock (p_this->p_libvlc); i_count = CountChildren( p_this, i_type ); p_list = NewList( i_count ); /* Check allocation was successful */ if( p_list->i_count != i_count ) { - msg_Err( p_this, "list allocation failed!" ); + libvlc_unlock (p_this->p_libvlc); p_list->i_count = 0; break; } p_list->i_count = 0; ListChildren( p_list, p_this, i_type ); + libvlc_unlock (p_this->p_libvlc); break; default: @@ -1027,11 +751,30 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) break; } - vlc_mutex_unlock( &structure_lock ); - return p_list; } +/** + * Gets the list of children of an objects, and increment their reference + * count. + * @return a list (possibly empty) or NULL in case of error. + */ +vlc_list_t *__vlc_list_children( vlc_object_t *obj ) +{ + vlc_list_t *l; + vlc_object_internals_t *priv = vlc_internals( obj ); + + libvlc_lock (obj->p_libvlc); + l = NewList( priv->i_children ); + for (int i = 0; i < l->i_count; i++) + { + vlc_object_hold( priv->pp_children[i] ); + l->p_values[i].p_object = priv->pp_children[i]; + } + libvlc_unlock (obj->p_libvlc); + return l; +} + /***************************************************************************** * DumpCommand: print the current vlc structure ***************************************************************************** @@ -1042,33 +785,21 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, vlc_value_t oldval, vlc_value_t newval, void *p_data ) { - libvlc_global_data_t *p_libvlc_global = vlc_global(); + libvlc_int_t *p_libvlc = p_this->p_libvlc; (void)oldval; (void)p_data; if( *psz_cmd == 'l' ) { - vlc_mutex_lock( &structure_lock ); - - vlc_object_t **pp_current, **pp_end; - - pp_current = p_libvlc_global->pp_objects; - pp_end = pp_current + p_libvlc_global->i_objects; + vlc_object_t *cur = VLC_OBJECT (p_libvlc); - for( ; pp_current < pp_end ; pp_current++ ) + libvlc_lock (p_this->p_libvlc); + do { - if( (*pp_current)->p_internals->b_attached ) - { - PrintObject( *pp_current, "" ); - } - else - { - printf( " o %.8i %s (not attached)\n", - (*pp_current)->i_object_id, - (*pp_current)->psz_object_type ); - } + PrintObject (cur, ""); + cur = vlc_internals (cur)->next; } - - vlc_mutex_unlock( &structure_lock ); + while (cur != VLC_OBJECT(p_libvlc)); + libvlc_unlock (p_this->p_libvlc); } else { @@ -1076,45 +807,22 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, if( *newval.psz_string ) { - char *end; - int i_id = strtol( newval.psz_string, &end, 0 ); - if( end != newval.psz_string ) - p_object = vlc_object_get( i_id ); - else - { - /* try using the object's name to find it */ - vlc_object_t *p_libvlc = vlc_object_get( 1 ); - if( p_libvlc ) - { - /* Look in p_libvlc's children tree */ - p_object = vlc_object_find_name( p_libvlc, - newval.psz_string, - FIND_CHILD ); - vlc_object_release( p_libvlc ); - } - if( !p_object ) - { - /* If it's not in libvlc, look in libvlc_global (== p_this) */ - p_object = vlc_object_find_name( p_this, - newval.psz_string, - FIND_CHILD ); - } - } - + /* try using the object's name to find it */ + p_object = vlc_object_find_name( p_this, newval.psz_string, + FIND_ANYWHERE ); if( !p_object ) { return VLC_ENOOBJ; } } - vlc_mutex_lock( &structure_lock ); - + libvlc_lock (p_this->p_libvlc); if( *psz_cmd == 't' ) { char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; if( !p_object ) - p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this; + p_object = VLC_OBJECT(p_this->p_libvlc); psz_foo[0] = '|'; DumpStructure( p_object, 0, psz_foo ); @@ -1128,11 +836,11 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, PrintObject( p_object, "" ); - if( !p_object->p_internals->i_vars ) + if( !vlc_internals( p_object )->i_vars ) printf( " `-o No variables\n" ); - for( i = 0; i < p_object->p_internals->i_vars; i++ ) + for( i = 0; i < vlc_internals( p_object )->i_vars; i++ ) { - variable_t *p_var = p_object->p_internals->p_vars + i; + variable_t *p_var = vlc_internals( p_object )->p_vars + i; const char *psz_type = "unknown"; switch( p_var->i_type & VLC_VAR_TYPE ) @@ -1158,16 +866,18 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, #undef MYCASE } printf( " %c-o \"%s\" (%s", - i + 1 == p_object->p_internals->i_vars ? '`' : '|', + i + 1 == vlc_internals( p_object )->i_vars ? '`' : '|', p_var->psz_name, psz_type ); if( p_var->psz_text ) printf( ", %s", p_var->psz_text ); printf( ")" ); + if( p_var->i_type & VLC_VAR_HASCHOICE ) + printf( ", has choices" ); if( p_var->i_type & VLC_VAR_ISCOMMAND ) printf( ", command" ); if( p_var->i_entries ) printf( ", %d callbacks", p_var->i_entries ); - switch( p_var->i_type & 0x00f0 ) + switch( p_var->i_type & VLC_VAR_CLASS ) { case VLC_VAR_VOID: case VLC_VAR_MUTEX: @@ -1185,7 +895,7 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, printf( ": %f", p_var->val.f_float ); break; case VLC_VAR_TIME: - printf( ": " I64Fi, (int64_t)p_var->val.i_time ); + printf( ": %"PRIi64, (int64_t)p_var->val.i_time ); break; case VLC_VAR_ADDRESS: printf( ": %p", p_var->val.p_address ); @@ -1197,8 +907,7 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, printf( "\n" ); } } - - vlc_mutex_unlock( &structure_lock ); + libvlc_unlock (p_this->p_libvlc); if( *newval.psz_string ) { @@ -1231,57 +940,18 @@ void vlc_list_release( vlc_list_t *p_list ) /***************************************************************************** * dump an object. (Debug function) *****************************************************************************/ -void __vlc_object_dump( vlc_object_t *p_this ) +#ifndef NDEBUG +static void vlc_object_dump( vlc_object_t *p_this ) { - vlc_mutex_lock( &structure_lock ); char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; psz_foo[0] = '|'; + DumpStructure( p_this, 0, psz_foo ); - vlc_mutex_unlock( &structure_lock ); } +#endif /* Following functions are local */ -/***************************************************************************** - * FindIndex: find the index of an object in an array of objects - ***************************************************************************** - * This function assumes that p_this can be found in pp_objects. It will not - * crash if p_this cannot be found, but will return a wrong value. It is your - * duty to check the return value if you are not certain that the object could - * be found for sure. - *****************************************************************************/ -static int FindIndex( vlc_object_t *p_this, - vlc_object_t **pp_objects, int i_count ) -{ - int i_middle = i_count / 2; - - if( i_count == 0 ) - { - return 0; - } - - if( pp_objects[i_middle] == p_this ) - { - return i_middle; - } - - if( i_count == 1 ) - { - return 0; - } - - /* We take advantage of the sorted array */ - if( pp_objects[i_middle]->i_object_id < p_this->i_object_id ) - { - return i_middle + FindIndex( p_this, pp_objects + i_middle, - i_count - i_middle ); - } - else - { - return FindIndex( p_this, pp_objects, i_middle ); - } -} - static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) { int i; @@ -1293,10 +963,9 @@ static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) p_tmp = p_this->p_parent; if( p_tmp ) { - if( p_tmp->i_object_type == i_type - && p_tmp->p_internals->i_refcount > 0 ) + if( vlc_internals( p_tmp )->i_object_type == i_type ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_hold( p_tmp ); return p_tmp; } else @@ -1307,16 +976,15 @@ static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) break; case FIND_CHILD: - for( i = p_this->i_children; i--; ) + for( i = vlc_internals( p_this )->i_children; i--; ) { - p_tmp = p_this->pp_children[i]; - if( p_tmp->i_object_type == i_type - && p_tmp->p_internals->i_refcount > 0 ) + p_tmp = vlc_internals( p_this )->pp_children[i]; + if( vlc_internals( p_tmp )->i_object_type == i_type ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_hold( p_tmp ); return p_tmp; } - else if( p_tmp->i_children ) + else if( vlc_internals( p_tmp )->i_children ) { p_tmp = FindObject( p_tmp, i_type, i_mode ); if( p_tmp ) @@ -1348,11 +1016,10 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, p_tmp = p_this->p_parent; if( p_tmp ) { - if( p_tmp->psz_object_name - && !strcmp( p_tmp->psz_object_name, psz_name ) - && p_tmp->p_internals->i_refcount > 0 ) + if( vlc_internals(p_tmp)->psz_object_name + && !strcmp( vlc_internals(p_tmp)->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_hold( p_tmp ); return p_tmp; } else @@ -1363,17 +1030,16 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, break; case FIND_CHILD: - for( i = p_this->i_children; i--; ) + for( i = vlc_internals( p_this )->i_children; i--; ) { - p_tmp = p_this->pp_children[i]; - if( p_tmp->psz_object_name - && !strcmp( p_tmp->psz_object_name, psz_name ) - && p_tmp->p_internals->i_refcount > 0 ) + p_tmp = vlc_internals( p_this )->pp_children[i]; + if( vlc_internals(p_tmp)->psz_object_name + && !strcmp( vlc_internals(p_tmp)->psz_object_name, psz_name ) ) { - vlc_object_yield_locked( p_tmp ); + vlc_object_hold( p_tmp ); return p_tmp; } - else if( p_tmp->i_children ) + else if( vlc_internals( p_tmp )->i_children ) { p_tmp = FindObjectName( p_tmp, psz_name, i_mode ); if( p_tmp ) @@ -1392,72 +1058,24 @@ static vlc_object_t * FindObjectName( vlc_object_t *p_this, return NULL; } -static void DetachObject( vlc_object_t *p_this ) -{ - vlc_object_t *p_parent = p_this->p_parent; - int i_index, i; - - /* Remove p_this's parent */ - p_this->p_parent = NULL; - - /* Remove all of p_parent's children which are p_this */ - for( i_index = p_parent->i_children ; i_index-- ; ) - { - if( p_parent->pp_children[i_index] == p_this ) - { - p_parent->i_children--; - for( i = i_index ; i < p_parent->i_children ; i++ ) - { - p_parent->pp_children[i] = p_parent->pp_children[i+1]; - } - } - } - - if( p_parent->i_children ) - { - p_parent->pp_children = (vlc_object_t **)realloc( p_parent->pp_children, - p_parent->i_children * sizeof(vlc_object_t *) ); - } - else - { - free( p_parent->pp_children ); - p_parent->pp_children = NULL; - } -} - -/***************************************************************************** - * SetAttachment: recursively set the b_attached flag of a subtree. - ***************************************************************************** - * This function is used by the attach and detach functions to propagate - * the b_attached flag in a subtree. - *****************************************************************************/ -static void SetAttachment( vlc_object_t *p_this, vlc_bool_t b_attached ) -{ - int i_index; - - for( i_index = p_this->i_children ; i_index-- ; ) - { - SetAttachment( p_this->pp_children[i_index], b_attached ); - } - - p_this->p_internals->b_attached = b_attached; -} static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) { char psz_children[20], psz_refcount[20], psz_thread[30], psz_name[50], psz_parent[20]; - psz_name[0] = '\0'; - if( p_this->psz_object_name ) + int canc = vlc_savecancel (); + memset( &psz_name, 0, sizeof(psz_name) ); + if( vlc_internals(p_this)->psz_object_name ) { - snprintf( psz_name, 49, " \"%s\"", p_this->psz_object_name ); + snprintf( psz_name, 49, " \"%s\"", + vlc_internals(p_this)->psz_object_name ); if( psz_name[48] ) psz_name[48] = '\"'; } psz_children[0] = '\0'; - switch( p_this->i_children ) + switch( vlc_internals( p_this )->i_children ) { case 0: break; @@ -1465,32 +1083,30 @@ static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) strcpy( psz_children, ", 1 child" ); break; default: - snprintf( psz_children, 19, ", %i children", p_this->i_children ); + snprintf( psz_children, 19, ", %i children", + vlc_internals( p_this )->i_children ); break; } psz_refcount[0] = '\0'; - if( p_this->p_internals->i_refcount > 0 ) + if( vlc_internals( p_this )->i_refcount > 0 ) snprintf( psz_refcount, 19, ", refcount %u", - p_this->p_internals->i_refcount ); + vlc_internals( p_this )->i_refcount ); psz_thread[0] = '\0'; - if( p_this->p_internals->b_thread ) - snprintf( psz_thread, 29, " (thread %u)", -#if defined(WIN32) || defined(UNDER_CE) - (unsigned)p_this->p_internals->thread_id.id ); -#else - (unsigned)p_this->p_internals->thread_id ); -#endif + if( vlc_internals( p_this )->b_thread ) + snprintf( psz_thread, 29, " (thread %lu)", + (unsigned long)vlc_internals( p_this )->thread_id ); psz_parent[0] = '\0'; if( p_this->p_parent ) - snprintf( psz_parent, 19, ", parent %i", p_this->p_parent->i_object_id ); + snprintf( psz_parent, 19, ", parent %p", p_this->p_parent ); - printf( " %so %.8i %s%s%s%s%s%s\n", psz_prefix, - p_this->i_object_id, p_this->psz_object_type, + printf( " %so %p %s%s%s%s%s%s\n", psz_prefix, + p_this, p_this->psz_object_type, psz_name, psz_thread, psz_refcount, psz_children, psz_parent ); + vlc_restorecancel (canc); } static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) @@ -1509,7 +1125,7 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) return; } - for( i = 0 ; i < p_this->i_children ; i++ ) + for( i = 0 ; i < vlc_internals( p_this )->i_children ; i++ ) { if( i_level ) { @@ -1521,7 +1137,7 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) } } - if( i == p_this->i_children - 1 ) + if( i == vlc_internals( p_this )->i_children - 1 ) { psz_foo[i_level] = '`'; } @@ -1533,7 +1149,8 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) psz_foo[i_level+1] = '-'; psz_foo[i_level+2] = '\0'; - DumpStructure( p_this->pp_children[i], i_level + 2, psz_foo ); + DumpStructure( vlc_internals( p_this )->pp_children[i], i_level + 2, + psz_foo ); } } @@ -1571,7 +1188,7 @@ static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, return; } - vlc_object_yield_locked( p_object ); + vlc_object_hold( p_object ); p_list->p_values[i_index].p_object = p_object; @@ -1593,7 +1210,7 @@ static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, return; } - vlc_object_yield_locked( p_object ); + vlc_object_hold( p_object ); p_list->p_values[p_list->i_count].p_object = p_object; p_list->i_count++; @@ -1606,19 +1223,15 @@ static int CountChildren( vlc_object_t *p_this, int i_type ) vlc_object_t *p_tmp; int i, i_count = 0; - for( i = 0; i < p_this->i_children; i++ ) + for( i = 0; i < vlc_internals( p_this )->i_children; i++ ) { - p_tmp = p_this->pp_children[i]; + p_tmp = vlc_internals( p_this )->pp_children[i]; - if( p_tmp->i_object_type == i_type ) + if( vlc_internals( p_tmp )->i_object_type == i_type ) { i_count++; } - - if( p_tmp->i_children ) - { - i_count += CountChildren( p_tmp, i_type ); - } + i_count += CountChildren( p_tmp, i_type ); } return i_count; @@ -1629,18 +1242,13 @@ static void ListChildren( vlc_list_t *p_list, vlc_object_t *p_this, int i_type ) vlc_object_t *p_tmp; int i; - for( i = 0; i < p_this->i_children; i++ ) + for( i = 0; i < vlc_internals( p_this )->i_children; i++ ) { - p_tmp = p_this->pp_children[i]; + p_tmp = vlc_internals( p_this )->pp_children[i]; - if( p_tmp->i_object_type == i_type ) - { + if( vlc_internals( p_tmp )->i_object_type == i_type ) ListReplace( p_list, p_tmp, p_list->i_count++ ); - } - if( p_tmp->i_children ) - { - ListChildren( p_list, p_tmp, i_type ); - } + ListChildren( p_list, p_tmp, i_type ); } }