X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=65802c77c74cb3d89bc5e3e96acfaf90ac5149c1;hb=12ade3e3bc975d5426ba4af155b7372c31093b31;hp=59391df6738ba69fc586e45bbbcc9a05212c7aef;hpb=e7ee6a9d861ea4f62a828ebd929f8ecd15b4163f;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 59391df673..65802c77c7 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -2,6 +2,7 @@ * objects.c: vlc_object_t handling ***************************************************************************** * Copyright (C) 2004-2008 the VideoLAN team + * Copyright (C) 2006-2010 Rémi Denis-Courmont * * Authors: Samuel Hocevar * @@ -50,6 +51,14 @@ # include #else # include +# include +# include +# undef read +# define read( a, b, c ) recv (a, b, c, 0) +# undef write +# define write( a, b, c ) send (a, b, c, 0) +# undef close +# define close( a ) closesocket (a) #endif #include @@ -58,6 +67,10 @@ #if defined (HAVE_SYS_EVENTFD_H) # include +# ifndef EFD_CLOEXEC +# define EFD_CLOEXEC 0 +# warning EFD_CLOEXEC missing. Consider updating libc. +# endif #endif @@ -67,19 +80,16 @@ static int DumpCommand( vlc_object_t *, char const *, vlc_value_t, vlc_value_t, void * ); -static vlc_object_t * FindObject ( vlc_object_t *, int, int ); -static vlc_object_t * FindObjectName( vlc_object_t *, const char *, int ); -static void PrintObject ( vlc_object_t *, const char * ); -static void DumpStructure ( vlc_object_t *, int, char * ); +static vlc_object_t * FindParent ( vlc_object_t *, int ); +static vlc_object_t * FindChild ( vlc_object_internals_t *, int ); +static vlc_object_t * FindParentName( vlc_object_t *, const char * ); +static vlc_object_t * FindChildName ( vlc_object_internals_t *, const char * ); +static void PrintObject( vlc_object_internals_t *, const char * ); +static void DumpStructure( vlc_object_internals_t *, unsigned, char * ); static vlc_list_t * NewList ( int ); -static void ListReplace ( vlc_list_t *, vlc_object_t *, int ); -/*static void ListAppend ( vlc_list_t *, vlc_object_t * );*/ -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_detach_unlocked (vlc_object_t *p_this); /***************************************************************************** * Local structure lock @@ -94,8 +104,9 @@ 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 ) +#undef vlc_custom_create +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; @@ -121,7 +132,6 @@ void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_priv->psz_name = NULL; p_new->b_die = false; - p_new->b_error = false; p_new->b_force = false; p_new->psz_header = NULL; @@ -147,8 +157,7 @@ void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, p_priv->pf_destructor = NULL; p_priv->b_thread = false; p_new->p_parent = NULL; - p_priv->pp_children = NULL; - p_priv->i_children = 0; + p_priv->first = NULL; /* Initialize mutexes and condvars */ vlc_mutex_init( &p_priv->var_lock ); @@ -168,42 +177,20 @@ void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size, return p_new; } - +#undef vlc_object_create /** * Allocates and initializes a vlc object. * - * @param i_type known object type (all of them are negative integer values), - * or object byte size (always positive). + * @param i_size object byte size * * @return the new object, or NULL on error. */ -void * __vlc_object_create( vlc_object_t *p_this, int i_type ) +void *vlc_object_create( vlc_object_t *p_this, size_t i_size ) { - const char * psz_type; - size_t i_size; - - switch( i_type ) - { - case VLC_OBJECT_DECODER: - i_size = sizeof(decoder_t); - psz_type = "decoder"; - break; - case VLC_OBJECT_AOUT: - i_size = sizeof(aout_instance_t); - psz_type = "audio output"; - break; - default: - assert( i_type > 0 ); /* unknown type?! */ - i_size = i_type; - i_type = VLC_OBJECT_GENERIC; - psz_type = "generic"; - break; - } - - return vlc_custom_create( p_this, i_size, i_type, psz_type ); + return vlc_custom_create( p_this, i_size, VLC_OBJECT_GENERIC, "generic" ); } - +#undef vlc_object_set_destructor /** **************************************************************************** * Set the destructor of a vlc object @@ -212,8 +199,8 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) * when the object is destroyed when the its refcount reaches 0. * (It is called by the internal function vlc_object_destroy()) *****************************************************************************/ -void __vlc_object_set_destructor( vlc_object_t *p_this, - vlc_destructor_t pf_destructor ) +void vlc_object_set_destructor( vlc_object_t *p_this, + vlc_destructor_t pf_destructor ) { vlc_object_internals_t *p_priv = vlc_internals(p_this ); @@ -267,9 +254,6 @@ static void vlc_object_destroy( vlc_object_t *p_this ) { vlc_object_internals_t *p_priv = vlc_internals( 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 ); @@ -303,9 +287,6 @@ static void vlc_object_destroy( vlc_object_t *p_this ) #ifdef WIN32 -# include -# include - /** * select()-able pipes emulated using Winsock */ @@ -346,13 +327,6 @@ error: closesocket (c); return -1; } - -#undef read -#define read( a, b, c ) recv (a, b, c, 0) -#undef write -#define write( a, b, c ) send (a, b, c, 0) -#undef close -#define close( a ) closesocket (a) #endif /* WIN32 */ static vlc_mutex_t pipe_lock = VLC_STATIC_MUTEX; @@ -379,8 +353,11 @@ int vlc_object_waitpipe( vlc_object_t *obj ) /* This can only ever happen if someone killed us without locking: */ assert (internals->pipes[1] == -1); + /* pipe() is not a cancellation point, but write() is and eventfd() is + * unspecified (not in POSIX). */ + int canc = vlc_savecancel (); #if defined (HAVE_SYS_EVENTFD_H) - internals->pipes[0] = internals->pipes[1] = eventfd (0, 0); + internals->pipes[0] = internals->pipes[1] = eventfd (0, EFD_CLOEXEC); if (internals->pipes[0] == -1) #endif { @@ -393,17 +370,18 @@ int vlc_object_waitpipe( vlc_object_t *obj ) msg_Dbg (obj, "waitpipe: object already dying"); write (internals->pipes[1], &(uint64_t){ 1 }, sizeof (uint64_t)); } + vlc_restorecancel (canc); } vlc_mutex_unlock (&pipe_lock); return internals->pipes[0]; } - +#undef vlc_object_kill /** * 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 ) +void vlc_object_kill( vlc_object_t *p_this ) { vlc_object_internals_t *priv = vlc_internals( p_this ); int fd = -1; @@ -430,32 +408,55 @@ void __vlc_object_kill( vlc_object_t *p_this ) } } - +#undef vlc_object_find /***************************************************************************** * find a typed object and increment its refcount ***************************************************************************** * This function recursively looks for a given object type. i_mode can be one * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE. *****************************************************************************/ -void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) +void * vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) { vlc_object_t *p_found; /* If we are of the requested type ourselves, don't look further */ - if( !(i_mode & FIND_STRICT) - && vlc_internals (p_this)->i_object_type == i_type ) + if( vlc_internals (p_this)->i_object_type == i_type ) { vlc_object_hold( p_this ); return p_this; } /* Otherwise, recursively look for the object */ - if ((i_mode & 0x000f) == FIND_ANYWHERE) - return vlc_object_find (p_this->p_libvlc, i_type, - (i_mode & ~0x000f)|FIND_CHILD); + if (i_mode == FIND_ANYWHERE) + return vlc_object_find (VLC_OBJECT(p_this->p_libvlc), i_type, FIND_CHILD); + + switch (i_type) + { + case VLC_OBJECT_VOUT: + case VLC_OBJECT_AOUT: + break; + case VLC_OBJECT_INPUT: + /* input can only be accessed like this from children, + * otherwise we could not promise that it is initialized */ + if (i_mode != FIND_PARENT) + return NULL; + break; + default: + return NULL; + } libvlc_lock (p_this->p_libvlc); - p_found = FindObject( p_this, i_type, i_mode ); + switch (i_mode) + { + case FIND_PARENT: + p_found = FindParent (p_this, i_type); + break; + case FIND_CHILD: + p_found = FindChild (vlc_internals (p_this), i_type); + break; + default: + assert (0); + } libvlc_unlock (p_this->p_libvlc); return p_found; } @@ -498,47 +499,40 @@ vlc_object_t *vlc_object_find_name( vlc_object_t *p_this, * 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) && !objnamecmp(p_this, psz_name) ) + if( !objnamecmp(p_this, psz_name) ) { 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 ) - { - 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; - } + if (i_mode == FIND_ANYWHERE) + return vlc_object_find_name (VLC_OBJECT(p_this->p_libvlc), psz_name, + FIND_CHILD); - p_found = FindObjectName( p_root, psz_name, - (i_mode & ~0x000f)|FIND_CHILD ); - if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) ) - { - p_found = FindObjectName( VLC_OBJECT( p_this->p_libvlc ), - psz_name, (i_mode & ~0x000f)|FIND_CHILD ); - } - } - else + libvlc_lock (p_this->p_libvlc); + vlc_mutex_lock (&name_lock); + switch (i_mode) { - p_found = FindObjectName( p_this, psz_name, i_mode ); + case FIND_PARENT: + p_found = FindParentName (p_this, psz_name); + break; + case FIND_CHILD: + p_found = FindChildName (vlc_internals (p_this), psz_name); + break; + default: + assert (0); } - + vlc_mutex_unlock (&name_lock); libvlc_unlock (p_this->p_libvlc); return p_found; } +#undef vlc_object_hold /** * Increment an object reference counter. */ -void * __vlc_object_hold( vlc_object_t *p_this ) +void * vlc_object_hold( vlc_object_t *p_this ) { vlc_object_internals_t *internals = vlc_internals( p_this ); @@ -551,11 +545,12 @@ void * __vlc_object_hold( vlc_object_t *p_this ) return p_this; } +#undef vlc_object_release /***************************************************************************** * Decrement an object refcount * And destroy the object if its refcount reach zero. *****************************************************************************/ -void __vlc_object_release( vlc_object_t *p_this ) +void vlc_object_release( vlc_object_t *p_this ) { vlc_object_internals_t *internals = vlc_internals( p_this ); vlc_object_t *parent = NULL; @@ -585,13 +580,21 @@ void __vlc_object_release( vlc_object_t *p_this ) if( b_should_destroy ) { + /* Detach from parent to protect against FIND_CHILDREN */ parent = p_this->p_parent; - if (parent) - /* Detach from parent to protect against FIND_CHILDREN */ - vlc_object_detach_unlocked (p_this); + if (likely(parent)) + { + /* Unlink */ + if (internals->prev != NULL) + internals->prev->next = internals->next; + else + vlc_internals(parent)->first = internals->next; + if (internals->next != NULL) + internals->next->prev = internals->prev; + } /* We have no children */ - assert (internals->i_children == 0); + assert (internals->first == NULL); } libvlc_unlock (p_this->p_libvlc); @@ -607,155 +610,60 @@ void __vlc_object_release( vlc_object_t *p_this ) } } +#undef vlc_object_attach /** **************************************************************************** * attach object to a parent object ***************************************************************************** * This function sets p_this as a child of p_parent, and p_parent as a parent - * of p_this. This link can be undone using vlc_object_detach. + * of p_this. *****************************************************************************/ -void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) +void vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) { if( !p_this ) return; + vlc_object_internals_t *pap = vlc_internals (p_parent); + vlc_object_internals_t *priv = vlc_internals (p_this); + + priv->prev = NULL; vlc_object_hold (p_parent); libvlc_lock (p_this->p_libvlc); /* Attach the parent to its child */ - assert (!p_this->p_parent); + assert (p_this->p_parent == NULL); p_this->p_parent = p_parent; /* Attach the child to its parent */ - 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); -} - - -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-- ; ) - { - 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]; - } - } - - 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 - ***************************************************************************** - * This function removes all links between an object and its parent. - *****************************************************************************/ -void __vlc_object_detach( vlc_object_t *p_this ) -{ - vlc_object_t *p_parent; - if( !p_this ) return; - - libvlc_lock (p_this->p_libvlc); - p_parent = p_this->p_parent; - if (p_parent) - vlc_object_detach_unlocked( p_this ); + priv->next = pap->first; + if (priv->next != NULL) + priv->next->prev = priv; + pap->first = priv; libvlc_unlock (p_this->p_libvlc); - - if (p_parent) - vlc_object_release (p_parent); } -/** - **************************************************************************** - * find a list typed objects and increment their refcount - ***************************************************************************** - * 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 *p_list; - int i_count = 0; - - /* Look for the objects */ - switch( i_mode & 0x000f ) - { - case FIND_ANYWHERE: - 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 ) - { - 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: - msg_Err( p_this, "unimplemented!" ); - p_list = NewList( 0 ); - break; - } - - return p_list; -} - +#undef vlc_list_children /** * 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 *vlc_list_children( vlc_object_t *obj ) { vlc_list_t *l; - vlc_object_internals_t *priv = vlc_internals( obj ); + vlc_object_internals_t *priv; + unsigned count = 0; libvlc_lock (obj->p_libvlc); - l = NewList( priv->i_children ); - for (int i = 0; i < l->i_count; i++) + for (priv = vlc_internals (obj)->first; priv; priv = priv->next) + count++; + l = NewList (count); + if (likely(l != NULL)) { - vlc_object_hold( priv->pp_children[i] ); - l->p_values[i].p_object = priv->pp_children[i]; + unsigned i = 0; + + for (priv = vlc_internals (obj)->first; priv; priv = priv->next) + l->p_values[i++].p_object = vlc_object_hold (vlc_externals (priv)); } libvlc_unlock (obj->p_libvlc); return l; @@ -787,9 +695,9 @@ static void DumpVariable (const void *data, const VISIT which, const int depth) MYCASE( VARIABLE, "variable" ); MYCASE( FLOAT, "float" ); MYCASE( TIME, "time" ); + MYCASE( COORDS, "coords" ); MYCASE( ADDRESS, "address" ); MYCASE( MUTEX, "mutex" ); - MYCASE( LIST, "list" ); #undef MYCASE } printf( " *-o \"%s\" (%s", p_var->psz_name, psz_type ); @@ -811,7 +719,7 @@ static void DumpVariable (const void *data, const VISIT which, const int depth) printf( ": %s", p_var->val.b_bool ? "true" : "false" ); break; case VLC_VAR_INTEGER: - printf( ": %d", p_var->val.i_int ); + printf( ": %"PRId64, p_var->val.i_int ); break; case VLC_VAR_STRING: printf( ": \"%s\"", p_var->val.psz_string ); @@ -822,12 +730,13 @@ static void DumpVariable (const void *data, const VISIT which, const int depth) case VLC_VAR_TIME: printf( ": %"PRIi64, (int64_t)p_var->val.i_time ); break; + case VLC_VAR_COORDS: + printf( ": %"PRId32"x%"PRId32, + p_var->val.coords.x, p_var->val.coords.y ); + break; case VLC_VAR_ADDRESS: printf( ": %p", p_var->val.p_address ); break; - case VLC_VAR_LIST: - fputs( ": TODO", stdout ); - break; } fputc( '\n', stdout ); } @@ -865,14 +774,14 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, p_object = VLC_OBJECT(p_this->p_libvlc); psz_foo[0] = '|'; - DumpStructure( p_object, 0, psz_foo ); + DumpStructure( vlc_internals(p_object), 0, psz_foo ); } else if( *psz_cmd == 'v' ) { if( !p_object ) p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this; - PrintObject( p_object, "" ); + PrintObject( vlc_internals(p_object), "" ); vlc_mutex_lock( &vlc_internals( p_object )->var_lock ); if( vlc_internals( p_object )->var_root == NULL ) puts( " `-o No variables" ); @@ -910,179 +819,115 @@ void vlc_list_release( vlc_list_t *p_list ) /* Following functions are local */ -static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode ) +static vlc_object_t *FindParent (vlc_object_t *p_this, int i_type) { - int i; - vlc_object_t *p_tmp; + for (vlc_object_t *parent = p_this->p_parent; + parent != NULL; + parent = parent->p_parent) + { + if (vlc_internals (parent)->i_object_type == i_type) + return vlc_object_hold (parent); + } + return NULL; +} - switch( i_mode & 0x000f ) +static vlc_object_t *FindParentName (vlc_object_t *p_this, const char *name) +{ + for (vlc_object_t *parent = p_this->p_parent; + parent != NULL; + parent = parent->p_parent) { - case FIND_PARENT: - p_tmp = p_this->p_parent; - if( p_tmp ) - { - if( vlc_internals( p_tmp )->i_object_type == i_type ) - { - vlc_object_hold( p_tmp ); - return p_tmp; - } - else - { - return FindObject( p_tmp, i_type, i_mode ); - } - } - break; + const char *objname = vlc_internals (parent)->psz_name; + if (objname && !strcmp (objname, name)) + return vlc_object_hold (parent); + } + return NULL; +} - case FIND_CHILD: - for( i = vlc_internals( p_this )->i_children; i--; ) - { - p_tmp = vlc_internals( p_this )->pp_children[i]; - if( vlc_internals( p_tmp )->i_object_type == i_type ) - { - vlc_object_hold( p_tmp ); - return p_tmp; - } - else if( vlc_internals( p_tmp )->i_children ) - { - p_tmp = FindObject( p_tmp, i_type, i_mode ); - if( p_tmp ) - { - return p_tmp; - } - } - } - break; +static vlc_object_t *FindChild (vlc_object_internals_t *priv, int i_type) +{ + for (priv = priv->first; priv != NULL; priv = priv->next) + { + if (priv->i_object_type == i_type) + return vlc_object_hold (vlc_externals (priv)); - case FIND_ANYWHERE: - /* Handled in vlc_object_find */ - break; + vlc_object_t *found = FindChild (priv, i_type); + if (found != NULL) + return found; } - return NULL; } -static vlc_object_t * FindObjectName( vlc_object_t *p_this, - const char *psz_name, - int i_mode ) +static vlc_object_t *FindChildName (vlc_object_internals_t *priv, + const char *name) { - int i; - vlc_object_t *p_tmp; - - switch( i_mode & 0x000f ) + for (priv = priv->first; priv != NULL; priv = priv->next) { - case FIND_PARENT: - p_tmp = p_this->p_parent; - if( p_tmp ) - { - if( !objnamecmp(p_tmp, psz_name) ) - { - vlc_object_hold( p_tmp ); - return p_tmp; - } - else - { - return FindObjectName( p_tmp, psz_name, i_mode ); - } - } - break; - - case FIND_CHILD: - for( i = vlc_internals( p_this )->i_children; i--; ) - { - p_tmp = vlc_internals( p_this )->pp_children[i]; - if( !objnamecmp(p_tmp, psz_name ) ) - { - vlc_object_hold( p_tmp ); - return p_tmp; - } - else if( vlc_internals( p_tmp )->i_children ) - { - p_tmp = FindObjectName( p_tmp, psz_name, i_mode ); - if( p_tmp ) - { - return p_tmp; - } - } - } - break; + if (priv->psz_name && !strcmp (priv->psz_name, name)) + return vlc_object_hold (vlc_externals (priv)); - case FIND_ANYWHERE: - /* Handled in vlc_object_find */ - break; + vlc_object_t *found = FindChildName (priv, name); + if (found != NULL) + return found; } - return NULL; } - -static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) +static void PrintObject( vlc_object_internals_t *priv, + const char *psz_prefix ) { - char psz_children[20], psz_refcount[20], psz_thread[30], psz_name[50], - psz_parent[20]; + char psz_refcount[20], psz_thread[30], psz_name[50], psz_parent[20]; int canc = vlc_savecancel (); memset( &psz_name, 0, sizeof(psz_name) ); - char *name = vlc_object_get_name(p_this); - if( name ) + + vlc_mutex_lock (&name_lock); + if (priv->psz_name != NULL) { - snprintf( psz_name, 49, " \"%s\"", name ); - free( name ); + snprintf( psz_name, 49, " \"%s\"", priv->psz_name ); if( psz_name[48] ) psz_name[48] = '\"'; } - - psz_children[0] = '\0'; - switch( vlc_internals( p_this )->i_children ) - { - case 0: - break; - case 1: - strcpy( psz_children, ", 1 child" ); - break; - default: - snprintf( psz_children, 19, ", %i children", - vlc_internals( p_this )->i_children ); - break; - } + vlc_mutex_unlock (&name_lock); psz_refcount[0] = '\0'; - if( vlc_internals( p_this )->i_refcount > 0 ) - snprintf( psz_refcount, 19, ", refcount %u", - vlc_internals( p_this )->i_refcount ); + if( priv->i_refcount > 0 ) + snprintf( psz_refcount, 19, ", %u refs", priv->i_refcount ); psz_thread[0] = '\0'; - if( vlc_internals( p_this )->b_thread ) + if( priv->b_thread ) snprintf( psz_thread, 29, " (thread %lu)", - (unsigned long)vlc_internals( p_this )->thread_id ); + (unsigned long)priv->thread_id ); psz_parent[0] = '\0'; - if( p_this->p_parent ) - snprintf( psz_parent, 19, ", parent %p", p_this->p_parent ); - - 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 ); + /* FIXME: need structure lock!!! */ + if( vlc_externals(priv)->p_parent ) + snprintf( psz_parent, 19, ", parent %p", + vlc_externals(priv)->p_parent ); + + printf( " %so %p %s%s%s%s%s\n", psz_prefix, + vlc_externals(priv), vlc_externals(priv)->psz_object_type, + psz_name, psz_thread, psz_refcount, psz_parent ); vlc_restorecancel (canc); } -static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) +static void DumpStructure (vlc_object_internals_t *priv, unsigned i_level, + char *psz_foo) { - int i; char i_back = psz_foo[i_level]; psz_foo[i_level] = '\0'; - PrintObject( p_this, psz_foo ); + PrintObject (priv, psz_foo); psz_foo[i_level] = i_back; if( i_level / 2 >= MAX_DUMPSTRUCTURE_DEPTH ) { - msg_Warn( p_this, "structure tree is too deep" ); + msg_Warn( vlc_externals(priv), "structure tree is too deep" ); return; } - for( i = 0 ; i < vlc_internals( p_this )->i_children ; i++ ) + for (priv = priv->first; priv != NULL; priv = priv->next) { if( i_level ) { @@ -1094,20 +939,11 @@ static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) } } - if( i == vlc_internals( p_this )->i_children - 1 ) - { - psz_foo[i_level] = '`'; - } - else - { - psz_foo[i_level] = '|'; - } - + psz_foo[i_level] = priv->next ? '|' : '`'; psz_foo[i_level+1] = '-'; psz_foo[i_level+2] = '\0'; - DumpStructure( vlc_internals( p_this )->pp_children[i], i_level + 2, - psz_foo ); + DumpStructure (priv, i_level + 2, psz_foo); } } @@ -1134,76 +970,3 @@ static vlc_list_t * NewList( int i_count ) return p_list; } - -static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, - int i_index ) -{ - if( p_list == NULL || i_index >= p_list->i_count ) - { - return; - } - - vlc_object_hold( p_object ); - - p_list->p_values[i_index].p_object = p_object; - - return; -} - -/*static void ListAppend( vlc_list_t *p_list, vlc_object_t *p_object ) -{ - if( p_list == NULL ) - { - return; - } - - p_list->p_values = realloc_or_free( p_list->p_values, - (p_list->i_count + 1) * sizeof( vlc_value_t ) ); - if( p_list->p_values == NULL ) - { - p_list->i_count = 0; - return; - } - - vlc_object_hold( p_object ); - - p_list->p_values[p_list->i_count].p_object = p_object; - p_list->i_count++; - - return; -}*/ - -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 < vlc_internals( p_this )->i_children; i++ ) - { - p_tmp = vlc_internals( p_this )->pp_children[i]; - - if( vlc_internals( p_tmp )->i_object_type == i_type ) - { - i_count++; - } - i_count += CountChildren( p_tmp, i_type ); - } - - return i_count; -} - -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 < vlc_internals( p_this )->i_children; i++ ) - { - p_tmp = vlc_internals( p_this )->pp_children[i]; - - if( vlc_internals( p_tmp )->i_object_type == i_type ) - ListReplace( p_list, p_tmp, p_list->i_count++ ); - - ListChildren( p_list, p_tmp, i_type ); - } -}