X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=7afbd52f8f2342f6fdebaf773795b0e7b71e4b5a;hb=ae780fe9874757c9c06c443e04ce613d875ab5ca;hp=e4e1d649c748e25aa520ff5f31b205c5b1924187;hpb=c63257e2bfec8d448c250635e7f512623ee70b22;p=vlc

diff --git a/src/input/input.c b/src/input/input.c
index e4e1d649c7..7afbd52f8f 100644
--- a/src/input/input.c
+++ b/src/input/input.c
@@ -43,12 +43,12 @@
 #include "demux.h"
 #include "stream.h"
 #include "item.h"
-#include "ressource.h"
+#include "resource.h"
 
 #include <vlc_sout.h>
 #include "../stream_output/stream_output.h"
 
-#include <vlc_interface.h>
+#include <vlc_dialog.h>
 #include <vlc_url.h>
 #include <vlc_charset.h>
 #include <vlc_strings.h>
@@ -66,16 +66,17 @@ 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, input_ressource_t * );
+                                  const char *, bool, input_resource_t * );
 static  int             Init    ( input_thread_t *p_input );
 static void             End     ( input_thread_t *p_input );
 static void             MainLoop( input_thread_t *p_input );
 
 static void ObjectKillChildrens( input_thread_t *, vlc_object_t * );
 
-static inline int ControlPopNoLock( input_thread_t *, int *, vlc_value_t *, mtime_t i_deadline );
+static inline int ControlPop( 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 );
+static void       ControlRelease( int i_type, vlc_value_t val );
+static bool       Control( input_thread_t *, int, vlc_value_t );
 
 static int  UpdateTitleSeekpointFromAccess( input_thread_t * );
 static void UpdateGenericFromAccess( input_thread_t * );
@@ -93,7 +94,7 @@ static void InputSourceMeta( input_thread_t *, input_source_t *, vlc_meta_t * );
 
 /* TODO */
 //static void InputGetAttachments( input_thread_t *, input_source_t * );
-static void SlaveDemux( input_thread_t *p_input );
+static void SlaveDemux( input_thread_t *p_input, bool *pb_demux_polled );
 static void SlaveSeek( input_thread_t *p_input );
 
 static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta );
@@ -109,6 +110,203 @@ static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_for
 
 static void input_ChangeState( input_thread_t *p_input, int i_state ); /* TODO fix name */
 
+/* Do not let a pts_delay from access/demux go beyong 60s */
+#define INPUT_PTS_DELAY_MAX INT64_C(60000000)
+
+/**
+ * Create a new input_thread_t.
+ *
+ * You need to call input_Start on it when you are done
+ * adding callback on the variables/events you want to monitor.
+ *
+ * \param p_parent a vlc_object
+ * \param p_item an input item
+ * \param psz_log an optional prefix for this input logs
+ * \param p_resource an optional input ressource
+ * \return a pointer to the spawned input thread
+ */
+
+input_thread_t *__input_Create( vlc_object_t *p_parent,
+                                input_item_t *p_item,
+                                const char *psz_log, input_resource_t *p_resource )
+{
+
+    return Create( p_parent, p_item, psz_log, false, p_resource );
+}
+
+/**
+ * Create a new input_thread_t and start it.
+ *
+ * Provided for convenience.
+ *
+ * \see input_Create
+ */
+input_thread_t *__input_CreateAndStart( vlc_object_t *p_parent,
+                                        input_item_t *p_item, const char *psz_log )
+{
+    input_thread_t *p_input = __input_Create( p_parent, p_item, psz_log, NULL );
+
+    if( input_Start( p_input ) )
+    {
+        vlc_object_release( p_input );
+        return NULL;
+    }
+    return p_input;
+}
+
+/**
+ * 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 an error code, VLC_SUCCESS on success
+ */
+int __input_Read( vlc_object_t *p_parent, input_item_t *p_item,
+                   bool b_block )
+{
+    input_thread_t *p_input;
+
+    p_input = Create( p_parent, p_item, NULL, false, NULL );
+    if( !p_input )
+        return VLC_EGENERIC;
+
+    if( b_block )
+    {
+        RunAndDestroy( VLC_OBJECT(p_input) );
+        return VLC_SUCCESS;
+    }
+    else
+    {
+        if( vlc_thread_create( p_input, "input", RunAndDestroy,
+                               VLC_THREAD_PRIORITY_INPUT ) )
+        {
+            input_ChangeState( p_input, ERROR_S );
+            msg_Err( p_input, "cannot create input thread" );
+            vlc_object_release( p_input );
+            return VLC_EGENERIC;
+        }
+    }
+    return VLC_SUCCESS;
+}
+
+/**
+ * Initialize an input and initialize it to preparse the item
+ * This function is blocking. It will only accept parsing regular files.
+ *
+ * \param p_parent a vlc_object_t
+ * \param p_item an input item
+ * \return VLC_SUCCESS or an error
+ */
+int input_Preparse( vlc_object_t *p_parent, input_item_t *p_item )
+{
+    input_thread_t *p_input;
+
+    /* Allocate descriptor */
+    p_input = Create( p_parent, p_item, NULL, true, NULL );
+    if( !p_input )
+        return VLC_EGENERIC;
+
+    if( !Init( p_input ) )
+        End( p_input );
+
+    vlc_object_release( p_input );
+
+    return VLC_SUCCESS;
+}
+
+/**
+ * Start a input_thread_t created by input_Create.
+ *
+ * You must not start an already running input_thread_t.
+ *
+ * \param the input thread to start
+ */
+int input_Start( input_thread_t *p_input )
+{
+    /* Create thread and wait for its readiness. */
+    if( vlc_thread_create( p_input, "input", Run,
+                           VLC_THREAD_PRIORITY_INPUT ) )
+    {
+        input_ChangeState( p_input, ERROR_S );
+        msg_Err( p_input, "cannot create input thread" );
+        return VLC_EGENERIC;
+    }
+    return VLC_SUCCESS;
+}
+
+/**
+ * Request a running input thread to stop and die
+ *
+ * b_abort must be true when a user stop is requested and not because you have
+ * detected an error or an eof. It will be used to properly send the
+ * INPUT_EVENT_ABORT event.
+ *
+ * \param p_input the input thread to stop
+ * \param b_abort true if the input has been aborted by a user request
+ */
+void input_Stop( input_thread_t *p_input, bool b_abort )
+{
+    /* 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) );
+
+    vlc_mutex_lock( &p_input->p->lock_control );
+    p_input->p->b_abort |= b_abort;
+    vlc_mutex_unlock( &p_input->p->lock_control );
+
+    input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL );
+}
+
+input_resource_t *input_DetachResource( input_thread_t *p_input )
+{
+    assert( p_input->b_dead );
+
+    input_resource_SetInput( p_input->p->p_resource, NULL );
+
+    input_resource_t *p_resource = input_resource_Detach( p_input->p->p_resource );
+    p_input->p->p_sout = NULL;
+
+    return p_resource;
+}
+
+/**
+ * Get the item from an input thread
+ * FIXME it does not increase ref count of the item.
+ * if it is used after p_input is destroyed nothing prevent it from
+ * being freed.
+ */
+input_item_t *input_GetItem( input_thread_t *p_input )
+{
+    assert( p_input && p_input->p );
+    return p_input->p->p_item;
+}
+
+/*****************************************************************************
+ * ObjectKillChildrens
+ *****************************************************************************/
+static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj )
+{
+    vlc_list_t *p_list;
+    int i;
+
+    /* FIXME ObjectKillChildrens seems a very bad idea in fact */
+    i = vlc_internals( p_obj )->i_object_type;
+    if( i == VLC_OBJECT_VOUT ||i == VLC_OBJECT_AOUT ||
+        p_obj == VLC_OBJECT(p_input->p->p_sout) ||
+        i == VLC_OBJECT_DECODER )
+        return;
+
+    vlc_object_kill( p_obj );
+
+    p_list = vlc_list_children( p_obj );
+    for( i = 0; i < p_list->i_count; i++ )
+        ObjectKillChildrens( p_input, p_list->p_values[i].p_object );
+    vlc_list_release( p_list );
+}
+
 /*****************************************************************************
  * This function creates a new input, and returns a pointer
  * to its description. On error, it returns NULL.
@@ -117,11 +315,10 @@ static void input_ChangeState( input_thread_t *p_input, int i_state ); /* TODO f
  *****************************************************************************/
 static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
                                const char *psz_header, bool b_quick,
