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

 * es.c : Generic audio ES input module for vlc

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

 * Copyright (C) 2001-2008 VLC authors and VideoLAN

 *               2022 VideoLabs

 *

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

 *          Gildas Bazin <gbazin@videolan.org>

 *

 * 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 <math.h>

#include <vlc_common.h>

#include <vlc_arrays.h>

#include <vlc_plugin.h>

#include <vlc_demux.h>

#include <vlc_codec.h>

#include <vlc_codecs.h>

#include <vlc_input.h>

#include <vlc_replay_gain.h>

#include "../../packetizer/a52.h"

#include "../../packetizer/dts_header.h"

#include "../../packetizer/mpegaudio.h"

#include "../../meta_engine/ID3Tag.h"

#include "../../meta_engine/ID3Text.h"

#include "../../meta_engine/ID3Meta.h"

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

 * Module descriptor

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

static int  OpenAudio( vlc_object_t * );

static int  OpenVideo( vlc_object_t * );

static void Close    ( vlc_object_t * );

#define FPS_TEXT N_("Frames per Second")

#define FPS_LONGTEXT N_("This is the frame rate used as a fallback when " \

    "playing MPEG video elementary streams.")

vlc_module_begin ()

    set_subcategory( SUBCAT_INPUT_DEMUX )

    set_description( N_("MPEG-I/II/4 / A52 / DTS / MLP audio" ) )

    set_shortname( N_("Audio ES") )

    set_capability( "demux", 155 )

    set_callbacks( OpenAudio, Close )

    add_shortcut( "mpga", "mp3",

                  "m4a", "mp4a", "aac",

                  "ac3", "a52",

                  "eac3",

                  "dts",

                  "mlp", "thd" )

    add_submodule()

    set_description( N_("MPEG-4 video" ) )

    set_capability( "demux", 7 )

    set_callbacks( OpenVideo, Close )

    add_float( "es-fps", 25, FPS_TEXT, FPS_LONGTEXT )

    add_shortcut( "m4v" )

    add_shortcut( "mp4v" )

vlc_module_end ()

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

 * Local prototypes

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

static int Demux  ( demux_t * );

static int Control( demux_t *, int, va_list );

#define WAV_PROBE_SIZE (512*1024)

#define BASE_PROBE_SIZE (8000)

#define WAV_EXTRA_PROBE_SIZE (44000/2*2*2)

typedef struct

{

    vlc_fourcc_t i_codec;

    bool       b_use_word;

    const char *psz_name;

    int  (*pf_probe)( demux_t *p_demux, uint64_t *pi_offset );

    int  (*pf_init)( demux_t *p_demux );

} codec_t;

typedef struct

{

    vlc_tick_t i_time;

    uint64_t i_pos;

    bs_t br;

} sync_table_ctx_t;

typedef struct

{

    uint16_t i_frames_btw_refs;

    uint32_t i_bytes_btw_refs;

    uint32_t i_ms_btw_refs;

    uint8_t i_bits_per_bytes_dev;

    uint8_t i_bits_per_ms_dev;

    uint8_t *p_bits;

    size_t i_bits;

    sync_table_ctx_t current;

} sync_table_t;

typedef struct

{

    uint32_t i_offset;

    seekpoint_t *p_seekpoint;

} chap_entry_t;

typedef struct

{

    vlc_tick_t i_start;

    char *psz_text;

} sylt_entry_t;

typedef struct

{

    char *psz_language;

    size_t i_count;

    size_t i_current; /* index of next lyric to send as SPU */

    sylt_entry_t *p_entry;

    es_out_id_t *p_es;

} sylt_track_t;

/* Mpga specific */

#define XING_FIELD_STREAMFRAMES    (1 << 0)

#define XING_FIELD_STREAMBYTES     (1 << 1)

#define XING_FIELD_TOC             (1 << 2)

#define XING_FIELD_QUALITY         (1 << 3)

#define XING_MIN_TAG_SIZE           42

#define XING_TOC_COUNTBYTES         100

#define XING_MAX_TAG_SIZE          (XING_MIN_TAG_SIZE + 4 + 4 + XING_TOC_COUNTBYTES + 4 + 2)

#define XING_SUB_ETE_NOK_OTAE       XING_MIN_TAG_SIZE

struct xing_info_s

{

    uint32_t i_frames;

    uint32_t i_bytes;

    uint32_t i_quality;

    vlc_fourcc_t infotag;

    vlc_fourcc_t encoder;

    uint8_t  rgi_toc[XING_TOC_COUNTBYTES];

    float f_peak_signal;

    float f_radio_replay_gain;

    float f_audiophile_replay_gain;

    enum

    {

        XING_MODE_UNKNOWN   = 0,

        XING_MODE_CBR       = 1,

