?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed a segfault when --programs is used in the TS demuxer.
[vlc/solaris.git] / modules / demux / ts.c
blobe49988903ccc95f0554a2dedad22a910c8635b34
1 /*****************************************************************************
2 * ts.c: Transport Stream input module for VLC.
3 *****************************************************************************
4 * Copyright (C) 2004-2005 the VideoLAN team
5 * $Id$
6 *
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Jean-Paul Saman <jpsaman #_at_# m2x.nl>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35
36 #include <assert.h>
37
38 #include <vlc_access.h> /* DVB-specific things */
39 #include <vlc_demux.h>
40 #include <vlc_meta.h>
41 #include <vlc_epg.h>
42
43 #include <vlc_iso_lang.h>
44 #include <vlc_network.h>
45 #include <vlc_charset.h>
46 #include <vlc_fs.h>
47
48 #include "../mux/mpeg/csa.h"
49
50 /* Include dvbpsi headers */
51 #ifdef HAVE_DVBPSI_DR_H
52 # include <dvbpsi/dvbpsi.h>
53 # include <dvbpsi/demux.h>
54 # include <dvbpsi/descriptor.h>
55 # include <dvbpsi/pat.h>
56 # include <dvbpsi/pmt.h>
57 # include <dvbpsi/sdt.h>
58 # include <dvbpsi/dr.h>
59 # include <dvbpsi/psi.h>
60 #else
61 # include "dvbpsi.h"
62 # include "demux.h"
63 # include "descriptor.h"
64 # include "tables/pat.h"
65 # include "tables/pmt.h"
66 # include "tables/sdt.h"
67 # include "descriptors/dr.h"
68 # include "psi.h"
69 #endif
70
71 /* EIT support */
72 #ifdef _DVBPSI_DR_4D_H_
73 # define TS_USE_DVB_SI 1
74 # ifdef HAVE_DVBPSI_DR_H
75 # include <dvbpsi/eit.h>
76 # else
77 # include "tables/eit.h"
78 # endif
79 #endif
80
81 /* TDT support */
82 #ifdef _DVBPSI_DR_58_H_
83 # define TS_USE_TDT 1
84 # ifdef HAVE_DVBPSI_DR_H
85 # include <dvbpsi/tot.h>
86 # else
87 # include "tables/tot.h"
88 # endif
89 #else
90 # include <time.h>
91 #endif
92
93 #undef TS_DEBUG
94
95 /*****************************************************************************
96 * Module descriptor
97 *****************************************************************************/
98 static int Open ( vlc_object_t * );
99 static void Close ( vlc_object_t * );
100
101 /* TODO
102 * - Rename "extra pmt" to "user pmt"
103 * - Update extra pmt description
104 * pmt_pid[:pmt_number][=pid_description[,pid_description]]
105 * where pid_description could take 3 forms:
106 * 1. pid:pcr (to force the pcr pid)
107 * 2. pid:stream_type
108 * 3. pid:type=fourcc where type=(video|audio|spu)
109 */
110 #define PMT_TEXT N_("Extra PMT")
111 #define PMT_LONGTEXT N_( \
112 "Allows a user to specify an extra pmt (pmt_pid=pid:stream_type[,...])." )
113
114 #define PID_TEXT N_("Set id of ES to PID")
115 #define PID_LONGTEXT N_("Set the internal ID of each elementary stream" \
116 " handled by VLC to the same value as the PID in" \
117 " the TS stream, instead of 1, 2, 3, etc. Useful to" \
118 " do \'#duplicate{..., select=\"es=<pid>\"}\'.")
119
120 #define TSOUT_TEXT N_("Fast udp streaming")
121 #define TSOUT_LONGTEXT N_( \
122 "Sends TS to specific ip:port by udp (you must know what you are doing).")
123
124 #define MTUOUT_TEXT N_("MTU for out mode")
125 #define MTUOUT_LONGTEXT N_("MTU for out mode.")
126
127 #define CSA_TEXT N_("CSA ck")
128 #define CSA_LONGTEXT N_("Control word for the CSA encryption algorithm")
129
130 #define CSA2_TEXT N_("Second CSA Key")
131 #define CSA2_LONGTEXT N_("The even CSA encryption key. This must be a " \
132 "16 char string (8 hexadecimal bytes).")
133
134 #define SILENT_TEXT N_("Silent mode")
135 #define SILENT_LONGTEXT N_("Do not complain on encrypted PES.")
136
137 #define CAPMT_SYSID_TEXT N_("CAPMT System ID")
138 #define CAPMT_SYSID_LONGTEXT N_("Only forward descriptors from this SysID to the CAM.")
139
140 #define CPKT_TEXT N_("Packet size in bytes to decrypt")
141 #define CPKT_LONGTEXT N_("Specify the size of the TS packet to decrypt. " \
142 "The decryption routines subtract the TS-header from the value before " \
143 "decrypting. " )
144
145 #define TSDUMP_TEXT N_("Filename of dump")
146 #define TSDUMP_LONGTEXT N_("Specify a filename where to dump the TS in.")
147
148 #define APPEND_TEXT N_("Append")
149 #define APPEND_LONGTEXT N_( \
150 "If the file exists and this option is selected, the existing file " \
151 "will not be overwritten." )
152
153 #define DUMPSIZE_TEXT N_("Dump buffer size")
154 #define DUMPSIZE_LONGTEXT N_( \
155 "Tweak the buffer size for reading and writing an integer number of packets." \
156 "Specify the size of the buffer here and not the number of packets." )
157
158 #define SPLIT_ES_TEXT N_("Separate sub-streams")
159 #define SPLIT_ES_LONGTEXT N_( \
160 "Separate teletex/dvbs pages into independent ES. " \
161 "It can be useful to turn off this option when using stream output." )
162
163 vlc_module_begin ()
164 set_description( N_("MPEG Transport Stream demuxer") )
165 set_shortname ( "MPEG-TS" )
166 set_category( CAT_INPUT )
167 set_subcategory( SUBCAT_INPUT_DEMUX )
168
169 add_string( "ts-extra-pmt", NULL, NULL, PMT_TEXT, PMT_LONGTEXT, true )
170 add_bool( "ts-es-id-pid", true, NULL, PID_TEXT, PID_LONGTEXT, true )
171 add_string( "ts-out", NULL, NULL, TSOUT_TEXT, TSOUT_LONGTEXT, true )
172 add_integer( "ts-out-mtu", 1400, NULL, MTUOUT_TEXT,
173 MTUOUT_LONGTEXT, true )
174 add_string( "ts-csa-ck", NULL, NULL, CSA_TEXT, CSA_LONGTEXT, true )
175 add_string( "ts-csa2-ck", NULL, NULL, CSA_TEXT, CSA_LONGTEXT, true )
176 add_integer( "ts-csa-pkt", 188, NULL, CPKT_TEXT, CPKT_LONGTEXT, true )
177 add_bool( "ts-silent", false, NULL, SILENT_TEXT, SILENT_LONGTEXT, true )
178
179 add_file( "ts-dump-file", NULL, NULL, TSDUMP_TEXT, TSDUMP_LONGTEXT, false )
180 add_bool( "ts-dump-append", false, NULL, APPEND_TEXT, APPEND_LONGTEXT, false )
181 add_integer( "ts-dump-size", 16384, NULL, DUMPSIZE_TEXT,
182 DUMPSIZE_LONGTEXT, true )
183 add_bool( "ts-split-es", true, NULL, SPLIT_ES_TEXT, SPLIT_ES_LONGTEXT, false )
184
185 set_capability( "demux", 10 )
186 set_callbacks( Open, Close )
187 add_shortcut( "ts" )
188 vlc_module_end ()
189
190 /*****************************************************************************
191 * Local prototypes
192 *****************************************************************************/
193 static const char *const ppsz_teletext_type[] = {
194 "",
195 N_("Teletext"),
196 N_("Teletext subtitles"),
197 N_("Teletext: additional information"),
198 N_("Teletext: program schedule"),
199 N_("Teletext subtitles: hearing impaired")
200 };
201
202 typedef struct
203 {
204 uint8_t i_objectTypeIndication;
205 uint8_t i_streamType;
206 bool b_upStream;
207 uint32_t i_bufferSizeDB;
208 uint32_t i_maxBitrate;
209 uint32_t i_avgBitrate;
210
211 int i_decoder_specific_info_len;
212 uint8_t *p_decoder_specific_info;
213
214 } decoder_config_descriptor_t;
215
216 typedef struct
217 {
218 bool b_useAccessUnitStartFlag;
219 bool b_useAccessUnitEndFlag;
220 bool b_useRandomAccessPointFlag;
221 bool b_useRandomAccessUnitsOnlyFlag;
222 bool b_usePaddingFlag;
223 bool b_useTimeStampsFlags;
224 bool b_useIdleFlag;
225 bool b_durationFlag;
226 uint32_t i_timeStampResolution;
227 uint32_t i_OCRResolution;
228 uint8_t i_timeStampLength;
229 uint8_t i_OCRLength;
230 uint8_t i_AU_Length;
231 uint8_t i_instantBitrateLength;
232 uint8_t i_degradationPriorityLength;
233 uint8_t i_AU_seqNumLength;
234 uint8_t i_packetSeqNumLength;
235
236 uint32_t i_timeScale;
237 uint16_t i_accessUnitDuration;
238 uint16_t i_compositionUnitDuration;
239
240 uint64_t i_startDecodingTimeStamp;
241 uint64_t i_startCompositionTimeStamp;
242
243 } sl_config_descriptor_t;
244
245 typedef struct
246 {
247 bool b_ok;
248 uint16_t i_es_id;
249
250 bool b_streamDependenceFlag;
251 bool b_OCRStreamFlag;
252 uint8_t i_streamPriority;
253
254 char *psz_url;
255
256 uint16_t i_dependOn_es_id;
257 uint16_t i_OCR_es_id;
258
259 decoder_config_descriptor_t dec_descr;
260 sl_config_descriptor_t sl_descr;
261
262 } es_mpeg4_descriptor_t;
263
264 typedef struct
265 {
266 uint8_t i_iod_label, i_iod_label_scope;
267
268 /* IOD */
269 uint16_t i_od_id;
270 char *psz_url;
271
272 uint8_t i_ODProfileLevelIndication;
273 uint8_t i_sceneProfileLevelIndication;
274 uint8_t i_audioProfileLevelIndication;
275 uint8_t i_visualProfileLevelIndication;
276 uint8_t i_graphicsProfileLevelIndication;
277
278 es_mpeg4_descriptor_t es_descr[255];
279
280 } iod_descriptor_t;
281
282 typedef struct
283 {
284 dvbpsi_handle handle;
285
286 int i_version;
287 int i_number;
288 int i_pid_pcr;
289 int i_pid_pmt;
290 /* IOD stuff (mpeg4) */
291 iod_descriptor_t *iod;
292
293 } ts_prg_psi_t;
294
295 typedef struct
296 {
297 /* for special PAT/SDT case */
298 dvbpsi_handle handle; /* PAT/SDT/EIT */
299 int i_pat_version;
300 int i_sdt_version;
301
302 /* For PMT */
303 int i_prg;
304 ts_prg_psi_t **prg;
305
306 } ts_psi_t;
307
308 typedef struct
309 {
310 es_format_t fmt;
311 es_out_id_t *id;
312 int i_pes_size;
313 int i_pes_gathered;
314 block_t *p_pes;
315 block_t **pp_last;
316
317 es_mpeg4_descriptor_t *p_mpeg4desc;
318 int b_gather;
319
320 } ts_es_t;
321
322 typedef struct
323 {
324 int i_pid;
325
326 bool b_seen;
327 bool b_valid;
328 int i_cc; /* countinuity counter */
329 bool b_scrambled;
330
331 /* PSI owner (ie PMT -> PAT, ES -> PMT */
332 ts_psi_t *p_owner;
333 int i_owner_number;
334
335 /* */
336 ts_psi_t *psi;
337 ts_es_t *es;
338
339 /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
340 ts_es_t **extra_es;
341 int i_extra_es;
342
343 } ts_pid_t;
344
345 struct demux_sys_t
346 {
347 vlc_mutex_t csa_lock;
348
349 /* TS packet size (188, 192, 204) */
350 int i_packet_size;
351
352 /* how many TS packet we read at once */
353 int i_ts_read;
354
355 /* All pid */
356 ts_pid_t pid[8192];
357
358 /* All PMT */
359 bool b_user_pmt;
360 int i_pmt;
361 ts_pid_t **pmt;
362 int i_pmt_es;
363
364 /* */
365 bool b_es_id_pid;
366 csa_t *csa;
367 int i_csa_pkt_size;
368 bool b_silent;
369 bool b_split_es;
370
371 bool b_udp_out;
372 int fd; /* udp socket */
373 uint8_t *buffer;
374
375 /* */
376 bool b_access_control;
377
378 /* */
379 bool b_dvb_meta;
380 int64_t i_tdt_delta;
381 int64_t i_dvb_start;
382 int64_t i_dvb_length;
383 bool b_broken_charset; /* True if broken encoding is used in EPG/SDT */
384
385 /* */
386 int i_current_program;
387 vlc_list_t programs_list;
388
389 /* TS dump */
390 char *psz_file; /* file to dump data in */
391 FILE *p_file; /* filehandle */
392 uint64_t i_write; /* bytes written */
393 bool b_file_out; /* dump mode enabled */
394
395 /* */
396 bool b_start_record;
397 };
398
399 static int Demux ( demux_t *p_demux );
400 static int DemuxFile( demux_t *p_demux );
401 static int Control( demux_t *p_demux, int i_query, va_list args );
402
403 static void PIDInit ( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner );
404 static void PIDClean( demux_t *, ts_pid_t *pid );
405 static int PIDFillFormat( ts_pid_t *pid, int i_stream_type );
406
407 static void PATCallBack( demux_t *, dvbpsi_pat_t * );
408 static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt );
409 #ifdef TS_USE_DVB_SI
410 static void PSINewTableCallBack( demux_t *, dvbpsi_handle,
411 uint8_t i_table_id, uint16_t i_extension );
412 #endif
413 static int ChangeKeyCallback( vlc_object_t *, char const *, vlc_value_t, vlc_value_t, void * );
414
415 static inline int PIDGet( block_t *p )
416 {
417 return ( (p->p_buffer[1]&0x1f)<<8 )|p->p_buffer[2];
418 }
419
420 static bool GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
421
422 static void PCRHandle( demux_t *p_demux, ts_pid_t *, block_t * );
423
424 static iod_descriptor_t *IODNew( int , uint8_t * );
425 static void IODFree( iod_descriptor_t * );
426
427 #define TS_USER_PMT_NUMBER (0)
428 static int UserPmt( demux_t *p_demux, const char * );
429
430 #define TS_PACKET_SIZE_188 188
431 #define TS_PACKET_SIZE_192 192
432 #define TS_PACKET_SIZE_204 204
433 #define TS_PACKET_SIZE_MAX 204
434 #define TS_TOPFIELD_HEADER 1320
435
436 /*****************************************************************************
437 * Open
438 *****************************************************************************/
439 static int Open( vlc_object_t *p_this )
440 {
441 demux_t *p_demux = (demux_t*)p_this;
442 demux_sys_t *p_sys;
443
444 const uint8_t *p_peek;
445 int i_sync, i_peek, i;
446 int i_packet_size;
447
448 ts_pid_t *pat;
449 const char *psz_mode;
450 bool b_append;
451 bool b_topfield = false;
452
453 if( stream_Peek( p_demux->s, &p_peek, TS_PACKET_SIZE_MAX ) <
454 TS_PACKET_SIZE_MAX ) return VLC_EGENERIC;
455
456 if( memcmp( p_peek, "TFrc", 4 ) == 0 )
457 {
458 b_topfield = true;
459 msg_Dbg( p_demux, "this is a topfield file" );
460 }
461
462 /* Search first sync byte */
463 for( i_sync = 0; i_sync < TS_PACKET_SIZE_MAX; i_sync++ )
464 {
465 if( p_peek[i_sync] == 0x47 ) break;
466 }
467 if( i_sync >= TS_PACKET_SIZE_MAX && !b_topfield )
468 {
469 if( !p_demux->b_force )
470 return VLC_EGENERIC;
471 msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
472 }
473
474 if( b_topfield )
475 {
476 /* Read the entire Topfield header */
477 i_peek = TS_TOPFIELD_HEADER;
478 }
479 else
480 {
481 /* Check next 3 sync bytes */
482 i_peek = TS_PACKET_SIZE_MAX * 3 + i_sync + 1;
483 }
484
485 if( ( stream_Peek( p_demux->s, &p_peek, i_peek ) ) < i_peek )
486 {
487 msg_Err( p_demux, "cannot peek" );
488 return VLC_EGENERIC;
489 }
490 if( p_peek[i_sync + TS_PACKET_SIZE_188] == 0x47 &&
491 p_peek[i_sync + 2 * TS_PACKET_SIZE_188] == 0x47 &&
492 p_peek[i_sync + 3 * TS_PACKET_SIZE_188] == 0x47 )
493 {
494 i_packet_size = TS_PACKET_SIZE_188;
495 }
496 else if( p_peek[i_sync + TS_PACKET_SIZE_192] == 0x47 &&
497 p_peek[i_sync + 2 * TS_PACKET_SIZE_192] == 0x47 &&
498 p_peek[i_sync + 3 * TS_PACKET_SIZE_192] == 0x47 )
499 {
500 i_packet_size = TS_PACKET_SIZE_192;
501 }
502 else if( p_peek[i_sync + TS_PACKET_SIZE_204] == 0x47 &&
503 p_peek[i_sync + 2 * TS_PACKET_SIZE_204] == 0x47 &&
504 p_peek[i_sync + 3 * TS_PACKET_SIZE_204] == 0x47 )
505 {
506 i_packet_size = TS_PACKET_SIZE_204;
507 }
508 else if( p_demux->b_force )
509 {
510 i_packet_size = TS_PACKET_SIZE_188;
511 }
512 else if( b_topfield )
513 {
514 i_packet_size = TS_PACKET_SIZE_188;
515 #if 0
516 /* I used the TF5000PVR 2004 Firmware .doc header documentation,
517 * http://www.i-topfield.com/data/product/firmware/Structure%20of%20Recorded%20File%20in%20TF5000PVR%20(Feb%2021%202004).doc
518 * but after the filename the offsets seem to be incorrect. - DJ */
519 int i_duration, i_name;
520 char *psz_name = malloc(25);
521 char *psz_event_name;
522 char *psz_event_text = malloc(130);
523 char *psz_ext_text = malloc(1025);
524
525 // 2 bytes version Uimsbf (4,5)
526 // 2 bytes reserved (6,7)
527 // 2 bytes duration in minutes Uimsbf (8,9(
528 i_duration = (int) (p_peek[8] << 8) | p_peek[9];
529 msg_Dbg( p_demux, "Topfield recording length: +/- %d minutes", i_duration);
530 // 2 bytes service number in channel list (10, 11)
531 // 2 bytes service type Bslbf 0=TV 1=Radio Bslb (12, 13)
532 // 4 bytes of reserved + tuner info (14,15,16,17)
533 // 2 bytes of Service ID Bslbf (18,19)
534 // 2 bytes of PMT PID Uimsbf (20,21)
535 // 2 bytes of PCR PID Uimsbf (22,23)
536 // 2 bytes of Video PID Uimsbf (24,25)
537 // 2 bytes of Audio PID Uimsbf (26,27)
538 // 24 bytes filename Bslbf
539 memcpy( psz_name, &p_peek[28], 24 );
540 psz_name[24] = '\0';
541 msg_Dbg( p_demux, "recordingname=%s", psz_name );
542 // 1 byte of sat index Uimsbf (52)
543 // 3 bytes (1 bit of polarity Bslbf +23 bits reserved)
544 // 4 bytes of freq. Uimsbf (56,57,58,59)
545 // 2 bytes of symbol rate Uimsbf (60,61)
546 // 2 bytes of TS stream ID Uimsbf (62,63)
547 // 4 bytes reserved
548 // 2 bytes reserved
549 // 2 bytes duration Uimsbf (70,71)
550 //i_duration = (int) (p_peek[70] << 8) | p_peek[71];
551 //msg_Dbg( p_demux, "Topfield 2nd duration field: +/- %d minutes", i_duration);
552 // 4 bytes EventID Uimsbf (72-75)
553 // 8 bytes of Start and End time info (76-83)
554 // 1 byte reserved (84)
555 // 1 byte event name length Uimsbf (89)
556 i_name = (int)(p_peek[89]&~0x81);
557 msg_Dbg( p_demux, "event name length = %d", i_name);
558 psz_event_name = malloc( i_name+1 );
559 // 1 byte parental rating (90)
560 // 129 bytes of event text
561 memcpy( psz_event_name, &p_peek[91], i_name );
562 psz_event_name[i_name] = '\0';
563 memcpy( psz_event_text, &p_peek[91+i_name], 129-i_name );
564 psz_event_text[129-i_name] = '\0';
565 msg_Dbg( p_demux, "event name=%s", psz_event_name );
566 msg_Dbg( p_demux, "event text=%s", psz_event_text );
567 // 12 bytes reserved (220)
568 // 6 bytes reserved
569 // 2 bytes Event Text Length Uimsbf
570 // 4 bytes EventID Uimsbf
571 // FIXME We just have 613 bytes. not enough for this entire text
572 // 1024 bytes Extended Event Text Bslbf
573 memcpy( psz_ext_text, p_peek+372, 1024 );
574 psz_ext_text[1024] = '\0';
575 msg_Dbg( p_demux, "extended event text=%s", psz_ext_text );
576 // 52 bytes reserved Bslbf
577 #endif
578 }
579 else
580 {
581 msg_Warn( p_demux, "TS module discarded (lost sync)" );
582 return VLC_EGENERIC;
583 }
584
585 p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
586 if( !p_sys )
587 return VLC_ENOMEM;
588 memset( p_sys, 0, sizeof( demux_sys_t ) );
589 p_sys->i_packet_size = i_packet_size;
590 vlc_mutex_init( &p_sys->csa_lock );
591
592 /* Fill dump mode fields */
593 p_sys->i_write = 0;
594 p_sys->buffer = NULL;
595 p_sys->p_file = NULL;
596 p_sys->b_file_out = false;
597 p_sys->psz_file = var_CreateGetString( p_demux, "ts-dump-file" );
598 if( *p_sys->psz_file != '\0' )
599 {
600 p_sys->b_file_out = true;
601
602 b_append = var_CreateGetBool( p_demux, "ts-dump-append" );
603 if ( b_append )
604 psz_mode = "ab";
605 else
606 psz_mode = "wb";
607
608 if( !strcmp( p_sys->psz_file, "-" ) )
609 {
610 msg_Info( p_demux, "dumping raw stream to standard output" );
611 p_sys->p_file = stdout;
612 }
613 else if( ( p_sys->p_file = vlc_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
614 {
615 msg_Err( p_demux, "cannot create `%s' for writing", p_sys->psz_file );
616 p_sys->b_file_out = false;
617 }
618
619 if( p_sys->b_file_out )
620 {
621 /* Determine how many packets to read. */
622 int bufsize = var_CreateGetInteger( p_demux, "ts-dump-size" );
623 p_sys->i_ts_read = (int) (bufsize / p_sys->i_packet_size);
624 if( p_sys->i_ts_read <= 0 )
625 {
626 p_sys->i_ts_read = 1500 / p_sys->i_packet_size;
627 }
628 p_sys->buffer = xmalloc( p_sys->i_packet_size * p_sys->i_ts_read );
629 msg_Info( p_demux, "%s raw stream to file `%s' reading packets %d",
630 b_append ? "appending" : "dumping", p_sys->psz_file,
631 p_sys->i_ts_read );
632 }
633 }
634
635 /* Fill p_demux field */
636 if( p_sys->b_file_out )
637 p_demux->pf_demux = DemuxFile;
638 else
639 p_demux->pf_demux = Demux;
640 p_demux->pf_control = Control;
641
642 /* Init p_sys field */
643 p_sys->b_dvb_meta = true;
644 p_sys->b_access_control = true;
645 p_sys->i_current_program = 0;
646 p_sys->programs_list.i_count = 0;
647 p_sys->programs_list.p_values = NULL;
648 p_sys->i_tdt_delta = 0;
649 p_sys->i_dvb_start = 0;
650 p_sys->i_dvb_length = 0;
651
652 p_sys->b_broken_charset = false;
653
654 for( i = 0; i < 8192; i++ )
655 {
656 ts_pid_t *pid = &p_sys->pid[i];
657
658 pid->i_pid = i;
659 pid->b_seen = false;
660 pid->b_valid = false;
661 }
662 /* PID 8191 is padding */
663 p_sys->pid[8191].b_seen = true;
664 p_sys->i_packet_size = i_packet_size;
665 p_sys->b_udp_out = false;
666 p_sys->fd = -1;
667 p_sys->i_ts_read = 50;
668 p_sys->csa = NULL;
669 p_sys->b_start_record = false;
670
671 /* Init PAT handler */
672 pat = &p_sys->pid[0];
673 PIDInit( pat, true, NULL );
674 pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack,
675 p_demux );
676 #ifdef TS_USE_DVB_SI
677 if( p_sys->b_dvb_meta )
678 {
679 ts_pid_t *sdt = &p_sys->pid[0x11];
680 ts_pid_t *eit = &p_sys->pid[0x12];
681
682 PIDInit( sdt, true, NULL );
683 sdt->psi->handle =
684 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
685 p_demux );
686 PIDInit( eit, true, NULL );
687 eit->psi->handle =
688 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
689 p_demux );
690 #ifdef TS_USE_TDT
691 ts_pid_t *tdt = &p_sys->pid[0x14];
692 PIDInit( tdt, true, NULL );
693 tdt->psi->handle =
694 dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
695 p_demux );
696 #endif
697 if( p_sys->b_access_control )
698 {
699 if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
700 ACCESS_SET_PRIVATE_ID_STATE, 0x11, true ) ||
701 #ifdef TS_USE_TDT
702 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
703 ACCESS_SET_PRIVATE_ID_STATE, 0x14, true ) ||
704 #endif
705 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
706 ACCESS_SET_PRIVATE_ID_STATE, 0x12, true ) )
707 p_sys->b_access_control = false;
708 }
709 }
710 #endif
711
712 /* Init PMT array */
713 TAB_INIT( p_sys->i_pmt, p_sys->pmt );
714 p_sys->i_pmt_es = 0;
715
716 /* Read config */
717 p_sys->b_es_id_pid = var_CreateGetBool( p_demux, "ts-es-id-pid" );
718
719 char* psz_string = var_CreateGetString( p_demux, "ts-out" );
720 if( psz_string && *psz_string && !p_sys->b_file_out )
721 {
722 char *psz = strchr( psz_string, ':' );
723 int i_port = 0;
724
725 p_sys->b_udp_out = true;
726
727 if( psz )
728 {
729 *psz++ = '\0';
730 i_port = atoi( psz );
731 }
732 if( i_port <= 0 ) i_port = 1234;
733 msg_Dbg( p_demux, "resend ts to '%s:%d'", psz_string, i_port );
734
735 p_sys->fd = net_ConnectUDP( VLC_OBJECT(p_demux), psz_string, i_port, -1 );
736 if( p_sys->fd < 0 )
737 {
738 msg_Err( p_demux, "failed to open udp socket, send disabled" );
739 p_sys->b_udp_out = false;
740 }
741 else
742 {
743 int i_mtu = var_CreateGetInteger( p_demux, "ts-out-mtu" );
744 p_sys->i_ts_read = i_mtu / p_sys->i_packet_size;
745 if( p_sys->i_ts_read <= 0 )
746 {
747 p_sys->i_ts_read = 1500 / p_sys->i_packet_size;
748 }
749 p_sys->buffer = malloc( p_sys->i_packet_size * p_sys->i_ts_read );
750 }
751 }
752 free( psz_string );
753
754 /* We handle description of an extra PMT */
755 psz_string = var_CreateGetString( p_demux, "ts-extra-pmt" );
756 p_sys->b_user_pmt = false;
757 if( psz_string && *psz_string )
758 UserPmt( p_demux, psz_string );
759 free( psz_string );
760
761 psz_string = var_CreateGetStringCommand( p_demux, "ts-csa-ck" );
762 if( psz_string && *psz_string )
763 {
764 int i_res;
765 char* psz_csa2;
766
767 p_sys->csa = csa_New();
768
769 psz_csa2 = var_CreateGetStringCommand( p_demux, "ts-csa2-ck" );
770 i_res = csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, true );
771 if( i_res == VLC_SUCCESS && psz_csa2 && *psz_csa2 )
772 {
773 if( csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_csa2, false ) != VLC_SUCCESS )
774 {
775 csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, false );
776 }
777 }
778 else if ( i_res == VLC_SUCCESS )
779 {
780 csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, false );
781 }
782 else
783 {
784 csa_Delete( p_sys->csa );
785 p_sys->csa = NULL;
786 }
787
788 if( p_sys->csa )
789 {
790 var_AddCallback( p_demux, "ts-csa-ck", ChangeKeyCallback, (void *)1 );
791 var_AddCallback( p_demux, "ts-csa2-ck", ChangeKeyCallback, NULL );
792
793 int i_pkt = var_CreateGetInteger( p_demux, "ts-csa-pkt" );
794 if( i_pkt < 4 || i_pkt > 188 )
795 {
796 msg_Err( p_demux, "wrong packet size %d specified.", i_pkt );
797 msg_Warn( p_demux, "using default packet size of 188 bytes" );
798 p_sys->i_csa_pkt_size = 188;
799 }
800 else
801 p_sys->i_csa_pkt_size = i_pkt;
802 msg_Dbg( p_demux, "decrypting %d bytes of packet", p_sys->i_csa_pkt_size );
803 }
804 free( psz_csa2 );
805 }
806 free( psz_string );
807
808 p_sys->b_silent = var_CreateGetBool( p_demux, "ts-silent" );
809 p_sys->b_split_es = var_InheritBool( p_demux, "ts-split-es" );
810
811 while( !p_sys->b_file_out && p_sys->i_pmt_es <= 0 &&
812 vlc_object_alive( p_demux ) )
813 {
814 if( p_demux->pf_demux( p_demux ) != 1 )
815 break;
816 }
817
818
819 return VLC_SUCCESS;
820 }
821
822 /*****************************************************************************
823 * Close
824 *****************************************************************************/
825 static void Close( vlc_object_t *p_this )
826 {
827 demux_t *p_demux = (demux_t*)p_this;
828 demux_sys_t *p_sys = p_demux->p_sys;
829
830 msg_Dbg( p_demux, "pid list:" );
831 for( int i = 0; i < 8192; i++ )
832 {
833 ts_pid_t *pid = &p_sys->pid[i];
834
835 if( pid->b_valid && pid->psi )
836 {
837 switch( pid->i_pid )
838 {
839 case 0: /* PAT */
840 dvbpsi_DetachPAT( pid->psi->handle );
841 free( pid->psi );
842 break;
843 case 1: /* CAT */
844 free( pid->psi );
845 break;
846 default:
847 if( p_sys->b_dvb_meta && ( pid->i_pid == 0x11 || pid->i_pid == 0x12 || pid->i_pid == 0x14 ) )
848 {
849 /* SDT or EIT or TDT */
850 dvbpsi_DetachDemux( pid->psi->handle );
851 free( pid->psi );
852 }
853 else
854 {
855 PIDClean( p_demux, pid );
856 }
857 break;
858 }
859 }
860 else if( pid->b_valid && pid->es )
861 {
862 PIDClean( p_demux, pid );
863 }
864
865 if( pid->b_seen )
866 {
867 msg_Dbg( p_demux, " - pid[%d] seen", pid->i_pid );
868 }
869
870 if( p_sys->b_access_control && pid->i_pid > 0 )
871 {
872 /* too much */
873 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
874 ACCESS_SET_PRIVATE_ID_STATE, pid->i_pid,
875 false );
876 }
877 }
878
879 vlc_mutex_lock( &p_sys->csa_lock );
880 if( p_sys->csa )
881 {
882 var_DelCallback( p_demux, "ts-csa-ck", ChangeKeyCallback, NULL );
883 var_DelCallback( p_demux, "ts-csa2-ck", ChangeKeyCallback, NULL );
884 csa_Delete( p_sys->csa );
885 }
886 vlc_mutex_unlock( &p_sys->csa_lock );
887
888 TAB_CLEAN( p_sys->i_pmt, p_sys->pmt );
889
890 free( p_sys->programs_list.p_values );
891
892 /* If in dump mode, then close the file */
893 if( p_sys->b_file_out )
894 {
895 msg_Info( p_demux ,"closing %s (%"PRId64" KiB dumped)",
896 p_sys->psz_file, p_sys->i_write / 1024 );
897
898 if( p_sys->p_file != stdout )
899 {
900 fclose( p_sys->p_file );
901 }
902 }
903 /* When streaming, close the port */
904 if( p_sys->fd > -1 )
905 {
906 net_Close( p_sys->fd );
907 }
908
909 free( p_sys->buffer );
910 free( p_sys->psz_file );
911
912 vlc_mutex_destroy( &p_sys->csa_lock );
913 free( p_sys );
914 }
915
916 /*****************************************************************************
917 * ChangeKeyCallback: called when changing the odd encryption key on the fly.
918 *****************************************************************************/
919 static int ChangeKeyCallback( vlc_object_t *p_this, char const *psz_cmd,
920 vlc_value_t oldval, vlc_value_t newval,
921 void *p_data )
922 {
923 VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
924 demux_t *p_demux = (demux_t*)p_this;
925 demux_sys_t *p_sys = p_demux->p_sys;
926 int i_tmp = (intptr_t)p_data;
927
928 vlc_mutex_lock( &p_sys->csa_lock );
929 if ( i_tmp )
930 i_tmp = csa_SetCW( p_this, p_sys->csa, newval.psz_string, true );
931 else
932 i_tmp = csa_SetCW( p_this, p_sys->csa, newval.psz_string, false );
933
934 vlc_mutex_unlock( &p_sys->csa_lock );
935 return i_tmp;
936 }
937
938 /*****************************************************************************
939 * DemuxFile:
940 *****************************************************************************/
941 static int DemuxFile( demux_t *p_demux )
942 {
943 demux_sys_t *p_sys = p_demux->p_sys;
944 const int i_bufsize = p_sys->i_packet_size * p_sys->i_ts_read;
945 uint8_t *p_buffer = p_sys->buffer; /* Put first on sync byte */
946 const int i_data = stream_Read( p_demux->s, p_sys->buffer, i_bufsize );
947
948 if( i_data <= 0 && i_data < p_sys->i_packet_size )
949 {
950 msg_Dbg( p_demux, "error reading malformed packets" );
951 return i_data;
952 }
953
954 /* Test continuity counter */
955 for( int i_pos = 0; i_pos < i_data; )
956 {
957 if( p_sys->buffer[i_pos] != 0x47 )
958 {
959 msg_Warn( p_demux, "lost sync" );
960 while( vlc_object_alive (p_demux) && (i_pos < i_data) )
961 {
962 i_pos++;
963 if( p_sys->buffer[i_pos] == 0x47 )
964 break;
965 }
966 if( vlc_object_alive (p_demux) )
967 msg_Warn( p_demux, "sync found" );
968 }
969
970 /* continuous when (one of this):
971 * diff == 1
972 * diff == 0 and payload == 0
973 * diff == 0 and duplicate packet (playload != 0) <- should we
974 * test the content ?
975 */
976 const int i_cc = p_buffer[i_pos+3]&0x0f;
977 const bool b_payload = p_buffer[i_pos+3]&0x10;
978 const bool b_adaptation = p_buffer[i_pos+3]&0x20;
979
980 /* Get the PID */
981 ts_pid_t *p_pid = &p_sys->pid[ ((p_buffer[i_pos+1]&0x1f)<<8)|p_buffer[i_pos+2] ];
982
983 /* Detect discontinuity indicator in adaptation field */
984 if( b_adaptation && p_buffer[i_pos + 4] > 0 )
985 {
986 if( p_buffer[i_pos+5]&0x80 )
987 msg_Warn( p_demux, "discontinuity indicator (pid=%d) ", p_pid->i_pid );
988 if( p_buffer[i_pos+5]&0x40 )
989 msg_Warn( p_demux, "random access indicator (pid=%d) ", p_pid->i_pid );
990 }
991
992 const int i_diff = ( i_cc - p_pid->i_cc )&0x0f;
993 if( b_payload && i_diff == 1 )
994 {
995 p_pid->i_cc = ( p_pid->i_cc + 1 ) & 0xf;
996 }
997 else
998 {
999 if( p_pid->i_cc == 0xff )
1000 {
1001 msg_Warn( p_demux, "first packet for pid=%d cc=0x%x",
1002 p_pid->i_pid, i_cc );
1003 p_pid->i_cc = i_cc;
1004 }
1005 else if( i_diff != 0 )
1006 {
1007 /* FIXME what to do when discontinuity_indicator is set ? */
1008 msg_Warn( p_demux, "transport error detected 0x%x instead of 0x%x",
1009 i_cc, ( p_pid->i_cc + 1 )&0x0f );
1010
1011 p_pid->i_cc = i_cc;
1012 /* Mark transport error in the TS packet. */
1013 p_buffer[i_pos+1] |= 0x80;
1014 }
1015 }
1016
1017 /* Test if user wants to decrypt it first */
1018 if( p_sys->csa )
1019 {
1020 vlc_mutex_lock( &p_sys->csa_lock );
1021 csa_Decrypt( p_demux->p_sys->csa, &p_buffer[i_pos], p_demux->p_sys->i_csa_pkt_size );
1022 vlc_mutex_unlock( &p_sys->csa_lock );
1023 }
1024
1025 i_pos += p_sys->i_packet_size;
1026 }
1027
1028 /* Then write */
1029 const int i_write = fwrite( p_sys->buffer, 1, i_data, p_sys->p_file );
1030 if( i_write < 0 )
1031 {
1032 msg_Err( p_demux, "failed to write data" );
1033 return -1;
1034 }
1035
1036 p_sys->i_write += i_write;
1037 return 1;
1038 }
1039
1040 /*****************************************************************************
1041 * Demux:
1042 *****************************************************************************/
1043 static int Demux( demux_t *p_demux )
1044 {
1045 demux_sys_t *p_sys = p_demux->p_sys;
1046 bool b_wait_es = p_sys->i_pmt_es <= 0;
1047
1048 /* We read at most 100 TS packet or until a frame is completed */
1049 for( int i_pkt = 0; i_pkt < p_sys->i_ts_read; i_pkt++ )
1050 {
1051 bool b_frame = false;
1052 block_t *p_pkt;
1053
1054 /* Get a new TS packet */
1055 if( !( p_pkt = stream_Block( p_demux->s, p_sys->i_packet_size ) ) )
1056 {
1057 msg_Dbg( p_demux, "eof ?" );
1058 return 0;
1059 }
1060
1061 /* Check sync byte and re-sync if needed */
1062 if( p_pkt->p_buffer[0] != 0x47 )
1063 {
1064 msg_Warn( p_demux, "lost synchro" );
1065 block_Release( p_pkt );
1066
1067 while( vlc_object_alive (p_demux) )
1068 {
1069 const uint8_t *p_peek;
1070 int i_peek, i_skip = 0;
1071
1072 i_peek = stream_Peek( p_demux->s, &p_peek,
1073 p_sys->i_packet_size * 10 );
1074 if( i_peek < p_sys->i_packet_size + 1 )
1075 {
1076 msg_Dbg( p_demux, "eof ?" );
1077 return 0;
1078 }
1079
1080 while( i_skip < i_peek - p_sys->i_packet_size )
1081 {
1082 if( p_peek[i_skip] == 0x47 &&
1083 p_peek[i_skip + p_sys->i_packet_size] == 0x47 )
1084 {
1085 break;
1086 }
1087 i_skip++;
1088 }
1089
1090 msg_Dbg( p_demux, "skipping %d bytes of garbage", i_skip );
1091 stream_Read( p_demux->s, NULL, i_skip );
1092
1093 if( i_skip < i_peek - p_sys->i_packet_size )
1094 {
1095 break;
1096 }
1097 }
1098
1099 if( !( p_pkt = stream_Block( p_demux->s, p_sys->i_packet_size ) ) )
1100 {
1101 msg_Dbg( p_demux, "eof ?" );
1102 return 0;
1103 }
1104 }
1105
1106 if( p_sys->b_start_record )
1107 {
1108 /* Enable recording once synchronized */
1109 stream_Control( p_demux->s, STREAM_SET_RECORD_STATE, true, "ts" );
1110 p_sys->b_start_record = false;
1111 }
1112
1113 if( p_sys->b_udp_out )
1114 {
1115 memcpy( &p_sys->buffer[i_pkt * p_sys->i_packet_size],
1116 p_pkt->p_buffer, p_sys->i_packet_size );
1117 }
1118
1119 /* Parse the TS packet */
1120 ts_pid_t *p_pid = &p_sys->pid[PIDGet( p_pkt )];
1121
1122 if( p_pid->b_valid )
1123 {
1124 if( p_pid->psi )
1125 {
1126 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 ) ) )
1127 {
1128 dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
1129 }
1130 else
1131 {
1132 for( int i_prg = 0; i_prg < p_pid->psi->i_prg; i_prg++ )
1133 {
1134 dvbpsi_PushPacket( p_pid->psi->prg[i_prg]->handle,
1135 p_pkt->p_buffer );
1136 }
1137 }
1138 block_Release( p_pkt );
1139 }
1140 else if( !p_sys->b_udp_out )
1141 {
1142 b_frame = GatherPES( p_demux, p_pid, p_pkt );
1143 }
1144 else
1145 {
1146 PCRHandle( p_demux, p_pid, p_pkt );
1147 block_Release( p_pkt );
1148 }
1149 }
1150 else
1151 {
1152 if( !p_pid->b_seen )
1153 {
1154 msg_Dbg( p_demux, "pid[%d] unknown", p_pid->i_pid );
1155 }
1156 /* We have to handle PCR if present */
1157 PCRHandle( p_demux, p_pid, p_pkt );
1158 block_Release( p_pkt );
1159 }
1160 p_pid->b_seen = true;
1161
1162 if( b_frame || ( b_wait_es && p_sys->i_pmt_es > 0 ) )
1163 break;
1164 }
1165
1166 if( p_sys->b_udp_out )
1167 {
1168 /* Send the complete block */
1169 net_Write( p_demux, p_sys->fd, NULL, p_sys->buffer,
1170 p_sys->i_ts_read * p_sys->i_packet_size );
1171 }
1172
1173 return 1;
1174 }
1175
1176 /*****************************************************************************
1177 * Control:
1178 *****************************************************************************/
1179 static int DVBEventInformation( demux_t *p_demux, int64_t *pi_time, int64_t *pi_length )
1180 {
1181 demux_sys_t *p_sys = p_demux->p_sys;
1182 if( pi_length )
1183 *pi_length = 0;
1184 if( pi_time )
1185 *pi_time = 0;
1186
1187 if( p_sys->i_dvb_length > 0 )
1188 {
1189 #ifdef TS_USE_TDT
1190 const int64_t t = mdate() + p_sys->i_tdt_delta;
1191 #else
1192 const int64_t t = CLOCK_FREQ * time ( NULL );
1193 #endif
1194
1195 if( p_sys->i_dvb_start <= t && t < p_sys->i_dvb_start + p_sys->i_dvb_length )
1196 {
1197 if( pi_length )
1198 *pi_length = p_sys->i_dvb_length;
1199 if( pi_time )
1200 *pi_time = t - p_sys->i_dvb_start;
1201 return VLC_SUCCESS;
1202 }
1203 }
1204 return VLC_EGENERIC;
1205 }
1206
1207 static int Control( demux_t *p_demux, int i_query, va_list args )
1208 {
1209 demux_sys_t *p_sys = p_demux->p_sys;
1210 double f, *pf;
1211 bool b_bool, *pb_bool;
1212 int64_t i64;
1213 int64_t *pi64;
1214 int i_int;
1215
1216 if( p_sys->b_file_out )
1217 return demux_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
1218
1219 switch( i_query )
1220 {
1221 case DEMUX_GET_POSITION:
1222 pf = (double*) va_arg( args, double* );
1223 i64 = stream_Size( p_demux->s );
1224 if( i64 > 0 )
1225 {
1226 double f_current = stream_Tell( p_demux->s );
1227 *pf = f_current / (double)i64;
1228 }
1229 else
1230 {
1231 int64_t i_time, i_length;
1232 if( !DVBEventInformation( p_demux, &i_time, &i_length ) && i_length > 0 )
1233 *pf = (double)i_time/(double)i_length;
1234 else
1235 *pf = 0.0;
1236 }
1237 return VLC_SUCCESS;
1238 case DEMUX_SET_POSITION:
1239 f = (double) va_arg( args, double );
1240 i64 = stream_Size( p_demux->s );
1241
1242 if( stream_Seek( p_demux->s, (int64_t)(i64 * f) ) )
1243 return VLC_EGENERIC;
1244
1245 return VLC_SUCCESS;
1246 #if 0
1247
1248 case DEMUX_GET_TIME:
1249 pi64 = (int64_t*)va_arg( args, int64_t * );
1250 if( p_sys->i_time < 0 )
1251 {
1252 *pi64 = 0;
1253 return VLC_EGENERIC;
1254 }
1255 *pi64 = p_sys->i_time;
1256 return VLC_SUCCESS;
1257
1258 case DEMUX_GET_LENGTH:
1259 pi64 = (int64_t*)va_arg( args, int64_t * );
1260 if( p_sys->i_mux_rate > 0 )
1261 {
1262 *pi64 = INT64_C(1000000) * ( stream_Size( p_demux->s ) / 50 ) /
1263 p_sys->i_mux_rate;
1264 return VLC_SUCCESS;
1265 }
1266 *pi64 = 0;
1267 return VLC_EGENERIC;
1268 #else
1269 case DEMUX_GET_TIME:
1270 pi64 = (int64_t*)va_arg( args, int64_t * );
1271 if( DVBEventInformation( p_demux, pi64, NULL ) )
1272 *pi64 = 0;
1273 return VLC_SUCCESS;
1274
1275 case DEMUX_GET_LENGTH:
1276 pi64 = (int64_t*)va_arg( args, int64_t * );
1277 if( DVBEventInformation( p_demux, NULL, pi64 ) )
1278 *pi64 = 0;
1279 return VLC_SUCCESS;
1280 #endif
1281 case DEMUX_SET_GROUP:
1282 {
1283 uint16_t i_vpid = 0, i_apid1 = 0, i_apid2 = 0, i_apid3 = 0;
1284 ts_prg_psi_t *p_prg = NULL;
1285 vlc_list_t *p_list;
1286
1287 i_int = (int)va_arg( args, int );
1288 p_list = (vlc_list_t *)va_arg( args, vlc_list_t * );
1289 msg_Dbg( p_demux, "DEMUX_SET_GROUP %d %p", i_int, p_list );
1290
1291 if( p_sys->b_access_control && i_int > 0 && i_int != p_sys->i_current_program )
1292 {
1293 int i_pmt_pid = -1;
1294
1295 /* Search pmt to be unselected */
1296 for( int i = 0; i < p_sys->i_pmt; i++ )
1297 {
1298 ts_pid_t *pmt = p_sys->pmt[i];
1299
1300 for( int i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
1301 {
1302 if( pmt->psi->prg[i_prg]->i_number == p_sys->i_current_program )
1303 {
1304 i_pmt_pid = p_sys->pmt[i]->i_pid;
1305 break;
1306 }
1307 }
1308 if( i_pmt_pid > 0 ) break;
1309 }
1310
1311 if( i_pmt_pid > 0 )
1312 {
1313 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
1314 ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
1315 false );
1316 /* All ES */
1317 for( int i = 2; i < 8192; i++ )
1318 {
1319 ts_pid_t *pid = &p_sys->pid[i];
1320
1321 if( !pid->b_valid || pid->psi )
1322 continue;
1323
1324 for( int i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
1325 {
1326 if( pid->p_owner->prg[i_prg]->i_pid_pmt == i_pmt_pid && pid->es->id )
1327 {
1328 /* We only remove es that aren't defined by extra pmt */
1329 stream_Control( p_demux->s,
1330 STREAM_CONTROL_ACCESS,
1331 ACCESS_SET_PRIVATE_ID_STATE,
1332 i, false );
1333 break;
1334 }
1335 }
1336 }
1337 }
1338
1339 /* select new program */
1340 p_sys->i_current_program = i_int;
1341 i_pmt_pid = -1;
1342 for( int i = 0; i < p_sys->i_pmt; i++ )
1343 {
1344 ts_pid_t *pmt = p_sys->pmt[i];
1345
1346 for( int i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
1347 {
1348 if( pmt->psi->prg[i_prg]->i_number == i_int )
1349 {
1350 i_pmt_pid = p_sys->pmt[i]->i_pid;
1351 p_prg = p_sys->pmt[i]->psi->prg[i_prg];
1352 break;
1353 }
1354 }
1355 if( i_pmt_pid > 0 )
1356 break;
1357 }
1358 if( i_pmt_pid > 0 )
1359 {
1360 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
1361 ACCESS_SET_PRIVATE_ID_STATE, i_pmt_pid,
1362 true );
1363 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
1364 ACCESS_SET_PRIVATE_ID_STATE, p_prg->i_pid_pcr,
1365 true );
1366
1367 for( int i = 2; i < 8192; i++ )
1368 {
1369 ts_pid_t *pid = &p_sys->pid[i];
1370
1371 if( !pid->b_valid || pid->psi )
1372 continue;
1373
1374 for( int i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
1375 {
1376 if( pid->p_owner->prg[i_prg]->i_pid_pmt == i_pmt_pid && pid->es->id )
1377 {
1378 if ( pid->es->fmt.i_cat == VIDEO_ES && !i_vpid )
1379 i_vpid = i;
1380 if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid1 )
1381 i_apid1 = i;
1382 else if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid2 )
1383 i_apid2 = i;
1384 else if ( pid->es->fmt.i_cat == AUDIO_ES && !i_apid3 )
1385 i_apid3 = i;
1386
1387 stream_Control( p_demux->s,
1388 STREAM_CONTROL_ACCESS,
1389 ACCESS_SET_PRIVATE_ID_STATE,
1390 i, true );
1391 break;
1392 }
1393 }
1394 }
1395 }
1396 }
1397 else
1398 {
1399 p_sys->i_current_program = -1;
1400 p_sys->programs_list.i_count = 0;
1401 if( p_list )
1402 {
1403 vlc_list_t *p_dst = &p_sys->programs_list;
1404 free( p_dst->p_values );
1405
1406 p_dst->p_values = calloc( p_list->i_count,
1407 sizeof(*p_dst->p_values) );
1408 if( p_dst->p_values )
1409 {
1410 p_dst->i_count = p_list->i_count;
1411 for( int i = 0; i < p_list->i_count; i++ )
1412 p_dst->p_values[i] = p_list->p_values[i];
1413 }
1414 }
1415 }
1416 return VLC_SUCCESS;
1417 }
1418
1419 case DEMUX_CAN_RECORD:
1420 pb_bool = (bool*)va_arg( args, bool * );
1421 *pb_bool = true;
1422 return VLC_SUCCESS;
1423
1424 case DEMUX_SET_RECORD_STATE:
1425 b_bool = (bool)va_arg( args, int );
1426
1427 if( !b_bool )
1428 stream_Control( p_demux->s, STREAM_SET_RECORD_STATE, false );
1429 p_sys->b_start_record = b_bool;
1430 return VLC_SUCCESS;
1431
1432 case DEMUX_GET_FPS:
1433 case DEMUX_SET_TIME:
1434 default:
1435 return VLC_EGENERIC;
1436 }
1437 }
1438
1439 /*****************************************************************************
1440 *
1441 *****************************************************************************/
1442 static int UserPmt( demux_t *p_demux, const char *psz_fmt )
1443 {
1444 demux_sys_t *p_sys = p_demux->p_sys;
1445 char *psz_dup = strdup( psz_fmt );
1446 char *psz = psz_dup;
1447 int i_pid;
1448 int i_number;
1449
1450 if( !psz_dup )
1451 return VLC_ENOMEM;
1452
1453 /* Parse PID */
1454 i_pid = strtol( psz, &psz, 0 );
1455 if( i_pid < 2 || i_pid >= 8192 )
1456 goto error;
1457
1458 /* Parse optional program number */
1459 i_number = 0;
1460 if( *psz == ':' )
1461 i_number = strtol( &psz[1], &psz, 0 );
1462
1463 /* */
1464 ts_pid_t *pmt = &p_sys->pid[i_pid];
1465 ts_prg_psi_t *prg;
1466
1467 msg_Dbg( p_demux, "user pmt specified (pid=%d,number=%d)", i_pid, i_number );
1468 PIDInit( pmt, true, NULL );
1469
1470 /* Dummy PMT */
1471 prg = malloc( sizeof( ts_prg_psi_t ) );
1472 if( !prg )
1473 goto error;
1474
1475 memset( prg, 0, sizeof( ts_prg_psi_t ) );
1476 prg->i_pid_pcr = -1;
1477 prg->i_pid_pmt = -1;
1478 prg->i_version = -1;
1479 prg->i_number = i_number != 0 ? i_number : TS_USER_PMT_NUMBER;
1480 prg->handle = dvbpsi_AttachPMT( i_number != TS_USER_PMT_NUMBER ? i_number : 1, (dvbpsi_pmt_callback)PMTCallBack, p_demux );
1481 TAB_APPEND( pmt->psi->i_prg, pmt->psi->prg, prg );
1482
1483 psz = strchr( psz, '=' );
1484 if( psz )
1485 psz++;
1486 while( psz && *psz )
1487 {
1488 char *psz_next = strchr( psz, ',' );
1489 int i_pid;
1490
1491 if( psz_next )
1492 *psz_next++ = '\0';
1493
1494 i_pid = strtol( psz, &psz, 0 );
1495 if( *psz != ':' || i_pid < 2 || i_pid >= 8192 )
1496 goto next;
1497
1498 char *psz_opt = &psz[1];
1499 if( !strcmp( psz_opt, "pcr" ) )
1500 {
1501 prg->i_pid_pcr = i_pid;
1502 }
1503 else if( !p_sys->pid[i_pid].b_valid )
1504 {
1505 ts_pid_t *pid = &p_sys->pid[i_pid];
1506
1507 char *psz_arg = strchr( psz_opt, '=' );
1508 if( psz_arg )
1509 *psz_arg++ = '\0';
1510
1511 PIDInit( pid, false, pmt->psi);
1512 if( prg->i_pid_pcr <= 0 )
1513 prg->i_pid_pcr = i_pid;
1514
1515 if( psz_arg && strlen( psz_arg ) == 4 )
1516 {
1517 const vlc_fourcc_t i_codec = VLC_FOURCC( psz_arg[0], psz_arg[1],
1518 psz_arg[2], psz_arg[3] );
1519 int i_cat = UNKNOWN_ES;
1520 es_format_t *fmt = &pid->es->fmt;
1521
1522 if( !strcmp( psz_opt, "video" ) )
1523 i_cat = VIDEO_ES;
1524 else if( !strcmp( psz_opt, "audio" ) )
1525 i_cat = AUDIO_ES;
1526 else if( !strcmp( psz_opt, "spu" ) )
1527 i_cat = SPU_ES;
1528
1529 es_format_Init( fmt, i_cat, i_codec );
1530 fmt->b_packetized = false;
1531 }
1532 else
1533 {
1534 const int i_stream_type = strtol( psz_opt, NULL, 0 );
1535 PIDFillFormat( pid, i_stream_type );
1536 }
1537 pid->es->fmt.i_group = i_number;
1538 if( p_sys->b_es_id_pid )
1539 pid->es->fmt.i_id = i_pid;
1540
1541 if( pid->es->fmt.i_cat != UNKNOWN_ES )
1542 {
1543 msg_Dbg( p_demux, " * es pid=%d fcc=%4.4s", i_pid,
1544 (char*)&pid->es->fmt.i_codec );
1545 pid->es->id = es_out_Add( p_demux->out,
1546 &pid->es->fmt );
1547 p_sys->i_pmt_es++;
1548 }
1549 }
1550
1551 next:
1552 psz = psz_next;
1553 }
1554
1555 p_sys->b_user_pmt = true;
1556 TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
1557 free( psz_dup );
1558 return VLC_SUCCESS;
1559
1560 error:
1561 free( psz_dup );
1562 return VLC_EGENERIC;
1563 }
1564
1565 static void PIDInit( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner )
1566 {
1567 bool b_old_valid = pid->b_valid;
1568
1569 pid->b_valid = true;
1570 pid->i_cc = 0xff;
1571 pid->b_scrambled = false;
1572 pid->p_owner = p_owner;
1573 pid->i_owner_number = 0;
1574
1575 TAB_INIT( pid->i_extra_es, pid->extra_es );
1576
1577 if( b_psi )
1578 {
1579 pid->es = NULL;
1580
1581 if( !b_old_valid )
1582 {
1583 pid->psi = xmalloc( sizeof( ts_psi_t ) );
1584 if( pid->psi )
1585 {
1586 pid->psi->handle = NULL;
1587 TAB_INIT( pid->psi->i_prg, pid->psi->prg );
1588 }
1589 }
1590 assert( pid->psi );
1591
1592 pid->psi->i_pat_version = -1;
1593 pid->psi->i_sdt_version = -1;
1594 if( p_owner )
1595 {
1596 ts_prg_psi_t *prg = malloc( sizeof( ts_prg_psi_t ) );
1597 if( prg )
1598 {
1599 /* PMT */
1600 prg->i_version = -1;
1601 prg->i_number = -1;
1602 prg->i_pid_pcr = -1;
1603 prg->i_pid_pmt = -1;
1604 prg->iod = NULL;
1605 prg->handle = NULL;
1606
1607 TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
1608 }
1609 }
1610 }
1611 else
1612 {
1613 pid->psi = NULL;
1614 pid->es = malloc( sizeof( ts_es_t ) );
1615 if( pid->es )
1616 {
1617 es_format_Init( &pid->es->fmt, UNKNOWN_ES, 0 );
1618 pid->es->id = NULL;
1619 pid->es->p_pes = NULL;
1620 pid->es->i_pes_size= 0;
1621 pid->es->i_pes_gathered= 0;
1622 pid->es->pp_last = &pid->es->p_pes;
1623 pid->es->p_mpeg4desc = NULL;
1624 pid->es->b_gather = false;
1625 }
1626 }
1627 }
1628
1629 static void PIDClean( demux_t *p_demux, ts_pid_t *pid )
1630 {
1631 demux_sys_t *p_sys = p_demux->p_sys;
1632 es_out_t *out = p_demux->out;
1633
1634 if( pid->psi )
1635 {
1636 if( pid->psi->handle )
1637 dvbpsi_DetachPMT( pid->psi->handle );
1638 for( int i = 0; i < pid->psi->i_prg; i++ )
1639 {
1640 if( pid->psi->prg[i]->iod )
1641 IODFree( pid->psi->prg[i]->iod );
1642 if( pid->psi->prg[i]->handle )
1643 dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
1644 free( pid->psi->prg[i] );
1645 }
1646 free( pid->psi->prg );
1647 free( pid->psi );
1648 }
1649 else
1650 {
1651 if( pid->es->id )
1652 {
1653 es_out_Del( out, pid->es->id );
1654 p_sys->i_pmt_es--;
1655 }
1656
1657 if( pid->es->p_pes )
1658 block_ChainRelease( pid->es->p_pes );
1659
1660 es_format_Clean( &pid->es->fmt );
1661
1662 free( pid->es );
1663
1664 for( int i = 0; i < pid->i_extra_es; i++ )
1665 {
1666 if( pid->extra_es[i]->id )
1667 {
1668 es_out_Del( out, pid->extra_es[i]->id );
1669 p_sys->i_pmt_es--;
1670 }
1671
1672 if( pid->extra_es[i]->p_pes )
1673 block_ChainRelease( pid->extra_es[i]->p_pes );
1674
1675 es_format_Clean( &pid->extra_es[i]->fmt );
1676
1677 free( pid->extra_es[i] );
1678 }
1679 if( pid->i_extra_es )
1680 free( pid->extra_es );
1681 }
1682
1683 pid->b_valid = false;
1684 }
1685
1686 /****************************************************************************
1687 * gathering stuff
1688 ****************************************************************************/
1689 static void ParsePES( demux_t *p_demux, ts_pid_t *pid )
1690 {
1691 block_t *p_pes = pid->es->p_pes;
1692 uint8_t header[34];
1693 unsigned i_pes_size = 0;
1694 unsigned i_skip = 0;
1695 mtime_t i_dts = -1;
1696 mtime_t i_pts = -1;
1697 mtime_t i_length = 0;
1698
1699 /* remove the pes from pid */
1700 pid->es->p_pes = NULL;
1701 pid->es->i_pes_size= 0;
1702 pid->es->i_pes_gathered= 0;
1703 pid->es->pp_last = &pid->es->p_pes;
1704
1705 /* FIXME find real max size */
1706 /* const int i_max = */ block_ChainExtract( p_pes, header, 34 );
1707
1708 if( header[0] != 0 || header[1] != 0 || header[2] != 1 )
1709 {
1710 if( !p_demux->p_sys->b_silent )
1711 msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x] (pid: %d)",
1712 header[0], header[1],header[2],header[3], pid->i_pid );
1713 block_ChainRelease( p_pes );
1714 return;
1715 }
1716
1717 /* TODO check size */
1718 switch( header[3] )
1719 {
1720 case 0xBC: /* Program stream map */
1721 case 0xBE: /* Padding */
1722 case 0xBF: /* Private stream 2 */
1723 case 0xF0: /* ECM */
1724 case 0xF1: /* EMM */
1725 case 0xFF: /* Program stream directory */
1726 case 0xF2: /* DSMCC stream */
1727 case 0xF8: /* ITU-T H.222.1 type E stream */
1728 i_skip = 6;
1729 break;
1730 default:
1731 if( ( header[6]&0xC0 ) == 0x80 )
1732 {
1733 /* mpeg2 PES */
1734 i_skip = header[8] + 9;
1735
1736 if( header[7]&0x80 ) /* has pts */
1737 {
1738 i_pts = ((mtime_t)(header[ 9]&0x0e ) << 29)|
1739 (mtime_t)(header[10] << 22)|
1740 ((mtime_t)(header[11]&0xfe) << 14)|
1741 (mtime_t)(header[12] << 7)|
1742 (mtime_t)(header[13] >> 1);
1743
1744 if( header[7]&0x40 ) /* has dts */
1745 {
1746 i_dts = ((mtime_t)(header[14]&0x0e ) << 29)|
1747 (mtime_t)(header[15] << 22)|
1748 ((mtime_t)(header[16]&0xfe) << 14)|
1749 (mtime_t)(header[17] << 7)|
1750 (mtime_t)(header[18] >> 1);
1751 }
1752 }
1753 }
1754 else
1755 {
1756 i_skip = 6;
1757 while( i_skip < 23 && header[i_skip] == 0xff )
1758 {
1759 i_skip++;
1760 }
1761 if( i_skip == 23 )
1762 {
1763 msg_Err( p_demux, "too much MPEG-1 stuffing" );
1764 block_ChainRelease( p_pes );
1765 return;
1766 }
1767 if( ( header[i_skip] & 0xC0 ) == 0x40 )
1768 {
1769 i_skip += 2;
1770 }
1771
1772 if( header[i_skip]&0x20 )
1773 {
1774 i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
1775 (mtime_t)(header[i_skip+1] << 22)|
1776 ((mtime_t)(header[i_skip+2]&0xfe) << 14)|
1777 (mtime_t)(header[i_skip+3] << 7)|
1778 (mtime_t)(header[i_skip+4] >> 1);
1779
1780 if( header[i_skip]&0x10 ) /* has dts */
1781 {
1782 i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
1783 (mtime_t)(header[i_skip+6] << 22)|
1784 ((mtime_t)(header[i_skip+7]&0xfe) << 14)|
1785 (mtime_t)(header[i_skip+8] << 7)|
1786 (mtime_t)(header[i_skip+9] >> 1);
1787 i_skip += 10;
1788 }
1789 else
1790 {
1791 i_skip += 5;
1792 }
1793 }
1794 else
1795 {
1796 i_skip += 1;
1797 }
1798 }
1799 break;
1800 }
1801
1802 if( pid->es->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', 'b' ) ||
1803 pid->es->fmt.i_codec == VLC_FOURCC( 'd', 't', 's', 'b' ) )
1804 {
1805 i_skip += 4;
1806 }
1807 else if( pid->es->fmt.i_codec == VLC_FOURCC( 'l', 'p', 'c', 'b' ) ||
1808 pid->es->fmt.i_codec == VLC_FOURCC( 's', 'p', 'u', 'b' ) ||
1809 pid->es->fmt.i_codec == VLC_FOURCC( 's', 'd', 'd', 'b' ) )
1810 {
1811 i_skip += 1;
1812 }
1813 else if( pid->es->fmt.i_codec == VLC_CODEC_SUBT &&
1814 pid->es->p_mpeg4desc )
1815 {
1816 decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
1817
1818 if( dcd->i_decoder_specific_info_len > 2 &&
1819 dcd->p_decoder_specific_info[0] == 0x10 &&
1820 ( dcd->p_decoder_specific_info[1]&0x10 ) )
1821 {
1822 /* display length */
1823 if( p_pes->i_buffer + 2 <= i_skip )
1824 i_length = GetWBE( &p_pes->p_buffer[i_skip] );
1825
1826 i_skip += 2;
1827 }
1828 if( p_pes->i_buffer + 2 <= i_skip )
1829 i_pes_size = GetWBE( &p_pes->p_buffer[i_skip] );
1830 /* */
1831 i_skip += 2;
1832 }
1833 #ifdef ZVBI_COMPILED
1834 else if( pid->es->fmt.i_codec == VLC_CODEC_TELETEXT )
1835 i_skip = 0; /*hack for zvbi support */
1836 #endif
1837 /* skip header */
1838 while( p_pes && i_skip > 0 )
1839 {
1840 if( p_pes->i_buffer <= i_skip )
1841 {
1842 block_t *p_next = p_pes->p_next;
1843
1844 i_skip -= p_pes->i_buffer;
1845 block_Release( p_pes );
1846 p_pes = p_next;
1847 }
1848 else
1849 {
1850 p_pes->i_buffer -= i_skip;
1851 p_pes->p_buffer += i_skip;
1852 break;
1853 }
1854 }
1855
1856 /* ISO/IEC 13818-1 2.7.5: if no pts and no dts, then dts == pts */
1857 if( i_pts >= 0 && i_dts < 0 )
1858 i_dts = i_pts;
1859
1860 if( p_pes )
1861 {
1862 block_t *p_block;
1863 int i;
1864
1865 if( i_dts >= 0 )
1866 p_pes->i_dts = VLC_TS_0 + i_dts * 100 / 9;
1867
1868 if( i_pts >= 0 )
1869 p_pes->i_pts = VLC_TS_0 + i_pts * 100 / 9;
1870
1871 p_pes->i_length = i_length * 100 / 9;
1872
1873 p_block = block_ChainGather( p_pes );
1874 if( pid->es->fmt.i_codec == VLC_CODEC_SUBT )
1875 {
1876 if( i_pes_size > 0 && p_block->i_buffer > i_pes_size )
1877 {
1878 p_block->i_buffer = i_pes_size;
1879 }
1880 /* Append a \0 */
1881 p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
1882 p_block->p_buffer[p_block->i_buffer -1] = '\0';
1883 }
1884
1885 for( i = 0; i < pid->i_extra_es; i++ )
1886 {
1887 es_out_Send( p_demux->out, pid->extra_es[i]->id,
1888 block_Duplicate( p_block ) );
1889 }
1890
1891 es_out_Send( p_demux->out, pid->es->id, p_block );
1892 }
1893 else
1894 {
1895 msg_Warn( p_demux, "empty pes" );
1896 }
1897 }
1898
1899 static void PCRHandle( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
1900 {
1901 demux_sys_t *p_sys = p_demux->p_sys;
1902 const uint8_t *p = p_bk->p_buffer;
1903
1904 if( p_sys->i_pmt_es <= 0 )
1905 return;
1906
1907 if( ( p[3]&0x20 ) && /* adaptation */
1908 ( p[5]&0x10 ) &&
1909 ( p[4] >= 7 ) )
1910 {
1911 /* PCR is 33 bits */
1912 const mtime_t i_pcr = ( (mtime_t)p[6] << 25 ) |
1913 ( (mtime_t)p[7] << 17 ) |
1914 ( (mtime_t)p[8] << 9 ) |
1915 ( (mtime_t)p[9] << 1 ) |
1916 ( (mtime_t)p[10] >> 7 );
1917
1918 /* Search program and set the PCR */
1919 for( int i = 0; i < p_sys->i_pmt; i++ )
1920 {
1921 for( int i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
1922 {
1923 if( pid->i_pid == p_sys->pmt[i]->psi->prg[i_prg]->i_pid_pcr )
1924 {
1925 es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
1926 (int)p_sys->pmt[i]->psi->prg[i_prg]->i_number,
1927 (int64_t)(VLC_TS_0 + i_pcr * 100 / 9) );
1928 }
1929 }
1930 }
1931 }
1932 }
1933
1934 static bool GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
1935 {
1936 const uint8_t *p = p_bk->p_buffer;
1937 const bool b_unit_start = p[1]&0x40;
1938 const bool b_scrambled = p[3]&0x80;
1939 const bool b_adaptation = p[3]&0x20;
1940 const bool b_payload = p[3]&0x10;
1941 const int i_cc = p[3]&0x0f; /* continuity counter */
1942 bool b_discontinuity = false; /* discontinuity */
1943
1944 /* transport_scrambling_control is ignored */
1945 int i_skip = 0;
1946 bool i_ret = false;
1947
1948 #if 0
1949 msg_Dbg( p_demux, "pid=%d unit_start=%d adaptation=%d payload=%d "
1950 "cc=0x%x", pid->i_pid, b_unit_start, b_adaptation,
1951 b_payload, i_cc );
1952 #endif
1953
1954 /* For now, ignore additional error correction
1955 * TODO: handle Reed-Solomon 204,188 error correction */
1956 p_bk->i_buffer = TS_PACKET_SIZE_188;
1957
1958 if( p[1]&0x80 )
1959 {
1960 msg_Dbg( p_demux, "transport_error_indicator set (pid=%d)",
1961 pid->i_pid );
1962 if( pid->es->p_pes ) //&& pid->es->fmt.i_cat == VIDEO_ES )
1963 pid->es->p_pes->i_flags |= BLOCK_FLAG_CORRUPTED;
1964 }
1965
1966 if( p_demux->p_sys->csa )
1967 {
1968 vlc_mutex_lock( &p_demux->p_sys->csa_lock );
1969 csa_Decrypt( p_demux->p_sys->csa, p_bk->p_buffer, p_demux->p_sys->i_csa_pkt_size );
1970 vlc_mutex_unlock( &p_demux->p_sys->csa_lock );
1971 }
1972
1973 if( !b_adaptation )
1974 {
1975 /* We don't have any adaptation_field, so payload starts
1976 * immediately after the 4 byte TS header */
1977 i_skip = 4;
1978 }
1979 else
1980 {
1981 /* p[4] is adaptation_field_length minus one */
1982 i_skip = 5 + p[4];
1983 if( p[4] > 0 )
1984 {
1985 /* discontinuity indicator found in stream */
1986 b_discontinuity = (p[5]&0x80) ? true : false;
1987 if( b_discontinuity && pid->es->p_pes )
1988 {
1989 msg_Warn( p_demux, "discontinuity indicator (pid=%d) ",
1990 pid->i_pid );
1991 /* pid->es->p_pes->i_flags |= BLOCK_FLAG_DISCONTINUITY; */
1992 }
1993 #if 0
1994 if( p[5]&0x40 )
1995 msg_Dbg( p_demux, "random access indicator (pid=%d) ", pid->i_pid );
1996 #endif
1997 }
1998 }
1999
2000 /* Test continuity counter */
2001 /* continuous when (one of this):
2002 * diff == 1
2003 * diff == 0 and payload == 0
2004 * diff == 0 and duplicate packet (playload != 0) <- should we
2005 * test the content ?
2006 */
2007 const int i_diff = ( i_cc - pid->i_cc )&0x0f;
2008 if( b_payload && i_diff == 1 )
2009 {
2010 pid->i_cc = ( pid->i_cc + 1 ) & 0xf;
2011 }
2012 else
2013 {
2014 if( pid->i_cc == 0xff )
2015 {
2016 msg_Warn( p_demux, "first packet for pid=%d cc=0x%x",
2017 pid->i_pid, i_cc );
2018 pid->i_cc = i_cc;
2019 }
2020 else if( i_diff != 0 && !b_discontinuity )
2021 {
2022 msg_Warn( p_demux, "discontinuity received 0x%x instead of 0x%x (pid=%d)",
2023 i_cc, ( pid->i_cc + 1 )&0x0f, pid->i_pid );
2024
2025 pid->i_cc = i_cc;
2026 if( pid->es->p_pes && pid->es->fmt.i_cat != VIDEO_ES )
2027 {
2028 /* Small video artifacts are usually better than
2029 * dropping full frames */
2030 pid->es->p_pes->i_flags |= BLOCK_FLAG_CORRUPTED;
2031 }
2032 }
2033 }
2034
2035 PCRHandle( p_demux, pid, p_bk );
2036
2037 if( i_skip >= 188 || pid->es->id == NULL || p_demux->p_sys->b_udp_out )
2038 {
2039 block_Release( p_bk );
2040 return i_ret;
2041 }
2042
2043 /* */
2044 if( !pid->b_scrambled != !b_scrambled )
2045 {
2046 msg_Warn( p_demux, "scrambled state changed on pid %d (%d->%d)",
2047 pid->i_pid, pid->b_scrambled, b_scrambled );
2048
2049 pid->b_scrambled = b_scrambled;
2050
2051 for( int i = 0; i < pid->i_extra_es; i++ )
2052 {
2053 es_out_Control( p_demux->out, ES_OUT_SET_ES_SCRAMBLED_STATE,
2054 pid->extra_es[i]->id, b_scrambled );
2055 }
2056 es_out_Control( p_demux->out, ES_OUT_SET_ES_SCRAMBLED_STATE,
2057 pid->es->id, b_scrambled );
2058 }
2059
2060 /* We have to gather it */
2061 p_bk->p_buffer += i_skip;
2062 p_bk->i_buffer -= i_skip;
2063
2064 if( b_unit_start )
2065 {
2066 if( pid->es->p_pes )
2067 {
2068 ParsePES( p_demux, pid );
2069 i_ret = true;
2070 }
2071
2072 block_ChainLastAppend( &pid->es->pp_last, p_bk );
2073 if( p_bk->i_buffer > 6 )
2074 {
2075 pid->es->i_pes_size = GetWBE( &p_bk->p_buffer[4] );
2076 if( pid->es->i_pes_size > 0 )
2077 {
2078 pid->es->i_pes_size += 6;
2079 }
2080 }
2081 pid->es->i_pes_gathered += p_bk->i_buffer;
2082 if( pid->es->i_pes_size > 0 &&
2083 pid->es->i_pes_gathered >= pid->es->i_pes_size )
2084 {
2085 ParsePES( p_demux, pid );
2086 i_ret = true;
2087 }
2088 }
2089 else
2090 {
2091 if( pid->es->p_pes == NULL )
2092 {
2093 /* msg_Dbg( p_demux, "broken packet" ); */
2094 block_Release( p_bk );
2095 }
2096 else
2097 {
2098 block_ChainLastAppend( &pid->es->pp_last, p_bk );
2099 pid->es->i_pes_gathered += p_bk->i_buffer;
2100 if( pid->es->i_pes_size > 0 &&
2101 pid->es->i_pes_gathered >= pid->es->i_pes_size )
2102 {
2103 ParsePES( p_demux, pid );
2104 i_ret = true;
2105 }
2106 }
2107 }
2108
2109 return i_ret;
2110 }
2111
2112 static int PIDFillFormat( ts_pid_t *pid, int i_stream_type )
2113 {
2114 es_format_t *fmt = &pid->es->fmt;
2115
2116 switch( i_stream_type )
2117 {
2118 case 0x01: /* MPEG-1 video */
2119 case 0x02: /* MPEG-2 video */
2120 case 0x80: /* MPEG-2 MOTO video */
2121 es_format_Init( fmt, VIDEO_ES, VLC_CODEC_MPGV );
2122 break;
2123 case 0x03: /* MPEG-1 audio */
2124 case 0x04: /* MPEG-2 audio */
2125 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_MPGA );
2126 break;
2127 case 0x11: /* MPEG4 (audio) LATM */
2128 case 0x0f: /* ISO/IEC 13818-7 Audio with ADTS transport syntax */
2129 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_MP4A );
2130 break;
2131 case 0x10: /* MPEG4 (video) */
2132 es_format_Init( fmt, VIDEO_ES, VLC_CODEC_MP4V );
2133 pid->es->b_gather = true;
2134 break;
2135 case 0x1B: /* H264 <- check transport syntax/needed descriptor */
2136 es_format_Init( fmt, VIDEO_ES, VLC_CODEC_H264 );
2137 break;
2138
2139 case 0x81: /* A52 (audio) */
2140 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_A52 );
2141 break;
2142 case 0x82: /* DVD_SPU (sub) */
2143 es_format_Init( fmt, SPU_ES, VLC_CODEC_SPU );
2144 break;
2145 case 0x83: /* LPCM (audio) */
2146 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_DVD_LPCM );
2147 break;
2148 case 0x84: /* SDDS (audio) */
2149 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_SDDS );
2150 break;
2151 case 0x85: /* DTS (audio) */
2152 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_DTS );
2153 break;
2154 case 0x87: /* E-AC3 */
2155 es_format_Init( fmt, AUDIO_ES, VLC_CODEC_EAC3 );
2156 break;
2157
2158 case 0x91: /* A52 vls (audio) */
2159 es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', 'b' ) );
2160 break;
2161 case 0x92: /* DVD_SPU vls (sub) */
2162 es_format_Init( fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', 'b' ) );
2163 break;
2164
2165 case 0x94: /* SDDS (audio) */
2166 es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
2167 break;
2168
2169 case 0xa0: /* MSCODEC vlc (video) (fixed later) */
2170 es_format_Init( fmt, UNKNOWN_ES, 0 );
2171 pid->es->b_gather = true;
2172 break;
2173
2174 case 0x06: /* PES_PRIVATE (fixed later) */
2175 case 0x12: /* MPEG-4 generic (sub/scene/...) (fixed later) */
2176 case 0xEA: /* Privately managed ES (VC-1) (fixed later */
2177 default:
2178 es_format_Init( fmt, UNKNOWN_ES, 0 );
2179 break;
2180 }
2181
2182 /* PES packets usually contain truncated frames */
2183 fmt->b_packetized = false;
2184
2185 return fmt->i_cat == UNKNOWN_ES ? VLC_EGENERIC : VLC_SUCCESS ;
2186 }
2187
2188 /*****************************************************************************
2189 * MP4 specific functions (IOD parser)
2190 *****************************************************************************/
2191 static int IODDescriptorLength( int *pi_data, uint8_t **pp_data )
2192 {
2193 unsigned int i_b;
2194 unsigned int i_len = 0;
2195 do
2196 {
2197 i_b = **pp_data;
2198 (*pp_data)++;
2199 (*pi_data)--;
2200 i_len = ( i_len << 7 ) + ( i_b&0x7f );
2201
2202 } while( i_b&0x80 );
2203
2204 return( i_len );
2205 }
2206
2207 static int IODGetByte( int *pi_data, uint8_t **pp_data )
2208 {
2209 if( *pi_data > 0 )
2210 {
2211 const int i_b = **pp_data;
2212 (*pp_data)++;
2213 (*pi_data)--;
2214 return( i_b );
2215 }
2216 return( 0 );
2217 }
2218
2219 static int IODGetWord( int *pi_data, uint8_t **pp_data )
2220 {
2221 const int i1 = IODGetByte( pi_data, pp_data );
2222 const int i2 = IODGetByte( pi_data, pp_data );
2223 return( ( i1 << 8 ) | i2 );
2224 }
2225
2226 static int IODGet3Bytes( int *pi_data, uint8_t **pp_data )
2227 {
2228 const int i1 = IODGetByte( pi_data, pp_data );
2229 const int i2 = IODGetByte( pi_data, pp_data );
2230 const int i3 = IODGetByte( pi_data, pp_data );
2231
2232 return( ( i1 << 16 ) | ( i2 << 8) | i3 );
2233 }
2234
2235 static uint32_t IODGetDWord( int *pi_data, uint8_t **pp_data )
2236 {
2237 const uint32_t i1 = IODGetWord( pi_data, pp_data );
2238 const uint32_t i2 = IODGetWord( pi_data, pp_data );
2239 return( ( i1 << 16 ) | i2 );
2240 }
2241
2242 static char* IODGetURL( int *pi_data, uint8_t **pp_data )
2243 {
2244 char *url;
2245 int i_url_len, i;
2246
2247 i_url_len = IODGetByte( pi_data, pp_data );
2248 url = malloc( i_url_len + 1 );
2249 if( !url ) return NULL;
2250 for( i = 0; i < i_url_len; i++ )
2251 {
2252 url[i] = IODGetByte( pi_data, pp_data );
2253 }
2254 url[i_url_len] = '\0';
2255 return( url );
2256 }
2257
2258 static iod_descriptor_t *IODNew( int i_data, uint8_t *p_data )
2259 {
2260 iod_descriptor_t *p_iod;
2261 int i;
2262 int i_es_index;
2263 uint8_t i_flags, i_iod_tag, byte1, byte2, byte3;
2264 bool b_url;
2265 int i_iod_length;
2266
2267 p_iod = malloc( sizeof( iod_descriptor_t ) );
2268 if( !p_iod ) return NULL;
2269 memset( p_iod, 0, sizeof( iod_descriptor_t ) );
2270
2271 #ifdef TS_DEBUG
2272 fprintf( stderr, "\n************ IOD ************" );
2273 #endif
2274 for( i = 0; i < 255; i++ )
2275 {
2276 p_iod->es_descr[i].b_ok = 0;
2277 }
2278 i_es_index = 0;
2279
2280 if( i_data < 3 )
2281 {
2282 return p_iod;
2283 }
2284
2285 byte1 = IODGetByte( &i_data, &p_data );
2286 byte2 = IODGetByte( &i_data, &p_data );
2287 byte3 = IODGetByte( &i_data, &p_data );
2288 if( byte2 == 0x02 ) //old vlc's buggy implementation of the IOD_descriptor
2289 {
2290 p_iod->i_iod_label_scope = 0x11;
2291 p_iod->i_iod_label = byte1;
2292 i_iod_tag = byte2;
2293 }
2294 else //correct implementation of the IOD_descriptor
2295 {
2296 p_iod->i_iod_label_scope = byte1;
2297 p_iod->i_iod_label = byte2;
2298 i_iod_tag = byte3;
2299 }
2300 #ifdef TS_DEBUG
2301 fprintf( stderr, "\n* iod_label:%d", p_iod->i_iod_label );
2302 fprintf( stderr, "\n* ===========" );
2303 fprintf( stderr, "\n* tag:0x%x", i_iod_tag );
2304 #endif
2305 if( i_iod_tag != 0x02 )
2306 {
2307 #ifdef TS_DEBUG
2308 fprintf( stderr, "\n ERR: tag %02x != 0x02", i_iod_tag );
2309 #endif
2310 return p_iod;
2311 }
2312
2313 i_iod_length = IODDescriptorLength( &i_data, &p_data );
2314 #ifdef TS_DEBUG
2315 fprintf( stderr, "\n* length:%d", i_iod_length );
2316 #endif
2317 if( i_iod_length > i_data )
2318 {
2319 i_iod_length = i_data;
2320 }
2321
2322 p_iod->i_od_id = ( IODGetByte( &i_data, &p_data ) << 2 );
2323 i_flags = IODGetByte( &i_data, &p_data );
2324 p_iod->i_od_id |= i_flags >> 6;
2325 b_url = ( i_flags >> 5 )&0x01;
2326 #ifdef TS_DEBUG
2327 fprintf( stderr, "\n* od_id:%d", p_iod->i_od_id );
2328 fprintf( stderr, "\n* url flag:%d", b_url );
2329 fprintf( stderr, "\n* includeInlineProfileLevel flag:%d", ( i_flags >> 4 )&0x01 );
2330 #endif
2331 if( b_url )
2332 {
2333 p_iod->psz_url = IODGetURL( &i_data, &p_data );
2334 #ifdef TS_DEBUG
2335 fprintf( stderr, "\n* url string:%s", p_iod->psz_url );
2336 fprintf( stderr, "\n*****************************\n" );
2337 #endif
2338 return p_iod;
2339 }
2340 else
2341 {
2342 p_iod->psz_url = NULL;
2343 }
2344
2345 p_iod->i_ODProfileLevelIndication = IODGetByte( &i_data, &p_data );
2346 p_iod->i_sceneProfileLevelIndication = IODGetByte( &i_data, &p_data );
2347 p_iod->i_audioProfileLevelIndication = IODGetByte( &i_data, &p_data );
2348 p_iod->i_visualProfileLevelIndication = IODGetByte( &i_data, &p_data );
2349 p_iod->i_graphicsProfileLevelIndication = IODGetByte( &i_data, &p_data );
2350 #ifdef TS_DEBUG
2351 fprintf( stderr, "\n* ODProfileLevelIndication:%d", p_iod->i_ODProfileLevelIndication );
2352 fprintf( stderr, "\n* sceneProfileLevelIndication:%d", p_iod->i_sceneProfileLevelIndication );
2353 fprintf( stderr, "\n* audioProfileLevelIndication:%d", p_iod->i_audioProfileLevelIndication );
2354 fprintf( stderr, "\n* visualProfileLevelIndication:%d", p_iod->i_visualProfileLevelIndication );
2355 fprintf( stderr, "\n* graphicsProfileLevelIndication:%d", p_iod->i_graphicsProfileLevelIndication );
2356 #endif
2357
2358 while( i_data > 0 && i_es_index < 255)
2359 {
2360 int i_tag, i_length;
2361 int i_data_sav;
2362 uint8_t *p_data_sav;
2363
2364 i_tag = IODGetByte( &i_data, &p_data );
2365 i_length = IODDescriptorLength( &i_data, &p_data );
2366
2367 i_data_sav = i_data;
2368 p_data_sav = p_data;
2369
2370 i_data = i_length;
2371
2372 switch( i_tag )
2373 {
2374 case 0x03:
2375 {
2376 #define es_descr p_iod->es_descr[i_es_index]
2377 int i_decoderConfigDescr_length;
2378 #ifdef TS_DEBUG
2379 fprintf( stderr, "\n* - ES_Descriptor length:%d", i_length );
2380 #endif
2381 es_descr.b_ok = 1;
2382
2383 es_descr.i_es_id = IODGetWord( &i_data, &p_data );
2384 i_flags = IODGetByte( &i_data, &p_data );
2385 es_descr.b_streamDependenceFlag = ( i_flags >> 7 )&0x01;
2386 b_url = ( i_flags >> 6 )&0x01;
2387 es_descr.b_OCRStreamFlag = ( i_flags >> 5 )&0x01;
2388 es_descr.i_streamPriority = i_flags & 0x1f;
2389 #ifdef TS_DEBUG
2390 fprintf( stderr, "\n* * streamDependenceFlag:%d", es_descr.b_streamDependenceFlag );
2391 fprintf( stderr, "\n* * OCRStreamFlag:%d", es_descr.b_OCRStreamFlag );
2392 fprintf( stderr, "\n* * streamPriority:%d", es_descr.i_streamPriority );
2393 #endif
2394 if( es_descr.b_streamDependenceFlag )
2395 {
2396 es_descr.i_dependOn_es_id = IODGetWord( &i_data, &p_data );
2397 #ifdef TS_DEBUG
2398 fprintf( stderr, "\n* * dependOn_es_id:%d", es_descr.i_dependOn_es_id );
2399 #endif
2400 }
2401
2402 if( b_url )
2403 {
2404 es_descr.psz_url = IODGetURL( &i_data, &p_data );
2405 #ifdef TS_DEBUG
2406 fprintf( stderr, "\n* url string:%s", es_descr.psz_url );
2407 #endif
2408 }
2409 else
2410 {
2411 es_descr.psz_url = NULL;
2412 }
2413
2414 if( es_descr.b_OCRStreamFlag )
2415 {
2416 es_descr.i_OCR_es_id = IODGetWord( &i_data, &p_data );
2417 #ifdef TS_DEBUG
2418 fprintf( stderr, "\n* * OCR_es_id:%d", es_descr.i_OCR_es_id );
2419 #endif
2420 }
2421
2422 if( IODGetByte( &i_data, &p_data ) != 0x04 )
2423 {
2424 #ifdef TS_DEBUG
2425 fprintf( stderr, "\n* ERR missing DecoderConfigDescr" );
2426 #endif
2427 es_descr.b_ok = 0;
2428 break;
2429 }
2430 i_decoderConfigDescr_length = IODDescriptorLength( &i_data, &p_data );
2431 #ifdef TS_DEBUG
2432 fprintf( stderr, "\n* - DecoderConfigDesc length:%d", i_decoderConfigDescr_length );
2433 #endif
2434 #define dec_descr es_descr.dec_descr
2435 dec_descr.i_objectTypeIndication = IODGetByte( &i_data, &p_data );
2436 i_flags = IODGetByte( &i_data, &p_data );
2437 dec_descr.i_streamType = i_flags >> 2;
2438 dec_descr.b_upStream = ( i_flags >> 1 )&0x01;
2439 dec_descr.i_bufferSizeDB = IODGet3Bytes( &i_data, &p_data );
2440 dec_descr.i_maxBitrate = IODGetDWord( &i_data, &p_data );
2441 dec_descr.i_avgBitrate = IODGetDWord( &i_data, &p_data );
2442 #ifdef TS_DEBUG
2443 fprintf( stderr, "\n* * objectTypeIndication:0x%x", dec_descr.i_objectTypeIndication );
2444 fprintf( stderr, "\n* * streamType:0x%x", dec_descr.i_streamType );
2445 fprintf( stderr, "\n* * upStream:%d", dec_descr.b_upStream );
2446 fprintf( stderr, "\n* * bufferSizeDB:%d", dec_descr.i_bufferSizeDB );
2447 fprintf( stderr, "\n* * maxBitrate:%d", dec_descr.i_maxBitrate );
2448 fprintf( stderr, "\n* * avgBitrate:%d", dec_descr.i_avgBitrate );
2449 #endif
2450 if( i_decoderConfigDescr_length > 13 && IODGetByte( &i_data, &p_data ) == 0x05 )
2451 {
2452 int i;
2453 dec_descr.i_decoder_specific_info_len =
2454 IODDescriptorLength( &i_data, &p_data );
2455 if( dec_descr.i_decoder_specific_info_len > 0 )
2456 {
2457 dec_descr.p_decoder_specific_info =
2458 malloc( dec_descr.i_decoder_specific_info_len );
2459 }
2460 for( i = 0; i < dec_descr.i_decoder_specific_info_len; i++ )
2461 {
2462 dec_descr.p_decoder_specific_info[i] = IODGetByte( &i_data, &p_data );
2463 }
2464 }
2465 else
2466 {
2467 dec_descr.i_decoder_specific_info_len = 0;
2468 dec_descr.p_decoder_specific_info = NULL;
2469 }
2470 }
2471 #undef dec_descr
2472 #define sl_descr es_descr.sl_descr
2473 {
2474 int i_SLConfigDescr_length;
2475 int i_predefined;
2476
2477 if( IODGetByte( &i_data, &p_data ) != 0x06 )
2478 {
2479 #ifdef TS_DEBUG
2480 fprintf( stderr, "\n* ERR missing SLConfigDescr" );
2481 #endif
2482 es_descr.b_ok = 0;
2483 break;
2484 }
2485 i_SLConfigDescr_length = IODDescriptorLength( &i_data, &p_data );
2486 #ifdef TS_DEBUG
2487 fprintf( stderr, "\n* - SLConfigDescr length:%d", i_SLConfigDescr_length );
2488 #endif
2489 i_predefined = IODGetByte( &i_data, &p_data );
2490 #ifdef TS_DEBUG
2491 fprintf( stderr, "\n* * i_predefined:0x%x", i_predefined );
2492 #endif
2493 switch( i_predefined )
2494 {
2495 case 0x01:
2496 {
2497 sl_descr.b_useAccessUnitStartFlag = 0;
2498 sl_descr.b_useAccessUnitEndFlag = 0;
2499 sl_descr.b_useRandomAccessPointFlag = 0;
2500 //sl_descr.b_useRandomAccessUnitsOnlyFlag = 0;
2501 sl_descr.b_usePaddingFlag = 0;
2502 sl_descr.b_useTimeStampsFlags = 0;
2503 sl_descr.b_useIdleFlag = 0;
2504 sl_descr.b_durationFlag = 0; // FIXME FIXME
2505 sl_descr.i_timeStampResolution = 1000;
2506 sl_descr.i_OCRResolution = 0; // FIXME FIXME
2507 sl_descr.i_timeStampLength = 32;
2508 sl_descr.i_OCRLength = 0; // FIXME FIXME
2509 sl_descr.i_AU_Length = 0;
2510 sl_descr.i_instantBitrateLength= 0; // FIXME FIXME
2511 sl_descr.i_degradationPriorityLength= 0;
2512 sl_descr.i_AU_seqNumLength = 0;
2513 sl_descr.i_packetSeqNumLength = 0;
2514 if( sl_descr.b_durationFlag )
2515 {
2516 sl_descr.i_timeScale = 0; // FIXME FIXME
2517 sl_descr.i_accessUnitDuration = 0; // FIXME FIXME
2518 sl_descr.i_compositionUnitDuration= 0; // FIXME FIXME
2519 }
2520 if( !sl_descr.b_useTimeStampsFlags )
2521 {
2522 sl_descr.i_startDecodingTimeStamp = 0; // FIXME FIXME
2523 sl_descr.i_startCompositionTimeStamp= 0; // FIXME FIXME
2524 }
2525 }
2526 break;
2527 default:
2528 #ifdef TS_DEBUG
2529 fprintf( stderr, "\n* ERR unsupported SLConfigDescr predefined" );
2530 #endif
2531 es_descr.b_ok = 0;
2532 break;
2533 }
2534 }
2535 break;
2536 #undef sl_descr
2537 #undef es_descr
2538 default:
2539 #ifdef TS_DEBUG
2540 fprintf( stderr, "\n* - OD tag:0x%x length:%d (Unsupported)", i_tag, i_length );
2541 #endif
2542 break;
2543 }
2544
2545 p_data = p_data_sav + i_length;
2546 i_data = i_data_sav - i_length;
2547 i_es_index++;
2548 }
2549 #ifdef TS_DEBUG
2550 fprintf( stderr, "\n*****************************\n" );
2551 #endif
2552 return p_iod;
2553 }
2554
2555 static void IODFree( iod_descriptor_t *p_iod )
2556 {
2557 int i;
2558
2559 if( p_iod->psz_url )
2560 {
2561 free( p_iod->psz_url );
2562 p_iod->psz_url = NULL;
2563 free( p_iod );
2564 return;
2565 }
2566
2567 for( i = 0; i < 255; i++ )
2568 {
2569 #define es_descr p_iod->es_descr[i]
2570 if( es_descr.b_ok )
2571 {
2572 if( es_descr.psz_url )
2573 {
2574 free( es_descr.psz_url );
2575 es_descr.psz_url = NULL;
2576 }
2577 else
2578 {
2579 free( es_descr.dec_descr.p_decoder_specific_info );
2580 es_descr.dec_descr.p_decoder_specific_info = NULL;
2581 es_descr.dec_descr.i_decoder_specific_info_len = 0;
2582 }
2583 }
2584 es_descr.b_ok = 0;
2585 #undef es_descr
2586 }
2587 free( p_iod );
2588 }
2589
2590 /****************************************************************************
2591 ****************************************************************************
2592 ** libdvbpsi callbacks
2593 ****************************************************************************
2594 ****************************************************************************/
2595 static bool ProgramIsSelected( demux_t *p_demux, uint16_t i_pgrm )
2596 {
2597 demux_sys_t *p_sys = p_demux->p_sys;
2598
2599 if( !p_sys->b_access_control )
2600 return false;
2601 if( ( p_sys->i_current_program == -1 && p_sys->programs_list.i_count == 0 ) ||
2602 p_sys->i_current_program == 0 )
2603 return true;
2604 if( p_sys->i_current_program == i_pgrm )
2605 return true;
2606
2607 if( p_sys->programs_list.i_count != 0 )
2608 {
2609 for( int i = 0; i < p_sys->programs_list.i_count; i++ )
2610 {
2611 if( i_pgrm == p_sys->programs_list.p_values[i].i_int )
2612 return true;
2613 }
2614 }
2615 return false;
2616 }
2617
2618 static void ValidateDVBMeta( demux_t *p_demux, int i_pid )
2619 {
2620 demux_sys_t *p_sys = p_demux->p_sys;
2621
2622 if( !p_sys->b_dvb_meta || ( i_pid != 0x11 && i_pid != 0x12 && i_pid != 0x14 ) )
2623 return;
2624
2625 msg_Warn( p_demux, "Switching to non DVB mode" );
2626
2627 /* This doesn't look like a DVB stream so don't try
2628 * parsing the SDT/EDT/TDT */
2629
2630 for( int i = 0x11; i <= 0x14; i++ )
2631 {
2632 if( i == 0x13 ) continue;
2633 ts_pid_t *p_pid = &p_sys->pid[i];
2634 if( p_pid->psi )
2635 {
2636 dvbpsi_DetachDemux( p_pid->psi->handle );
2637 free( p_pid->psi );
2638 p_pid->psi = NULL;
2639 p_pid->b_valid = false;
2640 }
2641 if( p_sys->b_access_control )
2642 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
2643 ACCESS_SET_PRIVATE_ID_STATE, i, false );
2644
2645 }
2646 p_sys->b_dvb_meta = false;
2647 }
2648
2649
2650 #ifdef TS_USE_DVB_SI
2651 /* FIXME same than dvbsi_to_utf8 from dvb access */
2652 static char *EITConvertToUTF8( const unsigned char *psz_instring,
2653 size_t i_length,
2654 bool b_broken )
2655 {
2656 const char *psz_encoding;
2657 char *psz_outstring;
2658 char psz_encbuf[sizeof( "ISO_8859-123" )];
2659 size_t i_in, i_out, offset = 1;
2660 vlc_iconv_t iconv_handle;
2661
2662 if( i_length < 1 ) return NULL;
2663 if( psz_instring[0] >= 0x20 )
2664 {
2665 /* According to ETSI EN 300 468 Annex A, this should be ISO6937,
2666 * but some broadcasters use different charset... */
2667 if( b_broken )
2668 psz_encoding = "ISO_8859-1";
2669 else
2670 psz_encoding = "ISO_6937";
2671
2672 offset = 0;
2673 }
2674 else switch( psz_instring[0] )
2675 {
2676 case 0x01:
2677 psz_encoding = "ISO_8859-5";
2678 break;
2679 case 0x02:
2680 psz_encoding = "ISO_8859-6";
2681 break;
2682 case 0x03:
2683 psz_encoding = "ISO_8859-7";
2684 break;
2685 case 0x04:
2686 psz_encoding = "ISO_8859-8";
2687 break;
2688 case 0x05:
2689 psz_encoding = "ISO_8859-9";
2690 break;
2691 case 0x06:
2692 psz_encoding = "ISO_8859-10";
2693 break;
2694 case 0x07:
2695 psz_encoding = "ISO_8859-11";
2696 break;
2697 case 0x08:
2698 psz_encoding = "ISO_8859-12";
2699 break;
2700 case 0x09:
2701 psz_encoding = "ISO_8859-13";
2702 break;
2703 case 0x0a:
2704 psz_encoding = "ISO_8859-14";
2705 break;
2706 case 0x0b:
2707 psz_encoding = "ISO_8859-15";
2708 break;
2709 case 0x10:
2710 #warning Is Latin-10 (psz_instring[2] == 16) really illegal?
2711 if( i_length < 3 || psz_instring[1] != 0x00 || psz_instring[2] > 15
2712 || psz_instring[2] == 0 )
2713 {
2714 psz_encoding = "UTF-8";
2715 offset = 0;
2716 }
2717 else
2718 {
2719 sprintf( psz_encbuf, "ISO_8859-%u", psz_instring[2] );
2720 psz_encoding = psz_encbuf;
2721 offset = 3;
2722 }
2723 break;
2724 case 0x11:
2725 #warning Is there a BOM or do we use a fixed endianess?
2726 psz_encoding = "UTF-16";
2727 break;
2728 case 0x12:
2729 psz_encoding = "KSC5601-1987";
2730 break;
2731 case 0x13:
2732 psz_encoding = "GB2312"; /* GB-2312-1980 */
2733 break;
2734 case 0x14:
2735 psz_encoding = "BIG-5";
2736 break;
2737 case 0x15:
2738 psz_encoding = "UTF-8";
2739 break;
2740 default:
2741 /* invalid */
2742 psz_encoding = "UTF-8";
2743 offset = 0;
2744 }
2745
2746 i_in = i_length - offset;
2747 i_out = i_in * 6 + 1;
2748
2749 psz_outstring = malloc( i_out );
2750 if( !psz_outstring )
2751 {
2752 return NULL;
2753 }
2754
2755 iconv_handle = vlc_iconv_open( "UTF-8", psz_encoding );
2756 if( iconv_handle == (vlc_iconv_t)(-1) )
2757 {
2758 /* Invalid character set (e.g. ISO_8859-12) */
2759 memcpy( psz_outstring, &psz_instring[offset], i_in );
2760 psz_outstring[i_in] = '\0';
2761 EnsureUTF8( psz_outstring );
2762 }
2763 else
2764 {
2765 const char *psz_in = (const char *)&psz_instring[offset];
2766 char *psz_out = psz_outstring;
2767
2768 while( vlc_iconv( iconv_handle, &psz_in, &i_in,
2769 &psz_out, &i_out ) == (size_t)(-1) )
2770 {
2771 /* skip naughty byte. This may fail terribly for multibyte stuff,
2772 * but what can we do anyway? */
2773 psz_in++;
2774 i_in--;
2775 vlc_iconv( iconv_handle, NULL, NULL, NULL, NULL ); /* reset */
2776 }
2777 vlc_iconv_close( iconv_handle );
2778
2779 *psz_out = '\0';
2780
2781 /* Convert EIT-coded CR/LFs */
2782 unsigned char *pbuf = (unsigned char *)psz_outstring;
2783 for( ; pbuf < (unsigned char *)psz_out ; pbuf++)
2784 {
2785 if( pbuf[0] == 0xc2 && pbuf[1] == 0x8a )
2786 {
2787 pbuf[0] = ' ';
2788 pbuf[1] = '\n';
2789 }
2790 }
2791
2792
2793 }
2794 return psz_outstring;
2795 }
2796
2797 static void SDTCallBack( demux_t *p_demux, dvbpsi_sdt_t *p_sdt )
2798 {
2799 demux_sys_t *p_sys = p_demux->p_sys;
2800 ts_pid_t *sdt = &p_sys->pid[0x11];
2801 dvbpsi_sdt_service_t *p_srv;
2802
2803 msg_Dbg( p_demux, "SDTCallBack called" );
2804
2805 if( sdt->psi->i_sdt_version != -1 &&
2806 ( !p_sdt->b_current_next ||
2807 p_sdt->i_version == sdt->psi->i_sdt_version ) )
2808 {
2809 dvbpsi_DeleteSDT( p_sdt );
2810 return;
2811 }
2812
2813 msg_Dbg( p_demux, "new SDT ts_id=%d version=%d current_next=%d "
2814 "network_id=%d",
2815 p_sdt->i_ts_id, p_sdt->i_version, p_sdt->b_current_next,
2816 p_sdt->i_network_id );
2817
2818 p_sys->b_broken_charset = false;
2819
2820 for( p_srv = p_sdt->p_first_service; p_srv; p_srv = p_srv->p_next )
2821 {
2822 vlc_meta_t *p_meta;
2823 dvbpsi_descriptor_t *p_dr;
2824
2825 const char *psz_type = NULL;
2826 const char *psz_status = NULL;
2827
2828 msg_Dbg( p_demux, " * service id=%d eit schedule=%d present=%d "
2829 "running=%d free_ca=%d",
2830 p_srv->i_service_id, p_srv->b_eit_schedule,
2831 p_srv->b_eit_present, p_srv->i_running_status,
2832 p_srv->b_free_ca );
2833
2834 if( p_sys->i_current_program != -1 && p_sys->i_current_program != p_srv->i_service_id )
2835 continue;
2836
2837 p_meta = vlc_meta_New();
2838 for( p_dr = p_srv->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
2839 {
2840 if( p_dr->i_tag == 0x48 )
2841 {
2842 static const char *ppsz_type[17] = {
2843 "Reserved",
2844 "Digital television service",
2845 "Digital radio sound service",
2846 "Teletext service",
2847 "NVOD reference service",
2848 "NVOD time-shifted service",
2849 "Mosaic service",
2850 "PAL coded signal",
2851 "SECAM coded signal",
2852 "D/D2-MAC",
2853 "FM Radio",
2854 "NTSC coded signal",
2855 "Data broadcast service",
2856 "Reserved for Common Interface Usage",
2857 "RCS Map (see EN 301 790 [35])",
2858 "RCS FLS (see EN 301 790 [35])",
2859 "DVB MHP service"
2860 };
2861 dvbpsi_service_dr_t *pD = dvbpsi_DecodeServiceDr( p_dr );
2862 char *str1 = NULL;
2863 char *str2 = NULL;
2864
2865 /* Workarounds for broadcasters with broken EPG */
2866
2867 if( p_sdt->i_network_id == 133 )
2868 p_sys->b_broken_charset = true; /* SKY DE & BetaDigital use ISO8859-1 */
2869
2870 /* List of providers using ISO8859-1 */
2871 static const char ppsz_broken_providers[][8] = {
2872 "CSAT", /* CanalSat FR */
2873 "GR1", /* France televisions */
2874 "MULTI4", /* NT1 */
2875 "MR5", /* France 2/M6 HD */
2876 ""
2877 };
2878 for( int i = 0; *ppsz_broken_providers[i]; i++ )
2879 {
2880 const size_t i_length = strlen(ppsz_broken_providers[i]);
2881 if( pD->i_service_provider_name_length == i_length &&
2882 !strncmp( pD->i_service_provider_name, ppsz_broken_providers[i], i_length ) )
2883 p_sys->b_broken_charset = true;
2884 }
2885
2886 /* FIXME: Digital+ ES also uses ISO8859-1 */
2887
2888 str1 = EITConvertToUTF8(pD->i_service_provider_name,
2889 pD->i_service_provider_name_length,
2890 p_sys->b_broken_charset );
2891 str2 = EITConvertToUTF8(pD->i_service_name,
2892 pD->i_service_name_length,
2893 p_sys->b_broken_charset );
2894
2895 msg_Dbg( p_demux, " - type=%d provider=%s name=%s",
2896 pD->i_service_type, str1, str2 );
2897
2898 vlc_meta_SetTitle( p_meta, str2 );
2899 vlc_meta_SetPublisher( p_meta, str1 );
2900 if( pD->i_service_type >= 0x01 && pD->i_service_type <= 0x10 )
2901 psz_type = ppsz_type[pD->i_service_type];
2902 free( str1 );
2903 free( str2 );
2904 }
2905 }
2906
2907 if( p_srv->i_running_status >= 0x01 && p_srv->i_running_status <= 0x04 )
2908 {
2909 static const char *ppsz_status[5] = {
2910 "Unknown",
2911 "Not running",
2912 "Starts in a few seconds",
2913 "Pausing",
2914 "Running"
2915 };
2916 psz_status = ppsz_status[p_srv->i_running_status];
2917 }
2918
2919 if( psz_type )
2920 vlc_meta_AddExtra( p_meta, "Type", psz_type );
2921 if( psz_status )
2922 vlc_meta_AddExtra( p_meta, "Status", psz_status );
2923
2924 es_out_Control( p_demux->out, ES_OUT_SET_GROUP_META,
2925 p_srv->i_service_id, p_meta );
2926 vlc_meta_Delete( p_meta );
2927 }
2928
2929 sdt->psi->i_sdt_version = p_sdt->i_version;
2930 dvbpsi_DeleteSDT( p_sdt );
2931 }
2932
2933 /* i_year: year - 1900 i_month: 0-11 i_mday: 1-31 i_hour: 0-23 i_minute: 0-59 i_second: 0-59 */
2934 static int64_t vlc_timegm( int i_year, int i_month, int i_mday, int i_hour, int i_minute, int i_second )
2935 {
2936 static const int pn_day[12+1] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
2937 int64_t i_day;
2938 int i;
2939
2940 if( i_year < 70 ||
2941 i_month < 0 || i_month > 11 || i_mday < 1 || i_mday > 31 ||
2942 i_hour < 0 || i_hour > 23 || i_minute < 0 || i_minute > 59 || i_second < 0 || i_second > 59 )
2943 return -1;
2944
2945 /* Count the number of days */
2946 i_day = 365 * (i_year-70) + pn_day[i_month] + i_mday - 1;
2947 #define LEAP(y) ( ((y)%4) == 0 && (((y)%100) != 0 || ((y)%400) == 0) ? 1 : 0)
2948 for( i = 70; i < i_year; i++ )
2949 i_day += LEAP(1900+i);
2950 if( i_month > 1 )
2951 i_day += LEAP(1900+i_year);
2952 #undef LEAP
2953 /**/
2954 return ((24*i_day + i_hour)*60 + i_minute)*60 + i_second;
2955 }
2956
2957 static void EITDecodeMjd( int i_mjd, int *p_y, int *p_m, int *p_d )
2958 {
2959 const int yp = (int)( ( (double)i_mjd - 15078.2)/365.25 );
2960 const int mp = (int)( ((double)i_mjd - 14956.1 - (int)(yp * 365.25)) / 30.6001 );
2961 const int c = ( mp == 14 || mp == 15 ) ? 1 : 0;
2962
2963 *p_y = 1900 + yp + c*1;
2964 *p_m = mp - 1 - c*12;
2965 *p_d = i_mjd - 14956 - (int)(yp*365.25) - (int)(mp*30.6001);
2966 }
2967 #define CVT_FROM_BCD(v) ((((v) >> 4)&0xf)*10 + ((v)&0xf))
2968 static int64_t EITConvertStartTime( uint64_t i_date )
2969 {
2970 const int i_mjd = i_date >> 24;
2971 const int i_hour = CVT_FROM_BCD(i_date >> 16);
2972 const int i_minute = CVT_FROM_BCD(i_date >> 8);
2973 const int i_second = CVT_FROM_BCD(i_date );
2974 int i_year;
2975 int i_month;
2976 int i_day;
2977
2978 /* if all 40 bits are 1, the start is unknown */
2979 if( i_date == UINT64_C(0xffffffffff) )
2980 return -1;
2981
2982 EITDecodeMjd( i_mjd, &i_year, &i_month, &i_day );
2983 return vlc_timegm( i_year - 1900, i_month - 1, i_day, i_hour, i_minute, i_second );
2984 }
2985 static int EITConvertDuration( uint32_t i_duration )
2986 {
2987 return CVT_FROM_BCD(i_duration >> 16) * 3600 +
2988 CVT_FROM_BCD(i_duration >> 8 ) * 60 +
2989 CVT_FROM_BCD(i_duration );
2990 }
2991 #undef CVT_FROM_BCD
2992
2993 #ifdef TS_USE_TDT
2994 static void TDTCallBack( demux_t *p_demux, dvbpsi_tot_t *p_tdt )
2995 {
2996 demux_sys_t *p_sys = p_demux->p_sys;
2997
2998 p_sys->i_tdt_delta = CLOCK_FREQ * EITConvertStartTime( p_tdt->i_utc_time )
2999 - mdate();
3000 dvbpsi_DeleteTOT(p_tdt);
3001 }
3002 #endif
3003
3004
3005 static void EITCallBack( demux_t *p_demux,
3006 dvbpsi_eit_t *p_eit, bool b_current_following )
3007 {
3008 demux_sys_t *p_sys = p_demux->p_sys;
3009 dvbpsi_eit_event_t *p_evt;
3010 vlc_epg_t *p_epg;
3011
3012 msg_Dbg( p_demux, "EITCallBack called" );
3013 if( !p_eit->b_current_next || ( p_sys->i_current_program != -1 && p_sys->i_current_program != p_eit->i_service_id ) )
3014 {
3015 dvbpsi_DeleteEIT( p_eit );
3016 return;
3017 }
3018
3019 msg_Dbg( p_demux, "new EIT service_id=%d version=%d current_next=%d "
3020 "ts_id=%d network_id=%d segment_last_section_number=%d "
3021 "last_table_id=%d",
3022 p_eit->i_service_id, p_eit->i_version, p_eit->b_current_next,
3023 p_eit->i_ts_id, p_eit->i_network_id,
3024 p_eit->i_segment_last_section_number, p_eit->i_last_table_id );
3025
3026 p_epg = vlc_epg_New( NULL );
3027 for( p_evt = p_eit->p_first_event; p_evt; p_evt = p_evt->p_next )
3028 {
3029 dvbpsi_descriptor_t *p_dr;
3030 char *psz_name = NULL;
3031 char *psz_text = NULL;
3032 char *psz_extra = strdup("");
3033 int64_t i_start;
3034 int i_duration;
3035
3036 i_start = EITConvertStartTime( p_evt->i_start_time );
3037 i_duration = EITConvertDuration( p_evt->i_duration );
3038
3039 msg_Dbg( p_demux, " * event id=%d start_time:%d duration=%d "
3040 "running=%d free_ca=%d",
3041 p_evt->i_event_id, (int)i_start, (int)i_duration,
3042 p_evt->i_running_status, p_evt->b_free_ca );
3043
3044 for( p_dr = p_evt->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
3045 {
3046 if( p_dr->i_tag == 0x4d )
3047 {
3048 dvbpsi_short_event_dr_t *pE = dvbpsi_DecodeShortEventDr( p_dr );
3049
3050 /* Only take first description, as we don't handle language-info
3051 for epg atm*/
3052 if( pE && psz_name == NULL)
3053 {
3054 psz_name = EITConvertToUTF8( pE->i_event_name, pE->i_event_name_length,
3055 p_sys->b_broken_charset );
3056 psz_text = EITConvertToUTF8( pE->i_text, pE->i_text_length,
3057 p_sys->b_broken_charset );
3058 msg_Dbg( p_demux, " - short event lang=%3.3s '%s' : '%s'",
3059 pE->i_iso_639_code, psz_name, psz_text );
3060 }
3061 }
3062 else if( p_dr->i_tag == 0x4e )
3063 {
3064 dvbpsi_extended_event_dr_t *pE = dvbpsi_DecodeExtendedEventDr( p_dr );
3065 if( pE )
3066 {
3067 msg_Dbg( p_demux, " - extended event lang=%3.3s [%d/%d]",
3068 pE->i_iso_639_code,
3069 pE->i_descriptor_number, pE->i_last_descriptor_number );
3070
3071 if( pE->i_text_length > 0 )
3072 {
3073 char *psz_text = EITConvertToUTF8( pE->i_text, pE->i_text_length,
3074 p_sys->b_broken_charset );
3075 if( psz_text )
3076 {
3077 msg_Dbg( p_demux, " - text='%s'", psz_text );
3078
3079 psz_extra = xrealloc( psz_extra,
3080 strlen(psz_extra) + strlen(psz_text) + 1 );
3081 strcat( psz_extra, psz_text );
3082 free( psz_text );
3083 }
3084 }
3085
3086 for( int i = 0; i < pE->i_entry_count; i++ )
3087 {
3088 char *psz_dsc = EITConvertToUTF8( pE->i_item_description[i],
3089 pE->i_item_description_length[i],
3090 p_sys->b_broken_charset );
3091 char *psz_itm = EITConvertToUTF8( pE->i_item[i], pE->i_item_length[i],
3092 p_sys->b_broken_charset );
3093
3094 if( psz_dsc && psz_itm )
3095 {
3096 msg_Dbg( p_demux, " - desc='%s' item='%s'", psz_dsc, psz_itm );
3097 #if 0
3098 psz_extra = xrealloc( psz_extra,
3099 strlen(psz_extra) + strlen(psz_dsc) +
3100 strlen(psz_itm) + 3 + 1 );
3101 strcat( psz_extra, "(" );
3102 strcat( psz_extra, psz_dsc );
3103 strcat( psz_extra, " " );
3104 strcat( psz_extra, psz_itm );
3105 strcat( psz_extra, ")" );
3106 #endif
3107 }
3108 free( psz_dsc );
3109 free( psz_itm );
3110 }
3111 }
3112 }
3113 else
3114 {
3115 msg_Dbg( p_demux, " - tag=0x%x(%d)", p_dr->i_tag, p_dr->i_tag );
3116 }
3117 }
3118
3119 /* */
3120 if( i_start > 0 )
3121 vlc_epg_AddEvent( p_epg, i_start, i_duration, psz_name, psz_text,
3122 *psz_extra ? psz_extra : NULL );
3123
3124 /* Update "now playing" field */
3125 if( p_evt->i_running_status == 0x04 && i_start > 0 )
3126 vlc_epg_SetCurrent( p_epg, i_start );
3127
3128 free( psz_name );
3129 free( psz_text );
3130
3131 free( psz_extra );
3132 }
3133 if( p_epg->i_event > 0 )
3134 {
3135 if( b_current_following &&
3136 ( p_sys->i_current_program == -1 ||
3137 p_sys->i_current_program == p_eit->i_service_id ) )
3138 {
3139 p_sys->i_dvb_length = 0;
3140 p_sys->i_dvb_start = 0;
3141
3142 if( p_epg->p_current )
3143 {
3144 p_sys->i_dvb_start = CLOCK_FREQ * p_epg->p_current->i_start;
3145 p_sys->i_dvb_length = CLOCK_FREQ * p_epg->p_current->i_duration;
3146 }
3147 }
3148 es_out_Control( p_demux->out, ES_OUT_SET_GROUP_EPG, p_eit->i_service_id, p_epg );
3149 }
3150 vlc_epg_Delete( p_epg );
3151
3152 dvbpsi_DeleteEIT( p_eit );
3153 }
3154 static void EITCallBackCurrentFollowing( demux_t *p_demux, dvbpsi_eit_t *p_eit )
3155 {
3156 EITCallBack( p_demux, p_eit, true );
3157 }
3158 static void EITCallBackSchedule( demux_t *p_demux, dvbpsi_eit_t *p_eit )
3159 {
3160 EITCallBack( p_demux, p_eit, false );
3161 }
3162
3163 static void PSINewTableCallBack( demux_t *p_demux, dvbpsi_handle h,
3164 uint8_t i_table_id, uint16_t i_extension )
3165 {
3166 #if 0
3167 msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3168 i_table_id, i_table_id, i_extension, i_extension );
3169 #endif
3170 if( p_demux->p_sys->pid[0].psi->i_pat_version != -1 && i_table_id == 0x42 )
3171 {
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 );
3174
3175 dvbpsi_AttachSDT( h, i_table_id, i_extension,
3176 (dvbpsi_sdt_callback)SDTCallBack, p_demux );
3177 }
3178 else if( p_demux->p_sys->pid[0x11].psi->i_sdt_version != -1 &&
3179 ( i_table_id == 0x4e || /* Current/Following */
3180 (i_table_id >= 0x50 && i_table_id <= 0x5f) ) ) /* Schedule */
3181 {
3182 msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3183 i_table_id, i_table_id, i_extension, i_extension );
3184
3185 dvbpsi_eit_callback cb = i_table_id == 0x4e ?
3186 (dvbpsi_eit_callback)EITCallBackCurrentFollowing :
3187 (dvbpsi_eit_callback)EITCallBackSchedule;
3188 dvbpsi_AttachEIT( h, i_table_id, i_extension, cb, p_demux );
3189 }
3190 #ifdef TS_USE_TDT
3191 else if( p_demux->p_sys->pid[0x11].psi->i_sdt_version != -1 &&
3192 i_table_id == 0x70 ) /* TDT */
3193 {
3194 msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3195 i_table_id, i_table_id, i_extension, i_extension );
3196 dvbpsi_AttachTOT( h, i_table_id, i_extension,
3197 (dvbpsi_tot_callback)TDTCallBack, p_demux);
3198 }
3199 #endif
3200
3201 }
3202 #endif
3203
3204 /*****************************************************************************
3205 * PMT callback and helpers
3206 *****************************************************************************/
3207 static dvbpsi_descriptor_t *PMTEsFindDescriptor( const dvbpsi_pmt_es_t *p_es,
3208 int i_tag )
3209 {
3210 dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
3211 while( p_dr && ( p_dr->i_tag != i_tag ) )
3212 p_dr = p_dr->p_next;
3213 return p_dr;
3214 }
3215 static bool PMTEsHasRegistration( demux_t *p_demux,
3216 const dvbpsi_pmt_es_t *p_es,
3217 const char *psz_tag )
3218 {
3219 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x05 );
3220 if( !p_dr )
3221 return false;
3222
3223 if( p_dr->i_length < 4 )
3224 {
3225 msg_Warn( p_demux, "invalid Registration Descriptor" );
3226 return false;
3227 }
3228
3229 assert( strlen(psz_tag) == 4 );
3230 return !memcmp( p_dr->p_data, psz_tag, 4 );
3231 }
3232 static void PMTSetupEsISO14496( demux_t *p_demux, ts_pid_t *pid,
3233 const ts_prg_psi_t *prg, const dvbpsi_pmt_es_t *p_es )
3234 {
3235 es_format_t *p_fmt = &pid->es->fmt;
3236
3237 /* MPEG-4 stream: search SL_DESCRIPTOR */
3238 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x1f );
3239
3240 if( p_dr && p_dr->i_length == 2 )
3241 {
3242 const int i_es_id = ( p_dr->p_data[0] << 8 ) | p_dr->p_data[1];
3243
3244 msg_Warn( p_demux, "found SL_descriptor es_id=%d", i_es_id );
3245
3246 pid->es->p_mpeg4desc = NULL;
3247
3248 for( int i = 0; i < 255; i++ )
3249 {
3250 iod_descriptor_t *iod = prg->iod;
3251
3252 if( iod->es_descr[i].b_ok &&
3253 iod->es_descr[i].i_es_id == i_es_id )
3254 {
3255 pid->es->p_mpeg4desc = &iod->es_descr[i];
3256 break;
3257 }
3258 }
3259 }
3260 if( !pid->es->p_mpeg4desc )
3261 {
3262 msg_Err( p_demux, "MPEG-4 descriptor not found" );
3263 return;
3264 }
3265
3266 const decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
3267 if( dcd->i_streamType == 0x04 ) /* VisualStream */
3268 {
3269 p_fmt->i_cat = VIDEO_ES;
3270 switch( dcd->i_objectTypeIndication )
3271 {
3272 case 0x0B: /* mpeg4 sub */
3273 p_fmt->i_cat = SPU_ES;
3274 p_fmt->i_codec = VLC_CODEC_SUBT;
3275 break;
3276
3277 case 0x20: /* mpeg4 */
3278 p_fmt->i_codec = VLC_CODEC_MP4V;
3279 break;
3280 case 0x21: /* h264 */
3281 p_fmt->i_codec = VLC_CODEC_H264;
3282 break;
3283 case 0x60:
3284 case 0x61:
3285 case 0x62:
3286 case 0x63:
3287 case 0x64:
3288 case 0x65: /* mpeg2 */
3289 p_fmt->i_codec = VLC_CODEC_MPGV;
3290 break;
3291 case 0x6a: /* mpeg1 */
3292 p_fmt->i_codec = VLC_CODEC_MPGV;
3293 break;
3294 case 0x6c: /* mpeg1 */
3295 p_fmt->i_codec = VLC_CODEC_JPEG;
3296 break;
3297 default:
3298 p_fmt->i_cat = UNKNOWN_ES;
3299 break;
3300 }
3301 }
3302 else if( dcd->i_streamType == 0x05 ) /* AudioStream */
3303 {
3304 p_fmt->i_cat = AUDIO_ES;
3305 switch( dcd->i_objectTypeIndication )
3306 {
3307 case 0x40: /* mpeg4 */
3308 p_fmt->i_codec = VLC_CODEC_MP4A;
3309 break;
3310 case 0x66:
3311 case 0x67:
3312 case 0x68: /* mpeg2 aac */
3313 p_fmt->i_codec = VLC_CODEC_MP4A;
3314 break;
3315 case 0x69: /* mpeg2 */
3316 p_fmt->i_codec = VLC_CODEC_MPGA;
3317 break;
3318 case 0x6b: /* mpeg1 */
3319 p_fmt->i_codec = VLC_CODEC_MPGA;
3320 break;
3321 default:
3322 p_fmt->i_cat = UNKNOWN_ES;
3323 break;
3324 }
3325 }
3326 else
3327 {
3328 p_fmt->i_cat = UNKNOWN_ES;
3329 }
3330
3331 if( p_fmt->i_cat != UNKNOWN_ES )
3332 {
3333 p_fmt->i_extra = dcd->i_decoder_specific_info_len;
3334 if( p_fmt->i_extra > 0 )
3335 {
3336 p_fmt->p_extra = malloc( p_fmt->i_extra );
3337 if( p_fmt->p_extra )
3338 memcpy( p_fmt->p_extra,
3339 dcd->p_decoder_specific_info,
3340 p_fmt->i_extra );
3341 else
3342 p_fmt->i_extra = 0;
3343 }
3344 }
3345 }
3346
3347 typedef struct
3348 {
3349 int i_type;
3350 int i_magazine;
3351 int i_page;
3352 char p_iso639[3];
3353 } ts_teletext_page_t;
3354
3355 static void PMTSetupEsTeletext( demux_t *p_demux, ts_pid_t *pid,
3356 const dvbpsi_pmt_es_t *p_es )
3357 {
3358 es_format_t *p_fmt = &pid->es->fmt;
3359
3360 ts_teletext_page_t p_page[2 * 64 + 20];
3361 unsigned i_page = 0;
3362
3363 /* Gather pages informations */
3364 #if defined _DVBPSI_DR_56_H_ && \
3365 defined DVBPSI_VERSION && DVBPSI_VERSION_INT > ((0<<16)+(1<<8)+5)
3366 for( unsigned i_tag_idx = 0; i_tag_idx < 2; i_tag_idx++ )
3367 {
3368 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, i_tag_idx == 0 ? 0x46 : 0x56 );
3369 if( !p_dr )
3370 continue;
3371
3372 dvbpsi_teletext_dr_t *p_sub = dvbpsi_DecodeTeletextDr( p_dr );
3373 if( !p_sub )
3374 continue;
3375
3376 for( int i = 0; i < p_sub->i_pages_number; i++ )
3377 {
3378 const dvbpsi_teletextpage_t *p_src = &p_sub->p_pages[i];
3379
3380 if( p_src->i_teletext_type >= 0x06 )
3381 continue;
3382
3383 assert( i_page < sizeof(p_page)/sizeof(*p_page) );
3384
3385 ts_teletext_page_t *p_dst = &p_page[i_page++];
3386
3387 p_dst->i_type = p_src->i_teletext_type;
3388 p_dst->i_magazine = p_src->i_teletext_magazine_number
3389 ? p_src->i_teletext_magazine_number : 8;
3390 p_dst->i_page = p_src->i_teletext_page_number;
3391 memcpy( p_dst->p_iso639, p_src->i_iso6392_language_code, 3 );
3392 }
3393 }
3394 #endif
3395
3396 #ifdef _DVBPSI_DR_59_H_
3397 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
3398 if( p_dr )
3399 {
3400 dvbpsi_subtitling_dr_t *p_sub = dvbpsi_DecodeSubtitlingDr( p_dr );
3401 for( int i = 0; p_sub && i < p_sub->i_subtitles_number; i++ )
3402 {
3403 dvbpsi_subtitle_t *p_src = &p_sub->p_subtitle[i];
3404
3405 if( p_src->i_subtitling_type < 0x01 || p_src->i_subtitling_type > 0x03 )
3406 continue;
3407
3408 assert( i_page < sizeof(p_page)/sizeof(*p_page) );
3409
3410 ts_teletext_page_t *p_dst = &p_page[i_page++];
3411
3412 switch( p_src->i_subtitling_type )
3413 {
3414 case 0x01:
3415 p_dst->i_type = 0x02;
3416 break;
3417 default:
3418 p_dst->i_type = 0x03;
3419 break;
3420 }
3421 /* FIXME check if it is the right split */
3422 p_dst->i_magazine = (p_src->i_composition_page_id >> 8)
3423 ? (p_src->i_composition_page_id >> 8) : 8;
3424 p_dst->i_page = p_src->i_composition_page_id & 0xff;
3425 memcpy( p_dst->p_iso639, p_src->i_iso6392_language_code, 3 );
3426 }
3427 }
3428 #endif
3429
3430 /* */
3431 es_format_Init( p_fmt, SPU_ES, VLC_CODEC_TELETEXT );
3432
3433 if( !p_demux->p_sys->b_split_es || i_page <= 0 )
3434 {
3435 p_fmt->subs.teletext.i_magazine = -1;
3436 p_fmt->subs.teletext.i_page = 0;
3437 p_fmt->psz_description = strdup( vlc_gettext(ppsz_teletext_type[1]) );
3438
3439 dvbpsi_descriptor_t *p_dr;
3440 p_dr = PMTEsFindDescriptor( p_es, 0x46 );
3441 if( !p_dr )
3442 p_dr = PMTEsFindDescriptor( p_es, 0x56 );
3443
3444 if( !p_demux->p_sys->b_split_es && p_dr && p_dr->i_length > 0 )
3445 {
3446 /* Descriptor pass-through */
3447 p_fmt->p_extra = malloc( p_dr->i_length );
3448 if( p_fmt->p_extra )
3449 {
3450 p_fmt->i_extra = p_dr->i_length;
3451 memcpy( p_fmt->p_extra, p_dr->p_data, p_dr->i_length );
3452 }
3453 }
3454 }
3455 else
3456 {
3457 for( unsigned i = 0; i < i_page; i++ )
3458 {
3459 ts_es_t *p_es;
3460
3461 /* */
3462 if( i == 0 )
3463 {
3464 p_es = pid->es;
3465 }
3466 else
3467 {
3468 p_es = malloc( sizeof(*p_es) );
3469 if( !p_es )
3470 break;
3471
3472 es_format_Copy( &p_es->fmt, &pid->es->fmt );
3473 free( p_es->fmt.psz_language );
3474 free( p_es->fmt.psz_description );
3475 p_es->fmt.psz_language = NULL;
3476 p_es->fmt.psz_description = NULL;
3477
3478 p_es->id = NULL;
3479 p_es->p_pes = NULL;
3480 p_es->i_pes_size = 0;
3481 p_es->i_pes_gathered = 0;
3482 p_es->pp_last = &p_es->p_pes;
3483 p_es->p_mpeg4desc = NULL;
3484 p_es->b_gather = false;
3485
3486 TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
3487 }
3488
3489 /* */
3490 const ts_teletext_page_t *p = &p_page[i];
3491 p_es->fmt.i_priority = (p->i_type == 0x02 || p->i_type == 0x05) ? 0 : -1;
3492 p_es->fmt.psz_language = strndup( p->p_iso639, 3 );
3493 p_es->fmt.psz_description = strdup(vlc_gettext(ppsz_teletext_type[p->i_type]));
3494 p_es->fmt.subs.teletext.i_magazine = p->i_magazine;
3495 p_es->fmt.subs.teletext.i_page = p->i_page;
3496
3497 msg_Dbg( p_demux,
3498 " * ttxt type=%s lan=%s page=%d%02x",
3499 p_es->fmt.psz_description,
3500 p_es->fmt.psz_language,
3501 p->i_magazine, p->i_page );
3502 }
3503 }
3504 }
3505 static void PMTSetupEsDvbSubtitle( demux_t *p_demux, ts_pid_t *pid,
3506 const dvbpsi_pmt_es_t *p_es )
3507 {
3508 es_format_t *p_fmt = &pid->es->fmt;
3509
3510 es_format_Init( p_fmt, SPU_ES, VLC_CODEC_DVBS );
3511
3512 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
3513 int i_page = 0;
3514 #ifdef _DVBPSI_DR_59_H_
3515 dvbpsi_subtitling_dr_t *p_sub = dvbpsi_DecodeSubtitlingDr( p_dr );
3516 for( int i = 0; p_sub && i < p_sub->i_subtitles_number; i++ )
3517 {
3518 const int i_type = p_sub->p_subtitle[i].i_subtitling_type;
3519 if( ( i_type >= 0x10 && i_type <= 0x14 ) ||
3520 ( i_type >= 0x20 && i_type <= 0x24 ) )
3521 i_page++;
3522 }
3523 #endif
3524
3525 if( !p_demux->p_sys->b_split_es || i_page <= 0 )
3526 {
3527 p_fmt->subs.dvb.i_id = -1;
3528 p_fmt->psz_description = strdup( _("DVB subtitles") );
3529
3530 if( !p_demux->p_sys->b_split_es && p_dr && p_dr->i_length > 0 )
3531 {
3532 /* Descriptor pass-through */
3533 p_fmt->p_extra = malloc( p_dr->i_length );
3534 if( p_fmt->p_extra )
3535 {
3536 p_fmt->i_extra = p_dr->i_length;
3537 memcpy( p_fmt->p_extra, p_dr->p_data, p_dr->i_length );
3538 }
3539 }
3540 }
3541 else
3542 {
3543 #ifdef _DVBPSI_DR_59_H_
3544 for( int i = 0; i < p_sub->i_subtitles_number; i++ )
3545 {
3546 ts_es_t *p_es;
3547
3548 /* */
3549 if( i == 0 )
3550 {
3551 p_es = pid->es;
3552 }
3553 else
3554 {
3555 p_es = malloc( sizeof(*p_es) );
3556 if( !p_es )
3557 break;
3558
3559 es_format_Copy( &p_es->fmt, &pid->es->fmt );
3560 free( p_es->fmt.psz_language );
3561 free( p_es->fmt.psz_description );
3562 p_es->fmt.psz_language = NULL;
3563 p_es->fmt.psz_description = NULL;
3564
3565 p_es->id = NULL;
3566 p_es->p_pes = NULL;
3567 p_es->i_pes_size = 0;
3568 p_es->i_pes_gathered = 0;
3569 p_es->pp_last = &p_es->p_pes;
3570 p_es->p_mpeg4desc = NULL;
3571 p_es->b_gather = false;
3572
3573 TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
3574 }
3575
3576 /* */
3577 const dvbpsi_subtitle_t *p = &p_sub->p_subtitle[i];
3578 p_es->fmt.psz_language = strndup( p->i_iso6392_language_code, 3 );
3579 switch( p->i_subtitling_type )
3580 {
3581 case 0x10: /* unspec. */
3582 case 0x11: /* 4:3 */
3583 case 0x12: /* 16:9 */
3584 case 0x13: /* 2.21:1 */
3585 case 0x14: /* HD monitor */
3586 p_es->fmt.psz_description = strdup( _("DVB subtitles") );
3587 break;
3588 case 0x20: /* Hearing impaired unspec. */
3589 case 0x21: /* h.i. 4:3 */
3590 case 0x22: /* h.i. 16:9 */
3591 case 0x23: /* h.i. 2.21:1 */
3592 case 0x24: /* h.i. HD monitor */
3593 p_es->fmt.psz_description = strdup( _("DVB subtitles: hearing impaired") );
3594 break;
3595 default:
3596 break;
3597 }
3598
3599 /* Hack, FIXME */
3600 p_es->fmt.subs.dvb.i_id = ( p->i_composition_page_id << 0 ) |
3601 ( p->i_ancillary_page_id << 16 );
3602 }
3603 #endif
3604 }
3605 }
3606 static void PMTSetupEs0x06( demux_t *p_demux, ts_pid_t *pid,
3607 const dvbpsi_pmt_es_t *p_es )
3608 {
3609 es_format_t *p_fmt = &pid->es->fmt;
3610
3611 if( PMTEsHasRegistration( p_demux, p_es, "AC-3" ) ||
3612 PMTEsFindDescriptor( p_es, 0x6a ) ||
3613 PMTEsFindDescriptor( p_es, 0x81 ) )
3614 {
3615 p_fmt->i_cat = AUDIO_ES;
3616 p_fmt->i_codec = VLC_CODEC_A52;
3617 }
3618 else if( PMTEsFindDescriptor( p_es, 0x7a ) )
3619 {
3620 /* DVB with stream_type 0x06 (ETS EN 300 468) */
3621 p_fmt->i_cat = AUDIO_ES;
3622 p_fmt->i_codec = VLC_CODEC_EAC3;
3623 }
3624 else if( PMTEsHasRegistration( p_demux, p_es, "DTS1" ) ||
3625 PMTEsHasRegistration( p_demux, p_es, "DTS2" ) ||
3626 PMTEsHasRegistration( p_demux, p_es, "DTS3" ) ||
3627 PMTEsFindDescriptor( p_es, 0x73 ) )
3628 {
3629 /*registration descriptor(ETSI TS 101 154 Annex F)*/
3630 p_fmt->i_cat = AUDIO_ES;
3631 p_fmt->i_codec = VLC_CODEC_DTS;
3632 }
3633 else if( PMTEsHasRegistration( p_demux, p_es, "BSSD" ) )
3634 {
3635 p_fmt->i_cat = AUDIO_ES;
3636 p_fmt->b_packetized = true;
3637 p_fmt->i_codec = VLC_CODEC_302M;
3638 }
3639 else
3640 {
3641 /* Subtitle/Teletext/VBI fallbacks */
3642 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
3643
3644 #ifdef _DVBPSI_DR_59_H_
3645 dvbpsi_subtitling_dr_t *p_sub;
3646 if( p_dr && ( p_sub = dvbpsi_DecodeSubtitlingDr( p_dr ) ) )
3647 {
3648 for( int i = 0; i < p_sub->i_subtitles_number; i++ )
3649 {
3650 if( p_fmt->i_cat != UNKNOWN_ES )
3651 break;
3652
3653 switch( p_sub->p_subtitle[i].i_subtitling_type )
3654 {
3655 case 0x01: /* EBU Teletext subtitles */
3656 case 0x02: /* Associated EBU Teletext */
3657 case 0x03: /* VBI data */
3658 PMTSetupEsTeletext( p_demux, pid, p_es );
3659 break;
3660 case 0x10: /* DVB Subtitle (normal) with no monitor AR critical */
3661 case 0x11: /* ... on 4:3 AR monitor */
3662 case 0x12: /* ... on 16:9 AR monitor */
3663 case 0x13: /* ... on 2.21:1 AR monitor */
3664 case 0x14: /* ... for display on a high definition monitor */
3665 case 0x20: /* DVB Subtitle (impaired) with no monitor AR critical */
3666 case 0x21: /* ... on 4:3 AR monitor */
3667 case 0x22: /* ... on 16:9 AR monitor */
3668 case 0x23: /* ... on 2.21:1 AR monitor */
3669 case 0x24: /* ... for display on a high definition monitor */
3670 PMTSetupEsDvbSubtitle( p_demux, pid, p_es );
3671 break;
3672 default:
3673 msg_Err( p_demux, "Unrecognized DVB subtitle type (0x%x)",
3674 p_sub->p_subtitle[i].i_subtitling_type );
3675 break;
3676 }
3677 }
3678 }
3679 #else
3680 if( p_fmt->i_cat == UNKNOWN_ES && p_dr )
3681 PMTSetupEsDvbSubtitle( p_demux, pid, p_es );
3682 #endif
3683 if( p_fmt->i_cat == UNKNOWN_ES &&
3684 ( PMTEsFindDescriptor( p_es, 0x45 ) || /* VBI Data descriptor */
3685 PMTEsFindDescriptor( p_es, 0x46 ) || /* VBI Teletext descriptor */
3686 PMTEsFindDescriptor( p_es, 0x56 ) ) ) /* EBU Teletext descriptor */
3687 {
3688 /* Teletext/VBI */
3689 PMTSetupEsTeletext( p_demux, pid, p_es );
3690 }
3691 }
3692
3693 #ifdef _DVBPSI_DR_52_H_
3694 /* FIXME is it useful ? */
3695 if( PMTEsFindDescriptor( p_es, 0x52 ) )
3696 {
3697 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x52 );
3698 dvbpsi_stream_identifier_dr_t *p_si = dvbpsi_DecodeStreamIdentifierDr( p_dr );
3699
3700 msg_Dbg( p_demux, " * Stream Component Identifier: %d", p_si->i_component_tag );
3701 }
3702 #endif
3703 }
3704
3705 static void PMTSetupEs0xEA( demux_t *p_demux, ts_pid_t *pid,
3706 const dvbpsi_pmt_es_t *p_es )
3707 {
3708 /* Registration Descriptor */
3709 if( !PMTEsHasRegistration( p_demux, p_es, "VC-1" ) )
3710 {
3711 msg_Err( p_demux, "Registration descriptor not found or invalid" );
3712 return;
3713 }
3714
3715 es_format_t *p_fmt = &pid->es->fmt;
3716
3717 /* registration descriptor for VC-1 (SMPTE rp227) */
3718 p_fmt->i_cat = VIDEO_ES;
3719 p_fmt->i_codec = VLC_CODEC_VC1;
3720
3721 /* XXX With Simple and Main profile the SEQUENCE
3722 * header is modified: video width and height are
3723 * inserted just after the start code as 2 int16_t
3724 * The packetizer will take care of that. */
3725 }
3726
3727 static void PMTSetupEs0xD1( demux_t *p_demux, ts_pid_t *pid,
3728 const dvbpsi_pmt_es_t *p_es )
3729 {
3730 /* Registration Descriptor */
3731 if( !PMTEsHasRegistration( p_demux, p_es, "drac" ) )
3732 {
3733 msg_Err( p_demux, "Registration descriptor not found or invalid" );
3734 return;
3735 }
3736
3737 es_format_t *p_fmt = &pid->es->fmt;
3738
3739 /* registration descriptor for Dirac
3740 * (backwards compatable with VC-2 (SMPTE Sxxxx:2008)) */
3741 p_fmt->i_cat = VIDEO_ES;
3742 p_fmt->i_codec = VLC_CODEC_DIRAC;
3743 }
3744
3745 static void PMTSetupEs0xA0( demux_t *p_demux, ts_pid_t *pid,
3746 const dvbpsi_pmt_es_t *p_es )
3747 {
3748 /* MSCODEC sent by vlc */
3749 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0xa0 );
3750 if( !p_dr || p_dr->i_length < 10 )
3751 {
3752 msg_Warn( p_demux,
3753 "private MSCODEC (vlc) without bih private descriptor" );
3754 return;
3755 }
3756
3757 es_format_t *p_fmt = &pid->es->fmt;
3758 p_fmt->i_cat = VIDEO_ES;
3759 p_fmt->i_codec = VLC_FOURCC( p_dr->p_data[0], p_dr->p_data[1],
3760 p_dr->p_data[2], p_dr->p_data[3] );
3761 p_fmt->video.i_width = GetWBE( &p_dr->p_data[4] );
3762 p_fmt->video.i_height = GetWBE( &p_dr->p_data[6] );
3763 p_fmt->i_extra = GetWBE( &p_dr->p_data[8] );
3764
3765 if( p_fmt->i_extra > 0 )
3766 {
3767 p_fmt->p_extra = malloc( p_fmt->i_extra );
3768 if( p_fmt->p_extra )
3769 memcpy( p_fmt->p_extra, &p_dr->p_data[10],
3770 __MIN( p_fmt->i_extra, p_dr->i_length - 10 ) );
3771 else
3772 p_fmt->i_extra = 0;
3773 }
3774 /* For such stream we will gather them ourself and don't launch a
3775 * packetizer.
3776 * Yes it's ugly but it's the only way to have DIV3 working */
3777 p_fmt->b_packetized = true;
3778 }
3779
3780 static void PMTSetupEsHDMV( demux_t *p_demux, ts_pid_t *pid,
3781 const dvbpsi_pmt_es_t *p_es )
3782 {
3783 VLC_UNUSED(p_demux);
3784 es_format_t *p_fmt = &pid->es->fmt;
3785
3786 /* Blu-Ray mapping */
3787 switch( p_es->i_type )
3788 {
3789 case 0x80:
3790 p_fmt->i_cat = AUDIO_ES;
3791 p_fmt->i_codec = VLC_CODEC_BD_LPCM;
3792 break;
3793 case 0x82:
3794 case 0x85: /* DTS-HD High resolution audio */
3795 case 0x86: /* DTS-HD Master audio */
3796 case 0xA2: /* Secondary DTS audio */
3797 p_fmt->i_cat = AUDIO_ES;
3798 p_fmt->i_codec = VLC_CODEC_DTS;
3799 break;
3800
3801 case 0x83: /* TrueHD AC3 */
3802 p_fmt->i_cat = AUDIO_ES;
3803 p_fmt->i_codec = VLC_CODEC_TRUEHD;
3804 break;
3805
3806 case 0x84: /* E-AC3 */
3807 case 0xA1: /* Secondary E-AC3 */
3808 p_fmt->i_cat = AUDIO_ES;
3809 p_fmt->i_codec = VLC_CODEC_EAC3;
3810 break;
3811 case 0x90: /* Presentation graphics */
3812 p_fmt->i_cat = SPU_ES;
3813 p_fmt->i_codec = VLC_CODEC_BD_PG;
3814 break;
3815 case 0x91: /* Interactive graphics */
3816 case 0x92: /* Subtitle */
3817 default:
3818 break;
3819 }
3820 }
3821
3822 static void PMTSetupEsRegistration( demux_t *p_demux, ts_pid_t *pid,
3823 const dvbpsi_pmt_es_t *p_es )
3824 {
3825 static const struct
3826 {
3827 char psz_tag[5];
3828 int i_cat;
3829 vlc_fourcc_t i_codec;
3830 } p_regs[] = {
3831 { "AC-3", AUDIO_ES, VLC_CODEC_A52 },
3832 { "DTS1", AUDIO_ES, VLC_CODEC_DTS },
3833 { "DTS2", AUDIO_ES, VLC_CODEC_DTS },
3834 { "DTS3", AUDIO_ES, VLC_CODEC_DTS },
3835 { "BSSD", AUDIO_ES, VLC_CODEC_302M },
3836 { "VC-1", VIDEO_ES, VLC_CODEC_VC1 },
3837 { "drac", VIDEO_ES, VLC_CODEC_DIRAC },
3838 { "", UNKNOWN_ES, 0 }
3839 };
3840 es_format_t *p_fmt = &pid->es->fmt;
3841
3842 for( int i = 0; p_regs[i].i_cat != UNKNOWN_ES; i++ )
3843 {
3844 if( PMTEsHasRegistration( p_demux, p_es, p_regs[i].psz_tag ) )
3845 {
3846 p_fmt->i_cat = p_regs[i].i_cat;
3847 p_fmt->i_codec = p_regs[i].i_codec;
3848 break;
3849 }
3850 }
3851 }
3852
3853 static void PMTParseEsIso639( demux_t *p_demux, ts_pid_t *pid,
3854 const dvbpsi_pmt_es_t *p_es )
3855 {
3856 /* get language descriptor */
3857 dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x0a );
3858
3859 if( !p_dr )
3860 return;
3861
3862 dvbpsi_iso639_dr_t *p_decoded = dvbpsi_DecodeISO639Dr( p_dr );
3863 if( !p_decoded )
3864 {
3865 msg_Err( p_demux, "Failed to decode a ISO 639 descriptor" );
3866 return;
3867 }
3868
3869 #if defined(DR_0A_API_VER) && (DR_0A_API_VER >= 2)
3870 pid->es->fmt.psz_language = malloc( 4 );
3871 if( pid->es->fmt.psz_language )
3872 {
3873 memcpy( pid->es->fmt.psz_language,
3874 p_decoded->code[0].iso_639_code, 3 );
3875 pid->es->fmt.psz_language[3] = 0;
3876 msg_Dbg( p_demux, "found language: %s", pid->es->fmt.psz_language);
3877 }
3878 switch( p_decoded->code[0].i_audio_type )
3879 {
3880 case 0:
3881 pid->es->fmt.psz_description = NULL;
3882 break;
3883 case 1:
3884 pid->es->fmt.psz_description =
3885 strdup(_("clean effects"));
3886 break;
3887 case 2:
3888 pid->es->fmt.psz_description =
3889 strdup(_("hearing impaired"));
3890 break;
3891 case 3:
3892 pid->es->fmt.psz_description =
3893 strdup(_("visual impaired commentary"));
3894 break;
3895 default:
3896 msg_Dbg( p_demux, "unknown audio type: %d",
3897 p_decoded->code[0].i_audio_type);
3898 pid->es->fmt.psz_description = NULL;
3899 break;
3900 }
3901 pid->es->fmt.i_extra_languages = p_decoded->i_code_count-1;
3902 if( pid->es->fmt.i_extra_languages > 0 )
3903 pid->es->fmt.p_extra_languages =
3904 malloc( sizeof(*pid->es->fmt.p_extra_languages) *
3905 pid->es->fmt.i_extra_languages );
3906 if( pid->es->fmt.p_extra_languages )
3907 {
3908 for( int i = 0; i < pid->es->fmt.i_extra_languages; i++ )
3909 {
3910 msg_Dbg( p_demux, "bang" );
3911 pid->es->fmt.p_extra_languages[i].psz_language =
3912 malloc(4);
3913 if( pid->es->fmt.p_extra_languages[i].psz_language )
3914 {
3915 memcpy( pid->es->fmt.p_extra_languages[i].psz_language,
3916 p_decoded->code[i+1].iso_639_code, 3 );
3917 pid->es->fmt.p_extra_languages[i].psz_language[3] = '\0';
3918 }
3919 switch( p_decoded->code[i].i_audio_type )
3920 {
3921 case 0:
3922 pid->es->fmt.p_extra_languages[i].psz_description =
3923 NULL;
3924 break;
3925 case 1:
3926 pid->es->fmt.p_extra_languages[i].psz_description =
3927 strdup(_("clean effects"));
3928 break;
3929 case 2:
3930 pid->es->fmt.p_extra_languages[i].psz_description =
3931 strdup(_("hearing impaired"));
3932 break;
3933 case 3:
3934 pid->es->fmt.p_extra_languages[i].psz_description =
3935 strdup(_("visual impaired commentary"));
3936 break;
3937 default:
3938 msg_Dbg( p_demux, "unknown audio type: %d",
3939 p_decoded->code[i].i_audio_type);
3940 pid->es->fmt.psz_description = NULL;
3941 break;
3942 }
3943
3944 }
3945 }
3946 #else
3947 pid->es->fmt.psz_language = malloc( 4 );
3948 if( pid->es->fmt.psz_language )
3949 {
3950 memcpy( pid->es->fmt.psz_language,
3951 p_decoded->i_iso_639_code, 3 );
3952 pid->es->fmt.psz_language[3] = 0;
3953 }
3954 #endif
3955 }
3956
3957 static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt )
3958 {
3959 demux_sys_t *p_sys = p_demux->p_sys;
3960 dvbpsi_descriptor_t *p_dr;
3961 dvbpsi_pmt_es_t *p_es;
3962
3963 ts_pid_t *pmt = NULL;
3964 ts_prg_psi_t *prg = NULL;
3965
3966 ts_pid_t **pp_clean = NULL;
3967 int i_clean = 0;
3968 bool b_hdmv = false;
3969
3970 msg_Dbg( p_demux, "PMTCallBack called" );
3971
3972 /* First find this PMT declared in PAT */
3973 for( int i = 0; i < p_sys->i_pmt; i++ )
3974 {
3975 int i_prg;
3976 for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
3977 {
3978 const int i_pmt_number = p_sys->pmt[i]->psi->prg[i_prg]->i_number;
3979 if( i_pmt_number != TS_USER_PMT_NUMBER && i_pmt_number == p_pmt->i_program_number )
3980 {
3981 pmt = p_sys->pmt[i];
3982 prg = p_sys->pmt[i]->psi->prg[i_prg];
3983 break;
3984 }
3985 }
3986 if( pmt )
3987 break;
3988 }
3989
3990 if( pmt == NULL )
3991 {
3992 msg_Warn( p_demux, "unreferenced program (broken stream)" );
3993 dvbpsi_DeletePMT(p_pmt);
3994 return;
3995 }
3996
3997 if( prg->i_version != -1 &&
3998 ( !p_pmt->b_current_next || prg->i_version == p_pmt->i_version ) )
3999 {
4000 dvbpsi_DeletePMT( p_pmt );
4001 return;
4002 }
4003
4004 /* Clean this program (remove all es) */
4005 for( int i = 0; i < 8192; i++ )
4006 {
4007 ts_pid_t *pid = &p_sys->pid[i];
4008
4009 if( pid->b_valid && pid->p_owner == pmt->psi &&
4010 pid->i_owner_number == prg->i_number && pid->psi == NULL )
4011 {
4012 TAB_APPEND( i_clean, pp_clean, pid );
4013 }
4014 }
4015 if( prg->iod )
4016 {
4017 IODFree( prg->iod );
4018 prg->iod = NULL;
4019 }
4020
4021 msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=%d",
4022 p_pmt->i_program_number, p_pmt->i_version, p_pmt->i_pcr_pid );
4023 prg->i_pid_pcr = p_pmt->i_pcr_pid;
4024 prg->i_version = p_pmt->i_version;
4025
4026 ValidateDVBMeta( p_demux, prg->i_pid_pcr );
4027 if( ProgramIsSelected( p_demux, prg->i_number ) )
4028 {
4029 /* Set demux filter */
4030 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4031 ACCESS_SET_PRIVATE_ID_STATE, prg->i_pid_pcr,
4032 true );
4033 }
4034 else if ( p_sys->b_access_control )
4035 {
4036 msg_Warn( p_demux, "skipping program (not selected)" );
4037 dvbpsi_DeletePMT(p_pmt);
4038 return;
4039 }
4040
4041 /* Parse descriptor */
4042 for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
4043 {
4044 if( p_dr->i_tag == 0x1d )
4045 {
4046 /* We have found an IOD descriptor */
4047 msg_Dbg( p_demux, " * descriptor : IOD (0x1d)" );
4048
4049 prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
4050 }
4051 else if( p_dr->i_tag == 0x9 )
4052 {
4053 uint16_t i_sysid = ((uint16_t)p_dr->p_data[0] << 8)
4054 | p_dr->p_data[1];
4055 msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x", i_sysid );
4056 }
4057 else if( p_dr->i_tag == 0x05 )
4058 {
4059 /* Registration Descriptor */
4060 if( p_dr->i_length != 4 )
4061 {
4062 msg_Warn( p_demux, "invalid Registration Descriptor" );
4063 }
4064 else
4065 {
4066 msg_Dbg( p_demux, " * descriptor : registration %4.4s", p_dr->p_data );
4067 if( !memcmp( p_dr->p_data, "HDMV", 4 ) )
4068 {
4069 /* Blu-Ray */
4070 b_hdmv = true;
4071 }
4072 }
4073 }
4074 else
4075 {
4076 msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
4077 }
4078 }
4079
4080 for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
4081 {
4082 ts_pid_t tmp_pid, *old_pid = 0, *pid = &tmp_pid;
4083
4084 /* Find out if the PID was already declared */
4085 for( int i = 0; i < i_clean; i++ )
4086 {
4087 if( pp_clean[i] == &p_sys->pid[p_es->i_pid] )
4088 {
4089 old_pid = pp_clean[i];
4090 break;
4091 }
4092 }
4093 ValidateDVBMeta( p_demux, p_es->i_pid );
4094
4095 if( !old_pid && p_sys->pid[p_es->i_pid].b_valid )
4096 {
4097 msg_Warn( p_demux, "pmt error: pid=%d already defined",
4098 p_es->i_pid );
4099 continue;
4100 }
4101
4102 for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
4103 p_dr = p_dr->p_next )
4104 {
4105 msg_Dbg( p_demux, " * es pid=%d type=%d dr->i_tag=0x%x",
4106 p_es->i_pid, p_es->i_type, p_dr->i_tag );
4107 }
4108
4109 PIDInit( pid, false, pmt->psi );
4110 PIDFillFormat( pid, p_es->i_type );
4111 pid->i_owner_number = prg->i_number;
4112 pid->i_pid = p_es->i_pid;
4113 pid->b_seen = p_sys->pid[p_es->i_pid].b_seen;
4114
4115 if( p_es->i_type == 0x10 || p_es->i_type == 0x11 ||
4116 p_es->i_type == 0x12 || p_es->i_type == 0x0f )
4117 {
4118 PMTSetupEsISO14496( p_demux, pid, prg, p_es );
4119 }
4120 else if( p_es->i_type == 0x06 )
4121 {
4122 PMTSetupEs0x06( p_demux, pid, p_es );
4123 }
4124 else if( p_es->i_type == 0xEA )
4125 {
4126 PMTSetupEs0xEA( p_demux, pid, p_es );
4127 }
4128 else if( p_es->i_type == 0xd1 )
4129 {
4130 PMTSetupEs0xD1( p_demux, pid, p_es );
4131 }
4132 else if( p_es->i_type == 0xa0 )
4133 {
4134 PMTSetupEs0xA0( p_demux, pid, p_es );
4135 }
4136 else if( b_hdmv )
4137 {
4138 PMTSetupEsHDMV( p_demux, pid, p_es );
4139 }
4140 else if( p_es->i_type >= 0x80 )
4141 {
4142 PMTSetupEsRegistration( p_demux, pid, p_es );
4143 }
4144
4145 if( pid->es->fmt.i_cat == AUDIO_ES ||
4146 ( pid->es->fmt.i_cat == SPU_ES &&
4147 pid->es->fmt.i_codec != VLC_CODEC_DVBS &&
4148 pid->es->fmt.i_codec != VLC_CODEC_TELETEXT ) )
4149 {
4150 PMTParseEsIso639( p_demux, pid, p_es );
4151 }
4152
4153 pid->es->fmt.i_group = p_pmt->i_program_number;
4154 for( int i = 0; i < pid->i_extra_es; i++ )
4155 pid->extra_es[i]->fmt.i_group = p_pmt->i_program_number;
4156
4157 if( pid->es->fmt.i_cat == UNKNOWN_ES )
4158 {
4159 msg_Dbg( p_demux, " * es pid=%d type=%d *unknown*",
4160 p_es->i_pid, p_es->i_type );
4161 }
4162 else if( !p_sys->b_udp_out )
4163 {
4164 msg_Dbg( p_demux, " * es pid=%d type=%d fcc=%4.4s",
4165 p_es->i_pid, p_es->i_type, (char*)&pid->es->fmt.i_codec );
4166
4167 if( p_sys->b_es_id_pid ) pid->es->fmt.i_id = p_es->i_pid;
4168
4169 /* Check if we can avoid restarting the ES */
4170 if( old_pid &&
4171 pid->es->fmt.i_codec == old_pid->es->fmt.i_codec &&
4172 pid->es->fmt.i_extra == old_pid->es->fmt.i_extra &&
4173 pid->es->fmt.i_extra == 0 &&
4174 pid->i_extra_es == old_pid->i_extra_es &&
4175 ( ( !pid->es->fmt.psz_language &&
4176 !old_pid->es->fmt.psz_language ) ||
4177 ( pid->es->fmt.psz_language &&
4178 old_pid->es->fmt.psz_language &&
4179 !strcmp( pid->es->fmt.psz_language,
4180 old_pid->es->fmt.psz_language ) ) ) )
4181 {
4182 pid->es->id = old_pid->es->id;
4183 old_pid->es->id = NULL;
4184 for( int i = 0; i < pid->i_extra_es; i++ )
4185 {
4186 pid->extra_es[i]->id = old_pid->extra_es[i]->id;
4187 old_pid->extra_es[i]->id = NULL;
4188 }
4189 }
4190 else
4191 {
4192 if( old_pid )
4193 {
4194 PIDClean( p_demux, old_pid );
4195 TAB_REMOVE( i_clean, pp_clean, old_pid );
4196 old_pid = 0;
4197 }
4198
4199 pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
4200 for( int i = 0; i < pid->i_extra_es; i++ )
4201 {
4202 pid->extra_es[i]->id =
4203 es_out_Add( p_demux->out, &pid->extra_es[i]->fmt );
4204 }
4205 p_sys->i_pmt_es += 1 + pid->i_extra_es;
4206 }
4207 }
4208
4209 /* Add ES to the list */
4210 if( old_pid )
4211 {
4212 PIDClean( p_demux, old_pid );
4213 TAB_REMOVE( i_clean, pp_clean, old_pid );
4214 }
4215 p_sys->pid[p_es->i_pid] = *pid;
4216
4217 p_dr = PMTEsFindDescriptor( p_es, 0x09 );
4218 if( p_dr && p_dr->i_length >= 2 )
4219 {
4220 uint16_t i_sysid = (p_dr->p_data[0] << 8) | p_dr->p_data[1];
4221 msg_Dbg( p_demux, " * descriptor : CA (0x9) SysID 0x%x",
4222 i_sysid );
4223 }
4224
4225 if( ProgramIsSelected( p_demux, prg->i_number ) &&
4226 ( pid->es->id != NULL || p_sys->b_udp_out ) )
4227 {
4228 /* Set demux filter */
4229 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4230 ACCESS_SET_PRIVATE_ID_STATE, p_es->i_pid,
4231 true );
4232 }
4233 }
4234
4235 /* Set CAM descrambling */
4236 if( !ProgramIsSelected( p_demux, prg->i_number )
4237 || stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4238 ACCESS_SET_PRIVATE_ID_CA, p_pmt ) != VLC_SUCCESS )
4239 dvbpsi_DeletePMT( p_pmt );
4240
4241 for( int i = 0; i < i_clean; i++ )
4242 {
4243 if( ProgramIsSelected( p_demux, prg->i_number ) )
4244 {
4245 stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4246 ACCESS_SET_PRIVATE_ID_STATE, pp_clean[i]->i_pid,
4247 false );
4248 }
4249
4250 PIDClean( p_demux, pp_clean[i] );
4251 }
4252 if( i_clean )
4253 free( pp_clean );
4254 }
4255
4256 static void PATCallBack( demux_t *p_demux, dvbpsi_pat_t *p_pat )
4257 {
4258 demux_sys_t *p_sys = p_demux->p_sys;
4259 dvbpsi_pat_program_t *p_program;
4260 ts_pid_t *pat = &p_sys->pid[0];
4261
4262 msg_Dbg( p_demux, "PATCallBack called" );
4263
4264 if( ( pat->psi->i_pat_version != -1 &&
4265 ( !p_pat->b_current_next ||
4266 p_pat->i_version == pat->psi->i_pat_version ) ) ||
4267 p_sys->b_user_pmt )
4268 {
4269 dvbpsi_DeletePAT( p_pat );
4270 return;
4271 }
4272
4273 msg_Dbg( p_demux, "new PAT ts_id=%d version=%d current_next=%d",
4274 p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
4275
4276 /* Clean old */
4277 if( p_sys->i_pmt > 0 )
4278 {
4279 int i_pmt_rm = 0;
4280 ts_pid_t **pmt_rm = NULL;
4281
4282 /* Search pmt to be deleted */
4283 for( int i = 0; i < p_sys->i_pmt; i++ )
4284 {
4285 ts_pid_t *pmt = p_sys->pmt[i];
4286 bool b_keep = false;
4287
4288 for( p_program = p_pat->p_first_program; p_program != NULL;
4289 p_program = p_program->p_next )
4290 {
4291 if( p_program->i_pid == pmt->i_pid )
4292 {
4293 for( int i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
4294 {
4295 if( p_program->i_number ==
4296 pmt->psi->prg[i_prg]->i_number )
4297 {
4298 b_keep = true;
4299 break;
4300 }
4301 }
4302 if( b_keep )
4303 break;
4304 }
4305 }
4306
4307 if( !b_keep )
4308 {
4309 TAB_APPEND( i_pmt_rm, pmt_rm, pmt );
4310 }
4311 }
4312
4313 /* Delete all ES attached to thoses PMT */
4314 for( int i = 2; i < 8192; i++ )
4315 {
4316 ts_pid_t *pid = &p_sys->pid[i];
4317
4318 if( !pid->b_valid || pid->psi )
4319 continue;
4320
4321 for( int j = 0; j < i_pmt_rm && pid->b_valid; j++ )
4322 {
4323 for( int i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
4324 {
4325 /* We only remove es that aren't defined by extra pmt */
4326 if( pid->p_owner->prg[i_prg]->i_pid_pmt != pmt_rm[j]->i_pid )
4327 continue;
4328
4329 if( p_sys->b_access_control && pid->es->id )
4330 {
4331 if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4332 ACCESS_SET_PRIVATE_ID_STATE, i,
4333 false ) )
4334 p_sys->b_access_control = false;
4335 }
4336
4337 PIDClean( p_demux, pid );
4338 break;
4339 }
4340 }
4341 }
4342
4343 /* Delete PMT pid */
4344 for( int i = 0; i < i_pmt_rm; i++ )
4345 {
4346 if( p_sys->b_access_control )
4347 {
4348 if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4349 ACCESS_SET_PRIVATE_ID_STATE,
4350 pmt_rm[i]->i_pid, false ) )
4351 p_sys->b_access_control = false;
4352 }
4353
4354 for( int i_prg = 0; i_prg < pmt_rm[i]->psi->i_prg; i_prg++ )
4355 {
4356 const int i_number = pmt_rm[i]->psi->prg[i_prg]->i_number;
4357 es_out_Control( p_demux->out, ES_OUT_DEL_GROUP, i_number );
4358 }
4359
4360 PIDClean( p_demux, &p_sys->pid[pmt_rm[i]->i_pid] );
4361 TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pmt_rm[i] );
4362 }
4363
4364 free( pmt_rm );
4365 }
4366
4367 /* now create programs */
4368 for( p_program = p_pat->p_first_program; p_program != NULL;
4369 p_program = p_program->p_next )
4370 {
4371 msg_Dbg( p_demux, " * number=%d pid=%d", p_program->i_number,
4372 p_program->i_pid );
4373 if( p_program->i_number != 0 )
4374 {
4375 ts_pid_t *pmt = &p_sys->pid[p_program->i_pid];
4376 bool b_add = true;
4377
4378 ValidateDVBMeta( p_demux, p_program->i_pid );
4379
4380 if( pmt->b_valid )
4381 {
4382 int i_prg;
4383 for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
4384 {
4385 if( pmt->psi->prg[i_prg]->i_number == p_program->i_number )
4386 {
4387 b_add = false;
4388 break;
4389 }
4390 }
4391 }
4392 else
4393 {
4394 TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
4395 }
4396
4397 if( b_add )
4398 {
4399 PIDInit( pmt, true, pat->psi );
4400 pmt->psi->prg[pmt->psi->i_prg-1]->handle =
4401 dvbpsi_AttachPMT( p_program->i_number,
4402 (dvbpsi_pmt_callback)PMTCallBack,
4403 p_demux );
4404 pmt->psi->prg[pmt->psi->i_prg-1]->i_number =
4405 p_program->i_number;
4406 pmt->psi->prg[pmt->psi->i_prg-1]->i_pid_pmt =
4407 p_program->i_pid;
4408
4409 /* Now select PID at access level */
4410 if( p_sys->b_access_control )
4411 {
4412 if( ProgramIsSelected( p_demux, p_program->i_number ) )
4413 {
4414 if( p_sys->i_current_program == 0 )
4415 p_sys->i_current_program = p_program->i_number;
4416
4417 if( stream_Control( p_demux->s, STREAM_CONTROL_ACCESS,
4418 ACCESS_SET_PRIVATE_ID_STATE,
4419 p_program->i_pid, true ) )
4420 p_sys->b_access_control = false;
4421 }
4422 }
4423 }
4424 }
4425 }
4426 pat->psi->i_pat_version = p_pat->i_version;
4427
4428 dvbpsi_DeletePAT( p_pat );
4429 }
VLC Solaris and OpenSolaris fixes