X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=a8729a4172c60ab0dcfaa00639c56380ac5fa0d5;hb=a03e58ee5370c68c707723ebcccda0782b92f176;hp=09608367d184733f755e38dd8946c22446e6ca94;hpb=9df284851e95e95a365d058ae26456e6168c84bb;p=vlc

diff --git a/src/input/input.c b/src/input/input.c
index 09608367d1..a8729a4172 100644
--- a/src/input/input.c
+++ b/src/input/input.c
@@ -29,13 +29,17 @@
 # include "config.h"
 #endif
 
-#include <vlc/vlc.h>
+#include <vlc_common.h>
 
 #include <ctype.h>
 #include <limits.h>
 #include <assert.h>
 
 #include "input_internal.h"
+#include "es_out.h"
+#include "access.h"
+#include "demux.h"
+#include "stream.h"
 
 #include <vlc_sout.h>
 #include "../stream_output/stream_output.h"
@@ -43,7 +47,7 @@
 #include <vlc_interface.h>
 #include <vlc_url.h>
 #include <vlc_charset.h>
-#include <vlc_playlist.h>
+#include <vlc_strings.h>
 
 #ifdef HAVE_SYS_STAT_H
 #   include <sys/stat.h>
@@ -54,17 +58,17 @@
  *****************************************************************************/
 static void Destructor( input_thread_t * p_input );
 
-static  int Run  ( input_thread_t *p_input );
-static  int RunAndDestroy  ( input_thread_t *p_input );
+static  void* Run            ( vlc_object_t *p_this );
+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 * );
 static  int             Init    ( input_thread_t *p_input );
-static void             Error   ( input_thread_t *p_input );
+static void             WaitDie   ( input_thread_t *p_input );
 static void             End     ( input_thread_t *p_input );
 static void             MainLoop( input_thread_t *p_input );
 
-static inline int ControlPopNoLock( input_thread_t *, int *, vlc_value_t * );
+static inline int ControlPopNoLock( input_thread_t *, int *, vlc_value_t *, mtime_t i_deadline );
 static void       ControlReduce( input_thread_t * );
 static bool Control( input_thread_t *, int, vlc_value_t );
 
@@ -86,15 +90,16 @@ static void SlaveSeek( input_thread_t *p_input );
 
 static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta );
 static void InputUpdateMeta( input_thread_t *p_input, vlc_meta_t *p_meta );
-
-static sout_instance_t *SoutFind( vlc_object_t *p_parent, input_item_t *p_item, bool * );
-static void SoutKeep( sout_instance_t * );
+static char *InputGetExtraFiles( input_thread_t *p_input,
+                                 const char *psz_access, const char *psz_path );
 
 static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_demux );
 static void AccessMeta( input_thread_t * p_input, vlc_meta_t *p_meta );
 static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment,
                               int i_new, input_attachment_t **pp_new );
 
+static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_forced );
+
 /*****************************************************************************
  * This function creates a new input, and returns a pointer
  * to its description. On error, it returns NULL.
@@ -116,9 +121,13 @@ static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_atta
  *  - seekable (if you can seek, it doesn't say if 'bar display' has be shown
  *    or not, for that check position != 0.0)
  *  - can-pause
- * * For intf callback upon changes
+ *  - can-record (if a stream can be recorded while playing)
+ *  - teletext-es to get the index of spu track that is teletext --1 if no teletext)
+ * * For intf callback upon changes:
  *  - intf-change
+ *  - intf-change-vout for when a vout is created or destroyed
  *  - rate-change for when playback rate changes
+ *  - stats-change for when statistics are updated
  * TODO explain when Callback is called
  * TODO complete this list (?)
  *****************************************************************************/
@@ -135,16 +144,16 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     p_input = vlc_custom_create( p_parent, sizeof( *p_input ),
                                  VLC_OBJECT_INPUT, input_name );
     if( p_input == NULL )
-    {
-        msg_Err( p_parent, "out of memory" );
         return NULL;
-    }
 
     /* Construct a nice name for the input timer */
     char psz_timer_name[255];
     char * psz_name = input_item_GetName( p_item );
     snprintf( psz_timer_name, sizeof(psz_timer_name),
               "input launching for '%s'", psz_name );
+
+    msg_Dbg( p_input, "Creating an input for '%s'", psz_name);
+
     free( psz_name );
 
     /* Start a timer to mesure how long it takes
@@ -152,23 +161,30 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     stats_TimerStart( p_input, psz_timer_name,
         STATS_TIMER_INPUT_LAUNCHING );
 
-    MALLOC_NULL( p_input->p, input_thread_private_t );
+    p_input->p = calloc( 1, sizeof( input_thread_private_t ) );
+    if( !p_input->p )
+        return NULL;
 
     /* One "randomly" selected input thread is responsible for computing
      * the global stats. Check if there is already someone doing this */
     if( p_input->p_libvlc->p_stats && !b_quick )
     {
+        libvlc_priv_t *p_private = libvlc_priv( p_input->p_libvlc );
         vlc_mutex_lock( &p_input->p_libvlc->p_stats->lock );
-        if( p_input->p_libvlc->p_stats_computer == NULL )
-        {
-            p_input->p_libvlc->p_stats_computer = p_input;
-        }
+        if( p_private->p_stats_computer == NULL )
+            p_private->p_stats_computer = p_input;
         vlc_mutex_unlock( &p_input->p_libvlc->p_stats->lock );
     }
 
     p_input->b_preparsing = b_quick;
     p_input->psz_header = psz_header ? strdup( psz_header ) : NULL;
 
+    /* Init events */
+    vlc_event_manager_t * p_em = &p_input->p->event_manager;
+    vlc_event_manager_init_with_vlc_object( p_em, p_input );
+    vlc_event_manager_register_event_type( p_em, vlc_InputStateChanged );
+    vlc_event_manager_register_event_type( p_em, vlc_InputSelectedStreamChanged );
+
     /* Init Common fields */
     p_input->b_eof = false;
     p_input->b_can_pace_control = true;
@@ -181,12 +197,11 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     p_input->p->i_title_offset = p_input->p->i_seekpoint_offset = 0;
     p_input->i_state = INIT_S;
     p_input->p->i_rate  = INPUT_RATE_DEFAULT;
+    p_input->p->b_recording = false;
     TAB_INIT( p_input->p->i_bookmark, p_input->p->bookmark );
     TAB_INIT( p_input->p->i_attachment, p_input->p->attachment );
     p_input->p->p_es_out = NULL;
     p_input->p->p_sout  = NULL;
-    p_input->p->b_owns_its_sout = true;
-    p_input->p->b_sout_keep  = false;
     p_input->p->b_out_pace_control = false;
     p_input->i_pts_delay = 0;
 
@@ -218,11 +233,12 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
 
     /* Init control buffer */
     vlc_mutex_init( &p_input->p->lock_control );
+    vlc_cond_init( &p_input->p->wait_control );
     p_input->p->i_control = 0;
 
     /* Parse input options */
     vlc_mutex_lock( &p_item->lock );
-    assert( p_item->optflagc == p_item->i_options );
+    assert( (int)p_item->optflagc == p_item->i_options );
     for( i = 0; i < p_item->i_options; i++ )
         var_OptionParse( VLC_OBJECT(p_input), p_item->ppsz_options[i],
                          !!(p_item->optflagv[i] & VLC_INPUT_OPTION_TRUSTED) );
@@ -234,6 +250,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     /* Create Objects variables for public Get and Set */
     input_ControlVarInit( p_input );
 
+    /* */
     p_input->p->input.i_cr_average = var_GetInteger( p_input, "cr-average" );
 
     if( !p_input->b_preparsing )
