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>
38 #include <vlc_access.h> /* DVB-specific things */
39 #include <vlc_demux.h>
42 #include <vlc_charset.h> /* FromCharset, for EIT */
44 #include "../mux/mpeg/csa.h"
46 /* Include dvbpsi headers */
47 # include <dvbpsi/dvbpsi.h>
48 # include <dvbpsi/demux.h>
49 # include <dvbpsi/descriptor.h>
50 # include <dvbpsi/pat.h>
51 # include <dvbpsi/pmt.h>
52 # include <dvbpsi/sdt.h>
53 # include <dvbpsi/dr.h>
54 # include <dvbpsi/psi.h>
57 # include <dvbpsi/eit.h>
60 # include <dvbpsi/tot.h>
62 #include "../mux/mpeg/dvbpsi_compat.h"
65 VLC_FORMAT(1, 2) static void ts_debug(const char *format
, ...)
70 vfprintf(stderr
, format
, ap
);
77 /*****************************************************************************
79 *****************************************************************************/
80 static int Open ( vlc_object_t
* );
81 static void Close ( vlc_object_t
* );
84 * - Rename "extra pmt" to "user pmt"
85 * - Update extra pmt description
86 * pmt_pid[:pmt_number][=pid_description[,pid_description]]
87 * where pid_description could take 3 forms:
88 * 1. pid:pcr (to force the pcr pid)
90 * 3. pid:type=fourcc where type=(video|audio|spu)
92 #define PMT_TEXT N_("Extra PMT")
93 #define PMT_LONGTEXT N_( \
94 "Allows a user to specify an extra pmt (pmt_pid=pid:stream_type[,...])." )
96 #define PID_TEXT N_("Set id of ES to PID")
97 #define PID_LONGTEXT N_("Set the internal ID of each elementary stream" \
98 " handled by VLC to the same value as the PID in" \
99 " the TS stream, instead of 1, 2, 3, etc. Useful to" \
100 " do \'#duplicate{..., select=\"es=<pid>\"}\'.")
102 #define TSOUT_TEXT N_("Fast udp streaming")
103 #define TSOUT_LONGTEXT N_( \
104 "Sends TS to specific ip:port by udp (you must know what you are doing).")
106 #define MTUOUT_TEXT N_("MTU for out mode")
107 #define MTUOUT_LONGTEXT N_("MTU for out mode.")
109 #define CSA_TEXT N_("CSA Key")
110 #define CSA_LONGTEXT N_("CSA encryption key. This must be a " \
111 "16 char string (8 hexadecimal bytes).")
113 #define CSA2_TEXT N_("Second CSA Key")
114 #define CSA2_LONGTEXT N_("The even CSA encryption key. This must be a " \
115 "16 char string (8 hexadecimal bytes).")
118 #define CPKT_TEXT N_("Packet size in bytes to decrypt")
119 #define CPKT_LONGTEXT N_("Specify the size of the TS packet to decrypt. " \
120 "The decryption routines subtract the TS-header from the value before " \
123 #define SPLIT_ES_TEXT N_("Separate sub-streams")
124 #define SPLIT_ES_LONGTEXT N_( \
125 "Separate teletex/dvbs pages into independent ES. " \
126 "It can be useful to turn off this option when using stream output." )
128 #define SEEK_PERCENT_TEXT N_("Seek based on percent not time")
129 #define SEEK_PERCENT_LONGTEXT N_( \
130 "Seek and position based on a percent byte position, not a PCR generated " \
131 "time position. If seeking doesn't work property, turn on this option." )
133 #define PCR_TEXT N_("Trust in-stream PCR")
134 #define PCR_LONGTEXT N_("Use the stream PCR as a reference.")
137 set_description( N_("MPEG Transport Stream demuxer") )
138 set_shortname ( "MPEG-TS" )
139 set_category( CAT_INPUT
)
140 set_subcategory( SUBCAT_INPUT_DEMUX
)
142 add_string( "ts-extra-pmt", NULL
, PMT_TEXT
, PMT_LONGTEXT
, true )
143 add_bool( "ts-trust-pcr", true, PCR_TEXT
, PCR_LONGTEXT
, true )
145 add_bool( "ts-es-id-pid", true, PID_TEXT
, PID_LONGTEXT
, true )
147 add_obsolete_string( "ts-out" ) /* since 2.2.0 */
148 add_obsolete_integer( "ts-out-mtu" ) /* since 2.2.0 */
149 add_string( "ts-csa-ck", NULL
, CSA_TEXT
, CSA_LONGTEXT
, true )
151 add_string( "ts-csa2-ck", NULL
, CSA2_TEXT
, CSA2_LONGTEXT
, true )
153 add_integer( "ts-csa-pkt", 188, CPKT_TEXT
, CPKT_LONGTEXT
, true )
156 add_bool( "ts-split-es", true, SPLIT_ES_TEXT
, SPLIT_ES_LONGTEXT
, false )
157 add_bool( "ts-seek-percent", false, SEEK_PERCENT_TEXT
, SEEK_PERCENT_LONGTEXT
, true )
159 add_obsolete_bool( "ts-silent" );
161 set_capability( "demux", 10 )
162 set_callbacks( Open
, Close
)
166 /*****************************************************************************
168 *****************************************************************************/
169 static const char *const ppsz_teletext_type
[] = {
172 N_("Teletext subtitles"),
173 N_("Teletext: additional information"),
174 N_("Teletext: program schedule"),
175 N_("Teletext subtitles: hearing impaired")
180 uint8_t i_objectTypeIndication
;
181 uint8_t i_streamType
;
186 } decoder_config_descriptor_t
;
195 decoder_config_descriptor_t dec_descr
;
197 } es_mpeg4_descriptor_t
;
204 es_mpeg4_descriptor_t es_descr
[255];
210 dvbpsi_handle handle
;
216 /* IOD stuff (mpeg4) */
217 iod_descriptor_t
*iod
;
223 /* for special PAT/SDT case */
224 dvbpsi_handle handle
; /* PAT/SDT/EIT */
237 TS_ES_DATA_TABLE_SECTION
242 TS_REGISTRATION_OTHER
= 0,
244 } ts_registration_type_t
;
250 ts_es_data_type_t data_type
;
256 es_mpeg4_descriptor_t
*p_mpeg4desc
;
266 int i_cc
; /* countinuity counter */
269 /* PSI owner (ie PMT -> PAT, ES -> PMT */
277 /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
285 vlc_mutex_t csa_lock
;
287 /* TS packet size (188, 192, 204) */
290 /* Additional TS packet header size (BluRay TS packets have 4-byte header before sync byte) */
291 int i_packet_header_size
;
293 /* how many TS packet we read at once */
296 /* to determine length and time */
299 mtime_t i_current_pcr
;
301 bool b_force_seek_per_percent
;
324 bool b_access_control
;
330 int64_t i_dvb_length
;
331 bool b_broken_charset
; /* True if broken encoding is used in EPG/SDT */
334 int i_current_program
;
335 vlc_list_t programs_list
;
341 static int Demux ( demux_t
*p_demux
);
342 static int Control( demux_t
*p_demux
, int i_query
, va_list args
);
344 static void PIDInit ( ts_pid_t
*pid
, bool b_psi
, ts_psi_t
*p_owner
);
345 static void PIDClean( demux_t
*, ts_pid_t
*pid
);
346 static void PIDFillFormat( const ts_es_t
*es
, int i_stream_type
);
348 static void PATCallBack( void*, dvbpsi_pat_t
* );
349 static void PMTCallBack( void *data
, dvbpsi_pmt_t
*p_pmt
);
350 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
351 static void PSINewTableCallBack( dvbpsi_t
*handle
, uint8_t i_table_id
,
352 uint16_t i_extension
, demux_t
* );
354 static void PSINewTableCallBack( demux_t
*, dvbpsi_handle
,
355 uint8_t i_table_id
, uint16_t i_extension
);
358 static int ChangeKeyCallback( vlc_object_t
*, char const *, vlc_value_t
, vlc_value_t
, void * );
360 static inline int PIDGet( block_t
*p
)
362 return ( (p
->p_buffer
[1]&0x1f)<<8 )|p
->p_buffer
[2];
365 static bool GatherData( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
);
367 static block_t
* ReadTSPacket( demux_t
*p_demux
);
368 static int Seek( demux_t
*p_demux
, double f_percent
);
369 static void GetFirstPCR( demux_t
*p_demux
);
370 static void GetLastPCR( demux_t
*p_demux
);
371 static void CheckPCR( demux_t
*p_demux
);
372 static void PCRHandle( demux_t
*p_demux
, ts_pid_t
*, block_t
* );
374 static void IODFree( iod_descriptor_t
* );
376 #define TS_USER_PMT_NUMBER (0)
377 static int UserPmt( demux_t
*p_demux
, const char * );
379 static int SetPIDFilter( demux_t
*, int i_pid
, bool b_selected
);
380 static void SetPrgFilter( demux_t
*, int i_prg
, bool b_selected
);
382 #define TS_PACKET_SIZE_188 188
383 #define TS_PACKET_SIZE_192 192
384 #define TS_PACKET_SIZE_204 204
385 #define TS_PACKET_SIZE_MAX 204
386 #define TS_TOPFIELD_HEADER 1320
388 static int DetectPacketSize( demux_t
*p_demux
, int *pi_header_size
)
390 const uint8_t *p_peek
;
391 if( stream_Peek( p_demux
->s
,
392 &p_peek
, TS_PACKET_SIZE_MAX
) < TS_PACKET_SIZE_MAX
)
397 if( memcmp( p_peek
, "TFrc", 4 ) == 0 )
400 /* I used the TF5000PVR 2004 Firmware .doc header documentation,
401 * http://www.i-topfield.com/data/product/firmware/Structure%20of%20Recorded%20File%20in%20TF5000PVR%20(Feb%2021%202004).doc
402 * but after the filename the offsets seem to be incorrect. - DJ */
403 int i_duration
, i_name
;
404 char *psz_name
= xmalloc(25);
405 char *psz_event_name
;
406 char *psz_event_text
= xmalloc(130);
407 char *psz_ext_text
= xmalloc(1025);
409 // 2 bytes version Uimsbf (4,5)
410 // 2 bytes reserved (6,7)
411 // 2 bytes duration in minutes Uimsbf (8,9(
412 i_duration
= (int) (p_peek
[8] << 8) | p_peek
[9];
413 msg_Dbg( p_demux
, "Topfield recording length: +/- %d minutes", i_duration
);
414 // 2 bytes service number in channel list (10, 11)
415 // 2 bytes service type Bslbf 0=TV 1=Radio Bslb (12, 13)
416 // 4 bytes of reserved + tuner info (14,15,16,17)
417 // 2 bytes of Service ID Bslbf (18,19)
418 // 2 bytes of PMT PID Uimsbf (20,21)
419 // 2 bytes of PCR PID Uimsbf (22,23)
420 // 2 bytes of Video PID Uimsbf (24,25)
421 // 2 bytes of Audio PID Uimsbf (26,27)
422 // 24 bytes filename Bslbf
423 memcpy( psz_name
, &p_peek
[28], 24 );
425 msg_Dbg( p_demux
, "recordingname=%s", psz_name
);
426 // 1 byte of sat index Uimsbf (52)
427 // 3 bytes (1 bit of polarity Bslbf +23 bits reserved)
428 // 4 bytes of freq. Uimsbf (56,57,58,59)
429 // 2 bytes of symbol rate Uimsbf (60,61)
430 // 2 bytes of TS stream ID Uimsbf (62,63)
433 // 2 bytes duration Uimsbf (70,71)
434 //i_duration = (int) (p_peek[70] << 8) | p_peek[71];
435 //msg_Dbg( p_demux, "Topfield 2nd duration field: +/- %d minutes", i_duration);
436 // 4 bytes EventID Uimsbf (72-75)
437 // 8 bytes of Start and End time info (76-83)
438 // 1 byte reserved (84)
439 // 1 byte event name length Uimsbf (89)
440 i_name
= (int)(p_peek
[89]&~0x81);
441 msg_Dbg( p_demux
, "event name length = %d", i_name
);
442 psz_event_name
= xmalloc( i_name
+1 );
443 // 1 byte parental rating (90)
444 // 129 bytes of event text
445 memcpy( psz_event_name
, &p_peek
[91], i_name
);
446 psz_event_name
[i_name
] = '\0';
447 memcpy( psz_event_text
, &p_peek
[91+i_name
], 129-i_name
);
448 psz_event_text
[129-i_name
] = '\0';
449 msg_Dbg( p_demux
, "event name=%s", psz_event_name
);
450 msg_Dbg( p_demux
, "event text=%s", psz_event_text
);
451 // 12 bytes reserved (220)
453 // 2 bytes Event Text Length Uimsbf
454 // 4 bytes EventID Uimsbf
455 // FIXME We just have 613 bytes. not enough for this entire text
456 // 1024 bytes Extended Event Text Bslbf
457 memcpy( psz_ext_text
, p_peek
+372, 1024 );
458 psz_ext_text
[1024] = '\0';
459 msg_Dbg( p_demux
, "extended event text=%s", psz_ext_text
);
460 // 52 bytes reserved Bslbf
462 msg_Dbg( p_demux
, "this is a topfield file" );
463 return TS_PACKET_SIZE_188
;
466 for( int i_sync
= 0; i_sync
< TS_PACKET_SIZE_MAX
; i_sync
++ )
468 if( p_peek
[i_sync
] != 0x47 )
471 /* Check next 3 sync bytes */
472 int i_peek
= TS_PACKET_SIZE_MAX
* 3 + i_sync
+ 1;
473 if( ( stream_Peek( p_demux
->s
, &p_peek
, i_peek
) ) < i_peek
)
475 msg_Err( p_demux
, "cannot peek" );
478 if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_188
] == 0x47 &&
479 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_188
] == 0x47 &&
480 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_188
] == 0x47 )
482 return TS_PACKET_SIZE_188
;
484 else if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_192
] == 0x47 &&
485 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_192
] == 0x47 &&
486 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_192
] == 0x47 )
490 *pi_header_size
= 4; /* BluRay TS packets have 4-byte header */
492 return TS_PACKET_SIZE_192
;
494 else if( p_peek
[i_sync
+ 1 * TS_PACKET_SIZE_204
] == 0x47 &&
495 p_peek
[i_sync
+ 2 * TS_PACKET_SIZE_204
] == 0x47 &&
496 p_peek
[i_sync
+ 3 * TS_PACKET_SIZE_204
] == 0x47 )
498 return TS_PACKET_SIZE_204
;
502 if( p_demux
->b_force
)
504 msg_Warn( p_demux
, "this does not look like a TS stream, continuing" );
505 return TS_PACKET_SIZE_188
;
507 msg_Dbg( p_demux
, "TS module discarded (lost sync)" );
511 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
512 static void vlc_dvbpsi_reset( demux_t
*p_demux
)
514 demux_sys_t
*p_sys
= p_demux
->p_sys
;
516 ts_pid_t
*pat
= &p_sys
->pid
[0];
517 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
518 ts_pid_t
*eit
= &p_sys
->pid
[0x12];
519 ts_pid_t
*tdt
= &p_sys
->pid
[0x14];
521 if( pat
->psi
->handle
)
523 if( dvbpsi_decoder_present( pat
->psi
->handle
) )
524 dvbpsi_pat_detach( pat
->psi
->handle
);
525 dvbpsi_delete( pat
->psi
->handle
);
526 pat
->psi
->handle
= NULL
;
529 if( sdt
->psi
->handle
)
531 if( dvbpsi_decoder_present( sdt
->psi
->handle
) )
532 dvbpsi_DetachDemux( sdt
->psi
->handle
);
533 dvbpsi_delete( sdt
->psi
->handle
);
534 sdt
->psi
->handle
= NULL
;
537 if( eit
->psi
->handle
)
539 if( dvbpsi_decoder_present( eit
->psi
->handle
) )
540 dvbpsi_DetachDemux( eit
->psi
->handle
);
541 dvbpsi_delete( eit
->psi
->handle
);
542 eit
->psi
->handle
= NULL
;
545 if( tdt
->psi
->handle
)
547 if( dvbpsi_decoder_present( tdt
->psi
->handle
) )
548 dvbpsi_DetachDemux( tdt
->psi
->handle
);
549 dvbpsi_delete( tdt
->psi
->handle
);
550 tdt
->psi
->handle
= NULL
;
555 /*****************************************************************************
557 *****************************************************************************/
558 static int Open( vlc_object_t
*p_this
)
560 demux_t
*p_demux
= (demux_t
*)p_this
;
563 int i_packet_size
, i_packet_header_size
= 0;
567 /* Search first sync byte */
568 i_packet_size
= DetectPacketSize( p_demux
, &i_packet_header_size
);
569 if( i_packet_size
< 0 )
572 p_demux
->p_sys
= p_sys
= malloc( sizeof( demux_sys_t
) );
575 memset( p_sys
, 0, sizeof( demux_sys_t
) );
576 vlc_mutex_init( &p_sys
->csa_lock
);
578 p_demux
->pf_demux
= Demux
;
579 p_demux
->pf_control
= Control
;
581 /* Init p_sys field */
582 p_sys
->b_dvb_meta
= true;
583 p_sys
->b_access_control
= true;
584 p_sys
->i_current_program
= 0;
585 p_sys
->programs_list
.i_count
= 0;
586 p_sys
->programs_list
.p_values
= NULL
;
587 p_sys
->i_tdt_delta
= 0;
588 p_sys
->i_dvb_start
= 0;
589 p_sys
->i_dvb_length
= 0;
591 p_sys
->b_broken_charset
= false;
593 for( int i
= 0; i
< 8192; i
++ )
595 ts_pid_t
*pid
= &p_sys
->pid
[i
];
598 pid
->b_valid
= false;
600 /* PID 8191 is padding */
601 p_sys
->pid
[8191].b_seen
= true;
602 p_sys
->i_packet_size
= i_packet_size
;
603 p_sys
->i_packet_header_size
= i_packet_header_size
;
604 p_sys
->i_ts_read
= 50;
606 p_sys
->b_start_record
= false;
608 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
609 # define VLC_DVBPSI_DEMUX_TABLE_INIT(table,obj) \
611 (table)->psi->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG ); \
612 if( ! (table)->psi->handle ) \
614 vlc_mutex_destroy( &p_sys->csa_lock ); \
618 (table)->psi->handle->p_sys = (void *) VLC_OBJECT(obj); \
619 if( !dvbpsi_AttachDemux( (table)->psi->handle, (dvbpsi_demux_new_cb_t)PSINewTableCallBack, (obj) ) ) \
621 vlc_dvbpsi_reset( obj ); \
622 vlc_mutex_destroy( &p_sys->csa_lock ); \
624 return VLC_EGENERIC; \
629 /* Init PAT handler */
630 pat
= &p_sys
->pid
[0];
631 PIDInit( pat
, true, NULL
);
632 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
633 pat
->psi
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
634 if( !pat
->psi
->handle
)
636 vlc_mutex_destroy( &p_sys
->csa_lock
);
640 pat
->psi
->handle
->p_sys
= (void *) p_demux
;
641 if( !dvbpsi_pat_attach( pat
->psi
->handle
, PATCallBack
, p_demux
) )
643 vlc_dvbpsi_reset( p_demux
);
644 vlc_mutex_destroy( &p_sys
->csa_lock
);
649 pat
->psi
->handle
= dvbpsi_AttachPAT( PATCallBack
, p_demux
);
651 if( p_sys
->b_dvb_meta
)
653 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
654 ts_pid_t
*eit
= &p_sys
->pid
[0x12];
656 PIDInit( sdt
, true, NULL
);
657 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
658 VLC_DVBPSI_DEMUX_TABLE_INIT( sdt
, p_demux
)
661 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
664 PIDInit( eit
, true, NULL
);
665 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
666 VLC_DVBPSI_DEMUX_TABLE_INIT( eit
, p_demux
)
669 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
672 ts_pid_t
*tdt
= &p_sys
->pid
[0x14];
673 PIDInit( tdt
, true, NULL
);
674 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
675 VLC_DVBPSI_DEMUX_TABLE_INIT( tdt
, p_demux
)
678 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t
)PSINewTableCallBack
,
682 if( p_sys
->b_access_control
)
684 if( SetPIDFilter( p_demux
, 0x11, true ) ||
685 SetPIDFilter( p_demux
, 0x14, true ) ||
686 SetPIDFilter( p_demux
, 0x12, true ) )
687 p_sys
->b_access_control
= false;
691 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
692 # undef VLC_DVBPSI_DEMUX_TABLE_INIT
696 TAB_INIT( p_sys
->i_pmt
, p_sys
->pmt
);
700 p_sys
->b_es_id_pid
= var_CreateGetBool( p_demux
, "ts-es-id-pid" );
702 p_sys
->b_trust_pcr
= var_CreateGetBool( p_demux
, "ts-trust-pcr" );
704 /* We handle description of an extra PMT */
705 char* psz_string
= var_CreateGetString( p_demux
, "ts-extra-pmt" );
706 p_sys
->b_user_pmt
= false;
707 if( psz_string
&& *psz_string
)
708 UserPmt( p_demux
, psz_string
);
711 psz_string
= var_CreateGetStringCommand( p_demux
, "ts-csa-ck" );
712 if( psz_string
&& *psz_string
)
717 p_sys
->csa
= csa_New();
719 psz_csa2
= var_CreateGetStringCommand( p_demux
, "ts-csa2-ck" );
720 i_res
= csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, true );
721 if( i_res
== VLC_SUCCESS
&& psz_csa2
&& *psz_csa2
)
723 if( csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_csa2
, false ) != VLC_SUCCESS
)
725 csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, false );
728 else if ( i_res
== VLC_SUCCESS
)
730 csa_SetCW( (vlc_object_t
*)p_demux
, p_sys
->csa
, psz_string
, false );
734 csa_Delete( p_sys
->csa
);
740 var_AddCallback( p_demux
, "ts-csa-ck", ChangeKeyCallback
, (void *)1 );
741 var_AddCallback( p_demux
, "ts-csa2-ck", ChangeKeyCallback
, NULL
);
743 int i_pkt
= var_CreateGetInteger( p_demux
, "ts-csa-pkt" );
744 if( i_pkt
< 4 || i_pkt
> 188 )
746 msg_Err( p_demux
, "wrong packet size %d specified.", i_pkt
);
747 msg_Warn( p_demux
, "using default packet size of 188 bytes" );
748 p_sys
->i_csa_pkt_size
= 188;
751 p_sys
->i_csa_pkt_size
= i_pkt
;
752 msg_Dbg( p_demux
, "decrypting %d bytes of packet", p_sys
->i_csa_pkt_size
);
758 p_sys
->b_split_es
= var_InheritBool( p_demux
, "ts-split-es" );
760 p_sys
->i_pid_ref_pcr
= -1;
761 p_sys
->i_first_pcr
= -1;
762 p_sys
->i_current_pcr
= -1;
763 p_sys
->i_last_pcr
= -1;
764 p_sys
->b_force_seek_per_percent
= var_InheritBool( p_demux
, "ts-seek-percent" );
765 p_sys
->i_pcrs_num
= 10;
766 p_sys
->p_pcrs
= (mtime_t
*)calloc( p_sys
->i_pcrs_num
, sizeof( mtime_t
) );
767 p_sys
->p_pos
= (int64_t *)calloc( p_sys
->i_pcrs_num
, sizeof( int64_t ) );
769 if( !p_sys
->p_pcrs
|| !p_sys
->p_pos
)
775 bool can_seek
= false;
776 stream_Control( p_demux
->s
, STREAM_CAN_FASTSEEK
, &can_seek
);
779 GetFirstPCR( p_demux
);
781 GetLastPCR( p_demux
);
783 if( p_sys
->i_first_pcr
< 0 || p_sys
->i_last_pcr
< 0 )
785 msg_Dbg( p_demux
, "Force Seek Per Percent: PCR's not found,");
786 p_sys
->b_force_seek_per_percent
= true;
789 while( p_sys
->i_pmt_es
<= 0 && vlc_object_alive( p_demux
) )
791 if( p_demux
->pf_demux( p_demux
) != 1 )
797 /*****************************************************************************
799 *****************************************************************************/
800 static void Close( vlc_object_t
*p_this
)
802 demux_t
*p_demux
= (demux_t
*)p_this
;
803 demux_sys_t
*p_sys
= p_demux
->p_sys
;
805 msg_Dbg( p_demux
, "pid list:" );
806 for( int i
= 0; i
< 8192; i
++ )
808 ts_pid_t
*pid
= &p_sys
->pid
[i
];
810 if( pid
->b_valid
&& pid
->psi
)
815 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
816 if( dvbpsi_decoder_present( pid
->psi
->handle
) )
817 dvbpsi_pat_detach( pid
->psi
->handle
);
818 dvbpsi_delete( pid
->psi
->handle
);
819 pid
->psi
->handle
= NULL
;
821 dvbpsi_DetachPAT( pid
->psi
->handle
);
829 if( p_sys
->b_dvb_meta
&& ( pid
->i_pid
== 0x11 || pid
->i_pid
== 0x12 || pid
->i_pid
== 0x14 ) )
831 /* SDT or EIT or TDT */
832 dvbpsi_DetachDemux( pid
->psi
->handle
);
833 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
834 dvbpsi_delete( pid
->psi
->handle
);
835 pid
->psi
->handle
= NULL
;
841 PIDClean( p_demux
, pid
);
846 else if( pid
->b_valid
&& pid
->es
)
848 PIDClean( p_demux
, pid
);
853 msg_Dbg( p_demux
, " - pid[%d] seen", pid
->i_pid
);
858 SetPIDFilter( p_demux
, pid
->i_pid
, false );
861 vlc_mutex_lock( &p_sys
->csa_lock
);
864 var_DelCallback( p_demux
, "ts-csa-ck", ChangeKeyCallback
, NULL
);
865 var_DelCallback( p_demux
, "ts-csa2-ck", ChangeKeyCallback
, NULL
);
866 csa_Delete( p_sys
->csa
);
868 vlc_mutex_unlock( &p_sys
->csa_lock
);
870 TAB_CLEAN( p_sys
->i_pmt
, p_sys
->pmt
);
872 free( p_sys
->programs_list
.p_values
);
874 free( p_sys
->p_pcrs
);
875 free( p_sys
->p_pos
);
877 vlc_mutex_destroy( &p_sys
->csa_lock
);
881 /*****************************************************************************
882 * ChangeKeyCallback: called when changing the odd encryption key on the fly.
883 *****************************************************************************/
884 static int ChangeKeyCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
885 vlc_value_t oldval
, vlc_value_t newval
,
888 VLC_UNUSED(psz_cmd
); VLC_UNUSED(oldval
);
889 demux_t
*p_demux
= (demux_t
*)p_this
;
890 demux_sys_t
*p_sys
= p_demux
->p_sys
;
891 int i_tmp
= (intptr_t)p_data
;
893 vlc_mutex_lock( &p_sys
->csa_lock
);
895 i_tmp
= csa_SetCW( p_this
, p_sys
->csa
, newval
.psz_string
, true );
897 i_tmp
= csa_SetCW( p_this
, p_sys
->csa
, newval
.psz_string
, false );
899 vlc_mutex_unlock( &p_sys
->csa_lock
);
903 /*****************************************************************************
905 *****************************************************************************/
906 static int Demux( demux_t
*p_demux
)
908 demux_sys_t
*p_sys
= p_demux
->p_sys
;
909 bool b_wait_es
= p_sys
->i_pmt_es
<= 0;
911 /* We read at most 100 TS packet or until a frame is completed */
912 for( int i_pkt
= 0; i_pkt
< p_sys
->i_ts_read
; i_pkt
++ )
914 bool b_frame
= false;
916 if( !(p_pkt
= ReadTSPacket( p_demux
)) )
921 if( p_sys
->b_start_record
)
923 /* Enable recording once synchronized */
924 stream_Control( p_demux
->s
, STREAM_SET_RECORD_STATE
, true, "ts" );
925 p_sys
->b_start_record
= false;
928 /* Parse the TS packet */
929 ts_pid_t
*p_pid
= &p_sys
->pid
[PIDGet( p_pkt
)];
935 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 ) ) )
937 dvbpsi_PushPacket( p_pid
->psi
->handle
, p_pkt
->p_buffer
);
941 for( int i_prg
= 0; i_prg
< p_pid
->psi
->i_prg
; i_prg
++ )
943 dvbpsi_PushPacket( p_pid
->psi
->prg
[i_prg
]->handle
,
947 block_Release( p_pkt
);
951 b_frame
= GatherData( p_demux
, p_pid
, p_pkt
);
958 msg_Dbg( p_demux
, "pid[%d] unknown", p_pid
->i_pid
);
960 /* We have to handle PCR if present */
961 PCRHandle( p_demux
, p_pid
, p_pkt
);
962 block_Release( p_pkt
);
964 p_pid
->b_seen
= true;
966 if( b_frame
|| ( b_wait_es
&& p_sys
->i_pmt_es
> 0 ) )
970 demux_UpdateTitleFromStream( p_demux
);
974 /*****************************************************************************
976 *****************************************************************************/
977 static int DVBEventInformation( demux_t
*p_demux
, int64_t *pi_time
, int64_t *pi_length
)
979 demux_sys_t
*p_sys
= p_demux
->p_sys
;
985 if( p_sys
->i_dvb_length
> 0 )
987 const int64_t t
= mdate() + p_sys
->i_tdt_delta
;
989 if( p_sys
->i_dvb_start
<= t
&& t
< p_sys
->i_dvb_start
+ p_sys
->i_dvb_length
)
992 *pi_length
= p_sys
->i_dvb_length
;
994 *pi_time
= t
- p_sys
->i_dvb_start
;
1001 static int Control( demux_t
*p_demux
, int i_query
, va_list args
)
1003 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1005 bool b_bool
, *pb_bool
;
1012 case DEMUX_GET_POSITION
:
1013 pf
= (double*) va_arg( args
, double* );
1015 if( p_sys
->b_force_seek_per_percent
||
1016 (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1017 p_sys
->i_current_pcr
- p_sys
->i_first_pcr
< 0 ||
1018 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1020 int64_t i_time
, i_length
;
1021 if( !DVBEventInformation( p_demux
, &i_time
, &i_length
) && i_length
> 0 )
1022 *pf
= (double)i_time
/(double)i_length
;
1023 else if( (i64
= stream_Size( p_demux
->s
) ) > 0 )
1025 int64_t offset
= stream_Tell( p_demux
->s
);
1027 *pf
= (double)offset
/ (double)i64
;
1034 *pf
= (double)(p_sys
->i_current_pcr
- p_sys
->i_first_pcr
) / (double)(p_sys
->i_last_pcr
- p_sys
->i_first_pcr
);
1038 case DEMUX_SET_POSITION
:
1039 f
= (double) va_arg( args
, double );
1041 if( p_sys
->b_force_seek_per_percent
||
1042 (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1043 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1045 i64
= stream_Size( p_demux
->s
);
1046 if( stream_Seek( p_demux
->s
, (int64_t)(i64
* f
) ) )
1047 return VLC_EGENERIC
;
1051 if( Seek( p_demux
, f
) )
1053 p_sys
->b_force_seek_per_percent
= true;
1054 return VLC_EGENERIC
;
1059 case DEMUX_GET_TIME
:
1060 pi64
= (int64_t*)va_arg( args
, int64_t * );
1061 if( (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1062 p_sys
->b_force_seek_per_percent
||
1063 p_sys
->i_current_pcr
- p_sys
->i_first_pcr
< 0 )
1065 if( DVBEventInformation( p_demux
, pi64
, NULL
) )
1072 *pi64
= (p_sys
->i_current_pcr
- p_sys
->i_first_pcr
) * 100 / 9;
1076 case DEMUX_GET_LENGTH
:
1077 pi64
= (int64_t*)va_arg( args
, int64_t * );
1078 if( (p_sys
->b_dvb_meta
&& p_sys
->b_access_control
) ||
1079 p_sys
->b_force_seek_per_percent
||
1080 p_sys
->i_last_pcr
- p_sys
->i_first_pcr
<= 0 )
1082 if( DVBEventInformation( p_demux
, NULL
, pi64
) )
1089 *pi64
= (p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * 100 / 9;
1093 case DEMUX_SET_GROUP
:
1097 i_int
= (int)va_arg( args
, int );
1098 p_list
= (vlc_list_t
*)va_arg( args
, vlc_list_t
* );
1099 msg_Dbg( p_demux
, "DEMUX_SET_GROUP %d %p", i_int
, p_list
);
1101 if( i_int
== 0 && p_sys
->i_current_program
> 0 )
1102 i_int
= p_sys
->i_current_program
;
1104 if( p_sys
->i_current_program
> 0 )
1106 if( p_sys
->i_current_program
!= i_int
)
1107 SetPrgFilter( p_demux
, p_sys
->i_current_program
, false );
1109 else if( p_sys
->i_current_program
< 0 )
1111 for( int i
= 0; i
< p_sys
->programs_list
.i_count
; i
++ )
1112 SetPrgFilter( p_demux
, p_sys
->programs_list
.p_values
[i
].i_int
, false );
1117 p_sys
->i_current_program
= i_int
;
1118 SetPrgFilter( p_demux
, p_sys
->i_current_program
, true );
1120 else if( i_int
< 0 )
1122 p_sys
->i_current_program
= -1;
1123 p_sys
->programs_list
.i_count
= 0;
1126 vlc_list_t
*p_dst
= &p_sys
->programs_list
;
1127 free( p_dst
->p_values
);
1129 p_dst
->p_values
= calloc( p_list
->i_count
,
1130 sizeof(*p_dst
->p_values
) );
1131 if( p_dst
->p_values
)
1133 p_dst
->i_count
= p_list
->i_count
;
1134 for( int i
= 0; i
< p_list
->i_count
; i
++ )
1136 p_dst
->p_values
[i
] = p_list
->p_values
[i
];
1137 SetPrgFilter( p_demux
, p_dst
->p_values
[i
].i_int
, true );
1145 case DEMUX_GET_TITLE_INFO
:
1147 struct input_title_t
***v
= va_arg( args
, struct input_title_t
*** );
1148 int *c
= va_arg( args
, int * );
1150 *va_arg( args
, int* ) = 0; /* Title offset */
1151 *va_arg( args
, int* ) = 0; /* Chapter offset */
1152 return stream_Control( p_demux
->s
, STREAM_GET_TITLE_INFO
, v
, c
);
1155 case DEMUX_SET_TITLE
:
1156 return stream_vaControl( p_demux
->s
, STREAM_SET_TITLE
, args
);
1158 case DEMUX_SET_SEEKPOINT
:
1159 return stream_vaControl( p_demux
->s
, STREAM_SET_SEEKPOINT
, args
);
1161 case DEMUX_GET_META
:
1162 return stream_vaControl( p_demux
->s
, STREAM_GET_META
, args
);
1164 case DEMUX_CAN_RECORD
:
1165 pb_bool
= (bool*)va_arg( args
, bool * );
1169 case DEMUX_SET_RECORD_STATE
:
1170 b_bool
= (bool)va_arg( args
, int );
1173 stream_Control( p_demux
->s
, STREAM_SET_RECORD_STATE
, false );
1174 p_sys
->b_start_record
= b_bool
;
1177 case DEMUX_GET_SIGNAL
:
1178 return stream_vaControl( p_demux
->s
, STREAM_GET_SIGNAL
, args
);
1181 return VLC_EGENERIC
;
1185 /*****************************************************************************
1187 *****************************************************************************/
1188 static int UserPmt( demux_t
*p_demux
, const char *psz_fmt
)
1190 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1191 char *psz_dup
= strdup( psz_fmt
);
1192 char *psz
= psz_dup
;
1195 ts_prg_psi_t
*prg
= NULL
;
1201 i_pid
= strtol( psz
, &psz
, 0 );
1202 if( i_pid
< 2 || i_pid
>= 8192 )
1205 /* Parse optional program number */
1208 i_number
= strtol( &psz
[1], &psz
, 0 );
1211 ts_pid_t
*pmt
= &p_sys
->pid
[i_pid
];
1213 msg_Dbg( p_demux
, "user pmt specified (pid=%d,number=%d)", i_pid
, i_number
);
1214 PIDInit( pmt
, true, NULL
);
1217 prg
= calloc( 1, sizeof( ts_prg_psi_t
) );
1221 prg
->i_pid_pcr
= -1;
1222 prg
->i_pid_pmt
= -1;
1223 prg
->i_version
= -1;
1224 prg
->i_number
= i_number
!= 0 ? i_number
: TS_USER_PMT_NUMBER
;
1225 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1226 prg
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
1229 prg
->handle
->p_sys
= (void *) VLC_OBJECT(p_demux
);
1230 if( !dvbpsi_pmt_attach( prg
->handle
,
1231 ((i_number
!= TS_USER_PMT_NUMBER
? i_number
: 1)),
1232 PMTCallBack
, p_demux
) )
1234 dvbpsi_delete( prg
->handle
);
1239 prg
->handle
= dvbpsi_AttachPMT(
1240 ((i_number
!= TS_USER_PMT_NUMBER
) ? i_number
: 1),
1241 PMTCallBack
, p_demux
);
1243 TAB_APPEND( pmt
->psi
->i_prg
, pmt
->psi
->prg
, prg
);
1245 psz
= strchr( psz
, '=' );
1248 while( psz
&& *psz
)
1250 char *psz_next
= strchr( psz
, ',' );
1256 i_pid
= strtol( psz
, &psz
, 0 );
1257 if( *psz
!= ':' || i_pid
< 2 || i_pid
>= 8192 )
1260 char *psz_opt
= &psz
[1];
1261 if( !strcmp( psz_opt
, "pcr" ) )
1263 prg
->i_pid_pcr
= i_pid
;
1265 else if( !p_sys
->pid
[i_pid
].b_valid
)
1267 ts_pid_t
*pid
= &p_sys
->pid
[i_pid
];
1269 char *psz_arg
= strchr( psz_opt
, '=' );
1273 PIDInit( pid
, false, pmt
->psi
);
1274 if( prg
->i_pid_pcr
<= 0 )
1275 prg
->i_pid_pcr
= i_pid
;
1277 if( psz_arg
&& strlen( psz_arg
) == 4 )
1279 const vlc_fourcc_t i_codec
= VLC_FOURCC( psz_arg
[0], psz_arg
[1],
1280 psz_arg
[2], psz_arg
[3] );
1281 int i_cat
= UNKNOWN_ES
;
1282 es_format_t
*fmt
= &pid
->es
->fmt
;
1284 if( !strcmp( psz_opt
, "video" ) )
1286 else if( !strcmp( psz_opt
, "audio" ) )
1288 else if( !strcmp( psz_opt
, "spu" ) )
1291 es_format_Init( fmt
, i_cat
, i_codec
);
1292 fmt
->b_packetized
= false;
1296 const int i_stream_type
= strtol( psz_opt
, NULL
, 0 );
1297 PIDFillFormat( pid
->es
, i_stream_type
);
1299 pid
->es
->fmt
.i_group
= i_number
;
1300 if( p_sys
->b_es_id_pid
)
1301 pid
->es
->fmt
.i_id
= i_pid
;
1303 if( pid
->es
->fmt
.i_cat
!= UNKNOWN_ES
)
1305 msg_Dbg( p_demux
, " * es pid=%d fcc=%4.4s", i_pid
,
1306 (char*)&pid
->es
->fmt
.i_codec
);
1307 pid
->es
->id
= es_out_Add( p_demux
->out
,
1317 p_sys
->b_user_pmt
= true;
1318 TAB_APPEND( p_sys
->i_pmt
, p_sys
->pmt
, pmt
);
1325 return VLC_EGENERIC
;
1328 static int SetPIDFilter( demux_t
*p_demux
, int i_pid
, bool b_selected
)
1330 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1332 if( !p_sys
->b_access_control
)
1333 return VLC_EGENERIC
;
1335 return stream_Control( p_demux
->s
, STREAM_SET_PRIVATE_ID_STATE
,
1336 i_pid
, b_selected
);
1339 static void SetPrgFilter( demux_t
*p_demux
, int i_prg_id
, bool b_selected
)
1341 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1342 ts_prg_psi_t
*p_prg
= NULL
;
1345 /* Search pmt to be unselected */
1346 for( int i
= 0; i
< p_sys
->i_pmt
; i
++ )
1348 ts_pid_t
*pmt
= p_sys
->pmt
[i
];
1350 for( int i_prg
= 0; i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
1352 if( pmt
->psi
->prg
[i_prg
]->i_number
== i_prg_id
)
1354 i_pmt_pid
= p_sys
->pmt
[i
]->i_pid
;
1355 p_prg
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
];
1362 if( i_pmt_pid
<= 0 )
1366 SetPIDFilter( p_demux
, i_pmt_pid
, b_selected
);
1367 if( p_prg
->i_pid_pcr
> 0 )
1368 SetPIDFilter( p_demux
, p_prg
->i_pid_pcr
, b_selected
);
1371 for( int i
= 2; i
< 8192; i
++ )
1373 ts_pid_t
*pid
= &p_sys
->pid
[i
];
1375 if( !pid
->b_valid
|| pid
->psi
)
1378 for( int i_prg
= 0; i_prg
< pid
->p_owner
->i_prg
; i_prg
++ )
1380 if( pid
->p_owner
->prg
[i_prg
]->i_pid_pmt
== i_pmt_pid
&& pid
->es
->id
)
1382 /* We only remove/select es that aren't defined by extra pmt */
1383 SetPIDFilter( p_demux
, i
, b_selected
);
1390 static void PIDInit( ts_pid_t
*pid
, bool b_psi
, ts_psi_t
*p_owner
)
1392 bool b_old_valid
= pid
->b_valid
;
1394 pid
->b_valid
= true;
1396 pid
->b_scrambled
= false;
1397 pid
->p_owner
= p_owner
;
1398 pid
->i_owner_number
= 0;
1400 TAB_INIT( pid
->i_extra_es
, pid
->extra_es
);
1408 pid
->psi
= xmalloc( sizeof( ts_psi_t
) );
1409 pid
->psi
->handle
= NULL
;
1410 TAB_INIT( pid
->psi
->i_prg
, pid
->psi
->prg
);
1414 pid
->psi
->i_pat_version
= -1;
1415 pid
->psi
->i_sdt_version
= -1;
1418 ts_prg_psi_t
*prg
= malloc( sizeof( ts_prg_psi_t
) );
1422 prg
->i_version
= -1;
1424 prg
->i_pid_pcr
= -1;
1425 prg
->i_pid_pmt
= -1;
1426 prg
->i_pcr_value
= -1;
1430 TAB_APPEND( pid
->psi
->i_prg
, pid
->psi
->prg
, prg
);
1436 pid
->es
= calloc( 1, sizeof( ts_es_t
) );
1440 es_format_Init( &pid
->es
->fmt
, UNKNOWN_ES
, 0 );
1441 pid
->es
->data_type
= TS_ES_DATA_PES
;
1442 pid
->es
->pp_last
= &pid
->es
->p_data
;
1446 static void PIDClean( demux_t
*p_demux
, ts_pid_t
*pid
)
1448 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1449 es_out_t
*out
= p_demux
->out
;
1453 if( pid
->psi
->handle
)
1455 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1456 if( dvbpsi_decoder_present( pid
->psi
->handle
) )
1457 dvbpsi_pmt_detach( pid
->psi
->handle
);
1458 dvbpsi_delete( pid
->psi
->handle
);
1459 pid
->psi
->handle
= NULL
;
1461 dvbpsi_DetachPMT( pid
->psi
->handle
);
1464 for( int i
= 0; i
< pid
->psi
->i_prg
; i
++ )
1466 if( pid
->psi
->prg
[i
]->iod
)
1467 IODFree( pid
->psi
->prg
[i
]->iod
);
1468 if( pid
->psi
->prg
[i
]->handle
)
1470 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1471 if( dvbpsi_decoder_present( pid
->psi
->prg
[i
]->handle
) )
1472 dvbpsi_pmt_detach( pid
->psi
->prg
[i
]->handle
);
1473 dvbpsi_delete( pid
->psi
->prg
[i
]->handle
);
1475 dvbpsi_DetachPMT( pid
->psi
->prg
[i
]->handle
);
1478 free( pid
->psi
->prg
[i
] );
1480 free( pid
->psi
->prg
);
1487 es_out_Del( out
, pid
->es
->id
);
1491 if( pid
->es
->p_data
)
1492 block_ChainRelease( pid
->es
->p_data
);
1494 es_format_Clean( &pid
->es
->fmt
);
1498 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
1500 if( pid
->extra_es
[i
]->id
)
1502 es_out_Del( out
, pid
->extra_es
[i
]->id
);
1506 if( pid
->extra_es
[i
]->p_data
)
1507 block_ChainRelease( pid
->extra_es
[i
]->p_data
);
1509 es_format_Clean( &pid
->extra_es
[i
]->fmt
);
1511 free( pid
->extra_es
[i
] );
1513 if( pid
->i_extra_es
)
1514 free( pid
->extra_es
);
1517 pid
->b_valid
= false;
1520 /****************************************************************************
1522 ****************************************************************************/
1523 static void ParsePES( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_pes
)
1525 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1527 unsigned i_pes_size
= 0;
1528 unsigned i_skip
= 0;
1531 mtime_t i_length
= 0;
1533 /* FIXME find real max size */
1534 /* const int i_max = */ block_ChainExtract( p_pes
, header
, 34 );
1536 if( header
[0] != 0 || header
[1] != 0 || header
[2] != 1 )
1538 msg_Warn( p_demux
, "invalid header [0x%02x:%02x:%02x:%02x] (pid: %d)",
1539 header
[0], header
[1],header
[2],header
[3], pid
->i_pid
);
1540 block_ChainRelease( p_pes
);
1544 /* TODO check size */
1547 case 0xBC: /* Program stream map */
1548 case 0xBE: /* Padding */
1549 case 0xBF: /* Private stream 2 */
1550 case 0xF0: /* ECM */
1551 case 0xF1: /* EMM */
1552 case 0xFF: /* Program stream directory */
1553 case 0xF2: /* DSMCC stream */
1554 case 0xF8: /* ITU-T H.222.1 type E stream */
1558 if( ( header
[6]&0xC0 ) == 0x80 )
1561 i_skip
= header
[8] + 9;
1563 if( header
[7]&0x80 ) /* has pts */
1565 i_pts
= ((mtime_t
)(header
[ 9]&0x0e ) << 29)|
1566 (mtime_t
)(header
[10] << 22)|
1567 ((mtime_t
)(header
[11]&0xfe) << 14)|
1568 (mtime_t
)(header
[12] << 7)|
1569 (mtime_t
)(header
[13] >> 1);
1571 if( header
[7]&0x40 ) /* has dts */
1573 i_dts
= ((mtime_t
)(header
[14]&0x0e ) << 29)|
1574 (mtime_t
)(header
[15] << 22)|
1575 ((mtime_t
)(header
[16]&0xfe) << 14)|
1576 (mtime_t
)(header
[17] << 7)|
1577 (mtime_t
)(header
[18] >> 1);
1584 while( i_skip
< 23 && header
[i_skip
] == 0xff )
1590 msg_Err( p_demux
, "too much MPEG-1 stuffing" );
1591 block_ChainRelease( p_pes
);
1594 if( ( header
[i_skip
] & 0xC0 ) == 0x40 )
1599 if( header
[i_skip
]&0x20 )
1601 i_pts
= ((mtime_t
)(header
[i_skip
]&0x0e ) << 29)|
1602 (mtime_t
)(header
[i_skip
+1] << 22)|
1603 ((mtime_t
)(header
[i_skip
+2]&0xfe) << 14)|
1604 (mtime_t
)(header
[i_skip
+3] << 7)|
1605 (mtime_t
)(header
[i_skip
+4] >> 1);
1607 if( header
[i_skip
]&0x10 ) /* has dts */
1609 i_dts
= ((mtime_t
)(header
[i_skip
+5]&0x0e ) << 29)|
1610 (mtime_t
)(header
[i_skip
+6] << 22)|
1611 ((mtime_t
)(header
[i_skip
+7]&0xfe) << 14)|
1612 (mtime_t
)(header
[i_skip
+8] << 7)|
1613 (mtime_t
)(header
[i_skip
+9] >> 1);
1629 if( pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'a', '5', '2', 'b' ) ||
1630 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'd', 't', 's', 'b' ) )
1634 else if( pid
->es
->fmt
.i_codec
== VLC_FOURCC( 'l', 'p', 'c', 'b' ) ||
1635 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 's', 'p', 'u', 'b' ) ||
1636 pid
->es
->fmt
.i_codec
== VLC_FOURCC( 's', 'd', 'd', 'b' ) )
1640 else if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SUBT
&&
1641 pid
->es
->p_mpeg4desc
)
1643 decoder_config_descriptor_t
*dcd
= &pid
->es
->p_mpeg4desc
->dec_descr
;
1645 if( dcd
->i_extra
> 2 &&
1646 dcd
->p_extra
[0] == 0x10 &&
1647 ( dcd
->p_extra
[1]&0x10 ) )
1649 /* display length */
1650 if( p_pes
->i_buffer
+ 2 <= i_skip
)
1651 i_length
= GetWBE( &p_pes
->p_buffer
[i_skip
] );
1655 if( p_pes
->i_buffer
+ 2 <= i_skip
)
1656 i_pes_size
= GetWBE( &p_pes
->p_buffer
[i_skip
] );
1662 while( p_pes
&& i_skip
> 0 )
1664 if( p_pes
->i_buffer
<= i_skip
)
1666 block_t
*p_next
= p_pes
->p_next
;
1668 i_skip
-= p_pes
->i_buffer
;
1669 block_Release( p_pes
);
1674 p_pes
->i_buffer
-= i_skip
;
1675 p_pes
->p_buffer
+= i_skip
;
1680 /* ISO/IEC 13818-1 2.7.5: if no pts and no dts, then dts == pts */
1681 if( i_pts
>= 0 && i_dts
< 0 )
1689 p_pes
->i_dts
= VLC_TS_0
+ i_dts
* 100 / 9;
1692 p_pes
->i_pts
= VLC_TS_0
+ i_pts
* 100 / 9;
1694 p_pes
->i_length
= i_length
* 100 / 9;
1696 p_block
= block_ChainGather( p_pes
);
1697 if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SUBT
)
1699 if( i_pes_size
> 0 && p_block
->i_buffer
> i_pes_size
)
1701 p_block
->i_buffer
= i_pes_size
;
1704 p_block
= block_Realloc( p_block
, 0, p_block
->i_buffer
+ 1 );
1707 p_block
->p_buffer
[p_block
->i_buffer
-1] = '\0';
1709 else if( pid
->es
->fmt
.i_codec
== VLC_CODEC_TELETEXT
)
1711 if( p_block
->i_pts
<= VLC_TS_INVALID
)
1713 /* Teletext may have missing PTS (ETSI EN 300 472 Annexe A)
1714 * In this case use the last PCR + 40ms */
1715 for( int i
= 0; pid
->p_owner
&& i
< pid
->p_owner
->i_prg
; i
++ )
1717 if( pid
->i_owner_number
== pid
->p_owner
->prg
[i
]->i_number
)
1719 mtime_t i_pcr
= pid
->p_owner
->prg
[i
]->i_pcr_value
;
1720 if( i_pcr
> VLC_TS_INVALID
)
1721 p_block
->i_pts
= VLC_TS_0
+ i_pcr
* 100 / 9 + 40000;
1728 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
1730 es_out_Send( p_demux
->out
, pid
->extra_es
[i
]->id
,
1731 block_Duplicate( p_block
) );
1734 if (!p_sys
->b_trust_pcr
)
1735 es_out_Control( p_demux
->out
, ES_OUT_SET_PCR
, p_block
->i_pts
);
1737 es_out_Send( p_demux
->out
, pid
->es
->id
, p_block
);
1741 msg_Warn( p_demux
, "empty pes" );
1745 static void ParseTableSection( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_data
)
1747 block_t
*p_content
= block_ChainGather( p_data
);
1748 mtime_t i_date
= -1;
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 i_date
= pid
->p_owner
->prg
[i
]->i_pcr_value
;
1760 if( pid
->es
->fmt
.i_codec
== VLC_CODEC_SCTE_27
)
1762 /* We need to extract the truncated pts stored inside the payload */
1763 if( p_content
->i_buffer
> 9 && p_content
->p_buffer
[0] == 0xc6 )
1767 if( p_content
->p_buffer
[3] & 0x40 )
1769 i_index
= ((p_content
->p_buffer
[7] & 0x0f) << 8) |
1770 p_content
->p_buffer
[8];
1773 if( i_index
== 0 && p_content
->i_buffer
> i_offset
+ 8 )
1775 bool is_immediate
= p_content
->p_buffer
[i_offset
+ 3] & 0x40;
1778 mtime_t i_display_in
= GetDWBE( &p_content
->p_buffer
[i_offset
+ 4] );
1779 if( i_display_in
< i_date
)
1780 i_date
= i_display_in
+ (1ll << 32);
1782 i_date
= i_display_in
;
1789 p_content
->i_pts
= VLC_TS_0
+ i_date
* 100 / 9;
1791 es_out_Send( p_demux
->out
, pid
->es
->id
, p_content
);
1793 static void ParseData( demux_t
*p_demux
, ts_pid_t
*pid
)
1795 block_t
*p_data
= pid
->es
->p_data
;
1797 /* remove the pes from pid */
1798 pid
->es
->p_data
= NULL
;
1799 pid
->es
->i_data_size
= 0;
1800 pid
->es
->i_data_gathered
= 0;
1801 pid
->es
->pp_last
= &pid
->es
->p_data
;
1803 if( pid
->es
->data_type
== TS_ES_DATA_PES
)
1805 ParsePES( p_demux
, pid
, p_data
);
1807 else if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
)
1809 ParseTableSection( p_demux
, pid
, p_data
);
1813 block_ChainRelease( p_data
);
1817 static block_t
* ReadTSPacket( demux_t
*p_demux
)
1819 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1823 /* Get a new TS packet */
1824 if( !( p_pkt
= stream_Block( p_demux
->s
, p_sys
->i_packet_size
) ) )
1826 msg_Dbg( p_demux
, "eof ?" );
1830 /* Skip header (BluRay streams).
1831 * re-sync logic would do this (by adjusting packet start), but this would result in losing first and last ts packets.
1832 * First packet is usually PAT, and losing it means losing whole first GOP. This is fatal with still-image based menus.
1834 p_pkt
->p_buffer
+= p_sys
->i_packet_header_size
;
1835 p_pkt
->i_buffer
-= p_sys
->i_packet_header_size
;
1837 /* Check sync byte and re-sync if needed */
1838 if( p_pkt
->p_buffer
[0] != 0x47 )
1840 msg_Warn( p_demux
, "lost synchro" );
1841 block_Release( p_pkt
);
1842 while( vlc_object_alive (p_demux
) )
1844 const uint8_t *p_peek
;
1845 int i_peek
, i_skip
= 0;
1847 i_peek
= stream_Peek( p_demux
->s
, &p_peek
,
1848 p_sys
->i_packet_size
* 10 );
1849 if( i_peek
< p_sys
->i_packet_size
+ 1 )
1851 msg_Dbg( p_demux
, "eof ?" );
1855 while( i_skip
< i_peek
- p_sys
->i_packet_size
)
1857 if( p_peek
[i_skip
+ p_sys
->i_packet_header_size
] == 0x47 &&
1858 p_peek
[i_skip
+ p_sys
->i_packet_header_size
+ p_sys
->i_packet_size
] == 0x47 )
1864 msg_Dbg( p_demux
, "skipping %d bytes of garbage", i_skip
);
1865 stream_Read( p_demux
->s
, NULL
, i_skip
);
1867 if( i_skip
< i_peek
- p_sys
->i_packet_size
)
1872 if( !( p_pkt
= stream_Block( p_demux
->s
, p_sys
->i_packet_size
) ) )
1874 msg_Dbg( p_demux
, "eof ?" );
1881 static mtime_t
AdjustPCRWrapAround( demux_t
*p_demux
, mtime_t i_pcr
)
1883 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1885 * PCR is 33bit. If PCR reaches to 0x1FFFFFFFF (26:30:43.717), ressets from 0.
1886 * So, need to add 0x1FFFFFFFF, for calculating duration or current position.
1888 mtime_t i_adjust
= 0;
1889 int64_t i_pos
= stream_Tell( p_demux
->s
);
1891 for( i
= 1; i
< p_sys
->i_pcrs_num
&& p_sys
->p_pos
[i
] <= i_pos
; ++i
)
1893 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
1894 i_adjust
+= 0x1FFFFFFFF;
1896 if( p_sys
->p_pcrs
[i
-1] > i_pcr
)
1897 i_adjust
+= 0x1FFFFFFFF;
1899 return i_pcr
+ i_adjust
;
1902 static mtime_t
GetPCR( block_t
*p_pkt
)
1904 const uint8_t *p
= p_pkt
->p_buffer
;
1908 if( ( p
[3]&0x20 ) && /* adaptation */
1912 /* PCR is 33 bits */
1913 i_pcr
= ( (mtime_t
)p
[6] << 25 ) |
1914 ( (mtime_t
)p
[7] << 17 ) |
1915 ( (mtime_t
)p
[8] << 9 ) |
1916 ( (mtime_t
)p
[9] << 1 ) |
1917 ( (mtime_t
)p
[10] >> 7 );
1922 static int SeekToPCR( demux_t
*p_demux
, int64_t i_pos
)
1924 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1927 const int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
1930 return VLC_EGENERIC
;
1932 int64_t i_last_pos
= stream_Size( p_demux
->s
) - p_sys
->i_packet_size
;
1933 if( i_pos
> i_last_pos
)
1936 if( stream_Seek( p_demux
->s
, i_pos
) )
1937 return VLC_EGENERIC
;
1939 while( vlc_object_alive( p_demux
) )
1943 if( !( p_pkt
= ReadTSPacket( p_demux
) ) )
1947 if( PIDGet( p_pkt
) == p_sys
->i_pid_ref_pcr
)
1949 i_pcr
= GetPCR( p_pkt
);
1951 block_Release( p_pkt
);
1954 if( stream_Tell( p_demux
->s
) >= i_last_pos
)
1959 stream_Seek( p_demux
->s
, i_initial_pos
);
1960 assert( i_initial_pos
== stream_Tell( p_demux
->s
) );
1961 return VLC_EGENERIC
;
1964 p_sys
->i_current_pcr
= i_pcr
;
1968 static int Seek( demux_t
*p_demux
, double f_percent
)
1970 demux_sys_t
*p_sys
= p_demux
->p_sys
;
1972 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
1973 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
1976 * Find the time position by using binary search algorithm.
1978 mtime_t i_target_pcr
= (p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * f_percent
+ p_sys
->i_first_pcr
;
1980 int64_t i_head_pos
= 0;
1983 mtime_t i_adjust
= 0;
1985 for( i
= 1; i
< p_sys
->i_pcrs_num
; ++i
)
1987 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
1988 i_adjust
+= 0x1FFFFFFFF;
1989 if( p_sys
->p_pcrs
[i
] + i_adjust
> i_target_pcr
)
1992 i_head_pos
= p_sys
->p_pos
[i
-1];
1993 i_tail_pos
= ( i
< p_sys
->i_pcrs_num
) ? p_sys
->p_pos
[i
] : stream_Size( p_demux
->s
);
1995 msg_Dbg( p_demux
, "Seek():i_head_pos:%"PRId64
", i_tail_pos:%"PRId64
, i_head_pos
, i_tail_pos
);
1997 bool b_found
= false;
1999 while( i_head_pos
<= i_tail_pos
)
2001 /* Round i_pos to a multiple of p_sys->i_packet_size */
2002 int64_t i_pos
= i_head_pos
+ (i_tail_pos
- i_head_pos
) / 2;
2003 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2005 if( SeekToPCR( p_demux
, i_pos
) )
2007 p_sys
->i_current_pcr
= AdjustPCRWrapAround( p_demux
, p_sys
->i_current_pcr
);
2008 int64_t i_diff_msec
= (p_sys
->i_current_pcr
- i_target_pcr
) * 100 / 9 / 1000;
2009 if( i_diff_msec
> 500 )
2011 i_tail_pos
= i_pos
- p_sys
->i_packet_size
;
2013 else if( i_diff_msec
< -500 )
2015 i_head_pos
= i_pos
+ p_sys
->i_packet_size
;
2019 // diff time <= 500msec
2027 msg_Dbg( p_demux
, "Seek():cannot find a time position. i_cnt:%d", i_cnt
);
2028 stream_Seek( p_demux
->s
, i_initial_pos
);
2029 p_sys
->i_current_pcr
= i_initial_pcr
;
2030 return VLC_EGENERIC
;
2034 msg_Dbg( p_demux
, "Seek():can find a time position. i_cnt:%d", i_cnt
);
2039 static void GetFirstPCR( demux_t
*p_demux
)
2041 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2043 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2045 if( stream_Seek( p_demux
->s
, 0 ) )
2048 while( vlc_object_alive (p_demux
) )
2052 if( !( p_pkt
= ReadTSPacket( p_demux
) ) )
2056 mtime_t i_pcr
= GetPCR( p_pkt
);
2059 p_sys
->i_pid_ref_pcr
= PIDGet( p_pkt
);
2060 p_sys
->i_first_pcr
= i_pcr
;
2061 p_sys
->i_current_pcr
= i_pcr
;
2063 block_Release( p_pkt
);
2064 if( p_sys
->i_first_pcr
>= 0 )
2067 stream_Seek( p_demux
->s
, i_initial_pos
);
2070 static void GetLastPCR( demux_t
*p_demux
)
2072 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2074 const int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2075 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
2077 int64_t i_stream_size
= stream_Size( p_demux
->s
);
2078 int64_t i_last_pos
= i_stream_size
- p_sys
->i_packet_size
;
2079 /* Round i_pos to a multiple of p_sys->i_packet_size */
2080 int64_t i_pos
= i_last_pos
- p_sys
->i_packet_size
* 4500; /* FIXME if the value is not reasonable, please change it. */
2081 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2084 if( i_pos
<= i_initial_pos
&& i_pos
>= i_stream_size
)
2085 i_pos
= i_initial_pos
+ p_sys
->i_packet_size
;
2086 if( i_pos
< 0 && i_pos
>= i_stream_size
)
2089 while( vlc_object_alive( p_demux
) )
2091 if( SeekToPCR( p_demux
, i_pos
) )
2093 p_sys
->i_last_pcr
= AdjustPCRWrapAround( p_demux
, p_sys
->i_current_pcr
);
2094 if( ( i_pos
= stream_Tell( p_demux
->s
) ) >= i_last_pos
)
2097 if( p_sys
->i_last_pcr
>= 0 )
2099 int64_t i_size
= stream_Size( p_demux
->s
);
2100 mtime_t i_duration_msec
= ( p_sys
->i_last_pcr
- p_sys
->i_first_pcr
) * 100 / 9 / 1000;
2101 int64_t i_rate
= ( i_size
< 0 || i_duration_msec
<= 0 ) ? 0 : i_size
* 1000 * 8 / i_duration_msec
;
2102 const int64_t TS_SUPPOSED_MAXRATE
= 55 * 1000 * 1000; //FIXME I think it's enough.
2103 const int64_t TS_SUPPOSED_MINRATE
= 0.5 * 1000 * 1000; //FIXME
2104 if( i_rate
< TS_SUPPOSED_MINRATE
|| i_rate
> TS_SUPPOSED_MAXRATE
)
2106 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)",
2107 i_rate
, TS_SUPPOSED_MINRATE
, TS_SUPPOSED_MAXRATE
);
2108 p_sys
->i_last_pcr
= -1;
2111 stream_Seek( p_demux
->s
, i_initial_pos
);
2112 assert( i_initial_pos
== stream_Tell( p_demux
->s
) );
2113 p_sys
->i_current_pcr
= i_initial_pcr
;
2116 static void CheckPCR( demux_t
*p_demux
)
2118 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2120 int64_t i_initial_pos
= stream_Tell( p_demux
->s
);
2121 mtime_t i_initial_pcr
= p_sys
->i_current_pcr
;
2123 int64_t i_size
= stream_Size( p_demux
->s
);
2126 p_sys
->p_pcrs
[0] = p_sys
->i_first_pcr
;
2127 p_sys
->p_pos
[0] = i_initial_pos
;
2129 for( i
= 1; i
< p_sys
->i_pcrs_num
&& vlc_object_alive( p_demux
); ++i
)
2131 /* Round i_pos to a multiple of p_sys->i_packet_size */
2132 int64_t i_pos
= i_size
/ p_sys
->i_pcrs_num
* i
;
2133 int64_t i_div
= i_pos
% p_sys
->i_packet_size
;
2135 if( SeekToPCR( p_demux
, i_pos
) )
2137 p_sys
->p_pcrs
[i
] = p_sys
->i_current_pcr
;
2138 p_sys
->p_pos
[i
] = stream_Tell( p_demux
->s
);
2139 if( p_sys
->p_pcrs
[i
-1] > p_sys
->p_pcrs
[i
] )
2141 msg_Dbg( p_demux
, "PCR Wrap Around found between %d%% and %d%% (pcr:%"PRId64
"(0x%09"PRIx64
") pcr:%"PRId64
"(0x%09"PRIx64
"))",
2142 (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
] );
2145 if( i
< p_sys
->i_pcrs_num
)
2147 msg_Dbg( p_demux
, "Force Seek Per Percent: Seeking failed at %d%%.", (int)(i
*100/p_sys
->i_pcrs_num
) );
2148 p_sys
->b_force_seek_per_percent
= true;
2151 stream_Seek( p_demux
->s
, i_initial_pos
);
2152 p_sys
->i_current_pcr
= i_initial_pcr
;
2155 static void PCRHandle( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
)
2157 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2159 if( p_sys
->i_pmt_es
<= 0 )
2162 mtime_t i_pcr
= GetPCR( p_bk
);
2166 if( p_sys
->i_pid_ref_pcr
== pid
->i_pid
)
2167 p_sys
->i_current_pcr
= AdjustPCRWrapAround( p_demux
, i_pcr
);
2169 /* Search program and set the PCR */
2170 for( int i
= 0; i
< p_sys
->i_pmt
; i
++ )
2171 for( int i_prg
= 0; i_prg
< p_sys
->pmt
[i
]->psi
->i_prg
; i_prg
++ )
2172 if( pid
->i_pid
== p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_pid_pcr
)
2174 p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_pcr_value
= i_pcr
;
2175 if (p_sys
->b_trust_pcr
)
2176 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_PCR
,
2177 (int)p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_number
,
2178 (int64_t)(VLC_TS_0
+ i_pcr
* 100 / 9) );
2182 static bool GatherData( demux_t
*p_demux
, ts_pid_t
*pid
, block_t
*p_bk
)
2184 const uint8_t *p
= p_bk
->p_buffer
;
2185 const bool b_unit_start
= p
[1]&0x40;
2186 const bool b_scrambled
= p
[3]&0x80;
2187 const bool b_adaptation
= p
[3]&0x20;
2188 const bool b_payload
= p
[3]&0x10;
2189 const int i_cc
= p
[3]&0x0f; /* continuity counter */
2190 bool b_discontinuity
= false; /* discontinuity */
2192 /* transport_scrambling_control is ignored */
2197 msg_Dbg( p_demux
, "pid=%d unit_start=%d adaptation=%d payload=%d "
2198 "cc=0x%x", pid
->i_pid
, b_unit_start
, b_adaptation
,
2202 /* For now, ignore additional error correction
2203 * TODO: handle Reed-Solomon 204,188 error correction */
2204 p_bk
->i_buffer
= TS_PACKET_SIZE_188
;
2208 msg_Dbg( p_demux
, "transport_error_indicator set (pid=%d)",
2210 if( pid
->es
->p_data
) //&& pid->es->fmt.i_cat == VIDEO_ES )
2211 pid
->es
->p_data
->i_flags
|= BLOCK_FLAG_CORRUPTED
;
2214 if( p_demux
->p_sys
->csa
)
2216 vlc_mutex_lock( &p_demux
->p_sys
->csa_lock
);
2217 csa_Decrypt( p_demux
->p_sys
->csa
, p_bk
->p_buffer
, p_demux
->p_sys
->i_csa_pkt_size
);
2218 vlc_mutex_unlock( &p_demux
->p_sys
->csa_lock
);
2223 /* We don't have any adaptation_field, so payload starts
2224 * immediately after the 4 byte TS header */
2229 /* p[4] is adaptation_field_length minus one */
2233 /* discontinuity indicator found in stream */
2234 b_discontinuity
= (p
[5]&0x80) ? true : false;
2235 if( b_discontinuity
&& pid
->es
->p_data
)
2237 msg_Warn( p_demux
, "discontinuity indicator (pid=%d) ",
2239 /* pid->es->p_data->i_flags |= BLOCK_FLAG_DISCONTINUITY; */
2243 msg_Dbg( p_demux
, "random access indicator (pid=%d) ", pid
->i_pid
);
2248 /* Test continuity counter */
2249 /* continuous when (one of this):
2251 * diff == 0 and payload == 0
2252 * diff == 0 and duplicate packet (playload != 0) <- should we
2253 * test the content ?
2255 const int i_diff
= ( i_cc
- pid
->i_cc
)&0x0f;
2256 if( b_payload
&& i_diff
== 1 )
2258 pid
->i_cc
= ( pid
->i_cc
+ 1 ) & 0xf;
2262 if( pid
->i_cc
== 0xff )
2264 msg_Warn( p_demux
, "first packet for pid=%d cc=0x%x",
2268 else if( i_diff
!= 0 && !b_discontinuity
)
2270 msg_Warn( p_demux
, "discontinuity received 0x%x instead of 0x%x (pid=%d)",
2271 i_cc
, ( pid
->i_cc
+ 1 )&0x0f, pid
->i_pid
);
2274 if( pid
->es
->p_data
&& pid
->es
->fmt
.i_cat
!= VIDEO_ES
)
2276 /* Small video artifacts are usually better than
2277 * dropping full frames */
2278 pid
->es
->p_data
->i_flags
|= BLOCK_FLAG_CORRUPTED
;
2283 PCRHandle( p_demux
, pid
, p_bk
);
2285 if( i_skip
>= 188 || pid
->es
->id
== NULL
)
2287 block_Release( p_bk
);
2292 if( !pid
->b_scrambled
!= !b_scrambled
)
2294 msg_Warn( p_demux
, "scrambled state changed on pid %d (%d->%d)",
2295 pid
->i_pid
, pid
->b_scrambled
, b_scrambled
);
2297 pid
->b_scrambled
= b_scrambled
;
2299 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
2301 es_out_Control( p_demux
->out
, ES_OUT_SET_ES_SCRAMBLED_STATE
,
2302 pid
->extra_es
[i
]->id
, b_scrambled
);
2304 es_out_Control( p_demux
->out
, ES_OUT_SET_ES_SCRAMBLED_STATE
,
2305 pid
->es
->id
, b_scrambled
);
2308 /* We have to gather it */
2309 p_bk
->p_buffer
+= i_skip
;
2310 p_bk
->i_buffer
-= i_skip
;
2314 if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
&& p_bk
->i_buffer
> 0 )
2316 int i_pointer_field
= __MIN( p_bk
->p_buffer
[0], p_bk
->i_buffer
- 1 );
2317 block_t
*p
= block_Duplicate( p_bk
);
2320 p
->i_buffer
= i_pointer_field
;
2322 block_ChainLastAppend( &pid
->es
->pp_last
, p
);
2324 p_bk
->i_buffer
-= 1 + i_pointer_field
;
2325 p_bk
->p_buffer
+= 1 + i_pointer_field
;
2327 if( pid
->es
->p_data
)
2329 ParseData( p_demux
, pid
);
2333 block_ChainLastAppend( &pid
->es
->pp_last
, p_bk
);
2334 if( pid
->es
->data_type
== TS_ES_DATA_PES
)
2336 if( p_bk
->i_buffer
> 6 )
2338 pid
->es
->i_data_size
= GetWBE( &p_bk
->p_buffer
[4] );
2339 if( pid
->es
->i_data_size
> 0 )
2341 pid
->es
->i_data_size
+= 6;
2345 else if( pid
->es
->data_type
== TS_ES_DATA_TABLE_SECTION
)
2347 if( p_bk
->i_buffer
> 3 && p_bk
->p_buffer
[0] != 0xff )
2349 pid
->es
->i_data_size
= 3 + (((p_bk
->p_buffer
[1] & 0xf) << 8) | p_bk
->p_buffer
[2]);
2352 pid
->es
->i_data_gathered
+= p_bk
->i_buffer
;
2353 if( pid
->es
->i_data_size
> 0 &&
2354 pid
->es
->i_data_gathered
>= pid
->es
->i_data_size
)
2356 ParseData( p_demux
, pid
);
2362 if( pid
->es
->p_data
== NULL
)
2364 /* msg_Dbg( p_demux, "broken packet" ); */
2365 block_Release( p_bk
);
2369 block_ChainLastAppend( &pid
->es
->pp_last
, p_bk
);
2370 pid
->es
->i_data_gathered
+= p_bk
->i_buffer
;
2372 if( pid
->es
->i_data_size
> 0 &&
2373 pid
->es
->i_data_gathered
>= pid
->es
->i_data_size
)
2375 ParseData( p_demux
, pid
);
2384 static void PIDFillFormat( const ts_es_t
*es
, int i_stream_type
)
2386 es_format_t
*fmt
= &es
->fmt
;
2388 switch( i_stream_type
)
2390 case 0x01: /* MPEG-1 video */
2391 case 0x02: /* MPEG-2 video */
2392 case 0x80: /* MPEG-2 MOTO video */
2393 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_MPGV
);
2395 case 0x03: /* MPEG-1 audio */
2396 case 0x04: /* MPEG-2 audio */
2397 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_MPGA
);
2399 case 0x11: /* MPEG4 (audio) LATM */
2400 case 0x0f: /* ISO/IEC 13818-7 Audio with ADTS transport syntax */
2401 case 0x1c: /* ISO/IEC 14496-3 Audio, without using any additional
2402 transport syntax, such as DST, ALS and SLS */
2403 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_MP4A
);
2405 case 0x10: /* MPEG4 (video) */
2406 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_MP4V
);
2408 case 0x1B: /* H264 <- check transport syntax/needed descriptor */
2409 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_H264
);
2411 case 0x24: /* HEVC */
2412 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_HEVC
);
2414 case 0x42: /* CAVS (Chinese AVS) */
2415 es_format_Init( fmt
, VIDEO_ES
, VLC_CODEC_CAVS
);
2418 case 0x81: /* A52 (audio) */
2419 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_A52
);
2421 case 0x82: /* SCTE-27 (sub) */
2422 es_format_Init( fmt
, SPU_ES
, VLC_CODEC_SCTE_27
);
2424 case 0x84: /* SDDS (audio) */
2425 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_SDDS
);
2427 case 0x85: /* DTS (audio) */
2428 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_DTS
);
2430 case 0x87: /* E-AC3 */
2431 es_format_Init( fmt
, AUDIO_ES
, VLC_CODEC_EAC3
);
2434 case 0x91: /* A52 vls (audio) */
2435 es_format_Init( fmt
, AUDIO_ES
, VLC_FOURCC( 'a', '5', '2', 'b' ) );
2437 case 0x92: /* DVD_SPU vls (sub) */
2438 es_format_Init( fmt
, SPU_ES
, VLC_FOURCC( 's', 'p', 'u', 'b' ) );
2441 case 0x94: /* SDDS (audio) */
2442 es_format_Init( fmt
, AUDIO_ES
, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
2445 case 0xa0: /* MSCODEC vlc (video) (fixed later) */
2446 es_format_Init( fmt
, UNKNOWN_ES
, 0 );
2449 case 0x06: /* PES_PRIVATE (fixed later) */
2450 case 0x12: /* MPEG-4 generic (sub/scene/...) (fixed later) */
2451 case 0xEA: /* Privately managed ES (VC-1) (fixed later */
2453 es_format_Init( fmt
, UNKNOWN_ES
, 0 );
2457 /* PES packets usually contain truncated frames */
2458 fmt
->b_packetized
= false;
2461 /*****************************************************************************
2462 * MP4 specific functions (IOD parser)
2463 *****************************************************************************/
2464 static int IODDescriptorLength( int *pi_data
, uint8_t **pp_data
)
2467 unsigned int i_len
= 0;
2473 i_len
= ( i_len
<< 7 ) + ( i_b
&0x7f );
2475 } while( i_b
&0x80 && *pi_data
> 0 );
2477 if (i_len
> *pi_data
)
2483 static int IODGetBytes( int *pi_data
, uint8_t **pp_data
, size_t bytes
)
2486 while( *pi_data
> 0 && bytes
-- )
2497 static char* IODGetURL( int *pi_data
, uint8_t **pp_data
)
2499 int len
= IODGetBytes( pi_data
, pp_data
, 1 );
2502 char *url
= strndup( (char*)*pp_data
, len
);
2508 static iod_descriptor_t
*IODNew( int i_data
, uint8_t *p_data
)
2510 uint8_t i_iod_tag
, i_iod_label
, byte1
, byte2
, byte3
;
2512 iod_descriptor_t
*p_iod
= calloc( 1, sizeof( iod_descriptor_t
) );
2521 byte1
= IODGetBytes( &i_data
, &p_data
, 1 );
2522 byte2
= IODGetBytes( &i_data
, &p_data
, 1 );
2523 byte3
= IODGetBytes( &i_data
, &p_data
, 1 );
2524 if( byte2
== 0x02 ) //old vlc's buggy implementation of the IOD_descriptor
2526 i_iod_label
= byte1
;
2529 else //correct implementation of the IOD_descriptor
2531 i_iod_label
= byte2
;
2535 ts_debug( "\n* iod label:%d tag:0x%x", i_iod_label
, i_iod_tag
);
2537 if( i_iod_tag
!= 0x02 )
2539 ts_debug( "\n ERR: tag %02x != 0x02", i_iod_tag
);
2543 IODDescriptorLength( &i_data
, &p_data
);
2545 uint16_t i_od_id
= ( IODGetBytes( &i_data
, &p_data
, 1 ) << 2 );
2546 uint8_t i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2547 i_od_id
|= i_flags
>> 6;
2548 ts_debug( "\n* od_id:%d", i_od_id
);
2549 ts_debug( "\n* includeInlineProfileLevel flag:%d", ( i_flags
>> 4 )&0x01 );
2550 if ((i_flags
>> 5) & 0x01)
2552 p_iod
->psz_url
= IODGetURL( &i_data
, &p_data
);
2553 ts_debug( "\n* url string:%s", p_iod
->psz_url
);
2554 ts_debug( "\n*****************************\n" );
2559 p_iod
->psz_url
= NULL
;
2562 /* Profile Level Indication */
2563 IODGetBytes( &i_data
, &p_data
, 1 ); /* OD */
2564 IODGetBytes( &i_data
, &p_data
, 1 ); /* scene */
2565 IODGetBytes( &i_data
, &p_data
, 1 ); /* audio */
2566 IODGetBytes( &i_data
, &p_data
, 1 ); /* visual */
2567 IODGetBytes( &i_data
, &p_data
, 1 ); /* graphics */
2570 int i_data_sav
= i_data
;
2571 uint8_t *p_data_sav
= p_data
;
2572 for (int i
= 0; i_data
> 0 && i
< 255; i
++)
2574 es_mpeg4_descriptor_t
*es_descr
= &p_iod
->es_descr
[i
];
2576 p_data
= p_data_sav
+ i_length
;
2577 i_data
= i_data_sav
- i_length
;
2579 int i_tag
= IODGetBytes( &i_data
, &p_data
, 1 );
2580 i_length
= IODDescriptorLength( &i_data
, &p_data
);
2582 i_data_sav
= i_data
;
2583 p_data_sav
= p_data
;
2587 if ( i_tag
!= 0x03 )
2589 ts_debug( "\n* - OD tag:0x%x Unsupported", i_tag
);
2593 es_descr
->i_es_id
= IODGetBytes( &i_data
, &p_data
, 2 );
2594 int i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2595 bool b_streamDependenceFlag
= ( i_flags
>> 7 )&0x01;
2596 if( b_streamDependenceFlag
)
2597 IODGetBytes( &i_data
, &p_data
, 2 ); /* dependOn_es_id */
2599 if( (i_flags
>> 6) & 0x01 )
2600 es_descr
->psz_url
= IODGetURL( &i_data
, &p_data
);
2602 bool b_OCRStreamFlag
= ( i_flags
>> 5 )&0x01;
2603 if( b_OCRStreamFlag
)
2604 IODGetBytes( &i_data
, &p_data
, 2 ); /* OCR_es_id */
2606 if( IODGetBytes( &i_data
, &p_data
, 1 ) != 0x04 )
2608 ts_debug( "\n* ERR missing DecoderConfigDescr" );
2611 decoder_config_descriptor_t
*dec_descr
= &es_descr
->dec_descr
;
2612 dec_descr
->i_objectTypeIndication
= IODGetBytes( &i_data
, &p_data
, 1 );
2613 i_flags
= IODGetBytes( &i_data
, &p_data
, 1 );
2614 dec_descr
->i_streamType
= i_flags
>> 2;
2616 IODGetBytes( &i_data
, &p_data
, 3); /* bufferSizeDB */
2617 IODGetBytes( &i_data
, &p_data
, 4); /* maxBitrate */
2618 IODGetBytes( &i_data
, &p_data
, 4 ); /* avgBitrate */
2620 int i_decoderConfigDescr_length
= IODDescriptorLength( &i_data
, &p_data
);
2621 if( i_decoderConfigDescr_length
> 13 && IODGetBytes( &i_data
, &p_data
, 1 ) == 0x05 )
2623 dec_descr
->i_extra
= IODDescriptorLength( &i_data
, &p_data
);
2624 if( dec_descr
->i_extra
> 0 )
2626 dec_descr
->p_extra
= xmalloc( dec_descr
->i_extra
);
2627 memcpy(dec_descr
->p_extra
, p_data
, dec_descr
->i_extra
);
2628 p_data
+= dec_descr
->i_extra
;
2629 i_data
-= dec_descr
->i_extra
;
2634 dec_descr
->i_extra
= 0;
2635 dec_descr
->p_extra
= NULL
;
2638 if( IODGetBytes( &i_data
, &p_data
, 1 ) != 0x06 )
2640 ts_debug( "\n* ERR missing SLConfigDescr" );
2643 IODDescriptorLength( &i_data
, &p_data
); /* SLConfigDescr_length */
2644 switch( IODGetBytes( &i_data
, &p_data
, 1 ) /* predefined */ )
2647 ts_debug( "\n* ERR unsupported SLConfigDescr predefined" );
2652 es_descr
->b_ok
= true;
2658 static void IODFree( iod_descriptor_t
*p_iod
)
2660 if( p_iod
->psz_url
)
2662 free( p_iod
->psz_url
);
2667 for( int i
= 0; i
< 255; i
++ )
2669 #define es_descr p_iod->es_descr[i]
2672 if( es_descr
.psz_url
)
2673 free( es_descr
.psz_url
);
2675 free( es_descr
.dec_descr
.p_extra
);
2682 /****************************************************************************
2683 ****************************************************************************
2684 ** libdvbpsi callbacks
2685 ****************************************************************************
2686 ****************************************************************************/
2687 static bool ProgramIsSelected( demux_t
*p_demux
, uint16_t i_pgrm
)
2689 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2691 if( ( p_sys
->i_current_program
== -1 && p_sys
->programs_list
.i_count
== 0 ) ||
2692 p_sys
->i_current_program
== 0 )
2694 if( p_sys
->i_current_program
== i_pgrm
)
2697 if( p_sys
->programs_list
.i_count
!= 0 )
2699 for( int i
= 0; i
< p_sys
->programs_list
.i_count
; i
++ )
2701 if( i_pgrm
== p_sys
->programs_list
.p_values
[i
].i_int
)
2708 static void ValidateDVBMeta( demux_t
*p_demux
, int i_pid
)
2710 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2712 if( !p_sys
->b_dvb_meta
|| ( i_pid
!= 0x11 && i_pid
!= 0x12 && i_pid
!= 0x14 ) )
2715 msg_Warn( p_demux
, "Switching to non DVB mode" );
2717 /* This doesn't look like a DVB stream so don't try
2718 * parsing the SDT/EDT/TDT */
2720 for( int i
= 0x11; i
<= 0x14; i
++ )
2722 if( i
== 0x13 ) continue;
2723 ts_pid_t
*p_pid
= &p_sys
->pid
[i
];
2727 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
2728 if( dvbpsi_decoder_present( p_pid
->psi
->handle
))
2729 dvbpsi_DetachDemux( p_pid
->psi
->handle
);
2730 dvbpsi_delete( p_pid
->psi
->handle
);
2732 dvbpsi_DetachDemux( p_pid
->psi
->handle
);
2736 p_pid
->b_valid
= false;
2738 SetPIDFilter( p_demux
, i
, false );
2740 p_sys
->b_dvb_meta
= false;
2743 #include "dvb-text.h"
2745 static char *EITConvertToUTF8( const unsigned char *psz_instring
,
2749 /* Deal with no longer broken providers (no switch byte
2750 but sending ISO_8859-1 instead of ISO_6937) without
2751 removing them from the broken providers table
2752 (keep the entry for correctly handling recorded TS).
2754 b_broken
= b_broken
&& i_length
&& *psz_instring
> 0x20;
2757 return FromCharset( "ISO_8859-1", psz_instring
, i_length
);
2758 return vlc_from_EIT( psz_instring
, i_length
);
2761 static void SDTCallBack( demux_t
*p_demux
, dvbpsi_sdt_t
*p_sdt
)
2763 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2764 ts_pid_t
*sdt
= &p_sys
->pid
[0x11];
2765 dvbpsi_sdt_service_t
*p_srv
;
2767 msg_Dbg( p_demux
, "SDTCallBack called" );
2769 if( sdt
->psi
->i_sdt_version
!= -1 &&
2770 ( !p_sdt
->b_current_next
||
2771 p_sdt
->i_version
== sdt
->psi
->i_sdt_version
) )
2773 dvbpsi_DeleteSDT( p_sdt
);
2777 msg_Dbg( p_demux
, "new SDT ts_id=%d version=%d current_next=%d "
2779 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
2784 p_sdt
->i_version
, p_sdt
->b_current_next
,
2785 p_sdt
->i_network_id
);
2787 p_sys
->b_broken_charset
= false;
2789 for( p_srv
= p_sdt
->p_first_service
; p_srv
; p_srv
= p_srv
->p_next
)
2792 dvbpsi_descriptor_t
*p_dr
;
2794 const char *psz_type
= NULL
;
2795 const char *psz_status
= NULL
;
2797 msg_Dbg( p_demux
, " * service id=%d eit schedule=%d present=%d "
2798 "running=%d free_ca=%d",
2799 p_srv
->i_service_id
, p_srv
->b_eit_schedule
,
2800 p_srv
->b_eit_present
, p_srv
->i_running_status
,
2803 p_meta
= vlc_meta_New();
2804 for( p_dr
= p_srv
->p_first_descriptor
; p_dr
; p_dr
= p_dr
->p_next
)
2806 if( p_dr
->i_tag
== 0x48 )
2808 static const char *ppsz_type
[17] = {
2810 "Digital television service",
2811 "Digital radio sound service",
2813 "NVOD reference service",
2814 "NVOD time-shifted service",
2817 "SECAM coded signal",
2820 "NTSC coded signal",
2821 "Data broadcast service",
2822 "Reserved for Common Interface Usage",
2823 "RCS Map (see EN 301 790 [35])",
2824 "RCS FLS (see EN 301 790 [35])",
2827 dvbpsi_service_dr_t
*pD
= dvbpsi_DecodeServiceDr( p_dr
);
2831 /* Workarounds for broadcasters with broken EPG */
2833 if( p_sdt
->i_network_id
== 133 )
2834 p_sys
->b_broken_charset
= true; /* SKY DE & BetaDigital use ISO8859-1 */
2836 /* List of providers using ISO8859-1 */
2837 static const char ppsz_broken_providers
[][8] = {
2838 "CSAT", /* CanalSat FR */
2839 "GR1", /* France televisions */
2841 "MR5", /* France 2/M6 HD */
2844 for( int i
= 0; *ppsz_broken_providers
[i
]; i
++ )
2846 const size_t i_length
= strlen(ppsz_broken_providers
[i
]);
2847 if( pD
->i_service_provider_name_length
== i_length
&&
2848 !strncmp( (char *)pD
->i_service_provider_name
, ppsz_broken_providers
[i
], i_length
) )
2849 p_sys
->b_broken_charset
= true;
2852 /* FIXME: Digital+ ES also uses ISO8859-1 */
2854 str1
= EITConvertToUTF8(pD
->i_service_provider_name
,
2855 pD
->i_service_provider_name_length
,
2856 p_sys
->b_broken_charset
);
2857 str2
= EITConvertToUTF8(pD
->i_service_name
,
2858 pD
->i_service_name_length
,
2859 p_sys
->b_broken_charset
);
2861 msg_Dbg( p_demux
, " - type=%d provider=%s name=%s",
2862 pD
->i_service_type
, str1
, str2
);
2864 vlc_meta_SetTitle( p_meta
, str2
);
2865 vlc_meta_SetPublisher( p_meta
, str1
);
2866 if( pD
->i_service_type
>= 0x01 && pD
->i_service_type
<= 0x10 )
2867 psz_type
= ppsz_type
[pD
->i_service_type
];
2873 if( p_srv
->i_running_status
>= 0x01 && p_srv
->i_running_status
<= 0x04 )
2875 static const char *ppsz_status
[5] = {
2878 "Starts in a few seconds",
2882 psz_status
= ppsz_status
[p_srv
->i_running_status
];
2886 vlc_meta_AddExtra( p_meta
, "Type", psz_type
);
2888 vlc_meta_AddExtra( p_meta
, "Status", psz_status
);
2890 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_META
,
2891 p_srv
->i_service_id
, p_meta
);
2892 vlc_meta_Delete( p_meta
);
2895 sdt
->psi
->i_sdt_version
= p_sdt
->i_version
;
2896 dvbpsi_DeleteSDT( p_sdt
);
2899 /* i_year: year - 1900 i_month: 0-11 i_mday: 1-31 i_hour: 0-23 i_minute: 0-59 i_second: 0-59 */
2900 static int64_t vlc_timegm( int i_year
, int i_month
, int i_mday
, int i_hour
, int i_minute
, int i_second
)
2902 static const int pn_day
[12+1] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
2906 i_month
< 0 || i_month
> 11 || i_mday
< 1 || i_mday
> 31 ||
2907 i_hour
< 0 || i_hour
> 23 || i_minute
< 0 || i_minute
> 59 || i_second
< 0 || i_second
> 59 )
2910 /* Count the number of days */
2911 i_day
= 365 * (i_year
-70) + pn_day
[i_month
] + i_mday
- 1;
2912 #define LEAP(y) ( ((y)%4) == 0 && (((y)%100) != 0 || ((y)%400) == 0) ? 1 : 0)
2913 for( int i
= 70; i
< i_year
; i
++ )
2914 i_day
+= LEAP(1900+i
);
2916 i_day
+= LEAP(1900+i_year
);
2919 return ((24*i_day
+ i_hour
)*60 + i_minute
)*60 + i_second
;
2922 static void EITDecodeMjd( int i_mjd
, int *p_y
, int *p_m
, int *p_d
)
2924 const int yp
= (int)( ( (double)i_mjd
- 15078.2)/365.25 );
2925 const int mp
= (int)( ((double)i_mjd
- 14956.1 - (int)(yp
* 365.25)) / 30.6001 );
2926 const int c
= ( mp
== 14 || mp
== 15 ) ? 1 : 0;
2928 *p_y
= 1900 + yp
+ c
*1;
2929 *p_m
= mp
- 1 - c
*12;
2930 *p_d
= i_mjd
- 14956 - (int)(yp
*365.25) - (int)(mp
*30.6001);
2932 #define CVT_FROM_BCD(v) ((((v) >> 4)&0xf)*10 + ((v)&0xf))
2933 static int64_t EITConvertStartTime( uint64_t i_date
)
2935 const int i_mjd
= i_date
>> 24;
2936 const int i_hour
= CVT_FROM_BCD(i_date
>> 16);
2937 const int i_minute
= CVT_FROM_BCD(i_date
>> 8);
2938 const int i_second
= CVT_FROM_BCD(i_date
);
2943 /* if all 40 bits are 1, the start is unknown */
2944 if( i_date
== UINT64_C(0xffffffffff) )
2947 EITDecodeMjd( i_mjd
, &i_year
, &i_month
, &i_day
);
2948 return vlc_timegm( i_year
- 1900, i_month
- 1, i_day
, i_hour
, i_minute
, i_second
);
2950 static int EITConvertDuration( uint32_t i_duration
)
2952 return CVT_FROM_BCD(i_duration
>> 16) * 3600 +
2953 CVT_FROM_BCD(i_duration
>> 8 ) * 60 +
2954 CVT_FROM_BCD(i_duration
);
2958 static void TDTCallBack( demux_t
*p_demux
, dvbpsi_tot_t
*p_tdt
)
2960 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2962 p_sys
->i_tdt_delta
= CLOCK_FREQ
* EITConvertStartTime( p_tdt
->i_utc_time
)
2964 dvbpsi_DeleteTOT(p_tdt
);
2968 static void EITCallBack( demux_t
*p_demux
,
2969 dvbpsi_eit_t
*p_eit
, bool b_current_following
)
2971 demux_sys_t
*p_sys
= p_demux
->p_sys
;
2972 dvbpsi_eit_event_t
*p_evt
;
2975 msg_Dbg( p_demux
, "EITCallBack called" );
2976 if( !p_eit
->b_current_next
)
2978 dvbpsi_DeleteEIT( p_eit
);
2982 msg_Dbg( p_demux
, "new EIT service_id=%d version=%d current_next=%d "
2983 "ts_id=%d network_id=%d segment_last_section_number=%d "
2985 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
2988 p_eit
->i_service_id
,
2990 p_eit
->i_version
, p_eit
->b_current_next
,
2991 p_eit
->i_ts_id
, p_eit
->i_network_id
,
2992 p_eit
->i_segment_last_section_number
, p_eit
->i_last_table_id
);
2994 p_epg
= vlc_epg_New( NULL
);
2995 for( p_evt
= p_eit
->p_first_event
; p_evt
; p_evt
= p_evt
->p_next
)
2997 dvbpsi_descriptor_t
*p_dr
;
2998 char *psz_name
= NULL
;
2999 char *psz_text
= NULL
;
3000 char *psz_extra
= strdup("");
3005 i_start
= EITConvertStartTime( p_evt
->i_start_time
);
3006 i_duration
= EITConvertDuration( p_evt
->i_duration
);
3008 msg_Dbg( p_demux
, " * event id=%d start_time:%d duration=%d "
3009 "running=%d free_ca=%d",
3010 p_evt
->i_event_id
, (int)i_start
, (int)i_duration
,
3011 p_evt
->i_running_status
, p_evt
->b_free_ca
);
3013 for( p_dr
= p_evt
->p_first_descriptor
; p_dr
; p_dr
= p_dr
->p_next
)
3015 if( p_dr
->i_tag
== 0x4d )
3017 dvbpsi_short_event_dr_t
*pE
= dvbpsi_DecodeShortEventDr( p_dr
);
3019 /* Only take first description, as we don't handle language-info
3021 if( pE
&& psz_name
== NULL
)
3023 psz_name
= EITConvertToUTF8( pE
->i_event_name
, pE
->i_event_name_length
,
3024 p_sys
->b_broken_charset
);
3025 psz_text
= EITConvertToUTF8( pE
->i_text
, pE
->i_text_length
,
3026 p_sys
->b_broken_charset
);
3027 msg_Dbg( p_demux
, " - short event lang=%3.3s '%s' : '%s'",
3028 pE
->i_iso_639_code
, psz_name
, psz_text
);
3031 else if( p_dr
->i_tag
== 0x4e )
3033 dvbpsi_extended_event_dr_t
*pE
= dvbpsi_DecodeExtendedEventDr( p_dr
);
3036 msg_Dbg( p_demux
, " - extended event lang=%3.3s [%d/%d]",
3038 pE
->i_descriptor_number
, pE
->i_last_descriptor_number
);
3040 if( pE
->i_text_length
> 0 )
3042 char *psz_text
= EITConvertToUTF8( pE
->i_text
, pE
->i_text_length
,
3043 p_sys
->b_broken_charset
);
3046 msg_Dbg( p_demux
, " - text='%s'", psz_text
);
3048 psz_extra
= xrealloc( psz_extra
,
3049 strlen(psz_extra
) + strlen(psz_text
) + 1 );
3050 strcat( psz_extra
, psz_text
);
3055 for( int i
= 0; i
< pE
->i_entry_count
; i
++ )
3057 char *psz_dsc
= EITConvertToUTF8( pE
->i_item_description
[i
],
3058 pE
->i_item_description_length
[i
],
3059 p_sys
->b_broken_charset
);
3060 char *psz_itm
= EITConvertToUTF8( pE
->i_item
[i
], pE
->i_item_length
[i
],
3061 p_sys
->b_broken_charset
);
3063 if( psz_dsc
&& psz_itm
)
3065 msg_Dbg( p_demux
, " - desc='%s' item='%s'", psz_dsc
, psz_itm
);
3067 psz_extra
= xrealloc( psz_extra
,
3068 strlen(psz_extra
) + strlen(psz_dsc
) +
3069 strlen(psz_itm
) + 3 + 1 );
3070 strcat( psz_extra
, "(" );
3071 strcat( psz_extra
, psz_dsc
);
3072 strcat( psz_extra
, " " );
3073 strcat( psz_extra
, psz_itm
);
3074 strcat( psz_extra
, ")" );
3082 else if( p_dr
->i_tag
== 0x55 )
3084 dvbpsi_parental_rating_dr_t
*pR
= dvbpsi_DecodeParentalRatingDr( p_dr
);
3087 for ( int i
= 0; i
< pR
->i_ratings_number
; i
++ )
3089 const dvbpsi_parental_rating_t
*p_rating
= & pR
->p_parental_rating
[ i
];
3090 if ( p_rating
->i_rating
> 0x00 && p_rating
->i_rating
<= 0x0F )
3092 if ( p_rating
->i_rating
+ 3 > i_min_age
)
3093 i_min_age
= p_rating
->i_rating
+ 3;
3094 msg_Dbg( p_demux
, "..* event parental control set to %d years",
3102 msg_Dbg( p_demux
, " - tag=0x%x(%d)", p_dr
->i_tag
, p_dr
->i_tag
);
3108 vlc_epg_AddEvent( p_epg
, i_start
, i_duration
, psz_name
, psz_text
,
3109 *psz_extra
? psz_extra
: NULL
, i_min_age
);
3111 /* Update "now playing" field */
3112 if( p_evt
->i_running_status
== 0x04 && i_start
> 0 )
3113 vlc_epg_SetCurrent( p_epg
, i_start
);
3120 if( p_epg
->i_event
> 0 )
3122 if( b_current_following
&&
3123 ( p_sys
->i_current_program
== -1 ||
3124 p_sys
->i_current_program
==
3125 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3132 p_sys
->i_dvb_length
= 0;
3133 p_sys
->i_dvb_start
= 0;
3135 if( p_epg
->p_current
)
3137 p_sys
->i_dvb_start
= CLOCK_FREQ
* p_epg
->p_current
->i_start
;
3138 p_sys
->i_dvb_length
= CLOCK_FREQ
* p_epg
->p_current
->i_duration
;
3141 es_out_Control( p_demux
->out
, ES_OUT_SET_GROUP_EPG
,
3142 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3145 p_eit
->i_service_id
,
3149 vlc_epg_Delete( p_epg
);
3151 dvbpsi_DeleteEIT( p_eit
);
3153 static void EITCallBackCurrentFollowing( demux_t
*p_demux
, dvbpsi_eit_t
*p_eit
)
3155 EITCallBack( p_demux
, p_eit
, true );
3157 static void EITCallBackSchedule( demux_t
*p_demux
, dvbpsi_eit_t
*p_eit
)
3159 EITCallBack( p_demux
, p_eit
, false );
3162 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3163 static void PSINewTableCallBack( dvbpsi_t
*h
, uint8_t i_table_id
,
3164 uint16_t i_extension
, demux_t
*p_demux
)
3166 static void PSINewTableCallBack( demux_t
*p_demux
, dvbpsi_handle h
,
3167 uint8_t i_table_id
, uint16_t i_extension
)
3172 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3173 i_table_id
, i_table_id
, i_extension
, i_extension
);
3175 if( p_demux
->p_sys
->pid
[0].psi
->i_pat_version
!= -1 && i_table_id
== 0x42 )
3177 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3178 i_table_id
, i_table_id
, i_extension
, i_extension
);
3179 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3180 if( !dvbpsi_sdt_attach( h
, i_table_id
, i_extension
, (dvbpsi_sdt_callback
)SDTCallBack
, p_demux
) )
3181 msg_Err( p_demux
, "PSINewTableCallback: failed attaching SDTCallback" );
3183 dvbpsi_AttachSDT( h
, i_table_id
, i_extension
,
3184 (dvbpsi_sdt_callback
)SDTCallBack
, p_demux
);
3187 else if( p_demux
->p_sys
->pid
[0x11].psi
->i_sdt_version
!= -1 &&
3188 ( i_table_id
== 0x4e || /* Current/Following */
3189 (i_table_id
>= 0x50 && i_table_id
<= 0x5f) ) ) /* Schedule */
3191 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3192 i_table_id
, i_table_id
, i_extension
, i_extension
);
3194 dvbpsi_eit_callback cb
= i_table_id
== 0x4e ?
3195 (dvbpsi_eit_callback
)EITCallBackCurrentFollowing
:
3196 (dvbpsi_eit_callback
)EITCallBackSchedule
;
3197 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3198 if( !dvbpsi_eit_attach( h
, i_table_id
, i_extension
, cb
, p_demux
) )
3199 msg_Err( p_demux
, "PSINewTableCallback: failed attaching EITCallback" );
3201 dvbpsi_AttachEIT( h
, i_table_id
, i_extension
, cb
, p_demux
);
3204 else if( p_demux
->p_sys
->pid
[0x11].psi
->i_sdt_version
!= -1 &&
3205 i_table_id
== 0x70 ) /* TDT */
3207 msg_Dbg( p_demux
, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3208 i_table_id
, i_table_id
, i_extension
, i_extension
);
3209 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3210 if( !dvbpsi_tot_attach( h
, i_table_id
, i_extension
, (dvbpsi_tot_callback
)TDTCallBack
, p_demux
) )
3211 msg_Err( p_demux
, "PSINewTableCallback: failed attaching TDTCallback" );
3213 dvbpsi_AttachTOT( h
, i_table_id
, i_extension
,
3214 (dvbpsi_tot_callback
)TDTCallBack
, p_demux
);
3219 /*****************************************************************************
3220 * PMT callback and helpers
3221 *****************************************************************************/
3222 static dvbpsi_descriptor_t
*PMTEsFindDescriptor( const dvbpsi_pmt_es_t
*p_es
,
3225 dvbpsi_descriptor_t
*p_dr
= p_es
->p_first_descriptor
;;
3226 while( p_dr
&& ( p_dr
->i_tag
!= i_tag
) )
3227 p_dr
= p_dr
->p_next
;
3230 static bool PMTEsHasRegistration( demux_t
*p_demux
,
3231 const dvbpsi_pmt_es_t
*p_es
,
3232 const char *psz_tag
)
3234 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x05 );
3238 if( p_dr
->i_length
< 4 )
3240 msg_Warn( p_demux
, "invalid Registration Descriptor" );
3244 assert( strlen(psz_tag
) == 4 );
3245 return !memcmp( p_dr
->p_data
, psz_tag
, 4 );
3247 static void PMTSetupEsISO14496( demux_t
*p_demux
, ts_pid_t
*pid
,
3248 const ts_prg_psi_t
*prg
, const dvbpsi_pmt_es_t
*p_es
)
3250 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3252 /* MPEG-4 stream: search SL_DESCRIPTOR */
3253 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x1f );
3255 if( p_dr
&& p_dr
->i_length
== 2 )
3257 const int i_es_id
= ( p_dr
->p_data
[0] << 8 ) | p_dr
->p_data
[1];
3259 msg_Warn( p_demux
, "found SL_descriptor es_id=%d", i_es_id
);
3261 pid
->es
->p_mpeg4desc
= NULL
;
3263 for( int i
= 0; i
< 255; i
++ )
3265 iod_descriptor_t
*iod
= prg
->iod
;
3267 if( iod
->es_descr
[i
].b_ok
&& iod
->es_descr
[i
].i_es_id
== i_es_id
)
3269 pid
->es
->p_mpeg4desc
= &iod
->es_descr
[i
];
3274 if( !pid
->es
->p_mpeg4desc
)
3276 msg_Err( p_demux
, "MPEG-4 descriptor not found" );
3280 const decoder_config_descriptor_t
*dcd
= &pid
->es
->p_mpeg4desc
->dec_descr
;
3281 if( dcd
->i_streamType
== 0x04 ) /* VisualStream */
3283 p_fmt
->i_cat
= VIDEO_ES
;
3284 switch( dcd
->i_objectTypeIndication
)
3286 case 0x0B: /* mpeg4 sub */
3287 p_fmt
->i_cat
= SPU_ES
;
3288 p_fmt
->i_codec
= VLC_CODEC_SUBT
;
3291 case 0x20: /* mpeg4 */
3292 p_fmt
->i_codec
= VLC_CODEC_MP4V
;
3294 case 0x21: /* h264 */
3295 p_fmt
->i_codec
= VLC_CODEC_H264
;
3302 case 0x65: /* mpeg2 */
3303 p_fmt
->i_codec
= VLC_CODEC_MPGV
;
3305 case 0x6a: /* mpeg1 */
3306 p_fmt
->i_codec
= VLC_CODEC_MPGV
;
3308 case 0x6c: /* mpeg1 */
3309 p_fmt
->i_codec
= VLC_CODEC_JPEG
;
3312 p_fmt
->i_cat
= UNKNOWN_ES
;
3316 else if( dcd
->i_streamType
== 0x05 ) /* AudioStream */
3318 p_fmt
->i_cat
= AUDIO_ES
;
3319 switch( dcd
->i_objectTypeIndication
)
3321 case 0x40: /* mpeg4 */
3322 p_fmt
->i_codec
= VLC_CODEC_MP4A
;
3326 case 0x68: /* mpeg2 aac */
3327 p_fmt
->i_codec
= VLC_CODEC_MP4A
;
3329 case 0x69: /* mpeg2 */
3330 p_fmt
->i_codec
= VLC_CODEC_MPGA
;
3332 case 0x6b: /* mpeg1 */
3333 p_fmt
->i_codec
= VLC_CODEC_MPGA
;
3336 p_fmt
->i_cat
= UNKNOWN_ES
;
3342 p_fmt
->i_cat
= UNKNOWN_ES
;
3345 if( p_fmt
->i_cat
!= UNKNOWN_ES
)
3347 p_fmt
->i_extra
= dcd
->i_extra
;
3348 if( p_fmt
->i_extra
> 0 )
3350 p_fmt
->p_extra
= malloc( p_fmt
->i_extra
);
3351 if( p_fmt
->p_extra
)
3352 memcpy( p_fmt
->p_extra
, dcd
->p_extra
, p_fmt
->i_extra
);
3365 } ts_teletext_page_t
;
3367 static void PMTSetupEsTeletext( demux_t
*p_demux
, ts_pid_t
*pid
,
3368 const dvbpsi_pmt_es_t
*p_es
)
3370 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3372 ts_teletext_page_t p_page
[2 * 64 + 20];
3373 unsigned i_page
= 0;
3375 /* Gather pages information */
3376 #if defined _DVBPSI_DR_56_H_ && \
3377 defined DVBPSI_VERSION && DVBPSI_VERSION_INT > DVBPSI_VERSION_WANTED(0,1,5)
3378 for( unsigned i_tag_idx
= 0; i_tag_idx
< 2; i_tag_idx
++ )
3380 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, i_tag_idx
== 0 ? 0x46 : 0x56 );
3384 dvbpsi_teletext_dr_t
*p_sub
= dvbpsi_DecodeTeletextDr( p_dr
);
3388 for( int i
= 0; i
< p_sub
->i_pages_number
; i
++ )
3390 const dvbpsi_teletextpage_t
*p_src
= &p_sub
->p_pages
[i
];
3392 if( p_src
->i_teletext_type
>= 0x06 )
3395 assert( i_page
< sizeof(p_page
)/sizeof(*p_page
) );
3397 ts_teletext_page_t
*p_dst
= &p_page
[i_page
++];
3399 p_dst
->i_type
= p_src
->i_teletext_type
;
3400 p_dst
->i_magazine
= p_src
->i_teletext_magazine_number
3401 ? p_src
->i_teletext_magazine_number
: 8;
3402 p_dst
->i_page
= p_src
->i_teletext_page_number
;
3403 memcpy( p_dst
->p_iso639
, p_src
->i_iso6392_language_code
, 3 );
3408 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3411 dvbpsi_subtitling_dr_t
*p_sub
= dvbpsi_DecodeSubtitlingDr( p_dr
);
3412 for( int i
= 0; p_sub
&& i
< p_sub
->i_subtitles_number
; i
++ )
3414 dvbpsi_subtitle_t
*p_src
= &p_sub
->p_subtitle
[i
];
3416 if( p_src
->i_subtitling_type
< 0x01 || p_src
->i_subtitling_type
> 0x03 )
3419 assert( i_page
< sizeof(p_page
)/sizeof(*p_page
) );
3421 ts_teletext_page_t
*p_dst
= &p_page
[i_page
++];
3423 switch( p_src
->i_subtitling_type
)
3426 p_dst
->i_type
= 0x02;
3429 p_dst
->i_type
= 0x03;
3432 /* FIXME check if it is the right split */
3433 p_dst
->i_magazine
= (p_src
->i_composition_page_id
>> 8)
3434 ? (p_src
->i_composition_page_id
>> 8) : 8;
3435 p_dst
->i_page
= p_src
->i_composition_page_id
& 0xff;
3436 memcpy( p_dst
->p_iso639
, p_src
->i_iso6392_language_code
, 3 );
3441 es_format_Init( p_fmt
, SPU_ES
, VLC_CODEC_TELETEXT
);
3443 if( !p_demux
->p_sys
->b_split_es
|| i_page
<= 0 )
3445 p_fmt
->subs
.teletext
.i_magazine
= -1;
3446 p_fmt
->subs
.teletext
.i_page
= 0;
3447 p_fmt
->psz_description
= strdup( vlc_gettext(ppsz_teletext_type
[1]) );
3449 dvbpsi_descriptor_t
*p_dr
;
3450 p_dr
= PMTEsFindDescriptor( p_es
, 0x46 );
3452 p_dr
= PMTEsFindDescriptor( p_es
, 0x56 );
3454 if( !p_demux
->p_sys
->b_split_es
&& p_dr
&& p_dr
->i_length
> 0 )
3456 /* Descriptor pass-through */
3457 p_fmt
->p_extra
= malloc( p_dr
->i_length
);
3458 if( p_fmt
->p_extra
)
3460 p_fmt
->i_extra
= p_dr
->i_length
;
3461 memcpy( p_fmt
->p_extra
, p_dr
->p_data
, p_dr
->i_length
);
3467 for( unsigned i
= 0; i
< i_page
; i
++ )
3478 p_es
= malloc( sizeof(*p_es
) );
3482 es_format_Copy( &p_es
->fmt
, &pid
->es
->fmt
);
3483 free( p_es
->fmt
.psz_language
);
3484 free( p_es
->fmt
.psz_description
);
3485 p_es
->fmt
.psz_language
= NULL
;
3486 p_es
->fmt
.psz_description
= NULL
;
3489 p_es
->p_data
= NULL
;
3490 p_es
->i_data_size
= 0;
3491 p_es
->i_data_gathered
= 0;
3492 p_es
->pp_last
= &p_es
->p_data
;
3493 p_es
->data_type
= TS_ES_DATA_PES
;
3494 p_es
->p_mpeg4desc
= NULL
;
3496 TAB_APPEND( pid
->i_extra_es
, pid
->extra_es
, p_es
);
3500 const ts_teletext_page_t
*p
= &p_page
[i
];
3501 p_es
->fmt
.i_priority
= (p
->i_type
== 0x02 || p
->i_type
== 0x05) ?
3502 ES_PRIORITY_SELECTABLE_MIN
: ES_PRIORITY_NOT_DEFAULTABLE
;
3503 p_es
->fmt
.psz_language
= strndup( p
->p_iso639
, 3 );
3504 p_es
->fmt
.psz_description
= strdup(vlc_gettext(ppsz_teletext_type
[p
->i_type
]));
3505 p_es
->fmt
.subs
.teletext
.i_magazine
= p
->i_magazine
;
3506 p_es
->fmt
.subs
.teletext
.i_page
= p
->i_page
;
3509 " * ttxt type=%s lan=%s page=%d%02x",
3510 p_es
->fmt
.psz_description
,
3511 p_es
->fmt
.psz_language
,
3512 p
->i_magazine
, p
->i_page
);
3516 static void PMTSetupEsDvbSubtitle( demux_t
*p_demux
, ts_pid_t
*pid
,
3517 const dvbpsi_pmt_es_t
*p_es
)
3519 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3521 es_format_Init( p_fmt
, SPU_ES
, VLC_CODEC_DVBS
);
3523 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3525 dvbpsi_subtitling_dr_t
*p_sub
= dvbpsi_DecodeSubtitlingDr( p_dr
);
3526 for( int i
= 0; p_sub
&& i
< p_sub
->i_subtitles_number
; i
++ )
3528 const int i_type
= p_sub
->p_subtitle
[i
].i_subtitling_type
;
3529 if( ( i_type
>= 0x10 && i_type
<= 0x14 ) ||
3530 ( i_type
>= 0x20 && i_type
<= 0x24 ) )
3534 if( !p_demux
->p_sys
->b_split_es
|| i_page
<= 0 )
3536 p_fmt
->subs
.dvb
.i_id
= -1;
3537 p_fmt
->psz_description
= strdup( _("DVB subtitles") );
3539 if( !p_demux
->p_sys
->b_split_es
&& p_dr
&& p_dr
->i_length
> 0 )
3541 /* Descriptor pass-through */
3542 p_fmt
->p_extra
= malloc( p_dr
->i_length
);
3543 if( p_fmt
->p_extra
)
3545 p_fmt
->i_extra
= p_dr
->i_length
;
3546 memcpy( p_fmt
->p_extra
, p_dr
->p_data
, p_dr
->i_length
);
3552 for( int i
= 0; i
< p_sub
->i_subtitles_number
; i
++ )
3563 p_es
= malloc( sizeof(*p_es
) );
3567 es_format_Copy( &p_es
->fmt
, &pid
->es
->fmt
);
3568 free( p_es
->fmt
.psz_language
);
3569 free( p_es
->fmt
.psz_description
);
3570 p_es
->fmt
.psz_language
= NULL
;
3571 p_es
->fmt
.psz_description
= NULL
;
3574 p_es
->p_data
= NULL
;
3575 p_es
->i_data_size
= 0;
3576 p_es
->i_data_gathered
= 0;
3577 p_es
->pp_last
= &p_es
->p_data
;
3578 p_es
->data_type
= TS_ES_DATA_PES
;
3579 p_es
->p_mpeg4desc
= NULL
;
3581 TAB_APPEND( pid
->i_extra_es
, pid
->extra_es
, p_es
);
3585 const dvbpsi_subtitle_t
*p
= &p_sub
->p_subtitle
[i
];
3586 p_es
->fmt
.psz_language
= strndup( (char *)p
->i_iso6392_language_code
, 3 );
3587 switch( p
->i_subtitling_type
)
3589 case 0x10: /* unspec. */
3590 case 0x11: /* 4:3 */
3591 case 0x12: /* 16:9 */
3592 case 0x13: /* 2.21:1 */
3593 case 0x14: /* HD monitor */
3594 p_es
->fmt
.psz_description
= strdup( _("DVB subtitles") );
3596 case 0x20: /* Hearing impaired unspec. */
3597 case 0x21: /* h.i. 4:3 */
3598 case 0x22: /* h.i. 16:9 */
3599 case 0x23: /* h.i. 2.21:1 */
3600 case 0x24: /* h.i. HD monitor */
3601 p_es
->fmt
.psz_description
= strdup( _("DVB subtitles: hearing impaired") );
3608 p_es
->fmt
.subs
.dvb
.i_id
= ( p
->i_composition_page_id
<< 0 ) |
3609 ( p
->i_ancillary_page_id
<< 16 );
3613 static void PMTSetupEs0x06( demux_t
*p_demux
, ts_pid_t
*pid
,
3614 const dvbpsi_pmt_es_t
*p_es
)
3616 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3618 if( PMTEsHasRegistration( p_demux
, p_es
, "AC-3" ) ||
3619 PMTEsFindDescriptor( p_es
, 0x6a ) ||
3620 PMTEsFindDescriptor( p_es
, 0x81 ) )
3622 p_fmt
->i_cat
= AUDIO_ES
;
3623 p_fmt
->i_codec
= VLC_CODEC_A52
;
3625 else if( PMTEsFindDescriptor( p_es
, 0x7a ) )
3627 /* DVB with stream_type 0x06 (ETS EN 300 468) */
3628 p_fmt
->i_cat
= AUDIO_ES
;
3629 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
3631 else if( PMTEsHasRegistration( p_demux
, p_es
, "DTS1" ) ||
3632 PMTEsHasRegistration( p_demux
, p_es
, "DTS2" ) ||
3633 PMTEsHasRegistration( p_demux
, p_es
, "DTS3" ) ||
3634 PMTEsFindDescriptor( p_es
, 0x73 ) )
3636 /*registration descriptor(ETSI TS 101 154 Annex F)*/
3637 p_fmt
->i_cat
= AUDIO_ES
;
3638 p_fmt
->i_codec
= VLC_CODEC_DTS
;
3640 else if( PMTEsHasRegistration( p_demux
, p_es
, "BSSD" ) )
3642 p_fmt
->i_cat
= AUDIO_ES
;
3643 p_fmt
->b_packetized
= true;
3644 p_fmt
->i_codec
= VLC_CODEC_302M
;
3646 else if( PMTEsHasRegistration( p_demux
, p_es
, "HEVC" ) )
3648 p_fmt
->i_cat
= VIDEO_ES
;
3649 p_fmt
->i_codec
= VLC_CODEC_HEVC
;
3653 /* Subtitle/Teletext/VBI fallbacks */
3654 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x59 );
3656 dvbpsi_subtitling_dr_t
*p_sub
;
3657 if( p_dr
&& ( p_sub
= dvbpsi_DecodeSubtitlingDr( p_dr
) ) )
3659 for( int i
= 0; i
< p_sub
->i_subtitles_number
; i
++ )
3661 if( p_fmt
->i_cat
!= UNKNOWN_ES
)
3664 switch( p_sub
->p_subtitle
[i
].i_subtitling_type
)
3666 case 0x01: /* EBU Teletext subtitles */
3667 case 0x02: /* Associated EBU Teletext */
3668 case 0x03: /* VBI data */
3669 PMTSetupEsTeletext( p_demux
, pid
, p_es
);
3671 case 0x10: /* DVB Subtitle (normal) with no monitor AR critical */
3672 case 0x11: /* ... on 4:3 AR monitor */
3673 case 0x12: /* ... on 16:9 AR monitor */
3674 case 0x13: /* ... on 2.21:1 AR monitor */
3675 case 0x14: /* ... for display on a high definition monitor */
3676 case 0x20: /* DVB Subtitle (impaired) with no monitor AR critical */
3677 case 0x21: /* ... on 4:3 AR monitor */
3678 case 0x22: /* ... on 16:9 AR monitor */
3679 case 0x23: /* ... on 2.21:1 AR monitor */
3680 case 0x24: /* ... for display on a high definition monitor */
3681 PMTSetupEsDvbSubtitle( p_demux
, pid
, p_es
);
3684 msg_Err( p_demux
, "Unrecognized DVB subtitle type (0x%x)",
3685 p_sub
->p_subtitle
[i
].i_subtitling_type
);
3691 if( p_fmt
->i_cat
== UNKNOWN_ES
&&
3692 ( PMTEsFindDescriptor( p_es
, 0x45 ) || /* VBI Data descriptor */
3693 PMTEsFindDescriptor( p_es
, 0x46 ) || /* VBI Teletext descriptor */
3694 PMTEsFindDescriptor( p_es
, 0x56 ) ) ) /* EBU Teletext descriptor */
3697 PMTSetupEsTeletext( p_demux
, pid
, p_es
);
3701 /* FIXME is it useful ? */
3702 if( PMTEsFindDescriptor( p_es
, 0x52 ) )
3704 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x52 );
3705 dvbpsi_stream_identifier_dr_t
*p_si
= dvbpsi_DecodeStreamIdentifierDr( p_dr
);
3707 msg_Dbg( p_demux
, " * Stream Component Identifier: %d", p_si
->i_component_tag
);
3711 static void PMTSetupEs0xEA( demux_t
*p_demux
, ts_pid_t
*pid
,
3712 const dvbpsi_pmt_es_t
*p_es
)
3714 /* Registration Descriptor */
3715 if( !PMTEsHasRegistration( p_demux
, p_es
, "VC-1" ) )
3717 msg_Err( p_demux
, "Registration descriptor not found or invalid" );
3721 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3723 /* registration descriptor for VC-1 (SMPTE rp227) */
3724 p_fmt
->i_cat
= VIDEO_ES
;
3725 p_fmt
->i_codec
= VLC_CODEC_VC1
;
3727 /* XXX With Simple and Main profile the SEQUENCE
3728 * header is modified: video width and height are
3729 * inserted just after the start code as 2 int16_t
3730 * The packetizer will take care of that. */
3733 static void PMTSetupEs0xD1( demux_t
*p_demux
, ts_pid_t
*pid
,
3734 const dvbpsi_pmt_es_t
*p_es
)
3736 /* Registration Descriptor */
3737 if( !PMTEsHasRegistration( p_demux
, p_es
, "drac" ) )
3739 msg_Err( p_demux
, "Registration descriptor not found or invalid" );
3743 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3745 /* registration descriptor for Dirac
3746 * (backwards compatable with VC-2 (SMPTE Sxxxx:2008)) */
3747 p_fmt
->i_cat
= VIDEO_ES
;
3748 p_fmt
->i_codec
= VLC_CODEC_DIRAC
;
3751 static void PMTSetupEs0xA0( demux_t
*p_demux
, ts_pid_t
*pid
,
3752 const dvbpsi_pmt_es_t
*p_es
)
3754 /* MSCODEC sent by vlc */
3755 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0xa0 );
3756 if( !p_dr
|| p_dr
->i_length
< 10 )
3759 "private MSCODEC (vlc) without bih private descriptor" );
3763 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3764 p_fmt
->i_cat
= VIDEO_ES
;
3765 p_fmt
->i_codec
= VLC_FOURCC( p_dr
->p_data
[0], p_dr
->p_data
[1],
3766 p_dr
->p_data
[2], p_dr
->p_data
[3] );
3767 p_fmt
->video
.i_width
= GetWBE( &p_dr
->p_data
[4] );
3768 p_fmt
->video
.i_height
= GetWBE( &p_dr
->p_data
[6] );
3769 p_fmt
->i_extra
= GetWBE( &p_dr
->p_data
[8] );
3771 if( p_fmt
->i_extra
> 0 )
3773 p_fmt
->p_extra
= malloc( p_fmt
->i_extra
);
3774 if( p_fmt
->p_extra
)
3775 memcpy( p_fmt
->p_extra
, &p_dr
->p_data
[10],
3776 __MIN( p_fmt
->i_extra
, p_dr
->i_length
- 10 ) );
3780 /* For such stream we will gather them ourself and don't launch a
3782 * Yes it's ugly but it's the only way to have DIV3 working */
3783 p_fmt
->b_packetized
= true;
3786 static void PMTSetupEs0x83( const dvbpsi_pmt_t
*p_pmt
, ts_pid_t
*pid
)
3788 /* WiDi broadcasts without registration on PMT 0x1, PCR 0x1000 and
3789 * with audio track pid being 0x1100..0x11FF */
3790 if ( p_pmt
->i_program_number
== 0x1 &&
3791 p_pmt
->i_pcr_pid
== 0x1000 &&
3792 ( pid
->i_pid
>> 8 ) == 0x11 )
3794 /* Not enough ? might contain 0x83 private descriptor, 2 bytes 0x473F */
3795 es_format_Init( &pid
->es
->fmt
, AUDIO_ES
, VLC_CODEC_WIDI_LPCM
);
3798 es_format_Init( &pid
->es
->fmt
, AUDIO_ES
, VLC_CODEC_DVD_LPCM
);
3801 static void PMTSetupEsHDMV( ts_pid_t
*pid
, const dvbpsi_pmt_es_t
*p_es
)
3803 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3805 /* Blu-Ray mapping */
3806 switch( p_es
->i_type
)
3809 p_fmt
->i_cat
= AUDIO_ES
;
3810 p_fmt
->i_codec
= VLC_CODEC_BD_LPCM
;
3813 case 0x85: /* DTS-HD High resolution audio */
3814 case 0x86: /* DTS-HD Master audio */
3815 case 0xA2: /* Secondary DTS audio */
3816 p_fmt
->i_cat
= AUDIO_ES
;
3817 p_fmt
->i_codec
= VLC_CODEC_DTS
;
3820 case 0x83: /* TrueHD AC3 */
3821 p_fmt
->i_cat
= AUDIO_ES
;
3822 p_fmt
->i_codec
= VLC_CODEC_TRUEHD
;
3825 case 0x84: /* E-AC3 */
3826 case 0xA1: /* Secondary E-AC3 */
3827 p_fmt
->i_cat
= AUDIO_ES
;
3828 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
3830 case 0x90: /* Presentation graphics */
3831 p_fmt
->i_cat
= SPU_ES
;
3832 p_fmt
->i_codec
= VLC_CODEC_BD_PG
;
3834 case 0x91: /* Interactive graphics */
3835 case 0x92: /* Subtitle */
3841 static void PMTSetupEsRegistration( demux_t
*p_demux
, ts_pid_t
*pid
,
3842 const dvbpsi_pmt_es_t
*p_es
)
3848 vlc_fourcc_t i_codec
;
3850 { "AC-3", AUDIO_ES
, VLC_CODEC_A52
},
3851 { "DTS1", AUDIO_ES
, VLC_CODEC_DTS
},
3852 { "DTS2", AUDIO_ES
, VLC_CODEC_DTS
},
3853 { "DTS3", AUDIO_ES
, VLC_CODEC_DTS
},
3854 { "BSSD", AUDIO_ES
, VLC_CODEC_302M
},
3855 { "VC-1", VIDEO_ES
, VLC_CODEC_VC1
},
3856 { "drac", VIDEO_ES
, VLC_CODEC_DIRAC
},
3857 { "", UNKNOWN_ES
, 0 }
3859 es_format_t
*p_fmt
= &pid
->es
->fmt
;
3861 for( int i
= 0; p_regs
[i
].i_cat
!= UNKNOWN_ES
; i
++ )
3863 if( PMTEsHasRegistration( p_demux
, p_es
, p_regs
[i
].psz_tag
) )
3865 p_fmt
->i_cat
= p_regs
[i
].i_cat
;
3866 p_fmt
->i_codec
= p_regs
[i
].i_codec
;
3867 if (p_es
->i_type
== 0x87)
3868 p_fmt
->i_codec
= VLC_CODEC_EAC3
;
3874 static char *GetAudioTypeDesc(demux_t
*p_demux
, int type
)
3876 static const char *audio_type
[] = {
3878 N_("clean effects"),
3879 N_("hearing impaired"),
3880 N_("visual impaired commentary"),
3883 if (type
< 0 || type
> 3)
3884 msg_Dbg( p_demux
, "unknown audio type: %d", type
);
3886 return strdup(audio_type
[type
]);
3890 static void PMTParseEsIso639( demux_t
*p_demux
, ts_pid_t
*pid
,
3891 const dvbpsi_pmt_es_t
*p_es
)
3893 /* get language descriptor */
3894 dvbpsi_descriptor_t
*p_dr
= PMTEsFindDescriptor( p_es
, 0x0a );
3899 dvbpsi_iso639_dr_t
*p_decoded
= dvbpsi_DecodeISO639Dr( p_dr
);
3902 msg_Err( p_demux
, "Failed to decode a ISO 639 descriptor" );
3906 #if defined(DR_0A_API_VER) && (DR_0A_API_VER >= 2)
3907 pid
->es
->fmt
.psz_language
= malloc( 4 );
3908 if( pid
->es
->fmt
.psz_language
)
3910 memcpy( pid
->es
->fmt
.psz_language
, p_decoded
->code
[0].iso_639_code
, 3 );
3911 pid
->es
->fmt
.psz_language
[3] = 0;
3912 msg_Dbg( p_demux
, "found language: %s", pid
->es
->fmt
.psz_language
);
3914 int type
= p_decoded
->code
[0].i_audio_type
;
3915 pid
->es
->fmt
.psz_description
= GetAudioTypeDesc(p_demux
, type
);
3917 pid
->es
->fmt
.i_priority
= ES_PRIORITY_SELECTABLE_MIN
+ 1; // prioritize normal audio tracks
3919 pid
->es
->fmt
.i_extra_languages
= p_decoded
->i_code_count
-1;
3920 if( pid
->es
->fmt
.i_extra_languages
> 0 )
3921 pid
->es
->fmt
.p_extra_languages
=
3922 malloc( sizeof(*pid
->es
->fmt
.p_extra_languages
) *
3923 pid
->es
->fmt
.i_extra_languages
);
3924 if( pid
->es
->fmt
.p_extra_languages
)
3926 for( int i
= 0; i
< pid
->es
->fmt
.i_extra_languages
; i
++ )
3928 pid
->es
->fmt
.p_extra_languages
[i
].psz_language
= malloc(4);
3929 if( pid
->es
->fmt
.p_extra_languages
[i
].psz_language
)
3931 memcpy( pid
->es
->fmt
.p_extra_languages
[i
].psz_language
,
3932 p_decoded
->code
[i
+1].iso_639_code
, 3 );
3933 pid
->es
->fmt
.p_extra_languages
[i
].psz_language
[3] = '\0';
3935 int type
= p_decoded
->code
[i
].i_audio_type
;
3936 pid
->es
->fmt
.p_extra_languages
[i
].psz_description
= GetAudioTypeDesc(p_demux
, type
);
3940 pid
->es
->fmt
.psz_language
= malloc( 4 );
3941 if( pid
->es
->fmt
.psz_language
)
3943 memcpy( pid
->es
->fmt
.psz_language
,
3944 p_decoded
->i_iso_639_code
, 3 );
3945 pid
->es
->fmt
.psz_language
[3] = 0;
3950 static void PMTCallBack( void *data
, dvbpsi_pmt_t
*p_pmt
)
3952 demux_t
*p_demux
= data
;
3953 demux_sys_t
*p_sys
= p_demux
->p_sys
;
3955 ts_pid_t
*pmt
= NULL
;
3958 msg_Dbg( p_demux
, "PMTCallBack called" );
3960 /* First find this PMT declared in PAT */
3961 for( int i
= 0; !pmt
&& i
< p_sys
->i_pmt
; i
++ )
3962 for( int i_prg
= 0; !pmt
&& i_prg
< p_sys
->pmt
[i
]->psi
->i_prg
; i_prg
++ )
3964 const int i_pmt_number
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
]->i_number
;
3965 if( i_pmt_number
!= TS_USER_PMT_NUMBER
&&
3966 i_pmt_number
== p_pmt
->i_program_number
)
3968 pmt
= p_sys
->pmt
[i
];
3969 prg
= p_sys
->pmt
[i
]->psi
->prg
[i_prg
];
3975 msg_Warn( p_demux
, "unreferenced program (broken stream)" );
3976 dvbpsi_DeletePMT(p_pmt
);
3981 if( prg
->i_version
!= -1 &&
3982 ( !p_pmt
->b_current_next
|| prg
->i_version
== p_pmt
->i_version
) )
3984 dvbpsi_DeletePMT( p_pmt
);
3988 ts_pid_t
**pp_clean
= NULL
;
3990 /* Clean this program (remove all es) */
3991 for( int i
= 0; i
< 8192; i
++ )
3993 ts_pid_t
*pid
= &p_sys
->pid
[i
];
3995 if( pid
->b_valid
&& pid
->p_owner
== pmt
->psi
&&
3996 pid
->i_owner_number
== prg
->i_number
&& pid
->psi
== NULL
)
3998 TAB_APPEND( i_clean
, pp_clean
, pid
);
4003 IODFree( prg
->iod
);
4007 msg_Dbg( p_demux
, "new PMT program number=%d version=%d pid_pcr=%d",
4008 p_pmt
->i_program_number
, p_pmt
->i_version
, p_pmt
->i_pcr_pid
);
4009 prg
->i_pid_pcr
= p_pmt
->i_pcr_pid
;
4010 prg
->i_version
= p_pmt
->i_version
;
4012 ValidateDVBMeta( p_demux
, prg
->i_pid_pcr
);
4013 if( ProgramIsSelected( p_demux
, prg
->i_number
) )
4014 SetPIDFilter( p_demux
, prg
->i_pid_pcr
, true ); /* Set demux filter */
4016 /* Parse descriptor */
4017 ts_registration_type_t registration_type
= TS_REGISTRATION_OTHER
;
4018 dvbpsi_descriptor_t
*p_dr
;
4019 for( p_dr
= p_pmt
->p_first_descriptor
; p_dr
!= NULL
; p_dr
= p_dr
->p_next
)
4022 case 0x1d: /* We have found an IOD descriptor */
4023 msg_Dbg( p_demux
, " * descriptor : IOD (0x1d)" );
4024 prg
->iod
= IODNew( p_dr
->i_length
, p_dr
->p_data
);
4028 msg_Dbg( p_demux
, " * descriptor : CA (0x9) SysID 0x%x",
4029 (p_dr
->p_data
[0] << 8) | p_dr
->p_data
[1] );
4032 case 0x5: /* Registration Descriptor */
4033 if( p_dr
->i_length
!= 4 )
4035 msg_Warn( p_demux
, "invalid Registration Descriptor" );
4039 msg_Dbg( p_demux
, " * descriptor : registration %4.4s", p_dr
->p_data
);
4040 if( !memcmp( p_dr
->p_data
, "HDMV", 4 ) || !memcmp( p_dr
->p_data
, "HDPR", 4 ) )
4041 registration_type
= TS_REGISTRATION_HDMV
; /* Blu-Ray */
4046 msg_Dbg( p_demux
, " * descriptor : unknown (0x%x)", p_dr
->i_tag
);
4049 dvbpsi_pmt_es_t
*p_es
;
4050 for( p_es
= p_pmt
->p_first_es
; p_es
!= NULL
; p_es
= p_es
->p_next
)
4052 ts_pid_t tmp_pid
, *old_pid
= 0, *pid
= &tmp_pid
;
4054 /* Find out if the PID was already declared */
4055 for( int i
= 0; i
< i_clean
; i
++ )
4057 if( pp_clean
[i
] == &p_sys
->pid
[p_es
->i_pid
] )
4059 old_pid
= pp_clean
[i
];
4063 ValidateDVBMeta( p_demux
, p_es
->i_pid
);
4065 if( !old_pid
&& p_sys
->pid
[p_es
->i_pid
].b_valid
)
4067 msg_Warn( p_demux
, "pmt error: pid=%d already defined",
4072 for( p_dr
= p_es
->p_first_descriptor
; p_dr
!= NULL
;
4073 p_dr
= p_dr
->p_next
)
4075 msg_Dbg( p_demux
, " * es pid=%d type=%d dr->i_tag=0x%x",
4076 p_es
->i_pid
, p_es
->i_type
, p_dr
->i_tag
);
4079 PIDInit( pid
, false, pmt
->psi
);
4080 PIDFillFormat( pid
->es
, p_es
->i_type
);
4081 pid
->i_owner_number
= prg
->i_number
;
4082 pid
->i_pid
= p_es
->i_pid
;
4083 pid
->b_seen
= p_sys
->pid
[p_es
->i_pid
].b_seen
;
4085 switch( p_es
->i_type
)
4091 PMTSetupEsISO14496( p_demux
, pid
, prg
, p_es
);
4094 PMTSetupEs0x06( p_demux
, pid
, p_es
);
4098 PMTSetupEs0x83( p_pmt
, pid
);
4101 PMTSetupEs0xA0( p_demux
, pid
, p_es
);
4104 PMTSetupEs0xD1( p_demux
, pid
, p_es
);
4107 PMTSetupEs0xEA( p_demux
, pid
, p_es
);
4110 if( registration_type
== TS_REGISTRATION_HDMV
)
4111 PMTSetupEsHDMV( pid
, p_es
);
4112 else if( p_es
->i_type
>= 0x80 )
4113 PMTSetupEsRegistration( p_demux
, pid
, p_es
);
4117 if( pid
->es
->fmt
.i_cat
== AUDIO_ES
||
4118 ( pid
->es
->fmt
.i_cat
== SPU_ES
&&
4119 pid
->es
->fmt
.i_codec
!= VLC_CODEC_DVBS
&&
4120 pid
->es
->fmt
.i_codec
!= VLC_CODEC_TELETEXT
) )
4122 PMTParseEsIso639( p_demux
, pid
, p_es
);
4125 switch( pid
->es
->fmt
.i_codec
)
4127 case VLC_CODEC_SCTE_27
:
4128 pid
->es
->data_type
= TS_ES_DATA_TABLE_SECTION
;
4131 //pid->es->data_type = TS_ES_DATA_PES;
4135 pid
->es
->fmt
.i_group
= p_pmt
->i_program_number
;
4136 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4137 pid
->extra_es
[i
]->fmt
.i_group
= p_pmt
->i_program_number
;
4139 if( pid
->es
->fmt
.i_cat
== UNKNOWN_ES
)
4141 msg_Dbg( p_demux
, " * es pid=%d type=%d *unknown*",
4142 p_es
->i_pid
, p_es
->i_type
);
4146 msg_Dbg( p_demux
, " * es pid=%d type=%d fcc=%4.4s",
4147 p_es
->i_pid
, p_es
->i_type
, (char*)&pid
->es
->fmt
.i_codec
);
4149 if( p_sys
->b_es_id_pid
) pid
->es
->fmt
.i_id
= p_es
->i_pid
;
4151 /* Check if we can avoid restarting the ES */
4153 pid
->es
->fmt
.i_codec
== old_pid
->es
->fmt
.i_codec
&&
4154 pid
->es
->fmt
.i_extra
== old_pid
->es
->fmt
.i_extra
&&
4155 pid
->es
->fmt
.i_extra
== 0 &&
4156 pid
->i_extra_es
== old_pid
->i_extra_es
&&
4157 ( ( !pid
->es
->fmt
.psz_language
&&
4158 !old_pid
->es
->fmt
.psz_language
) ||
4159 ( pid
->es
->fmt
.psz_language
&&
4160 old_pid
->es
->fmt
.psz_language
&&
4161 !strcmp( pid
->es
->fmt
.psz_language
,
4162 old_pid
->es
->fmt
.psz_language
) ) ) )
4164 pid
->i_cc
= old_pid
->i_cc
;
4165 ts_es_t
*e
= pid
->es
;
4166 pid
->es
= old_pid
->es
;
4168 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4170 e
= pid
->extra_es
[i
];
4171 pid
->extra_es
[i
] = old_pid
->extra_es
[i
];
4172 old_pid
->extra_es
[i
] = e
;
4177 pid
->es
->id
= es_out_Add( p_demux
->out
, &pid
->es
->fmt
);
4178 for( int i
= 0; i
< pid
->i_extra_es
; i
++ )
4180 pid
->extra_es
[i
]->id
=
4181 es_out_Add( p_demux
->out
, &pid
->extra_es
[i
]->fmt
);
4183 p_sys
->i_pmt_es
+= 1 + pid
->i_extra_es
;
4187 /* Add ES to the list */
4190 PIDClean( p_demux
, old_pid
);
4191 TAB_REMOVE( i_clean
, pp_clean
, old_pid
);
4193 p_sys
->pid
[p_es
->i_pid
] = *pid
;
4195 p_dr
= PMTEsFindDescriptor( p_es
, 0x09 );
4196 if( p_dr
&& p_dr
->i_length
>= 2 )
4198 msg_Dbg( p_demux
, " * descriptor : CA (0x9) SysID 0x%x",
4199 (p_dr
->p_data
[0] << 8) | p_dr
->p_data
[1] );
4202 if( ProgramIsSelected( p_demux
, prg
->i_number
) && pid
->es
->id
!= NULL
)
4203 SetPIDFilter( p_demux
, p_es
->i_pid
, true ); /* Set demux filter */
4206 /* Set CAM descrambling */
4207 if( !ProgramIsSelected( p_demux
, prg
->i_number
)
4208 || stream_Control( p_demux
->s
, STREAM_SET_PRIVATE_ID_CA
,
4209 p_pmt
) != VLC_SUCCESS
)
4210 dvbpsi_DeletePMT( p_pmt
);
4212 for( int i
= 0; i
< i_clean
; i
++ )
4214 if( ProgramIsSelected( p_demux
, prg
->i_number
) )
4215 SetPIDFilter( p_demux
, pp_clean
[i
]->i_pid
, false );
4217 PIDClean( p_demux
, pp_clean
[i
] );
4223 static void PATCallBack( void *data
, dvbpsi_pat_t
*p_pat
)
4225 demux_t
*p_demux
= data
;
4226 demux_sys_t
*p_sys
= p_demux
->p_sys
;
4227 dvbpsi_pat_program_t
*p_program
;
4228 ts_pid_t
*pat
= &p_sys
->pid
[0];
4230 msg_Dbg( p_demux
, "PATCallBack called" );
4232 if( ( pat
->psi
->i_pat_version
!= -1 &&
4233 ( !p_pat
->b_current_next
||
4234 p_pat
->i_version
== pat
->psi
->i_pat_version
) ) ||
4237 dvbpsi_DeletePAT( p_pat
);
4241 msg_Dbg( p_demux
, "new PAT ts_id=%d version=%d current_next=%d",
4242 p_pat
->i_ts_id
, p_pat
->i_version
, p_pat
->b_current_next
);
4245 if( p_sys
->i_pmt
> 0 )
4248 ts_pid_t
**pmt_rm
= NULL
;
4250 /* Search pmt to be deleted */
4251 for( int i
= 0; i
< p_sys
->i_pmt
; i
++ )
4253 ts_pid_t
*pmt
= p_sys
->pmt
[i
];
4254 bool b_keep
= false;
4256 for( p_program
= p_pat
->p_first_program
; !b_keep
&& p_program
;
4257 p_program
= p_program
->p_next
)
4259 if( p_program
->i_pid
!= pmt
->i_pid
)
4262 for( int i_prg
= 0; !b_keep
&& i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
4263 if( p_program
->i_number
== pmt
->psi
->prg
[i_prg
]->i_number
)
4270 TAB_APPEND( i_pmt_rm
, pmt_rm
, pmt
);
4273 /* Delete all ES attached to thoses PMT */
4274 for( int i
= 2; i
< 8192; i
++ )
4276 ts_pid_t
*pid
= &p_sys
->pid
[i
];
4278 if( !pid
->b_valid
|| pid
->psi
)
4281 for( int j
= 0; j
< i_pmt_rm
&& pid
->b_valid
; j
++ )
4283 for( int i_prg
= 0; i_prg
< pid
->p_owner
->i_prg
; i_prg
++ )
4285 /* We only remove es that aren't defined by extra pmt */
4286 if( pid
->p_owner
->prg
[i_prg
]->i_pid_pmt
!= pmt_rm
[j
]->i_pid
)
4290 SetPIDFilter( p_demux
, i
, false );
4292 PIDClean( p_demux
, pid
);
4298 /* Delete PMT pid */
4299 for( int i
= 0; i
< i_pmt_rm
; i
++ )
4301 ts_pid_t
*pid
= pmt_rm
[i
];
4302 SetPIDFilter( p_demux
, pid
->i_pid
, false );
4304 for( int i_prg
= 0; i_prg
< pid
->psi
->i_prg
; i_prg
++ )
4306 const int i_number
= pid
->psi
->prg
[i_prg
]->i_number
;
4307 es_out_Control( p_demux
->out
, ES_OUT_DEL_GROUP
, i_number
);
4310 PIDClean( p_demux
, &p_sys
->pid
[pid
->i_pid
] );
4311 TAB_REMOVE( p_sys
->i_pmt
, p_sys
->pmt
, pid
);
4317 /* now create programs */
4318 for( p_program
= p_pat
->p_first_program
; p_program
!= NULL
;
4319 p_program
= p_program
->p_next
)
4321 msg_Dbg( p_demux
, " * number=%d pid=%d", p_program
->i_number
,
4323 if( p_program
->i_number
== 0 )
4326 ts_pid_t
*pmt
= &p_sys
->pid
[p_program
->i_pid
];
4328 ValidateDVBMeta( p_demux
, p_program
->i_pid
);
4333 for( int i_prg
= 0; b_add
&& i_prg
< pmt
->psi
->i_prg
; i_prg
++ )
4334 if( pmt
->psi
->prg
[i_prg
]->i_number
== p_program
->i_number
)
4342 TAB_APPEND( p_sys
->i_pmt
, p_sys
->pmt
, pmt
);
4345 PIDInit( pmt
, true, pat
->psi
);
4346 ts_prg_psi_t
*prg
= pmt
->psi
->prg
[pmt
->psi
->i_prg
-1];
4347 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
4348 prg
->handle
= dvbpsi_new( &dvbpsi_messages
, DVBPSI_MSG_DEBUG
);
4351 dvbpsi_DeletePAT( p_pat
);
4354 prg
->handle
->p_sys
= (void *) VLC_OBJECT(p_demux
);
4355 if( !dvbpsi_pmt_attach( prg
->handle
, p_program
->i_number
, PMTCallBack
, p_demux
) )
4356 msg_Err( p_demux
, "PATCallback failed attaching PMTCallback to program %d",
4357 p_program
->i_number
);
4359 prg
->handle
= dvbpsi_AttachPMT( p_program
->i_number
, PMTCallBack
, p_demux
);
4361 prg
->i_number
= p_program
->i_number
;
4362 prg
->i_pid_pmt
= p_program
->i_pid
;
4364 /* Now select PID at access level */
4365 if( ProgramIsSelected( p_demux
, p_program
->i_number
) )
4367 if( p_sys
->i_current_program
== 0 )
4368 p_sys
->i_current_program
= p_program
->i_number
;
4370 if( SetPIDFilter( p_demux
, p_program
->i_pid
, true ) )
4371 p_sys
->b_access_control
= false;
4374 pat
->psi
->i_pat_version
= p_pat
->i_version
;
4376 dvbpsi_DeletePAT( p_pat
);