X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fobjects.c;h=49b784e1d679baba78e7847814c21dbe691c6f70;hb=690aa907649d409f2e5738571f1dbe3e98f792d4;hp=9fda906e4f8728ea089a103892ba4e9cbacc05a8;hpb=25cd1327a67705cdecbb8754f405be01557a175b;p=vlc diff --git a/src/misc/objects.c b/src/misc/objects.c index 9fda906e4f..49b784e1d6 100644 --- a/src/misc/objects.c +++ b/src/misc/objects.c @@ -1,8 +1,8 @@ /***************************************************************************** * objects.c: vlc_object_t handling ***************************************************************************** - * Copyright (C) 2004 VideoLAN - * $Id: objects.c,v 1.44 2004/01/06 12:02:06 zorglub Exp $ + * Copyright (C) 2004 the VideoLAN team + * $Id$ * * Authors: Samuel Hocevar * @@ -18,7 +18,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /** @@ -36,22 +36,33 @@ # include /* realloc() */ #endif -#include "stream_control.h" -#include "input_ext-intf.h" -#include "input_ext-dec.h" +#include "../libvlc.h" +#include +#include +#include "audio_output/aout_internal.h" -#include "vlc_video.h" -#include "video_output.h" +#include +#include +#include -#include "audio_output.h" -#include "aout_internal.h" -#include "stream_output.h" +#include +#include "stream_output/stream_output.h" #include "vlc_playlist.h" #include "vlc_interface.h" #include "vlc_codec.h" +#include "vlc_filter.h" + +#include "vlc_httpd.h" +#include "vlc_vlm.h" +#include "vlc_vod.h" +#include "vlc_tls.h" +#include "vlc_xml.h" +#include "vlc_osd.h" +#include "vlc_meta.h" + +#include "variables.h" -#include "httpd.h" /***************************************************************************** * Local prototypes *****************************************************************************/ @@ -67,7 +78,7 @@ 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 ); -static void ListAppend ( vlc_list_t *, vlc_object_t * ); +/*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 ); @@ -76,108 +87,19 @@ static void ListChildren ( vlc_list_t *, vlc_object_t *, int ); *****************************************************************************/ static vlc_mutex_t structure_lock; -/***************************************************************************** - * vlc_object_create: initialize a vlc object - ***************************************************************************** - * This function allocates memory for a vlc object and initializes it. If - * i_type is not a known value such as VLC_OBJECT_ROOT, VLC_OBJECT_VOUT and - * so on, vlc_object_create will use its value for the object size. - *****************************************************************************/ - -/** - * Initialize a vlc object - * - * This function allocates memory for a vlc object and initializes it. If - * i_type is not a known value such as VLC_OBJECT_ROOT, VLC_OBJECT_VOUT and - * so on, vlc_object_create will use its value for the object size. - */ -void * __vlc_object_create( vlc_object_t *p_this, int i_type ) +vlc_object_t *vlc_custom_create( vlc_object_t *p_this, size_t i_size, + int i_type, const char *psz_type ) { - vlc_object_t * p_new; - char * psz_type; - size_t i_size; + vlc_object_t * p_new = NULL; - switch( i_type ) - { - case VLC_OBJECT_ROOT: - i_size = sizeof(libvlc_t); - psz_type = "root"; - break; - case VLC_OBJECT_VLC: - i_size = sizeof(vlc_t); - psz_type = "vlc"; - break; - case VLC_OBJECT_MODULE: - i_size = sizeof(module_t); - psz_type = "module"; - 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 provider"; - break; - case VLC_OBJECT_PLAYLIST: - i_size = sizeof(playlist_t); - psz_type = "playlist"; - break; - case VLC_OBJECT_INPUT: - i_size = sizeof(input_thread_t); - psz_type = "input"; - 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_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_HTTPD: - i_size = sizeof( httpd_t ); - psz_type = "http daemon"; - break; - default: - i_size = i_type > 0 - ? i_type > (int)sizeof(vlc_object_t) - ? i_type : (int)sizeof(vlc_object_t) - : (int)sizeof(vlc_object_t); - i_type = VLC_OBJECT_GENERIC; - psz_type = "generic"; - break; - } - - if( i_type == VLC_OBJECT_ROOT ) + if( i_type == VLC_OBJECT_GLOBAL ) { p_new = p_this; } else { p_new = malloc( i_size ); - - if( !p_new ) - { - return NULL; - } - + if( !p_new ) return NULL; memset( p_new, 0, i_size ); } @@ -190,47 +112,58 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) p_new->b_error = VLC_FALSE; p_new->b_dead = VLC_FALSE; p_new->b_attached = VLC_FALSE; + p_new->b_force = VLC_FALSE; + + p_new->psz_header = NULL; + + p_new->i_flags = 0; + if( p_this->i_flags & OBJECT_FLAGS_NODBG ) + p_new->i_flags |= OBJECT_FLAGS_NODBG; + if( p_this->i_flags & OBJECT_FLAGS_QUIET ) + p_new->i_flags |= OBJECT_FLAGS_QUIET; + if( p_this->i_flags & OBJECT_FLAGS_NOINTERACT ) + p_new->i_flags |= OBJECT_FLAGS_NOINTERACT; p_new->i_vars = 0; p_new->p_vars = (variable_t *)malloc( 16 * sizeof( variable_t ) ); if( !p_new->p_vars ) { - free( p_new ); + if( i_type != VLC_OBJECT_GLOBAL ) + free( p_new ); return NULL; } - if( i_type == VLC_OBJECT_ROOT ) + if( i_type == VLC_OBJECT_GLOBAL ) { - /* 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; + /* If i_type is global, then p_new is actually p_libvlc_global */ + p_new->p_libvlc_global = (libvlc_global_data_t*)p_new; + p_new->p_libvlc = NULL; - p_new->p_libvlc->i_counter = 0; + p_new->p_libvlc_global->i_counter = 0; p_new->i_object_id = 0; - p_new->p_libvlc->i_objects = 1; - p_new->p_libvlc->pp_objects = malloc( sizeof(vlc_object_t *) ); - p_new->p_libvlc->pp_objects[0] = p_new; + p_new->p_libvlc_global->i_objects = 1; + p_new->p_libvlc_global->pp_objects = malloc( sizeof(vlc_object_t *) ); + p_new->p_libvlc_global->pp_objects[0] = p_new; p_new->b_attached = VLC_TRUE; } else { - p_new->p_libvlc = p_this->p_libvlc; - p_new->p_vlc = ( i_type == VLC_OBJECT_VLC ) ? (vlc_t*)p_new - : p_this->p_vlc; + p_new->p_libvlc_global = p_this->p_libvlc_global; + p_new->p_libvlc = ( i_type == VLC_OBJECT_LIBVLC ) ? (libvlc_int_t*)p_new + : p_this->p_libvlc; 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_global->i_counter++; + p_new->i_object_id = p_new->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. */ - INSERT_ELEM( p_new->p_libvlc->pp_objects, - p_new->p_libvlc->i_objects, - p_new->p_libvlc->i_objects, - p_new ); + TAB_APPEND( p_new->p_libvlc_global->i_objects, + p_new->p_libvlc_global->pp_objects, + p_new ); vlc_mutex_unlock( &structure_lock ); } @@ -247,7 +180,7 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) vlc_cond_init( p_new, &p_new->object_wait ); vlc_mutex_init( p_new, &p_new->var_lock ); - if( i_type == VLC_OBJECT_ROOT ) + if( i_type == VLC_OBJECT_GLOBAL ) { vlc_mutex_init( p_new, &structure_lock ); @@ -255,15 +188,153 @@ void * __vlc_object_create( vlc_object_t *p_this, int i_type ) 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 ); } return p_new; } + +/** + * 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). + * + * @return the new object, or NULL on error. + */ +void * __vlc_object_create( vlc_object_t *p_this, int i_type ) +{ + const char * psz_type; + size_t i_size; + + switch( i_type ) + { + case VLC_OBJECT_GLOBAL: + i_size = sizeof(libvlc_global_data_t); + psz_type = "global"; + break; + case VLC_OBJECT_LIBVLC: + i_size = sizeof(libvlc_int_t); + psz_type = "libvlc"; + break; + case VLC_OBJECT_MODULE: + i_size = sizeof(module_t); + psz_type = "module"; + 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_PLAYLIST: + i_size = sizeof(playlist_t); + psz_type = "playlist"; + break; + case VLC_OBJECT_SD: + i_size = sizeof(services_discovery_t); + psz_type = "services discovery"; + break; + case VLC_OBJECT_INPUT: + i_size = sizeof(input_thread_t); + psz_type = "input"; + break; + case VLC_OBJECT_DEMUX: + i_size = sizeof(demux_t); + psz_type = "demux"; + break; + case VLC_OBJECT_STREAM: + i_size = sizeof(stream_t); + psz_type = "stream"; + 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_SPU: + i_size = sizeof(spu_t); + psz_type = "subpicture"; + 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_VLM: + i_size = sizeof( vlm_t ); + psz_type = "vlm dameon"; + break; + case VLC_OBJECT_VOD: + i_size = sizeof( vod_t ); + psz_type = "vod server"; + break; + case VLC_OBJECT_TLS: + i_size = sizeof( tls_t ); + psz_type = "tls"; + break; + case VLC_OBJECT_XML: + i_size = sizeof( xml_t ); + psz_type = "xml"; + 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_META_ENGINE: + i_size = sizeof( meta_engine_t ); + psz_type = "meta engine"; + break; + case VLC_OBJECT_OSDMENU: + i_size = sizeof( osd_menu_t ); + psz_type = "osd menu"; + break; + default: + i_size = i_type > (int)sizeof(vlc_object_t) + ? i_type : (int)sizeof(vlc_object_t); + i_type = VLC_OBJECT_GENERIC; + psz_type = "generic"; + break; + } + + return vlc_custom_create( p_this, i_size, i_type, psz_type ); +} + + /** **************************************************************************** * Destroy a vlc object - * + * * 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. @@ -293,17 +364,23 @@ void __vlc_object_destroy( vlc_object_t *p_this ) /* Don't warn immediately ... 100ms seems OK */ if( i_delay == 2 ) { - msg_Warn( p_this, "refcount is %i, delaying before deletion", - p_this->i_refcount ); + msg_Warn( p_this, + "refcount is %i, delaying before deletion (id=%d,type=%d)", + p_this->i_refcount, p_this->i_object_id, + p_this->i_object_type ); } - else if( i_delay == 12 ) + else if( i_delay == 10 ) { - msg_Err( p_this, "refcount is %i, I have a bad feeling about this", - p_this->i_refcount ); + msg_Err( p_this, + "refcount is %i, delaying again (id=%d,type=%d)", + p_this->i_refcount, p_this->i_object_id, + p_this->i_object_type ); } - else if( i_delay == 42 ) + else if( i_delay == 20 ) { - msg_Err( p_this, "we waited too long, cancelling destruction" ); + msg_Err( p_this, + "waited too long, cancelling destruction (id=%d,type=%d)", + p_this->i_object_id, p_this->i_object_type ); return; } @@ -320,12 +397,14 @@ void __vlc_object_destroy( vlc_object_t *p_this ) free( p_this->p_vars ); vlc_mutex_destroy( &p_this->var_lock ); - if( p_this->i_object_type == VLC_OBJECT_ROOT ) + if( p_this->psz_header ) free( p_this->psz_header ); + + if( p_this->i_object_type == VLC_OBJECT_GLOBAL ) { - /* We are the root object ... no need to lock. */ - free( p_this->p_libvlc->pp_objects ); - p_this->p_libvlc->pp_objects = NULL; - p_this->p_libvlc->i_objects--; + /* We are the global object ... no need to lock. */ + free( p_this->p_libvlc_global->pp_objects ); + p_this->p_libvlc_global->pp_objects = NULL; + p_this->p_libvlc_global->i_objects--; vlc_mutex_destroy( &structure_lock ); } @@ -337,10 +416,10 @@ void __vlc_object_destroy( vlc_object_t *p_this ) /* 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 ); - REMOVE_ELEM( p_this->p_libvlc->pp_objects, - p_this->p_libvlc->i_objects, i_index ); + i_index = FindIndex( p_this, p_this->p_libvlc_global->pp_objects, + p_this->p_libvlc_global->i_objects ); + REMOVE_ELEM( p_this->p_libvlc_global->pp_objects, + p_this->p_libvlc_global->i_objects, i_index ); vlc_mutex_unlock( &structure_lock ); } @@ -348,9 +427,23 @@ void __vlc_object_destroy( vlc_object_t *p_this ) vlc_mutex_destroy( &p_this->object_lock ); vlc_cond_destroy( &p_this->object_wait ); - free( p_this ); + /* global is not dynamically allocated by vlc_object_create */ + if( p_this->i_object_type != VLC_OBJECT_GLOBAL ) + { + free( p_this ); + p_this = NULL; + } } + +void __vlc_object_die( vlc_object_t *p_this ) +{ + vlc_mutex_lock( &p_this->object_lock ); + p_this->b_die = VLC_TRUE; + vlc_mutex_unlock( &p_this->object_lock ); +} + + /** * find an object given its ID * @@ -364,10 +457,10 @@ void * __vlc_object_get( vlc_object_t *p_this, int i_id ) vlc_mutex_lock( &structure_lock ); - pp_objects = p_this->p_libvlc->pp_objects; + pp_objects = p_this->p_libvlc_global->pp_objects; /* Perform our dichotomy */ - for( i_max = p_this->p_libvlc->i_objects - 1 ; ; ) + for( i_max = p_this->p_libvlc_global->i_objects - 1 ; ; ) { i_middle = i_max / 2; @@ -441,15 +534,15 @@ void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode ) /* Find the root */ while( p_root->p_parent != NULL && - p_root != VLC_OBJECT( p_this->p_vlc ) ) + 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_vlc ) ) + if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) ) { - p_found = FindObject( VLC_OBJECT( p_this->p_vlc ), + p_found = FindObject( VLC_OBJECT( p_this->p_libvlc ), i_type, (i_mode & ~0x000f)|FIND_CHILD ); } } @@ -494,6 +587,8 @@ void __vlc_object_release( vlc_object_t *p_this ) *****************************************************************************/ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) { + if( !p_this ) return; + vlc_mutex_lock( &structure_lock ); /* Attach the parent to its child */ @@ -520,6 +615,8 @@ void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent ) *****************************************************************************/ void __vlc_object_detach( vlc_object_t *p_this ) { + if( !p_this ) return; + vlc_mutex_lock( &structure_lock ); if( !p_this->p_parent ) { @@ -536,6 +633,7 @@ void __vlc_object_detach( vlc_object_t *p_this ) DetachObject( p_this ); vlc_mutex_unlock( &structure_lock ); + p_this = NULL; } /** @@ -557,8 +655,8 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) switch( i_mode & 0x000f ) { case FIND_ANYWHERE: - pp_current = p_this->p_libvlc->pp_objects; - pp_end = pp_current + p_this->p_libvlc->i_objects; + pp_current = p_this->p_libvlc_global->pp_objects; + pp_end = pp_current + p_this->p_libvlc_global->i_objects; for( ; pp_current < pp_end ; pp_current++ ) { @@ -570,7 +668,7 @@ vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode ) } p_list = NewList( i_count ); - pp_current = p_this->p_libvlc->pp_objects; + pp_current = p_this->p_libvlc_global->pp_objects; for( ; pp_current < pp_end ; pp_current++ ) { @@ -620,10 +718,34 @@ 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 ) { - if( *psz_cmd == 't' ) + if( *psz_cmd == 'l' ) + { + vlc_mutex_lock( &structure_lock ); + + vlc_object_t **pp_current, **pp_end; + + pp_current = p_this->p_libvlc_global->pp_objects; + pp_end = pp_current + p_this->p_libvlc_global->i_objects; + + for( ; pp_current < pp_end ; pp_current++ ) + { + if( (*pp_current)->b_attached ) + { + PrintObject( *pp_current, "" ); + } + else + { + printf( " o %.8i %s (not attached)\n", + (*pp_current)->i_object_id, + (*pp_current)->psz_object_type ); + } + } + + vlc_mutex_unlock( &structure_lock ); + } + else { - char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; - vlc_object_t *p_object; + vlc_object_t *p_object = NULL; if( *newval.psz_string ) { @@ -634,47 +756,104 @@ static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd, return VLC_ENOOBJ; } } - else - { - p_object = p_this->p_vlc ? VLC_OBJECT(p_this->p_vlc) : p_this; - } vlc_mutex_lock( &structure_lock ); - psz_foo[0] = '|'; - DumpStructure( p_object, 0, psz_foo ); + if( *psz_cmd == 't' ) + { + char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1]; - vlc_mutex_unlock( &structure_lock ); + if( !p_object ) + p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this; - if( *newval.psz_string ) - { - vlc_object_release( p_this ); + psz_foo[0] = '|'; + DumpStructure( p_object, 0, psz_foo ); } - } - else if( *psz_cmd == 'l' ) - { - vlc_object_t **pp_current, **pp_end; + else if( *psz_cmd == 'v' ) + { + int i; - vlc_mutex_lock( &structure_lock ); + if( !p_object ) + p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this; - pp_current = p_this->p_libvlc->pp_objects; - pp_end = pp_current + p_this->p_libvlc->i_objects; + PrintObject( p_object, "" ); - for( ; pp_current < pp_end ; pp_current++ ) - { - if( (*pp_current)->b_attached ) + if( !p_object->i_vars ) + printf( " `-o No variables\n" ); + for( i = 0; i < p_object->i_vars; i++ ) { - PrintObject( *pp_current, "" ); - } - else - { - printf( " o %.8i %s (not attached)\n", - (*pp_current)->i_object_id, - (*pp_current)->psz_object_type ); + variable_t *p_var = p_object->p_vars + i; + + const char *psz_type = "unknown"; + switch( p_var->i_type & VLC_VAR_TYPE ) + { +#define MYCASE( type, nice ) \ + case VLC_VAR_ ## type: \ + psz_type = nice; \ + break; + MYCASE( VOID, "void" ); + MYCASE( BOOL, "bool" ); + MYCASE( INTEGER, "integer" ); + MYCASE( HOTKEY, "hotkey" ); + MYCASE( STRING, "string" ); + MYCASE( MODULE, "module" ); + MYCASE( FILE, "file" ); + MYCASE( DIRECTORY, "directory" ); + MYCASE( VARIABLE, "variable" ); + MYCASE( FLOAT, "float" ); + MYCASE( TIME, "time" ); + MYCASE( ADDRESS, "address" ); + MYCASE( MUTEX, "mutex" ); + MYCASE( LIST, "list" ); +#undef MYCASE + } + printf( " %c-o \"%s\" (%s", + i + 1 == 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_ISCOMMAND ) + printf( ", command" ); + if( p_var->i_entries ) + printf( ", %d callbacks", p_var->i_entries ); + switch( p_var->i_type & 0x00f0 ) + { + case VLC_VAR_VOID: + case VLC_VAR_MUTEX: + break; + case VLC_VAR_BOOL: + printf( ": %s", p_var->val.b_bool ? "true" : "false" ); + break; + case VLC_VAR_INTEGER: + printf( ": %d", p_var->val.i_int ); + break; + case VLC_VAR_STRING: + printf( ": \"%s\"", p_var->val.psz_string ); + break; + case VLC_VAR_FLOAT: + printf( ": %f", p_var->val.f_float ); + break; + case VLC_VAR_TIME: + printf( ": " I64Fi, p_var->val.i_time ); + break; + case VLC_VAR_ADDRESS: + printf( ": %p", p_var->val.p_address ); + break; + case VLC_VAR_LIST: + printf( ": TODO" ); + break; + } + printf( "\n" ); } } vlc_mutex_unlock( &structure_lock ); + + if( *newval.psz_string ) + { + vlc_object_release( p_object ); + } } return VLC_SUCCESS; @@ -690,14 +869,12 @@ void vlc_list_release( vlc_list_t *p_list ) { int i_index; + vlc_mutex_lock( &structure_lock ); for( i_index = 0; i_index < p_list->i_count; i_index++ ) { - vlc_mutex_lock( &structure_lock ); - p_list->p_values[i_index].p_object->i_refcount--; - - vlc_mutex_unlock( &structure_lock ); } + vlc_mutex_unlock( &structure_lock ); free( p_list->p_values ); free( p_list ); @@ -849,14 +1026,15 @@ static void SetAttachment( vlc_object_t *p_this, vlc_bool_t b_attached ) static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) { - char psz_children[20], psz_refcount[20], psz_thread[20], psz_name[50]; + 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 ) { - snprintf( psz_name, 50, " \"%s\"", p_this->psz_object_name ); - psz_name[48] = '\"'; - psz_name[49] = '\0'; + snprintf( psz_name, 49, " \"%s\"", p_this->psz_object_name ); + if( psz_name[48] ) + psz_name[48] = '\"'; } psz_children[0] = '\0'; @@ -868,29 +1046,26 @@ static void PrintObject( vlc_object_t *p_this, const char *psz_prefix ) strcpy( psz_children, ", 1 child" ); break; default: - snprintf( psz_children, 20, - ", %i children", p_this->i_children ); - psz_children[19] = '\0'; + snprintf( psz_children, 19, ", %i children", p_this->i_children ); break; } psz_refcount[0] = '\0'; if( p_this->i_refcount ) - { - snprintf( psz_refcount, 20, ", refcount %i", p_this->i_refcount ); - psz_refcount[19] = '\0'; - } + snprintf( psz_refcount, 19, ", refcount %i", p_this->i_refcount ); psz_thread[0] = '\0'; if( p_this->b_thread ) - { - snprintf( psz_thread, 20, " (thread %d)", (int)p_this->thread_id ); - psz_thread[19] = '\0'; - } + snprintf( psz_thread, 29, " (thread %d)", (int)p_this->thread_id ); - printf( " %so %.8i %s%s%s%s%s\n", psz_prefix, + psz_parent[0] = '\0'; + if( p_this->p_parent ) + snprintf( psz_parent, 19, ", parent %i", p_this->p_parent->i_object_id ); + + printf( " %so %.8i %s%s%s%s%s%s\n", psz_prefix, p_this->i_object_id, p_this->psz_object_type, - psz_name, psz_thread, psz_refcount, psz_children ); + psz_name, psz_thread, psz_refcount, psz_children, + psz_parent ); } static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo ) @@ -978,7 +1153,7 @@ static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object, return; } -static void ListAppend( vlc_list_t *p_list, vlc_object_t *p_object ) +/*static void ListAppend( vlc_list_t *p_list, vlc_object_t *p_object ) { if( p_list == NULL ) { @@ -999,7 +1174,7 @@ static void ListAppend( vlc_list_t *p_list, vlc_object_t *p_object ) p_list->i_count++; return; -} +}*/ static int CountChildren( vlc_object_t *p_this, int i_type ) {