Revert "Hide es out timeshift delay from time display."
[vlc.git] / src / input / es_out.c
1 /*****************************************************************************
2  * es_out.c: Es Out handler for input.
3  *****************************************************************************
4  * Copyright (C) 2003-2004 the VideoLAN team
5  * $Id$
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  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <stdio.h>
33 #include <assert.h>
34 #include <vlc_common.h>
35
36 #include <vlc_input.h>
37 #include <vlc_es_out.h>
38 #include <vlc_block.h>
39 #include <vlc_aout.h>
40
41 #include "input_internal.h"
42 #include "clock.h"
43 #include "decoder.h"
44 #include "es_out.h"
45 #include "event.h"
46
47 #include "../stream_output/stream_output.h"
48
49 #include <vlc_iso_lang.h>
50 /* FIXME we should find a better way than including that */
51 #include "../text/iso-639_def.h"
52
53 /*****************************************************************************
54  * Local prototypes
55  *****************************************************************************/
56 typedef struct
57 {
58     /* Program ID */
59     int i_id;
60
61     /* Number of es for this pgrm */
62     int i_es;
63
64     bool b_selected;
65
66     /* Clock for this program */
67     input_clock_t *p_clock;
68
69     char    *psz_name;
70     char    *psz_now_playing;
71     char    *psz_publisher;
72
73     vlc_epg_t *p_epg;
74 } es_out_pgrm_t;
75
76 struct es_out_id_t
77 {
78     /* ES ID */
79     int       i_id;
80     es_out_pgrm_t *p_pgrm;
81
82     /* Channel in the track type */
83     int         i_channel;
84     es_format_t fmt;
85     char        *psz_language;
86     char        *psz_language_code;
87
88     decoder_t   *p_dec;
89     decoder_t   *p_dec_record;
90
91     /* Fields for Video with CC */
92     bool  pb_cc_present[4];
93     es_out_id_t  *pp_cc_es[4];
94
95     /* Field for CC track from a master video */
96     es_out_id_t *p_master;
97
98     /* ID for the meta data */
99     int         i_meta_id;
100 };
101
102 struct es_out_sys_t
103 {
104     input_thread_t *p_input;
105
106     /* */
107     vlc_mutex_t   lock;
108
109     /* all programs */
110     int           i_pgrm;
111     es_out_pgrm_t **pgrm;
112     es_out_pgrm_t **pp_selected_pgrm; /* --programs */
113     es_out_pgrm_t *p_pgrm;  /* Master program */
114
115     /* all es */
116     int         i_id;
117     int         i_es;
118     es_out_id_t **es;
119
120     /* mode gestion */
121     bool  b_active;
122     int         i_mode;
123
124     /* es count */
125     int         i_audio;
126     int         i_video;
127     int         i_sub;
128
129     /* es to select */
130     int         i_audio_last, i_audio_id;
131     int         i_sub_last, i_sub_id;
132     int         i_default_sub_id;   /* As specified in container; if applicable */
133     char        **ppsz_audio_language;
134     char        **ppsz_sub_language;
135
136     /* current main es */
137     es_out_id_t *p_es_audio;
138     es_out_id_t *p_es_video;
139     es_out_id_t *p_es_sub;
140
141     /* delay */
142     int64_t i_audio_delay;
143     int64_t i_spu_delay;
144
145     /* Rate used for clock */
146     int         i_rate;
147
148     /* */
149     bool        b_paused;
150     mtime_t     i_pause_date;
151
152     /* Current preroll */
153     mtime_t     i_preroll_end;
154
155     /* Used for buffering */
156     bool        b_buffering;
157     mtime_t     i_buffering_extra_initial;
158     mtime_t     i_buffering_extra_stream;
159     mtime_t     i_buffering_extra_system;
160
161     /* Record */
162     sout_instance_t *p_sout_record;
163 };
164
165 static es_out_id_t *EsOutAdd    ( es_out_t *, const es_format_t * );
166 static int          EsOutSend   ( es_out_t *, es_out_id_t *, block_t * );
167 static void         EsOutDel    ( es_out_t *, es_out_id_t * );
168 static int          EsOutControl( es_out_t *, int i_query, va_list );
169 static void         EsOutDelete ( es_out_t * );
170
171 static void         EsOutSelect( es_out_t *, es_out_id_t *es, bool b_force );
172 static void         EsOutUpdateInfo( es_out_t *, es_out_id_t *es, const es_format_t * );
173 static int          EsOutSetRecord(  es_out_t *, bool b_record );
174
175 static bool EsIsSelected( es_out_id_t *es );
176 static void EsSelect( es_out_t *out, es_out_id_t *es );
177 static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update );
178 static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es );
179 static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date );
180 static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date );
181 static void EsOutProgramsChangeRate( es_out_t *out );
182 static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced );
183 static char *LanguageGetName( const char *psz_code );
184 static char *LanguageGetCode( const char *psz_lang );
185 static char **LanguageSplit( const char *psz_langs );
186 static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang );
187
188 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm );
189
190 static const vlc_fourcc_t EsOutFourccClosedCaptions[4] = {
191     VLC_FOURCC('c', 'c', '1', ' '),
192     VLC_FOURCC('c', 'c', '2', ' '),
193     VLC_FOURCC('c', 'c', '3', ' '),
194     VLC_FOURCC('c', 'c', '4', ' '),
195 };
196 static inline int EsOutGetClosedCaptionsChannel( vlc_fourcc_t fcc )
197 {
198     int i;
199     for( i = 0; i < 4; i++ )
200     {
201         if( fcc == EsOutFourccClosedCaptions[i] )
202             return i;
203     }
204     return -1;
205 }
206
207
208 /*****************************************************************************
209  * input_EsOutNew:
210  *****************************************************************************/
211 es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate )
212 {
213     vlc_value_t  val;
214     int i;
215
216     es_out_t     *out = malloc( sizeof( *out ) );
217     if( !out )
218         return NULL;
219
220     es_out_sys_t *p_sys = malloc( sizeof( *p_sys ) );
221     if( !p_sys )
222     {
223         free( out );
224         return NULL;
225     }
226
227     out->pf_add     = EsOutAdd;
228     out->pf_send    = EsOutSend;
229     out->pf_del     = EsOutDel;
230     out->pf_control = EsOutControl;
231     out->pf_destroy = EsOutDelete;
232     out->p_sys      = p_sys;
233     out->b_sout     = p_input->p->p_sout != NULL;
234
235
236     vlc_mutex_init_recursive( &p_sys->lock );
237     p_sys->p_input = p_input;
238
239     p_sys->b_active = false;
240     p_sys->i_mode   = ES_OUT_MODE_AUTO;
241
242
243     TAB_INIT( p_sys->i_pgrm, p_sys->pgrm );
244     p_sys->p_pgrm   = NULL;
245
246     p_sys->i_id    = 0;
247
248     TAB_INIT( p_sys->i_es, p_sys->es );
249
250     p_sys->i_audio = 0;
251     p_sys->i_video = 0;
252     p_sys->i_sub   = 0;
253
254     /* */
255     var_Get( p_input, "audio-track", &val );
256     p_sys->i_audio_last = val.i_int;
257
258     var_Get( p_input, "sub-track", &val );
259     p_sys->i_sub_last = val.i_int;
260
261     p_sys->i_default_sub_id   = -1;
262
263     if( !p_input->b_preparsing )
264     {
265         var_Get( p_input, "audio-language", &val );
266         p_sys->ppsz_audio_language = LanguageSplit(val.psz_string);
267         if( p_sys->ppsz_audio_language )
268         {
269             for( i = 0; p_sys->ppsz_audio_language[i]; i++ )
270                 msg_Dbg( p_input, "selected audio language[%d] %s",
271                          i, p_sys->ppsz_audio_language[i] );
272         }
273         free( val.psz_string );
274
275         var_Get( p_input, "sub-language", &val );
276         p_sys->ppsz_sub_language = LanguageSplit(val.psz_string);
277         if( p_sys->ppsz_sub_language )
278         {
279             for( i = 0; p_sys->ppsz_sub_language[i]; i++ )
280                 msg_Dbg( p_input, "selected subtitle language[%d] %s",
281                          i, p_sys->ppsz_sub_language[i] );
282         }
283         free( val.psz_string );
284     }
285     else
286     {
287         p_sys->ppsz_sub_language = NULL;
288         p_sys->ppsz_audio_language = NULL;
289     }
290
291     var_Get( p_input, "audio-track-id", &val );
292     p_sys->i_audio_id = val.i_int;
293
294     var_Get( p_input, "sub-track-id", &val );
295     p_sys->i_sub_id = val.i_int;
296
297     p_sys->p_es_audio = NULL;
298     p_sys->p_es_video = NULL;
299     p_sys->p_es_sub   = NULL;
300
301     p_sys->i_audio_delay= 0;
302     p_sys->i_spu_delay  = 0;
303
304     p_sys->b_paused = false;
305     p_sys->i_pause_date = -1;
306
307     p_sys->i_rate = i_rate;
308
309     p_sys->b_buffering = true;
310     p_sys->i_buffering_extra_initial = 0;
311     p_sys->i_buffering_extra_stream = 0;
312     p_sys->i_buffering_extra_system = 0;
313     p_sys->i_preroll_end = -1;
314
315     p_sys->p_sout_record = NULL;
316
317     return out;
318 }
319
320 /*****************************************************************************
321  *
322  *****************************************************************************/
323 static void EsOutDelete( es_out_t *out )
324 {
325     es_out_sys_t *p_sys = out->p_sys;
326     int i;
327
328     if( p_sys->p_sout_record )
329         EsOutSetRecord( out, false );
330
331     for( i = 0; i < p_sys->i_es; i++ )
332     {
333         if( p_sys->es[i]->p_dec )
334             input_DecoderDelete( p_sys->es[i]->p_dec );
335
336         free( p_sys->es[i]->psz_language );
337         free( p_sys->es[i]->psz_language_code );
338         es_format_Clean( &p_sys->es[i]->fmt );
339
340         free( p_sys->es[i] );
341     }
342     if( p_sys->ppsz_audio_language )
343     {
344         for( i = 0; p_sys->ppsz_audio_language[i]; i++ )
345             free( p_sys->ppsz_audio_language[i] );
346         free( p_sys->ppsz_audio_language );
347     }
348     if( p_sys->ppsz_sub_language )
349     {
350         for( i = 0; p_sys->ppsz_sub_language[i]; i++ )
351             free( p_sys->ppsz_sub_language[i] );
352         free( p_sys->ppsz_sub_language );
353     }
354     free( p_sys->es );
355
356     /* FIXME duplicate work EsOutProgramDel (but we cannot use it) add a EsOutProgramClean ? */
357     for( i = 0; i < p_sys->i_pgrm; i++ )
358     {
359         es_out_pgrm_t *p_pgrm = p_sys->pgrm[i];
360         input_clock_Delete( p_pgrm->p_clock );
361         free( p_pgrm->psz_now_playing );
362         free( p_pgrm->psz_publisher );
363         free( p_pgrm->psz_name );
364         if( p_pgrm->p_epg )
365             vlc_epg_Delete( p_pgrm->p_epg );
366
367         free( p_pgrm );
368     }
369     TAB_CLEAN( p_sys->i_pgrm, p_sys->pgrm );
370     vlc_mutex_destroy( &p_sys->lock );
371
372     free( p_sys );
373     free( out );
374 }
375
376 static mtime_t EsOutGetWakeup( es_out_t *out )
377 {
378     es_out_sys_t   *p_sys = out->p_sys;
379     input_thread_t *p_input = p_sys->p_input;
380
381     if( !p_sys->p_pgrm )
382         return 0;
383
384     /* We do not have a wake up date if the input cannot have its speed
385      * controlled or sout is imposing its own or while buffering
386      *
387      * FIXME for !p_input->b_can_pace_control a wkeup time is still needed to avoid too strong buffering */
388     if( !p_input->b_can_pace_control ||
389         p_input->p->b_out_pace_control ||
390         p_sys->b_buffering )
391         return 0;
392
393     return input_clock_GetWakeup( p_sys->p_pgrm->p_clock );
394 }
395
396 static es_out_id_t *EsOutGetFromID( es_out_t *out, int i_id )
397 {
398     int i;
399     if( i_id < 0 )
400     {
401         /* Special HACK, -i_id is the cat of the stream */
402         return (es_out_id_t*)((uint8_t*)NULL-i_id);
403     }
404
405     for( i = 0; i < out->p_sys->i_es; i++ )
406     {
407         if( out->p_sys->es[i]->i_id == i_id )
408             return out->p_sys->es[i];
409     }
410     return NULL;
411 }
412
413 static bool EsOutDecodersIsEmpty( es_out_t *out )
414 {
415     es_out_sys_t      *p_sys = out->p_sys;
416     int i;
417
418     if( p_sys->b_buffering && p_sys->p_pgrm )
419     {
420         EsOutDecodersStopBuffering( out, true );
421         if( p_sys->b_buffering )
422             return true;
423     }
424
425     for( i = 0; i < p_sys->i_es; i++ )
426     {
427         es_out_id_t *es = p_sys->es[i];
428
429         if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) )
430             return false;
431         if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) )
432             return false;
433     }
434     return true;
435 }
436
437 static void EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay )
438 {
439     es_out_sys_t *p_sys = out->p_sys;
440
441     if( i_cat == AUDIO_ES )
442         p_sys->i_audio_delay = i_delay;
443     else if( i_cat == SPU_ES )
444         p_sys->i_spu_delay = i_delay;
445
446     for( int i = 0; i < p_sys->i_es; i++ )
447         EsOutDecoderChangeDelay( out, p_sys->es[i] );
448 }
449
450 static int EsOutSetRecord(  es_out_t *out, bool b_record )
451 {
452     es_out_sys_t   *p_sys = out->p_sys;
453     input_thread_t *p_input = p_sys->p_input;
454
455     assert( ( b_record && !p_sys->p_sout_record ) || ( !b_record && p_sys->p_sout_record ) );
456
457     if( b_record )
458     {
459         char *psz_path = var_CreateGetString( p_input, "input-record-path" );
460         if( !psz_path || *psz_path == '\0' )
461         {
462             free( psz_path );
463             psz_path = strdup( config_GetHomeDir() );
464         }
465
466         char *psz_sout = NULL;  // TODO conf
467
468         if( !psz_sout && psz_path )
469         {
470             char *psz_file = input_CreateFilename( VLC_OBJECT(p_input), psz_path, INPUT_RECORD_PREFIX, NULL );
471             if( psz_file )
472             {
473                 if( asprintf( &psz_sout, "#record{dst-prefix='%s'}", psz_file ) < 0 )
474                     psz_sout = NULL;
475                 free( psz_file );
476             }
477         }
478         free( psz_path );
479
480         if( !psz_sout )
481             return VLC_EGENERIC;
482
483 #ifdef ENABLE_SOUT
484         p_sys->p_sout_record = sout_NewInstance( p_input, psz_sout );
485 #endif
486         free( psz_sout );
487
488         if( !p_sys->p_sout_record )
489             return VLC_EGENERIC;
490
491         for( int i = 0; i < p_sys->i_es; i++ )
492         {
493             es_out_id_t *p_es = p_sys->es[i];
494
495             if( !p_es->p_dec || p_es->p_master )
496                 continue;
497
498             p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record );
499             if( p_es->p_dec_record && p_sys->b_buffering )
500                 input_DecoderStartBuffering( p_es->p_dec_record );
501         }
502     }
503     else
504     {
505         for( int i = 0; i < p_sys->i_es; i++ )
506         {
507             es_out_id_t *p_es = p_sys->es[i];
508
509             if( !p_es->p_dec_record )
510                 continue;
511
512             input_DecoderDelete( p_es->p_dec_record );
513             p_es->p_dec_record = NULL;
514         }
515 #ifdef ENABLE_SOUT
516         sout_DeleteInstance( p_sys->p_sout_record );
517 #endif
518         p_sys->p_sout_record = NULL;
519     }
520
521     return VLC_SUCCESS;
522 }
523 static void EsOutChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
524 {
525     es_out_sys_t *p_sys = out->p_sys;
526
527     /* XXX the order is important */
528     if( b_paused )
529     {
530         EsOutDecodersChangePause( out, true, i_date );
531         EsOutProgramChangePause( out, true, i_date );
532     }
533     else
534     {
535         if( p_sys->i_buffering_extra_initial > 0 )
536         {
537             mtime_t i_stream_start;
538             mtime_t i_system_start;
539             mtime_t i_stream_duration;
540             mtime_t i_system_duration;
541             int i_ret;
542             i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
543                                           &i_stream_start, &i_system_start,
544                                           &i_stream_duration, &i_system_duration );
545             if( !i_ret )
546             {
547                 /* FIXME pcr != exactly what wanted */
548                 const mtime_t i_used = /*(i_stream_duration - p_sys->p_input->i_pts_delay)*/ p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial;
549                 i_date -= i_used;
550             }
551             p_sys->i_buffering_extra_initial = 0;
552             p_sys->i_buffering_extra_stream = 0;
553             p_sys->i_buffering_extra_system = 0;
554         }
555         EsOutProgramChangePause( out, false, i_date );
556         EsOutDecodersChangePause( out, false, i_date );
557
558         EsOutProgramsChangeRate( out );
559     }
560     p_sys->b_paused = b_paused;
561     p_sys->i_pause_date = i_date;
562 }
563
564 static void EsOutChangeRate( es_out_t *out, int i_rate )
565 {
566     es_out_sys_t      *p_sys = out->p_sys;
567
568     p_sys->i_rate = i_rate;
569
570     if( !p_sys->b_paused )
571         EsOutProgramsChangeRate( out );
572 }
573
574 static void EsOutChangePosition( es_out_t *out )
575 {
576     es_out_sys_t      *p_sys = out->p_sys;
577
578     for( int i = 0; i < p_sys->i_es; i++ )
579     {
580         es_out_id_t *p_es = p_sys->es[i];
581
582         if( !p_es->p_dec )
583             continue;
584
585         input_DecoderStartBuffering( p_es->p_dec );
586
587         if( p_es->p_dec_record )
588             input_DecoderStartBuffering( p_es->p_dec );
589     }
590
591     for( int i = 0; i < p_sys->i_pgrm; i++ )
592         input_clock_Reset( p_sys->pgrm[i]->p_clock );
593
594     p_sys->b_buffering = true;
595     p_sys->i_buffering_extra_initial = 0;
596     p_sys->i_buffering_extra_stream = 0;
597     p_sys->i_buffering_extra_system = 0;
598     p_sys->i_preroll_end = -1;
599 }
600
601
602
603 static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
604 {
605     es_out_sys_t *p_sys = out->p_sys;
606     int i_ret;
607
608     mtime_t i_stream_start;
609     mtime_t i_system_start;
610     mtime_t i_stream_duration;
611     mtime_t i_system_duration;
612     i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
613                                   &i_stream_start, &i_system_start,
614                                   &i_stream_duration, &i_system_duration );
615     assert( !i_ret || b_forced );
616     if( i_ret )
617         return;
618
619     mtime_t i_preroll_duration = 0;
620     if( p_sys->i_preroll_end >= 0 )
621         i_preroll_duration = __MAX( p_sys->i_preroll_end - i_stream_start, 0 );
622
623     const mtime_t i_buffering_duration = p_sys->p_input->i_pts_delay +
624                                          i_preroll_duration +
625                                          p_sys->i_buffering_extra_stream;
626
627     if( i_stream_duration <= i_buffering_duration && !b_forced )
628     {
629         msg_Dbg( p_sys->p_input, "Buffering %d%%",
630                  (int)(100 * i_stream_duration / i_buffering_duration ) );
631         return;
632     }
633
634     msg_Dbg( p_sys->p_input, "Stream buffering done (%d ms in %d ms)",
635               (int)(i_stream_duration/1000), (int)(i_system_duration/1000) );
636     p_sys->b_buffering = false;
637     p_sys->i_preroll_end = -1;
638
639     if( p_sys->i_buffering_extra_initial > 0 )
640     {
641         /* FIXME wrong ? */
642         return;
643     }
644
645     const mtime_t i_decoder_buffering_start = mdate();
646     for( int i = 0; i < p_sys->i_es; i++ )
647     {
648         es_out_id_t *p_es = p_sys->es[i];
649
650         if( !p_es->p_dec )
651             continue;
652         input_DecoderWaitBuffering( p_es->p_dec );
653         if( p_es->p_dec_record )
654             input_DecoderWaitBuffering( p_es->p_dec_record );
655     }
656
657     msg_Dbg( p_sys->p_input, "Decoder buffering done in %d ms",
658               (int)(mdate() - i_decoder_buffering_start)/1000 );
659
660     const mtime_t i_wakeup_delay = 10*1000; /* FIXME CLEANUP thread wake up time*/
661     const mtime_t i_current_date = p_sys->b_paused ? p_sys->i_pause_date : mdate();
662
663     input_clock_ChangeSystemOrigin( p_sys->p_pgrm->p_clock, i_current_date + i_wakeup_delay - i_buffering_duration );
664
665     for( int i = 0; i < p_sys->i_es; i++ )
666     {
667         es_out_id_t *p_es = p_sys->es[i];
668
669         if( !p_es->p_dec )
670             continue;
671
672         input_DecoderStopBuffering( p_es->p_dec );
673         if( p_es->p_dec_record )
674             input_DecoderStopBuffering( p_es->p_dec );
675     }
676 }
677 static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
678 {
679     es_out_sys_t *p_sys = out->p_sys;
680
681     /* Pause decoders first */
682     for( int i = 0; i < p_sys->i_es; i++ )
683     {
684         es_out_id_t *es = p_sys->es[i];
685
686         if( es->p_dec )
687         {
688             input_DecoderChangePause( es->p_dec, b_paused, i_date );
689             if( es->p_dec_record )
690                 input_DecoderChangePause( es->p_dec_record, b_paused, i_date );
691         }
692     }
693 }
694 static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date )
695 {
696     es_out_sys_t *p_sys = out->p_sys;
697
698     for( int i = 0; i < p_sys->i_pgrm; i++ )
699         input_clock_ChangePause( p_sys->pgrm[i]->p_clock, b_paused, i_date );
700 }
701
702 static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es )
703 {
704     es_out_sys_t *p_sys = out->p_sys;
705
706     mtime_t i_delay = 0;
707     if( p_es->fmt.i_cat == AUDIO_ES )
708         i_delay = p_sys->i_audio_delay;
709     else if( p_es->fmt.i_cat == SPU_ES )
710         i_delay = p_sys->i_spu_delay;
711
712     if( i_delay != 0 )
713     {
714         if( p_es->p_dec )
715             input_DecoderChangeDelay( p_es->p_dec, i_delay );
716         if( p_es->p_dec_record )
717             input_DecoderChangeDelay( p_es->p_dec_record, i_delay );
718     }
719 }
720 static void EsOutProgramsChangeRate( es_out_t *out )
721 {
722     es_out_sys_t      *p_sys = out->p_sys;
723
724     for( int i = 0; i < p_sys->i_pgrm; i++ )
725         input_clock_ChangeRate( p_sys->pgrm[i]->p_clock, p_sys->i_rate );
726 }
727
728 static void EsOutFrameNext( es_out_t *out )
729 {
730     es_out_sys_t *p_sys = out->p_sys;
731     es_out_id_t *p_es_video = NULL;
732
733     if( p_sys->b_buffering )
734     {
735         msg_Warn( p_sys->p_input, "buffering, ignoring 'frame next'" );
736         return;
737     }
738
739     assert( p_sys->b_paused );
740
741     for( int i = 0; i < p_sys->i_es; i++ )
742     {
743         es_out_id_t *p_es = p_sys->es[i];
744
745         if( p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec )
746         {
747             p_es_video = p_es;
748             break;
749         }
750     }
751
752     if( !p_es_video )
753     {
754         msg_Warn( p_sys->p_input, "No video track selected, ignoring 'frame next'" );
755         return;
756     }
757
758     mtime_t i_duration;
759     input_DecoderFrameNext( p_es_video->p_dec, &i_duration );
760
761     msg_Dbg( out->p_sys->p_input, "EsOutFrameNext consummed %d ms", (int)(i_duration/1000) );
762
763     if( i_duration <= 0 )
764         i_duration = 40*1000;
765
766     /* FIXME it is not a clean way ? */
767     if( p_sys->i_buffering_extra_initial <= 0 )
768     {
769         mtime_t i_stream_start;
770         mtime_t i_system_start;
771         mtime_t i_stream_duration;
772         mtime_t i_system_duration;
773         int i_ret;
774
775         i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock,
776                                       &i_stream_start, &i_system_start,
777                                       &i_stream_duration, &i_system_duration );
778         if( i_ret )
779             return;
780
781         p_sys->i_buffering_extra_initial = 1 + i_stream_duration - p_sys->p_input->i_pts_delay; /* FIXME < 0 ? */
782         p_sys->i_buffering_extra_system =
783         p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial;
784     }
785
786     const int i_rate = input_clock_GetRate( p_sys->p_pgrm->p_clock );
787
788     p_sys->b_buffering = true;
789     p_sys->i_buffering_extra_system += i_duration;
790     p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial +
791                                       ( p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial ) *
792                                                 INPUT_RATE_DEFAULT / i_rate;
793
794     p_sys->i_preroll_end = -1;
795 }
796
797
798
799 static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id, es_format_t *fmt, const char *psz_language,
800                                      bool b_delete )
801 {
802     es_out_sys_t      *p_sys = out->p_sys;
803     input_thread_t    *p_input = p_sys->p_input;
804     const  bool b_teletext = fmt->i_cat == SPU_ES && fmt->i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' );
805     vlc_value_t       val, text;
806
807     if( b_delete )
808     {
809         /* TODO it should probably be a list */
810         if( b_teletext )
811             input_SendEventTeletext( p_sys->p_input, -1 );
812
813         input_SendEventEsDel( p_input, SPU_ES, i_id );
814         return;
815     }
816
817     /* Get the number of ES already added */
818     const char *psz_var;
819     if( fmt->i_cat == AUDIO_ES )
820         psz_var = "audio-es";
821     else if( fmt->i_cat == VIDEO_ES )
822         psz_var = "video-es";
823     else
824         psz_var = "spu-es";
825
826     var_Change( p_input, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
827     if( val.i_int == 0 )
828     {
829         vlc_value_t val2;
830
831         /* First one, we need to add the "Disable" choice */
832         val2.i_int = -1; text.psz_string = _("Disable");
833         var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val2, &text );
834         val.i_int++;
835     }
836
837     /* Take care of the ES description */
838     if( fmt->psz_description && *fmt->psz_description )
839     {
840         if( psz_language && *psz_language )
841         {
842             text.psz_string = malloc( strlen( fmt->psz_description) +
843                                       strlen( psz_language ) + 10 );
844             sprintf( text.psz_string, "%s - [%s]", fmt->psz_description,
845                                                    psz_language );
846         }
847         else text.psz_string = strdup( fmt->psz_description );
848     }
849     else
850     {
851         if( psz_language && *psz_language )
852         {
853             if( asprintf( &text.psz_string, "%s %i - [%s]", _( "Track" ), val.i_int, psz_language ) == -1 )
854                 text.psz_string = NULL;
855         }
856         else
857         {
858             if( asprintf( &text.psz_string, "%s %i", _( "Track" ), val.i_int ) == -1 )
859                 text.psz_string = NULL;
860         }
861     }
862
863     input_SendEventEsAdd( p_input, fmt->i_cat, i_id, text.psz_string );
864
865     free( text.psz_string );
866
867     if( b_teletext )
868     {
869         /* TODO it should probably be a list */
870         if( var_GetInteger( p_sys->p_input, "teletext-es" ) < 0 )
871             input_SendEventTeletext( p_sys->p_input, i_id );
872     }
873 }
874
875 static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es,
876                               bool b_delete )
877 {
878     EsOutESVarUpdateGeneric( out, es->i_id, &es->fmt, es->psz_language, b_delete );
879 }
880
881 /* EsOutProgramSelect:
882  *  Select a program and update the object variable
883  */
884 static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm )
885 {
886     es_out_sys_t      *p_sys = out->p_sys;
887     input_thread_t    *p_input = p_sys->p_input;
888     int               i;
889
890     if( p_sys->p_pgrm == p_pgrm )
891         return; /* Nothing to do */
892
893     if( p_sys->p_pgrm )
894     {
895         es_out_pgrm_t *old = p_sys->p_pgrm;
896         msg_Dbg( p_input, "unselecting program id=%d", old->i_id );
897
898         for( i = 0; i < p_sys->i_es; i++ )
899         {
900             if( p_sys->es[i]->p_pgrm == old && EsIsSelected( p_sys->es[i] ) &&
901                 p_sys->i_mode != ES_OUT_MODE_ALL )
902                 EsUnselect( out, p_sys->es[i], true );
903         }
904
905         p_sys->p_es_audio = NULL;
906         p_sys->p_es_sub = NULL;
907         p_sys->p_es_video = NULL;
908     }
909
910     msg_Dbg( p_input, "selecting program id=%d", p_pgrm->i_id );
911
912     /* Mark it selected */
913     p_pgrm->b_selected = true;
914
915     /* Switch master stream */
916     p_sys->p_pgrm = p_pgrm;
917
918     /* Update "program" */
919     input_SendEventProgramSelect( p_input, p_pgrm->i_id );
920
921     /* Update "es-*" */
922     input_SendEventEsDel( p_input, AUDIO_ES, -1 );
923     input_SendEventEsDel( p_input, VIDEO_ES, -1 );
924     input_SendEventEsDel( p_input, SPU_ES, -1 );
925
926     /* TODO event */
927     var_SetInteger( p_input, "teletext-es", -1 );
928
929     for( i = 0; i < p_sys->i_es; i++ )
930     {
931         if( p_sys->es[i]->p_pgrm == p_sys->p_pgrm )
932             EsOutESVarUpdate( out, p_sys->es[i], false );
933         EsOutSelect( out, p_sys->es[i], false );
934     }
935
936     /* Update now playing */
937     input_item_SetNowPlaying( p_input->p->input.p_item,
938                               p_pgrm->psz_now_playing );
939     input_item_SetPublisher( p_input->p->input.p_item,
940                              p_pgrm->psz_publisher );
941
942     input_SendEventMeta( p_input );
943 }
944
945 /* EsOutAddProgram:
946  *  Add a program
947  */
948 static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group )
949 {
950     es_out_sys_t      *p_sys = out->p_sys;
951     input_thread_t    *p_input = p_sys->p_input;
952
953     es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) );
954     if( !p_pgrm )
955         return NULL;
956
957     /* Init */
958     p_pgrm->i_id = i_group;
959     p_pgrm->i_es = 0;
960     p_pgrm->b_selected = false;
961     p_pgrm->psz_name = NULL;
962     p_pgrm->psz_now_playing = NULL;
963     p_pgrm->psz_publisher = NULL;
964     p_pgrm->p_epg = NULL;
965     p_pgrm->p_clock = input_clock_New( p_input->p->input.i_cr_average, p_sys->i_rate );
966     if( !p_pgrm->p_clock )
967     {
968         free( p_pgrm );
969         return NULL;
970     }
971
972     /* Append it */
973     TAB_APPEND( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
974
975     /* Update "program" variable */
976     input_SendEventProgramAdd( p_input, i_group, NULL );
977
978     if( i_group == var_GetInteger( p_input, "program" ) )
979         EsOutProgramSelect( out, p_pgrm );
980
981     return p_pgrm;
982 }
983
984 /* EsOutDelProgram:
985  *  Delete a program
986  */
987 static int EsOutProgramDel( es_out_t *out, int i_group )
988 {
989     es_out_sys_t      *p_sys = out->p_sys;
990     input_thread_t    *p_input = p_sys->p_input;
991     es_out_pgrm_t     *p_pgrm = NULL;
992     int               i;
993
994     for( i = 0; i < p_sys->i_pgrm; i++ )
995     {
996         if( p_sys->pgrm[i]->i_id == i_group )
997         {
998             p_pgrm = p_sys->pgrm[i];
999             break;
1000         }
1001     }
1002
1003     if( p_pgrm == NULL )
1004         return VLC_EGENERIC;
1005
1006     if( p_pgrm->i_es )
1007     {
1008         msg_Dbg( p_input, "can't delete program %d which still has %i ES",
1009                  i_group, p_pgrm->i_es );
1010         return VLC_EGENERIC;
1011     }
1012
1013     TAB_REMOVE( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
1014
1015     /* If program is selected we need to unselect it */
1016     if( p_sys->p_pgrm == p_pgrm )
1017         p_sys->p_pgrm = NULL;
1018
1019     input_clock_Delete( p_pgrm->p_clock );
1020
1021     free( p_pgrm->psz_name );
1022     free( p_pgrm->psz_now_playing );
1023     free( p_pgrm->psz_publisher );
1024     if( p_pgrm->p_epg )
1025         vlc_epg_Delete( p_pgrm->p_epg );
1026     free( p_pgrm );
1027
1028     /* Update "program" variable */
1029     input_SendEventProgramDel( p_input, i_group );
1030
1031     return VLC_SUCCESS;
1032 }
1033
1034 /* EsOutProgramMeta:
1035  */
1036 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm )
1037 {
1038     char *psz = NULL;
1039     if( p_pgrm->psz_name )
1040     {
1041         if( asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id ) == -1 )
1042             return NULL;
1043     }
1044     else
1045     {
1046         if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 )
1047             return NULL;
1048     }
1049     return psz;
1050 }
1051
1052 static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta )
1053 {
1054     es_out_sys_t      *p_sys = out->p_sys;
1055     es_out_pgrm_t     *p_pgrm = NULL;
1056     input_thread_t    *p_input = p_sys->p_input;
1057     char              *psz_cat;
1058     const char        *psz_title = NULL;
1059     const char        *psz_provider = NULL;
1060     int i;
1061
1062     msg_Dbg( p_input, "EsOutProgramMeta: number=%d", i_group );
1063
1064     /* Check against empty meta data (empty for what we handle) */
1065     if( !vlc_meta_Get( p_meta, vlc_meta_Title) &&
1066         !vlc_meta_Get( p_meta, vlc_meta_NowPlaying) &&
1067         !vlc_meta_Get( p_meta, vlc_meta_Publisher) &&
1068         vlc_dictionary_keys_count( &p_meta->extra_tags ) <= 0 )
1069     {
1070         return;
1071     }
1072     /* Find program */
1073     for( i = 0; i < p_sys->i_pgrm; i++ )
1074     {
1075         if( p_sys->pgrm[i]->i_id == i_group )
1076         {
1077             p_pgrm = p_sys->pgrm[i];
1078             break;
1079         }
1080     }
1081     if( p_pgrm == NULL )
1082         p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
1083
1084     /* */
1085     psz_title = vlc_meta_Get( p_meta, vlc_meta_Title);
1086     psz_provider = vlc_meta_Get( p_meta, vlc_meta_Publisher);
1087
1088     /* Update the description text of the program */
1089     if( psz_title && *psz_title )
1090     {
1091         if( !p_pgrm->psz_name || strcmp( p_pgrm->psz_name, psz_title ) )
1092         {
1093             char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
1094
1095             /* Remove old entries */
1096             input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
1097             /* TODO update epg name */
1098             free( psz_cat );
1099         }
1100         free( p_pgrm->psz_name );
1101         p_pgrm->psz_name = strdup( psz_title );
1102
1103         char *psz_text;
1104         if( psz_provider && *psz_provider )
1105         {
1106             if( asprintf( &psz_text, "%s [%s]", psz_title, psz_provider ) < 0 )
1107                 psz_text = NULL;
1108         }
1109         else
1110         {
1111             psz_text = strdup( psz_title );
1112         }
1113
1114         /* ugly but it works */
1115         if( psz_text )
1116         {
1117             input_SendEventProgramDel( p_input, i_group );
1118             input_SendEventProgramAdd( p_input, i_group, psz_text );
1119
1120             free( psz_text );
1121         }
1122     }
1123
1124     psz_cat = EsOutProgramGetMetaName( p_pgrm );
1125     if( psz_provider )
1126     {
1127         if( p_sys->p_pgrm == p_pgrm )
1128         {
1129             input_item_SetPublisher( p_input->p->input.p_item, psz_provider );
1130             input_SendEventMeta( p_input );
1131         }
1132         input_Control( p_input, INPUT_ADD_INFO, psz_cat, input_MetaTypeToLocalizedString(vlc_meta_Publisher), psz_provider );
1133     }
1134     char ** ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags );
1135     for( i = 0; ppsz_all_keys[i]; i++ )
1136     {
1137         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _(ppsz_all_keys[i]),
1138                        vlc_dictionary_value_for_key( &p_meta->extra_tags, ppsz_all_keys[i] ) );
1139         free( ppsz_all_keys[i] );
1140     }
1141     free( ppsz_all_keys );
1142
1143     free( psz_cat );
1144 }
1145
1146 static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src )
1147 {
1148     int i;
1149
1150     /* Add new event */
1151     for( i = 0; i < p_src->i_event; i++ )
1152     {
1153         vlc_epg_event_t *p_evt = p_src->pp_event[i];
1154         bool b_add = true;
1155         int j;
1156
1157         for( j = 0; j < p_dst->i_event; j++ )
1158         {
1159             if( p_dst->pp_event[j]->i_start == p_evt->i_start && p_dst->pp_event[j]->i_duration == p_evt->i_duration )
1160             {
1161                 b_add = false;
1162                 break;
1163             }
1164             if( p_dst->pp_event[j]->i_start > p_evt->i_start )
1165                 break;
1166         }
1167         if( b_add )
1168         {
1169             vlc_epg_event_t *p_copy = malloc( sizeof(vlc_epg_event_t) );
1170             if( !p_copy )
1171                 break;
1172             memset( p_copy, 0, sizeof(vlc_epg_event_t) );
1173             p_copy->i_start = p_evt->i_start;
1174             p_copy->i_duration = p_evt->i_duration;
1175             p_copy->psz_name = p_evt->psz_name ? strdup( p_evt->psz_name ) : NULL;
1176             p_copy->psz_short_description = p_evt->psz_short_description ? strdup( p_evt->psz_short_description ) : NULL;
1177             p_copy->psz_description = p_evt->psz_description ? strdup( p_evt->psz_description ) : NULL;
1178             TAB_INSERT( p_dst->i_event, p_dst->pp_event, p_copy, j );
1179         }
1180     }
1181     /* Update current */
1182     vlc_epg_SetCurrent( p_dst, p_src->p_current ? p_src->p_current->i_start : -1 );
1183
1184     /* Keep only 1 old event  */
1185     if( p_dst->p_current )
1186     {
1187         while( p_dst->i_event > 1 && p_dst->pp_event[0] != p_dst->p_current && p_dst->pp_event[1] != p_dst->p_current )
1188             TAB_REMOVE( p_dst->i_event, p_dst->pp_event, p_dst->pp_event[0] );
1189     }
1190 }
1191
1192 static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg )
1193 {
1194     es_out_sys_t      *p_sys = out->p_sys;
1195     input_thread_t    *p_input = p_sys->p_input;
1196     es_out_pgrm_t     *p_pgrm = NULL;
1197     char *psz_cat;
1198     int i;
1199
1200     /* Find program */
1201     for( i = 0; i < p_sys->i_pgrm; i++ )
1202     {
1203         if( p_sys->pgrm[i]->i_id == i_group )
1204         {
1205             p_pgrm = p_sys->pgrm[i];
1206             break;
1207         }
1208     }
1209     if( p_pgrm == NULL )
1210         p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
1211
1212     /* Merge EPG */
1213     if( !p_pgrm->p_epg )
1214         p_pgrm->p_epg = vlc_epg_New( p_pgrm->psz_name );
1215     vlc_epg_Merge( p_pgrm->p_epg, p_epg );
1216
1217     /* Update info */
1218     psz_cat = EsOutProgramGetMetaName( p_pgrm );
1219 #ifdef HAVE_LOCALTIME_R
1220     char *psz_epg;
1221     if( asprintf( &psz_epg, "EPG %s", psz_cat ) == -1 )
1222         psz_epg = NULL;
1223     input_Control( p_input, INPUT_DEL_INFO, psz_epg, NULL );
1224     msg_Dbg( p_input, "EsOutProgramEpg: number=%d name=%s", i_group, p_pgrm->p_epg->psz_name );
1225     for( i = 0; i < p_pgrm->p_epg->i_event; i++ )
1226     {
1227         const vlc_epg_event_t *p_evt = p_pgrm->p_epg->pp_event[i];
1228         time_t t_start = (time_t)p_evt->i_start;
1229         struct tm tm_start;
1230         char psz_start[128];
1231
1232         localtime_r( &t_start, &tm_start );
1233
1234         snprintf( psz_start, sizeof(psz_start), "%2.2d:%2.2d:%2.2d", tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
1235         if( p_evt->psz_short_description || p_evt->psz_description )
1236             input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s",
1237                            p_evt->psz_name,
1238                            p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
1239                            p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description );
1240         else
1241             input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
1242                            p_evt->psz_name,
1243                            p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
1244     }
1245     free( psz_epg );
1246 #endif
1247     /* Update now playing */
1248     free( p_pgrm->psz_now_playing );
1249     p_pgrm->psz_now_playing = NULL;
1250     if( p_epg->p_current && p_epg->p_current->psz_name && *p_epg->p_current->psz_name )
1251         p_pgrm->psz_now_playing = strdup( p_epg->p_current->psz_name );
1252
1253     if( p_pgrm == p_sys->p_pgrm )
1254     {
1255         input_item_SetNowPlaying( p_input->p->input.p_item, p_pgrm->psz_now_playing );
1256         input_SendEventMeta( p_input );
1257     }
1258
1259     if( p_pgrm->psz_now_playing )
1260     {
1261         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1262             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying),
1263             p_pgrm->psz_now_playing );
1264     }
1265     else
1266     {
1267         input_Control( p_input, INPUT_DEL_INFO, psz_cat,
1268             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying) );
1269     }
1270
1271     free( psz_cat );
1272 }
1273
1274 /* EsOutAdd:
1275  *  Add an es_out
1276  */
1277 static es_out_id_t *EsOutAdd( es_out_t *out, const es_format_t *fmt )
1278 {
1279     es_out_sys_t      *p_sys = out->p_sys;
1280     input_thread_t    *p_input = p_sys->p_input;
1281
1282     if( fmt->i_group < 0 )
1283     {
1284         msg_Err( p_input, "invalid group number" );
1285         return NULL;
1286     }
1287
1288     es_out_id_t       *es = malloc( sizeof( *es ) );
1289     es_out_pgrm_t     *p_pgrm = NULL;
1290     int i;
1291
1292     if( !es )
1293         return NULL;
1294
1295     vlc_mutex_lock( &p_sys->lock );
1296
1297     /* Search the program */
1298     for( i = 0; i < p_sys->i_pgrm; i++ )
1299     {
1300         if( fmt->i_group == p_sys->pgrm[i]->i_id )
1301         {
1302             p_pgrm = p_sys->pgrm[i];
1303             break;
1304         }
1305     }
1306     if( p_pgrm == NULL )
1307     {
1308         /* Create a new one */
1309         p_pgrm = EsOutProgramAdd( out, fmt->i_group );
1310     }
1311
1312     /* Increase ref count for program */
1313     p_pgrm->i_es++;
1314
1315     /* Set up ES */
1316     es->p_pgrm = p_pgrm;
1317     es_format_Copy( &es->fmt, fmt );
1318     if( es->fmt.i_id < 0 )
1319         es->fmt.i_id = out->p_sys->i_id;
1320     es->i_id = es->fmt.i_id;
1321     es->i_meta_id = out->p_sys->i_id;
1322
1323     switch( es->fmt.i_cat )
1324     {
1325     case AUDIO_ES:
1326     {
1327         audio_replay_gain_t rg;
1328
1329         es->i_channel = p_sys->i_audio;
1330
1331         memset( &rg, 0, sizeof(rg) );
1332         vlc_mutex_lock( &p_input->p->input.p_item->lock );
1333         vlc_audio_replay_gain_MergeFromMeta( &rg, p_input->p->input.p_item->p_meta );
1334         vlc_mutex_unlock( &p_input->p->input.p_item->lock );
1335
1336         for( i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
1337         {
1338             if( !es->fmt.audio_replay_gain.pb_peak[i] )
1339             {
1340                 es->fmt.audio_replay_gain.pb_peak[i] = rg.pb_peak[i];
1341                 es->fmt.audio_replay_gain.pf_peak[i] = rg.pf_peak[i];
1342             }
1343             if( !es->fmt.audio_replay_gain.pb_gain[i] )
1344             {
1345                 es->fmt.audio_replay_gain.pb_gain[i] = rg.pb_gain[i];
1346                 es->fmt.audio_replay_gain.pf_gain[i] = rg.pf_gain[i];
1347             }
1348         }
1349         break;
1350     }
1351
1352     case VIDEO_ES:
1353         es->i_channel = p_sys->i_video;
1354         if( es->fmt.video.i_frame_rate && es->fmt.video.i_frame_rate_base )
1355             vlc_ureduce( &es->fmt.video.i_frame_rate,
1356                          &es->fmt.video.i_frame_rate_base,
1357                          es->fmt.video.i_frame_rate,
1358                          es->fmt.video.i_frame_rate_base, 0 );
1359         break;
1360
1361     case SPU_ES:
1362         es->i_channel = p_sys->i_sub;
1363         break;
1364
1365     default:
1366         es->i_channel = 0;
1367         break;
1368     }
1369     es->psz_language = LanguageGetName( es->fmt.psz_language ); /* remember so we only need to do it once */
1370     es->psz_language_code = LanguageGetCode( es->fmt.psz_language );
1371     es->p_dec = NULL;
1372     es->p_dec_record = NULL;
1373     for( i = 0; i < 4; i++ )
1374         es->pb_cc_present[i] = false;
1375     es->p_master = NULL;
1376
1377     if( es->p_pgrm == p_sys->p_pgrm )
1378         EsOutESVarUpdate( out, es, false );
1379
1380     /* Select it if needed */
1381     EsOutSelect( out, es, false );
1382
1383
1384     TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es );
1385     p_sys->i_id++;  /* always incremented */
1386     switch( es->fmt.i_cat )
1387     {
1388         case AUDIO_ES:
1389             p_sys->i_audio++;
1390             break;
1391         case SPU_ES:
1392             p_sys->i_sub++;
1393             break;
1394         case VIDEO_ES:
1395             p_sys->i_video++;
1396             break;
1397     }
1398
1399     EsOutUpdateInfo( out, es, &es->fmt );
1400
1401     vlc_mutex_unlock( &p_sys->lock );
1402
1403     return es;
1404 }
1405
1406 static bool EsIsSelected( es_out_id_t *es )
1407 {
1408     if( es->p_master )
1409     {
1410         bool b_decode = false;
1411         if( es->p_master->p_dec )
1412         {
1413             int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
1414             if( i_channel != -1 )
1415                 input_DecoderGetCcState( es->p_master->p_dec, &b_decode, i_channel );
1416         }
1417         return b_decode;
1418     }
1419     else
1420     {
1421         return es->p_dec != NULL;
1422     }
1423 }
1424 static void EsCreateDecoder( es_out_t *out, es_out_id_t *p_es )
1425 {
1426     es_out_sys_t   *p_sys = out->p_sys;
1427     input_thread_t *p_input = p_sys->p_input;
1428
1429     p_es->p_dec = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_input->p->p_sout );
1430     if( p_es->p_dec )
1431     {
1432         if( p_sys->b_buffering )
1433             input_DecoderStartBuffering( p_es->p_dec );
1434
1435         if( !p_es->p_master && p_sys->p_sout_record )
1436         {
1437             p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record );
1438             if( p_es->p_dec_record && p_sys->b_buffering )
1439                 input_DecoderStartBuffering( p_es->p_dec_record );
1440         }
1441     }
1442
1443     EsOutDecoderChangeDelay( out, p_es );
1444 }
1445 static void EsDestroyDecoder( es_out_t *out, es_out_id_t *p_es )
1446 {
1447     VLC_UNUSED(out);
1448
1449     if( !p_es->p_dec )
1450         return;
1451
1452     input_DecoderDelete( p_es->p_dec );
1453     p_es->p_dec = NULL;
1454
1455     if( p_es->p_dec_record )
1456     {
1457         input_DecoderDelete( p_es->p_dec_record );
1458         p_es->p_dec_record = NULL;
1459     }
1460 }
1461
1462 static void EsSelect( es_out_t *out, es_out_id_t *es )
1463 {
1464     es_out_sys_t   *p_sys = out->p_sys;
1465     input_thread_t *p_input = p_sys->p_input;
1466     vlc_value_t    val;
1467
1468     if( EsIsSelected( es ) )
1469     {
1470         msg_Warn( p_input, "ES 0x%x is already selected", es->i_id );
1471         return;
1472     }
1473
1474     if( es->p_master )
1475     {
1476         int i_channel;
1477         if( !es->p_master->p_dec )
1478             return;
1479
1480         i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
1481         if( i_channel == -1 || input_DecoderSetCcState( es->p_master->p_dec, true, i_channel ) )
1482             return;
1483     }
1484     else
1485     {
1486         if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES )
1487         {
1488             if( !var_GetBool( p_input, out->b_sout ? "sout-video" : "video" ) )
1489             {
1490                 msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x",
1491                          es->i_id );
1492                 return;
1493             }
1494         }
1495         else if( es->fmt.i_cat == AUDIO_ES )
1496         {
1497             var_Get( p_input, "audio", &val );
1498             if( !var_GetBool( p_input, out->b_sout ? "sout-audio" : "audio" ) )
1499             {
1500                 msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x",
1501                          es->i_id );
1502                 return;
1503             }
1504         }
1505         if( es->fmt.i_cat == SPU_ES )
1506         {
1507             var_Get( p_input, "spu", &val );
1508             if( !var_GetBool( p_input, out->b_sout ? "sout-spu" : "spu" ) )
1509             {
1510                 msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x",
1511                          es->i_id );
1512                 return;
1513             }
1514         }
1515
1516         EsCreateDecoder( out, es );
1517
1518         if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm )
1519             return;
1520     }
1521
1522     /* Mark it as selected */
1523     input_SendEventEsSelect( p_input, es->fmt.i_cat, es->i_id );
1524 }
1525
1526 static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update )
1527 {
1528     es_out_sys_t   *p_sys = out->p_sys;
1529     input_thread_t *p_input = p_sys->p_input;
1530
1531     if( !EsIsSelected( es ) )
1532     {
1533         msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id );
1534         return;
1535     }
1536
1537     if( es->p_master )
1538     {
1539         if( es->p_master->p_dec )
1540         {
1541             int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec );
1542             if( i_channel != -1 )
1543                 input_DecoderSetCcState( es->p_master->p_dec, false, i_channel );
1544         }
1545     }
1546     else
1547     {
1548         const int i_spu_id = var_GetInteger( p_input, "spu-es");
1549         int i;
1550         for( i = 0; i < 4; i++ )
1551         {
1552             if( !es->pb_cc_present[i] || !es->pp_cc_es[i] )
1553                 continue;
1554
1555             if( i_spu_id == es->pp_cc_es[i]->i_id )
1556             {
1557                 /* Force unselection of the CC */
1558                 input_SendEventEsSelect( p_input, SPU_ES, -1 );
1559             }
1560             EsOutDel( out, es->pp_cc_es[i] );
1561
1562             es->pb_cc_present[i] = false;
1563         }
1564         EsDestroyDecoder( out, es );
1565     }
1566
1567     if( !b_update )
1568         return;
1569
1570     /* Update var */
1571     if( es->p_dec == NULL )
1572         return;
1573
1574     /* Mark it as unselected */
1575     input_SendEventEsSelect( p_input, es->fmt.i_cat, -1 );
1576 }
1577
1578 /**
1579  * Select an ES given the current mode
1580  * XXX: you need to take a the lock before (stream.stream_lock)
1581  *
1582  * \param out The es_out structure
1583  * \param es es_out_id structure
1584  * \param b_force ...
1585  * \return nothing
1586  */
1587 static void EsOutSelect( es_out_t *out, es_out_id_t *es, bool b_force )
1588 {
1589     es_out_sys_t      *p_sys = out->p_sys;
1590
1591     int i_cat = es->fmt.i_cat;
1592
1593     if( !p_sys->b_active ||
1594         ( !b_force && es->fmt.i_priority < 0 ) )
1595     {
1596         return;
1597     }
1598
1599     if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force )
1600     {
1601         if( !EsIsSelected( es ) )
1602             EsSelect( out, es );
1603     }
1604     else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL )
1605     {
1606         vlc_value_t val;
1607         int i;
1608         var_Get( p_sys->p_input, "programs", &val );
1609         for ( i = 0; i < val.p_list->i_count; i++ )
1610         {
1611             if ( val.p_list->p_values[i].i_int == es->p_pgrm->i_id || b_force )
1612             {
1613                 if( !EsIsSelected( es ) )
1614                     EsSelect( out, es );
1615                 break;
1616             }
1617         }
1618         var_Change( p_sys->p_input, "programs", VLC_VAR_FREELIST, &val, NULL );
1619     }
1620     else if( p_sys->i_mode == ES_OUT_MODE_AUTO )
1621     {
1622         int i_wanted  = -1;
1623
1624         if( es->p_pgrm != p_sys->p_pgrm )
1625             return;
1626
1627         if( i_cat == AUDIO_ES )
1628         {
1629             int idx1 = LanguageArrayIndex( p_sys->ppsz_audio_language,
1630                                      es->psz_language_code );
1631
1632             if( p_sys->p_es_audio &&
1633                 p_sys->p_es_audio->fmt.i_priority >= es->fmt.i_priority )
1634             {
1635                 int idx2 = LanguageArrayIndex( p_sys->ppsz_audio_language,
1636                                          p_sys->p_es_audio->psz_language_code );
1637
1638                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
1639                     return;
1640                 i_wanted = es->i_channel;
1641             }
1642             else
1643             {
1644                 /* Select audio if (no audio selected yet)
1645                  * - no audio-language
1646                  * - no audio code for the ES
1647                  * - audio code in the requested list */
1648                 if( idx1 >= 0 ||
1649                     !strcmp( es->psz_language_code, "??" ) ||
1650                     !p_sys->ppsz_audio_language )
1651                     i_wanted = es->i_channel;
1652             }
1653
1654             if( p_sys->i_audio_last >= 0 )
1655                 i_wanted = p_sys->i_audio_last;
1656
1657             if( p_sys->i_audio_id >= 0 )
1658             {
1659                 if( es->i_id == p_sys->i_audio_id )
1660                     i_wanted = es->i_channel;
1661                 else
1662                     return;
1663             }
1664         }
1665         else if( i_cat == SPU_ES )
1666         {
1667             int idx1 = LanguageArrayIndex( p_sys->ppsz_sub_language,
1668                                      es->psz_language_code );
1669
1670             if( p_sys->p_es_sub &&
1671                 p_sys->p_es_sub->fmt.i_priority >= es->fmt.i_priority )
1672             {
1673                 int idx2 = LanguageArrayIndex( p_sys->ppsz_sub_language,
1674                                          p_sys->p_es_sub->psz_language_code );
1675
1676                 msg_Dbg( p_sys->p_input, "idx1=%d(%s) idx2=%d(%s)",
1677                         idx1, es->psz_language_code, idx2,
1678                         p_sys->p_es_sub->psz_language_code );
1679
1680                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
1681                     return;
1682                 /* We found a SPU that matches our language request */
1683                 i_wanted  = es->i_channel;
1684             }
1685             else if( idx1 >= 0 )
1686             {
1687                 msg_Dbg( p_sys->p_input, "idx1=%d(%s)",
1688                         idx1, es->psz_language_code );
1689
1690                 i_wanted  = es->i_channel;
1691             }
1692             else if( p_sys->i_default_sub_id >= 0 )
1693             {
1694                 if( es->i_id == p_sys->i_default_sub_id )
1695                     i_wanted = es->i_channel;
1696             }
1697
1698             if( p_sys->i_sub_last >= 0 )
1699                 i_wanted  = p_sys->i_sub_last;
1700
1701             if( p_sys->i_sub_id >= 0 )
1702             {
1703                 if( es->i_id == p_sys->i_sub_id )
1704                     i_wanted = es->i_channel;
1705                 else
1706                     return;
1707             }
1708         }
1709         else if( i_cat == VIDEO_ES )
1710         {
1711             i_wanted  = es->i_channel;
1712         }
1713
1714         if( i_wanted == es->i_channel && !EsIsSelected( es ) )
1715             EsSelect( out, es );
1716     }
1717
1718     /* FIXME TODO handle priority here */
1719     if( EsIsSelected( es ) )
1720     {
1721         if( i_cat == AUDIO_ES )
1722         {
1723             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
1724                 p_sys->p_es_audio &&
1725                 p_sys->p_es_audio != es &&
1726                 EsIsSelected( p_sys->p_es_audio ) )
1727             {
1728                 EsUnselect( out, p_sys->p_es_audio, false );
1729             }
1730             p_sys->p_es_audio = es;
1731         }
1732         else if( i_cat == SPU_ES )
1733         {
1734             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
1735                 p_sys->p_es_sub &&
1736                 p_sys->p_es_sub != es &&
1737                 EsIsSelected( p_sys->p_es_sub ) )
1738             {
1739                 EsUnselect( out, p_sys->p_es_sub, false );
1740             }
1741             p_sys->p_es_sub = es;
1742         }
1743         else if( i_cat == VIDEO_ES )
1744         {
1745             p_sys->p_es_video = es;
1746         }
1747     }
1748 }
1749
1750 /**
1751  * Send a block for the given es_out
1752  *
1753  * \param out the es_out to send from
1754  * \param es the es_out_id
1755  * \param p_block the data block to send
1756  */
1757 static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
1758 {
1759     es_out_sys_t   *p_sys = out->p_sys;
1760     input_thread_t *p_input = p_sys->p_input;
1761     int i_total = 0;
1762
1763     if( libvlc_stats( p_input ) )
1764     {
1765         vlc_mutex_lock( &p_input->p->counters.counters_lock );
1766         stats_UpdateInteger( p_input, p_input->p->counters.p_demux_read,
1767                              p_block->i_buffer, &i_total );
1768         stats_UpdateFloat( p_input , p_input->p->counters.p_demux_bitrate,
1769                            (float)i_total, NULL );
1770         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1771     }
1772
1773     vlc_mutex_lock( &p_sys->lock );
1774
1775     /* Mark preroll blocks */
1776     if( p_sys->i_preroll_end >= 0 )
1777     {
1778         int64_t i_date = p_block->i_pts;
1779         if( i_date <= 0 )
1780             i_date = p_block->i_dts;
1781
1782         if( i_date < p_sys->i_preroll_end )
1783             p_block->i_flags |= BLOCK_FLAG_PREROLL;
1784     }
1785
1786     p_block->i_rate = 0;
1787
1788     if( !es->p_dec )
1789     {
1790         block_Release( p_block );
1791         vlc_mutex_unlock( &p_sys->lock );
1792         return VLC_SUCCESS;
1793     }
1794
1795     /* Decode */
1796     if( es->p_dec_record )
1797     {
1798         block_t *p_dup = block_Duplicate( p_block );
1799         if( p_dup )
1800             input_DecoderDecode( es->p_dec_record, p_dup );
1801     }
1802     input_DecoderDecode( es->p_dec, p_block );
1803
1804     es_format_t fmt_dsc;
1805     if( input_DecoderHasFormatChanged( es->p_dec, &fmt_dsc ) )
1806     {
1807         EsOutUpdateInfo( out, es, &fmt_dsc );
1808         es_format_Clean( &fmt_dsc );
1809     }
1810
1811     /* Check CC status */
1812     bool pb_cc[4];
1813
1814     input_DecoderIsCcPresent( es->p_dec, pb_cc );
1815     for( int i = 0; i < 4; i++ )
1816     {
1817         static const vlc_fourcc_t fcc[4] = {
1818             VLC_FOURCC('c', 'c', '1', ' '),
1819             VLC_FOURCC('c', 'c', '2', ' '),
1820             VLC_FOURCC('c', 'c', '3', ' '),
1821             VLC_FOURCC('c', 'c', '4', ' '),
1822         };
1823         es_format_t fmt;
1824
1825         if(  es->pb_cc_present[i] || !pb_cc[i] )
1826             continue;
1827         msg_Dbg( p_input, "Adding CC track %d for es[%d]", 1+i, es->i_id );
1828
1829         es_format_Init( &fmt, SPU_ES, fcc[i] );
1830         fmt.i_group = es->fmt.i_group;
1831         if( asprintf( &fmt.psz_description,
1832                       _("Closed captions %u"), 1 + i ) == -1 )
1833             fmt.psz_description = NULL;
1834         es->pp_cc_es[i] = EsOutAdd( out, &fmt );
1835         es->pp_cc_es[i]->p_master = es;
1836         es_format_Clean( &fmt );
1837
1838         /* */
1839         es->pb_cc_present[i] = true;
1840     }
1841
1842     vlc_mutex_unlock( &p_sys->lock );
1843
1844     return VLC_SUCCESS;
1845 }
1846
1847 /*****************************************************************************
1848  * EsOutDel:
1849  *****************************************************************************/
1850 static void EsOutDel( es_out_t *out, es_out_id_t *es )
1851 {
1852     es_out_sys_t *p_sys = out->p_sys;
1853     bool b_reselect = false;
1854     int i;
1855
1856     vlc_mutex_lock( &p_sys->lock );
1857
1858     /* We don't try to reselect */
1859     if( es->p_dec )
1860     {
1861         while( !p_sys->p_input->b_die && !p_sys->b_buffering && es->p_dec )
1862         {
1863             if( input_DecoderIsEmpty( es->p_dec ) &&
1864                 ( !es->p_dec_record || input_DecoderIsEmpty( es->p_dec_record ) ))
1865                 break;
1866             /* FIXME there should be a way to have auto deleted es, but there will be
1867              * a problem when another codec of the same type is created (mainly video) */
1868             msleep( 20*1000 );
1869         }
1870         EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
1871     }
1872
1873     if( es->p_pgrm == p_sys->p_pgrm )
1874         EsOutESVarUpdate( out, es, true );
1875
1876     TAB_REMOVE( p_sys->i_es, p_sys->es, es );
1877
1878     es->p_pgrm->i_es--;
1879     if( es->p_pgrm->i_es == 0 )
1880     {
1881         msg_Dbg( p_sys->p_input, "Program doesn't contain anymore ES" );
1882     }
1883
1884     if( p_sys->p_es_audio == es || p_sys->p_es_video == es ||
1885         p_sys->p_es_sub == es ) b_reselect = true;
1886
1887     if( p_sys->p_es_audio == es ) p_sys->p_es_audio = NULL;
1888     if( p_sys->p_es_video == es ) p_sys->p_es_video = NULL;
1889     if( p_sys->p_es_sub   == es ) p_sys->p_es_sub   = NULL;
1890
1891     switch( es->fmt.i_cat )
1892     {
1893         case AUDIO_ES:
1894             p_sys->i_audio--;
1895             break;
1896         case SPU_ES:
1897             p_sys->i_sub--;
1898             break;
1899         case VIDEO_ES:
1900             p_sys->i_video--;
1901             break;
1902     }
1903
1904     /* Re-select another track when needed */
1905     if( b_reselect )
1906     {
1907         for( i = 0; i < p_sys->i_es; i++ )
1908         {
1909             if( es->fmt.i_cat == p_sys->es[i]->fmt.i_cat )
1910                 EsOutSelect( out, p_sys->es[i], false );
1911         }
1912     }
1913
1914     free( es->psz_language );
1915     free( es->psz_language_code );
1916
1917     es_format_Clean( &es->fmt );
1918
1919     vlc_mutex_unlock( &p_sys->lock );
1920
1921     free( es );
1922 }
1923
1924 /**
1925  * Control query handler
1926  *
1927  * \param out the es_out to control
1928  * \param i_query A es_out query as defined in include/ninput.h
1929  * \param args a variable list of arguments for the query
1930  * \return VLC_SUCCESS or an error code
1931  */
1932 static int EsOutControlLocked( es_out_t *out, int i_query, va_list args )
1933 {
1934     es_out_sys_t *p_sys = out->p_sys;
1935     bool  b, *pb;
1936     int         i;
1937
1938     es_out_id_t *es;
1939
1940     switch( i_query )
1941     {
1942         case ES_OUT_SET_ES_STATE:
1943             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1944             b = (bool) va_arg( args, int );
1945             if( b && !EsIsSelected( es ) )
1946             {
1947                 EsSelect( out, es );
1948                 return EsIsSelected( es ) ? VLC_SUCCESS : VLC_EGENERIC;
1949             }
1950             else if( !b && EsIsSelected( es ) )
1951             {
1952                 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
1953                 return VLC_SUCCESS;
1954             }
1955             return VLC_SUCCESS;
1956
1957         case ES_OUT_GET_ES_STATE:
1958             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1959             pb = (bool*) va_arg( args, bool * );
1960
1961             *pb = EsIsSelected( es );
1962             return VLC_SUCCESS;
1963
1964         case ES_OUT_SET_ACTIVE:
1965         {
1966             b = (bool) va_arg( args, int );
1967             p_sys->b_active = b;
1968             return VLC_SUCCESS;
1969         }
1970
1971         case ES_OUT_SET_MODE:
1972             i = (int) va_arg( args, int );
1973             if( i == ES_OUT_MODE_NONE || i == ES_OUT_MODE_ALL ||
1974                 i == ES_OUT_MODE_AUTO || i == ES_OUT_MODE_PARTIAL )
1975             {
1976                 p_sys->i_mode = i;
1977
1978                 /* Reapply policy mode */
1979                 for( i = 0; i < p_sys->i_es; i++ )
1980                 {
1981                     if( EsIsSelected( p_sys->es[i] ) )
1982                     {
1983                         EsUnselect( out, p_sys->es[i],
1984                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1985                     }
1986                 }
1987                 for( i = 0; i < p_sys->i_es; i++ )
1988                 {
1989                     EsOutSelect( out, p_sys->es[i], false );
1990                 }
1991                 return VLC_SUCCESS;
1992             }
1993             return VLC_EGENERIC;
1994
1995         case ES_OUT_SET_ES:
1996         case ES_OUT_RESTART_ES:
1997         {
1998             int i_cat;
1999
2000             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
2001
2002             if( es == NULL )
2003                 i_cat = UNKNOWN_ES;
2004             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
2005                 i_cat = AUDIO_ES;
2006             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
2007                 i_cat = VIDEO_ES;
2008             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
2009                 i_cat = SPU_ES;
2010             else
2011                 i_cat = -1;
2012
2013             for( i = 0; i < p_sys->i_es; i++ )
2014             {
2015                 if( i_cat == -1 )
2016                 {
2017                     if( es == p_sys->es[i] )
2018                     {
2019                         EsOutSelect( out, es, true );
2020                         break;
2021                     }
2022                 }
2023                 else
2024                 {
2025                     if( i_cat == UNKNOWN_ES || p_sys->es[i]->fmt.i_cat == i_cat )
2026                     {
2027                         if( EsIsSelected( p_sys->es[i] ) )
2028                         {
2029                             if( i_query == ES_OUT_RESTART_ES )
2030                             {
2031                                 if( p_sys->es[i]->p_dec )
2032                                 {
2033                                     EsDestroyDecoder( out, p_sys->es[i] );
2034                                     EsCreateDecoder( out, p_sys->es[i] );
2035                                 }
2036                             }
2037                             else
2038                             {
2039                                 EsUnselect( out, p_sys->es[i],
2040                                             p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
2041                             }
2042                         }
2043                     }
2044                 }
2045             }
2046             return VLC_SUCCESS;
2047         }
2048  
2049         case ES_OUT_SET_ES_DEFAULT:
2050         {
2051             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
2052
2053             if( es == NULL )
2054             {
2055                 /*p_sys->i_default_video_id = -1;*/
2056                 /*p_sys->i_default_audio_id = -1;*/
2057                 p_sys->i_default_sub_id = -1;
2058             }
2059             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
2060             {
2061                 /*p_sys->i_default_video_id = -1;*/
2062             }
2063             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
2064             {
2065                 /*p_sys->i_default_audio_id = -1;*/
2066             }
2067             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
2068             {
2069                 p_sys->i_default_sub_id = -1;
2070             }
2071             else
2072             {
2073                 /*if( es->fmt.i_cat == VIDEO_ES )
2074                     p_sys->i_default_video_id = es->i_id;
2075                 else
2076                 if( es->fmt.i_cat == AUDIO_ES )
2077                     p_sys->i_default_audio_id = es->i_id;
2078                 else*/
2079                 if( es->fmt.i_cat == SPU_ES )
2080                     p_sys->i_default_sub_id = es->i_id;
2081             }
2082             return VLC_SUCCESS;
2083         }
2084
2085         case ES_OUT_SET_PCR:
2086         case ES_OUT_SET_GROUP_PCR:
2087         {
2088             es_out_pgrm_t *p_pgrm = NULL;
2089             int            i_group = 0;
2090             int64_t        i_pcr;
2091
2092             if( i_query == ES_OUT_SET_PCR )
2093             {
2094                 p_pgrm = p_sys->p_pgrm;
2095             }
2096             else
2097             {
2098                 int i;
2099                 i_group = (int)va_arg( args, int );
2100                 for( i = 0; i < p_sys->i_pgrm; i++ )
2101                 {
2102                     if( p_sys->pgrm[i]->i_id == i_group )
2103                     {
2104                         p_pgrm = p_sys->pgrm[i];
2105                         break;
2106                     }
2107                 }
2108             }
2109             if( p_pgrm == NULL )
2110                 p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
2111
2112             i_pcr = (int64_t)va_arg( args, int64_t );
2113             /* search program
2114              * TODO do not use mdate() but proper stream acquisition date */
2115             input_clock_Update( p_pgrm->p_clock, VLC_OBJECT(p_sys->p_input),
2116                                 p_sys->p_input->b_can_pace_control || p_sys->b_buffering, i_pcr, mdate() );
2117             /* Check buffering state on master clock update */
2118             if( p_sys->b_buffering && p_pgrm == p_sys->p_pgrm )
2119                 EsOutDecodersStopBuffering( out, false );
2120
2121             return VLC_SUCCESS;
2122         }
2123
2124         case ES_OUT_RESET_PCR:
2125             msg_Err( p_sys->p_input, "ES_OUT_RESET_PCR called" );
2126             EsOutChangePosition( out );
2127             return VLC_SUCCESS;
2128
2129         case ES_OUT_GET_TS:
2130             if( p_sys->p_pgrm )
2131             {
2132                 int64_t i_ts = (int64_t)va_arg( args, int64_t );
2133                 int64_t *pi_ts = (int64_t *)va_arg( args, int64_t * );
2134                 *pi_ts = input_clock_GetTS( p_sys->p_pgrm->p_clock, NULL,
2135                                             p_sys->p_input->i_pts_delay, i_ts );
2136                 return VLC_SUCCESS;
2137             }
2138             return VLC_EGENERIC;
2139
2140         case ES_OUT_SET_GROUP:
2141         {
2142             int j;
2143             i = (int) va_arg( args, int );
2144             for( j = 0; j < p_sys->i_pgrm; j++ )
2145             {
2146                 es_out_pgrm_t *p_pgrm = p_sys->pgrm[j];
2147                 if( p_pgrm->i_id == i )
2148                 {
2149                     EsOutProgramSelect( out, p_pgrm );
2150                     return VLC_SUCCESS;
2151                 }
2152             }
2153             return VLC_EGENERIC;
2154         }
2155
2156         case ES_OUT_SET_ES_FMT:
2157         {
2158             /* This ain't pretty but is need by some demuxers (eg. Ogg )
2159              * to update the p_extra data */
2160             es_format_t *p_fmt;
2161             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
2162             p_fmt = (es_format_t*) va_arg( args, es_format_t * );
2163             if( es == NULL )
2164                 return VLC_EGENERIC;
2165
2166             if( p_fmt->i_extra )
2167             {
2168                 es->fmt.i_extra = p_fmt->i_extra;
2169                 es->fmt.p_extra = realloc( es->fmt.p_extra, p_fmt->i_extra );
2170                 memcpy( es->fmt.p_extra, p_fmt->p_extra, p_fmt->i_extra );
2171
2172                 if( !es->p_dec )
2173                     return VLC_SUCCESS;
2174 #if 1
2175                 EsDestroyDecoder( out, es );
2176
2177                 EsCreateDecoder( out, es );
2178 #else
2179                 es->p_dec->fmt_in.i_extra = p_fmt->i_extra;
2180                 es->p_dec->fmt_in.p_extra =
2181                     realloc( es->p_dec->fmt_in.p_extra, p_fmt->i_extra );
2182                 memcpy( es->p_dec->fmt_in.p_extra,
2183                         p_fmt->p_extra, p_fmt->i_extra );
2184 #endif
2185             }
2186
2187             return VLC_SUCCESS;
2188         }
2189
2190         case ES_OUT_SET_NEXT_DISPLAY_TIME:
2191         {
2192             const int64_t i_date = (int64_t)va_arg( args, int64_t );
2193
2194             if( i_date < 0 )
2195                 return VLC_EGENERIC;
2196
2197             p_sys->i_preroll_end = i_date;
2198
2199             return VLC_SUCCESS;
2200         }
2201         case ES_OUT_SET_GROUP_META:
2202         {
2203             int i_group = (int)va_arg( args, int );
2204             vlc_meta_t *p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t * );
2205
2206             EsOutProgramMeta( out, i_group, p_meta );
2207             return VLC_SUCCESS;
2208         }
2209         case ES_OUT_SET_GROUP_EPG:
2210         {
2211             int i_group = (int)va_arg( args, int );
2212             vlc_epg_t *p_epg = (vlc_epg_t*)va_arg( args, vlc_epg_t * );
2213
2214             EsOutProgramEpg( out, i_group, p_epg );
2215             return VLC_SUCCESS;
2216         }
2217         case ES_OUT_DEL_GROUP:
2218         {
2219             int i_group = (int)va_arg( args, int );
2220
2221             return EsOutProgramDel( out, i_group );
2222         }
2223
2224         case ES_OUT_GET_WAKE_UP:
2225         {
2226             mtime_t *pi_wakeup = (mtime_t*)va_arg( args, mtime_t* );
2227             *pi_wakeup = EsOutGetWakeup( out );
2228             return VLC_SUCCESS;
2229         }
2230
2231         case ES_OUT_SET_ES_BY_ID:
2232         case ES_OUT_RESTART_ES_BY_ID:
2233         case ES_OUT_SET_ES_DEFAULT_BY_ID:
2234         {
2235             const int i_id = (int)va_arg( args, int );
2236             es_out_id_t *p_es = EsOutGetFromID( out, i_id );
2237             int i_new_query;
2238
2239             switch( i_query )
2240             {
2241             case ES_OUT_SET_ES_BY_ID:         i_new_query = ES_OUT_SET_ES; break;
2242             case ES_OUT_RESTART_ES_BY_ID:     i_new_query = ES_OUT_RESTART_ES; break;
2243             case ES_OUT_SET_ES_DEFAULT_BY_ID: i_new_query = ES_OUT_SET_ES_DEFAULT; break;
2244             default:
2245               assert(0);
2246             }
2247             /* TODO if the lock is made non recursive it should be changed */
2248             return es_out_Control( out, i_new_query, p_es );
2249         }
2250
2251         case ES_OUT_GET_BUFFERING:
2252             pb = (bool *)va_arg( args, bool* );
2253             *pb = p_sys->b_buffering;
2254             return VLC_SUCCESS;
2255
2256         case ES_OUT_GET_EMPTY:
2257             pb = (bool *)va_arg( args, bool* );
2258             *pb = EsOutDecodersIsEmpty( out );
2259             return VLC_SUCCESS;
2260
2261         case ES_OUT_SET_DELAY:
2262         {
2263             const int i_cat = (int)va_arg( args, int );
2264             const mtime_t i_delay = (mtime_t)va_arg( args, mtime_t );
2265             EsOutSetDelay( out, i_cat, i_delay );
2266             return VLC_SUCCESS;
2267         }
2268
2269         case ES_OUT_SET_RECORD_STATE:
2270             b = (bool) va_arg( args, int );
2271             return EsOutSetRecord( out, b );
2272
2273         case ES_OUT_SET_PAUSE_STATE:
2274         {
2275             const bool b_source_paused = (bool)va_arg( args, int );
2276             const bool b_paused = (bool)va_arg( args, int );
2277             const mtime_t i_date = (mtime_t) va_arg( args, mtime_t );
2278
2279             assert( !b_source_paused == !b_paused );
2280             EsOutChangePause( out, b_paused, i_date );
2281
2282             return VLC_SUCCESS;
2283         }
2284
2285         case ES_OUT_SET_RATE:
2286         {
2287             const int i_src_rate = (int)va_arg( args, int );
2288             const int i_rate = (int)va_arg( args, int );
2289
2290             assert( i_src_rate == i_rate );
2291             EsOutChangeRate( out, i_rate );
2292
2293             return VLC_SUCCESS;
2294         }
2295
2296         case ES_OUT_SET_TIME:
2297         {
2298             const mtime_t i_date = (mtime_t)va_arg( args, mtime_t );
2299
2300             assert( i_date == -1 );
2301             EsOutChangePosition( out );
2302
2303             return VLC_SUCCESS;
2304         }
2305
2306         case ES_OUT_SET_FRAME_NEXT:
2307             EsOutFrameNext( out );
2308             return VLC_SUCCESS;
2309
2310         default:
2311             msg_Err( p_sys->p_input, "unknown query in es_out_Control" );
2312             return VLC_EGENERIC;
2313     }
2314 }
2315 static int EsOutControl( es_out_t *out, int i_query, va_list args )
2316 {
2317     es_out_sys_t *p_sys = out->p_sys;
2318     int i_ret;
2319
2320     vlc_mutex_lock( &p_sys->lock );
2321     i_ret = EsOutControlLocked( out, i_query, args );
2322     vlc_mutex_unlock( &p_sys->lock );
2323
2324     return i_ret;
2325 }
2326
2327 /****************************************************************************
2328  * LanguageGetName: try to expend iso639 into plain name
2329  ****************************************************************************/
2330 static char *LanguageGetName( const char *psz_code )
2331 {
2332     const iso639_lang_t *pl;
2333
2334     if( psz_code == NULL )
2335     {
2336         return strdup( "" );
2337     }
2338
2339     if( strlen( psz_code ) == 2 )
2340     {
2341         pl = GetLang_1( psz_code );
2342     }
2343     else if( strlen( psz_code ) == 3 )
2344     {
2345         pl = GetLang_2B( psz_code );
2346         if( !strcmp( pl->psz_iso639_1, "??" ) )
2347         {
2348             pl = GetLang_2T( psz_code );
2349         }
2350     }
2351     else
2352     {
2353         return strdup( psz_code );
2354     }
2355
2356     if( !strcmp( pl->psz_iso639_1, "??" ) )
2357     {
2358        return strdup( psz_code );
2359     }
2360     else
2361     {
2362         if( *pl->psz_native_name )
2363         {
2364             return strdup( pl->psz_native_name );
2365         }
2366         return strdup( pl->psz_eng_name );
2367     }
2368 }
2369
2370 /* Get a 2 char code */
2371 static char *LanguageGetCode( const char *psz_lang )
2372 {
2373     const iso639_lang_t *pl;
2374
2375     if( psz_lang == NULL || *psz_lang == '\0' )
2376         return strdup("??");
2377
2378     for( pl = p_languages; pl->psz_iso639_1 != NULL; pl++ )
2379     {
2380         if( !strcasecmp( pl->psz_eng_name, psz_lang ) ||
2381             !strcasecmp( pl->psz_native_name, psz_lang ) ||
2382             !strcasecmp( pl->psz_iso639_1, psz_lang ) ||
2383             !strcasecmp( pl->psz_iso639_2T, psz_lang ) ||
2384             !strcasecmp( pl->psz_iso639_2B, psz_lang ) )
2385             break;
2386     }
2387
2388     if( pl->psz_iso639_1 != NULL )
2389         return strdup( pl->psz_iso639_1 );
2390
2391     return strdup("??");
2392 }
2393
2394 static char **LanguageSplit( const char *psz_langs )
2395 {
2396     char *psz_dup;
2397     char *psz_parser;
2398     char **ppsz = NULL;
2399     int i_psz = 0;
2400
2401     if( psz_langs == NULL ) return NULL;
2402
2403     psz_parser = psz_dup = strdup(psz_langs);
2404
2405     while( psz_parser && *psz_parser )
2406     {
2407         char *psz;
2408         char *psz_code;
2409
2410         psz = strchr(psz_parser, ',' );
2411         if( psz ) *psz++ = '\0';
2412
2413         if( !strcmp( psz_parser, "any" ) )
2414         {
2415             TAB_APPEND( i_psz, ppsz, strdup("any") );
2416         }
2417         else
2418         {
2419             psz_code = LanguageGetCode( psz_parser );
2420             if( strcmp( psz_code, "??" ) )
2421             {
2422                 TAB_APPEND( i_psz, ppsz, psz_code );
2423             }
2424             else
2425             {
2426                 free( psz_code );
2427             }
2428         }
2429
2430         psz_parser = psz;
2431     }
2432
2433     if( i_psz )
2434     {
2435         TAB_APPEND( i_psz, ppsz, NULL );
2436     }
2437
2438     free( psz_dup );
2439     return ppsz;
2440 }
2441
2442 static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang )
2443 {
2444     int i;
2445
2446     if( !ppsz_langs || !psz_lang ) return -1;
2447
2448     for( i = 0; ppsz_langs[i]; i++ )
2449     {
2450         if( !strcasecmp( ppsz_langs[i], psz_lang ) ||
2451             !strcasecmp( ppsz_langs[i], "any" ) )
2452         {
2453             return i;
2454         }
2455     }
2456
2457     return -1;
2458 }
2459
2460 /****************************************************************************
2461  * EsOutUpdateInfo:
2462  * - add meta info to the playlist item
2463  ****************************************************************************/
2464 static void EsOutUpdateInfo( es_out_t *out, es_out_id_t *es, const es_format_t *fmt )
2465 {
2466     es_out_sys_t   *p_sys = out->p_sys;
2467     input_thread_t *p_input = p_sys->p_input;
2468     const es_format_t *p_fmt_es = &es->fmt;
2469     char           *psz_cat;
2470     lldiv_t         div;
2471
2472     /* Create category name */
2473     if( asprintf( &psz_cat, _("Stream %d"), es->i_meta_id ) == -1 )
2474         return;
2475
2476     /* Remove previous information */
2477     input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
2478
2479     /* Add informations */
2480     const char *psz_type;
2481     switch( fmt->i_cat )
2482     {
2483     case AUDIO_ES:
2484         psz_type = _("Audio");
2485         break;
2486     case VIDEO_ES:
2487         psz_type = _("Video");
2488         break;
2489     case SPU_ES:
2490         psz_type = _("Subtitle");
2491         break;
2492     default:
2493         psz_type = NULL;
2494         break;
2495     }
2496
2497     if( psz_type )
2498         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Type"), psz_type );
2499
2500     if( es->i_meta_id != es->i_id )
2501         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Original ID"),
2502                        "%d", es->i_id );
2503
2504     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Codec"),
2505                    "%.4s", (char*)&p_fmt_es->i_codec );
2506
2507     if( es->psz_language && *es->psz_language )
2508         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"),
2509                        "%s", es->psz_language );
2510     if( fmt->psz_description && *fmt->psz_description )
2511         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Description"),
2512                        "%s", fmt->psz_description );
2513
2514     switch( fmt->i_cat )
2515     {
2516     case AUDIO_ES:
2517         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2518                        _("Type"), _("Audio") );
2519
2520         if( fmt->audio.i_physical_channels & AOUT_CHAN_PHYSMASK )
2521             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
2522                            "%s", aout_FormatPrintChannels( &fmt->audio ) );
2523         else if( fmt->audio.i_channels > 0 )
2524             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
2525                            "%u", fmt->audio.i_channels );
2526
2527         if( fmt->audio.i_rate > 0 )
2528         {
2529             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"),
2530                            _("%u Hz"), fmt->audio.i_rate );
2531             /* FIXME that should be removed or improved ! (used by text/strings.c) */
2532             var_SetInteger( p_input, "sample-rate", fmt->audio.i_rate );
2533         }
2534
2535         unsigned int i_bitspersample = fmt->audio.i_bitspersample;
2536         if( i_bitspersample <= 0 )
2537             i_bitspersample = aout_BitsPerSample( p_fmt_es->i_codec );
2538         if( i_bitspersample > 0 )
2539             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2540                            _("Bits per sample"), "%u",
2541                            i_bitspersample );
2542
2543         if( fmt->i_bitrate > 0 )
2544         {
2545             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"),
2546                            _("%u kb/s"), fmt->i_bitrate / 1000 );
2547             /* FIXME that should be removed or improved ! (used by text/strings.c) */
2548             var_SetInteger( p_input, "bit-rate", fmt->i_bitrate );
2549         }
2550         for( int i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
2551         {
2552             const audio_replay_gain_t *p_rg = &fmt->audio_replay_gain;
2553             if( !p_rg->pb_gain[i] )
2554                 continue;
2555             const char *psz_name;
2556             if( i == AUDIO_REPLAY_GAIN_TRACK )
2557                 psz_name = _("Track replay gain");
2558             else
2559                 psz_name = _("Album replay gain");
2560             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2561                            psz_name, _("%.2f dB"), p_rg->pf_gain[i] );
2562         }
2563         break;
2564
2565     case VIDEO_ES:
2566         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2567                        _("Type"), _("Video") );
2568
2569         if( fmt->video.i_width > 0 && fmt->video.i_height > 0 )
2570             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2571                            _("Resolution"), "%ux%u",
2572                            fmt->video.i_width, fmt->video.i_height );
2573
2574         if( fmt->video.i_visible_width > 0 &&
2575             fmt->video.i_visible_height > 0 )
2576             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2577                            _("Display resolution"), "%ux%u",
2578                            fmt->video.i_visible_width,
2579                            fmt->video.i_visible_height);
2580        if( fmt->video.i_frame_rate > 0 &&
2581            fmt->video.i_frame_rate_base > 0 )
2582        {
2583            div = lldiv( (float)fmt->video.i_frame_rate /
2584                                fmt->video.i_frame_rate_base * 1000000,
2585                                1000000 );
2586            if( div.rem > 0 )
2587                input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2588                               _("Frame rate"), "%"PRId64".%06u",
2589                               div.quot, (unsigned int )div.rem );
2590            else
2591                input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2592                               _("Frame rate"), "%"PRId64, div.quot );
2593        }
2594        break;
2595
2596     case SPU_ES:
2597         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
2598                        _("Type"), _("Subtitle") );
2599         break;
2600
2601     default:
2602         break;
2603     }
2604
2605     free( psz_cat );
2606 }