-                               input_ressource_t *p_ressource )
+                               input_resource_t *p_resource )
 {
     static const char input_name[] = "input";
     input_thread_t *p_input = NULL;                 /* thread descriptor */
-    vlc_value_t val;
     int i;
 
     /* Allocate descriptor */
@@ -149,23 +346,12 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     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_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 Common fields */
     p_input->b_eof = false;
-    p_input->b_can_pace_control = true;
+    p_input->p->b_can_pace_control = true;
     p_input->p->i_start = 0;
     p_input->p->i_time  = 0;
     p_input->p->i_stop  = 0;
@@ -183,8 +369,6 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     p_input->p->p_es_out = NULL;
     p_input->p->p_sout   = NULL;
     p_input->p->b_out_pace_control = false;
-    p_input->p->i_pts_delay = 0;
-    p_input->p->i_cr_average = 0;
 
     vlc_gc_incref( p_item ); /* Released in Destructor() */
     p_input->p->p_item = p_item;
@@ -213,16 +397,17 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     p_input->p->slave   = NULL;
 
     /* */
-    if( p_ressource )
-        p_input->p->p_ressource = p_ressource;
+    if( p_resource )
+        p_input->p->p_resource = p_resource;
     else
-        p_input->p->p_ressource = input_ressource_New();
-    input_ressource_SetInput( p_input->p->p_ressource, p_input );
+        p_input->p->p_resource = input_resource_New();
+    input_resource_SetInput( p_input->p->p_resource, p_input );
 
     /* 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;
+    p_input->p->b_abort = false;
 
     /* Parse input options */
     vlc_mutex_lock( &p_item->lock );
@@ -239,16 +424,14 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
     input_ControlVarInit( p_input );
 
     /* */
-    p_input->p->i_cr_average = var_GetInteger( p_input, "cr-average" );
-
     if( !p_input->b_preparsing )
     {
-        var_Get( p_input, "bookmarks", &val );
-        if( val.psz_string )
+        char *psz_bookmarks = var_GetNonEmptyString( p_input, "bookmarks" );
+        if( psz_bookmarks )
         {
             /* FIXME: have a common cfg parsing routine used by sout and others */
             char *psz_parser, *psz_start, *psz_end;
-            psz_parser = val.psz_string;
+            psz_parser = psz_bookmarks;
             while( (psz_start = strchr( psz_parser, '{' ) ) )
             {
                  seekpoint_t *p_seekpoint;
@@ -287,7 +470,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item,
                 vlc_seekpoint_Delete( p_seekpoint );
                 *psz_parser = backup;
             }
-            free( val.psz_string );
+            free( psz_bookmarks );
         }
     }
 
@@ -326,182 +509,22 @@ static void Destructor( input_thread_t * p_input )
     stats_TimerDump( p_input, STATS_TIMER_INPUT_LAUNCHING );
     stats_TimerClean( p_input, STATS_TIMER_INPUT_LAUNCHING );
 
-    if( p_input->p->p_ressource )
-        input_ressource_Delete( p_input->p->p_ressource );
+    if( p_input->p->p_resource )
+        input_resource_Delete( p_input->p->p_resource );
 
     vlc_gc_decref( p_input->p->p_item );
 
     vlc_mutex_destroy( &p_input->p->counters.counters_lock );
 
-    vlc_cond_destroy( &p_input->p->wait_control );
-    vlc_mutex_destroy( &p_input->p->lock_control );
-    free( p_input->p );
-}
-
-/**
- * Initialize an input thread and run it. You will need to monitor the
- * thread to clean up after it is done
- *
- * \param p_parent a vlc_object
- * \param p_item an input item
- * \return a pointer to the spawned input thread
- */
-input_thread_t *__input_CreateThread( vlc_object_t *p_parent,
-                                      input_item_t *p_item )
-{
-    return __input_CreateThreadExtended( p_parent, p_item, NULL, NULL );
-}
-
-/* */
-input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent,
-                                              input_item_t *p_item,
-                                              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_ressource );
-    if( !p_input )
-        return NULL;
-
-    /* Create thread and wait for its readiness. */
-    if( vlc_thread_create( p_input, "input", Run,
-                           VLC_THREAD_PRIORITY_INPUT, false ) )
+    for( int i = 0; i < p_input->p->i_control; i++ )
     {
-        input_ChangeState( p_input, ERROR_S );
-        msg_Err( p_input, "cannot create input thread" );
-        vlc_object_detach( p_input );
-        vlc_object_release( p_input );
-        return NULL;
-    }
-
-    return p_input;
-}
-
-/**
- * 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 an error code, VLC_SUCCESS on success
- */
-int __input_Read( vlc_object_t *p_parent, input_item_t *p_item,
-                   bool b_block )
-{
-    input_thread_t *p_input;
-
-    p_input = Create( p_parent, p_item, NULL, false, NULL );
-    if( !p_input )
-        return VLC_EGENERIC;
-
-    if( b_block )
-    {
-        RunAndDestroy( VLC_OBJECT(p_input) );
-        return VLC_SUCCESS;
+        input_control_t *p_ctrl = &p_input->p->control[i];
+        ControlRelease( p_ctrl->i_type, p_ctrl->val );
     }
-    else
-    {
-        if( vlc_thread_create( p_input, "input", RunAndDestroy,
-                               VLC_THREAD_PRIORITY_INPUT, false ) )
-        {
-            input_ChangeState( p_input, ERROR_S );
-            msg_Err( p_input, "cannot create input thread" );
-            vlc_object_release( p_input );
-            return VLC_EGENERIC;
-        }
-    }
-    return VLC_SUCCESS;
-}
-
-/**
- * Initialize an input and initialize it to preparse the item
- * This function is blocking. It will only accept to parse files
- *
- * \param p_parent a vlc_object_t
- * \param p_item an input item
- * \return VLC_SUCCESS or an error
- */
-int __input_Preparse( vlc_object_t *p_parent, input_item_t *p_item )
-{
-    input_thread_t *p_input;
-
-    /* Allocate descriptor */
-    p_input = Create( p_parent, p_item, NULL, true, NULL );
-    if( !p_input )
-        return VLC_EGENERIC;
-
-    if( !Init( p_input ) )
-        End( p_input );
 
-    vlc_object_detach( p_input );
-    vlc_object_release( p_input );
-
-    return VLC_SUCCESS;
-}
-
-/**
- * Request a running input thread to stop and die
- *
- * \param the input thread to stop
- */
-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 );
-}
-
-input_ressource_t *input_DetachRessource( input_thread_t *p_input )
-{
-    assert( p_input->b_dead );
-
-    input_ressource_t *p_ressource = p_input->p->p_ressource;
-    input_ressource_SetInput( p_ressource, NULL );
-
-    p_input->p->p_ressource = NULL;
-    p_input->p->p_sout = NULL;
-
-    return p_ressource;
-}
-
-/**
- * Get the item from an input thread
- * FIXME it does not increase ref count of the item.
- * if it is used after p_input is destroyed nothing prevent it from
- * being freed.
- */
-input_item_t *input_GetItem( input_thread_t *p_input )
-{
-    assert( p_input && p_input->p );
-    return p_input->p->p_item;
-}
-
-/*****************************************************************************
- * ObjectKillChildrens
- *****************************************************************************/
-static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj )
-{
-    vlc_list_t *p_list;
-    int i;
-
-    /* FIXME ObjectKillChildrens seems a very bad idea in fact */
-    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) ||
-        p_obj->i_object_type == VLC_OBJECT_DECODER ||
-        p_obj->i_object_type == VLC_OBJECT_PACKETIZER )
-        return;
-
-    vlc_object_kill( p_obj );
-
-    p_list = vlc_list_children( p_obj );
-    for( i = 0; i < p_list->i_count; i++ )
-        ObjectKillChildrens( p_input, p_list->p_values[i].p_object );
-    vlc_list_release( p_list );
+    vlc_cond_destroy( &p_input->p->wait_control );
+    vlc_mutex_destroy( &p_input->p->lock_control );
+    free( p_input->p );
 }
 
 /*****************************************************************************
@@ -524,7 +547,14 @@ static void *Run( vlc_object_t *p_this )
 
 exit:
     /* Tell we're dead */
