msg_Dbg( p_sys->p_input, "Decoder buffering done in %d ms",
(int)(mdate() - i_decoder_buffering_start)/1000 );
+ /* Here is a good place to destroy unused vout with every demuxer */
+ input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+
+ /* */
const mtime_t i_wakeup_delay = 10*1000; /* FIXME CLEANUP thread wake up time*/
const mtime_t i_current_date = p_sys->b_paused ? p_sys->i_pause_date : mdate();
case ES_OUT_SET_ACTIVE:
{
b = (bool) va_arg( args, int );
+ if( b && !p_sys->b_active && p_sys->i_es > 0 )
+ {
+ /* XXX Terminate vout if there are tracks but no video one.
+ * This one is not mandatory but is he earliest place where it
+ * can be done */
+ for( i = 0; i < p_sys->i_es; i++ )
+ {
+ es_out_id_t *p_es = p_sys->es[i];
+ if( p_es->fmt.i_cat == VIDEO_ES )
+ break;
+ }
+ if( i >= p_sys->i_es )
+ input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+ }
p_sys->b_active = b;
return VLC_SUCCESS;
}
assert(0);
}
/* TODO if the lock is made non recursive it should be changed */
- return es_out_Control( out, i_new_query, p_es );
+ int i_ret = es_out_Control( out, i_new_query, p_es );
+
+ /* Clean up vout after user action (in active mode only).
+ * FIXME it does not work well with multiple video windows */
+ if( p_sys->b_active )
+ input_ressource_TerminateVout( p_sys->p_input->p->p_ressource );
+ return i_ret;
}
case ES_OUT_GET_BUFFERING:
static void *RunAndDestroy ( vlc_object_t *p_this );
static input_thread_t * Create ( vlc_object_t *, input_item_t *,
- const char *, bool, sout_instance_t * );
+ const char *, bool, input_ressource_t * );
static int Init ( input_thread_t *p_input );
static void WaitDie ( input_thread_t *p_input );
static void End ( input_thread_t *p_input );
*****************************************************************************/
static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
const char *psz_header, bool b_quick,
- sout_instance_t *p_sout )
+ input_ressource_t *p_ressource )
{
static const char input_name[] = "input";
input_thread_t *p_input = NULL; /* thread descriptor */
p_input->p->slave = NULL;
/* */
- p_input->p->p_ressource = input_ressource_New();
+ if( p_ressource )
+ p_input->p->p_ressource = p_ressource;
+ else
+ p_input->p->p_ressource = input_ressource_New();
input_ressource_SetInput( p_input->p->p_ressource, p_input );
/* Init control buffer */
p_input->i_flags |= OBJECT_FLAGS_QUIET | OBJECT_FLAGS_NOINTERACT;
/* */
- if( p_sout )
- input_ressource_RequestSout( p_input->p->p_ressource, p_sout, NULL );
-
memset( &p_input->p->counters, 0, sizeof( p_input->p->counters ) );
vlc_mutex_init( &p_input->p->counters.counters_lock );
/* */
input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
input_item_t *p_item,
- const char *psz_log, sout_instance_t *p_sout )
+ const char *psz_log, input_ressource_t *p_ressource )
{
input_thread_t *p_input;
- p_input = Create( p_parent, p_item, psz_log, false, p_sout );
+ p_input = Create( p_parent, p_item, psz_log, false, p_ressource );
if( !p_input )
return NULL;
void input_ressource_Delete( input_ressource_t * );
/**
- * This function return the current sout (if any) from the ressource
- * and stop tracking it.
+ * This function deletes the current sout in the ressources.
*
- * You are then responsible of its release.
+ * It can only be called on detached ressources.
*/
-sout_instance_t *input_ressource_ExtractSout( input_ressource_t *p_ressource );
+void input_ressource_TerminateSout( input_ressource_t *p_ressource );
+
+/**
+ * This function deletes the current vout in the ressources.
+ *
+ * It can only be called on detached ressources.
+ */
+void input_ressource_TerminateVout( input_ressource_t *p_ressource );
+
/* input.c */
#define input_CreateThreadExtended(a,b,c,d) __input_CreateThreadExtended(VLC_OBJECT(a),b,c,d)
-input_thread_t *__input_CreateThreadExtended ( vlc_object_t *, input_item_t *, const char *, sout_instance_t * );
+input_thread_t *__input_CreateThreadExtended ( vlc_object_t *, input_item_t *, const char *, input_ressource_t * );
/**
* This function detaches ressources from a dead input.
sout_DeleteInstance( p_ressource->p_sout );
p_ressource->p_sout = NULL;
}
-static sout_instance_t *ExtractSout( input_ressource_t *p_ressource )
-{
- sout_instance_t *p_sout = p_ressource->p_sout;
-
- p_ressource->p_sout = NULL;
-
- return p_sout;
-}
static sout_instance_t *RequestSout( input_ressource_t *p_ressource,
sout_instance_t *p_sout, const char *psz_sout )
{
- assert( p_ressource->p_input );
- assert( !p_sout || ( !p_ressource->p_sout && !psz_sout ) );
-
if( !p_sout && !psz_sout )
{
if( p_ressource->p_sout )
- msg_Dbg( p_ressource->p_input, "destroying useless sout" );
+ msg_Dbg( p_ressource->p_sout, "destroying useless sout" );
DestroySout( p_ressource );
return NULL;
}
+ assert( p_ressource->p_input );
+ assert( !p_sout || ( !p_ressource->p_sout && !psz_sout ) );
+
/* Check the validity of the sout */
if( p_ressource->p_sout &&
strcmp( p_ressource->p_sout->psz_sout, psz_sout ) )
/* Create a new one */
p_ressource->p_sout = sout_NewInstance( p_ressource->p_input, psz_sout );
}
- return ExtractSout( p_ressource );
+
+ p_sout = p_ressource->p_sout;
+ p_ressource->p_sout = NULL;
+
+ return p_sout;
}
else
{
static vout_thread_t *RequestVout( input_ressource_t *p_ressource,
vout_thread_t *p_vout, video_format_t *p_fmt )
{
- assert( p_ressource->p_input );
-
if( !p_vout && !p_fmt )
{
if( p_ressource->p_vout_free )
{
- msg_Err( p_ressource->p_input, "destroying useless vout" );
+ msg_Dbg( p_ressource->p_vout_free, "destroying useless vout" );
vout_CloseAndRelease( p_ressource->p_vout_free );
p_ressource->p_vout_free = NULL;
}
return NULL;
}
+ assert( p_ressource->p_input );
if( p_fmt )
{
/* */
if( !p_vout && p_ressource->p_vout_free )
{
- msg_Err( p_ressource->p_input, "trying to reuse free vout" );
+ msg_Dbg( p_ressource->p_input, "trying to reuse free vout" );
p_vout = p_ressource->p_vout_free;
p_ressource->p_vout_free = NULL;
TAB_REMOVE( p_ressource->i_vout, p_ressource->pp_vout, p_vout );
if( p_ressource->p_vout_free )
{
- msg_Err( p_ressource->p_input, "detroying vout (already one saved)" );
+ msg_Dbg( p_ressource->p_input, "detroying vout (already one saved)" );
vout_CloseAndRelease( p_vout );
}
else
{
- msg_Err( p_ressource->p_input, "saving a free vout" );
+ msg_Dbg( p_ressource->p_input, "saving a free vout" );
p_ressource->p_vout_free = p_vout;
}
return NULL;
if( p_aout )
{
- msg_Err( p_ressource->p_input, "releasing aout" );
+ msg_Dbg( p_ressource->p_input, "releasing aout" );
vlc_object_release( p_aout );
return NULL;
}
{
if( !p_ressource->p_aout )
{
- msg_Err( p_ressource->p_input, "creating aout" );
+ msg_Dbg( p_ressource->p_input, "creating aout" );
p_ressource->p_aout = aout_New( p_ressource->p_input );
}
else
{
- msg_Err( p_ressource->p_input, "reusing aout" );
- vlc_object_attach( p_ressource->p_aout, p_ressource->p_input );
+ msg_Dbg( p_ressource->p_input, "reusing aout" );
}
-
if( !p_ressource->p_aout )
return NULL;
+ vlc_object_detach( p_ressource->p_aout );
+ vlc_object_attach( p_ressource->p_aout, p_ressource->p_input );
vlc_object_hold( p_ressource->p_aout );
return p_ressource->p_aout;
}
return p_ret;
}
+void input_ressource_TerminateVout( input_ressource_t *p_ressource )
+{
+ input_ressource_RequestVout( p_ressource, NULL, NULL );
+}
/* */
aout_instance_t *input_ressource_RequestAout( input_ressource_t *p_ressource, aout_instance_t *p_aout )
return p_ret;
}
-sout_instance_t *input_ressource_ExtractSout( input_ressource_t *p_ressource )
+void input_ressource_TerminateSout( input_ressource_t *p_ressource )
{
- vlc_mutex_lock( &p_ressource->lock );
- sout_instance_t *p_ret = ExtractSout( p_ressource );
- vlc_mutex_unlock( &p_ressource->lock );
-
- return p_ret;
+ input_ressource_RequestSout( p_ressource, NULL, NULL );
}
-
p_instance->i_index = 0;
p_instance->b_sout_keep = false;
p_instance->p_input = NULL;
- p_instance->p_sout = NULL;
+ p_instance->p_input_ressource = NULL;
return p_instance;
}
vlc_object_release( p_input );
}
- if( p_instance->p_sout )
- sout_DeleteInstance( p_instance->p_sout );
+ if( p_instance->p_input_ressource )
+ input_ressource_Delete( p_instance->p_input_ressource );
vlc_gc_decref( p_instance->p_item );
free( p_instance->psz_name );
input_thread_t *p_input = p_instance->p_input;
if( p_input )
{
- input_ressource_t *p_ressource;
-
if( p_instance->i_index == i_input_index &&
!p_input->b_eof && !p_input->b_error )
{
input_StopThread( p_input );
vlc_thread_join( p_input );
- p_ressource = input_DetachRessource( p_input );
+ p_instance->p_input_ressource = input_DetachRessource( p_input );
vlc_object_release( p_input );
- if( p_instance->b_sout_keep )
- p_instance->p_sout = input_ressource_ExtractSout( p_ressource );
- input_ressource_Delete( p_ressource );
+ if( !p_instance->b_sout_keep )
+ input_ressource_TerminateSout( p_instance->p_input_ressource );
+ input_ressource_TerminateVout( p_instance->p_input_ressource );
}
/* Start new one */
if( asprintf( &psz_log, _("Media: %s"), p_media->cfg.psz_name ) != -1 )
{
- p_instance->p_input = input_CreateThreadExtended( p_vlm, p_instance->p_item, psz_log, p_instance->p_sout );
+ p_instance->p_input = input_CreateThreadExtended( p_vlm, p_instance->p_item,
+ psz_log, p_instance->p_input_ressource );
+ p_instance->p_input_ressource = NULL;
+
if( !p_instance->p_input )
{
TAB_REMOVE( p_media->i_instance, p_media->instance, p_instance );
vlm_MediaInstanceDelete( p_instance );
}
- else
- {
- p_instance->p_sout = NULL;
- }
free( psz_log );
}
bool b_sout_keep;
- input_item_t *p_item;
- input_thread_t *p_input;
- sout_instance_t *p_sout;
+ input_item_t *p_item;
+ input_thread_t *p_input;
+ input_ressource_t *p_input_ressource;
} vlm_media_instance_sys_t;
playlist_private_t *p_sys = pl_priv(p_playlist);
assert( !p_sys->p_input );
- assert( !p_sys->p_sout );
+ assert( !p_sys->p_input_ressource );
assert( !p_sys->p_preparser );
assert( !p_sys->p_fetcher );
playlist_t public_data;
playlist_preparser_t *p_preparser; /**< Preparser data */
playlist_fetcher_t *p_fetcher; /**< Meta and art fetcher data */
- sout_instance_t *p_sout; /**< Kept sout instance */
playlist_item_array_t items_to_delete; /**< Array of items and nodes to
delete... At the very end. This sucks. */
int i_sds; /**< Number of service discovery modules */
input_thread_t * p_input; /**< the input thread associated
* with the current item */
+ input_ressource_t * p_input_ressource; /**< input ressources */
struct {
/* Current status. These fields are readonly, only the playlist
* main loop can touch it*/
if( p_fetcher )
playlist_fetcher_Delete( p_fetcher );
- /* close the remaining sout-keep */
- if( p_sys->p_sout )
- sout_DeleteInstance( p_sys->p_sout );
- p_sys->p_sout = NULL;
+ /* release input ressources */
+ if( p_sys->p_input_ressource )
+ input_ressource_Delete( p_sys->p_input_ressource );
+ p_sys->p_input_ressource = NULL;
/* */
playlist_MLDump( p_playlist );
assert( p_sys->p_input == NULL );
input_thread_t *p_input_thread =
- input_CreateThreadExtended( p_playlist, p_input, NULL, p_sys->p_sout );
+ input_CreateThreadExtended( p_playlist, p_input, NULL, p_sys->p_input_ressource );
if( p_input_thread )
{
var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist );
}
- p_sys->p_sout = NULL;
+ p_sys->p_input_ressource = NULL;
char *psz_uri = input_item_GetURI( p_item->p_input );
if( psz_uri && ( !strncmp( psz_uri, "directory:", 10 ) ||
{
PL_DEBUG( "dead input" );
- assert( p_sys->p_sout == NULL );
+ assert( p_sys->p_input_ressource == NULL );
- input_ressource_t *p_ressource = input_DetachRessource( p_input );
-
- if( var_CreateGetBool( p_input, "sout-keep" ) )
- p_sys->p_sout = input_ressource_ExtractSout( p_ressource );
- input_ressource_Delete( p_ressource );
+ p_sys->p_input_ressource = input_DetachRessource( p_input );
+ if( !var_CreateGetBool( p_input, "sout-keep" ) )
+ input_ressource_TerminateSout( p_sys->p_input_ressource );
/* The DelCallback must be issued without playlist lock
* It is not a problem as we return VLC_EGENERIC */
{
p_sys->status.i_status = PLAYLIST_STOPPED;
+ if( p_sys->p_input_ressource )
+ input_ressource_TerminateVout( p_sys->p_input_ressource );
+
if( vlc_object_alive( p_playlist ) )
vlc_object_wait( p_playlist );
return;
projects / vlc / commitdiff