/*****************************************************************************

 * input.c: input thread

 *****************************************************************************

 * Copyright (C) 1998-2007 VLC authors and VideoLAN

 *

 * Authors: Christophe Massiot <massiot@via.ecp.fr>

 *          Laurent Aimar <fenrir@via.ecp.fr>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

 *****************************************************************************/

/*****************************************************************************

 * Preamble

 *****************************************************************************/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <vlc_common.h>

#include <vlc_arrays.h>

#include <vlc_decoder.h>

#include <limits.h>

#include <assert.h>

#include <sys/stat.h>

#include "input_internal.h"

#include "event.h"

#include "es_out.h"

#include "demux.h"

#include "item.h"

#include "resource.h"

#include "stream.h"

#include "stream_output/stream_output.h"

#include "mrl_helpers.h"

#include <vlc_aout.h>

#include <vlc_dialog.h>

#include <vlc_url.h>

#include <vlc_charset.h>

#include <vlc_fs.h>

#include <vlc_strings.h>

#include <vlc_modules.h>

#include <vlc_stream.h>

#include <vlc_stream_extractor.h>

#include <vlc_renderer_discovery.h>

#include <vlc_hash.h>

/*****************************************************************************

 * Local prototypes

 *****************************************************************************/

static  void *Run( void * );

static  void *Preparse( void * );

static void             Destroy ( input_thread_t *p_input );

static  int             Init    ( input_thread_t *p_input );

static void             End     ( input_thread_t *p_input );

static void             MainLoop( input_thread_t *p_input, bool b_interactive );

static inline int ControlPop( input_thread_t *, int *, input_control_param_t *, vlc_tick_t i_deadline, bool b_postpone_seek );

static int ControlPopEarly(input_thread_t *input, int *type,

                           input_control_param_t *param);

static void       ControlRelease( int i_type, const input_control_param_t *p_param );

static bool       ControlIsSeekRequest( int i_type );

static bool       Control( input_thread_t *, int, input_control_param_t );

static void       ControlPause( input_thread_t *, vlc_tick_t );

static int  UpdateTitleSeekpointFromDemux( input_thread_t * );

static void UpdateGenericFromDemux( input_thread_t * );

static void UpdateTitleListfromDemux( input_thread_t * );

static void MRLSections( const char *, int *, int *, int *, int *);

static input_source_t *InputSourceNew( const char *psz_mrl );

static int InputSourceInit( input_source_t *in, input_thread_t *p_input,

                            const char *psz_mrl,

                            const char *psz_forced_demux, bool b_in_can_fail );

static void InputSourceDestroy( input_source_t * );

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 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, demux_t *p_demux );

static void InputGetExtraFiles( input_thread_t *p_input,

                                int *pi_list, char ***pppsz_list,

                                const char **psz_access, const char *mrl );

static void AppendAttachment(input_thread_t* p_input,

                              int i_new, input_attachment_t **pp_new);

#define SLAVE_ADD_NOFLAG    0

#define SLAVE_ADD_FORCED    (1<<0)

#define SLAVE_ADD_CANFAIL   (1<<1)

#define SLAVE_ADD_SET_TIME  (1<<2)

static int input_SlaveSourceAdd( input_thread_t *, enum slave_type,

                                 const char *, unsigned );

static char *input_SubtitleFile2Uri( input_thread_t *, const char * );

static void input_ChangeState( input_thread_t *p_input, int i_state, vlc_tick_t ); /* TODO fix name */

/**

 * Start a input_thread_t created by input_Create.

 *

 * You must not start an already running input_thread_t.

 *

 * \param p_input the input thread to start

 */

int input_Start( input_thread_t *p_input )