        XING_MODE_ABR       = 2,

        XING_MODE_VBR1      = 3,

        XING_MODE_VBR2      = 4,

        XING_MODE_VBR3      = 5,

        XING_MODE_VBR4      = 6,

        XING_MODE_CBR_2PASS = 8,

        XING_MODE_ABR_2PASS = 9,

    } brmode;

    enum

    {

        XING_AUDIOMODE_UNKNOWN    = 0,

        XING_AUDIOMODE_DPL        = 1,

        XING_AUDIOMODE_DPL2       = 2,

        XING_AUDIOMODE_AMBISONICS = 3,

    } audiomode;

    uint8_t  bitrate_avg;

    uint16_t i_delay_samples;

    uint16_t i_padding_samples;

    uint32_t i_music_length;

};

static int ParseXing( const uint8_t *p_buf, size_t i_buf, struct xing_info_s *xing )

{

    if( i_buf < XING_MIN_TAG_SIZE )

        return VLC_EGENERIC;

    vlc_fourcc_t infotag = VLC_FOURCC(p_buf[0], p_buf[1], p_buf[2], p_buf[3]);

    /* L3Enc VBR info */

    if( infotag == VLC_FOURCC('V','B','R','I') )

    {

        if( GetWBE( &p_buf[4] ) != 0x0001 )

            return VLC_EGENERIC;

        xing->i_bytes = GetDWBE( &p_buf[10] );

        xing->i_frames = GetDWBE( &p_buf[14] );

        xing->infotag = infotag;

        return VLC_SUCCESS;

    }

    /* Xing VBR/CBR tags */

    else if( infotag != VLC_FOURCC('X','i','n','g') &&

             infotag != VLC_FOURCC('I','n','f','o') )

    {

        return VLC_EGENERIC;

    }

    xing->infotag = infotag;

    const uint32_t i_flags = GetDWBE( &p_buf[4] );

    /* compute our variable struct size for early checks */

    const unsigned varsz[4] = { ((i_flags & 0x01) ? 4 : 0),

                                ((i_flags & 0x02) ? 4 : 0),

                                ((i_flags & 0x04) ? XING_TOC_COUNTBYTES : 0),

                                ((i_flags & 0x08) ? 4 : 0) };

    const unsigned i_varallsz = varsz[0] + varsz[1] + varsz[2] + varsz[3];

    const unsigned i_tag_total = XING_MIN_TAG_SIZE + i_varallsz;

    if( i_buf < i_tag_total )

        return VLC_EGENERIC;

    if( i_flags & XING_FIELD_STREAMFRAMES )

        xing->i_frames = GetDWBE( &p_buf[8] );

    if( i_flags & XING_FIELD_STREAMBYTES )

        xing->i_bytes = GetDWBE( &p_buf[8 + varsz[0]] );

    if( i_flags & XING_FIELD_TOC )

        memcpy( xing->rgi_toc, &p_buf[8 + varsz[0] + varsz[1]], XING_TOC_COUNTBYTES );

    if( i_flags & XING_FIELD_QUALITY )

        xing->i_quality = GetDWBE( &p_buf[8 + varsz[0] + varsz[1] + varsz[2]] );

    /* pointer past optional members */

    const uint8_t *p_fixed = &p_buf[8 + i_varallsz];

    /* Original Xing encoder header stops here */

    xing->encoder = VLC_FOURCC(p_fixed[0], p_fixed[1], p_fixed[2], p_fixed[3]); /* char version[9] start */

    if( xing->encoder != VLC_FOURCC('L','A','M','E') &&

        xing->encoder != VLC_FOURCC('L','a','v','c') &&

        xing->encoder != VLC_FOURCC('L','a','v','f') )

        return VLC_SUCCESS;

    xing->brmode  = p_fixed[9] & 0x0f; /* version upper / mode lower */

    uint32_t peak_signal  = GetDWBE( &p_fixed[11] );

    xing->f_peak_signal = peak_signal / 8388608.0; /* pow(2, 23) */

    uint16_t gain = GetWBE( &p_fixed[15] );

    xing->f_radio_replay_gain = (gain & 0x1FF) / /* 9bits val stored x10 */

                                ((gain & 0x200) ? -10.0 : 10.0); /* -sign bit on bit 6 */

    gain = GetWBE( &p_fixed[17] );

    xing->f_radio_replay_gain = (gain & 0x1FF) / /* 9bits val stored x10 */

                                ((gain & 0x200) ? -10.0 : 10.0); /* -sign bit on bit 6 */

    /* flags @19 */

    xing->bitrate_avg = (p_fixed[20] != 0xFF) ? p_fixed[20] : 0; /* clipped to 255, so it's unknown from there */

    xing->i_delay_samples = (p_fixed[21] << 4) | (p_fixed[22] >> 4); /* upper 12bits */

    xing->i_padding_samples = ((p_fixed[22] & 0x0F) << 8) | p_fixed[23]; /* lower 12bits */

    xing->audiomode = (p_fixed[26] >> 3) & 0x07; /* over 16bits, 2b unused / 3b mode / 11b preset */

    xing->i_music_length  = GetDWBE( &p_fixed[28] );

    return VLC_SUCCESS;

}

