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