* Meaning, that when created objects gets a refcount to 1.
* Destroying is instantaneous and we don't have to poll for a few secondss or so to wait until the object's refcount reach 0.
* We now track vlc_object_t's mem leaks when libvlc_global is released (Hard error for now, so they don't get unoticed)
* We fail hard if an object is released with a refcount of 1 without being detached from its parent and its children, to make sure such cases don't go unoticed.
(make test or make check still pass after that one. VLC is known to leak one object when no module is loaded, this must be fixed).
module_Need( location, "packetizer", NULL, 0 ); \
if( location->p_module == NULL ) \
{ \
- vlc_object_destroy( location ); \
+ vlc_object_release( location ); \
msg_Err( p_demux, "cannot find packetizer for " # msg ); \
free( p_sys ); \
return VLC_EGENERIC; \
#define DESTROY_PACKETIZER( location ) \
if( location->p_module ) module_Unneed( location, location->p_module ); \
- vlc_object_destroy( location );
+ vlc_object_release( location );
/**
* @}
* Prototypes
*****************************************************************************/
VLC_EXPORT( void *, __vlc_object_create, ( vlc_object_t *, int ) );
-VLC_EXPORT( void, __vlc_object_destroy, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_object_attach, ( vlc_object_t *, vlc_object_t * ) );
VLC_EXPORT( void, __vlc_object_detach, ( vlc_object_t * ) );
VLC_EXPORT( void *, vlc_object_get, ( int ) );
#define vlc_object_create(a,b) \
__vlc_object_create( VLC_OBJECT(a), b )
-#define vlc_object_destroy(a) do { \
- __vlc_object_destroy( VLC_OBJECT(a) ); \
- (a) = NULL; } while(0)
-
#define vlc_object_detach(a) \
__vlc_object_detach( VLC_OBJECT(a) )
p_sys->p_ev->pp_last = &p_sys->p_frame;
vlc_mutex_unlock( &p_sys->p_ev->lock );
}
- vlc_object_destroy( p_sys->p_ev );
+ vlc_object_release( p_sys->p_ev );
}
if( p_sys->p_frame )
/* stop the event handler */
vlc_object_kill( p_sys->p_ev );
vlc_thread_join( p_sys->p_ev );
- vlc_object_destroy( p_sys->p_ev );
+ vlc_object_release( p_sys->p_ev );
var_Destroy( p_sys->p_input, "highlight-mutex" );
var_Destroy( p_sys->p_input, "highlight" );
error:
if( p_sys->poll_thread != NULL )
- vlc_object_destroy( p_sys->poll_thread );
+ vlc_object_release( p_sys->poll_thread );
if( p_sys->client != NULL )
avahi_client_free( p_sys->client );
if( p_sys->simple_poll != NULL )
vlc_object_kill( p_sys->poll_thread );
vlc_thread_join( p_sys->poll_thread );
- vlc_object_destroy( p_sys->poll_thread );
+ vlc_object_release( p_sys->poll_thread );
if( p_sys->group != NULL )
avahi_entry_group_free( p_sys->group );
if( i_handle == -1 )
{
msg_Err( p_access, "failed to create raw UDP socket" );
- vlc_object_destroy (p_sys->p_thread);
+ vlc_object_release (p_sys->p_thread);
free (p_sys);
return VLC_EGENERIC;
}
{
msg_Err( p_access->p_sout, "cannot spawn sout access thread" );
net_Close (i_handle);
- vlc_object_destroy( p_sys->p_thread );
+ vlc_object_release( p_sys->p_thread );
free (p_sys);
return VLC_EGENERIC;
}
net_Close( p_sys->p_thread->i_handle );
vlc_object_detach( p_sys->p_thread );
- vlc_object_destroy( p_sys->p_thread );
+ vlc_object_release( p_sys->p_thread );
/* update p_sout->i_out_pace_nocontrol */
p_access->p_sout->i_out_pace_nocontrol--;
{
msg_Err( p_aout, "cannot create DirectSoundThread" );
CloseHandle( p_aout->output.p_sys->p_notif->event );
- vlc_object_destroy( p_aout->output.p_sys->p_notif );
+ vlc_object_release( p_aout->output.p_sys->p_notif );
p_aout->output.p_sys->p_notif = NULL;
goto error;
}
if( !p_sys->b_playing ) SetEvent( p_sys->p_notif->event );
vlc_thread_join( p_sys->p_notif );
- vlc_object_destroy( p_sys->p_notif );
+ vlc_object_release( p_sys->p_notif );
}
/* release the secondary buffer */
/* wake up the audio thread */
SetEvent( p_sys->event );
vlc_thread_join( p_sys->p_notif );
- vlc_object_destroy( p_sys->p_notif );
+ vlc_object_release( p_sys->p_notif );
CloseHandle( p_sys->event );
/* Close the device */
if( !p_sys->p_swscaler->p_module || !p_sys->p_swscaler->p_owner )
{
vlc_object_detach( p_sys->p_swscaler );
- vlc_object_destroy( p_sys->p_swscaler );
+ vlc_object_release( p_sys->p_swscaler );
free( p_vout->chroma.p_sys );
return VLC_EGENERIC;
}
free( p_sys->p_swscaler->p_owner );
module_Unneed( p_sys->p_swscaler, p_sys->p_swscaler->p_module );
vlc_object_detach( p_sys->p_swscaler );
- vlc_object_destroy( p_sys->p_swscaler );
+ vlc_object_release( p_sys->p_swscaler );
p_sys->p_swscaler= NULL;
}
free( p_vout->chroma.p_sys );
vlc_thread_join( pp_contexts[i] );
vlc_mutex_destroy( &pp_contexts[i]->lock );
vlc_cond_destroy( &pp_contexts[i]->cond );
- vlc_object_destroy( pp_contexts[i] );
+ vlc_object_release( pp_contexts[i] );
}
free( pp_contexts );
{
if( p_sys->p_packetizer->fmt_in.p_extra )
free( p_sys->p_packetizer->fmt_in.p_extra );
- vlc_object_destroy( p_sys->p_packetizer );
+ vlc_object_release( p_sys->p_packetizer );
msg_Err( p_demux, "cannot find flac packetizer" );
return VLC_EGENERIC;
free( p_sys->p_packetizer->fmt_in.p_extra );
/* Delete the decoder */
- vlc_object_destroy( p_sys->p_packetizer );
+ vlc_object_release( p_sys->p_packetizer );
if( p_sys->p_meta )
vlc_meta_Delete( p_sys->p_meta );
free( p_sys );
vlc_object_kill( p_sys->p_timeout );
vlc_thread_join( p_sys->p_timeout );
vlc_object_detach( p_sys->p_timeout );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
if( p_sys->scheduler ) delete p_sys->scheduler;
if( p_sys->p_sdp ) free( p_sys->p_sdp );
vlc_object_kill( p_sys->p_timeout );
vlc_thread_join( p_sys->p_timeout );
vlc_object_detach( p_sys->p_timeout );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
if( p_sys->scheduler ) delete p_sys->scheduler;
if( p_sys->p_sdp ) free( p_sys->p_sdp );
VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
{
msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
msg_Dbg( p_demux, "spawned timeout thread" );
vlc_object_attach( p_sys->p_timeout, p_demux );
{
vlc_object_kill( p_ev );
vlc_thread_join( p_ev );
- vlc_object_destroy( p_ev );
+ vlc_object_release( p_ev );
p_ev = NULL;
p_intf->p_sys->p_blend->p_module );
vlc_object_detach( p_intf->p_sys->p_blend );
- vlc_object_destroy( p_intf->p_sys->p_blend );
+ vlc_object_release( p_intf->p_sys->p_blend );
}
}
#endif
p_intf->p_sys->p_text->p_module );
vlc_object_detach( p_intf->p_sys->p_text );
- vlc_object_destroy( p_intf->p_sys->p_text );
+ vlc_object_release( p_intf->p_sys->p_text );
}
}
#if 0
p_intf->p_sys->p_scale->p_module );
vlc_object_detach( p_intf->p_sys->p_scale );
- vlc_object_destroy( p_intf->p_sys->p_scale );
+ vlc_object_release( p_intf->p_sys->p_scale );
}
}
#endif
vlc_object_detach( m_pProvider );
module_Unneed( m_pProvider, m_pModule );
- vlc_object_destroy( m_pProvider );
+ vlc_object_release( m_pProvider );
}
/* Unregister callbacks */
if( m_pModule == NULL )
{
msg_Err( getIntf(), "no suitable dialogs provider found (hint: compile the wxWidgets plugin, and make sure it is loaded properly)" );
- vlc_object_destroy( m_pProvider );
+ vlc_object_release( m_pProvider );
m_pProvider = NULL;
return false;
}
if( p_this->p_module )
module_Unneed( p_this, p_this->p_module );
vlc_mutex_destroy( &p_this->change_lock );
- vlc_object_destroy( p_this );
+ vlc_object_release( p_this );
}
/*****************************************************************************
}
else
{
- vlc_object_destroy( p_fontbuilder );
+ vlc_object_release( p_fontbuilder );
}
}
else
gnutls_deinit( p_sys->session );
vlc_object_detach( p_session );
- vlc_object_destroy( p_session );
+ vlc_object_release( p_session );
free( p_sys );
}
p_session->p_sys = malloc( sizeof(struct tls_session_sys_t) );
if( p_session->p_sys == NULL )
{
- vlc_object_destroy( p_session );
+ vlc_object_release( p_session );
return NULL;
}
error:
free( p_session->p_sys );
vlc_object_detach( p_session );
- vlc_object_destroy( p_session );
+ vlc_object_release( p_session );
return NULL;
}
if( vlc_thread_create( p_gtk_main, "gtk_main", GtkMain,
VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
{
- vlc_object_destroy( p_gtk_main );
+ vlc_object_release( p_gtk_main );
i_refcount--;
vlc_mutex_unlock( lock );
return VLC_ETHREAD;
gtk_main_quit();
vlc_thread_join( p_gtk_main );
- vlc_object_destroy( p_gtk_main );
+ vlc_object_release( p_gtk_main );
p_gtk_main = NULL;
vlc_mutex_unlock( lock );
if( vlc_thread_create( p_qte_main, "qte_main", QteMain,
VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
{
- vlc_object_destroy( p_qte_main );
+ vlc_object_release( p_qte_main );
i_refcount--;
vlc_mutex_unlock( lock );
return VLC_ETHREAD;
msg_Dbg( p_this, "Detaching qte_main" );
vlc_object_detach( p_qte_main );
- vlc_object_destroy( p_qte_main );
+ vlc_object_release( p_qte_main );
p_qte_main = NULL;
vlc_mutex_unlock( lock );
vlc_object_kill( pp_objects[i] );
vlc_thread_join( pp_objects[i] );
vlc_object_detach( pp_objects[i] );
- vlc_object_destroy( pp_objects[i] );
+ vlc_object_release( pp_objects[i] );
}
/* Clean our mess */
printf( " - destroying the objects (LIFO)\n" );
for( i = MAXOBJ * i_level; i--; )
{
- vlc_object_destroy( pp_objects[i] );
+ vlc_object_release( pp_objects[i] );
}
printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
{
pp_objects[i]->b_die = VLC_TRUE;
vlc_thread_join( pp_objects[i] );
- vlc_object_destroy( pp_objects[i] );
+ vlc_object_release( pp_objects[i] );
}
printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
for( i = MAXOBJ/MAXTH; i--; )
{
- vlc_object_destroy( pp_objects[i] );
+ vlc_object_release( pp_objects[i] );
}
return NULL;
{
msg_Err( p_stream, "cannot find decoder" );
vlc_object_detach( p_sys->p_decoder );
- vlc_object_destroy( p_sys->p_decoder );
+ vlc_object_release( p_sys->p_decoder );
return NULL;
}
"no video filter matching name \"%s\" found",
psz_name );
vlc_object_detach( *pp_vfilter );
- vlc_object_destroy( *pp_vfilter );
+ vlc_object_release( *pp_vfilter );
p_sys->i_vfilters--;
}
}
if( p_sys->p_decoder->p_module )
module_Unneed( p_sys->p_decoder, p_sys->p_decoder->p_module );
vlc_object_detach( p_sys->p_decoder );
- vlc_object_destroy( p_sys->p_decoder );
+ vlc_object_release( p_sys->p_decoder );
for( i = 0; i < PICTURE_RING_SIZE; i++ )
{
vlc_object_detach( *pp_vfilter );
if( (*pp_vfilter)->p_module )
module_Unneed( *pp_vfilter, (*pp_vfilter)->p_module );
- vlc_object_destroy( *pp_vfilter );
+ vlc_object_release( *pp_vfilter );
}
free( p_sys->pp_vfilters );
if( p_sys->b_export_sdp_file ) FileSetup( p_stream );
vlc_object_detach( id );
- vlc_object_destroy( id );
+ vlc_object_release( id );
return VLC_SUCCESS;
}
if( !p_sys->p_out )
{
msg_Err( p_stream, "cannot create chain" );
- vlc_object_destroy( p_sys );
+ vlc_object_release( p_sys );
return VLC_EGENERIC;
}
}
if( p_sys->psz_osdenc ) free( p_sys->psz_osdenc );
- vlc_object_destroy( p_sys );
+ vlc_object_release( p_sys );
}
struct sout_stream_id_t
if( id->p_decoder )
{
vlc_object_detach( id->p_decoder );
- vlc_object_destroy( id->p_decoder );
+ vlc_object_release( id->p_decoder );
id->p_decoder = NULL;
}
{
vlc_object_detach( id->p_encoder );
es_format_Clean( &id->p_encoder->fmt_out );
- vlc_object_destroy( id->p_encoder );
+ vlc_object_release( id->p_encoder );
id->p_encoder = NULL;
}
if( id->p_decoder )
{
vlc_object_detach( id->p_decoder );
- vlc_object_destroy( id->p_decoder );
+ vlc_object_release( id->p_decoder );
id->p_decoder = NULL;
}
{
vlc_object_detach( id->p_encoder );
es_format_Clean( &id->p_encoder->fmt_out );
- vlc_object_destroy( id->p_encoder );
+ vlc_object_release( id->p_encoder );
id->p_encoder = NULL;
}
free( id );
else
{
vlc_object_detach( p_filter );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
p_filter = 0;
}
vlc_object_detach( id->pp_filter[i] );
if( id->pp_filter[i]->p_module )
module_Unneed( id->pp_filter[i], id->pp_filter[i]->p_module );
- vlc_object_destroy( id->pp_filter[i] );
+ vlc_object_release( id->pp_filter[i] );
}
for( i = 0; i < id->i_ufilter; i++ )
{
vlc_object_detach( id->pp_ufilter[i] );
if( id->pp_ufilter[i]->p_module )
module_Unneed( id->pp_ufilter[i], id->pp_ufilter[i]->p_module );
- vlc_object_destroy( id->pp_ufilter[i] );
+ vlc_object_release( id->pp_ufilter[i] );
}
}
id->pp_filter[i]->p_owner->pp_pics[j] );
}
free( id->pp_filter[i]->p_owner );
- vlc_object_destroy( id->pp_filter[i] );
+ vlc_object_release( id->pp_filter[i] );
id->pp_filter[i] = NULL;
}
id->pp_ufilter[i]->p_owner->pp_pics[j] );
}
free( id->pp_ufilter[i]->p_owner );
- vlc_object_destroy( id->pp_ufilter[i] );
+ vlc_object_release( id->pp_ufilter[i] );
id->pp_ufilter[i] = NULL;
}
}
{
msg_Dbg( p_stream, "no video filter found" );
vlc_object_detach( id->pp_filter[id->i_filter] );
- vlc_object_destroy( id->pp_filter[id->i_filter] );
+ vlc_object_release( id->pp_filter[id->i_filter] );
}
}
{
msg_Dbg( p_stream, "no video filter found" );
vlc_object_detach( id->pp_filter[id->i_filter] );
- vlc_object_destroy( id->pp_filter[id->i_filter] );
+ vlc_object_release( id->pp_filter[id->i_filter] );
p_pic->pf_release( p_pic );
transcode_video_close( p_stream, id );
{
msg_Dbg( p_stream, "no video filter found" );
vlc_object_detach( id->pp_ufilter[id->i_ufilter] );
- vlc_object_destroy( id->pp_ufilter[id->i_ufilter] );
+ vlc_object_release( id->pp_ufilter[id->i_ufilter] );
id->pp_ufilter[id->i_ufilter] = NULL;
}
}
vlc_mutex_destroy( &m_TerminateLock );
vlc_cond_destroy( &m_TerminateCond );
vlc_object_detach(m_pAtmoThread);
- vlc_object_destroy(m_pAtmoThread);
+ vlc_object_release(m_pAtmoThread);
}
}
VLC_FALSE ) )
{
msg_Err( p_filter, "cannot create FadeToColorThread" );
- vlc_object_destroy( p_sys->p_fadethread );
+ vlc_object_release( p_sys->p_fadethread );
p_sys->p_fadethread = NULL;
vlc_mutex_unlock( &p_sys->filter_lock );
/* wait for the thread... */
vlc_thread_join(p_sys->p_fadethread);
- vlc_object_destroy(p_sys->p_fadethread);
+ vlc_object_release(p_sys->p_fadethread);
p_sys->p_fadethread = NULL;
}
vlc_thread_join(p_sys->p_fadethread);
- vlc_object_destroy(p_sys->p_fadethread);
+ vlc_object_release(p_sys->p_fadethread);
p_sys->p_fadethread = NULL;
}
vlc_mutex_unlock( &p_sys->filter_lock );
VLC_FALSE) )
{
msg_Err( p_filter, "cannot create FadeToColorThread" );
- vlc_object_destroy( p_sys->p_fadethread );
+ vlc_object_release( p_sys->p_fadethread );
p_sys->p_fadethread = NULL;
}
}
{
msg_Err( p_vout, "can't open blending filter, aborting" );
vlc_object_detach( p_sys->p_blend );
- vlc_object_destroy( p_sys->p_blend );
+ vlc_object_release( p_sys->p_blend );
return VLC_EGENERIC;
}
if( p_sys->p_blend->p_module )
module_Unneed( p_sys->p_blend, p_sys->p_blend->p_module );
vlc_object_detach( p_sys->p_blend );
- vlc_object_destroy( p_sys->p_blend );
+ vlc_object_release( p_sys->p_blend );
}
/*****************************************************************************
msg_Err( p_vout, "can't open internal opencv filter: %s", p_vout->p_sys->psz_inner_name );
p_vout->p_sys->psz_inner_name = NULL;
vlc_object_detach( p_sys->p_opencv );
- vlc_object_destroy( p_sys->p_opencv );
+ vlc_object_release( p_sys->p_opencv );
p_sys->p_opencv = NULL;
}
if( p_vout->p_sys->p_opencv->p_module )
module_Unneed( p_vout->p_sys->p_opencv, p_vout->p_sys->p_opencv->p_module );
vlc_object_detach( p_vout->p_sys->p_opencv );
- vlc_object_destroy( p_vout->p_sys->p_opencv );
+ vlc_object_release( p_vout->p_sys->p_opencv );
p_vout->p_sys->p_opencv = NULL;
}
E_(EventThread), 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
p_vout->p_sys->p_event = NULL;
goto error;
}
}
vlc_thread_join( p_vout->p_sys->p_event );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
}
vlc_mutex_destroy( &p_vout->p_sys->lock );
E_(EventThread), 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
p_vout->p_sys->p_event = NULL;
goto error;
}
}
vlc_thread_join( p_vout->p_sys->p_event );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
}
vlc_mutex_destroy( &p_vout->p_sys->lock );
E_(EventThread), 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
p_vout->p_sys->p_event = NULL;
goto error;
}
}
vlc_thread_join( p_vout->p_sys->p_event );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
}
vlc_mutex_destroy( &p_vout->p_sys->lock );
E_(EventThread), 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
p_vout->p_sys->p_event = NULL;
goto error;
}
}
vlc_thread_join( p_vout->p_sys->p_event );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
}
vlc_mutex_destroy( &p_vout->p_sys->lock );
{
msg_Warn( p_vout, "No OpenGL provider found" );
vlc_object_detach( p_sys->p_vout );
- vlc_object_destroy( p_sys->p_vout );
+ vlc_object_release( p_sys->p_vout );
return VLC_ENOOBJ;
}
module_Unneed( p_sys->p_vout, p_sys->p_vout->p_module );
vlc_object_detach( p_sys->p_vout );
- vlc_object_destroy( p_sys->p_vout );
+ vlc_object_release( p_sys->p_vout );
free( p_sys );
}
CloseDisplay(p_vout);
vlc_thread_join( p_vout->p_sys->p_event );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
}
#ifdef NEED_QTE_MAIN
VLC_THREAD_PRIORITY_OUTPUT, VLC_TRUE) )
{
msg_Err( p_vout, "cannot create QT Embedded Thread" );
- vlc_object_destroy( p_vout->p_sys->p_event );
+ vlc_object_release( p_vout->p_sys->p_event );
p_vout->p_sys->p_event = NULL;
return -1;
}
msg_Err( p_filter, "cannot lauch galaktos thread" );
if( p_thread->psz_title ) free( p_thread->psz_title );
vlc_object_detach( p_thread );
- vlc_object_destroy( p_thread );
+ vlc_object_release( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
{
msg_Err( p_thread, "unable to initialize OpenGL" );
vlc_object_detach( p_thread->p_opengl );
- vlc_object_destroy( p_thread->p_opengl );
+ vlc_object_release( p_thread->p_opengl );
return;
}
/* Free the openGL provider */
module_Unneed( p_thread->p_opengl, p_thread->p_module );
vlc_object_detach( p_thread->p_opengl );
- vlc_object_destroy( p_thread->p_opengl );
+ vlc_object_release( p_thread->p_opengl );
}
/*****************************************************************************
/* Free data */
vlc_object_detach( p_sys->p_thread );
- vlc_object_destroy( p_sys->p_thread );
+ vlc_object_release( p_sys->p_thread );
free( p_sys );
}
{
msg_Err( p_filter, "no suitable vout module" );
vlc_object_detach( p_thread );
- vlc_object_destroy( p_thread );
+ vlc_object_release( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
vlc_cond_destroy( &p_thread->wait );
if( p_thread->psz_title ) free( p_thread->psz_title );
vlc_object_detach( p_thread );
- vlc_object_destroy( p_thread );
+ vlc_object_release( p_thread );
free( p_sys );
return VLC_EGENERIC;
}
block_Release( p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks] );
}
- vlc_object_destroy( p_sys->p_thread );
+ vlc_object_release( p_sys->p_thread );
free( p_sys );
}
vlc_mutex_destroy( &p_aout->output_fifo_lock );
/* Free structure. */
- vlc_object_destroy( p_aout );
+ vlc_object_release( p_aout );
}
if ( p_filter->p_module == NULL )
{
vlc_object_detach( p_filter );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
return NULL;
}
{
module_Unneed( p_filter, p_filter->p_module );
vlc_object_detach( p_filter );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
}
/*****************************************************************************
{
module_Unneed( pp_filters[i], pp_filters[i]->p_module );
vlc_object_detach( pp_filters[i] );
- vlc_object_destroy( pp_filters[i] );
+ vlc_object_release( pp_filters[i] );
}
}
psz_parser );
vlc_object_detach( p_filter );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
psz_parser = psz_next;
continue;
module_Unneed( p_filter, p_filter->p_module );
vlc_object_detach( p_filter );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
psz_parser = psz_next;
continue;
p_snapshot = ( snapshot_t* ) p_cache->p_private;
vlc_object_unlock( p_cache );
- vlc_object_destroy( p_cache );
+ vlc_object_release( p_cache );
if( p_snapshot )
{
free( p_access->psz_access );
free( p_access->psz_path );
free( p_access->psz_demux );
- vlc_object_destroy( p_access );
+ vlc_object_release( p_access );
return NULL;
}
access2_Delete( p_access->p_source );
}
- vlc_object_destroy( p_access );
+ vlc_object_release( p_access );
}
DecoderUnsupportedCodec( p_dec, fmt->i_codec );
DeleteDecoder( p_dec );
- vlc_object_destroy( p_dec );
+ vlc_object_release( p_dec );
return NULL;
}
msg_Err( p_dec, "cannot spawn decoder thread" );
module_Unneed( p_dec, p_dec->p_module );
DeleteDecoder( p_dec );
- vlc_object_destroy( p_dec );
+ vlc_object_release( p_dec );
return NULL;
}
}
DeleteDecoder( p_dec );
/* Delete the decoder */
- vlc_object_destroy( p_dec );
+ vlc_object_release( p_dec );
}
/**
{
DecoderUnsupportedCodec( p_dec, fcc[i_channel] );
DeleteDecoder( p_cc );
- vlc_object_destroy( p_cc );
+ vlc_object_release( p_cc );
return VLC_EGENERIC;
}
vlc_object_kill( p_cc );
module_Unneed( p_cc, p_cc->p_module );
DeleteDecoder( p_cc );
- vlc_object_destroy( p_cc );
+ vlc_object_release( p_cc );
}
}
return VLC_SUCCESS;
{
es_format_Clean( &p_dec->p_owner->p_packetizer->fmt_in );
vlc_object_detach( p_dec->p_owner->p_packetizer );
- vlc_object_destroy( p_dec->p_owner->p_packetizer );
+ vlc_object_release( p_dec->p_owner->p_packetizer );
}
}
}
es_format_Clean( &p_dec->p_owner->p_packetizer->fmt_in );
es_format_Clean( &p_dec->p_owner->p_packetizer->fmt_out );
vlc_object_detach( p_dec->p_owner->p_packetizer );
- vlc_object_destroy( p_dec->p_owner->p_packetizer );
+ vlc_object_release( p_dec->p_owner->p_packetizer );
}
vlc_mutex_destroy( &p_dec->p_owner->lock_cc );
free( p_demux->psz_path );
free( p_demux->psz_demux );
free( p_demux->psz_access );
- vlc_object_destroy( p_demux );
+ vlc_object_release( p_demux );
return NULL;
}
free( p_demux->psz_demux );
free( p_demux->psz_access );
- vlc_object_destroy( p_demux );
+ vlc_object_release( p_demux );
}
/*****************************************************************************
if( ( p_sys->p_fifo = block_FifoNew( s ) ) == NULL )
{
msg_Err( s, "out of memory" );
- vlc_object_destroy( s );
+ vlc_object_release( s );
free( p_sys );
return NULL;
}
if( vlc_thread_create( s, "stream out", DStreamThread,
VLC_THREAD_PRIORITY_INPUT, VLC_FALSE ) )
{
- vlc_object_destroy( s );
+ vlc_object_release( s );
free( p_sys );
return NULL;
}
free( p_sys->psz_name );
free( p_sys );
- vlc_object_destroy( s );
+ vlc_object_release( s );
}
sout_DeleteInstance( priv->p_sout );
}
- vlc_object_destroy( p_input );
+ vlc_object_release( p_input );
vlc_mutex_destroy( &priv->lock_control );
free( priv );
}
if( !s->p_sys->i_preserve_memory ) free( s->p_sys->p_buffer );
free( s->p_sys );
vlc_object_detach( s );
- vlc_object_destroy( s );
+ vlc_object_release( s );
}
/****************************************************************************
p_me->p_module = module_Need( p_me, "meta fetcher", 0, VLC_FALSE );
if( !p_me->p_module )
{
- vlc_object_destroy( p_me );
+ vlc_object_release( p_me );
return VLC_EGENERIC;
}
module_Unneed( p_me, p_me->p_module );
- vlc_object_destroy( p_me );
+ vlc_object_release( p_me );
input_item_SetMetaFetched( p_item, VLC_TRUE );
free( psz_list );
free( s->p_sys );
vlc_object_detach( s );
- vlc_object_destroy( s );
+ vlc_object_release( s );
return NULL;
}
}
free( s->p_sys );
- vlc_object_destroy( s );
+ vlc_object_release( s );
}
static void UStreamDestroy( stream_t *s )
Manage, VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
{
vlc_mutex_destroy( &p_vlm->lock );
- vlc_object_destroy( p_vlm );
+ vlc_object_release( p_vlm );
return NULL;
}
vlc_mutex_destroy( &p_vlm->lock );
- vlc_object_destroy( p_vlm );
+ vlc_object_release( p_vlm );
vlc_mutex_unlock( lockval.p_address );
}
{
msg_Err( p_vlm, "cannot find vod server" );
vlc_object_detach( p_vlm->p_vod );
- vlc_object_destroy( p_vlm->p_vod );
+ vlc_object_release( p_vlm->p_vod );
p_vlm->p_vod = 0;
return VLC_EGENERIC;
}
{
module_Unneed( p_vlm->p_vod, p_vlm->p_vod->p_module );
vlc_object_detach( p_vlm->p_vod );
- vlc_object_destroy( p_vlm->p_vod );
+ vlc_object_release( p_vlm->p_vod );
p_vlm->p_vod = NULL;
}
return VLC_SUCCESS;
DialogDestroy( p_dialog );
REMOVE_ELEM( p_interaction->pp_dialogs, p_interaction->i_dialogs, i );
}
- vlc_object_destroy( p_interaction );
+ vlc_object_release( p_interaction );
}
/**
{
msg_Err( p_intf, "no suitable interface module" );
free( p_intf->psz_intf );
- vlc_object_destroy( p_intf );
+ vlc_object_release( p_intf );
return NULL;
}
vlc_mutex_destroy( &p_intf->change_lock );
/* Free structure */
- vlc_object_destroy( p_intf );
+ vlc_object_release( p_intf );
}
vlc_mutex_destroy( &p_libvlc->timer_lock );
if( b_release ) vlc_object_release( p_libvlc );
- vlc_object_destroy( p_libvlc );
+ vlc_object_release( p_libvlc );
p_libvlc = NULL;
/* Stop thread system: last one out please shut the door!
__vlc_object_alive
__vlc_object_attach
__vlc_object_create
-__vlc_object_destroy
__vlc_object_detach
__vlc_object_find
__vlc_object_find_name
be_app->PostMessage( REALLY_QUIT );
vlc_thread_join( vlc_global()->p_appthread );
- vlc_object_destroy( vlc_global()->p_appthread );
+ vlc_object_release( vlc_global()->p_appthread );
free( vlc_global()->psz_vlcpath );
}
if( p_probe->p_module == NULL )
{
msg_Err( p_this, "no devices probing module could be loaded" );
- vlc_object_destroy( p_probe );
+ vlc_object_release( p_probe );
return;
}
es_format_Clean( &p_dec->fmt_in );
es_format_Clean( &p_dec->fmt_out );
- vlc_object_destroy( p_dec );
+ vlc_object_release( p_dec );
p_dec = NULL;
}
es_format_Clean( &p_enc->fmt_in );
es_format_Clean( &p_enc->fmt_out );
- vlc_object_destroy( p_enc );
+ vlc_object_release( p_enc );
p_enc = NULL;
}
es_format_Clean( &p_filter->fmt_in );
es_format_Clean( &p_filter->fmt_out );
- vlc_object_destroy( p_filter );
+ vlc_object_release( p_filter );
p_filter = NULL;
}
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(). */
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
}
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++;
msleep( 100000 );
}
+>>>>>>> .r25344
/* Destroy the associated variables, starting from the end so that
* no memmove calls have to be done. */
while( p_priv->i_vars )
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 )
+ {
+ int i;
+ for( i = 0; i < p_global->i_objects; i++ )
+ {
+ /* 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 );
+ 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 );
}
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);
+
vlc_mutex_unlock( &structure_lock );
+
+ if( b_should_destroy )
+ vlc_object_destroy( p_this );
+}
+
+/* Version without the lock */
+static void vlc_object_release_locked( vlc_object_t *p_this )
+{
+ vlc_bool_t b_should_destroy;
+
+ 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 )
+ vlc_object_destroy( p_this );
}
/**
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_locked( p_list->p_values[i_index].p_object );
}
vlc_mutex_unlock( &structure_lock );
if( i_initializations == 0 )
{
i_status = VLC_THREADS_UNINITIALIZED;
- vlc_object_destroy( p_root );
+ vlc_object_release( p_root );
}
#if defined( UNDER_CE )
if( p_uct->pf_callback )
(p_uct->pf_callback)( p_uct->p_data, b_ret );
- vlc_object_destroy( p_uct );
+ vlc_object_release( p_uct );
}
/**
free( p_buffer );
free( psz_size );
- vlc_object_destroy( p_udt );
+ vlc_object_release( p_udt );
}
#endif
if( !p_xml->p_module )
{
vlc_object_detach( p_xml );
- vlc_object_destroy( p_xml );
+ vlc_object_release( p_xml );
msg_Err( p_this, "XML provider not found" );
return NULL;
}
{
module_Unneed( p_xml, p_xml->p_module );
vlc_object_detach( p_xml );
- vlc_object_destroy( p_xml );
+ vlc_object_release( p_xml );
}
/* We just free the module by hand. Niahahahahaha. */
vlc_object_detach( p_next );
- vlc_object_destroy( p_next );
+ vlc_object_release( p_next );
}
}
- vlc_object_destroy( p_libvlc_global->p_module_bank );
+ vlc_object_release( p_libvlc_global->p_module_bank );
p_libvlc_global->p_module_bank = NULL;
}
if( module_Call( p_module ) != 0 )
{
/* We couldn't call module_init() */
- vlc_object_destroy( p_module );
+ vlc_object_release( p_module );
module_Unload( handle );
return NULL;
}
/* With a well-written module we shouldn't have to print an
* additional error message here, but just make sure. */
msg_Err( p_this, "failed calling entry point in builtin module" );
- vlc_object_destroy( p_module );
+ vlc_object_release( p_module );
return -1;
}
{
vlc_object_t *p_this = p_module->pp_children[0];
vlc_object_detach( p_this );
- vlc_object_destroy( p_this );
+ vlc_object_release( p_this );
}
config_Free( p_module );
- vlc_object_destroy( p_module );
+ vlc_object_release( p_module );
p_module = NULL;
return 0;
}
{
vlc_object_release( httpd );
vlc_object_detach( httpd );
- vlc_object_destroy( httpd );
+ vlc_object_release( httpd );
}
vlc_mutex_unlock( lockval.p_address );
{
net_ListenClose( host->fds );
vlc_mutex_destroy( &host->lock );
- vlc_object_destroy( host );
+ vlc_object_release( host );
}
if( p_tls != NULL )
free( host->psz_hostname );
vlc_mutex_destroy( &host->lock );
- vlc_object_destroy( host );
+ vlc_object_release( host );
vlc_object_release( httpd );
if( httpd->i_host <= 0 )
{
msg_Dbg( httpd, "no host left, stopping httpd" );
vlc_object_detach( httpd );
- vlc_object_destroy( httpd );
+ vlc_object_release( httpd );
}
vlc_mutex_unlock( lockval.p_address );
}
if (srv->p_module == NULL)
{
msg_Err (srv, "TLS server plugin not available");
- vlc_object_destroy (srv);
+ vlc_object_release (srv);
return NULL;
}
module_Unneed (srv, srv->p_module);
vlc_object_detach (srv);
- vlc_object_destroy (srv);
+ vlc_object_release (srv);
}
if (cl->p_module == NULL)
{
msg_Err (cl, "TLS client plugin not available");
- vlc_object_destroy (cl);
+ vlc_object_release (cl);
return NULL;
}
msg_Err (cl, "TLS client session handshake error");
module_Unneed (cl, cl->p_module);
- vlc_object_destroy (cl);
+ vlc_object_release (cl);
return NULL;
}
module_Unneed (cl, cl->p_module);
vlc_object_detach (cl);
- vlc_object_destroy (cl);
+ vlc_object_release (cl);
}
module_Unneed( p_menu, p_menu->p_parser );
vlc_object_detach( p_menu );
- vlc_object_destroy( p_menu );
+ vlc_object_release( p_menu );
}
/**
free( p_osd->psz_file );
vlc_object_detach( p_osd );
- vlc_object_destroy( p_osd );
+ vlc_object_release( p_osd );
vlc_mutex_unlock( lockval.p_address );
return NULL;
}
vlc_mutex_destroy( &p_playlist->gc_lock );
vlc_object_detach( p_playlist );
- vlc_object_destroy( p_playlist );
+ vlc_object_release( p_playlist );
}
/* Destroy remaining objects */
if( p_sd->p_module == NULL )
{
msg_Err( p_super, "no suitable services discovery module" );
- vlc_object_destroy( p_sd );
+ vlc_object_release( p_sd );
return NULL;
}
p_sd->psz_module = strdup( psz_module_name );
free( p_sd->psz_localized_name );
vlc_object_detach( p_sd );
- vlc_object_destroy( p_sd );
+ vlc_object_release( p_sd );
}
/***********************************************************************
VLC_THREAD_PRIORITY_LOW, VLC_FALSE))
{
msg_Err( p_sd, "cannot create services discovery thread" );
- vlc_object_destroy( p_sd );
+ vlc_object_release( p_sd );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
if( !p_playlist->p_preparse )
{
msg_Err( p_playlist, "unable to create preparser" );
- vlc_object_destroy( p_playlist );
+ vlc_object_release( p_playlist );
return;
}
p_playlist->p_preparse->i_waiting = 0;
{
msg_Err( p_playlist, "cannot spawn preparse thread" );
vlc_object_detach( p_playlist->p_preparse );
- vlc_object_destroy( p_playlist->p_preparse );
+ vlc_object_release( p_playlist->p_preparse );
return;
}
if( !p_playlist->p_fetcher )
{
msg_Err( p_playlist, "unable to create secondary preparser" );
- vlc_object_destroy( p_playlist );
+ vlc_object_release( p_playlist );
return;
}
p_playlist->p_fetcher->i_waiting = 0;
{
msg_Err( p_playlist, "cannot spawn secondary preparse thread" );
vlc_object_detach( p_playlist->p_fetcher );
- vlc_object_destroy( p_playlist->p_fetcher );
+ vlc_object_release( p_playlist->p_fetcher );
return;
}
VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
{
msg_Err( p_playlist, "cannot spawn playlist thread" );
- vlc_object_destroy( p_playlist );
+ vlc_object_release( p_playlist );
return;
}
vlc_thread_join( p_playlist->p_preparse );
free( p_playlist->p_preparse->pp_waiting );
vlc_object_detach( p_playlist->p_preparse );
- vlc_object_destroy( p_playlist->p_preparse );
+ vlc_object_release( p_playlist->p_preparse );
}
// Kill meta fetcher
vlc_thread_join( p_playlist->p_fetcher );
free( p_playlist->p_fetcher->p_waiting );
vlc_object_detach( p_playlist->p_fetcher );
- vlc_object_destroy( p_playlist->p_fetcher );
+ vlc_object_release( p_playlist->p_fetcher );
}
// Wait for thread to complete
}
/* Free the structure */
- vlc_object_destroy( p_announce );
+ vlc_object_release( p_announce );
return VLC_SUCCESS;
}
}
/* Free the structure */
- vlc_object_destroy( p_sap );
+ vlc_object_release( p_sap );
}
/**
FREENULL( p_sout->psz_chain );
vlc_object_detach( p_sout );
- vlc_object_destroy( p_sout );
+ vlc_object_release( p_sout );
return NULL;
}
vlc_mutex_destroy( &p_sout->lock );
/* *** free structure *** */
- vlc_object_destroy( p_sout );
+ vlc_object_release( p_sout );
}
/*****************************************************************************
free( p_access->psz_access );
free( p_access->psz_path );
vlc_object_detach( p_access );
- vlc_object_destroy( p_access );
+ vlc_object_release( p_access );
return( NULL );
}
free( p_access->psz_path );
- vlc_object_destroy( p_access );
+ vlc_object_release( p_access );
}
/*****************************************************************************
FREENULL( p_mux->psz_mux );
vlc_object_detach( p_mux );
- vlc_object_destroy( p_mux );
+ vlc_object_release( p_mux );
return NULL;
}
config_ChainDestroy( p_mux->p_cfg );
- vlc_object_destroy( p_mux );
+ vlc_object_release( p_mux );
}
/*****************************************************************************
config_ChainDestroy( p_stream->p_cfg );
msg_Dbg( p_stream, "destroying chain done" );
- vlc_object_destroy( p_stream );
+ vlc_object_release( p_stream );
}
static char *_sout_stream_url_to_chain( vlc_object_t *p_this, char *psz_url )
{
msg_Err( p_vout, "no suitable vout module" );
vlc_object_detach( p_vout );
- vlc_object_destroy( p_vout );
+ vlc_object_release( p_vout );
return NULL;
}
msg_Err( p_vout, "out of memory" );
module_Unneed( p_vout, p_vout->p_module );
vlc_object_detach( p_vout );
- vlc_object_destroy( p_vout );
+ vlc_object_release( p_vout );
return NULL;
}
vlc_thread_join( p_vout );
vlc_object_detach( p_vout );
- vlc_object_destroy( p_vout );
+ vlc_object_release( p_vout );
return NULL;
}
config_ChainDestroy( p_vout->p_cfg );
/* Free structure */
- vlc_object_destroy( p_vout );
+ vlc_object_release( p_vout );
#ifndef __APPLE__
/* This is a dirty hack for mostly Linux, where there is no way to get the GUI
back if you closed it while playing video. This is solved in Mac OS X,
msg_Err( p_vout, "no video filter found (%s)",
p_vout->psz_vfilters[i] );
vlc_object_detach( p_vfilter );
- vlc_object_destroy( p_vfilter );
+ vlc_object_release( p_vfilter );
}
}
p_vout->b_vfilter_change = VLC_FALSE;
vlc_object_release( p_this->p_input );
- vlc_object_destroy( p_this );
+ vlc_object_release( p_this );
}
/*****************************************************************************
}
free( p_vout->pp_vfilters[i]->p_owner );
- vlc_object_destroy( p_vout->pp_vfilters[i] );
+ vlc_object_release( p_vout->pp_vfilters[i] );
}
p_vout->i_vfilters = 0;
}
msg_Dbg( p_spu, "no sub filter found" );
config_ChainDestroy( p_spu->pp_filter[p_spu->i_filter]->p_cfg );
vlc_object_detach( p_spu->pp_filter[p_spu->i_filter] );
- vlc_object_destroy( p_spu->pp_filter[p_spu->i_filter] );
+ vlc_object_release( p_spu->pp_filter[p_spu->i_filter] );
}
if( p_spu->i_filter >= 10 )
module_Unneed( p_spu->p_blend, p_spu->p_blend->p_module );
vlc_object_detach( p_spu->p_blend );
- vlc_object_destroy( p_spu->p_blend );
+ vlc_object_release( p_spu->p_blend );
}
if( p_spu->p_text )
module_Unneed( p_spu->p_text, p_spu->p_text->p_module );
vlc_object_detach( p_spu->p_text );
- vlc_object_destroy( p_spu->p_text );
+ vlc_object_release( p_spu->p_text );
}
if( p_spu->p_scale )
module_Unneed( p_spu->p_scale, p_spu->p_scale->p_module );
vlc_object_detach( p_spu->p_scale );
- vlc_object_destroy( p_spu->p_scale );
+ vlc_object_release( p_spu->p_scale );
}
spu_DeleteChain( p_spu );
vlc_mutex_destroy( &p_spu->subpicture_lock );
- vlc_object_destroy( p_spu );
+ vlc_object_release( p_spu );
}
static void spu_DeleteChain( spu_t *p_spu )
free( p_spu->pp_filter[p_spu->i_filter]->p_owner );
config_ChainDestroy( p_spu->pp_filter[p_spu->i_filter]->p_cfg );
vlc_object_detach( p_spu->pp_filter[p_spu->i_filter] );
- vlc_object_destroy( p_spu->pp_filter[p_spu->i_filter] );
+ vlc_object_release( p_spu->pp_filter[p_spu->i_filter] );
}
}
projects / vlc / commitdiff