static int MpgaGetCBRSeekpoint( const struct mpga_frameheader_s *mpgah,

                                const struct xing_info_s *xing,

                                uint64_t i_seekablesize,

                                double f_pos, vlc_tick_t *pi_time, uint64_t *pi_offset )

{

    if( xing->infotag != 0 &&

        xing->infotag != VLC_FOURCC('I','n','f','o') &&

        xing->brmode != XING_MODE_CBR &&

        xing->brmode != XING_MODE_CBR_2PASS )

        return -1;

    if( !mpgah->i_sample_rate || !mpgah->i_samples_per_frame || !mpgah->i_frame_size )

        return -1;

    uint32_t i_total_frames = xing->i_frames ? xing->i_frames

                                             : i_seekablesize / mpgah->i_frame_size;

    /* xing must be optional here */

    uint32_t i_frame = i_total_frames * f_pos;

    *pi_offset = i_frame * mpgah->i_frame_size;

    *pi_time = vlc_tick_from_samples( i_frame * mpgah->i_samples_per_frame,

                                      mpgah->i_sample_rate ) + VLC_TICK_0;

    return 0;

}

static int SeekByPosUsingXingTOC( const struct mpga_frameheader_s *mpgah,

                                  const struct xing_info_s *xing,double pos,

                                  vlc_tick_t *pi_time, uint64_t *pi_offset )

{

    if( !xing->rgi_toc[XING_TOC_COUNTBYTES - 1] ||

        !mpgah->i_sample_rate || !mpgah->i_samples_per_frame )

        return -1;

    unsigned syncentry = pos * XING_TOC_COUNTBYTES;

    syncentry = VLC_CLIP(syncentry, 0, XING_TOC_COUNTBYTES - 1);

    unsigned syncframe = syncentry * xing->i_frames / XING_TOC_COUNTBYTES;

    *pi_time = vlc_tick_from_samples( syncframe * mpgah->i_samples_per_frame,

                                      mpgah->i_sample_rate ) + VLC_TICK_0;

    *pi_offset = xing->rgi_toc[syncentry] * xing->i_bytes / 256;

    return 0;

}

static int SeekByTimeUsingXingTOC( const struct mpga_frameheader_s *mpgah,

                                   const struct xing_info_s *xing,

                                   vlc_tick_t *pi_time, uint64_t *pi_offset )

{

    if( !mpgah->i_sample_rate || !mpgah->i_samples_per_frame || !xing->i_frames ||

        *pi_time < VLC_TICK_0 )

        return -1;

    uint32_t sample = samples_from_vlc_tick( *pi_time - VLC_TICK_0, mpgah->i_sample_rate );

    uint64_t totalsamples = mpgah->i_samples_per_frame * (uint64_t) xing->i_frames;

    return SeekByPosUsingXingTOC( mpgah, xing, (double)sample / totalsamples,

                                  pi_time, pi_offset );

}

static int MpgaSeek( const struct mpga_frameheader_s *mpgah,

                     const struct xing_info_s *xing,

                     uint64_t i_seekablesize, double f_pos,

                     vlc_tick_t *pi_time, uint64_t *pi_offset )

{

    if( f_pos >= 0 ) /* Set Pos */

    {

        if( !MpgaGetCBRSeekpoint( mpgah, xing, i_seekablesize,

                                  f_pos, pi_time, pi_offset ) )

        {

             return 0;

        }

    }

    if( *pi_time != VLC_TICK_INVALID &&

        !SeekByTimeUsingXingTOC( mpgah, xing, pi_time, pi_offset ) )

        return 0;

    return SeekByPosUsingXingTOC( mpgah, xing, f_pos, pi_time, pi_offset );

}

typedef struct

