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 ); }