{

    input_thread_private_t *priv = input_priv(p_input);

    void *(*func)(void *) = Run;

    if( priv->type == INPUT_TYPE_PREPARSING )

        func = Preparse;

    assert( !priv->is_running );

    /* Create thread and wait for its readiness. */

    priv->is_running = !vlc_clone( &priv->thread, func, priv );

    if( !priv->is_running )

    {

        msg_Err( p_input, "cannot create input thread" );

        return VLC_EGENERIC;

    }

    return VLC_SUCCESS;

}

/**

 * Request a running input thread to stop and die

 *

 * \param p_input the input thread to stop

 */

void input_Stop( input_thread_t *p_input )

{

    input_thread_private_t *sys = input_priv(p_input);

    vlc_mutex_lock( &sys->lock_control );

    /* Discard all pending controls */

    for( size_t i = 0; i < sys->i_control; i++ )

    {

        input_control_t *ctrl = &sys->control[i];

        ControlRelease( ctrl->i_type, &ctrl->param );

    }

    sys->i_control = 0;

    sys->is_stopped = true;

    vlc_cond_signal( &sys->wait_control );

    vlc_mutex_unlock( &sys->lock_control );

    vlc_interrupt_kill( &sys->interrupt );

}

/**

 * Close an input

 *

 * It does not call input_Stop itself.

 */

void input_Close( input_thread_t *p_input )

{

    if( input_priv(p_input)->is_running )

        vlc_join( input_priv(p_input)->thread, NULL );

    vlc_interrupt_deinit( &input_priv(p_input)->interrupt );

    Destroy(p_input);

}

void input_SetTime( input_thread_t *p_input, vlc_tick_t i_time, bool b_fast )

{

    input_control_param_t param;

    param.time.i_val = i_time;

    param.time.b_fast_seek = b_fast;

    input_ControlPush( p_input, INPUT_CONTROL_SET_TIME, &param );

}

void input_SetPosition( input_thread_t *p_input, double f_position, bool b_fast )

{

    input_control_param_t param;

    param.pos.f_val = f_position;

    param.pos.b_fast_seek = b_fast;

    input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION, &param );

}

