src/input/es_out.c

@@ -703,9 +703,9 @@ static vlc_tick_t EsOutGetWakeup( es_out_t *out )
     /* We do not have a wake up date if the input cannot have its speed
      * controlled or sout is imposing its own or while buffering
      *
-     * FIXME for !input_priv(p_input)->b_can_pace_control a wake-up time is still needed
+     * FIXME for !input_CanPaceControl() a wake-up time is still needed
      * to avoid too heavy buffering */
-    if( !input_priv(p_input)->b_can_pace_control ||
+    if( !input_CanPaceControl(p_input) ||
         input_priv(p_input)->b_out_pace_control ||
         p_sys->b_buffering )
         return 0;
@@ -1278,14 +1278,13 @@ static void EsOutProgramHandleClockSource( es_out_t *out, es_out_pgrm_t *p_pgrm
 {
     es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
     input_thread_t *p_input = p_sys->p_input;
-    input_thread_private_t *priv = input_priv(p_input);
 
-    /* XXX: The clock source selection depends on priv->b_can_pace_control but
+    /* XXX: The clock source selection depends on input_CanPaceControl() but
      * this variable is only initialized from the input_thread_t after the
      * demux is opened. Programs and ES tracks can be created from the demux
      * open callback or midstream (from the demux callback). Therefore, we
      * can't handle the clock source selection after the program is created
-     * since priv->b_can_pace_control might not be initialized. To fix this
+     * since input_CanPaceControl() might not be initialized. To fix this
      * issue, handle clock source selection when the first PCR is sent (from
      * ES_OUT_SET_PCR). */
     assert( p_sys->b_active );
@@ -1293,7 +1292,7 @@ static void EsOutProgramHandleClockSource( es_out_t *out, es_out_pgrm_t *p_pgrm
     switch( p_sys->clock_source )
     {
         case VLC_CLOCK_MASTER_AUTO:
-            if (priv->b_can_pace_control)
+            if (input_CanPaceControl(p_input))
             {
                 p_pgrm->active_clock_source = VLC_CLOCK_MASTER_AUDIO;
                 break;
@@ -3300,7 +3299,7 @@ static int EsOutVaControlLocked( es_out_t *out, input_source_t *source,
         bool b_extra_buffering_allowed = !b_low_delay && EsOutIsExtraBufferingAllowed( out );
         vlc_tick_t i_late = input_clock_Update(
                             p_pgrm->p_input_clock, VLC_OBJECT(p_sys->p_input),
-                            priv->b_can_pace_control || p_sys->b_buffering,
+                            input_CanPaceControl(p_sys->p_input) || p_sys->b_buffering,
                             b_extra_buffering_allowed,
                             i_pcr, vlc_tick_now() );
 

src/input/es_out_timeshift.c

@@ -546,7 +546,7 @@ static int ControlLockedGetWakeup( es_out_t *p_out, vlc_tick_t *pi_wakeup )
 
     if( p_sys->b_delayed )
     {
-        assert( !input_priv(p_sys->p_input)->b_can_pace_control );
+        assert( !input_CanPaceControl( p_sys->p_input ) );
         *pi_wakeup = 0;
     }
     else
@@ -579,7 +579,7 @@ static int ControlLockedSetPauseState( es_out_t *p_out, bool b_source_paused, bo
     else
     {
         i_ret = VLC_EGENERIC;
-        if( !input_priv(p_sys->p_input)->b_can_pace_control )
+        if( !input_CanPaceControl( p_sys->p_input ) )
         {
             if( !p_sys->b_delayed )
                 TsStart( p_out );
@@ -614,7 +614,7 @@ static int ControlLockedSetRate( es_out_t *p_out, float src_rate, float rate )
     else
     {
         i_ret = VLC_EGENERIC;
-        if( !input_priv(p_sys->p_input)->b_can_pace_control )
+        if( !input_CanPaceControl( p_sys->p_input ) )
         {
             if( !p_sys->b_delayed )
                 TsStart( p_out );

src/input/input.c

@@ -304,7 +304,6 @@ static input_thread_t *Create( vlc_object_t *p_parent,
     priv->events_data = events_data;
     priv->b_preparsing = option == INPUT_CREATE_OPTION_PREPARSING;
     priv->b_thumbnailing = option == INPUT_CREATE_OPTION_THUMBNAILING;
-    priv->b_can_pace_control = true;
     priv->i_start = 0;
     priv->i_stop  = 0;
     priv->i_title_offset = input_priv(p_input)->i_seekpoint_offset = 0;
@@ -466,7 +465,7 @@ static void *Run( void *data )
 
     if( !Init( p_input ) )
     {
-        if( priv->b_can_pace_control && priv->b_out_pace_control )
+        if( priv->master->b_can_pace_control && priv->b_out_pace_control )
         {
             /* We don't want a high input priority here or we'll
              * end-up sucking up all the CPU time */
@@ -704,7 +703,7 @@ static void MainLoop( input_thread_t *p_input, bool b_interactive )
             }
             /* Pause after eof only if the input is pausable.
              * This way we won't trigger timeshifting for nothing */
-            else if( b_pause_after_eof && input_priv(p_input)->b_can_pause )
+            else if( b_pause_after_eof && input_priv(p_input)->master->b_can_pause )
             {
                 if( b_paused_at_eof )
                     break;
@@ -826,6 +825,55 @@ static int InitSout( input_thread_t * p_input )
 }
 #endif
 
+static void InitProperties( input_thread_t *input )
+{
+    input_thread_private_t *priv = input_priv(input);
+    input_source_t *master = priv->master;
+    assert(master);
+
+    int capabilites = 0;
+    bool b_can_seek;
+
+    if( demux_Control( master->p_demux, DEMUX_CAN_SEEK, &b_can_seek ) )
+        b_can_seek = false;
+    if( b_can_seek )
+        capabilites |= VLC_INPUT_CAPABILITIES_SEEKABLE;
+
+    if( master->b_can_pause || !master->b_can_pace_control )
+        capabilites |= VLC_INPUT_CAPABILITIES_PAUSEABLE;
+    if( !master->b_can_pace_control || master->b_can_rate_control )
+        capabilites |= VLC_INPUT_CAPABILITIES_CHANGE_RATE;
+    if( !master->b_rescale_ts && !master->b_can_pace_control && master->b_can_rate_control )
+        capabilites |= VLC_INPUT_CAPABILITIES_REWINDABLE;
+
+#ifdef ENABLE_SOUT
+    capabilites |= VLC_INPUT_CAPABILITIES_RECORDABLE;
+#else
+    if( master->b_can_stream_record )
+        capabilites |= VLC_INPUT_CAPABILITIES_RECORDABLE;
+#endif
+
+    input_SendEventCapabilities( input, capabilites );
+
+    int i_attachment;
+    input_attachment_t **attachment;
+    if( !demux_Control( master->p_demux, DEMUX_GET_ATTACHMENTS,
+                        &attachment, &i_attachment ) )
+    {
+        vlc_mutex_lock( &priv->p_item->lock );
+        AppendAttachment( input, i_attachment, attachment );
+        vlc_mutex_unlock( &priv->p_item->lock );
+    }
+
+    int input_type;
+    if( !demux_Control( master->p_demux, DEMUX_GET_TYPE, &input_type ) )
+    {
+        vlc_mutex_lock( &priv->p_item->lock );
+        priv->p_item->i_type = input_type;
+        vlc_mutex_unlock( &priv->p_item->lock );
+    }
+}
+
 static void InitTitle( input_thread_t * p_input, bool had_titles )
 {
     input_thread_private_t *priv = input_priv(p_input);
@@ -837,11 +885,6 @@ static void InitTitle( input_thread_t * p_input, bool had_titles )
     vlc_mutex_lock( &priv->p_item->lock );
     priv->i_title_offset = p_master->i_title_offset;
     priv->i_seekpoint_offset = p_master->i_seekpoint_offset;
-
-    /* Global flag */
-    priv->b_can_pace_control = p_master->b_can_pace_control;
-    priv->b_can_pause        = p_master->b_can_pause;
-    priv->b_can_rate_control = p_master->b_can_rate_control;
     vlc_mutex_unlock( &priv->p_item->lock );
 
     /* Send event only if the count is valid or if titles are gone */
@@ -1302,6 +1345,8 @@ static int Init( input_thread_t * p_input )
         goto error;
     }
 
+    InitProperties( p_input );
+
     InitTitle( p_input, false );
 
     /* Load master infos */
@@ -1646,7 +1691,7 @@ static void ControlPause( input_thread_t *p_input, vlc_tick_t i_control_date )
 {
     int i_state = PAUSE_S;
 
-    if( input_priv(p_input)->b_can_pause )
+    if( input_priv(p_input)->master->b_can_pause )
     {
         demux_t *p_demux = input_priv(p_input)->master->p_demux;
 
@@ -1658,7 +1703,8 @@ static void ControlPause( input_thread_t *p_input, vlc_tick_t i_control_date )
     }
 
     /* */
-    if( es_out_SetPauseState( input_priv(p_input)->p_es_out, input_priv(p_input)->b_can_pause,
+    if( es_out_SetPauseState( input_priv(p_input)->p_es_out,
+                              input_priv(p_input)->master->b_can_pause,
                               true, i_control_date ) )
     {
         msg_Warn( p_input, "cannot set pause state at es_out level" );
@@ -1671,7 +1717,7 @@ static void ControlPause( input_thread_t *p_input, vlc_tick_t i_control_date )
 
 static void ControlUnpause( input_thread_t *p_input, vlc_tick_t i_control_date )
 {
-    if( input_priv(p_input)->b_can_pause )
+    if( input_priv(p_input)->master->b_can_pause )
     {
         demux_t *p_demux = input_priv(p_input)->master->p_demux;
 
@@ -2073,14 +2119,14 @@ static bool Control( input_thread_t *p_input,
             }
 
             if( rate != 1.f &&
-                ( ( !priv->b_can_rate_control && !priv->master->b_rescale_ts ) ||
+                ( ( !priv->master->b_can_rate_control && !priv->master->b_rescale_ts ) ||
                   ( priv->p_sout && !priv->b_out_pace_control ) ) )
             {
                 msg_Dbg( p_input, "cannot change rate" );
                 rate = 1.f;
             }
             if( rate != priv->rate &&
-                !priv->b_can_pace_control && priv->b_can_rate_control )
+                !priv->master->b_can_pace_control && priv->master->b_can_rate_control )
             {
                 if( !priv->master->b_rescale_ts )
                     es_out_Control( priv->p_es_out, ES_OUT_RESET_PCR );
@@ -2101,7 +2147,8 @@ static bool Control( input_thread_t *p_input,
 
                 if( priv->master->b_rescale_ts )
                 {
-                    const float rate_source = (priv->b_can_pace_control || priv->b_can_rate_control ) ? rate : 1.f;
+                    const float rate_source = (priv->master->b_can_pace_control ||
+                        priv->master->b_can_rate_control ) ? rate : 1.f;
                     es_out_SetRate( priv->p_es_out, rate_source, rate );
                 }
 
@@ -2733,13 +2780,6 @@ static int InputSourceInit( input_source_t *in, input_thread_t *p_input,
     }
 
     /* Get infos from (access_)demux */
-    int capabilites = 0;
-    bool b_can_seek;
-    if( demux_Control( in->p_demux, DEMUX_CAN_SEEK, &b_can_seek ) )
-        b_can_seek = false;
-    if( b_can_seek )
-        capabilites |= VLC_INPUT_CAPABILITIES_SEEKABLE;
-
     if( demux_Control( in->p_demux, DEMUX_CAN_CONTROL_PACE,
                        &in->b_can_pace_control ) )
         in->b_can_pace_control = false;
@@ -2764,28 +2804,15 @@ static int InputSourceInit( input_source_t *in, input_thread_t *p_input,
         in->b_rescale_ts = true;
     }
 
-    demux_Control( in->p_demux, DEMUX_CAN_PAUSE, &in->b_can_pause );
-
-    if( in->b_can_pause || !in->b_can_pace_control )
-        capabilites |= VLC_INPUT_CAPABILITIES_PAUSEABLE;
-    if( !in->b_can_pace_control || in->b_can_rate_control )
-        capabilites |= VLC_INPUT_CAPABILITIES_CHANGE_RATE;
-    if( !in->b_rescale_ts && !in->b_can_pace_control && in->b_can_rate_control )
-        capabilites |= VLC_INPUT_CAPABILITIES_REWINDABLE;
-
     /* 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_GetBool( p_input, "input-record-native" ) )
         in->b_can_stream_record = false;
-    capabilites |= VLC_INPUT_CAPABILITIES_RECORDABLE;
-#else
-    if( in->b_can_stream_record )
-        capabilites |= VLC_INPUT_CAPABILITIES_RECORDABLE;
 #endif
 
-    input_SendEventCapabilities( p_input, capabilites );
+    demux_Control( in->p_demux, DEMUX_CAN_PAUSE, &in->b_can_pause );
 
     /* get attachment
      * FIXME improve for b_preparsing: move it after GET_META and check psz_arturl */
@@ -2809,27 +2836,9 @@ static int InputSourceInit( input_source_t *in, input_thread_t *p_input,
             in->i_pts_delay = 0;
     }
 
-    int i_attachment;
-    input_attachment_t **attachment;
-    if( !demux_Control( in->p_demux, DEMUX_GET_ATTACHMENTS,
-                         &attachment, &i_attachment ) )
-    {
-        vlc_mutex_lock( &input_priv(p_input)->p_item->lock );
-        AppendAttachment( p_input, i_attachment, attachment );
-        vlc_mutex_unlock( &input_priv(p_input)->p_item->lock );
-    }
-
     if( demux_Control( in->p_demux, DEMUX_GET_FPS, &in->f_fps ) )
         in->f_fps = 0.f;
 
-    int input_type;
-    if( !demux_Control( in->p_demux, DEMUX_GET_TYPE, &input_type ) )
-    {
-        vlc_mutex_lock( &input_priv(p_input)->p_item->lock );
-        input_priv(p_input)->p_item->i_type = input_type;
-        vlc_mutex_unlock( &input_priv(p_input)->p_item->lock );
-    }
-
     if( var_GetInteger( p_input, "clock-synchro" ) != -1 )
         in->b_can_pace_control = !var_GetInteger( p_input, "clock-synchro" );
 
@@ -3550,3 +3559,9 @@ input_attachment_t *input_GetAttachment(input_thread_t *input, const char *name)
     vlc_mutex_unlock( &priv->p_item->lock );
     return NULL;
 }
+
+bool input_CanPaceControl(input_thread_t *input)
+{
+    input_thread_private_t *priv = input_priv(input);
+    return priv->master->b_can_pace_control;
+}

src/input/input_internal.h

@@ -471,9 +471,6 @@ typedef struct input_thread_private_t
 
     /* Global properties */
     bool        b_preparsing;
-    bool        b_can_pause;
-    bool        b_can_rate_control;
-    bool        b_can_pace_control;
 
     /* Current state */
     int         i_state;
@@ -658,6 +655,8 @@ int input_GetAttachments(input_thread_t *input, input_attachment_t ***attachment
 
 input_attachment_t *input_GetAttachment(input_thread_t *input, const char *name);
 
+bool input_CanPaceControl(input_thread_t *input);
+
 /**
  * Hold the input_source_t
  */