+    vlc_mutex_lock( &p_input->p->lock_control );
+    const bool b_abort = p_input->p->b_abort;
+    vlc_mutex_unlock( &p_input->p->lock_control );
+
+    if( b_abort )
+        input_SendEventAbort( p_input );
     input_SendEventDead( p_input );
+
     vlc_restorecancel( canc );
     return NULL;
 }
@@ -562,14 +592,15 @@ exit:
  * 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 )
+static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, bool *pb_demux_polled, mtime_t i_start_mdate )
 {
     int i_ret;
 
     *pb_changed = false;
+    *pb_demux_polled = p_input->p->input.p_demux->pf_demux != NULL;
 
     if( ( p_input->p->i_stop > 0 && p_input->p->i_time >= p_input->p->i_stop ) ||
-        ( p_input->p->i_run > 0 && *pi_start_mdate+p_input->p->i_run < mdate() ) )
+        ( p_input->p->i_run > 0 && i_start_mdate+p_input->p->i_run < mdate() ) )
         i_ret = 0; /* EOF */
     else
         i_ret = demux_Demux( p_input->p->input.p_demux );
@@ -599,69 +630,67 @@ static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, mtime_t *p
 
     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. */
-            msg_Dbg( p_input, "EOF reached" );
-            p_input->p->input.b_eof = true;
-        }
-        else
-        {
-            vlc_value_t val;
+        msg_Dbg( p_input, "EOF reached" );
+        p_input->p->input.b_eof = true;
+    }
+    else if( i_ret < 0 )
+    {
+        input_ChangeState( p_input, ERROR_S );
+    }
 
-            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 );
-            }
+    if( i_ret > 0 && p_input->p->i_slave > 0 )
+    {
+        bool b_demux_polled;
+        SlaveDemux( p_input, &b_demux_polled );
 
-            /* 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 );
+        *pb_demux_polled |= b_demux_polled;
+    }
+}
 
-            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 );
+static int MainLoopTryRepeat( input_thread_t *p_input, mtime_t *pi_start_mdate )
+{
+    int i_repeat = var_GetInteger( p_input, "input-repeat" );
+    if( i_repeat == 0 )
+        return VLC_EGENERIC;
 
-            /* 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 );
-            }
+    vlc_value_t val;
 
-            /* */
-            *pi_start_mdate = mdate();
-        }
-    }
-    else if( i_ret < 0 )
+    msg_Dbg( p_input, "repeating the same input (%d)", i_repeat );
+    if( i_repeat > 0 )
     {
-        input_ChangeState( p_input, ERROR_S );
+        i_repeat--;
+        var_SetInteger( p_input, "input-repeat", i_repeat );
     }
 
-    if( i_ret > 0 && p_input->p->i_slave > 0 )
+    /* 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 )
     {
-        SlaveDemux( p_input );
+        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 );
+    }
+
+    /* */
+    *pi_start_mdate = mdate();
+    return VLC_SUCCESS;
 }
 
 /**
@@ -705,12 +734,6 @@ static void MainLoopInterface( input_thread_t *p_input )
 static void MainLoopStatistic( input_thread_t *p_input )
 {
     stats_ComputeInputStats( p_input, p_input->p->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 );
-    }
     input_SendEventStatistics( p_input );
 }
 
@@ -736,6 +759,7 @@ static void MainLoop( input_thread_t *p_input )
         mtime_t i_deadline;
         mtime_t i_wakeup;
         bool b_paused;
+        bool b_demux_polled;
 
         /* Demux data */
         b_force_update = false;
@@ -746,11 +770,12 @@ static void MainLoop( input_thread_t *p_input )
         b_paused = p_input->p->i_state == PAUSE_S &&
                    !es_out_GetBuffering( p_input->p->p_es_out );
 
+        b_demux_polled = true;
         if( !b_paused )
         {
             if( !p_input->p->input.b_eof )
             {
-                MainLoopDemux( p_input, &b_force_update, &i_start_mdate );
+                MainLoopDemux( p_input, &b_force_update, &b_demux_polled, i_start_mdate );
 
                 i_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
             }
@@ -761,27 +786,27 @@ static void MainLoop( input_thread_t *p_input )
             }
             else
             {
-                break;
+                if( MainLoopTryRepeat( p_input, &i_start_mdate ) )
+                    break;
             }
         }
 
         /* */
         do {
             i_deadline = i_wakeup;
-            if( b_paused )
+            if( b_paused || !b_demux_polled )
                 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 ) )
+            while( !ControlPop( p_input, &i_type, &val, i_deadline ) )
             {
+
                 msg_Dbg( p_input, "control type=%d", i_type );
 
                 if( Control( p_input, i_type, val ) )
                     b_force_update = true;
             }
-            vlc_mutex_unlock( &p_input->p->lock_control );
 
             /* Update interface and statistics */
             i_current = mdate();
@@ -797,13 +822,9 @@ static void MainLoop( input_thread_t *p_input )
                 i_statistic_update = i_current + INT64_C(1000000);
             }
 
-            /* Check if i_wakeup is still valid */
+            /* Update the wakeup time */
             if( i_wakeup != 0 )
-            {
-                mtime_t i_new_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
-                if( !i_new_wakeup )
-                    i_wakeup = 0;
-            }
+                i_wakeup = es_out_GetWakeup( p_input->p->p_es_out );
         } while( i_current < i_wakeup );
     }
 
@@ -825,6 +846,8 @@ static void InitStatistics( input_thread_t * p_input )
         INIT_COUNTER( demux_read, INTEGER, COUNTER );
         INIT_COUNTER( input_bitrate, FLOAT, DERIVATIVE );
         INIT_COUNTER( demux_bitrate, FLOAT, DERIVATIVE );
+        INIT_COUNTER( demux_corrupted, INTEGER, COUNTER );
+        INIT_COUNTER( demux_discontinuity, INTEGER, COUNTER );
         INIT_COUNTER( played_abuffers, INTEGER, COUNTER );
         INIT_COUNTER( lost_abuffers, INTEGER, COUNTER );
         INIT_COUNTER( displayed_pictures, INTEGER, COUNTER );