@@ -246,7 +263,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
             psz_parser = val.psz_string;
             while( (psz_start = strchr( psz_parser, '{' ) ) )
             {
-                 seekpoint_t *p_seekpoint = vlc_seekpoint_New();
+                 seekpoint_t *p_seekpoint;
                  char backup;
                  psz_start++;
                  psz_end = strchr( psz_start, '}' );
@@ -255,6 +272,8 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
                  backup = *psz_parser;
                  *psz_parser = 0;
                  *psz_end = ',';
+
+                 p_seekpoint = vlc_seekpoint_New();
                  while( (psz_end = strchr( psz_start, ',' ) ) )
                  {
                      *psz_end = 0;
@@ -293,20 +312,17 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
 
     /* */
     if( p_sout )
-    {
         p_input->p->p_sout = p_sout;
-        p_input->p->b_owns_its_sout = false;
-    }
 
     memset( &p_input->p->counters, 0, sizeof( p_input->p->counters ) );
     vlc_mutex_init( &p_input->p->counters.counters_lock );
 
-    /* Attach only once we are ready */
-    vlc_object_attach( p_input, p_parent );
-
     /* Set the destructor when we are sure we are initialized */
     vlc_object_set_destructor( p_input, (vlc_destructor_t)Destructor );
 
+    /* Attach only once we are ready */
+    vlc_object_attach( p_input, p_parent );
+
     return p_input;
 }
 
@@ -315,28 +331,27 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
  */
 static void Destructor( input_thread_t * p_input )
 {
-    input_thread_private_t *priv = p_input->p;
+#ifndef NDEBUG
+    char * psz_name = input_item_GetName( p_input->p->input.p_item );
+    msg_Dbg( p_input, "Destroying the input for '%s'", psz_name);
+    free( psz_name );
+#endif
+
+    vlc_event_manager_fini( &p_input->p->event_manager );
 
     stats_TimerDump( p_input, STATS_TIMER_INPUT_LAUNCHING );
     stats_TimerClean( p_input, STATS_TIMER_INPUT_LAUNCHING );
 #ifdef ENABLE_SOUT
-    if( priv->b_owns_its_sout && priv->p_sout )
-    {
-        if( priv->b_sout_keep )
-            SoutKeep( priv->p_sout );
-        else
-        {
-            sout_DeleteInstance( priv->p_sout );
-            priv->p_sout = NULL;
-        }
-    }
+    if( p_input->p->p_sout )
+        sout_DeleteInstance( p_input->p->p_sout );
 #endif
     vlc_gc_decref( p_input->p->input.p_item );
 
     vlc_mutex_destroy( &p_input->p->counters.counters_lock );
 
-    vlc_mutex_destroy( &priv->lock_control );
-    free( priv );
+    vlc_cond_destroy( &p_input->p->wait_control );
+    vlc_mutex_destroy( &p_input->p->lock_control );
+    free( p_input->p );
 }
 
 /**
@@ -350,15 +365,7 @@ static void Destructor( input_thread_t * p_input )
 input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
                                       input_item_t *p_item )
 {
-    bool b_sout_keep;
-    sout_instance_t *p_sout = SoutFind( p_parent, p_item, &b_sout_keep );
-    input_thread_t *p_input =  __input_CreateThreadExtended( p_parent, p_item, NULL, p_sout );
-
-    if( !p_input && p_sout )
-        SoutKeep( p_sout );
-
-    p_input->p->b_sout_keep = b_sout_keep;
-    return p_input;
+    return __input_CreateThreadExtended( p_parent, p_item, NULL, NULL );
 }
 
 /* */
@@ -374,7 +381,7 @@ input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
 
     /* Create thread and wait for its readiness. */
     if( vlc_thread_create( p_input, "input", Run,
-                           VLC_THREAD_PRIORITY_INPUT, true ) )
+                           VLC_THREAD_PRIORITY_INPUT, false ) )
     {
         input_ChangeState( p_input, ERROR_S );
         msg_Err( p_input, "cannot create input thread" );
@@ -387,38 +394,32 @@ input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
 }
 
 /**
- * Initialize an input thread and run it. This thread will clean after himself,
+ * Initialize an input thread and run it. This thread will clean after itself,
  * you can forget about it. It can work either in blocking or non-blocking mode
  *
  * \param p_parent a vlc_object
  * \param p_item an input item
  * \param b_block should we block until read is finished ?
- * \return the input object id if non blocking, an error code else
+ * \return an error code, VLC_SUCCESS on success
  */
 int __input_Read( vlc_object_t *p_parent, input_item_t *p_item,
                    bool b_block )
 {
-    bool b_sout_keep;
-    sout_instance_t *p_sout = SoutFind( p_parent, p_item, &b_sout_keep );
     input_thread_t *p_input;
 
-    p_input = Create( p_parent, p_item, NULL, false, p_sout );
-    if( !p_input && p_sout )
-    {
-        SoutKeep( p_sout );
+    p_input = Create( p_parent, p_item, NULL, false, NULL );
+    if( !p_input )
         return VLC_EGENERIC;
-    }
-    p_input->p->b_sout_keep = b_sout_keep;
 
     if( b_block )
     {
-        RunAndDestroy( p_input );
+        RunAndDestroy( VLC_OBJECT(p_input) );
         return VLC_SUCCESS;
     }
     else
     {
         if( vlc_thread_create( p_input, "input", RunAndDestroy,
-                               VLC_THREAD_PRIORITY_INPUT, true ) )
+                               VLC_THREAD_PRIORITY_INPUT, false ) )
         {
             input_ChangeState( p_input, ERROR_S );
             msg_Err( p_input, "cannot create input thread" );
@@ -426,7 +427,7 @@ int __input_Read( vlc_object_t *p_parent, input_item_t *p_item,
             return VLC_EGENERIC;
         }
     }
-    return p_input->i_object_id;
+    return VLC_SUCCESS;
 }
 
 /**
@@ -460,49 +461,40 @@ int __input_Preparse( vlc_object_t *p_parent, input_item_t *p_item )
  *
  * \param the input thread to stop
  */
-void input_StopThread( input_thread_t *p_input )
+static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj )
 {
     vlc_list_t *p_list;
     int i;
 
-    /* Set die for input */
-    vlc_object_kill( p_input );
-    /* FIXME: seems to be duplicated in ControlPush(INPUT_CONTROL_SET_DIE) */
-
-    /* We cannot touch p_input fields directly (we come from another thread),
-     * so use the vlc_object_find way, it's perfectly safe */
+    if( p_obj->i_object_type == VLC_OBJECT_VOUT ||
+        p_obj->i_object_type == VLC_OBJECT_AOUT ||
+        p_obj == VLC_OBJECT(p_input->p->p_sout) )
+        return;
 
-    /* Set die for all access */
-    p_list = vlc_list_find( p_input, VLC_OBJECT_ACCESS, FIND_CHILD );
-    for( i = 0; i < p_list->i_count; i++ )
-    {
-        vlc_object_kill( p_list->p_values[i].p_object );
-    }
-    vlc_list_release( p_list );
+    vlc_object_kill( p_obj );
 
-    /* Set die for all stream */
-    p_list = vlc_list_find( p_input, VLC_OBJECT_STREAM, FIND_CHILD );
+    p_list = vlc_list_children( p_obj );
     for( i = 0; i < p_list->i_count; i++ )
-    {
-        vlc_object_kill( p_list->p_values[i].p_object );
-    }
-    vlc_list_release( p_list );
-
-    /* Set die for all demux */
-    p_list = vlc_list_find( p_input, VLC_OBJECT_DEMUX, FIND_CHILD );
-    for( i = 0; i < p_list->i_count; i++ )
-    {
-        vlc_object_kill( p_list->p_values[i].p_object );
-    }
+        ObjectKillChildrens( p_input, p_list->p_values[i].p_object );
     vlc_list_release( p_list );
+}
+void input_StopThread( input_thread_t *p_input )
+{
+    /* Set die for input and ALL of this childrens (even (grand-)grand-childrens)
+     * It is needed here even if it is done in INPUT_CONTROL_SET_DIE handler to
+     * unlock the control loop */
+    ObjectKillChildrens( p_input, VLC_OBJECT(p_input) );
 
     input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
 }
 
 sout_instance_t * input_DetachSout( input_thread_t *p_input )
 {
-    p_input->p->b_owns_its_sout = false;
-    return p_input->p->p_sout;
+    assert( p_input->b_dead );
+    sout_instance_t *p_sout = p_input->p->p_sout;
+    vlc_object_detach( p_sout );
+    p_input->p->p_sout = NULL;
+    return p_sout;
 }
 
 /*****************************************************************************
@@ -510,63 +502,31 @@ sout_instance_t * input_DetachSout( input_thread_t *p_input )
  * This is the "normal" thread that spawns the input processing chain,
  * reads the stream, cleans up and waits
  *****************************************************************************/
-static int Run( input_thread_t *p_input )
+static void* Run( vlc_object_t *p_this )
 {
-    /* Signal that the thread is launched */
-    vlc_thread_ready( p_input );
+    input_thread_t *p_input = (input_thread_t *)p_this;
+    const int canc = vlc_savecancel();
 
     if( Init( p_input ) )
     {
         /* If we failed, wait before we are killed, and exit */
-        p_input->b_error = true;
-
-        /* FIXME: we don't want to depend on the playlist */
-        playlist_t * p_playlist = vlc_object_find( p_input,
-            VLC_OBJECT_PLAYLIST, FIND_PARENT );
-        if( p_playlist )
-        {
-            playlist_Signal( p_playlist );
-            vlc_object_release( p_playlist );
-        }
-
-        Error( p_input );
-
-        /* Tell we're dead */
-        p_input->b_dead = true;
-
-        return 0;
+        WaitDie( p_input );
+        goto exit;
     }
 
     MainLoop( p_input );
 
-    if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof )
-    {
-        /* We have finish to demux data but not to play them */
-        while( !p_input->b_die )
-        {
-            if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) )
-                break;
-
-            msg_Dbg( p_input, "waiting decoder fifos to empty" );
-
-            msleep( INPUT_IDLE_SLEEP );
-        }
-
-        /* We have finished */
-        p_input->b_eof = true;
-        playlist_Signal( pl_Get( p_input ) );
-    }
-
     /* Wait until we are asked to die */
     if( !p_input->b_die )
-    {
-        Error( p_input );
-    }
+        WaitDie( p_input );
 
     /* Clean up */
     End( p_input );
 
-    return 0;
+exit:
+    p_input->b_dead = true;
+    vlc_restorecancel( canc );
+    return NULL;
 }
 
 /*****************************************************************************
@@ -574,217 +534,290 @@ static int Run( input_thread_t *p_input )
  * This is the "just forget me" thread that spawns the input processing chain,
  * reads the stream, cleans up and releases memory
  *****************************************************************************/
-static int RunAndDestroy( input_thread_t *p_input )
+static void* RunAndDestroy( vlc_object_t *p_this )
 {
-    /* Signal that the thread is launched */
-    vlc_thread_ready( p_input );
+    input_thread_t *p_input = (input_thread_t *)p_this;
+    const int canc = vlc_savecancel();
 
     if( Init( p_input ) )
         goto exit;
 
     MainLoop( p_input );
 
-    if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof )
-    {
-        /* We have finished demuxing data but not playing it */
-        while( !p_input->b_die )
-        {
-            if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) )
-                break;
-
-            msg_Dbg( p_input, "waiting decoder fifos to empty" );
-
-            msleep( INPUT_IDLE_SLEEP );
-        }
-
-        /* We have finished */
-        p_input->b_eof = true;
-    }
-
     /* Clean up */
     End( p_input );
 
 exit:
     /* Release memory */
     vlc_object_release( p_input );
