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 ); }
static int transcode_audio_initialize_filters( sout_stream_t *p_stream, sout_stream_id_t *id, sout_stream_sys_t *p_sys, audio_sample_format_t *fmt_last ) { /* Load user specified audio filters */ /* XXX: These variable names come kinda out of nowhere... */ var_Create( p_stream, "audio-time-stretch", VLC_VAR_BOOL ); var_Create( p_stream, "audio-filter", VLC_VAR_STRING ); if( p_sys->psz_af ) var_SetString( p_stream, "audio-filter", p_sys->psz_af ); id->p_af_chain = aout_FiltersNew( p_stream, fmt_last, &id->p_encoder->fmt_in.audio, NULL ); var_Destroy( p_stream, "audio-filter" ); var_Destroy( p_stream, "audio-time-stretch" ); if( id->p_af_chain == NULL ) { msg_Err( p_stream, "Unable to initialize audio filters" ); module_unneed( id->p_encoder, id->p_encoder->p_module ); id->p_encoder->p_module = NULL; module_unneed( id->p_decoder, id->p_decoder->p_module ); id->p_decoder->p_module = NULL; return VLC_EGENERIC; } p_sys->fmt_audio.i_rate = fmt_last->i_rate; p_sys->fmt_audio.i_physical_channels = fmt_last->i_physical_channels; return VLC_SUCCESS; }
void vlc_inhibit_Destroy (vlc_inhibit_t *ih) { assert (ih != NULL); module_unneed (ih, ((inhibit_t *)ih)->module); vlc_object_release (ih); }
int filter_ConfigureBlend( filter_t *p_blend, int i_dst_width, int i_dst_height, const video_format_t *p_src ) { /* */ if( p_blend->p_module && p_blend->fmt_in.video.i_chroma != p_src->i_chroma ) { /* The chroma is not the same, we need to reload the blend module */ module_unneed( p_blend, p_blend->p_module ); p_blend->p_module = NULL; } /* */ p_blend->fmt_in.i_codec = p_src->i_chroma; p_blend->fmt_in.video = *p_src; /* */ p_blend->fmt_out.video.i_width = p_blend->fmt_out.video.i_visible_width = i_dst_width; p_blend->fmt_out.video.i_height = p_blend->fmt_out.video.i_visible_height = i_dst_height; /* */ if( !p_blend->p_module ) p_blend->p_module = module_need( p_blend, "video blending", NULL, false ); if( !p_blend->p_module ) return VLC_EGENERIC; return VLC_SUCCESS; }
/* * OSD menu */ int transcode_osd_new( sout_stream_t *p_stream, sout_stream_id_sys_t *id ) { sout_stream_sys_t *p_sys = p_stream->p_sys; id->p_decoder->fmt_in.i_cat = SPU_ES; id->p_encoder->fmt_out.psz_language = strdup( "osd" ); if( p_sys->i_osdcodec != 0 || p_sys->psz_osdenc ) { msg_Dbg( p_stream, "creating osdmenu transcoding from fcc=`%4.4s' " "to fcc=`%4.4s'", (char*)&id->p_encoder->fmt_out.i_codec, (char*)&p_sys->i_osdcodec ); /* Complete destination format */ id->p_encoder->fmt_out.i_codec = p_sys->i_osdcodec; /* Open encoder */ es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat, VLC_CODEC_YUVA ); id->p_encoder->fmt_in.psz_language = strdup( "osd" ); id->p_encoder->p_cfg = p_sys->p_osd_cfg; id->p_encoder->p_module = module_need( id->p_encoder, "encoder", p_sys->psz_osdenc, true ); if( !id->p_encoder->p_module ) { msg_Err( p_stream, "cannot find spu encoder (%s)", p_sys->psz_osdenc ); goto error; } /* open output stream */ id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_encoder->fmt_out ); id->b_transcode = true; if( !id->id ) goto error; } else { msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')", (char*)&id->p_decoder->fmt_out.i_codec ); id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_decoder->fmt_out ); id->b_transcode = false; if( !id->id ) goto error; } if( !p_sys->p_spu ) p_sys->p_spu = spu_Create( p_stream ); return VLC_SUCCESS; error: msg_Err( p_stream, "starting osd encoding thread failed" ); if( id->p_encoder->p_module ) module_unneed( id->p_encoder, id->p_encoder->p_module ); p_sys->b_osd = false; return VLC_EGENERIC; }
void vlc_vk_Release(vlc_vk_t *vk) { if (!vlc_atomic_rc_dec(&vk->ref_count)) return; module_unneed(vk, vk->module); vlc_object_delete(vk); }
int input_item_WriteMeta( vlc_object_t *obj, input_item_t *p_item ) { meta_export_t *p_export = (meta_export_t *) vlc_custom_create( obj, sizeof( *p_export ), "meta writer" ); // sunqueen modify if( p_export == NULL ) return VLC_ENOMEM; p_export->p_item = p_item; int type; vlc_mutex_lock( &p_item->lock ); type = p_item->i_type; vlc_mutex_unlock( &p_item->lock ); if( type != ITEM_TYPE_FILE ) goto error; char *psz_uri = input_item_GetURI( p_item ); p_export->psz_file = make_path( psz_uri ); if( p_export->psz_file == NULL ) msg_Err( p_export, "cannot write meta to remote media %s", psz_uri ); free( psz_uri ); if( p_export->psz_file == NULL ) goto error; module_t *p_mod = module_need( p_export, "meta writer", NULL, false ); if( p_mod ) module_unneed( p_export, p_mod ); vlc_object_release( p_export ); return VLC_SUCCESS; error: vlc_object_release( p_export ); return VLC_EGENERIC; }
static int Install( addons_storage_t *p_storage, addon_entry_t *p_entry ) { vlc_object_t *p_this = VLC_OBJECT( p_storage ); int i_ret = VLC_EGENERIC; if ( ! p_entry->psz_source_module ) return i_ret; /* Query origin module for download path */ addons_finder_t *p_finder = vlc_object_create( p_this, sizeof( addons_finder_t ) ); if( !p_finder ) return VLC_ENOMEM; module_t *p_module = module_need( p_finder, "addons finder", p_entry->psz_source_module, true ); if( p_module ) { if ( p_finder->pf_retrieve( p_finder, p_entry ) == VLC_SUCCESS ) { /* Do things while retrieved data is here */ vlc_mutex_lock( &p_entry->lock ); i_ret = InstallAllFiles( p_storage, p_entry ); vlc_mutex_unlock( &p_entry->lock ); /* !Do things while retrieved data is here */ } module_unneed( p_finder, p_module ); } vlc_object_release( p_finder ); return i_ret; }
/** * 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; } }
static void vlc_vidsplit_Close(vout_display_t *vd) { vout_display_sys_t *sys = vd->sys; int n = sys->splitter.i_output; for (int i = 0; i < n; i++) { struct vlc_vidsplit_part *part = &sys->parts[i]; vout_display_t *display; vlc_sem_wait(&part->lock); display = part->display; part->display = NULL; vlc_sem_post(&part->lock); if (display != NULL) vout_display_Delete(display); vout_window_Disable(part->window); vout_window_Delete(part->window); vlc_sem_destroy(&part->lock); } module_unneed(&sys->splitter, sys->splitter.p_module); video_format_Clean(&sys->splitter.fmt); vlc_mutex_destroy(&sys->lock); vlc_object_release(&sys->splitter); }
static void StreamDelete( stream_t *s ) { module_unneed( s, s->p_module ); if( s->p_source ) vlc_stream_Delete( s->p_source ); }
void filter_DeleteBlend( filter_t *p_blend ) { if( p_blend->p_module ) module_unneed( p_blend, p_blend->p_module ); vlc_object_release( p_blend ); }
/***************************************************************************** * CloseVideo: destroy Sys video thread output method ***************************************************************************** * Terminate an output method created by Open *****************************************************************************/ static void Close ( vlc_object_t *p_this ) { vout_thread_t * p_vout = (vout_thread_t *)p_this; msg_Dbg( p_vout, "close" ); if( p_vout->p_sys->p_event ) { vlc_object_detach( p_vout->p_sys->p_event ); /* Kill RunQtThread */ vlc_object_kill( p_vout->p_sys->p_event ); CloseDisplay(p_vout); vlc_thread_join( p_vout->p_sys->p_event ); vlc_object_release( p_vout->p_sys->p_event ); } #ifdef NEED_QTE_MAIN msg_Dbg( p_vout, "releasing gui-helper" ); module_unneed( p_vout, p_vout->p_sys->p_qte_main ); #endif if( p_vout->p_sys ) { free( p_vout->p_sys ); p_vout->p_sys = NULL; } }
/** * Stops and destroys all interfaces, then the playlist. * @warning FIXME * @param libvlc the LibVLC instance */ void intf_DestroyAll(libvlc_int_t *libvlc) { playlist_t *playlist; vlc_mutex_lock(&lock); playlist = libvlc_priv(libvlc)->playlist; if (playlist != NULL) { intf_thread_t *intf, **pp = &(pl_priv(playlist)->interface); while ((intf = *pp) != NULL) { *pp = intf->p_next; vlc_mutex_unlock(&lock); module_unneed(intf, intf->p_module); config_ChainDestroy(intf->p_cfg); var_DelCallback(intf, "intf-add", AddIntfCallback, playlist); vlc_object_release(intf); vlc_mutex_lock(&lock); } libvlc_priv(libvlc)->playlist = NULL; } vlc_mutex_unlock(&lock); if (playlist != NULL) playlist_Destroy(playlist); }
/** * Releases data allocated with tls_ServerCreate. * @param srv TLS server object to be destroyed, or NULL */ void tls_ServerDelete (tls_server_t *srv) { if (srv == NULL) return; module_unneed (srv, srv->p_module); vlc_object_release (srv); }
void video_splitter_Delete( video_splitter_t *p_splitter ) { if( p_splitter->p_module ) module_unneed( p_splitter, p_splitter->p_module ); video_format_Clean( &p_splitter->fmt ); vlc_object_delete(p_splitter); }
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; module_unneed( &p_sys->volume, p_sys->module ); vlc_object_release( &p_sys->volume ); }
void vlc_keystore_release(vlc_keystore *p_keystore) { assert(p_keystore); module_unneed(p_keystore, p_keystore->p_module); vlc_object_release(p_keystore); }
static void StreamDelete(stream_t *s) { struct vlc_stream_filter_private *priv = vlc_stream_Private(s); module_unneed(s, priv->module); vlc_stream_Delete(s->s); free(s->psz_filepath); }
void vlc_gl_Release(vlc_gl_t *gl) { struct vlc_gl_priv_t *glpriv = (struct vlc_gl_priv_t *)gl; if (atomic_fetch_sub(&glpriv->ref_count, 1) != 1) return; module_unneed(gl, gl->module); vlc_object_release(gl); }
/** * Releases data allocated with tls_ClientCreate. * It is your job to close the underlying socket. */ void tls_ClientDelete (tls_session_t *cl) { if (cl == NULL) return; module_unneed (cl, cl->p_module); vlc_object_release (cl); }
/** * Releases data allocated with vlc_tls_ServerCreate(). * @param srv TLS server object to be destroyed, or NULL */ void vlc_tls_ServerDelete (vlc_tls_creds_t *srv) { if (srv == NULL) return; module_unneed (srv, srv->module); vlc_object_release (srv); }
/** * Destroys a software amplifier. */ void aout_MixerDelete(audio_mixer_t *mixer) { if (mixer == NULL) return; module_unneed(mixer, mixer->module); vlc_object_release(mixer); }
bool transcode_audio_add( sout_stream_t *p_stream, es_format_t *p_fmt, sout_stream_id_t *id ) { sout_stream_sys_t *p_sys = p_stream->p_sys; msg_Dbg( p_stream, "creating audio transcoding from fcc=`%4.4s' to fcc=`%4.4s'", (char*)&p_fmt->i_codec, (char*)&p_sys->i_acodec ); /* Complete destination format */ id->p_encoder->fmt_out.i_codec = p_sys->i_acodec; id->p_encoder->fmt_out.audio.i_rate = p_sys->i_sample_rate > 0 ? p_sys->i_sample_rate : p_fmt->audio.i_rate; id->p_encoder->fmt_out.i_bitrate = p_sys->i_abitrate; id->p_encoder->fmt_out.audio.i_bitspersample = p_fmt->audio.i_bitspersample; id->p_encoder->fmt_out.audio.i_channels = p_sys->i_channels > 0 ? p_sys->i_channels : p_fmt->audio.i_channels; /* Sanity check for audio channels */ id->p_encoder->fmt_out.audio.i_channels = __MIN( id->p_encoder->fmt_out.audio.i_channels, id->p_decoder->fmt_in.audio.i_channels ); id->p_encoder->fmt_out.audio.i_original_channels = id->p_decoder->fmt_in.audio.i_physical_channels; id->p_encoder->fmt_out.audio.i_physical_channels = pi_channels_maps[id->p_encoder->fmt_out.audio.i_channels]; /* Build decoder -> filter -> encoder chain */ if( transcode_audio_new( p_stream, id ) ) { msg_Err( p_stream, "cannot create audio chain" ); return false; } /* Open output stream */ id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_encoder->fmt_out ); id->b_transcode = true; if( !id->id ) { transcode_audio_close( id ); return false; } module_unneed( id->p_encoder, id->p_encoder->p_module ); if( id->p_encoder->fmt_out.p_extra ) { free( id->p_encoder->fmt_out.p_extra ); id->p_encoder->fmt_out.p_extra = NULL; id->p_encoder->fmt_out.i_extra = 0; } id->p_encoder->p_module = NULL; date_Init( &id->interpolated_pts, p_fmt->audio.i_rate, 1 ); return true; }
void vlc_access_Delete(access_t *access) { module_unneed(access, access->p_module); free(access->psz_filepath); free(access->psz_url); free(access->psz_access); vlc_object_release(access); }
static void DeleteFilter( filter_t * p_filter ) { if( p_filter->p_module ) module_unneed( p_filter, p_filter->p_module ); es_format_Clean( &p_filter->fmt_in ); es_format_Clean( &p_filter->fmt_out ); vlc_object_release( p_filter ); }
static void DeleteEncoder( encoder_t * p_enc ) { if( p_enc->p_module ) module_unneed( p_enc, p_enc->p_module ); es_format_Clean( &p_enc->fmt_in ); es_format_Clean( &p_enc->fmt_out ); vlc_object_release( p_enc ); p_enc = NULL; }
static void osd_ParserUnload( osd_menu_t *p_menu ) { if( p_menu->p_image ) image_HandlerDelete( p_menu->p_image ); if( p_menu->p_parser ) module_unneed( p_menu, p_menu->p_parser ); free( p_menu->psz_file ); }
void transcode_spu_close( sout_stream_t *p_stream, sout_stream_id_t *id) { sout_stream_sys_t *p_sys = p_stream->p_sys; /* 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 ); /* Close encoder */ if( id->p_encoder->p_module ) module_unneed( id->p_encoder, id->p_encoder->p_module ); if( p_sys->p_spu ) { spu_Destroy( p_sys->p_spu ); p_sys->p_spu = NULL; } }
/** * Destroys a chain of audio filters. */ static void aout_FiltersPipelineDestroy(filter_t *const *filters, unsigned n) { for( unsigned i = 0; i < n; i++ ) { filter_t *p_filter = filters[i]; module_unneed( p_filter, p_filter->p_module ); vlc_object_release( p_filter ); } }