@@ -852,7 +875,7 @@ static int InitSout( input_thread_t * p_input )
     char *psz = var_GetNonEmptyString( p_input, "sout" );
     if( psz && strncasecmp( p_input->p->p_item->psz_uri, "vlc:", 4 ) )
     {
-        p_input->p->p_sout  = input_ressource_RequestSout( p_input->p->p_ressource, NULL, psz );
+        p_input->p->p_sout  = input_resource_RequestSout( p_input->p->p_resource, NULL, psz );
         if( !p_input->p->p_sout )
         {
             input_ChangeState( p_input, ERROR_S );
@@ -873,7 +896,7 @@ static int InitSout( input_thread_t * p_input )
     }
     else
     {
-        input_ressource_RequestSout( p_input->p->p_ressource, NULL, NULL );
+        input_resource_RequestSout( p_input->p->p_resource, NULL, NULL );
     }
     free( psz );
 
@@ -897,29 +920,13 @@ static void InitTitle( input_thread_t * p_input )
     {
         /* Setup variables */
         input_ControlVarNavigation( p_input );
-        input_ControlVarTitle( p_input, 0 );
+        input_SendEventTitle( p_input, 0 );
     }
 
     /* Global flag */
-    p_input->b_can_pace_control    = p_master->b_can_pace_control;
+    p_input->p->b_can_pace_control    = p_master->b_can_pace_control;
     p_input->p->b_can_pause        = p_master->b_can_pause;
     p_input->p->b_can_rate_control = p_master->b_can_rate_control;
-
-    /* Fix pts delay */
-    if( p_input->p->i_pts_delay < 0 )
-        p_input->p->i_pts_delay = 0;
-
-    /* If the desynchronisation requested by the user is < 0, we need to
-     * cache more data. */
-    const int i_desynch = var_GetInteger( p_input, "audio-desync" );
-    if( i_desynch < 0 )
-        p_input->p->i_pts_delay -= i_desynch * 1000;
-
-    /* Update cr_average depending on the caching */
-    p_input->p->i_cr_average *= (10 * p_input->p->i_pts_delay / 200000);
-    p_input->p->i_cr_average /= 10;
-    if( p_input->p->i_cr_average < 10 )
-        p_input->p->i_cr_average = 10;
 }
 
 static void StartTitle( input_thread_t * p_input )
@@ -938,9 +945,12 @@ static void StartTitle( input_thread_t * p_input )
         input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &val );
 
     /* Start/stop/run time */
-    p_input->p->i_start = INT64_C(1000000) * var_GetInteger( p_input, "start-time" );
-    p_input->p->i_stop  = INT64_C(1000000) * var_GetInteger( p_input, "stop-time" );
-    p_input->p->i_run   = INT64_C(1000000) * var_GetInteger( p_input, "run-time" );
+    p_input->p->i_start = (int64_t)(1000000.0
+                                     * var_GetFloat( p_input, "start-time" ));
+    p_input->p->i_stop  = (int64_t)(1000000.0
+                                     * var_GetFloat( p_input, "stop-time" ));
+    p_input->p->i_run   = (int64_t)(1000000.0
+                                     * var_GetFloat( p_input, "run-time" ));
     if( p_input->p->i_run < 0 )
     {
         msg_Warn( p_input, "invalid run-time ignored" );
@@ -970,6 +980,7 @@ static void StartTitle( input_thread_t * p_input )
         msg_Warn( p_input, "invalid stop-time ignored" );
         p_input->p->i_stop = 0;
     }
+    p_input->p->b_fast_seek = var_GetBool( p_input, "input-fast-seek" );
 }
 
 static void LoadSubtitles( input_thread_t *p_input )
@@ -1060,22 +1071,48 @@ static void LoadSlaves( input_thread_t *p_input )
     free( psz_org );
 }
 
+static void UpdatePtsDelay( input_thread_t *p_input )
+{
+    input_thread_private_t *p_sys = p_input->p;
+
+    /* Get max pts delay from input source */
+    mtime_t i_pts_delay = p_sys->input.i_pts_delay;
+    for( int i = 0; i < p_sys->i_slave; i++ )
+        i_pts_delay = __MAX( i_pts_delay, p_sys->slave[i]->i_pts_delay );
+
+    if( i_pts_delay < 0 )
+        i_pts_delay = 0;
+
+    /* Take care of audio/spu delay */
+    const mtime_t i_audio_delay = var_GetTime( p_input, "audio-delay" );
+    const mtime_t i_spu_delay   = var_GetTime( p_input, "spu-delay" );
+    const mtime_t i_extra_delay = __MIN( i_audio_delay, i_spu_delay );
+    if( i_extra_delay < 0 )
+        i_pts_delay -= i_extra_delay;
+
+    /* Update cr_average depending on the caching */
+    const int i_cr_average = var_GetInteger( p_input, "cr-average" ) * i_pts_delay / DEFAULT_PTS_DELAY;
+
+    /* */
+    es_out_SetJitter( p_input->p->p_es_out, i_pts_delay, i_cr_average );
+}
+
 static void InitPrograms( input_thread_t * p_input )
 {
     int i_es_out_mode;
     vlc_value_t val;
 
+    /* Compute correct pts_delay */
+    UpdatePtsDelay( p_input );
+
     /* Set up es_out */
     es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, true );
     i_es_out_mode = ES_OUT_MODE_AUTO;
-    val.p_list = NULL;
     if( p_input->p->p_sout )
     {
-        var_Get( p_input, "sout-all", &val );
-        if( val.b_bool )
+        if( var_GetBool( p_input, "sout-all" ) )
         {
             i_es_out_mode = ES_OUT_MODE_ALL;
-            val.p_list = NULL;
         }
         else
         {
@@ -1087,8 +1124,7 @@ static void InitPrograms( input_thread_t * p_input )
             }
             else
             {
-                var_Change( p_input, "programs", VLC_VAR_FREELIST, &val,
-                            NULL );
+                var_FreeList( &val, NULL );
             }
         }
     }
@@ -1134,7 +1170,7 @@ static int Init( input_thread_t * p_input )
 #ifdef ENABLE_SOUT
     ret = InitSout( p_input );
     if( ret != VLC_SUCCESS )
-        return ret; /* FIXME: goto error; should be better here */
+        goto error_stats;
 #endif
 
     /* Create es out */
@@ -1167,7 +1203,9 @@ static int Init( input_thread_t * p_input )
         i_length = 0;
     if( i_length <= 0 )
         i_length = input_item_GetDuration( p_input->p->p_item );
