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