#include "vlc_httpd.h"
#include "vlc_vlm.h"
#include "input/vlm_internal.h"
-#include "vlc_vod.h"
#include "vlc_tls.h"
#include "vlc_xml.h"
#include "vlc_osd.h"
#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( vlm_t );
psz_type = "vlm dameon";
break;
- case VLC_OBJECT_VOD:
- i_size = sizeof( vod_t );
- psz_type = "vod server";
- break;
case VLC_OBJECT_XML:
i_size = sizeof( xml_t );
psz_type = "xml";
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 );
- /* 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;
+ /* Automatically detach the object from its parents */
+ if( p_this->p_parent ) vlc_object_detach( p_this );
+
+
+ /* 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 );
+
+ /* Sanity checks */
if( p_this->i_children )
{
-<<<<<<< .mine
- fprintf( stderr,
- "ERROR: cannot delete object (%i, %s) with children\n",
- p_this->i_object_id, p_this->psz_object_name );
- fflush(stderr);
- abort();
-=======
- msg_Err( logger, "cannot delete object (%i, %s) with children" ,
- p_this->i_object_id, p_this->psz_object_name );
- return;
->>>>>>> .r25344
- }
+ int i;
- if( p_this->p_parent )
- {
-<<<<<<< .mine
fprintf( stderr,
- "ERROR: cannot delete object (%i, %s) with a parent\n",
- p_this->i_object_id, p_this->psz_object_name );
- fflush(stderr);
- abort();
-=======
- msg_Err( logger, "cannot delete object (%i, %s) with a parent",
- p_this->i_object_id, p_this->psz_object_name );
- return;
->>>>>>> .r25344
- }
-
-<<<<<<< .mine
-=======
- while( p_priv->i_refcount > 0 )
- {
- i_delay++;
+ "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 )
- {
- 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 )
+ for( i = 0; i < p_this->i_children; i++ )
{
- 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 );
}
-
- msleep( 100000 );
+ fflush(stderr);
+ abort();
}
->>>>>>> .r25344
/* Destroy the associated variables, starting from the end so that
* no memmove calls have to be done. */
while( p_priv->i_vars )
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 )
{
libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this;
- /* Remove ourselves */
- int i_index = FindIndex( p_this, p_global->pp_objects,
- p_global->i_objects );
- REMOVE_ELEM( p_global->pp_objects,
- p_global->i_objects, i_index );
-
/* Test for leaks */
if( p_global->i_objects > 0 )
{
{
/* We are leaking this object */
fprintf( stderr,
- "ERROR: We are 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 );
+ "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 */
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 */
else
{
/* This happens when there are only two remaining objects */
- if( pp_objects[i_middle+1]->i_object_id == i_id )
+ if( pp_objects[i_middle+1]->i_object_id == i_id
+ && pp_objects[i_middle+1]->p_internals->i_refcount > 0 )
{
+ 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
+ else if( pp_objects[i_middle]->p_internals->i_refcount > 0 )
{
+ 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 );
/* If we are of the requested type ourselves, don't look further */
- if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type )
+ if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type
+ && p_this->p_internals->i_refcount > 0 )
{
- 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 ) )
+ && !strcmp( p_this->psz_object_name, psz_name )
+ && p_this->p_internals->i_refcount > 0 )
{
- 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.
p_this->p_internals->i_refcount--;
b_should_destroy = (p_this->p_internals->i_refcount == 0);
- vlc_mutex_unlock( &structure_lock );
-
if( b_should_destroy )
- vlc_object_destroy( p_this );
-}
+ {
+ /* 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;
-/* Version without the lock */
-static void vlc_object_release_locked( vlc_object_t *p_this )
-{
- vlc_bool_t b_should_destroy;
+ /* 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 );
+ }
- assert( p_this->p_internals->i_refcount > 0 );
- p_this->p_internals->i_refcount--;
- b_should_destroy = (p_this->p_internals->i_refcount == 0);
+ vlc_mutex_unlock( &structure_lock );
if( b_should_destroy )
vlc_object_destroy( p_this );
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" );
{
int i_index;
- vlc_mutex_lock( &structure_lock );
for( i_index = 0; i_index < p_list->i_count; i_index++ )
{
- vlc_object_release_locked( 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 );
p_tmp = p_this->p_parent;
if( p_tmp )
{
- if( p_tmp->i_object_type == i_type )
+ if( p_tmp->i_object_type == i_type
+ && p_tmp->p_internals->i_refcount > 0 )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else
for( i = p_this->i_children; i--; )
{
p_tmp = p_this->pp_children[i];
- if( p_tmp->i_object_type == i_type )
+ if( p_tmp->i_object_type == i_type
+ && p_tmp->p_internals->i_refcount > 0 )
{
- p_tmp->p_internals->i_refcount++;
+ vlc_object_yield_locked( p_tmp );
return p_tmp;
}
else if( p_tmp->i_children )
if( p_tmp )
{
if( p_tmp->psz_object_name
- && !strcmp( p_tmp->psz_object_name, psz_name ) )
+ && !strcmp( p_tmp->psz_object_name, psz_name )
+ && p_tmp->p_internals->i_refcount > 0 )
{
- 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->psz_object_name
- && !strcmp( p_tmp->psz_object_name, psz_name ) )
+ && !strcmp( p_tmp->psz_object_name, psz_name )
+ && p_tmp->p_internals->i_refcount > 0 )
{
- 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++;
projects / vlc / blobdiff