-    input_SendEventTimes( p_input, 0.0, 0, i_length );
+    input_SendEventLength( p_input, i_length );
+
+    input_SendEventPosition( p_input, 0.0, 0 );
 
     if( !p_input->b_preparsing )
     {
@@ -1181,7 +1219,7 @@ static int Init( input_thread_t * p_input )
     {
         p_input->p->b_out_pace_control = (p_input->p->p_sout->i_out_pace_nocontrol > 0);
 
-        if( p_input->b_can_pace_control && p_input->p->b_out_pace_control )
+        if( p_input->p->b_can_pace_control && p_input->p->b_out_pace_control )
         {
             /* We don't want a high input priority here or we'll
              * end-up sucking up all the CPU time */
@@ -1209,12 +1247,8 @@ static int Init( input_thread_t * p_input )
         InputUpdateMeta( p_input, p_meta );
     }
 
-    if( !p_input->b_preparsing )
-    {
-        msg_Dbg( p_input, "`%s' successfully opened",
-                 p_input->p->p_item->psz_uri );
-
-    }
+    msg_Dbg( p_input, "`%s' successfully opened",
+             p_input->p->p_item->psz_uri );
 
     /* initialization is complete */
     input_ChangeState( p_input, PLAYING_S );
@@ -1228,14 +1262,17 @@ error:
         es_out_Delete( p_input->p->p_es_out );
     if( p_input->p->p_es_out_display )
         es_out_Delete( p_input->p->p_es_out_display );
-    if( p_input->p->p_ressource )
+    if( p_input->p->p_resource )
     {
         if( p_input->p->p_sout )
-            input_ressource_RequestSout( p_input->p->p_ressource,
+            input_resource_RequestSout( p_input->p->p_resource,
                                          p_input->p->p_sout, NULL );
-        input_ressource_SetInput( p_input->p->p_ressource, NULL );
+        input_resource_SetInput( p_input->p->p_resource, NULL );
     }
 
+#ifdef ENABLE_SOUT
+error_stats:
+#endif
     if( !p_input->b_preparsing && libvlc_stats( p_input ) )
     {
 #define EXIT_COUNTER( c ) do { if( p_input->p->counters.p_##c ) \
@@ -1246,6 +1283,8 @@ error:
         EXIT_COUNTER( demux_read );
         EXIT_COUNTER( input_bitrate );
         EXIT_COUNTER( demux_bitrate );
+        EXIT_COUNTER( demux_corrupted );
+        EXIT_COUNTER( demux_discontinuity );
         EXIT_COUNTER( played_abuffers );
         EXIT_COUNTER( lost_abuffers );
         EXIT_COUNTER( displayed_pictures );
@@ -1313,22 +1352,15 @@ static void End( input_thread_t * p_input )
 #define CL_CO( c ) stats_CounterClean( p_input->p->counters.p_##c ); p_input->p->counters.p_##c = NULL;
         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->p_item->p_stats );
-            if( p_private->p_stats_computer == p_input )
-            {
-                stats_ComputeGlobalStats( p_input->p_libvlc,
-                                          p_input->p_libvlc->p_stats );
-                /* FIXME how can it be thread safe ? */
-                p_private->p_stats_computer = NULL;
-            }
             CL_CO( read_bytes );
             CL_CO( read_packets );
             CL_CO( demux_read );
             CL_CO( input_bitrate );
             CL_CO( demux_bitrate );
+            CL_CO( demux_corrupted );
+            CL_CO( demux_discontinuity );
             CL_CO( played_abuffers );
             CL_CO( lost_abuffers );
             CL_CO( displayed_pictures );
@@ -1348,17 +1380,19 @@ static void End( input_thread_t * p_input )
 #undef CL_CO
     }
 
+    vlc_mutex_lock( &p_input->p->p_item->lock );
     if( p_input->p->i_attachment > 0 )
     {
         for( i = 0; i < p_input->p->i_attachment; i++ )
             vlc_input_attachment_Delete( p_input->p->attachment[i] );
         TAB_CLEAN( p_input->p->i_attachment, p_input->p->attachment );
     }
+    vlc_mutex_unlock( &p_input->p->p_item->lock );
 
     /* */
-    input_ressource_RequestSout( p_input->p->p_ressource,
+    input_resource_RequestSout( p_input->p->p_resource,
                                  p_input->p->p_sout, NULL );
-    input_ressource_SetInput( p_input->p->p_ressource, NULL );
+    input_resource_SetInput( p_input->p->p_resource, NULL );
 }
 
 /*****************************************************************************
@@ -1371,73 +1405,77 @@ void input_ControlPush( input_thread_t *p_input,
     if( i_type == INPUT_CONTROL_SET_DIE )
     {
         /* Special case, empty the control */
-        p_input->p->i_control = 1;
-        p_input->p->control[0].i_type = i_type;
-        memset( &p_input->p->control[0].val, 0, sizeof( vlc_value_t ) );
+        for( int i = 0; i < p_input->p->i_control; i++ )
+        {
+            input_control_t *p_ctrl = &p_input->p->control[i];
+            ControlRelease( p_ctrl->i_type, p_ctrl->val );
+        }
+        p_input->p->i_control = 0;
     }
-    else if( p_input->p->i_control >= INPUT_CONTROL_FIFO_SIZE )
+
+    if( p_input->p->i_control >= INPUT_CONTROL_FIFO_SIZE )
     {
         msg_Err( p_input, "input control fifo overflow, trashing type=%d",
                  i_type );
+        if( p_val )
+            ControlRelease( i_type, *p_val );
     }
     else
     {
-        p_input->p->control[p_input->p->i_control].i_type = i_type;
+        input_control_t c;
+        c.i_type = i_type;
         if( p_val )
-            p_input->p->control[p_input->p->i_control].val = *p_val;
+            c.val = *p_val;
         else
-            memset( &p_input->p->control[p_input->p->i_control].val, 0,
-                    sizeof( vlc_value_t ) );
+            memset( &c.val, 0, sizeof(c.val) );
 
-        p_input->p->i_control++;
+        p_input->p->control[p_input->p->i_control++] = c;
     }
     vlc_cond_signal( &p_input->p->wait_control );
     vlc_mutex_unlock( &p_input->p->lock_control );
 }
 
-static inline int ControlPopNoLock( input_thread_t *p_input,
-                                    int *pi_type, vlc_value_t *p_val,
-                                    mtime_t i_deadline )
+static inline int ControlPop( input_thread_t *p_input,
+                              int *pi_type, vlc_value_t *p_val,
+                              mtime_t i_deadline )
 {
+    input_thread_private_t *p_sys = p_input->p;
 
-    while( p_input->p->i_control <= 0 )
+    vlc_mutex_lock( &p_sys->lock_control );
+    while( p_sys->i_control <= 0 )
     {
-        if( !vlc_object_alive( p_input ) )
-            return VLC_EGENERIC;
-
-        if( i_deadline < 0 )
+        if( !vlc_object_alive( p_input ) || i_deadline < 0 )
+        {
+            vlc_mutex_unlock( &p_sys->lock_control );
             return VLC_EGENERIC;
+        }
 
-        if( vlc_cond_timedwait( &p_input->p->wait_control, &p_input->p->lock_control, i_deadline ) )
+        if( vlc_cond_timedwait( &p_sys->wait_control, &p_sys->lock_control,
+                                i_deadline ) )
+        {
+            vlc_mutex_unlock( &p_sys->lock_control );
             return VLC_EGENERIC;
+        }
     }
 
-    *pi_type = p_input->p->control[0].i_type;
-    *p_val   = p_input->p->control[0].val;
-
-    p_input->p->i_control--;
-    if( p_input->p->i_control > 0 )
-    {
-        int i;
+    /* */
+    *pi_type = p_sys->control[0].i_type;
+    *p_val   = p_sys->control[0].val;
 
-        for( i = 0; i < p_input->p->i_control; i++ )
-        {
-            p_input->p->control[i].i_type = p_input->p->control[i+1].i_type;
-            p_input->p->control[i].val    = p_input->p->control[i+1].val;
-        }
-    }
+    p_sys->i_control--;
+    if( p_sys->i_control > 0 )
+        memmove( &p_sys->control[0], &p_sys->control[1],
+                 sizeof(*p_sys->control) * p_sys->i_control );
+    vlc_mutex_unlock( &p_sys->lock_control );
 
     return VLC_SUCCESS;
 }
 
 static void ControlReduce( input_thread_t *p_input )
 {
-    int i;
-
-    if( !p_input )
-        return;
+    vlc_mutex_lock( &p_input->p->lock_control );
 
-    for( i = 1; i < p_input->p->i_control; i++ )
+    for( int i = 1; i < p_input->p->i_control; i++ )
     {
         const int i_lt = p_input->p->control[i-1].i_type;
         const int i_ct = p_input->p->control[i].i_type;
@@ -1473,7 +1511,23 @@ static void ControlReduce( input_thread_t *p_input )
                 */
         }
     }
+    vlc_mutex_unlock( &p_input->p->lock_control );
+}
+
+static void ControlRelease( int i_type, vlc_value_t val )
+{
+    switch( i_type )
+    {
+    case INPUT_CONTROL_ADD_SUBTITLE:
+    case INPUT_CONTROL_ADD_SLAVE:
+        free( val.psz_string );
+        break;
+
+    default:
+        break;
+    }
 }
