?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
es_out: add ES_OUT_UNSET_ES
[vlc.git] / src / input / es_out.c
blob948bb4407f53196132d3bb12acb8d48b8632f716
1 /*****************************************************************************
2 * es_out.c: Es Out handler for input.
3 *****************************************************************************
4 * Copyright (C) 2003-2004 VLC authors and VideoLAN
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 it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * 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 #include <vlc_fourcc.h>
41 #include <vlc_meta.h>
42 #include <vlc_list.h>
43
44 #include "input_internal.h"
45 #include "../clock/input_clock.h"
46 #include "decoder.h"
47 #include "es_out.h"
48 #include "event.h"
49 #include "info.h"
50 #include "item.h"
51
52 #include "../stream_output/stream_output.h"
53
54 #include <vlc_iso_lang.h>
55 /* FIXME we should find a better way than including that */
56 #include "../text/iso-639_def.h"
57
58 /*****************************************************************************
59 * Local prototypes
60 *****************************************************************************/
61 typedef struct
62 {
63 /* Program ID */
64 int i_id;
65
66 /* Number of es for this pgrm */
67 int i_es;
68
69 bool b_selected;
70 bool b_scrambled;
71
72 /* Clock for this program */
73 input_clock_t *p_input_clock;
74
75 vlc_meta_t *p_meta;
76 struct vlc_list node;
77 } es_out_pgrm_t;
78
79 struct es_out_id_t
80 {
81 /* ES ID */
82 int i_id;
83 es_out_pgrm_t *p_pgrm;
84
85 /* */
86 bool b_scrambled;
87 bool b_forced; /* if true, bypass variables when selecting this track */
88
89 /* Channel in the track type */
90 int i_channel;
91 es_format_t fmt;
92 char *psz_language;
93 char *psz_language_code;
94
95 decoder_t *p_dec;
96 decoder_t *p_dec_record;
97
98 /* Fields for Video with CC */
99 struct
100 {
101 vlc_fourcc_t type;
102 uint64_t i_bitmap; /* channels bitmap */
103 es_out_id_t *pp_es[64]; /* a max of 64 chans for CEA708 */
104 } cc;
105
106 /* Field for CC track from a master video */
107 es_out_id_t *p_master;
108
109 /* ID for the meta data */
110 int i_meta_id;
111
112 struct vlc_list node;
113 };
114
115 typedef struct
116 {
117 int i_count; /* es count */
118 es_out_id_t *p_main_es; /* current main es */
119 enum es_out_policy_e e_policy;
120
121 /* Parameters used for es selection */
122 bool b_autoselect; /* if we want to select an es when no user prefs */
123 int i_id; /* es id as set by es fmt.id */
124 int i_demux_id; /* same as previous, demuxer set default value */
125 int i_channel; /* es number in creation order */
126 char **ppsz_language;
127 } es_out_es_props_t;
128
129 typedef struct
130 {
131 input_thread_t *p_input;
132
133 /* */
134 vlc_mutex_t lock;
135
136 /* all programs */
137 struct vlc_list programs;
138 es_out_pgrm_t *p_pgrm; /* Master program */
139
140 /* all es */
141 int i_id;
142 struct vlc_list es;
143 struct vlc_list es_slaves; /* Dynamically created es on regular es selection */
144
145 /* mode gestion */
146 bool b_active;
147 int i_mode;
148
149 es_out_es_props_t video, audio, sub;
150
151 /* es/group to select */
152 int i_group_id;
153
154 /* delay */
155 vlc_tick_t i_audio_delay;
156 vlc_tick_t i_spu_delay;
157
158 /* Clock configuration */
159 vlc_tick_t i_pts_delay;
160 vlc_tick_t i_pts_jitter;
161 int i_cr_average;
162 int i_rate;
163
164 /* */
165 bool b_paused;
166 vlc_tick_t i_pause_date;
167
168 /* Current preroll */
169 vlc_tick_t i_preroll_end;
170
171 /* Used for buffering */
172 bool b_buffering;
173 vlc_tick_t i_buffering_extra_initial;
174 vlc_tick_t i_buffering_extra_stream;
175 vlc_tick_t i_buffering_extra_system;
176
177 /* Record */
178 sout_instance_t *p_sout_record;
179
180 /* Used only to limit debugging output */
181 int i_prev_stream_level;
182
183 es_out_t out;
184 } es_out_sys_t;
185
186 static void EsOutDelLocked( es_out_t *, es_out_id_t * );
187 static void EsOutDel ( es_out_t *, es_out_id_t * );
188
189 static void EsOutTerminate( es_out_t * );
190 static void EsOutSelect( es_out_t *, es_out_id_t *es, bool b_force );
191 static void EsOutUpdateInfo( es_out_t *, es_out_id_t *es, const es_format_t *, const vlc_meta_t * );
192 static int EsOutSetRecord( es_out_t *, bool b_record );
193
194 static bool EsIsSelected( es_out_id_t *es );
195 static void EsSelect( es_out_t *out, es_out_id_t *es );
196 static void EsDeleteInfo( es_out_t *, es_out_id_t *es );
197 static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update );
198 static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es );
199 static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date );
200 static void EsOutProgramChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date );
201 static void EsOutProgramsChangeRate( es_out_t *out );
202 static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced );
203 static void EsOutGlobalMeta( es_out_t *p_out, const vlc_meta_t *p_meta );
204 static void EsOutMeta( es_out_t *p_out, const vlc_meta_t *p_meta, const vlc_meta_t *p_progmeta );
205
206 static char *LanguageGetName( const char *psz_code );
207 static char *LanguageGetCode( const char *psz_lang );
208 static char **LanguageSplit( const char *psz_langs );
209 static int LanguageArrayIndex( char **ppsz_langs, const char *psz_lang );
210
211 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm );
212 static char *EsInfoCategoryName( es_out_id_t* es );
213
214 static inline int EsOutGetClosedCaptionsChannel( const es_format_t *p_fmt )
215 {
216 int i_channel;
217 if( p_fmt->i_codec == VLC_CODEC_CEA608 && p_fmt->subs.cc.i_channel < 4 )
218 i_channel = p_fmt->subs.cc.i_channel;
219 else if( p_fmt->i_codec == VLC_CODEC_CEA708 && p_fmt->subs.cc.i_channel < 64 )
220 i_channel = p_fmt->subs.cc.i_channel;
221 else
222 i_channel = -1;
223 return i_channel;
224 }
225 static inline bool EsFmtIsTeletext( const es_format_t *p_fmt )
226 {
227 return p_fmt->i_cat == SPU_ES && p_fmt->i_codec == VLC_CODEC_TELETEXT;
228 }
229
230 #define foreach_es_then_es_slaves( pos ) \
231 for( int fetes_i=0; fetes_i<2; fetes_i++ ) \
232 vlc_list_foreach( pos, (!fetes_i ? &p_sys->es : &p_sys->es_slaves), node )
233
234
235 /*****************************************************************************
236 * Es category specific structs
237 *****************************************************************************/
238 static es_out_es_props_t * GetPropsByCat( es_out_sys_t *p_sys, int i_cat )
239 {
240 switch( i_cat )
241 {
242 case AUDIO_ES:
243 return &p_sys->audio;
244 case SPU_ES:
245 return &p_sys->sub;
246 case VIDEO_ES:
247 return &p_sys->video;
248 }
249 return NULL;
250 }
251
252 static void EsOutPropsCleanup( es_out_es_props_t *p_props )
253 {
254 if( p_props->ppsz_language )
255 {
256 for( int i = 0; p_props->ppsz_language[i]; i++ )
257 free( p_props->ppsz_language[i] );
258 free( p_props->ppsz_language );
259 }
260 }
261
262 static void EsOutPropsInit( es_out_es_props_t *p_props,
263 bool autoselect,
264 input_thread_t *p_input,
265 enum es_out_policy_e e_default_policy,
266 const char *psz_trackidvar,
267 const char *psz_trackvar,
268 const char *psz_langvar,
269 const char *psz_debug )
270 {
271 p_props->e_policy = e_default_policy;
272 p_props->i_count = 0;
273 p_props->b_autoselect = autoselect;
274 p_props->i_id = (psz_trackidvar) ? var_GetInteger( p_input, psz_trackidvar ): -1;
275 p_props->i_channel = (psz_trackvar) ? var_GetInteger( p_input, psz_trackvar ): -1;
276 p_props->i_demux_id = -1;
277 p_props->p_main_es = NULL;
278
279 if( !input_priv(p_input)->b_preparsing && psz_langvar )
280 {
281 char *psz_string = var_GetString( p_input, psz_langvar );
282 p_props->ppsz_language = LanguageSplit( psz_string );
283 if( p_props->ppsz_language )
284 {
285 for( int i = 0; p_props->ppsz_language[i]; i++ )
286 msg_Dbg( p_input, "selected %s language[%d] %s",
287 psz_debug, i, p_props->ppsz_language[i] );
288 }
289 free( psz_string );
290 }
291 }
292
293 static const struct es_out_callbacks es_out_cbs;
294
295 /*****************************************************************************
296 * input_EsOutNew:
297 *****************************************************************************/
298 es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate )
299 {
300 es_out_sys_t *p_sys = calloc( 1, sizeof( *p_sys ) );
301 if( !p_sys )
302 return NULL;
303
304 p_sys->out.cbs = &es_out_cbs;
305
306 vlc_mutex_init( &p_sys->lock );
307 p_sys->p_input = p_input;
308
309 p_sys->b_active = false;
310 p_sys->i_mode = ES_OUT_MODE_NONE;
311
312 vlc_list_init(&p_sys->programs);
313 vlc_list_init(&p_sys->es);
314 vlc_list_init(&p_sys->es_slaves);
315
316 /* */
317 EsOutPropsInit( &p_sys->video, true, p_input, ES_OUT_ES_POLICY_SIMULTANEOUS,
318 NULL, NULL, NULL, NULL );
319 EsOutPropsInit( &p_sys->audio, true, p_input, ES_OUT_ES_POLICY_EXCLUSIVE,
320 "audio-track-id", "audio-track", "audio-language", "audio" );
321 EsOutPropsInit( &p_sys->sub, false, p_input, ES_OUT_ES_POLICY_EXCLUSIVE,
322 "sub-track-id", "sub-track", "sub-language", "sub" );
323
324 p_sys->i_group_id = var_GetInteger( p_input, "program" );
325
326 p_sys->i_pause_date = -1;
327
328 p_sys->i_rate = i_rate;
329
330 p_sys->b_buffering = true;
331 p_sys->i_preroll_end = -1;
332 p_sys->i_prev_stream_level = -1;
333
334 return &p_sys->out;
335 }
336
337 /*****************************************************************************
338 *
339 *****************************************************************************/
340 static void EsOutDelete( es_out_t *out )
341 {
342 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
343
344 assert(vlc_list_is_empty(&p_sys->es));
345 assert(vlc_list_is_empty(&p_sys->es_slaves));
346 assert(vlc_list_is_empty(&p_sys->programs));
347 assert(p_sys->p_pgrm == NULL);
348 EsOutPropsCleanup( &p_sys->audio );
349 EsOutPropsCleanup( &p_sys->sub );
350
351 vlc_mutex_destroy( &p_sys->lock );
352
353 free( p_sys );
354 }
355
356 static void EsOutTerminate( es_out_t *out )
357 {
358 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
359 es_out_id_t *es;
360
361 if( p_sys->p_sout_record )
362 EsOutSetRecord( out, false );
363
364 foreach_es_then_es_slaves(es)
365 {
366 if (es->p_dec != NULL)
367 input_DecoderDelete(es->p_dec);
368
369 free(es->psz_language);
370 free(es->psz_language_code);
371 es_format_Clean(&es->fmt);
372 vlc_list_remove(&es->node);
373 free(es);
374 }
375
376 /* FIXME duplicate work EsOutProgramDel (but we cannot use it) add a EsOutProgramClean ? */
377 es_out_pgrm_t *p_pgrm;
378 vlc_list_foreach(p_pgrm, &p_sys->programs, node)
379 {
380 input_clock_Delete( p_pgrm->p_input_clock );
381 if( p_pgrm->p_meta )
382 vlc_meta_Delete( p_pgrm->p_meta );
383
384 vlc_list_remove(&p_pgrm->node);
385 free( p_pgrm );
386 }
387
388 p_sys->p_pgrm = NULL;
389
390 input_item_SetEpgOffline( input_priv(p_sys->p_input)->p_item );
391 input_SendEventMetaEpg( p_sys->p_input );
392 }
393
394 static vlc_tick_t EsOutGetWakeup( es_out_t *out )
395 {
396 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
397 input_thread_t *p_input = p_sys->p_input;
398
399 if( !p_sys->p_pgrm )
400 return 0;
401
402 /* We do not have a wake up date if the input cannot have its speed
403 * controlled or sout is imposing its own or while buffering
404 *
405 * FIXME for !input_priv(p_input)->b_can_pace_control a wake-up time is still needed
406 * to avoid too heavy buffering */
407 if( !input_priv(p_input)->b_can_pace_control ||
408 input_priv(p_input)->b_out_pace_control ||
409 p_sys->b_buffering )
410 return 0;
411
412 return input_clock_GetWakeup( p_sys->p_pgrm->p_input_clock );
413 }
414
415 static es_out_id_t es_cat[DATA_ES];
416
417 static es_out_id_t *EsOutGetFromID( es_out_t *out, int i_id )
418 {
419 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
420 es_out_id_t *es;
421
422 if( i_id < 0 )
423 {
424 /* Special HACK, -i_id is the cat of the stream */
425 return es_cat - i_id;
426 }
427
428 foreach_es_then_es_slaves(es)
429 if (es->i_id == i_id)
430 return es;
431 return NULL;
432 }
433
434 static es_out_id_t *EsOutGetSelectedCat( es_out_t *out,
435 enum es_format_category_e cat )
436 {
437 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
438 es_out_id_t *es;
439
440 foreach_es_then_es_slaves( es )
441 if( es->fmt.i_cat == cat && EsIsSelected( es ) )
442 return es;
443 return NULL;
444 }
445
446 static bool EsOutDecodersIsEmpty( es_out_t *out )
447 {
448 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
449 es_out_id_t *es;
450
451 if( p_sys->b_buffering && p_sys->p_pgrm )
452 {
453 EsOutDecodersStopBuffering( out, true );
454 if( p_sys->b_buffering )
455 return true;
456 }
457
458 foreach_es_then_es_slaves(es)
459 {
460 if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) )
461 return false;
462 if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) )
463 return false;
464 }
465 return true;
466 }
467
468 static void EsOutSetDelay( es_out_t *out, int i_cat, vlc_tick_t i_delay )
469 {
470 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
471 es_out_id_t *es;
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 foreach_es_then_es_slaves(es)
479 EsOutDecoderChangeDelay(out, es);
480 }
481
482 static int EsOutSetRecord( es_out_t *out, bool b_record )
483 {
484 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
485 input_thread_t *p_input = p_sys->p_input;
486 es_out_id_t *p_es;
487
488 assert( ( b_record && !p_sys->p_sout_record ) || ( !b_record && p_sys->p_sout_record ) );
489
490 if( b_record )
491 {
492 char *psz_path = var_CreateGetNonEmptyString( p_input, "input-record-path" );
493 if( !psz_path )
494 {
495 if( var_CountChoices( p_input, "video-es" ) )
496 psz_path = config_GetUserDir( VLC_VIDEOS_DIR );
497 else if( var_CountChoices( p_input, "audio-es" ) )
498 psz_path = config_GetUserDir( VLC_MUSIC_DIR );
499 else
500 psz_path = config_GetUserDir( VLC_DOWNLOAD_DIR );
501 }
502
503 char *psz_sout = NULL; // TODO conf
504
505 if( !psz_sout && psz_path )
506 {
507 char *psz_file = input_CreateFilename( p_input, psz_path, INPUT_RECORD_PREFIX, NULL );
508 if( psz_file )
509 {
510 char* psz_file_esc = config_StringEscape( psz_file );
511 if ( psz_file_esc )
512 {
513 if( asprintf( &psz_sout, "#record{dst-prefix='%s'}", psz_file_esc ) < 0 )
514 psz_sout = NULL;
515 free( psz_file_esc );
516 }
517 free( psz_file );
518 }
519 }
520 free( psz_path );
521
522 if( !psz_sout )
523 return VLC_EGENERIC;
524
525 #ifdef ENABLE_SOUT
526 p_sys->p_sout_record = sout_NewInstance( p_input, psz_sout );
527 #endif
528 free( psz_sout );
529
530 if( !p_sys->p_sout_record )
531 return VLC_EGENERIC;
532
533 vlc_list_foreach( p_es, &p_sys->es, node ) /* Only master es */
534 {
535 if( !p_es->p_dec )
536 continue;
537
538 p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_input_clock, p_sys->p_sout_record );
539 if( p_es->p_dec_record && p_sys->b_buffering )
540 input_DecoderStartWait( p_es->p_dec_record );
541 }
542 }
543 else
544 {
545 vlc_list_foreach( p_es, &p_sys->es, node ) /* Only master es */
546 {
547 if( !p_es->p_dec_record )
548 continue;
549
550 input_DecoderDelete( p_es->p_dec_record );
551 p_es->p_dec_record = NULL;
552 }
553 #ifdef ENABLE_SOUT
554 sout_DeleteInstance( p_sys->p_sout_record );
555 #endif
556 p_sys->p_sout_record = NULL;
557 }
558
559 return VLC_SUCCESS;
560 }
561 static void EsOutChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date )
562 {
563 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
564
565 /* XXX the order is important */
566 if( b_paused )
567 {
568 EsOutDecodersChangePause( out, true, i_date );
569 EsOutProgramChangePause( out, true, i_date );
570 }
571 else
572 {
573 if( p_sys->i_buffering_extra_initial > 0 )
574 {
575 vlc_tick_t i_stream_start;
576 vlc_tick_t i_system_start;
577 vlc_tick_t i_stream_duration;
578 vlc_tick_t i_system_duration;
579 int i_ret;
580 i_ret = input_clock_GetState( p_sys->p_pgrm->p_input_clock,
581 &i_stream_start, &i_system_start,
582 &i_stream_duration, &i_system_duration );
583 if( !i_ret )
584 {
585 /* FIXME pcr != exactly what wanted */
586 const vlc_tick_t i_used = /*(i_stream_duration - input_priv(p_sys->p_input)->i_pts_delay)*/ p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial;
587 i_date -= i_used;
588 }
589 p_sys->i_buffering_extra_initial = 0;
590 p_sys->i_buffering_extra_stream = 0;
591 p_sys->i_buffering_extra_system = 0;
592 }
593 EsOutProgramChangePause( out, false, i_date );
594 EsOutDecodersChangePause( out, false, i_date );
595
596 EsOutProgramsChangeRate( out );
597 }
598 p_sys->b_paused = b_paused;
599 p_sys->i_pause_date = i_date;
600 }
601
602 static void EsOutChangeRate( es_out_t *out, int i_rate )
603 {
604 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
605 float rate = (float)i_rate / (float)INPUT_RATE_DEFAULT;
606 es_out_id_t *es;
607
608 p_sys->i_rate = i_rate;
609 EsOutProgramsChangeRate( out );
610
611 foreach_es_then_es_slaves(es)
612 if( es->p_dec != NULL )
613 input_DecoderChangeRate( es->p_dec, rate );
614 }
615
616 static void EsOutChangePosition( es_out_t *out )
617 {
618 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
619 es_out_id_t *p_es;
620
621 input_SendEventCache( p_sys->p_input, 0.0 );
622
623 foreach_es_then_es_slaves(p_es)
624 if( p_es->p_dec != NULL )
625 {
626 input_DecoderFlush( p_es->p_dec );
627 if( !p_sys->b_buffering )
628 {
629 input_DecoderStartWait( p_es->p_dec );
630 if( p_es->p_dec_record != NULL )
631 input_DecoderStartWait( p_es->p_dec_record );
632 }
633 }
634
635 es_out_pgrm_t *pgrm;
636 vlc_list_foreach(pgrm, &p_sys->programs, node)
637 input_clock_Reset(pgrm->p_input_clock);
638
639 p_sys->b_buffering = true;
640 p_sys->i_buffering_extra_initial = 0;
641 p_sys->i_buffering_extra_stream = 0;
642 p_sys->i_buffering_extra_system = 0;
643 p_sys->i_preroll_end = -1;
644 p_sys->i_prev_stream_level = -1;
645 }
646
647
648
649 static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
650 {
651 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
652 es_out_id_t *p_es;
653
654 vlc_tick_t i_stream_start;
655 vlc_tick_t i_system_start;
656 vlc_tick_t i_stream_duration;
657 vlc_tick_t i_system_duration;
658 if (input_clock_GetState( p_sys->p_pgrm->p_input_clock,
659 &i_stream_start, &i_system_start,
660 &i_stream_duration, &i_system_duration ))
661 return;
662
663 vlc_tick_t i_preroll_duration = 0;
664 if( p_sys->i_preroll_end >= 0 )
665 i_preroll_duration = __MAX( p_sys->i_preroll_end - i_stream_start, 0 );
666
667 const vlc_tick_t i_buffering_duration = p_sys->i_pts_delay +
668 i_preroll_duration +
669 p_sys->i_buffering_extra_stream - p_sys->i_buffering_extra_initial;
670
671 if( i_stream_duration <= i_buffering_duration && !b_forced )
672 {
673 double f_level;
674 if (i_buffering_duration == 0)
675 f_level = 0;
676 else
677 f_level = __MAX( (double)i_stream_duration / i_buffering_duration, 0 );
678 input_SendEventCache( p_sys->p_input, f_level );
679
680 int i_level = (int)(100 * f_level);
681 if( p_sys->i_prev_stream_level != i_level )
682 {
683 msg_Dbg( p_sys->p_input, "Buffering %d%%", i_level );
684 p_sys->i_prev_stream_level = i_level;
685 }
686
687 return;
688 }
689 input_SendEventCache( p_sys->p_input, 1.0 );
690
691 msg_Dbg( p_sys->p_input, "Stream buffering done (%d ms in %d ms)",
692 (int)MS_FROM_VLC_TICK(i_stream_duration), (int)MS_FROM_VLC_TICK(i_system_duration) );
693 p_sys->b_buffering = false;
694 p_sys->i_preroll_end = -1;
695 p_sys->i_prev_stream_level = -1;
696
697 if( p_sys->i_buffering_extra_initial > 0 )
698 {
699 /* FIXME wrong ? */
700 return;
701 }
702
703 const vlc_tick_t i_decoder_buffering_start = vlc_tick_now();
704 foreach_es_then_es_slaves(p_es)
705 {
706 if( !p_es->p_dec || p_es->fmt.i_cat == SPU_ES )
707 continue;
708 input_DecoderWait( p_es->p_dec );
709 if( p_es->p_dec_record )
710 input_DecoderWait( p_es->p_dec_record );
711 }
712
713 msg_Dbg( p_sys->p_input, "Decoder wait done in %d ms",
714 (int)MS_FROM_VLC_TICK(vlc_tick_now() - i_decoder_buffering_start) );
715
716 /* Here is a good place to destroy unused vout with every demuxer */
717 input_resource_TerminateVout( input_priv(p_sys->p_input)->p_resource );
718
719 /* */
720 const vlc_tick_t i_wakeup_delay = VLC_TICK_FROM_MS(10); /* FIXME CLEANUP thread wake up time*/
721 const vlc_tick_t i_current_date = p_sys->b_paused ? p_sys->i_pause_date : vlc_tick_now();
722
723 input_clock_ChangeSystemOrigin( p_sys->p_pgrm->p_input_clock, true,
724 i_current_date + i_wakeup_delay - i_buffering_duration );
725
726 foreach_es_then_es_slaves(p_es)
727 {
728 if( !p_es->p_dec )
729 continue;
730
731 input_DecoderStopWait( p_es->p_dec );
732 if( p_es->p_dec_record )
733 input_DecoderStopWait( p_es->p_dec_record );
734 }
735 }
736 static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date )
737 {
738 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
739 es_out_id_t *es;
740
741 /* Pause decoders first */
742 foreach_es_then_es_slaves(es)
743 if( es->p_dec )
744 {
745 input_DecoderChangePause( es->p_dec, b_paused, i_date );
746 if( es->p_dec_record )
747 input_DecoderChangePause( es->p_dec_record, b_paused, i_date );
748 }
749 }
750
751 static bool EsOutIsExtraBufferingAllowed( es_out_t *out )
752 {
753 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
754 es_out_id_t *p_es;
755
756 size_t i_size = 0;
757 foreach_es_then_es_slaves(p_es)
758 {
759 if( p_es->p_dec )
760 i_size += input_DecoderGetFifoSize( p_es->p_dec );
761 if( p_es->p_dec_record )
762 i_size += input_DecoderGetFifoSize( p_es->p_dec_record );
763 }
764 //msg_Info( out, "----- EsOutIsExtraBufferingAllowed =% 5d KiB -- ", i_size / 1024 );
765
766 /* TODO maybe we want to be able to tune it ? */
767 #if defined(OPTIMIZE_MEMORY)
768 const size_t i_level_high = 512*1024; /* 0.5 MiB */
769 #else
770 const size_t i_level_high = 10*1024*1024; /* 10 MiB */
771 #endif
772 return i_size < i_level_high;
773 }
774
775 static void EsOutProgramChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date )
776 {
777 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
778 es_out_pgrm_t *pgrm;
779
780 vlc_list_foreach(pgrm, &p_sys->programs, node)
781 input_clock_ChangePause(pgrm->p_input_clock, b_paused, i_date);
782 }
783
784 static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es )
785 {
786 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
787
788 vlc_tick_t i_delay;
789 if( p_es->fmt.i_cat == AUDIO_ES )
790 i_delay = p_sys->i_audio_delay;
791 else if( p_es->fmt.i_cat == SPU_ES )
792 i_delay = p_sys->i_spu_delay;
793 else
794 return;
795
796 if( p_es->p_dec )
797 input_DecoderChangeDelay( p_es->p_dec, i_delay );
798 if( p_es->p_dec_record )
799 input_DecoderChangeDelay( p_es->p_dec_record, i_delay );
800 }
801 static void EsOutProgramsChangeRate( es_out_t *out )
802 {
803 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
804 es_out_pgrm_t *pgrm;
805
806 vlc_list_foreach(pgrm, &p_sys->programs, node)
807 input_clock_ChangeRate(pgrm->p_input_clock, p_sys->i_rate);
808 }
809
810 static void EsOutFrameNext( es_out_t *out )
811 {
812 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
813 es_out_id_t *p_es_video = NULL, *p_es;
814
815 if( p_sys->b_buffering )
816 {
817 msg_Warn( p_sys->p_input, "buffering, ignoring 'frame next'" );
818 return;
819 }
820
821 assert( p_sys->b_paused );
822
823 foreach_es_then_es_slaves(p_es)
824 if( p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec && !p_es_video /* nested loop */ )
825 {
826 p_es_video = p_es;
827 break;
828 }
829
830 if( !p_es_video )
831 {
832 msg_Warn( p_sys->p_input, "No video track selected, ignoring 'frame next'" );
833 return;
834 }
835
836 vlc_tick_t i_duration;
837 input_DecoderFrameNext( p_es_video->p_dec, &i_duration );
838
839 msg_Dbg( p_sys->p_input, "EsOutFrameNext consummed %d ms", (int)MS_FROM_VLC_TICK(i_duration) );
840
841 if( i_duration <= 0 )
842 i_duration = VLC_TICK_FROM_MS(40);
843
844 /* FIXME it is not a clean way ? */
845 if( p_sys->i_buffering_extra_initial <= 0 )
846 {
847 vlc_tick_t i_stream_start;
848 vlc_tick_t i_system_start;
849 vlc_tick_t i_stream_duration;
850 vlc_tick_t i_system_duration;
851 int i_ret;
852
853 i_ret = input_clock_GetState( p_sys->p_pgrm->p_input_clock,
854 &i_stream_start, &i_system_start,
855 &i_stream_duration, &i_system_duration );
856 if( i_ret )
857 return;
858
859 p_sys->i_buffering_extra_initial = 1 + i_stream_duration - p_sys->i_pts_delay; /* FIXME < 0 ? */
860 p_sys->i_buffering_extra_system =
861 p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial;
862 }
863
864 const int i_rate = input_clock_GetRate( p_sys->p_pgrm->p_input_clock );
865
866 p_sys->b_buffering = true;
867 p_sys->i_buffering_extra_system += i_duration;
868 p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial +
869 ( p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial ) *
870 INPUT_RATE_DEFAULT / i_rate;
871
872 p_sys->i_preroll_end = -1;
873 p_sys->i_prev_stream_level = -1;
874 }
875 static vlc_tick_t EsOutGetBuffering( es_out_t *out )
876 {
877 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
878 vlc_tick_t i_stream_duration, i_system_start;
879
880 if( !p_sys->p_pgrm )
881 return 0;
882 else
883 {
884 vlc_tick_t i_stream_start, i_system_duration;
885
886 if( input_clock_GetState( p_sys->p_pgrm->p_input_clock,
887 &i_stream_start, &i_system_start,
888 &i_stream_duration, &i_system_duration ) )
889 return 0;
890 }
891
892 vlc_tick_t i_delay;
893
894 if( p_sys->b_buffering && p_sys->i_buffering_extra_initial <= 0 )
895 {
896 i_delay = i_stream_duration;
897 }
898 else
899 {
900 vlc_tick_t i_system_duration;
901
902 if( p_sys->b_paused )
903 {
904 i_system_duration = p_sys->i_pause_date - i_system_start;
905 if( p_sys->i_buffering_extra_initial > 0 )
906 i_system_duration += p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial;
907 }
908 else
909 {
910 i_system_duration = vlc_tick_now() - i_system_start;
911 }
912
913 const vlc_tick_t i_consumed = i_system_duration * INPUT_RATE_DEFAULT / p_sys->i_rate - i_stream_duration;
914 i_delay = p_sys->i_pts_delay - i_consumed;
915 }
916 if( i_delay < 0 )
917 return 0;
918 return i_delay;
919 }
920
921 static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id,
922 const es_format_t *fmt, const char *psz_language,
923 bool b_delete )
924 {
925 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
926 input_thread_t *p_input = p_sys->p_input;
927 vlc_value_t text;
928 es_out_id_t *es;
929 size_t count = 0;
930
931 if( b_delete )
932 {
933 if( EsFmtIsTeletext( fmt ) )
934 input_SendEventTeletextDel( p_sys->p_input, i_id );
935
936 input_SendEventEsDel( p_input, fmt->i_cat, i_id );
937 return;
938 }
939
940 /* Get the number of ES already added */
941 foreach_es_then_es_slaves(es)
942 if( es->fmt.i_cat == fmt->i_cat )
943 count++;
944
945 /* Take care of the ES description */
946 if( fmt->psz_description && *fmt->psz_description )
947 {
948 if( psz_language && *psz_language )
949 {
950 if( asprintf( &text.psz_string, "%s - [%s]", fmt->psz_description,
951 psz_language ) == -1 )
952 text.psz_string = NULL;
953 }
954 else text.psz_string = strdup( fmt->psz_description );
955 }
956 else
957 {
958 if( psz_language && *psz_language )
959 {
960 if( asprintf( &text.psz_string, "%s %zu - [%s]", _("Track"), count,
961 psz_language ) == -1 )
962 text.psz_string = NULL;
963 }
964 else
965 {
966 if( asprintf( &text.psz_string, "%s %zu", _("Track"), count ) == -1 )
967 text.psz_string = NULL;
968 }
969 }
970
971 input_SendEventEsAdd( p_input, fmt->i_cat, i_id, text.psz_string );
972 if( EsFmtIsTeletext( fmt ) )
973 {
974 char psz_page[3+1];
975 snprintf( psz_page, sizeof(psz_page), "%d%2.2x",
976 fmt->subs.teletext.i_magazine,
977 fmt->subs.teletext.i_page );
978 input_SendEventTeletextAdd( p_sys->p_input,
979 i_id, fmt->subs.teletext.i_magazine >= 0 ? psz_page : NULL );
980 }
981
982 free( text.psz_string );
983 }
984
985 static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es,
986 bool b_delete )
987 {
988 EsOutESVarUpdateGeneric( out, es->i_id, &es->fmt, es->psz_language, b_delete );
989 }
990
991 static bool EsOutIsProgramVisible( es_out_t *out, int i_group )
992 {
993 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
994 return p_sys->i_group_id == 0 || p_sys->i_group_id == i_group;
995 }
996
997 /* EsOutProgramSelect:
998 * Select a program and update the object variable
999 */
1000 static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm )
1001 {
1002 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1003 input_thread_t *p_input = p_sys->p_input;
1004 es_out_id_t *es;
1005
1006 if( p_sys->p_pgrm == p_pgrm )
1007 return; /* Nothing to do */
1008
1009 if( p_sys->p_pgrm )
1010 {
1011 es_out_pgrm_t *old = p_sys->p_pgrm;
1012
1013 msg_Dbg( p_input, "unselecting program id=%d", old->i_id );
1014
1015 foreach_es_then_es_slaves(es)
1016 if (es->p_pgrm == old && EsIsSelected(es)
1017 && p_sys->i_mode != ES_OUT_MODE_ALL)
1018 EsUnselect(out, es, true);
1019
1020 p_sys->audio.p_main_es = NULL;
1021 p_sys->video.p_main_es = NULL;
1022 p_sys->sub.p_main_es = NULL;
1023 }
1024
1025 msg_Dbg( p_input, "selecting program id=%d", p_pgrm->i_id );
1026
1027 /* Mark it selected */
1028 p_pgrm->b_selected = true;
1029
1030 /* Switch master stream */
1031 p_sys->p_pgrm = p_pgrm;
1032
1033 /* Update "program" */
1034 input_SendEventProgramSelect( p_input, p_pgrm->i_id );
1035
1036 /* Update "es-*" */
1037 input_SendEventEsDel( p_input, AUDIO_ES, -1 );
1038 input_SendEventEsDel( p_input, VIDEO_ES, -1 );
1039 input_SendEventEsDel( p_input, SPU_ES, -1 );
1040 input_SendEventTeletextDel( p_input, -1 );
1041 input_SendEventProgramScrambled( p_input, p_pgrm->i_id, p_pgrm->b_scrambled );
1042
1043 foreach_es_then_es_slaves(es)
1044 {
1045 if (es->p_pgrm == p_sys->p_pgrm)
1046 {
1047 EsOutESVarUpdate(out, es, false);
1048 EsOutUpdateInfo(out, es, &es->fmt, NULL);
1049 }
1050
1051 EsOutSelect(out, es, false);
1052 }
1053
1054 /* Ensure the correct running EPG table is selected */
1055 input_item_ChangeEPGSource( input_priv(p_input)->p_item, p_pgrm->i_id );
1056
1057 /* Update now playing */
1058 if( p_pgrm->p_meta )
1059 {
1060 input_item_SetESNowPlaying( input_priv(p_input)->p_item,
1061 vlc_meta_Get( p_pgrm->p_meta, vlc_meta_ESNowPlaying ) );
1062 input_item_SetPublisher( input_priv(p_input)->p_item,
1063 vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Publisher ) );
1064 input_item_SetTitle( input_priv(p_input)->p_item,
1065 vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title ) );
1066 input_SendEventMeta( p_input );
1067 /* FIXME: we probably want to replace every input meta */
1068 }
1069 }
1070
1071 /* EsOutAddProgram:
1072 * Add a program
1073 */
1074 static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group )
1075 {
1076 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1077 input_thread_t *p_input = p_sys->p_input;
1078
1079 es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) );
1080 if( !p_pgrm )
1081 return NULL;
1082
1083 /* Init */
1084 p_pgrm->i_id = i_group;
1085 p_pgrm->i_es = 0;
1086 p_pgrm->b_selected = false;
1087 p_pgrm->b_scrambled = false;
1088 p_pgrm->p_meta = NULL;
1089 p_pgrm->p_input_clock = input_clock_New( p_sys->i_rate );
1090 if( !p_pgrm->p_input_clock )
1091 {
1092 free( p_pgrm );
1093 return NULL;
1094 }
1095 if( p_sys->b_paused )
1096 input_clock_ChangePause( p_pgrm->p_input_clock, p_sys->b_paused, p_sys->i_pause_date );
1097 input_clock_SetJitter( p_pgrm->p_input_clock, p_sys->i_pts_delay, p_sys->i_cr_average );
1098
1099 /* Append it */
1100 vlc_list_append(&p_pgrm->node, &p_sys->programs);
1101
1102 /* Update "program" variable */
1103 if( EsOutIsProgramVisible( out, i_group ) )
1104 input_SendEventProgramAdd( p_input, i_group, NULL );
1105
1106 if( i_group == p_sys->i_group_id || ( !p_sys->p_pgrm && p_sys->i_group_id == 0 ) )
1107 EsOutProgramSelect( out, p_pgrm );
1108
1109 return p_pgrm;
1110 }
1111
1112 /* EsOutDelProgram:
1113 * Delete a program
1114 */
1115 static int EsOutProgramDel( es_out_t *out, int i_group )
1116 {
1117 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1118 input_thread_t *p_input = p_sys->p_input;
1119 es_out_pgrm_t *p_pgrm = NULL, *pgrm;
1120
1121 vlc_list_foreach(pgrm, &p_sys->programs, node)
1122 if (pgrm->i_id == i_group)
1123 {
1124 p_pgrm = pgrm;
1125 break;
1126 }
1127
1128 if( p_pgrm == NULL )
1129 return VLC_EGENERIC;
1130
1131 if( p_pgrm->i_es )
1132 {
1133 msg_Dbg( p_input, "can't delete program %d which still has %i ES",
1134 i_group, p_pgrm->i_es );
1135 return VLC_EGENERIC;
1136 }
1137
1138 vlc_list_remove(&p_pgrm->node);
1139
1140 /* If program is selected we need to unselect it */
1141 if( p_sys->p_pgrm == p_pgrm )
1142 p_sys->p_pgrm = NULL;
1143
1144 input_clock_Delete( p_pgrm->p_input_clock );
1145
1146 if( p_pgrm->p_meta )
1147 vlc_meta_Delete( p_pgrm->p_meta );
1148 free( p_pgrm );
1149
1150 /* Update "program" variable */
1151 input_SendEventProgramDel( p_input, i_group );
1152
1153 return VLC_SUCCESS;
1154 }
1155
1156 /* EsOutProgramFind
1157 */
1158 static es_out_pgrm_t *EsOutProgramFind( es_out_t *p_out, int i_group )
1159 {
1160 es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
1161 es_out_pgrm_t *pgrm;
1162
1163 vlc_list_foreach(pgrm, &p_sys->programs, node)
1164 if (pgrm->i_id == i_group)
1165 return pgrm;
1166
1167 return EsOutProgramAdd( p_out, i_group );
1168 }
1169
1170 /* EsOutProgramMeta:
1171 */
1172 static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm )
1173 {
1174 char *psz = NULL;
1175 if( p_pgrm->p_meta && vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title ) )
1176 {
1177 if( asprintf( &psz, _("%s [%s %d]"), vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title ),
1178 _("Program"), p_pgrm->i_id ) == -1 )
1179 return NULL;
1180 }
1181 else
1182 {
1183 if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 )
1184 return NULL;
1185 }
1186 return psz;
1187 }
1188
1189 static char *EsOutProgramGetProgramName( es_out_pgrm_t *p_pgrm )
1190 {
1191 char *psz = NULL;
1192 if( p_pgrm->p_meta && vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title ) )
1193 {
1194 return strdup( vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title ) );
1195 }
1196 else
1197 {
1198 if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 )
1199 return NULL;
1200 }
1201 return psz;
1202 }
1203
1204 static char *EsInfoCategoryName( es_out_id_t* es )
1205 {
1206 char *psz_category;
1207
1208 if( asprintf( &psz_category, _("Stream %d"), es->i_meta_id ) == -1 )
1209 return NULL;
1210
1211 return psz_category;
1212 }
1213
1214 static void EsOutProgramMeta( es_out_t *out, int i_group, const vlc_meta_t *p_meta )
1215 {
1216 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1217 es_out_pgrm_t *p_pgrm;
1218 input_thread_t *p_input = p_sys->p_input;
1219 const char *psz_title = NULL;
1220 const char *psz_provider = NULL;
1221 int i;
1222
1223 msg_Dbg( p_input, "EsOutProgramMeta: number=%d", i_group );
1224
1225 /* Check against empty meta data (empty for what we handle) */
1226 if( !vlc_meta_Get( p_meta, vlc_meta_Title) &&
1227 !vlc_meta_Get( p_meta, vlc_meta_ESNowPlaying) &&
1228 !vlc_meta_Get( p_meta, vlc_meta_Publisher) )
1229 {
1230 return;
1231 }
1232
1233 if( i_group < 0 )
1234 {
1235 EsOutGlobalMeta( out, p_meta );
1236 return;
1237 }
1238
1239 /* Find program */
1240 if( !EsOutIsProgramVisible( out, i_group ) )
1241 return;
1242 p_pgrm = EsOutProgramFind( out, i_group );
1243 if( !p_pgrm )
1244 return;
1245
1246 if( p_pgrm->p_meta )
1247 {
1248 const char *psz_current_title = vlc_meta_Get( p_pgrm->p_meta, vlc_meta_Title );
1249 const char *psz_new_title = vlc_meta_Get( p_meta, vlc_meta_Title );
1250 if( (psz_current_title != NULL && psz_new_title != NULL)
1251 ? strcmp(psz_new_title, psz_current_title)
1252 : (psz_current_title != psz_new_title) )
1253 {
1254 /* Remove old entries */
1255 char *psz_oldinfokey = EsOutProgramGetMetaName( p_pgrm );
1256 input_Control( p_input, INPUT_DEL_INFO, psz_oldinfokey, NULL );
1257 /* TODO update epg name ?
1258 * TODO update scrambled info name ? */
1259 free( psz_oldinfokey );
1260 }
1261 vlc_meta_Delete( p_pgrm->p_meta );
1262 }
1263 p_pgrm->p_meta = vlc_meta_New();
1264 if( p_pgrm->p_meta )
1265 vlc_meta_Merge( p_pgrm->p_meta, p_meta );
1266
1267 if( p_sys->p_pgrm == p_pgrm )
1268 {
1269 EsOutMeta( out, NULL, p_meta );
1270 }
1271 /* */
1272 psz_title = vlc_meta_Get( p_meta, vlc_meta_Title);
1273 psz_provider = vlc_meta_Get( p_meta, vlc_meta_Publisher);
1274
1275 /* Update the description text of the program */
1276 if( psz_title && *psz_title )
1277 {
1278 char *psz_text;
1279 if( psz_provider && *psz_provider )
1280 {
1281 if( asprintf( &psz_text, "%s [%s]", psz_title, psz_provider ) < 0 )
1282 psz_text = NULL;
1283 }
1284 else
1285 {
1286 psz_text = strdup( psz_title );
1287 }
1288
1289 /* ugly but it works */
1290 if( psz_text )
1291 {
1292 input_SendEventProgramDel( p_input, i_group );
1293 input_SendEventProgramAdd( p_input, i_group, psz_text );
1294 if( p_sys->p_pgrm == p_pgrm )
1295 input_SendEventProgramSelect( p_input, i_group );
1296 free( psz_text );
1297 }
1298 }
1299
1300 /* */
1301 char **ppsz_all_keys = vlc_meta_CopyExtraNames(p_meta );
1302
1303 info_category_t *p_cat = NULL;
1304 if( psz_provider || ( ppsz_all_keys[0] && *ppsz_all_keys[0] ) )
1305 {
1306 char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
1307 if( psz_cat )
1308 p_cat = info_category_New( psz_cat );
1309 free( psz_cat );
1310 }
1311
1312 for( i = 0; ppsz_all_keys[i]; i++ )
1313 {
1314 if( p_cat )
1315 info_category_AddInfo( p_cat, vlc_gettext(ppsz_all_keys[i]), "%s",
1316 vlc_meta_GetExtra( p_meta, ppsz_all_keys[i] ) );
1317 free( ppsz_all_keys[i] );
1318 }
1319 free( ppsz_all_keys );
1320
1321 if( psz_provider )
1322 {
1323 if( p_sys->p_pgrm == p_pgrm )
1324 {
1325 input_item_SetPublisher( input_priv(p_input)->p_item, psz_provider );
1326 input_SendEventMeta( p_input );
1327 }
1328 if( p_cat )
1329 info_category_AddInfo( p_cat, vlc_meta_TypeToLocalizedString(vlc_meta_Publisher),
1330 "%s",psz_provider );
1331 }
1332 if( p_cat )
1333 input_Control( p_input, INPUT_MERGE_INFOS, p_cat );
1334 }
1335
1336 static void EsOutProgramEpgEvent( es_out_t *out, int i_group, const vlc_epg_event_t *p_event )
1337 {
1338 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1339 input_thread_t *p_input = p_sys->p_input;
1340 input_item_t *p_item = input_priv(p_input)->p_item;
1341 es_out_pgrm_t *p_pgrm;
1342
1343 /* Find program */
1344 if( !EsOutIsProgramVisible( out, i_group ) )
1345 return;
1346 p_pgrm = EsOutProgramFind( out, i_group );
1347 if( !p_pgrm )
1348 return;
1349
1350 input_item_SetEpgEvent( p_item, p_event );
1351 }
1352
1353 static void EsOutProgramEpg( es_out_t *out, int i_group, const vlc_epg_t *p_epg )
1354 {
1355 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1356 input_thread_t *p_input = p_sys->p_input;
1357 input_item_t *p_item = input_priv(p_input)->p_item;
1358 es_out_pgrm_t *p_pgrm;
1359 char *psz_cat;
1360
1361 /* Find program */
1362 if( !EsOutIsProgramVisible( out, i_group ) )
1363 return;
1364 p_pgrm = EsOutProgramFind( out, i_group );
1365 if( !p_pgrm )
1366 return;
1367
1368 /* Update info */
1369 psz_cat = EsOutProgramGetMetaName( p_pgrm );
1370 msg_Dbg( p_input, "EsOutProgramEpg: number=%d name=%s", i_group, psz_cat );
1371
1372 /* Merge EPG */
1373 vlc_epg_t epg;
1374
1375 epg = *p_epg;
1376 epg.psz_name = EsOutProgramGetProgramName( p_pgrm );
1377
1378 input_item_SetEpg( p_item, &epg, p_sys->p_pgrm && (p_epg->i_source_id == p_sys->p_pgrm->i_id) );
1379 input_SendEventMetaEpg( p_sys->p_input );
1380
1381 free( epg.psz_name );
1382
1383 /* Update now playing */
1384 if( p_epg->b_present && p_pgrm->p_meta &&
1385 ( p_epg->p_current || p_epg->i_event == 0 ) )
1386 {
1387 vlc_meta_SetNowPlaying( p_pgrm->p_meta, NULL );
1388 }
1389
1390 vlc_mutex_lock( &p_item->lock );
1391 for( int i = 0; i < p_item->i_epg; i++ )
1392 {
1393 const vlc_epg_t *p_tmp = p_item->pp_epg[i];
1394
1395 if( p_tmp->b_present && p_tmp->i_source_id == p_pgrm->i_id )
1396 {
1397 const char *psz_name = ( p_tmp->p_current ) ? p_tmp->p_current->psz_name : NULL;
1398 if( !p_pgrm->p_meta )
1399 p_pgrm->p_meta = vlc_meta_New();
1400 if( p_pgrm->p_meta )
1401 vlc_meta_Set( p_pgrm->p_meta, vlc_meta_ESNowPlaying, psz_name );
1402 break;
1403 }
1404 }
1405 vlc_mutex_unlock( &p_item->lock );
1406
1407 /* Update selected program input info */
1408 if( p_pgrm == p_sys->p_pgrm )
1409 {
1410 const char *psz_nowplaying = p_pgrm->p_meta ?
1411 vlc_meta_Get( p_pgrm->p_meta, vlc_meta_ESNowPlaying ) : NULL;
1412
1413 input_item_SetESNowPlaying( input_priv(p_input)->p_item, psz_nowplaying );
1414 input_SendEventMeta( p_input );
1415
1416 if( psz_nowplaying )
1417 {
1418 input_Control( p_input, INPUT_ADD_INFO, psz_cat,
1419 vlc_meta_TypeToLocalizedString(vlc_meta_ESNowPlaying), "%s", psz_nowplaying );
1420 }
1421 else
1422 {
1423 input_Control( p_input, INPUT_DEL_INFO, psz_cat,
1424 vlc_meta_TypeToLocalizedString(vlc_meta_ESNowPlaying) );
1425 }
1426 }
1427
1428 free( psz_cat );
1429 }
1430
1431 static void EsOutEpgTime( es_out_t *out, int64_t time )
1432 {
1433 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1434 input_thread_t *p_input = p_sys->p_input;
1435 input_item_t *p_item = input_priv(p_input)->p_item;
1436
1437 input_item_SetEpgTime( p_item, time );
1438 }
1439
1440 static void EsOutProgramUpdateScrambled( es_out_t *p_out, es_out_pgrm_t *p_pgrm )
1441 {
1442 es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
1443 input_thread_t *p_input = p_sys->p_input;
1444 es_out_id_t *es;
1445 bool b_scrambled = false;
1446
1447 vlc_list_foreach( es, &p_sys->es, node ) /* Only master es */
1448 if (es->p_pgrm == p_pgrm && es->b_scrambled)
1449 {
1450 b_scrambled = true;
1451 break;
1452 }
1453
1454 if( !p_pgrm->b_scrambled == !b_scrambled )
1455 return;
1456
1457 p_pgrm->b_scrambled = b_scrambled;
1458 char *psz_cat = EsOutProgramGetMetaName( p_pgrm );
1459
1460 if( b_scrambled )
1461 input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Scrambled"), _("Yes") );
1462 else
1463 input_Control( p_input, INPUT_DEL_INFO, psz_cat, _("Scrambled") );
1464 free( psz_cat );
1465
1466 input_SendEventProgramScrambled( p_input, p_pgrm->i_id, b_scrambled );
1467 }
1468
1469 static void EsOutMeta( es_out_t *p_out, const vlc_meta_t *p_meta, const vlc_meta_t *p_program_meta )
1470 {
1471 es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
1472 input_thread_t *p_input = p_sys->p_input;
1473 input_item_t *p_item = input_GetItem( p_input );
1474
1475 vlc_mutex_lock( &p_item->lock );
1476 if( p_meta )
1477 vlc_meta_Merge( p_item->p_meta, p_meta );
1478 vlc_mutex_unlock( &p_item->lock );
1479
1480 /* Check program meta to not override GROUP_META values */
1481 if( p_meta && (!p_program_meta || vlc_meta_Get( p_program_meta, vlc_meta_Title ) == NULL) &&
1482 vlc_meta_Get( p_meta, vlc_meta_Title ) != NULL )
1483 input_item_SetName( p_item, vlc_meta_Get( p_meta, vlc_meta_Title ) );
1484
1485 const char *psz_arturl = NULL;
1486 char *psz_alloc = NULL;
1487
1488 if( p_program_meta )
1489 psz_arturl = vlc_meta_Get( p_program_meta, vlc_meta_ArtworkURL );
1490 if( psz_arturl == NULL && p_meta )
1491 psz_arturl = vlc_meta_Get( p_meta, vlc_meta_ArtworkURL );
1492
1493 if( psz_arturl == NULL ) /* restore/favor previously set item art URL */
1494 psz_arturl = psz_alloc = input_item_GetArtURL( p_item );
1495
1496 if( psz_arturl != NULL )
1497 input_item_SetArtURL( p_item, psz_arturl );
1498
1499 if( psz_arturl != NULL && !strncmp( psz_arturl, "attachment://", 13 ) )
1500 { /* Clear art cover if streaming out.
1501 * FIXME: Why? Remove this when sout gets meta data support. */
1502 if( input_priv(p_input)->p_sout != NULL )
1503 input_item_SetArtURL( p_item, NULL );
1504 else
1505 input_ExtractAttachmentAndCacheArt( p_input, psz_arturl + 13 );
1506 }
1507 free( psz_alloc );
1508
1509 input_item_SetPreparsed( p_item, true );
1510
1511 input_SendEventMeta( p_input );
1512 /* TODO handle sout meta ? */
1513 }
1514
1515 static void EsOutGlobalMeta( es_out_t *p_out, const vlc_meta_t *p_meta )
1516 {
1517 es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
1518 EsOutMeta( p_out, p_meta,
1519 (p_sys->p_pgrm && p_sys->p_pgrm->p_meta) ? p_sys->p_pgrm->p_meta : NULL );
1520 }
1521
1522 static es_out_id_t *EsOutAddSlaveLocked( es_out_t *out, const es_format_t *fmt,
1523 es_out_id_t *p_master )
1524 {
1525 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1526 input_thread_t *p_input = p_sys->p_input;
1527
1528 if( fmt->i_group < 0 )
1529 {
1530 msg_Err( p_input, "invalid group number" );
1531 return NULL;
1532 }
1533
1534 es_out_id_t *es = malloc( sizeof( *es ) );
1535 es_out_pgrm_t *p_pgrm;
1536 int i;
1537
1538 if( !es )
1539 return NULL;
1540
1541 /* Search the program */
1542 p_pgrm = EsOutProgramFind( out, fmt->i_group );
1543 if( !p_pgrm )
1544 {
1545 free( es );
1546 return NULL;
1547 }
1548
1549 /* Increase ref count for program */
1550 p_pgrm->i_es++;
1551
1552 /* Set up ES */
1553 es->p_pgrm = p_pgrm;
1554 es_format_Copy( &es->fmt, fmt );
1555 if( es->fmt.i_id < 0 )
1556 es->fmt.i_id = p_sys->i_id;
1557 if( !es->fmt.i_original_fourcc )
1558 es->fmt.i_original_fourcc = es->fmt.i_codec;
1559
1560 es->i_id = es->fmt.i_id;
1561 es->i_meta_id = p_sys->i_id++; /* always incremented */
1562 es->b_scrambled = false;
1563 es->b_forced = false;
1564
1565 switch( es->fmt.i_cat )
1566 {
1567 case AUDIO_ES:
1568 {
1569 es->fmt.i_codec = vlc_fourcc_GetCodecAudio( es->fmt.i_codec,
1570 es->fmt.audio.i_bitspersample );
1571 es->i_channel = p_sys->audio.i_count++;
1572
1573 audio_replay_gain_t rg;
1574 memset( &rg, 0, sizeof(rg) );
1575 vlc_mutex_lock( &input_priv(p_input)->p_item->lock );
1576 vlc_audio_replay_gain_MergeFromMeta( &rg, input_priv(p_input)->p_item->p_meta );
1577 vlc_mutex_unlock( &input_priv(p_input)->p_item->lock );
1578
1579 for( i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
1580 {
1581 if( !es->fmt.audio_replay_gain.pb_peak[i] )
1582 {
1583 es->fmt.audio_replay_gain.pb_peak[i] = rg.pb_peak[i];
1584 es->fmt.audio_replay_gain.pf_peak[i] = rg.pf_peak[i];
1585 }
1586 if( !es->fmt.audio_replay_gain.pb_gain[i] )
1587 {
1588 es->fmt.audio_replay_gain.pb_gain[i] = rg.pb_gain[i];
1589 es->fmt.audio_replay_gain.pf_gain[i] = rg.pf_gain[i];
1590 }
1591 }
1592 break;
1593 }
1594
1595 case VIDEO_ES:
1596 es->fmt.i_codec = vlc_fourcc_GetCodec( es->fmt.i_cat, es->fmt.i_codec );
1597 es->i_channel = p_sys->video.i_count++;
1598
1599 if( !es->fmt.video.i_visible_width || !es->fmt.video.i_visible_height )
1600 {
1601 es->fmt.video.i_visible_width = es->fmt.video.i_width;
1602 es->fmt.video.i_visible_height = es->fmt.video.i_height;
1603 }
1604
1605 if( es->fmt.video.i_frame_rate && es->fmt.video.i_frame_rate_base )
1606 vlc_ureduce( &es->fmt.video.i_frame_rate,
1607 &es->fmt.video.i_frame_rate_base,
1608 es->fmt.video.i_frame_rate,
1609 es->fmt.video.i_frame_rate_base, 0 );
1610 break;
1611
1612 case SPU_ES:
1613 es->fmt.i_codec = vlc_fourcc_GetCodec( es->fmt.i_cat, es->fmt.i_codec );
1614 es->i_channel = p_sys->sub.i_count++;
1615 break;
1616
1617 default:
1618 es->i_channel = 0;
1619 break;
1620 }
1621 es->psz_language = LanguageGetName( es->fmt.psz_language ); /* remember so we only need to do it once */
1622 es->psz_language_code = LanguageGetCode( es->fmt.psz_language );
1623 es->p_dec = NULL;
1624 es->p_dec_record = NULL;
1625 es->cc.type = 0;
1626 es->cc.i_bitmap = 0;
1627 es->p_master = p_master;
1628
1629 vlc_list_append(&es->node, es->p_master ? &p_sys->es_slaves : &p_sys->es);
1630
1631 if( es->p_pgrm == p_sys->p_pgrm )
1632 EsOutESVarUpdate( out, es, false );
1633
1634 EsOutUpdateInfo( out, es, &es->fmt, NULL );
1635 EsOutSelect( out, es, false );
1636
1637 if( es->b_scrambled )
1638 EsOutProgramUpdateScrambled( out, es->p_pgrm );
1639
1640 return es;
1641 }
1642
1643 /* EsOutAdd:
1644 * Add an es_out
1645 */
1646 static es_out_id_t *EsOutAdd( es_out_t *out, const es_format_t *fmt )
1647 {
1648 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1649 vlc_mutex_lock( &p_sys->lock );
1650 es_out_id_t *es = EsOutAddSlaveLocked( out, fmt, NULL );
1651 vlc_mutex_unlock( &p_sys->lock );
1652 return es;
1653 }
1654
1655 static bool EsIsSelected( es_out_id_t *es )
1656 {
1657 if( es->p_master )
1658 {
1659 bool b_decode = false;
1660 if( es->p_master->p_dec )
1661 {
1662 int i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
1663 input_DecoderGetCcState( es->p_master->p_dec, es->fmt.i_codec,
1664 i_channel, &b_decode );
1665 }
1666 return b_decode;
1667 }
1668 else
1669 {
1670 return es->p_dec != NULL;
1671 }
1672 }
1673 static void EsCreateDecoder( es_out_t *out, es_out_id_t *p_es )
1674 {
1675 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1676 input_thread_t *p_input = p_sys->p_input;
1677 decoder_t *dec;
1678
1679 dec = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_input_clock,
1680 input_priv(p_input)->p_sout );
1681 if( dec != NULL )
1682 {
1683 float rate = (float)p_sys->i_rate / (float)INPUT_RATE_DEFAULT;
1684
1685 input_DecoderChangeRate( dec, rate );
1686
1687 if( p_sys->b_buffering )
1688 input_DecoderStartWait( dec );
1689
1690 if( !p_es->p_master && p_sys->p_sout_record )
1691 {
1692 p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_input_clock, p_sys->p_sout_record );
1693 if( p_es->p_dec_record && p_sys->b_buffering )
1694 input_DecoderStartWait( p_es->p_dec_record );
1695 }
1696 }
1697 p_es->p_dec = dec;
1698
1699 EsOutDecoderChangeDelay( out, p_es );
1700 }
1701 static void EsDestroyDecoder( es_out_t *out, es_out_id_t *p_es )
1702 {
1703 VLC_UNUSED(out);
1704
1705 if( !p_es->p_dec )
1706 return;
1707
1708 input_DecoderDelete( p_es->p_dec );
1709 p_es->p_dec = NULL;
1710
1711 if( p_es->p_dec_record )
1712 {
1713 input_DecoderDelete( p_es->p_dec_record );
1714 p_es->p_dec_record = NULL;
1715 }
1716 }
1717
1718 static void EsSelect( es_out_t *out, es_out_id_t *es )
1719 {
1720 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1721 input_thread_t *p_input = p_sys->p_input;
1722
1723 if( EsIsSelected( es ) )
1724 {
1725 msg_Warn( p_input, "ES 0x%x is already selected", es->i_id );
1726 return;
1727 }
1728
1729 if( es->p_master )
1730 {
1731 int i_channel;
1732 if( !es->p_master->p_dec )
1733 return;
1734
1735 i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
1736
1737 if( i_channel == -1 ||
1738 input_DecoderSetCcState( es->p_master->p_dec, es->fmt.i_codec,
1739 i_channel, true ) )
1740 return;
1741 }
1742 else
1743 {
1744 const bool b_sout = input_priv(p_input)->p_sout != NULL;
1745 /* If b_forced, the ES is specifically requested by the user, so bypass
1746 * the following vars check. */
1747 if( !es->b_forced )
1748 {
1749 if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES )
1750 {
1751 if( !var_GetBool( p_input, b_sout ? "sout-video" : "video" ) )
1752 {
1753 msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x",
1754 es->i_id );
1755 return;
1756 }
1757 }
1758 else if( es->fmt.i_cat == AUDIO_ES )
1759 {
1760 if( !var_GetBool( p_input, b_sout ? "sout-audio" : "audio" ) )
1761 {
1762 msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x",
1763 es->i_id );
1764 return;
1765 }
1766 }
1767 if( es->fmt.i_cat == SPU_ES )
1768 {
1769 if( !var_GetBool( p_input, b_sout ? "sout-spu" : "spu" ) )
1770 {
1771 msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x",
1772 es->i_id );
1773 return;
1774 }
1775 }
1776 }
1777
1778 EsCreateDecoder( out, es );
1779
1780 if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm )
1781 return;
1782 }
1783
1784 /* Mark it as selected */
1785 input_SendEventEsSelect( p_input, es->fmt.i_cat, es->i_id );
1786 input_SendEventTeletextSelect( p_input, EsFmtIsTeletext( &es->fmt ) ? es->i_id : -1 );
1787 }
1788
1789 static void EsDeleteCCChannels( es_out_t *out, es_out_id_t *parent )
1790 {
1791 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1792 input_thread_t *p_input = p_sys->p_input;
1793
1794 if( parent->cc.type == 0 )
1795 return;
1796
1797 es_out_id_t *spu_es = EsOutGetSelectedCat( out, SPU_ES );
1798 const int i_spu_id = spu_es ? spu_es->i_id : -1;
1799
1800 uint64_t i_bitmap = parent->cc.i_bitmap;
1801 for( int i = 0; i_bitmap > 0; i++, i_bitmap >>= 1 )
1802 {
1803 if( (i_bitmap & 1) == 0 || !parent->cc.pp_es[i] )
1804 continue;
1805
1806 if( i_spu_id == parent->cc.pp_es[i]->i_id )
1807 {
1808 /* Force unselection of the CC */
1809 input_SendEventEsSelect( p_input, SPU_ES, -1 );
1810 }
1811 EsOutDelLocked( out, parent->cc.pp_es[i] );
1812 }
1813
1814 parent->cc.i_bitmap = 0;
1815 parent->cc.type = 0;
1816 }
1817
1818 static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update )
1819 {
1820 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1821 input_thread_t *p_input = p_sys->p_input;
1822
1823 if( !EsIsSelected( es ) )
1824 {
1825 msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id );
1826 return;
1827 }
1828
1829 if( es->p_master )
1830 {
1831 if( es->p_master->p_dec )
1832 {
1833 int i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
1834 if( i_channel != -1 )
1835 input_DecoderSetCcState( es->p_master->p_dec, es->fmt.i_codec,
1836 i_channel, false );
1837 }
1838 }
1839 else
1840 {
1841 EsDeleteCCChannels( out, es );
1842 EsDestroyDecoder( out, es );
1843 }
1844
1845 if( !b_update )
1846 return;
1847
1848 /* Mark it as unselected */
1849 input_SendEventEsSelect( p_input, es->fmt.i_cat, -1 );
1850 if( EsFmtIsTeletext( &es->fmt ) )
1851 input_SendEventTeletextSelect( p_input, -1 );
1852 }
1853
1854 /**
1855 * Select an ES given the current mode
1856 * XXX: you need to take a the lock before (stream.stream_lock)
1857 *
1858 * \param out The es_out structure
1859 * \param es es_out_id structure
1860 * \param b_force ...
1861 * \return nothing
1862 */
1863 static void EsOutSelect( es_out_t *out, es_out_id_t *es, bool b_force )
1864 {
1865 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
1866 es_out_es_props_t *p_esprops = GetPropsByCat( p_sys, es->fmt.i_cat );
1867
1868 if( !p_sys->b_active ||
1869 ( !b_force && es->fmt.i_priority < ES_PRIORITY_SELECTABLE_MIN ) )
1870 {
1871 return;
1872 }
1873
1874 bool b_auto_unselect = p_esprops && p_sys->i_mode == ES_OUT_MODE_AUTO &&
1875 p_esprops->e_policy == ES_OUT_ES_POLICY_EXCLUSIVE &&
1876 p_esprops->p_main_es && p_esprops->p_main_es != es;
1877
1878 if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force )
1879 {
1880 if( !EsIsSelected( es ) )
1881 {
1882 if( b_auto_unselect )
1883 EsUnselect( out, p_esprops->p_main_es, false );
1884
1885 EsSelect( out, es );
1886 }
1887 }
1888 else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL )
1889 {
1890 char *prgms = var_GetNonEmptyString( p_sys->p_input, "programs" );
1891 if( prgms != NULL )
1892 {
1893 char *buf;
1894
1895 for ( const char *prgm = strtok_r( prgms, ",", &buf );
1896 prgm != NULL;
1897 prgm = strtok_r( NULL, ",", &buf ) )
1898 {
1899 if( atoi( prgm ) == es->p_pgrm->i_id || b_force )
1900 {
1901 if( !EsIsSelected( es ) )
1902 EsSelect( out, es );
1903 break;
1904 }
1905 }
1906 free( prgms );
1907 }
1908 }
1909 else if( p_sys->i_mode == ES_OUT_MODE_AUTO )
1910 {
1911 const es_out_id_t *wanted_es = NULL;
1912
1913 if( es->p_pgrm != p_sys->p_pgrm || !p_esprops )
1914 return;
1915
1916 /* user designated by ID ES have higher prio than everything */
1917 if ( p_esprops->i_id >= 0 )
1918 {
1919 if( es->i_id == p_esprops->i_id )
1920 wanted_es = es;
1921 }
1922 /* then per pos */
1923 else if( p_esprops->i_channel >= 0 )
1924 {
1925 if( p_esprops->i_channel == es->i_channel )
1926 wanted_es = es;
1927 }
1928 else if( p_esprops->ppsz_language )
1929 {
1930 /* If not deactivated */
1931 const int i_stop_idx = LanguageArrayIndex( p_esprops->ppsz_language, "none" );
1932 {
1933 int current_es_idx = ( p_esprops->p_main_es == NULL ) ? -1 :
1934 LanguageArrayIndex( p_esprops->ppsz_language,
1935 p_esprops->p_main_es->psz_language_code );
1936 int es_idx = LanguageArrayIndex( p_esprops->ppsz_language,
1937 es->psz_language_code );
1938 if( es_idx >= 0 && (i_stop_idx < 0 || i_stop_idx > es_idx) )
1939 {
1940 /* Only select the language if it's in the list */
1941 if( p_esprops->p_main_es == NULL ||
1942 current_es_idx < 0 || /* current es was not selected by lang prefs */
1943 es_idx < current_es_idx || /* current es has lower lang prio */
1944 ( es_idx == current_es_idx && /* lang is same, but es has higher prio */
1945 p_esprops->p_main_es->fmt.i_priority < es->fmt.i_priority ) )
1946 {
1947 wanted_es = es;
1948 }
1949 }
1950 /* We did not find a language matching our prefs */
1951 else if( i_stop_idx < 0 ) /* If not fallback disabled by 'none' */
1952 {
1953 /* Select if asked by demuxer */
1954 if( current_es_idx < 0 ) /* No es is currently selected by lang pref */
1955 {
1956 /* If demux has specified a track */
1957 if( p_esprops->i_demux_id >= 0 && es->i_id == p_esprops->i_demux_id )
1958 {
1959 wanted_es = es;
1960 }
1961 /* Otherwise, fallback by priority */
1962 else if( p_esprops->p_main_es == NULL ||
1963 es->fmt.i_priority > p_esprops->p_main_es->fmt.i_priority )
1964 {
1965 if( p_esprops->b_autoselect )
1966 wanted_es = es;
1967 }
1968 }
1969 }
1970 }
1971
1972 }
1973 /* If there is no user preference, select the default subtitle
1974 * or adapt by ES priority */
1975 else if( p_esprops->i_demux_id >= 0 && es->i_id == p_esprops->i_demux_id )
1976 {
1977 wanted_es = es;
1978 }
1979 else if( p_esprops->p_main_es == NULL ||
1980 es->fmt.i_priority > p_esprops->p_main_es->fmt.i_priority )
1981 {
1982 if( p_esprops->b_autoselect )
1983 wanted_es = es;
1984 }
1985
1986 if( wanted_es == es && !EsIsSelected( es ) )
1987 {
1988 if( b_auto_unselect )
1989 EsUnselect( out, p_esprops->p_main_es, false );
1990
1991 EsSelect( out, es );
1992 }
1993 }
1994
1995 /* FIXME TODO handle priority here */
1996 if( p_esprops && p_sys->i_mode == ES_OUT_MODE_AUTO && EsIsSelected( es ) )
1997 p_esprops->p_main_es = es;
1998 }
1999
2000 static void EsOutCreateCCChannels( es_out_t *out, vlc_fourcc_t codec, uint64_t i_bitmap,
2001 const char *psz_descfmt, es_out_id_t *parent )
2002 {
2003 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2004 input_thread_t *p_input = p_sys->p_input;
2005
2006 /* Only one type of captions is allowed ! */
2007 if( parent->cc.type && parent->cc.type != codec )
2008 return;
2009
2010 uint64_t i_existingbitmap = parent->cc.i_bitmap;
2011 for( int i = 0; i_bitmap > 0; i++, i_bitmap >>= 1, i_existingbitmap >>= 1 )
2012 {
2013 es_format_t fmt;
2014
2015 if( (i_bitmap & 1) == 0 || (i_existingbitmap & 1) )
2016 continue;
2017
2018 msg_Dbg( p_input, "Adding CC track %d for es[%d]", 1+i, parent->i_id );
2019
2020 es_format_Init( &fmt, SPU_ES, codec );
2021 fmt.subs.cc.i_channel = i;
2022 fmt.i_group = parent->fmt.i_group;
2023 if( asprintf( &fmt.psz_description, psz_descfmt, 1 + i ) == -1 )
2024 fmt.psz_description = NULL;
2025
2026 es_out_id_t **pp_es = &parent->cc.pp_es[i];
2027 *pp_es = EsOutAddSlaveLocked( out, &fmt, parent );
2028 es_format_Clean( &fmt );
2029
2030 /* */
2031 parent->cc.i_bitmap |= (1ULL << i);
2032 parent->cc.type = codec;
2033
2034 /* Enable if user specified on command line */
2035 if (p_sys->sub.i_channel == i)
2036 EsOutSelect(out, *pp_es, true);
2037 }
2038 }
2039
2040 /**
2041 * Send a block for the given es_out
2042 *
2043 * \param out the es_out to send from
2044 * \param es the es_out_id
2045 * \param p_block the data block to send
2046 */
2047 static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
2048 {
2049 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2050 input_thread_t *p_input = p_sys->p_input;
2051
2052 assert( p_block->p_next == NULL );
2053
2054 struct input_stats *stats = input_priv(p_input)->stats;
2055 if( stats != NULL )
2056 {
2057 input_rate_Add( &stats->demux_bitrate, p_block->i_buffer );
2058
2059 /* Update number of corrupted data packats */
2060 if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
2061 atomic_fetch_add_explicit(&stats->demux_corrupted, 1,
2062 memory_order_relaxed);
2063
2064 /* Update number of discontinuities */
2065 if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
2066 atomic_fetch_add_explicit(&stats->demux_discontinuity, 1,
2067 memory_order_relaxed);
2068 }
2069
2070 vlc_mutex_lock( &p_sys->lock );
2071
2072 /* Mark preroll blocks */
2073 if( p_sys->i_preroll_end >= 0 )
2074 {
2075 vlc_tick_t i_date = p_block->i_pts;
2076 if( p_block->i_pts == VLC_TICK_INVALID )
2077 i_date = p_block->i_dts;
2078
2079 if( i_date + p_block->i_length < p_sys->i_preroll_end )
2080 p_block->i_flags |= BLOCK_FLAG_PREROLL;
2081 }
2082
2083 if( !es->p_dec )
2084 {
2085 block_Release( p_block );
2086 vlc_mutex_unlock( &p_sys->lock );
2087 return VLC_SUCCESS;
2088 }
2089
2090 /* Check for sout mode */
2091 if( input_priv(p_input)->p_sout )
2092 {
2093 /* FIXME review this, proper lock may be missing */
2094 if( input_priv(p_input)->p_sout->i_out_pace_nocontrol > 0 &&
2095 input_priv(p_input)->b_out_pace_control )
2096 {
2097 msg_Dbg( p_input, "switching to sync mode" );
2098 input_priv(p_input)->b_out_pace_control = false;
2099 }
2100 else if( input_priv(p_input)->p_sout->i_out_pace_nocontrol <= 0 &&
2101 !input_priv(p_input)->b_out_pace_control )
2102 {
2103 msg_Dbg( p_input, "switching to async mode" );
2104 input_priv(p_input)->b_out_pace_control = true;
2105 }
2106 }
2107
2108 /* Decode */
2109 if( es->p_dec_record )
2110 {
2111 block_t *p_dup = block_Duplicate( p_block );
2112 if( p_dup )
2113 input_DecoderDecode( es->p_dec_record, p_dup,
2114 input_priv(p_input)->b_out_pace_control );
2115 }
2116 input_DecoderDecode( es->p_dec, p_block,
2117 input_priv(p_input)->b_out_pace_control );
2118
2119 es_format_t fmt_dsc;
2120 vlc_meta_t *p_meta_dsc;
2121 if( input_DecoderHasFormatChanged( es->p_dec, &fmt_dsc, &p_meta_dsc ) )
2122 {
2123 EsOutUpdateInfo( out, es, &fmt_dsc, p_meta_dsc );
2124
2125 es_format_Clean( &fmt_dsc );
2126 if( p_meta_dsc )
2127 vlc_meta_Delete( p_meta_dsc );
2128 }
2129
2130 /* Check CC status */
2131 decoder_cc_desc_t desc;
2132
2133 input_DecoderGetCcDesc( es->p_dec, &desc );
2134 if( var_InheritInteger( p_input, "captions" ) == 708 )
2135 EsOutCreateCCChannels( out, VLC_CODEC_CEA708, desc.i_708_channels,
2136 _("DTVCC Closed captions %u"), es );
2137 EsOutCreateCCChannels( out, VLC_CODEC_CEA608, desc.i_608_channels,
2138 _("Closed captions %u"), es );
2139
2140 vlc_mutex_unlock( &p_sys->lock );
2141
2142 return VLC_SUCCESS;
2143 }
2144
2145 /*****************************************************************************
2146 * EsOutDelLocked:
2147 *****************************************************************************/
2148 static void EsOutDelLocked( es_out_t *out, es_out_id_t *es )
2149 {
2150 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2151 bool b_reselect = false;
2152
2153 es_out_es_props_t *p_esprops = GetPropsByCat( p_sys, es->fmt.i_cat );
2154
2155 /* We don't try to reselect */
2156 if( es->p_dec )
2157 { /* FIXME: This might hold the ES output caller (i.e. the demux), and
2158 * the corresponding thread (typically the input thread), for a little
2159 * bit too long if the ES is deleted in the middle of a stream. */
2160 input_DecoderDrain( es->p_dec );
2161 while( !input_Stopped(p_sys->p_input) && !p_sys->b_buffering )
2162 {
2163 if( input_DecoderIsEmpty( es->p_dec ) &&
2164 ( !es->p_dec_record || input_DecoderIsEmpty( es->p_dec_record ) ))
2165 break;
2166 /* FIXME there should be a way to have auto deleted es, but there will be
2167 * a problem when another codec of the same type is created (mainly video) */
2168 vlc_tick_sleep(VLC_TICK_FROM_MS(20));
2169 }
2170 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
2171 }
2172
2173 if( es->p_pgrm == p_sys->p_pgrm )
2174 EsOutESVarUpdate( out, es, true );
2175
2176 EsDeleteInfo( out, es );
2177
2178 vlc_list_remove(&es->node);
2179
2180 /* Update program */
2181 es->p_pgrm->i_es--;
2182 if( es->p_pgrm->i_es == 0 )
2183 msg_Dbg( p_sys->p_input, "Program doesn't contain anymore ES" );
2184
2185 if( es->b_scrambled )
2186 EsOutProgramUpdateScrambled( out, es->p_pgrm );
2187
2188 /* */
2189 if( p_esprops )
2190 {
2191 if( p_esprops->p_main_es == es )
2192 {
2193 b_reselect = true;
2194 p_esprops->p_main_es = NULL;
2195 }
2196 p_esprops->i_count--;
2197 }
2198
2199 /* Re-select another track when needed */
2200 if( b_reselect )
2201 {
2202 es_out_id_t *other;
2203
2204 foreach_es_then_es_slaves(other)
2205 if( es->fmt.i_cat == other->fmt.i_cat )
2206 {
2207 if (EsIsSelected(other))
2208 {
2209 input_SendEventEsSelect(p_sys->p_input, es->fmt.i_cat,
2210 other->i_id);
2211 if( p_esprops->p_main_es == NULL )
2212 p_esprops->p_main_es = other;
2213 }
2214 else
2215 EsOutSelect(out, other, false);
2216 }
2217 }
2218
2219 free( es->psz_language );
2220 free( es->psz_language_code );
2221
2222 es_format_Clean( &es->fmt );
2223
2224 free( es );
2225 }
2226
2227 static void EsOutDel( es_out_t *out, es_out_id_t *es )
2228 {
2229 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2230 vlc_mutex_lock( &p_sys->lock );
2231 EsOutDelLocked( out, es );
2232 vlc_mutex_unlock( &p_sys->lock );
2233 }
2234
2235 static int EsOutVaControlLocked( es_out_t *, int, va_list );
2236 static int EsOutControlLocked( es_out_t *out, int i_query, ... )
2237 {
2238 va_list args;
2239
2240 va_start( args, i_query );
2241 int ret = EsOutVaControlLocked( out, i_query, args );
2242 va_end( args );
2243 return ret;
2244 }
2245
2246 /**
2247 * Control query handler
2248 *
2249 * \param out the es_out to control
2250 * \param i_query A es_out query as defined in include/ninput.h
2251 * \param args a variable list of arguments for the query
2252 * \return VLC_SUCCESS or an error code
2253 */
2254 static int EsOutVaControlLocked( es_out_t *out, int i_query, va_list args )
2255 {
2256 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2257
2258 switch( i_query )
2259 {
2260 case ES_OUT_SET_ES_STATE:
2261 {
2262 es_out_id_t *es = va_arg( args, es_out_id_t * );
2263 bool b = va_arg( args, int );
2264 if( b && !EsIsSelected( es ) )
2265 {
2266 EsSelect( out, es );
2267 return EsIsSelected( es ) ? VLC_SUCCESS : VLC_EGENERIC;
2268 }
2269 else if( !b && EsIsSelected( es ) )
2270 {
2271 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
2272 return VLC_SUCCESS;
2273 }
2274 return VLC_SUCCESS;
2275 }
2276
2277 case ES_OUT_GET_ES_STATE:
2278 {
2279 es_out_id_t *es = va_arg( args, es_out_id_t * );
2280 bool *pb = va_arg( args, bool * );
2281
2282 *pb = EsIsSelected( es );
2283 return VLC_SUCCESS;
2284 }
2285
2286 case ES_OUT_SET_ES_CAT_POLICY:
2287 {
2288 enum es_format_category_e i_cat = va_arg( args, enum es_format_category_e );
2289 enum es_out_policy_e i_pol = va_arg( args, enum es_out_policy_e );
2290 es_out_es_props_t *p_esprops = GetPropsByCat( p_sys, i_cat );
2291 if( p_esprops == NULL )
2292 return VLC_EGENERIC;
2293 p_esprops->e_policy = i_pol;
2294 return VLC_SUCCESS;
2295 }
2296
2297 case ES_OUT_GET_GROUP_FORCED:
2298 {
2299 int *pi_group = va_arg( args, int * );
2300 *pi_group = p_sys->i_group_id;
2301 return VLC_SUCCESS;
2302 }
2303
2304 case ES_OUT_SET_MODE:
2305 {
2306 const int i_mode = va_arg( args, int );
2307 assert( i_mode == ES_OUT_MODE_NONE || i_mode == ES_OUT_MODE_ALL ||
2308 i_mode == ES_OUT_MODE_AUTO || i_mode == ES_OUT_MODE_PARTIAL ||
2309 i_mode == ES_OUT_MODE_END );
2310
2311 if (i_mode != ES_OUT_MODE_NONE && !p_sys->b_active && !vlc_list_is_empty(&p_sys->es))
2312 {
2313 /* XXX Terminate vout if there are tracks but no video one.
2314 * This one is not mandatory but is he earliest place where it
2315 * can be done */
2316 es_out_id_t *p_es;
2317 bool found = false;
2318
2319 foreach_es_then_es_slaves(p_es)
2320 if( p_es->fmt.i_cat == VIDEO_ES && !found /* nested loop */ )
2321 {
2322 found = true;
2323 break;
2324 }
2325
2326 if (!found)
2327 input_resource_TerminateVout( input_priv(p_sys->p_input)->p_resource );
2328 }
2329 p_sys->b_active = i_mode != ES_OUT_MODE_NONE;
2330 p_sys->i_mode = i_mode;
2331
2332 /* Reapply policy mode */
2333 es_out_id_t *es;
2334
2335 foreach_es_then_es_slaves(es)
2336 {
2337 if (EsIsSelected(es))
2338 EsUnselect(out, es, es->p_pgrm == p_sys->p_pgrm);
2339 }
2340 foreach_es_then_es_slaves(es)
2341 {
2342 EsOutSelect(out, es, false);
2343 }
2344
2345 if( i_mode == ES_OUT_MODE_END )
2346 EsOutTerminate( out );
2347 return VLC_SUCCESS;
2348 }
2349
2350 case ES_OUT_SET_ES:
2351 case ES_OUT_RESTART_ES:
2352 {
2353 #define IGNORE_ES DATA_ES
2354 es_out_id_t *es = va_arg( args, es_out_id_t * ), *other;
2355
2356 enum es_format_category_e i_cat;
2357 if( es == NULL )
2358 i_cat = UNKNOWN_ES;
2359 else if( es == es_cat + AUDIO_ES )
2360 i_cat = AUDIO_ES;
2361 else if( es == es_cat + VIDEO_ES )
2362 i_cat = VIDEO_ES;
2363 else if( es == es_cat + SPU_ES )
2364 i_cat = SPU_ES;
2365 else
2366 i_cat = IGNORE_ES;
2367
2368 foreach_es_then_es_slaves(other)
2369 {
2370 if( i_cat == IGNORE_ES )
2371 {
2372 if (es == other)
2373 {
2374 if (i_query == ES_OUT_RESTART_ES && es->p_dec != NULL)
2375 {
2376 EsDestroyDecoder(out, es);
2377 EsCreateDecoder(out, es);
2378 }
2379 else if( i_query == ES_OUT_SET_ES )
2380 {
2381 EsOutSelect(out, es, true);
2382 }
2383 break;
2384 }
2385 }
2386 else if (i_cat == UNKNOWN_ES || other->fmt.i_cat == i_cat)
2387 {
2388 if (EsIsSelected(other))
2389 {
2390 if (i_query == ES_OUT_RESTART_ES)
2391 {
2392 if (other->p_dec != NULL)
2393 {
2394 EsDestroyDecoder(out, other);
2395 EsCreateDecoder(out, other);
2396 }
2397 }
2398 else
2399 EsUnselect(out, other, other->p_pgrm == p_sys->p_pgrm);
2400 }
2401 }
2402 }
2403
2404 return VLC_SUCCESS;
2405 }
2406 case ES_OUT_UNSET_ES:
2407 {
2408 es_out_id_t *es = va_arg( args, es_out_id_t * ), *other;
2409 foreach_es_then_es_slaves(other)
2410 {
2411 if (es == other)
2412 {
2413 if (EsIsSelected(other))
2414 {
2415 EsUnselect(out, other, other->p_pgrm == p_sys->p_pgrm);
2416 return VLC_SUCCESS;
2417 }
2418 break;
2419 }
2420 }
2421 return VLC_EGENERIC;
2422 }
2423 case ES_OUT_STOP_ALL_ES:
2424 {
2425 es_out_id_t *es;
2426 int count = 0;
2427
2428 foreach_es_then_es_slaves(es)
2429 count++;
2430
2431 int *selected_es = vlc_alloc(count + 1, sizeof(int));
2432 if (!selected_es)
2433 return VLC_ENOMEM;
2434
2435 *va_arg(args, void **) = selected_es;
2436 *selected_es = count;
2437
2438 foreach_es_then_es_slaves(es)
2439 {
2440 if (EsIsSelected(es))
2441 {
2442 EsDestroyDecoder(out, es);
2443 *++selected_es = es->i_id;
2444 }
2445 else
2446 *++selected_es = -1;
2447 }
2448 return VLC_SUCCESS;
2449 }
2450 case ES_OUT_START_ALL_ES:
2451 {
2452 int *selected_es = va_arg( args, void * );
2453 int count = selected_es[0];
2454 for( int i = 0; i < count; ++i )
2455 {
2456 int i_id = selected_es[i + 1];
2457 if( i_id != -1 )
2458 {
2459 es_out_id_t *p_es = EsOutGetFromID( out, i_id );
2460 EsCreateDecoder( out, p_es );
2461 }
2462 }
2463 free(selected_es);
2464 return VLC_SUCCESS;
2465 }
2466
2467 case ES_OUT_SET_ES_DEFAULT:
2468 {
2469 es_out_id_t *es = va_arg( args, es_out_id_t * );
2470
2471 if( es == NULL )
2472 {
2473 /*p_sys->i_default_video_id = -1;*/
2474 /*p_sys->i_default_audio_id = -1;*/
2475 p_sys->sub.i_demux_id = -1;
2476 }
2477 else if( es == es_cat + AUDIO_ES )
2478 {
2479 /*p_sys->i_default_video_id = -1;*/
2480 }
2481 else if( es == es_cat + VIDEO_ES )
2482 {
2483 /*p_sys->i_default_audio_id = -1;*/
2484 }
2485 else if( es == es_cat + SPU_ES )
2486 {
2487 p_sys->sub.i_demux_id = -1;
2488 }
2489 else
2490 {
2491 /*if( es->fmt.i_cat == VIDEO_ES )
2492 p_sys->i_default_video_id = es->i_id;
2493 else
2494 if( es->fmt.i_cat == AUDIO_ES )
2495 p_sys->i_default_audio_id = es->i_id;
2496 else*/
2497 if( es->fmt.i_cat == SPU_ES )
2498 p_sys->sub.i_demux_id = es->i_id;
2499 }
2500 return VLC_SUCCESS;
2501 }
2502
2503 case ES_OUT_SET_PCR:
2504 case ES_OUT_SET_GROUP_PCR:
2505 {
2506 es_out_pgrm_t *p_pgrm = NULL;
2507 int i_group = 0;
2508 vlc_tick_t i_pcr;
2509
2510 /* Search program */
2511 if( i_query == ES_OUT_SET_PCR )
2512 {
2513 p_pgrm = p_sys->p_pgrm;
2514 if( !p_pgrm )
2515 p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */
2516 }
2517 else
2518 {
2519 i_group = va_arg( args, int );
2520 p_pgrm = EsOutProgramFind( out, i_group );
2521 }
2522 if( !p_pgrm )
2523 return VLC_EGENERIC;
2524
2525 i_pcr = va_arg( args, vlc_tick_t );
2526 if( i_pcr == VLC_TICK_INVALID )
2527 {
2528 msg_Err( p_sys->p_input, "Invalid PCR value in ES_OUT_SET_(GROUP_)PCR !" );
2529 return VLC_EGENERIC;
2530 }
2531
2532 /* TODO do not use vlc_tick_now() but proper stream acquisition date */
2533 bool b_late;
2534 input_clock_Update( p_pgrm->p_input_clock, VLC_OBJECT(p_sys->p_input),
2535 &b_late,
2536 input_priv(p_sys->p_input)->b_can_pace_control || p_sys->b_buffering,
2537 EsOutIsExtraBufferingAllowed( out ),
2538 i_pcr, vlc_tick_now() );
2539
2540 if( !p_sys->p_pgrm )
2541 return VLC_SUCCESS;
2542
2543 if( p_sys->b_buffering )
2544 {
2545 /* Check buffering state on master clock update */
2546 EsOutDecodersStopBuffering( out, false );
2547 }
2548 else if( p_pgrm == p_sys->p_pgrm )
2549 {
2550 if( b_late && ( !input_priv(p_sys->p_input)->p_sout ||
2551 !input_priv(p_sys->p_input)->b_out_pace_control ) )
2552 {
2553 const vlc_tick_t i_pts_delay_base = p_sys->i_pts_delay - p_sys->i_pts_jitter;
2554 vlc_tick_t i_pts_delay = input_clock_GetJitter( p_pgrm->p_input_clock );
2555
2556 /* Avoid dangerously high value */
2557 const vlc_tick_t i_jitter_max =
2558 VLC_TICK_FROM_MS(var_InheritInteger( p_sys->p_input, "clock-jitter" ));
2559 if( i_pts_delay > __MIN( i_pts_delay_base + i_jitter_max, INPUT_PTS_DELAY_MAX ) )
2560 {
2561 es_out_pgrm_t *pgrm;
2562
2563 msg_Err( p_sys->p_input,
2564 "ES_OUT_SET_(GROUP_)PCR is called too late (jitter of %d ms ignored)",
2565 (int)MS_FROM_VLC_TICK(i_pts_delay - i_pts_delay_base) );
2566 i_pts_delay = p_sys->i_pts_delay;
2567
2568 /* reset clock */
2569 vlc_list_foreach(pgrm, &p_sys->programs, node)
2570 input_clock_Reset(pgrm->p_input_clock);
2571 }
2572 else
2573 {
2574 msg_Err( p_sys->p_input,
2575 "ES_OUT_SET_(GROUP_)PCR is called too late (pts_delay increased to %d ms)",
2576 (int)MS_FROM_VLC_TICK(i_pts_delay) );
2577
2578 /* Force a rebufferization when we are too late */
2579
2580 /* It is not really good, as we throw away already buffered data
2581 * TODO have a mean to correctly reenter bufferization */
2582 EsOutControlLocked( out, ES_OUT_RESET_PCR );
2583 }
2584
2585 es_out_SetJitter( out, i_pts_delay_base, i_pts_delay - i_pts_delay_base, p_sys->i_cr_average );
2586 }
2587 }
2588 return VLC_SUCCESS;
2589 }
2590
2591 case ES_OUT_RESET_PCR:
2592 msg_Dbg( p_sys->p_input, "ES_OUT_RESET_PCR called" );
2593 EsOutChangePosition( out );
2594 return VLC_SUCCESS;
2595
2596 case ES_OUT_SET_GROUP:
2597 {
2598 int i = va_arg( args, int );
2599 es_out_pgrm_t *p_pgrm;
2600
2601 vlc_list_foreach(p_pgrm, &p_sys->programs, node)
2602 if( p_pgrm->i_id == i )
2603 {
2604 EsOutProgramSelect( out, p_pgrm );
2605 return VLC_SUCCESS;
2606 }
2607 return VLC_EGENERIC;
2608 }
2609
2610 case ES_OUT_SET_ES_FMT:
2611 {
2612 /* This ain't pretty but is need by some demuxers (eg. Ogg )
2613 * to update the p_extra data */
2614 es_out_id_t *es = va_arg( args, es_out_id_t * );
2615 es_format_t *p_fmt = va_arg( args, es_format_t * );
2616 if( es == NULL )
2617 return VLC_EGENERIC;
2618
2619 es_format_Clean( &es->fmt );
2620 es_format_Copy( &es->fmt, p_fmt );
2621
2622 if( es->p_dec )
2623 {
2624 EsDestroyDecoder( out, es );
2625 EsCreateDecoder( out, es );
2626 }
2627
2628 return VLC_SUCCESS;
2629 }
2630
2631 case ES_OUT_SET_ES_SCRAMBLED_STATE:
2632 {
2633 es_out_id_t *es = va_arg( args, es_out_id_t * );
2634 bool b_scrambled = (bool)va_arg( args, int );
2635
2636 if( !es->b_scrambled != !b_scrambled )
2637 {
2638 es->b_scrambled = b_scrambled;
2639 EsOutProgramUpdateScrambled( out, es->p_pgrm );
2640 }
2641 return VLC_SUCCESS;
2642 }
2643
2644 case ES_OUT_SET_NEXT_DISPLAY_TIME:
2645 {
2646 const int64_t i_date = va_arg( args, int64_t );
2647
2648 if( i_date < 0 )
2649 return VLC_EGENERIC;
2650
2651 p_sys->i_preroll_end = i_date;
2652
2653 return VLC_SUCCESS;
2654 }
2655 case ES_OUT_SET_GROUP_META:
2656 {
2657 int i_group = va_arg( args, int );
2658 const vlc_meta_t *p_meta = va_arg( args, const vlc_meta_t * );
2659
2660 EsOutProgramMeta( out, i_group, p_meta );
2661 return VLC_SUCCESS;
2662 }
2663 case ES_OUT_SET_GROUP_EPG:
2664 {
2665 int i_group = va_arg( args, int );
2666 const vlc_epg_t *p_epg = va_arg( args, const vlc_epg_t * );
2667
2668 EsOutProgramEpg( out, i_group, p_epg );
2669 return VLC_SUCCESS;
2670 }
2671 case ES_OUT_SET_GROUP_EPG_EVENT:
2672 {
2673 int i_group = va_arg( args, int );
2674 const vlc_epg_event_t *p_evt = va_arg( args, const vlc_epg_event_t * );
2675
2676 EsOutProgramEpgEvent( out, i_group, p_evt );
2677 return VLC_SUCCESS;
2678 }
2679 case ES_OUT_SET_EPG_TIME:
2680 {
2681 int64_t i64 = va_arg( args, int64_t );
2682
2683 EsOutEpgTime( out, i64 );
2684 return VLC_SUCCESS;
2685 }
2686
2687 case ES_OUT_DEL_GROUP:
2688 {
2689 int i_group = va_arg( args, int );
2690
2691 return EsOutProgramDel( out, i_group );
2692 }
2693
2694 case ES_OUT_SET_META:
2695 {
2696 const vlc_meta_t *p_meta = va_arg( args, const vlc_meta_t * );
2697
2698 EsOutGlobalMeta( out, p_meta );
2699 return VLC_SUCCESS;
2700 }
2701
2702 case ES_OUT_GET_WAKE_UP:
2703 {
2704 vlc_tick_t *pi_wakeup = va_arg( args, vlc_tick_t* );
2705 *pi_wakeup = EsOutGetWakeup( out );
2706 return VLC_SUCCESS;
2707 }
2708
2709 case ES_OUT_SET_ES_BY_ID:
2710 case ES_OUT_RESTART_ES_BY_ID:
2711 case ES_OUT_SET_ES_DEFAULT_BY_ID:
2712 {
2713 const int i_id = va_arg( args, int );
2714 es_out_id_t *p_es = EsOutGetFromID( out, i_id );
2715 int i_new_query = 0;
2716
2717 switch( i_query )
2718 {
2719 case ES_OUT_SET_ES_BY_ID: i_new_query = ES_OUT_SET_ES;
2720 p_es->b_forced = va_arg( args, int );
2721 break;
2722 case ES_OUT_RESTART_ES_BY_ID: i_new_query = ES_OUT_RESTART_ES; break;
2723 case ES_OUT_SET_ES_DEFAULT_BY_ID: i_new_query = ES_OUT_SET_ES_DEFAULT; break;
2724 default:
2725 vlc_assert_unreachable();
2726 }
2727 int i_ret = EsOutControlLocked( out, i_new_query, p_es );
2728
2729 /* Clean up vout after user action (in active mode only).
2730 * FIXME it does not work well with multiple video windows */
2731 if( p_sys->b_active )
2732 input_resource_TerminateVout( input_priv(p_sys->p_input)->p_resource );
2733 return i_ret;
2734 }
2735
2736 case ES_OUT_GET_ES_OBJECTS_BY_ID:
2737 {
2738 const int i_id = va_arg( args, int );
2739 es_out_id_t *p_es = EsOutGetFromID( out, i_id );
2740 if( !p_es )
2741 return VLC_EGENERIC;
2742
2743 vlc_object_t **pp_decoder = va_arg( args, vlc_object_t ** );
2744 vout_thread_t **pp_vout = va_arg( args, vout_thread_t ** );
2745 audio_output_t **pp_aout = va_arg( args, audio_output_t ** );
2746 if( p_es->p_dec )
2747 {
2748 if( pp_decoder )
2749 *pp_decoder = vlc_object_hold( p_es->p_dec );
2750 input_DecoderGetObjects( p_es->p_dec, pp_vout, pp_aout );
2751 }
2752 else
2753 {
2754 if( pp_decoder )
2755 *pp_decoder = NULL;
2756 if( pp_vout )
2757 *pp_vout = NULL;
2758 if( pp_aout )
2759 *pp_aout = NULL;
2760 }
2761 return VLC_SUCCESS;
2762 }
2763
2764 case ES_OUT_GET_BUFFERING:
2765 {
2766 bool *pb = va_arg( args, bool* );
2767 *pb = p_sys->b_buffering;
2768 return VLC_SUCCESS;
2769 }
2770
2771 case ES_OUT_GET_EMPTY:
2772 {
2773 bool *pb = va_arg( args, bool* );
2774 *pb = EsOutDecodersIsEmpty( out );
2775 return VLC_SUCCESS;
2776 }
2777
2778 case ES_OUT_SET_DELAY:
2779 {
2780 const int i_cat = va_arg( args, int );
2781 const vlc_tick_t i_delay = va_arg( args, vlc_tick_t );
2782 EsOutSetDelay( out, i_cat, i_delay );
2783 return VLC_SUCCESS;
2784 }
2785
2786 case ES_OUT_SET_RECORD_STATE:
2787 {
2788 bool b = va_arg( args, int );
2789 return EsOutSetRecord( out, b );
2790 }
2791
2792 case ES_OUT_SET_PAUSE_STATE:
2793 {
2794 const bool b_source_paused = (bool)va_arg( args, int );
2795 const bool b_paused = (bool)va_arg( args, int );
2796 const vlc_tick_t i_date = va_arg( args, vlc_tick_t );
2797
2798 assert( !b_source_paused == !b_paused );
2799 EsOutChangePause( out, b_paused, i_date );
2800
2801 return VLC_SUCCESS;
2802 }
2803
2804 case ES_OUT_SET_RATE:
2805 {
2806 const int i_src_rate = va_arg( args, int );
2807 const int i_rate = va_arg( args, int );
2808
2809 assert( i_src_rate == i_rate );
2810 EsOutChangeRate( out, i_rate );
2811
2812 return VLC_SUCCESS;
2813 }
2814
2815 case ES_OUT_SET_FRAME_NEXT:
2816 EsOutFrameNext( out );
2817 return VLC_SUCCESS;
2818
2819 case ES_OUT_SET_TIMES:
2820 {
2821 double f_position = va_arg( args, double );
2822 vlc_tick_t i_time = va_arg( args, vlc_tick_t );
2823 vlc_tick_t i_length = va_arg( args, vlc_tick_t );
2824
2825 input_SendEventLength( p_sys->p_input, i_length );
2826
2827 if( !p_sys->b_buffering )
2828 {
2829 vlc_tick_t i_delay;
2830
2831 /* Fix for buffering delay */
2832 if( !input_priv(p_sys->p_input)->p_sout ||
2833 !input_priv(p_sys->p_input)->b_out_pace_control )
2834 i_delay = EsOutGetBuffering( out );
2835 else
2836 i_delay = 0;
2837
2838 i_time -= i_delay;
2839 if( i_time < 0 )
2840 i_time = 0;
2841
2842 if( i_length > 0 )
2843 f_position -= (double)i_delay / i_length;
2844 if( f_position < 0 )
2845 f_position = 0;
2846
2847 input_SendEventPosition( p_sys->p_input, f_position, i_time );
2848 }
2849 return VLC_SUCCESS;
2850 }
2851 case ES_OUT_SET_JITTER:
2852 {
2853 vlc_tick_t i_pts_delay = va_arg( args, vlc_tick_t );
2854 vlc_tick_t i_pts_jitter = va_arg( args, vlc_tick_t );
2855 int i_cr_average = va_arg( args, int );
2856 es_out_pgrm_t *pgrm;
2857
2858 bool b_change_clock =
2859 i_pts_delay + i_pts_jitter != p_sys->i_pts_delay ||
2860 i_cr_average != p_sys->i_cr_average;
2861
2862 assert( i_pts_jitter >= 0 );
2863 p_sys->i_pts_delay = i_pts_delay + i_pts_jitter;
2864 p_sys->i_pts_jitter = i_pts_jitter;
2865 p_sys->i_cr_average = i_cr_average;
2866
2867 if (b_change_clock)
2868 vlc_list_foreach(pgrm, &p_sys->programs, node)
2869 input_clock_SetJitter(pgrm->p_input_clock, i_pts_delay
2870 + i_pts_jitter, i_cr_average);
2871 return VLC_SUCCESS;
2872 }
2873
2874 case ES_OUT_GET_PCR_SYSTEM:
2875 {
2876 if( p_sys->b_buffering )
2877 return VLC_EGENERIC;
2878
2879 es_out_pgrm_t *p_pgrm = p_sys->p_pgrm;
2880 if( !p_pgrm )
2881 return VLC_EGENERIC;
2882
2883 vlc_tick_t *pi_system = va_arg( args, vlc_tick_t *);
2884 vlc_tick_t *pi_delay = va_arg( args, vlc_tick_t *);
2885 input_clock_GetSystemOrigin( p_pgrm->p_input_clock, pi_system, pi_delay );
2886 return VLC_SUCCESS;
2887 }
2888
2889 case ES_OUT_MODIFY_PCR_SYSTEM:
2890 {
2891 if( p_sys->b_buffering )
2892 return VLC_EGENERIC;
2893
2894 es_out_pgrm_t *p_pgrm = p_sys->p_pgrm;
2895 if( !p_pgrm )
2896 return VLC_EGENERIC;
2897
2898 const bool b_absolute = va_arg( args, int );
2899 const vlc_tick_t i_system = va_arg( args, vlc_tick_t );
2900 input_clock_ChangeSystemOrigin( p_pgrm->p_input_clock, b_absolute, i_system );
2901 return VLC_SUCCESS;
2902 }
2903 case ES_OUT_SET_EOS:
2904 {
2905 es_out_id_t *id;
2906 foreach_es_then_es_slaves(id)
2907 if (id->p_dec != NULL)
2908 input_DecoderDrain(id->p_dec);
2909 return VLC_SUCCESS;
2910 }
2911
2912 case ES_OUT_POST_SUBNODE:
2913 {
2914 input_item_node_t *node = va_arg(args, input_item_node_t *);
2915 input_item_node_PostAndDelete(node);
2916 return VLC_SUCCESS;
2917 }
2918
2919 default:
2920 msg_Err( p_sys->p_input, "unknown query 0x%x in %s", i_query,
2921 __func__ );
2922 return VLC_EGENERIC;
2923 }
2924 }
2925 static int EsOutControl( es_out_t *out, int i_query, va_list args )
2926 {
2927 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
2928 int i_ret;
2929
2930 vlc_mutex_lock( &p_sys->lock );
2931 i_ret = EsOutVaControlLocked( out, i_query, args );
2932 vlc_mutex_unlock( &p_sys->lock );
2933
2934 return i_ret;
2935 }
2936
2937 static const struct es_out_callbacks es_out_cbs =
2938 {
2939 .add = EsOutAdd,
2940 .send = EsOutSend,
2941 .del = EsOutDel,
2942 .control = EsOutControl,
2943 .destroy = EsOutDelete,
2944 };
2945
2946 /****************************************************************************
2947 * LanguageGetName: try to expend iso639 into plain name
2948 ****************************************************************************/
2949 static char *LanguageGetName( const char *psz_code )
2950 {
2951 const iso639_lang_t *pl;
2952
2953 if( psz_code == NULL || !strcmp( psz_code, "und" ) )
2954 {
2955 return strdup( "" );
2956 }
2957
2958 if( strlen( psz_code ) == 2 )
2959 {
2960 pl = GetLang_1( psz_code );
2961 }
2962 else if( strlen( psz_code ) == 3 )
2963 {
2964 pl = GetLang_2B( psz_code );
2965 if( !strcmp( pl->psz_iso639_1, "??" ) )
2966 {
2967 pl = GetLang_2T( psz_code );
2968 }
2969 }
2970 else
2971 {
2972 char *lang = LanguageGetCode( psz_code );
2973 pl = GetLang_1( lang );
2974 free( lang );
2975 }
2976
2977 if( !strcmp( pl->psz_iso639_1, "??" ) )
2978 {
2979 return strdup( psz_code );
2980 }
2981 else
2982 {
2983 return strdup( vlc_gettext(pl->psz_eng_name) );
2984 }
2985 }
2986
2987 /* Get a 2 char code */
2988 static char *LanguageGetCode( const char *psz_lang )
2989 {
2990 const iso639_lang_t *pl;
2991
2992 if( psz_lang == NULL || *psz_lang == '\0' )
2993 return strdup("??");
2994
2995 for( pl = p_languages; pl->psz_eng_name != NULL; pl++ )
2996 {
2997 if( !strcasecmp( pl->psz_eng_name, psz_lang ) ||
2998 !strcasecmp( pl->psz_iso639_1, psz_lang ) ||
2999 !strcasecmp( pl->psz_iso639_2T, psz_lang ) ||
3000 !strcasecmp( pl->psz_iso639_2B, psz_lang ) )
3001 return strdup( pl->psz_iso639_1 );
3002 }
3003
3004 return strdup("??");
3005 }
3006
3007 static char **LanguageSplit( const char *psz_langs )
3008 {
3009 char *psz_dup;
3010 char *psz_parser;
3011 char **ppsz = NULL;
3012 int i_psz = 0;
3013
3014 if( psz_langs == NULL ) return NULL;
3015
3016 psz_parser = psz_dup = strdup(psz_langs);
3017
3018 while( psz_parser && *psz_parser )
3019 {
3020 char *psz;
3021 char *psz_code;
3022
3023 psz = strchr(psz_parser, ',' );
3024 if( psz ) *psz++ = '\0';
3025
3026 if( !strcmp( psz_parser, "any" ) )
3027 {
3028 TAB_APPEND( i_psz, ppsz, strdup("any") );
3029 }
3030 else if( !strcmp( psz_parser, "none" ) )
3031 {
3032 TAB_APPEND( i_psz, ppsz, strdup("none") );
3033 }
3034 else
3035 {
3036 psz_code = LanguageGetCode( psz_parser );
3037 if( strcmp( psz_code, "??" ) )
3038 {
3039 TAB_APPEND( i_psz, ppsz, psz_code );
3040 }
3041 else
3042 {
3043 free( psz_code );
3044 }
3045 }
3046
3047 psz_parser = psz;
3048 }
3049
3050 if( i_psz )
3051 {
3052 TAB_APPEND( i_psz, ppsz, NULL );
3053 }
3054
3055 free( psz_dup );
3056 return ppsz;
3057 }
3058
3059 static int LanguageArrayIndex( char **ppsz_langs, const char *psz_lang )
3060 {
3061 if( !ppsz_langs || !psz_lang )
3062 return -1;
3063
3064 for( int i = 0; ppsz_langs[i]; i++ )
3065 {
3066 if( !strcasecmp( ppsz_langs[i], psz_lang ) ||
3067 ( !strcasecmp( ppsz_langs[i], "any" ) && strcasecmp( psz_lang, "none") ) )
3068 return i;
3069 if( !strcasecmp( ppsz_langs[i], "none" ) )
3070 break;
3071 }
3072
3073 return -1;
3074 }
3075
3076 /****************************************************************************
3077 * EsOutUpdateInfo:
3078 * - add meta info to the playlist item
3079 ****************************************************************************/
3080 static void EsOutUpdateInfo( es_out_t *out, es_out_id_t *es, const es_format_t *fmt, const vlc_meta_t *p_meta )
3081 {
3082 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
3083 input_thread_t *p_input = p_sys->p_input;
3084 const es_format_t *p_fmt_es = &es->fmt;
3085
3086 if( es->fmt.i_cat == fmt->i_cat )
3087 {
3088 es_format_t update = *fmt;
3089 update.i_id = es->i_meta_id;
3090 update.i_codec = es->fmt.i_codec;
3091 update.i_original_fourcc = es->fmt.i_original_fourcc;
3092
3093 /* Update infos that could have been lost by the decoder (no need to
3094 * dup them since input_item_UpdateTracksInfo() will do it). */
3095 if (update.psz_language == NULL)
3096 update.psz_language = es->fmt.psz_language;
3097 if (update.psz_description == NULL)
3098 update.psz_description = es->fmt.psz_description;
3099 if (update.i_cat == SPU_ES)
3100 {
3101 if (update.subs.psz_encoding == NULL)
3102 update.subs.psz_encoding = es->fmt.subs.psz_encoding;
3103 }
3104 if (update.i_extra_languages == 0)
3105 {
3106 assert(update.p_extra_languages == NULL);
3107 update.i_extra_languages = es->fmt.i_extra_languages;
3108 update.p_extra_languages = es->fmt.p_extra_languages;
3109 }
3110
3111 /* No need to update codec specific data */
3112 update.i_extra = 0;
3113 update.p_extra = NULL;
3114
3115 input_item_UpdateTracksInfo(input_GetItem(p_input), &update);
3116 }
3117
3118 /* Create category */
3119 char* psz_cat = EsInfoCategoryName( es );
3120
3121 if( unlikely( !psz_cat ) )
3122 return;
3123
3124 info_category_t* p_cat = info_category_New( psz_cat );
3125
3126 free( psz_cat );
3127
3128 if( unlikely( !p_cat ) )
3129 return;
3130
3131 /* Add information */
3132 if( es->i_meta_id != es->i_id )
3133 info_category_AddInfo( p_cat, _("Original ID"),
3134 "%d", es->i_id );
3135
3136 const vlc_fourcc_t i_codec_fourcc = ( p_fmt_es->i_original_fourcc )?
3137 p_fmt_es->i_original_fourcc : p_fmt_es->i_codec;
3138 const char *psz_codec_description =
3139 vlc_fourcc_GetDescription( p_fmt_es->i_cat, i_codec_fourcc );
3140 if( psz_codec_description && *psz_codec_description )
3141 info_category_AddInfo( p_cat, _("Codec"), "%s (%.4s)",
3142 psz_codec_description, (char*)&i_codec_fourcc );
3143 else if ( i_codec_fourcc != VLC_FOURCC(0,0,0,0) )
3144 info_category_AddInfo( p_cat, _("Codec"), "%.4s",
3145 (char*)&i_codec_fourcc );
3146
3147 if( es->psz_language && *es->psz_language )
3148 info_category_AddInfo( p_cat, _("Language"), "%s",
3149 es->psz_language );
3150 if( fmt->psz_description && *fmt->psz_description )
3151 info_category_AddInfo( p_cat, _("Description"), "%s",
3152 fmt->psz_description );
3153
3154 switch( fmt->i_cat )
3155 {
3156 case AUDIO_ES:
3157 info_category_AddInfo( p_cat, _("Type"), _("Audio") );
3158
3159 if( fmt->audio.i_physical_channels )
3160 info_category_AddInfo( p_cat, _("Channels"), "%s",
3161 vlc_gettext( aout_FormatPrintChannels( &fmt->audio ) ) );
3162
3163 if( fmt->audio.i_rate != 0 )
3164 {
3165 info_category_AddInfo( p_cat, _("Sample rate"), _("%u Hz"),
3166 fmt->audio.i_rate );
3167 /* FIXME that should be removed or improved ! (used by text/strings.c) */
3168 var_SetInteger( p_input, "sample-rate", fmt->audio.i_rate );
3169 }
3170
3171 unsigned int i_bitspersample = fmt->audio.i_bitspersample;
3172 if( i_bitspersample == 0 )
3173 i_bitspersample = aout_BitsPerSample( p_fmt_es->i_codec );
3174 if( i_bitspersample != 0 )
3175 info_category_AddInfo( p_cat, _("Bits per sample"), "%u",
3176 i_bitspersample );
3177
3178 if( fmt->i_bitrate != 0 )
3179 {
3180 info_category_AddInfo( p_cat, _("Bitrate"), _("%u kb/s"),
3181 fmt->i_bitrate / 1000 );
3182 /* FIXME that should be removed or improved ! (used by text/strings.c) */
3183 var_SetInteger( p_input, "bit-rate", fmt->i_bitrate );
3184 }
3185 for( int i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
3186 {
3187 const audio_replay_gain_t *p_rg = &fmt->audio_replay_gain;
3188 if( !p_rg->pb_gain[i] )
3189 continue;
3190 const char *psz_name;
3191 if( i == AUDIO_REPLAY_GAIN_TRACK )
3192 psz_name = _("Track replay gain");
3193 else
3194 psz_name = _("Album replay gain");
3195 info_category_AddInfo( p_cat, psz_name, _("%.2f dB"),
3196 p_rg->pf_gain[i] );
3197 }
3198 break;
3199
3200 case VIDEO_ES:
3201 info_category_AddInfo( p_cat, _("Type"), _("Video") );
3202
3203 if( fmt->video.i_visible_width > 0 &&
3204 fmt->video.i_visible_height > 0 )
3205 info_category_AddInfo( p_cat, _("Video resolution"), "%ux%u",
3206 fmt->video.i_visible_width,
3207 fmt->video.i_visible_height);
3208
3209 if( fmt->video.i_width > 0 && fmt->video.i_height > 0 )
3210 info_category_AddInfo( p_cat, _("Buffer dimensions"), "%ux%u",
3211 fmt->video.i_width, fmt->video.i_height );
3212
3213 if( fmt->video.i_frame_rate > 0 &&
3214 fmt->video.i_frame_rate_base > 0 )
3215 {
3216 if( fmt->video.i_frame_rate_base == 1 )
3217 info_category_AddInfo( p_cat, _("Frame rate"), "%u",
3218 fmt->video.i_frame_rate );
3219 else
3220 info_category_AddInfo( p_cat, _("Frame rate"), "%.6f",
3221 (double)fmt->video.i_frame_rate
3222 / (double)fmt->video.i_frame_rate_base );
3223 }
3224 if( fmt->i_codec != p_fmt_es->i_codec )
3225 {
3226 const char *psz_chroma_description =
3227 vlc_fourcc_GetDescription( VIDEO_ES, fmt->i_codec );
3228 if( psz_chroma_description )
3229 info_category_AddInfo( p_cat, _("Decoded format"), "%s",
3230 psz_chroma_description );
3231 }
3232 {
3233 static const char orient_names[][13] = {
3234 N_("Top left"), N_("Left top"),
3235 N_("Right bottom"), N_("Top right"),
3236 N_("Bottom left"), N_("Bottom right"),
3237 N_("Left bottom"), N_("Right top"),
3238 };
3239 info_category_AddInfo( p_cat, _("Orientation"), "%s",
3240 vlc_gettext(orient_names[fmt->video.orientation]) );
3241 }
3242 if( fmt->video.primaries != COLOR_PRIMARIES_UNDEF )
3243 {
3244 static const char primaries_names[][32] = {
3245 [COLOR_PRIMARIES_UNDEF] = N_("Undefined"),
3246 [COLOR_PRIMARIES_BT601_525] =
3247 N_("ITU-R BT.601 (525 lines, 60 Hz)"),
3248 [COLOR_PRIMARIES_BT601_625] =
3249 N_("ITU-R BT.601 (625 lines, 50 Hz)"),
3250 [COLOR_PRIMARIES_BT709] = "ITU-R BT.709",
3251 [COLOR_PRIMARIES_BT2020] = "ITU-R BT.2020",
3252 [COLOR_PRIMARIES_DCI_P3] = "DCI/P3 D65",
3253 [COLOR_PRIMARIES_BT470_M] = "ITU-R BT.470 M",
3254 };
3255 static_assert(ARRAY_SIZE(primaries_names) == COLOR_PRIMARIES_MAX+1,
3256 "Color primiaries table mismatch");
3257 info_category_AddInfo( p_cat, _("Color primaries"), "%s",
3258 vlc_gettext(primaries_names[fmt->video.primaries]) );
3259 }
3260 if( fmt->video.transfer != TRANSFER_FUNC_UNDEF )
3261 {
3262 static const char func_names[][20] = {
3263 [TRANSFER_FUNC_UNDEF] = N_("Undefined"),
3264 [TRANSFER_FUNC_LINEAR] = N_("Linear"),
3265 [TRANSFER_FUNC_SRGB] = "sRGB",
3266 [TRANSFER_FUNC_BT470_BG] = "ITU-R BT.470 BG",
3267 [TRANSFER_FUNC_BT470_M] = "ITU-R BT.470 M",
3268 [TRANSFER_FUNC_BT709] = "ITU-R BT.709",
3269 [TRANSFER_FUNC_SMPTE_ST2084] = "SMPTE ST2084",
3270 [TRANSFER_FUNC_SMPTE_240] = "SMPTE 240M",
3271 [TRANSFER_FUNC_HLG] = N_("Hybrid Log-Gamma"),
3272 };
3273 static_assert(ARRAY_SIZE(func_names) == TRANSFER_FUNC_MAX+1,
3274 "Transfer functions table mismatch");
3275 info_category_AddInfo( p_cat, _("Color transfer function"), "%s",
3276 vlc_gettext(func_names[fmt->video.transfer]) );
3277 }
3278 if( fmt->video.space != COLOR_SPACE_UNDEF )
3279 {
3280 static const char space_names[][16] = {
3281 [COLOR_SPACE_UNDEF] = N_("Undefined"),
3282 [COLOR_SPACE_BT601] = "ITU-R BT.601",
3283 [COLOR_SPACE_BT709] = "ITU-R BT.709",
3284 [COLOR_SPACE_BT2020] = "ITU-R BT.2020",
3285 };
3286 static_assert(ARRAY_SIZE(space_names) == COLOR_SPACE_MAX+1,
3287 "Color space table mismatch");
3288 info_category_AddInfo( p_cat, _("Color space"), _("%s %s Range"),
3289 vlc_gettext(space_names[fmt->video.space]),
3290 vlc_gettext(fmt->video.b_color_range_full
3291 ? N_("Full") : N_("Limited")) );
3292 }
3293 if( fmt->video.chroma_location != CHROMA_LOCATION_UNDEF )
3294 {
3295 static const char c_loc_names[][16] = {
3296 [CHROMA_LOCATION_UNDEF] = N_("Undefined"),
3297 [CHROMA_LOCATION_LEFT] = N_("Left"),
3298 [CHROMA_LOCATION_CENTER] = N_("Center"),
3299 [CHROMA_LOCATION_TOP_LEFT] = N_("Top Left"),
3300 [CHROMA_LOCATION_TOP_CENTER] = N_("Top Center"),
3301 [CHROMA_LOCATION_BOTTOM_LEFT] =N_("Bottom Left"),
3302 [CHROMA_LOCATION_BOTTOM_CENTER] = N_("Bottom Center"),
3303 };
3304 static_assert(ARRAY_SIZE(c_loc_names) == CHROMA_LOCATION_MAX+1,
3305 "Chroma location table mismatch");
3306 info_category_AddInfo( p_cat, _("Chroma location"), "%s",
3307 vlc_gettext(c_loc_names[fmt->video.chroma_location]) );
3308 }
3309 if( fmt->video.projection_mode != PROJECTION_MODE_RECTANGULAR )
3310 {
3311 const char *psz_loc_name = NULL;
3312 switch (fmt->video.projection_mode)
3313 {
3314 case PROJECTION_MODE_RECTANGULAR:
3315 psz_loc_name = N_("Rectangular");
3316 break;
3317 case PROJECTION_MODE_EQUIRECTANGULAR:
3318 psz_loc_name = N_("Equirectangular");
3319 break;
3320 case PROJECTION_MODE_CUBEMAP_LAYOUT_STANDARD:
3321 psz_loc_name = N_("Cubemap");
3322 break;
3323 default:
3324 vlc_assert_unreachable();
3325 break;
3326 }
3327 info_category_AddInfo( p_cat, _("Projection"), "%s",
3328 vlc_gettext(psz_loc_name) );
3329
3330 info_category_AddInfo( p_cat, vlc_pgettext("ViewPoint", "Yaw"),
3331 "%.2f", fmt->video.pose.yaw );
3332 info_category_AddInfo( p_cat, vlc_pgettext("ViewPoint", "Pitch"),
3333 "%.2f", fmt->video.pose.pitch );
3334 info_category_AddInfo( p_cat, vlc_pgettext("ViewPoint", "Roll"),
3335 "%.2f", fmt->video.pose.roll );
3336 info_category_AddInfo( p_cat,
3337 vlc_pgettext("ViewPoint", "Field of view"),
3338 "%.2f", fmt->video.pose.fov );
3339 }
3340 if ( fmt->video.mastering.max_luminance )
3341 {
3342 info_category_AddInfo( p_cat, _("Max. luminance"), "%.4f cd/m²",
3343 fmt->video.mastering.max_luminance / 10000.f );
3344 }
3345 if ( fmt->video.mastering.min_luminance )
3346 {
3347 info_category_AddInfo( p_cat, _("Min. luminance"), "%.4f cd/m²",
3348 fmt->video.mastering.min_luminance / 10000.f );
3349 }
3350 if ( fmt->video.mastering.primaries[4] &&
3351 fmt->video.mastering.primaries[5] )
3352 {
3353 float x = (float)fmt->video.mastering.primaries[4] / 50000.f;
3354 float y = (float)fmt->video.mastering.primaries[5] / 50000.f;
3355 info_category_AddInfo( p_cat, _("Primary R"), "x=%.4f y=%.4f", x, y );
3356 }
3357 if ( fmt->video.mastering.primaries[0] &&
3358 fmt->video.mastering.primaries[1] )
3359 {
3360 float x = (float)fmt->video.mastering.primaries[0] / 50000.f;
3361 float y = (float)fmt->video.mastering.primaries[1] / 50000.f;
3362 info_category_AddInfo( p_cat, _("Primary G"), "x=%.4f y=%.4f", x, y );
3363 }
3364 if ( fmt->video.mastering.primaries[2] &&
3365 fmt->video.mastering.primaries[3] )
3366 {
3367 float x = (float)fmt->video.mastering.primaries[2] / 50000.f;
3368 float y = (float)fmt->video.mastering.primaries[3] / 50000.f;
3369 info_category_AddInfo( p_cat, _("Primary B"), "x=%.4f y=%.4f", x, y );
3370 }
3371 if ( fmt->video.mastering.white_point[0] &&
3372 fmt->video.mastering.white_point[1] )
3373 {
3374 float x = (float)fmt->video.mastering.white_point[0] / 50000.f;
3375 float y = (float)fmt->video.mastering.white_point[1] / 50000.f;
3376 info_category_AddInfo( p_cat, _("White point"), "x=%.4f y=%.4f", x, y );
3377 }
3378 if ( fmt->video.lighting.MaxCLL )
3379 {
3380 info_category_AddInfo( p_cat, "MaxCLL", "%" PRIu16 " cd/m²",
3381 fmt->video.lighting.MaxCLL );
3382 }
3383 if ( fmt->video.lighting.MaxFALL )
3384 {
3385 info_category_AddInfo( p_cat, "MaxFALL", "%" PRIu16 " cd/m²",
3386 fmt->video.lighting.MaxFALL );
3387 }
3388 break;
3389
3390 case SPU_ES:
3391 info_category_AddInfo( p_cat, _("Type"), _("Subtitle") );
3392 break;
3393
3394 default:
3395 break;
3396 }
3397
3398 /* Append generic meta */
3399 if( p_meta )
3400 {
3401 char **ppsz_all_keys = vlc_meta_CopyExtraNames( p_meta );
3402 for( int i = 0; ppsz_all_keys && ppsz_all_keys[i]; i++ )
3403 {
3404 char *psz_key = ppsz_all_keys[i];
3405 const char *psz_value = vlc_meta_GetExtra( p_meta, psz_key );
3406
3407 if( psz_value )
3408 info_category_AddInfo( p_cat, vlc_gettext(psz_key), "%s",
3409 vlc_gettext(psz_value) );
3410 free( psz_key );
3411 }
3412 free( ppsz_all_keys );
3413 }
3414 /* */
3415 input_Control( p_input, INPUT_REPLACE_INFOS, p_cat );
3416 }
3417
3418 static void EsDeleteInfo( es_out_t *out, es_out_id_t *es )
3419 {
3420 es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
3421 char* psz_info_category;
3422
3423 if( likely( psz_info_category = EsInfoCategoryName( es ) ) )
3424 {
3425 input_Control( p_sys->p_input, INPUT_DEL_INFO,
3426 psz_info_category, NULL );
3427
3428 free( psz_info_category );
3429 }
3430 }
VLC Development tree mirror