开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
es_out.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：86k
源码类别：

midi

开发平台：

Unix_Linux

es_out.c：源码内容
  1. /*****************************************************************************
  2.  * es_out.c: Es Out handler for input.
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2004 the VideoLAN team
  5.  * $Id: 6f12b1877aafbdf799a9ce18684a11b998b7ec95 $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *          Jean-Paul Saman <jpsaman #_at_# m2x dot nl>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <stdio.h>
  33. #include <assert.h>
  34. #include <vlc_common.h>
  36. #include <vlc_input.h>
  37. #include <vlc_es_out.h>
  38. #include <vlc_block.h>
  39. #include <vlc_aout.h>
  41. #include "input_internal.h"
  42. #include "clock.h"
  43. #include "decoder.h"
  44. #include "es_out.h"
  45. #include "event.h"
  47. #include "../stream_output/stream_output.h"
  49. #include <vlc_iso_lang.h>
  50. /* FIXME we should find a better way than including that */
  51. #include "../text/iso-639_def.h"
  53. /*****************************************************************************
  54.  * Local prototypes
  55.  *****************************************************************************/
  56. typedef struct
  57. {
  58.     /* Program ID */
  59.     int i_id;
  61.     /* Number of es for this pgrm */
  62.     int i_es;
  64.     bool b_selected;
  65.     bool b_scrambled;
  67.     /* Clock for this program */
  68.     input_clock_t *p_clock;
  70.     char    *psz_name;
  71.     char    *psz_now_playing;
  72.     char    *psz_publisher;
  74.     vlc_epg_t *p_epg;
  75. } es_out_pgrm_t;
  77. struct es_out_id_t
  78. {
  79.     /* ES ID */
  80.     int       i_id;
  81.     es_out_pgrm_t *p_pgrm;
  83.     /* */
  84.     bool b_scrambled;
  86.     /* Channel in the track type */
  87.     int         i_channel;
  88.     es_format_t fmt;
  89.     char        *psz_language;
  90.     char        *psz_language_code;
  92.     decoder_t   *p_dec;
  93.     decoder_t   *p_dec_record;
  95.     /* Fields for Video with CC */
  96.     bool  pb_cc_present[4];
  97.     es_out_id_t  *pp_cc_es[4];
  99.     /* Field for CC track from a master video */
  100.     es_out_id_t *p_master;
  102.     /* ID for the meta data */
  103.     int         i_meta_id;
  104. };
  106. struct es_out_sys_t
  107. {
  108.     input_thread_t *p_input;
  110.     /* */
  111.     vlc_mutex_t   lock;
  113.     /* all programs */
  114.     int           i_pgrm;
  115.     es_out_pgrm_t **pgrm;
  116.     es_out_pgrm_t **pp_selected_pgrm; /* --programs */
  117.     es_out_pgrm_t *p_pgrm;  /* Master program */
  119.     /* all es */
  120.     int         i_id;
  121.     int         i_es;
  122.     es_out_id_t **es;
  124.     /* mode gestion */
  125.     bool  b_active;
  126.     int         i_mode;
  128.     /* es count */
  129.     int         i_audio;
  130.     int         i_video;
  131.     int         i_sub;
  133.     /* es to select */
  134.     int         i_audio_last, i_audio_id;
  135.     int         i_sub_last, i_sub_id;
  136.     int         i_default_sub_id;   /* As specified in container; if applicable */
  137.     char        **ppsz_audio_language;
  138.     char        **ppsz_sub_language;
  140.     /* current main es */
  141.     es_out_id_t *p_es_audio;
  142.     es_out_id_t *p_es_video;
  143.     es_out_id_t *p_es_sub;
  145.     /* delay */
  146.     int64_t i_audio_delay;
  147.     int64_t i_spu_delay;
  149.     /* Clock configuration */
  150.     mtime_t     i_pts_delay;
  151.     int         i_cr_average;
  152.     int         i_rate;
  154.     /* */
  155.     bool        b_paused;
  156.     mtime_t     i_pause_date;
  158.     /* Current preroll */
  159.     mtime_t     i_preroll_end;
  161.     /* Used for buffering */
  162.     bool        b_buffering;
  163.     mtime_t     i_buffering_extra_initial;
  164.     mtime_t     i_buffering_extra_stream;
  165.     mtime_t     i_buffering_extra_system;
  167.     /* Record */
  168.     sout_instance_t *p_sout_record;
  169. };
  171. static es_out_id_t *EsOutAdd    ( es_out_t *, const es_format_t * );
  172. static int          EsOutSend   ( es_out_t *, es_out_id_t *, block_t * );
  173. static void         EsOutDel    ( es_out_t *, es_out_id_t * );
  174. static int          EsOutControl( es_out_t *, int i_query, va_list );
  175. static void         EsOutDelete ( es_out_t * );
  177. static void         EsOutSelect( es_out_t *, es_out_id_t *es, bool b_force );
  178. static void         EsOutUpdateInfo( es_out_t *, es_out_id_t *es, const es_format_t *, const vlc_meta_t * );
  179. static int          EsOutSetRecord(  es_out_t *, bool b_record );
  181. static bool EsIsSelected( es_out_id_t *es );
  182. static void EsSelect( es_out_t *out, es_out_id_t *es );
  183. static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update );
  184. static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es );
  185. static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date );
  186. static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date );
  187. static void EsOutProgramsChangeRate( es_out_t *out );
  188. static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced );
  190. static char *LanguageGetName( const char *psz_code );
  191. static char *LanguageGetCode( const char *psz_lang );
  192. static char **LanguageSplit( const char *psz_langs );
  193. static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang );
  195. static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm );
  197. static const vlc_fourcc_t EsOutFourccClosedCaptions[4] = {
  198.     VLC_FOURCC('c', 'c', '1', ' '),
  199.     VLC_FOURCC('c', 'c', '2', ' '),
  200.     VLC_FOURCC('c', 'c', '3', ' '),
  201.     VLC_FOURCC('c', 'c', '4', ' '),
  202. };
  203. static inline int EsOutGetClosedCaptionsChannel( vlc_fourcc_t fcc )
  204. {
  205.     int i;
  206.     for( i = 0; i < 4; i++ )
  207.     {
  208.         if( fcc == EsOutFourccClosedCaptions[i] )
  209.             return i;
  210.     }
  211.     return -1;
  212. }
  213. static inline bool EsFmtIsTeletext( const es_format_t *p_fmt )
  214. {
  215.     return p_fmt->i_cat == SPU_ES && p_fmt->i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' );
  216. }
  218. /*****************************************************************************
  219.  * input_EsOutNew:
  220.  *****************************************************************************/
  221. es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate )
  222. {
  223.     es_out_t     *out = malloc( sizeof( *out ) );
  224.     if( !out )
  225.         return NULL;
  227.     es_out_sys_t *p_sys = malloc( sizeof( *p_sys ) );
  228.     if( !p_sys )
  229.     {
  230.         free( out );
  231.         return NULL;
  232.     }
  234.     out->pf_add     = EsOutAdd;
  235.     out->pf_send    = EsOutSend;
  236.     out->pf_del     = EsOutDel;
  237.     out->pf_control = EsOutControl;
  238.     out->pf_destroy = EsOutDelete;
  239.     out->p_sys      = p_sys;
  240.     out->b_sout     = p_input->p->p_sout != NULL;
  243.     vlc_mutex_init_recursive( &p_sys->lock );
  244.     p_sys->p_input = p_input;
  246.     p_sys->b_active = false;
  247.     p_sys->i_mode   = ES_OUT_MODE_AUTO;
  250.     TAB_INIT( p_sys->i_pgrm, p_sys->pgrm );
  251.     p_sys->p_pgrm   = NULL;
  253.     p_sys->i_id    = 0;
  255.     TAB_INIT( p_sys->i_es, p_sys->es );
  257.     p_sys->i_audio = 0;
  258.     p_sys->i_video = 0;
  259.     p_sys->i_sub   = 0;
  261.     /* */
  262.     p_sys->i_audio_last = var_GetInteger( p_input, "audio-track" );
  264.     p_sys->i_sub_last = var_GetInteger( p_input, "sub-track" );
  266.     p_sys->i_default_sub_id   = -1;
  268.     if( !p_input->b_preparsing )
  269.     {
  270.         char *psz_string;
  272.         psz_string = var_GetString( p_input, "audio-language" );
  273.         p_sys->ppsz_audio_language = LanguageSplit( psz_string );
  274.         if( p_sys->ppsz_audio_language )
  275.         {
  276.             for( int i = 0; p_sys->ppsz_audio_language[i]; i++ )
  277.                 msg_Dbg( p_input, "selected audio language[%d] %s",
  278.                          i, p_sys->ppsz_audio_language[i] );
  279.         }
  280.         free( psz_string );
  282.         psz_string = var_GetString( p_input, "sub-language" );
  283.         p_sys->ppsz_sub_language = LanguageSplit( psz_string );
  284.         if( p_sys->ppsz_sub_language )
  285.         {
  286.             for( int i = 0; p_sys->ppsz_sub_language[i]; i++ )
  287.                 msg_Dbg( p_input, "selected subtitle language[%d] %s",
  288.                          i, p_sys->ppsz_sub_language[i] );
  289.         }
  290.         free( psz_string );
  291.     }
  292.     else
  293.     {
  294.         p_sys->ppsz_sub_language = NULL;
  295.         p_sys->ppsz_audio_language = NULL;
  296.     }
  298.     p_sys->i_audio_id = var_GetInteger( p_input, "audio-track-id" );
  300.     p_sys->i_sub_id = var_GetInteger( p_input, "sub-track-id" );
  302.     p_sys->p_es_audio = NULL;
  303.     p_sys->p_es_video = NULL;
  304.     p_sys->p_es_sub   = NULL;
  306.     p_sys->i_audio_delay= 0;
  307.     p_sys->i_spu_delay  = 0;
  309.     p_sys->b_paused = false;
  310.     p_sys->i_pause_date = -1;
  312.     p_sys->i_rate = i_rate;
  313.     p_sys->i_pts_delay = 0;
  314.     p_sys->i_cr_average = 0;
  316.     p_sys->b_buffering = true;
  317.     p_sys->i_buffering_extra_initial = 0;
  318.     p_sys->i_buffering_extra_stream = 0;
  319.     p_sys->i_buffering_extra_system = 0;
  320.     p_sys->i_preroll_end = -1;
  322.     p_sys->p_sout_record = NULL;
  324.     return out;
  325. }
  327. /*****************************************************************************
  328.  *
  329.  *****************************************************************************/
  330. static void EsOutDelete( es_out_t *out )
  331. {
  332.     es_out_sys_t *p_sys = out->p_sys;
  333.     input_thread_t *p_input = p_sys->p_input;
  334.     int i;
  336.     if( p_sys->p_sout_record )
  337.         EsOutSetRecord( out, false );
  339.     for( i = 0; i < p_sys->i_es; i++ )
  340.     {
  341.         if( p_sys->es[i]->p_dec )
  342.             input_DecoderDelete( p_sys->es[i]->p_dec );
  344.         free( p_sys->es[i]->psz_language );
  345.         free( p_sys->es[i]->psz_language_code );
  346.         es_format_Clean( &p_sys->es[i]->fmt );
  348.         free( p_sys->es[i] );
  349.     }
  350.     if( p_sys->ppsz_audio_language )
  351.     {
  352.         for( i = 0; p_sys->ppsz_audio_language[i]; i++ )
  353.             free( p_sys->ppsz_audio_language[i] );
  354.         free( p_sys->ppsz_audio_language );
  355.     }
  356.     if( p_sys->ppsz_sub_language )
  357.     {
  358.         for( i = 0; p_sys->ppsz_sub_language[i]; i++ )
  359.             free( p_sys->ppsz_sub_language[i] );
  360.         free( p_sys->ppsz_sub_language );
  361.     }
  362.     free( p_sys->es );
  364.     /* FIXME duplicate work EsOutProgramDel (but we cannot use it) add a EsOutProgramClean ? */
  365.     for( i = 0; i < p_sys->i_pgrm; i++ )
  366.     {
  367.         es_out_pgrm_t *p_pgrm = p_sys->pgrm[i];
  368.         input_clock_Delete( p_pgrm->p_clock );
  370.         /* Remove SDT and EPG entries */
  371.         char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
  372.         input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
  373.         char *psz_epg;
  374.         if( asprintf( &psz_epg, "EPG %s", psz_cat ) >= 0 )
  375.         {
  376.             input_Control( p_input, INPUT_DEL_INFO, psz_epg, NULL );
  377.             free( psz_epg );
  378.         }
  379.         free( psz_cat );
  381.         free( p_pgrm->psz_now_playing );
  382.         free( p_pgrm->psz_publisher );
  383.         free( p_pgrm->psz_name );
  384.         if( p_pgrm->p_epg )
  385.             vlc_epg_Delete( p_pgrm->p_epg );
  387.         free( p_pgrm );
  388.     }
  389.     TAB_CLEAN( p_sys->i_pgrm, p_sys->pgrm );
  390.     vlc_mutex_destroy( &p_sys->lock );
  392.     free( p_sys );
  393.     free( out );
  394. }
  396. static mtime_t EsOutGetWakeup( es_out_t *out )
  397. {
  398.     es_out_sys_t   *p_sys = out->p_sys;
  399.     input_thread_t *p_input = p_sys->p_input;
  401.     if( !p_sys->p_pgrm )
  402.         return 0;
  404.     /* We do not have a wake up date if the input cannot have its speed
  405.      * controlled or sout is imposing its own or while buffering
  406.      *
  407.      * FIXME for !p_input->p->b_can_pace_control a wkeup time is still needed to avoid too strong buffering */
  408.     if( !p_input->p->b_can_pace_control ||
  409.         p_input->p->b_out_pace_control ||
  410.         p_sys->b_buffering )
  411.         return 0;
  413.     return input_clock_GetWakeup( p_sys->p_pgrm->p_clock );
  414. }
  416. static es_out_id_t *EsOutGetFromID( es_out_t *out, int i_id )
  417. {
  418.     int i;
  419.     if( i_id < 0 )
  420.     {
  421.         /* Special HACK, -i_id is the cat of the stream */
  422.         return (es_out_id_t*)((uint8_t*)NULL-i_id);
  423.     }
  425.     for( i = 0; i < out->p_sys->i_es; i++ )
  426.     {
  427.         if( out->p_sys->es[i]->i_id == i_id )
  428.             return out->p_sys->es[i];
  429.     }
  430.     return NULL;
  431. }
  433. static bool EsOutDecodersIsEmpty( es_out_t *out )
  434. {
  435.     es_out_sys_t      *p_sys = out->p_sys;
  436.     int i;
  438.     if( p_sys->b_buffering && p_sys->p_pgrm )
  439.     {
  440.         EsOutDecodersStopBuffering( out, true );
  441.         if( p_sys->b_buffering )
  442.             return true;
  443.     }
  445.     for( i = 0; i < p_sys->i_es; i++ )
  446.     {
  447.         es_out_id_t *es = p_sys->es[i];
  449.         if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) )
  450.             return false;
  451.         if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) )
  452.             return false;
  453.     }
  454.     return true;
  455. }
  457. static void EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay )
  458. {
  459.     es_out_sys_t *p_sys = out->p_sys;
  461.     if( i_cat == AUDIO_ES )
  462.         p_sys->i_audio_delay = i_delay;
  463.     else if( i_cat == SPU_ES )
  464.         p_sys->i_spu_delay = i_delay;
  466.     for( int i = 0; i < p_sys->i_es; i++ )
  467.         EsOutDecoderChangeDelay( out, p_sys->es[i] );
  468. }
  470. static int EsOutSetRecord(  es_out_t *out, bool b_record )
  471. {
  472.     es_out_sys_t   *p_sys = out->p_sys;
  473.     input_thread_t *p_input = p_sys->p_input;
  475.     assert( ( b_record && !p_sys->p_sout_record ) || ( !b_record && p_sys->p_sout_record ) );
  477.     if( b_record )
  478.     {
  479.         char *psz_path = var_CreateGetString( p_input, "input-record-path" );
  480.         if( !psz_path || *psz_path == '' )
  481.         {
  482.             free( psz_path );
  483.             psz_path = strdup( config_GetHomeDir() );
  484.         }
  486.         char *psz_sout = NULL;  // TODO conf
  488.         if( !psz_sout && psz_path )
  489.         {
  490.             char *psz_file = input_CreateFilename( VLC_OBJECT(p_input), psz_path, INPUT_RECORD_PREFIX, NULL );
  491.             if( psz_file )
  492.             {
  493.                 if( asprintf( &psz_sout, "#record{dst-prefix='%s'}", psz_file ) < 0 )
  494.                     psz_sout = NULL;
  495.                 free( psz_file );
  496.             }
  497.         }
  498.         free( psz_path );
  500.         if( !psz_sout )
  501.             return VLC_EGENERIC;
  503. #ifdef ENABLE_SOUT
  504.         p_sys->p_sout_record = sout_NewInstance( p_input, psz_sout );
  505. #endif
  506.         free( psz_sout );
  508.         if( !p_sys->p_sout_record )
  509.             return VLC_EGENERIC;
  511.         for( int i = 0; i < p_sys->i_es; i++ )
  512.         {
  513.             es_out_id_t *p_es = p_sys->es[i];
  515.             if( !p_es->p_dec || p_es->p_master )
  516.                 continue;
  518.             p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record );
  519.             if( p_es->p_dec_record && p_sys->b_buffering )
  520.                 input_DecoderStartBuffering( p_es->p_dec_record );
  521.         }
  522.     }
  523.     else
  524.     {
  525.         for( int i = 0; i < p_sys->i_es; i++ )
  526.         {
  527.             es_out_id_t *p_es = p_sys->es[i];
  529.             if( !p_es->p_dec_record )
  530.                 continue;
  532.             input_DecoderDelete( p_es->p_dec_record );
  533.             p_es->p_dec_record = NULL;
  534.         }
  535. #ifdef ENABLE_SOUT
  536.         sout_DeleteInstance( p_sys->p_sout_record );
  537. #endif
  538.         p_sys->p_sout_record = NULL;
  539.     }
  541.     return VLC_SUCCESS;
  542. }
  543. static void EsOutChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
  544. {
  545.     es_out_sys_t *p_sys = out->p_sys;
  547.     /* XXX the order is important */
  548.     if( b_paused )
  549.     {
  550.         EsOutDecodersChangePause( out, true, i_date );
  551.         EsOutProgramChangePause( out, true, i_date );
  552.     }
  553.     else
  554.     {
  555.         if( p_sys->i_buffering_extra_initial > 0 )
  556.         {
  557.             mtime_t i_stream_start;
  558.             mtime_t i_system_start;
  559.             mtime_t i_stream_duration;
  560.             mtime_t i_system_duration;
  561.             int i_ret;
  562.             i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
  563.                                           &i_stream_start, &i_system_start,
  564.                                           &i_stream_duration, &i_system_duration );
  565.             if( !i_ret )
  566.             {
  567.                 /* FIXME pcr != exactly what wanted */
  568.                 const mtime_t i_used = /*(i_stream_duration - p_sys->p_input->p->i_pts_delay)*/ p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial;
  569.                 i_date -= i_used;
  570.             }
  571.             p_sys->i_buffering_extra_initial = 0;
  572.             p_sys->i_buffering_extra_stream = 0;
  573.             p_sys->i_buffering_extra_system = 0;
  574.         }
  575.         EsOutProgramChangePause( out, false, i_date );
  576.         EsOutDecodersChangePause( out, false, i_date );
  578.         EsOutProgramsChangeRate( out );
  579.     }
  580.     p_sys->b_paused = b_paused;
  581.     p_sys->i_pause_date = i_date;
  582. }
  584. static void EsOutChangeRate( es_out_t *out, int i_rate )
  585. {
  586.     es_out_sys_t      *p_sys = out->p_sys;
  588.     p_sys->i_rate = i_rate;
  589.     EsOutProgramsChangeRate( out );
  590. }
  592. static void EsOutChangePosition( es_out_t *out )
  593. {
  594.     es_out_sys_t      *p_sys = out->p_sys;
  596.     input_SendEventCache( p_sys->p_input, 0.0 );
  598.     for( int i = 0; i < p_sys->i_es; i++ )
  599.     {
  600.         es_out_id_t *p_es = p_sys->es[i];
  602.         if( !p_es->p_dec )
  603.             continue;
  605.         input_DecoderStartBuffering( p_es->p_dec );
  607.         if( p_es->p_dec_record )
  608.             input_DecoderStartBuffering( p_es->p_dec_record );
  609.     }
  611.     for( int i = 0; i < p_sys->i_pgrm; i++ )
  612.         input_clock_Reset( p_sys->pgrm[i]->p_clock );
  614.     p_sys->b_buffering = true;
  615.     p_sys->i_buffering_extra_initial = 0;
  616.     p_sys->i_buffering_extra_stream = 0;
  617.     p_sys->i_buffering_extra_system = 0;
  618.     p_sys->i_preroll_end = -1;
  619. }
  623. static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
  624. {
  625.     es_out_sys_t *p_sys = out->p_sys;
  626.     int i_ret;
  628.     mtime_t i_stream_start;
  629.     mtime_t i_system_start;
  630.     mtime_t i_stream_duration;
  631.     mtime_t i_system_duration;
  632.     i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
  633.                                   &i_stream_start, &i_system_start,
  634.                                   &i_stream_duration, &i_system_duration );
  635.     assert( !i_ret || b_forced );
  636.     if( i_ret )
  637.         return;
  639.     mtime_t i_preroll_duration = 0;
  640.     if( p_sys->i_preroll_end >= 0 )
  641.         i_preroll_duration = __MAX( p_sys->i_preroll_end - i_stream_start, 0 );
  643.     const mtime_t i_buffering_duration = p_sys->i_pts_delay +
  644.                                          i_preroll_duration +
  645.                                          p_sys->i_buffering_extra_stream - p_sys->i_buffering_extra_initial;
  647.     if( i_stream_duration <= i_buffering_duration && !b_forced )
  648.     {
  649.         const double f_level = (double)i_stream_duration / i_buffering_duration;
  650.         input_SendEventCache( p_sys->p_input, f_level );
  652.         msg_Dbg( p_sys->p_input, "Buffering %d%%", (int)(100 * f_level) );
  653.         return;
  654.     }
  655.     input_SendEventCache( p_sys->p_input, 1.0 );
  657.     msg_Dbg( p_sys->p_input, "Stream buffering done (%d ms in %d ms)",
  658.               (int)(i_stream_duration/1000), (int)(i_system_duration/1000) );
  659.     p_sys->b_buffering = false;
  660.     p_sys->i_preroll_end = -1;
  662.     if( p_sys->i_buffering_extra_initial > 0 )
  663.     {
  664.         /* FIXME wrong ? */
  665.         return;
  666.     }
  668.     const mtime_t i_decoder_buffering_start = mdate();
  669.     for( int i = 0; i < p_sys->i_es; i++ )
  670.     {
  671.         es_out_id_t *p_es = p_sys->es[i];
  673.         if( !p_es->p_dec || p_es->fmt.i_cat == SPU_ES )
  674.             continue;
  675.         input_DecoderWaitBuffering( p_es->p_dec );
  676.         if( p_es->p_dec_record )
  677.             input_DecoderWaitBuffering( p_es->p_dec_record );
  678.     }
  680.     msg_Dbg( p_sys->p_input, "Decoder buffering done in %d ms",
  681.               (int)(mdate() - i_decoder_buffering_start)/1000 );
  683.     /* Here is a good place to destroy unused vout with every demuxer */
  684.     input_resource_TerminateVout( p_sys->p_input->p->p_resource );
  686.     /* */
  687.     const mtime_t i_wakeup_delay = 10*1000; /* FIXME CLEANUP thread wake up time*/
  688.     const mtime_t i_current_date = p_sys->b_paused ? p_sys->i_pause_date : mdate();
  690.     input_clock_ChangeSystemOrigin( p_sys->p_pgrm->p_clock, i_current_date + i_wakeup_delay - i_buffering_duration );
  692.     for( int i = 0; i < p_sys->i_es; i++ )
  693.     {
  694.         es_out_id_t *p_es = p_sys->es[i];
  696.         if( !p_es->p_dec )
  697.             continue;
  699.         input_DecoderStopBuffering( p_es->p_dec );
  700.         if( p_es->p_dec_record )
  701.             input_DecoderStopBuffering( p_es->p_dec_record );
  702.     }
  703. }
  704. static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
  705. {
  706.     es_out_sys_t *p_sys = out->p_sys;
  708.     /* Pause decoders first */
  709.     for( int i = 0; i < p_sys->i_es; i++ )
  710.     {
  711.         es_out_id_t *es = p_sys->es[i];
  713.         if( es->p_dec )
  714.         {
  715.             input_DecoderChangePause( es->p_dec, b_paused, i_date );
  716.             if( es->p_dec_record )
  717.                 input_DecoderChangePause( es->p_dec_record, b_paused, i_date );
  718.         }
  719.     }
  720. }
  722. static bool EsOutIsExtraBufferingAllowed( es_out_t *out )
  723. {
  724.     es_out_sys_t *p_sys = out->p_sys;
  726.     size_t i_size = 0;
  727.     for( int i = 0; i < p_sys->i_es; i++ )
  728.     {
  729.         es_out_id_t *p_es = p_sys->es[i];
  731.         if( p_es->p_dec )
  732.             i_size += input_DecoderGetFifoSize( p_es->p_dec );
  733.         if( p_es->p_dec_record )
  734.             i_size += input_DecoderGetFifoSize( p_es->p_dec_record );
  735.     }
  736.     //fprintf( stderr, "----- EsOutIsExtraBufferingAllowed =% 5d kbytes -- ", i_size / 1024 );
  738.     /* TODO maybe we want to be able to tune it ? */
  739. #if defined(OPTIMIZE_MEMORY)
  740.     const size_t i_level_high = 500000;  /* 0.5 Mbytes */
  741. #else
  742.     const size_t i_level_high = 10000000; /* 10 Mbytes */
  743. #endif
  744.     return i_size < i_level_high;
  745. }
  747. static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
  748. {
  749.     es_out_sys_t *p_sys = out->p_sys;
  751.     for( int i = 0; i < p_sys->i_pgrm; i++ )
  752.         input_clock_ChangePause( p_sys->pgrm[i]->p_clock, b_paused, i_date );
  753. }
  755. static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es )
  756. {
  757.     es_out_sys_t *p_sys = out->p_sys;
  759.     mtime_t i_delay = 0;
  760.     if( p_es->fmt.i_cat == AUDIO_ES )
  761.         i_delay = p_sys->i_audio_delay;
  762.     else if( p_es->fmt.i_cat == SPU_ES )
  763.         i_delay = p_sys->i_spu_delay;
  765.     if( i_delay != 0 )
  766.     {
  767.         if( p_es->p_dec )
  768.             input_DecoderChangeDelay( p_es->p_dec, i_delay );
  769.         if( p_es->p_dec_record )
  770.             input_DecoderChangeDelay( p_es->p_dec_record, i_delay );
  771.     }
  772. }
  773. static void EsOutProgramsChangeRate( es_out_t *out )
  774. {
  775.     es_out_sys_t      *p_sys = out->p_sys;
  777.     for( int i = 0; i < p_sys->i_pgrm; i++ )
  778.         input_clock_ChangeRate( p_sys->pgrm[i]->p_clock, p_sys->i_rate );
  779. }
  781. static void EsOutFrameNext( es_out_t *out )
  782. {
  783.     es_out_sys_t *p_sys = out->p_sys;
  784.     es_out_id_t *p_es_video = NULL;
  786.     if( p_sys->b_buffering )
  787.     {
  788.         msg_Warn( p_sys->p_input, "buffering, ignoring 'frame next'" );
  789.         return;
  790.     }
  792.     assert( p_sys->b_paused );
  794.     for( int i = 0; i < p_sys->i_es; i++ )
  795.     {
  796.         es_out_id_t *p_es = p_sys->es[i];
  798.         if( p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec )
  799.         {
  800.             p_es_video = p_es;
  801.             break;
  802.         }
  803.     }
  805.     if( !p_es_video )
  806.     {
  807.         msg_Warn( p_sys->p_input, "No video track selected, ignoring 'frame next'" );
  808.         return;
  809.     }
  811.     mtime_t i_duration;
  812.     input_DecoderFrameNext( p_es_video->p_dec, &i_duration );
  814.     msg_Dbg( out->p_sys->p_input, "EsOutFrameNext consummed %d ms", (int)(i_duration/1000) );
  816.     if( i_duration <= 0 )
  817.         i_duration = 40*1000;
  819.     /* FIXME it is not a clean way ? */
  820.     if( p_sys->i_buffering_extra_initial <= 0 )
  821.     {
  822.         mtime_t i_stream_start;
  823.         mtime_t i_system_start;
  824.         mtime_t i_stream_duration;
  825.         mtime_t i_system_duration;
  826.         int i_ret;
  828.         i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
  829.                                       &i_stream_start, &i_system_start,
  830.                                       &i_stream_duration, &i_system_duration );
  831.         if( i_ret )
  832.             return;
  834.         p_sys->i_buffering_extra_initial = 1 + i_stream_duration - p_sys->i_pts_delay; /* FIXME < 0 ? */
  835.         p_sys->i_buffering_extra_system =
  836.         p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial;
  837.     }
  839.     const int i_rate = input_clock_GetRate( p_sys->p_pgrm->p_clock );
  841.     p_sys->b_buffering = true;
  842.     p_sys->i_buffering_extra_system += i_duration;
  843.     p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial +
  844.                                       ( p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial ) *
  845.                                                 INPUT_RATE_DEFAULT / i_rate;
  847.     p_sys->i_preroll_end = -1;
  848. }
  849. static mtime_t EsOutGetBuffering( es_out_t *out )
  850. {
  851.     es_out_sys_t *p_sys = out->p_sys;
  853.     if( !p_sys->p_pgrm )
  854.         return 0;
  856.     int i_ret;
  857.     mtime_t i_stream_start;
  858.     mtime_t i_system_start;
  859.     mtime_t i_stream_duration;
  860.     mtime_t i_system_duration;
  861.     i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
  862.                                   &i_stream_start, &i_system_start,
  863.                                   &i_stream_duration, &i_system_duration );
  865.     if( i_ret )
  866.         return 0;
  868.     mtime_t i_delay;
  870.     if( p_sys->b_buffering && p_sys->i_buffering_extra_initial <= 0 )
  871.     {
  872.         i_delay = i_stream_duration;
  873.     }
  874.     else
  875.     {
  876.         mtime_t i_system_duration;
  877.         if( p_sys->b_paused )
  878.         {
  879.             i_system_duration = p_sys->i_pause_date  - i_system_start;
  880.             if( p_sys->i_buffering_extra_initial > 0 )
  881.                 i_system_duration += p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial;
  882.         }
  883.         else
  884.         {
  885.             i_system_duration = mdate() - i_system_start;
  886.         }
  888.         const mtime_t i_consumed = i_system_duration * INPUT_RATE_DEFAULT / p_sys->i_rate - i_stream_duration;
  889.         i_delay = p_sys->i_pts_delay - i_consumed;
  890.     }
  891.     if( i_delay < 0 )
  892.         return 0;
  893.     return i_delay;
  894. }
  896. static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id,
  897.                                      const es_format_t *fmt, const char *psz_language,
  898.                                      bool b_delete )
  899. {
  900.     es_out_sys_t      *p_sys = out->p_sys;
  901.     input_thread_t    *p_input = p_sys->p_input;
  902.     vlc_value_t       val, text;
  904.     if( b_delete )
  905.     {
  906.         if( EsFmtIsTeletext( fmt ) )
  907.             input_SendEventTeletextDel( p_sys->p_input, i_id );
  909.         input_SendEventEsDel( p_input, fmt->i_cat, i_id );
  910.         return;
  911.     }
  913.     /* Get the number of ES already added */
  914.     const char *psz_var;
  915.     if( fmt->i_cat == AUDIO_ES )
  916.         psz_var = "audio-es";
  917.     else if( fmt->i_cat == VIDEO_ES )
  918.         psz_var = "video-es";
  919.     else
  920.         psz_var = "spu-es";
  922.     var_Change( p_input, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
  923.     if( val.i_int == 0 )
  924.     {
  925.         vlc_value_t val2;
  927.         /* First one, we need to add the "Disable" choice */
  928.         val2.i_int = -1; text.psz_string = _("Disable");
  929.         var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val2, &text );
  930.         val.i_int++;
  931.     }
  933.     /* Take care of the ES description */
  934.     if( fmt->psz_description && *fmt->psz_description )
  935.     {
  936.         if( psz_language && *psz_language )
  937.         {
  938.             text.psz_string = malloc( strlen( fmt->psz_description) +
  939.                                       strlen( psz_language ) + 10 );
  940.             sprintf( text.psz_string, "%s - [%s]", fmt->psz_description,
  941.                                                    psz_language );
  942.         }
  943.         else text.psz_string = strdup( fmt->psz_description );
  944.     }
  945.     else
  946.     {
  947.         if( psz_language && *psz_language )
  948.         {
  949.             if( asprintf( &text.psz_string, "%s %i - [%s]", _( "Track" ), val.i_int, psz_language ) == -1 )
  950.                 text.psz_string = NULL;
  951.         }
  952.         else
  953.         {
  954.             if( asprintf( &text.psz_string, "%s %i", _( "Track" ), val.i_int ) == -1 )
  955.                 text.psz_string = NULL;
  956.         }
  957.     }
  959.     input_SendEventEsAdd( p_input, fmt->i_cat, i_id, text.psz_string );
  960.     if( EsFmtIsTeletext( fmt ) )
  961.     {
  962.         char psz_page[3+1];
  963.         snprintf( psz_page, sizeof(psz_page), "%d%2.2x",
  964.                   fmt->subs.teletext.i_magazine,
  965.                   fmt->subs.teletext.i_page );
  966.         input_SendEventTeletextAdd( p_sys->p_input,
  967.                                     i_id, fmt->subs.teletext.i_magazine >= 0 ? psz_page : NULL );
  968.     }
  970.     free( text.psz_string );
  971. }
  973. static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es,
  974.                               bool b_delete )
  975. {
  976.     EsOutESVarUpdateGeneric( out, es->i_id, &es->fmt, es->psz_language, b_delete );
  977. }
  979. /* EsOutProgramSelect:
  980.  *  Select a program and update the object variable
  981.  */
  982. static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm )
  983. {
  984.     es_out_sys_t      *p_sys = out->p_sys;
  985.     input_thread_t    *p_input = p_sys->p_input;
  986.     int               i;
  988.     if( p_sys->p_pgrm == p_pgrm )
  989.         return; /* Nothing to do */
  991.     if( p_sys->p_pgrm )
  992.     {
  993.         es_out_pgrm_t *old = p_sys->p_pgrm;
  994.         msg_Dbg( p_input, "unselecting program id=%d", old->i_id );
  996.         for( i = 0; i < p_sys->i_es; i++ )
  997.         {
  998.             if( p_sys->es[i]->p_pgrm == old && EsIsSelected( p_sys->es[i] ) &&
  999.                 p_sys->i_mode != ES_OUT_MODE_ALL )
  1000.                 EsUnselect( out, p_sys->es[i], true );
  1001.         }
  1003.         p_sys->p_es_audio = NULL;
  1004.         p_sys->p_es_sub = NULL;
  1005.         p_sys->p_es_video = NULL;
  1006.     }
  1008.     msg_Dbg( p_input, "selecting program id=%d", p_pgrm->i_id );
  1010.     /* Mark it selected */
  1011.     p_pgrm->b_selected = true;
  1013.     /* Switch master stream */
  1014.     p_sys->p_pgrm = p_pgrm;
  1016.     /* Update "program" */
  1017.     input_SendEventProgramSelect( p_input, p_pgrm->i_id );
  1019.     /* Update "es-*" */
  1020.     input_SendEventEsDel( p_input, AUDIO_ES, -1 );
  1021.     input_SendEventEsDel( p_input, VIDEO_ES, -1 );
  1022.     input_SendEventEsDel( p_input, SPU_ES, -1 );
  1023.     input_SendEventTeletextDel( p_input, -1 );
  1024.     input_SendEventProgramScrambled( p_input, p_pgrm->i_id, p_pgrm->b_scrambled );
  1026.     /* TODO event */
  1027.     var_SetInteger( p_input, "teletext-es", -1 );
  1029.     for( i = 0; i < p_sys->i_es; i++ )
  1030.     {
  1031.         if( p_sys->es[i]->p_pgrm == p_sys->p_pgrm )
  1032.             EsOutESVarUpdate( out, p_sys->es[i], false );
  1033.         EsOutSelect( out, p_sys->es[i], false );
  1034.     }
  1036.     /* Update now playing */
  1037.     input_item_SetNowPlaying( p_input->p->p_item, p_pgrm->psz_now_playing );
  1038.     input_item_SetPublisher( p_input->p->p_item, p_pgrm->psz_publisher );
  1040.     input_SendEventMeta( p_input );
  1041. }
  1043. /* EsOutAddProgram:
  1044.  *  Add a program
  1045.  */
  1046. static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group )
  1047. {
  1048.     es_out_sys_t      *p_sys = out->p_sys;
  1049.     input_thread_t    *p_input = p_sys->p_input;
  1051.     es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) );
  1052.     if( !p_pgrm )
  1053.         return NULL;
  1055.     /* Init */
  1056.     p_pgrm->i_id = i_group;
  1057.     p_pgrm->i_es = 0;
  1058.     p_pgrm->b_selected = false;
  1059.     p_pgrm->b_scrambled = false;
  1060.     p_pgrm->psz_name = NULL;
  1061.     p_pgrm->psz_now_playing = NULL;
  1062.     p_pgrm->psz_publisher = NULL;
  1063.     p_pgrm->p_epg = NULL;
  1064.     p_pgrm->p_clock = input_clock_New( p_sys->i_rate );
  1065.     if( !p_pgrm->p_clock )
  1066.     {
  1067.         free( p_pgrm );
  1068.         return NULL;
  1069.     }
  1070.     if( p_sys->b_paused )
  1071.         input_clock_ChangePause( p_pgrm->p_clock, p_sys->b_paused, p_sys->i_pause_date );
  1072.     input_clock_SetJitter( p_pgrm->p_clock, p_sys->i_pts_delay, p_sys->i_cr_average );
  1074.     /* Append it */
  1075.     TAB_APPEND( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
  1077.     /* Update "program" variable */
  1078.     input_SendEventProgramAdd( p_input, i_group, NULL );
  1080.     if( i_group == var_GetInteger( p_input, "program" ) )
  1081.         EsOutProgramSelect( out, p_pgrm );
  1083.     return p_pgrm;
  1084. }
  1086. /* EsOutDelProgram:
  1087.  *  Delete a program
  1088.  */
  1089. static int EsOutProgramDel( es_out_t *out, int i_group )
  1090. {
  1091.     es_out_sys_t      *p_sys = out->p_sys;
  1092.     input_thread_t    *p_input = p_sys->p_input;
  1093.     es_out_pgrm_t     *p_pgrm = NULL;
  1094.     int               i;
  1096.     for( i = 0; i < p_sys->i_pgrm; i++ )
  1097.     {
  1098.         if( p_sys->pgrm[i]->i_id == i_group )
  1099.         {
  1100.             p_pgrm = p_sys->pgrm[i];
  1101.             break;
  1102.         }
  1103.     }
  1105.     if( p_pgrm == NULL )
  1106.         return VLC_EGENERIC;
  1108.     if( p_pgrm->i_es )
  1109.     {
  1110.         msg_Dbg( p_input, "can't delete program %d which still has %i ES",
  1111.                  i_group, p_pgrm->i_es );
  1112.         return VLC_EGENERIC;
  1113.     }
  1115.     TAB_REMOVE( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
  1117.     /* If program is selected we need to unselect it */
  1118.     if( p_sys->p_pgrm == p_pgrm )
  1119.         p_sys->p_pgrm = NULL;
  1121.     input_clock_Delete( p_pgrm->p_clock );
  1123.     free( p_pgrm->psz_name );
  1124.     free( p_pgrm->psz_now_playing );
  1125.     free( p_pgrm->psz_publisher );
  1126.     if( p_pgrm->p_epg )
  1127.         vlc_epg_Delete( p_pgrm->p_epg );
  1128.     free( p_pgrm );
  1130.     /* Update "program" variable */
  1131.     input_SendEventProgramDel( p_input, i_group );
  1133.     return VLC_SUCCESS;
  1134. }
  1136. /* EsOutProgramFind
  1137.  */
  1138. static es_out_pgrm_t *EsOutProgramFind( es_out_t *p_out, int i_group )
  1139. {
  1140.     es_out_sys_t *p_sys = p_out->p_sys;
  1142.     for( int i = 0; i < p_sys->i_pgrm; i++ )
  1143.     {
  1144.         if( p_sys->pgrm[i]->i_id == i_group )
  1145.             return p_sys->pgrm[i];
  1146.     }
  1147.     return EsOutProgramAdd( p_out, i_group );
  1148. }
  1150. /* EsOutProgramMeta:
  1151.  */
  1152. static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm )
  1153. {
  1154.     char *psz = NULL;
  1155.     if( p_pgrm->psz_name )
  1156.     {
  1157.         if( asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id ) == -1 )
  1158.             return NULL;
  1159.     }
  1160.     else
  1161.     {
  1162.         if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 )
  1163.             return NULL;
  1164.     }
  1165.     return psz;
  1166. }
  1168. static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta )
  1169. {
  1170.     es_out_sys_t      *p_sys = out->p_sys;
  1171.     es_out_pgrm_t     *p_pgrm;
  1172.     input_thread_t    *p_input = p_sys->p_input;
  1173.     char              *psz_cat;
  1174.     const char        *psz_title = NULL;
  1175.     const char        *psz_provider = NULL;
  1176.     int i;
  1178.     msg_Dbg( p_input, "EsOutProgramMeta: number=%d", i_group );
  1180.     /* Check against empty meta data (empty for what we handle) */
  1181.     if( !vlc_meta_Get( p_meta, vlc_meta_Title) &&
  1182.         !vlc_meta_Get( p_meta, vlc_meta_NowPlaying) &&
  1183.         !vlc_meta_Get( p_meta, vlc_meta_Publisher) &&
  1184.         vlc_dictionary_keys_count( &p_meta->extra_tags ) <= 0 )
  1185.     {
  1186.         return;
  1187.     }
  1188.     /* Find program */
  1189.     p_pgrm = EsOutProgramFind( out, i_group );
  1190.     if( !p_pgrm )
  1191.         return;
  1193.     /* */
  1194.     psz_title = vlc_meta_Get( p_meta, vlc_meta_Title);
  1195.     psz_provider = vlc_meta_Get( p_meta, vlc_meta_Publisher);
  1197.     /* Update the description text of the program */
  1198.     if( psz_title && *psz_title )
  1199.     {
  1200.         if( !p_pgrm->psz_name || strcmp( p_pgrm->psz_name, psz_title ) )
  1201.         {
  1202.             char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
  1204.             /* Remove old entries */
  1205.             input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
  1206.             /* TODO update epg name ?
  1207.              * TODO update scrambled info name ? */
  1208.             free( psz_cat );
  1209.         }
  1210.         free( p_pgrm->psz_name );
  1211.         p_pgrm->psz_name = strdup( psz_title );
  1213.         char *psz_text;
  1214.         if( psz_provider && *psz_provider )
  1215.         {
  1216.             if( asprintf( &psz_text, "%s [%s]", psz_title, psz_provider ) < 0 )
  1217.                 psz_text = NULL;
  1218.         }
  1219.         else
  1220.         {
  1221.             psz_text = strdup( psz_title );
  1222.         }
  1224.         /* ugly but it works */
  1225.         if( psz_text )
  1226.         {
  1227.             input_SendEventProgramDel( p_input, i_group );
  1228.             input_SendEventProgramAdd( p_input, i_group, psz_text );
  1230.             free( psz_text );
  1231.         }
  1232.     }
  1234.     psz_cat = EsOutProgramGetMetaName( p_pgrm );
  1235.     if( psz_provider )
  1236.     {
  1237.         if( p_sys->p_pgrm == p_pgrm )
  1238.         {
  1239.             input_item_SetPublisher( p_input->p->p_item, psz_provider );
  1240.             input_SendEventMeta( p_input );
  1241.         }
  1242.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, input_MetaTypeToLocalizedString(vlc_meta_Publisher), psz_provider );
  1243.     }
  1244.     char ** ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags );
  1245.     for( i = 0; ppsz_all_keys[i]; i++ )
  1246.     {
  1247.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1248.                        vlc_gettext(ppsz_all_keys[i]),
  1249.                        vlc_dictionary_value_for_key( &p_meta->extra_tags,
  1250.                        ppsz_all_keys[i] ) );
  1251.         free( ppsz_all_keys[i] );
  1252.     }
  1253.     free( ppsz_all_keys );
  1255.     free( psz_cat );
  1256. }
  1258. static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src )
  1259. {
  1260.     int i;
  1262.     /* Add new event */
  1263.     for( i = 0; i < p_src->i_event; i++ )
  1264.     {
  1265.         vlc_epg_event_t *p_evt = p_src->pp_event[i];
  1266.         bool b_add = true;
  1267.         int j;
  1269.         for( j = 0; j < p_dst->i_event; j++ )
  1270.         {
  1271.             if( p_dst->pp_event[j]->i_start == p_evt->i_start && p_dst->pp_event[j]->i_duration == p_evt->i_duration )
  1272.             {
  1273.                 b_add = false;
  1274.                 break;
  1275.             }
  1276.             if( p_dst->pp_event[j]->i_start > p_evt->i_start )
  1277.                 break;
  1278.         }
  1279.         if( b_add )
  1280.         {
  1281.             vlc_epg_event_t *p_copy = calloc( 1, sizeof(vlc_epg_event_t) );
  1282.             if( !p_copy )
  1283.                 break;
  1284.             p_copy->i_start = p_evt->i_start;
  1285.             p_copy->i_duration = p_evt->i_duration;
  1286.             p_copy->psz_name = p_evt->psz_name ? strdup( p_evt->psz_name ) : NULL;
  1287.             p_copy->psz_short_description = p_evt->psz_short_description ? strdup( p_evt->psz_short_description ) : NULL;
  1288.             p_copy->psz_description = p_evt->psz_description ? strdup( p_evt->psz_description ) : NULL;
  1289.             TAB_INSERT( p_dst->i_event, p_dst->pp_event, p_copy, j );
  1290.         }
  1291.     }
  1292.     /* Update current */
  1293.     if( p_src->p_current )
  1294.         vlc_epg_SetCurrent( p_dst, p_src->p_current->i_start );
  1296.     /* Keep only 1 old event  */
  1297.     if( p_dst->p_current )
  1298.     {
  1299.         while( p_dst->i_event > 1 && p_dst->pp_event[0] != p_dst->p_current && p_dst->pp_event[1] != p_dst->p_current )
  1300.             TAB_REMOVE( p_dst->i_event, p_dst->pp_event, p_dst->pp_event[0] );
  1301.     }
  1302. }
  1304. static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg )
  1305. {
  1306.     es_out_sys_t      *p_sys = out->p_sys;
  1307.     input_thread_t    *p_input = p_sys->p_input;
  1308.     es_out_pgrm_t     *p_pgrm;
  1309.     char *psz_cat;
  1311.     /* Find program */
  1312.     p_pgrm = EsOutProgramFind( out, i_group );
  1313.     if( !p_pgrm )
  1314.         return;
  1316.     /* Merge EPG */
  1317.     if( !p_pgrm->p_epg )
  1318.         p_pgrm->p_epg = vlc_epg_New( p_pgrm->psz_name );
  1319.     vlc_epg_Merge( p_pgrm->p_epg, p_epg );
  1321.     /* Update info */
  1322.     msg_Dbg( p_input, "EsOutProgramEpg: number=%d name=%s", i_group, p_pgrm->p_epg->psz_name );
  1324.     psz_cat = EsOutProgramGetMetaName( p_pgrm );
  1326.     char *psz_epg;
  1327.     if( asprintf( &psz_epg, "EPG %s", psz_cat ) >= 0 )
  1328.     {
  1329.         input_item_SetEpg( p_input->p->p_item, psz_epg, p_pgrm->p_epg );
  1330.         free( psz_epg );
  1331.     }
  1333.     /* Update now playing */
  1334.     free( p_pgrm->psz_now_playing );
  1335.     p_pgrm->psz_now_playing = NULL;
  1336.     if( p_pgrm->p_epg->p_current && p_pgrm->p_epg->p_current->psz_name && *p_pgrm->p_epg->p_current->psz_name )
  1337.         p_pgrm->psz_now_playing = strdup( p_pgrm->p_epg->p_current->psz_name );
  1339.     if( p_pgrm == p_sys->p_pgrm )
  1340.     {
  1341.         input_item_SetNowPlaying( p_input->p->p_item, p_pgrm->psz_now_playing );
  1342.         input_SendEventMeta( p_input );
  1343.     }
  1345.     if( p_pgrm->psz_now_playing )
  1346.     {
  1347.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1348.             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying),
  1349.             p_pgrm->psz_now_playing );
  1350.     }
  1351.     else
  1352.     {
  1353.         input_Control( p_input, INPUT_DEL_INFO, psz_cat,
  1354.             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying) );
  1355.     }
  1357.     free( psz_cat );
  1358. }
  1360. static void EsOutProgramUpdateScrambled( es_out_t *p_out, es_out_pgrm_t *p_pgrm )
  1361. {
  1362.     es_out_sys_t    *p_sys = p_out->p_sys;
  1363.     input_thread_t  *p_input = p_sys->p_input;
  1364.     bool b_scrambled = false;
  1366.     for( int i = 0; i < p_sys->i_es; i++ )
  1367.     {
  1368.         if( p_sys->es[i]->p_pgrm == p_pgrm && p_sys->es[i]->b_scrambled )
  1369.         {
  1370.             b_scrambled = true;
  1371.             break;
  1372.         }
  1373.     }
  1374.     if( !p_pgrm->b_scrambled == !b_scrambled )
  1375.         return;
  1377.     p_pgrm->b_scrambled = b_scrambled;
  1378.     char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
  1380.     if( b_scrambled )
  1381.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Scrambled"), _("Yes") );
  1382.     else
  1383.         input_Control( p_input, INPUT_DEL_INFO, psz_cat, _("Scrambled") );
  1385.     input_SendEventProgramScrambled( p_input, p_pgrm->i_id, b_scrambled );
  1386. }
  1388. static void EsOutMeta( es_out_t *p_out, const vlc_meta_t *p_meta )
  1389. {
  1390.     es_out_sys_t    *p_sys = p_out->p_sys;
  1391.     input_thread_t  *p_input = p_sys->p_input;
  1393.     input_item_t *p_item = input_GetItem( p_input );
  1395.     char *psz_title = NULL;
  1396.     char *psz_arturl = input_item_GetArtURL( p_item );
  1398.     vlc_mutex_lock( &p_item->lock );
  1400.     if( vlc_meta_Get( p_meta, vlc_meta_Title ) && !p_item->b_fixed_name )
  1401.         psz_title = strdup( vlc_meta_Get( p_meta, vlc_meta_Title ) );
  1403.     vlc_meta_Merge( p_item->p_meta, p_meta );
  1405.     if( !psz_arturl || *psz_arturl == '' )
  1406.     {
  1407.         const char *psz_tmp = vlc_meta_Get( p_item->p_meta, vlc_meta_ArtworkURL );
  1408.         if( psz_tmp )
  1409.             psz_arturl = strdup( psz_tmp );
  1410.     }
  1411.     vlc_mutex_unlock( &p_item->lock );
  1413.     if( psz_arturl && *psz_arturl )
  1414.     {
  1415.         input_item_SetArtURL( p_item, psz_arturl );
  1417.         if( !strncmp( psz_arturl, "attachment://", strlen("attachment") ) )
  1418.         {
  1419.             /* Don't look for art cover if sout
  1420.              * XXX It can change when sout has meta data support */
  1421.             if( p_out->b_sout && !p_input->b_preparsing )
  1422.                 input_item_SetArtURL( p_item, "" );
  1423.             else
  1424.                 input_ExtractAttachmentAndCacheArt( p_input );
  1425.         }
  1426.     }
  1427.     free( psz_arturl );
  1429.     if( psz_title )
  1430.     {
  1431.         input_item_SetName( p_item, psz_title );
  1432.         free( psz_title );
  1433.     }
  1434.     input_item_SetPreparsed( p_item, true );
  1436.     input_SendEventMeta( p_input );
  1437.     /* TODO handle sout meta ? */
  1438. }
  1440. /* EsOutAdd:
  1441.  *  Add an es_out
  1442.  */
  1443. static es_out_id_t *EsOutAdd( es_out_t *out, const es_format_t *fmt )
  1444. {
  1445.     es_out_sys_t      *p_sys = out->p_sys;
  1446.     input_thread_t    *p_input = p_sys->p_input;
  1448.     if( fmt->i_group < 0 )
  1449.     {
  1450.         msg_Err( p_input, "invalid group number" );
  1451.         return NULL;
  1452.     }
  1454.     es_out_id_t   *es = malloc( sizeof( *es ) );
  1455.     es_out_pgrm_t *p_pgrm;
  1456.     int i;
  1458.     if( !es )
  1459.         return NULL;
  1461.     vlc_mutex_lock( &p_sys->lock );
  1463.     /* Search the program */
  1464.     p_pgrm = EsOutProgramFind( out, fmt->i_group );
  1465.     if( !p_pgrm )
  1466.     {
  1467.         vlc_mutex_unlock( &p_sys->lock );
  1468.         free( es );
  1469.         return NULL;
  1470.     }
  1472.     /* Increase ref count for program */
  1473.     p_pgrm->i_es++;
  1475.     /* Set up ES */
  1476.     es->p_pgrm = p_pgrm;
  1477.     es_format_Copy( &es->fmt, fmt );
  1478.     if( es->fmt.i_id < 0 )
  1479.         es->fmt.i_id = out->p_sys->i_id;
  1480.     es->i_id = es->fmt.i_id;
  1481.     es->i_meta_id = out->p_sys->i_id;
  1482.     es->b_scrambled = false;
  1484.     switch( es->fmt.i_cat )
  1485.     {
  1486.     case AUDIO_ES:
  1487.     {
  1488.         audio_replay_gain_t rg;
  1490.         es->i_channel = p_sys->i_audio;
  1492.         memset( &rg, 0, sizeof(rg) );
  1493.         vlc_mutex_lock( &p_input->p->p_item->lock );
  1494.         vlc_audio_replay_gain_MergeFromMeta( &rg, p_input->p->p_item->p_meta );
  1495.         vlc_mutex_unlock( &p_input->p->p_item->lock );
  1497.         for( i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
  1498.         {
  1499.             if( !es->fmt.audio_replay_gain.pb_peak[i] )
  1500.             {
  1501.                 es->fmt.audio_replay_gain.pb_peak[i] = rg.pb_peak[i];
  1502.                 es->fmt.audio_replay_gain.pf_peak[i] = rg.pf_peak[i];
  1503.             }
  1504.             if( !es->fmt.audio_replay_gain.pb_gain[i] )
  1505.             {
  1506.                 es->fmt.audio_replay_gain.pb_gain[i] = rg.pb_gain[i];
  1507.                 es->fmt.audio_replay_gain.pf_gain[i] = rg.pf_gain[i];
  1508.             }
  1509.         }
  1510.         break;
  1511.     }
  1513.     case VIDEO_ES:
  1514.         es->i_channel = p_sys->i_video;
  1515.         if( es->fmt.video.i_frame_rate && es->fmt.video.i_frame_rate_base )
  1516.             vlc_ureduce( &es->fmt.video.i_frame_rate,
  1517.                          &es->fmt.video.i_frame_rate_base,
  1518.                          es->fmt.video.i_frame_rate,
  1519.                          es->fmt.video.i_frame_rate_base, 0 );
  1520.         break;
  1522.     case SPU_ES:
  1523.         es->i_channel = p_sys->i_sub;
  1524.         break;
  1526.     default:
  1527.         es->i_channel = 0;
  1528.         break;
  1529.     }
  1530.     es->psz_language = LanguageGetName( es->fmt.psz_language ); /* remember so we only need to do it once */
  1531.     es->psz_language_code = LanguageGetCode( es->fmt.psz_language );
  1532.     es->p_dec = NULL;
  1533.     es->p_dec_record = NULL;
  1534.     for( i = 0; i < 4; i++ )
  1535.         es->pb_cc_present[i] = false;
  1536.     es->p_master = NULL;
  1538.     if( es->p_pgrm == p_sys->p_pgrm )
  1539.         EsOutESVarUpdate( out, es, false );
  1541.     /* Select it if needed */
  1542.     EsOutSelect( out, es, false );
  1545.     TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es );
  1546.     p_sys->i_id++;  /* always incremented */
  1547.     switch( es->fmt.i_cat )
  1548.     {
  1549.         case AUDIO_ES:
  1550.             p_sys->i_audio++;
  1551.             break;
  1552.         case SPU_ES:
  1553.             p_sys->i_sub++;
  1554.             break;
  1555.         case VIDEO_ES:
  1556.             p_sys->i_video++;
  1557.             break;
  1558.     }
  1560.     EsOutUpdateInfo( out, es, &es->fmt, NULL );
  1562.     if( es->b_scrambled )
  1563.         EsOutProgramUpdateScrambled( out, es->p_pgrm );
  1565.     vlc_mutex_unlock( &p_sys->lock );
  1567.     return es;
  1568. }
  1570. static bool EsIsSelected( es_out_id_t *es )
  1571. {
  1572.     if( es->p_master )
  1573.     {
  1574.         bool b_decode = false;
  1575.         if( es->p_master->p_dec )
  1576.         {
  1577.             int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
  1578.             if( i_channel != -1 )
  1579.                 input_DecoderGetCcState( es->p_master->p_dec, &b_decode, i_channel );
  1580.         }
  1581.         return b_decode;
  1582.     }
  1583.     else
  1584.     {
  1585.         return es->p_dec != NULL;
  1586.     }
  1587. }
  1588. static void EsCreateDecoder( es_out_t *out, es_out_id_t *p_es )
  1589. {
  1590.     es_out_sys_t   *p_sys = out->p_sys;
  1591.     input_thread_t *p_input = p_sys->p_input;
  1593.     p_es->p_dec = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_input->p->p_sout );
  1594.     if( p_es->p_dec )
  1595.     {
  1596.         if( p_sys->b_buffering )
  1597.             input_DecoderStartBuffering( p_es->p_dec );
  1599.         if( !p_es->p_master && p_sys->p_sout_record )
  1600.         {
  1601.             p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record );
  1602.             if( p_es->p_dec_record && p_sys->b_buffering )
  1603.                 input_DecoderStartBuffering( p_es->p_dec_record );
  1604.         }
  1605.     }
  1607.     EsOutDecoderChangeDelay( out, p_es );
  1608. }
  1609. static void EsDestroyDecoder( es_out_t *out, es_out_id_t *p_es )
  1610. {
  1611.     VLC_UNUSED(out);
  1613.     if( !p_es->p_dec )
  1614.         return;
  1616.     input_DecoderDelete( p_es->p_dec );
  1617.     p_es->p_dec = NULL;
  1619.     if( p_es->p_dec_record )
  1620.     {
  1621.         input_DecoderDelete( p_es->p_dec_record );
  1622.         p_es->p_dec_record = NULL;
  1623.     }
  1624. }
  1626. static void EsSelect( es_out_t *out, es_out_id_t *es )
  1627. {
  1628.     es_out_sys_t   *p_sys = out->p_sys;
  1629.     input_thread_t *p_input = p_sys->p_input;
  1631.     if( EsIsSelected( es ) )
  1632.     {
  1633.         msg_Warn( p_input, "ES 0x%x is already selected", es->i_id );
  1634.         return;
  1635.     }
  1637.     if( es->p_master )
  1638.     {
  1639.         int i_channel;
  1640.         if( !es->p_master->p_dec )
  1641.             return;
  1643.         i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
  1644.         if( i_channel == -1 || input_DecoderSetCcState( es->p_master->p_dec, true, i_channel ) )
  1645.             return;
  1646.     }
  1647.     else
  1648.     {
  1649.         if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES )
  1650.         {
  1651.             if( !var_GetBool( p_input, out->b_sout ? "sout-video" : "video" ) )
  1652.             {
  1653.                 msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x",
  1654.                          es->i_id );
  1655.                 return;
  1656.             }
  1657.         }
  1658.         else if( es->fmt.i_cat == AUDIO_ES )
  1659.         {
  1660.             if( !var_GetBool( p_input, out->b_sout ? "sout-audio" : "audio" ) )
  1661.             {
  1662.                 msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x",
  1663.                          es->i_id );
  1664.                 return;
  1665.             }
  1666.         }
  1667.         if( es->fmt.i_cat == SPU_ES )
  1668.         {
  1669.             if( !var_GetBool( p_input, out->b_sout ? "sout-spu" : "spu" ) )
  1670.             {
  1671.                 msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x",
  1672.                          es->i_id );
  1673.                 return;
  1674.             }
  1675.         }
  1677.         EsCreateDecoder( out, es );
  1679.         if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm )
  1680.             return;
  1681.     }
  1683.     /* Mark it as selected */
  1684.     input_SendEventEsSelect( p_input, es->fmt.i_cat, es->i_id );
  1685.     input_SendEventTeletextSelect( p_input, EsFmtIsTeletext( &es->fmt ) ? es->i_id : -1 );
  1686. }
  1688. static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update )
  1689. {
  1690.     es_out_sys_t   *p_sys = out->p_sys;
  1691.     input_thread_t *p_input = p_sys->p_input;
  1693.     if( !EsIsSelected( es ) )
  1694.     {
  1695.         msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id );
  1696.         return;
  1697.     }
  1699.     if( es->p_master )
  1700.     {
  1701.         if( es->p_master->p_dec )
  1702.         {
  1703.             int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
  1704.             if( i_channel != -1 )
  1705.                 input_DecoderSetCcState( es->p_master->p_dec, false, i_channel );
  1706.         }
  1707.     }
  1708.     else
  1709.     {
  1710.         const int i_spu_id = var_GetInteger( p_input, "spu-es");
  1711.         int i;
  1712.         for( i = 0; i < 4; i++ )
  1713.         {
  1714.             if( !es->pb_cc_present[i] || !es->pp_cc_es[i] )
  1715.                 continue;
  1717.             if( i_spu_id == es->pp_cc_es[i]->i_id )
  1718.             {
  1719.                 /* Force unselection of the CC */
  1720.                 input_SendEventEsSelect( p_input, SPU_ES, -1 );
  1721.             }
  1722.             EsOutDel( out, es->pp_cc_es[i] );
  1724.             es->pb_cc_present[i] = false;
  1725.         }
  1726.         EsDestroyDecoder( out, es );
  1727.     }
  1729.     if( !b_update )
  1730.         return;
  1732.     /* Mark it as unselected */
  1733.     input_SendEventEsSelect( p_input, es->fmt.i_cat, -1 );
  1734.     if( EsFmtIsTeletext( &es->fmt ) )
  1735.         input_SendEventTeletextSelect( p_input, -1 );
  1736. }
  1738. /**
  1739.  * Select an ES given the current mode
  1740.  * XXX: you need to take a the lock before (stream.stream_lock)
  1741.  *
  1742.  * param out The es_out structure
  1743.  * param es es_out_id structure
  1744.  * param b_force ...
  1745.  * return nothing
  1746.  */
  1747. static void EsOutSelect( es_out_t *out, es_out_id_t *es, bool b_force )
  1748. {
  1749.     es_out_sys_t      *p_sys = out->p_sys;
  1751.     int i_cat = es->fmt.i_cat;
  1753.     if( !p_sys->b_active ||
  1754.         ( !b_force && es->fmt.i_priority < 0 ) )
  1755.     {
  1756.         return;
  1757.     }
  1759.     if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force )
  1760.     {
  1761.         if( !EsIsSelected( es ) )
  1762.             EsSelect( out, es );
  1763.     }
  1764.     else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL )
  1765.     {
  1766.         vlc_value_t val;
  1767.         int i;
  1768.         var_Get( p_sys->p_input, "programs", &val );
  1769.         for ( i = 0; i < val.p_list->i_count; i++ )
  1770.         {
  1771.             if ( val.p_list->p_values[i].i_int == es->p_pgrm->i_id || b_force )
  1772.             {
  1773.                 if( !EsIsSelected( es ) )
  1774.                     EsSelect( out, es );
  1775.                 break;
  1776.             }
  1777.         }
  1778.         var_Change( p_sys->p_input, "programs", VLC_VAR_FREELIST, &val, NULL );
  1779.     }
  1780.     else if( p_sys->i_mode == ES_OUT_MODE_AUTO )
  1781.     {
  1782.         int i_wanted  = -1;
  1784.         if( es->p_pgrm != p_sys->p_pgrm )
  1785.             return;
  1787.         if( i_cat == AUDIO_ES )
  1788.         {
  1789.             int idx1 = LanguageArrayIndex( p_sys->ppsz_audio_language,
  1790.                                      es->psz_language_code );
  1792.             if( p_sys->p_es_audio &&
  1793.                 p_sys->p_es_audio->fmt.i_priority >= es->fmt.i_priority )
  1794.             {
  1795.                 int idx2 = LanguageArrayIndex( p_sys->ppsz_audio_language,
  1796.                                          p_sys->p_es_audio->psz_language_code );
  1798.                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
  1799.                     return;
  1800.                 i_wanted = es->i_channel;
  1801.             }
  1802.             else
  1803.             {
  1804.                 /* Select audio if (no audio selected yet)
  1805.                  * - no audio-language
  1806.                  * - no audio code for the ES
  1807.                  * - audio code in the requested list */
  1808.                 if( idx1 >= 0 ||
  1809.                     !strcmp( es->psz_language_code, "??" ) ||
  1810.                     !p_sys->ppsz_audio_language )
  1811.                     i_wanted = es->i_channel;
  1812.             }
  1814.             if( p_sys->i_audio_last >= 0 )
  1815.                 i_wanted = p_sys->i_audio_last;
  1817.             if( p_sys->i_audio_id >= 0 )
  1818.             {
  1819.                 if( es->i_id == p_sys->i_audio_id )
  1820.                     i_wanted = es->i_channel;
  1821.                 else
  1822.                     return;
  1823.             }
  1824.         }
  1825.         else if( i_cat == SPU_ES )
  1826.         {
  1827.             int idx1 = LanguageArrayIndex( p_sys->ppsz_sub_language,
  1828.                                      es->psz_language_code );
  1830.             if( p_sys->p_es_sub &&
  1831.                 p_sys->p_es_sub->fmt.i_priority >= es->fmt.i_priority )
  1832.             {
  1833.                 int idx2 = LanguageArrayIndex( p_sys->ppsz_sub_language,
  1834.                                          p_sys->p_es_sub->psz_language_code );
  1836.                 msg_Dbg( p_sys->p_input, "idx1=%d(%s) idx2=%d(%s)",
  1837.                         idx1, es->psz_language_code, idx2,
  1838.                         p_sys->p_es_sub->psz_language_code );
  1840.                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
  1841.                     return;
  1842.                 /* We found a SPU that matches our language request */
  1843.                 i_wanted  = es->i_channel;
  1844.             }
  1845.             else if( idx1 >= 0 )
  1846.             {
  1847.                 msg_Dbg( p_sys->p_input, "idx1=%d(%s)",
  1848.                         idx1, es->psz_language_code );
  1850.                 i_wanted  = es->i_channel;
  1851.             }
  1852.             else if( p_sys->i_default_sub_id >= 0 )
  1853.             {
  1854.                 if( es->i_id == p_sys->i_default_sub_id )
  1855.                     i_wanted = es->i_channel;
  1856.             }
  1858.             if( p_sys->i_sub_last >= 0 )
  1859.                 i_wanted  = p_sys->i_sub_last;
  1861.             if( p_sys->i_sub_id >= 0 )
  1862.             {
  1863.                 if( es->i_id == p_sys->i_sub_id )
  1864.                     i_wanted = es->i_channel;
  1865.                 else
  1866.                     return;
  1867.             }
  1868.         }
  1869.         else if( i_cat == VIDEO_ES )
  1870.         {
  1871.             i_wanted  = es->i_channel;
  1872.         }
  1874.         if( i_wanted == es->i_channel && !EsIsSelected( es ) )
  1875.             EsSelect( out, es );
  1876.     }
  1878.     /* FIXME TODO handle priority here */
  1879.     if( EsIsSelected( es ) )
  1880.     {
  1881.         if( i_cat == AUDIO_ES )
  1882.         {
  1883.             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
  1884.                 p_sys->p_es_audio &&
  1885.                 p_sys->p_es_audio != es &&
  1886.                 EsIsSelected( p_sys->p_es_audio ) )
  1887.             {
  1888.                 EsUnselect( out, p_sys->p_es_audio, false );
  1889.             }
  1890.             p_sys->p_es_audio = es;
  1891.         }
  1892.         else if( i_cat == SPU_ES )
  1893.         {
  1894.             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
  1895.                 p_sys->p_es_sub &&
  1896.                 p_sys->p_es_sub != es &&
  1897.                 EsIsSelected( p_sys->p_es_sub ) )
  1898.             {
  1899.                 EsUnselect( out, p_sys->p_es_sub, false );
  1900.             }
  1901.             p_sys->p_es_sub = es;
  1902.         }
  1903.         else if( i_cat == VIDEO_ES )
  1904.         {
  1905.             p_sys->p_es_video = es;
  1906.         }
  1907.     }
  1908. }
  1910. /**
  1911.  * Send a block for the given es_out
  1912.  *
  1913.  * param out the es_out to send from
  1914.  * param es the es_out_id
  1915.  * param p_block the data block to send
  1916.  */
  1917. static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
  1918. {
  1919.     es_out_sys_t   *p_sys = out->p_sys;
  1920.     input_thread_t *p_input = p_sys->p_input;
  1921.     int i_total = 0;
  1923.     if( libvlc_stats( p_input ) )
  1924.     {
  1925.         vlc_mutex_lock( &p_input->p->counters.counters_lock );
  1926.         stats_UpdateInteger( p_input, p_input->p->counters.p_demux_read,
  1927.                              p_block->i_buffer, &i_total );
  1928.         stats_UpdateFloat( p_input , p_input->p->counters.p_demux_bitrate,
  1929.                            (float)i_total, NULL );
  1931.         /* Update number of corrupted data packats */
  1932.         if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
  1933.         {
  1934.             stats_UpdateInteger( p_input, p_input->p->counters.p_demux_corrupted,
  1935.                                  1, NULL );
  1936.         }
  1937.         /* Update number of discontinuities */
  1938.         if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
  1939.         {
  1940.             stats_UpdateInteger( p_input, p_input->p->counters.p_demux_discontinuity,
  1941.                                  1, NULL );
  1942.         }
  1943.         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
  1944.     }
  1946.     vlc_mutex_lock( &p_sys->lock );
  1948.     /* Mark preroll blocks */
  1949.     if( p_sys->i_preroll_end >= 0 )
  1950.     {
  1951.         int64_t i_date = p_block->i_pts;
  1952.         if( i_date <= 0 )
  1953.             i_date = p_block->i_dts;
  1955.         if( i_date < p_sys->i_preroll_end )
  1956.             p_block->i_flags |= BLOCK_FLAG_PREROLL;
  1957.     }
  1959.     p_block->i_rate = 0;
  1961.     if( !es->p_dec )
  1962.     {
  1963.         block_Release( p_block );
  1964.         vlc_mutex_unlock( &p_sys->lock );
  1965.         return VLC_SUCCESS;
  1966.     }
  1968.     /* Check for sout mode */
  1969.     if( out->b_sout )
  1970.     {
  1971.         /* FIXME review this, proper lock may be missing */
  1972.         if( p_input->p->p_sout->i_out_pace_nocontrol > 0 &&
  1973.             p_input->p->b_out_pace_control )
  1974.         {
  1975.             msg_Dbg( p_input, "switching to sync mode" );
  1976.             p_input->p->b_out_pace_control = false;
  1977.         }
  1978.         else if( p_input->p->p_sout->i_out_pace_nocontrol <= 0 &&
  1979.                  !p_input->p->b_out_pace_control )
  1980.         {
  1981.             msg_Dbg( p_input, "switching to async mode" );
  1982.             p_input->p->b_out_pace_control = true;
  1983.         }
  1984.     }
  1986.     /* Decode */
  1987.     if( es->p_dec_record )
  1988.     {
  1989.         block_t *p_dup = block_Duplicate( p_block );
  1990.         if( p_dup )
  1991.             input_DecoderDecode( es->p_dec_record, p_dup,
  1992.                                  p_input->p->b_out_pace_control );
  1993.     }
  1994.     input_DecoderDecode( es->p_dec, p_block,
  1995.                          p_input->p->b_out_pace_control );
  1997.     es_format_t fmt_dsc;
  1998.     vlc_meta_t  *p_meta_dsc;
  1999.     if( input_DecoderHasFormatChanged( es->p_dec, &fmt_dsc, &p_meta_dsc ) )
  2000.     {
  2001.         EsOutUpdateInfo( out, es, &fmt_dsc, p_meta_dsc );
  2003.         es_format_Clean( &fmt_dsc );
  2004.         if( p_meta_dsc )
  2005.             vlc_meta_Delete( p_meta_dsc );
  2006.     }
  2008.     /* Check CC status */
  2009.     bool pb_cc[4];
  2011.     input_DecoderIsCcPresent( es->p_dec, pb_cc );
  2012.     for( int i = 0; i < 4; i++ )
  2013.     {
  2014.         static const vlc_fourcc_t fcc[4] = {
  2015.             VLC_FOURCC('c', 'c', '1', ' '),
  2016.             VLC_FOURCC('c', 'c', '2', ' '),
  2017.             VLC_FOURCC('c', 'c', '3', ' '),
  2018.             VLC_FOURCC('c', 'c', '4', ' '),
  2019.         };
  2020.         es_format_t fmt;
  2022.         if(  es->pb_cc_present[i] || !pb_cc[i] )
  2023.             continue;
  2024.         msg_Dbg( p_input, "Adding CC track %d for es[%d]", 1+i, es->i_id );
  2026.         es_format_Init( &fmt, SPU_ES, fcc[i] );
  2027.         fmt.i_group = es->fmt.i_group;
  2028.         if( asprintf( &fmt.psz_description,
  2029.                       _("Closed captions %u"), 1 + i ) == -1 )
  2030.             fmt.psz_description = NULL;
  2031.         es->pp_cc_es[i] = EsOutAdd( out, &fmt );
  2032.         es->pp_cc_es[i]->p_master = es;
  2033.         es_format_Clean( &fmt );
  2035.         /* */
  2036.         es->pb_cc_present[i] = true;
  2037.     }
  2039.     vlc_mutex_unlock( &p_sys->lock );
  2041.     return VLC_SUCCESS;
  2042. }
  2044. /*****************************************************************************
  2045.  * EsOutDel:
  2046.  *****************************************************************************/
  2047. static void EsOutDel( es_out_t *out, es_out_id_t *es )
  2048. {
  2049.     es_out_sys_t *p_sys = out->p_sys;
  2050.     bool b_reselect = false;
  2051.     int i;
  2053.     vlc_mutex_lock( &p_sys->lock );
  2055.     /* We don't try to reselect */
  2056.     if( es->p_dec )
  2057.     {
  2058.         while( !p_sys->p_input->b_die && !p_sys->b_buffering && es->p_dec )
  2059.         {
  2060.             if( input_DecoderIsEmpty( es->p_dec ) &&
  2061.                 ( !es->p_dec_record || input_DecoderIsEmpty( es->p_dec_record ) ))
  2062.                 break;
  2063.             /* FIXME there should be a way to have auto deleted es, but there will be
  2064.              * a problem when another codec of the same type is created (mainly video) */
  2065.             msleep( 20*1000 );
  2066.         }
  2067.         EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
  2068.     }
  2070.     if( es->p_pgrm == p_sys->p_pgrm )
  2071.         EsOutESVarUpdate( out, es, true );
  2073.     TAB_REMOVE( p_sys->i_es, p_sys->es, es );
  2075.     /* Update program */
  2076.     es->p_pgrm->i_es--;
  2077.     if( es->p_pgrm->i_es == 0 )
  2078.         msg_Dbg( p_sys->p_input, "Program doesn't contain anymore ES" );
  2080.     if( es->b_scrambled )
  2081.         EsOutProgramUpdateScrambled( out, es->p_pgrm );
  2083.     /* */
  2084.     if( p_sys->p_es_audio == es || p_sys->p_es_video == es ||
  2085.         p_sys->p_es_sub == es ) b_reselect = true;
  2087.     if( p_sys->p_es_audio == es ) p_sys->p_es_audio = NULL;
  2088.     if( p_sys->p_es_video == es ) p_sys->p_es_video = NULL;
  2089.     if( p_sys->p_es_sub   == es ) p_sys->p_es_sub   = NULL;
  2091.     switch( es->fmt.i_cat )
  2092.     {
  2093.         case AUDIO_ES:
  2094.             p_sys->i_audio--;
  2095.             break;
  2096.         case SPU_ES:
  2097.             p_sys->i_sub--;
  2098.             break;
  2099.         case VIDEO_ES:
  2100.             p_sys->i_video--;
  2101.             break;
  2102.     }
  2104.     /* Re-select another track when needed */
  2105.     if( b_reselect )
  2106.     {
  2107.         for( i = 0; i < p_sys->i_es; i++ )
  2108.         {
  2109.             if( es->fmt.i_cat == p_sys->es[i]->fmt.i_cat )
  2110.                 EsOutSelect( out, p_sys->es[i], false );
  2111.         }
  2112.     }
  2114.     free( es->psz_language );
  2115.     free( es->psz_language_code );
  2117.     es_format_Clean( &es->fmt );
  2119.     vlc_mutex_unlock( &p_sys->lock );
  2121.     free( es );
  2122. }
  2124. /**
  2125.  * Control query handler
  2126.  *
  2127.  * param out the es_out to control
  2128.  * param i_query A es_out query as defined in include/ninput.h
  2129.  * param args a variable list of arguments for the query
  2130.  * return VLC_SUCCESS or an error code
  2131.  */
  2132. static int EsOutControlLocked( es_out_t *out, int i_query, va_list args )
  2133. {
  2134.     es_out_sys_t *p_sys = out->p_sys;
  2135.     bool  b, *pb;
  2136.     int         i;
  2138.     es_out_id_t *es;
  2140.     switch( i_query )
  2141.     {
  2142.         case ES_OUT_SET_ES_STATE:
  2143.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2144.             b = (bool) va_arg( args, int );
  2145.             if( b && !EsIsSelected( es ) )
  2146.             {
  2147.                 EsSelect( out, es );
  2148.                 return EsIsSelected( es ) ? VLC_SUCCESS : VLC_EGENERIC;
  2149.             }
  2150.             else if( !b && EsIsSelected( es ) )
  2151.             {
  2152.                 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
  2153.                 return VLC_SUCCESS;
  2154.             }
  2155.             return VLC_SUCCESS;
  2157.         case ES_OUT_GET_ES_STATE:
  2158.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2159.             pb = (bool*) va_arg( args, bool * );
  2161.             *pb = EsIsSelected( es );
  2162.             return VLC_SUCCESS;
  2164.         case ES_OUT_SET_ACTIVE:
  2165.         {
  2166.             b = (bool) va_arg( args, int );
  2167.             if( b && !p_sys->b_active && p_sys->i_es > 0 )
  2168.             {
  2169.                 /* XXX Terminate vout if there are tracks but no video one.
  2170.                  * This one is not mandatory but is he earliest place where it
  2171.                  * can be done */
  2172.                 for( i = 0; i < p_sys->i_es; i++ )
  2173.                 {
  2174.                     es_out_id_t *p_es = p_sys->es[i];
  2175.                     if( p_es->fmt.i_cat == VIDEO_ES )
  2176.                         break;
  2177.                 }
  2178.                 if( i >= p_sys->i_es )
  2179.                     input_resource_TerminateVout( p_sys->p_input->p->p_resource );
  2180.             }
  2181.             p_sys->b_active = b;
  2182.             return VLC_SUCCESS;
  2183.         }
  2185.         case ES_OUT_SET_MODE:
  2186.             i = (int) va_arg( args, int );
  2187.             if( i == ES_OUT_MODE_NONE || i == ES_OUT_MODE_ALL ||
  2188.                 i == ES_OUT_MODE_AUTO || i == ES_OUT_MODE_PARTIAL )
  2189.             {
  2190.                 p_sys->i_mode = i;
  2192.                 /* Reapply policy mode */
  2193.                 for( i = 0; i < p_sys->i_es; i++ )
  2194.                 {
  2195.                     if( EsIsSelected( p_sys->es[i] ) )
  2196.                     {
  2197.                         EsUnselect( out, p_sys->es[i],
  2198.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  2199.                     }
  2200.                 }
  2201.                 for( i = 0; i < p_sys->i_es; i++ )
  2202.                 {
  2203.                     EsOutSelect( out, p_sys->es[i], false );
  2204.                 }
  2205.                 return VLC_SUCCESS;
  2206.             }
  2207.             return VLC_EGENERIC;
  2209.         case ES_OUT_SET_ES:
  2210.         case ES_OUT_RESTART_ES:
  2211.         {
  2212.             int i_cat;
  2214.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2216.             if( es == NULL )
  2217.                 i_cat = UNKNOWN_ES;
  2218.             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
  2219.                 i_cat = AUDIO_ES;
  2220.             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
  2221.                 i_cat = VIDEO_ES;
  2222.             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
  2223.                 i_cat = SPU_ES;
  2224.             else
  2225.                 i_cat = -1;
  2227.             for( i = 0; i < p_sys->i_es; i++ )
  2228.             {
  2229.                 if( i_cat == -1 )
  2230.                 {
  2231.                     if( es == p_sys->es[i] )
  2232.                     {
  2233.                         EsOutSelect( out, es, true );
  2234.                         break;
  2235.                     }
  2236.                 }
  2237.                 else
  2238.                 {
  2239.                     if( i_cat == UNKNOWN_ES || p_sys->es[i]->fmt.i_cat == i_cat )
  2240.                     {
  2241.                         if( EsIsSelected( p_sys->es[i] ) )
  2242.                         {
  2243.                             if( i_query == ES_OUT_RESTART_ES )
  2244.                             {
  2245.                                 if( p_sys->es[i]->p_dec )
  2246.                                 {
  2247.                                     EsDestroyDecoder( out, p_sys->es[i] );
  2248.                                     EsCreateDecoder( out, p_sys->es[i] );
  2249.                                 }
  2250.                             }
  2251.                             else
  2252.                             {
  2253.                                 EsUnselect( out, p_sys->es[i],
  2254.                                             p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  2255.                             }
  2256.                         }
  2257.                     }
  2258.                 }
  2259.             }
  2260.             return VLC_SUCCESS;
  2261.         }
  2262.  
  2263.         case ES_OUT_SET_ES_DEFAULT:
  2264.         {
  2265.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2267.             if( es == NULL )
  2268.             {
  2269.                 /*p_sys->i_default_video_id = -1;*/
  2270.                 /*p_sys->i_default_audio_id = -1;*/
  2271.                 p_sys->i_default_sub_id = -1;
  2272.             }
  2273.             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
  2274.             {
  2275.                 /*p_sys->i_default_video_id = -1;*/
  2276.             }
  2277.             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
  2278.             {
  2279.                 /*p_sys->i_default_audio_id = -1;*/
  2280.             }
  2281.             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
  2282.             {
  2283.                 p_sys->i_default_sub_id = -1;
  2284.             }
  2285.             else
  2286.             {
  2287.                 /*if( es->fmt.i_cat == VIDEO_ES )
  2288.                     p_sys->i_default_video_id = es->i_id;
  2289.                 else
  2290.                 if( es->fmt.i_cat == AUDIO_ES )
  2291.                     p_sys->i_default_audio_id = es->i_id;
  2292.                 else*/
  2293.                 if( es->fmt.i_cat == SPU_ES )
  2294.                     p_sys->i_default_sub_id = es->i_id;
  2295.             }
  2296.             return VLC_SUCCESS;
  2297.         }
  2299.         case ES_OUT_SET_PCR:
  2300.         case ES_OUT_SET_GROUP_PCR:
  2301.         {
  2302.             es_out_pgrm_t *p_pgrm = NULL;
  2303.             int            i_group = 0;
  2304.             int64_t        i_pcr;
  2306.             /* Search program */
  2307.             if( i_query == ES_OUT_SET_PCR )
  2308.             {
  2309.                 p_pgrm = p_sys->p_pgrm;
  2310.                 if( !p_pgrm )
  2311.                     p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
  2312.             }
  2313.             else
  2314.             {
  2315.                 i_group = (int)va_arg( args, int );
  2316.                 p_pgrm = EsOutProgramFind( out, i_group );
  2317.             }
  2318.             if( !p_pgrm )
  2319.                 return VLC_EGENERIC;
  2321.             i_pcr = (int64_t)va_arg( args, int64_t );
  2322.             if( i_pcr <= VLC_TS_INVALID )
  2323.             {
  2324.                 msg_Err( p_sys->p_input, "Invalid PCR value in ES_OUT_SET_(GROUP_)PCR !" );
  2325.                 return VLC_EGENERIC;
  2326.             }
  2328.             /* TODO do not use mdate() but proper stream acquisition date */
  2329.             bool b_late;
  2330.             input_clock_Update( p_pgrm->p_clock, VLC_OBJECT(p_sys->p_input),
  2331.                                 &b_late,
  2332.                                 p_sys->p_input->p->b_can_pace_control || p_sys->b_buffering,
  2333.                                 EsOutIsExtraBufferingAllowed( out ),
  2334.                                 i_pcr, mdate() );
  2336.             if( p_pgrm == p_sys->p_pgrm )
  2337.             {
  2338.                 if( p_sys->b_buffering )
  2339.                 {
  2340.                     /* Check buffering state on master clock update */
  2341.                     EsOutDecodersStopBuffering( out, false );
  2342.                 }
  2343.                 else if( b_late )
  2344.                 {
  2345.                     mtime_t i_pts_delay = input_clock_GetJitter( p_pgrm->p_clock );
  2347.                     /* Avoid dangerously high value */
  2348.                     const mtime_t i_pts_delay_max = 30000000;
  2349.                     if( i_pts_delay > i_pts_delay_max )
  2350.                         i_pts_delay = __MAX( i_pts_delay_max, p_sys->i_pts_delay );
  2352.                     /* Force a rebufferization when we are too late */
  2353.                     msg_Err( p_sys->p_input,
  2354.                              "ES_OUT_SET_(GROUP_)PCR  is called too late, increasing pts_delay to %d ms",
  2355.                              (int)(i_pts_delay/1000) );
  2357.                     /* It is not really good, as we throw away already buffered data
  2358.                      * TODO have a mean to correctly reenter bufferization */
  2359.                     es_out_Control( out, ES_OUT_RESET_PCR );
  2361.                     es_out_Control( out, ES_OUT_SET_JITTER, i_pts_delay, p_sys->i_cr_average );
  2362.                 }
  2363.             }
  2364.             return VLC_SUCCESS;
  2365.         }
  2367.         case ES_OUT_RESET_PCR:
  2368.             msg_Err( p_sys->p_input, "ES_OUT_RESET_PCR called" );
  2369.             EsOutChangePosition( out );
  2370.             return VLC_SUCCESS;
  2372.         case ES_OUT_SET_GROUP:
  2373.         {
  2374.             int j;
  2375.             i = (int) va_arg( args, int );
  2376.             for( j = 0; j < p_sys->i_pgrm; j++ )
  2377.             {
  2378.                 es_out_pgrm_t *p_pgrm = p_sys->pgrm[j];
  2379.                 if( p_pgrm->i_id == i )
  2380.                 {
  2381.                     EsOutProgramSelect( out, p_pgrm );
  2382.                     return VLC_SUCCESS;
  2383.                 }
  2384.             }
  2385.             return VLC_EGENERIC;
  2386.         }
  2388.         case ES_OUT_SET_ES_FMT:
  2389.         {
  2390.             /* This ain't pretty but is need by some demuxers (eg. Ogg )
  2391.              * to update the p_extra data */
  2392.             es_format_t *p_fmt;
  2393.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2394.             p_fmt = (es_format_t*) va_arg( args, es_format_t * );
  2395.             if( es == NULL )
  2396.                 return VLC_EGENERIC;
  2398.             if( p_fmt->i_extra )
  2399.             {
  2400.                 es->fmt.i_extra = p_fmt->i_extra;
  2401.                 es->fmt.p_extra = realloc( es->fmt.p_extra, p_fmt->i_extra );
  2402.                 memcpy( es->fmt.p_extra, p_fmt->p_extra, p_fmt->i_extra );
  2404.                 if( !es->p_dec )
  2405.                     return VLC_SUCCESS;
  2406. #if 1
  2407.                 EsDestroyDecoder( out, es );
  2409.                 EsCreateDecoder( out, es );
  2410. #else
  2411.                 es->p_dec->fmt_in.i_extra = p_fmt->i_extra;
  2412.                 es->p_dec->fmt_in.p_extra =
  2413.                     realloc( es->p_dec->fmt_in.p_extra, p_fmt->i_extra );
  2414.                 memcpy( es->p_dec->fmt_in.p_extra,
  2415.                         p_fmt->p_extra, p_fmt->i_extra );
  2416. #endif
  2417.             }
  2419.             return VLC_SUCCESS;
  2420.         }
  2422.         case ES_OUT_SET_ES_SCRAMBLED_STATE:
  2423.         {
  2424.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  2425.             bool b_scrambled = (bool)va_arg( args, int );
  2427.             if( !es->b_scrambled != !b_scrambled )
  2428.             {
  2429.                 es->b_scrambled = b_scrambled;
  2430.                 EsOutProgramUpdateScrambled( out, es->p_pgrm );
  2431.             }
  2432.             return VLC_SUCCESS;
  2433.         }
  2435.         case ES_OUT_SET_NEXT_DISPLAY_TIME:
  2436.         {
  2437.             const int64_t i_date = (int64_t)va_arg( args, int64_t );
  2439.             if( i_date < 0 )
  2440.                 return VLC_EGENERIC;
  2442.             p_sys->i_preroll_end = i_date;
  2444.             return VLC_SUCCESS;
  2445.         }
  2446.         case ES_OUT_SET_GROUP_META:
  2447.         {
  2448.             int i_group = (int)va_arg( args, int );
  2449.             vlc_meta_t *p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t * );
  2451.             EsOutProgramMeta( out, i_group, p_meta );
  2452.             return VLC_SUCCESS;
  2453.         }
  2454.         case ES_OUT_SET_GROUP_EPG:
  2455.         {
  2456.             int i_group = (int)va_arg( args, int );
  2457.             vlc_epg_t *p_epg = (vlc_epg_t*)va_arg( args, vlc_epg_t * );
  2459.             EsOutProgramEpg( out, i_group, p_epg );
  2460.             return VLC_SUCCESS;
  2461.         }
  2463.         case ES_OUT_DEL_GROUP:
  2464.         {
  2465.             int i_group = (int)va_arg( args, int );
  2467.             return EsOutProgramDel( out, i_group );
  2468.         }
  2470.         case ES_OUT_SET_META:
  2471.         {
  2472.             const vlc_meta_t *p_meta = va_arg( args, const vlc_meta_t * );
  2474.             EsOutMeta( out, p_meta );
  2475.             return VLC_SUCCESS;
  2476.         }
  2478.         case ES_OUT_GET_WAKE_UP:
  2479.         {
  2480.             mtime_t *pi_wakeup = (mtime_t*)va_arg( args, mtime_t* );
  2481.             *pi_wakeup = EsOutGetWakeup( out );
  2482.             return VLC_SUCCESS;
  2483.         }
  2485.         case ES_OUT_SET_ES_BY_ID:
  2486.         case ES_OUT_RESTART_ES_BY_ID:
  2487.         case ES_OUT_SET_ES_DEFAULT_BY_ID:
  2488.         {
  2489.             const int i_id = (int)va_arg( args, int );
  2490.             es_out_id_t *p_es = EsOutGetFromID( out, i_id );
  2491.             int i_new_query;
  2493.             switch( i_query )
  2494.             {
  2495.             case ES_OUT_SET_ES_BY_ID:         i_new_query = ES_OUT_SET_ES; break;
  2496.             case ES_OUT_RESTART_ES_BY_ID:     i_new_query = ES_OUT_RESTART_ES; break;
  2497.             case ES_OUT_SET_ES_DEFAULT_BY_ID: i_new_query = ES_OUT_SET_ES_DEFAULT; break;
  2498.             default:
  2499.               assert(0);
  2500.             }
  2501.             /* TODO if the lock is made non recursive it should be changed */
  2502.             int i_ret = es_out_Control( out, i_new_query, p_es );
  2504.             /* Clean up vout after user action (in active mode only).
  2505.              * FIXME it does not work well with multiple video windows */
  2506.             if( p_sys->b_active )
  2507.                 input_resource_TerminateVout( p_sys->p_input->p->p_resource );
  2508.             return i_ret;
  2509.         }
  2511.         case ES_OUT_GET_BUFFERING:
  2512.             pb = (bool *)va_arg( args, bool* );
  2513.             *pb = p_sys->b_buffering;
  2514.             return VLC_SUCCESS;
  2516.         case ES_OUT_GET_EMPTY:
  2517.             pb = (bool *)va_arg( args, bool* );
  2518.             *pb = EsOutDecodersIsEmpty( out );
  2519.             return VLC_SUCCESS;
  2521.         case ES_OUT_SET_DELAY:
  2522.         {
  2523.             const int i_cat = (int)va_arg( args, int );
  2524.             const mtime_t i_delay = (mtime_t)va_arg( args, mtime_t );
  2525.             EsOutSetDelay( out, i_cat, i_delay );
  2526.             return VLC_SUCCESS;
  2527.         }
  2529.         case ES_OUT_SET_RECORD_STATE:
  2530.             b = (bool) va_arg( args, int );
  2531.             return EsOutSetRecord( out, b );
  2533.         case ES_OUT_SET_PAUSE_STATE:
  2534.         {
  2535.             const bool b_source_paused = (bool)va_arg( args, int );
  2536.             const bool b_paused = (bool)va_arg( args, int );
  2537.             const mtime_t i_date = (mtime_t) va_arg( args, mtime_t );
  2539.             assert( !b_source_paused == !b_paused );
  2540.             EsOutChangePause( out, b_paused, i_date );
  2542.             return VLC_SUCCESS;
  2543.         }
  2545.         case ES_OUT_SET_RATE:
  2546.         {
  2547.             const int i_src_rate = (int)va_arg( args, int );
  2548.             const int i_rate = (int)va_arg( args, int );
  2550.             assert( i_src_rate == i_rate );
  2551.             EsOutChangeRate( out, i_rate );
  2553.             return VLC_SUCCESS;
  2554.         }
  2556.         case ES_OUT_SET_TIME:
  2557.         {
  2558.             const mtime_t i_date = (mtime_t)va_arg( args, mtime_t );
  2560.             assert( i_date == -1 );
  2561.             EsOutChangePosition( out );
  2563.             return VLC_SUCCESS;
  2564.         }
  2566.         case ES_OUT_SET_FRAME_NEXT:
  2567.             EsOutFrameNext( out );
  2568.             return VLC_SUCCESS;
  2570.         case ES_OUT_SET_TIMES:
  2571.         {
  2572.             double f_position = (double)va_arg( args, double );
  2573.             mtime_t i_time = (mtime_t)va_arg( args, mtime_t );
  2574.             mtime_t i_length = (mtime_t)va_arg( args, mtime_t );
  2576.             /* Fix for buffering delay */
  2577.             const mtime_t i_delay = EsOutGetBuffering( out );
  2579.             i_time -= i_delay;
  2580.             if( i_time < 0 )
  2581.                 i_time = 0;
  2583.             if( i_length > 0 )
  2584.                 f_position -= (double)i_delay / i_length;
  2585.             if( f_position < 0 )
  2586.                 f_position = 0;
  2588.             if( !p_sys->b_buffering )
  2589.                 input_SendEventTimes( p_sys->p_input, f_position, i_time, i_length );
  2590.             return VLC_SUCCESS;
  2591.         }
  2592.         case ES_OUT_SET_JITTER:
  2593.         {
  2594.             mtime_t i_pts_delay = (mtime_t)va_arg( args, mtime_t );
  2595.             int     i_cr_average = (int)va_arg( args, int );
  2597.             if( i_pts_delay == p_sys->i_pts_delay &&
  2598.                 i_cr_average == p_sys->i_cr_average )
  2599.                 return VLC_SUCCESS;
  2601.             p_sys->i_pts_delay = i_pts_delay;
  2602.             p_sys->i_cr_average = i_cr_average;
  2604.             for( int i = 0; i < p_sys->i_pgrm; i++ )
  2605.                 input_clock_SetJitter( p_sys->pgrm[i]->p_clock,
  2606.                                        i_pts_delay, i_cr_average );
  2607.             return VLC_SUCCESS;
  2608.         }
  2610.         default:
  2611.             msg_Err( p_sys->p_input, "unknown query in es_out_Control" );
  2612.             return VLC_EGENERIC;
  2613.     }
  2614. }
  2615. static int EsOutControl( es_out_t *out, int i_query, va_list args )
  2616. {
  2617.     es_out_sys_t *p_sys = out->p_sys;
  2618.     int i_ret;
  2620.     vlc_mutex_lock( &p_sys->lock );
  2621.     i_ret = EsOutControlLocked( out, i_query, args );
  2622.     vlc_mutex_unlock( &p_sys->lock );
  2624.     return i_ret;
  2625. }
  2627. /****************************************************************************
  2628.  * LanguageGetName: try to expend iso639 into plain name
  2629.  ****************************************************************************/
  2630. static char *LanguageGetName( const char *psz_code )
  2631. {
  2632.     const iso639_lang_t *pl;
  2634.     if( psz_code == NULL )
  2635.     {
  2636.         return strdup( "" );
  2637.     }
  2639.     if( strlen( psz_code ) == 2 )
  2640.     {
  2641.         pl = GetLang_1( psz_code );
  2642.     }
  2643.     else if( strlen( psz_code ) == 3 )
  2644.     {
  2645.         pl = GetLang_2B( psz_code );
  2646.         if( !strcmp( pl->psz_iso639_1, "??" ) )
  2647.         {
  2648.             pl = GetLang_2T( psz_code );
  2649.         }
  2650.     }
  2651.     else
  2652.     {
  2653.         return strdup( psz_code );
  2654.     }
  2656.     if( !strcmp( pl->psz_iso639_1, "??" ) )
  2657.     {
  2658.        return strdup( psz_code );
  2659.     }
  2660.     else
  2661.     {
  2662.         if( *pl->psz_native_name )
  2663.         {
  2664.             return strdup( pl->psz_native_name );
  2665.         }
  2666.         return strdup( pl->psz_eng_name );
  2667.     }
  2668. }
  2670. /* Get a 2 char code */
  2671. static char *LanguageGetCode( const char *psz_lang )
  2672. {
  2673.     const iso639_lang_t *pl;
  2675.     if( psz_lang == NULL || *psz_lang == '' )
  2676.         return strdup("??");
  2678.     for( pl = p_languages; pl->psz_iso639_1 != NULL; pl++ )
  2679.     {
  2680.         if( !strcasecmp( pl->psz_eng_name, psz_lang ) ||
  2681.             !strcasecmp( pl->psz_native_name, psz_lang ) ||
  2682.             !strcasecmp( pl->psz_iso639_1, psz_lang ) ||
  2683.             !strcasecmp( pl->psz_iso639_2T, psz_lang ) ||
  2684.             !strcasecmp( pl->psz_iso639_2B, psz_lang ) )
  2685.             break;
  2686.     }
  2688.     if( pl->psz_iso639_1 != NULL )
  2689.         return strdup( pl->psz_iso639_1 );
  2691.     return strdup("??");
  2692. }
  2694. static char **LanguageSplit( const char *psz_langs )
  2695. {
  2696.     char *psz_dup;
  2697.     char *psz_parser;
  2698.     char **ppsz = NULL;
  2699.     int i_psz = 0;
  2701.     if( psz_langs == NULL ) return NULL;
  2703.     psz_parser = psz_dup = strdup(psz_langs);
  2705.     while( psz_parser && *psz_parser )
  2706.     {
  2707.         char *psz;
  2708.         char *psz_code;
  2710.         psz = strchr(psz_parser, ',' );
  2711.         if( psz ) *psz++ = '';
  2713.         if( !strcmp( psz_parser, "any" ) )
  2714.         {
  2715.             TAB_APPEND( i_psz, ppsz, strdup("any") );
  2716.         }
  2717.         else
  2718.         {
  2719.             psz_code = LanguageGetCode( psz_parser );
  2720.             if( strcmp( psz_code, "??" ) )
  2721.             {
  2722.                 TAB_APPEND( i_psz, ppsz, psz_code );
  2723.             }
  2724.             else
  2725.             {
  2726.                 free( psz_code );
  2727.             }
  2728.         }
  2730.         psz_parser = psz;
  2731.     }
  2733.     if( i_psz )
  2734.     {
  2735.         TAB_APPEND( i_psz, ppsz, NULL );
  2736.     }
  2738.     free( psz_dup );
  2739.     return ppsz;
  2740. }
  2742. static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang )
  2743. {
  2744.     int i;
  2746.     if( !ppsz_langs || !psz_lang ) return -1;
  2748.     for( i = 0; ppsz_langs[i]; i++ )
  2749.     {
  2750.         if( !strcasecmp( ppsz_langs[i], psz_lang ) ||
  2751.             !strcasecmp( ppsz_langs[i], "any" ) )
  2752.         {
  2753.             return i;
  2754.         }
  2755.     }
  2757.     return -1;
  2758. }
  2760. /****************************************************************************
  2761.  * EsOutUpdateInfo:
  2762.  * - add meta info to the playlist item
  2763.  ****************************************************************************/
  2764. static void EsOutUpdateInfo( es_out_t *out, es_out_id_t *es, const es_format_t *fmt, const vlc_meta_t *p_meta )
  2765. {
  2766.     es_out_sys_t   *p_sys = out->p_sys;
  2767.     input_thread_t *p_input = p_sys->p_input;
  2768.     const es_format_t *p_fmt_es = &es->fmt;
  2769.     char           *psz_cat;
  2770.     lldiv_t         div;
  2772.     /* Create category name */
  2773.     if( asprintf( &psz_cat, _("Stream %d"), es->i_meta_id ) == -1 )
  2774.         return;
  2776.     /* Remove previous information */
  2777.     input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
  2779.     /* Add informations */
  2780.     const char *psz_type;
  2781.     switch( fmt->i_cat )
  2782.     {
  2783.     case AUDIO_ES:
  2784.         psz_type = _("Audio");
  2785.         break;
  2786.     case VIDEO_ES:
  2787.         psz_type = _("Video");
  2788.         break;
  2789.     case SPU_ES:
  2790.         psz_type = _("Subtitle");
  2791.         break;
  2792.     default:
  2793.         psz_type = NULL;
  2794.         break;
  2795.     }
  2797.     if( psz_type )
  2798.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Type"), psz_type );
  2800.     if( es->i_meta_id != es->i_id )
  2801.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Original ID"),
  2802.                        "%d", es->i_id );
  2804.     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Codec"),
  2805.                    "%.4s", (char*)&p_fmt_es->i_codec );
  2807.     if( es->psz_language && *es->psz_language )
  2808.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"),
  2809.                        "%s", es->psz_language );
  2810.     if( fmt->psz_description && *fmt->psz_description )
  2811.         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Description"),
  2812.                        "%s", fmt->psz_description );
  2814.     switch( fmt->i_cat )
  2815.     {
  2816.     case AUDIO_ES:
  2817.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2818.                        _("Type"), _("Audio") );
  2820.         if( fmt->audio.i_physical_channels & AOUT_CHAN_PHYSMASK )
  2821.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
  2822.                            "%s", _( aout_FormatPrintChannels( &fmt->audio ) ) );
  2823.         else if( fmt->audio.i_channels > 0 )
  2824.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
  2825.                            "%u", fmt->audio.i_channels );
  2827.         if( fmt->audio.i_rate > 0 )
  2828.         {
  2829.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"),
  2830.                            _("%u Hz"), fmt->audio.i_rate );
  2831.             /* FIXME that should be removed or improved ! (used by text/strings.c) */
  2832.             var_SetInteger( p_input, "sample-rate", fmt->audio.i_rate );
  2833.         }
  2835.         unsigned int i_bitspersample = fmt->audio.i_bitspersample;
  2836.         if( i_bitspersample <= 0 )
  2837.             i_bitspersample = aout_BitsPerSample( p_fmt_es->i_codec );
  2838.         if( i_bitspersample > 0 )
  2839.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2840.                            _("Bits per sample"), "%u",
  2841.                            i_bitspersample );
  2843.         if( fmt->i_bitrate > 0 )
  2844.         {
  2845.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"),
  2846.                            _("%u kb/s"), fmt->i_bitrate / 1000 );
  2847.             /* FIXME that should be removed or improved ! (used by text/strings.c) */
  2848.             var_SetInteger( p_input, "bit-rate", fmt->i_bitrate );
  2849.         }
  2850.         for( int i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
  2851.         {
  2852.             const audio_replay_gain_t *p_rg = &fmt->audio_replay_gain;
  2853.             if( !p_rg->pb_gain[i] )
  2854.                 continue;
  2855.             const char *psz_name;
  2856.             if( i == AUDIO_REPLAY_GAIN_TRACK )
  2857.                 psz_name = _("Track replay gain");
  2858.             else
  2859.                 psz_name = _("Album replay gain");
  2860.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2861.                            psz_name, _("%.2f dB"), p_rg->pf_gain[i] );
  2862.         }
  2863.         break;
  2865.     case VIDEO_ES:
  2866.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2867.                        _("Type"), _("Video") );
  2869.         if( fmt->video.i_width > 0 && fmt->video.i_height > 0 )
  2870.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2871.                            _("Resolution"), "%ux%u",
  2872.                            fmt->video.i_width, fmt->video.i_height );
  2874.         if( fmt->video.i_visible_width > 0 &&
  2875.             fmt->video.i_visible_height > 0 )
  2876.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2877.                            _("Display resolution"), "%ux%u",
  2878.                            fmt->video.i_visible_width,
  2879.                            fmt->video.i_visible_height);
  2880.        if( fmt->video.i_frame_rate > 0 &&
  2881.            fmt->video.i_frame_rate_base > 0 )
  2882.        {
  2883.            div = lldiv( (float)fmt->video.i_frame_rate /
  2884.                                fmt->video.i_frame_rate_base * 1000000,
  2885.                                1000000 );
  2886.            if( div.rem > 0 )
  2887.                input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2888.                               _("Frame rate"), "%"PRId64".%06u",
  2889.                               div.quot, (unsigned int )div.rem );
  2890.            else
  2891.                input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2892.                               _("Frame rate"), "%"PRId64, div.quot );
  2893.        }
  2894.        break;
  2896.     case SPU_ES:
  2897.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2898.                        _("Type"), _("Subtitle") );
  2899.         break;
  2901.     default:
  2902.         break;
  2903.     }
  2905.     /* Append generic meta */
  2906.     if( p_meta )
  2907.     {
  2908.         char **ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags );
  2909.         for( int i = 0; ppsz_all_keys && ppsz_all_keys[i]; i++ )
  2910.         {
  2911.             char *psz_key = ppsz_all_keys[i];
  2912.             char *psz_value = vlc_dictionary_value_for_key( &p_meta->extra_tags, psz_key );
  2914.             if( psz_value )
  2915.                 input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  2916.                                vlc_gettext(psz_key), vlc_gettext(psz_value) );
  2917.             free( psz_key );
  2918.         }
  2919.         free( ppsz_all_keys );
  2920.     }
  2922.     free( psz_cat );
  2923. }