+
 /* Pause input */
 static void ControlPause( input_thread_t *p_input, mtime_t i_control_date )
 {
@@ -1528,9 +1582,7 @@ static void ControlUnpause( input_thread_t *p_input, mtime_t i_control_date )
         {
             /* 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 );
         }
     }
 
@@ -1542,8 +1594,8 @@ static void ControlUnpause( input_thread_t *p_input, mtime_t i_control_date )
         es_out_SetPauseState( p_input->p->p_es_out, false, false, i_control_date );
 }
 
-static bool Control( input_thread_t *p_input, int i_type,
-                           vlc_value_t val )
+static bool Control( input_thread_t *p_input,
+                     int i_type, vlc_value_t val )
 {
     const mtime_t i_control_date = mdate();
     /* FIXME b_force_update is abused, it should be carefully checked */
@@ -1581,7 +1633,7 @@ static bool Control( input_thread_t *p_input, int i_type,
             /* Reset the decoders states and clock sync (before calling the demuxer */
             es_out_SetTime( p_input->p->p_es_out, -1 );
             if( demux_Control( p_input->p->input.p_demux, DEMUX_SET_POSITION,
-                                f_pos ) )
+                                f_pos, !p_input->p->b_fast_seek ) )
             {
                 msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) "
                          "%2.1f%% failed", f_pos * 100 );
@@ -1620,7 +1672,8 @@ static bool Control( input_thread_t *p_input, int i_type,
             es_out_SetTime( p_input->p->p_es_out, -1 );
 
             i_ret = demux_Control( p_input->p->input.p_demux,
-                                    DEMUX_SET_TIME, i_time );
+                                   DEMUX_SET_TIME, i_time,
+                                   !p_input->p->b_fast_seek );
             if( i_ret )
             {
                 int64_t i_length;
@@ -1632,7 +1685,8 @@ static bool Control( input_thread_t *p_input, int i_type,
                 {
                     double f_pos = (double)i_time / (double)i_length;
                     i_ret = demux_Control( p_input->p->input.p_demux,
-                                            DEMUX_SET_POSITION, f_pos );
+                                            DEMUX_SET_POSITION, f_pos,
+                                            !p_input->p->b_fast_seek );
                 }
             }
             if( i_ret )
@@ -1773,7 +1827,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                 i_rate = INPUT_RATE_DEFAULT;
             }
             if( i_rate != p_input->p->i_rate &&
-                !p_input->b_can_pace_control && p_input->p->b_can_rate_control )
+                !p_input->p->b_can_pace_control && p_input->p->b_can_rate_control )
             {
                 int i_ret;
                 if( p_input->p->input.p_access )
@@ -1803,7 +1857,7 @@ static bool Control( input_thread_t *p_input, int i_type,
 
                 if( p_input->p->input.b_rescale_ts )
                 {
-                    const int i_rate_source = (p_input->b_can_pace_control || p_input->p->b_can_rate_control ) ? i_rate : INPUT_RATE_DEFAULT;
+                    const int i_rate_source = (p_input->p->b_can_pace_control || p_input->p->b_can_rate_control ) ? i_rate : INPUT_RATE_DEFAULT;
                     es_out_SetRate( p_input->p->p_es_out, i_rate_source, i_rate );
                 }
 
@@ -1832,12 +1886,18 @@ static bool Control( input_thread_t *p_input, int i_type,
 
         case INPUT_CONTROL_SET_AUDIO_DELAY:
             if( !es_out_SetDelay( p_input->p->p_es_out_display, AUDIO_ES, val.i_time ) )
+            {
                 input_SendEventAudioDelay( p_input, val.i_time );
+                UpdatePtsDelay( p_input );
+            }
             break;
 
         case INPUT_CONTROL_SET_SPU_DELAY:
             if( !es_out_SetDelay( p_input->p->p_es_out_display, SPU_ES, val.i_time ) )
+            {
                 input_SendEventSubtitleDelay( p_input, val.i_time );
+                UpdatePtsDelay( p_input );
+            }
             break;
 
         case INPUT_CONTROL_SET_TITLE:
@@ -1868,7 +1928,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                     es_out_SetTime( p_input->p->p_es_out, -1 );
 
                     demux_Control( p_demux, DEMUX_SET_TITLE, i_title );
-                    input_ControlVarTitle( p_input, i_title );
+                    input_SendEventTitle( p_input, i_title );
                 }
             }
             else if( p_input->p->input.i_title > 0 )
@@ -1889,6 +1949,7 @@ static bool Control( input_thread_t *p_input, int i_type,
 
                     stream_Control( p_input->p->input.p_stream, STREAM_CONTROL_ACCESS,
                                     ACCESS_SET_TITLE, i_title );
+                    input_SendEventTitle( p_input, i_title );
                 }
             }
             break;
@@ -1934,6 +1995,7 @@ static bool Control( input_thread_t *p_input, int i_type,
                     es_out_SetTime( p_input->p->p_es_out, -1 );
 
                     demux_Control( p_demux, DEMUX_SET_SEEKPOINT, i_seekpoint );
+                    input_SendEventSeekpoint( p_input, p_demux->info.i_title, i_seekpoint );
                 }
             }
             else if( p_input->p->input.i_title > 0 )
@@ -1968,16 +2030,14 @@ static bool Control( input_thread_t *p_input, int i_type,
 
                     stream_Control( p_input->p->input.p_stream, STREAM_CONTROL_ACCESS,
                                     ACCESS_SET_SEEKPOINT, i_seekpoint );
+                    input_SendEventSeekpoint( p_input, p_access->info.i_title, i_seekpoint );
                 }
             }
             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:
@@ -2004,7 +2064,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, true ) )
                     {
                         msg_Err( p_input, "seek failed for new slave" );
                         InputSourceClean( slave );
@@ -2029,8 +2089,6 @@ static bool Control( input_thread_t *p_input, int i_type,
                     msg_Warn( p_input, "failed to add %s as slave",
                               val.psz_string );
                 }
-
-                free( val.psz_string );
             }
             break;
 
@@ -2117,6 +2175,7 @@ static bool Control( input_thread_t *p_input, int i_type,
             break;
     }
 
+    ControlRelease( i_type, val );
     return b_force_update;
 }
 
@@ -2275,18 +2334,61 @@ 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 char *psz_access;
     const char *psz_demux;
     char *psz_path;
-    vlc_value_t val;
+    char *psz_var_demux = NULL;
     double f_fps;
 
-    strcpy( psz_dup, psz_mrl );
+    assert( psz_mrl );
+    char *psz_dup = strdup( psz_mrl );
+
+    if( psz_dup == NULL )
+        goto error;
 
     /* Split uri */
     input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_dup );
 
