21f672b8b3297cdb2c123760002e1d885c0b1c93
[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 #include <vlc/vlc.h>
29
30 #include <stdio.h>
31
32 #include <vlc_input.h>
33 #include <vlc_es_out.h>
34 #include <vlc_block.h>
35 #include <vlc_aout.h>
36
37 #include "input_internal.h"
38
39 #include "vlc_playlist.h"
40 #include "iso_lang.h"
41 /* FIXME we should find a better way than including that */
42 #include "../text/iso-639_def.h"
43
44 /*****************************************************************************
45  * Local prototypes
46  *****************************************************************************/
47 typedef struct
48 {
49     /* Program ID */
50     int i_id;
51
52     /* Number of es for this pgrm */
53     int i_es;
54
55     vlc_bool_t b_selected;
56
57     /* Clock for this program */
58     input_clock_t clock;
59
60     char    *psz_name;
61     char    *psz_now_playing;
62     char    *psz_publisher;
63
64     vlc_epg_t *p_epg;
65 } es_out_pgrm_t;
66
67 struct es_out_id_t
68 {
69     /* ES ID */
70     int       i_id;
71     es_out_pgrm_t *p_pgrm;
72
73     /* Misc. */
74     int64_t i_preroll_end;
75
76     /* Channel in the track type */
77     int         i_channel;
78     es_format_t fmt;
79     char        *psz_language;
80     char        *psz_language_code;
81     decoder_t   *p_dec;
82 };
83
84 struct es_out_sys_t
85 {
86     input_thread_t *p_input;
87
88     /* all programs */
89     int           i_pgrm;
90     es_out_pgrm_t **pgrm;
91     es_out_pgrm_t **pp_selected_pgrm; /* --programs */
92     es_out_pgrm_t *p_pgrm;  /* Master program */
93
94     /* all es */
95     int         i_id;
96     int         i_es;
97     es_out_id_t **es;
98
99     /* mode gestion */
100     vlc_bool_t  b_active;
101     int         i_mode;
102
103     /* es count */
104     int         i_audio;
105     int         i_video;
106     int         i_sub;
107
108     /* es to select */
109     int         i_audio_last, i_audio_id;
110     int         i_sub_last, i_sub_id;
111     int         i_default_sub_id;   /* As specified in container; if applicable */
112     char        **ppsz_audio_language;
113     char        **ppsz_sub_language;
114
115     /* current main es */
116     es_out_id_t *p_es_audio;
117     es_out_id_t *p_es_video;
118     es_out_id_t *p_es_sub;
119
120     /* delay */
121     int64_t i_audio_delay;
122     int64_t i_spu_delay;
123 };
124
125 static es_out_id_t *EsOutAdd    ( es_out_t *, es_format_t * );
126 static int          EsOutSend   ( es_out_t *, es_out_id_t *, block_t * );
127 static void         EsOutDel    ( es_out_t *, es_out_id_t * );
128 static void         EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force );
129 static int          EsOutControl( es_out_t *, int i_query, va_list );
130
131 static void         EsOutAddInfo( es_out_t *, es_out_id_t *es );
132
133 static void EsSelect( es_out_t *out, es_out_id_t *es );
134 static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update );
135 static char *LanguageGetName( const char *psz_code );
136 static char *LanguageGetCode( const char *psz_lang );
137 static char **LanguageSplit( const char *psz_langs );
138 static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang );
139
140 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm );
141
142 /*****************************************************************************
143  * input_EsOutNew:
144  *****************************************************************************/
145 es_out_t *input_EsOutNew( input_thread_t *p_input )
146 {
147     es_out_t     *out = malloc( sizeof( es_out_t ) );
148     es_out_sys_t *p_sys = malloc( sizeof( es_out_sys_t ) );
149     vlc_value_t  val;
150     int i;
151
152     out->pf_add     = EsOutAdd;
153     out->pf_send    = EsOutSend;
154     out->pf_del     = EsOutDel;
155     out->pf_control = EsOutControl;
156     out->p_sys      = p_sys;
157     out->b_sout     = (p_input->p->p_sout != NULL ? VLC_TRUE : VLC_FALSE);
158
159     p_sys->p_input = p_input;
160
161     p_sys->b_active = VLC_FALSE;
162     p_sys->i_mode   = ES_OUT_MODE_AUTO;
163
164
165     TAB_INIT( p_sys->i_pgrm, p_sys->pgrm );
166     p_sys->p_pgrm   = NULL;
167
168     p_sys->i_id    = 0;
169
170     TAB_INIT( p_sys->i_es, p_sys->es );
171
172     p_sys->i_audio = 0;
173     p_sys->i_video = 0;
174     p_sys->i_sub   = 0;
175
176     /* */
177     var_Get( p_input, "audio-track", &val );
178     p_sys->i_audio_last = val.i_int;
179
180     var_Get( p_input, "sub-track", &val );
181     p_sys->i_sub_last = val.i_int;
182
183     p_sys->i_default_sub_id   = -1;
184
185     if( !p_input->b_preparsing )
186     {
187         var_Get( p_input, "audio-language", &val );
188         p_sys->ppsz_audio_language = LanguageSplit(val.psz_string);
189         if( p_sys->ppsz_audio_language )
190         {
191             for( i = 0; p_sys->ppsz_audio_language[i]; i++ )
192                 msg_Dbg( p_input, "selected audio language[%d] %s",
193                          i, p_sys->ppsz_audio_language[i] );
194         }
195         if( val.psz_string ) free( val.psz_string );
196
197         var_Get( p_input, "sub-language", &val );
198         p_sys->ppsz_sub_language = LanguageSplit(val.psz_string);
199         if( p_sys->ppsz_sub_language )
200         {
201             for( i = 0; p_sys->ppsz_sub_language[i]; i++ )
202                 msg_Dbg( p_input, "selected subtitle language[%d] %s",
203                          i, p_sys->ppsz_sub_language[i] );
204         }
205         if( val.psz_string ) free( val.psz_string );
206     }
207     else
208     {
209         p_sys->ppsz_sub_language = NULL;
210         p_sys->ppsz_audio_language = NULL;
211     }
212
213     var_Get( p_input, "audio-track-id", &val );
214     p_sys->i_audio_id = val.i_int;
215
216     var_Get( p_input, "sub-track-id", &val );
217     p_sys->i_sub_id = val.i_int;
218
219     p_sys->p_es_audio = NULL;
220     p_sys->p_es_video = NULL;
221     p_sys->p_es_sub   = NULL;
222
223     p_sys->i_audio_delay= 0;
224     p_sys->i_spu_delay  = 0;
225
226     return out;
227 }
228
229 /*****************************************************************************
230  * input_EsOutDelete:
231  *****************************************************************************/
232 void input_EsOutDelete( es_out_t *out )
233 {
234     es_out_sys_t *p_sys = out->p_sys;
235     int i;
236
237     for( i = 0; i < p_sys->i_es; i++ )
238     {
239         if( p_sys->es[i]->p_dec )
240         {
241             input_DecoderDelete( p_sys->es[i]->p_dec );
242         }
243         if( p_sys->es[i]->psz_language )
244             free( p_sys->es[i]->psz_language );
245         if( p_sys->es[i]->psz_language_code )
246             free( p_sys->es[i]->psz_language_code );
247         es_format_Clean( &p_sys->es[i]->fmt );
248
249         free( p_sys->es[i] );
250     }
251     if( p_sys->ppsz_audio_language )
252     {
253         for( i = 0; p_sys->ppsz_audio_language[i]; i++ )
254             free( p_sys->ppsz_audio_language[i] );
255         free( p_sys->ppsz_audio_language );
256     }
257     if( p_sys->ppsz_sub_language )
258     {
259         for( i = 0; p_sys->ppsz_sub_language[i]; i++ )
260             free( p_sys->ppsz_sub_language[i] );
261         free( p_sys->ppsz_sub_language );
262     }
263
264     if( p_sys->es )
265         free( p_sys->es );
266
267     /* FIXME duplicate work EsOutProgramDel (but we cannot use it) add a EsOutProgramClean ? */
268     for( i = 0; i < p_sys->i_pgrm; i++ )
269     {
270         es_out_pgrm_t *p_pgrm = p_sys->pgrm[i];
271         if( p_pgrm->psz_now_playing )
272             free( p_pgrm->psz_now_playing );
273         if( p_pgrm->psz_publisher )
274             free( p_pgrm->psz_publisher );
275         if( p_pgrm->psz_name )
276             free( p_pgrm->psz_name );
277         if( p_pgrm->p_epg )
278             vlc_epg_Delete( p_pgrm->p_epg );
279
280         free( p_pgrm );
281     }
282     TAB_CLEAN( p_sys->i_pgrm, p_sys->pgrm );
283
284     free( p_sys );
285     free( out );
286 }
287
288 es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id )
289 {
290     int i;
291     if( i_id < 0 )
292     {
293         /* Special HACK, -i_id is tha cat of the stream */
294         return (es_out_id_t*)((uint8_t*)NULL-i_id);
295     }
296
297     for( i = 0; i < out->p_sys->i_es; i++ )
298     {
299         if( out->p_sys->es[i]->i_id == i_id )
300             return out->p_sys->es[i];
301     }
302     return NULL;
303 }
304
305 void input_EsOutDiscontinuity( es_out_t *out, vlc_bool_t b_flush, vlc_bool_t b_audio )
306 {
307     es_out_sys_t      *p_sys = out->p_sys;
308     int i;
309
310     for( i = 0; i < p_sys->i_es; i++ )
311     {
312         es_out_id_t *es = p_sys->es[i];
313
314         /* Send a dummy block to let decoder know that
315          * there is a discontinuity */
316         if( es->p_dec && ( !b_audio || es->fmt.i_cat == AUDIO_ES ) )
317             input_DecoderDiscontinuity( es->p_dec, b_flush );
318     }
319 }
320 void input_EsOutChangeRate( es_out_t *out )
321 {
322     es_out_sys_t      *p_sys = out->p_sys;
323     int i;
324
325     input_EsOutDiscontinuity( out, VLC_FALSE, VLC_FALSE );
326
327     for( i = 0; i < p_sys->i_pgrm; i++ )
328         input_ClockSetRate( p_sys->p_input, &p_sys->pgrm[i]->clock );
329 }
330
331 void input_EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay )
332 {
333     es_out_sys_t *p_sys = out->p_sys;
334
335     if( i_cat == AUDIO_ES )
336         p_sys->i_audio_delay = i_delay;
337     else if( i_cat == SPU_ES )
338         p_sys->i_spu_delay = i_delay;
339 }
340 void input_EsOutChangeState( es_out_t *out )
341 {
342     es_out_sys_t *p_sys = out->p_sys;
343     input_thread_t *p_input = p_sys->p_input;
344
345     if( p_input->i_state  == PAUSE_S )
346     {
347         /* Send discontinuity to decoders (it will allow them to flush
348          *                  * if implemented */
349         input_EsOutDiscontinuity( out, VLC_FALSE, VLC_FALSE );
350     }
351     else
352     {
353         /* Out of pause, reset pcr */
354         es_out_Control( out, ES_OUT_RESET_PCR );
355     }
356 }
357
358 vlc_bool_t input_EsOutDecodersEmpty( es_out_t *out )
359 {
360     es_out_sys_t      *p_sys = out->p_sys;
361     int i;
362
363     for( i = 0; i < p_sys->i_es; i++ )
364     {
365         es_out_id_t *es = p_sys->es[i];
366
367         if( es->p_dec && !input_DecoderEmpty( es->p_dec ) )
368             return VLC_FALSE;
369     }
370     return VLC_TRUE;
371 }
372
373 /*****************************************************************************
374  *
375  *****************************************************************************/
376 static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es,
377                               vlc_bool_t b_delete )
378 {
379     es_out_sys_t      *p_sys = out->p_sys;
380     input_thread_t    *p_input = p_sys->p_input;
381     vlc_value_t       val, text;
382
383     const char *psz_var;
384
385     if( es->fmt.i_cat == AUDIO_ES )
386         psz_var = "audio-es";
387     else if( es->fmt.i_cat == VIDEO_ES )
388         psz_var = "video-es";
389     else if( es->fmt.i_cat == SPU_ES )
390         psz_var = "spu-es";
391     else
392         return;
393
394     if( b_delete )
395     {
396         val.i_int = es->i_id;
397         var_Change( p_input, psz_var, VLC_VAR_DELCHOICE, &val, NULL );
398         var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
399         return;
400     }
401
402     /* Get the number of ES already added */
403     var_Change( p_input, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
404     if( val.i_int == 0 )
405     {
406         vlc_value_t val2;
407
408         /* First one, we need to add the "Disable" choice */
409         val2.i_int = -1; text.psz_string = _("Disable");
410         var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val2, &text );
411         val.i_int++;
412     }
413
414     /* Take care of the ES description */
415     if( es->fmt.psz_description && *es->fmt.psz_description )
416     {
417         if( es->psz_language && *es->psz_language )
418         {
419             text.psz_string = malloc( strlen( es->fmt.psz_description) +
420                                       strlen( es->psz_language ) + 10 );
421             sprintf( text.psz_string, "%s - [%s]", es->fmt.psz_description,
422                                                    es->psz_language );
423         }
424         else text.psz_string = strdup( es->fmt.psz_description );
425     }
426     else
427     {
428         if( es->psz_language && *es->psz_language )
429         {
430             char *temp;
431             text.psz_string = malloc( strlen( _("Track %i") )+
432                                       strlen( es->psz_language ) + 30 );
433             asprintf( &temp,  _("Track %i"), val.i_int );
434             sprintf( text.psz_string, "%s - [%s]", temp, es->psz_language );
435             free( temp );
436         }
437         else
438         {
439             text.psz_string = malloc( strlen( _("Track %i") ) + 20 );
440             sprintf( text.psz_string, _("Track %i"), val.i_int );
441         }
442     }
443
444     val.i_int = es->i_id;
445     var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val, &text );
446
447     free( text.psz_string );
448
449     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
450 }
451
452 /* EsOutProgramSelect:
453  *  Select a program and update the object variable
454  */
455 static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm )
456 {
457     es_out_sys_t      *p_sys = out->p_sys;
458     input_thread_t    *p_input = p_sys->p_input;
459     vlc_value_t       val;
460     int               i;
461
462     if( p_sys->p_pgrm == p_pgrm )
463         return; /* Nothing to do */
464
465     if( p_sys->p_pgrm )
466     {
467         es_out_pgrm_t *old = p_sys->p_pgrm;
468         msg_Dbg( p_input, "unselecting program id=%d", old->i_id );
469
470         for( i = 0; i < p_sys->i_es; i++ )
471         {
472             if( p_sys->es[i]->p_pgrm == old && p_sys->es[i]->p_dec &&
473                 p_sys->i_mode != ES_OUT_MODE_ALL )
474                 EsUnselect( out, p_sys->es[i], VLC_TRUE );
475         }
476
477         p_sys->p_es_audio = NULL;
478         p_sys->p_es_sub = NULL;
479         p_sys->p_es_video = NULL;
480     }
481
482     msg_Dbg( p_input, "selecting program id=%d", p_pgrm->i_id );
483
484     /* Mark it selected */
485     p_pgrm->b_selected = VLC_TRUE;
486
487     /* Switch master stream */
488     if( p_sys->p_pgrm && p_sys->p_pgrm->clock.b_master )
489     {
490         p_sys->p_pgrm->clock.b_master = VLC_FALSE;
491     }
492     p_pgrm->clock.b_master = VLC_TRUE;
493     p_sys->p_pgrm = p_pgrm;
494
495     /* Update "program" */
496     val.i_int = p_pgrm->i_id;
497     var_Change( p_input, "program", VLC_VAR_SETVALUE, &val, NULL );
498
499     /* Update "es-*" */
500     var_Change( p_input, "audio-es", VLC_VAR_CLEARCHOICES, NULL, NULL );
501     var_Change( p_input, "video-es", VLC_VAR_CLEARCHOICES, NULL, NULL );
502     var_Change( p_input, "spu-es",   VLC_VAR_CLEARCHOICES, NULL, NULL );
503     for( i = 0; i < p_sys->i_es; i++ )
504     {
505         if( p_sys->es[i]->p_pgrm == p_sys->p_pgrm )
506             EsOutESVarUpdate( out, p_sys->es[i], VLC_FALSE );
507         EsOutSelect( out, p_sys->es[i], VLC_FALSE );
508     }
509
510     /* Update now playing */
511     input_item_SetNowPlaying( p_input->p->input.p_item,
512                               p_pgrm->psz_now_playing );
513     input_item_SetPublisher( p_input->p->input.p_item,
514                              p_pgrm->psz_publisher );
515
516     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
517 }
518
519 /* EsOutAddProgram:
520  *  Add a program
521  */
522 static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group )
523 {
524     es_out_sys_t      *p_sys = out->p_sys;
525     input_thread_t    *p_input = p_sys->p_input;
526     vlc_value_t       val;
527
528     es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) );
529
530     /* Init */
531     p_pgrm->i_id = i_group;
532     p_pgrm->i_es = 0;
533     p_pgrm->b_selected = VLC_FALSE;
534     p_pgrm->psz_name = NULL;
535     p_pgrm->psz_now_playing = NULL;
536     p_pgrm->psz_publisher = NULL;
537     p_pgrm->p_epg = NULL;
538     input_ClockInit( p_input, &p_pgrm->clock, VLC_FALSE, p_input->p->input.i_cr_average );
539
540     /* Append it */
541     TAB_APPEND( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
542
543     /* Update "program" variable */
544     val.i_int = i_group;
545     var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, NULL );
546
547     if( i_group == var_GetInteger( p_input, "program" ) )
548     {
549         EsOutProgramSelect( out, p_pgrm );
550     }
551     else
552     {
553         var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
554     }
555     return p_pgrm;
556 }
557
558 /* EsOutDelProgram:
559  *  Delete a program
560  */
561 static int EsOutProgramDel( es_out_t *out, int i_group )
562 {
563     es_out_sys_t      *p_sys = out->p_sys;
564     input_thread_t    *p_input = p_sys->p_input;
565     es_out_pgrm_t     *p_pgrm = NULL;
566     vlc_value_t       val;
567     int               i;
568
569     for( i = 0; i < p_sys->i_pgrm; i++ )
570     {
571         if( p_sys->pgrm[i]->i_id == i_group )
572         {
573             p_pgrm = p_sys->pgrm[i];
574             break;
575         }
576     }
577
578     if( p_pgrm == NULL )
579         return VLC_EGENERIC;
580
581     if( p_pgrm->i_es )
582     {
583         msg_Dbg( p_input, "can't delete program %d which still has %i ES",
584                  i_group, p_pgrm->i_es );
585         return VLC_EGENERIC;
586     }
587
588     TAB_REMOVE( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
589
590     /* If program is selected we need to unselect it */
591     if( p_sys->p_pgrm == p_pgrm ) p_sys->p_pgrm = NULL;
592
593     if( p_pgrm->psz_name ) free( p_pgrm->psz_name );
594     if( p_pgrm->psz_now_playing ) free( p_pgrm->psz_now_playing );
595     if( p_pgrm->psz_publisher ) free( p_pgrm->psz_publisher );
596     if( p_pgrm->p_epg )
597         vlc_epg_Delete( p_pgrm->p_epg );
598     free( p_pgrm );
599
600     /* Update "program" variable */
601     val.i_int = i_group;
602     var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL );
603
604     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
605
606     return VLC_SUCCESS;
607 }
608
609 /* EsOutProgramMeta:
610  */
611 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm )
612 {
613     char *psz = NULL;
614     if( p_pgrm->psz_name )
615         asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id );
616     else
617         asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id );
618     return psz;
619 }
620
621 static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta )
622 {
623     es_out_sys_t      *p_sys = out->p_sys;
624     es_out_pgrm_t     *p_pgrm = NULL;
625     input_thread_t    *p_input = p_sys->p_input;
626     char              *psz_cat;
627     const char        *psz_title = NULL;
628     const char        *psz_provider = NULL;
629     int i;
630
631     msg_Dbg( p_input, "EsOutProgramMeta: number=%d", i_group );
632
633     /* Check against empty meta data (empty for what we handle) */
634     if( !vlc_meta_Get( p_meta, vlc_meta_Title) &&
635         !vlc_meta_Get( p_meta, vlc_meta_NowPlaying) &&
636         !vlc_meta_Get( p_meta, vlc_meta_Publisher) &&
637         vlc_dictionary_keys_count( &p_meta->extra_tags ) <= 0 )
638             return;
639     /* Find program */
640     for( i = 0; i < p_sys->i_pgrm; i++ )
641     {
642         if( p_sys->pgrm[i]->i_id == i_group )
643         {
644             p_pgrm = p_sys->pgrm[i];
645             break;
646         }
647     }
648     if( p_pgrm == NULL )
649         p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
650
651     /* */
652     psz_title = vlc_meta_Get( p_meta, vlc_meta_Title);
653     psz_provider = vlc_meta_Get( p_meta, vlc_meta_Publisher);
654
655     /* Update the description text of the program */
656     if( psz_title && *psz_title )
657     {
658         vlc_value_t val;
659         vlc_value_t text;
660
661         if( !p_pgrm->psz_name || strcmp( p_pgrm->psz_name, psz_title ) )
662         {
663             char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
664
665             /* Remove old entries */
666             input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL );
667             /* TODO update epg name */
668             free( psz_cat );
669         }
670         if( p_pgrm->psz_name ) free( p_pgrm->psz_name );
671         p_pgrm->psz_name = strdup( psz_title );
672
673         /* ugly but it works */
674         val.i_int = i_group;
675         var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL );
676
677         if( psz_provider && *psz_provider )
678         {
679             asprintf( &text.psz_string, "%s [%s]", psz_title, psz_provider );
680             var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, &text );
681             free( text.psz_string );
682         }
683         else
684         {
685             text.psz_string = (char *)psz_title;
686             var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, &text );
687         }
688     }
689
690     psz_cat = EsOutProgramGetMetaName( p_pgrm );
691     if( psz_provider )
692     {
693         if( p_sys->p_pgrm == p_pgrm )
694             input_item_SetPublisher( p_input->p->input.p_item, psz_provider );
695         input_Control( p_input, INPUT_ADD_INFO, psz_cat, input_MetaTypeToLocalizedString(vlc_meta_Publisher), psz_provider );
696     }
697     char ** ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags );
698     for( i = 0; ppsz_all_keys[i]; i++ )
699     {
700         input_Control( p_input, INPUT_ADD_INFO, psz_cat, _(ppsz_all_keys[i]),
701                        vlc_dictionary_value_for_key( &p_meta->extra_tags, ppsz_all_keys[i] ) );
702         free( ppsz_all_keys[i] );
703     }
704     free( ppsz_all_keys );
705
706     free( psz_cat );
707 }
708
709 static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src )
710 {
711     int i;
712
713     /* Add new event */
714     for( i = 0; i < p_src->i_event; i++ )
715     {
716         vlc_epg_event_t *p_evt = p_src->pp_event[i];
717         vlc_bool_t b_add = VLC_TRUE;
718         int j;
719
720         for( j = 0; j < p_dst->i_event; j++ )
721         {
722             if( p_dst->pp_event[j]->i_start == p_evt->i_start && p_dst->pp_event[j]->i_duration == p_evt->i_duration )
723             {
724                 b_add = VLC_FALSE;
725                 break;
726             }
727             if( p_dst->pp_event[j]->i_start > p_evt->i_start )
728                 break;
729         }
730         if( b_add )
731         {
732             vlc_epg_event_t *p_copy = malloc( sizeof(vlc_epg_event_t) );
733             if( !p_copy )
734                 break;
735             memset( p_copy, 0, sizeof(vlc_epg_event_t) );
736             p_copy->i_start = p_evt->i_start;
737             p_copy->i_duration = p_evt->i_duration;
738             p_copy->psz_name = p_evt->psz_name ? strdup( p_evt->psz_name ) : NULL;
739             p_copy->psz_short_description = p_evt->psz_short_description ? strdup( p_evt->psz_short_description ) : NULL;
740             p_copy->psz_description = p_evt->psz_description ? strdup( p_evt->psz_description ) : NULL;
741             TAB_INSERT( p_dst->i_event, p_dst->pp_event, p_copy, j );
742         }
743     }
744     /* Update current */
745     vlc_epg_SetCurrent( p_dst, p_src->p_current ? p_src->p_current->i_start : -1 );
746
747     /* Keep only 1 old event  */
748     if( p_dst->p_current )
749     {
750         while( p_dst->i_event > 1 && p_dst->pp_event[0] != p_dst->p_current && p_dst->pp_event[1] != p_dst->p_current )
751             TAB_REMOVE( p_dst->i_event, p_dst->pp_event, p_dst->pp_event[0] );
752     }
753 }
754
755 static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg )
756 {
757     es_out_sys_t      *p_sys = out->p_sys;
758     input_thread_t    *p_input = p_sys->p_input;
759     es_out_pgrm_t     *p_pgrm = NULL;
760     char *psz_cat;
761     int i;
762
763     /* Find program */
764     for( i = 0; i < p_sys->i_pgrm; i++ )
765     {
766         if( p_sys->pgrm[i]->i_id == i_group )
767         {
768             p_pgrm = p_sys->pgrm[i];
769             break;
770         }
771     }
772     if( p_pgrm == NULL )
773         p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
774
775     /* Merge EPG */
776     if( !p_pgrm->p_epg )
777         p_pgrm->p_epg = vlc_epg_New( p_pgrm->psz_name );
778     vlc_epg_Merge( p_pgrm->p_epg, p_epg );
779
780     /* Update info */
781     psz_cat = EsOutProgramGetMetaName( p_pgrm );
782 #ifdef HAVE_LOCALTIME_R
783     char *psz_epg;
784     if( asprintf( &psz_epg, "EPG %s", psz_cat ) == -1 )
785         psz_epg = NULL;
786     input_Control( p_input, INPUT_DEL_INFO, psz_epg, NULL );
787     msg_Dbg( p_input, "EsOutProgramEpg: number=%d name=%s", i_group, p_pgrm->p_epg->psz_name );
788     for( i = 0; i < p_pgrm->p_epg->i_event; i++ )
789     {
790         const vlc_epg_event_t *p_evt = p_pgrm->p_epg->pp_event[i];
791         time_t t_start = (time_t)p_evt->i_start;
792         struct tm tm_start;
793         char psz_start[128];
794
795         localtime_r( &t_start, &tm_start );
796
797         snprintf( psz_start, sizeof(psz_start), "%2.2d:%2.2d:%2.2d", tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
798         if( p_evt->psz_short_description || p_evt->psz_description )
799             input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s",
800                            p_evt->psz_name,
801                            p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
802                            p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description );
803         else
804             input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
805                            p_evt->psz_name,
806                            p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
807     }
808     free( psz_epg );
809 #endif
810     /* Update now playing */
811     if( p_pgrm->psz_now_playing )
812         free( p_pgrm->psz_now_playing );
813     p_pgrm->psz_now_playing = NULL;
814     if( p_epg->p_current && p_epg->p_current->psz_name && *p_epg->p_current->psz_name )
815         p_pgrm->psz_now_playing = strdup( p_epg->p_current->psz_name );
816
817     if( p_pgrm == p_sys->p_pgrm )
818         input_item_SetNowPlaying( p_input->p->input.p_item, p_pgrm->psz_now_playing );
819
820     if( p_pgrm->psz_now_playing )
821     {
822         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
823             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying),
824             p_pgrm->psz_now_playing );
825     }
826     else
827     {
828         input_Control( p_input, INPUT_DEL_INFO, psz_cat,
829             input_MetaTypeToLocalizedString(vlc_meta_NowPlaying) );
830     }
831
832     free( psz_cat );
833 }
834
835 /* EsOutAdd:
836  *  Add an es_out
837  */
838 static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt )
839 {
840     es_out_sys_t      *p_sys = out->p_sys;
841     input_thread_t    *p_input = p_sys->p_input;
842
843     es_out_id_t       *es = malloc( sizeof( es_out_id_t ) );
844     es_out_pgrm_t     *p_pgrm = NULL;
845     int i;
846
847     if( fmt->i_group < 0 )
848     {
849         msg_Err( p_input, "invalid group number" );
850         return NULL;
851     }
852
853     /* Search the program */
854     for( i = 0; i < p_sys->i_pgrm; i++ )
855     {
856         if( fmt->i_group == p_sys->pgrm[i]->i_id )
857         {
858             p_pgrm = p_sys->pgrm[i];
859             break;
860         }
861     }
862     if( p_pgrm == NULL )
863     {
864         /* Create a new one */
865         p_pgrm = EsOutProgramAdd( out, fmt->i_group );
866     }
867
868     /* Increase ref count for program */
869     p_pgrm->i_es++;
870
871     /* Set up ES */
872     if( fmt->i_id < 0 )
873         fmt->i_id = out->p_sys->i_id;
874     es->i_id = fmt->i_id;
875     es->p_pgrm = p_pgrm;
876     es_format_Copy( &es->fmt, fmt );
877     es->i_preroll_end = -1;
878
879     switch( fmt->i_cat )
880     {
881     case AUDIO_ES:
882         es->i_channel = p_sys->i_audio;
883         break;
884
885     case VIDEO_ES:
886         es->i_channel = p_sys->i_video;
887         if( fmt->video.i_frame_rate && fmt->video.i_frame_rate_base )
888             vlc_ureduce( &es->fmt.video.i_frame_rate,
889                          &es->fmt.video.i_frame_rate_base,
890                          fmt->video.i_frame_rate,
891                          fmt->video.i_frame_rate_base, 0 );
892         break;
893
894     case SPU_ES:
895         es->i_channel = p_sys->i_sub;
896         break;
897
898     default:
899         es->i_channel = 0;
900         break;
901     }
902     es->psz_language = LanguageGetName( fmt->psz_language ); /* remember so we only need to do it once */
903     es->psz_language_code = LanguageGetCode( fmt->psz_language );
904     es->p_dec = NULL;
905
906     if( es->p_pgrm == p_sys->p_pgrm )
907         EsOutESVarUpdate( out, es, VLC_FALSE );
908
909     /* Select it if needed */
910     EsOutSelect( out, es, VLC_FALSE );
911
912
913     TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es );
914     p_sys->i_id++;  /* always incremented */
915     switch( fmt->i_cat )
916     {
917         case AUDIO_ES:
918             p_sys->i_audio++;
919             break;
920         case SPU_ES:
921             p_sys->i_sub++;
922             break;
923         case VIDEO_ES:
924             p_sys->i_video++;
925             break;
926     }
927
928     EsOutAddInfo( out, es );
929
930     return es;
931 }
932
933 static void EsSelect( es_out_t *out, es_out_id_t *es )
934 {
935     es_out_sys_t   *p_sys = out->p_sys;
936     input_thread_t *p_input = p_sys->p_input;
937     vlc_value_t    val;
938     const char     *psz_var;
939
940     if( es->p_dec )
941     {
942         msg_Warn( p_input, "ES 0x%x is already selected", es->i_id );
943         return;
944     }
945
946     if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES )
947     {
948         if( !var_GetBool( p_input, "video" ) ||
949             ( p_input->p->p_sout && !var_GetBool( p_input, "sout-video" ) ) )
950         {
951             msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x",
952                      es->i_id );
953             return;
954         }
955     }
956     else if( es->fmt.i_cat == AUDIO_ES )
957     {
958         var_Get( p_input, "audio", &val );
959         if( !var_GetBool( p_input, "audio" ) ||
960             ( p_input->p->p_sout && !var_GetBool( p_input, "sout-audio" ) ) )
961         {
962             msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x",
963                      es->i_id );
964             return;
965         }
966     }
967     if( es->fmt.i_cat == SPU_ES )
968     {
969         var_Get( p_input, "spu", &val );
970         if( !var_GetBool( p_input, "spu" ) ||
971             ( p_input->p->p_sout && !var_GetBool( p_input, "sout-spu" ) ) )
972         {
973             msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x",
974                      es->i_id );
975             return;
976         }
977     }
978
979     es->i_preroll_end = -1;
980     es->p_dec = input_DecoderNew( p_input, &es->fmt, VLC_FALSE );
981     if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm )
982         return;
983
984     if( es->fmt.i_cat == VIDEO_ES )
985         psz_var = "video-es";
986     else if( es->fmt.i_cat == AUDIO_ES )
987         psz_var = "audio-es";
988     else if( es->fmt.i_cat == SPU_ES )
989         psz_var = "spu-es";
990     else
991         return;
992
993     /* Mark it as selected */
994     val.i_int = es->i_id;
995     var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL );
996
997
998     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
999 }
1000
1001 static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update )
1002 {
1003     es_out_sys_t   *p_sys = out->p_sys;
1004     input_thread_t *p_input = p_sys->p_input;
1005     vlc_value_t    val;
1006     const char     *psz_var;
1007
1008     if( es->p_dec == NULL )
1009     {
1010         msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id );
1011         return;
1012     }
1013
1014     input_DecoderDelete( es->p_dec );
1015     es->p_dec = NULL;
1016
1017     if( !b_update )
1018         return;
1019
1020     /* Update var */
1021     if( es->p_dec == NULL )
1022         return;
1023     if( es->fmt.i_cat == VIDEO_ES )
1024         psz_var = "video-es";
1025     else if( es->fmt.i_cat == AUDIO_ES )
1026         psz_var = "audio-es";
1027     else if( es->fmt.i_cat == SPU_ES )
1028         psz_var = "spu-es";
1029     else
1030         return;
1031
1032     /* Mark it as selected */
1033     val.i_int = -1;
1034     var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL );
1035
1036     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
1037 }
1038
1039 /**
1040  * Select an ES given the current mode
1041  * XXX: you need to take a the lock before (stream.stream_lock)
1042  *
1043  * \param out The es_out structure
1044  * \param es es_out_id structure
1045  * \param b_force ...
1046  * \return nothing
1047  */
1048 static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force )
1049 {
1050     es_out_sys_t      *p_sys = out->p_sys;
1051
1052     int i_cat = es->fmt.i_cat;
1053
1054     if( !p_sys->b_active ||
1055         ( !b_force && es->fmt.i_priority < 0 ) )
1056     {
1057         return;
1058     }
1059
1060     if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force )
1061     {
1062         if( !es->p_dec )
1063             EsSelect( out, es );
1064     }
1065     else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL )
1066     {
1067         vlc_value_t val;
1068         int i;
1069         var_Get( p_sys->p_input, "programs", &val );
1070         for ( i = 0; i < val.p_list->i_count; i++ )
1071         {
1072             if ( val.p_list->p_values[i].i_int == es->p_pgrm->i_id || b_force )
1073             {
1074                 if( !es->p_dec )
1075                     EsSelect( out, es );
1076                 break;
1077             }
1078         }
1079         var_Change( p_sys->p_input, "programs", VLC_VAR_FREELIST, &val, NULL );
1080     }
1081     else if( p_sys->i_mode == ES_OUT_MODE_AUTO )
1082     {
1083         int i_wanted  = -1;
1084
1085         if( es->p_pgrm != p_sys->p_pgrm )
1086             return;
1087
1088         if( i_cat == AUDIO_ES )
1089         {
1090             int idx1 = LanguageArrayIndex( p_sys->ppsz_audio_language,
1091                                      es->psz_language_code );
1092
1093             if( p_sys->p_es_audio &&
1094                 p_sys->p_es_audio->fmt.i_priority >= es->fmt.i_priority )
1095             {
1096                 int idx2 = LanguageArrayIndex( p_sys->ppsz_audio_language,
1097                                          p_sys->p_es_audio->psz_language_code );
1098
1099                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
1100                     return;
1101                 i_wanted = es->i_channel;
1102             }
1103             else
1104             {
1105                 /* Select audio if (no audio selected yet)
1106                  * - no audio-language
1107                  * - no audio code for the ES
1108                  * - audio code in the requested list */
1109                 if( idx1 >= 0 ||
1110                     !strcmp( es->psz_language_code, "??" ) ||
1111                     !p_sys->ppsz_audio_language )
1112                     i_wanted = es->i_channel;
1113             }
1114
1115             if( p_sys->i_audio_last >= 0 )
1116                 i_wanted = p_sys->i_audio_last;
1117
1118             if( p_sys->i_audio_id >= 0 )
1119             {
1120                 if( es->i_id == p_sys->i_audio_id )
1121                     i_wanted = es->i_channel;
1122                 else
1123                     return;
1124             }
1125         }
1126         else if( i_cat == SPU_ES )
1127         {
1128             int idx1 = LanguageArrayIndex( p_sys->ppsz_sub_language,
1129                                      es->psz_language_code );
1130
1131             if( p_sys->p_es_sub &&
1132                 p_sys->p_es_sub->fmt.i_priority >= es->fmt.i_priority )
1133             {
1134                 int idx2 = LanguageArrayIndex( p_sys->ppsz_sub_language,
1135                                          p_sys->p_es_sub->psz_language_code );
1136
1137                 msg_Dbg( p_sys->p_input, "idx1=%d(%s) idx2=%d(%s)",
1138                         idx1, es->psz_language_code, idx2,
1139                         p_sys->p_es_sub->psz_language_code );
1140
1141                 if( idx1 < 0 || ( idx2 >= 0 && idx2 <= idx1 ) )
1142                     return;
1143                 /* We found a SPU that matches our language request */
1144                 i_wanted  = es->i_channel;
1145             }
1146             else if( idx1 >= 0 )
1147             {
1148                 msg_Dbg( p_sys->p_input, "idx1=%d(%s)",
1149                         idx1, es->psz_language_code );
1150
1151                 i_wanted  = es->i_channel;
1152             }
1153             else if( p_sys->i_default_sub_id >= 0 )
1154             {
1155                 if( es->i_id == p_sys->i_default_sub_id )
1156                     i_wanted = es->i_channel;
1157             }
1158
1159             if( p_sys->i_sub_last >= 0 )
1160                 i_wanted  = p_sys->i_sub_last;
1161
1162             if( p_sys->i_sub_id >= 0 )
1163             {
1164                 if( es->i_id == p_sys->i_sub_id )
1165                     i_wanted = es->i_channel;
1166                 else
1167                     return;
1168             }
1169         }
1170         else if( i_cat == VIDEO_ES )
1171         {
1172             i_wanted  = es->i_channel;
1173         }
1174
1175         if( i_wanted == es->i_channel && es->p_dec == NULL )
1176             EsSelect( out, es );
1177     }
1178
1179     /* FIXME TODO handle priority here */
1180     if( es->p_dec )
1181     {
1182         if( i_cat == AUDIO_ES )
1183         {
1184             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
1185                 p_sys->p_es_audio &&
1186                 p_sys->p_es_audio != es &&
1187                 p_sys->p_es_audio->p_dec )
1188             {
1189                 EsUnselect( out, p_sys->p_es_audio, VLC_FALSE );
1190             }
1191             p_sys->p_es_audio = es;
1192         }
1193         else if( i_cat == SPU_ES )
1194         {
1195             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
1196                 p_sys->p_es_sub &&
1197                 p_sys->p_es_sub != es &&
1198                 p_sys->p_es_sub->p_dec )
1199             {
1200                 EsUnselect( out, p_sys->p_es_sub, VLC_FALSE );
1201             }
1202             p_sys->p_es_sub = es;
1203         }
1204         else if( i_cat == VIDEO_ES )
1205         {
1206             p_sys->p_es_video = es;
1207         }
1208     }
1209 }
1210
1211 /**
1212  * Send a block for the given es_out
1213  *
1214  * \param out the es_out to send from
1215  * \param es the es_out_id
1216  * \param p_block the data block to send
1217  */
1218 static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
1219 {
1220     es_out_sys_t *p_sys = out->p_sys;
1221     input_thread_t    *p_input = p_sys->p_input;
1222     es_out_pgrm_t *p_pgrm = es->p_pgrm;
1223     int64_t i_delay;
1224     int i_total=0;
1225
1226     if( es->fmt.i_cat == AUDIO_ES )
1227         i_delay = p_sys->i_audio_delay;
1228     else if( es->fmt.i_cat == SPU_ES )
1229         i_delay = p_sys->i_spu_delay;
1230     else
1231         i_delay = 0;
1232
1233     if( p_input->p_libvlc->b_stats )
1234     {
1235         vlc_mutex_lock( &p_input->p->counters.counters_lock );
1236         stats_UpdateInteger( p_input, p_input->p->counters.p_demux_read,
1237                              p_block->i_buffer, &i_total );
1238         stats_UpdateFloat( p_input , p_input->p->counters.p_demux_bitrate,
1239                            (float)i_total, NULL );
1240         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1241     }
1242
1243     /* Mark preroll blocks */
1244     if( es->i_preroll_end >= 0 )
1245     {
1246         int64_t i_date = p_block->i_pts;
1247         if( i_date <= 0 )
1248             i_date = p_block->i_dts;
1249
1250         if( i_date < es->i_preroll_end )
1251             p_block->i_flags |= BLOCK_FLAG_PREROLL;
1252         else
1253             es->i_preroll_end = -1;
1254     }
1255
1256     if( p_block->i_dts > 0 && (p_block->i_flags&BLOCK_FLAG_PREROLL) )
1257     {
1258         p_block->i_dts += i_delay;
1259     }
1260     else if( p_block->i_dts > 0 )
1261     {
1262         p_block->i_dts =
1263             input_ClockGetTS( p_input, &p_pgrm->clock, p_block->i_dts ) + i_delay;
1264     }
1265     if( p_block->i_pts > 0 && (p_block->i_flags&BLOCK_FLAG_PREROLL) )
1266     {
1267         p_block->i_pts += i_delay;
1268     }
1269     else if( p_block->i_pts > 0 )
1270     {
1271         p_block->i_pts =
1272             input_ClockGetTS( p_input, &p_pgrm->clock, p_block->i_pts ) + i_delay;
1273     }
1274     if ( es->fmt.i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' ) )
1275     {
1276         mtime_t current_date = mdate();
1277         if( !p_block->i_pts
1278                || p_block->i_pts > current_date + 10000000
1279                || current_date > p_block->i_pts )
1280         {
1281             /* ETSI EN 300 472 Annex A : do not take into account the PTS
1282              * for teletext streams. */
1283             p_block->i_pts = current_date + 400000
1284                                + p_input->i_pts_delay + i_delay;
1285         }
1286     }
1287
1288     p_block->i_rate = p_input->p->i_rate;
1289
1290     /* TODO handle mute */
1291     if( es->p_dec &&
1292         ( es->fmt.i_cat != AUDIO_ES ||
1293           ( p_input->p->i_rate >= INPUT_RATE_DEFAULT/AOUT_MAX_INPUT_RATE &&
1294             p_input->p->i_rate <= INPUT_RATE_DEFAULT*AOUT_MAX_INPUT_RATE ) ) )
1295     {
1296         input_DecoderDecode( es->p_dec, p_block );
1297     }
1298     else
1299     {
1300         block_Release( p_block );
1301     }
1302
1303     return VLC_SUCCESS;
1304 }
1305
1306 /*****************************************************************************
1307  * EsOutDel:
1308  *****************************************************************************/
1309 static void EsOutDel( es_out_t *out, es_out_id_t *es )
1310 {
1311     es_out_sys_t *p_sys = out->p_sys;
1312     vlc_bool_t b_reselect = VLC_FALSE;
1313     int i;
1314
1315     /* We don't try to reselect */
1316     if( es->p_dec )
1317     {
1318         while( !out->p_sys->p_input->b_die && es->p_dec )
1319         {
1320             if( input_DecoderEmpty( es->p_dec ) )
1321                 break;
1322             msleep( 20*1000 );
1323         }
1324         EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
1325     }
1326
1327     if( es->p_pgrm == p_sys->p_pgrm )
1328         EsOutESVarUpdate( out, es, VLC_TRUE );
1329
1330     TAB_REMOVE( p_sys->i_es, p_sys->es, es );
1331
1332     es->p_pgrm->i_es--;
1333     if( es->p_pgrm->i_es == 0 )
1334     {
1335         msg_Dbg( p_sys->p_input, "Program doesn't contain anymore ES" );
1336     }
1337
1338     if( p_sys->p_es_audio == es || p_sys->p_es_video == es ||
1339         p_sys->p_es_sub == es ) b_reselect = VLC_TRUE;
1340
1341     if( p_sys->p_es_audio == es ) p_sys->p_es_audio = NULL;
1342     if( p_sys->p_es_video == es ) p_sys->p_es_video = NULL;
1343     if( p_sys->p_es_sub   == es ) p_sys->p_es_sub   = NULL;
1344
1345     switch( es->fmt.i_cat )
1346     {
1347         case AUDIO_ES:
1348             p_sys->i_audio--;
1349             break;
1350         case SPU_ES:
1351             p_sys->i_sub--;
1352             break;
1353         case VIDEO_ES:
1354             p_sys->i_video--;
1355             break;
1356     }
1357
1358     /* Re-select another track when needed */
1359     if( b_reselect )
1360         for( i = 0; i < p_sys->i_es; i++ )
1361         {
1362             if( es->fmt.i_cat == p_sys->es[i]->fmt.i_cat )
1363                 EsOutSelect( out, p_sys->es[i], VLC_FALSE );
1364         }
1365
1366     if( es->psz_language )
1367         free( es->psz_language );
1368     if( es->psz_language_code )
1369         free( es->psz_language_code );
1370
1371     es_format_Clean( &es->fmt );
1372
1373     free( es );
1374 }
1375
1376 /**
1377  * Control query handler
1378  *
1379  * \param out the es_out to control
1380  * \param i_query A es_out query as defined in include/ninput.h
1381  * \param args a variable list of arguments for the query
1382  * \return VLC_SUCCESS or an error code
1383  */
1384 static int EsOutControl( es_out_t *out, int i_query, va_list args )
1385 {
1386     es_out_sys_t *p_sys = out->p_sys;
1387     vlc_bool_t  b, *pb;
1388     int         i, *pi;
1389
1390     es_out_id_t *es;
1391
1392     switch( i_query )
1393     {
1394         case ES_OUT_SET_ES_STATE:
1395             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1396             b = (vlc_bool_t) va_arg( args, vlc_bool_t );
1397             if( b && es->p_dec == NULL )
1398             {
1399                 EsSelect( out, es );
1400                 return es->p_dec ? VLC_SUCCESS : VLC_EGENERIC;
1401             }
1402             else if( !b && es->p_dec )
1403             {
1404                 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
1405                 return VLC_SUCCESS;
1406             }
1407             return VLC_SUCCESS;
1408
1409         case ES_OUT_GET_ES_STATE:
1410             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1411             pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * );
1412
1413             *pb = es->p_dec ? VLC_TRUE : VLC_FALSE;
1414             return VLC_SUCCESS;
1415
1416         case ES_OUT_SET_ACTIVE:
1417         {
1418             b = (vlc_bool_t) va_arg( args, vlc_bool_t );
1419             p_sys->b_active = b;
1420             /* Needed ? */
1421             if( b )
1422                 var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
1423             return VLC_SUCCESS;
1424         }
1425
1426         case ES_OUT_GET_ACTIVE:
1427             pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * );
1428             *pb = p_sys->b_active;
1429             return VLC_SUCCESS;
1430
1431         case ES_OUT_SET_MODE:
1432             i = (int) va_arg( args, int );
1433             if( i == ES_OUT_MODE_NONE || i == ES_OUT_MODE_ALL ||
1434                 i == ES_OUT_MODE_AUTO || i == ES_OUT_MODE_PARTIAL )
1435             {
1436                 p_sys->i_mode = i;
1437
1438                 /* Reapply policy mode */
1439                 for( i = 0; i < p_sys->i_es; i++ )
1440                 {
1441                     if( p_sys->es[i]->p_dec )
1442                     {
1443                         EsUnselect( out, p_sys->es[i],
1444                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1445                     }
1446                 }
1447                 for( i = 0; i < p_sys->i_es; i++ )
1448                 {
1449                     EsOutSelect( out, p_sys->es[i], VLC_FALSE );
1450                 }
1451                 return VLC_SUCCESS;
1452             }
1453             return VLC_EGENERIC;
1454
1455         case ES_OUT_GET_MODE:
1456             pi = (int*) va_arg( args, int* );
1457             *pi = p_sys->i_mode;
1458             return VLC_SUCCESS;
1459
1460         case ES_OUT_SET_ES:
1461             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1462             /* Special case NULL, NULL+i_cat */
1463             if( es == NULL )
1464             {
1465                 for( i = 0; i < p_sys->i_es; i++ )
1466                 {
1467                     if( p_sys->es[i]->p_dec )
1468                         EsUnselect( out, p_sys->es[i],
1469                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1470                 }
1471             }
1472             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
1473             {
1474                 for( i = 0; i < p_sys->i_es; i++ )
1475                 {
1476                     if( p_sys->es[i]->p_dec &&
1477                         p_sys->es[i]->fmt.i_cat == AUDIO_ES )
1478                         EsUnselect( out, p_sys->es[i],
1479                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1480                 }
1481             }
1482             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
1483             {
1484                 for( i = 0; i < p_sys->i_es; i++ )
1485                 {
1486                     if( p_sys->es[i]->p_dec &&
1487                         p_sys->es[i]->fmt.i_cat == VIDEO_ES )
1488                         EsUnselect( out, p_sys->es[i],
1489                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1490                 }
1491             }
1492             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
1493             {
1494                 for( i = 0; i < p_sys->i_es; i++ )
1495                 {
1496                     if( p_sys->es[i]->p_dec &&
1497                         p_sys->es[i]->fmt.i_cat == SPU_ES )
1498                         EsUnselect( out, p_sys->es[i],
1499                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
1500                 }
1501             }
1502             else
1503             {
1504                 for( i = 0; i < p_sys->i_es; i++ )
1505                 {
1506                     if( es == p_sys->es[i] )
1507                     {
1508                         EsOutSelect( out, es, VLC_TRUE );
1509                         break;
1510                     }
1511                 }
1512             }
1513             {
1514                 playlist_t * p_playlist = pl_Yield( p_sys->p_input );
1515                 PL_LOCK;
1516                 p_playlist->gc_date = mdate();
1517                 vlc_object_signal_unlocked( p_playlist );
1518                 PL_UNLOCK;
1519                 pl_Release( p_playlist );
1520             }
1521             return VLC_SUCCESS;
1522  
1523         case ES_OUT_SET_DEFAULT:
1524         {
1525             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1526
1527             if( es == NULL )
1528             {
1529                 /*p_sys->i_default_video_id = -1;*/
1530                 /*p_sys->i_default_audio_id = -1;*/
1531                 p_sys->i_default_sub_id = -1;
1532             }
1533             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
1534             {
1535                 /*p_sys->i_default_video_id = -1;*/
1536             }
1537             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
1538             {
1539                 /*p_sys->i_default_audio_id = -1;*/
1540             }
1541             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
1542             {
1543                 p_sys->i_default_sub_id = -1;
1544             }
1545             else
1546             {
1547                 /*if( es->fmt.i_cat == VIDEO_ES )
1548                     p_sys->i_default_video_id = es->i_id;
1549                 else
1550                 if( es->fmt.i_cat == AUDIO_ES )
1551                     p_sys->i_default_audio_id = es->i_id;
1552                 else*/
1553                 if( es->fmt.i_cat == SPU_ES )
1554                     p_sys->i_default_sub_id = es->i_id;
1555             }
1556             return VLC_SUCCESS;
1557         }
1558
1559         case ES_OUT_SET_PCR:
1560         case ES_OUT_SET_GROUP_PCR:
1561         {
1562             es_out_pgrm_t *p_pgrm = NULL;
1563             int            i_group = 0;
1564             int64_t        i_pcr;
1565
1566             if( i_query == ES_OUT_SET_PCR )
1567             {
1568                 p_pgrm = p_sys->p_pgrm;
1569             }
1570             else
1571             {
1572                 int i;
1573                 i_group = (int)va_arg( args, int );
1574                 for( i = 0; i < p_sys->i_pgrm; i++ )
1575                 {
1576                     if( p_sys->pgrm[i]->i_id == i_group )
1577                     {
1578                         p_pgrm = p_sys->pgrm[i];
1579                         break;
1580                     }
1581                 }
1582             }
1583             if( p_pgrm == NULL )
1584                 p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
1585
1586             i_pcr = (int64_t)va_arg( args, int64_t );
1587             /* search program */
1588             input_ClockSetPCR( p_sys->p_input, &p_pgrm->clock, i_pcr );
1589             return VLC_SUCCESS;
1590         }
1591
1592         case ES_OUT_RESET_PCR:
1593             for( i = 0; i < p_sys->i_pgrm; i++ )
1594             {
1595                 p_sys->pgrm[i]->clock.i_synchro_state =  SYNCHRO_REINIT;
1596                 p_sys->pgrm[i]->clock.last_pts = 0;
1597             }
1598             return VLC_SUCCESS;
1599
1600         case ES_OUT_GET_TS:
1601             if( p_sys->p_pgrm )
1602             {
1603                 int64_t i_ts = (int64_t)va_arg( args, int64_t );
1604                 int64_t *pi_ts = (int64_t *)va_arg( args, int64_t * );
1605                 *pi_ts = input_ClockGetTS( p_sys->p_input,
1606                                            &p_sys->p_pgrm->clock, i_ts );
1607                 return VLC_SUCCESS;
1608             }
1609             return VLC_EGENERIC;
1610
1611         case ES_OUT_GET_GROUP:
1612             pi = (int*) va_arg( args, int* );
1613             if( p_sys->p_pgrm )
1614                 *pi = p_sys->p_pgrm->i_id;
1615             else
1616                 *pi = -1;    /* FIXME */
1617             return VLC_SUCCESS;
1618
1619         case ES_OUT_SET_GROUP:
1620         {
1621             int j;
1622             i = (int) va_arg( args, int );
1623             for( j = 0; j < p_sys->i_pgrm; j++ )
1624             {
1625                 es_out_pgrm_t *p_pgrm = p_sys->pgrm[j];
1626                 if( p_pgrm->i_id == i )
1627                 {
1628                     EsOutProgramSelect( out, p_pgrm );
1629                     return VLC_SUCCESS;
1630                 }
1631             }
1632             return VLC_EGENERIC;
1633         }
1634
1635         case ES_OUT_SET_FMT:
1636         {
1637             /* This ain't pretty but is need by some demuxers (eg. Ogg )
1638              * to update the p_extra data */
1639             es_format_t *p_fmt;
1640             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1641             p_fmt = (es_format_t*) va_arg( args, es_format_t * );
1642             if( es == NULL ) return VLC_EGENERIC;
1643
1644             if( p_fmt->i_extra )
1645             {
1646                 es->fmt.i_extra = p_fmt->i_extra;
1647                 es->fmt.p_extra = realloc( es->fmt.p_extra, p_fmt->i_extra );
1648                 memcpy( es->fmt.p_extra, p_fmt->p_extra, p_fmt->i_extra );
1649
1650                 if( !es->p_dec ) return VLC_SUCCESS;
1651
1652 #if 1
1653                 input_DecoderDelete( es->p_dec );
1654                 es->p_dec = input_DecoderNew( p_sys->p_input,
1655                                               &es->fmt, VLC_FALSE );
1656
1657 #else
1658                 es->p_dec->fmt_in.i_extra = p_fmt->i_extra;
1659                 es->p_dec->fmt_in.p_extra =
1660                     realloc( es->p_dec->fmt_in.p_extra, p_fmt->i_extra );
1661                 memcpy( es->p_dec->fmt_in.p_extra,
1662                         p_fmt->p_extra, p_fmt->i_extra );
1663 #endif
1664             }
1665
1666             return VLC_SUCCESS;
1667         }
1668
1669         case ES_OUT_SET_NEXT_DISPLAY_TIME:
1670         {
1671             int64_t i_date;
1672
1673             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
1674             i_date = (int64_t)va_arg( args, int64_t );
1675
1676             if( !es || !es->p_dec )
1677                 return VLC_EGENERIC;
1678
1679             /* XXX We should call input_ClockGetTS but PCR has been reseted
1680              * and it will return 0, so we won't call input_ClockGetTS on all preroll samples
1681              * but that's ugly(more time discontinuity), it need to be improved -- fenrir */
1682             es->i_preroll_end = i_date;
1683
1684             return VLC_SUCCESS;
1685         }
1686         case ES_OUT_SET_GROUP_META:
1687         {
1688             int i_group = (int)va_arg( args, int );
1689             vlc_meta_t *p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t * );
1690
1691             EsOutProgramMeta( out, i_group, p_meta );
1692             return VLC_SUCCESS;
1693         }
1694         case ES_OUT_SET_GROUP_EPG:
1695         {
1696             int i_group = (int)va_arg( args, int );
1697             vlc_epg_t *p_epg = (vlc_epg_t*)va_arg( args, vlc_epg_t * );
1698
1699             EsOutProgramEpg( out, i_group, p_epg );
1700             return VLC_SUCCESS;
1701         }
1702         case ES_OUT_DEL_GROUP:
1703         {
1704             int i_group = (int)va_arg( args, int );
1705
1706             return EsOutProgramDel( out, i_group );
1707         }
1708
1709         default:
1710             msg_Err( p_sys->p_input, "unknown query in es_out_Control" );
1711             return VLC_EGENERIC;
1712     }
1713 }
1714
1715 /****************************************************************************
1716  * LanguageGetName: try to expend iso639 into plain name
1717  ****************************************************************************/
1718 static char *LanguageGetName( const char *psz_code )
1719 {
1720     const iso639_lang_t *pl;
1721
1722     if( psz_code == NULL )
1723     {
1724         return strdup( "" );
1725     }
1726
1727     if( strlen( psz_code ) == 2 )
1728     {
1729         pl = GetLang_1( psz_code );
1730     }
1731     else if( strlen( psz_code ) == 3 )
1732     {
1733         pl = GetLang_2B( psz_code );
1734         if( !strcmp( pl->psz_iso639_1, "??" ) )
1735         {
1736             pl = GetLang_2T( psz_code );
1737         }
1738     }
1739     else
1740     {
1741         return strdup( psz_code );
1742     }
1743
1744     if( !strcmp( pl->psz_iso639_1, "??" ) )
1745     {
1746        return strdup( psz_code );
1747     }
1748     else
1749     {
1750         if( *pl->psz_native_name )
1751         {
1752             return strdup( pl->psz_native_name );
1753         }
1754         return strdup( pl->psz_eng_name );
1755     }
1756 }
1757
1758 /* Get a 2 char code */
1759 static char *LanguageGetCode( const char *psz_lang )
1760 {
1761     const iso639_lang_t *pl;
1762
1763     if( psz_lang == NULL || *psz_lang == '\0' )
1764         return strdup("??");
1765
1766     for( pl = p_languages; pl->psz_iso639_1 != NULL; pl++ )
1767     {
1768         if( !strcasecmp( pl->psz_eng_name, psz_lang ) ||
1769             !strcasecmp( pl->psz_native_name, psz_lang ) ||
1770             !strcasecmp( pl->psz_iso639_1, psz_lang ) ||
1771             !strcasecmp( pl->psz_iso639_2T, psz_lang ) ||
1772             !strcasecmp( pl->psz_iso639_2B, psz_lang ) )
1773             break;
1774     }
1775
1776     if( pl->psz_iso639_1 != NULL )
1777         return strdup( pl->psz_iso639_1 );
1778
1779     return strdup("??");
1780 }
1781
1782 static char **LanguageSplit( const char *psz_langs )
1783 {
1784     char *psz_dup;
1785     char *psz_parser;
1786     char **ppsz = NULL;
1787     int i_psz = 0;
1788
1789     if( psz_langs == NULL ) return NULL;
1790
1791     psz_parser = psz_dup = strdup(psz_langs);
1792
1793     while( psz_parser && *psz_parser )
1794     {
1795         char *psz;
1796         char *psz_code;
1797
1798         psz = strchr(psz_parser, ',' );
1799         if( psz ) *psz++ = '\0';
1800
1801         psz_code = LanguageGetCode( psz_parser );
1802         if( strcmp( psz_code, "??" ) )
1803         {
1804             TAB_APPEND( i_psz, ppsz, psz_code );
1805         }
1806
1807         psz_parser = psz;
1808     }
1809
1810     if( i_psz )
1811     {
1812         TAB_APPEND( i_psz, ppsz, NULL );
1813     }
1814
1815     free( psz_dup );
1816     return ppsz;
1817 }
1818
1819 static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang )
1820 {
1821     int i;
1822
1823     if( !ppsz_langs || !psz_lang ) return -1;
1824
1825     for( i = 0; ppsz_langs[i]; i++ )
1826         if( !strcasecmp( ppsz_langs[i], psz_lang ) ) return i;
1827
1828     return -1;
1829 }
1830
1831 /****************************************************************************
1832  * EsOutAddInfo:
1833  * - add meta info to the playlist item
1834  ****************************************************************************/
1835 static void EsOutAddInfo( es_out_t *out, es_out_id_t *es )
1836 {
1837     es_out_sys_t   *p_sys = out->p_sys;
1838     input_thread_t *p_input = p_sys->p_input;
1839     es_format_t    *fmt = &es->fmt;
1840     char           *psz_cat;
1841     lldiv_t         div;
1842
1843     /* Add stream info */
1844     asprintf( &psz_cat, _("Stream %d"), out->p_sys->i_id - 1 );
1845
1846     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Codec"),
1847                    "%.4s", (char*)&fmt->i_codec );
1848
1849     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"),
1850                    "%s", es->psz_language );
1851
1852     /* Add information */
1853     switch( fmt->i_cat )
1854     {
1855     case AUDIO_ES:
1856         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1857                        _("Type"), _("Audio") );
1858
1859         if( fmt->audio.i_channels > 0 )
1860             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
1861                            "%u", fmt->audio.i_channels );
1862
1863         if( fmt->audio.i_rate > 0 )
1864         {
1865             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"),
1866                            _("%u Hz"), fmt->audio.i_rate );
1867             var_SetInteger( p_input, "sample-rate", fmt->audio.i_rate );
1868         }
1869
1870         if( fmt->audio.i_bitspersample > 0 )
1871             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1872                            _("Bits per sample"), "%u",
1873                            fmt->audio.i_bitspersample );
1874
1875         if( fmt->i_bitrate > 0 )
1876         {
1877             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"),
1878                            _("%u kb/s"), fmt->i_bitrate / 1000 );
1879             var_SetInteger( p_input, "bit-rate", fmt->i_bitrate );
1880         }
1881         break;
1882
1883     case VIDEO_ES:
1884         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1885                        _("Type"), _("Video") );
1886
1887         if( fmt->video.i_width > 0 && fmt->video.i_height > 0 )
1888             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1889                            _("Resolution"), "%ux%u",
1890                            fmt->video.i_width, fmt->video.i_height );
1891
1892         if( fmt->video.i_visible_width > 0 &&
1893             fmt->video.i_visible_height > 0 )
1894             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1895                            _("Display resolution"), "%ux%u",
1896                            fmt->video.i_visible_width,
1897                            fmt->video.i_visible_height);
1898        if( fmt->video.i_frame_rate > 0 &&
1899            fmt->video.i_frame_rate_base > 0 )
1900        {
1901            div = lldiv( (float)fmt->video.i_frame_rate /
1902                                fmt->video.i_frame_rate_base * 1000000,
1903                                1000000 );
1904            input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1905                           _("Frame rate"), I64Fd".%06u",
1906                           div.quot, (unsigned int )div.rem );
1907        }
1908        break;
1909
1910     case SPU_ES:
1911         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1912                        _("Type"), _("Subtitle") );
1913         break;
1914
1915     default:
1916         break;
1917     }
1918
1919     free( psz_cat );
1920 }