{

    codec_t codec;

    vlc_fourcc_t i_original;

    es_out_id_t *p_es;

    bool  b_start;

    decoder_t   *p_packetizer;

    block_t     *p_packetized_data;

    vlc_tick_t  i_pts;

    vlc_tick_t  i_time_offset;

    uint64_t    i_bytes;

    bool        b_big_endian;

    bool        b_estimate_bitrate;

    unsigned    i_bitrate;  /* extracted from Xing header */

    vlc_tick_t  i_duration;

    bool b_initial_sync_failed;

    unsigned i_packet_size;

    uint64_t i_stream_offset;

    unsigned i_demux_flags;

    float   f_fps;

    /* Mpga specific */

    struct mpga_frameheader_s mpgah;

    struct xing_info_s xing;

    audio_replay_gain_t audio_replay_gain;

    sync_table_t mllt;

    struct

    {

        size_t i_count;

        size_t i_current;

        chap_entry_t *p_entry;

    } chapters;

    /* Synchronized lyrics from ID3v2 SYLT, one track per language */

    struct

    {

        size_t i_count;

        sylt_track_t *p_track;

        bool b_meta_sent; /* true once sylt-data extra meta has been emitted */

    } sylt;

    vlc_meta_t *p_meta;

} demux_sys_t;

static int MpgaProbe( demux_t *p_demux, uint64_t *pi_offset );

static int MpgaInit( demux_t *p_demux );

static int AacProbe( demux_t *p_demux, uint64_t *pi_offset );

static int AacInit( demux_t *p_demux );

static int EA52Probe( demux_t *p_demux, uint64_t *pi_offset );

static int A52Probe( demux_t *p_demux, uint64_t *pi_offset );

static int A52Init( demux_t *p_demux );

static int DtsProbe( demux_t *p_demux, uint64_t *pi_offset );

static int DtsInit( demux_t *p_demux );

static int MlpProbe( demux_t *p_demux, uint64_t *pi_offset );

static int ThdProbe( demux_t *p_demux, uint64_t *pi_offset );

static int MlpInit( demux_t *p_demux );

static bool Parse( demux_t *p_demux, block_t **pp_output );

static int SeekByMlltTable( sync_table_t *, vlc_tick_t *, uint64_t * );

static const codec_t p_codecs[] = {

    { VLC_CODEC_MP4A, false, "mp4 audio",  AacProbe,  AacInit },

    { VLC_CODEC_MPGA, false, "mpeg audio", MpgaProbe, MpgaInit },

    { VLC_CODEC_A52, true,  "a52 audio",  A52Probe,  A52Init },

    { VLC_CODEC_EAC3, true,  "eac3 audio", EA52Probe, A52Init },

    { VLC_CODEC_DTS, false, "dts audio",  DtsProbe,  DtsInit },

    { VLC_CODEC_MLP, false, "mlp audio",  MlpProbe,  MlpInit },

    { VLC_CODEC_TRUEHD, false, "TrueHD audio",  ThdProbe,  MlpInit },

    { 0, false, NULL, NULL, NULL }

};

static int VideoInit( demux_t *p_demux );

static const codec_t codec_m4v = {

    VLC_CODEC_MP4V, false, "mp4 video", NULL,  VideoInit

};

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

 * OpenCommon: initializes demux structures

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

static int OpenCommon( demux_t *p_demux,

                       int i_cat, const codec_t *p_codec, uint64_t i_bs_offset )

{

    demux_sys_t *p_sys;

    es_format_t fmt;

    DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys;

    memset( p_sys, 0, sizeof( demux_sys_t ) );

    p_sys->codec = *p_codec;

    p_sys->p_es = NULL;

    p_sys->b_start = true;

    p_sys->i_stream_offset = i_bs_offset;

    p_sys->b_estimate_bitrate = true;

    p_sys->i_bitrate = 0;

    p_sys->i_duration = 0;

    p_sys->b_big_endian = false;

    p_sys->f_fps = var_InheritFloat( p_demux, "es-fps" );

    p_sys->p_packetized_data = NULL;

    p_sys->chapters.i_current = 0;

    p_sys->xing.f_peak_signal = NAN;

    p_sys->xing.f_radio_replay_gain = NAN;

    p_sys->xing.f_audiophile_replay_gain = NAN;

    TAB_INIT(p_sys->chapters.i_count, p_sys->chapters.p_entry);

    TAB_INIT(p_sys->sylt.i_count, p_sys->sylt.p_track);

    if( vlc_stream_Seek( p_demux->s, p_sys->i_stream_offset ) )

    {

        free( p_sys );

        return VLC_EGENERIC;

    }

    if( p_sys->codec.pf_init( p_demux ) )

    {

        free( p_sys );

        return VLC_EGENERIC;

    }

    if( vlc_stream_Seek( p_demux->s, p_sys->i_stream_offset ) )

    {

        free( p_sys );

        return VLC_EGENERIC;

    }

    msg_Dbg( p_demux, "detected format %4.4s", (const char*)&p_sys->codec.i_codec );

    /* Load the audio packetizer */

    es_format_Init( &fmt, i_cat, p_sys->codec.i_codec );

    fmt.i_original_fourcc = p_sys->i_original;

    p_sys->p_packetizer = demux_PacketizerNew( VLC_OBJECT(p_demux), &fmt, p_sys->codec.psz_name );

    if( !p_sys->p_packetizer )

    {

        free( p_sys );

        return VLC_EGENERIC;

    }

    es_format_t *p_fmt = &p_sys->p_packetizer->fmt_out;

    replay_gain_Merge( &p_fmt->audio_replay_gain, &p_sys->audio_replay_gain );

    /* Register one SPU ES per SYLT language track */

    for( size_t i = 0; i < p_sys->sylt.i_count; i++ )

    {

        sylt_track_t *p_tk = &p_sys->sylt.p_track[i];

        es_format_t spu_fmt;

        es_format_Init( &spu_fmt, SPU_ES, VLC_CODEC_SUBT );

        spu_fmt.psz_description = strdup( _("Lyrics") );

        spu_fmt.psz_language = p_tk->psz_language

                             ? strdup( p_tk->psz_language ) : NULL;

        p_tk->p_es = es_out_Add( p_demux->out, &spu_fmt );

        es_format_Clean( &spu_fmt );

        msg_Dbg( p_demux, "registered %zu synchronized lyrics entries (lang: %s)",

                 p_tk->i_count,

                 p_tk->psz_language ? p_tk->psz_language : "und" );

    }

    for( ;; )

    {

        if( Parse( p_demux, &p_sys->p_packetized_data ) )

            break;

        if( p_sys->p_packetized_data )

            break;

    }

    return VLC_SUCCESS;

}