+    /* FIXME: file:// handling plugins do not support URIs properly...
+     * So we pre-decoded the URI to a path for them. Note that we do not do it
+     * for non-standard VLC-specific schemes. */
+    if( !strcmp( psz_access, "file" ) )
+    {
+        if( psz_path[0] != '/'
+#if (DIR_SEP_CHAR != '/')
+            /* We accept invalid URIs too. */
+            && psz_path[0] != DIR_SEP_CHAR
+#endif
+          )
+        {   /* host specified -> only localhost is supported */
+            static const size_t i_localhost = sizeof("localhost")-1;
+            if( strncmp( psz_path, "localhost/", i_localhost + 1) != 0 )
+            {
+                msg_Err( p_input, "cannot open remote file `%s://%s'",
+                         psz_access, psz_path );
+                msg_Info( p_input, "Did you mean `%s:///%s'?",
+                          psz_access, psz_path );
+                goto error;
+            }
+            psz_path += i_localhost;
+        }
+        /* Remove HTML anchor if present (not supported). */
+        char *p = strchr( psz_path, '#' );
+        if( p )
+            *p = '\0';
+        /* Then URI-decode the path. */
+        decode_URI( psz_path );
+#if defined( WIN32 ) && !defined( UNDER_CE )
+        /* Strip leading slash in front of the drive letter */
+        psz_path++;
+#endif
+#if (DIR_SEP_CHAR != '/')
+        /* Turn slashes into anti-slashes */
+        for( char *s = strchr( psz_path, '/' ); s; s = strchr( s + 1, '/' ) )
+            *s = DIR_SEP_CHAR;
+#endif
+    }
+
     msg_Dbg( p_input, "`%s' gives access `%s' demux `%s' path `%s'",
              psz_mrl, psz_access, psz_demux, psz_path );
     if( !p_input->b_preparsing )
