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