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