/**

 * 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 != NULL );

    return input_priv(p_input)->p_item;

}

#undef input_Create

input_thread_t * input_Create( vlc_object_t *p_parent, input_item_t *p_item,

                               const struct vlc_input_thread_cfg *cfg )

{

    assert(cfg != NULL);

    /* Allocate descriptor */

    input_thread_private_t *priv;

    priv = vlc_custom_create( p_parent, sizeof( *priv ), "input" );

    if( unlikely(priv == NULL) )

        return NULL;

    priv->master = InputSourceNew( NULL );

    if( !priv->master )

    {

        free( priv );

        return NULL;

    }

    input_thread_t *p_input = &priv->input;

    char * psz_name = input_item_GetName( p_item );

    const char *type_str;

    switch (cfg->type)

    {

        case INPUT_TYPE_PREPARSING:

            type_str = "preparsing ";

            break;

        case INPUT_TYPE_THUMBNAILING:

            type_str = "thumbnailing ";

            break;

        default:

            type_str = "playback";

            break;

    }

    msg_Dbg( p_input, "Creating an input for %s'%s'", type_str, psz_name);

    free( psz_name );

    /* Parse input options */

    input_item_ApplyOptions( VLC_OBJECT(p_input), p_item );

    /* Init Common fields */

    switch (cfg->hw_dec)

    {

        case INPUT_CFG_HW_DEC_DEFAULT:

            priv->hw_dec = var_InheritBool(p_input, "hw-dec");

            break;

        case INPUT_CFG_HW_DEC_DISABLED:

            priv->hw_dec = false;

            break;

        case INPUT_CFG_HW_DEC_ENABLED:

            priv->hw_dec = true;

            break;

        default: vlc_assert_unreachable();

    }

    priv->cbs = cfg->cbs;

    priv->cbs_data = cfg->cbs_data;

    priv->type = cfg->type;

    priv->preparse_subitems = cfg->preparsing.subitems;

    priv->i_start = 0;

    priv->i_stop  = 0;

    priv->i_title_offset = input_priv(p_input)->i_seekpoint_offset = 0;

    priv->i_state = INIT_S;

    priv->is_running = false;

    priv->is_stopped = false;

    priv->b_recording = false;

    priv->rate = 1.f;

    TAB_INIT( priv->i_attachment, priv->attachment );

    priv->p_sout   = NULL;

    priv->b_out_pace_control = priv->type == INPUT_TYPE_THUMBNAILING;

    priv->p_renderer = cfg->renderer && priv->type == INPUT_TYPE_PLAYBACK ?

                vlc_renderer_item_hold( cfg->renderer ) : NULL;

    priv->prev_frame.enabled = priv->prev_frame.end = false;

    priv->prev_frame.last_pts = VLC_TICK_INVALID;

    priv->next_frame_need_data = false;

    priv->viewpoint_changed = false;

    /* Fetch the viewpoint from the mediaplayer or the playlist if any */

    vlc_viewpoint_t *p_viewpoint = var_InheritAddress( p_input, "viewpoint" );

    if (p_viewpoint != NULL)

        priv->viewpoint = *p_viewpoint;

    else

        vlc_viewpoint_init( &priv->viewpoint );

    input_item_Hold( p_item ); /* Released in Destructor() */

    priv->p_item = p_item;

    /* Init Input fields */

    vlc_mutex_lock( &p_item->lock );

    if( !p_item->p_stats )

        p_item->p_stats = calloc( 1, sizeof(*p_item->p_stats) );

    if( priv->type != INPUT_TYPE_PLAYBACK )

    {

        p_input->obj.logger = NULL;

        p_input->obj.no_interact = true;

    }

    /* Make sure the interaction option is honored */

    if( !var_InheritBool( p_input, "interact" ) )

        p_input->obj.no_interact = true;

    else if( cfg->interact )

        p_input->obj.no_interact = false;

    vlc_mutex_unlock( &p_item->lock );

    /* No slave */

    priv->i_slave = 0;

    priv->slave   = NULL;

    /* */

    if( cfg->resource )

        priv->p_resource = input_resource_Hold( cfg->resource );

    else

        priv->p_resource = input_resource_New( VLC_OBJECT( p_input ) );

    input_resource_SetInput( priv->p_resource, p_input );

    /* Init control buffer */

    vlc_mutex_init( &priv->lock_control );

    vlc_cond_init( &priv->wait_control );

    priv->i_control = 0;

    vlc_interrupt_init(&priv->interrupt);

    /* Create Object Variables for private use only */

    vlc_object_InitInputConfig(VLC_OBJECT(p_input),

                               input_priv(p_input)->type != INPUT_TYPE_PREPARSING,

                               true);

    priv->b_low_delay = var_InheritBool( p_input, "low-delay" );

    priv->i_jitter_max = VLC_TICK_FROM_MS(var_InheritInteger( p_input, "clock-jitter" ));

    /* Remove 'Now playing' info as it is probably outdated */

    input_item_SetNowPlaying( p_item, NULL );

    input_item_SetESNowPlaying( p_item, NULL );

    /* */

    if( priv->type == INPUT_TYPE_PLAYBACK && var_InheritBool( p_input, "stats" ) )

        priv->stats = input_stats_Create();

    else

        priv->stats = NULL;

    priv->p_es_out_display = input_EsOutNew(p_input, priv->master, priv->rate,

                                            priv->type);

    if( !priv->p_es_out_display )

    {

        Destroy( p_input );

        return NULL;

    }

    priv->p_es_out = NULL;

    return p_input;

}

static void Destroy(input_thread_t *input)

