/*****************************************************************************
* Close: destroy interface
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
sout_stream_t *p_stream = (sout_stream_t *)p_this;
sout_stream_sys_t *p_sys = p_stream->p_sys;
vlc_cancel(p_sys->chromecastThread);
vlc_join(p_sys->chromecastThread, NULL);
switch (p_sys->i_status)
{
case CHROMECAST_MEDIA_LOAD_SENT:
case CHROMECAST_APP_STARTED:
// Generate the close messages.
msgClose(p_stream, p_sys->appTransportId);
// ft
case CHROMECAST_AUTHENTICATED:
msgClose(p_stream, "receiver-0");
// Send the just added close messages.
sendMessages(p_stream);
// ft
default:
break;
}
Clean(p_stream);
}
/*****************************************************************************
* Close: close the target
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
sout_access_out_t *p_access = (sout_access_out_t *) p_this;
sout_access_out_sys_t *p_sys = p_access->p_sys;
int i;
vlc_cancel( p_sys->p_thread->thread );
vlc_join( p_sys->p_thread->thread, NULL );
vlc_cond_destroy( &p_sys->p_thread->wait );
vlc_mutex_destroy( &p_sys->p_thread->lock );
block_FifoRelease( p_sys->p_thread->p_fifo_input );
block_FifoRelease( p_sys->p_thread->p_empty_blocks );
for( i = 0; i < 64; i++ ) /* RTMP_HEADER_STREAM_INDEX_MASK */
{
if( p_sys->p_thread->rtmp_headers_recv[i].body != NULL )
{
free( p_sys->p_thread->rtmp_headers_recv[i].body->body );
free( p_sys->p_thread->rtmp_headers_recv[i].body );
}
}
net_Close( p_sys->p_thread->fd );
vlc_object_release( p_sys->p_thread );
vlc_UrlClean( &p_sys->p_thread->url );
free( p_sys->p_thread->psz_application );
free( p_sys->p_thread->psz_media );
free( p_sys );
}
/**************************************************************************
* libvlc_event_async_fini (internal) :
*
* Destroy what might have been created by.
**************************************************************************/
void
libvlc_event_async_fini(libvlc_event_manager_t * p_em)
{
if(!is_queue_initialized(p_em)) return;
if(current_thread_is_asynch_thread(p_em))
{
fprintf(stderr, "*** Error: releasing the last reference of the observed object from its callback thread is not (yet!) supported\n");
abort();
}
vlc_thread_t thread = queue(p_em)->thread;
if(thread)
{
vlc_cancel(thread);
vlc_join(thread, NULL);
}
vlc_mutex_destroy(&queue(p_em)->lock);
vlc_cond_destroy(&queue(p_em)->signal);
vlc_cond_destroy(&queue(p_em)->signal_idle);
vlc_threadvar_delete(&queue(p_em)->is_asynch_dispatch_thread_var);
struct queue_elmt * iter = queue(p_em)->elements;
while (iter) {
struct queue_elmt * elemt_to_delete = iter;
iter = iter->next;
free(elemt_to_delete);
}
free(queue(p_em));
}
/*****************************************************************************
* Close: destroy interface
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
sout_stream_t *p_stream = reinterpret_cast<sout_stream_t*>(p_this);
sout_stream_sys_t *p_sys = p_stream->p_sys;
vlc_cancel(p_sys->chromecastThread);
vlc_join(p_sys->chromecastThread, NULL);
switch (p_sys->p_intf->getConnectionStatus())
{
case CHROMECAST_MEDIA_LOAD_SENT:
case CHROMECAST_APP_STARTED:
// Generate the close messages.
p_sys->p_intf->msgReceiverClose(p_sys->p_intf->appTransportId);
// ft
case CHROMECAST_AUTHENTICATED:
p_sys->p_intf->msgReceiverClose(DEFAULT_CHOMECAST_RECEIVER);
// Send the just added close messages.
p_sys->p_intf->sendMessages();
// ft
default:
break;
}
Clean(p_stream);
}
/*****************************************************************************
* Close: close the ALSA device
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
struct aout_sys_t * p_sys = p_aout->output.p_sys;
int i_snd_rc;
/* Make sure that the thread will stop once it is waken up */
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
vlc_sem_destroy( &p_sys->wait );
/* */
i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );
if( i_snd_rc > 0 )
{
msg_Err( p_aout, "failed closing ALSA device (%s)",
snd_strerror( i_snd_rc ) );
}
#ifdef ALSA_DEBUG
snd_output_close( p_sys->p_snd_stderr );
#endif
free( p_sys );
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
fingerprinter_thread_t *p_fingerprinter = (fingerprinter_thread_t*) p_this;
fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
vlc_mutex_destroy( &p_sys->condwait.lock );
vlc_cond_destroy( &p_sys->condwait.wait );
for ( int i = 0; i < vlc_array_count( p_sys->incoming.queue ); i++ )
fingerprint_request_Delete( vlc_array_item_at_index( p_sys->incoming.queue, i ) );
vlc_array_destroy( p_sys->incoming.queue );
vlc_mutex_destroy( &p_sys->incoming.lock );
vlc_cond_destroy( &p_sys->incoming_queue_filled );
for ( int i = 0; i < vlc_array_count( p_sys->processing.queue ); i++ )
fingerprint_request_Delete( vlc_array_item_at_index( p_sys->processing.queue, i ) );
vlc_array_destroy( p_sys->processing.queue );
vlc_mutex_destroy( &p_sys->processing.lock );
for ( int i = 0; i < vlc_array_count( p_sys->results.queue ); i++ )
fingerprint_request_Delete( vlc_array_item_at_index( p_sys->results.queue, i ) );
vlc_array_destroy( p_sys->results.queue );
vlc_mutex_destroy( &p_sys->results.lock );
free( p_sys );
}
/**
* Stops and destroys all interfaces
* @param p_libvlc the LibVLC instance
*/
void intf_DestroyAll( libvlc_int_t *p_libvlc )
{
intf_thread_t *p_first;
vlc_mutex_lock( &lock );
p_first = libvlc_priv( p_libvlc )->p_intf;
#ifndef NDEBUG
libvlc_priv( p_libvlc )->p_intf = NULL;
#endif
vlc_mutex_unlock( &lock );
/* Tell the interfaces to die */
for( intf_thread_t *p_intf = p_first; p_intf; p_intf = p_intf->p_next )
vlc_object_kill( p_intf );
/* Cleanup the interfaces */
for( intf_thread_t *p_intf = p_first; p_intf != NULL; )
{
intf_thread_t *p_next = p_intf->p_next;
if( p_intf->pf_run )
{
vlc_cancel( p_intf->thread );
vlc_join( p_intf->thread, NULL );
}
module_unneed( p_intf, p_intf->p_module );
config_ChainDestroy( p_intf->p_cfg );
vlc_object_release( p_intf );
p_intf = p_next;
}
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
var_DelCallback(pl_Get(p_intf), "input-current", ItemChange, p_intf);
if (p_sys->p_input != NULL)
{
var_DelCallback(p_sys->p_input, "intf-event", PlayingChange, p_intf);
vlc_object_release(p_sys->p_input);
}
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
free(p_sys);
}
/**
* Arm or disarm an initialized timer.
* This functions overrides any previous call to itself.
*
* @note A timer can fire later than requested due to system scheduling
* limitations. An interval timer can fail to trigger sometimes, either because
* the system is busy or suspended, or because a previous iteration of the
* timer is still running. See also vlc_timer_getoverrun().
*
* @param timer initialized timer
* @param absolute the timer value origin is the same as mdate() if true,
* the timer value is relative to now if false.
* @param value zero to disarm the timer, otherwise the initial time to wait
* before firing the timer.
* @param interval zero to fire the timer just once, otherwise the timer
* repetition interval.
*/
void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
mtime_t value, mtime_t interval)
{
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
vlc_mutex_lock (&timer->lock);
if (timer->value)
{
vlc_mutex_unlock (&timer->lock);
vlc_cancel (timer->thread);
vlc_join (timer->thread, NULL);
vlc_mutex_lock (&timer->lock);
timer->value = 0;
}
if ((value != 0)
&& (vlc_clone (&timer->thread, vlc_timer_thread, timer,
VLC_THREAD_PRIORITY_INPUT) == 0))
{
timer->value = (absolute ? 0 : mdate ()) + value;
timer->interval = interval;
}
vlc_mutex_unlock (&timer->lock);
vlc_mutex_unlock (&lock);
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = p_sd->p_sys;
int i;
vlc_cancel (p_sys->thread);
vlc_join (p_sys->thread, NULL);
var_DelCallback( p_sd, "podcast-urls", UrlsChange, p_sys );
var_DelCallback( p_sd, "podcast-request", Request, p_sys );
vlc_cond_destroy( &p_sys->wait );
vlc_mutex_destroy( &p_sys->lock );
for( i = 0; i < p_sys->i_input; i++ )
{
input_thread_t *p_input = p_sd->p_sys->pp_input[i];
if( !p_input )
continue;
input_Stop( p_input, true );
vlc_thread_join( p_input );
vlc_object_release( p_input );
p_sd->p_sys->pp_input[i] = NULL;
}
free( p_sd->p_sys->pp_input );
for( i = 0; i < p_sys->i_urls; i++ ) free( p_sys->ppsz_urls[i] );
free( p_sys->ppsz_urls );
for( i = 0; i < p_sys->i_items; i++ ) vlc_gc_decref( p_sys->pp_items[i] );
free( p_sys->pp_items );
free( p_sys->psz_request );
free( p_sys );
}
static void update_thread_cleanup( void *p )
{
vlc_thread_t *th = p;
vlc_cancel( *th );
vlc_join( *th, NULL );
}
void vlc_thread_cancel (vlc_object_t *obj)
{
vlc_object_internals_t *priv = vlc_internals (obj);
if (priv->b_thread)
vlc_cancel (priv->thread_id);
}
/**
* Closes the audio device.
*/
static HRESULT Stop( aout_stream_sys_t *p_sys )
{
vlc_mutex_lock( &p_sys->lock );
p_sys->b_playing = true;
vlc_cond_signal( &p_sys->cond );
vlc_mutex_unlock( &p_sys->lock );
vlc_cancel( p_sys->eraser_thread );
vlc_join( p_sys->eraser_thread, NULL );
vlc_cond_destroy( &p_sys->cond );
vlc_mutex_destroy( &p_sys->lock );
if( p_sys->p_notify != NULL )
{
IDirectSoundNotify_Release(p_sys->p_notify );
p_sys->p_notify = NULL;
}
if( p_sys->p_dsbuffer != NULL )
{
IDirectSoundBuffer_Stop( p_sys->p_dsbuffer );
IDirectSoundBuffer_Release( p_sys->p_dsbuffer );
p_sys->p_dsbuffer = NULL;
}
if( p_sys->p_dsobject != NULL )
{
IDirectSound_Release( p_sys->p_dsobject );
p_sys->p_dsobject = NULL;
}
return DS_OK;
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_playlist_t *playlist = p_sys->playlist;
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
vlc_UrlClean(&p_sys->p_nowp_url);
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
vlc_playlist_Lock(playlist);
vlc_player_RemoveListener(
vlc_playlist_GetPlayer(playlist), p_sys->player_listener);
vlc_playlist_RemoveListener(playlist, p_sys->playlist_listener);
vlc_playlist_Unlock(playlist);
free(p_sys);
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
var_DelCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);
vlc_cancel(p_sys->thread);
vlc_join(p_sys->thread, NULL);
input_thread_t *p_input = pl_CurrentInput(p_intf);
if (p_input)
{
if (p_sys->b_state_cb)
var_DelCallback(p_input, "intf-event", PlayingChange, p_intf);
vlc_object_release(p_input);
}
int i;
for (i = 0; i < p_sys->i_songs; i++)
DeleteSong(&p_sys->p_queue[i]);
vlc_UrlClean(&p_sys->p_submit_url);
#if 0 //NOT USED
free(p_sys->psz_nowp_host);
free(p_sys->psz_nowp_file);
#endif
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
free(p_sys);
}
void vlc_timer_destroy (vlc_timer_t timer)
{
vlc_cancel (timer->thread);
vlc_join (timer->thread, NULL);
vlc_cond_destroy (&timer->reschedule);
vlc_mutex_destroy (&timer->lock);
free (timer);
}
/*****************************************************************************
* Close: cleanup
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
services_discovery_t *p_sd = ( services_discovery_t * )p_this;
free( p_sd->p_sys->psz_name );
vlc_cancel( p_sd->p_sys->thread );
vlc_join( p_sd->p_sys->thread, NULL );
free( p_sd->p_sys );
}
static void Close (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = demux->p_sys;
vlc_cancel (sys->thread);
vlc_join (sys->thread, NULL);
snd_pcm_close (sys->pcm);
}
/*****************************************************************************
* CloseIntf: destroy interface
*****************************************************************************/
static void Close ( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
motion_destroy( p_sys->p_motion );
free( p_sys );
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close(vlc_object_t *p_this)
{
fingerprinter_thread_t *p_fingerprinter = (fingerprinter_thread_t*) p_this;
fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
CleanSys( p_sys );
free( p_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);
}
void Close_LuaIntf( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
lua_close( p_sys->L );
free( p_sys->psz_filename );
free( p_sys );
}
/*****************************************************************************
* Close: destroy interface
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
/* Destroy structure */
lirc_freeconfig( p_sys->config );
lirc_deinit();
free( p_sys );
}
/**
* Releases resources
*/
static void Close (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
services_discovery_sys_t *p_sys = sd->p_sys;
vlc_cancel (p_sys->thread);
vlc_join (p_sys->thread, NULL);
xcb_disconnect (p_sys->conn);
tdestroy (p_sys->apps, DelApp);
if (p_sys->apps_root != NULL)
input_item_Release(p_sys->apps_root);
free (p_sys);
}
/*****************************************************************************
* Close:
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
services_discovery_t *p_sd = (services_discovery_t *)p_this;
services_discovery_sys_t *p_sys = p_sd->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
var_DelCallback( p_sd->p_libvlc, p_sys->psz_var, onNewFileAdded, p_sd );
free( p_sys->psz_dir[1] );
free( p_sys->psz_dir[0] );
free( p_sys );
}
static void Close(vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = demux->p_sys;
vlc_cancel(sys->thread);
vlc_join(sys->thread, NULL);
screenshooter_destroy(sys->screenshooter);
wl_shm_destroy(sys->shm);
wl_output_destroy(sys->output);
wl_display_disconnect(sys->display);
free(sys);
}
/*****************************************************************************
* Close: destroy interface
*****************************************************************************/
void Close(vlc_object_t *object)
{
intf_thread_t *intf = (intf_thread_t*)object;
intf_sys_t *sys = intf->p_sys;
var_DelCallback(sys->playlist, "input-current", PlaylistEvent, intf);
if (sys->input != NULL) {
vlc_cancel(sys->thread);
vlc_join(sys->thread, NULL);
}
net_Close(sys->fd);
free(sys);
}
static void Close (vlc_object_t *obj)
{
intf_thread_t *intf = (intf_thread_t *)obj;
intf_sys_t *p_sys = intf->p_sys;
vlc_cancel (p_sys->thread);
#ifdef __APPLE__
/* In Mac OS X up to 10.5 sigwait (among others) is not a pthread
* cancellation point, so we throw a dummy quit signal to end
* sigwait() in the sigth thread */
pthread_kill (p_sys->thread, SIGQUIT);
# endif
vlc_join (p_sys->thread, NULL);
free (p_sys);
}
/**
* Destroys the X11 window.
*/
static void Close (vout_window_t *wnd)
{
vout_window_sys_t *p_sys = wnd->sys;
xcb_connection_t *conn = p_sys->conn;
if (p_sys->keys)
{
vlc_cancel (p_sys->thread);
vlc_join (p_sys->thread, NULL);
DestroyKeyHandler (p_sys->keys);
}
xcb_disconnect (conn);
free (wnd->display.x11);
free (p_sys);
}
/*****************************************************************************
* Close: close the target
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys = p_access->p_sys;
vlc_cancel( p_sys->thread );
vlc_join( p_sys->thread, NULL );
block_FifoRelease( p_sys->p_fifo );
block_FifoRelease( p_sys->p_empty_blocks );
if( p_sys->p_buffer ) block_Release( p_sys->p_buffer );
net_Close( p_sys->i_handle );
free( p_sys );
}
