#endif
#include <assert.h>
+/*****************************************************************************
+ * Constants
+ *****************************************************************************/
+
+const vlc_destructor_t kVLCDestructor = NULL;
+
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static void ListChildren ( vlc_list_t *, vlc_object_t *, int );
static void vlc_object_destroy( vlc_object_t *p_this );
+static void vlc_object_yield_locked( vlc_object_t *p_this );
/*****************************************************************************
* Local structure lock
}
p_priv->i_refcount = 1;
+ p_priv->pf_destructor = kVLCDestructor;
+ p_priv->b_thread = VLC_FALSE;
p_new->p_parent = NULL;
p_new->pp_children = NULL;
p_new->i_children = 0;
i_size = sizeof( osd_menu_t );
psz_type = "osd menu";
break;
+ case VLC_OBJECT_INTERACTION:
+ i_size = sizeof( interaction_t );
+ psz_type = "interaction";
+ break;
default:
i_size = i_type > (int)sizeof(vlc_object_t)
? i_type : (int)sizeof(vlc_object_t);
}
+/**
+ ****************************************************************************
+ * Set the destructor of a vlc object
+ *
+ * This function sets the destructor of the vlc object. It will be called
+ * when the object is destroyed when the its refcount reaches 0.
+ * (It is called by the internal function vlc_object_destroy())
+ *****************************************************************************/
+void __vlc_object_set_destructor( vlc_object_t *p_this,
+ vlc_destructor_t pf_destructor )
+{
+ vlc_object_internals_t *p_priv = vlc_internals(p_this );
+
+ vlc_mutex_lock( &structure_lock );
+ p_priv->pf_destructor = pf_destructor;
+ vlc_mutex_unlock( &structure_lock );
+}
+
/**
****************************************************************************
* Destroy a vlc object (Internal)
{
vlc_object_internals_t *p_priv = vlc_internals( p_this );
+ /* Automatically detach the object from its parents */
+ if( p_this->p_parent ) vlc_object_detach( p_this );
+
/* Sanity checks */
if( p_this->i_children )
{
abort();
}
- 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();
- }
+
+ /* Send a kill to the object's thread if applicable */
+ vlc_object_kill( p_this );
+
+ /* If we are running on a thread, wait until it ends */
+ if( p_priv->b_thread )
+ vlc_thread_join( p_this );
+
+ /* Call the custom "subclass" destructor */
+ if( p_priv->pf_destructor )
+ p_priv->pf_destructor( p_this );
+
/* Destroy the associated variables, starting from the end so that
* no memmove calls have to be done. */
free( p_priv->p_vars );
vlc_mutex_destroy( &p_priv->var_lock );
- if( p_this->psz_header ) free( p_this->psz_header );
+ free( p_this->psz_header );
if( p_this->i_object_type == VLC_OBJECT_GLOBAL )
{
/* This happens when there are only two remaining objects */
if( pp_objects[i_middle+1]->i_object_id == i_id )
{
+ vlc_object_yield_locked( pp_objects[i_middle+1] );
vlc_mutex_unlock( &structure_lock );
- pp_objects[i_middle+1]->p_internals->i_refcount++;
return pp_objects[i_middle+1];
}
break;
}
else
{
+ vlc_object_yield_locked( pp_objects[i_middle] );
vlc_mutex_unlock( &structure_lock );
- pp_objects[i_middle]->p_internals->i_refcount++;
return pp_objects[i_middle];
}
vlc_mutex_lock( &structure_lock );
+ /* Avoid obvious freed object uses */
+ assert( p_this->p_internals->i_refcount > 0 );
+
/* If we are of the requested type ourselves, don't look further */
if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type )
{
- p_this->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_this );
vlc_mutex_unlock( &structure_lock );
return p_this;
}
vlc_mutex_lock( &structure_lock );
+ /* Avoid obvious freed object uses */
+ assert( p_this->p_internals->i_refcount > 0 );
+
/* If have the requested name ourselves, don't look further */
if( !(i_mode & FIND_STRICT)
&& p_this->psz_object_name
&& !strcmp( p_this->psz_object_name, psz_name ) )
{
- p_this->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_this );
vlc_mutex_unlock( &structure_lock );
return p_this;
}
****************************************************************************
* increment an object refcount
*****************************************************************************/
+
+/* When the structure_lock is locked */
+static void vlc_object_yield_locked( vlc_object_t *p_this )
+{
+ vlc_assert_locked (&structure_lock);
+
+ /* Avoid obvious freed object uses */
+ assert( p_this->p_internals->i_refcount > 0 );
+
+ /* Increment the counter */
+ p_this->p_internals->i_refcount++;
+}
+
+/* Public function */
void __vlc_object_yield( vlc_object_t *p_this )
{
vlc_mutex_lock( &structure_lock );
- p_this->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_this );
vlc_mutex_unlock( &structure_lock );
}
+
/*****************************************************************************
* decrement an object refcount
* And destroy the object if its refcount reach zero.
vlc_mutex_lock( &structure_lock );
+ /* Avoid obvious freed object uses */
+ assert( p_this->p_internals->i_refcount > 0 );
+
/* Attach the parent to its child */
p_this->p_parent = p_parent;
if( !p_this ) return;
vlc_mutex_lock( &structure_lock );
+
if( !p_this->p_parent )
{
msg_Err( p_this, "object is not attached" );
vlc_mutex_lock( &structure_lock );
+ /* Avoid obvious freed object uses */
+ assert( p_this->p_internals->i_refcount > 0 );
+
/* Look for the objects */
switch( i_mode & 0x000f )
{
{
if( p_tmp->i_object_type == i_type )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else
p_tmp = p_this->pp_children[i];
if( p_tmp->i_object_type == i_type )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else if( p_tmp->i_children )
if( p_tmp->psz_object_name
&& !strcmp( p_tmp->psz_object_name, psz_name ) )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else
if( p_tmp->psz_object_name
&& !strcmp( p_tmp->psz_object_name, psz_name ) )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else if( p_tmp->i_children )
return;
}
- p_object->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_object );
p_list->p_values[i_index].p_object = p_object;
return;
}
- p_object->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_object );
p_list->p_values[p_list->i_count].p_object = p_object;
p_list->i_count++;