static int OpenAudio( vlc_object_t *p_this )

{

    demux_t *p_demux = (demux_t*)p_this;

    for( int i = 0; p_codecs[i].i_codec != 0; i++ )

    {

        uint64_t i_offset;

        if( !p_codecs[i].pf_probe( p_demux, &i_offset ) )

            return OpenCommon( p_demux, AUDIO_ES, &p_codecs[i], i_offset );

    }

    return VLC_EGENERIC;

}

static int OpenVideo( vlc_object_t *p_this )

{

    demux_t *p_demux = (demux_t*)p_this;

    /* Only m4v is supported for the moment */

    bool b_m4v_ext    = demux_IsPathExtension( p_demux, ".m4v" );

    bool b_re4_ext    = !b_m4v_ext && demux_IsPathExtension( p_demux, ".re4" );

    bool b_m4v_forced = demux_IsForced( p_demux, "m4v" ) ||

                        demux_IsForced( p_demux, "mp4v" );

    if( !b_m4v_ext && !b_m4v_forced && !b_re4_ext )

        return VLC_EGENERIC;

    ssize_t i_off = b_re4_ext ? 220 : 0;

    const uint8_t *p_peek;

    if( vlc_stream_Peek( p_demux->s, &p_peek, i_off + 4 ) < i_off + 4 )

        return VLC_EGENERIC;

    if( p_peek[i_off + 0] != 0x00 || p_peek[i_off + 1] != 0x00 || p_peek[i_off + 2] != 0x01 )

    {

        if( !b_m4v_forced)

            return VLC_EGENERIC;

        msg_Warn( p_demux,

                  "this doesn't look like an MPEG ES stream, continuing anyway" );

    }

    return OpenCommon( p_demux, VIDEO_ES, &codec_m4v, i_off );

}

static void IncreaseChapter( demux_t *p_demux, vlc_tick_t i_time )

{

    demux_sys_t *p_sys = p_demux->p_sys;

    while( p_sys->chapters.i_current + 1 < p_sys->chapters.i_count )

    {

        const chap_entry_t *p = &p_sys->chapters.p_entry[p_sys->chapters.i_current + 1];

        if( (p->i_offset != UINT32_MAX && vlc_stream_Tell( p_demux->s ) < p->i_offset) ||

            (i_time == VLC_TICK_INVALID || p->p_seekpoint->i_time_offset + VLC_TICK_0 > i_time) )

            break;

        ++p_sys->chapters.i_current;

        p_sys->i_demux_flags |= INPUT_UPDATE_SEEKPOINT;

    }

}

/* Export all SYLT tracks as input item extra meta for the Qt display layer.

 * Called once on the first Demux invocation (deferred from Open) so that

 * the in-band metadata pass (InputSourceMeta / TagLib) has already run and

 * set title/artist/album before we call es_out_SetMeta, which sets the

 * ITEM_PREPARSED flag and would otherwise prevent those passes from running.

 *

 * Encoding: entries are packed as "ms\x1Ftext\x1E" (ASCII Unit Separator 0x1F

 * between timestamp and text; ASCII Record Separator 0x1E after each entry).

 * "sylt-data" carries the first (default) track for backward compatibility;

 * "sylt-data:xxx" carries each language for future language-aware UI. */

static void SyltEmitMeta( demux_t *p_demux )

