static void Close(vlc_object_t *object)
{
filter_t *filter = (filter_t *)object;
filter_sys_t *sys = filter->p_sys;
var_DelCallback(filter, CFG_PREFIX "radius", Callback, NULL);
var_DelCallback(filter, CFG_PREFIX "strength", Callback, NULL);
vlc_free(sys->cfg.buf);
vlc_mutex_destroy(&sys->lock);
free(sys);
}
static void AddressDestroy (sap_address_t *addr)
{
assert (addr->first == NULL);
vlc_cancel (addr->thread);
vlc_join (addr->thread, NULL);
vlc_cond_destroy (&addr->wait);
vlc_mutex_destroy (&addr->lock);
net_Close (addr->fd);
free (addr);
}
CAtmoConnection::~CAtmoConnection(void)
{
if(isOpen())
CloseConnection();
#if defined(_ATMO_VLC_PLUGIN_)
vlc_mutex_destroy( &m_AccessConnection );
#else
DeleteCriticalSection( &m_AccessConnection );
#endif
}
/*****************************************************************************
* CloseDecoder: fake decoder destruction
*****************************************************************************/
static void CloseDecoder( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t *)p_this;
picture_t *p_image = p_dec->p_sys->p_image;
if( p_image != NULL )
picture_Release( p_image );
vlc_mutex_destroy( &p_dec->p_sys->lock );
free( p_dec->p_sys );
}
/*****************************************************************************
* Destroy: destroy adjust video thread output method
*****************************************************************************
* Terminate an output method created by adjustCreateOutputMethod
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
var_DelCallback( p_filter, CFG_PREFIX "color", FilterCallback, NULL );
var_DelCallback( p_filter, CFG_PREFIX "similaritythres", FilterCallback, NULL );
var_DelCallback( p_filter, CFG_PREFIX "saturationthres", FilterCallback, NULL );
vlc_mutex_destroy( &p_filter->p_sys->lock );
free( p_filter->p_sys );
}
/*****************************************************************************
* Open: initialize interface
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys = malloc( sizeof (intf_sys_t) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_intf->p_sys = p_sys;
p_sys->hotkeyWindow = NULL;
vlc_mutex_init( &p_sys->lock );
vlc_cond_init( &p_sys->wait );
if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) )
{
vlc_mutex_destroy( &p_sys->lock );
vlc_cond_destroy( &p_sys->wait );
free( p_sys );
p_intf->p_sys = NULL;
return VLC_ENOMEM;
}
vlc_mutex_lock( &p_sys->lock );
while( p_sys->hotkeyWindow == NULL )
vlc_cond_wait( &p_sys->wait, &p_sys->lock );
if( p_sys->hotkeyWindow == INVALID_HANDLE_VALUE )
{
vlc_mutex_unlock( &p_sys->lock );
vlc_join( p_sys->thread, NULL );
vlc_mutex_destroy( &p_sys->lock );
vlc_cond_destroy( &p_sys->wait );
free( p_sys );
p_intf->p_sys = NULL;
return VLC_ENOMEM;
}
vlc_mutex_unlock( &p_sys->lock );
return VLC_SUCCESS;
}
static void Close( vlc_object_t *p_this )
{
stream_t *s = (stream_t*)p_this;
stream_sys_t *p_sys = s->p_sys;
p_sys->b_close = true;
vlc_cond_signal(&p_sys->download.wait);
vlc_mutex_lock( &p_sys->playback.lock );
p_sys->playback.toffset = 0;
vlc_mutex_unlock( &p_sys->playback.lock );
vlc_join( p_sys->download.thread, NULL );
vlc_mutex_destroy( &p_sys->lock );
vlc_cond_destroy( &p_sys->download.wait );
vlc_mutex_destroy( &p_sys->playback.lock );
vlc_cond_destroy( &p_sys->playback.wait );
SysCleanup( p_sys );
free( p_sys );
}
void vout_snapshot_Clean(vout_snapshot_t *snap)
{
picture_t *picture = snap->picture;
while (picture) {
picture_t *next = picture->p_next;
picture_Release(picture);
picture = next;
}
vlc_cond_destroy(&snap->wait);
vlc_mutex_destroy(&snap->lock);
}
void directx_va_Close(vlc_va_t *va, directx_sys_t *dx_sys)
{
DestroyVideoDecoder(va, dx_sys);
DestroyVideoService(va, dx_sys);
DestroyDeviceManager(va, dx_sys);
DestroyDevice(va, dx_sys);
if (dx_sys->hdecoder_dll)
FreeLibrary(dx_sys->hdecoder_dll);
vlc_mutex_destroy( &dx_sys->surface_lock );
}
/**
* Deinitializes an interruption context.
* The context shall no longer be used by any thread.
*/
void vlc_interrupt_deinit(vlc_interrupt_t *ctx)
{
assert(ctx->callback == NULL);
assert(!ctx->attached);
vlc_mutex_destroy(&ctx->lock);
vlc_rwlock_wrlock(&vlc_interrupt_lock);
assert(vlc_interrupt_refs > 0);
if (--vlc_interrupt_refs == 0)
vlc_threadvar_delete(&vlc_interrupt_var);
vlc_rwlock_unlock(&vlc_interrupt_lock);
}
static void Deactivate(vlc_object_t *p_this) {
intf_thread_t *p_intf = (intf_thread_t*)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
net_ListenClose(p_sys->pi_socket);
if(p_sys->i_socket != -1)
net_Close(p_sys->i_socket);
vlc_mutex_destroy(&p_sys->o_write_lock);
close(p_sys->i_wakeup[0]);
close(p_sys->i_wakeup[1]);
free(p_sys);
}
stream_t *stream_DemuxNew( demux_t *p_demux, const char *psz_demux, es_out_t *out )
{
vlc_object_t *p_obj = VLC_OBJECT(p_demux);
/* We create a stream reader, and launch a thread */
stream_t *s;
stream_sys_t *p_sys;
s = stream_CommonNew( p_obj );
if( s == NULL )
return NULL;
s->p_input = p_demux->p_input;
s->pf_read = DStreamRead;
s->pf_control= DStreamControl;
s->pf_destroy= DStreamDelete;
s->p_sys = p_sys = malloc( sizeof( *p_sys) );
if( !s->p_sys )
{
stream_Delete( s );
return NULL;
}
p_sys->out = out;
p_sys->p_block = NULL;
p_sys->psz_name = strdup( psz_demux );
p_sys->stats.position = 0.;
p_sys->stats.length = 0;
p_sys->stats.time = 0;
/* decoder fifo */
if( ( p_sys->p_fifo = block_FifoNew() ) == NULL )
{
stream_Delete( s );
free( p_sys->psz_name );
free( p_sys );
return NULL;
}
atomic_init( &p_sys->active, true );
vlc_mutex_init( &p_sys->lock );
if( vlc_clone( &p_sys->thread, DStreamThread, s, VLC_THREAD_PRIORITY_INPUT ) )
{
vlc_mutex_destroy( &p_sys->lock );
block_FifoRelease( p_sys->p_fifo );
stream_Delete( s );
free( p_sys->psz_name );
free( p_sys );
return NULL;
}
return s;
}
static void
vlc_media_tree_Delete(vlc_media_tree_t *tree)
{
media_tree_private_t *priv = mt_priv(tree);
vlc_media_tree_listener_id *listener;
vlc_list_foreach(listener, &priv->listeners, node)
free(listener);
vlc_list_init(&priv->listeners); /* reset */
vlc_media_tree_DestroyRootNode(tree);
vlc_mutex_destroy(&priv->lock);
free(tree);
}
/**
* Destroys an initialized timer. If needed, the timer is first disarmed.
* This function is undefined if the specified timer is not initialized.
*
* @warning This function <b>must</b> be called before the timer data can be
* freed and before the timer callback function can be unloaded.
*
* @param timer timer to destroy
*/
void vlc_timer_destroy (vlc_timer_t timer)
{
vlc_timer_schedule (timer, false, 0, 0);
vlc_mutex_lock (&timer->lock);
while (timer->users != 0)
vlc_cond_wait (&timer->wait, &timer->lock);
vlc_mutex_unlock (&timer->lock);
vlc_cond_destroy (&timer->wait);
vlc_mutex_destroy (&timer->lock);
free (timer);
}
/*
* Releases resources.
*/
static void Close( vlc_object_t *p_this )
{
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
UpnpUnRegisterClient( p_sd->p_sys->client_handle );
UpnpFinish();
delete p_sd->p_sys->p_server_list;
vlc_mutex_destroy( &p_sd->p_sys->callback_lock );
free( p_sd->p_sys );
}
/**************************************************************************
* new (Public)
**************************************************************************/
libvlc_media_list_player_t *
libvlc_media_list_player_new(libvlc_instance_t * p_instance)
{
libvlc_media_list_player_t * p_mlp;
p_mlp = calloc( 1, sizeof(libvlc_media_list_player_t) );
if (unlikely(p_mlp == NULL))
{
libvlc_printerr("Not enough memory");
return NULL;
}
p_mlp->i_refcount = 1;
p_mlp->seek_offset = 0;
vlc_mutex_init(&p_mlp->object_lock);
vlc_mutex_init(&p_mlp->mp_callback_lock);
vlc_cond_init(&p_mlp->seek_pending);
libvlc_event_manager_init(&p_mlp->event_manager, p_mlp);
/* Create the underlying media_player */
p_mlp->p_mi = libvlc_media_player_new(p_instance);
if( p_mlp->p_mi == NULL )
goto error;
install_media_player_observer(p_mlp);
if (vlc_clone(&p_mlp->thread, playlist_thread, p_mlp,
VLC_THREAD_PRIORITY_LOW))
{
libvlc_media_player_release(p_mlp->p_mi);
goto error;
}
return p_mlp;
error:
libvlc_event_manager_destroy(&p_mlp->event_manager);
vlc_cond_destroy(&p_mlp->seek_pending);
vlc_mutex_destroy(&p_mlp->mp_callback_lock);
vlc_mutex_destroy(&p_mlp->object_lock);
free(p_mlp);
return NULL;
}
/**************************************************************************
* release (Public)
**************************************************************************/
void libvlc_media_list_player_release(libvlc_media_list_player_t * p_mlp)
{
if (!p_mlp)
return;
lock(p_mlp);
p_mlp->i_refcount--;
if (p_mlp->i_refcount > 0)
{
unlock(p_mlp);
return;
}
assert(p_mlp->i_refcount == 0);
unlock(p_mlp);
vlc_cancel(p_mlp->thread);
vlc_join(p_mlp->thread, NULL);
lock(p_mlp);
/* Keep the lock(), because the uninstall functions
* check for it. That's convenient. */
uninstall_media_player_observer(p_mlp);
libvlc_media_player_release(p_mlp->p_mi);
if (p_mlp->p_mlist)
{
uninstall_playlist_observer(p_mlp);
libvlc_media_list_release(p_mlp->p_mlist);
}
unlock(p_mlp);
libvlc_event_manager_destroy(&p_mlp->event_manager);
vlc_cond_destroy(&p_mlp->seek_pending);
vlc_mutex_destroy(&p_mlp->mp_callback_lock);
vlc_mutex_destroy(&p_mlp->object_lock);
free(p_mlp->current_playing_item_path);
free(p_mlp);
}
/*****************************************************************************
* sout_NewInstance: creates a new stream output instance
*****************************************************************************/
sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest )
{
sout_instance_t *p_sout;
char *psz_chain;
if( psz_dest && psz_dest[0] == '#' )
{
psz_chain = strdup( &psz_dest[1] );
}
else
{
psz_chain = sout_stream_url_to_chain(
var_InheritBool(p_parent, "sout-display"), psz_dest );
}
if(!psz_chain)
return NULL;
/* *** Allocate descriptor *** */
p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );
if( p_sout == NULL )
{
free( psz_chain );
return NULL;
}
msg_Dbg( p_sout, "using sout chain=`%s'", psz_chain );
/* *** init descriptor *** */
p_sout->psz_sout = strdup( psz_dest );
p_sout->i_out_pace_nocontrol = 0;
vlc_mutex_init( &p_sout->lock );
p_sout->p_stream = NULL;
var_Create( p_sout, "sout-mux-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_sout->p_stream = sout_StreamChainNew( p_sout, psz_chain, NULL, NULL );
if( p_sout->p_stream )
{
free( psz_chain );
return p_sout;
}
msg_Err( p_sout, "stream chain failed for `%s'", psz_chain );
free( psz_chain );
FREENULL( p_sout->psz_sout );
vlc_mutex_destroy( &p_sout->lock );
vlc_object_release( p_sout );
return NULL;
}
static inline void input_item_Clean( input_item_t *p_i )
{
int i;
vlc_event_manager_fini( &p_i->event_manager );
free( p_i->psz_name );
free( p_i->psz_uri );
if( p_i->p_stats )
{
vlc_mutex_destroy( &p_i->p_stats->lock );
free( p_i->p_stats );
}
if( p_i->p_meta )
vlc_meta_Delete( p_i->p_meta );
for( i = 0; i < p_i->i_options; i++ )
free( p_i->ppsz_options[i] );
TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
free( p_i->optflagv);
for( i = 0; i < p_i->i_es; i++ )
{
es_format_Clean( p_i->es[i] );
free( p_i->es[i] );
}
TAB_CLEAN( p_i->i_es, p_i->es );
for( i = 0; i < p_i->i_epg; i++ )
vlc_epg_Delete( p_i->pp_epg[i] );
TAB_CLEAN( p_i->i_epg, p_i->pp_epg );
for( i = 0; i < p_i->i_categories; i++ )
info_category_Delete( p_i->pp_categories[i] );
TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
vlc_mutex_destroy( &p_i->lock );
}
static void
dialog_id_release(vlc_dialog_id *p_id)
{
if (p_id->answer.i_type == VLC_DIALOG_LOGIN)
{
free(p_id->answer.u.login.psz_username);
free(p_id->answer.u.login.psz_password);
}
free(p_id->psz_progress_text);
vlc_mutex_destroy(&p_id->lock);
vlc_cond_destroy(&p_id->wait);
free(p_id);
}
/*****************************************************************************
* sout_DeleteInstance: delete a previously allocated instance
*****************************************************************************/
void sout_DeleteInstance( sout_instance_t * p_sout )
{
/* remove the stream out chain */
sout_StreamChainDelete( p_sout->p_stream, NULL );
/* *** free all string *** */
FREENULL( p_sout->psz_sout );
vlc_mutex_destroy( &p_sout->lock );
/* *** free structure *** */
vlc_object_release( p_sout );
}
/*****************************************************************************
* DestroyFilter: destroy RSS video filter
*****************************************************************************/
static void DestroyFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
vlc_timer_destroy( p_sys->timer );
vlc_mutex_destroy( &p_sys->lock );
text_style_Delete( p_sys->p_style );
free( p_sys->psz_marquee );
FreeRSS( p_sys->p_feeds, p_sys->i_feeds );
free( p_sys );
}
static void Close(filter_t *filter)
{
filter_sys_t *sys = filter->p_sys;
MMAL_BUFFER_HEADER_T *buffer;
if (!sys)
return;
if (sys->component && sys->component->control->is_enabled)
mmal_port_disable(sys->component->control);
if (sys->input && sys->input->is_enabled)
mmal_port_disable(sys->input);
if (sys->output && sys->output->is_enabled)
mmal_port_disable(sys->output);
if (sys->component && sys->component->is_enabled)
mmal_component_disable(sys->component);
while ((buffer = mmal_queue_get(sys->filtered_pictures))) {
picture_t *pic = (picture_t *)buffer->user_data;
picture_Release(pic);
}
if (sys->filtered_pictures)
mmal_queue_destroy(sys->filtered_pictures);
if (sys->component)
mmal_component_release(sys->component);
vlc_mutex_destroy(&sys->mutex);
vlc_mutex_destroy(&sys->buffer_cond_mutex);
vlc_cond_destroy(&sys->buffer_cond);
free(sys);
bcm_host_deinit();
}
/**
* Close the filter
*/
static void Close( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
var_DelCallback( p_filter, CFG_PREFIX "rows", PuzzleCallback, p_sys );
var_DelCallback( p_filter, CFG_PREFIX "cols", PuzzleCallback, p_sys );
var_DelCallback( p_filter, CFG_PREFIX "black-slot", PuzzleCallback, p_sys );
vlc_mutex_destroy( &p_sys->lock );
free( p_sys->pi_order );
free( p_sys );
}
static void Destroy( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
var_DelCallback( p_filter, CFG_PREFIX "u", BluescreenCallback, p_sys );
var_DelCallback( p_filter, CFG_PREFIX "v", BluescreenCallback, p_sys );
var_DelCallback( p_filter, CFG_PREFIX "ut", BluescreenCallback, p_sys );
var_DelCallback( p_filter, CFG_PREFIX "vt", BluescreenCallback, p_sys );
free( p_sys->p_at );
vlc_mutex_destroy( &p_sys->lock );
free( p_sys );
}
static void Destroy( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
var_DelCallback( p_filter, CFG_PREFIX "mask", MaskCallback,
p_filter );
vlc_mutex_destroy( &p_sys->mask_lock );
if( p_sys->p_mask )
picture_Release( p_sys->p_mask );
free( p_sys );
}
/*****************************************************************************
* aout_DecDelete : delete a decoder
*****************************************************************************/
int aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input )
{
int i_input;
/* This function can only be called by the decoder itself, so no need
* to lock p_input->lock. */
vlc_mutex_lock( &p_aout->mixer_lock );
for ( i_input = 0; i_input < p_aout->i_nb_inputs; i_input++ )
{
if ( p_aout->pp_inputs[i_input] == p_input )
{
break;
}
}
if ( i_input == p_aout->i_nb_inputs )
{
msg_Err( p_aout, "cannot find an input to delete" );
return -1;
}
/* Remove the input from the list. */
memmove( &p_aout->pp_inputs[i_input], &p_aout->pp_inputs[i_input + 1],
(AOUT_MAX_INPUTS - i_input - 1) * sizeof(aout_input_t *) );
p_aout->i_nb_inputs--;
aout_InputDelete( p_aout, p_input );
vlc_mutex_destroy( &p_input->lock );
free( p_input );
if ( !p_aout->i_nb_inputs )
{
aout_OutputDelete( p_aout );
aout_MixerDelete( p_aout );
if ( var_Type( p_aout, "audio-device" ) != 0 )
{
var_Destroy( p_aout, "audio-device" );
}
if ( var_Type( p_aout, "audio-channels" ) != 0 )
{
var_Destroy( p_aout, "audio-channels" );
}
}
vlc_mutex_unlock( &p_aout->mixer_lock );
return 0;
}
void vlc_http_cookies_destroy( vlc_http_cookie_jar_t * p_jar )
{
if ( !p_jar )
return;
int i;
for( i = 0; i < vlc_array_count( &p_jar->cookies ); i++ )
cookie_destroy( vlc_array_item_at_index( &p_jar->cookies, i ) );
vlc_array_clear( &p_jar->cookies );
vlc_mutex_destroy( &p_jar->lock );
free( p_jar );
}
/**************************************************************************
* Destroy a Media Instance object (libvlc internal)
*
* Warning: No lock held here, but hey, this is internal. Caller must lock.
**************************************************************************/
static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi )
{
assert( p_mi );
/* Detach Callback from the main libvlc object */
var_DelCallback( p_mi->p_libvlc,
"snapshot-file", snapshot_was_taken, p_mi );
/* No need for lock_input() because no other threads knows us anymore */
if( p_mi->input.p_thread )
release_input_thread(p_mi, true);
input_resource_Terminate( p_mi->input.p_resource );
input_resource_Release( p_mi->input.p_resource );
vlc_mutex_destroy( &p_mi->input.lock );
libvlc_event_manager_release( p_mi->p_event_manager );
libvlc_media_release( p_mi->p_md );
vlc_mutex_destroy( &p_mi->object_lock );
libvlc_instance_t *instance = p_mi->p_libvlc_instance;
vlc_object_release( p_mi );
libvlc_release(instance);
}
/*****************************************************************************
* End: terminate Crop video thread output method
*****************************************************************************/
static void End( vout_thread_t *p_vout )
{
vout_sys_t *p_sys = p_vout->p_sys;
if( p_sys->p_vout )
{
vout_filter_DelChild( p_vout, p_sys->p_vout, MouseEvent );
vout_CloseAndRelease( p_sys->p_vout );
}
vout_filter_ReleaseDirectBuffers( p_vout );
var_DelCallback( p_vout, "ratio-crop", FilterCallback, NULL );
vlc_mutex_destroy( &p_sys->lock );
}