{

    input_thread_private_t *priv = input_priv(input);

#ifndef NDEBUG

    char *name = input_item_GetName(priv->p_item);

    msg_Dbg(input, "destroying input for '%s'", name);

    free(name);

#endif

    if (priv->p_renderer != NULL)

        vlc_renderer_item_release(priv->p_renderer);

    if (priv->p_es_out_display != NULL)

        vlc_input_es_out_Delete(priv->p_es_out_display);

    if (priv->p_resource != NULL)

        input_resource_Release(priv->p_resource);

    input_source_Release(priv->master);

    input_item_Release(priv->p_item);

    if (priv->stats != NULL)

        input_stats_Destroy(priv->stats);

    for (size_t i = 0; i < priv->i_control; i++)

    {

        input_control_t *ctrl = &priv->control[i];

        ControlRelease(ctrl->i_type, &ctrl->param);

    }

    vlc_object_delete(VLC_OBJECT(input));

}

/*****************************************************************************

 * Run: main thread loop

 * This is the "normal" thread that spawns the input processing chain,

 * reads the stream, cleans up and waits

 *****************************************************************************/

static void *Run( void *data )

{

    input_thread_private_t *priv = data;

    input_thread_t *p_input = &priv->input;

    vlc_thread_set_name("vlc-input");

    vlc_interrupt_set(&priv->interrupt);

    if( !Init( p_input ) )

    {

        MainLoop( p_input, true ); /* FIXME it can be wrong (like with VLM) */

        /* Clean up */

        End( p_input );

    }

    input_SendEventDead( p_input );

    return NULL;

}

static void *Preparse( void *data )

{

    input_thread_private_t *priv = data;

    input_thread_t *p_input = &priv->input;

    vlc_thread_set_name("vlc-preparse");

    vlc_interrupt_set(&priv->interrupt);

    if( !Init( p_input ) )

    {   /* if the demux is a playlist, call Mainloop that will call

         * demux_Demux in order to fetch sub items */

        if( priv->preparse_subitems

         && priv->master->p_demux->pf_readdir != NULL )

            MainLoop( p_input, false );

        End( p_input );

    }

    input_SendEventDead( p_input );

    return NULL;

}

bool input_Stopped( input_thread_t *input )

{

    input_thread_private_t *sys = input_priv(input);

    bool ret;

    vlc_mutex_lock( &sys->lock_control );

    ret = sys->is_stopped;

    vlc_mutex_unlock( &sys->lock_control );

    return ret;

}

static void StartTitle( input_thread_t * p_input, bool restart )

{

    input_thread_private_t *priv = input_priv(p_input);

    vlc_value_t val;

    /* Start title/chapter */

    val.i_int = priv->master->i_title_start - priv->master->i_title_offset;

    if( val.i_int > 0 && val.i_int < priv->master->i_title )

        input_ControlPushHelper( p_input, INPUT_CONTROL_SET_TITLE, &val );

    else if( restart )

    {

        val.i_int = 0;

        input_ControlPushHelper( p_input, INPUT_CONTROL_SET_TITLE, &val );

    }

    val.i_int = priv->master->i_seekpoint_start -

                priv->master->i_seekpoint_offset;

    if( val.i_int > 0 /* TODO: check upper boundary */ )

        input_ControlPushHelper( p_input, INPUT_CONTROL_SET_SEEKPOINT, &val );

}

static void ResetPosition( input_thread_t *p_input )

{

    input_thread_private_t *priv = input_priv(p_input);

    StartTitle( p_input, true );

    /* Seek to start position */

    if( priv->i_start > 0 )

        input_SetTime( p_input, 0, false );

    else

        input_SetPosition( p_input, 0.0f, false );

}

/*****************************************************************************

 * Main loop: Fill buffers from access, and demux

 *****************************************************************************/

/**

 * MainLoopDemux

 * It asks the demuxer to demux some data

 */

static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed )

{

    input_thread_private_t* p_priv = input_priv(p_input);

    demux_t *p_demux = p_priv->master->p_demux;

    int i_ret = VLC_DEMUXER_SUCCESS;

    *pb_changed = false;

    if( p_priv->i_stop > 0 )

    {

        vlc_tick_t i_time;

        if( demux_Control( p_demux, DEMUX_GET_TIME, &i_time ) )

            i_time = VLC_TICK_INVALID;

        if( p_priv->i_stop <= i_time )

            i_ret = VLC_DEMUXER_EOF;

    }

    if( i_ret == VLC_DEMUXER_SUCCESS )

        i_ret = demux_Demux( p_demux );

    i_ret = i_ret > 0 ? VLC_DEMUXER_SUCCESS : ( i_ret < 0 ? VLC_DEMUXER_EGENERIC : VLC_DEMUXER_EOF);

    if( i_ret == VLC_DEMUXER_SUCCESS )

    {

        if( demux_TestAndClearFlags( p_demux, INPUT_UPDATE_TITLE_LIST ) )

            UpdateTitleListfromDemux( p_input );

        if( p_priv->master->b_title_demux )

        {

            i_ret = UpdateTitleSeekpointFromDemux( p_input );

            *pb_changed = true;

        }

        UpdateGenericFromDemux( p_input );

    }

    /* If the input is stopped, we don't signal anything to the es_out and

     * ignore the previous results from the demux, and we need to stop

     * demuxing to let the input close as fast as possible. */

    if (input_Stopped(p_input))

        return;

    if( i_ret == VLC_DEMUXER_EOF )

    {

        msg_Dbg( p_input, "EOF reached" );

        p_priv->master->b_eof = true;

        es_out_Eos(p_priv->p_es_out);

    }

    else if( i_ret == VLC_DEMUXER_EGENERIC )

    {

        input_ChangeState( p_input, ERROR_S, VLC_TICK_INVALID );

    }

    else if( p_priv->i_slave > 0 )

        SlaveDemux( p_input );

}

static vlc_tick_t InputSourceGetLength( input_source_t *source, input_item_t *item,

                                        bool *live )

{

    vlc_tick_t length;

    bool ignored;

    bool *liveptr;

    if (live == NULL)

        liveptr = &ignored;

    else

    {

        liveptr = live;

        *liveptr = false;

    }

    if( demux_Control( source->p_demux, DEMUX_GET_LENGTH, &length, liveptr ) )

        length = VLC_TICK_INVALID;

    if( length == VLC_TICK_INVALID && item != NULL )

        length = input_item_GetDuration( item );

    return length;

}

static void InputSourceStatistics(input_source_t *source, input_item_t *item,

                                  struct vlc_input_es_out *out )

{

    double f_position = 0.0;

    vlc_tick_t i_time;

    vlc_tick_t i_length;

    vlc_tick_t i_normal_time;

    /* update input status variables */

    if( demux_Control( source->p_demux,

                       DEMUX_GET_POSITION, &f_position ) )

        f_position = 0.0;

    if( demux_Control( source->p_demux, DEMUX_GET_TIME, &i_time ) )

        i_time = VLC_TICK_INVALID;

    bool live;

    i_length = InputSourceGetLength( source, item, &live );

    /* In case of failure (not implemented or in case of seek), use VLC_TICK_INVALID. */

    if (demux_Control( source->p_demux, DEMUX_GET_NORMAL_TIME, &i_normal_time ) != VLC_SUCCESS)

        i_normal_time = VLC_TICK_INVALID;

    es_out_SetTimes( out, f_position, i_time, i_normal_time, i_length,

                     live );

}

/**

 * Update timing infos and statistics.

 */

static void MainLoopStatistics( input_thread_t *p_input )

{

    input_thread_private_t *priv = input_priv(p_input);

    InputSourceStatistics( priv->master, priv->p_item, priv->p_es_out );

    for (size_t i = 0; i < priv->i_slave; i++)

    {

        input_source_t *in = priv->slave[i];

        InputSourceStatistics( in, NULL, in->p_slave_es_out );

    }

    if (priv->stats != NULL)

    {

        struct input_stats_t new_stats;

        input_stats_Compute(priv->stats, &new_stats);

        vlc_mutex_lock(&priv->p_item->lock);

        *priv->p_item->p_stats = new_stats;

        vlc_mutex_unlock(&priv->p_item->lock);

        input_SendEventStatistics(p_input, &new_stats);

    }

}