{

    demux_sys_t *p_sys = p_demux->p_sys;

    for( size_t tk = 0; tk < p_sys->sylt.i_count; tk++ )

    {

        const sylt_track_t *p_tk = &p_sys->sylt.p_track[tk];

        /* 20 bytes for PRId64 decimal digits + 2 ASCII separator bytes per entry */

        size_t i_total = 1; /* null terminator */

        for( size_t i = 0; i < p_tk->i_count; i++ )

            i_total += 22 + strlen( p_tk->p_entry[i].psz_text );

        char *psz_data = malloc( i_total );

        if( !psz_data )

            continue;

        char *p = psz_data;

        *p = '\0';

        for( size_t i = 0; i < p_tk->i_count; i++ )

            p += sprintf( p, "%" PRId64 "\x1F%s\x1E",

                          MS_FROM_VLC_TICK( p_tk->p_entry[i].i_start ),

                          p_tk->p_entry[i].psz_text );

        vlc_meta_t *p_meta = vlc_meta_New();

        if( p_meta )

        {

            char psz_key[32];

            snprintf( psz_key, sizeof(psz_key), "sylt-data:%s",

                      p_tk->psz_language ? p_tk->psz_language : "und" );

            vlc_meta_SetExtra( p_meta, psz_key, psz_data );

            if( tk == 0 ) /* default key for single-language backward compat */

                vlc_meta_SetExtra( p_meta, "sylt-data", psz_data );

            es_out_SetMeta( p_demux->out, p_meta );

            vlc_meta_Delete( p_meta );

        }

        free( psz_data );

    }

    p_sys->sylt.b_meta_sent = true;

}

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

 * Demux: reads and demuxes data packets

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

 * Returns -1 in case of error, 0 in case of EOF, 1 otherwise

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

static int Demux( demux_t *p_demux )

{

    int ret = 1;

    demux_sys_t *p_sys = p_demux->p_sys;

    /* Emit sylt-data meta on the first Demux call, after InputSourceMeta has

     * already run and set title/artist/album. Doing this in Open would set the

     * ITEM_PREPARSED flag prematurely and prevent those metadata passes. */

    if( unlikely( !p_sys->sylt.b_meta_sent ) && p_sys->sylt.i_count > 0 )

        SyltEmitMeta( p_demux );

    block_t *p_block_out = p_sys->p_packetized_data;

    if( p_block_out )

        p_sys->p_packetized_data = NULL;

    else

        ret = Parse( p_demux, &p_block_out ) ? 0 : 1;

    /* Update chapter if any */

    IncreaseChapter( p_demux,

                     p_block_out ? p_sys->i_time_offset + p_block_out->i_dts

                                 : VLC_TICK_INVALID );

    while( p_block_out )

    {

        block_t *p_next = p_block_out->p_next;

        /* Correct timestamp */

        if( p_sys->p_packetizer->fmt_out.i_cat == VIDEO_ES )

        {

            if( p_block_out->i_pts == VLC_TICK_INVALID &&

                p_block_out->i_dts == VLC_TICK_INVALID )

                p_block_out->i_dts = VLC_TICK_0 + p_sys->i_pts + VLC_TICK_FROM_SEC(1) / p_sys->f_fps;

            if( p_block_out->i_dts != VLC_TICK_INVALID )

                p_sys->i_pts = p_block_out->i_dts - VLC_TICK_0;

        }

        else

        {

            p_sys->i_pts = p_block_out->i_pts - VLC_TICK_0;

        }

        if( p_block_out->i_pts != VLC_TICK_INVALID )

        {

            p_block_out->i_pts += p_sys->i_time_offset;

        }

        if( p_block_out->i_dts != VLC_TICK_INVALID )

        {

            p_block_out->i_dts += p_sys->i_time_offset;

            es_out_SetPCR( p_demux->out, p_block_out->i_dts );

        }

        /* Send synchronized lyrics as subtitle blocks */

        if( p_sys->sylt.i_count > 0 && p_block_out->i_dts != VLC_TICK_INVALID )

        {

            vlc_tick_t i_audio_time = p_block_out->i_dts; /* already offset-adjusted above */

            for( size_t tk = 0; tk < p_sys->sylt.i_count; tk++ )

            {

                sylt_track_t *p_tk = &p_sys->sylt.p_track[tk];

                if( !p_tk->p_es )

                    continue;

                while( p_tk->i_current < p_tk->i_count )

                {

                    const sylt_entry_t *e = &p_tk->p_entry[p_tk->i_current];

                    if( VLC_TICK_0 + e->i_start > i_audio_time )

                        break;

                    size_t i_len = strlen( e->psz_text );

                    block_t *p_spu = block_Alloc( i_len + 1 );

                    if( p_spu )

                    {

                        memcpy( p_spu->p_buffer, e->psz_text, i_len + 1 );

                        p_spu->i_dts =

                        p_spu->i_pts = VLC_TICK_0 + e->i_start;

                        if( p_tk->i_current + 1 < p_tk->i_count )

                            p_spu->i_length = p_tk->p_entry[p_tk->i_current + 1].i_start

                                            - e->i_start;

                        else

                            p_spu->i_length = VLC_TICK_FROM_SEC( 5 );

                        es_out_Send( p_demux->out, p_tk->p_es, p_spu );

                    }

                    p_tk->i_current++;

                }

            }

        }

        /* Re-estimate bitrate */

        if( p_sys->b_estimate_bitrate && p_sys->i_pts > VLC_TICK_FROM_MS(500) )

            p_sys->i_bitrate = 8 * CLOCK_FREQ * p_sys->i_bytes

                                   / (p_sys->i_pts - 1);

        p_sys->i_bytes += p_block_out->i_buffer;

        p_block_out->p_next = NULL;

        if( likely(p_sys->p_es) )

            es_out_Send( p_demux->out, p_sys->p_es, p_block_out );

        else

            block_Release( p_block_out );

        p_block_out = p_next;

    }

    return ret;

}

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

 * Close: frees unused data

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