@@ -2309,7 +2411,7 @@ static int InputSourceInit( input_thread_t *p_input,
         {
             /* special hack for forcing a demuxer with --demux=module
              * (and do nothing with a list) */
-            char *psz_var_demux = var_GetNonEmptyString( p_input, "demux" );
+            psz_var_demux = var_GetNonEmptyString( p_input, "demux" );
 
             if( psz_var_demux != NULL &&
                 !strchr(psz_var_demux, ',' ) &&
@@ -2339,12 +2441,11 @@ static int InputSourceInit( input_thread_t *p_input,
 
     if( in->p_demux )
     {
-        int64_t i_pts_delay;
-
         /* Get infos from access_demux */
         demux_Control( in->p_demux,
-                        DEMUX_GET_PTS_DELAY, &i_pts_delay );
-        p_input->p->i_pts_delay = __MAX( p_input->p->i_pts_delay, i_pts_delay );
+                        DEMUX_GET_PTS_DELAY, &in->i_pts_delay );
+        in->i_pts_delay = __MAX( 0, __MIN( in->i_pts_delay, INPUT_PTS_DELAY_MAX ) );
+
 
         in->b_title_demux = true;
         if( demux_Control( in->p_demux, DEMUX_GET_TITLE_INFO,
@@ -2357,6 +2458,8 @@ static int InputSourceInit( input_thread_t *p_input,
                             &in->b_can_pace_control ) )
             in->b_can_pace_control = false;
 
+        assert( in->p_demux->pf_demux != NULL || !in->b_can_pace_control );
+
         if( !in->b_can_pace_control )
         {
             if( demux_Control( in->p_demux, DEMUX_CAN_CONTROL_RATE,
@@ -2376,49 +2479,37 @@ static int InputSourceInit( input_thread_t *p_input,
             in->b_can_pause = false;
         var_SetBool( p_input, "can-pause", in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/
         var_SetBool( p_input, "can-rate", !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/
-        var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control );
+        var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control && in->b_can_rate_control );
 
-        int ret = demux_Control( in->p_demux, DEMUX_CAN_SEEK,
-                        &val.b_bool );
-        if( ret != VLC_SUCCESS )
-            val.b_bool = false;
-        var_Set( p_input, "can-seek", val );
+        bool b_can_seek;
+        if( demux_Control( in->p_demux, DEMUX_CAN_SEEK, &b_can_seek ) )
+            b_can_seek = false;
+        var_SetBool( p_input, "can-seek", b_can_seek );
     }
     else
     {
-        int64_t i_pts_delay;
-
         /* Now try a real access */
         in->p_access = access_New( p_input, psz_access, psz_demux, psz_path );
-
-        /* Access failed, URL encoded ? */
-        if( in->p_access == NULL && strchr( psz_path, '%' ) )
-        {
-            decode_URI( psz_path );
-
-            msg_Dbg( p_input, "retrying with access `%s' demux `%s' path `%s'",
-                     psz_access, psz_demux, psz_path );
-
-            in->p_access = access_New( p_input,
-                                        psz_access, psz_demux, psz_path );
-        }
         if( in->p_access == NULL )
         {
-            msg_Err( p_input, "open of `%s' failed: %s", psz_mrl,
-                                                         msg_StackMsg() );
-            intf_UserFatal( VLC_OBJECT( p_input), false,
-                            _("Your input can't be opened"),
-                            _("VLC is unable to open the MRL '%s'."
-                            " Check the log for details."), psz_mrl );
+            if( vlc_object_alive( p_input ) )
+            {
+                msg_Err( p_input, "open of `%s' failed: %s", psz_mrl,
+                                                             msg_StackMsg() );
+                dialog_Fatal( p_input, _("Your input can't be opened"),
+                              _("VLC is unable to open the MRL '%s'."
+                                " Check the log for details."), psz_mrl );
+            }
             goto error;
         }
 
         /* Get infos from access */
         if( !p_input->b_preparsing )
         {
+            bool b_can_seek;
             access_Control( in->p_access,
-                             ACCESS_GET_PTS_DELAY, &i_pts_delay );
-            p_input->p->i_pts_delay = __MAX( p_input->p->i_pts_delay, i_pts_delay );
+                             ACCESS_GET_PTS_DELAY, &in->i_pts_delay );
+            in->i_pts_delay = __MAX( 0, __MIN( in->i_pts_delay, INPUT_PTS_DELAY_MAX ) );
 
             in->b_title_demux = false;
             if( access_Control( in->p_access, ACCESS_GET_TITLE_INFO,
@@ -2433,15 +2524,13 @@ static int InputSourceInit( input_thread_t *p_input,
             in->b_can_rate_control = in->b_can_pace_control;
             in->b_rescale_ts = true;
 
-            access_Control( in->p_access, ACCESS_CAN_PAUSE,
-                             &in->b_can_pause );
+            access_Control( in->p_access, ACCESS_CAN_PAUSE, &in->b_can_pause );
             var_SetBool( p_input, "can-pause", in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/
             var_SetBool( p_input, "can-rate", !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/
             var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control );
 
-            access_Control( in->p_access, ACCESS_CAN_SEEK,
-                             &val.b_bool );
-            var_Set( p_input, "can-seek", val );
+            access_Control( in->p_access, ACCESS_CAN_SEEK, &b_can_seek );
+            var_SetBool( p_input, "can-seek", b_can_seek );
         }
 
         /* */
@@ -2515,13 +2604,13 @@ static int InputSourceInit( input_thread_t *p_input,
         }
 
         {
-            /* Take access redirections into account */
+            /* Take access/stream redirections into account */
             char *psz_real_path;
             char *psz_buf = NULL;
-            if( in->p_access->psz_path )
+            if( in->p_stream->psz_path )
             {
                 const char *psz_a, *psz_d;
-                psz_buf = strdup( in->p_access->psz_path );
+                psz_buf = strdup( in->p_stream->psz_path );
                 input_SplitMRL( &psz_a, &psz_d, &psz_real_path, psz_buf );
             }
             else
@@ -2537,14 +2626,18 @@ static int InputSourceInit( input_thread_t *p_input,
 
         if( in->p_demux == NULL )
         {
-            msg_Err( p_input, "no suitable demux module for `%s/%s://%s'",
-                     psz_access, psz_demux, psz_path );
-            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 at the log for details."), psz_mrl );
+            if( vlc_object_alive( p_input ) )
+            {
+                msg_Err( p_input, "no suitable demux module for `%s/%s://%s'",
+                         psz_access, psz_demux, psz_path );
+                dialog_Fatal( VLC_OBJECT( p_input ),
+                              _("VLC can't recognize the input's format"),
+                              _("The format of '%s' cannot be detected. "
+                                "Have a look at the log for details."), psz_mrl );
+            }
             goto error;
         }
+        assert( in->p_demux->pf_demux != NULL );
 
         /* Get title from demux */
         if( !p_input->b_preparsing && in->i_title <= 0 )
@@ -2562,6 +2655,9 @@ static int InputSourceInit( input_thread_t *p_input,
         }
     }
 
+    free( psz_var_demux );
+    free( psz_dup );
+
     /* Set record capabilities */
     if( demux_Control( in->p_demux, DEMUX_CAN_RECORD, &in->b_can_stream_record ) )
         in->b_can_stream_record = false;
@@ -2610,6 +2706,9 @@ error:
     if( in->p_access )
         access_Delete( in->p_access );
 
+    free( psz_var_demux );
+    free( psz_dup );
+
     return VLC_EGENERIC;
 }
 
@@ -2689,11 +2788,12 @@ static void InputSourceMeta( input_thread_t *p_input,
 }
 
 
-static void SlaveDemux( input_thread_t *p_input )
+static void SlaveDemux( input_thread_t *p_input, bool *pb_demux_polled )
 {
     int64_t i_time;
     int i;
 
+    *pb_demux_polled = false;
     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" );
@@ -2703,11 +2803,18 @@ static void SlaveDemux( input_thread_t *p_input )
     for( i = 0; i < p_input->p->i_slave; i++ )
     {
         input_source_t *in = p_input->p->slave[i];
-        int i_ret = 1;
+        int i_ret;
 
         if( in->b_eof )
             continue;
 
+        const bool b_demux_polled = in->p_demux->pf_demux != NULL;
+        if( !b_demux_polled )
+            continue;
+
+        *pb_demux_polled = true;
+
+        /* Call demux_Demux until we have read enough data */
         if( demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) )
         {
             for( ;; )
@@ -2722,7 +2829,10 @@ static void SlaveDemux( input_thread_t *p_input )
                 }
 
                 if( i_stime >= i_time )
+                {
+                    i_ret = 1;
                     break;
+                }
 
                 if( ( i_ret = demux_Demux( in->p_demux ) ) <= 0 )
                     break;
@@ -2756,7 +2866,7 @@ static void SlaveSeek( input_thread_t *p_input )
     {
         input_source_t *in = p_input->p->slave[i];
 
-        if( demux_Control( in->p_demux, DEMUX_SET_TIME, i_time ) )
+        if( demux_Control( in->p_demux, DEMUX_SET_TIME, i_time, true ) )
         {
             if( !in->b_eof )
                 msg_Err( p_input, "seek failed for slave %d -> EOF", i );
@@ -2774,23 +2884,28 @@ static void SlaveSeek( input_thread_t *p_input )
  *****************************************************************************/
 static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta )
 {
-    vlc_value_t val;
+    static const struct { int i_meta; const char *psz_name; } p_list[] = {
+        { vlc_meta_Title,       "meta-title" },
+        { vlc_meta_Artist,      "meta-artist" },
+        { vlc_meta_Genre,       "meta-genre" },
+        { vlc_meta_Copyright,   "meta-copyright" },
+        { vlc_meta_Description, "meta-description" },
+        { vlc_meta_Date,        "meta-date" },
+        { vlc_meta_URL,         "meta-url" },
+        { 0, NULL }
+    };
 
     /* Get meta information from user */
-#define GET_META( field, s ) do { \
-    var_Get( p_input, (s), &val );  \
-    if( val.psz_string && *val.psz_string ) \
-        vlc_meta_Set( p_meta, vlc_meta_ ## field, val.psz_string ); \
-    free( val.psz_string ); } while(0)
-
-    GET_META( Title, "meta-title" );
-    GET_META( Artist, "meta-artist" );
-    GET_META( Genre, "meta-genre" );
-    GET_META( Copyright, "meta-copyright" );
-    GET_META( Description, "meta-description" );
-    GET_META( Date, "meta-date" );
-    GET_META( URL, "meta-url" );
-#undef GET_META
+    for( int i = 0; p_list[i].psz_name; i++ )
+    {
+        char *psz_string = var_GetNonEmptyString( p_input, p_list[i].psz_name );
+        if( !psz_string )
+            continue;
+
+        EnsureUTF8( psz_string );
+        vlc_meta_Set( p_meta, p_list[i].i_meta, psz_string );
+        free( psz_string );
+    }
 }
 
 /*****************************************************************************
@@ -2799,48 +2914,8 @@ 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 )
 {
-    input_item_t *p_item = p_input->p->p_item;
-
-    char *psz_title = NULL;
-    char *psz_arturl = input_item_GetArtURL( p_item );
-
-    vlc_mutex_lock( &p_item->lock );
-
-    if( vlc_meta_Get( p_meta, vlc_meta_Title ) && !p_item->b_fixed_name )
-        psz_title = strdup( vlc_meta_Get( p_meta, vlc_meta_Title ) );
-
-    vlc_meta_Merge( p_item->p_meta, p_meta );
-
+    es_out_ControlSetMeta( p_input->p->p_es_out, p_meta );
     vlc_meta_Delete( p_meta );
-
-    if( psz_arturl && *psz_arturl )
-    {
-        vlc_meta_Set( p_item->p_meta, vlc_meta_ArtworkURL, psz_arturl );
-
-        if( !strncmp( psz_arturl, "attachment://", strlen("attachment") ) )
-        {
-            /* Don't look for art cover if sout
-             * XXX It can change when sout has meta data support */
-            if( p_input->p->p_sout && !p_input->b_preparsing )
-                vlc_meta_Set( p_item->p_meta, vlc_meta_ArtworkURL, "" );
-            else
-                input_ExtractAttachmentAndCacheArt( p_input );
-        }
-    }
-    free( psz_arturl );
-
-    vlc_mutex_unlock( &p_item->lock );
-
-    if( psz_title )
-    {
-        input_item_SetName( p_item, psz_title );
-        free( psz_title );
-    }
-    input_item_SetPreparsed( p_item, true );
-
-    input_SendEventMeta( p_input );
-
-    /** \todo handle sout meta */
 }
 
 static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment,
@@ -2925,7 +3000,7 @@ static void InputGetExtraFiles( input_thread_t *p_input,
         { ".part1.rar",   "%s.part%.1d.rar",2, 9 },
         { ".part01.rar",  "%s.part%.2d.rar",2, 99, },
         { ".part001.rar", "%s.part%.3d.rar",2, 999 },
-        { ".rar",         "%s.r%.2d",       1, 99 },
+        { ".rar",         "%s.r%.2d",       0, 99 },
         { NULL, NULL, 0, 0 }
     };
 
@@ -3160,7 +3235,7 @@ static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_for
             es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_DEFAULT_BY_ID, i_id );
             es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_BY_ID, i_id );
         }
-        var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL );
+        var_FreeList( &list, NULL );
     }
 }
 
@@ -3220,13 +3295,16 @@ char *input_CreateFilename( vlc_object_t *p_obj, const char *psz_path, const cha
         if( !psz_tmp )
             return NULL;
 
-        filename_sanitize( psz_tmp );
-        if( asprintf( &psz_file, "%s"DIR_SEP"%s%s%s",
-                      psz_path, psz_tmp,
+        char *psz_tmp2 = filename_sanitize( psz_tmp );
+        free( psz_tmp );
+
+        if( !psz_tmp2 ||
+            asprintf( &psz_file, "%s"DIR_SEP"%s%s%s",
+                      psz_path, psz_tmp2,
                       psz_extension ? "." : "",
                       psz_extension ? psz_extension : "" ) < 0 )
             psz_file = NULL;
-        free( psz_tmp );
+        free( psz_tmp2 );
         return psz_file;
     }
     else