/**

 * MainLoop

 * The main input loop.

 */

static void MainLoop( input_thread_t *p_input, bool b_interactive )

{

    vlc_tick_t i_intf_update = 0;

    vlc_tick_t i_inf_update_delay =

        VLC_TICK_FROM_MS(var_InheritInteger( p_input, "stats-min-report-interval" ));

    vlc_tick_t i_last_seek_mdate = 0;

    if( b_interactive && var_InheritBool( p_input, "start-paused" ) )

        ControlPause( p_input, vlc_tick_now() );

    bool eof_signaled = false;

    demux_t *p_demux = input_priv(p_input)->master->p_demux;

    const bool b_can_demux = p_demux->ops != NULL ?

        (p_demux->ops->demux.demux != NULL || p_demux->ops->demux.readdir != NULL) :

        (p_demux->pf_demux != NULL || p_demux->pf_readdir != NULL);

    while( !input_Stopped( p_input ) && input_priv(p_input)->i_state != ERROR_S )

    {

        vlc_tick_t i_wakeup = -1;

        bool b_paused = input_priv(p_input)->i_state == PAUSE_S;

        /* FIXME if input_priv(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 */

        if( b_paused )

        {

            b_paused = !es_out_GetBuffering( input_priv(p_input)->p_es_out )

                    || input_priv(p_input)->master->b_eof;

            if( b_paused && input_priv(p_input)->next_frame_need_data )

                b_paused = false;

        }

        if( !b_paused )

        {

            if( !input_priv(p_input)->master->b_eof )

            {

                bool b_force_update = false;

                MainLoopDemux( p_input, &b_force_update );

                if( b_can_demux )

                    i_wakeup = es_out_GetWakeup( input_priv(p_input)->p_es_out );

                if( b_force_update )

                    i_intf_update = 0;

                eof_signaled = false;

            }

            else if( !es_out_IsEmpty( input_priv(p_input)->p_es_out ) )

            {

                msg_Dbg( p_input, "waiting decoder fifos to empty" );

                i_wakeup = vlc_tick_now() + INPUT_IDLE_SLEEP;

            }

            else

            {

                bool eof_handled;

                if( !eof_signaled )

                {

                    eof_handled =

                        input_SendEvent(p_input, &(struct vlc_input_event) {

                            .type = INPUT_EVENT_EOF,

                        });

                    eof_signaled = true;

                }

                else

                    eof_handled = true;

                if (eof_handled)

                    i_wakeup = -1;

                else

                    break;

            }

            /* Update interface and statistics */

            vlc_tick_t now = vlc_tick_now();

            if( now >= i_intf_update )

            {

                MainLoopStatistics( p_input );

                i_intf_update = now + i_inf_update_delay;

            }

        }

        /* Handle control */

        for( ;; )

        {

            vlc_tick_t i_deadline = i_wakeup;

            /* Postpone seeking until ES buffering is complete or at most

             * 125 ms. */

            bool b_postpone = es_out_GetBuffering( input_priv(p_input)->p_es_out )

                            && !input_priv(p_input)->master->b_eof;

            if( b_postpone )

            {

                vlc_tick_t now = vlc_tick_now();

                /* Recheck ES buffer level every 20 ms when seeking */

                if( now < i_last_seek_mdate + VLC_TICK_FROM_MS(125)

                 && (i_deadline < 0 || i_deadline > now + VLC_TICK_FROM_MS(20)) )

                    i_deadline = now + VLC_TICK_FROM_MS(20);

                else

                    b_postpone = false;

            }

            int i_type;

            input_control_param_t param;

            if( ControlPop( p_input, &i_type, &param, i_deadline, b_postpone ) )

            {

                if( b_postpone )

                    continue;

                break; /* Wake-up time reached */

            }

            if( Control( p_input, i_type, param ) )

            {

                if( ControlIsSeekRequest( i_type ) )

                    i_last_seek_mdate = vlc_tick_now();

                i_intf_update = 0;

            }

            /* Update the wakeup time */

            if( input_priv(p_input)->next_frame_need_data )

                i_wakeup = 0;

            else if( i_wakeup != 0 )

            {

                i_wakeup = es_out_GetWakeup( input_priv(p_input)->p_es_out );

            }

        }

    }

}

