1 /*****************************************************************************
2 * ts.c: Transport Stream input module for VLC.
3 *****************************************************************************
4 * Copyright (C) 2004-2005 VLC authors and VideoLAN
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Jean-Paul Saman <jpsaman #_at_# m2x.nl>
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.
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.
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 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
39 #include <vlc_access.h> /* DVB-specific things */
40 #include <vlc_demux.h>
43 #include <vlc_charset.h> /* FromCharset, for EIT */
45 #include "../mux/mpeg/csa.h"
47 /* Include dvbpsi headers */
48 # include <dvbpsi/dvbpsi.h>
49 # include <dvbpsi/demux.h>
50 # include <dvbpsi/descriptor.h>
51 # include <dvbpsi/pat.h>
52 # include <dvbpsi/pmt.h>
53 # include <dvbpsi/sdt.h>
54 # include <dvbpsi/dr.h>
55 # include <dvbpsi/psi.h>
58 # include <dvbpsi/eit.h>
61 # include <dvbpsi/tot.h>
63 #include "../mux/mpeg/dvbpsi_compat.h"
66 VLC_FORMAT(1, 2) static void ts_debug(const char *format
, ...)
71 vfprintf(stderr
, format
, ap
);
79 #include <aribb24/aribb24.h>
80 #include <aribb24/decoder.h>
83 typedef enum arib_modes_e
86 ARIBMODE_DISABLED
= 0,
90 /*****************************************************************************
92 *****************************************************************************/
93 static int Open ( vlc_object_t
* );
94 static void Close ( vlc_object_t
* );
97 * - Rename "extra pmt" to "user pmt"
98 * - Update extra pmt description
99 * pmt_pid[:pmt_number][=pid_description[,pid_description]]
100 * where pid_description could take 3 forms:
101 * 1. pid:pcr (to force the pcr pid)
103 * 3. pid:type=fourcc where type=(video|audio|spu)
105 #define PMT_TEXT N_("Extra PMT")
106 #define PMT_LONGTEXT N_( \
107 "Allows a user to specify an extra pmt (pmt_pid=pid:stream_type[,...])." )
109 #define PID_TEXT N_("Set id of ES to PID")
110 #define PID_LONGTEXT N_("Set the internal ID of each elementary stream" \
111 " handled by VLC to the same value as the PID in" \
112 " the TS stream, instead of 1, 2, 3, etc. Useful to" \
113 " do \'#duplicate{..., select=\"es=<pid>\"}\'.")
115 #define CSA_TEXT N_("CSA Key")
116 #define CSA_LONGTEXT N_("CSA encryption key. This must be a " \
117 "16 char string (8 hexadecimal bytes).")
119 #define CSA2_TEXT N_("Second CSA Key")
120 #define CSA2_LONGTEXT N_("The even CSA encryption key. This must be a " \
121 "16 char string (8 hexadecimal bytes).")
124 #define CPKT_TEXT N_("Packet size in bytes to decrypt")
125 #define CPKT_LONGTEXT N_("Specify the size of the TS packet to decrypt. " \
126 "The decryption routines subtract the TS-header from the value before " \
129 #define SPLIT_ES_TEXT N_("Separate sub-streams")
130 #define SPLIT_ES_LONGTEXT N_( \
131 "Separate teletex/dvbs pages into independent ES. " \
132 "It can be useful to turn off this option when using stream output." )
134 #define SEEK_PERCENT_TEXT N_("Seek based on percent not time")
135 #define SEEK_PERCENT_LONGTEXT N_( \
136 "Seek and position based on a percent byte position, not a PCR generated " \
137 "time position. If seeking doesn't work property, turn on this option." )
139 #define PCR_TEXT N_("Trust in-stream PCR")
140 #define PCR_LONGTEXT N_("Use the stream PCR as a reference.")
142 static const int const arib_mode_list
[] =
143 { ARIBMODE_AUTO
, ARIBMODE_ENABLED
, ARIBMODE_DISABLED
};
144 static const char *const arib_mode_list_text
[] =
145 { N_("Auto"), N_("Enabled"), N_("Disabled") };
147 #define SUPPORT_ARIB_TEXT N_("ARIB STD-B24 mode")
148 #define SUPPORT_ARIB_LONGTEXT N_( \
149 "Forces ARIB STD-B24 mode for decoding characters." \
150 "This feature affects EPG information and subtitles." )
153 set_description( N_("MPEG Transport Stream demuxer") )
154 set_shortname ( "MPEG-TS" )
155 set_category( CAT_INPUT
)
156 set_subcategory( SUBCAT_INPUT_DEMUX
)
158 add_string( "ts-extra-pmt", NULL
, PMT_TEXT
, PMT_LONGTEXT
, true )
159 add_bool( "ts-trust-pcr", true, PCR_TEXT
, PCR_LONGTEXT
, true )
161 add_bool( "ts-es-id-pid", true, PID_TEXT
, PID_LONGTEXT
, true )
163 add_obsolete_string( "ts-out" ) /* since 2.2.0 */
164 add_obsolete_integer( "ts-out-mtu" ) /* since 2.2.0 */
165 add_string( "ts-csa-ck", NULL
, CSA_TEXT
, CSA_LONGTEXT
, true )
167 add_string( "ts-csa2-ck", NULL
, CSA2_TEXT
, CSA2_LONGTEXT
, true )
169 add_integer( "ts-csa-pkt", 188, CPKT_TEXT
, CPKT_LONGTEXT
, true )
172 add_bool( "ts-split-es", true, SPLIT_ES_TEXT
, SPLIT_ES_LONGTEXT
, false )
173 add_bool( "ts-seek-percent", false, SEEK_PERCENT_TEXT
, SEEK_PERCENT_LONGTEXT
, true )
175 add_integer( "ts-arib", ARIBMODE_AUTO
, SUPPORT_ARIB_TEXT
, SUPPORT_ARIB_LONGTEXT
, false )
176 change_integer_list( arib_mode_list
, arib_mode_list_text
)
178 add_obsolete_bool( "ts-silent" );
180 set_capability( "demux", 10 )
181 set_callbacks( Open
, Close
)
185 /*****************************************************************************
187 *****************************************************************************/
188 static const char *const ppsz_teletext_type
[] = {
191 N_("Teletext subtitles"),
192 N_("Teletext: additional information"),
193 N_("Teletext: program schedule"),
194 N_("Teletext subtitles: hearing impaired")
199 uint8_t i_objectTypeIndication
;
200 uint8_t i_streamType
;
205 } decoder_config_descriptor_t
;
214 decoder_config_descriptor_t dec_descr
;
216 } es_mpeg4_descriptor_t
;
218 #define ES_DESCRIPTOR_COUNT 255
224 es_mpeg4_descriptor_t es_descr
[ES_DESCRIPTOR_COUNT
];
230 dvbpsi_handle handle
;
236 /* IOD stuff (mpeg4) */
237 iod_descriptor_t
*iod
;
243 /* for special PAT/SDT case */
244 dvbpsi_handle handle
; /* PAT/SDT/EIT */
257 TS_ES_DATA_TABLE_SECTION
262 TS_PMT_REGISTRATION_NONE
= 0,
263 TS_PMT_REGISTRATION_HDMV
264 } ts_pmt_registration_type_t
;
270 ts_es_data_type_t data_type
;
276 es_mpeg4_descriptor_t
*p_mpeg4desc
;
286 int i_cc
; /* countinuity counter */
289 /* PSI owner (ie PMT -> PAT, ES -> PMT */
297 /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
305 vlc_mutex_t csa_lock
;
307 /* TS packet size (188, 192, 204) */
310 /* Additional TS packet header size (BluRay TS packets have 4-byte header before sync byte) */
311 int i_packet_header_size
;
313 /* how many TS packet we read at once */
316 /* to determine length and time */
319 mtime_t i_current_pcr
;
321 bool b_force_seek_per_percent
;
330 arib_instance_t
*p_instance
;
352 bool b_access_control
;
358 int64_t i_dvb_length
;
359 bool b_broken_charset
; /* True if broken encoding is used in EPG/SDT */
362 int i_current_program
;
363 vlc_list_t programs_list
;
369 static int Demux ( demux_t
*p_demux
);
370 static int Control( demux_t
*p_demux
, int i_query
, va_list args
);
372 static void PIDInit ( ts_pid_t
*pid
, bool b_psi
, ts_psi_t
*p_owner
);
373 static void PIDClean( demux_t
*, ts_pid_t
*pid
);
374 static void PIDFillFormat( es_format_t
*fmt
, int i_stream_type
);
376 static void PATCallBack( void*, dvbpsi_pat_t
* );
377 static void PMTCallBack( void *data
, dvbpsi_pmt_t
*p_pmt
);
378 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
379 static void PSINewTableCallBack( dvbpsi_t
*handle
, uint8_t i_table_id
,
380 uint16_t i_extension
, demux_t
* );
382 static void PSINewTableCallBack( demux_t
*, dvbpsi_handle
,
383 uint8_t i_table_id
, uint16_t i_extension
);
386 static int ChangeKeyCallback( vlc_object_t
*, char const *, vlc_value_t
, vlc_value_t
, void * );
388 static inline int PIDGet( block_t
*p
)
390 return ( (p
->p_buffer
[1]&0x1f)<<8 )|p
->p_buffer
[2];
393 static bool GatherData( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
);
395 static block_t
* ReadTSPacket( demux_t
*p_demux
);
396 static int Seek( demux_t
*p_demux
, double f_percent
);
397 static void GetFirstPCR( demux_t
*p_demux
);
398 static void GetLastPCR( demux_t
*p_demux
);
399 static void CheckPCR( demux_t
*p_demux
);
400 static void PCRHandle( demux_t
*p_demux
, ts_pid_t
*, block_t
* );
402 static void IODFree( iod_descriptor_t
* );
404 #define TS_USER_PMT_NUMBER (0)
405 static int UserPmt( demux_t
*p_demux
, const char * );
407 static int SetPIDFilter( demux_t
*, int i_pid
, bool b_selected
);
408 static void SetPrgFilter( demux_t
*, int i_prg
, bool b_selected
);
410 #define TS_PACKET_SIZE_188 188
411 #define TS_PACKET_SIZE_192 192
412 #define TS_PACKET_SIZE_204 204
413 #define TS_PACKET_SIZE_MAX 204
415 static int DetectPacketSize( demux_t
*p_demux
, int *pi_header_size
)
417 const uint8_t *p_peek
;
418 if( stream_Peek( p_demux
->s
,
419 &p_peek
, TS_PACKET_SIZE_MAX
) < TS_PACKET_SIZE_MAX
)
424 if( memcmp( p_peek
, "TFrc", 4 ) == 0 )
427 /* I used the TF5000PVR 2004 Firmware .doc header documentation,
428 * http://www.i-topfield.com/data/product/firmware/Structure%20of%20Recorded%20File%20in%20TF5000PVR%20(Feb%2021%202004).doc
429 * but after the filename the offsets seem to be incorrect. - DJ */
430 int i_duration
, i_name
;
431 char *psz_name
= xmalloc(25);
432 char *psz_event_name
;
433 char *psz_event_text
= xmalloc(130);
434 char *psz_ext_text
= xmalloc(1025);
436 // 2 bytes version Uimsbf (4,5)
437 // 2 bytes reserved (6,7)
438 // 2 bytes duration in minutes Uimsbf (8,9(
439 i_duration
= (int) (p_peek
[8] << 8) | p_peek
[9];
440 msg_Dbg( p_demux
, "Topfield recording length: +/- %d minutes", i_duration
);
441 // 2 bytes service number in channel list (10, 11)
442 // 2 bytes service type Bslbf 0=TV 1=Radio Bslb (12, 13)
443 // 4 bytes of reserved + tuner info (14,15,16,17)
444 // 2 bytes of Service ID Bslbf (18,19)
445 // 2 bytes of PMT PID Uimsbf (20,21)
446 // 2 bytes of PCR PID Uimsbf (22,23)
447 // 2 bytes of Video PID Uimsbf (24,25)
448 // 2 bytes of Audio PID Uimsbf (26,27)
449 // 24 bytes filename Bslbf
450 memcpy( psz_name
, &p_peek
[28], 24 );
452 msg_Dbg( p_demux
, "recordingname=%s", psz_name
);
453 // 1 byte of sat index Uimsbf (52)
454 // 3 bytes (1 bit of polarity Bslbf +23 bits reserved)
455 // 4 bytes of freq. Uimsbf (56,57,58,59)
456 // 2 bytes of symbol rate Uimsbf (60,61)
457 // 2 bytes of TS stream ID Uimsbf (62,63)
460 // 2 bytes duration Uimsbf (70,71)
461 //i_duration = (int) (p_peek[70] << 8) | p_peek[71];
462 //msg_Dbg( p_demux, "Topfield 2nd duration field: +/- %d minutes", i_duration);
463 // 4 bytes EventID Uimsbf (72-75)
464 // 8 bytes of Start and End time info (76-83)
465 // 1 byte reserved (84)
466 // 1 byte event name length Uimsbf (89)
467 i_name
= (int)(p_peek
[89]&~0x81);
468 msg_Dbg( p_demux
, "event name length = %d", i_name
);
469 psz_event_name
= xmalloc( i_name
+1 );
470 // 1 byte parental rating (90)
471 // 129 bytes of event text
472 memcpy( psz_event_name
, &p_peek
[91], i_name
);
473 psz_event_name
[i_name
] = '\0';
474 memcpy( psz_event_text
, &p_peek
[91+i_name
], 129-i_name
);
475 psz_event_text
[129-i_name
] = '\0';
476 msg_Dbg( p_demux
, "event name=%s", psz_event_name
);
477 msg_Dbg( p_demux
, "event text=%s", psz_event_text
);
478 // 12 bytes reserved (220)
480 // 2 bytes Event Text Length Uimsbf
481 // 4 bytes EventID Uimsbf
482 // FIXME We just have 613 bytes. not enough for this entire text
483 // 1024 bytes Extended Event Text Bslbf
484 memcpy( psz_ext_text
, p_peek
+372, 1024 );
485 psz_ext_text
[1024] = '\0';
486 msg_Dbg( p_demux
, "extended event text=%s", psz_ext_text
);
487 // 52 bytes reserved Bslbf
489 msg_Dbg( p_demux
, "this is a topfield file" );
490 return TS_PACKET_SIZE_188
;
493 for( int i_sync
= 0; i_sync
< TS_PACKET_SIZE_MAX
; i_sync
++ )
495 if( p_peek
[i_sync
] != 0x47 )
498 /* Check next 3 sync bytes */
499 int i_peek
= TS_PACKET_SIZE_MAX
* 3 + i_sync
+ 1;
500 if( ( stream_Peek( p_demux
->s
, &p_peek
, i_peek
) ) < i_peek
)
502 msg_Err( p_demux
, "cannot peek" );
505 if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_188
] == 0x47 &&
506 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_188
] == 0x47 &&
507 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_188
] == 0x47 )
509 return TS_PACKET_SIZE_188
;
511 else if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_192
] == 0x47 &&
512 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_192
] == 0x47 &&
513 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_192
] == 0x47 )
517 *pi_header_size
= 4; /* BluRay TS packets have 4-byte header */
519 return TS_PACKET_SIZE_192
;
521 else if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_204
] == 0x47 &&
522 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_204
] == 0x47 &&
523 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_204
] == 0x47 )
525 return TS_PACKET_SIZE_204
;
529 if( p_demux
->b_force
)
531 msg_Warn( p_demux
, "this does not look like a TS stream, continuing" );
532 return TS_PACKET_SIZE_188
;
534 msg_Dbg( p_demux
, "TS module discarded (lost sync)" );
538 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
539 static void vlc_dvbpsi_reset( demux_t
*p_demux
)
541 demux_sys_t
*p_sys
= p_demux
->p_sys
;
543 ts_pid_t
*pat
= &p_sys
->pid
[0];
544 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
545 ts_pid_t
*eit
= &p_sys
->pid
[0x12];
546 ts_pid_t
*tdt
= &p_sys
->pid
[0x14];
548 if( pat
->psi
->handle
)
550 if( dvbpsi_decoder_present( pat
->psi
->handle
) )
551 dvbpsi_pat_detach( pat
->psi
->handle
);
552 dvbpsi_delete( pat
->psi
->handle
);
553 pat
->psi
->handle
= NULL
;
556 if( sdt
->psi
->handle
)
558 if( dvbpsi_decoder_present( sdt
->psi
->handle
) )
559 dvbpsi_DetachDemux( sdt
->psi
->handle
);
560 dvbpsi_delete( sdt
->psi
->handle
);
561 sdt
->psi
->handle
= NULL
;
564 if( eit
->psi
->handle
)
566 if( dvbpsi_decoder_present( eit
->psi
->handle
) )
567 dvbpsi_DetachDemux( eit
->psi
->handle
);
568 dvbpsi_delete( eit
->psi
->handle
);
569 eit
->psi
->handle
= NULL
;
572 if( tdt
->psi
->handle
)
574 if( dvbpsi_decoder_present( tdt
->psi
->handle
) )
575 dvbpsi_DetachDemux( tdt
->psi
->handle
);
576 dvbpsi_delete( tdt
->psi
->handle
);
577 tdt
->psi
->handle
= NULL
;
582 /*****************************************************************************
584 *****************************************************************************/
585 static int Open( vlc_object_t
*p_this
)
587 demux_t
*p_demux
= (demux_t
*)p_this
;
590 int i_packet_size
, i_packet_header_size
= 0;
594 /* Search first sync byte */
595 i_packet_size
= DetectPacketSize( p_demux
, &i_packet_header_size
);
596 if( i_packet_size
< 0 )
599 p_demux
->p_sys
= p_sys
= malloc( sizeof( demux_sys_t
) );
602 memset( p_sys
, 0, sizeof( demux_sys_t
) );
603 vlc_mutex_init( &p_sys
->csa_lock
);
605 p_demux
->pf_demux
= Demux
;
606 p_demux
->pf_control
= Control
;
608 /* Init p_sys field */
609 p_sys
->b_dvb_meta
= true;
610 p_sys
->b_access_control
= true;
611 p_sys
->i_current_program
= 0;
612 p_sys
->programs_list
.i_count
= 0;
613 p_sys
->programs_list
.p_values
= NULL
;
614 p_sys
->i_tdt_delta
= 0;
615 p_sys
->i_dvb_start
= 0;
616 p_sys
->i_dvb_length
= 0;
618 p_sys
->b_broken_charset
= false;
620 for( int i
= 0; i
< 8192; i
++ )
622 ts_pid_t
*pid
= &p_sys
->pid
[i
];
625 pid
->b_valid
= false;
627 /* PID 8191 is padding */
628 p_sys
->pid
[8191].b_seen
= true;
629 p_sys
->i_packet_size
= i_packet_size
;
630 p_sys
->i_packet_header_size
= i_packet_header_size
;
631 p_sys
->i_ts_read
= 50;
633 p_sys
->b_start_record
= false;
635 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
636 # define VLC_DVBPSI_DEMUX_TABLE_INIT(table,obj) \
638 (table)->psi->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG ); \
639 if( ! (table)->psi->handle ) \
641 vlc_mutex_destroy( &p_sys->csa_lock ); \
645 (table)->psi->handle->p_sys = (void *) VLC_OBJECT(obj); \
646 if( !dvbpsi_AttachDemux( (table)->psi->handle, (dvbpsi_demux_new_cb_t)PSINewTableCallBack, (obj) ) ) \
648 vlc_dvbpsi_reset( obj ); \
649 vlc_mutex_destroy( &p_sys->csa_lock ); \
651 return VLC_EGENERIC; \
656 /* Init PAT handler */
657 pat
= &p_sys
->pid
[0];
658 PIDInit( pat
, true, NULL
);
659 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
660 pat
->psi
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
661 if( !pat
->psi
->handle
)
663 vlc_mutex_destroy( &p_sys
->csa_lock
);
667 pat
->psi
->handle
->p_sys
= (void *) p_demux
;
668 if( !dvbpsi_pat_attach( pat
->psi
->handle
, PATCallBack
, p_demux
) )
670 vlc_dvbpsi_reset( p_demux
);
671 vlc_mutex_destroy( &p_sys
->csa_lock
);
676 pat
->psi
->handle
= dvbpsi_AttachPAT( PATCallBack
, p_demux
);
678 if( p_sys
->b_dvb_meta
)
680 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
681 ts_pid_t
*eit
= &p_sys
->pid
[0x12];
683 PIDInit( sdt
, true, NULL
);
684 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
685 VLC_DVBPSI_DEMUX_TABLE_INIT( sdt
, p_demux
)
688 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
691 PIDInit( eit
, true, NULL
);
692 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
693 VLC_DVBPSI_DEMUX_TABLE_INIT( eit
, p_demux
)
696 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
699 ts_pid_t
*tdt
= &p_sys
->pid
[0x14];
700 PIDInit( tdt
, true, NULL
);
701 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
702 VLC_DVBPSI_DEMUX_TABLE_INIT( tdt
, p_demux
)
705 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
709 if( p_sys
->b_access_control
)
711 if( SetPIDFilter( p_demux
, 0x11, true ) ||
712 SetPIDFilter( p_demux
, 0x14, true ) ||
713 SetPIDFilter( p_demux
, 0x12, true ) )
714 p_sys
->b_access_control
= false;
718 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
719 # undef VLC_DVBPSI_DEMUX_TABLE_INIT
723 TAB_INIT( p_sys
->i_pmt
, p_sys
->pmt
);
727 p_sys
->b_es_id_pid
= var_CreateGetBool( p_demux
, "ts-es-id-pid" );
729 p_sys
->b_trust_pcr
= var_CreateGetBool( p_demux
, "ts-trust-pcr" );
731 /* We handle description of an extra PMT */
732 char* psz_string
= var_CreateGetString( p_demux
, "ts-extra-pmt" );
733 p_sys
->b_user_pmt
= false;
734 if( psz_string
&& *psz_string
)
735 UserPmt( p_demux
, psz_string
);
738 psz_string
= var_CreateGetStringCommand( p_demux
, "ts-csa-ck" );
739 if( psz_string
&& *psz_string
)
744 p_sys
->csa
= csa_New();
746 psz_csa2
= var_CreateGetStringCommand( p_demux
, "ts-csa2-ck" );
747 i_res
= csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, true );
748 if( i_res
== VLC_SUCCESS
&& psz_csa2
&& *psz_csa2
)
750 if( csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_csa2
, false ) != VLC_SUCCESS
)
752 csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, false );
755 else if ( i_res
== VLC_SUCCESS
)
757 csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, false );
761 csa_Delete( p_sys
->csa
);
767 var_AddCallback( p_demux
, "ts-csa-ck", ChangeKeyCallback
, (void *)1 );
768 var_AddCallback( p_demux
, "ts-csa2-ck", ChangeKeyCallback
, NULL
);
770 int i_pkt
= var_CreateGetInteger( p_demux
, "ts-csa-pkt" );
771 if( i_pkt
< 4 || i_pkt
> 188 )
773 msg_Err( p_demux
, "wrong packet size %d specified.", i_pkt
);
774 msg_Warn( p_demux
, "using default packet size of 188 bytes" );
775 p_sys
->i_csa_pkt_size
= 188;
778 p_sys
->i_csa_pkt_size
= i_pkt
;
779 msg_Dbg( p_demux
, "decrypting %d bytes of packet", p_sys
->i_csa_pkt_size
);
785 p_sys
->b_split_es
= var_InheritBool( p_demux
, "ts-split-es" );
787 p_sys
->i_pid_ref_pcr
= -1;
788 p_sys
->i_first_pcr
= -1;
789 p_sys
->i_current_pcr
= -1;
790 p_sys
->i_last_pcr
= -1;
791 p_sys
->b_force_seek_per_percent
= var_InheritBool( p_demux
, "ts-seek-percent" );
792 p_sys
->i_pcrs_num
= 10;
793 p_sys
->p_pcrs
= (mtime_t
*)calloc( p_sys
->i_pcrs_num
, sizeof( mtime_t
) );
794 p_sys
->p_pos
= (int64_t *)calloc( p_sys
->i_pcrs_num
, sizeof( int64_t ) );
796 p_sys
->arib
.e_mode
= var_InheritInteger( p_demux
, "ts-arib" );
798 if( !p_sys
->p_pcrs
|| !p_sys
->p_pos
)
804 bool can_seek
= false;
805 stream_Control( p_demux
->s
, STREAM_CAN_FASTSEEK
, &can_seek
);
808 GetFirstPCR( p_demux
);
810 GetLastPCR( p_demux
);
812 if( p_sys
->i_first_pcr
< 0 || p_sys
->i_last_pcr
< 0 )
814 msg_Dbg( p_demux
, "Force Seek Per Percent: PCR's not found,");
815 p_sys
->b_force_seek_per_percent
= true;
818 while( p_sys
->i_pmt_es
<= 0 && vlc_object_alive( p_demux
) )
820 if( Demux( p_demux
) != 1 )
826 /*****************************************************************************
828 *****************************************************************************/
829 static void Close( vlc_object_t
*p_this
)
831 demux_t
*p_demux
= (demux_t
*)p_this
;
832 demux_sys_t
*p_sys
= p_demux
->p_sys
;
834 msg_Dbg( p_demux
, "pid list:" );
835 for( int i
= 0; i
< 8192; i
++ )
837 ts_pid_t
*pid
= &p_sys
->pid
[i
];
839 if( pid
->b_valid
&& pid
->psi
)
844 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
845 if( dvbpsi_decoder_present( pid
->psi
->handle
) )
846 dvbpsi_pat_detach( pid
->psi
->handle
);
847 dvbpsi_delete( pid
->psi
->handle
);
848 pid
->psi
->handle
= NULL
;
850 dvbpsi_DetachPAT( pid
->psi
->handle
);
858 if( p_sys
->b_dvb_meta
&& ( pid
->i_pid
== 0x11 || pid
->i_pid
== 0x12 || pid
->i_pid
== 0x14 ) )
860 /* SDT or EIT or TDT */
861 dvbpsi_DetachDemux( pid
->psi
->handle
);
862 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
863 dvbpsi_delete( pid
->psi
->handle
);
864 pid
->psi
->handle
= NULL
;
870 PIDClean( p_demux
, pid
);
875 else if( pid
->b_valid
&& pid
->es
)
877 PIDClean( p_demux
, pid
);
882 msg_Dbg( p_demux
, " - pid[%d] seen", pid
->i_pid
);
887 SetPIDFilter( p_demux
, pid
->i_pid
, false );
890 vlc_mutex_lock( &p_sys
->csa_lock
);
893 var_DelCallback( p_demux
, "ts-csa-ck", ChangeKeyCallback
, NULL
);
894 var_DelCallback( p_demux
, "ts-csa2-ck", ChangeKeyCallback
, NULL
);
895 csa_Delete( p_sys
->csa
);
897 vlc_mutex_unlock( &p_sys
->csa_lock
);
899 TAB_CLEAN( p_sys
->i_pmt
, p_sys
->pmt
);
901 free( p_sys
->programs_list
.p_values
);
903 free( p_sys
->p_pcrs
);
904 free( p_sys
->p_pos
);
907 if ( p_sys
->arib
.p_instance
)
908 arib_instance_destroy( p_sys
->arib
.p_instance
);
911 vlc_mutex_destroy( &p_sys
->csa_lock
);
915 /*****************************************************************************
916 * ChangeKeyCallback: called when changing the odd encryption key on the fly.
917 *****************************************************************************/
918 static int ChangeKeyCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
919 vlc_value_t oldval
, vlc_value_t newval
,
922 VLC_UNUSED(psz_cmd
); VLC_UNUSED(oldval
);
923 demux_t
*p_demux
= (demux_t
*)p_this
;
924 demux_sys_t
*p_sys
= p_demux
->p_sys
;
925 int i_tmp
= (intptr_t)p_data
;
927 vlc_mutex_lock( &p_sys
->csa_lock
);
929 i_tmp
= csa_SetCW( p_this
, p_sys
->csa
, newval
.psz_string
, true );
931 i_tmp
= csa_SetCW( p_this
, p_sys
->csa
, newval
.psz_string
, false );
933 vlc_mutex_unlock( &p_sys
->csa_lock
);
937 /*****************************************************************************
939 *****************************************************************************/
940 static int Demux( demux_t
*p_demux
)
942 demux_sys_t
*p_sys
= p_demux
->p_sys
;
943 bool b_wait_es
= p_sys
->i_pmt_es
<= 0;
945 /* We read at most 100 TS packet or until a frame is completed */
946 for( int i_pkt
= 0; i_pkt
< p_sys
->i_ts_read
; i_pkt
++ )
948 bool b_frame
= false;
950 if( !(p_pkt
= ReadTSPacket( p_demux
)) )
955 if( p_sys
->b_start_record
)
957 /* Enable recording once synchronized */
958 stream_Control( p_demux
->s
, STREAM_SET_RECORD_STATE
, true, "ts" );
959 p_sys
->b_start_record
= false;
962 /* Parse the TS packet */
963 ts_pid_t
*p_pid
= &p_sys
->pid
[PIDGet( p_pkt
)];
969 if( p_pid
->i_pid
== 0 || ( p_sys
->b_dvb_meta
&& ( p_pid
->i_pid
== 0x11 || p_pid
->i_pid
== 0x12 || p_pid
->i_pid
== 0x14 ) ) )
971 dvbpsi_PushPacket( p_pid
->psi
->handle
, p_pkt
->p_buffer
);
975 for( int i_prg
= 0; i_prg
< p_pid
->psi
->i_prg
; i_prg
++ )
977 dvbpsi_PushPacket( p_pid
->psi
->prg
[i_prg
]->handle
,
981 block_Release( p_pkt
);
985 b_frame
= GatherData( p_demux
, p_pid
, p_pkt
);
992 msg_Dbg( p_demux
, "pid[%d] unknown", p_pid
->i_pid
);
994 /* We have to handle PCR if present */
995 PCRHandle( p_demux
, p_pid
, p_pkt
);
996 block_Release( p_pkt
);
998 p_pid
->b_seen
= true;
1000 if( b_frame
|| ( b_wait_es
&& p_sys
->i_pmt_es
> 0 ) )
1004 demux_UpdateTitleFromStream( p_demux
);
1008 /*****************************************************************************
1010 *****************************************************************************/
1011 static int DVBEventInformation( demux_t
*p_demux
, int64_t *pi_time
, int64_t *pi_length
)
1013 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1019 if( p_sys
->i_dvb_length
> 0 )
1021 const int64_t t
= mdate() + p_sys
->i_tdt_delta
;
1023 if( p_sys
->i_dvb_start
<= t
&& t
< p_sys
->i_dvb_start
+ p_sys
->i_dvb_length
)
1026 *pi_length
= p_sys
->i_dvb_length
;
1028 *pi_time
= t
- p_sys
->i_dvb_start
;
1032 return VLC_EGENERIC
;
1035 static int Control( demux_t
*p_demux
, int i_query
, va_list args
)
1037 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1039 bool b_bool
, *pb_bool
;
1046 case DEMUX_GET_POSITION
:
1047 pf
= (double*) va_arg( args
, double* );
1049 if( p_sys
->b_force_seek_per_percent
||
1050 (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1051 p_sys
->i_current_pcr
- p_sys
->i_first_pcr
< 0 ||
1052 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1054 int64_t i_time
, i_length
;
1055 if( !DVBEventInformation( p_demux
, &i_time
, &i_length
) && i_length
> 0 )
1056 *pf
= (double)i_time
/(double)i_length
;
1057 else if( (i64
= stream_Size( p_demux
->s
) ) > 0 )
1059 int64_t offset
= stream_Tell( p_demux
->s
);
1061 *pf
= (double)offset
/ (double)i64
;
1068 *pf
= (double)(p_sys
->i_current_pcr
- p_sys
->i_first_pcr
) / (double)(p_sys
->i_last_pcr
- p_sys
->i_first_pcr
);
1072 case DEMUX_SET_POSITION
:
1073 f
= (double) va_arg( args
, double );
1075 if( p_sys
->b_force_seek_per_percent
||
1076 (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1077 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1079 i64
= stream_Size( p_demux
->s
);
1080 if( stream_Seek( p_demux
->s
, (int64_t)(i64
* f
) ) )
1081 return VLC_EGENERIC
;
1085 if( Seek( p_demux
, f
) )
1087 p_sys
->b_force_seek_per_percent
= true;
1088 return VLC_EGENERIC
;
1093 case DEMUX_GET_TIME
:
1094 pi64
= (int64_t*)va_arg( args
, int64_t * );
1095 if( (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1096 p_sys
->b_force_seek_per_percent
||
1097 p_sys
->i_current_pcr
- p_sys
->i_first_pcr
< 0 )
1099 if( DVBEventInformation( p_demux
, pi64
, NULL
) )
1106 *pi64
= (p_sys
->i_current_pcr
- p_sys
->i_first_pcr
) * 100 / 9;
1110 case DEMUX_GET_LENGTH
:
1111 pi64
= (int64_t*)va_arg( args
, int64_t * );
1112 if( (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1113 p_sys
->b_force_seek_per_percent
||
1114 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1116 if( DVBEventInformation( p_demux
, NULL
, pi64
) )
1123 *pi64
= (p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * 100 / 9;
1127 case DEMUX_SET_GROUP
:
1131 i_int
= (int)va_arg( args
, int );
1132 p_list
= (vlc_list_t
*)va_arg( args
, vlc_list_t
* );
1133 msg_Dbg( p_demux
, "DEMUX_SET_GROUP %d %p", i_int
, p_list
);
1135 if( i_int
== 0 && p_sys
->i_current_program
> 0 )
1136 i_int
= p_sys
->i_current_program
;
1138 if( p_sys
->i_current_program
> 0 )
1140 if( p_sys
->i_current_program
!= i_int
)
1141 SetPrgFilter( p_demux
, p_sys
->i_current_program
, false );
1143 else if( p_sys
->i_current_program
< 0 )
1145 for( int i
= 0; i
< p_sys
->programs_list
.i_count
; i
++ )
1146 SetPrgFilter( p_demux
, p_sys
->programs_list
.p_values
[i
].i_int
, false );
1151 p_sys
->i_current_program
= i_int
;
1152 SetPrgFilter( p_demux
, p_sys
->i_current_program
, true );
1154 else if( i_int
< 0 )
1156 p_sys
->i_current_program
= -1;
1157 p_sys
->programs_list
.i_count
= 0;
1160 vlc_list_t
*p_dst
= &p_sys
->programs_list
;
1161 free( p_dst
->p_values
);
1163 p_dst
->p_values
= calloc( p_list
->i_count
,
1164 sizeof(*p_dst
->p_values
) );
1165 if( p_dst
->p_values
)
1167 p_dst
->i_count
= p_list
->i_count
;
1168 for( int i
= 0; i
< p_list
->i_count
; i
++ )
1170 p_dst
->p_values
[i
] = p_list
->p_values
[i
];
1171 SetPrgFilter( p_demux
, p_dst
->p_values
[i
].i_int
, true );
1179 case DEMUX_GET_TITLE_INFO
:
1181 struct input_title_t
***v
= va_arg( args
, struct input_title_t
*** );
1182 int *c
= va_arg( args
, int * );
1184 *va_arg( args
, int* ) = 0; /* Title offset */
1185 *va_arg( args
, int* ) = 0; /* Chapter offset */
1186 return stream_Control( p_demux
->s
, STREAM_GET_TITLE_INFO
, v
, c
);
1189 case DEMUX_SET_TITLE
:
1190 return stream_vaControl( p_demux
->s
, STREAM_SET_TITLE
, args
);
1192 case DEMUX_SET_SEEKPOINT
:
1193 return stream_vaControl( p_demux
->s
, STREAM_SET_SEEKPOINT
, args
);
1195 case DEMUX_GET_META
:
1196 return stream_vaControl( p_demux
->s
, STREAM_GET_META
, args
);
1198 case DEMUX_CAN_RECORD
:
1199 pb_bool
= (bool*)va_arg( args
, bool * );
1203 case DEMUX_SET_RECORD_STATE
:
1204 b_bool
= (bool)va_arg( args
, int );
1207 stream_Control( p_demux
->s
, STREAM_SET_RECORD_STATE
, false );
1208 p_sys
->b_start_record
= b_bool
;
1211 case DEMUX_GET_SIGNAL
:
1212 return stream_vaControl( p_demux
->s
, STREAM_GET_SIGNAL
, args
);
1215 return VLC_EGENERIC
;
1219 /*****************************************************************************
1221 *****************************************************************************/
1222 static int UserPmt( demux_t
*p_demux
, const char *psz_fmt
)
1224 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1225 char *psz_dup
= strdup( psz_fmt
);
1226 char *psz
= psz_dup
;
1229 ts_prg_psi_t
*prg
= NULL
;
1235 i_pid
= strtol( psz
, &psz
, 0 );
1236 if( i_pid
< 2 || i_pid
>= 8192 )
1239 /* Parse optional program number */
1242 i_number
= strtol( &psz
[1], &psz
, 0 );
1245 ts_pid_t
*pmt
= &p_sys
->pid
[i_pid
];
1247 msg_Dbg( p_demux
, "user pmt specified (pid=%d,number=%d)", i_pid
, i_number
);
1248 PIDInit( pmt
, true, NULL
);
1251 prg
= calloc( 1, sizeof( ts_prg_psi_t
) );
1255 prg
->i_pid_pcr
= -1;
1256 prg
->i_pid_pmt
= -1;
1257 prg
->i_version
= -1;
1258 prg
->i_number
= i_number
!= 0 ? i_number
: TS_USER_PMT_NUMBER
;
1259 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1260 prg
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
1263 prg
->handle
->p_sys
= (void *) VLC_OBJECT(p_demux
);
1264 if( !dvbpsi_pmt_attach( prg
->handle
,
1265 ((i_number
!= TS_USER_PMT_NUMBER
? i_number
: 1)),
1266 PMTCallBack
, p_demux
) )
1268 dvbpsi_delete( prg
->handle
);
1273 prg
->handle
= dvbpsi_AttachPMT(
1274 ((i_number
!= TS_USER_PMT_NUMBER
) ? i_number
: 1),
1275 PMTCallBack
, p_demux
);
1277 TAB_APPEND( pmt
->psi
->i_prg
, pmt
->psi
->prg
, prg
);
1279 psz
= strchr( psz
, '=' );
1282 while( psz
&& *psz
)
1284 char *psz_next
= strchr( psz
, ',' );
1290 i_pid
= strtol( psz
, &psz
, 0 );
1291 if( *psz
!= ':' || i_pid
< 2 || i_pid
>= 8192 )
1294 char *psz_opt
= &psz
[1];
1295 if( !strcmp( psz_opt
, "pcr" ) )
1297 prg
->i_pid_pcr
= i_pid
;
1299 else if( !p_sys
->pid
[i_pid
].b_valid
)
1301 ts_pid_t
*pid
= &p_sys
->pid
[i_pid
];
1303 char *psz_arg
= strchr( psz_opt
, '=' );
1307 PIDInit( pid
, false, pmt
->psi
);
1308 if( prg
->i_pid_pcr
<= 0 )
1309 prg
->i_pid_pcr
= i_pid
;
1311 if( psz_arg
&& strlen( psz_arg
) == 4 )
1313 const vlc_fourcc_t i_codec
= VLC_FOURCC( psz_arg
[0], psz_arg
[1],
1314 psz_arg
[2], psz_arg
[3] );
1315 int i_cat
= UNKNOWN_ES
;
1316 es_format_t
*fmt
= &pid
->es
->fmt
;
1318 if( !strcmp( psz_opt
, "video" ) )
1320 else if( !strcmp( psz_opt
, "audio" ) )
1322 else if( !strcmp( psz_opt
, "spu" ) )
1325 es_format_Init( fmt
, i_cat
, i_codec
);
1326 fmt
->b_packetized
= false;
1330 const int i_stream_type
= strtol( psz_opt
, NULL
, 0 );
1331 PIDFillFormat( &pid
->es
->fmt
, i_stream_type
);
1333 pid
->es
->fmt
.i_group
= i_number
;
1334 if( p_sys
->b_es_id_pid
)
1335 pid
->es
->fmt
.i_id
= i_pid
;
1337 if( pid
->es
->fmt
.i_cat
!= UNKNOWN_ES
)
1339 msg_Dbg( p_demux
, " * es pid=%d fcc=%4.4s", i_pid
,
1340 (char*)&pid
->es
->fmt
.i_codec
);
1341 pid
->es
->id
= es_out_Add( p_demux
->out
,
1351 p_sys
->b_user_pmt
= true;
1352 TAB_APPEND( p_sys
->i_pmt
, p_sys
->pmt
, pmt
);
1359 return VLC_EGENERIC
;
1362 static int SetPIDFilter( demux_t
*p_demux
, int i_pid
, bool b_selected
)
1364 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1366 if( !p_sys
->b_access_control
)
1367 return VLC_EGENERIC
;
1369 return stream_Control( p_demux
->s
, STREAM_SET_PRIVATE_ID_STATE
,
1370 i_pid
, b_selected
);
1373 static void SetPrgFilter( demux_t
*p_demux
, int i_prg_id
, bool b_selected
)
1375 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1376 ts_prg_psi_t
*p_prg
= NULL
;
1379 /* Search pmt to be unselected */
1380 for( int i
= 0; i
< p_sys
->i_pmt
; i
++ )
1382 ts_pid_t
*pmt
= p_sys
->pmt
[i
];
1384 for( int i_prg
= 0; i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
1386 if( pmt
->psi
->prg
[i_prg
]->i_number
== i_prg_id
)
1388 i_pmt_pid
= p_sys
->pmt
[i
]->i_pid
;
1389 p_prg
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
];
1396 if( i_pmt_pid
<= 0 )
1400 SetPIDFilter( p_demux
, i_pmt_pid
, b_selected
);
1401 if( p_prg
->i_pid_pcr
> 0 )
1402 SetPIDFilter( p_demux
, p_prg
->i_pid_pcr
, b_selected
);
1405 for( int i
= 2; i
< 8192; i
++ )
1407 ts_pid_t
*pid
= &p_sys
->pid
[i
];
1409 if( !pid
->b_valid
|| pid
->psi
)
1412 for( int i_prg
= 0; i_prg
< pid
->p_owner
->i_prg
; i_prg
++ )
1414 if( pid
->p_owner
->prg
[i_prg
]->i_pid_pmt
== i_pmt_pid
&& pid
->es
->id
)
1416 /* We only remove/select es that aren't defined by extra pmt */
1417 SetPIDFilter( p_demux
, i
, b_selected
);
1424 static void PIDInit( ts_pid_t
*pid
, bool b_psi
, ts_psi_t
*p_owner
)
1426 bool b_old_valid
= pid
->b_valid
;
1428 pid
->b_valid
= true;
1430 pid
->b_scrambled
= false;
1431 pid
->p_owner
= p_owner
;
1432 pid
->i_owner_number
= 0;
1434 TAB_INIT( pid
->i_extra_es
, pid
->extra_es
);
1442 pid
->psi
= xmalloc( sizeof( ts_psi_t
) );
1443 pid
->psi
->handle
= NULL
;
1444 TAB_INIT( pid
->psi
->i_prg
, pid
->psi
->prg
);
1448 pid
->psi
->i_pat_version
= -1;
1449 pid
->psi
->i_sdt_version
= -1;
1452 ts_prg_psi_t
*prg
= malloc( sizeof( ts_prg_psi_t
) );
1456 prg
->i_version
= -1;
1458 prg
->i_pid_pcr
= -1;
1459 prg
->i_pid_pmt
= -1;
1460 prg
->i_pcr_value
= -1;
1464 TAB_APPEND( pid
->psi
->i_prg
, pid
->psi
->prg
, prg
);
1470 pid
->es
= calloc( 1, sizeof( ts_es_t
) );
1474 es_format_Init( &pid
->es
->fmt
, UNKNOWN_ES
, 0 );
1475 pid
->es
->data_type
= TS_ES_DATA_PES
;
1476 pid
->es
->pp_last
= &pid
->es
->p_data
;
1480 static void PIDClean( demux_t
*p_demux
, ts_pid_t
*pid
)
1482 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1483 es_out_t
*out
= p_demux
->out
;
1487 if( pid
->psi
->handle
)
1489 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1490 if( dvbpsi_decoder_present( pid
->psi
->handle
) )
1491 dvbpsi_pmt_detach( pid
->psi
->handle
);
1492 dvbpsi_delete( pid
->psi
->handle
);
1493 pid
->psi
->handle
= NULL
;
1495 dvbpsi_DetachPMT( pid
->psi
->handle
);
1498 for( int i
= 0; i
< pid
->psi
->i_prg
; i
++ )
1500 if( pid
->psi
->prg
[i
]->iod
)
1501 IODFree( pid
->psi
->prg
[i
]->iod
);
1502 if( pid
->psi
->prg
[i
]->handle
)
1504 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1505 if( dvbpsi_decoder_present( pid
->psi
->prg
[i
]->handle
) )
1506 dvbpsi_pmt_detach( pid
->psi
->prg
[i
]->handle
);
1507 dvbpsi_delete( pid
->psi
->prg
[i
]->handle
);
1509 dvbpsi_DetachPMT( pid
->psi
->prg
[i
]->handle
);
1512 free( pid
->psi
->prg
[i
] );
1514 free( pid
->psi
->prg
);
1521 es_out_Del( out
, pid
->es
->id
);
1525 if( pid
->es
->p_data
)
1526 block_ChainRelease( pid
->es
->p_data
);
1528 es_format_Clean( &pid
->es
->fmt
);
1532 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
1534 if( pid
->extra_es
[i
]->id
)
1536 es_out_Del( out
, pid
->extra_es
[i
]->id
);
1540 if( pid
->extra_es
[i
]->p_data
)
1541 block_ChainRelease( pid
->extra_es
[i
]->p_data
);
1543 es_format_Clean( &pid
->extra_es
[i
]->fmt
);
1545 free( pid
->extra_es
[i
] );
1547 if( pid
->i_extra_es
)
1548 free( pid
->extra_es
);
1551 pid
->b_valid
= false;
1554 /****************************************************************************
1556 ****************************************************************************/
1557 static void ParsePES( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_pes
)
1559 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1561 unsigned i_pes_size
= 0;
1562 unsigned i_skip
= 0;
1565 mtime_t i_length
= 0;
1567 /* FIXME find real max size */
1568 /* const int i_max = */ block_ChainExtract( p_pes
, header
, 34 );
1570 if( header
[0] != 0 || header
[1] != 0 || header
[2] != 1 )
1572 msg_Warn( p_demux
, "invalid header [0x%02x:%02x:%02x:%02x] (pid: %d)",
1573 header
[0], header
[1],header
[2],header
[3], pid
->i_pid
);
1574 block_ChainRelease( p_pes
);
1578 /* TODO check size */
1581 case 0xBC: /* Program stream map */
1582 case 0xBE: /* Padding */
1583 case 0xBF: /* Private stream 2 */
1584 case 0xF0: /* ECM */
1585 case 0xF1: /* EMM */
1586 case 0xFF: /* Program stream directory */
1587 case 0xF2: /* DSMCC stream */
1588 case 0xF8: /* ITU-T H.222.1 type E stream */
1592 if( ( header
[6]&0xC0 ) == 0x80 )
1595 i_skip
= header
[8] + 9;
1597 if( header
[7]&0x80 ) /* has pts */
1599 i_pts
= ((mtime_t
)(header
[ 9]&0x0e ) << 29)|
1600 (mtime_t
)(header
[10] << 22)|
1601 ((mtime_t
)(header
[11]&0xfe) << 14)|
1602 (mtime_t
)(header
[12] << 7)|
1603 (mtime_t
)(header
[13] >> 1);
1605 if( header
[7]&0x40 ) /* has dts */
1607 i_dts
= ((mtime_t
)(header
[14]&0x0e ) << 29)|
1608 (mtime_t
)(header
[15] << 22)|
1609 ((mtime_t
)(header
[16]&0xfe) << 14)|
1610 (mtime_t
)(header
[17] << 7)|
1611 (mtime_t
)(header
[18] >> 1);
1618 while( i_skip
< 23 && header
[i_skip
] == 0xff )
1624 msg_Err( p_demux
, "too much MPEG-1 stuffing" );
1625 block_ChainRelease( p_pes
);
1628 if( ( header
[i_skip
] & 0xC0 ) == 0x40 )
1633 if( header
[i_skip
]&0x20 )
1635 i_pts
= ((mtime_t
)(header
[i_skip
]&0x0e ) << 29)|
1636 (mtime_t
)(header
[i_skip
+1] << 22)|
1637 ((mtime_t
)(header
[i_skip
+2]&0xfe) << 14)|
1638 (mtime_t
)(header
[i_skip
+3] << 7)|
1639 (mtime_t
)(header
[i_skip
+4] >> 1);
1641 if( header
[i_skip
]&0x10 ) /* has dts */
1643 i_dts
= ((mtime_t
)(header
[i_skip
+5]&0x0e ) << 29)|
1644 (mtime_t
)(header
[i_skip
+6] << 22)|
1645 ((mtime_t
)(header
[i_skip
+7]&0xfe) << 14)|
1646 (mtime_t
)(header
[i_skip
+8] << 7)|
1647 (mtime_t
)(header
[i_skip
+9] >> 1);
1663 if( pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'a', '5', '2', 'b' ) ||
1664 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'd', 't', 's', 'b' ) )
1668 else if( pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'l', 'p', 'c', 'b' ) ||
1669 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 's', 'p', 'u', 'b' ) ||
1670 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 's', 'd', 'd', 'b' ) )
1674 else if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SUBT
&&
1675 pid
->es
->p_mpeg4desc
)
1677 decoder_config_descriptor_t
*dcd
= &pid
->es
->p_mpeg4desc
->dec_descr
;
1679 if( dcd
->i_extra
> 2 &&
1680 dcd
->p_extra
[0] == 0x10 &&
1681 ( dcd
->p_extra
[1]&0x10 ) )
1683 /* display length */
1684 if( p_pes
->i_buffer
+ 2 <= i_skip
)
1685 i_length
= GetWBE( &p_pes
->p_buffer
[i_skip
] );
1689 if( p_pes
->i_buffer
+ 2 <= i_skip
)
1690 i_pes_size
= GetWBE( &p_pes
->p_buffer
[i_skip
] );
1696 while( p_pes
&& i_skip
> 0 )
1698 if( p_pes
->i_buffer
<= i_skip
)
1700 block_t
*p_next
= p_pes
->p_next
;
1702 i_skip
-= p_pes
->i_buffer
;
1703 block_Release( p_pes
);
1708 p_pes
->i_buffer
-= i_skip
;
1709 p_pes
->p_buffer
+= i_skip
;
1714 /* ISO/IEC 13818-1 2.7.5: if no pts and no dts, then dts == pts */
1715 if( i_pts
>= 0 && i_dts
< 0 )
1723 p_pes
->i_dts
= VLC_TS_0
+ i_dts
* 100 / 9;
1726 p_pes
->i_pts
= VLC_TS_0
+ i_pts
* 100 / 9;
1728 p_pes
->i_length
= i_length
* 100 / 9;
1730 p_block
= block_ChainGather( p_pes
);
1731 if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SUBT
)
1733 if( i_pes_size
> 0 && p_block
->i_buffer
> i_pes_size
)
1735 p_block
->i_buffer
= i_pes_size
;
1738 p_block
= block_Realloc( p_block
, 0, p_block
->i_buffer
+ 1 );
1741 p_block
->p_buffer
[p_block
->i_buffer
-1] = '\0';
1743 else if( pid
->es
->fmt
.i_codec
== VLC_CODEC_TELETEXT
)
1745 if( p_block
->i_pts
<= VLC_TS_INVALID
)
1747 /* Teletext may have missing PTS (ETSI EN 300 472 Annexe A)
1748 * In this case use the last PCR + 40ms */
1749 for( int i
= 0; pid
->p_owner
&& i
< pid
->p_owner
->i_prg
; i
++ )
1751 if( pid
->i_owner_number
== pid
->p_owner
->prg
[i
]->i_number
)
1753 mtime_t i_pcr
= pid
->p_owner
->prg
[i
]->i_pcr_value
;
1754 if( i_pcr
> VLC_TS_INVALID
)
1755 p_block
->i_pts
= VLC_TS_0
+ i_pcr
* 100 / 9 + 40000;
1761 else if( pid
->es
->fmt
.i_codec
== VLC_CODEC_ARIB_A
||
1762 pid
->es
->fmt
.i_codec
== VLC_CODEC_ARIB_C
)
1764 if( p_block
->i_pts
<= VLC_TS_INVALID
)
1766 if( i_pes_size
> 0 && p_block
->i_buffer
> i_pes_size
)
1768 p_block
->i_buffer
= i_pes_size
;
1771 p_block
= block_Realloc( p_block
, 0, p_block
->i_buffer
+ 1 );
1774 p_block
->p_buffer
[p_block
->i_buffer
-1] = '\0';
1778 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
1780 es_out_Send( p_demux
->out
, pid
->extra_es
[i
]->id
,
1781 block_Duplicate( p_block
) );
1784 if (!p_sys
->b_trust_pcr
)
1785 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_PCR
,
1786 pid
->i_owner_number
, p_block
->i_pts
);
1788 es_out_Send( p_demux
->out
, pid
->es
->id
, p_block
);
1792 msg_Warn( p_demux
, "empty pes" );
1796 static void ParseTableSection( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_data
)
1798 block_t
*p_content
= block_ChainGather( p_data
);
1799 mtime_t i_date
= -1;
1800 for( int i
= 0; pid
->p_owner
&& i
< pid
->p_owner
->i_prg
; i
++ )
1802 if( pid
->i_owner_number
== pid
->p_owner
->prg
[i
]->i_number
)
1804 i_date
= pid
->p_owner
->prg
[i
]->i_pcr_value
;
1811 if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SCTE_27
)
1813 /* We need to extract the truncated pts stored inside the payload */
1814 if( p_content
->i_buffer
> 9 && p_content
->p_buffer
[0] == 0xc6 )
1817 size_t i_offset
= 4;
1818 if( p_content
->p_buffer
[3] & 0x40 )
1820 i_index
= ((p_content
->p_buffer
[7] & 0x0f) << 8) |
1821 p_content
->p_buffer
[8];
1824 if( i_index
== 0 && p_content
->i_buffer
> i_offset
+ 8 )
1826 bool is_immediate
= p_content
->p_buffer
[i_offset
+ 3] & 0x40;
1829 mtime_t i_display_in
= GetDWBE( &p_content
->p_buffer
[i_offset
+ 4] );
1830 if( i_display_in
< i_date
)
1831 i_date
= i_display_in
+ (1ll << 32);
1833 i_date
= i_display_in
;
1840 p_content
->i_pts
= VLC_TS_0
+ i_date
* 100 / 9;
1842 es_out_Send( p_demux
->out
, pid
->es
->id
, p_content
);
1844 static void ParseData( demux_t
*p_demux
, ts_pid_t
*pid
)
1846 block_t
*p_data
= pid
->es
->p_data
;
1848 /* remove the pes from pid */
1849 pid
->es
->p_data
= NULL
;
1850 pid
->es
->i_data_size
= 0;
1851 pid
->es
->i_data_gathered
= 0;
1852 pid
->es
->pp_last
= &pid
->es
->p_data
;
1854 if( pid
->es
->data_type
== TS_ES_DATA_PES
)
1856 ParsePES( p_demux
, pid
, p_data
);
1858 else if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
)
1860 ParseTableSection( p_demux
, pid
, p_data
);
1864 block_ChainRelease( p_data
);
1868 static block_t
* ReadTSPacket( demux_t
*p_demux
)
1870 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1874 /* Get a new TS packet */
1875 if( !( p_pkt
= stream_Block( p_demux
->s
, p_sys
->i_packet_size
) ) )
1877 msg_Dbg( p_demux
, "eof ?" );
1881 /* Skip header (BluRay streams).
1882 * re-sync logic would do this (by adjusting packet start), but this would result in losing first and last ts packets.
1883 * First packet is usually PAT, and losing it means losing whole first GOP. This is fatal with still-image based menus.
1885 p_pkt
->p_buffer
+= p_sys
->i_packet_header_size
;
1886 p_pkt
->i_buffer
-= p_sys
->i_packet_header_size
;
1888 /* Check sync byte and re-sync if needed */
1889 if( p_pkt
->p_buffer
[0] != 0x47 )
1891 msg_Warn( p_demux
, "lost synchro" );
1892 block_Release( p_pkt
);
1893 while( vlc_object_alive (p_demux
) )
1895 const uint8_t *p_peek
;
1896 int i_peek
, i_skip
= 0;
1898 i_peek
= stream_Peek( p_demux
->s
, &p_peek
,
1899 p_sys
->i_packet_size
* 10 );
1900 if( i_peek
< p_sys
->i_packet_size
+ 1 )
1902 msg_Dbg( p_demux
, "eof ?" );
1906 while( i_skip
< i_peek
- p_sys
->i_packet_size
)
1908 if( p_peek
[i_skip
+ p_sys
->i_packet_header_size
] == 0x47 &&
1909 p_peek
[i_skip
+ p_sys
->i_packet_header_size
+ p_sys
->i_packet_size
] == 0x47 )
1915 msg_Dbg( p_demux
, "skipping %d bytes of garbage", i_skip
);
1916 stream_Read( p_demux
->s
, NULL
, i_skip
);
1918 if( i_skip
< i_peek
- p_sys
->i_packet_size
)
1923 if( !( p_pkt
= stream_Block( p_demux
->s
, p_sys
->i_packet_size
) ) )
1925 msg_Dbg( p_demux
, "eof ?" );
1932 static mtime_t
AdjustPCRWrapAround( demux_t
*p_demux
, mtime_t i_pcr
)
1934 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1936 * PCR is 33bit. If PCR reaches to 0x1FFFFFFFF (26:30:43.717), ressets from 0.
1937 * So, need to add 0x1FFFFFFFF, for calculating duration or current position.
1939 mtime_t i_adjust
= 0;
1940 int64_t i_pos
= stream_Tell( p_demux
->s
);
1942 for( i
= 1; i
< p_sys
->i_pcrs_num
&& p_sys
->p_pos
[i
] <= i_pos
; ++i
)
1944 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
1945 i_adjust
+= 0x1FFFFFFFF;
1947 if( p_sys
->p_pcrs
[i
-1] > i_pcr
)
1948 i_adjust
+= 0x1FFFFFFFF;
1950 return i_pcr
+ i_adjust
;
1953 static mtime_t
GetPCR( block_t
*p_pkt
)
1955 const uint8_t *p
= p_pkt
->p_buffer
;
1959 if( ( p
[3]&0x20 ) && /* adaptation */
1963 /* PCR is 33 bits */
1964 i_pcr
= ( (mtime_t
)p
[6] << 25 ) |
1965 ( (mtime_t
)p
[7] << 17 ) |
1966 ( (mtime_t
)p
[8] << 9 ) |
1967 ( (mtime_t
)p
[9] << 1 ) |
1968 ( (mtime_t
)p
[10] >> 7 );
1973 static int SeekToPCR( demux_t
*p_demux
, int64_t i_pos
)
1975 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1978 const int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
1981 return VLC_EGENERIC
;
1983 int64_t i_last_pos
= stream_Size( p_demux
->s
) - p_sys
->i_packet_size
;
1984 if( i_pos
> i_last_pos
)
1987 if( stream_Seek( p_demux
->s
, i_pos
) )
1988 return VLC_EGENERIC
;
1990 while( vlc_object_alive( p_demux
) )
1994 if( !( p_pkt
= ReadTSPacket( p_demux
) ) )
1998 if( PIDGet( p_pkt
) == p_sys
->i_pid_ref_pcr
)
2000 i_pcr
= GetPCR( p_pkt
);
2002 block_Release( p_pkt
);
2005 if( stream_Tell( p_demux
->s
) >= i_last_pos
)
2010 stream_Seek( p_demux
->s
, i_initial_pos
);
2011 assert( i_initial_pos
== stream_Tell( p_demux
->s
) );
2012 return VLC_EGENERIC
;
2015 p_sys
->i_current_pcr
= i_pcr
;
2019 static int Seek( demux_t
*p_demux
, double f_percent
)
2021 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2023 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2024 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
2027 * Find the time position by using binary search algorithm.
2029 mtime_t i_target_pcr
= (p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * f_percent
+ p_sys
->i_first_pcr
;
2031 int64_t i_head_pos
= 0;
2034 mtime_t i_adjust
= 0;
2036 for( i
= 1; i
< p_sys
->i_pcrs_num
; ++i
)
2038 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
2039 i_adjust
+= 0x1FFFFFFFF;
2040 if( p_sys
->p_pcrs
[i
] + i_adjust
> i_target_pcr
)
2043 i_head_pos
= p_sys
->p_pos
[i
-1];
2044 i_tail_pos
= ( i
< p_sys
->i_pcrs_num
) ? p_sys
->p_pos
[i
] : stream_Size( p_demux
->s
);
2046 msg_Dbg( p_demux
, "Seek():i_head_pos:%"PRId64
", i_tail_pos:%"PRId64
, i_head_pos
, i_tail_pos
);
2048 bool b_found
= false;
2050 while( i_head_pos
<= i_tail_pos
)
2052 /* Round i_pos to a multiple of p_sys->i_packet_size */
2053 int64_t i_pos
= i_head_pos
+ (i_tail_pos
- i_head_pos
) / 2;
2054 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2056 if( SeekToPCR( p_demux
, i_pos
) )
2058 p_sys
->i_current_pcr
= AdjustPCRWrapAround( p_demux
, p_sys
->i_current_pcr
);
2059 int64_t i_diff_msec
= (p_sys
->i_current_pcr
- i_target_pcr
) * 100 / 9 / 1000;
2060 if( i_diff_msec
> 500 )
2062 i_tail_pos
= i_pos
- p_sys
->i_packet_size
;
2064 else if( i_diff_msec
< -500 )
2066 i_head_pos
= i_pos
+ p_sys
->i_packet_size
;
2070 // diff time <= 500msec
2078 msg_Dbg( p_demux
, "Seek():cannot find a time position. i_cnt:%d", i_cnt
);
2079 stream_Seek( p_demux
->s
, i_initial_pos
);
2080 p_sys
->i_current_pcr
= i_initial_pcr
;
2081 return VLC_EGENERIC
;
2085 msg_Dbg( p_demux
, "Seek():can find a time position. i_cnt:%d", i_cnt
);
2090 static void GetFirstPCR( demux_t
*p_demux
)
2092 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2094 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2096 if( stream_Seek( p_demux
->s
, 0 ) )
2099 while( vlc_object_alive (p_demux
) )
2103 if( !( p_pkt
= ReadTSPacket( p_demux
) ) )
2107 mtime_t i_pcr
= GetPCR( p_pkt
);
2110 p_sys
->i_pid_ref_pcr
= PIDGet( p_pkt
);
2111 p_sys
->i_first_pcr
= i_pcr
;
2112 p_sys
->i_current_pcr
= i_pcr
;
2114 block_Release( p_pkt
);
2115 if( p_sys
->i_first_pcr
>= 0 )
2118 stream_Seek( p_demux
->s
, i_initial_pos
);
2121 static void GetLastPCR( demux_t
*p_demux
)
2123 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2125 const int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2126 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
2128 int64_t i_stream_size
= stream_Size( p_demux
->s
);
2129 int64_t i_last_pos
= i_stream_size
- p_sys
->i_packet_size
;
2130 /* Round i_pos to a multiple of p_sys->i_packet_size */
2131 int64_t i_pos
= i_last_pos
- p_sys
->i_packet_size
* 4500; /* FIXME if the value is not reasonable, please change it. */
2132 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2135 if( i_pos
<= i_initial_pos
&& i_pos
>= i_stream_size
)
2136 i_pos
= i_initial_pos
+ p_sys
->i_packet_size
;
2137 if( i_pos
< 0 && i_pos
>= i_stream_size
)
2140 while( vlc_object_alive( p_demux
) )
2142 if( SeekToPCR( p_demux
, i_pos
) )
2144 p_sys
->i_last_pcr
= AdjustPCRWrapAround( p_demux
, p_sys
->i_current_pcr
);
2145 if( ( i_pos
= stream_Tell( p_demux
->s
) ) >= i_last_pos
)
2148 if( p_sys
->i_last_pcr
>= 0 )
2150 int64_t i_size
= stream_Size( p_demux
->s
);
2151 mtime_t i_duration_msec
= ( p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * 100 / 9 / 1000;
2152 int64_t i_rate
= ( i_size
< 0 || i_duration_msec
<= 0 ) ? 0 : i_size
* 1000 * 8 / i_duration_msec
;
2153 const int64_t TS_SUPPOSED_MAXRATE
= 55 * 1000 * 1000; //FIXME I think it's enough.
2154 const int64_t TS_SUPPOSED_MINRATE
= 0.5 * 1000 * 1000; //FIXME
2155 if( i_rate
< TS_SUPPOSED_MINRATE
|| i_rate
> TS_SUPPOSED_MAXRATE
)
2157 msg_Dbg( p_demux
, "calculated bitrate (%"PRId64
"bit/s) is too low or too high. min bitrate (%"PRId64
"bit/s) max bitrate (%"PRId64
"bit/s)",
2158 i_rate
, TS_SUPPOSED_MINRATE
, TS_SUPPOSED_MAXRATE
);
2159 p_sys
->i_last_pcr
= -1;
2162 stream_Seek( p_demux
->s
, i_initial_pos
);
2163 assert( i_initial_pos
== stream_Tell( p_demux
->s
) );
2164 p_sys
->i_current_pcr
= i_initial_pcr
;
2167 static void CheckPCR( demux_t
*p_demux
)
2169 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2171 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2172 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
2174 int64_t i_size
= stream_Size( p_demux
->s
);
2177 p_sys
->p_pcrs
[0] = p_sys
->i_first_pcr
;
2178 p_sys
->p_pos
[0] = i_initial_pos
;
2180 for( i
= 1; i
< p_sys
->i_pcrs_num
&& vlc_object_alive( p_demux
); ++i
)
2182 /* Round i_pos to a multiple of p_sys->i_packet_size */
2183 int64_t i_pos
= i_size
/ p_sys
->i_pcrs_num
* i
;
2184 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2186 if( SeekToPCR( p_demux
, i_pos
) )
2188 p_sys
->p_pcrs
[i
] = p_sys
->i_current_pcr
;
2189 p_sys
->p_pos
[i
] = stream_Tell( p_demux
->s
);
2190 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
2192 msg_Dbg( p_demux
, "PCR Wrap Around found between %d%% and %d%% (pcr:%"PRId64
"(0x%09"PRIx64
") pcr:%"PRId64
"(0x%09"PRIx64
"))",
2193 (int)((i
-1)*100/p_sys
->i_pcrs_num
), (int)(i
*100/p_sys
->i_pcrs_num
), p_sys
->p_pcrs
[i
-1], p_sys
->p_pcrs
[i
-1], p_sys
->p_pcrs
[i
], p_sys
->p_pcrs
[i
] );
2196 if( i
< p_sys
->i_pcrs_num
)
2198 msg_Dbg( p_demux
, "Force Seek Per Percent: Seeking failed at %d%%.", (int)(i
*100/p_sys
->i_pcrs_num
) );
2199 p_sys
->b_force_seek_per_percent
= true;
2202 stream_Seek( p_demux
->s
, i_initial_pos
);
2203 p_sys
->i_current_pcr
= i_initial_pcr
;
2206 static void PCRHandle( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
)
2208 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2210 if( p_sys
->i_pmt_es
<= 0 )
2213 mtime_t i_pcr
= GetPCR( p_bk
);
2217 if( p_sys
->i_pid_ref_pcr
== pid
->i_pid
)
2218 p_sys
->i_current_pcr
= AdjustPCRWrapAround( p_demux
, i_pcr
);
2220 /* Search program and set the PCR */
2222 for( int i
= 0; i
< p_sys
->i_pmt
&& i_group
< 0 ; i
++ )
2224 bool b_pmt_has_es
= false;
2226 for( int i_prg
= 0; i_prg
< p_sys
->pmt
[i
]->psi
->i_prg
; i_prg
++ )
2228 if( pid
->i_pid
== p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_pid_pcr
)
2230 /* We've found our target group */
2231 p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_pcr_value
= i_pcr
;
2232 i_group
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_number
;
2233 for( int j
= 0; j
< 8192; j
++ )
2235 const ts_pid_t
*pid
= &p_sys
->pid
[j
];
2236 if( pid
->b_valid
&& pid
->p_owner
== p_sys
->pmt
[i
]->psi
&& pid
->es
)
2238 b_pmt_has_es
= true;
2245 if ( p_sys
->b_trust_pcr
&& i_group
> 0 && b_pmt_has_es
)
2246 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_PCR
,
2247 i_group
, VLC_TS_0
+ i_pcr
* 100 / 9 );
2251 static bool GatherData( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
)
2253 const uint8_t *p
= p_bk
->p_buffer
;
2254 const bool b_unit_start
= p
[1]&0x40;
2255 const bool b_scrambled
= p
[3]&0x80;
2256 const bool b_adaptation
= p
[3]&0x20;
2257 const bool b_payload
= p
[3]&0x10;
2258 const int i_cc
= p
[3]&0x0f; /* continuity counter */
2259 bool b_discontinuity
= false; /* discontinuity */
2261 /* transport_scrambling_control is ignored */
2266 msg_Dbg( p_demux
, "pid=%d unit_start=%d adaptation=%d payload=%d "
2267 "cc=0x%x", pid
->i_pid
, b_unit_start
, b_adaptation
,
2271 /* For now, ignore additional error correction
2272 * TODO: handle Reed-Solomon 204,188 error correction */
2273 p_bk
->i_buffer
= TS_PACKET_SIZE_188
;
2277 msg_Dbg( p_demux
, "transport_error_indicator set (pid=%d)",
2279 if( pid
->es
->p_data
) //&& pid->es->fmt.i_cat == VIDEO_ES )
2280 pid
->es
->p_data
->i_flags
|= BLOCK_FLAG_CORRUPTED
;
2283 if( p_demux
->p_sys
->csa
)
2285 vlc_mutex_lock( &p_demux
->p_sys
->csa_lock
);
2286 csa_Decrypt( p_demux
->p_sys
->csa
, p_bk
->p_buffer
, p_demux
->p_sys
->i_csa_pkt_size
);
2287 vlc_mutex_unlock( &p_demux
->p_sys
->csa_lock
);
2292 /* We don't have any adaptation_field, so payload starts
2293 * immediately after the 4 byte TS header */
2298 /* p[4] is adaptation_field_length minus one */
2302 /* discontinuity indicator found in stream */
2303 b_discontinuity
= (p
[5]&0x80) ? true : false;
2304 if( b_discontinuity
&& pid
->es
->p_data
)
2306 msg_Warn( p_demux
, "discontinuity indicator (pid=%d) ",
2308 /* pid->es->p_data->i_flags |= BLOCK_FLAG_DISCONTINUITY; */
2312 msg_Dbg( p_demux
, "random access indicator (pid=%d) ", pid
->i_pid
);
2317 /* Test continuity counter */
2318 /* continuous when (one of this):
2320 * diff == 0 and payload == 0
2321 * diff == 0 and duplicate packet (playload != 0) <- should we
2322 * test the content ?
2324 const int i_diff
= ( i_cc
- pid
->i_cc
)&0x0f;
2325 if( b_payload
&& i_diff
== 1 )
2327 pid
->i_cc
= ( pid
->i_cc
+ 1 ) & 0xf;
2331 if( pid
->i_cc
== 0xff )
2333 msg_Warn( p_demux
, "first packet for pid=%d cc=0x%x",
2337 else if( i_diff
!= 0 && !b_discontinuity
)
2339 msg_Warn( p_demux
, "discontinuity received 0x%x instead of 0x%x (pid=%d)",
2340 i_cc
, ( pid
->i_cc
+ 1 )&0x0f, pid
->i_pid
);
2343 if( pid
->es
->p_data
&& pid
->es
->fmt
.i_cat
!= VIDEO_ES
)
2345 /* Small video artifacts are usually better than
2346 * dropping full frames */
2347 pid
->es
->p_data
->i_flags
|= BLOCK_FLAG_CORRUPTED
;
2352 PCRHandle( p_demux
, pid
, p_bk
);
2354 if( i_skip
>= 188 || pid
->es
->id
== NULL
)
2356 block_Release( p_bk
);
2361 if( !pid
->b_scrambled
!= !b_scrambled
)
2363 msg_Warn( p_demux
, "scrambled state changed on pid %d (%d->%d)",
2364 pid
->i_pid
, pid
->b_scrambled
, b_scrambled
);
2366 pid
->b_scrambled
= b_scrambled
;
2368 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
2370 es_out_Control( p_demux
->out
, ES_OUT_SET_ES_SCRAMBLED_STATE
,
2371 pid
->extra_es
[i
]->id
, b_scrambled
);
2373 es_out_Control( p_demux
->out
, ES_OUT_SET_ES_SCRAMBLED_STATE
,
2374 pid
->es
->id
, b_scrambled
);
2377 /* We have to gather it */
2378 p_bk
->p_buffer
+= i_skip
;
2379 p_bk
->i_buffer
-= i_skip
;
2383 if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
&& p_bk
->i_buffer
> 0 )
2385 int i_pointer_field
= __MIN( p_bk
->p_buffer
[0], p_bk
->i_buffer
- 1 );
2386 block_t
*p
= block_Duplicate( p_bk
);
2389 p
->i_buffer
= i_pointer_field
;
2391 block_ChainLastAppend( &pid
->es
->pp_last
, p
);
2393 p_bk
->i_buffer
-= 1 + i_pointer_field
;
2394 p_bk
->p_buffer
+= 1 + i_pointer_field
;
2396 if( pid
->es
->p_data
)
2398 ParseData( p_demux
, pid
);
2402 block_ChainLastAppend( &pid
->es
->pp_last
, p_bk
);
2403 if( pid
->es
->data_type
== TS_ES_DATA_PES
)
2405 if( p_bk
->i_buffer
> 6 )
2407 pid
->es
->i_data_size
= GetWBE( &p_bk
->p_buffer
[4] );
2408 if( pid
->es
->i_data_size
> 0 )
2410 pid
->es
->i_data_size
+= 6;
2414 else if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
)
2416 if( p_bk
->i_buffer
> 3 && p_bk
->p_buffer
[0] != 0xff )
2418 pid
->es
->i_data_size
= 3 + (((p_bk
->p_buffer
[1] & 0xf) << 8) | p_bk
->p_buffer
[2]);
2421 pid
->es
->i_data_gathered
+= p_bk
->i_buffer
;
2422 if( pid
->es
->i_data_size
> 0 &&
2423 pid
->es
->i_data_gathered
>= pid
->es
->i_data_size
)
2425 ParseData( p_demux
, pid
);
2431 if( pid
->es
->p_data
== NULL
)
2433 /* msg_Dbg( p_demux, "broken packet" ); */
2434 block_Release( p_bk
);
2438 block_ChainLastAppend( &pid
->es
->pp_last
, p_bk
);
2439 pid
->es
->i_data_gathered
+= p_bk
->i_buffer
;
2441 if( pid
->es
->i_data_size
> 0 &&
2442 pid
->es
->i_data_gathered
>= pid
->es
->i_data_size
)
2444 ParseData( p_demux
, pid
);
2453 static void PIDFillFormat( es_format_t
*fmt
, int i_stream_type
)
2455 switch( i_stream_type
)
2457 case 0x01: /* MPEG-1 video */
2458 case 0x02: /* MPEG-2 video */
2459 case 0x80: /* MPEG-2 MOTO video */
2460 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_MPGV
);
2462 case 0x03: /* MPEG-1 audio */
2463 case 0x04: /* MPEG-2 audio */
2464 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_MPGA
);
2466 case 0x11: /* MPEG4 (audio) LATM */
2467 case 0x0f: /* ISO/IEC 13818-7 Audio with ADTS transport syntax */
2468 case 0x1c: /* ISO/IEC 14496-3 Audio, without using any additional
2469 transport syntax, such as DST, ALS and SLS */
2470 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_MP4A
);
2472 case 0x10: /* MPEG4 (video) */
2473 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_MP4V
);
2475 case 0x1B: /* H264 <- check transport syntax/needed descriptor */
2476 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_H264
);
2478 case 0x24: /* HEVC */
2479 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_HEVC
);
2481 case 0x42: /* CAVS (Chinese AVS) */
2482 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_CAVS
);
2485 case 0x81: /* A52 (audio) */
2486 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_A52
);
2488 case 0x82: /* SCTE-27 (sub) */
2489 es_format_Init( fmt
, SPU_ES
, VLC_CODEC_SCTE_27
);
2491 case 0x84: /* SDDS (audio) */
2492 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_SDDS
);
2494 case 0x85: /* DTS (audio) */
2495 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_DTS
);
2497 case 0x87: /* E-AC3 */
2498 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_EAC3
);
2501 case 0x91: /* A52 vls (audio) */
2502 es_format_Init( fmt
, AUDIO_ES
, VLC_FOURCC( 'a', '5', '2', 'b' ) );
2504 case 0x92: /* DVD_SPU vls (sub) */
2505 es_format_Init( fmt
, SPU_ES
, VLC_FOURCC( 's', 'p', 'u', 'b' ) );
2508 case 0x94: /* SDDS (audio) */
2509 es_format_Init( fmt
, AUDIO_ES
, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
2512 case 0xa0: /* MSCODEC vlc (video) (fixed later) */
2513 es_format_Init( fmt
, UNKNOWN_ES
, 0 );
2516 case 0x06: /* PES_PRIVATE (fixed later) */
2517 case 0x12: /* MPEG-4 generic (sub/scene/...) (fixed later) */
2518 case 0xEA: /* Privately managed ES (VC-1) (fixed later */
2520 es_format_Init( fmt
, UNKNOWN_ES
, 0 );
2524 /* PES packets usually contain truncated frames */
2525 fmt
->b_packetized
= false;
2528 /*****************************************************************************
2529 * MP4 specific functions (IOD parser)
2530 *****************************************************************************/
2531 static int IODDescriptorLength( int *pi_data
, uint8_t **pp_data
)
2534 unsigned int i_len
= 0;
2540 i_len
= ( i_len
<< 7 ) + ( i_b
&0x7f );
2542 } while( i_b
&0x80 && *pi_data
> 0 );
2544 if (i_len
> *pi_data
)
2550 static int IODGetBytes( int *pi_data
, uint8_t **pp_data
, size_t bytes
)
2553 while( *pi_data
> 0 && bytes
-- )
2564 static char* IODGetURL( int *pi_data
, uint8_t **pp_data
)
2566 int len
= IODGetBytes( pi_data
, pp_data
, 1 );
2569 char *url
= strndup( (char*)*pp_data
, len
);
2575 static iod_descriptor_t
*IODNew( int i_data
, uint8_t *p_data
)
2577 uint8_t i_iod_tag
, i_iod_label
, byte1
, byte2
, byte3
;
2579 iod_descriptor_t
*p_iod
= calloc( 1, sizeof( iod_descriptor_t
) );
2588 byte1
= IODGetBytes( &i_data
, &p_data
, 1 );
2589 byte2
= IODGetBytes( &i_data
, &p_data
, 1 );
2590 byte3
= IODGetBytes( &i_data
, &p_data
, 1 );
2591 if( byte2
== 0x02 ) //old vlc's buggy implementation of the IOD_descriptor
2593 i_iod_label
= byte1
;
2596 else //correct implementation of the IOD_descriptor
2598 i_iod_label
= byte2
;
2602 ts_debug( "\n* iod label:%d tag:0x%x", i_iod_label
, i_iod_tag
);
2604 if( i_iod_tag
!= 0x02 )
2606 ts_debug( "\n ERR: tag %02x != 0x02", i_iod_tag
);
2610 IODDescriptorLength( &i_data
, &p_data
);
2612 uint16_t i_od_id
= ( IODGetBytes( &i_data
, &p_data
, 1 ) << 2 );
2613 uint8_t i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2614 i_od_id
|= i_flags
>> 6;
2615 ts_debug( "\n* od_id:%d", i_od_id
);
2616 ts_debug( "\n* includeInlineProfileLevel flag:%d", ( i_flags
>> 4 )&0x01 );
2617 if ((i_flags
>> 5) & 0x01)
2619 p_iod
->psz_url
= IODGetURL( &i_data
, &p_data
);
2620 ts_debug( "\n* url string:%s", p_iod
->psz_url
);
2621 ts_debug( "\n*****************************\n" );
2626 p_iod
->psz_url
= NULL
;
2629 /* Profile Level Indication */
2630 IODGetBytes( &i_data
, &p_data
, 1 ); /* OD */
2631 IODGetBytes( &i_data
, &p_data
, 1 ); /* scene */
2632 IODGetBytes( &i_data
, &p_data
, 1 ); /* audio */
2633 IODGetBytes( &i_data
, &p_data
, 1 ); /* visual */
2634 IODGetBytes( &i_data
, &p_data
, 1 ); /* graphics */
2637 int i_data_sav
= i_data
;
2638 uint8_t *p_data_sav
= p_data
;
2639 for (int i
= 0; i_data
> 0 && i
< ES_DESCRIPTOR_COUNT
; i
++)
2641 es_mpeg4_descriptor_t
*es_descr
= &p_iod
->es_descr
[i
];
2643 p_data
= p_data_sav
+ i_length
;
2644 i_data
= i_data_sav
- i_length
;
2646 int i_tag
= IODGetBytes( &i_data
, &p_data
, 1 );
2647 i_length
= IODDescriptorLength( &i_data
, &p_data
);
2649 i_data_sav
= i_data
;
2650 p_data_sav
= p_data
;
2654 if ( i_tag
!= 0x03 )
2656 ts_debug( "\n* - OD tag:0x%x Unsupported", i_tag
);
2660 es_descr
->i_es_id
= IODGetBytes( &i_data
, &p_data
, 2 );
2661 int i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2662 bool b_streamDependenceFlag
= ( i_flags
>> 7 )&0x01;
2663 if( b_streamDependenceFlag
)
2664 IODGetBytes( &i_data
, &p_data
, 2 ); /* dependOn_es_id */
2666 if( (i_flags
>> 6) & 0x01 )
2667 es_descr
->psz_url
= IODGetURL( &i_data
, &p_data
);
2669 bool b_OCRStreamFlag
= ( i_flags
>> 5 )&0x01;
2670 if( b_OCRStreamFlag
)
2671 IODGetBytes( &i_data
, &p_data
, 2 ); /* OCR_es_id */
2673 if( IODGetBytes( &i_data
, &p_data
, 1 ) != 0x04 )
2675 ts_debug( "\n* ERR missing DecoderConfigDescr" );
2678 int i_config_desc_length
= IODDescriptorLength( &i_data
, &p_data
); /* DecoderConfigDescr_length */
2679 decoder_config_descriptor_t
*dec_descr
= &es_descr
->dec_descr
;
2680 dec_descr
->i_objectTypeIndication
= IODGetBytes( &i_data
, &p_data
, 1 );
2681 i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2682 dec_descr
->i_streamType
= i_flags
>> 2;
2684 IODGetBytes( &i_data
, &p_data
, 3); /* bufferSizeDB */
2685 IODGetBytes( &i_data
, &p_data
, 4); /* maxBitrate */
2686 IODGetBytes( &i_data
, &p_data
, 4 ); /* avgBitrate */
2688 if( i_config_desc_length
> 13 && IODGetBytes( &i_data
, &p_data
, 1 ) == 0x05 )
2690 dec_descr
->i_extra
= IODDescriptorLength( &i_data
, &p_data
);
2691 if( dec_descr
->i_extra
> 0 )
2693 dec_descr
->p_extra
= xmalloc( dec_descr
->i_extra
);
2694 memcpy(dec_descr
->p_extra
, p_data
, dec_descr
->i_extra
);
2695 p_data
+= dec_descr
->i_extra
;
2696 i_data
-= dec_descr
->i_extra
;
2701 dec_descr
->i_extra
= 0;
2702 dec_descr
->p_extra
= NULL
;
2705 if( IODGetBytes( &i_data
, &p_data
, 1 ) != 0x06 )
2707 ts_debug( "\n* ERR missing SLConfigDescr" );
2710 IODDescriptorLength( &i_data
, &p_data
); /* SLConfigDescr_length */
2711 switch( IODGetBytes( &i_data
, &p_data
, 1 ) /* predefined */ )
2714 ts_debug( "\n* ERR unsupported SLConfigDescr predefined" );
2719 es_descr
->b_ok
= true;
2725 static void IODFree( iod_descriptor_t
*p_iod
)
2727 if( p_iod
->psz_url
)
2729 free( p_iod
->psz_url
);
2734 for( int i
= 0; i
< 255; i
++ )
2736 #define es_descr p_iod->es_descr[i]
2739 if( es_descr
.psz_url
)
2740 free( es_descr
.psz_url
);
2742 free( es_descr
.dec_descr
.p_extra
);
2749 /****************************************************************************
2750 ****************************************************************************
2751 ** libdvbpsi callbacks
2752 ****************************************************************************
2753 ****************************************************************************/
2754 static bool ProgramIsSelected( demux_t
*p_demux
, uint16_t i_pgrm
)
2756 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2758 if( ( p_sys
->i_current_program
== -1 && p_sys
->programs_list
.i_count
== 0 ) ||
2759 p_sys
->i_current_program
== 0 )
2761 if( p_sys
->i_current_program
== i_pgrm
)
2764 if( p_sys
->programs_list
.i_count
!= 0 )
2766 for( int i
= 0; i
< p_sys
->programs_list
.i_count
; i
++ )
2768 if( i_pgrm
== p_sys
->programs_list
.p_values
[i
].i_int
)
2775 static void ValidateDVBMeta( demux_t
*p_demux
, int i_pid
)
2777 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2779 if( !p_sys
->b_dvb_meta
|| ( i_pid
!= 0x11 && i_pid
!= 0x12 && i_pid
!= 0x14 ) )
2782 msg_Warn( p_demux
, "Switching to non DVB mode" );
2784 /* This doesn't look like a DVB stream so don't try
2785 * parsing the SDT/EDT/TDT */
2787 for( int i
= 0x11; i
<= 0x14; i
++ )
2789 if( i
== 0x13 ) continue;
2790 ts_pid_t
*p_pid
= &p_sys
->pid
[i
];
2794 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
2795 if( dvbpsi_decoder_present( p_pid
->psi
->handle
))
2796 dvbpsi_DetachDemux( p_pid
->psi
->handle
);
2797 dvbpsi_delete( p_pid
->psi
->handle
);
2799 dvbpsi_DetachDemux( p_pid
->psi
->handle
);
2803 p_pid
->b_valid
= false;
2805 SetPIDFilter( p_demux
, i
, false );
2807 p_sys
->b_dvb_meta
= false;
2810 #include "dvb-text.h"
2812 static char *EITConvertToUTF8( demux_t
*p_demux
,
2813 const unsigned char *psz_instring
,
2817 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2819 if( p_sys
->arib
.e_mode
== ARIBMODE_ENABLED
)
2821 if ( !p_sys
->arib
.p_instance
)
2822 p_sys
->arib
.p_instance
= arib_instance_new( p_demux
);
2823 if ( !p_sys
->arib
.p_instance
)
2825 arib_decoder_t
*p_decoder
= arib_get_decoder( p_sys
->arib
.p_instance
);
2829 char *psz_outstring
= NULL
;
2832 i_out
= i_length
* 4;
2833 psz_outstring
= (char*) calloc( i_out
+ 1, sizeof(char) );
2834 if( !psz_outstring
)
2837 arib_initialize_decoder( p_decoder
);
2838 i_out
= arib_decode_buffer( p_decoder
, psz_instring
, i_length
,
2839 psz_outstring
, i_out
);
2840 arib_finalize_decoder( p_decoder
);
2842 return psz_outstring
;
2847 /* Deal with no longer broken providers (no switch byte
2848 but sending ISO_8859-1 instead of ISO_6937) without
2849 removing them from the broken providers table
2850 (keep the entry for correctly handling recorded TS).
2852 b_broken
= b_broken
&& i_length
&& *psz_instring
> 0x20;
2855 return FromCharset( "ISO_8859-1", psz_instring
, i_length
);
2856 return vlc_from_EIT( psz_instring
, i_length
);
2859 static void SDTCallBack( demux_t
*p_demux
, dvbpsi_sdt_t
*p_sdt
)
2861 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2862 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
2863 dvbpsi_sdt_service_t
*p_srv
;
2865 msg_Dbg( p_demux
, "SDTCallBack called" );
2867 if( sdt
->psi
->i_sdt_version
!= -1 &&
2868 ( !p_sdt
->b_current_next
||
2869 p_sdt
->i_version
== sdt
->psi
->i_sdt_version
) )
2871 dvbpsi_DeleteSDT( p_sdt
);
2875 msg_Dbg( p_demux
, "new SDT ts_id=%d version=%d current_next=%d "
2877 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
2882 p_sdt
->i_version
, p_sdt
->b_current_next
,
2883 p_sdt
->i_network_id
);
2885 p_sys
->b_broken_charset
= false;
2887 for( p_srv
= p_sdt
->p_first_service
; p_srv
; p_srv
= p_srv
->p_next
)
2890 dvbpsi_descriptor_t
*p_dr
;
2892 const char *psz_type
= NULL
;
2893 const char *psz_status
= NULL
;
2895 msg_Dbg( p_demux
, " * service id=%d eit schedule=%d present=%d "
2896 "running=%d free_ca=%d",
2897 p_srv
->i_service_id
, p_srv
->b_eit_schedule
,
2898 p_srv
->b_eit_present
, p_srv
->i_running_status
,
2901 p_meta
= vlc_meta_New();
2902 for( p_dr
= p_srv
->p_first_descriptor
; p_dr
; p_dr
= p_dr
->p_next
)
2904 if( p_dr
->i_tag
== 0x48 )
2906 static const char *ppsz_type
[17] = {
2908 "Digital television service",
2909 "Digital radio sound service",
2911 "NVOD reference service",
2912 "NVOD time-shifted service",
2915 "SECAM coded signal",
2918 "NTSC coded signal",
2919 "Data broadcast service",
2920 "Reserved for Common Interface Usage",
2921 "RCS Map (see EN 301 790 [35])",
2922 "RCS FLS (see EN 301 790 [35])",
2925 dvbpsi_service_dr_t
*pD
= dvbpsi_DecodeServiceDr( p_dr
);
2929 /* Workarounds for broadcasters with broken EPG */
2931 if( p_sdt
->i_network_id
== 133 )
2932 p_sys
->b_broken_charset
= true; /* SKY DE & BetaDigital use ISO8859-1 */
2934 /* List of providers using ISO8859-1 */
2935 static const char ppsz_broken_providers
[][8] = {
2936 "CSAT", /* CanalSat FR */
2937 "GR1", /* France televisions */
2939 "MR5", /* France 2/M6 HD */
2942 for( int i
= 0; *ppsz_broken_providers
[i
]; i
++ )
2944 const size_t i_length
= strlen(ppsz_broken_providers
[i
]);
2945 if( pD
->i_service_provider_name_length
== i_length
&&
2946 !strncmp( (char *)pD
->i_service_provider_name
, ppsz_broken_providers
[i
], i_length
) )
2947 p_sys
->b_broken_charset
= true;
2950 /* FIXME: Digital+ ES also uses ISO8859-1 */
2952 str1
= EITConvertToUTF8(p_demux
,
2953 pD
->i_service_provider_name
,
2954 pD
->i_service_provider_name_length
,
2955 p_sys
->b_broken_charset
);
2956 str2
= EITConvertToUTF8(p_demux
,
2958 pD
->i_service_name_length
,
2959 p_sys
->b_broken_charset
);
2961 msg_Dbg( p_demux
, " - type=%d provider=%s name=%s",
2962 pD
->i_service_type
, str1
, str2
);
2964 vlc_meta_SetTitle( p_meta
, str2
);
2965 vlc_meta_SetPublisher( p_meta
, str1
);
2966 if( pD
->i_service_type
>= 0x01 && pD
->i_service_type
<= 0x10 )
2967 psz_type
= ppsz_type
[pD
->i_service_type
];
2973 if( p_srv
->i_running_status
>= 0x01 && p_srv
->i_running_status
<= 0x04 )
2975 static const char *ppsz_status
[5] = {
2978 "Starts in a few seconds",
2982 psz_status
= ppsz_status
[p_srv
->i_running_status
];
2986 vlc_meta_AddExtra( p_meta
, "Type", psz_type
);
2988 vlc_meta_AddExtra( p_meta
, "Status", psz_status
);
2990 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_META
,
2991 p_srv
->i_service_id
, p_meta
);
2992 vlc_meta_Delete( p_meta
);
2995 sdt
->psi
->i_sdt_version
= p_sdt
->i_version
;
2996 dvbpsi_DeleteSDT( p_sdt
);
2999 /* i_year: year - 1900 i_month: 0-11 i_mday: 1-31 i_hour: 0-23 i_minute: 0-59 i_second: 0-59 */
3000 static int64_t vlc_timegm( int i_year
, int i_month
, int i_mday
, int i_hour
, int i_minute
, int i_second
)
3002 static const int pn_day
[12+1] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
3006 i_month
< 0 || i_month
> 11 || i_mday
< 1 || i_mday
> 31 ||
3007 i_hour
< 0 || i_hour
> 23 || i_minute
< 0 || i_minute
> 59 || i_second
< 0 || i_second
> 59 )
3010 /* Count the number of days */
3011 i_day
= 365 * (i_year
-70) + pn_day
[i_month
] + i_mday
- 1;
3012 #define LEAP(y) ( ((y)%4) == 0 && (((y)%100) != 0 || ((y)%400) == 0) ? 1 : 0)
3013 for( int i
= 70; i
< i_year
; i
++ )
3014 i_day
+= LEAP(1900+i
);
3016 i_day
+= LEAP(1900+i_year
);
3019 return ((24*i_day
+ i_hour
)*60 + i_minute
)*60 + i_second
;
3022 static void EITDecodeMjd( int i_mjd
, int *p_y
, int *p_m
, int *p_d
)
3024 const int yp
= (int)( ( (double)i_mjd
- 15078.2)/365.25 );
3025 const int mp
= (int)( ((double)i_mjd
- 14956.1 - (int)(yp
* 365.25)) / 30.6001 );
3026 const int c
= ( mp
== 14 || mp
== 15 ) ? 1 : 0;
3028 *p_y
= 1900 + yp
+ c
*1;
3029 *p_m
= mp
- 1 - c
*12;
3030 *p_d
= i_mjd
- 14956 - (int)(yp
*365.25) - (int)(mp
*30.6001);
3032 #define CVT_FROM_BCD(v) ((((v) >> 4)&0xf)*10 + ((v)&0xf))
3033 static int64_t EITConvertStartTime( uint64_t i_date
)
3035 const int i_mjd
= i_date
>> 24;
3036 const int i_hour
= CVT_FROM_BCD(i_date
>> 16);
3037 const int i_minute
= CVT_FROM_BCD(i_date
>> 8);
3038 const int i_second
= CVT_FROM_BCD(i_date
);
3043 /* if all 40 bits are 1, the start is unknown */
3044 if( i_date
== UINT64_C(0xffffffffff) )
3047 EITDecodeMjd( i_mjd
, &i_year
, &i_month
, &i_day
);
3048 return vlc_timegm( i_year
- 1900, i_month
- 1, i_day
, i_hour
, i_minute
, i_second
);
3050 static int EITConvertDuration( uint32_t i_duration
)
3052 return CVT_FROM_BCD(i_duration
>> 16) * 3600 +
3053 CVT_FROM_BCD(i_duration
>> 8 ) * 60 +
3054 CVT_FROM_BCD(i_duration
);
3058 static void TDTCallBack( demux_t
*p_demux
, dvbpsi_tot_t
*p_tdt
)
3060 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3062 p_sys
->i_tdt_delta
= CLOCK_FREQ
* EITConvertStartTime( p_tdt
->i_utc_time
)
3064 dvbpsi_DeleteTOT(p_tdt
);
3068 static void EITCallBack( demux_t
*p_demux
,
3069 dvbpsi_eit_t
*p_eit
, bool b_current_following
)
3071 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3072 dvbpsi_eit_event_t
*p_evt
;
3075 msg_Dbg( p_demux
, "EITCallBack called" );
3076 if( !p_eit
->b_current_next
)
3078 dvbpsi_DeleteEIT( p_eit
);
3082 msg_Dbg( p_demux
, "new EIT service_id=%d version=%d current_next=%d "
3083 "ts_id=%d network_id=%d segment_last_section_number=%d "
3085 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3088 p_eit
->i_service_id
,
3090 p_eit
->i_version
, p_eit
->b_current_next
,
3091 p_eit
->i_ts_id
, p_eit
->i_network_id
,
3092 p_eit
->i_segment_last_section_number
, p_eit
->i_last_table_id
);
3094 p_epg
= vlc_epg_New( NULL
);
3095 for( p_evt
= p_eit
->p_first_event
; p_evt
; p_evt
= p_evt
->p_next
)
3097 dvbpsi_descriptor_t
*p_dr
;
3098 char *psz_name
= NULL
;
3099 char *psz_text
= NULL
;
3100 char *psz_extra
= strdup("");
3104 int64_t i_tot_time
= 0;
3106 i_start
= EITConvertStartTime( p_evt
->i_start_time
);
3107 i_duration
= EITConvertDuration( p_evt
->i_duration
);
3109 if( p_sys
->arib
.e_mode
== ARIBMODE_ENABLED
)
3111 if( p_sys
->i_tdt_delta
== 0 )
3112 p_sys
->i_tdt_delta
= CLOCK_FREQ
* (i_start
+ i_duration
- 5) - mdate();
3114 //i_start -= 9 * 60 * 60; // JST -> UTC
3115 time_t timer
= time( NULL
);
3116 int64_t diff
= difftime( mktime( localtime( &timer
) ),
3117 mktime( gmtime( &timer
) ) );
3119 i_tot_time
= (mdate() + p_sys
->i_tdt_delta
) / CLOCK_FREQ
- diff
;
3121 if( p_evt
->i_running_status
== 0x00 &&
3122 (i_start
- 5 < i_tot_time
&&
3123 i_tot_time
< i_start
+ i_duration
+ 5) )
3125 p_evt
->i_running_status
= 0x04;
3126 msg_Dbg( p_demux
, " EIT running status 0x00 -> 0x04" );
3130 msg_Dbg( p_demux
, " * event id=%d start_time:%d duration=%d "
3131 "running=%d free_ca=%d",
3132 p_evt
->i_event_id
, (int)i_start
, (int)i_duration
,
3133 p_evt
->i_running_status
, p_evt
->b_free_ca
);
3135 for( p_dr
= p_evt
->p_first_descriptor
; p_dr
; p_dr
= p_dr
->p_next
)
3141 dvbpsi_short_event_dr_t
*pE
= dvbpsi_DecodeShortEventDr( p_dr
);
3143 /* Only take first description, as we don't handle language-info
3145 if( pE
&& psz_name
== NULL
)
3147 psz_name
= EITConvertToUTF8( p_demux
,
3148 pE
->i_event_name
, pE
->i_event_name_length
,
3149 p_sys
->b_broken_charset
);
3150 psz_text
= EITConvertToUTF8( p_demux
,
3151 pE
->i_text
, pE
->i_text_length
,
3152 p_sys
->b_broken_charset
);
3153 msg_Dbg( p_demux
, " - short event lang=%3.3s '%s' : '%s'",
3154 pE
->i_iso_639_code
, psz_name
, psz_text
);
3161 dvbpsi_extended_event_dr_t
*pE
= dvbpsi_DecodeExtendedEventDr( p_dr
);
3164 msg_Dbg( p_demux
, " - extended event lang=%3.3s [%d/%d]",
3166 pE
->i_descriptor_number
, pE
->i_last_descriptor_number
);
3168 if( pE
->i_text_length
> 0 )
3170 char *psz_text
= EITConvertToUTF8( p_demux
,
3171 pE
->i_text
, pE
->i_text_length
,
3172 p_sys
->b_broken_charset
);
3175 msg_Dbg( p_demux
, " - text='%s'", psz_text
);
3177 psz_extra
= xrealloc( psz_extra
,
3178 strlen(psz_extra
) + strlen(psz_text
) + 1 );
3179 strcat( psz_extra
, psz_text
);
3184 for( int i
= 0; i
< pE
->i_entry_count
; i
++ )
3186 char *psz_dsc
= EITConvertToUTF8( p_demux
,
3187 pE
->i_item_description
[i
],
3188 pE
->i_item_description_length
[i
],
3189 p_sys
->b_broken_charset
);
3190 char *psz_itm
= EITConvertToUTF8( p_demux
,
3191 pE
->i_item
[i
], pE
->i_item_length
[i
],
3192 p_sys
->b_broken_charset
);
3194 if( psz_dsc
&& psz_itm
)
3196 msg_Dbg( p_demux
, " - desc='%s' item='%s'", psz_dsc
, psz_itm
);
3198 psz_extra
= xrealloc( psz_extra
,
3199 strlen(psz_extra
) + strlen(psz_dsc
) +
3200 strlen(psz_itm
) + 3 + 1 );
3201 strcat( psz_extra
, "(" );
3202 strcat( psz_extra
, psz_dsc
);
3203 strcat( psz_extra
, " " );
3204 strcat( psz_extra
, psz_itm
);
3205 strcat( psz_extra
, ")" );
3217 dvbpsi_parental_rating_dr_t
*pR
= dvbpsi_DecodeParentalRatingDr( p_dr
);
3220 for ( int i
= 0; i
< pR
->i_ratings_number
; i
++ )
3222 const dvbpsi_parental_rating_t
*p_rating
= & pR
->p_parental_rating
[ i
];
3223 if ( p_rating
->i_rating
> 0x00 && p_rating
->i_rating
<= 0x0F )
3225 if ( p_rating
->i_rating
+ 3 > i_min_age
)
3226 i_min_age
= p_rating
->i_rating
+ 3;
3227 msg_Dbg( p_demux
, " - parental control set to %d years",
3236 msg_Dbg( p_demux
, " - event unknown dr 0x%x(%d)", p_dr
->i_tag
, p_dr
->i_tag
);
3242 if( i_start
> 0 && psz_name
&& psz_text
)
3243 vlc_epg_AddEvent( p_epg
, i_start
, i_duration
, psz_name
, psz_text
,
3244 *psz_extra
? psz_extra
: NULL
, i_min_age
);
3246 /* Update "now playing" field */
3247 if( p_evt
->i_running_status
== 0x04 && i_start
> 0 && psz_name
&& psz_text
)
3248 vlc_epg_SetCurrent( p_epg
, i_start
);
3255 if( p_epg
->i_event
> 0 )
3257 if( b_current_following
&&
3258 ( p_sys
->i_current_program
== -1 ||
3259 p_sys
->i_current_program
==
3260 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3267 p_sys
->i_dvb_length
= 0;
3268 p_sys
->i_dvb_start
= 0;
3270 if( p_epg
->p_current
)
3272 p_sys
->i_dvb_start
= CLOCK_FREQ
* p_epg
->p_current
->i_start
;
3273 p_sys
->i_dvb_length
= CLOCK_FREQ
* p_epg
->p_current
->i_duration
;
3276 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_EPG
,
3277 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3280 p_eit
->i_service_id
,
3284 vlc_epg_Delete( p_epg
);
3286 dvbpsi_DeleteEIT( p_eit
);
3288 static void EITCallBackCurrentFollowing( demux_t
*p_demux
, dvbpsi_eit_t
*p_eit
)
3290 EITCallBack( p_demux
, p_eit
, true );
3292 static void EITCallBackSchedule( demux_t
*p_demux
, dvbpsi_eit_t
*p_eit
)
3294 EITCallBack( p_demux
, p_eit
, false );
3297 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3298 static void PSINewTableCallBack( dvbpsi_t
*h
, uint8_t i_table_id
,
3299 uint16_t i_extension
, demux_t
*p_demux
)
3301 static void PSINewTableCallBack( demux_t
*p_demux
, dvbpsi_handle h
,
3302 uint8_t i_table_id
, uint16_t i_extension
)
3307 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3308 i_table_id
, i_table_id
, i_extension
, i_extension
);
3310 if( p_demux
->p_sys
->pid
[0].psi
->i_pat_version
!= -1 && i_table_id
== 0x42 )
3312 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3313 i_table_id
, i_table_id
, i_extension
, i_extension
);
3314 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3315 if( !dvbpsi_sdt_attach( h
, i_table_id
, i_extension
, (dvbpsi_sdt_callback
)SDTCallBack
, p_demux
) )
3316 msg_Err( p_demux
, "PSINewTableCallback: failed attaching SDTCallback" );
3318 dvbpsi_AttachSDT( h
, i_table_id
, i_extension
,
3319 (dvbpsi_sdt_callback
)SDTCallBack
, p_demux
);
3322 else if( p_demux
->p_sys
->pid
[0x11].psi
->i_sdt_version
!= -1 &&
3323 ( i_table_id
== 0x4e || /* Current/Following */
3324 (i_table_id
>= 0x50 && i_table_id
<= 0x5f) ) ) /* Schedule */
3326 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3327 i_table_id
, i_table_id
, i_extension
, i_extension
);
3329 dvbpsi_eit_callback cb
= i_table_id
== 0x4e ?
3330 (dvbpsi_eit_callback
)EITCallBackCurrentFollowing
:
3331 (dvbpsi_eit_callback
)EITCallBackSchedule
;
3332 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3333 if( !dvbpsi_eit_attach( h
, i_table_id
, i_extension
, cb
, p_demux
) )
3334 msg_Err( p_demux
, "PSINewTableCallback: failed attaching EITCallback" );
3336 dvbpsi_AttachEIT( h
, i_table_id
, i_extension
, cb
, p_demux
);
3339 else if( p_demux
->p_sys
->pid
[0x11].psi
->i_sdt_version
!= -1 &&
3340 (i_table_id
== 0x70 /* TDT */ || i_table_id
== 0x73 /* TOT */) )
3342 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3343 i_table_id
, i_table_id
, i_extension
, i_extension
);
3344 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3345 if( !dvbpsi_tot_attach( h
, i_table_id
, i_extension
, (dvbpsi_tot_callback
)TDTCallBack
, p_demux
) )
3346 msg_Err( p_demux
, "PSINewTableCallback: failed attaching TDTCallback" );
3348 dvbpsi_AttachTOT( h
, i_table_id
, i_extension
,
3349 (dvbpsi_tot_callback
)TDTCallBack
, p_demux
);
3354 /*****************************************************************************
3355 * PMT callback and helpers
3356 *****************************************************************************/
3357 static dvbpsi_descriptor_t
*PMTEsFindDescriptor( const dvbpsi_pmt_es_t
*p_es
,
3360 dvbpsi_descriptor_t
*p_dr
= p_es
->p_first_descriptor
;;
3361 while( p_dr
&& ( p_dr
->i_tag
!= i_tag
) )
3362 p_dr
= p_dr
->p_next
;
3365 static bool PMTEsHasRegistration( demux_t
*p_demux
,
3366 const dvbpsi_pmt_es_t
*p_es
,
3367 const char *psz_tag
)
3369 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x05 );
3373 if( p_dr
->i_length
< 4 )
3375 msg_Warn( p_demux
, "invalid Registration Descriptor" );
3379 assert( strlen(psz_tag
) == 4 );
3380 return !memcmp( p_dr
->p_data
, psz_tag
, 4 );
3383 static bool PMTEsHasComponentTag( const dvbpsi_pmt_es_t
*p_es
,
3384 int i_component_tag
)
3386 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x52 );
3389 dvbpsi_stream_identifier_dr_t
*p_si
= dvbpsi_DecodeStreamIdentifierDr( p_dr
);
3393 return p_si
->i_component_tag
== i_component_tag
;
3396 static void PMTSetupEsISO14496( demux_t
*p_demux
, ts_pid_t
*pid
,
3397 const ts_prg_psi_t
*prg
, const dvbpsi_pmt_es_t
*p_es
)
3399 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3401 /* MPEG-4 stream: search FMC_DESCRIPTOR (SL Packetized stream) */
3402 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x1f );
3404 if( p_dr
&& p_dr
->i_length
== 2 )
3406 const int i_es_id
= ( p_dr
->p_data
[0] << 8 ) | p_dr
->p_data
[1];
3408 msg_Dbg( p_demux
, "found FMC_descriptor declaring sl packetization on es_id=%d", i_es_id
);
3410 pid
->es
->p_mpeg4desc
= NULL
;
3412 for( int i
= 0; i
< ES_DESCRIPTOR_COUNT
; i
++ )
3414 iod_descriptor_t
*iod
= prg
->iod
;
3415 if( iod
->es_descr
[i
].i_es_id
== i_es_id
)
3417 if ( iod
->es_descr
[i
].b_ok
)
3418 pid
->es
->p_mpeg4desc
= &iod
->es_descr
[i
];
3420 msg_Dbg( p_demux
, "MPEG-4 descriptor not yet available on es_id=%d", i_es_id
);
3425 if( !pid
->es
->p_mpeg4desc
)
3427 switch( p_es
->i_type
)
3429 /* non fatal, set by packetizer */
3430 case 0x0f: /* ADTS */
3431 case 0x11: /* LOAS */
3432 msg_Info( p_demux
, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
3433 pid
->i_pid
, p_es
->i_type
);
3436 msg_Err( p_demux
, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
3437 pid
->i_pid
, p_es
->i_type
);
3443 const decoder_config_descriptor_t
*dcd
= &pid
->es
->p_mpeg4desc
->dec_descr
;
3444 if( dcd
->i_streamType
== 0x04 ) /* VisualStream */
3446 p_fmt
->i_cat
= VIDEO_ES
;
3447 switch( dcd
->i_objectTypeIndication
)
3449 case 0x0B: /* mpeg4 sub */
3450 p_fmt
->i_cat
= SPU_ES
;
3451 p_fmt
->i_codec
= VLC_CODEC_SUBT
;
3454 case 0x20: /* mpeg4 */
3455 p_fmt
->i_codec
= VLC_CODEC_MP4V
;
3457 case 0x21: /* h264 */
3458 p_fmt
->i_codec
= VLC_CODEC_H264
;
3465 case 0x65: /* mpeg2 */
3466 p_fmt
->i_codec
= VLC_CODEC_MPGV
;
3468 case 0x6a: /* mpeg1 */
3469 p_fmt
->i_codec
= VLC_CODEC_MPGV
;
3471 case 0x6c: /* mpeg1 */
3472 p_fmt
->i_codec
= VLC_CODEC_JPEG
;
3475 p_fmt
->i_cat
= UNKNOWN_ES
;
3479 else if( dcd
->i_streamType
== 0x05 ) /* AudioStream */
3481 p_fmt
->i_cat
= AUDIO_ES
;
3482 switch( dcd
->i_objectTypeIndication
)
3484 case 0x40: /* mpeg4 */
3485 p_fmt
->i_codec
= VLC_CODEC_MP4A
;
3489 case 0x68: /* mpeg2 aac */
3490 p_fmt
->i_codec
= VLC_CODEC_MP4A
;
3492 case 0x69: /* mpeg2 */
3493 p_fmt
->i_codec
= VLC_CODEC_MPGA
;
3495 case 0x6b: /* mpeg1 */
3496 p_fmt
->i_codec
= VLC_CODEC_MPGA
;
3499 p_fmt
->i_cat
= UNKNOWN_ES
;
3505 p_fmt
->i_cat
= UNKNOWN_ES
;
3508 if( p_fmt
->i_cat
!= UNKNOWN_ES
)
3510 p_fmt
->i_extra
= dcd
->i_extra
;
3511 if( p_fmt
->i_extra
> 0 )
3513 p_fmt
->p_extra
= malloc( p_fmt
->i_extra
);
3514 if( p_fmt
->p_extra
)
3515 memcpy( p_fmt
->p_extra
, dcd
->p_extra
, p_fmt
->i_extra
);
3528 } ts_teletext_page_t
;
3530 static void PMTSetupEsTeletext( demux_t
*p_demux
, ts_pid_t
*pid
,
3531 const dvbpsi_pmt_es_t
*p_es
)
3533 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3535 ts_teletext_page_t p_page
[2 * 64 + 20];
3536 unsigned i_page
= 0;
3538 /* Gather pages information */
3539 #if defined _DVBPSI_DR_56_H_ && \
3540 defined DVBPSI_VERSION && DVBPSI_VERSION_INT > DVBPSI_VERSION_WANTED(0,1,5)
3541 for( unsigned i_tag_idx
= 0; i_tag_idx
< 2; i_tag_idx
++ )
3543 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, i_tag_idx
== 0 ? 0x46 : 0x56 );
3547 dvbpsi_teletext_dr_t
*p_sub
= dvbpsi_DecodeTeletextDr( p_dr
);
3551 for( int i
= 0; i
< p_sub
->i_pages_number
; i
++ )
3553 const dvbpsi_teletextpage_t
*p_src
= &p_sub
->p_pages
[i
];
3555 if( p_src
->i_teletext_type
>= 0x06 )
3558 assert( i_page
< sizeof(p_page
)/sizeof(*p_page
) );
3560 ts_teletext_page_t
*p_dst
= &p_page
[i_page
++];
3562 p_dst
->i_type
= p_src
->i_teletext_type
;
3563 p_dst
->i_magazine
= p_src
->i_teletext_magazine_number
3564 ? p_src
->i_teletext_magazine_number
: 8;
3565 p_dst
->i_page
= p_src
->i_teletext_page_number
;
3566 memcpy( p_dst
->p_iso639
, p_src
->i_iso6392_language_code
, 3 );
3571 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3574 dvbpsi_subtitling_dr_t
*p_sub
= dvbpsi_DecodeSubtitlingDr( p_dr
);
3575 for( int i
= 0; p_sub
&& i
< p_sub
->i_subtitles_number
; i
++ )
3577 dvbpsi_subtitle_t
*p_src
= &p_sub
->p_subtitle
[i
];
3579 if( p_src
->i_subtitling_type
< 0x01 || p_src
->i_subtitling_type
> 0x03 )
3582 assert( i_page
< sizeof(p_page
)/sizeof(*p_page
) );
3584 ts_teletext_page_t
*p_dst
= &p_page
[i_page
++];
3586 switch( p_src
->i_subtitling_type
)
3589 p_dst
->i_type
= 0x02;
3592 p_dst
->i_type
= 0x03;
3595 /* FIXME check if it is the right split */
3596 p_dst
->i_magazine
= (p_src
->i_composition_page_id
>> 8)
3597 ? (p_src
->i_composition_page_id
>> 8) : 8;
3598 p_dst
->i_page
= p_src
->i_composition_page_id
& 0xff;
3599 memcpy( p_dst
->p_iso639
, p_src
->i_iso6392_language_code
, 3 );
3604 es_format_Init( p_fmt
, SPU_ES
, VLC_CODEC_TELETEXT
);
3606 if( !p_demux
->p_sys
->b_split_es
|| i_page
<= 0 )
3608 p_fmt
->subs
.teletext
.i_magazine
= -1;
3609 p_fmt
->subs
.teletext
.i_page
= 0;
3610 p_fmt
->psz_description
= strdup( vlc_gettext(ppsz_teletext_type
[1]) );
3612 dvbpsi_descriptor_t
*p_dr
;
3613 p_dr
= PMTEsFindDescriptor( p_es
, 0x46 );
3615 p_dr
= PMTEsFindDescriptor( p_es
, 0x56 );
3617 if( !p_demux
->p_sys
->b_split_es
&& p_dr
&& p_dr
->i_length
> 0 )
3619 /* Descriptor pass-through */
3620 p_fmt
->p_extra
= malloc( p_dr
->i_length
);
3621 if( p_fmt
->p_extra
)
3623 p_fmt
->i_extra
= p_dr
->i_length
;
3624 memcpy( p_fmt
->p_extra
, p_dr
->p_data
, p_dr
->i_length
);
3630 for( unsigned i
= 0; i
< i_page
; i
++ )
3641 p_es
= malloc( sizeof(*p_es
) );
3645 es_format_Copy( &p_es
->fmt
, &pid
->es
->fmt
);
3646 free( p_es
->fmt
.psz_language
);
3647 free( p_es
->fmt
.psz_description
);
3648 p_es
->fmt
.psz_language
= NULL
;
3649 p_es
->fmt
.psz_description
= NULL
;
3652 p_es
->p_data
= NULL
;
3653 p_es
->i_data_size
= 0;
3654 p_es
->i_data_gathered
= 0;
3655 p_es
->pp_last
= &p_es
->p_data
;
3656 p_es
->data_type
= TS_ES_DATA_PES
;
3657 p_es
->p_mpeg4desc
= NULL
;
3659 TAB_APPEND( pid
->i_extra_es
, pid
->extra_es
, p_es
);
3663 const ts_teletext_page_t
*p
= &p_page
[i
];
3664 p_es
->fmt
.i_priority
= (p
->i_type
== 0x02 || p
->i_type
== 0x05) ?
3665 ES_PRIORITY_SELECTABLE_MIN
: ES_PRIORITY_NOT_DEFAULTABLE
;
3666 p_es
->fmt
.psz_language
= strndup( p
->p_iso639
, 3 );
3667 p_es
->fmt
.psz_description
= strdup(vlc_gettext(ppsz_teletext_type
[p
->i_type
]));
3668 p_es
->fmt
.subs
.teletext
.i_magazine
= p
->i_magazine
;
3669 p_es
->fmt
.subs
.teletext
.i_page
= p
->i_page
;
3672 " * ttxt type=%s lan=%s page=%d%02x",
3673 p_es
->fmt
.psz_description
,
3674 p_es
->fmt
.psz_language
,
3675 p
->i_magazine
, p
->i_page
);
3679 static void PMTSetupEsDvbSubtitle( demux_t
*p_demux
, ts_pid_t
*pid
,
3680 const dvbpsi_pmt_es_t
*p_es
)
3682 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3684 es_format_Init( p_fmt
, SPU_ES
, VLC_CODEC_DVBS
);
3686 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3688 dvbpsi_subtitling_dr_t
*p_sub
= dvbpsi_DecodeSubtitlingDr( p_dr
);
3689 for( int i
= 0; p_sub
&& i
< p_sub
->i_subtitles_number
; i
++ )
3691 const int i_type
= p_sub
->p_subtitle
[i
].i_subtitling_type
;
3692 if( ( i_type
>= 0x10 && i_type
<= 0x14 ) ||
3693 ( i_type
>= 0x20 && i_type
<= 0x24 ) )
3697 if( !p_demux
->p_sys
->b_split_es
|| i_page
<= 0 )
3699 p_fmt
->subs
.dvb
.i_id
= -1;
3700 p_fmt
->psz_description
= strdup( _("DVB subtitles") );
3702 if( !p_demux
->p_sys
->b_split_es
&& p_dr
&& p_dr
->i_length
> 0 )
3704 /* Descriptor pass-through */
3705 p_fmt
->p_extra
= malloc( p_dr
->i_length
);
3706 if( p_fmt
->p_extra
)
3708 p_fmt
->i_extra
= p_dr
->i_length
;
3709 memcpy( p_fmt
->p_extra
, p_dr
->p_data
, p_dr
->i_length
);
3715 for( int i
= 0; i
< p_sub
->i_subtitles_number
; i
++ )
3726 p_es
= malloc( sizeof(*p_es
) );
3730 es_format_Copy( &p_es
->fmt
, &pid
->es
->fmt
);
3731 free( p_es
->fmt
.psz_language
);
3732 free( p_es
->fmt
.psz_description
);
3733 p_es
->fmt
.psz_language
= NULL
;
3734 p_es
->fmt
.psz_description
= NULL
;
3737 p_es
->p_data
= NULL
;
3738 p_es
->i_data_size
= 0;
3739 p_es
->i_data_gathered
= 0;
3740 p_es
->pp_last
= &p_es
->p_data
;
3741 p_es
->data_type
= TS_ES_DATA_PES
;
3742 p_es
->p_mpeg4desc
= NULL
;
3744 TAB_APPEND( pid
->i_extra_es
, pid
->extra_es
, p_es
);
3748 const dvbpsi_subtitle_t
*p
= &p_sub
->p_subtitle
[i
];
3749 p_es
->fmt
.psz_language
= strndup( (char *)p
->i_iso6392_language_code
, 3 );
3750 switch( p
->i_subtitling_type
)
3752 case 0x10: /* unspec. */
3753 case 0x11: /* 4:3 */
3754 case 0x12: /* 16:9 */
3755 case 0x13: /* 2.21:1 */
3756 case 0x14: /* HD monitor */
3757 p_es
->fmt
.psz_description
= strdup( _("DVB subtitles") );
3759 case 0x20: /* Hearing impaired unspec. */
3760 case 0x21: /* h.i. 4:3 */
3761 case 0x22: /* h.i. 16:9 */
3762 case 0x23: /* h.i. 2.21:1 */
3763 case 0x24: /* h.i. HD monitor */
3764 p_es
->fmt
.psz_description
= strdup( _("DVB subtitles: hearing impaired") );
3771 p_es
->fmt
.subs
.dvb
.i_id
= ( p
->i_composition_page_id
<< 0 ) |
3772 ( p
->i_ancillary_page_id
<< 16 );
3776 static void PMTSetupEs0x06( demux_t
*p_demux
, ts_pid_t
*pid
,
3777 const dvbpsi_pmt_es_t
*p_es
)
3779 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3780 dvbpsi_descriptor_t
*p_subs_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3782 if( PMTEsHasRegistration( p_demux
, p_es
, "AC-3" ) ||
3783 PMTEsFindDescriptor( p_es
, 0x6a ) ||
3784 PMTEsFindDescriptor( p_es
, 0x81 ) )
3786 p_fmt
->i_cat
= AUDIO_ES
;
3787 p_fmt
->i_codec
= VLC_CODEC_A52
;
3789 else if( PMTEsFindDescriptor( p_es
, 0x7a ) )
3791 /* DVB with stream_type 0x06 (ETS EN 300 468) */
3792 p_fmt
->i_cat
= AUDIO_ES
;
3793 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
3795 else if( PMTEsHasRegistration( p_demux
, p_es
, "DTS1" ) ||
3796 PMTEsHasRegistration( p_demux
, p_es
, "DTS2" ) ||
3797 PMTEsHasRegistration( p_demux
, p_es
, "DTS3" ) ||
3798 PMTEsFindDescriptor( p_es
, 0x73 ) )
3800 /*registration descriptor(ETSI TS 101 154 Annex F)*/
3801 p_fmt
->i_cat
= AUDIO_ES
;
3802 p_fmt
->i_codec
= VLC_CODEC_DTS
;
3804 else if( PMTEsHasRegistration( p_demux
, p_es
, "BSSD" ) && !p_subs_dr
)
3806 /* BSSD is AES3 DATA, but could also be subtitles
3807 * we need to check for secondary descriptor then s*/
3808 p_fmt
->i_cat
= AUDIO_ES
;
3809 p_fmt
->b_packetized
= true;
3810 p_fmt
->i_codec
= VLC_CODEC_302M
;
3812 else if( PMTEsHasRegistration( p_demux
, p_es
, "HEVC" ) )
3814 p_fmt
->i_cat
= VIDEO_ES
;
3815 p_fmt
->i_codec
= VLC_CODEC_HEVC
;
3817 else if ( p_demux
->p_sys
->arib
.e_mode
== ARIBMODE_ENABLED
)
3819 /* Lookup our data component descriptor first ARIB STD B10 6.4 */
3820 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0xFD );
3821 /* and check that it maps to something ARIB STD B14 Table 5.1/5.2 */
3822 if ( p_dr
&& p_dr
->i_length
>= 2 )
3824 if( !memcmp( p_dr
->p_data
, "\x00\x08", 2 ) && (
3825 PMTEsHasComponentTag( p_es
, 0x30 ) ||
3826 PMTEsHasComponentTag( p_es
, 0x31 ) ||
3827 PMTEsHasComponentTag( p_es
, 0x32 ) ||
3828 PMTEsHasComponentTag( p_es
, 0x33 ) ||
3829 PMTEsHasComponentTag( p_es
, 0x34 ) ||
3830 PMTEsHasComponentTag( p_es
, 0x35 ) ||
3831 PMTEsHasComponentTag( p_es
, 0x36 ) ||
3832 PMTEsHasComponentTag( p_es
, 0x37 ) ) )
3834 es_format_Init( &pid
->es
->fmt
, SPU_ES
, VLC_CODEC_ARIB_A
);
3835 p_fmt
->psz_language
= strndup ( "jpn", 3 );
3836 p_fmt
->psz_description
= strdup( _("ARIB subtitles") );
3838 else if( !memcmp( p_dr
->p_data
, "\x00\x12", 2 ) && (
3839 PMTEsHasComponentTag( p_es
, 0x87 ) ||
3840 PMTEsHasComponentTag( p_es
, 0x88 ) ) )
3842 es_format_Init( &pid
->es
->fmt
, SPU_ES
, VLC_CODEC_ARIB_C
);
3843 p_fmt
->psz_language
= strndup ( "jpn", 3 );
3844 p_fmt
->psz_description
= strdup( _("ARIB subtitles") );
3850 /* Subtitle/Teletext/VBI fallbacks */
3851 dvbpsi_subtitling_dr_t
*p_sub
;
3852 if( p_subs_dr
&& ( p_sub
= dvbpsi_DecodeSubtitlingDr( p_subs_dr
) ) )
3854 for( int i
= 0; i
< p_sub
->i_subtitles_number
; i
++ )
3856 if( p_fmt
->i_cat
!= UNKNOWN_ES
)
3859 switch( p_sub
->p_subtitle
[i
].i_subtitling_type
)
3861 case 0x01: /* EBU Teletext subtitles */
3862 case 0x02: /* Associated EBU Teletext */
3863 case 0x03: /* VBI data */
3864 PMTSetupEsTeletext( p_demux
, pid
, p_es
);
3866 case 0x10: /* DVB Subtitle (normal) with no monitor AR critical */
3867 case 0x11: /* ... on 4:3 AR monitor */
3868 case 0x12: /* ... on 16:9 AR monitor */
3869 case 0x13: /* ... on 2.21:1 AR monitor */
3870 case 0x14: /* ... for display on a high definition monitor */
3871 case 0x20: /* DVB Subtitle (impaired) with no monitor AR critical */
3872 case 0x21: /* ... on 4:3 AR monitor */
3873 case 0x22: /* ... on 16:9 AR monitor */
3874 case 0x23: /* ... on 2.21:1 AR monitor */
3875 case 0x24: /* ... for display on a high definition monitor */
3876 PMTSetupEsDvbSubtitle( p_demux
, pid
, p_es
);
3879 msg_Err( p_demux
, "Unrecognized DVB subtitle type (0x%x)",
3880 p_sub
->p_subtitle
[i
].i_subtitling_type
);
3886 if( p_fmt
->i_cat
== UNKNOWN_ES
&&
3887 ( PMTEsFindDescriptor( p_es
, 0x45 ) || /* VBI Data descriptor */
3888 PMTEsFindDescriptor( p_es
, 0x46 ) || /* VBI Teletext descriptor */
3889 PMTEsFindDescriptor( p_es
, 0x56 ) ) ) /* EBU Teletext descriptor */
3892 PMTSetupEsTeletext( p_demux
, pid
, p_es
);
3896 /* FIXME is it useful ? */
3897 if( PMTEsFindDescriptor( p_es
, 0x52 ) )
3899 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x52 );
3900 dvbpsi_stream_identifier_dr_t
*p_si
= dvbpsi_DecodeStreamIdentifierDr( p_dr
);
3902 msg_Dbg( p_demux
, " * Stream Component Identifier: %d", p_si
->i_component_tag
);
3906 static void PMTSetupEs0xEA( demux_t
*p_demux
, ts_pid_t
*pid
,
3907 const dvbpsi_pmt_es_t
*p_es
)
3909 /* Registration Descriptor */
3910 if( !PMTEsHasRegistration( p_demux
, p_es
, "VC-1" ) )
3912 msg_Err( p_demux
, "Registration descriptor not found or invalid" );
3916 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3918 /* registration descriptor for VC-1 (SMPTE rp227) */
3919 p_fmt
->i_cat
= VIDEO_ES
;
3920 p_fmt
->i_codec
= VLC_CODEC_VC1
;
3922 /* XXX With Simple and Main profile the SEQUENCE
3923 * header is modified: video width and height are
3924 * inserted just after the start code as 2 int16_t
3925 * The packetizer will take care of that. */
3928 static void PMTSetupEs0xD1( demux_t
*p_demux
, ts_pid_t
*pid
,
3929 const dvbpsi_pmt_es_t
*p_es
)
3931 /* Registration Descriptor */
3932 if( !PMTEsHasRegistration( p_demux
, p_es
, "drac" ) )
3934 msg_Err( p_demux
, "Registration descriptor not found or invalid" );
3938 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3940 /* registration descriptor for Dirac
3941 * (backwards compatable with VC-2 (SMPTE Sxxxx:2008)) */
3942 p_fmt
->i_cat
= VIDEO_ES
;
3943 p_fmt
->i_codec
= VLC_CODEC_DIRAC
;
3946 static void PMTSetupEs0xA0( demux_t
*p_demux
, ts_pid_t
*pid
,
3947 const dvbpsi_pmt_es_t
*p_es
)
3949 /* MSCODEC sent by vlc */
3950 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0xa0 );
3951 if( !p_dr
|| p_dr
->i_length
< 10 )
3954 "private MSCODEC (vlc) without bih private descriptor" );
3958 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3959 p_fmt
->i_cat
= VIDEO_ES
;
3960 p_fmt
->i_codec
= VLC_FOURCC( p_dr
->p_data
[0], p_dr
->p_data
[1],
3961 p_dr
->p_data
[2], p_dr
->p_data
[3] );
3962 p_fmt
->video
.i_width
= GetWBE( &p_dr
->p_data
[4] );
3963 p_fmt
->video
.i_height
= GetWBE( &p_dr
->p_data
[6] );
3964 p_fmt
->i_extra
= GetWBE( &p_dr
->p_data
[8] );
3966 if( p_fmt
->i_extra
> 0 )
3968 p_fmt
->p_extra
= malloc( p_fmt
->i_extra
);
3969 if( p_fmt
->p_extra
)
3970 memcpy( p_fmt
->p_extra
, &p_dr
->p_data
[10],
3971 __MIN( p_fmt
->i_extra
, p_dr
->i_length
- 10 ) );
3975 /* For such stream we will gather them ourself and don't launch a
3977 * Yes it's ugly but it's the only way to have DIV3 working */
3978 p_fmt
->b_packetized
= true;
3981 static void PMTSetupEs0x83( const dvbpsi_pmt_t
*p_pmt
, ts_pid_t
*pid
)
3983 /* WiDi broadcasts without registration on PMT 0x1, PCR 0x1000 and
3984 * with audio track pid being 0x1100..0x11FF */
3985 if ( p_pmt
->i_program_number
== 0x1 &&
3986 p_pmt
->i_pcr_pid
== 0x1000 &&
3987 ( pid
->i_pid
>> 8 ) == 0x11 )
3989 /* Not enough ? might contain 0x83 private descriptor, 2 bytes 0x473F */
3990 es_format_Init( &pid
->es
->fmt
, AUDIO_ES
, VLC_CODEC_WIDI_LPCM
);
3993 es_format_Init( &pid
->es
->fmt
, AUDIO_ES
, VLC_CODEC_DVD_LPCM
);
3996 static bool PMTSetupEsHDMV( demux_t
*p_demux
, ts_pid_t
*pid
,
3997 const dvbpsi_pmt_es_t
*p_es
)
3999 es_format_t
*p_fmt
= &pid
->es
->fmt
;
4001 /* Blu-Ray mapping */
4002 switch( p_es
->i_type
)
4005 p_fmt
->i_cat
= AUDIO_ES
;
4006 p_fmt
->i_codec
= VLC_CODEC_BD_LPCM
;
4009 case 0x85: /* DTS-HD High resolution audio */
4010 case 0x86: /* DTS-HD Master audio */
4011 case 0xA2: /* Secondary DTS audio */
4012 p_fmt
->i_cat
= AUDIO_ES
;
4013 p_fmt
->i_codec
= VLC_CODEC_DTS
;
4016 case 0x83: /* TrueHD AC3 */
4017 p_fmt
->i_cat
= AUDIO_ES
;
4018 p_fmt
->i_codec
= VLC_CODEC_TRUEHD
;
4021 case 0x84: /* E-AC3 */
4022 case 0xA1: /* Secondary E-AC3 */
4023 p_fmt
->i_cat
= AUDIO_ES
;
4024 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
4026 case 0x90: /* Presentation graphics */
4027 p_fmt
->i_cat
= SPU_ES
;
4028 p_fmt
->i_codec
= VLC_CODEC_BD_PG
;
4030 case 0x91: /* Interactive graphics */
4031 case 0x92: /* Subtitle */
4034 msg_Info( p_demux
, "HDMV registration not implemented for pid 0x%x type 0x%x",
4035 p_es
->i_pid
, p_es
->i_type
);
4042 static bool PMTSetupEsRegistration( demux_t
*p_demux
, ts_pid_t
*pid
,
4043 const dvbpsi_pmt_es_t
*p_es
)
4049 vlc_fourcc_t i_codec
;
4051 { "AC-3", AUDIO_ES
, VLC_CODEC_A52
},
4052 { "DTS1", AUDIO_ES
, VLC_CODEC_DTS
},
4053 { "DTS2", AUDIO_ES
, VLC_CODEC_DTS
},
4054 { "DTS3", AUDIO_ES
, VLC_CODEC_DTS
},
4055 { "BSSD", AUDIO_ES
, VLC_CODEC_302M
},
4056 { "VC-1", VIDEO_ES
, VLC_CODEC_VC1
},
4057 { "drac", VIDEO_ES
, VLC_CODEC_DIRAC
},
4058 { "", UNKNOWN_ES
, 0 }
4060 es_format_t
*p_fmt
= &pid
->es
->fmt
;
4062 for( int i
= 0; p_regs
[i
].i_cat
!= UNKNOWN_ES
; i
++ )
4064 if( PMTEsHasRegistration( p_demux
, p_es
, p_regs
[i
].psz_tag
) )
4066 p_fmt
->i_cat
= p_regs
[i
].i_cat
;
4067 p_fmt
->i_codec
= p_regs
[i
].i_codec
;
4068 if (p_es
->i_type
== 0x87)
4069 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
4076 static char *GetAudioTypeDesc(demux_t
*p_demux
, int type
)
4078 static const char *audio_type
[] = {
4080 N_("clean effects"),
4081 N_("hearing impaired"),
4082 N_("visual impaired commentary"),
4085 if (type
< 0 || type
> 3)
4086 msg_Dbg( p_demux
, "unknown audio type: %d", type
);
4088 return strdup(audio_type
[type
]);
4092 static void PMTParseEsIso639( demux_t
*p_demux
, ts_pid_t
*pid
,
4093 const dvbpsi_pmt_es_t
*p_es
)
4095 /* get language descriptor */
4096 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x0a );
4101 dvbpsi_iso639_dr_t
*p_decoded
= dvbpsi_DecodeISO639Dr( p_dr
);
4104 msg_Err( p_demux
, "Failed to decode a ISO 639 descriptor" );
4108 #if defined(DR_0A_API_VER) && (DR_0A_API_VER >= 2)
4109 pid
->es
->fmt
.psz_language
= malloc( 4 );
4110 if( pid
->es
->fmt
.psz_language
)
4112 memcpy( pid
->es
->fmt
.psz_language
, p_decoded
->code
[0].iso_639_code
, 3 );
4113 pid
->es
->fmt
.psz_language
[3] = 0;
4114 msg_Dbg( p_demux
, "found language: %s", pid
->es
->fmt
.psz_language
);
4116 int type
= p_decoded
->code
[0].i_audio_type
;
4117 pid
->es
->fmt
.psz_description
= GetAudioTypeDesc(p_demux
, type
);
4119 pid
->es
->fmt
.i_priority
= ES_PRIORITY_SELECTABLE_MIN
+ 1; // prioritize normal audio tracks
4121 pid
->es
->fmt
.i_extra_languages
= p_decoded
->i_code_count
-1;
4122 if( pid
->es
->fmt
.i_extra_languages
> 0 )
4123 pid
->es
->fmt
.p_extra_languages
=
4124 malloc( sizeof(*pid
->es
->fmt
.p_extra_languages
) *
4125 pid
->es
->fmt
.i_extra_languages
);
4126 if( pid
->es
->fmt
.p_extra_languages
)
4128 for( int i
= 0; i
< pid
->es
->fmt
.i_extra_languages
; i
++ )
4130 pid
->es
->fmt
.p_extra_languages
[i
].psz_language
= malloc(4);
4131 if( pid
->es
->fmt
.p_extra_languages
[i
].psz_language
)
4133 memcpy( pid
->es
->fmt
.p_extra_languages
[i
].psz_language
,
4134 p_decoded
->code
[i
+1].iso_639_code
, 3 );
4135 pid
->es
->fmt
.p_extra_languages
[i
].psz_language
[3] = '\0';
4137 int type
= p_decoded
->code
[i
].i_audio_type
;
4138 pid
->es
->fmt
.p_extra_languages
[i
].psz_description
= GetAudioTypeDesc(p_demux
, type
);
4142 pid
->es
->fmt
.psz_language
= malloc( 4 );
4143 if( pid
->es
->fmt
.psz_language
)
4145 memcpy( pid
->es
->fmt
.psz_language
,
4146 p_decoded
->i_iso_639_code
, 3 );
4147 pid
->es
->fmt
.psz_language
[3] = 0;
4152 static void PMTCallBack( void *data
, dvbpsi_pmt_t
*p_pmt
)
4154 demux_t
*p_demux
= data
;
4155 demux_sys_t
*p_sys
= p_demux
->p_sys
;
4157 ts_pid_t
*pmt
= NULL
;
4160 msg_Dbg( p_demux
, "PMTCallBack called" );
4162 /* First find this PMT declared in PAT */
4163 for( int i
= 0; !pmt
&& i
< p_sys
->i_pmt
; i
++ )
4164 for( int i_prg
= 0; !pmt
&& i_prg
< p_sys
->pmt
[i
]->psi
->i_prg
; i_prg
++ )
4166 const int i_pmt_number
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_number
;
4167 if( i_pmt_number
!= TS_USER_PMT_NUMBER
&&
4168 i_pmt_number
== p_pmt
->i_program_number
)
4170 pmt
= p_sys
->pmt
[i
];
4171 prg
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
];
4177 msg_Warn( p_demux
, "unreferenced program (broken stream)" );
4178 dvbpsi_DeletePMT(p_pmt
);
4183 if( prg
->i_version
!= -1 &&
4184 ( !p_pmt
->b_current_next
|| prg
->i_version
== p_pmt
->i_version
) )
4186 dvbpsi_DeletePMT( p_pmt
);
4190 ts_pid_t
**pp_clean
= NULL
;
4192 /* Clean this program (remove all es) */
4193 for( int i
= 0; i
< 8192; i
++ )
4195 ts_pid_t
*pid
= &p_sys
->pid
[i
];
4197 if( pid
->b_valid
&& pid
->p_owner
== pmt
->psi
&&
4198 pid
->i_owner_number
== prg
->i_number
&& pid
->psi
== NULL
)
4200 TAB_APPEND( i_clean
, pp_clean
, pid
);
4205 IODFree( prg
->iod
);
4209 msg_Dbg( p_demux
, "new PMT program number=%d version=%d pid_pcr=%d",
4210 p_pmt
->i_program_number
, p_pmt
->i_version
, p_pmt
->i_pcr_pid
);
4211 prg
->i_pid_pcr
= p_pmt
->i_pcr_pid
;
4212 prg
->i_version
= p_pmt
->i_version
;
4214 ValidateDVBMeta( p_demux
, prg
->i_pid_pcr
);
4215 if( ProgramIsSelected( p_demux
, prg
->i_number
) )
4216 SetPIDFilter( p_demux
, prg
->i_pid_pcr
, true ); /* Set demux filter */
4218 /* Parse PMT descriptors */
4219 ts_pmt_registration_type_t registration_type
= TS_PMT_REGISTRATION_NONE
;
4220 dvbpsi_descriptor_t
*p_dr
;
4222 /* First pass for standard detection */
4223 if ( p_sys
->arib
.e_mode
== ARIBMODE_AUTO
)
4225 int i_arib_flags
= 0; /* Descriptors can be repeated */
4226 for( p_dr
= p_pmt
->p_first_descriptor
; p_dr
!= NULL
; p_dr
= p_dr
->p_next
)
4232 dvbpsi_ca_dr_t
*p_cadr
= dvbpsi_DecodeCADr( p_dr
);
4233 i_arib_flags
|= (p_cadr
->i_ca_system_id
== 0x05);
4237 i_arib_flags
|= 1 << 1;
4240 i_arib_flags
|= 1 << 2;
4246 if ( i_arib_flags
== 0b111 )
4247 p_sys
->arib
.e_mode
= ARIBMODE_ENABLED
;
4250 for( p_dr
= p_pmt
->p_first_descriptor
; p_dr
!= NULL
; p_dr
= p_dr
->p_next
)
4252 /* special descriptors handling */
4255 case 0x1d: /* We have found an IOD descriptor */
4256 msg_Dbg( p_demux
, " * PMT descriptor : IOD (0x1d)" );
4257 prg
->iod
= IODNew( p_dr
->i_length
, p_dr
->p_data
);
4261 msg_Dbg( p_demux
, " * PMT descriptor : CA (0x9) SysID 0x%x",
4262 (p_dr
->p_data
[0] << 8) | p_dr
->p_data
[1] );
4265 case 0x5: /* Registration Descriptor */
4266 if( p_dr
->i_length
!= 4 )
4268 msg_Warn( p_demux
, " * PMT invalid Registration Descriptor" );
4272 msg_Dbg( p_demux
, " * PMT descriptor : registration %4.4s", p_dr
->p_data
);
4273 if( !memcmp( p_dr
->p_data
, "HDMV", 4 ) || !memcmp( p_dr
->p_data
, "HDPR", 4 ) )
4274 registration_type
= TS_PMT_REGISTRATION_HDMV
; /* Blu-Ray */
4279 msg_Dbg( p_demux
, " * PMT descriptor : Private Data (0x0f)" );
4283 msg_Dbg( p_demux
, " * PMT descriptor : Digital copy control (0xC1)" );
4286 case 0x88: /* EACEM Simulcast HD Logical channels ordering */
4287 msg_Dbg( p_demux
, " * descriptor : EACEM Simulcast HD" );
4288 /* TODO: apply visibility flags */
4292 msg_Dbg( p_demux
, " * PMT descriptor : unknown (0x%x)", p_dr
->i_tag
);
4295 dvbpsi_pmt_es_t
*p_es
;
4296 for( p_es
= p_pmt
->p_first_es
; p_es
!= NULL
; p_es
= p_es
->p_next
)
4298 ts_pid_t tmp_pid
, *old_pid
= 0, *pid
= &tmp_pid
;
4300 /* Find out if the PID was already declared */
4301 for( int i
= 0; i
< i_clean
; i
++ )
4303 if( pp_clean
[i
] == &p_sys
->pid
[p_es
->i_pid
] )
4305 old_pid
= pp_clean
[i
];
4309 ValidateDVBMeta( p_demux
, p_es
->i_pid
);
4311 if( !old_pid
&& p_sys
->pid
[p_es
->i_pid
].b_valid
)
4313 msg_Warn( p_demux
, " * PMT error: pid=%d already defined",
4318 char const * psz_typedesc
= "";
4319 switch(p_es
->i_type
)
4322 psz_typedesc
= "ISO/IEC Reserved";
4325 psz_typedesc
= "ISO/IEC 11172 Video";
4328 psz_typedesc
= "ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream";
4331 psz_typedesc
= "ISO/IEC 11172 Audio";
4334 psz_typedesc
= "ISO/IEC 13818-3 Audio";
4337 psz_typedesc
= "ISO/IEC 13818-1 private_sections";
4340 psz_typedesc
= "ISO/IEC 13818-1 PES packets containing private data";
4343 psz_typedesc
= "ISO/IEC 13522 MHEG";
4346 psz_typedesc
= "ISO/IEC 13818-1 Annex A DSM CC";
4349 psz_typedesc
= "ITU-T Rec. H.222.1";
4352 psz_typedesc
= "ISO/IEC 13818-6 type A";
4355 psz_typedesc
= "ISO/IEC 13818-6 type B";
4358 psz_typedesc
= "ISO/IEC 13818-6 type C";
4361 psz_typedesc
= "ISO/IEC 13818-6 type D";
4364 psz_typedesc
= "ISO/IEC 13818-1 auxiliary";
4367 if (p_es
->i_type
>= 0x0F && p_es
->i_type
<=0x7F)
4368 psz_typedesc
= "ISO/IEC 13818-1 Reserved";
4370 psz_typedesc
= "User Private";
4373 msg_Dbg( p_demux
, " * pid=%d type=0x%x %s",
4374 p_es
->i_pid
, p_es
->i_type
, psz_typedesc
);
4376 for( p_dr
= p_es
->p_first_descriptor
; p_dr
!= NULL
;
4377 p_dr
= p_dr
->p_next
)
4379 msg_Dbg( p_demux
, " - descriptor tag 0x%x",
4383 PIDInit( pid
, false, pmt
->psi
);
4384 PIDFillFormat( &pid
->es
->fmt
, p_es
->i_type
);
4385 pid
->i_owner_number
= prg
->i_number
;
4386 pid
->i_pid
= p_es
->i_pid
;
4387 pid
->b_seen
= p_sys
->pid
[p_es
->i_pid
].b_seen
;
4390 bool b_registration_applied
= false;
4391 if ( p_es
->i_type
>= 0x80 ) /* non standard, extensions */
4393 if ( registration_type
== TS_PMT_REGISTRATION_HDMV
)
4395 if (( b_registration_applied
= PMTSetupEsHDMV( p_demux
, pid
, p_es
) ))
4396 msg_Dbg( p_demux
, " + HDMV registration applied to pid %d type 0x%x",
4397 p_es
->i_pid
, p_es
->i_type
);
4401 if (( b_registration_applied
= PMTSetupEsRegistration( p_demux
, pid
, p_es
) ))
4402 msg_Dbg( p_demux
, " + registration applied to pid %d type 0x%x",
4403 p_es
->i_pid
, p_es
->i_type
);
4407 if ( !b_registration_applied
)
4409 switch( p_es
->i_type
)
4412 /* Handle PES private data */
4413 PMTSetupEs0x06( p_demux
, pid
, p_es
);
4415 /* All other private or reserved types */
4420 PMTSetupEsISO14496( p_demux
, pid
, prg
, p_es
);
4424 PMTSetupEs0x83( p_pmt
, pid
);
4427 PMTSetupEs0xA0( p_demux
, pid
, p_es
);
4430 PMTSetupEs0xD1( p_demux
, pid
, p_es
);
4433 PMTSetupEs0xEA( p_demux
, pid
, p_es
);
4439 if( pid
->es
->fmt
.i_cat
== AUDIO_ES
||
4440 ( pid
->es
->fmt
.i_cat
== SPU_ES
&&
4441 pid
->es
->fmt
.i_codec
!= VLC_CODEC_DVBS
&&
4442 pid
->es
->fmt
.i_codec
!= VLC_CODEC_TELETEXT
) )
4444 PMTParseEsIso639( p_demux
, pid
, p_es
);
4447 switch( pid
->es
->fmt
.i_codec
)
4449 case VLC_CODEC_SCTE_27
:
4450 pid
->es
->data_type
= TS_ES_DATA_TABLE_SECTION
;
4453 //pid->es->data_type = TS_ES_DATA_PES;
4457 pid
->es
->fmt
.i_group
= p_pmt
->i_program_number
;
4458 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4459 pid
->extra_es
[i
]->fmt
.i_group
= p_pmt
->i_program_number
;
4461 if( pid
->es
->fmt
.i_cat
== UNKNOWN_ES
)
4463 msg_Dbg( p_demux
, " => pid %d content is *unknown*",
4468 msg_Dbg( p_demux
, " => pid %d has now es fcc=%4.4s",
4469 p_es
->i_pid
, (char*)&pid
->es
->fmt
.i_codec
);
4471 if( p_sys
->b_es_id_pid
) pid
->es
->fmt
.i_id
= p_es
->i_pid
;
4473 /* Check if we can avoid restarting the ES */
4475 pid
->es
->fmt
.i_codec
== old_pid
->es
->fmt
.i_codec
&&
4476 pid
->es
->fmt
.i_extra
== old_pid
->es
->fmt
.i_extra
&&
4477 pid
->es
->fmt
.i_extra
== 0 &&
4478 pid
->i_extra_es
== old_pid
->i_extra_es
&&
4479 ( ( !pid
->es
->fmt
.psz_language
&&
4480 !old_pid
->es
->fmt
.psz_language
) ||
4481 ( pid
->es
->fmt
.psz_language
&&
4482 old_pid
->es
->fmt
.psz_language
&&
4483 !strcmp( pid
->es
->fmt
.psz_language
,
4484 old_pid
->es
->fmt
.psz_language
) ) ) )
4486 pid
->i_cc
= old_pid
->i_cc
;
4487 ts_es_t
*e
= pid
->es
;
4488 pid
->es
= old_pid
->es
;
4490 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4492 e
= pid
->extra_es
[i
];
4493 pid
->extra_es
[i
] = old_pid
->extra_es
[i
];
4494 old_pid
->extra_es
[i
] = e
;
4499 pid
->es
->id
= es_out_Add( p_demux
->out
, &pid
->es
->fmt
);
4500 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4502 pid
->extra_es
[i
]->id
=
4503 es_out_Add( p_demux
->out
, &pid
->extra_es
[i
]->fmt
);
4505 p_sys
->i_pmt_es
+= 1 + pid
->i_extra_es
;
4509 /* Add ES to the list */
4512 PIDClean( p_demux
, old_pid
);
4513 TAB_REMOVE( i_clean
, pp_clean
, old_pid
);
4515 p_sys
->pid
[p_es
->i_pid
] = *pid
;
4517 p_dr
= PMTEsFindDescriptor( p_es
, 0x09 );
4518 if( p_dr
&& p_dr
->i_length
>= 2 )
4520 msg_Dbg( p_demux
, " * PMT descriptor : CA (0x9) SysID 0x%x",
4521 (p_dr
->p_data
[0] << 8) | p_dr
->p_data
[1] );
4524 if( ProgramIsSelected( p_demux
, prg
->i_number
) && pid
->es
->id
!= NULL
)
4525 SetPIDFilter( p_demux
, p_es
->i_pid
, true ); /* Set demux filter */
4528 /* Set CAM descrambling */
4529 if( !ProgramIsSelected( p_demux
, prg
->i_number
)
4530 || stream_Control( p_demux
->s
, STREAM_SET_PRIVATE_ID_CA
,
4531 p_pmt
) != VLC_SUCCESS
)
4532 dvbpsi_DeletePMT( p_pmt
);
4534 for( int i
= 0; i
< i_clean
; i
++ )
4536 if( ProgramIsSelected( p_demux
, prg
->i_number
) )
4537 SetPIDFilter( p_demux
, pp_clean
[i
]->i_pid
, false );
4539 PIDClean( p_demux
, pp_clean
[i
] );
4545 static void PATCallBack( void *data
, dvbpsi_pat_t
*p_pat
)
4547 demux_t
*p_demux
= data
;
4548 demux_sys_t
*p_sys
= p_demux
->p_sys
;
4549 dvbpsi_pat_program_t
*p_program
;
4550 ts_pid_t
*pat
= &p_sys
->pid
[0];
4552 msg_Dbg( p_demux
, "PATCallBack called" );
4554 if( ( pat
->psi
->i_pat_version
!= -1 &&
4555 ( !p_pat
->b_current_next
||
4556 p_pat
->i_version
== pat
->psi
->i_pat_version
) ) ||
4559 dvbpsi_DeletePAT( p_pat
);
4563 msg_Dbg( p_demux
, "new PAT ts_id=%d version=%d current_next=%d",
4564 p_pat
->i_ts_id
, p_pat
->i_version
, p_pat
->b_current_next
);
4567 if( p_sys
->i_pmt
> 0 )
4570 ts_pid_t
**pmt_rm
= NULL
;
4572 /* Search pmt to be deleted */
4573 for( int i
= 0; i
< p_sys
->i_pmt
; i
++ )
4575 ts_pid_t
*pmt
= p_sys
->pmt
[i
];
4576 bool b_keep
= false;
4578 for( p_program
= p_pat
->p_first_program
; !b_keep
&& p_program
;
4579 p_program
= p_program
->p_next
)
4581 if( p_program
->i_pid
!= pmt
->i_pid
)
4584 for( int i_prg
= 0; !b_keep
&& i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
4585 if( p_program
->i_number
== pmt
->psi
->prg
[i_prg
]->i_number
)
4592 TAB_APPEND( i_pmt_rm
, pmt_rm
, pmt
);
4595 /* Delete all ES attached to thoses PMT */
4596 for( int i
= 2; i
< 8192; i
++ )
4598 ts_pid_t
*pid
= &p_sys
->pid
[i
];
4600 if( !pid
->b_valid
|| pid
->psi
)
4603 for( int j
= 0; j
< i_pmt_rm
&& pid
->b_valid
; j
++ )
4605 for( int i_prg
= 0; i_prg
< pid
->p_owner
->i_prg
; i_prg
++ )
4607 /* We only remove es that aren't defined by extra pmt */
4608 if( pid
->p_owner
->prg
[i_prg
]->i_pid_pmt
!= pmt_rm
[j
]->i_pid
)
4612 SetPIDFilter( p_demux
, i
, false );
4614 PIDClean( p_demux
, pid
);
4620 /* Delete PMT pid */
4621 for( int i
= 0; i
< i_pmt_rm
; i
++ )
4623 ts_pid_t
*pid
= pmt_rm
[i
];
4624 SetPIDFilter( p_demux
, pid
->i_pid
, false );
4626 for( int i_prg
= 0; i_prg
< pid
->psi
->i_prg
; i_prg
++ )
4628 const int i_number
= pid
->psi
->prg
[i_prg
]->i_number
;
4629 es_out_Control( p_demux
->out
, ES_OUT_DEL_GROUP
, i_number
);
4632 PIDClean( p_demux
, &p_sys
->pid
[pid
->i_pid
] );
4633 TAB_REMOVE( p_sys
->i_pmt
, p_sys
->pmt
, pid
);
4639 /* now create programs */
4640 for( p_program
= p_pat
->p_first_program
; p_program
!= NULL
;
4641 p_program
= p_program
->p_next
)
4643 msg_Dbg( p_demux
, " * number=%d pid=%d", p_program
->i_number
,
4645 if( p_program
->i_number
== 0 )
4648 ts_pid_t
*pmt
= &p_sys
->pid
[p_program
->i_pid
];
4650 ValidateDVBMeta( p_demux
, p_program
->i_pid
);
4655 for( int i_prg
= 0; b_add
&& i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
4656 if( pmt
->psi
->prg
[i_prg
]->i_number
== p_program
->i_number
)
4664 TAB_APPEND( p_sys
->i_pmt
, p_sys
->pmt
, pmt
);
4667 PIDInit( pmt
, true, pat
->psi
);
4668 ts_prg_psi_t
*prg
= pmt
->psi
->prg
[pmt
->psi
->i_prg
-1];
4669 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
4670 prg
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
4673 dvbpsi_DeletePAT( p_pat
);
4676 prg
->handle
->p_sys
= (void *) VLC_OBJECT(p_demux
);
4677 if( !dvbpsi_pmt_attach( prg
->handle
, p_program
->i_number
, PMTCallBack
, p_demux
) )
4678 msg_Err( p_demux
, "PATCallback failed attaching PMTCallback to program %d",
4679 p_program
->i_number
);
4681 prg
->handle
= dvbpsi_AttachPMT( p_program
->i_number
, PMTCallBack
, p_demux
);
4683 prg
->i_number
= p_program
->i_number
;
4684 prg
->i_pid_pmt
= p_program
->i_pid
;
4686 /* Now select PID at access level */
4687 if( ProgramIsSelected( p_demux
, p_program
->i_number
) )
4689 if( p_sys
->i_current_program
== 0 )
4690 p_sys
->i_current_program
= p_program
->i_number
;
4692 if( SetPIDFilter( p_demux
, p_program
->i_pid
, true ) )
4693 p_sys
->b_access_control
= false;
4696 pat
->psi
->i_pat_version
= p_pat
->i_version
;
4698 dvbpsi_DeletePAT( p_pat
);