static void Close( vlc_object_t * p_this )

{

    demux_t     *p_demux = (demux_t*)p_this;

    demux_sys_t *p_sys = p_demux->p_sys;

    if( p_sys->p_packetized_data )

        block_ChainRelease( p_sys->p_packetized_data );

    for( size_t i=0; i< p_sys->chapters.i_count; i++ )

        vlc_seekpoint_Delete( p_sys->chapters.p_entry[i].p_seekpoint );

    TAB_CLEAN( p_sys->chapters.i_count, p_sys->chapters.p_entry );

    for( size_t i = 0; i < p_sys->sylt.i_count; i++ )

    {

        sylt_track_t *p_tk = &p_sys->sylt.p_track[i];

        for( size_t j = 0; j < p_tk->i_count; j++ )

            free( p_tk->p_entry[j].psz_text );

        TAB_CLEAN( p_tk->i_count, p_tk->p_entry );

        free( p_tk->psz_language );

    }

    TAB_CLEAN( p_sys->sylt.i_count, p_sys->sylt.p_track );

    if( p_sys->mllt.p_bits )

        free( p_sys->mllt.p_bits );

    if( p_sys->p_meta )

        vlc_meta_Delete( p_sys->p_meta );

    demux_PacketizerDestroy( p_sys->p_packetizer );

    free( p_sys );

}

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

 * Time seek:

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

static void PostSeekCleanup( demux_sys_t *p_sys, vlc_tick_t i_time )

{

    /* Fix time_offset */

    if( i_time >= 0 )

        p_sys->i_time_offset = i_time - p_sys->i_pts;

    /* And reset buffered data */

    if( p_sys->p_packetized_data )

        block_ChainRelease( p_sys->p_packetized_data );

    p_sys->p_packetized_data = NULL;

    /* Reset chapter if any */

    p_sys->chapters.i_current = 0;

    p_sys->i_demux_flags |= INPUT_UPDATE_SEEKPOINT;

    /* Reset synchronized lyrics position */

    for( size_t tk = 0; tk < p_sys->sylt.i_count; tk++ )

    {

        sylt_track_t *p_tk = &p_sys->sylt.p_track[tk];

        p_tk->i_current = 0;

        if( i_time >= 0 )

        {

            for( size_t i = 0; i < p_tk->i_count; i++ )

            {

                if( VLC_TICK_0 + p_tk->p_entry[i].i_start > i_time )

                    break;

                p_tk->i_current = i;

            }

        }

    }

}

static int MovetoTimePos( demux_t *p_demux, vlc_tick_t i_time, uint64_t i_pos )

{

    demux_sys_t *p_sys  = p_demux->p_sys;

    int i_ret = vlc_stream_Seek( p_demux->s, p_sys->i_stream_offset + i_pos );

    if( i_ret != VLC_SUCCESS )

        return i_ret;

    PostSeekCleanup( p_sys, i_time );

    return VLC_SUCCESS;

}

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

 * Control:

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

static int Control( demux_t *p_demux, int i_query, va_list args )