static int InitSout( input_thread_t * p_input )

{

    input_thread_private_t *priv = input_priv(p_input);

    if( priv->type != INPUT_TYPE_PLAYBACK )

        return VLC_SUCCESS;

    /* Find a usable sout and attach it to p_input */

    char *psz = var_GetNonEmptyString( p_input, "sout" );

    if( priv->p_renderer )

    {

        /* Keep sout if it comes from a renderer and if the user didn't touch

         * the sout config */

        bool keep_sout = psz == NULL;

        free(psz);

        const char *psz_renderer_sout = vlc_renderer_item_sout( priv->p_renderer );

        if( asprintf( &psz, "#%s", psz_renderer_sout ) < 0 )

            return VLC_ENOMEM;

        if( keep_sout )

            var_SetBool( p_input, "sout-keep", true );

    }

    if( psz && strncasecmp( priv->p_item->psz_uri, "vlc:", 4 ) )

    {

        priv->p_sout  = input_resource_RequestSout( priv->p_resource, psz );

        if( priv->p_sout == NULL )

        {

            input_ChangeState( p_input, ERROR_S, VLC_TICK_INVALID );

            msg_Err( p_input, "cannot start stream output instance, " \

                              "aborting" );

            free( psz );

            return VLC_EGENERIC;

        }

    }

    else

    {

        input_resource_TerminateSout( priv->p_resource );

    }

    free( psz );

    return VLC_SUCCESS;

}

static void InitProperties( input_thread_t *input )

{

    input_thread_private_t *priv = input_priv(input);

    input_source_t *master = priv->master;

    assert(master);

    int capabilities = 0;

    if( demux_Control( master->p_demux, DEMUX_CAN_SEEK, &master->b_can_seek ) )

        master->b_can_seek = false;

    if( master->b_can_seek )

        capabilities |= VLC_INPUT_CAPABILITIES_SEEKABLE;

    if( master->b_can_pause || !master->b_can_pace_control )

        capabilities |= VLC_INPUT_CAPABILITIES_PAUSEABLE;

    if( !master->b_can_pace_control || master->b_can_rate_control )

        capabilities |= VLC_INPUT_CAPABILITIES_CHANGE_RATE;

    if( !master->b_rescale_ts && !master->b_can_pace_control && master->b_can_rate_control )

        capabilities |= VLC_INPUT_CAPABILITIES_REWINDABLE;

    input_SendEventCapabilities( input, capabilities );

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

    input_source_t *p_master = priv->master;

    if( priv->type != INPUT_TYPE_PLAYBACK )

        return;

    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;

    vlc_mutex_unlock( &priv->p_item->lock );

    /* Send event only if the count is valid or if titles are gone */

    if (had_titles || p_master->i_title > 0)

        input_SendEventTitle( p_input, &(struct vlc_input_event_title) {

            .action = VLC_INPUT_TITLE_NEW_LIST,

            .list = {

                .array = p_master->title,

                .count = p_master->i_title,

            },

        });

}

static void FillFileStatsIfAny( input_thread_t * p_input )

{

    input_thread_private_t *priv = input_priv( p_input );

    input_source_t *master = priv->master;

    stream_t *stream_filters = master->p_demux->s;

    if( stream_filters == NULL )

        return;

    uint64_t size;

    if( vlc_stream_GetSize(stream_filters, &size) == VLC_SUCCESS )