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