{

    demux_sys_t *p_sys  = p_demux->p_sys;

    bool *pb_bool;

    switch( i_query )

    {

        case DEMUX_HAS_UNSUPPORTED_META:

            pb_bool = va_arg( args, bool * );

            *pb_bool = true;

            return VLC_SUCCESS;

        case DEMUX_GET_META:

            if( p_sys->p_meta == NULL )

                return VLC_EGENERIC;

            vlc_meta_Merge( va_arg( args, vlc_meta_t * ), p_sys->p_meta );

            return VLC_SUCCESS;

        case DEMUX_GET_TIME:

            *va_arg( args, vlc_tick_t * ) = p_sys->i_pts + p_sys->i_time_offset;

            return VLC_SUCCESS;

        case DEMUX_GET_LENGTH:

        {

            if( p_sys->i_duration > 0 )

            {

                *va_arg( args, vlc_tick_t * ) = p_sys->i_duration;

                return VLC_SUCCESS;

            }

            /* compute length from bitrate */

            va_list ap;

            int i_ret;

            va_copy ( ap, args );

            i_ret = demux_vaControlHelper( p_demux->s, p_sys->i_stream_offset,

                                    -1, p_sys->i_bitrate, 1, i_query, ap );

            va_end( ap );

            /* No bitrate, we can't have it precisely, but we can compute

             * a raw approximation with time/position */

            if( i_ret && !p_sys->i_bitrate )

            {

                uint64_t i_stream_size;

                if( vlc_stream_GetSize( p_demux->s, &i_stream_size ) != VLC_SUCCESS )

                    return VLC_EGENERIC;

                uint64_t i_pos = vlc_stream_Tell( p_demux->s );

                float f_pos = (double)i_pos / (double)i_stream_size;

                /* The first few seconds are guaranteed to be very whacky,

                 * don't bother trying ... Too bad */

                if( f_pos < 0.01f ||

                    (p_sys->i_pts + p_sys->i_time_offset) < VLC_TICK_FROM_SEC(8) )

                {

                    return VLC_EGENERIC;

                }

                *va_arg( args, vlc_tick_t * ) =

                    (p_sys->i_pts + p_sys->i_time_offset) / f_pos;

                return VLC_SUCCESS;

            }

            return i_ret;

        }

        case DEMUX_SET_TIME:

        case DEMUX_SET_POSITION:

        {

            vlc_tick_t i_time;

            double f_pos;

            uint64_t i_offset;

            va_list ap;

            va_copy ( ap, args ); /* don't break args for helper fallback */

            if( i_query == DEMUX_SET_TIME )

            {

                i_time = va_arg(ap, vlc_tick_t);

                f_pos = p_sys->i_duration ? i_time / (double) p_sys->i_duration : -1.0;

                if( f_pos > 1.0 )

                    f_pos = 1.0;

            }

            else

            {

                f_pos = va_arg(ap, double);

                i_time = p_sys->i_duration ? p_sys->i_duration * f_pos : VLC_TICK_INVALID;

            }

            va_end( ap );

            /* Try to use ID3 table */

            if( !SeekByMlltTable( &p_sys->mllt, &i_time, &i_offset ) )

                return MovetoTimePos( p_demux, i_time, i_offset );

            if( p_sys->codec.i_codec == VLC_CODEC_MPGA )

            {

                uint64_t streamsize;

                if( !vlc_stream_GetSize( p_demux->s, &streamsize ) &&

                    streamsize > p_sys->i_stream_offset )

                    streamsize -= p_sys->i_stream_offset;

                else

                    streamsize = 0;

                if( !MpgaSeek( &p_sys->mpgah, &p_sys->xing,

                           streamsize, f_pos, &i_time, &i_offset ) )

                {

                    return MovetoTimePos( p_demux, i_time, i_offset );

                }

            }

            /* fallback on bitrate / file position seeking */

            i_time = VLC_TICK_INVALID;

            int ret = demux_vaControlHelper( p_demux->s, p_sys->i_stream_offset, -1,

                                             p_sys->i_bitrate, 1, i_query, args );

            if( ret != VLC_SUCCESS )

                return ret; /* not much we can do */

            if( p_sys->i_bitrate > 0 )

            {

                i_offset = vlc_stream_Tell( p_demux->s ); /* new pos */

                i_time = VLC_TICK_0;

                if( likely(i_offset > p_sys->i_stream_offset) )

                {

                    i_offset -= p_sys->i_stream_offset;

                    i_time += vlc_tick_from_samples( i_offset * 8, p_sys->i_bitrate );

                }

            }

            PostSeekCleanup( p_sys, i_time );

            /* FIXME TODO: implement a high precision seek (with mp3 parsing)

             * needed for multi-input */

            return VLC_SUCCESS;

        }

        case DEMUX_GET_TITLE_INFO:

        {

            if( p_sys->chapters.i_count == 0 )

                return VLC_EGENERIC;

            input_title_t **pp_title = malloc( sizeof(*pp_title) );

            if( !pp_title )

                return VLC_EGENERIC;

            *pp_title = vlc_input_title_New();

            if( !*pp_title )

            {

                free( pp_title );

                return VLC_EGENERIC;

            }