*****************************************************************************/
static vlc_mutex_t structure_lock;
-void *vlc_custom_create( vlc_object_t *p_this, size_t i_size,
- int i_type, const char *psz_type )
+void *__vlc_custom_create( vlc_object_t *p_this, size_t i_size,
+ int i_type, const char *psz_type )
{
vlc_object_t *p_new;
vlc_object_internals_t *p_priv;
p_new->p_private = NULL;
/* Initialize mutexes and condvars */
- vlc_mutex_init( &p_new->object_lock );
- vlc_cond_init( p_new, &p_new->object_wait );
+ vlc_mutex_init( &p_priv->lock );
+ vlc_cond_init( p_new, &p_priv->wait );
vlc_mutex_init( &p_priv->var_lock );
vlc_spin_init( &p_priv->spin );
p_priv->pipes[0] = p_priv->pipes[1] = -1;
switch( i_type )
{
- case VLC_OBJECT_LIBVLC:
- i_size = sizeof(libvlc_int_t);
- psz_type = "libvlc";
- break;
case VLC_OBJECT_INTF:
i_size = sizeof(intf_thread_t);
psz_type = "interface";
break;
- case VLC_OBJECT_DIALOGS:
- i_size = sizeof(intf_thread_t);
- psz_type = "dialogs";
- break;
case VLC_OBJECT_DECODER:
i_size = sizeof(decoder_t);
psz_type = "decoder";
i_size = sizeof(encoder_t);
psz_type = "encoder";
break;
- case VLC_OBJECT_FILTER:
- i_size = sizeof(filter_t);
- psz_type = "filter";
- break;
- case VLC_OBJECT_VOUT:
- i_size = sizeof(vout_thread_t);
- psz_type = "video output";
- break;
case VLC_OBJECT_AOUT:
i_size = sizeof(aout_instance_t);
psz_type = "audio output";
i_size = sizeof( announce_handler_t );
psz_type = "announce";
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);
+ assert( i_type > 0 ); /* unknown type?! */
+ i_size = i_type;
i_type = VLC_OBJECT_GENERIC;
psz_type = "generic";
break;
/* If we are running on a thread, wait until it ends */
if( p_priv->b_thread )
+ {
+ msg_Warn (p_this->p_libvlc, /* do NOT use a dead object for logging! */
+ "%s %d destroyed while thread alive (VLC might crash)",
+ p_this->psz_object_type, p_this->i_object_id);
vlc_thread_join( p_this );
+ }
/* Call the custom "subclass" destructor */
if( p_priv->pf_destructor )
if( p_this->p_libvlc == NULL )
{
+#ifndef NDEBUG
libvlc_global_data_t *p_global = (libvlc_global_data_t *)p_this;
-#ifndef NDEBUG
assert( p_global == vlc_global() );
/* Test for leaks */
if (p_priv->next != p_this)
#endif
vlc_spin_destroy( &p_priv->ref_spin );
- vlc_mutex_destroy( &p_this->object_lock );
- vlc_cond_destroy( &p_this->object_wait );
+ vlc_mutex_destroy( &p_priv->lock );
+ vlc_cond_destroy( &p_priv->wait );
vlc_spin_destroy( &p_priv->spin );
if( p_priv->pipes[1] != -1 )
close( p_priv->pipes[1] );
void __vlc_object_lock( vlc_object_t *obj )
{
- vlc_mutex_lock( &obj->object_lock );
+ vlc_mutex_lock( &(vlc_internals(obj)->lock) );
}
void __vlc_object_unlock( vlc_object_t *obj )
{
- vlc_assert_locked( &obj->object_lock );
- vlc_mutex_unlock( &obj->object_lock );
+ vlc_assert_locked( &(vlc_internals(obj)->lock) );
+ vlc_mutex_unlock( &(vlc_internals(obj)->lock) );
}
#ifdef WIN32
*/
void __vlc_object_wait( vlc_object_t *obj )
{
- vlc_assert_locked( &obj->object_lock );
- vlc_cond_wait( &obj->object_wait, &obj->object_lock );
+ vlc_object_internals_t *priv = vlc_internals( obj );
+ vlc_assert_locked( &priv->lock);
+ vlc_cond_wait( &priv->wait, &priv->lock );
}
*/
int __vlc_object_timedwait( vlc_object_t *obj, mtime_t deadline )
{
- vlc_assert_locked( &obj->object_lock );
- return vlc_cond_timedwait( &obj->object_wait, &obj->object_lock, deadline );
-}
-
-
-/**
- * Checks whether an object has been "killed".
- * The object lock must be held.
- *
- * Typical code for an object thread could be:
- *
- vlc_object_lock (self);
- ...initialization...
- while (vlc_object_alive (self))
- {
- ...preprocessing...
-
- vlc_object_wait (self);
-
- ...postprocessing...
- }
- ...deinitialization...
- vlc_object_unlock (self);
- *
- *
- * @return true iff the object has not been killed yet
- */
-bool __vlc_object_alive( vlc_object_t *obj )
-{
- vlc_assert_locked( &obj->object_lock );
- return !obj->b_die;
+ vlc_object_internals_t *priv = vlc_internals( obj );
+ vlc_assert_locked( &priv->lock);
+ return vlc_cond_timedwait( &priv->wait, &priv->lock, deadline );
}
*/
void __vlc_object_signal_unlocked( vlc_object_t *obj )
{
- vlc_assert_locked (&obj->object_lock);
- vlc_cond_signal( &obj->object_wait );
+ vlc_assert_locked (&(vlc_internals(obj)->lock));
+ vlc_cond_signal( &(vlc_internals(obj)->wait) );
}
*/
void __vlc_object_kill( vlc_object_t *p_this )
{
- vlc_object_internals_t *internals = vlc_internals( p_this );
+ vlc_object_internals_t *priv = vlc_internals( p_this );
int fd;
- vlc_mutex_lock( &p_this->object_lock );
+ vlc_object_lock( p_this );
p_this->b_die = true;
- vlc_spin_lock (&internals->spin);
- fd = internals->pipes[1];
- internals->pipes[1] = -1;
- vlc_spin_unlock (&internals->spin);
+ vlc_spin_lock (&priv->spin);
+ fd = priv->pipes[1];
+ priv->pipes[1] = -1;
+ vlc_spin_unlock (&priv->spin);
if( fd != -1 )
{
}
vlc_object_signal_unlocked( p_this );
- vlc_mutex_unlock( &p_this->object_lock );
-
- if (p_this->i_object_type == VLC_OBJECT_LIBVLC)
- {
- vlc_list_t *children = vlc_list_children (p_this);
- for (int i = 0; i < children->i_count; i++)
- vlc_object_kill (children->p_values[i].p_object);
- vlc_list_release (children);
- }
+ /* This also serves as a memory barrier toward vlc_object_alive(): */
+ vlc_object_unlock( p_this );
}