-    return 0;
+    vlc_restorecancel( canc );
+    return NULL;
 }
 
 /*****************************************************************************
  * Main loop: Fill buffers from access, and demux
  *****************************************************************************/
-static void MainLoop( input_thread_t *p_input )
+
+/**
+ * MainLoopDemux
+ * It asks the demuxer to demux some data
+ */
+static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, mtime_t *pi_start_mdate )
 {
-    int64_t i_start_mdate = mdate();
-    int64_t i_intf_update = 0;
-    int i_updates = 0;
+    int i_ret;
 
-    /* Stop the timer */
-    stats_TimerStop( p_input, STATS_TIMER_INPUT_LAUNCHING );
+    *pb_changed = false;
 
-    while( !p_input->b_die && !p_input->b_error && !p_input->p->input.b_eof )
+    if( ( p_input->p->i_stop > 0 && p_input->i_time >= p_input->p->i_stop ) ||
+        ( p_input->p->i_run > 0 && *pi_start_mdate+p_input->p->i_run < mdate() ) )
+        i_ret = 0; /* EOF */
+    else
+        i_ret = p_input->p->input.p_demux->pf_demux(p_input->p->input.p_demux);
+
+    if( i_ret > 0 )
     {
-        bool b_force_update = false;
-        int i_ret;
-        int i_type;
-        vlc_value_t val;
+        /* TODO */
+        if( p_input->p->input.b_title_demux &&
+            p_input->p->input.p_demux->info.i_update )
+        {
+            i_ret = UpdateFromDemux( p_input );
+            *pb_changed = true;
+        }
+        else if( !p_input->p->input.b_title_demux &&
+                  p_input->p->input.p_access &&
+                  p_input->p->input.p_access->info.i_update )
+        {
+            i_ret = UpdateFromAccess( p_input );
+            *pb_changed = true;
+        }
+    }
+
+    if( i_ret == 0 )    /* EOF */
+    {
+        vlc_value_t repeat;
 
-        /* Do the read */
-        if( p_input->i_state != PAUSE_S )
+        var_Get( p_input, "input-repeat", &repeat );
+        if( repeat.i_int == 0 )
         {
-            if( ( p_input->p->i_stop > 0 && p_input->i_time >= p_input->p->i_stop ) ||
-                ( p_input->p->i_run > 0 && i_start_mdate+p_input->p->i_run < mdate() ) )
-                i_ret = 0; /* EOF */
-            else
-                i_ret = p_input->p->input.p_demux->pf_demux(p_input->p->input.p_demux);
+            /* End of file - we do not set b_die because only the
+             * playlist is allowed to do so. */
+            msg_Dbg( p_input, "EOF reached" );
+            p_input->p->input.b_eof = true;
+        }
+        else
+        {
+            vlc_value_t val;
 
-            if( i_ret > 0 )
+            msg_Dbg( p_input, "repeating the same input (%d)",
+                     repeat.i_int );
+            if( repeat.i_int > 0 )
             {
-                /* TODO */
-                if( p_input->p->input.b_title_demux &&
-                    p_input->p->input.p_demux->info.i_update )
-                {
-                    i_ret = UpdateFromDemux( p_input );
-                    b_force_update = true;
-                }
-                else if( !p_input->p->input.b_title_demux &&
-                          p_input->p->input.p_access &&
-                          p_input->p->input.p_access->info.i_update )
-                {
-                    i_ret = UpdateFromAccess( p_input );
-                    b_force_update = true;
-                }
+                repeat.i_int--;
+                var_Set( p_input, "input-repeat", repeat );
             }
 
-            if( i_ret == 0 )    /* EOF */
-            {
-                vlc_value_t repeat;
-
-                var_Get( p_input, "input-repeat", &repeat );
-                if( repeat.i_int == 0 )
-                {
-                    /* End of file - we do not set b_die because only the
-                     * playlist is allowed to do so. */
-                    input_ChangeState( p_input, END_S );
-                    msg_Dbg( p_input, "EOF reached" );
-                    p_input->p->input.b_eof = true;
-                }
-                else
-                {
-                    msg_Dbg( p_input, "repeating the same input (%d)",
-                             repeat.i_int );
-                    if( repeat.i_int > 0 )
-                    {
-                        repeat.i_int--;
-                        var_Set( p_input, "input-repeat", repeat );
-                    }
+            /* Seek to start title/seekpoint */
+            val.i_int = p_input->p->input.i_title_start -
+                p_input->p->input.i_title_offset;
+            if( val.i_int < 0 || val.i_int >= p_input->p->input.i_title )
+                val.i_int = 0;
+            input_ControlPush( p_input,
+                               INPUT_CONTROL_SET_TITLE, &val );
 
-                    /* Seek to start title/seekpoint */
-                    val.i_int = p_input->p->input.i_title_start -
-                        p_input->p->input.i_title_offset;
-                    if( val.i_int < 0 || val.i_int >= p_input->p->input.i_title )
-                        val.i_int = 0;
-                    input_ControlPush( p_input,
-                                       INPUT_CONTROL_SET_TITLE, &val );
-
-                    val.i_int = p_input->p->input.i_seekpoint_start -
-                        p_input->p->input.i_seekpoint_offset;
-                    if( val.i_int > 0 /* TODO: check upper boundary */ )
-                        input_ControlPush( p_input,
-                                           INPUT_CONTROL_SET_SEEKPOINT, &val );
-
-                    /* Seek to start position */
-                    if( p_input->p->i_start > 0 )
-                    {
-                        val.i_time = p_input->p->i_start;
-                        input_ControlPush( p_input, INPUT_CONTROL_SET_TIME,
-                                           &val );
-                    }
-                    else
-                    {
-                        val.f_float = 0.0;
-                        input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION,
-                                           &val );
-                    }
+            val.i_int = p_input->p->input.i_seekpoint_start -
+                p_input->p->input.i_seekpoint_offset;
+            if( val.i_int > 0 /* TODO: check upper boundary */ )
+                input_ControlPush( p_input,
+                                   INPUT_CONTROL_SET_SEEKPOINT, &val );
 
-                    /* */
-                    i_start_mdate = mdate();
-                }
-            }
-            else if( i_ret < 0 )
+            /* Seek to start position */
+            if( p_input->p->i_start > 0 )
             {
-                p_input->b_error = true;
+                val.i_time = p_input->p->i_start;
+                input_ControlPush( p_input, INPUT_CONTROL_SET_TIME,
+                                   &val );
             }
-
-            if( i_ret > 0 && p_input->p->i_slave > 0 )
+            else
             {
-                SlaveDemux( p_input );
+                val.f_float = 0.0;
+                input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION,
+                                   &val );
             }
+
+            /* */
+            *pi_start_mdate = mdate();
         }
