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