git.sesse.net Git - vlc/blob - src/misc/objects.c

   1 /*****************************************************************************
   2  * objects.c: vlc_object_t handling
   3  *****************************************************************************
   4  * Copyright (C) 2004-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /**
  25  * \file
  26  * This file contains the functions to handle the vlc_object_t type
  27  */
  28
  29
  30 /*****************************************************************************
  31  * Preamble
  32  *****************************************************************************/
  33 #include <vlc/vlc.h>
  34
  35 #include "../libvlc.h"
  36 #include <vlc_vout.h>
  37 #include <vlc_aout.h>
  38 #include "audio_output/aout_internal.h"
  39
  40 #include <vlc_access.h>
  41 #include <vlc_demux.h>
  42 #include <vlc_stream.h>
  43
  44 #include <vlc_sout.h>
  45 #include "stream_output/stream_output.h"
  46
  47 #include "vlc_playlist.h"
  48 #include "vlc_interface.h"
  49 #include "vlc_codec.h"
  50 #include "vlc_filter.h"
  51
  52 #include "vlc_httpd.h"
  53 #include "vlc_vlm.h"
  54 #include "input/vlm_internal.h"
  55 #include "vlc_vod.h"
  56 #include "vlc_tls.h"
  57 #include "vlc_xml.h"
  58 #include "vlc_osd.h"
  59 #include "vlc_meta.h"
  60
  61 #include "variables.h"
  62
  63 /*****************************************************************************
  64  * Local prototypes
  65  *****************************************************************************/
  66 static int  DumpCommand( vlc_object_t *, char const *,
  67                          vlc_value_t, vlc_value_t, void * );
  68
  69 static vlc_object_t * FindObject    ( vlc_object_t *, int, int );
  70 static vlc_object_t * FindObjectName( vlc_object_t *, const char *, int );
  71 static void           DetachObject  ( vlc_object_t * );
  72 static void           PrintObject   ( vlc_object_t *, const char * );
  73 static void           DumpStructure ( vlc_object_t *, int, char * );
  74 static int            FindIndex     ( vlc_object_t *, vlc_object_t **, int );
  75 static void           SetAttachment ( vlc_object_t *, vlc_bool_t );
  76
  77 static vlc_list_t   * NewList       ( int );
  78 static void           ListReplace   ( vlc_list_t *, vlc_object_t *, int );
  79 /*static void           ListAppend    ( vlc_list_t *, vlc_object_t * );*/
  80 static int            CountChildren ( vlc_object_t *, int );
  81 static void           ListChildren  ( vlc_list_t *, vlc_object_t *, int );
  82
  83 /*****************************************************************************
  84  * Local structure lock
  85  *****************************************************************************/
  86 static vlc_mutex_t    structure_lock;
  87 static vlc_object_internals_t global_internals;
  88
  89 vlc_object_t *vlc_custom_create( vlc_object_t *p_this, size_t i_size,
  90                                  int i_type, const char *psz_type )
  91 {
  92     vlc_object_t *p_new;
  93     vlc_object_internals_t *p_priv;
  94
  95     if( i_type == VLC_OBJECT_GLOBAL )
  96     {
  97         p_new = p_this;
  98         p_priv = &global_internals;
  99         memset( p_priv, 0, sizeof( *p_priv ) );
 100     }
 101     else
 102     {
 103         p_priv = calloc( 1, sizeof( *p_priv ) + i_size );
 104         if( p_priv == NULL )
 105             return NULL;
 106
 107         p_new = (vlc_object_t *)(p_priv + 1);
 108     }
 109
 110     p_new->p_internals = p_priv;
 111     p_new->i_object_type = i_type;
 112     p_new->psz_object_type = psz_type;
 113
 114     p_new->psz_object_name = NULL;
 115
 116     p_new->b_die = VLC_FALSE;
 117     p_new->b_error = VLC_FALSE;
 118     p_new->b_dead = VLC_FALSE;
 119     p_priv->b_attached = VLC_FALSE;
 120     p_new->b_force = VLC_FALSE;
 121
 122     p_new->psz_header = NULL;
 123
 124     if( p_this->i_flags & OBJECT_FLAGS_NODBG )
 125         p_new->i_flags |= OBJECT_FLAGS_NODBG;
 126     if( p_this->i_flags & OBJECT_FLAGS_QUIET )
 127         p_new->i_flags |= OBJECT_FLAGS_QUIET;
 128     if( p_this->i_flags & OBJECT_FLAGS_NOINTERACT )
 129         p_new->i_flags |= OBJECT_FLAGS_NOINTERACT;
 130
 131     p_priv->p_vars = calloc( sizeof( variable_t ), 16 );
 132
 133     if( !p_priv->p_vars )
 134     {
 135         if( i_type != VLC_OBJECT_GLOBAL )
 136             free( p_priv );
 137         return NULL;
 138     }
 139
 140     if( i_type == VLC_OBJECT_GLOBAL )
 141     {
 142         /* If i_type is global, then p_new is actually p_libvlc_global */
 143         libvlc_global_data_t *p_libvlc_global = (libvlc_global_data_t *)p_new;
 144         p_new->p_libvlc = NULL;
 145
 146         p_libvlc_global->i_counter = 0;
 147         p_new->i_object_id = 0;
 148
 149         p_libvlc_global->i_objects = 1;
 150         p_libvlc_global->pp_objects = malloc( sizeof(vlc_object_t *) );
 151         p_libvlc_global->pp_objects[0] = p_new;
 152         p_priv->b_attached = VLC_TRUE;
 153     }
 154     else
 155     {
 156         libvlc_global_data_t *p_libvlc_global = vlc_global();
 157         if( i_type == VLC_OBJECT_LIBVLC )
 158         {
 159             p_new->p_libvlc = (libvlc_int_t*)p_new;
 160             p_priv->b_attached = VLC_TRUE;
 161         }
 162         else
 163         {
 164             p_new->p_libvlc = p_this->p_libvlc;
 165         }
 166
 167         vlc_mutex_lock( &structure_lock );
 168
 169         p_libvlc_global->i_counter++;
 170         p_new->i_object_id = p_libvlc_global->i_counter;
 171
 172         /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
 173          * useless to try and recover anything if pp_objects gets smashed. */
 174         TAB_APPEND( p_libvlc_global->i_objects, p_libvlc_global->pp_objects,
 175                     p_new );
 176
 177         vlc_mutex_unlock( &structure_lock );
 178     }
 179
 180     p_new->i_refcount = 0;
 181     p_new->p_parent = NULL;
 182     p_new->pp_children = NULL;
 183     p_new->i_children = 0;
 184
 185     p_new->p_private = NULL;
 186
 187     /* Initialize mutexes and condvars */
 188     vlc_mutex_init( p_new, &p_new->object_lock );
 189     vlc_cond_init( p_new, &p_new->object_wait );
 190     vlc_mutex_init( p_new, &p_priv->var_lock );
 191
 192     if( i_type == VLC_OBJECT_GLOBAL )
 193     {
 194         vlc_mutex_init( p_new, &structure_lock );
 195     }
 196
 197     if( i_type == VLC_OBJECT_LIBVLC )
 198     {
 199         var_Create( p_new, "list", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 200         var_AddCallback( p_new, "list", DumpCommand, NULL );
 201         var_Create( p_new, "tree", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 202         var_AddCallback( p_new, "tree", DumpCommand, NULL );
 203         var_Create( p_new, "vars", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 204         var_AddCallback( p_new, "vars", DumpCommand, NULL );
 205     }
 206
 207     return p_new;
 208 }
 209
 210
 211 /**
 212  * Allocates and initializes a vlc object.
 213  *
 214  * @param i_type known object type (all of them are negative integer values),
 215  *               or object byte size (always positive).
 216  *
 217  * @return the new object, or NULL on error.
 218  */
 219 void * __vlc_object_create( vlc_object_t *p_this, int i_type )
 220 {
 221     const char   * psz_type;
 222     size_t         i_size;
 223
 224     switch( i_type )
 225     {
 226         case VLC_OBJECT_GLOBAL:
 227             i_size = sizeof(libvlc_global_data_t);
 228             psz_type = "global";
 229             break;
 230         case VLC_OBJECT_LIBVLC:
 231             i_size = sizeof(libvlc_int_t);
 232             psz_type = "libvlc";
 233             break;
 234         case VLC_OBJECT_INTF:
 235             i_size = sizeof(intf_thread_t);
 236             psz_type = "interface";
 237             break;
 238         case VLC_OBJECT_DIALOGS:
 239             i_size = sizeof(intf_thread_t);
 240             psz_type = "dialogs";
 241             break;
 242         case VLC_OBJECT_PLAYLIST:
 243             i_size = sizeof(playlist_t);
 244             psz_type = "playlist";
 245             break;
 246         case VLC_OBJECT_SD:
 247             i_size = sizeof(services_discovery_t);
 248             psz_type = "services discovery";
 249             break;
 250         case VLC_OBJECT_INPUT:
 251             i_size = sizeof(input_thread_t);
 252             psz_type = "input";
 253             break;
 254         case VLC_OBJECT_DEMUX:
 255             i_size = sizeof(demux_t);
 256             psz_type = "demux";
 257             break;
 258         case VLC_OBJECT_ACCESS:
 259             i_size = sizeof(access_t);
 260             psz_type = "access";
 261             break;
 262         case VLC_OBJECT_DECODER:
 263             i_size = sizeof(decoder_t);
 264             psz_type = "decoder";
 265             break;
 266         case VLC_OBJECT_PACKETIZER:
 267             i_size = sizeof(decoder_t);
 268             psz_type = "packetizer";
 269             break;
 270         case VLC_OBJECT_ENCODER:
 271             i_size = sizeof(encoder_t);
 272             psz_type = "encoder";
 273             break;
 274         case VLC_OBJECT_FILTER:
 275             i_size = sizeof(filter_t);
 276             psz_type = "filter";
 277             break;
 278         case VLC_OBJECT_VOUT:
 279             i_size = sizeof(vout_thread_t);
 280             psz_type = "video output";
 281             break;
 282         case VLC_OBJECT_SPU:
 283             i_size = sizeof(spu_t);
 284             psz_type = "subpicture";
 285             break;
 286         case VLC_OBJECT_AOUT:
 287             i_size = sizeof(aout_instance_t);
 288             psz_type = "audio output";
 289             break;
 290         case VLC_OBJECT_SOUT:
 291             i_size = sizeof(sout_instance_t);
 292             psz_type = "stream output";
 293             break;
 294         case VLC_OBJECT_VLM:
 295             i_size = sizeof( vlm_t );
 296             psz_type = "vlm dameon";
 297             break;
 298         case VLC_OBJECT_VOD:
 299             i_size = sizeof( vod_t );
 300             psz_type = "vod server";
 301             break;
 302         case VLC_OBJECT_XML:
 303             i_size = sizeof( xml_t );
 304             psz_type = "xml";
 305             break;
 306         case VLC_OBJECT_OPENGL:
 307             i_size = sizeof( vout_thread_t );
 308             psz_type = "opengl";
 309             break;
 310         case VLC_OBJECT_ANNOUNCE:
 311             i_size = sizeof( announce_handler_t );
 312             psz_type = "announce";
 313             break;
 314         case VLC_OBJECT_META_ENGINE:
 315             i_size = sizeof( meta_engine_t );
 316             psz_type = "meta engine";
 317             break;
 318         case VLC_OBJECT_OSDMENU:
 319             i_size = sizeof( osd_menu_t );
 320             psz_type = "osd menu";
 321             break;
 322         default:
 323             i_size = i_type > (int)sizeof(vlc_object_t)
 324                          ? i_type : (int)sizeof(vlc_object_t);
 325             i_type = VLC_OBJECT_GENERIC;
 326             psz_type = "generic";
 327             break;
 328     }
 329
 330     return vlc_custom_create( p_this, i_size, i_type, psz_type );
 331 }
 332
 333
 334 /**
 335  ****************************************************************************
 336  * Destroy a vlc object
 337  *
 338  * This function destroys an object that has been previously allocated with
 339  * vlc_object_create. The object's refcount must be zero and it must not be
 340  * attached to other objects in any way.
 341  *****************************************************************************/
 342 void __vlc_object_destroy( vlc_object_t *p_this )
 343 {
 344     vlc_object_internals_t *p_priv = vlc_internals( p_this );
 345     int i_delay = 0;
 346
 347     if( p_this->i_children )
 348     {
 349         msg_Err( p_this, "cannot delete object (%i, %s) with children" ,
 350                  p_this->i_object_id, p_this->psz_object_name );
 351         return;
 352     }
 353
 354     if( p_this->p_parent )
 355     {
 356         msg_Err( p_this, "cannot delete object (%i, %s) with a parent",
 357                  p_this->i_object_id, p_this->psz_object_name );
 358         return;
 359     }
 360
 361     while( p_this->i_refcount )
 362     {
 363         i_delay++;
 364
 365         /* Don't warn immediately ... 100ms seems OK */
 366         if( i_delay == 2 )
 367         {
 368             msg_Warn( p_this,
 369                   "refcount is %i, delaying before deletion (id=%d,type=%d)",
 370                   p_this->i_refcount, p_this->i_object_id,
 371                   p_this->i_object_type );
 372         }
 373         else if( i_delay == 10 )
 374         {
 375             msg_Err( p_this,
 376                   "refcount is %i, delaying again (id=%d,type=%d)",
 377                   p_this->i_refcount, p_this->i_object_id,
 378                   p_this->i_object_type );
 379         }
 380         else if( i_delay == 20 )
 381         {
 382             msg_Err( p_this,
 383                   "waited too long, cancelling destruction (id=%d,type=%d)",
 384                   p_this->i_object_id, p_this->i_object_type );
 385             return;
 386         }
 387
 388         msleep( 100000 );
 389     }
 390
 391     /* Destroy the associated variables, starting from the end so that
 392      * no memmove calls have to be done. */
 393     while( p_priv->i_vars )
 394     {
 395         var_Destroy( p_this, p_priv->p_vars[p_priv->i_vars - 1].psz_name );
 396     }
 397
 398     free( p_priv->p_vars );
 399     vlc_mutex_destroy( &p_priv->var_lock );
 400
 401     if( p_this->psz_header ) free( p_this->psz_header );
 402
 403     if( p_this->i_object_type == VLC_OBJECT_GLOBAL )
 404     {
 405         libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this;
 406         /* We are the global object ... no need to lock. */
 407         free( p_global->pp_objects );
 408         p_global->pp_objects = NULL;
 409         p_global->i_objects--;
 410
 411         vlc_mutex_destroy( &structure_lock );
 412     }
 413     else
 414     {
 415         libvlc_global_data_t *p_libvlc_global = vlc_global();
 416         int i_index;
 417
 418         vlc_mutex_lock( &structure_lock );
 419
 420         /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
 421          * useless to try and recover anything if pp_objects gets smashed. */
 422         i_index = FindIndex( p_this, p_libvlc_global->pp_objects,
 423                              p_libvlc_global->i_objects );
 424         REMOVE_ELEM( p_libvlc_global->pp_objects,
 425                      p_libvlc_global->i_objects, i_index );
 426
 427         vlc_mutex_unlock( &structure_lock );
 428     }
 429
 430 #if defined(WIN32) || defined(UNDER_CE)
 431     /* if object has an associated thread, close it now */
 432     if( p_priv->thread_id.hThread )
 433        CloseHandle(p_priv->thread_id.hThread);
 434 #endif
 435
 436     vlc_mutex_destroy( &p_this->object_lock );
 437     vlc_cond_destroy( &p_this->object_wait );
 438
 439     /* global is not dynamically allocated by vlc_object_create */
 440     if( p_this->i_object_type != VLC_OBJECT_GLOBAL )
 441         free( p_priv );
 442 }
 443
 444
 445 /** Inter-object signaling */
 446
 447 void __vlc_object_lock( vlc_object_t *obj )
 448 {
 449     vlc_mutex_lock( &obj->object_lock );
 450 }
 451
 452 void __vlc_object_unlock( vlc_object_t *obj )
 453 {
 454     vlc_assert_locked( &obj->object_lock );
 455     vlc_mutex_unlock( &obj->object_lock );
 456 }
 457
 458 /**
 459  * Waits for the object to be signaled (using vlc_object_signal()).
 460  * If the object already has a signal pending, this function will return
 461  * immediately. It is asserted that the caller holds the object lock.
 462  *
 463  * @return true if the object is dying and should terminate.
 464  */
 465 vlc_bool_t __vlc_object_wait( vlc_object_t *obj )
 466 {
 467     vlc_assert_locked( &obj->object_lock );
 468     vlc_cond_wait( &obj->object_wait, &obj->object_lock );
 469     return obj->b_die;
 470 }
 471
 472
 473 /**
 474  * Waits for the object to be signaled (using vlc_object_signal()), or for
 475  * a timer to expire.
 476  * If the object already has a signal pending, this function will return
 477  * immediately. It is asserted that the caller holds the object lock.
 478  *
 479  * @return negative if the object is dying and should terminate,
 480  * positive if the the object has been signaled but is not dying,
 481  * 0 if timeout has been reached.
 482  */
 483 int __vlc_object_timedwait( vlc_object_t *obj, mtime_t deadline )
 484 {
 485     int v;
 486
 487     vlc_assert_locked( &obj->object_lock );
 488     v = vlc_cond_timedwait( &obj->object_wait, &obj->object_lock, deadline );
 489     if( v == 0 ) /* signaled */
 490         return obj->b_die ? -1 : 1;
 491     return 0;
 492 }
 493
 494
 495 /**
 496  * Signals an object for which the lock is held.
 497  */
 498 void __vlc_object_signal_unlocked( vlc_object_t *obj )
 499 {
 500     vlc_assert_locked( &obj->object_lock );
 501     vlc_cond_signal( &obj->object_wait );
 502 }
 503
 504
 505 /**
 506  * Requests termination of an object.
 507  * If the object is LibVLC, also request to terminate all its children.
 508  */
 509 void __vlc_object_kill( vlc_object_t *p_this )
 510 {
 511     vlc_mutex_lock( &p_this->object_lock );
 512
 513     if( p_this->i_object_type == VLC_OBJECT_LIBVLC )
 514         for( int i = 0; i < p_this->i_children ; i++ )
 515             vlc_object_kill( p_this->pp_children[i] );
 516
 517     p_this->b_die = VLC_TRUE;
 518     vlc_object_signal_unlocked( p_this );
 519     vlc_mutex_unlock( &p_this->object_lock );
 520 }
 521
 522
 523 /**
 524  * find an object given its ID
 525  *
 526  * This function looks for the object whose i_object_id field is i_id. We
 527  * use a dichotomy so that lookups are in log2(n).
 528  *****************************************************************************/
 529 void * __vlc_object_get( vlc_object_t *p_this, int i_id )
 530 {
 531     int i_max, i_middle;
 532     vlc_object_t **pp_objects;
 533     libvlc_global_data_t *p_libvlc_global = vlc_global();
 534
 535     vlc_mutex_lock( &structure_lock );
 536
 537     pp_objects = p_libvlc_global->pp_objects;
 538
 539     /* Perform our dichotomy */
 540     for( i_max = p_libvlc_global->i_objects - 1 ; ; )
 541     {
 542         i_middle = i_max / 2;
 543
 544         if( pp_objects[i_middle]->i_object_id > i_id )
 545         {
 546             i_max = i_middle;
 547         }
 548         else if( pp_objects[i_middle]->i_object_id < i_id )
 549         {
 550             if( i_middle )
 551             {
 552                 pp_objects += i_middle;
 553                 i_max -= i_middle;
 554             }
 555             else
 556             {
 557                 /* This happens when there are only two remaining objects */
 558                 if( pp_objects[i_middle+1]->i_object_id == i_id )
 559                 {
 560                     vlc_mutex_unlock( &structure_lock );
 561                     pp_objects[i_middle+1]->i_refcount++;
 562                     return pp_objects[i_middle+1];
 563                 }
 564                 break;
 565             }
 566         }
 567         else
 568         {
 569             vlc_mutex_unlock( &structure_lock );
 570             pp_objects[i_middle]->i_refcount++;
 571             return pp_objects[i_middle];
 572         }
 573
 574         if( i_max == 0 )
 575         {
 576             /* this means that i_max == i_middle, and since we have already
 577              * tested pp_objects[i_middle]), p_found is properly set. */
 578             break;
 579         }
 580     }
 581
 582     vlc_mutex_unlock( &structure_lock );
 583     return NULL;
 584 }
 585
 586 /**
 587  ****************************************************************************
 588  * find a typed object and increment its refcount
 589  *****************************************************************************
 590  * This function recursively looks for a given object type. i_mode can be one
 591  * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE.
 592  *****************************************************************************/
 593 void * __vlc_object_find( vlc_object_t *p_this, int i_type, int i_mode )
 594 {
 595     vlc_object_t *p_found;
 596
 597     vlc_mutex_lock( &structure_lock );
 598
 599     /* If we are of the requested type ourselves, don't look further */
 600     if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type )
 601     {
 602         p_this->i_refcount++;
 603         vlc_mutex_unlock( &structure_lock );
 604         return p_this;
 605     }
 606
 607     /* Otherwise, recursively look for the object */
 608     if( (i_mode & 0x000f) == FIND_ANYWHERE )
 609     {
 610         vlc_object_t *p_root = p_this;
 611
 612         /* Find the root */
 613         while( p_root->p_parent != NULL &&
 614                p_root != VLC_OBJECT( p_this->p_libvlc ) )
 615         {
 616             p_root = p_root->p_parent;
 617         }
 618
 619         p_found = FindObject( p_root, i_type, (i_mode & ~0x000f)|FIND_CHILD );
 620         if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) )
 621         {
 622             p_found = FindObject( VLC_OBJECT( p_this->p_libvlc ),
 623                                   i_type, (i_mode & ~0x000f)|FIND_CHILD );
 624         }
 625     }
 626     else
 627     {
 628         p_found = FindObject( p_this, i_type, i_mode );
 629     }
 630
 631     vlc_mutex_unlock( &structure_lock );
 632
 633     return p_found;
 634 }
 635
 636 /**
 637  ****************************************************************************
 638  * find a named object and increment its refcount
 639  *****************************************************************************
 640  * This function recursively looks for a given object name. i_mode can be one
 641  * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE.
 642  *****************************************************************************/
 643 void * __vlc_object_find_name( vlc_object_t *p_this, const char *psz_name,
 644                                int i_mode )
 645 {
 646     vlc_object_t *p_found;
 647
 648     vlc_mutex_lock( &structure_lock );
 649
 650     /* If have the requested name ourselves, don't look further */
 651     if( !(i_mode & FIND_STRICT)
 652         && p_this->psz_object_name
 653         && !strcmp( p_this->psz_object_name, psz_name ) )
 654     {
 655         p_this->i_refcount++;
 656         vlc_mutex_unlock( &structure_lock );
 657         return p_this;
 658     }
 659
 660     /* Otherwise, recursively look for the object */
 661     if( (i_mode & 0x000f) == FIND_ANYWHERE )
 662     {
 663         vlc_object_t *p_root = p_this;
 664
 665         /* Find the root */
 666         while( p_root->p_parent != NULL &&
 667                p_root != VLC_OBJECT( p_this->p_libvlc ) )
 668         {
 669             p_root = p_root->p_parent;
 670         }
 671
 672         p_found = FindObjectName( p_root, psz_name,
 673                                  (i_mode & ~0x000f)|FIND_CHILD );
 674         if( p_found == NULL && p_root != VLC_OBJECT( p_this->p_libvlc ) )
 675         {
 676             p_found = FindObjectName( VLC_OBJECT( p_this->p_libvlc ),
 677                                       psz_name, (i_mode & ~0x000f)|FIND_CHILD );
 678         }
 679     }
 680     else
 681     {
 682         p_found = FindObjectName( p_this, psz_name, i_mode );
 683     }
 684
 685     vlc_mutex_unlock( &structure_lock );
 686
 687     return p_found;
 688 }
 689
 690 /**
 691  ****************************************************************************
 692  * increment an object refcount
 693  *****************************************************************************/
 694 void __vlc_object_yield( vlc_object_t *p_this )
 695 {
 696     vlc_mutex_lock( &structure_lock );
 697     p_this->i_refcount++;
 698     vlc_mutex_unlock( &structure_lock );
 699 }
 700
 701 /**
 702  ****************************************************************************
 703  * decrement an object refcount
 704  *****************************************************************************/
 705 void __vlc_object_release( vlc_object_t *p_this )
 706 {
 707     vlc_mutex_lock( &structure_lock );
 708     p_this->i_refcount--;
 709     vlc_mutex_unlock( &structure_lock );
 710 }
 711
 712 /**
 713  ****************************************************************************
 714  * attach object to a parent object
 715  *****************************************************************************
 716  * This function sets p_this as a child of p_parent, and p_parent as a parent
 717  * of p_this. This link can be undone using vlc_object_detach.
 718  *****************************************************************************/
 719 void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent )
 720 {
 721     if( !p_this ) return;
 722
 723     vlc_mutex_lock( &structure_lock );
 724
 725     /* Attach the parent to its child */
 726     p_this->p_parent = p_parent;
 727
 728     /* Attach the child to its parent */
 729     INSERT_ELEM( p_parent->pp_children, p_parent->i_children,
 730                  p_parent->i_children, p_this );
 731
 732     /* Climb up the tree to see whether we are connected with the root */
 733     if( p_parent->p_internals->b_attached )
 734     {
 735         SetAttachment( p_this, VLC_TRUE );
 736     }
 737
 738     vlc_mutex_unlock( &structure_lock );
 739 }
 740
 741 /**
 742  ****************************************************************************
 743  * detach object from its parent
 744  *****************************************************************************
 745  * This function removes all links between an object and its parent.
 746  *****************************************************************************/
 747 void __vlc_object_detach( vlc_object_t *p_this )
 748 {
 749     if( !p_this ) return;
 750
 751     vlc_mutex_lock( &structure_lock );
 752     if( !p_this->p_parent )
 753     {
 754         msg_Err( p_this, "object is not attached" );
 755         vlc_mutex_unlock( &structure_lock );
 756         return;
 757     }
 758
 759     /* Climb up the tree to see whether we are connected with the root */
 760     if( p_this->p_parent->p_internals->b_attached )
 761     {
 762         SetAttachment( p_this, VLC_FALSE );
 763     }
 764
 765     DetachObject( p_this );
 766     vlc_mutex_unlock( &structure_lock );
 767     p_this = NULL;
 768 }
 769
 770 /**
 771  ****************************************************************************
 772  * find a list typed objects and increment their refcount
 773  *****************************************************************************
 774  * This function recursively looks for a given object type. i_mode can be one
 775  * of FIND_PARENT, FIND_CHILD or FIND_ANYWHERE.
 776  *****************************************************************************/
 777 vlc_list_t * __vlc_list_find( vlc_object_t *p_this, int i_type, int i_mode )
 778 {
 779     vlc_list_t *p_list;
 780     vlc_object_t **pp_current, **pp_end;
 781     int i_count = 0, i_index = 0;
 782     libvlc_global_data_t *p_libvlc_global = vlc_global();
 783
 784     vlc_mutex_lock( &structure_lock );
 785
 786     /* Look for the objects */
 787     switch( i_mode & 0x000f )
 788     {
 789     case FIND_ANYWHERE:
 790         pp_current = p_libvlc_global->pp_objects;
 791         pp_end = pp_current + p_libvlc_global->i_objects;
 792
 793         for( ; pp_current < pp_end ; pp_current++ )
 794         {
 795             if( (*pp_current)->p_internals->b_attached
 796                  && (*pp_current)->i_object_type == i_type )
 797             {
 798                 i_count++;
 799             }
 800         }
 801
 802         p_list = NewList( i_count );
 803         pp_current = p_libvlc_global->pp_objects;
 804
 805         for( ; pp_current < pp_end ; pp_current++ )
 806         {
 807             if( (*pp_current)->p_internals->b_attached
 808                  && (*pp_current)->i_object_type == i_type )
 809             {
 810                 ListReplace( p_list, *pp_current, i_index );
 811                 if( i_index < i_count ) i_index++;
 812             }
 813         }
 814     break;
 815
 816     case FIND_CHILD:
 817         i_count = CountChildren( p_this, i_type );
 818         p_list = NewList( i_count );
 819
 820         /* Check allocation was successful */
 821         if( p_list->i_count != i_count )
 822         {
 823             msg_Err( p_this, "list allocation failed!" );
 824             p_list->i_count = 0;
 825             break;
 826         }
 827
 828         p_list->i_count = 0;
 829         ListChildren( p_list, p_this, i_type );
 830         break;
 831
 832     default:
 833         msg_Err( p_this, "unimplemented!" );
 834         p_list = NewList( 0 );
 835         break;
 836     }
 837
 838     vlc_mutex_unlock( &structure_lock );
 839
 840     return p_list;
 841 }
 842
 843 /*****************************************************************************
 844  * DumpCommand: print the current vlc structure
 845  *****************************************************************************
 846  * This function prints either an ASCII tree showing the connections between
 847  * vlc objects, and additional information such as their refcount, thread ID,
 848  * etc. (command "tree"), or the same data as a simple list (command "list").
 849  *****************************************************************************/
 850 static int DumpCommand( vlc_object_t *p_this, char const *psz_cmd,
 851                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
 852 {
 853     libvlc_global_data_t *p_libvlc_global = vlc_global();
 854
 855     (void)oldval; (void)p_data;
 856     if( *psz_cmd == 'l' )
 857     {
 858         vlc_mutex_lock( &structure_lock );
 859
 860         vlc_object_t **pp_current, **pp_end;
 861
 862         pp_current = p_libvlc_global->pp_objects;
 863         pp_end = pp_current + p_libvlc_global->i_objects;
 864
 865         for( ; pp_current < pp_end ; pp_current++ )
 866         {
 867             if( (*pp_current)->p_internals->b_attached )
 868             {
 869                 PrintObject( *pp_current, "" );
 870             }
 871             else
 872             {
 873                 printf( " o %.8i %s (not attached)\n",
 874                         (*pp_current)->i_object_id,
 875                         (*pp_current)->psz_object_type );
 876             }
 877         }
 878
 879         vlc_mutex_unlock( &structure_lock );
 880     }
 881     else
 882     {
 883         vlc_object_t *p_object = NULL;
 884
 885         if( *newval.psz_string )
 886         {
 887             char *end;
 888             int i_id = strtol( newval.psz_string, &end, 0 );
 889             if( end != newval.psz_string )
 890                 p_object = vlc_object_get( p_this, i_id );
 891             else
 892             {
 893                 /* try using the object's name to find it */
 894                 vlc_object_t *p_libvlc = vlc_object_get( p_this, 1 );
 895                 if( p_libvlc )
 896                 {
 897                     /* Look in p_libvlc's children tree */
 898                     p_object = vlc_object_find_name( p_libvlc,
 899                                                      newval.psz_string,
 900                                                      FIND_CHILD );
 901                     vlc_object_release( p_libvlc );
 902                 }
 903                 if( !p_object )
 904                 {
 905                     /* If it's not in libvlc, look in libvlc_global (== p_this) */
 906                     p_object = vlc_object_find_name( p_this,
 907                                                      newval.psz_string,
 908                                                      FIND_CHILD );
 909                 }
 910             }
 911
 912             if( !p_object )
 913             {
 914                 return VLC_ENOOBJ;
 915             }
 916         }
 917
 918         vlc_mutex_lock( &structure_lock );
 919
 920         if( *psz_cmd == 't' )
 921         {
 922             char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1];
 923
 924             if( !p_object )
 925                 p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this;
 926
 927             psz_foo[0] = '|';
 928             DumpStructure( p_object, 0, psz_foo );
 929         }
 930         else if( *psz_cmd == 'v' )
 931         {
 932             int i;
 933
 934             if( !p_object )
 935                 p_object = p_this->p_libvlc ? VLC_OBJECT(p_this->p_libvlc) : p_this;
 936
 937             PrintObject( p_object, "" );
 938
 939             if( !p_object->p_internals->i_vars )
 940                 printf( " `-o No variables\n" );
 941             for( i = 0; i < p_object->p_internals->i_vars; i++ )
 942             {
 943                 variable_t *p_var = p_object->p_internals->p_vars + i;
 944
 945                 const char *psz_type = "unknown";
 946                 switch( p_var->i_type & VLC_VAR_TYPE )
 947                 {
 948 #define MYCASE( type, nice )                \
 949                     case VLC_VAR_ ## type:  \
 950                         psz_type = nice;    \
 951                         break;
 952                     MYCASE( VOID, "void" );
 953                     MYCASE( BOOL, "bool" );
 954                     MYCASE( INTEGER, "integer" );
 955                     MYCASE( HOTKEY, "hotkey" );
 956                     MYCASE( STRING, "string" );
 957                     MYCASE( MODULE, "module" );
 958                     MYCASE( FILE, "file" );
 959                     MYCASE( DIRECTORY, "directory" );
 960                     MYCASE( VARIABLE, "variable" );
 961                     MYCASE( FLOAT, "float" );
 962                     MYCASE( TIME, "time" );
 963                     MYCASE( ADDRESS, "address" );
 964                     MYCASE( MUTEX, "mutex" );
 965                     MYCASE( LIST, "list" );
 966 #undef MYCASE
 967                 }
 968                 printf( " %c-o \"%s\" (%s",
 969                         i + 1 == p_object->p_internals->i_vars ? '`' : '|',
 970                         p_var->psz_name, psz_type );
 971                 if( p_var->psz_text )
 972                     printf( ", %s", p_var->psz_text );
 973                 printf( ")" );
 974                 if( p_var->i_type & VLC_VAR_ISCOMMAND )
 975                     printf( ", command" );
 976                 if( p_var->i_entries )
 977                     printf( ", %d callbacks", p_var->i_entries );
 978                 switch( p_var->i_type & 0x00f0 )
 979                 {
 980                     case VLC_VAR_VOID:
 981                     case VLC_VAR_MUTEX:
 982                         break;
 983                     case VLC_VAR_BOOL:
 984                         printf( ": %s", p_var->val.b_bool ? "true" : "false" );
 985                         break;
 986                     case VLC_VAR_INTEGER:
 987                         printf( ": %d", p_var->val.i_int );
 988                         break;
 989                     case VLC_VAR_STRING:
 990                         printf( ": \"%s\"", p_var->val.psz_string );
 991                         break;
 992                     case VLC_VAR_FLOAT:
 993                         printf( ": %f", p_var->val.f_float );
 994                         break;
 995                     case VLC_VAR_TIME:
 996                         printf( ": " I64Fi, (int64_t)p_var->val.i_time );
 997                         break;
 998                     case VLC_VAR_ADDRESS:
 999                         printf( ": %p", p_var->val.p_address );
1000                         break;
1001                     case VLC_VAR_LIST:
1002                         printf( ": TODO" );
1003                         break;
1004                 }
1005                 printf( "\n" );
1006             }
1007         }
1008
1009         vlc_mutex_unlock( &structure_lock );
1010
1011         if( *newval.psz_string )
1012         {
1013             vlc_object_release( p_object );
1014         }
1015     }
1016
1017     return VLC_SUCCESS;
1018 }
1019
1020 /*****************************************************************************
1021  * vlc_list_release: free a list previously allocated by vlc_list_find
1022  *****************************************************************************
1023  * This function decreases the refcount of all objects in the list and
1024  * frees the list.
1025  *****************************************************************************/
1026 void vlc_list_release( vlc_list_t *p_list )
1027 {
1028     int i_index;
1029
1030     vlc_mutex_lock( &structure_lock );
1031     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1032     {
1033         p_list->p_values[i_index].p_object->i_refcount--;
1034     }
1035     vlc_mutex_unlock( &structure_lock );
1036
1037     free( p_list->p_values );
1038     free( p_list );
1039 }
1040
1041 /* Following functions are local */
1042
1043 /*****************************************************************************
1044  * FindIndex: find the index of an object in an array of objects
1045  *****************************************************************************
1046  * This function assumes that p_this can be found in pp_objects. It will not
1047  * crash if p_this cannot be found, but will return a wrong value. It is your
1048  * duty to check the return value if you are not certain that the object could
1049  * be found for sure.
1050  *****************************************************************************/
1051 static int FindIndex( vlc_object_t *p_this,
1052                       vlc_object_t **pp_objects, int i_count )
1053 {
1054     int i_middle = i_count / 2;
1055
1056     if( i_count == 0 )
1057     {
1058         return 0;
1059     }
1060
1061     if( pp_objects[i_middle] == p_this )
1062     {
1063         return i_middle;
1064     }
1065
1066     if( i_count == 1 )
1067     {
1068         return 0;
1069     }
1070
1071     /* We take advantage of the sorted array */
1072     if( pp_objects[i_middle]->i_object_id < p_this->i_object_id )
1073     {
1074         return i_middle + FindIndex( p_this, pp_objects + i_middle,
1075                                              i_count - i_middle );
1076     }
1077     else
1078     {
1079         return FindIndex( p_this, pp_objects, i_middle );
1080     }
1081 }
1082
1083 static vlc_object_t * FindObject( vlc_object_t *p_this, int i_type, int i_mode )
1084 {
1085     int i;
1086     vlc_object_t *p_tmp;
1087
1088     switch( i_mode & 0x000f )
1089     {
1090     case FIND_PARENT:
1091         p_tmp = p_this->p_parent;
1092         if( p_tmp )
1093         {
1094             if( p_tmp->i_object_type == i_type )
1095             {
1096                 p_tmp->i_refcount++;
1097                 return p_tmp;
1098             }
1099             else
1100             {
1101                 return FindObject( p_tmp, i_type, i_mode );
1102             }
1103         }
1104         break;
1105
1106     case FIND_CHILD:
1107         for( i = p_this->i_children; i--; )
1108         {
1109             p_tmp = p_this->pp_children[i];
1110             if( p_tmp->i_object_type == i_type )
1111             {
1112                 p_tmp->i_refcount++;
1113                 return p_tmp;
1114             }
1115             else if( p_tmp->i_children )
1116             {
1117                 p_tmp = FindObject( p_tmp, i_type, i_mode );
1118                 if( p_tmp )
1119                 {
1120                     return p_tmp;
1121                 }
1122             }
1123         }
1124         break;
1125
1126     case FIND_ANYWHERE:
1127         /* Handled in vlc_object_find */
1128         break;
1129     }
1130
1131     return NULL;
1132 }
1133
1134 static vlc_object_t * FindObjectName( vlc_object_t *p_this,
1135                                       const char *psz_name,
1136                                       int i_mode )
1137 {
1138     int i;
1139     vlc_object_t *p_tmp;
1140
1141     switch( i_mode & 0x000f )
1142     {
1143     case FIND_PARENT:
1144         p_tmp = p_this->p_parent;
1145         if( p_tmp )
1146         {
1147             if( p_tmp->psz_object_name
1148                 && !strcmp( p_tmp->psz_object_name, psz_name ) )
1149             {
1150                 p_tmp->i_refcount++;
1151                 return p_tmp;
1152             }
1153             else
1154             {
1155                 return FindObjectName( p_tmp, psz_name, i_mode );
1156             }
1157         }
1158         break;
1159
1160     case FIND_CHILD:
1161         for( i = p_this->i_children; i--; )
1162         {
1163             p_tmp = p_this->pp_children[i];
1164             if( p_tmp->psz_object_name
1165                 && !strcmp( p_tmp->psz_object_name, psz_name ) )
1166             {
1167                 p_tmp->i_refcount++;
1168                 return p_tmp;
1169             }
1170             else if( p_tmp->i_children )
1171             {
1172                 p_tmp = FindObjectName( p_tmp, psz_name, i_mode );
1173                 if( p_tmp )
1174                 {
1175                     return p_tmp;
1176                 }
1177             }
1178         }
1179         break;
1180
1181     case FIND_ANYWHERE:
1182         /* Handled in vlc_object_find */
1183         break;
1184     }
1185
1186     return NULL;
1187 }
1188
1189 static void DetachObject( vlc_object_t *p_this )
1190 {
1191     vlc_object_t *p_parent = p_this->p_parent;
1192     int i_index, i;
1193
1194     /* Remove p_this's parent */
1195     p_this->p_parent = NULL;
1196
1197     /* Remove all of p_parent's children which are p_this */
1198     for( i_index = p_parent->i_children ; i_index-- ; )
1199     {
1200         if( p_parent->pp_children[i_index] == p_this )
1201         {
1202             p_parent->i_children--;
1203             for( i = i_index ; i < p_parent->i_children ; i++ )
1204             {
1205                 p_parent->pp_children[i] = p_parent->pp_children[i+1];
1206             }
1207         }
1208     }
1209
1210     if( p_parent->i_children )
1211     {
1212         p_parent->pp_children = (vlc_object_t **)realloc( p_parent->pp_children,
1213                                p_parent->i_children * sizeof(vlc_object_t *) );
1214     }
1215     else
1216     {
1217         free( p_parent->pp_children );
1218         p_parent->pp_children = NULL;
1219     }
1220 }
1221
1222 /*****************************************************************************
1223  * SetAttachment: recursively set the b_attached flag of a subtree.
1224  *****************************************************************************
1225  * This function is used by the attach and detach functions to propagate
1226  * the b_attached flag in a subtree.
1227  *****************************************************************************/
1228 static void SetAttachment( vlc_object_t *p_this, vlc_bool_t b_attached )
1229 {
1230     int i_index;
1231
1232     for( i_index = p_this->i_children ; i_index-- ; )
1233     {
1234         SetAttachment( p_this->pp_children[i_index], b_attached );
1235     }
1236
1237     p_this->p_internals->b_attached = b_attached;
1238 }
1239
1240 static void PrintObject( vlc_object_t *p_this, const char *psz_prefix )
1241 {
1242     char psz_children[20], psz_refcount[20], psz_thread[30], psz_name[50],
1243          psz_parent[20];
1244
1245     psz_name[0] = '\0';
1246     if( p_this->psz_object_name )
1247     {
1248         snprintf( psz_name, 49, " \"%s\"", p_this->psz_object_name );
1249         if( psz_name[48] )
1250             psz_name[48] = '\"';
1251     }
1252
1253     psz_children[0] = '\0';
1254     switch( p_this->i_children )
1255     {
1256         case 0:
1257             break;
1258         case 1:
1259             strcpy( psz_children, ", 1 child" );
1260             break;
1261         default:
1262             snprintf( psz_children, 19, ", %i children", p_this->i_children );
1263             break;
1264     }
1265
1266     psz_refcount[0] = '\0';
1267     if( p_this->i_refcount )
1268         snprintf( psz_refcount, 19, ", refcount %i", p_this->i_refcount );
1269
1270     psz_thread[0] = '\0';
1271     if( p_this->p_internals->b_thread )
1272         snprintf( psz_thread, 29, " (thread %u)",
1273 #if defined(WIN32) || defined(UNDER_CE)
1274                   (unsigned)p_this->p_internals->thread_id.id );
1275 #else
1276                   (unsigned)p_this->p_internals->thread_id );
1277 #endif
1278
1279     psz_parent[0] = '\0';
1280     if( p_this->p_parent )
1281         snprintf( psz_parent, 19, ", parent %i", p_this->p_parent->i_object_id );
1282
1283     printf( " %so %.8i %s%s%s%s%s%s\n", psz_prefix,
1284             p_this->i_object_id, p_this->psz_object_type,
1285             psz_name, psz_thread, psz_refcount, psz_children,
1286             psz_parent );
1287 }
1288
1289 static void DumpStructure( vlc_object_t *p_this, int i_level, char *psz_foo )
1290 {
1291     int i;
1292     char i_back = psz_foo[i_level];
1293     psz_foo[i_level] = '\0';
1294
1295     PrintObject( p_this, psz_foo );
1296
1297     psz_foo[i_level] = i_back;
1298
1299     if( i_level / 2 >= MAX_DUMPSTRUCTURE_DEPTH )
1300     {
1301         msg_Warn( p_this, "structure tree is too deep" );
1302         return;
1303     }
1304
1305     for( i = 0 ; i < p_this->i_children ; i++ )
1306     {
1307         if( i_level )
1308         {
1309             psz_foo[i_level-1] = ' ';
1310
1311             if( psz_foo[i_level-2] == '`' )
1312             {
1313                 psz_foo[i_level-2] = ' ';
1314             }
1315         }
1316
1317         if( i == p_this->i_children - 1 )
1318         {
1319             psz_foo[i_level] = '`';
1320         }
1321         else
1322         {
1323             psz_foo[i_level] = '|';
1324         }
1325
1326         psz_foo[i_level+1] = '-';
1327         psz_foo[i_level+2] = '\0';
1328
1329         DumpStructure( p_this->pp_children[i], i_level + 2, psz_foo );
1330     }
1331 }
1332
1333 static vlc_list_t * NewList( int i_count )
1334 {
1335     vlc_list_t * p_list = (vlc_list_t *)malloc( sizeof( vlc_list_t ) );
1336     if( p_list == NULL )
1337     {
1338         return NULL;
1339     }
1340
1341     p_list->i_count = i_count;
1342
1343     if( i_count == 0 )
1344     {
1345         p_list->p_values = NULL;
1346         return p_list;
1347     }
1348
1349     p_list->p_values = malloc( i_count * sizeof( vlc_value_t ) );
1350     if( p_list->p_values == NULL )
1351     {
1352         p_list->i_count = 0;
1353         return p_list;
1354     }
1355
1356     return p_list;
1357 }
1358
1359 static void ListReplace( vlc_list_t *p_list, vlc_object_t *p_object,
1360                          int i_index )
1361 {
1362     if( p_list == NULL || i_index >= p_list->i_count )
1363     {
1364         return;
1365     }
1366
1367     p_object->i_refcount++;
1368
1369     p_list->p_values[i_index].p_object = p_object;
1370
1371     return;
1372 }
1373
1374 /*static void ListAppend( vlc_list_t *p_list, vlc_object_t *p_object )
1375 {
1376     if( p_list == NULL )
1377     {
1378         return;
1379     }
1380
1381     p_list->p_values = realloc( p_list->p_values, (p_list->i_count + 1)
1382                                 * sizeof( vlc_value_t ) );
1383     if( p_list->p_values == NULL )
1384     {
1385         p_list->i_count = 0;
1386         return;
1387     }
1388
1389     p_object->i_refcount++;
1390
1391     p_list->p_values[p_list->i_count].p_object = p_object;
1392     p_list->i_count++;
1393
1394     return;
1395 }*/
1396
1397 static int CountChildren( vlc_object_t *p_this, int i_type )
1398 {
1399     vlc_object_t *p_tmp;
1400     int i, i_count = 0;
1401
1402     for( i = 0; i < p_this->i_children; i++ )
1403     {
1404         p_tmp = p_this->pp_children[i];
1405
1406         if( p_tmp->i_object_type == i_type )
1407         {
1408             i_count++;
1409         }
1410
1411         if( p_tmp->i_children )
1412         {
1413             i_count += CountChildren( p_tmp, i_type );
1414         }
1415     }
1416
1417     return i_count;
1418 }
1419
1420 static void ListChildren( vlc_list_t *p_list, vlc_object_t *p_this, int i_type )
1421 {
1422     vlc_object_t *p_tmp;
1423     int i;
1424
1425     for( i = 0; i < p_this->i_children; i++ )
1426     {
1427         p_tmp = p_this->pp_children[i];
1428
1429         if( p_tmp->i_object_type == i_type )
1430         {
1431             ListReplace( p_list, p_tmp, p_list->i_count++ );
1432         }
1433
1434         if( p_tmp->i_children )
1435         {
1436             ListChildren( p_list, p_tmp, i_type );
1437         }
1438     }
1439 }