static int CountChildren ( vlc_object_t *, int );
static void ListChildren ( vlc_list_t *, vlc_object_t *, int );
+static void vlc_object_destroy( vlc_object_t *p_this );
+
/*****************************************************************************
* Local structure lock
*****************************************************************************/
vlc_mutex_unlock( &structure_lock );
}
- p_priv->i_refcount = 0;
+ p_priv->i_refcount = 1;
p_new->p_parent = NULL;
p_new->pp_children = NULL;
p_new->i_children = 0;
/**
****************************************************************************
- * Destroy a vlc object
+ * Destroy a vlc object (Internal)
*
* This function destroys an object that has been previously allocated with
* vlc_object_create. The object's refcount must be zero and it must not be
* attached to other objects in any way.
*****************************************************************************/
-void __vlc_object_destroy( vlc_object_t *p_this )
+static void vlc_object_destroy( vlc_object_t *p_this )
{
vlc_object_internals_t *p_priv = vlc_internals( p_this );
- int i_delay = 0;
-
- /* FIXME: ugly hack - we cannot use the message queue after
- * msg_Destroy(). */
- vlc_object_t *logger = p_this;
- if( p_this->p_libvlc == p_this )
- logger = NULL;
+ /* Sanity checks */
if( p_this->i_children )
{
- msg_Err( logger, "cannot delete object (%i, %s) with children" ,
- p_this->i_object_id, p_this->psz_object_name );
- return;
- }
-
- if( p_this->p_parent )
- {
- msg_Err( logger, "cannot delete object (%i, %s) with a parent",
- p_this->i_object_id, p_this->psz_object_name );
- return;
- }
+ int i;
- while( p_priv->i_refcount > 0 )
- {
- i_delay++;
+ fprintf( stderr,
+ "ERROR: cannot delete object (%i, %s) with %d children\n",
+ p_this->i_object_id, p_this->psz_object_name,
+ p_this->i_children );
- /* Don't warn immediately ... 100ms seems OK */
- if( i_delay == 2 )
- {
- msg_Warn( logger,
- "refcount is %u, delaying before deletion (id=%d,type=%d)",
- p_priv->i_refcount, p_this->i_object_id,
- p_this->i_object_type );
- }
- else if( i_delay == 10 )
+ for( i = 0; i < p_this->i_children; i++ )
{
- msg_Err( logger,
- "refcount is %u, delaying again (id=%d,type=%d)",
- p_priv->i_refcount, p_this->i_object_id,
- p_this->i_object_type );
- }
- else if( i_delay == 20 )
- {
- msg_Err( logger,
- "waited too long, cancelling destruction (id=%d,type=%d)",
- p_this->i_object_id, p_this->i_object_type );
- return;
+ fprintf( stderr,
+ "ERROR: Remaining children object "
+ "(id:%i, type:%s, name:%s)\n",
+ p_this->pp_children[i]->i_object_id,
+ p_this->pp_children[i]->psz_object_type,
+ p_this->pp_children[i]->psz_object_name );
}
+ fflush(stderr);
+ abort();
+ }
- msleep( 100000 );
+ if( p_this->p_parent )
+ {
+ fprintf( stderr,
+ "ERROR: cannot delete object (id:%i, type:%s, name:%s) "
+ "with a parent (id:%i, type:%s, name:%s)\n",
+ p_this->i_object_id, p_this->psz_object_type,
+ p_this->psz_object_name, p_this->p_parent->i_object_id,
+ p_this->p_parent->psz_object_type,
+ p_this->p_parent->psz_object_name );
+ fflush(stderr);
+ abort();
}
/* Destroy the associated variables, starting from the end so that
if( p_this->i_object_type == VLC_OBJECT_GLOBAL )
{
libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this;
+
+ /* Test for leaks */
+ if( p_global->i_objects > 0 )
+ {
+ int i;
+ for( i = 0; i < p_global->i_objects; i++ )
+ {
+ /* We are leaking this object */
+ fprintf( stderr,
+ "ERROR: leaking object (id:%i, type:%s, name:%s)\n",
+ p_global->pp_objects[i]->i_object_id,
+ p_global->pp_objects[i]->psz_object_type,
+ p_global->pp_objects[i]->psz_object_name );
+ fflush(stderr);
+ }
+ /* Strongly abort, cause we want these to be fixed */
+ abort();
+ }
+
/* We are the global object ... no need to lock. */
free( p_global->pp_objects );
p_global->pp_objects = NULL;
- p_global->i_objects--;
vlc_mutex_destroy( &structure_lock );
}
- else
- {
- libvlc_global_data_t *p_libvlc_global = vlc_global();
- int i_index;
-
- vlc_mutex_lock( &structure_lock );
-
- /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
- * useless to try and recover anything if pp_objects gets smashed. */
- i_index = FindIndex( p_this, p_libvlc_global->pp_objects,
- p_libvlc_global->i_objects );
- REMOVE_ELEM( p_libvlc_global->pp_objects,
- p_libvlc_global->i_objects, i_index );
-
- vlc_mutex_unlock( &structure_lock );
- }
#if defined(WIN32) || defined(UNDER_CE)
/* if object has an associated thread, close it now */
vlc_mutex_unlock( &structure_lock );
}
-static inline void Release( vlc_object_t *obj )
-{
- assert( obj->p_internals->i_refcount > 0 );
- obj->p_internals->i_refcount--;
-}
-
/*****************************************************************************
* decrement an object refcount
+ * And destroy the object if its refcount reach zero.
*****************************************************************************/
void __vlc_object_release( vlc_object_t *p_this )
{
+ vlc_bool_t b_should_destroy;
+
vlc_mutex_lock( &structure_lock );
- Release( p_this );
+
+ assert( p_this->p_internals->i_refcount > 0 );
+ p_this->p_internals->i_refcount--;
+ b_should_destroy = (p_this->p_internals->i_refcount == 0);
+
+ if( b_should_destroy )
+ {
+ /* Make sure this object can't be obtained via vlc_find_object now that
+ * it is freed */
+ libvlc_global_data_t *p_libvlc_global = vlc_global();
+ int i_index;
+
+ /* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
+ * useless to try and recover anything if pp_objects gets smashed. */
+ i_index = FindIndex( p_this, p_libvlc_global->pp_objects,
+ p_libvlc_global->i_objects );
+ REMOVE_ELEM( p_libvlc_global->pp_objects,
+ p_libvlc_global->i_objects, i_index );
+ }
+
vlc_mutex_unlock( &structure_lock );
+
+ if( b_should_destroy )
+ vlc_object_destroy( p_this );
}
/**
{
int i_index;
- vlc_mutex_lock( &structure_lock );
for( i_index = 0; i_index < p_list->i_count; i_index++ )
{
- Release( p_list->p_values[i_index].p_object );
+ vlc_object_release( p_list->p_values[i_index].p_object );
}
- vlc_mutex_unlock( &structure_lock );
free( p_list->p_values );
free( p_list );