-        else
+    }
+    else if( i_ret < 0 )
+    {
+        input_ChangeState( p_input, ERROR_S );
+    }
+
+    if( i_ret > 0 && p_input->p->i_slave > 0 )
+    {
+        SlaveDemux( p_input );
+    }
+}
+
+/**
+ * MainLoopInterface
+ * It update the variables used by the interfaces
+ */
+static void MainLoopInterface( input_thread_t *p_input )
+{
+    vlc_value_t val;
+    double f_pos;
+    int64_t i_time, i_length;
+
+    /* update input status variables */
+    if( !demux_Control( p_input->p->input.p_demux,
+                         DEMUX_GET_POSITION, &f_pos ) )
+    {
+        val.f_float = (float)f_pos;
+        var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
+    }
+    if( !demux_Control( p_input->p->input.p_demux,
+                         DEMUX_GET_TIME, &i_time ) )
+    {
+        p_input->i_time = i_time;
+        val.i_time = i_time;
+        var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
+    }
+    if( !demux_Control( p_input->p->input.p_demux,
+                         DEMUX_GET_LENGTH, &i_length ) )
+    {
+        vlc_value_t old_val;
+        var_Get( p_input, "length", &old_val );
+        val.i_time = i_length;
+        var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
+
+        if( old_val.i_time != val.i_time )
         {
-            /* Small wait */
-            msleep( 10*1000 );
+            UpdateItemLength( p_input, i_length );
         }
+    }
 
-        /* Handle control */
-        vlc_mutex_lock( &p_input->p->lock_control );
-        ControlReduce( p_input );
-        while( !ControlPopNoLock( p_input, &i_type, &val ) )
+    var_SetBool( p_input, "intf-change", true );
+}
+
+/**
+ * MainLoopStatistic
+ * It updates the globals statics
+ */
+static void MainLoopStatistic( input_thread_t *p_input )
+{
+    stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
+    /* Are we the thread responsible for computing global stats ? */
+    if( libvlc_priv( p_input->p_libvlc )->p_stats_computer == p_input )
+    {
+        stats_ComputeGlobalStats( p_input->p_libvlc,
+                                  p_input->p_libvlc->p_stats );
+    }
+    var_SetBool( p_input, "stats-change", true );
+}
+
+/**
+ * MainLoop
+ * The main input loop.
+ */
+static void MainLoop( input_thread_t *p_input )
+{
+    mtime_t i_start_mdate = mdate();
+    mtime_t i_intf_update = 0;
+    mtime_t i_statistic_update = 0;
+
+    /* Start the timer */
+    stats_TimerStop( p_input, STATS_TIMER_INPUT_LAUNCHING );
+
+    while( !p_input->b_die && !p_input->b_error && !p_input->p->input.b_eof )
+    {
+        bool b_force_update;
+        int i_type;
+        vlc_value_t val;
+        mtime_t i_current;
+        mtime_t i_deadline;
+        mtime_t i_wakeup;
+        bool b_paused;
+
+        /* Demux data */
+        b_force_update = false;
+        i_wakeup = 0;
+        /* FIXME if p_input->i_state == PAUSE_S the access/access_demux
+         * is paused -> this may cause problem with some of them
+         * The same problem can be seen when seeking while paused */
+        input_EsOutLock( p_input->p->p_es_out );
+        b_paused = p_input->i_state == PAUSE_S &&
+                   !input_EsOutIsBuffering( p_input->p->p_es_out );
+        input_EsOutUnlock( p_input->p->p_es_out );
+
+        if( !b_paused )
         {
-            msg_Dbg( p_input, "control type=%d", i_type );
-            if( Control( p_input, i_type, val ) )
-                b_force_update = true;
+            MainLoopDemux( p_input, &b_force_update, &i_start_mdate );
+
+            i_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
         }
-        vlc_mutex_unlock( &p_input->p->lock_control );
 
-        if( b_force_update || i_intf_update < mdate() )
-        {
-            vlc_value_t val;
-            double f_pos;
-            int64_t i_time, i_length;
-            /* update input status variables */
-            if( !demux_Control( p_input->p->input.p_demux,
-                                 DEMUX_GET_POSITION, &f_pos ) )
+        /* */
+        do {
+            i_deadline = i_wakeup;
+            if( b_paused )
+                i_deadline = __MIN( i_intf_update, i_statistic_update );
+
+            /* Handle control */
+            vlc_mutex_lock( &p_input->p->lock_control );
+            ControlReduce( p_input );
+            while( !ControlPopNoLock( p_input, &i_type, &val, i_deadline ) )
             {
-                val.f_float = (float)f_pos;
-                var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL );
+                msg_Dbg( p_input, "control type=%d", i_type );
+
+                if( Control( p_input, i_type, val ) )
+                    b_force_update = true;
             }
-            if( !demux_Control( p_input->p->input.p_demux,
-                                 DEMUX_GET_TIME, &i_time ) )
+            vlc_mutex_unlock( &p_input->p->lock_control );
+
+            /* Update interface and statistics */
+            i_current = mdate();
+            if( i_intf_update < i_current || b_force_update )
             {
-                p_input->i_time = i_time;
-                val.i_time = i_time;
-                var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );
+                MainLoopInterface( p_input );
+                i_intf_update = i_current + INT64_C(250000);
+                b_force_update = false;
             }
-            if( !demux_Control( p_input->p->input.p_demux,
-                                 DEMUX_GET_LENGTH, &i_length ) )
+            if( i_statistic_update < i_current )
             {
-                vlc_value_t old_val;
-                var_Get( p_input, "length", &old_val );
-                val.i_time = i_length;
-                var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
-
-                if( old_val.i_time != val.i_time )
-                {
-                    UpdateItemLength( p_input, i_length );
-                }
+                MainLoopStatistic( p_input );
+                i_statistic_update = i_current + INT64_C(1000000);
             }
 
-            var_SetBool( p_input, "intf-change", true );
-            i_intf_update = mdate() + INT64_C(150000);
-        }
-        /* 150ms * 8 = ~ 1 second */
-        if( ++i_updates % 8 == 0 )
-        {
-            stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
-            /* Are we the thread responsible for computing global stats ? */
-            if( p_input->p_libvlc->p_stats_computer == p_input )
+            /* Check if i_wakeup is still valid */
+            if( i_wakeup != 0 )
             {
-                stats_ComputeGlobalStats( p_input->p_libvlc,
-                                     p_input->p_libvlc->p_stats );
+                mtime_t i_new_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
+                if( !i_new_wakeup )
+                    i_wakeup = 0;
             }
+        } while( i_current < i_wakeup );
+    }
+
+    if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof )
+    {
+        /* We have finish to demux data but not to play them */
+        while( vlc_object_alive( p_input ) )
+        {
+            input_EsOutLock( p_input->p->p_es_out );
+            bool b_empty = input_EsOutDecodersIsEmpty( p_input->p->p_es_out );
+            input_EsOutUnlock( p_input->p->p_es_out );
+
+            if( b_empty )
+                break;
+
+            msg_Dbg( p_input, "waiting decoder fifos to empty" );
+
+            msleep( INPUT_IDLE_SLEEP );
         }
+
+        /* We have finished */
+        input_ChangeState( p_input, END_S );
     }
 }
 
@@ -795,7 +828,7 @@ static void InitStatistics( input_thread_t * p_input )
     /* Prepare statistics */
 #define INIT_COUNTER( c, type, compute ) p_input->p->counters.p_##c = \
  stats_CounterCreate( p_input, VLC_VAR_##type, STATS_##compute);
-    if( libvlc_stats (p_input) )
+    if( libvlc_stats( p_input ) )
     {
         INIT_COUNTER( read_bytes, INTEGER, COUNTER );
         INIT_COUNTER( read_packets, INTEGER, COUNTER );
@@ -863,10 +896,10 @@ static int InitSout( input_thread_t * p_input )
                 return VLC_EGENERIC;
             }
         }
