/*****************************************************************************
* 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 );
}
/**************************************************************************
* 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));
}
int vlc_mwait_i11e(mtime_t deadline)
{
vlc_interrupt_t *ctx = vlc_threadvar_get(vlc_interrupt_var);
if (ctx == NULL)
return mwait(deadline), 0;
vlc_cond_t wait;
vlc_cond_init(&wait);
int ret = vlc_interrupt_prepare(ctx, vlc_mwait_i11e_wake, &wait);
if (ret)
{
vlc_cond_destroy(&wait);
vlc_testcancel();
return ret;
}
vlc_mutex_lock(&ctx->lock);
vlc_cleanup_push(vlc_mwait_i11e_cleanup, ctx);
while (!ctx->interrupted
&& vlc_cond_timedwait(&wait, &ctx->lock, deadline) == 0);
vlc_cleanup_pop();
vlc_mutex_unlock(&ctx->lock);
ret = vlc_interrupt_finish(ctx);
vlc_cond_destroy(&wait);
return ret;
}
//---------------------------------------------------------------------------
// Close: destroy interface
//---------------------------------------------------------------------------
static void Close( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
msg_Dbg( p_intf, "closing skins2 module" );
vlc_mutex_lock( &skin_load.mutex );
skin_load.intf = NULL;
vlc_mutex_unlock( &skin_load.mutex);
vlc_join( p_intf->p_sys->thread, NULL );
vlc_mutex_destroy( &p_intf->p_sys->init_lock );
vlc_cond_destroy( &p_intf->p_sys->init_wait );
if( p_intf->p_sys->p_playlist )
pl_Release( p_this );
// Unsubscribe from messages bank
#if 0
msg_Unsubscribe( p_intf, p_intf->p_sys->p_sub );
#endif
vlc_cond_destroy( &p_intf->p_sys->vout_wait );
vlc_mutex_destroy( &p_intf->p_sys->vout_lock );
// Destroy structure
free( p_intf->p_sys );
}
void background_worker_Delete( struct background_worker* worker )
{
BackgroundWorkerCancel( worker, NULL );
vlc_array_clear( &worker->tail.data );
vlc_mutex_destroy( &worker->lock );
vlc_cond_destroy( &worker->head.wait );
vlc_cond_destroy( &worker->head.worker_wait );
vlc_cond_destroy( &worker->tail.wait );
free( worker );
}
static void Close( vlc_object_t *p_this )
{
stream_t *s = (stream_t*)p_this;
stream_sys_t *p_sys = s->p_sys;
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 EventThreadDestroy( event_thread_t *p_event )
{
free( p_event->psz_title );
vlc_cond_destroy( &p_event->wait );
vlc_mutex_destroy( &p_event->lock );
free( p_event );
}
BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
{
(void) hinstDll;
(void) lpvReserved;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
#if (_WIN32_WINNT < 0x0601)
if (!QueryPerformanceFrequency (&freq))
return FALSE;
#endif
vlc_mutex_init (&super_mutex);
vlc_cond_init (&super_variable);
vlc_threadvar_create (&thread_key, NULL);
vlc_rwlock_init (&config_lock);
vlc_rwlock_init (&msg_lock);
vlc_CPU_init ();
break;
case DLL_PROCESS_DETACH:
vlc_rwlock_destroy (&msg_lock);
vlc_rwlock_destroy (&config_lock);
vlc_threadvar_delete (&thread_key);
vlc_cond_destroy (&super_variable);
vlc_mutex_destroy (&super_mutex);
break;
}
return TRUE;
}
void transcode_video_close( sout_stream_t *p_stream,
sout_stream_id_t *id )
{
if( p_stream->p_sys->i_threads >= 1 )
{
vlc_mutex_lock( &p_stream->p_sys->lock_out );
vlc_object_kill( p_stream->p_sys );
vlc_cond_signal( &p_stream->p_sys->cond );
vlc_mutex_unlock( &p_stream->p_sys->lock_out );
vlc_thread_join( p_stream->p_sys );
vlc_mutex_destroy( &p_stream->p_sys->lock_out );
vlc_cond_destroy( &p_stream->p_sys->cond );
}
video_timer_close( id->p_encoder );
/* Close decoder */
if( id->p_decoder->p_module )
module_unneed( id->p_decoder, id->p_decoder->p_module );
if( id->p_decoder->p_description )
vlc_meta_Delete( id->p_decoder->p_description );
free( id->p_decoder->p_owner );
/* Close encoder */
if( id->p_encoder->p_module )
module_unneed( id->p_encoder, id->p_encoder->p_module );
/* Close filters */
if( id->p_f_chain )
filter_chain_Delete( id->p_f_chain );
if( id->p_uf_chain )
filter_chain_Delete( id->p_uf_chain );
}
/*****************************************************************************
* Open: initialize and create stuff
*****************************************************************************/
static int Open(vlc_object_t *p_this)
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
intf_sys_t *p_sys = calloc(1, sizeof(intf_sys_t));
if (!p_sys)
return VLC_ENOMEM;
p_intf->p_sys = p_sys;
vlc_mutex_init(&p_sys->lock);
vlc_cond_init(&p_sys->wait);
if (vlc_clone(&p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW))
{
vlc_cond_destroy(&p_sys->wait);
vlc_mutex_destroy(&p_sys->lock);
free(p_sys);
return VLC_ENOMEM;
}
var_AddCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);
return VLC_SUCCESS;
}
/**
* 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);
}
int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
{
struct vlc_timer *timer = malloc (sizeof (*timer));
if (unlikely(timer == NULL))
return ENOMEM;
vlc_mutex_init (&timer->lock);
vlc_cond_init (&timer->reschedule);
assert (func);
timer->func = func;
timer->data = data;
timer->value = 0;
timer->interval = 0;
atomic_init(&timer->overruns, 0);
if (vlc_clone (&timer->thread, vlc_timer_thread, timer,
VLC_THREAD_PRIORITY_INPUT))
{
vlc_cond_destroy (&timer->reschedule);
vlc_mutex_destroy (&timer->lock);
free (timer);
return ENOMEM;
}
*id = timer;
return 0;
}
/**
****************************************************************************
* 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.
*
* This function must be called with cancellation disabled (currently).
*****************************************************************************/
static void vlc_object_destroy( vlc_object_t *p_this )
{
vlc_object_internals_t *p_priv = vlc_internals( p_this );
/* Send a kill to the object's thread if applicable */
vlc_object_kill( p_this );
/* Call the custom "subclass" destructor */
if( p_priv->pf_destructor )
p_priv->pf_destructor( p_this );
/* Any thread must have been cleaned up at this point. */
assert( !p_priv->b_thread );
/* Destroy the associated variables. */
var_DestroyAll( p_this );
vlc_cond_destroy( &p_priv->var_wait );
vlc_mutex_destroy( &p_priv->var_lock );
free( p_this->psz_header );
free( p_priv->psz_name );
vlc_spin_destroy( &p_priv->ref_spin );
if( p_priv->pipes[1] != -1 && p_priv->pipes[1] != p_priv->pipes[0] )
close( p_priv->pipes[1] );
if( p_priv->pipes[0] != -1 )
close( p_priv->pipes[0] );
if( VLC_OBJECT(p_this->p_libvlc) == p_this )
vlc_mutex_destroy (&(libvlc_priv ((libvlc_int_t *)p_this)->structure_lock));
free( p_priv );
}
/**
* @brief Directory Monitoring thread loop
*/
void *RunMonitoringThread( void *p_this )
{
monitoring_thread_t *p_mon = (monitoring_thread_t*) p_this;
vlc_cond_init( &p_mon->wait );
vlc_mutex_init( &p_mon->lock );
var_Create( p_mon, "ml-recursive-scan", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
while( vlc_object_alive( p_mon ) )
{
vlc_mutex_lock( &p_mon->lock );
/* Update */
UpdateLibrary( p_mon );
/* We wait MONITORING_DELAY seconds or wait that the media library
signals us to do something */
vlc_cond_timedwait( &p_mon->wait, &p_mon->lock,
mdate() + 1000000*MONITORING_DELAY );
vlc_mutex_unlock( &p_mon->lock );
}
vlc_cond_destroy( &p_mon->wait );
vlc_mutex_destroy( &p_mon->lock );
return NULL;
}
/*****************************************************************************
* Close: destroy interface stuff
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
playlist_t *p_playlist = pl_Get( p_this );
input_thread_t *p_input;
intf_thread_t *p_intf = ( intf_thread_t* ) p_this;
intf_sys_t *p_sys = p_intf->p_sys;
var_DelCallback( p_playlist, "item-current", ItemChange, p_intf );
p_input = playlist_CurrentInput( p_playlist );
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] );
free( p_sys->psz_submit_host );
free( p_sys->psz_submit_file );
#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 );
}
/*****************************************************************************
* 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 );
}
struct vlc_h2_output *vlc_h2_output_create(struct vlc_tls *tls, bool client)
{
struct vlc_h2_output *out = malloc(sizeof (*out));
if (unlikely(out == NULL))
return NULL;
out->tls = tls;
out->prio.first = NULL;
out->prio.last = &out->prio.first;
out->queue.first = NULL;
out->queue.last = &out->queue.first;
out->size = 0;
out->failed = false;
out->closing = false;
vlc_mutex_init(&out->lock);
vlc_cond_init(&out->wait);
void *(*cb)(void *) = client ? vlc_h2_client_output_thread
: vlc_h2_output_thread;
if (vlc_clone(&out->thread, cb, out, VLC_THREAD_PRIORITY_INPUT))
{
vlc_cond_destroy(&out->wait);
vlc_mutex_destroy(&out->lock);
free(out);
out = NULL;
}
return out;
}
/*****************************************************************************
* 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);
}
unsigned long _System _DLL_InitTerm(unsigned long hmod, unsigned long flag)
{
VLC_UNUSED (hmod);
switch (flag)
{
case 0 : /* Initialization */
if(_CRT_init() == -1)
return 0;
vlc_mutex_init (&super_mutex);
vlc_cond_init (&super_variable);
vlc_threadvar_create (&thread_key, NULL);
vlc_rwlock_init (&config_lock);
vlc_rwlock_init (&msg_lock);
vlc_CPU_init ();
return 1;
case 1 : /* Termination */
vlc_rwlock_destroy (&msg_lock);
vlc_rwlock_destroy (&config_lock);
vlc_threadvar_delete (&thread_key);
vlc_cond_destroy (&super_variable);
vlc_mutex_destroy (&super_mutex);
_CRT_term();
return 1;
}
return 0; /* Failed */
}
/*****************************************************************************
* 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 );
}
/*****************************************************************************
* Close: close the plugin
*****************************************************************************/
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;
/* Stop Goom Thread */
vlc_mutex_lock( &p_sys->p_thread->lock );
p_sys->p_thread->b_exit = true;
vlc_cond_signal( &p_sys->p_thread->wait );
vlc_mutex_unlock( &p_sys->p_thread->lock );
vlc_join( p_sys->p_thread->thread, NULL );
/* Free data */
aout_filter_RequestVout( p_filter, p_sys->p_thread->p_vout, NULL );
vlc_mutex_destroy( &p_sys->p_thread->lock );
vlc_cond_destroy( &p_sys->p_thread->wait );
while( p_sys->p_thread->i_blocks-- )
{
block_Release( p_sys->p_thread->pp_blocks[p_sys->p_thread->i_blocks] );
}
free( p_sys->p_thread );
free( p_sys );
}
/*****************************************************************************
* CloseEncoder: ffmpeg encoder destruction
*****************************************************************************/
void E_(CloseEncoder)( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys = p_enc->p_sys;
#if LIBAVCODEC_BUILD >= 4702
if ( p_sys->b_inited && p_enc->i_threads >= 1 )
{
int i;
struct thread_context_t ** pp_contexts =
(struct thread_context_t **)p_sys->p_context->thread_opaque;
for ( i = 0; i < p_enc->i_threads; i++ )
{
pp_contexts[i]->b_die = 1;
vlc_cond_signal( &pp_contexts[i]->cond );
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] );
}
free( pp_contexts );
}
#endif
avcodec_close( p_sys->p_context );
av_free( p_sys->p_context );
if( p_sys->p_buffer ) free( p_sys->p_buffer );
if( p_sys->p_buffer_out ) free( p_sys->p_buffer_out );
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;
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);
}
/**************************************************************************
* Delete a media descriptor object
**************************************************************************/
void libvlc_media_release( libvlc_media_t *p_md )
{
if (!p_md)
return;
p_md->i_refcount--;
if( p_md->i_refcount > 0 )
return;
if( p_md->p_subitems )
libvlc_media_list_release( p_md->p_subitems );
uninstall_input_item_observer( p_md );
vlc_gc_decref( p_md->p_input_item );
vlc_cond_destroy( &p_md->parsed_cond );
vlc_mutex_destroy( &p_md->parsed_lock );
/* Construct the event */
libvlc_event_t event;
event.type = libvlc_MediaFreed;
event.u.media_freed.md = p_md;
/* Send the event */
libvlc_event_send( p_md->p_event_manager, &event );
libvlc_event_manager_release( p_md->p_event_manager );
free( p_md );
}
void playlist_preparser_Delete( playlist_preparser_t *p_preparser )
{
vlc_mutex_lock( &p_preparser->lock );
/* Remove pending item to speed up preparser thread exit */
while( p_preparser->i_waiting > 0 )
{
preparser_entry_t *p_entry = p_preparser->pp_waiting[0];
vlc_gc_decref( p_entry->p_item );
free( p_entry );
REMOVE_ELEM( p_preparser->pp_waiting, p_preparser->i_waiting, 0 );
}
vlc_sem_post( &p_preparser->item_done );
while( p_preparser->b_live )
vlc_cond_wait( &p_preparser->wait, &p_preparser->lock );
vlc_mutex_unlock( &p_preparser->lock );
/* Destroy the item preparser */
vlc_sem_destroy( &p_preparser->item_done );
vlc_cond_destroy( &p_preparser->wait );
vlc_mutex_destroy( &p_preparser->lock );
if( p_preparser->p_fetcher != NULL )
playlist_fetcher_Delete( p_preparser->p_fetcher );
free( p_preparser );
}
/*****************************************************************************
* HTTPClose: Stop the internal HTTP server
*****************************************************************************/
void E_(HTTPClose)( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
if ( p_sys->p_httpd_host != NULL )
{
if ( p_sys->p_httpd_file != NULL )
{
/* Unlock the thread if it is stuck in HttpCallback */
vlc_mutex_lock( &p_sys->httpd_mutex );
if ( p_sys->b_request_frontend_info == VLC_TRUE )
{
p_sys->b_request_frontend_info = VLC_FALSE;
p_sys->psz_frontend_info = strdup("");
}
if ( p_sys->b_request_mmi_info == VLC_TRUE )
{
p_sys->b_request_mmi_info = VLC_FALSE;
p_sys->psz_mmi_info = strdup("");
}
vlc_cond_signal( &p_sys->httpd_cond );
vlc_mutex_unlock( &p_sys->httpd_mutex );
httpd_FileDelete( p_sys->p_httpd_file->p_file );
httpd_RedirectDelete( p_sys->p_httpd_redir );
}
httpd_HostDelete( p_sys->p_httpd_host );
}
vlc_mutex_destroy( &p_sys->httpd_mutex );
vlc_cond_destroy( &p_sys->httpd_cond );
}
static void ReleaseDLSys(vlc_object_t *obj)
{
vlc_object_t *libvlc = VLC_OBJECT(obj->p_libvlc);
vlc_mutex_lock(&sys_lock);
struct decklink_sys_t *sys = (struct decklink_sys_t*)var_GetAddress(libvlc, "decklink-sys");
if (--sys->users == 0) {
msg_Dbg(obj, "Destroying decklink data");
vlc_mutex_destroy(&sys->lock);
vlc_cond_destroy(&sys->cond);
if (sys->p_output) {
sys->p_output->StopScheduledPlayback(0, NULL, 0);
sys->p_output->DisableVideoOutput();
sys->p_output->DisableAudioOutput();
sys->p_output->Release();
}
free(sys);
var_Destroy(libvlc, "decklink-sys");
}
vlc_mutex_unlock(&sys_lock);
}
//BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
BOOL WINAPI _CRT_INIT (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved) // sunqueen modify
{
(void) hinstDll;
(void) lpvReserved;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
InitializeCriticalSection (&clock_lock);
vlc_mutex_init (&super_mutex);
vlc_cond_init (&super_variable);
vlc_threadvar_create (&thread_key, NULL);
vlc_rwlock_init (&config_lock);
vlc_CPU_init ();
break;
case DLL_PROCESS_DETACH:
vlc_rwlock_destroy (&config_lock);
vlc_threadvar_delete (&thread_key);
vlc_cond_destroy (&super_variable);
vlc_mutex_destroy (&super_mutex);
DeleteCriticalSection (&clock_lock);
break;
}
return TRUE;
}
//---------------------------------------------------------------------------
// Close: destroy interface
//---------------------------------------------------------------------------
static void Close( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
msg_Dbg( p_intf, "closing skins2 module" );
/* Terminate input to ensure that our window provider is released. */
playlist_Deactivate( p_intf->p_sys->p_playlist );
vlc_mutex_lock( &skin_load.mutex );
skin_load.intf = NULL;
vlc_mutex_unlock( &skin_load.mutex);
AsyncQueue *pQueue = p_intf->p_sys->p_queue;
if( pQueue )
{
CmdGeneric *pCmd = new CmdExitLoop( p_intf );
if( pCmd )
pQueue->push( CmdGenericPtr( pCmd ) );
}
else
{
msg_Err( p_intf, "thread found already stopped (weird!)" );
}
vlc_join( p_intf->p_sys->thread, NULL );
vlc_mutex_destroy( &p_intf->p_sys->init_lock );
vlc_cond_destroy( &p_intf->p_sys->init_wait );
// Destroy structure
free( p_intf->p_sys );
}