-        if( libvlc_stats (p_input) )
+        if( libvlc_stats( p_input ) )
         {
             INIT_COUNTER( sout_sent_packets, INTEGER, COUNTER );
-            INIT_COUNTER (sout_sent_bytes, INTEGER, COUNTER );
+            INIT_COUNTER( sout_sent_bytes, INTEGER, COUNTER );
             INIT_COUNTER( sout_send_bitrate, FLOAT, DERIVATIVE );
             if( p_input->p->counters.p_sout_send_bitrate )
                  p_input->p->counters.p_sout_send_bitrate->update_interval =
@@ -916,7 +949,8 @@ static void InitTitle( input_thread_t * p_input )
     /* If the desynchronisation requested by the user is < 0, we need to
      * cache more data. */
     var_Get( p_input, "audio-desync", &val );
-    if( val.i_int < 0 ) p_input->i_pts_delay -= (val.i_int * 1000);
+    if( val.i_int < 0 )
+        p_input->i_pts_delay -= (val.i_int * 1000);
 
     /* Update cr_average depending on the caching */
     p_input->p->input.i_cr_average *= (10 * p_input->i_pts_delay / 200000);
@@ -928,7 +962,7 @@ static void StartTitle( input_thread_t * p_input )
 {
     double f_fps;
     vlc_value_t val;
-    int i, i_delay;
+    int i_delay;
     char *psz;
     char *psz_subtitle;
     int64_t i_length;
@@ -1015,45 +1049,29 @@ static void StartTitle( input_thread_t * p_input )
     if( psz_subtitle != NULL )
     {
         msg_Dbg( p_input, "forced subtitle: %s", psz_subtitle );
-        input_AddSubtitles( p_input, psz_subtitle, false );
+        SubtitleAdd( p_input, psz_subtitle, true );
     }
 
     var_Get( p_input, "sub-autodetect-file", &val );
     if( val.b_bool )
     {
         char *psz_autopath = var_GetNonEmptyString( p_input, "sub-autodetect-path" );
-        char **subs = subtitles_Detect( p_input, psz_autopath,
-                                        p_input->p->input.p_item->psz_uri );
-        input_source_t *sub;
-        i = 0;
-        if( psz_autopath == NULL )
-            psz_autopath = strdup("");
+        char **ppsz_subs = subtitles_Detect( p_input, psz_autopath,
+                                             p_input->p->input.p_item->psz_uri );
+        free( psz_autopath );
 
-        /* Try to autoselect the first autodetected subtitles file
-         * if no subtitles file was specified */
-        if( ( psz_subtitle == NULL ) && subs && subs[0] )
+        for( int i = 0; ppsz_subs && ppsz_subs[i]; i++ )
         {
-            input_AddSubtitles( p_input, subs[0], false );
-            free( subs[0] );
-            i = 1;
-        }
+            /* Try to autoselect the first autodetected subtitles file
+             * if no subtitles file was specified */
+            bool b_forced = i == 0 && !psz_subtitle;
 
-        /* Then, just add the following subtitles files */
-        for( ; subs && subs[i]; i++ )
-        {
-            if( !psz_subtitle || strcmp( psz_subtitle, subs[i] ) )
-            {
-                sub = InputSourceNew( p_input );
-                if( !InputSourceInit( p_input, sub, subs[i], "subtitle" ) )
-                {
-                    TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
-                }
-                else free( sub );
-            }
-            free( subs[i] );
+            if( !psz_subtitle || strcmp( psz_subtitle, ppsz_subs[i] ) )
+                SubtitleAdd( p_input, ppsz_subs[i], b_forced );
+
+            free( ppsz_subs[i] );
         }
-        free( subs );
-        free( psz_autopath );
+        free( ppsz_subs );
     }
     free( psz_subtitle );
 
@@ -1105,7 +1123,7 @@ static void InitPrograms( input_thread_t * p_input )
     if( p_input->p->p_sout )
     {
         var_Get( p_input, "sout-all", &val );
-        if ( val.b_bool )
+        if( val.b_bool )
         {
             i_es_out_mode = ES_OUT_MODE_ALL;
             val.p_list = NULL;
@@ -1113,14 +1131,16 @@ static void InitPrograms( input_thread_t * p_input )
         else
         {
             var_Get( p_input, "programs", &val );
-            if ( val.p_list && val.p_list->i_count )
+            if( val.p_list && val.p_list->i_count )
             {
                 i_es_out_mode = ES_OUT_MODE_PARTIAL;
                 /* Note : we should remove the "program" callback. */
             }
             else
+            {
                 var_Change( p_input, "programs", VLC_VAR_FREELIST, &val,
                             NULL );
+            }
         }
     }
     es_out_Control( p_input->p->p_es_out, ES_OUT_SET_MODE, i_es_out_mode );
@@ -1251,7 +1271,7 @@ error:
     input_ChangeState( p_input, ERROR_S );
 
     if( p_input->p->p_es_out )
-        input_EsOutDelete( p_input->p->p_es_out );
+        es_out_Delete( p_input->p->p_es_out );
 #ifdef ENABLE_SOUT
     if( p_input->p->p_sout )
     {
@@ -1260,7 +1280,7 @@ error:
     }
 #endif
 
-    if( !p_input->b_preparsing && libvlc_stats (p_input) )
+    if( !p_input->b_preparsing && libvlc_stats( p_input ) )
     {
 #define EXIT_COUNTER( c ) do { if( p_input->p->counters.p_##c ) \
                                    stats_CounterClean( p_input->p->counters.p_##c );\
@@ -1281,7 +1301,7 @@ error:
         if( p_input->p->p_sout )
         {
             EXIT_COUNTER( sout_sent_packets );
-            EXIT_COUNTER (sout_sent_bytes );
+            EXIT_COUNTER( sout_sent_bytes );
             EXIT_COUNTER( sout_send_bitrate );
         }
 #undef EXIT_COUNTER
@@ -1298,18 +1318,19 @@ error:
 }
 
 /*****************************************************************************
- * Error: RunThread() error loop
+ * WaitDie: Wait until we are asked to die.
  *****************************************************************************
  * This function is called when an error occurred during thread main's loop.
  *****************************************************************************/
-static void Error( input_thread_t *p_input )
+static void WaitDie( input_thread_t *p_input )
 {
-    input_ChangeState( p_input, ERROR_S );
-    while( !p_input->b_die )
-    {
-        /* Sleep a while */
-        msleep( INPUT_IDLE_SLEEP );
-    }
+    input_ChangeState( p_input, p_input->b_error ? ERROR_S : END_S );
+
+    /* Wait a die order */
+    vlc_object_lock( p_input );
+    while( vlc_object_alive( p_input ) )
+        vlc_object_wait( p_input );
+    vlc_object_unlock( p_input );
 }
 
 /*****************************************************************************
@@ -1323,7 +1344,7 @@ static void End( input_thread_t * p_input )
     input_ChangeState( p_input, END_S );
 
     /* Clean control variables */
-    input_ControlVarClean( p_input );
+    input_ControlVarStop( p_input );
 
     /* Clean up master */
     InputSourceClean( &p_input->p->input );
@@ -1338,20 +1359,22 @@ static void End( input_thread_t * p_input )
 
     /* Unload all modules */
     if( p_input->p->p_es_out )
-        input_EsOutDelete( p_input->p->p_es_out );
+        es_out_Delete( p_input->p->p_es_out );
 
     if( !p_input->b_preparsing )
     {
 #define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL;
-        if( libvlc_stats (p_input) )
+        if( libvlc_stats( p_input ) )
         {
+            libvlc_priv_t *p_private = libvlc_priv( p_input->p_libvlc );
+
             /* make sure we are up to date */
             stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats );
-            if( p_input->p_libvlc->p_stats_computer == p_input )
+            if( p_private->p_stats_computer == p_input )
             {
                 stats_ComputeGlobalStats( p_input->p_libvlc,
                                           p_input->p_libvlc->p_stats );
-                p_input->p_libvlc->p_stats_computer = NULL;
+                p_private->p_stats_computer = NULL;
             }
             CL_CO( read_bytes );
             CL_CO( read_packets );
@@ -1390,72 +1413,24 @@ static void End( input_thread_t * p_input )
     p_input->b_dead = true;
 }
 
-static sout_instance_t *SoutFind( vlc_object_t *p_parent, input_item_t *p_item, bool *pb_sout_keep )
-{
-    bool b_keep_sout = var_CreateGetBool( p_parent, "sout-keep" );
-    sout_instance_t *p_sout = NULL;
-    int i;
-
-    /* Search sout-keep options
-     * XXX it has to be done here, but it is duplicated work :( */
-    vlc_mutex_lock( &p_item->lock );
-    for( i = 0; i < p_item->i_options; i++ )
-    {
-        const char *psz_option = p_item->ppsz_options[i];
-        if( !psz_option )
-            continue;
-        if( *psz_option == ':' )
-            psz_option++;
-
-        if( !strcmp( psz_option, "sout-keep" ) )
-            b_keep_sout = true;
-        else if( !strcmp( psz_option, "no-sout-keep" ) || !strcmp( psz_option, "nosout-keep" ) )
-            b_keep_sout = false;
-    }
-    vlc_mutex_unlock( &p_item->lock );
-
-    /* Find a potential sout to reuse
-     * XXX it might be unusable but this will be checked later */
-    if( b_keep_sout )
-    {
-        p_sout = vlc_object_find( p_parent->p_libvlc, VLC_OBJECT_SOUT,
-                                                      FIND_CHILD );
-        if( p_sout )
-        {
-            if( p_sout->p_parent != VLC_OBJECT( p_sout->p_libvlc ) )
-            {
-                vlc_object_release( p_sout );
-                p_sout = NULL;
-            }
-            else
-            {
-                vlc_object_detach( p_sout );    /* Remove it from the GC */
-                vlc_object_release( p_sout );
-            }
-        }
-    }
-
-    if( pb_sout_keep )
-        *pb_sout_keep = b_keep_sout;
-
-    return p_sout;
-}
-
-static void SoutKeep( sout_instance_t *p_sout )
-{
-    msg_Dbg( p_sout, "sout has been kept" );
-    vlc_object_attach( p_sout, p_sout->p_libvlc );
-}
-
 /*****************************************************************************
  * Control
  *****************************************************************************/
 static inline int ControlPopNoLock( input_thread_t *p_input,
-                                    int *pi_type, vlc_value_t *p_val )
+                                    int *pi_type, vlc_value_t *p_val,
+                                    mtime_t i_deadline )
 {
-    if( p_input->p->i_control <= 0 )
+
+    while( p_input->p->i_control <= 0 )
     {
-        return VLC_EGENERIC;
+        if( !vlc_object_alive( p_input ) )
+            return VLC_EGENERIC;
+
+        if( i_deadline < 0 )
+            return VLC_EGENERIC;
+
+        if( vlc_cond_timedwait( &p_input->p->wait_control, &p_input->p->lock_control, i_deadline ) )
+            return VLC_EGENERIC;
     }
 
     *pi_type = p_input->p->control[0].i_type;
@@ -1520,32 +1495,89 @@ static void ControlReduce( input_thread_t *p_input )
         }
     }
 }
+/* Pause input */
+static void ControlPause( input_thread_t *p_input, mtime_t i_control_date )
+{
+    int i_ret;
+    int i_state;
+    if( p_input->p->input.p_access )
+        i_ret = access_Control( p_input->p->input.p_access,
+                                 ACCESS_SET_PAUSE_STATE, true );
+    else
+        i_ret = demux_Control( p_input->p->input.p_demux,
+                                DEMUX_SET_PAUSE_STATE, true );
+
+    i_state = PAUSE_S;
+    if( i_ret )
+    {
+        msg_Warn( p_input, "cannot set pause state" );
+        i_state = p_input->i_state;
+    }
+
+    /* Switch to new state */
+    input_ChangeStateWithVarCallback( p_input, i_state, false );
+
+    /* */
+    if( !i_ret )
+        input_EsOutChangePause( p_input->p->p_es_out, true, i_control_date );
+}
+static void ControlUnpause( input_thread_t *p_input, mtime_t i_control_date )
+{
+    int i_ret;
+    if( p_input->p->input.p_access )
+        i_ret = access_Control( p_input->p->input.p_access,
+                                 ACCESS_SET_PAUSE_STATE, false );
+    else
+        i_ret = demux_Control( p_input->p->input.p_demux,
+                                DEMUX_SET_PAUSE_STATE, false );
+
+    if( i_ret )
+    {
+        /* FIXME What to do ? */
+        msg_Warn( p_input, "cannot unset pause -> EOF" );
+        vlc_mutex_unlock( &p_input->p->lock_control );
+        input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
+        vlc_mutex_lock( &p_input->p->lock_control );
+    }
+
+    /* Switch to play */
+    input_ChangeStateWithVarCallback( p_input, PLAYING_S, false );
+
+    /* */
+    if( !i_ret )
+        input_EsOutChangePause( p_input->p->p_es_out, false, i_control_date );
+}
 
 static bool Control( input_thread_t *p_input, int i_type,
                            vlc_value_t val )
 {
+    const mtime_t i_control_date = mdate();
     bool b_force_update = false;
 
-    if( !p_input ) return b_force_update;
+    if( !p_input )
+        return b_force_update;
+
+    input_EsOutLock( p_input->p->p_es_out );
 
     switch( i_type )
     {
         case INPUT_CONTROL_SET_DIE:
             msg_Dbg( p_input, "control: stopping input" );
-            /* Mark all submodules to die */
-            if( p_input->p->input.p_access )
-                vlc_object_kill( p_input->p->input.p_access );
-            if( p_input->p->input.p_stream )
-                vlc_object_kill( p_input->p->input.p_stream );
-            vlc_object_kill( p_input->p->input.p_demux );
 
-            vlc_object_kill( p_input );
+            /* Mark all submodules to die */
+            ObjectKillChildrens( p_input, VLC_OBJECT(p_input) );
             break;
 
         case INPUT_CONTROL_SET_POSITION:
         case INPUT_CONTROL_SET_POSITION_OFFSET:
         {
             double f_pos;
+
+            if( p_input->p->b_recording )
+            {
+                msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) ignored while recording" );
+                break;
+            }
             if( i_type == INPUT_CONTROL_SET_POSITION )
             {
                 f_pos = val.f_float;
@@ -1583,6 +1615,12 @@ static bool Control( input_thread_t *p_input, int i_type,
             int64_t i_time;
             int i_ret;
 
+            if( p_input->p->b_recording )
+            {
+                msg_Err( p_input, "INPUT_CONTROL_SET_TIME(_OFFSET) ignored while recording" );
+                break;
+            }
+
             if( i_type == INPUT_CONTROL_SET_TIME )
             {
                 i_time = val.i_time;
@@ -1634,72 +1672,23 @@ static bool Control( input_thread_t *p_input, int i_type,
             if( ( val.i_int == PLAYING_S && p_input->i_state == PAUSE_S ) ||
                 ( val.i_int == PAUSE_S && p_input->i_state == PAUSE_S ) )
             {
-                int i_ret;
-                if( p_input->p->input.p_access )
-                    i_ret = access_Control( p_input->p->input.p_access,
-                                             ACCESS_SET_PAUSE_STATE, false );
-                else
-                    i_ret = demux_Control( p_input->p->input.p_demux,
-                                            DEMUX_SET_PAUSE_STATE, false );
-
-                if( i_ret )
-                {
-                    /* FIXME What to do ? */
-                    msg_Warn( p_input, "cannot unset pause -> EOF" );
-                    vlc_mutex_unlock( &p_input->p->lock_control );
-                    input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
-                    vlc_mutex_lock( &p_input->p->lock_control );
-                }
+                ControlUnpause( p_input, i_control_date );
 
                 b_force_update = true;
-
-                /* Switch to play */
-                p_input->i_state = PLAYING_S;
-                val.i_int = PLAYING_S;
-                var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
-
-                /* */
-                if( !i_ret )
-                    input_EsOutChangeState( p_input->p->p_es_out );
             }
             else if( val.i_int == PAUSE_S && p_input->i_state == PLAYING_S &&
                      p_input->p->b_can_pause )
             {
-                int i_ret;
-                if( p_input->p->input.p_access )
-                    i_ret = access_Control( p_input->p->input.p_access,
-                                             ACCESS_SET_PAUSE_STATE, true );
-                else
-                    i_ret = demux_Control( p_input->p->input.p_demux,
-                                            DEMUX_SET_PAUSE_STATE, true );
+                ControlPause( p_input, i_control_date );
 
                 b_force_update = true;
-
-                if( i_ret )
-                {
-                    msg_Warn( p_input, "cannot set pause state" );
-                    val.i_int = p_input->i_state;
-                }
-                else
-                {
-                    val.i_int = PAUSE_S;
-                }
-
-                /* Switch to new state */
-                p_input->i_state = val.i_int;
-                var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
-
-                /* */
-                if( !i_ret )
-                    input_EsOutChangeState( p_input->p->p_es_out );
             }
             else if( val.i_int == PAUSE_S && !p_input->p->b_can_pause )
             {
                 b_force_update = true;
 
                 /* Correct "state" value */
-                val.i_int = p_input->i_state;
-                var_Change( p_input, "state", VLC_VAR_SETVALUE, &val, NULL );
+                input_ChangeStateWithVarCallback( p_input, p_input->i_state, false );
             }
             else if( val.i_int != PLAYING_S && val.i_int != PAUSE_S )
             {
@@ -1823,8 +1812,12 @@ static bool Control( input_thread_t *p_input, int i_type,
         case INPUT_CONTROL_SET_ES:
             /* No need to force update, es_out does it if needed */
             es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES,
-                            input_EsOutGetFromID( p_input->p->p_es_out,
-                                                  val.i_int ) );
+                            input_EsOutGetFromID( p_input->p->p_es_out, val.i_int ) );
+            break;
+
+        case INPUT_CONTROL_RESTART_ES:
+            es_out_Control( p_input->p->p_es_out, ES_OUT_RESTART_ES,
+                            input_EsOutGetFromID( p_input->p->p_es_out, val.i_int ) );
             break;
 
         case INPUT_CONTROL_SET_AUDIO_DELAY:
@@ -1842,6 +1835,11 @@ static bool Control( input_thread_t *p_input, int i_type,
         case INPUT_CONTROL_SET_TITLE:
         case INPUT_CONTROL_SET_TITLE_NEXT:
         case INPUT_CONTROL_SET_TITLE_PREV:
+            if( p_input->p->b_recording )
+            {
+                msg_Err( p_input, "INPUT_CONTROL_SET_TITLE(*) ignored while recording" );
+                break;
+            }
             if( p_input->p->input.b_title_demux &&
                 p_input->p->input.i_title > 0 )
             {
@@ -1889,6 +1887,12 @@ static bool Control( input_thread_t *p_input, int i_type,
         case INPUT_CONTROL_SET_SEEKPOINT:
         case INPUT_CONTROL_SET_SEEKPOINT_NEXT:
         case INPUT_CONTROL_SET_SEEKPOINT_PREV:
+            if( p_input->p->b_recording )
+            {
+                msg_Err( p_input, "INPUT_CONTROL_SET_SEEKPOINT(*) ignored while recording" );
+                break;
+            }
+
             if( p_input->p->input.b_title_demux &&
                 p_input->p->input.i_title > 0 )
             {
@@ -1905,7 +1909,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                          !demux_Control( p_demux,
                                           DEMUX_GET_TIME, &i_input_time ) )
                     {
-                        if ( i_input_time < i_seekpoint_time + 3000000 )
+                        if( i_input_time < i_seekpoint_time + 3000000 )
                             i_seekpoint--;
                     }
                     else
@@ -1941,7 +1945,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                         demux_Control( p_demux,
                                         DEMUX_GET_TIME, &i_input_time ) )
                     {
-                        if ( i_input_time < i_seekpoint_time + 3000000 )
+                        if( i_input_time < i_seekpoint_time + 3000000 )
                             i_seekpoint--;
                     }
                     else
@@ -1964,6 +1968,14 @@ static bool Control( input_thread_t *p_input, int i_type,
             }
             break;
 
+        case INPUT_CONTROL_ADD_SUBTITLE:
+            if( val.psz_string )
+            {
+                SubtitleAdd( p_input, val.psz_string, true );
+                free( val.psz_string );
+            }
+            break;
+
         case INPUT_CONTROL_ADD_SLAVE:
             if( val.psz_string )
             {
@@ -1988,7 +2000,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                         break;
                     }
                     if( demux_Control( slave->p_demux,
-                                        DEMUX_SET_TIME, i_time ) )
+                                       DEMUX_SET_TIME, i_time ) )
                     {
                         msg_Err( p_input, "seek failed for new slave" );
                         InputSourceClean( slave );
@@ -2016,12 +2028,55 @@ static bool Control( input_thread_t *p_input, int i_type,
             }
             break;
 
+        case INPUT_CONTROL_SET_RECORD_STATE:
+            if( !!p_input->p->b_recording != !!val.b_bool )
+            {
+                if( p_input->p->input.b_can_stream_record )
+                {
+                    if( demux_Control( p_input->p->input.p_demux,
+                                       DEMUX_SET_RECORD_STATE, val.b_bool ) )
+                        val.b_bool = false;
+                }
+                else
+                {
+                    if( input_EsOutSetRecord( p_input->p->p_es_out, val.b_bool ) )
+                        val.b_bool = false;
+                }
+                p_input->p->b_recording = val.b_bool;
+
+                var_Change( p_input, "record", VLC_VAR_SETVALUE, &val, NULL );
+
+                b_force_update = true;
+            }
+            break;
+
+        case INPUT_CONTROL_SET_FRAME_NEXT:
+            if( !p_input->p->b_can_pause )
+                break;
+
+            if( p_input->i_state == PAUSE_S )
+            {
+                input_EsOutFrameNext( p_input->p->p_es_out );
+            }
+            else if( p_input->i_state == PLAYING_S )
+            {
+                ControlPause( p_input, i_control_date );
+            }
+            else
+            {
+                msg_Err( p_input, "invalid state for frame next" );
+            }
+            b_force_update = true;
+            break;
+
         case INPUT_CONTROL_SET_BOOKMARK:
         default:
             msg_Err( p_input, "not yet implemented" );
             break;
     }
 
+    input_EsOutUnlock( p_input->p->p_es_out );
+
     return b_force_update;
 }
 
@@ -2109,9 +2164,21 @@ static int UpdateFromAccess( input_thread_t *p_input )
         vlc_meta_t *p_meta = vlc_meta_New();
         access_Control( p_input->p->input.p_access,ACCESS_GET_META, p_meta );
         InputUpdateMeta( p_input, p_meta );
-        var_SetInteger( pl_Get( p_input ), "item-change", p_input->p->input.p_item->i_id );
         p_access->info.i_update &= ~INPUT_UPDATE_META;
     }
+    if( p_access->info.i_update & INPUT_UPDATE_SIGNAL )
+    {
+        double f_quality;
+        double f_strength;
+
+        if( access_Control( p_access, ACCESS_GET_SIGNAL, &f_quality, &f_strength ) )
+            f_quality = f_strength = -1;
+
+        var_SetFloat( p_input, "signal-quality", f_quality );
+        var_SetFloat( p_input, "signal-strength", f_strength );
+
+        p_access->info.i_update &= ~INPUT_UPDATE_SIGNAL;
+    }
 
     p_access->info.i_update &= ~INPUT_UPDATE_SIZE;
 
@@ -2148,14 +2215,6 @@ static int UpdateFromAccess( input_thread_t *p_input )
 static void UpdateItemLength( input_thread_t *p_input, int64_t i_length )
 {
     input_item_SetDuration( p_input->p->input.p_item, (mtime_t) i_length );
-
-    if( !p_input->b_preparsing )
-    {
-        pl_Yield( p_input );
-        var_SetInteger( pl_Get( p_input ), "item-change",
-                        p_input->p->input.p_item->i_id );
-        pl_Release( p_input );
-    }
 }
 
 /*****************************************************************************
@@ -2163,28 +2222,10 @@ static void UpdateItemLength( input_thread_t *p_input, int64_t i_length )
  *****************************************************************************/
 static input_source_t *InputSourceNew( input_thread_t *p_input )
 {
-    input_source_t *in = (input_source_t*) malloc( sizeof( input_source_t ) );
-
-    if( !in )
-    {
-        msg_Err( p_input, "out of memory for new input source" );
-        return NULL;
-    }
-
-    in->p_item   = NULL;
-    in->p_access = NULL;
-    in->p_stream = NULL;
-    in->p_demux  = NULL;
-    in->b_title_demux = false;
-    TAB_INIT( in->i_title, in->title );
-    in->b_can_pause = true;
-    in->b_can_pace_control = true;
-    in->b_can_rate_control = true;
-    in->b_rescale_ts = true;
-    in->b_eof = false;
-    in->f_fps = 0.0;
-    in->i_cr_average = 0;
-
+    VLC_UNUSED(p_input);
+    input_source_t *in = malloc( sizeof( input_source_t ) );
+    if( in )
+        memset( in, 0, sizeof( input_source_t ) );
     return in;
 }
 
@@ -2195,7 +2236,9 @@ static int InputSourceInit( input_thread_t *p_input,
                             input_source_t *in, const char *psz_mrl,
                             const char *psz_forced_demux )
 {
-    char psz_dup[strlen (psz_mrl) + 1];
+    const bool b_master = in == &p_input->p->input;
+
+    char psz_dup[strlen(psz_mrl) + 1];
     const char *psz_access;
     const char *psz_demux;
     char *psz_path;
@@ -2210,7 +2253,7 @@ static int InputSourceInit( input_thread_t *p_input,
     if( !p_input ) return VLC_EGENERIC;
 
     /* Split uri */
-    MRLSplit( psz_dup, &psz_access, &psz_demux, &psz_path );
+    input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_dup );
 
     msg_Dbg( p_input, "`%s' gives access `%s' demux `%s' path `%s'",
              psz_mrl, psz_access, psz_demux, psz_path );
@@ -2246,12 +2289,9 @@ static int InputSourceInit( input_thread_t *p_input,
             }
         }
 
-        /* Try access_demux if no demux given */
-        if( *psz_demux == '\0' )
-        {
-            in->p_demux = demux_New( p_input, psz_access, psz_demux, psz_path,
-                                      NULL, p_input->p->p_es_out, false );
-        }
+        /* Try access_demux first */
+        in->p_demux = demux_New( p_input, psz_access, psz_demux, psz_path,
+                                  NULL, p_input->p->p_es_out, false );
     }
     else
     {
@@ -2279,8 +2319,7 @@ static int InputSourceInit( input_thread_t *p_input,
                             &in->title, &in->i_title,
                             &in->i_title_offset, &in->i_seekpoint_offset ) )
         {
-            in->i_title = 0;
-            in->title   = NULL;
+            TAB_INIT( in->i_title, in->title );
         }
         if( demux_Control( in->p_demux, DEMUX_CAN_CONTROL_PACE,
                             &in->b_can_pace_control ) )
@@ -2315,7 +2354,8 @@ static int InputSourceInit( input_thread_t *p_input,
     {
         int64_t i_pts_delay;
 
-        input_ChangeState( p_input, OPENING_S );
+        if( b_master )
+            input_ChangeState( p_input, OPENING_S );
 
         /* Now try a real access */
         in->p_access = access_New( p_input, psz_access, psz_demux, psz_path );
@@ -2377,8 +2417,7 @@ static int InputSourceInit( input_thread_t *p_input,
                                 &in->i_title_offset, &in->i_seekpoint_offset ) )
 
             {
-                in->i_title = 0;
-                in->title   = NULL;
+                TAB_INIT( in->i_title, in->title );
             }
             access_Control( in->p_access, ACCESS_CAN_CONTROL_PACE,
                              &in->b_can_pace_control );
@@ -2393,10 +2432,27 @@ static int InputSourceInit( input_thread_t *p_input,
             var_Set( p_input, "seekable", val );
         }
 
-        input_ChangeState( p_input, BUFFERING_S );
+        if( b_master )
+            input_ChangeState( p_input, BUFFERING_S );
+
+        /* Autodetect extra files if none specified */
+        char *psz_input_list = var_CreateGetNonEmptyString( p_input, "input-list" );
+        if( !psz_input_list )
+        {
+            char *psz_extra_files = InputGetExtraFiles( p_input, psz_access, psz_path );
+            if( psz_extra_files )
+                var_SetString( p_input, "input-list", psz_extra_files );
+            free( psz_extra_files );
+        }
 
         /* Create the stream_t */
         in->p_stream = stream_AccessNew( in->p_access, p_input->b_preparsing );
+
+        /* Restor old value */
+        if( !psz_input_list )
+            var_SetString( p_input, "input-list", "" );
+        free( psz_input_list );
+
         if( in->p_stream == NULL )
         {
             msg_Warn( p_input, "cannot create a stream_t from access" );
@@ -2417,7 +2473,7 @@ static int InputSourceInit( input_thread_t *p_input,
             {
                 const char *psz_a, *psz_d;
                 psz_buf = strdup( in->p_access->psz_path );
-                MRLSplit( psz_buf, &psz_a, &psz_d, &psz_real_path );
+                input_SplitMRL( &psz_a, &psz_d, &psz_real_path, psz_buf );
             }
             else
             {
@@ -2437,7 +2493,7 @@ static int InputSourceInit( input_thread_t *p_input,
             intf_UserFatal( VLC_OBJECT( p_input ), false,
                             _("VLC can't recognize the input's format"),
                             _("The format of '%s' cannot be detected. "
-                            "Have a look the log for details."), psz_mrl );
+                            "Have a look at the log for details."), psz_mrl );
             goto error;
         }
 
@@ -2457,6 +2513,17 @@ static int InputSourceInit( input_thread_t *p_input,
         }
     }
 
+    /* Set record capabilities */
+    if( demux_Control( in->p_demux, DEMUX_CAN_RECORD, &in->b_can_stream_record ) )
+        in->b_can_stream_record = false;
+#ifdef ENABLE_SOUT
+    if( !var_CreateGetBool( p_input, "input-record-native" ) )
+        in->b_can_stream_record = false;
+    var_SetBool( p_input, "can-record", true );
+#else
+    var_SetBool( p_input, "can-record", in->b_can_stream_record );
+#endif
+
     /* get attachment
      * FIXME improve for b_preparsing: move it after GET_META and check psz_arturl */
     if( 1 || !p_input->b_preparsing )
@@ -2485,7 +2552,8 @@ static int InputSourceInit( input_thread_t *p_input,
     return VLC_SUCCESS;
 
 error:
-    input_ChangeState( p_input, ERROR_S );
+    if( b_master )
+        input_ChangeState( p_input, ERROR_S );
 
     if( in->p_demux )
         demux_Delete( in->p_demux );
@@ -2527,11 +2595,12 @@ static void SlaveDemux( input_thread_t *p_input )
 {
     int64_t i_time;
     int i;
+    bool b_set_time = true;
 
     if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) )
     {
-        msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" );
-        return;
+        /* msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" ); */
+        b_set_time = false;
     }
 
     for( i = 0; i < p_input->p->i_slave; i++ )
@@ -2542,7 +2611,7 @@ static void SlaveDemux( input_thread_t *p_input )
         if( in->b_eof )
             continue;
 
-        if( demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) )
+        if( b_set_time && demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) )
         {
             for( ;; )
             {
@@ -2594,9 +2663,14 @@ static void SlaveSeek( input_thread_t *p_input )
 
         if( demux_Control( in->p_demux, DEMUX_SET_TIME, i_time ) )
         {
-            msg_Err( p_input, "seek failed for slave %d -> EOF", i );
+            if( !in->b_eof )
+                msg_Err( p_input, "seek failed for slave %d -> EOF", i );
             in->b_eof = true;
         }
+        else
+        {
+            in->b_eof = false;
+        }
     }
 }
 
@@ -2626,6 +2700,61 @@ static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta )
 #undef GET_META
 }
 
+/*****************************************************************************
+ * InputGetExtraFiles
+ *  Autodetect extra input list
+ *****************************************************************************/
+static char *InputGetExtraFiles( input_thread_t *p_input,
+                                 const char *psz_access, const char *psz_path )
+{
+    char *psz_list = NULL;
+
+    if( ( psz_access && *psz_access && strcmp( psz_access, "file" ) ) || !psz_path )
+        return NULL;
+
+
+    const char *psz_ext = strrchr( psz_path, '.' );
+    if( !psz_ext || strcmp( psz_ext, ".001" ) )
+        return NULL;
+
+    char *psz_file = strdup( psz_path );
+    if( !psz_file )
+        return NULL;
+
+    /* Try to list .xyz files */
+    for( int i = 2; i < 999; i++ )
+    {
+        char *psz_ext = strrchr( psz_file, '.' );
+        struct stat st;
+
+        snprintf( psz_ext, 5, ".%.3d", i );
+
+        if( utf8_stat( psz_file, &st )
+         || !S_ISREG( st.st_mode ) || !st.st_size )
+            continue;
+
+        msg_Dbg( p_input, "Detected extra file `%s'", psz_file );
+
+        if( psz_list )
+        {
+            char *psz_old = psz_list;
+            /* FIXME how to handle file with ',' ?*/
+            if( asprintf( &psz_list, "%s,%s", psz_old, psz_file ) < 0 )
+            {
+                psz_list = psz_old;
+                break;
+            }
+        }
+        else
+        {
+            psz_list = strdup( psz_file );
+        }
+    }
+    free( psz_file );
+
+    return psz_list;
+}
+
 /*****************************************************************************
  * InputUpdateMeta: merge p_item meta data with p_meta taking care of
  * arturl and locking issue.
@@ -2771,7 +2900,7 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d
     if(! p_demux->p_private )
         return;
 
-    p_id3 = module_Need( p_demux, "meta reader", NULL, 0 );
+    p_id3 = module_need( p_demux, "meta reader", NULL, 0 );
     if( p_id3 )
     {
         demux_meta_t *p_demux_meta = (demux_meta_t *)p_demux->p_private;
@@ -2789,7 +2918,7 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d
                               p_demux_meta->i_attachments, p_demux_meta->attachments );
             vlc_mutex_unlock( &p_input->p->input.p_item->lock );
         }
-        module_Unneed( p_demux, p_id3 );
+        module_unneed( p_demux, p_id3 );
     }
     free( p_demux->p_private );
 }
@@ -2799,8 +2928,8 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d
  * MRLSplit: parse the access, demux and url part of the
  *           Media Resource Locator.
  *****************************************************************************/
-void MRLSplit( char *psz_dup, const char **ppsz_access, const char **ppsz_demux,
-               char **ppsz_path )
+void input_SplitMRL( const char **ppsz_access, const char **ppsz_demux, char **ppsz_path,
+                     char *psz_dup )
 {
     char *psz_access = NULL;
     char *psz_demux  = NULL;
@@ -2819,15 +2948,34 @@ void MRLSplit( char *psz_dup, const char **ppsz_access, const char **ppsz_demux,
         psz_demux = strchr( psz_access, '/' );
         if( psz_demux )
             *psz_demux++ = '\0';
+
+        /* We really don't want module name substitution here! */
+        if( psz_access[0] == '$' )
+            psz_access++;
+        if( psz_demux && psz_demux[0] == '$' )
+            psz_demux++;
     }
     else
     {
         psz_path = psz_dup;
     }
+    *ppsz_access = psz_access ? psz_access : (char*)"";
+    *ppsz_demux = psz_demux ? psz_demux : (char*)"";
+    *ppsz_path = psz_path;
+}
 
-    *ppsz_access = psz_access ? psz_access : "";
-    *ppsz_demux = psz_demux ? psz_demux : "";
-    *ppsz_path = psz_path ? psz_path : "";
+static inline bool next(char ** src)
+{
+    char *end;
+    errno = 0;
+    long result = strtol( *src, &end, 0 );
+    if( errno != 0 || result >= LONG_MAX || result <= LONG_MIN ||
+        end == *src )
+    {
+        return false;
+    }
+    *src = end;
+    return true;
 }
 
 /*****************************************************************************
@@ -2848,19 +2996,30 @@ static void MRLSections( input_thread_t *p_input, char *psz_source,
     /* Start by parsing titles and chapters */
     if( !psz_source || !( psz = strrchr( psz_source, '@' ) ) ) return;
 
+
     /* Check we are really dealing with a title/chapter section */
     psz_check = psz + 1;
     if( !*psz_check ) return;
-    if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
+    if( isdigit(*psz_check) )
+        if(!next(&psz_check)) return;
     if( *psz_check != ':' && *psz_check != '-' && *psz_check ) return;
     if( *psz_check == ':' && ++psz_check )
-        if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
+    {
+        if( isdigit(*psz_check) )
+            if(!next(&psz_check)) return;
+    }
     if( *psz_check != '-' && *psz_check ) return;
     if( *psz_check == '-' && ++psz_check )
-        if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
+    {
+        if( isdigit(*psz_check) )
+            if(!next(&psz_check)) return;
+    }
     if( *psz_check != ':' && *psz_check ) return;
     if( *psz_check == ':' && ++psz_check )
-        if( isdigit(*psz_check) ) strtol( psz_check, &psz_check, 0 );
+    {
+        if( isdigit(*psz_check) )
+            if(!next(&psz_check)) return;
+    }
     if( *psz_check ) return;
 
     /* Separate start and end */
@@ -2900,19 +3059,13 @@ static void MRLSections( input_thread_t *p_input, char *psz_source,
 /*****************************************************************************
  * input_AddSubtitles: add a subtitles file and enable it
  *****************************************************************************/
-bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle,
-                               bool b_check_extension )
+static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_forced )
 {
     input_source_t *sub;
     vlc_value_t count;
     vlc_value_t list;
     char *psz_path, *psz_extension;
 
-    if( b_check_extension && !subtitles_Filter( psz_subtitle ) )
-    {
-        return false;
-    }
-
     /* if we are provided a subtitle.sub file,
      * see if we don't have a subtitle.idx and use it instead */
     psz_path = strdup( psz_subtitle );
@@ -2921,13 +3074,12 @@ bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle,
         psz_extension = strrchr( psz_path, '.');
         if( psz_extension && strcmp( psz_extension, ".sub" ) == 0 )
         {
-            FILE *f;
+            struct stat st;
 
             strcpy( psz_extension, ".idx" );
-            /* FIXME: a portable wrapper for stat() or access() would be more suited */
-            if( ( f = utf8_fopen( psz_path, "rt" ) ) )
+
+            if( !utf8_stat( psz_path, &st ) && S_ISREG( st.st_mode ) )
             {
-                fclose( f );
                 msg_Dbg( p_input, "using %s subtitles file instead of %s",
                          psz_path, psz_subtitle );
                 strcpy( psz_subtitle, psz_path );
@@ -2939,26 +3091,89 @@ bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle,
     var_Change( p_input, "spu-es", VLC_VAR_CHOICESCOUNT, &count, NULL );
 
     sub = InputSourceNew( p_input );
-    if( !InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) )
+    if( InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) )
     {
-        TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
+        free( sub );
+        return;
+    }
+    TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub );
 
-        /* Select the ES */
-        if( !var_Change( p_input, "spu-es", VLC_VAR_GETLIST, &list, NULL ) )
+    /* Select the ES */
+    if( b_forced && !var_Change( p_input, "spu-es", VLC_VAR_GETLIST, &list, NULL ) )
+    {
+        if( count.i_int == 0 )
+            count.i_int++;
+        /* if it was first one, there is disable too */
+
+        if( count.i_int < list.p_list->i_count )
         {
-            if( count.i_int == 0 )
-                count.i_int++;
-            /* if it was first one, there is disable too */
+            int i_id = list.p_list->p_values[count.i_int].i_int;
 
-            if( count.i_int < list.p_list->i_count )
-            {
-                input_ControlPush( p_input, INPUT_CONTROL_SET_ES,
-                                   &list.p_list->p_values[count.i_int] );
-            }
-            var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL );
+            input_EsOutLock( p_input->p->p_es_out );
+            es_out_id_t *p_es = input_EsOutGetFromID( p_input->p->p_es_out, i_id );
+
+            es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES_DEFAULT, p_es );
+            es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES, p_es );
+            input_EsOutUnlock( p_input->p->p_es_out );
         }
+        var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL );
     }
-    else free( sub );
+}
+
+bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle,
+                               bool b_check_extension )
+{
+    vlc_value_t val;
 
+    if( b_check_extension && !subtitles_Filter( psz_subtitle ) )
+        return false;
+
+    assert( psz_subtitle != NULL );
+
+    val.psz_string = strdup( psz_subtitle );
+    if( val.psz_string )
+        input_ControlPush( p_input, INPUT_CONTROL_ADD_SUBTITLE, &val );
     return true;
 }
+
+/*****************************************************************************
+ * input_get_event_manager
+ *****************************************************************************/
+vlc_event_manager_t *input_get_event_manager( input_thread_t *p_input )
+{
+    return &p_input->p->event_manager;
+}
+
+/**/
+/* TODO FIXME nearly the same logic that snapshot code */
+char *input_CreateFilename( vlc_object_t *p_obj, const char *psz_path, const char *psz_prefix, const char *psz_extension )
+{
+    char *psz_file;
+    DIR *path;
+
+    path = utf8_opendir( psz_path );
+    if( path )
+    {
+        closedir( path );
+
+        char *psz_tmp = str_format( p_obj, psz_prefix );
+        if( !psz_tmp )
+            return NULL;
+
+        filename_sanitize( psz_tmp );
+        if( asprintf( &psz_file, "%s"DIR_SEP"%s%s%s",
+                      psz_path, psz_tmp,
+                      psz_extension ? "." : "",
+                      psz_extension ? psz_extension : "" ) < 0 )
+            psz_file = NULL;
+        free( psz_tmp );
+        return psz_file;
+    }
+    else
+    {
+        psz_file = str_format( p_obj, psz_path );
+        path_sanitize( psz_file );
+        return psz_file;
+    }
+}
+