git.sesse.net Git - vlc/blob - modules/demux/ts.c

   1 /*****************************************************************************
   2  * ts.c: Transport Stream input module for VLC.
   3  *****************************************************************************
   4  * Copyright (C) 2004-2005 VLC authors and VideoLAN
   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 it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  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 #include <time.h>
  38
  39 #include <vlc_access.h>    /* DVB-specific things */
  40 #include <vlc_demux.h>
  41 #include <vlc_meta.h>
  42 #include <vlc_epg.h>
  43 #include <vlc_charset.h>   /* FromCharset, for EIT */
  44 #include <vlc_bits.h>
  45
  46 #include "../mux/mpeg/csa.h"
  47
  48 /* Include dvbpsi headers */
  49 # include <dvbpsi/dvbpsi.h>
  50 # include <dvbpsi/demux.h>
  51 # include <dvbpsi/descriptor.h>
  52 # include <dvbpsi/pat.h>
  53 # include <dvbpsi/pmt.h>
  54 # include <dvbpsi/sdt.h>
  55 # include <dvbpsi/dr.h>
  56 # include <dvbpsi/psi.h>
  57
  58 /* EIT support */
  59 # include <dvbpsi/eit.h>
  60
  61 /* TDT support */
  62 # include <dvbpsi/tot.h>
  63
  64 #include "../mux/mpeg/dvbpsi_compat.h"
  65 #include "../mux/mpeg/streams.h"
  66 #include "../mux/mpeg/tsutil.h"
  67 #include "../mux/mpeg/tables.h"
  68
  69 #include "../codec/opus_header.h"
  70
  71 #include "opus.h"
  72
  73 #undef TS_DEBUG
  74 VLC_FORMAT(1, 2) static void ts_debug(const char *format, ...)
  75 {
  76 #ifdef TS_DEBUG
  77     va_list ap;
  78     va_start(ap, format);
  79     vfprintf(stderr, format, ap);
  80     va_end(ap);
  81 #else
  82     (void)format;
  83 #endif
  84 }
  85
  86 #ifdef HAVE_ARIBB24
  87  #include <aribb24/aribb24.h>
  88  #include <aribb24/decoder.h>
  89 #endif
  90
  91 typedef enum arib_modes_e
  92 {
  93     ARIBMODE_AUTO = -1,
  94     ARIBMODE_DISABLED = 0,
  95     ARIBMODE_ENABLED = 1
  96 } arib_modes_e;
  97
  98 /*****************************************************************************
  99  * Module descriptor
 100  *****************************************************************************/
 101 static int  Open  ( vlc_object_t * );
 102 static void Close ( vlc_object_t * );
 103
 104 /* TODO
 105  * - Rename "extra pmt" to "user pmt"
 106  * - Update extra pmt description
 107  *      pmt_pid[:pmt_number][=pid_description[,pid_description]]
 108  *      where pid_description could take 3 forms:
 109  *          1. pid:pcr (to force the pcr pid)
 110  *          2. pid:stream_type
 111  *          3. pid:type=fourcc where type=(video|audio|spu)
 112  */
 113 #define PMT_TEXT N_("Extra PMT")
 114 #define PMT_LONGTEXT N_( \
 115   "Allows a user to specify an extra pmt (pmt_pid=pid:stream_type[,...])." )
 116
 117 #define PID_TEXT N_("Set id of ES to PID")
 118 #define PID_LONGTEXT N_("Set the internal ID of each elementary stream" \
 119                        " handled by VLC to the same value as the PID in" \
 120                        " the TS stream, instead of 1, 2, 3, etc. Useful to" \
 121                        " do \'#duplicate{..., select=\"es=<pid>\"}\'.")
 122
 123 #define CSA_TEXT N_("CSA Key")
 124 #define CSA_LONGTEXT N_("CSA encryption key. This must be a " \
 125   "16 char string (8 hexadecimal bytes).")
 126
 127 #define CSA2_TEXT N_("Second CSA Key")
 128 #define CSA2_LONGTEXT N_("The even CSA encryption key. This must be a " \
 129   "16 char string (8 hexadecimal bytes).")
 130
 131
 132 #define CPKT_TEXT N_("Packet size in bytes to decrypt")
 133 #define CPKT_LONGTEXT N_("Specify the size of the TS packet to decrypt. " \
 134     "The decryption routines subtract the TS-header from the value before " \
 135     "decrypting. " )
 136
 137 #define SPLIT_ES_TEXT N_("Separate sub-streams")
 138 #define SPLIT_ES_LONGTEXT N_( \
 139     "Separate teletex/dvbs pages into independent ES. " \
 140     "It can be useful to turn off this option when using stream output." )
 141
 142 #define SEEK_PERCENT_TEXT N_("Seek based on percent not time")
 143 #define SEEK_PERCENT_LONGTEXT N_( \
 144     "Seek and position based on a percent byte position, not a PCR generated " \
 145     "time position. If seeking doesn't work property, turn on this option." )
 146
 147 #define PCR_TEXT N_("Trust in-stream PCR")
 148 #define PCR_LONGTEXT N_("Use the stream PCR as a reference.")
 149
 150 static const int const arib_mode_list[] =
 151   { ARIBMODE_AUTO, ARIBMODE_ENABLED, ARIBMODE_DISABLED };
 152 static const char *const arib_mode_list_text[] =
 153   { N_("Auto"), N_("Enabled"), N_("Disabled") };
 154
 155 #define SUPPORT_ARIB_TEXT N_("ARIB STD-B24 mode")
 156 #define SUPPORT_ARIB_LONGTEXT N_( \
 157     "Forces ARIB STD-B24 mode for decoding characters." \
 158     "This feature affects EPG information and subtitles." )
 159
 160 vlc_module_begin ()
 161     set_description( N_("MPEG Transport Stream demuxer") )
 162     set_shortname ( "MPEG-TS" )
 163     set_category( CAT_INPUT )
 164     set_subcategory( SUBCAT_INPUT_DEMUX )
 165
 166     add_string( "ts-extra-pmt", NULL, PMT_TEXT, PMT_LONGTEXT, true )
 167     add_bool( "ts-trust-pcr", true, PCR_TEXT, PCR_LONGTEXT, true )
 168         change_safe()
 169     add_bool( "ts-es-id-pid", true, PID_TEXT, PID_LONGTEXT, true )
 170         change_safe()
 171     add_obsolete_string( "ts-out" ) /* since 2.2.0 */
 172     add_obsolete_integer( "ts-out-mtu" ) /* since 2.2.0 */
 173     add_string( "ts-csa-ck", NULL, CSA_TEXT, CSA_LONGTEXT, true )
 174         change_safe()
 175     add_string( "ts-csa2-ck", NULL, CSA2_TEXT, CSA2_LONGTEXT, true )
 176         change_safe()
 177     add_integer( "ts-csa-pkt", 188, CPKT_TEXT, CPKT_LONGTEXT, true )
 178         change_safe()
 179
 180     add_bool( "ts-split-es", true, SPLIT_ES_TEXT, SPLIT_ES_LONGTEXT, false )
 181     add_bool( "ts-seek-percent", false, SEEK_PERCENT_TEXT, SEEK_PERCENT_LONGTEXT, true )
 182
 183     add_integer( "ts-arib", ARIBMODE_AUTO, SUPPORT_ARIB_TEXT, SUPPORT_ARIB_LONGTEXT, false )
 184         change_integer_list( arib_mode_list, arib_mode_list_text )
 185
 186     add_obsolete_bool( "ts-silent" );
 187
 188     set_capability( "demux", 10 )
 189     set_callbacks( Open, Close )
 190     add_shortcut( "ts" )
 191 vlc_module_end ()
 192
 193 /*****************************************************************************
 194  * Local prototypes
 195  *****************************************************************************/
 196 static const char *const ppsz_teletext_type[] = {
 197  "",
 198  N_("Teletext"),
 199  N_("Teletext subtitles"),
 200  N_("Teletext: additional information"),
 201  N_("Teletext: program schedule"),
 202  N_("Teletext subtitles: hearing impaired")
 203 };
 204
 205 typedef struct
 206 {
 207     uint8_t                 i_objectTypeIndication;
 208     uint8_t                 i_streamType;
 209
 210     int                     i_extra;
 211     uint8_t                 *p_extra;
 212
 213 } decoder_config_descriptor_t;
 214
 215 typedef struct
 216 {
 217     bool                    b_ok;
 218     uint16_t                i_es_id;
 219
 220     char                    *psz_url;
 221
 222     decoder_config_descriptor_t    dec_descr;
 223
 224 } es_mpeg4_descriptor_t;
 225
 226 #define ES_DESCRIPTOR_COUNT 255
 227 typedef struct
 228 {
 229     /* IOD */
 230     char                    *psz_url;
 231
 232     es_mpeg4_descriptor_t   es_descr[ES_DESCRIPTOR_COUNT];
 233
 234 } iod_descriptor_t;
 235
 236 typedef struct
 237 {
 238     dvbpsi_handle   handle;
 239     int             i_version;
 240     int             i_number;
 241     int             i_pid_pcr;
 242     int             i_pid_pmt;
 243     mtime_t         i_pcr_value;
 244     /* IOD stuff (mpeg4) */
 245     iod_descriptor_t *iod;
 246
 247 } ts_prg_psi_t;
 248
 249 typedef struct
 250 {
 251     /* for special PAT/SDT case */
 252     dvbpsi_handle   handle; /* PAT/SDT/EIT */
 253     int             i_pat_version;
 254     int             i_sdt_version;
 255
 256     /* For PMT */
 257     int             i_prg;
 258     ts_prg_psi_t    **prg;
 259
 260 } ts_psi_t;
 261
 262 typedef enum
 263 {
 264     TS_ES_DATA_PES,
 265     TS_ES_DATA_TABLE_SECTION
 266 } ts_es_data_type_t;
 267
 268 typedef enum
 269 {
 270     TS_PMT_REGISTRATION_NONE = 0,
 271     TS_PMT_REGISTRATION_HDMV
 272 } ts_pmt_registration_type_t;
 273
 274 typedef struct
 275 {
 276     es_format_t  fmt;
 277     es_out_id_t *id;
 278     ts_es_data_type_t data_type;
 279     int         i_data_size;
 280     int         i_data_gathered;
 281     block_t     *p_data;
 282     block_t     **pp_last;
 283
 284     es_mpeg4_descriptor_t *p_mpeg4desc;
 285
 286 } ts_es_t;
 287
 288 typedef struct
 289 {
 290     int         i_pid;
 291
 292     bool        b_seen;
 293     bool        b_valid;
 294     int         i_cc;   /* countinuity counter */
 295     bool        b_scrambled;
 296
 297     /* PSI owner (ie PMT -> PAT, ES -> PMT */
 298     ts_psi_t   *p_owner;
 299     int         i_owner_number;
 300
 301     /* */
 302     ts_psi_t    *psi;
 303     ts_es_t     *es;
 304
 305     /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
 306     ts_es_t     **extra_es;
 307     int         i_extra_es;
 308
 309     struct
 310     {
 311         vlc_fourcc_t i_fourcc;
 312         int i_type;
 313         bool b_haspcr;
 314     } probed;
 315 } ts_pid_t;
 316
 317 typedef struct
 318 {
 319     int i_service;
 320 } vdr_info_t;
 321
 322 #define MIN_ES_PID 4    /* Should be 32.. broken muxers */
 323 #define MAX_ES_PID 8190
 324
 325 struct demux_sys_t
 326 {
 327     stream_t   *stream;
 328     bool        b_canseek;
 329     vlc_mutex_t     csa_lock;
 330
 331     /* TS packet size (188, 192, 204) */
 332     int         i_packet_size;
 333
 334     /* Additional TS packet header size (BluRay TS packets have 4-byte header before sync byte) */
 335     int         i_packet_header_size;
 336
 337     /* how many TS packet we read at once */
 338     int         i_ts_read;
 339
 340     /* to determine length and time */
 341     int         i_pid_ref_pcr;
 342     mtime_t     i_first_pcr;
 343     mtime_t     i_current_pcr;
 344     mtime_t     i_last_pcr;
 345     bool        b_force_seek_per_percent;
 346     int         i_pcrs_num;
 347     mtime_t     *p_pcrs;
 348     int64_t     *p_pos;
 349
 350     struct
 351     {
 352         arib_modes_e e_mode;
 353 #ifdef HAVE_ARIBB24
 354         arib_instance_t *p_instance;
 355 #endif
 356         stream_t     *b25stream;
 357     } arib;
 358
 359     /* All pid */
 360     ts_pid_t    pid[8192];
 361
 362     /* All PMT */
 363     bool        b_user_pmt;
 364     int         i_pmt;
 365     ts_pid_t    **pmt;
 366     int         i_pmt_es;
 367     bool        b_delay_es_creation;
 368
 369     /* */
 370     bool        b_es_id_pid;
 371     csa_t       *csa;
 372     int         i_csa_pkt_size;
 373     bool        b_split_es;
 374
 375     bool        b_trust_pcr;
 376     bool        b_disable_pcr;
 377
 378     /* */
 379     bool        b_access_control;
 380
 381     /* */
 382     bool        b_dvb_meta;
 383     int64_t     i_tdt_delta;
 384     int64_t     i_dvb_start;
 385     int64_t     i_dvb_length;
 386     bool        b_broken_charset; /* True if broken encoding is used in EPG/SDT */
 387
 388     /* */
 389     int         i_current_program;
 390     vlc_list_t  programs_list;
 391
 392     struct
 393     {
 394         /* broken PCR handling */
 395         bool        b_program_pcr_seen;
 396         mtime_t     i_first_dts;
 397     } pcrfix;
 398
 399     struct
 400     {
 401         mtime_t i_first_dts;     /* first dts encountered for the stream */
 402         int     i_timesourcepid; /* which pid we saved the dts from */
 403         bool    b_pat_deadline;  /* set if we haven't seen PAT within 140ms */
 404     } patfix;
 405
 406     vdr_info_t  vdr;
 407
 408     /* */
 409     bool        b_start_record;
 410 };
 411
 412 static int Demux    ( demux_t *p_demux );
 413 static int Control( demux_t *p_demux, int i_query, va_list args );
 414
 415 static void PIDInit ( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner );
 416 static void PIDClean( demux_t *, ts_pid_t *pid );
 417 static void PIDFillFormat( es_format_t *fmt, int i_stream_type );
 418
 419 static void PATCallBack( void*, dvbpsi_pat_t * );
 420 static void PMTCallBack( void *data, dvbpsi_pmt_t *p_pmt );
 421 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
 422 static void PSINewTableCallBack( dvbpsi_t *handle, uint8_t  i_table_id,
 423                                  uint16_t i_extension, demux_t * );
 424 #else
 425 static void PSINewTableCallBack( demux_t *, dvbpsi_handle,
 426                                  uint8_t  i_table_id, uint16_t i_extension );
 427 #endif
 428
 429 static int ChangeKeyCallback( vlc_object_t *, char const *, vlc_value_t, vlc_value_t, void * );
 430
 431 static inline int PIDGet( block_t *p )
 432 {
 433     return ( (p->p_buffer[1]&0x1f)<<8 )|p->p_buffer[2];
 434 }
 435
 436 static bool GatherData( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
 437 static void AddAndCreateES( demux_t *p_demux, ts_pid_t *pid );
 438
 439 static block_t* ReadTSPacket( demux_t *p_demux );
 440 static int Seek( demux_t *p_demux, double f_percent );
 441 static void GetFirstPCR( demux_t *p_demux );
 442 static void GetLastPCR( demux_t *p_demux );
 443 static void CheckPCR( demux_t *p_demux );
 444 static void PCRHandle( demux_t *p_demux, ts_pid_t *, block_t * );
 445 static void PCRFixHandle( demux_t *, block_t * );
 446 static mtime_t AdjustPTSWrapAround( demux_t *, mtime_t );
 447
 448 static void              IODFree( iod_descriptor_t * );
 449
 450 #define TS_USER_PMT_NUMBER (0)
 451 static int UserPmt( demux_t *p_demux, const char * );
 452
 453 static int  SetPIDFilter( demux_t *, int i_pid, bool b_selected );
 454 static void SetPrgFilter( demux_t *, int i_prg, bool b_selected );
 455
 456 #define TS_PACKET_SIZE_188 188
 457 #define TS_PACKET_SIZE_192 192
 458 #define TS_PACKET_SIZE_204 204
 459 #define TS_PACKET_SIZE_MAX 204
 460
 461 static int DetectPacketSize( demux_t *p_demux, int *pi_header_size, int i_offset )
 462 {
 463     const uint8_t *p_peek;
 464
 465     if( stream_Peek( p_demux->s,
 466                      &p_peek, i_offset + TS_PACKET_SIZE_MAX ) < i_offset + TS_PACKET_SIZE_MAX )
 467         return -1;
 468
 469     for( int i_sync = 0; i_sync < TS_PACKET_SIZE_MAX; i_sync++ )
 470     {
 471         if( p_peek[i_offset + i_sync] != 0x47 )
 472             continue;
 473
 474         /* Check next 3 sync bytes */
 475         int i_peek = i_offset + TS_PACKET_SIZE_MAX * 3 + i_sync + 1;
 476         if( ( stream_Peek( p_demux->s, &p_peek, i_peek ) ) < i_peek )
 477         {
 478             msg_Err( p_demux, "cannot peek" );
 479             return -1;
 480         }
 481         if( p_peek[i_offset + i_sync + 1 * TS_PACKET_SIZE_188] == 0x47 &&
 482             p_peek[i_offset + i_sync + 2 * TS_PACKET_SIZE_188] == 0x47 &&
 483             p_peek[i_offset + i_sync + 3 * TS_PACKET_SIZE_188] == 0x47 )
 484         {
 485             return TS_PACKET_SIZE_188;
 486         }
 487         else if( p_peek[i_offset + i_sync + 1 * TS_PACKET_SIZE_192] == 0x47 &&
 488                  p_peek[i_offset + i_sync + 2 * TS_PACKET_SIZE_192] == 0x47 &&
 489                  p_peek[i_offset + i_sync + 3 * TS_PACKET_SIZE_192] == 0x47 )
 490         {
 491             if( i_sync == 4 )
 492             {
 493                 *pi_header_size = 4; /* BluRay TS packets have 4-byte header */
 494             }
 495             return TS_PACKET_SIZE_192;
 496         }
 497         else if( p_peek[i_offset + i_sync + 1 * TS_PACKET_SIZE_204] == 0x47 &&
 498                  p_peek[i_offset + i_sync + 2 * TS_PACKET_SIZE_204] == 0x47 &&
 499                  p_peek[i_offset + i_sync + 3 * TS_PACKET_SIZE_204] == 0x47 )
 500         {
 501             return TS_PACKET_SIZE_204;
 502         }
 503     }
 504
 505     if( p_demux->b_force )
 506     {
 507         msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
 508         return TS_PACKET_SIZE_188;
 509     }
 510     msg_Dbg( p_demux, "TS module discarded (lost sync)" );
 511     return -1;
 512 }
 513
 514 #define TOPFIELD_HEADER_SIZE 3712
 515
 516 static int DetectPVRHeadersAndHeaderSize( demux_t *p_demux, int *pi_header_size, vdr_info_t *p_vdr )
 517 {
 518     const uint8_t *p_peek;
 519     *pi_header_size = 0;
 520     int i_packet_size = -1;
 521
 522     if( stream_Peek( p_demux->s,
 523                      &p_peek, TS_PACKET_SIZE_MAX ) < TS_PACKET_SIZE_MAX )
 524         return -1;
 525
 526     if( memcmp( p_peek, "TFrc", 4 ) == 0 &&
 527         p_peek[6] == 0 && memcmp( &p_peek[53], "\x80\x00\x00", 4 ) == 0 &&
 528         stream_Peek( p_demux->s, &p_peek, TOPFIELD_HEADER_SIZE + TS_PACKET_SIZE_MAX )
 529             == TOPFIELD_HEADER_SIZE + TS_PACKET_SIZE_MAX )
 530     {
 531         i_packet_size = DetectPacketSize( p_demux, pi_header_size, TOPFIELD_HEADER_SIZE );
 532         if( i_packet_size != -1 )
 533         {
 534             msg_Dbg( p_demux, "this is a topfield file" );
 535 #if 0
 536             /* I used the TF5000PVR 2004 Firmware .doc header documentation,
 537              * http://www.i-topfield.com/data/product/firmware/Structure%20of%20Recorded%20File%20in%20TF5000PVR%20(Feb%2021%202004).doc
 538              * but after the filename the offsets seem to be incorrect.  - DJ */
 539             int i_duration, i_name;
 540             char *psz_name = xmalloc(25);
 541             char *psz_event_name;
 542             char *psz_event_text = xmalloc(130);
 543             char *psz_ext_text = xmalloc(1025);
 544
 545             // 2 bytes version Uimsbf (4,5)
 546             // 2 bytes reserved (6,7)
 547             // 2 bytes duration in minutes Uimsbf (8,9(
 548             i_duration = (int) (p_peek[8] << 8) | p_peek[9];
 549             msg_Dbg( p_demux, "Topfield recording length: +/- %d minutes", i_duration);
 550             // 2 bytes service number in channel list (10, 11)
 551             // 2 bytes service type Bslbf 0=TV 1=Radio Bslb (12, 13)
 552             // 4 bytes of reserved + tuner info (14,15,16,17)
 553             // 2 bytes of Service ID  Bslbf (18,19)
 554             // 2 bytes of PMT PID  Uimsbf (20,21)
 555             // 2 bytes of PCR PID  Uimsbf (22,23)
 556             // 2 bytes of Video PID  Uimsbf (24,25)
 557             // 2 bytes of Audio PID  Uimsbf (26,27)
 558             // 24 bytes filename Bslbf
 559             memcpy( psz_name, &p_peek[28], 24 );
 560             psz_name[24] = '\0';
 561             msg_Dbg( p_demux, "recordingname=%s", psz_name );
 562             // 1 byte of sat index Uimsbf  (52)
 563             // 3 bytes (1 bit of polarity Bslbf +23 bits reserved)
 564             // 4 bytes of freq. Uimsbf (56,57,58,59)
 565             // 2 bytes of symbol rate Uimsbf (60,61)
 566             // 2 bytes of TS stream ID Uimsbf (62,63)
 567             // 4 bytes reserved
 568             // 2 bytes reserved
 569             // 2 bytes duration Uimsbf (70,71)
 570             //i_duration = (int) (p_peek[70] << 8) | p_peek[71];
 571             //msg_Dbg( p_demux, "Topfield 2nd duration field: +/- %d minutes", i_duration);
 572             // 4 bytes EventID Uimsbf (72-75)
 573             // 8 bytes of Start and End time info (76-83)
 574             // 1 byte reserved (84)
 575             // 1 byte event name length Uimsbf (89)
 576             i_name = (int)(p_peek[89]&~0x81);
 577             msg_Dbg( p_demux, "event name length = %d", i_name);
 578             psz_event_name = xmalloc( i_name+1 );
 579             // 1 byte parental rating (90)
 580             // 129 bytes of event text
 581             memcpy( psz_event_name, &p_peek[91], i_name );
 582             psz_event_name[i_name] = '\0';
 583             memcpy( psz_event_text, &p_peek[91+i_name], 129-i_name );
 584             psz_event_text[129-i_name] = '\0';
 585             msg_Dbg( p_demux, "event name=%s", psz_event_name );
 586             msg_Dbg( p_demux, "event text=%s", psz_event_text );
 587             // 12 bytes reserved (220)
 588             // 6 bytes reserved
 589             // 2 bytes Event Text Length Uimsbf
 590             // 4 bytes EventID Uimsbf
 591             // FIXME We just have 613 bytes. not enough for this entire text
 592             // 1024 bytes Extended Event Text Bslbf
 593             memcpy( psz_ext_text, p_peek+372, 1024 );
 594             psz_ext_text[1024] = '\0';
 595             msg_Dbg( p_demux, "extended event text=%s", psz_ext_text );
 596             // 52 bytes reserved Bslbf
 597 #endif
 598             p_vdr->i_service = GetWBE(&p_peek[18]);
 599
 600             return i_packet_size;
 601             //return TS_PACKET_SIZE_188;
 602         }
 603     }
 604
 605     return DetectPacketSize( p_demux, pi_header_size, 0 );
 606 }
 607
 608 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
 609 static void vlc_dvbpsi_reset( demux_t *p_demux )
 610 {
 611     demux_sys_t *p_sys = p_demux->p_sys;
 612
 613     ts_pid_t *pat = &p_sys->pid[0];
 614     ts_pid_t *sdt = &p_sys->pid[0x11];
 615     ts_pid_t *eit = &p_sys->pid[0x12];
 616     ts_pid_t *tdt = &p_sys->pid[0x14];
 617
 618     if( pat->psi->handle )
 619     {
 620         if( dvbpsi_decoder_present( pat->psi->handle ) )
 621             dvbpsi_pat_detach( pat->psi->handle );
 622         dvbpsi_delete( pat->psi->handle );
 623         pat->psi->handle = NULL;
 624     }
 625
 626     if( sdt->psi->handle )
 627     {
 628         if( dvbpsi_decoder_present( sdt->psi->handle ) )
 629             dvbpsi_DetachDemux( sdt->psi->handle );
 630         dvbpsi_delete( sdt->psi->handle );
 631         sdt->psi->handle = NULL;
 632     }
 633
 634     if( eit->psi->handle )
 635     {
 636         if( dvbpsi_decoder_present( eit->psi->handle ) )
 637             dvbpsi_DetachDemux( eit->psi->handle );
 638         dvbpsi_delete( eit->psi->handle );
 639         eit->psi->handle = NULL;
 640     }
 641
 642     if( tdt->psi->handle )
 643     {
 644         if( dvbpsi_decoder_present( tdt->psi->handle ) )
 645             dvbpsi_DetachDemux( tdt->psi->handle );
 646         dvbpsi_delete( tdt->psi->handle );
 647         tdt->psi->handle = NULL;
 648     }
 649 }
 650 #endif
 651
 652 static inline mtime_t ExtractPESTimestamp( const uint8_t *p_data )
 653 {
 654     return ((mtime_t)(p_data[ 0]&0x0e ) << 29)|
 655              (mtime_t)(p_data[1] << 22)|
 656             ((mtime_t)(p_data[2]&0xfe) << 14)|
 657              (mtime_t)(p_data[3] << 7)|
 658              (mtime_t)(p_data[4] >> 1);
 659 }
 660
 661 static void ProbePES( demux_t *p_demux, ts_pid_t *pid, const uint8_t *p_pesstart, bool b_adaptfield )
 662 {
 663     demux_sys_t *p_sys = p_demux->p_sys;
 664     const uint8_t *p_pes = p_pesstart;
 665     pid->probed.i_type = -1;
 666
 667     if( b_adaptfield )
 668     {
 669         uint8_t len = *p_pes;
 670         p_pes++;
 671
 672         if(len == 0)
 673         {
 674             p_pes++; /* stuffing */
 675         }
 676         else
 677         {
 678             pid->probed.b_haspcr = ( *p_pes >= 7 && (p_pes[1] & 0x10) );
 679             p_pes += len;
 680         }
 681     }
 682
 683     if( p_pes - p_pesstart >= TS_PACKET_SIZE_188 - 9)
 684         return;
 685
 686     if( p_pes[0] != 0 || p_pes[1] != 0 || p_pes[2] != 1 )
 687         return;
 688
 689     size_t i_pesextoffset = 8;
 690     mtime_t i_dts = -1;
 691     if( p_pes[7] & 0x80 ) // PTS
 692     {
 693         i_pesextoffset += 5;
 694         i_dts = ExtractPESTimestamp( &p_pes[9] );
 695     }
 696     if( p_pes[7] & 0x40 ) // DTS
 697     {
 698         i_pesextoffset += 5;
 699         i_dts = ExtractPESTimestamp( &p_pes[14] );
 700     }
 701     if( p_pes[7] & 0x20 ) // ESCR
 702         i_pesextoffset += 6;
 703     if( p_pes[7] & 0x10 ) // ESrate
 704         i_pesextoffset += 3;
 705     if( p_pes[7] & 0x08 ) // DSM
 706         i_pesextoffset += 1;
 707     if( p_pes[7] & 0x04 ) // CopyInfo
 708         i_pesextoffset += 1;
 709     if( p_pes[7] & 0x02 ) // PESCRC
 710         i_pesextoffset += 2;
 711
 712      /* HeaderdataLength */
 713     const size_t i_payloadoffset = 8 + 1 + p_pes[8];
 714     i_pesextoffset += 1;
 715
 716     if( p_pes[7] & 0x01 ) // PESExt
 717     {
 718         size_t i_extension2_offset = 1;
 719         if ( p_pes[i_pesextoffset] & 0x80 ) // private data
 720             i_extension2_offset += 16;
 721         if ( p_pes[i_pesextoffset] & 0x40 ) // pack
 722             i_extension2_offset += 1;
 723         if ( p_pes[i_pesextoffset] & 0x20 ) // seq
 724             i_extension2_offset += 2;
 725         if ( p_pes[i_pesextoffset] & 0x10 ) // P-STD
 726             i_extension2_offset += 2;
 727         if ( p_pes[i_pesextoffset] & 0x01 ) // Extension 2
 728         {
 729             uint8_t i_len = p_pes[i_pesextoffset + i_extension2_offset] & 0x7F;
 730             i_extension2_offset += i_len;
 731         }
 732     }
 733     /* (i_payloadoffset - i_pesextoffset) 0xFF stuffing */
 734
 735     if( &p_pes[i_payloadoffset] - p_pesstart >= TS_PACKET_SIZE_188 - 4)
 736         return;
 737
 738     const uint8_t *p_data = &p_pes[i_payloadoffset];
 739     /* AUDIO STREAM */
 740     if(p_pes[3] >= 0xC0 && p_pes[3] <= 0xDF)
 741     {
 742         if( !memcmp( p_data, "\x7F\xFE\x80\x01", 4 ) )
 743         {
 744             pid->probed.i_type = 0x06;
 745             pid->probed.i_fourcc = VLC_CODEC_DTS;
 746         }
 747         else if( !memcmp( p_data, "\x0B\x77", 2 ) )
 748         {
 749             pid->probed.i_type = 0x06;
 750             pid->probed.i_fourcc = VLC_CODEC_EAC3;
 751         }
 752         else if( p_data[0] == 0xFF && (p_data[1] & 0xE0) == 0xE0 )
 753         {
 754             switch(p_data[1] & 18)
 755             {
 756             /* 10 - MPEG Version 2 (ISO/IEC 13818-3)
 757                11 - MPEG Version 1 (ISO/IEC 11172-3) */
 758                 case 0x10:
 759                     pid->probed.i_type = 0x04;
 760                     break;
 761                 case 0x18:
 762                     pid->probed.i_type = 0x03;
 763                 default:
 764                     break;
 765             }
 766
 767             switch(p_data[1] & 6)
 768             {
 769             /* 01 - Layer III
 770                10 - Layer II
 771                11 - Layer I */
 772                 case 0x06:
 773                     pid->probed.i_type = 0x04;
 774                     pid->probed.i_fourcc = VLC_CODEC_MPGA;
 775                     break;
 776                 case 0x04:
 777                     pid->probed.i_type = 0x04;
 778                     pid->probed.i_fourcc = VLC_CODEC_MP2;
 779                     break;
 780                 case 0x02:
 781                     pid->probed.i_type = 0x04;
 782                     pid->probed.i_fourcc = VLC_CODEC_MP3;
 783                 default:
 784                     break;
 785             }
 786         }
 787     }
 788     /* VIDEO STREAM */
 789     else if( p_pes[3] >= 0xE0 && p_pes[3] <= 0xEF )
 790     {
 791         if( !memcmp( p_data, "\x00\x00\x00", 4 ) )
 792         {
 793             pid->probed.i_type = 0x1b;
 794             pid->probed.i_fourcc = VLC_CODEC_H264;
 795         }
 796         else if( !memcmp( p_data, "\x00\x00\x01", 4 ) )
 797         {
 798             pid->probed.i_type = 0x02;
 799             pid->probed.i_fourcc = VLC_CODEC_MPGV;
 800         }
 801     }
 802
 803     /* Track timestamps and flag missing PAT */
 804     if( !p_sys->patfix.i_timesourcepid && i_dts > -1 )
 805     {
 806         p_sys->patfix.i_first_dts = i_dts;
 807         p_sys->patfix.i_timesourcepid = pid->i_pid;
 808     }
 809     else if( p_sys->patfix.i_timesourcepid == pid->i_pid && i_dts > -1 &&
 810              !p_sys->patfix.b_pat_deadline )
 811     {
 812         if( i_dts - p_sys->patfix.i_first_dts > 9 * 140000 / 100 )
 813             p_sys->patfix.b_pat_deadline = true;
 814     }
 815
 816 }
 817
 818 static void BuildPATCallback( void *p_opaque, block_t *p_block )
 819 {
 820     ts_pid_t *pat_pid = (ts_pid_t *) p_opaque;
 821     dvbpsi_PushPacket( pat_pid->psi->handle, p_block->p_buffer );
 822 }
 823
 824 static void BuildPMTCallback( void *p_opaque, block_t *p_block )
 825 {
 826     ts_pid_t *program_pid = (ts_pid_t *) p_opaque;
 827     while( p_block )
 828     {
 829         for( int i_prg = 0; i_prg < program_pid->psi->i_prg; i_prg++ )
 830         {
 831             dvbpsi_PushPacket( program_pid->psi->prg[i_prg]->handle,
 832                                p_block->p_buffer );
 833         }
 834         p_block = p_block->p_next;
 835     }
 836 }
 837
 838 static void MissingPATPMTFixup( demux_t *p_demux )
 839 {
 840     demux_sys_t *p_sys = p_demux->p_sys;
 841     int i_program_number = 1234;
 842     int i_program_pid = 1337;
 843     int i_pcr_pid = 0x1FFF;
 844     int i_num_pes = 0;
 845
 846     if( p_sys->pid[i_program_pid].b_seen )
 847     {
 848         /* Find a free one */
 849         for( i_program_pid = MIN_ES_PID;
 850              i_program_pid < MAX_ES_PID && p_sys->pid[i_program_pid].b_seen;
 851              i_program_pid++ );
 852     }
 853
 854     for( int i = MIN_ES_PID; i < MAX_ES_PID; i++ )
 855     {
 856         if( !p_sys->pid[i].b_seen ||
 857             !p_sys->pid[i].probed.i_type )
 858             continue;
 859
 860         if( i_pcr_pid == 0x1FFF && ( p_sys->pid[i].probed.i_type == 0x03 ||
 861                                      p_sys->pid[i].probed.b_haspcr ) )
 862             i_pcr_pid = p_sys->pid[i].i_pid;
 863
 864         i_num_pes++;
 865     }
 866
 867     if( i_num_pes == 0 )
 868         return;
 869
 870     ts_stream_t patstream =
 871     {
 872         .i_pid = 0,
 873         .i_continuity_counter = 0x10,
 874         .b_discontinuity = false
 875     };
 876
 877     ts_stream_t pmtprogramstream =
 878     {
 879         .i_pid = i_program_pid,
 880         .i_continuity_counter = 0x0,
 881         .b_discontinuity = false
 882     };
 883
 884     BuildPAT( DVBPSI_HANDLE_PARAM(p_sys->pid[0].psi->handle)
 885             &p_sys->pid[0], BuildPATCallback,
 886             0, 1,
 887             &patstream,
 888             1, &pmtprogramstream, &i_program_number );
 889
 890     if( !p_sys->pid[i_program_pid].psi )
 891     {
 892         msg_Err( p_demux, "PAT creation failed" );
 893         return;
 894     }
 895
 896     struct esstreams_t
 897     {
 898         pes_stream_t pes;
 899         ts_stream_t ts;
 900     };
 901     es_format_t esfmt = {0};
 902     struct esstreams_t *esstreams = calloc( i_num_pes, sizeof(struct esstreams_t) );
 903     pes_mapped_stream_t *mapped = calloc( i_num_pes, sizeof(pes_mapped_stream_t) );
 904     if( esstreams && mapped )
 905     {
 906         int j=0;
 907         for( int i = MIN_ES_PID; i < MAX_ES_PID; i++ )
 908         {
 909             if( !p_sys->pid[i].b_seen ||
 910                 !p_sys->pid[i].probed.i_type )
 911                 continue;
 912
 913             esstreams[j].pes.i_stream_type = p_sys->pid[i].probed.i_type;
 914             esstreams[j].pes.i_stream_type = p_sys->pid[i].probed.i_type;
 915             esstreams[j].ts.i_pid = p_sys->pid[i].i_pid;
 916             mapped[j].pes = &esstreams[j].pes;
 917             mapped[j].ts = &esstreams[j].ts;
 918             mapped[j].fmt = &esfmt;
 919             j++;
 920         }
 921
 922         BuildPMT( DVBPSI_HANDLE_PARAM(p_sys->pid[0].psi->handle) VLC_OBJECT(p_demux),
 923                 &p_sys->pid[i_program_pid], BuildPMTCallback,
 924                 0, 1,
 925                 i_pcr_pid,
 926                 NULL,
 927                 1, &pmtprogramstream, &i_program_number,
 928                 i_num_pes, mapped );
 929     }
 930     free(esstreams);
 931     free(mapped);
 932 }
 933
 934 /*****************************************************************************
 935  * Open
 936  *****************************************************************************/
 937 static int Open( vlc_object_t *p_this )
 938 {
 939     demux_t     *p_demux = (demux_t*)p_this;
 940     demux_sys_t *p_sys;
 941
 942     int          i_packet_size, i_packet_header_size = 0;
 943
 944     ts_pid_t    *pat;
 945     vdr_info_t   vdr = {0};
 946
 947     /* Search first sync byte */
 948     i_packet_size = DetectPVRHeadersAndHeaderSize( p_demux, &i_packet_header_size, &vdr );
 949     if( i_packet_size < 0 )
 950         return VLC_EGENERIC;
 951
 952     p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
 953     if( !p_sys )
 954         return VLC_ENOMEM;
 955     memset( p_sys, 0, sizeof( demux_sys_t ) );
 956     vlc_mutex_init( &p_sys->csa_lock );
 957
 958     p_demux->pf_demux = Demux;
 959     p_demux->pf_control = Control;
 960
 961     /* Init p_sys field */
 962     p_sys->b_dvb_meta = true;
 963     p_sys->b_access_control = true;
 964     p_sys->i_current_program = 0;
 965     p_sys->programs_list.i_count = 0;
 966     p_sys->programs_list.p_values = NULL;
 967     p_sys->i_tdt_delta = 0;
 968     p_sys->i_dvb_start = 0;
 969     p_sys->i_dvb_length = 0;
 970
 971     p_sys->vdr = vdr;
 972
 973     p_sys->arib.b25stream = NULL;
 974     p_sys->stream = p_demux->s;
 975
 976     p_sys->b_broken_charset = false;
 977
 978     for( int i = 0; i < 8192; i++ )
 979     {
 980         ts_pid_t *pid = &p_sys->pid[i];
 981         pid->i_pid      = i;
 982         pid->b_seen     = false;
 983         pid->b_valid    = false;
 984         pid->probed.i_fourcc = 0;
 985         pid->probed.i_type = 0;
 986     }
 987     /* PID 8191 is padding */
 988     p_sys->pid[8191].b_seen = true;
 989     p_sys->i_packet_size = i_packet_size;
 990     p_sys->i_packet_header_size = i_packet_header_size;
 991     p_sys->i_ts_read = 50;
 992     p_sys->csa = NULL;
 993     p_sys->b_start_record = false;
 994
 995 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
 996 # define VLC_DVBPSI_DEMUX_TABLE_INIT(table,obj) \
 997     do { \
 998         (table)->psi->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG ); \
 999         if( ! (table)->psi->handle ) \
1000         { \
1001             vlc_mutex_destroy( &p_sys->csa_lock ); \
1002             free( p_sys ); \
1003             return VLC_ENOMEM; \
1004         } \
1005         (table)->psi->handle->p_sys = (void *) VLC_OBJECT(obj); \
1006         if( !dvbpsi_AttachDemux( (table)->psi->handle, (dvbpsi_demux_new_cb_t)PSINewTableCallBack, (obj) ) ) \
1007         { \
1008             vlc_dvbpsi_reset( obj ); \
1009             vlc_mutex_destroy( &p_sys->csa_lock ); \
1010             free( p_sys ); \
1011             return VLC_EGENERIC; \
1012         } \
1013     } while (0);
1014 #endif
1015
1016     /* Init PAT handler */
1017     pat = &p_sys->pid[0];
1018     PIDInit( pat, true, NULL );
1019 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1020     pat->psi->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG );
1021     if( !pat->psi->handle )
1022     {
1023         vlc_mutex_destroy( &p_sys->csa_lock );
1024         free( p_sys );
1025         return VLC_ENOMEM;
1026     }
1027     pat->psi->handle->p_sys = (void *) p_demux;
1028     if( !dvbpsi_pat_attach( pat->psi->handle, PATCallBack, p_demux ) )
1029     {
1030         vlc_dvbpsi_reset( p_demux );
1031         vlc_mutex_destroy( &p_sys->csa_lock );
1032         free( p_sys );
1033         return VLC_EGENERIC;
1034     }
1035 #else
1036     pat->psi->handle = dvbpsi_AttachPAT( PATCallBack, p_demux );
1037 #endif
1038     if( p_sys->b_dvb_meta )
1039     {
1040         ts_pid_t *sdt = &p_sys->pid[0x11];
1041         ts_pid_t *eit = &p_sys->pid[0x12];
1042
1043         PIDInit( sdt, true, NULL );
1044 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1045         VLC_DVBPSI_DEMUX_TABLE_INIT( sdt, p_demux )
1046 #else
1047         sdt->psi->handle =
1048             dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
1049                                 p_demux );
1050 #endif
1051         PIDInit( eit, true, NULL );
1052 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1053         VLC_DVBPSI_DEMUX_TABLE_INIT( eit, p_demux )
1054 #else
1055         eit->psi->handle =
1056             dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
1057                                 p_demux );
1058 #endif
1059         ts_pid_t *tdt = &p_sys->pid[0x14];
1060         PIDInit( tdt, true, NULL );
1061 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1062         VLC_DVBPSI_DEMUX_TABLE_INIT( tdt, p_demux )
1063 #else
1064         tdt->psi->handle =
1065             dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack,
1066                                 p_demux );
1067 #endif
1068
1069         if( p_sys->b_access_control )
1070         {
1071             if( SetPIDFilter( p_demux, 0x11, true ) ||
1072                 SetPIDFilter( p_demux, 0x14, true ) ||
1073                 SetPIDFilter( p_demux, 0x12, true ) )
1074                 p_sys->b_access_control = false;
1075         }
1076     }
1077
1078 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1079 # undef VLC_DVBPSI_DEMUX_TABLE_INIT
1080 #endif
1081
1082     /* Init PMT array */
1083     TAB_INIT( p_sys->i_pmt, p_sys->pmt );
1084     p_sys->i_pmt_es = 0;
1085     p_sys->b_delay_es_creation = true;
1086
1087     /* Read config */
1088     p_sys->b_es_id_pid = var_CreateGetBool( p_demux, "ts-es-id-pid" );
1089
1090     p_sys->b_trust_pcr = var_CreateGetBool( p_demux, "ts-trust-pcr" );
1091
1092     /* We handle description of an extra PMT */
1093     char* psz_string = var_CreateGetString( p_demux, "ts-extra-pmt" );
1094     p_sys->b_user_pmt = false;
1095     if( psz_string && *psz_string )
1096         UserPmt( p_demux, psz_string );
1097     free( psz_string );
1098
1099     psz_string = var_CreateGetStringCommand( p_demux, "ts-csa-ck" );
1100     if( psz_string && *psz_string )
1101     {
1102         int i_res;
1103         char* psz_csa2;
1104
1105         p_sys->csa = csa_New();
1106
1107         psz_csa2 = var_CreateGetStringCommand( p_demux, "ts-csa2-ck" );
1108         i_res = csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, true );
1109         if( i_res == VLC_SUCCESS && psz_csa2 && *psz_csa2 )
1110         {
1111             if( csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_csa2, false ) != VLC_SUCCESS )
1112             {
1113                 csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, false );
1114             }
1115         }
1116         else if ( i_res == VLC_SUCCESS )
1117         {
1118             csa_SetCW( (vlc_object_t*)p_demux, p_sys->csa, psz_string, false );
1119         }
1120         else
1121         {
1122             csa_Delete( p_sys->csa );
1123             p_sys->csa = NULL;
1124         }
1125
1126         if( p_sys->csa )
1127         {
1128             var_AddCallback( p_demux, "ts-csa-ck", ChangeKeyCallback, (void *)1 );
1129             var_AddCallback( p_demux, "ts-csa2-ck", ChangeKeyCallback, NULL );
1130
1131             int i_pkt = var_CreateGetInteger( p_demux, "ts-csa-pkt" );
1132             if( i_pkt < 4 || i_pkt > 188 )
1133             {
1134                 msg_Err( p_demux, "wrong packet size %d specified.", i_pkt );
1135                 msg_Warn( p_demux, "using default packet size of 188 bytes" );
1136                 p_sys->i_csa_pkt_size = 188;
1137             }
1138             else
1139                 p_sys->i_csa_pkt_size = i_pkt;
1140             msg_Dbg( p_demux, "decrypting %d bytes of packet", p_sys->i_csa_pkt_size );
1141         }
1142         free( psz_csa2 );
1143     }
1144     free( psz_string );
1145
1146     p_sys->b_split_es = var_InheritBool( p_demux, "ts-split-es" );
1147
1148     p_sys->b_canseek = false;
1149     p_sys->i_pid_ref_pcr = -1;
1150     p_sys->i_first_pcr = -1;
1151     p_sys->i_current_pcr = -1;
1152     p_sys->i_last_pcr = -1;
1153     p_sys->b_force_seek_per_percent = var_InheritBool( p_demux, "ts-seek-percent" );
1154     p_sys->i_pcrs_num = 10;
1155     p_sys->p_pcrs = (mtime_t *)calloc( p_sys->i_pcrs_num, sizeof( mtime_t ) );
1156     p_sys->p_pos = (int64_t *)calloc( p_sys->i_pcrs_num, sizeof( int64_t ) );
1157
1158     p_sys->arib.e_mode = var_InheritInteger( p_demux, "ts-arib" );
1159
1160     if( !p_sys->p_pcrs || !p_sys->p_pos )
1161     {
1162         Close( p_this );
1163         return VLC_ENOMEM;
1164     }
1165
1166     bool b_can_fastseek = false;
1167     stream_Control( p_sys->stream, STREAM_CAN_SEEK, &p_sys->b_canseek );
1168     stream_Control( p_sys->stream, STREAM_CAN_FASTSEEK, &b_can_fastseek );
1169     if ( p_sys->b_canseek )
1170     {
1171         if( b_can_fastseek )
1172         {
1173             GetFirstPCR( p_demux );
1174             CheckPCR( p_demux );
1175             GetLastPCR( p_demux );
1176         }
1177
1178         if( p_sys->i_first_pcr < 0 || p_sys->i_last_pcr < 0 )
1179         {
1180             msg_Dbg( p_demux, "Force Seek Per Percent: PCR's not found,");
1181             p_sys->b_force_seek_per_percent = true;
1182         }
1183     }
1184
1185     while( p_sys->i_pmt_es <= 0
1186            && (!p_sys->pid[0].b_seen && !p_sys->patfix.b_pat_deadline) )
1187     {
1188         if( Demux( p_demux ) != 1 )
1189             break;
1190     }
1191
1192     /* If we had no PAT within 140ms, create PAT/PMT from probed streams */
1193     if( p_sys->i_pmt_es == 0 && !p_sys->pid[0].b_seen )
1194         MissingPATPMTFixup( p_demux );
1195
1196     while( p_sys->i_pmt_es <= 0 )
1197     {
1198         if( Demux( p_demux ) != 1 )
1199             break;
1200     }
1201     return VLC_SUCCESS;
1202 }
1203
1204 /*****************************************************************************
1205  * Close
1206  *****************************************************************************/
1207 static void Close( vlc_object_t *p_this )
1208 {
1209     demux_t     *p_demux = (demux_t*)p_this;
1210     demux_sys_t *p_sys = p_demux->p_sys;
1211
1212     msg_Dbg( p_demux, "pid list:" );
1213     for( int i = 0; i < 8192; i++ )
1214     {
1215         ts_pid_t *pid = &p_sys->pid[i];
1216
1217         if( pid->b_valid && pid->psi )
1218         {
1219             switch( pid->i_pid )
1220             {
1221             case 0: /* PAT */
1222 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1223                 if( dvbpsi_decoder_present( pid->psi->handle ) )
1224                     dvbpsi_pat_detach( pid->psi->handle );
1225                 dvbpsi_delete( pid->psi->handle );
1226                 pid->psi->handle = NULL;
1227 #else
1228                 dvbpsi_DetachPAT( pid->psi->handle );
1229 #endif
1230                 free( pid->psi );
1231                 break;
1232             case 1: /* CAT */
1233                 free( pid->psi );
1234                 break;
1235             default:
1236                 if( p_sys->b_dvb_meta && ( pid->i_pid == 0x11 || pid->i_pid == 0x12 || pid->i_pid == 0x14 ) )
1237                 {
1238                     /* SDT or EIT or TDT */
1239                     dvbpsi_DetachDemux( pid->psi->handle );
1240 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1241                     dvbpsi_delete( pid->psi->handle );
1242                     pid->psi->handle = NULL;
1243 #endif
1244                     free( pid->psi );
1245                 }
1246                 else
1247                 {
1248                     PIDClean( p_demux, pid );
1249                 }
1250                 break;
1251             }
1252         }
1253         else if( pid->b_valid && pid->es )
1254         {
1255             PIDClean( p_demux, pid );
1256         }
1257
1258         if( pid->b_seen )
1259         {
1260             msg_Dbg( p_demux, "  - pid[%d] seen", pid->i_pid );
1261         }
1262
1263         /* too much */
1264         if( pid->i_pid > 0 )
1265             SetPIDFilter( p_demux, pid->i_pid, false );
1266     }
1267
1268     vlc_mutex_lock( &p_sys->csa_lock );
1269     if( p_sys->csa )
1270     {
1271         var_DelCallback( p_demux, "ts-csa-ck", ChangeKeyCallback, NULL );
1272         var_DelCallback( p_demux, "ts-csa2-ck", ChangeKeyCallback, NULL );
1273         csa_Delete( p_sys->csa );
1274     }
1275     vlc_mutex_unlock( &p_sys->csa_lock );
1276
1277     TAB_CLEAN( p_sys->i_pmt, p_sys->pmt );
1278
1279     free( p_sys->programs_list.p_values );
1280
1281     free( p_sys->p_pcrs );
1282     free( p_sys->p_pos );
1283
1284 #ifdef HAVE_ARIBB24
1285     if ( p_sys->arib.p_instance )
1286         arib_instance_destroy( p_sys->arib.p_instance );
1287 #endif
1288
1289     if ( p_sys->arib.b25stream )
1290     {
1291         p_sys->arib.b25stream->p_source = NULL; /* don't chain kill demuxer's source */
1292         stream_Delete( p_sys->arib.b25stream );
1293     }
1294
1295     vlc_mutex_destroy( &p_sys->csa_lock );
1296     free( p_sys );
1297 }
1298
1299 /*****************************************************************************
1300  * ChangeKeyCallback: called when changing the odd encryption key on the fly.
1301  *****************************************************************************/
1302 static int ChangeKeyCallback( vlc_object_t *p_this, char const *psz_cmd,
1303                            vlc_value_t oldval, vlc_value_t newval,
1304                            void *p_data )
1305 {
1306     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
1307     demux_t     *p_demux = (demux_t*)p_this;
1308     demux_sys_t *p_sys = p_demux->p_sys;
1309     int         i_tmp = (intptr_t)p_data;
1310
1311     vlc_mutex_lock( &p_sys->csa_lock );
1312     if ( i_tmp )
1313         i_tmp = csa_SetCW( p_this, p_sys->csa, newval.psz_string, true );
1314     else
1315         i_tmp = csa_SetCW( p_this, p_sys->csa, newval.psz_string, false );
1316
1317     vlc_mutex_unlock( &p_sys->csa_lock );
1318     return i_tmp;
1319 }
1320
1321 /*****************************************************************************
1322  * Demux:
1323  *****************************************************************************/
1324 static int Demux( demux_t *p_demux )
1325 {
1326     demux_sys_t *p_sys = p_demux->p_sys;
1327     bool b_wait_es = p_sys->i_pmt_es <= 0;
1328
1329     /* We read at most 100 TS packet or until a frame is completed */
1330     for( int i_pkt = 0; i_pkt < p_sys->i_ts_read; i_pkt++ )
1331     {
1332         bool         b_frame = false;
1333         block_t     *p_pkt;
1334         if( !(p_pkt = ReadTSPacket( p_demux )) )
1335         {
1336             return 0;
1337         }
1338
1339         if( p_sys->b_start_record )
1340         {
1341             /* Enable recording once synchronized */
1342             stream_Control( p_sys->stream, STREAM_SET_RECORD_STATE, true, "ts" );
1343             p_sys->b_start_record = false;
1344         }
1345
1346         /* Parse the TS packet */
1347         ts_pid_t *p_pid = &p_sys->pid[PIDGet( p_pkt )];
1348
1349         /* Probe streams to build PAT/PMT after 140ms in case we don't see any PAT */
1350         if( !p_sys->pid[0].b_seen &&
1351             (p_pid->probed.i_type == 0 || p_pid->i_pid == p_sys->patfix.i_timesourcepid) &&
1352             (p_pkt->p_buffer[1] & 0xC0) == 0x40 && /* Payload start but not corrupt */
1353             (p_pkt->p_buffer[3] & 0xD0) == 0x10 )  /* Has payload but is not encrypted */
1354         {
1355             ProbePES( p_demux, p_pid, p_pkt->p_buffer + 4, p_pkt->p_buffer[3] & 0x20 /* Adaptation field */);
1356         }
1357
1358         if( p_pid->b_valid )
1359         {
1360             if( p_pid->psi )
1361             {
1362                 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 ) ) )
1363                 {
1364                     dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
1365                 }
1366                 else
1367                 {
1368                     for( int i_prg = 0; i_prg < p_pid->psi->i_prg; i_prg++ )
1369                     {
1370                         dvbpsi_PushPacket( p_pid->psi->prg[i_prg]->handle,
1371                                            p_pkt->p_buffer );
1372                     }
1373                 }
1374                 block_Release( p_pkt );
1375             }
1376             else
1377             {
1378                 if(p_sys->b_delay_es_creation) /* No longer delay ES since that pid's program sends data */
1379                     AddAndCreateES( p_demux, NULL );
1380                 b_frame = GatherData( p_demux, p_pid, p_pkt );
1381             }
1382         }
1383         else
1384         {
1385             if( !p_pid->b_seen )
1386             {
1387                 msg_Dbg( p_demux, "pid[%d] unknown", p_pid->i_pid );
1388             }
1389             /* We have to handle PCR if present */
1390             PCRHandle( p_demux, p_pid, p_pkt );
1391             block_Release( p_pkt );
1392         }
1393         p_pid->b_seen = true;
1394
1395         if( b_frame || ( b_wait_es && p_sys->i_pmt_es > 0 ) )
1396             break;
1397     }
1398
1399     demux_UpdateTitleFromStream( p_demux );
1400     return 1;
1401 }
1402
1403 /*****************************************************************************
1404  * Control:
1405  *****************************************************************************/
1406 static int DVBEventInformation( demux_t *p_demux, int64_t *pi_time, int64_t *pi_length )
1407 {
1408     demux_sys_t *p_sys = p_demux->p_sys;
1409     if( pi_length )
1410         *pi_length = 0;
1411     if( pi_time )
1412         *pi_time = 0;
1413
1414     if( p_sys->i_dvb_length > 0 )
1415     {
1416         const int64_t t = mdate() + p_sys->i_tdt_delta;
1417
1418         if( p_sys->i_dvb_start <= t && t < p_sys->i_dvb_start + p_sys->i_dvb_length )
1419         {
1420             if( pi_length )
1421                 *pi_length = p_sys->i_dvb_length;
1422             if( pi_time )
1423                 *pi_time   = t - p_sys->i_dvb_start;
1424             return VLC_SUCCESS;
1425         }
1426     }
1427     return VLC_EGENERIC;
1428 }
1429
1430 static int Control( demux_t *p_demux, int i_query, va_list args )
1431 {
1432     demux_sys_t *p_sys = p_demux->p_sys;
1433     double f, *pf;
1434     bool b_bool, *pb_bool;
1435     int64_t i64;
1436     int64_t *pi64;
1437     int i_int;
1438
1439     switch( i_query )
1440     {
1441     case DEMUX_GET_POSITION:
1442         pf = (double*) va_arg( args, double* );
1443
1444         if( p_sys->b_force_seek_per_percent ||
1445             (p_sys->b_dvb_meta && p_sys->b_access_control) ||
1446             p_sys->i_current_pcr - p_sys->i_first_pcr < 0 ||
1447             p_sys->i_last_pcr - p_sys->i_first_pcr <= 0 )
1448         {
1449             int64_t i_time, i_length;
1450             if( !DVBEventInformation( p_demux, &i_time, &i_length ) && i_length > 0 )
1451                 *pf = (double)i_time/(double)i_length;
1452             else if( (i64 = stream_Size( p_sys->stream) ) > 0 )
1453             {
1454                 int64_t offset = stream_Tell( p_sys->stream );
1455
1456                 *pf = (double)offset / (double)i64;
1457             }
1458             else
1459                 *pf = 0.0;
1460         }
1461         else
1462         {
1463             *pf = (double)(p_sys->i_current_pcr - p_sys->i_first_pcr) / (double)(p_sys->i_last_pcr - p_sys->i_first_pcr);
1464         }
1465         return VLC_SUCCESS;
1466
1467     case DEMUX_SET_POSITION:
1468         f = (double) va_arg( args, double );
1469
1470         if(!p_sys->b_canseek)
1471             return VLC_EGENERIC;
1472
1473         if( p_sys->b_force_seek_per_percent ||
1474             (p_sys->b_dvb_meta && p_sys->b_access_control) ||
1475             p_sys->i_last_pcr - p_sys->i_first_pcr <= 0 )
1476         {
1477             i64 = stream_Size( p_sys->stream );
1478             if( stream_Seek( p_sys->stream, (int64_t)(i64 * f) ) )
1479                 return VLC_EGENERIC;
1480         }
1481         else
1482         {
1483             if( Seek( p_demux, f ) )
1484             {
1485                 p_sys->b_force_seek_per_percent = true;
1486                 return VLC_EGENERIC;
1487             }
1488         }
1489         return VLC_SUCCESS;
1490
1491     case DEMUX_GET_TIME:
1492         pi64 = (int64_t*)va_arg( args, int64_t * );
1493         if( (p_sys->b_dvb_meta && p_sys->b_access_control) ||
1494             p_sys->b_force_seek_per_percent ||
1495             p_sys->i_current_pcr - p_sys->i_first_pcr < 0 )
1496         {
1497             if( DVBEventInformation( p_demux, pi64, NULL ) )
1498             {
1499                 *pi64 = 0;
1500             }
1501         }
1502         else
1503         {
1504             *pi64 = (p_sys->i_current_pcr - p_sys->i_first_pcr) * 100 / 9;
1505         }
1506         return VLC_SUCCESS;
1507
1508     case DEMUX_GET_LENGTH:
1509         pi64 = (int64_t*)va_arg( args, int64_t * );
1510         if( (p_sys->b_dvb_meta && p_sys->b_access_control) ||
1511             p_sys->b_force_seek_per_percent ||
1512             p_sys->i_last_pcr - p_sys->i_first_pcr <= 0 )
1513         {
1514             if( DVBEventInformation( p_demux, NULL, pi64 ) )
1515             {
1516                 *pi64 = 0;
1517             }
1518         }
1519         else
1520         {
1521             *pi64 = (p_sys->i_last_pcr - p_sys->i_first_pcr) * 100 / 9;
1522         }
1523         return VLC_SUCCESS;
1524
1525     case DEMUX_SET_GROUP:
1526     {
1527         vlc_list_t *p_list;
1528
1529         i_int = (int)va_arg( args, int );
1530         p_list = (vlc_list_t *)va_arg( args, vlc_list_t * );
1531         msg_Dbg( p_demux, "DEMUX_SET_GROUP %d %p", i_int, p_list );
1532
1533         if( i_int == 0 && p_sys->i_current_program > 0 )
1534             i_int = p_sys->i_current_program;
1535
1536         if( p_sys->i_current_program > 0 )
1537         {
1538             if( p_sys->i_current_program != i_int )
1539                 SetPrgFilter( p_demux, p_sys->i_current_program, false );
1540         }
1541         else if( p_sys->i_current_program < 0 )
1542         {
1543             for( int i = 0; i < p_sys->programs_list.i_count; i++ )
1544                 SetPrgFilter( p_demux, p_sys->programs_list.p_values[i].i_int, false );
1545         }
1546
1547         if( i_int > 0 )
1548         {
1549             p_sys->i_current_program = i_int;
1550             SetPrgFilter( p_demux, p_sys->i_current_program, true );
1551         }
1552         else if( i_int < 0 )
1553         {
1554             p_sys->i_current_program = -1;
1555             p_sys->programs_list.i_count = 0;
1556             if( p_list )
1557             {
1558                 vlc_list_t *p_dst = &p_sys->programs_list;
1559                 free( p_dst->p_values );
1560
1561                 p_dst->p_values = calloc( p_list->i_count,
1562                                           sizeof(*p_dst->p_values) );
1563                 if( p_dst->p_values )
1564                 {
1565                     p_dst->i_count = p_list->i_count;
1566                     for( int i = 0; i < p_list->i_count; i++ )
1567                     {
1568                         p_dst->p_values[i] = p_list->p_values[i];
1569                         SetPrgFilter( p_demux, p_dst->p_values[i].i_int, true );
1570                     }
1571                 }
1572             }
1573         }
1574         return VLC_SUCCESS;
1575     }
1576
1577     case DEMUX_GET_TITLE_INFO:
1578     {
1579         struct input_title_t ***v = va_arg( args, struct input_title_t*** );
1580         int *c = va_arg( args, int * );
1581
1582         *va_arg( args, int* ) = 0; /* Title offset */
1583         *va_arg( args, int* ) = 0; /* Chapter offset */
1584         return stream_Control( p_sys->stream, STREAM_GET_TITLE_INFO, v, c );
1585     }
1586
1587     case DEMUX_SET_TITLE:
1588         return stream_vaControl( p_sys->stream, STREAM_SET_TITLE, args );
1589
1590     case DEMUX_SET_SEEKPOINT:
1591         return stream_vaControl( p_sys->stream, STREAM_SET_SEEKPOINT, args );
1592
1593     case DEMUX_GET_META:
1594         return stream_vaControl( p_sys->stream, STREAM_GET_META, args );
1595
1596     case DEMUX_CAN_RECORD:
1597         pb_bool = (bool*)va_arg( args, bool * );
1598         *pb_bool = true;
1599         return VLC_SUCCESS;
1600
1601     case DEMUX_SET_RECORD_STATE:
1602         b_bool = (bool)va_arg( args, int );
1603
1604         if( !b_bool )
1605             stream_Control( p_sys->stream, STREAM_SET_RECORD_STATE, false );
1606         p_sys->b_start_record = b_bool;
1607         return VLC_SUCCESS;
1608
1609     case DEMUX_GET_SIGNAL:
1610         return stream_vaControl( p_sys->stream, STREAM_GET_SIGNAL, args );
1611
1612     default:
1613         return VLC_EGENERIC;
1614     }
1615 }
1616
1617 /*****************************************************************************
1618  *
1619  *****************************************************************************/
1620 static int UserPmt( demux_t *p_demux, const char *psz_fmt )
1621 {
1622     demux_sys_t *p_sys = p_demux->p_sys;
1623     char *psz_dup = strdup( psz_fmt );
1624     char *psz = psz_dup;
1625     int  i_pid;
1626     int  i_number;
1627     ts_prg_psi_t *prg = NULL;
1628
1629     if( !psz_dup )
1630         return VLC_ENOMEM;
1631
1632     /* Parse PID */
1633     i_pid = strtol( psz, &psz, 0 );
1634     if( i_pid < 2 || i_pid >= 8192 )
1635         goto error;
1636
1637     /* Parse optional program number */
1638     i_number = 0;
1639     if( *psz == ':' )
1640         i_number = strtol( &psz[1], &psz, 0 );
1641
1642     /* */
1643     ts_pid_t *pmt = &p_sys->pid[i_pid];
1644
1645     msg_Dbg( p_demux, "user pmt specified (pid=%d,number=%d)", i_pid, i_number );
1646     PIDInit( pmt, true, NULL );
1647
1648     /* Dummy PMT */
1649     prg = calloc( 1, sizeof( ts_prg_psi_t ) );
1650     if( !prg )
1651         goto error;
1652
1653     prg->i_pid_pcr  = -1;
1654     prg->i_pid_pmt  = -1;
1655     prg->i_version  = -1;
1656     prg->i_number   = i_number != 0 ? i_number : TS_USER_PMT_NUMBER;
1657 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1658     prg->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG );
1659     if( !prg->handle )
1660         goto error;
1661     prg->handle->p_sys = (void *) VLC_OBJECT(p_demux);
1662     if( !dvbpsi_pmt_attach( prg->handle,
1663                             ((i_number != TS_USER_PMT_NUMBER ? i_number : 1)),
1664                             PMTCallBack, p_demux ) )
1665     {
1666         dvbpsi_delete( prg->handle );
1667         prg->handle = NULL;
1668         goto error;
1669     }
1670 #else
1671     prg->handle     = dvbpsi_AttachPMT(
1672         ((i_number != TS_USER_PMT_NUMBER) ? i_number : 1),
1673         PMTCallBack, p_demux );
1674 #endif
1675     TAB_APPEND( pmt->psi->i_prg, pmt->psi->prg, prg );
1676
1677     psz = strchr( psz, '=' );
1678     if( psz )
1679         psz++;
1680     while( psz && *psz )
1681     {
1682         char *psz_next = strchr( psz, ',' );
1683         int i_pid;
1684
1685         if( psz_next )
1686             *psz_next++ = '\0';
1687
1688         i_pid = strtol( psz, &psz, 0 );
1689         if( *psz != ':' || i_pid < 2 || i_pid >= 8192 )
1690             goto next;
1691
1692         char *psz_opt = &psz[1];
1693         if( !strcmp( psz_opt, "pcr" ) )
1694         {
1695             prg->i_pid_pcr = i_pid;
1696         }
1697         else if( !p_sys->pid[i_pid].b_valid )
1698         {
1699             ts_pid_t *pid = &p_sys->pid[i_pid];
1700
1701             char *psz_arg = strchr( psz_opt, '=' );
1702             if( psz_arg )
1703                 *psz_arg++ = '\0';
1704
1705             PIDInit( pid, false, pmt->psi);
1706             if( prg->i_pid_pcr <= 0 )
1707                 prg->i_pid_pcr = i_pid;
1708
1709             if( psz_arg && strlen( psz_arg ) == 4 )
1710             {
1711                 const vlc_fourcc_t i_codec = VLC_FOURCC( psz_arg[0], psz_arg[1],
1712                                                          psz_arg[2], psz_arg[3] );
1713                 int i_cat = UNKNOWN_ES;
1714                 es_format_t *fmt = &pid->es->fmt;
1715
1716                 if( !strcmp( psz_opt, "video" ) )
1717                     i_cat = VIDEO_ES;
1718                 else if( !strcmp( psz_opt, "audio" ) )
1719                     i_cat = AUDIO_ES;
1720                 else if( !strcmp( psz_opt, "spu" ) )
1721                     i_cat = SPU_ES;
1722
1723                 es_format_Init( fmt, i_cat, i_codec );
1724                 fmt->b_packetized = false;
1725             }
1726             else
1727             {
1728                 const int i_stream_type = strtol( psz_opt, NULL, 0 );
1729                 PIDFillFormat( &pid->es->fmt, i_stream_type );
1730             }
1731             pid->es->fmt.i_group = i_number;
1732             if( p_sys->b_es_id_pid )
1733                 pid->es->fmt.i_id = i_pid;
1734
1735             if( pid->es->fmt.i_cat != UNKNOWN_ES )
1736             {
1737                 msg_Dbg( p_demux, "  * es pid=%d fcc=%4.4s", i_pid,
1738                          (char*)&pid->es->fmt.i_codec );
1739                 pid->es->id = es_out_Add( p_demux->out,
1740                                           &pid->es->fmt );
1741                 p_sys->i_pmt_es++;
1742             }
1743         }
1744
1745     next:
1746         psz = psz_next;
1747     }
1748
1749     p_sys->b_user_pmt = true;
1750     TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
1751     free( psz_dup );
1752     return VLC_SUCCESS;
1753
1754 error:
1755     free( prg );
1756     free( psz_dup );
1757     return VLC_EGENERIC;
1758 }
1759
1760 static int SetPIDFilter( demux_t *p_demux, int i_pid, bool b_selected )
1761 {
1762     demux_sys_t *p_sys = p_demux->p_sys;
1763
1764     if( !p_sys->b_access_control )
1765         return VLC_EGENERIC;
1766
1767     return stream_Control( p_sys->stream, STREAM_SET_PRIVATE_ID_STATE,
1768                            i_pid, b_selected );
1769 }
1770
1771 static void SetPrgFilter( demux_t *p_demux, int i_prg_id, bool b_selected )
1772 {
1773     demux_sys_t *p_sys = p_demux->p_sys;
1774     ts_prg_psi_t *p_prg = NULL;
1775     int i_pmt_pid = -1;
1776
1777     p_sys->b_disable_pcr = !p_sys->b_trust_pcr;
1778
1779     /* Search pmt to be unselected */
1780     for( int i = 0; i < p_sys->i_pmt; i++ )
1781     {
1782         ts_pid_t *pmt = p_sys->pmt[i];
1783
1784         for( int i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
1785         {
1786             if( pmt->psi->prg[i_prg]->i_number == i_prg_id )
1787             {
1788                 i_pmt_pid = p_sys->pmt[i]->i_pid;
1789                 p_prg = p_sys->pmt[i]->psi->prg[i_prg];
1790                 break;
1791             }
1792         }
1793         if( i_pmt_pid > 0 )
1794             break;
1795     }
1796     if( i_pmt_pid <= 0 )
1797         return;
1798     assert( p_prg );
1799
1800     SetPIDFilter( p_demux, i_pmt_pid, b_selected );
1801     if( p_prg->i_pid_pcr > 0 )
1802         SetPIDFilter( p_demux, p_prg->i_pid_pcr, b_selected );
1803
1804     /* All ES */
1805     for( int i = 2; i < 8192; i++ )
1806     {
1807         ts_pid_t *pid = &p_sys->pid[i];
1808
1809         if( !pid->b_valid || pid->psi )
1810             continue;
1811
1812         for( int i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
1813         {
1814             if( pid->p_owner->prg[i_prg]->i_pid_pmt == i_pmt_pid && pid->es->id )
1815             {
1816                 /* We only remove/select es that aren't defined by extra pmt */
1817                 SetPIDFilter( p_demux, i, b_selected );
1818                 break;
1819             }
1820         }
1821     }
1822 }
1823
1824 static void PIDInit( ts_pid_t *pid, bool b_psi, ts_psi_t *p_owner )
1825 {
1826     bool b_old_valid = pid->b_valid;
1827
1828     pid->b_valid    = true;
1829     pid->i_cc       = 0xff;
1830     pid->b_scrambled = false;
1831     pid->p_owner    = p_owner;
1832     pid->i_owner_number = 0;
1833
1834     TAB_INIT( pid->i_extra_es, pid->extra_es );
1835
1836     if( b_psi )
1837     {
1838         pid->es  = NULL;
1839
1840         if( !b_old_valid )
1841         {
1842             pid->psi = xmalloc( sizeof( ts_psi_t ) );
1843             pid->psi->handle = NULL;
1844             TAB_INIT( pid->psi->i_prg, pid->psi->prg );
1845         }
1846         assert( pid->psi );
1847
1848         pid->psi->i_pat_version  = -1;
1849         pid->psi->i_sdt_version  = -1;
1850         if( p_owner )
1851         {
1852             ts_prg_psi_t *prg = malloc( sizeof( ts_prg_psi_t ) );
1853             if( !prg )
1854                 return;
1855             /* PMT */
1856             prg->i_version  = -1;
1857             prg->i_number   = -1;
1858             prg->i_pid_pcr  = -1;
1859             prg->i_pid_pmt  = -1;
1860             prg->i_pcr_value= -1;
1861             prg->iod        = NULL;
1862             prg->handle     = NULL;
1863
1864             TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
1865         }
1866     }
1867     else
1868     {
1869         pid->psi = NULL;
1870         pid->es  = calloc( 1, sizeof( ts_es_t ) );
1871         if( !pid->es )
1872             return;
1873
1874         es_format_Init( &pid->es->fmt, UNKNOWN_ES, 0 );
1875         pid->es->data_type = TS_ES_DATA_PES;
1876         pid->es->pp_last = &pid->es->p_data;
1877     }
1878 }
1879
1880 static void PIDClean( demux_t *p_demux, ts_pid_t *pid )
1881 {
1882     demux_sys_t *p_sys = p_demux->p_sys;
1883     es_out_t *out = p_demux->out;
1884
1885     if( pid->psi )
1886     {
1887         if( pid->psi->handle )
1888         {
1889 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1890             if( dvbpsi_decoder_present( pid->psi->handle ) )
1891                 dvbpsi_pmt_detach( pid->psi->handle );
1892             dvbpsi_delete( pid->psi->handle );
1893             pid->psi->handle = NULL;
1894 #else
1895             dvbpsi_DetachPMT( pid->psi->handle );
1896 #endif
1897         }
1898         for( int i = 0; i < pid->psi->i_prg; i++ )
1899         {
1900             if( pid->psi->prg[i]->iod )
1901                 IODFree( pid->psi->prg[i]->iod );
1902             if( pid->psi->prg[i]->handle )
1903             {
1904 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
1905                 if( dvbpsi_decoder_present( pid->psi->prg[i]->handle ) )
1906                     dvbpsi_pmt_detach( pid->psi->prg[i]->handle );
1907                 dvbpsi_delete( pid->psi->prg[i]->handle );
1908 #else
1909                 dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
1910 #endif
1911             }
1912             free( pid->psi->prg[i] );
1913         }
1914         free( pid->psi->prg );
1915         free( pid->psi );
1916     }
1917     else
1918     {
1919         if( pid->es->id )
1920         {
1921             es_out_Del( out, pid->es->id );
1922             p_sys->i_pmt_es--;
1923         }
1924
1925         if( pid->es->p_data )
1926             block_ChainRelease( pid->es->p_data );
1927
1928         es_format_Clean( &pid->es->fmt );
1929
1930         free( pid->es );
1931
1932         for( int i = 0; i < pid->i_extra_es; i++ )
1933         {
1934             if( pid->extra_es[i]->id )
1935             {
1936                 es_out_Del( out, pid->extra_es[i]->id );
1937                 p_sys->i_pmt_es--;
1938             }
1939
1940             if( pid->extra_es[i]->p_data )
1941                 block_ChainRelease( pid->extra_es[i]->p_data );
1942
1943             es_format_Clean( &pid->extra_es[i]->fmt );
1944
1945             free( pid->extra_es[i] );
1946         }
1947         if( pid->i_extra_es )
1948             free( pid->extra_es );
1949     }
1950
1951     pid->b_valid = false;
1952 }
1953
1954 static int16_t read_opus_flag(uint8_t **buf, size_t *len)
1955 {
1956     if (*len < 2)
1957         return -1;
1958
1959     int16_t ret = ((*buf)[0] << 8) | (*buf)[1];
1960
1961     *len -= 2;
1962     *buf += 2;
1963
1964     if (ret & (3<<13))
1965         ret = -1;
1966
1967     return ret;
1968 }
1969
1970 static block_t *Opus_Parse(demux_t *demux, block_t *block)
1971 {
1972     block_t *out = NULL;
1973     block_t **last = NULL;
1974
1975     uint8_t *buf = block->p_buffer;
1976     size_t len = block->i_buffer;
1977
1978     while (len > 3 && ((buf[0] << 3) | (buf[1] >> 5)) == 0x3ff) {
1979         int16_t start_trim = 0, end_trim = 0;
1980         int start_trim_flag        = (buf[1] >> 4) & 1;
1981         int end_trim_flag          = (buf[1] >> 3) & 1;
1982         int control_extension_flag = (buf[1] >> 2) & 1;
1983
1984         len -= 2;
1985         buf += 2;
1986
1987         unsigned au_size = 0;
1988         while (len--) {
1989             int c = *buf++;
1990             au_size += c;
1991             if (c != 0xff)
1992                 break;
1993         }
1994
1995         if (start_trim_flag) {
1996             start_trim = read_opus_flag(&buf, &len);
1997             if (start_trim < 0) {
1998                 msg_Err(demux, "Invalid start trimming flag");
1999             }
2000         }
2001         if (end_trim_flag) {
2002             end_trim = read_opus_flag(&buf, &len);
2003             if (end_trim < 0) {
2004                 msg_Err(demux, "Invalid end trimming flag");
2005             }
2006         }
2007         if (control_extension_flag && len) {
2008             unsigned l = *buf++; len--;
2009             if (l > len) {
2010                 msg_Err(demux, "Invalid control extension length %d > %zu", l, len);
2011                 break;
2012             }
2013             buf += l;
2014             len -= l;
2015         }
2016
2017         if (!au_size || au_size > len) {
2018             msg_Err(demux, "Invalid Opus AU size %d (PES %zu)", au_size, len);
2019             break;
2020         }
2021
2022         block_t *au = block_Alloc(au_size);
2023         if (!au)
2024             break;
2025         memcpy(au->p_buffer, buf, au_size);
2026         block_CopyProperties(au, block);
2027         au->p_next = NULL;
2028
2029         if (!out)
2030             out = au;
2031         else
2032             *last = au;
2033         last = &au->p_next;
2034
2035         au->i_nb_samples = opus_frame_duration(buf, au_size);
2036         if (end_trim && end_trim <= au->i_nb_samples)
2037             au->i_length = end_trim; /* Blatant abuse of the i_length field. */
2038         else
2039             au->i_length = 0;
2040
2041         if (start_trim && start_trim < (au->i_nb_samples - au->i_length)) {
2042             au->i_nb_samples -= start_trim;
2043             if (au->i_nb_samples == 0)
2044                 au->i_flags |= BLOCK_FLAG_PREROLL;
2045         }
2046
2047         buf += au_size;
2048         len -= au_size;
2049     }
2050
2051     block_Release(block);
2052     return out;
2053 }
2054
2055 /****************************************************************************
2056  * gathering stuff
2057  ****************************************************************************/
2058 static void ParsePES( demux_t *p_demux, ts_pid_t *pid, block_t *p_pes )
2059 {
2060     demux_sys_t *p_sys = p_demux->p_sys;
2061     uint8_t header[34];
2062     unsigned i_pes_size = 0;
2063     unsigned i_skip = 0;
2064     mtime_t i_dts = -1;
2065     mtime_t i_pts = -1;
2066     mtime_t i_length = 0;
2067
2068     /* FIXME find real max size */
2069     /* const int i_max = */ block_ChainExtract( p_pes, header, 34 );
2070
2071     if( pid->b_scrambled || header[0] != 0 || header[1] != 0 || header[2] != 1 )
2072     {
2073         if ( !pid->b_scrambled )
2074             msg_Warn( p_demux, "invalid header [0x%02x:%02x:%02x:%02x] (pid: %d)",
2075                         header[0], header[1],header[2],header[3], pid->i_pid );
2076         block_ChainRelease( p_pes );
2077         return;
2078     }
2079
2080     /* TODO check size */
2081     switch( header[3] )
2082     {
2083     case 0xBC:  /* Program stream map */
2084     case 0xBE:  /* Padding */
2085     case 0xBF:  /* Private stream 2 */
2086     case 0xF0:  /* ECM */
2087     case 0xF1:  /* EMM */
2088     case 0xFF:  /* Program stream directory */
2089     case 0xF2:  /* DSMCC stream */
2090     case 0xF8:  /* ITU-T H.222.1 type E stream */
2091         i_skip = 6;
2092         break;
2093     default:
2094         if( ( header[6]&0xC0 ) == 0x80 )
2095         {
2096             /* mpeg2 PES */
2097             i_skip = header[8] + 9;
2098
2099             if( header[7]&0x80 )    /* has pts */
2100             {
2101                 i_pts = ExtractPESTimestamp( &header[9] );
2102                 i_pts = AdjustPTSWrapAround( p_demux, i_pts );
2103
2104                 if( header[7]&0x40 )    /* has dts */
2105                 {
2106                     i_dts = ExtractPESTimestamp( &header[14] );
2107                     i_dts = AdjustPTSWrapAround( p_demux, i_dts );
2108                 }
2109             }
2110         }
2111         else
2112         {
2113             i_skip = 6;
2114             while( i_skip < 23 && header[i_skip] == 0xff )
2115             {
2116                 i_skip++;
2117             }
2118             if( i_skip == 23 )
2119             {
2120                 msg_Err( p_demux, "too much MPEG-1 stuffing" );
2121                 block_ChainRelease( p_pes );
2122                 return;
2123             }
2124             if( ( header[i_skip] & 0xC0 ) == 0x40 )
2125             {
2126                 i_skip += 2;
2127             }
2128
2129             if(  header[i_skip]&0x20 )
2130             {
2131                 i_pts = ExtractPESTimestamp( &header[i_skip] );
2132
2133                 if( header[i_skip]&0x10 )    /* has dts */
2134                 {
2135                     i_dts = ExtractPESTimestamp( &header[i_skip+5] );
2136                     i_skip += 10;
2137                 }
2138                 else
2139                 {
2140                     i_skip += 5;
2141                 }
2142             }
2143             else
2144             {
2145                 i_skip += 1;
2146             }
2147         }
2148         break;
2149     }
2150
2151     if( pid->es->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', 'b' ) ||
2152         pid->es->fmt.i_codec == VLC_FOURCC( 'd', 't', 's', 'b' ) )
2153     {
2154         i_skip += 4;
2155     }
2156     else if( pid->es->fmt.i_codec == VLC_FOURCC( 'l', 'p', 'c', 'b' ) ||
2157              pid->es->fmt.i_codec == VLC_FOURCC( 's', 'p', 'u', 'b' ) ||
2158              pid->es->fmt.i_codec == VLC_FOURCC( 's', 'd', 'd', 'b' ) )
2159     {
2160         i_skip += 1;
2161     }
2162     else if( pid->es->fmt.i_codec == VLC_CODEC_SUBT &&
2163              pid->es->p_mpeg4desc )
2164     {
2165         decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
2166
2167         if( dcd->i_extra > 2 &&
2168             dcd->p_extra[0] == 0x10 &&
2169             ( dcd->p_extra[1]&0x10 ) )
2170         {
2171             /* display length */
2172             if( p_pes->i_buffer + 2 <= i_skip )
2173                 i_length = GetWBE( &p_pes->p_buffer[i_skip] );
2174
2175             i_skip += 2;
2176         }
2177         if( p_pes->i_buffer + 2 <= i_skip )
2178             i_pes_size = GetWBE( &p_pes->p_buffer[i_skip] );
2179         /* */
2180         i_skip += 2;
2181     }
2182
2183     /* skip header */
2184     while( p_pes && i_skip > 0 )
2185     {
2186         if( p_pes->i_buffer <= i_skip )
2187         {
2188             block_t *p_next = p_pes->p_next;
2189
2190             i_skip -= p_pes->i_buffer;
2191             block_Release( p_pes );
2192             p_pes = p_next;
2193         }
2194         else
2195         {
2196             p_pes->i_buffer -= i_skip;
2197             p_pes->p_buffer += i_skip;
2198             break;
2199         }
2200     }
2201
2202     /* ISO/IEC 13818-1 2.7.5: if no pts and no dts, then dts == pts */
2203     if( i_pts >= 0 && i_dts < 0 )
2204         i_dts = i_pts;
2205
2206     if( p_pes )
2207     {
2208         block_t *p_block;
2209
2210         if( i_dts >= 0 )
2211             p_pes->i_dts = VLC_TS_0 + i_dts * 100 / 9;
2212
2213         if( i_pts >= 0 )
2214             p_pes->i_pts = VLC_TS_0 + i_pts * 100 / 9;
2215
2216         p_pes->i_length = i_length * 100 / 9;
2217
2218         p_block = block_ChainGather( p_pes );
2219         if( pid->es->fmt.i_codec == VLC_CODEC_SUBT )
2220         {
2221             if( i_pes_size > 0 && p_block->i_buffer > i_pes_size )
2222             {
2223                 p_block->i_buffer = i_pes_size;
2224             }
2225             /* Append a \0 */
2226             p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
2227             if( !p_block )
2228                 return;
2229             p_block->p_buffer[p_block->i_buffer -1] = '\0';
2230         }
2231         else if( pid->es->fmt.i_codec == VLC_CODEC_TELETEXT )
2232         {
2233             if( p_block->i_pts <= VLC_TS_INVALID )
2234             {
2235                 /* Teletext may have missing PTS (ETSI EN 300 472 Annexe A)
2236                  * In this case use the last PCR + 40ms */
2237                 for( int i = 0; pid->p_owner && i < pid->p_owner->i_prg; i++ )
2238                 {
2239                     if( pid->i_owner_number == pid->p_owner->prg[i]->i_number )
2240                     {
2241                         mtime_t i_pcr = pid->p_owner->prg[i]->i_pcr_value;
2242                         if( i_pcr > VLC_TS_INVALID )
2243                             p_block->i_pts = VLC_TS_0 + i_pcr * 100 / 9 + 40000;
2244                         break;
2245                     }
2246                 }
2247             }
2248         }
2249         else if( pid->es->fmt.i_codec == VLC_CODEC_ARIB_A ||
2250                  pid->es->fmt.i_codec == VLC_CODEC_ARIB_C )
2251         {
2252             if( p_block->i_pts <= VLC_TS_INVALID )
2253             {
2254                 if( i_pes_size > 0 && p_block->i_buffer > i_pes_size )
2255                 {
2256                     p_block->i_buffer = i_pes_size;
2257                 }
2258                 /* Append a \0 */
2259                 p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
2260                 if( !p_block )
2261                     return;
2262                 p_block->p_buffer[p_block->i_buffer -1] = '\0';
2263             }
2264         }
2265         else if( pid->es->fmt.i_codec == VLC_CODEC_OPUS)
2266         {
2267             p_block = Opus_Parse(p_demux, p_block);
2268         }
2269
2270         while (p_block) {
2271             block_t *p_next = p_block->p_next;
2272             p_block->p_next = NULL;
2273             for( int i = 0; i < pid->i_extra_es; i++ )
2274             {
2275                 es_out_Send( p_demux->out, pid->extra_es[i]->id,
2276                         block_Duplicate( p_block ) );
2277             }
2278
2279             PCRFixHandle( p_demux, p_block );
2280
2281             if ( p_sys->b_disable_pcr && p_block->i_dts > VLC_TS_INVALID )
2282                 es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
2283                         pid->i_owner_number, p_block->i_dts);
2284
2285             if( !p_sys->b_disable_pcr && p_block->i_dts > VLC_TS_INVALID &&
2286                  p_block->i_dts < (VLC_TS_0 + p_sys->i_current_pcr * 100 / 9) )
2287                 msg_Warn( p_demux, "Broken stream: pid %d sends packets with dts %"PRId64"us later than pcr",
2288                           pid->i_pid, (p_sys->i_current_pcr * 100 / 9) - p_block->i_dts + VLC_TS_0  );
2289
2290             es_out_Send( p_demux->out, pid->es->id, p_block );
2291
2292             p_block = p_next;
2293         }
2294     }
2295     else
2296     {
2297         msg_Warn( p_demux, "empty pes" );
2298     }
2299 }
2300
2301 static void ParseTableSection( demux_t *p_demux, ts_pid_t *pid, block_t *p_data )
2302 {
2303     block_t *p_content = block_ChainGather( p_data );
2304     mtime_t i_date = -1;
2305     for( int i = 0; pid->p_owner && i < pid->p_owner->i_prg; i++ )
2306     {
2307         if( pid->i_owner_number == pid->p_owner->prg[i]->i_number )
2308         {
2309             i_date = pid->p_owner->prg[i]->i_pcr_value;
2310             if( i_date >= 0 )
2311                 break;
2312         }
2313     }
2314     if( i_date >= 0 )
2315     {
2316         if( pid->es->fmt.i_codec == VLC_CODEC_SCTE_27 )
2317         {
2318             /* We need to extract the truncated pts stored inside the payload */
2319             if( p_content->i_buffer > 9 && p_content->p_buffer[0] == 0xc6 )
2320             {
2321                 int i_index = 0;
2322                 size_t i_offset = 4;
2323                 if( p_content->p_buffer[3] & 0x40 )
2324                 {
2325                     i_index = ((p_content->p_buffer[7] & 0x0f) << 8) |
2326                               p_content->p_buffer[8];
2327                     i_offset = 9;
2328                 }
2329                 if( i_index == 0 && p_content->i_buffer > i_offset + 8 )
2330                 {
2331                     bool is_immediate = p_content->p_buffer[i_offset + 3] & 0x40;
2332                     if( !is_immediate )
2333                     {
2334                         mtime_t i_display_in = GetDWBE( &p_content->p_buffer[i_offset + 4] );
2335                         if( i_display_in < i_date )
2336                             i_date = i_display_in + (1ll << 32);
2337                         else
2338                             i_date = i_display_in;
2339                     }
2340
2341                 }
2342             }
2343         }
2344         p_content->i_dts =
2345         p_content->i_pts = VLC_TS_0 + i_date * 100 / 9;
2346     }
2347     es_out_Send( p_demux->out, pid->es->id, p_content );
2348
2349     PCRFixHandle( p_demux, p_content );
2350 }
2351 static void ParseData( demux_t *p_demux, ts_pid_t *pid )
2352 {
2353     block_t *p_data = pid->es->p_data;
2354
2355     /* remove the pes from pid */
2356     pid->es->p_data = NULL;
2357     pid->es->i_data_size = 0;
2358     pid->es->i_data_gathered = 0;
2359     pid->es->pp_last = &pid->es->p_data;
2360
2361     if( pid->es->data_type == TS_ES_DATA_PES )
2362     {
2363         ParsePES( p_demux, pid, p_data );
2364     }
2365     else if( pid->es->data_type == TS_ES_DATA_TABLE_SECTION )
2366     {
2367         ParseTableSection( p_demux, pid, p_data );
2368     }
2369     else
2370     {
2371         block_ChainRelease( p_data );
2372     }
2373 }
2374
2375 static block_t* ReadTSPacket( demux_t *p_demux )
2376 {
2377     demux_sys_t *p_sys = p_demux->p_sys;
2378
2379     block_t     *p_pkt;
2380
2381     /* Get a new TS packet */
2382     if( !( p_pkt = stream_Block( p_sys->stream, p_sys->i_packet_size ) ) )
2383     {
2384         msg_Dbg( p_demux, "eof ?" );
2385         return NULL;
2386     }
2387
2388     /* Skip header (BluRay streams).
2389      * re-sync logic would do this (by adjusting packet start), but this would result in losing first and last ts packets.
2390      * First packet is usually PAT, and losing it means losing whole first GOP. This is fatal with still-image based menus.
2391      */
2392     p_pkt->p_buffer += p_sys->i_packet_header_size;
2393     p_pkt->i_buffer -= p_sys->i_packet_header_size;
2394
2395     /* Check sync byte and re-sync if needed */
2396     if( p_pkt->p_buffer[0] != 0x47 )
2397     {
2398         msg_Warn( p_demux, "lost synchro" );
2399         block_Release( p_pkt );
2400         for( ;; )
2401         {
2402             const uint8_t *p_peek;
2403             int i_peek, i_skip = 0;
2404
2405             i_peek = stream_Peek( p_sys->stream, &p_peek,
2406                     p_sys->i_packet_size * 10 );
2407             if( i_peek < p_sys->i_packet_size + 1 )
2408             {
2409                 msg_Dbg( p_demux, "eof ?" );
2410                 return NULL;
2411             }
2412
2413             while( i_skip < i_peek - p_sys->i_packet_size )
2414             {
2415                 if( p_peek[i_skip + p_sys->i_packet_header_size] == 0x47 &&
2416                         p_peek[i_skip + p_sys->i_packet_header_size + p_sys->i_packet_size] == 0x47 )
2417                 {
2418                     break;
2419                 }
2420                 i_skip++;
2421             }
2422             msg_Dbg( p_demux, "skipping %d bytes of garbage", i_skip );
2423             stream_Read( p_sys->stream, NULL, i_skip );
2424
2425             if( i_skip < i_peek - p_sys->i_packet_size )
2426             {
2427                 break;
2428             }
2429         }
2430         if( !( p_pkt = stream_Block( p_sys->stream, p_sys->i_packet_size ) ) )
2431         {
2432             msg_Dbg( p_demux, "eof ?" );
2433             return NULL;
2434         }
2435     }
2436     return p_pkt;
2437 }
2438
2439 static mtime_t AdjustPCRWrapAround( demux_t *p_demux, mtime_t i_pcr )
2440 {
2441     demux_sys_t   *p_sys = p_demux->p_sys;
2442     /*
2443      * PCR is 33bit. If PCR reaches to 0x1FFFFFFFF (26:30:43.717), ressets from 0.
2444      * So, need to add 0x1FFFFFFFF, for calculating duration or current position.
2445      */
2446     mtime_t i_adjust = 0;
2447     int64_t i_pos = stream_Tell( p_sys->stream );
2448     int i;
2449     for( i = 1; i < p_sys->i_pcrs_num && p_sys->p_pos[i] <= i_pos; ++i )
2450     {
2451         if( p_sys->p_pcrs[i-1] > p_sys->p_pcrs[i] )
2452             i_adjust += 0x1FFFFFFFF;
2453     }
2454     if( p_sys->p_pcrs[i-1] > i_pcr )
2455         i_adjust += 0x1FFFFFFFF;
2456
2457     return i_pcr + i_adjust;
2458 }
2459
2460 static mtime_t AdjustPTSWrapAround( demux_t *p_demux, mtime_t i_pts )
2461 {
2462     demux_sys_t *p_sys = p_demux->p_sys;
2463     mtime_t i_pcr = p_sys->i_current_pcr;
2464
2465     mtime_t i_adjustremain = i_pcr % 0x1FFFFFFFF;
2466     mtime_t i_adjustbase = i_pcr - i_adjustremain;
2467
2468     mtime_t i_pts_adjust = i_adjustbase;
2469
2470     /* PTS has rolled first */
2471     if( i_adjustremain >= 0xFFFFFFFF && i_pts < 0xFFFFFFFF )
2472     {
2473         i_pts_adjust += 0x1FFFFFFFF;
2474     }
2475     /* PCR has rolled first (PTS is late!) */
2476     else if( i_adjustremain < 0xFFFFFFFF && i_pts >= 0xFFFFFFFF )
2477     {
2478         if( i_adjustbase >= 0x1FFFFFFFF ) /* we need to remove current roll */
2479             i_pts_adjust -= 0x1FFFFFFFF;
2480     }
2481
2482     i_pts += i_pts_adjust;
2483     return i_pts;
2484 }
2485
2486 static mtime_t GetPCR( block_t *p_pkt )
2487 {
2488     const uint8_t *p = p_pkt->p_buffer;
2489
2490     mtime_t i_pcr = -1;
2491
2492     if( ( p[3]&0x20 ) && /* adaptation */
2493         ( p[5]&0x10 ) &&
2494         ( p[4] >= 7 ) )
2495     {
2496         /* PCR is 33 bits */
2497         i_pcr = ( (mtime_t)p[6] << 25 ) |
2498                 ( (mtime_t)p[7] << 17 ) |
2499                 ( (mtime_t)p[8] << 9 ) |
2500                 ( (mtime_t)p[9] << 1 ) |
2501                 ( (mtime_t)p[10] >> 7 );
2502     }
2503     return i_pcr;
2504 }
2505
2506 static int SeekToPCR( demux_t *p_demux, int64_t i_pos )
2507 {
2508     demux_sys_t *p_sys = p_demux->p_sys;
2509
2510     mtime_t i_pcr = -1;
2511     const int64_t i_initial_pos = stream_Tell( p_sys->stream );
2512
2513     if( i_pos < 0 )
2514         return VLC_EGENERIC;
2515
2516     int64_t i_last_pos = stream_Size( p_sys->stream ) - p_sys->i_packet_size;
2517     if( i_pos > i_last_pos )
2518         i_pos = i_last_pos;
2519
2520     if( stream_Seek( p_sys->stream, i_pos ) )
2521         return VLC_EGENERIC;
2522
2523     for( ;; )
2524     {
2525         block_t *p_pkt;
2526
2527         if( !( p_pkt = ReadTSPacket( p_demux ) ) )
2528         {
2529             break;
2530         }
2531         if( PIDGet( p_pkt ) == p_sys->i_pid_ref_pcr )
2532         {
2533             i_pcr = GetPCR( p_pkt );
2534         }
2535         block_Release( p_pkt );
2536         if( i_pcr >= 0 )
2537             break;
2538         if( stream_Tell( p_sys->stream ) >= i_last_pos )
2539             break;
2540     }
2541     if( i_pcr < 0 )
2542     {
2543         stream_Seek( p_sys->stream, i_initial_pos );
2544         assert( i_initial_pos == stream_Tell( p_sys->stream ) );
2545         return VLC_EGENERIC;
2546     }
2547
2548     p_sys->i_current_pcr = i_pcr;
2549     return VLC_SUCCESS;
2550 }
2551
2552 static int Seek( demux_t *p_demux, double f_percent )
2553 {
2554     demux_sys_t *p_sys = p_demux->p_sys;
2555
2556     int64_t i_initial_pos = stream_Tell( p_sys->stream );
2557     mtime_t i_initial_pcr = p_sys->i_current_pcr;
2558
2559     /*
2560      * Find the time position by using binary search algorithm.
2561      */
2562     mtime_t i_target_pcr = (p_sys->i_last_pcr - p_sys->i_first_pcr) * f_percent + p_sys->i_first_pcr;
2563
2564     int64_t i_head_pos = 0;
2565     int64_t i_tail_pos;
2566     {
2567         mtime_t i_adjust = 0;
2568         int i;
2569         for( i = 1; i < p_sys->i_pcrs_num; ++i )
2570         {
2571             if( p_sys->p_pcrs[i-1] > p_sys->p_pcrs[i] )
2572                 i_adjust += 0x1FFFFFFFF;
2573             if( p_sys->p_pcrs[i] + i_adjust > i_target_pcr )
2574                 break;
2575         }
2576         i_head_pos = p_sys->p_pos[i-1];
2577         i_tail_pos = ( i < p_sys->i_pcrs_num ) ?  p_sys->p_pos[i] : stream_Size( p_sys->stream );
2578     }
2579     msg_Dbg( p_demux, "Seek():i_head_pos:%"PRId64", i_tail_pos:%"PRId64, i_head_pos, i_tail_pos);
2580
2581     bool b_found = false;
2582     int i_cnt = 0;
2583     while( i_head_pos <= i_tail_pos )
2584     {
2585         /* Round i_pos to a multiple of p_sys->i_packet_size */
2586         int64_t i_pos = i_head_pos + (i_tail_pos - i_head_pos) / 2;
2587         int64_t i_div = i_pos % p_sys->i_packet_size;
2588         i_pos -= i_div;
2589         if( SeekToPCR( p_demux, i_pos ) )
2590             break;
2591         p_sys->i_current_pcr = AdjustPCRWrapAround( p_demux, p_sys->i_current_pcr );
2592         int64_t i_diff_msec = (p_sys->i_current_pcr - i_target_pcr) * 100 / 9 / 1000;
2593         if( i_diff_msec > 500 )
2594         {
2595             i_tail_pos = i_pos - p_sys->i_packet_size;
2596         }
2597         else if( i_diff_msec < -500 )
2598         {
2599             i_head_pos = i_pos + p_sys->i_packet_size;
2600         }
2601         else
2602         {
2603             // diff time <= 500msec
2604             b_found = true;
2605             break;
2606         }
2607         ++i_cnt;
2608     }
2609     if( !b_found )
2610     {
2611         msg_Dbg( p_demux, "Seek():cannot find a time position. i_cnt:%d", i_cnt );
2612         stream_Seek( p_sys->stream, i_initial_pos );
2613         p_sys->i_current_pcr = i_initial_pcr;
2614         return VLC_EGENERIC;
2615     }
2616     else
2617     {
2618         msg_Dbg( p_demux, "Seek():can find a time position. i_cnt:%d", i_cnt );
2619         p_demux->p_sys->pcrfix.i_first_dts = 0;
2620         return VLC_SUCCESS;
2621     }
2622 }
2623
2624 static void GetFirstPCR( demux_t *p_demux )
2625 {
2626     demux_sys_t *p_sys = p_demux->p_sys;
2627
2628     int64_t i_initial_pos = stream_Tell( p_sys->stream );
2629
2630     if( stream_Seek( p_sys->stream, 0 ) )
2631         return;
2632
2633     for( ;; )
2634     {
2635         block_t     *p_pkt;
2636
2637         if( !( p_pkt = ReadTSPacket( p_demux ) ) )
2638         {
2639             break;
2640         }
2641         mtime_t i_pcr = GetPCR( p_pkt );
2642         if( i_pcr >= 0 )
2643         {
2644             p_sys->i_pid_ref_pcr = PIDGet( p_pkt );
2645             p_sys->i_first_pcr = i_pcr;
2646             p_sys->i_current_pcr = i_pcr;
2647         }
2648         block_Release( p_pkt );
2649         if( p_sys->i_first_pcr >= 0 )
2650             break;
2651     }
2652     stream_Seek( p_sys->stream, i_initial_pos );
2653 }
2654
2655 static void GetLastPCR( demux_t *p_demux )
2656 {
2657     demux_sys_t *p_sys = p_demux->p_sys;
2658
2659     const int64_t i_initial_pos = stream_Tell( p_sys->stream );
2660     mtime_t i_initial_pcr = p_sys->i_current_pcr;
2661
2662     int64_t i_stream_size = stream_Size( p_sys->stream );
2663     int64_t i_last_pos = i_stream_size - p_sys->i_packet_size;
2664     /* Round i_pos to a multiple of p_sys->i_packet_size */
2665     int64_t i_pos = i_last_pos - p_sys->i_packet_size * 4500; /* FIXME if the value is not reasonable, please change it. */
2666     int64_t i_div = i_pos % p_sys->i_packet_size;
2667     i_pos -= i_div;
2668
2669     if( i_pos <= i_initial_pos && i_pos >= i_stream_size )
2670         i_pos = i_initial_pos + p_sys->i_packet_size;
2671     if( i_pos < 0 && i_pos >= i_stream_size )
2672         return;
2673
2674     for( ;; )
2675     {
2676         if( SeekToPCR( p_demux, i_pos ) )
2677             break;
2678         p_sys->i_last_pcr = AdjustPCRWrapAround( p_demux, p_sys->i_current_pcr );
2679         if( ( i_pos = stream_Tell( p_sys->stream ) ) >= i_last_pos )
2680             break;
2681     }
2682
2683     stream_Seek( p_sys->stream, i_initial_pos );
2684     assert( i_initial_pos == stream_Tell( p_sys->stream ) );
2685     p_sys->i_current_pcr = i_initial_pcr;
2686 }
2687
2688 static void CheckPCR( demux_t *p_demux )
2689 {
2690     demux_sys_t   *p_sys = p_demux->p_sys;
2691
2692     int64_t i_initial_pos = stream_Tell( p_sys->stream );
2693     mtime_t i_initial_pcr = p_sys->i_current_pcr;
2694
2695     int64_t i_size = stream_Size( p_sys->stream );
2696
2697     int i = 0;
2698     p_sys->p_pcrs[0] = p_sys->i_first_pcr;
2699     p_sys->p_pos[0] = i_initial_pos;
2700
2701     for( i = 1; i < p_sys->i_pcrs_num; ++i )
2702     {
2703         /* Round i_pos to a multiple of p_sys->i_packet_size */
2704         int64_t i_pos = i_size / p_sys->i_pcrs_num * i;
2705         int64_t i_div = i_pos % p_sys->i_packet_size;
2706         i_pos -= i_div;
2707         if( SeekToPCR( p_demux, i_pos ) )
2708             break;
2709         p_sys->p_pcrs[i] = p_sys->i_current_pcr;
2710         p_sys->p_pos[i] = stream_Tell( p_sys->stream );
2711         if( p_sys->p_pcrs[i-1] > p_sys->p_pcrs[i] )
2712         {
2713             msg_Dbg( p_demux, "PCR Wrap Around found between %d%% and %d%% (pcr:%"PRId64"(0x%09"PRIx64") pcr:%"PRId64"(0x%09"PRIx64"))",
2714                     (int)((i-1)*100/p_sys->i_pcrs_num), (int)(i*100/p_sys->i_pcrs_num), p_sys->p_pcrs[i-1], p_sys->p_pcrs[i-1], p_sys->p_pcrs[i], p_sys->p_pcrs[i] );
2715         }
2716     }
2717     if( i < p_sys->i_pcrs_num )
2718     {
2719         msg_Dbg( p_demux, "Force Seek Per Percent: Seeking failed at %d%%.", (int)(i*100/p_sys->i_pcrs_num) );
2720         p_sys->b_force_seek_per_percent = true;
2721     }
2722
2723     stream_Seek( p_sys->stream, i_initial_pos );
2724     p_sys->i_current_pcr = i_initial_pcr;
2725 }
2726
2727 static void PCRHandle( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
2728 {
2729     demux_sys_t   *p_sys = p_demux->p_sys;
2730
2731     if( p_sys->i_pmt_es <= 0 )
2732         return;
2733
2734     mtime_t i_pcr = GetPCR( p_bk );
2735     if( i_pcr < 0 )
2736         return;
2737
2738     i_pcr = AdjustPCRWrapAround( p_demux, i_pcr );
2739
2740     if( p_sys->i_pid_ref_pcr == pid->i_pid )
2741         p_sys->i_current_pcr = i_pcr;
2742
2743     /* Search program and set the PCR */
2744     for( int i = 0; i < p_sys->i_pmt; i++ )
2745     {
2746         int i_group = -1;
2747         for( int i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
2748         {
2749             ts_prg_psi_t *p_prg = p_sys->pmt[i]->psi->prg[i_prg];
2750
2751             if( p_prg->i_pid_pcr == 0x1FFF ) /* That program has no dedicated PCR pid ISO/IEC 13818-1 2.4.4.9 */
2752             {
2753                 if( pid->p_owner ) /* PCR shall be on pid itself */
2754                 {
2755                     p_prg->i_pcr_value = i_pcr; /* ? update PCR for the whole group program */
2756                     i_group = p_prg->i_number;
2757                     p_sys->pcrfix.b_program_pcr_seen = true;
2758                     p_sys->pcrfix.i_first_dts = 0;
2759                     p_sys->b_disable_pcr = !p_sys->b_trust_pcr;
2760                 }
2761                 else
2762                 {
2763                     msg_Warn(p_demux, "discarding PCR update from pid %d which has no owner", pid->i_pid);
2764                 }
2765                 break;
2766             }
2767             else /* set PCR provided by current pid to program(s) referencing it */
2768             {
2769                 /* Can be dedicated PCR pid (no owned then) or another pid (owner == pmt) */
2770                 if( p_prg->i_pid_pcr == pid->i_pid ) /* If that program references current pid as PCR */
2771                 {
2772                     p_prg->i_pcr_value = i_pcr;
2773                     i_group = p_prg->i_number; /* We've found a target group for update */
2774                     p_sys->pcrfix.b_program_pcr_seen = true;
2775                     p_sys->pcrfix.i_first_dts = 0;
2776                     p_sys->b_disable_pcr = !p_sys->b_trust_pcr;
2777                 }
2778             }
2779         }
2780         if ( !p_sys->b_disable_pcr && i_group > 0 && p_sys->i_pmt_es )
2781         {
2782             es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
2783               i_group, VLC_TS_0 + i_pcr * 100 / 9 );
2784         }
2785     }
2786 }
2787
2788 static void PCRFixHandle( demux_t *p_demux, block_t *p_block )
2789 {
2790     demux_sys_t *p_sys = p_demux->p_sys;
2791     /* Record the first data packet timestamp in case there wont be any PCR */
2792     if( !p_sys->pcrfix.b_program_pcr_seen && !p_sys->b_disable_pcr )
2793     {
2794         if( !p_sys->pcrfix.i_first_dts )
2795         {
2796             p_sys->pcrfix.i_first_dts = p_block->i_dts;
2797         }
2798         else if( p_block->i_dts - p_sys->pcrfix.i_first_dts > CLOCK_FREQ / 10 ) /* "shall not exceed 100ms" */
2799         {
2800             p_sys->b_disable_pcr = true;
2801             msg_Warn( p_demux, "No PCR received for program %d, set up workaround",
2802                       p_sys->i_current_program );
2803         }
2804     }
2805 }
2806
2807 static bool GatherData( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
2808 {
2809     const uint8_t *p = p_bk->p_buffer;
2810     const bool b_unit_start = p[1]&0x40;
2811     const bool b_scrambled  = p[3]&0x80;
2812     const bool b_adaptation = p[3]&0x20;
2813     const bool b_payload    = p[3]&0x10;
2814     const int  i_cc         = p[3]&0x0f; /* continuity counter */
2815     bool       b_discontinuity = false;  /* discontinuity */
2816
2817     /* transport_scrambling_control is ignored */
2818     int         i_skip = 0;
2819     bool        i_ret  = false;
2820
2821 #if 0
2822     msg_Dbg( p_demux, "pid=%d unit_start=%d adaptation=%d payload=%d "
2823              "cc=0x%x", pid->i_pid, b_unit_start, b_adaptation,
2824              b_payload, i_cc );
2825 #endif
2826
2827     /* For now, ignore additional error correction
2828      * TODO: handle Reed-Solomon 204,188 error correction */
2829     p_bk->i_buffer = TS_PACKET_SIZE_188;
2830
2831     if( p[1]&0x80 )
2832     {
2833         msg_Dbg( p_demux, "transport_error_indicator set (pid=%d)",
2834                  pid->i_pid );
2835         if( pid->es->p_data ) //&& pid->es->fmt.i_cat == VIDEO_ES )
2836             pid->es->p_data->i_flags |= BLOCK_FLAG_CORRUPTED;
2837     }
2838
2839     if( p_demux->p_sys->csa )
2840     {
2841         vlc_mutex_lock( &p_demux->p_sys->csa_lock );
2842         csa_Decrypt( p_demux->p_sys->csa, p_bk->p_buffer, p_demux->p_sys->i_csa_pkt_size );
2843         vlc_mutex_unlock( &p_demux->p_sys->csa_lock );
2844     }
2845
2846     if( !b_adaptation )
2847     {
2848         /* We don't have any adaptation_field, so payload starts
2849          * immediately after the 4 byte TS header */
2850         i_skip = 4;
2851     }
2852     else
2853     {
2854         /* p[4] is adaptation_field_length minus one */
2855         i_skip = 5 + p[4];
2856         if( p[4] > 0 )
2857         {
2858             /* discontinuity indicator found in stream */
2859             b_discontinuity = (p[5]&0x80) ? true : false;
2860             if( b_discontinuity && pid->es->p_data )
2861             {
2862                 msg_Warn( p_demux, "discontinuity indicator (pid=%d) ",
2863                             pid->i_pid );
2864                 /* pid->es->p_data->i_flags |= BLOCK_FLAG_DISCONTINUITY; */
2865             }
2866 #if 0
2867             if( p[5]&0x40 )
2868                 msg_Dbg( p_demux, "random access indicator (pid=%d) ", pid->i_pid );
2869 #endif
2870         }
2871     }
2872
2873     /* Test continuity counter */
2874     /* continuous when (one of this):
2875         * diff == 1
2876         * diff == 0 and payload == 0
2877         * diff == 0 and duplicate packet (playload != 0) <- should we
2878         *   test the content ?
2879      */
2880     const int i_diff = ( i_cc - pid->i_cc )&0x0f;
2881     if( b_payload && i_diff == 1 )
2882     {
2883         pid->i_cc = ( pid->i_cc + 1 ) & 0xf;
2884     }
2885     else
2886     {
2887         if( pid->i_cc == 0xff )
2888         {
2889             msg_Warn( p_demux, "first packet for pid=%d cc=0x%x",
2890                       pid->i_pid, i_cc );
2891             pid->i_cc = i_cc;
2892         }
2893         else if( i_diff != 0 && !b_discontinuity )
2894         {
2895             msg_Warn( p_demux, "discontinuity received 0x%x instead of 0x%x (pid=%d)",
2896                       i_cc, ( pid->i_cc + 1 )&0x0f, pid->i_pid );
2897
2898             pid->i_cc = i_cc;
2899             if( pid->es->p_data && pid->es->fmt.i_cat != VIDEO_ES &&
2900                 pid->es->fmt.i_cat != AUDIO_ES )
2901             {
2902                 /* Small audio/video artifacts are usually better than
2903                  * dropping full frames */
2904                 pid->es->p_data->i_flags |= BLOCK_FLAG_CORRUPTED;
2905             }
2906         }
2907     }
2908
2909     PCRHandle( p_demux, pid, p_bk );
2910
2911     if( i_skip >= 188 || pid->es->id == NULL )
2912     {
2913         block_Release( p_bk );
2914         return i_ret;
2915     }
2916
2917     /* */
2918     if( !pid->b_scrambled != !b_scrambled )
2919     {
2920         msg_Warn( p_demux, "scrambled state changed on pid %d (%d->%d)",
2921                   pid->i_pid, pid->b_scrambled, b_scrambled );
2922
2923         pid->b_scrambled = b_scrambled;
2924
2925         for( int i = 0; i < pid->i_extra_es; i++ )
2926         {
2927             es_out_Control( p_demux->out, ES_OUT_SET_ES_SCRAMBLED_STATE,
2928                             pid->extra_es[i]->id, b_scrambled );
2929         }
2930         es_out_Control( p_demux->out, ES_OUT_SET_ES_SCRAMBLED_STATE,
2931                         pid->es->id, b_scrambled );
2932     }
2933
2934     /* We have to gather it */
2935     p_bk->p_buffer += i_skip;
2936     p_bk->i_buffer -= i_skip;
2937
2938     if( b_unit_start )
2939     {
2940         if( pid->es->data_type == TS_ES_DATA_TABLE_SECTION && p_bk->i_buffer > 0 )
2941         {
2942             int i_pointer_field = __MIN( p_bk->p_buffer[0], p_bk->i_buffer - 1 );
2943             block_t *p = block_Duplicate( p_bk );
2944             if( p )
2945             {
2946                 p->i_buffer = i_pointer_field;
2947                 p->p_buffer++;
2948                 block_ChainLastAppend( &pid->es->pp_last, p );
2949             }
2950             p_bk->i_buffer -= 1 + i_pointer_field;
2951             p_bk->p_buffer += 1 + i_pointer_field;
2952         }
2953         if( pid->es->p_data )
2954         {
2955             ParseData( p_demux, pid );
2956             i_ret = true;
2957         }
2958
2959         block_ChainLastAppend( &pid->es->pp_last, p_bk );
2960         if( pid->es->data_type == TS_ES_DATA_PES )
2961         {
2962             if( p_bk->i_buffer > 6 )
2963             {
2964                 pid->es->i_data_size = GetWBE( &p_bk->p_buffer[4] );
2965                 if( pid->es->i_data_size > 0 )
2966                 {
2967                     pid->es->i_data_size += 6;
2968                 }
2969             }
2970         }
2971         else if( pid->es->data_type == TS_ES_DATA_TABLE_SECTION )
2972         {
2973             if( p_bk->i_buffer > 3 && p_bk->p_buffer[0] != 0xff )
2974             {
2975                 pid->es->i_data_size = 3 + (((p_bk->p_buffer[1] & 0xf) << 8) | p_bk->p_buffer[2]);
2976             }
2977         }
2978         pid->es->i_data_gathered += p_bk->i_buffer;
2979         if( pid->es->i_data_size > 0 &&
2980             pid->es->i_data_gathered >= pid->es->i_data_size )
2981         {
2982             ParseData( p_demux, pid );
2983             i_ret = true;
2984         }
2985     }
2986     else
2987     {
2988         if( pid->es->p_data == NULL )
2989         {
2990             /* msg_Dbg( p_demux, "broken packet" ); */
2991             block_Release( p_bk );
2992         }
2993         else
2994         {
2995             block_ChainLastAppend( &pid->es->pp_last, p_bk );
2996             pid->es->i_data_gathered += p_bk->i_buffer;
2997
2998             if( pid->es->i_data_size > 0 &&
2999                 pid->es->i_data_gathered >= pid->es->i_data_size )
3000             {
3001                 ParseData( p_demux, pid );
3002                 i_ret = true;
3003             }
3004         }
3005     }
3006
3007     return i_ret;
3008 }
3009
3010 static void PIDFillFormat( es_format_t *fmt, int i_stream_type )
3011 {
3012     switch( i_stream_type )
3013     {
3014     case 0x01:  /* MPEG-1 video */
3015     case 0x02:  /* MPEG-2 video */
3016     case 0x80:  /* MPEG-2 MOTO video */
3017         es_format_Init( fmt, VIDEO_ES, VLC_CODEC_MPGV );
3018         break;
3019     case 0x03:  /* MPEG-1 audio */
3020     case 0x04:  /* MPEG-2 audio */
3021         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_MPGA );
3022         break;
3023     case 0x11:  /* MPEG4 (audio) LATM */
3024     case 0x0f:  /* ISO/IEC 13818-7 Audio with ADTS transport syntax */
3025     case 0x1c:  /* ISO/IEC 14496-3 Audio, without using any additional
3026                    transport syntax, such as DST, ALS and SLS */
3027         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_MP4A );
3028         break;
3029     case 0x10:  /* MPEG4 (video) */
3030         es_format_Init( fmt, VIDEO_ES, VLC_CODEC_MP4V );
3031         break;
3032     case 0x1B:  /* H264 <- check transport syntax/needed descriptor */
3033         es_format_Init( fmt, VIDEO_ES, VLC_CODEC_H264 );
3034         break;
3035     case 0x24:  /* HEVC */
3036         es_format_Init( fmt, VIDEO_ES, VLC_CODEC_HEVC );
3037         break;
3038     case 0x42:  /* CAVS (Chinese AVS) */
3039         es_format_Init( fmt, VIDEO_ES, VLC_CODEC_CAVS );
3040         break;
3041
3042     case 0x81:  /* A52 (audio) */
3043         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_A52 );
3044         break;
3045     case 0x82:  /* SCTE-27 (sub) */
3046         es_format_Init( fmt, SPU_ES, VLC_CODEC_SCTE_27 );
3047         break;
3048     case 0x84:  /* SDDS (audio) */
3049         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_SDDS );
3050         break;
3051     case 0x85:  /* DTS (audio) */
3052         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_DTS );
3053         break;
3054     case 0x87: /* E-AC3 */
3055         es_format_Init( fmt, AUDIO_ES, VLC_CODEC_EAC3 );
3056         break;
3057
3058     case 0x91:  /* A52 vls (audio) */
3059         es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', 'b' ) );
3060         break;
3061     case 0x92:  /* DVD_SPU vls (sub) */
3062         es_format_Init( fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', 'b' ) );
3063         break;
3064
3065     case 0x94:  /* SDDS (audio) */
3066         es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
3067         break;
3068
3069     case 0xa0:  /* MSCODEC vlc (video) (fixed later) */
3070         es_format_Init( fmt, UNKNOWN_ES, 0 );
3071         break;
3072
3073     case 0x06:  /* PES_PRIVATE  (fixed later) */
3074     case 0x12:  /* MPEG-4 generic (sub/scene/...) (fixed later) */
3075     case 0xEA:  /* Privately managed ES (VC-1) (fixed later */
3076     default:
3077         es_format_Init( fmt, UNKNOWN_ES, 0 );
3078         break;
3079     }
3080
3081     /* PES packets usually contain truncated frames */
3082     fmt->b_packetized = false;
3083 }
3084
3085 /*****************************************************************************
3086  * MP4 specific functions (IOD parser)
3087  *****************************************************************************/
3088 static int  IODDescriptorLength( int *pi_data, uint8_t **pp_data )
3089 {
3090     unsigned int i_b;
3091     unsigned int i_len = 0;
3092     do
3093     {
3094         i_b = **pp_data;
3095         (*pp_data)++;
3096         (*pi_data)--;
3097         i_len = ( i_len << 7 ) + ( i_b&0x7f );
3098
3099     } while( i_b&0x80 && *pi_data > 0 );
3100
3101     if (i_len > *pi_data)
3102         i_len = *pi_data;
3103
3104     return i_len;
3105 }
3106
3107 static int IODGetBytes( int *pi_data, uint8_t **pp_data, size_t bytes )
3108 {
3109     uint32_t res = 0;
3110     while( *pi_data > 0 && bytes-- )
3111     {
3112         res <<= 8;
3113         res |= **pp_data;
3114         (*pp_data)++;
3115         (*pi_data)--;
3116     }
3117
3118     return res;
3119 }
3120
3121 static char* IODGetURL( int *pi_data, uint8_t **pp_data )
3122 {
3123     int len = IODGetBytes( pi_data, pp_data, 1 );
3124     if (len > *pi_data)
3125         len = *pi_data;
3126     char *url = strndup( (char*)*pp_data, len );
3127     *pp_data += len;
3128     *pi_data -= len;
3129     return url;
3130 }
3131
3132 static iod_descriptor_t *IODNew( int i_data, uint8_t *p_data )
3133 {
3134     uint8_t i_iod_tag, i_iod_label, byte1, byte2, byte3;
3135
3136     iod_descriptor_t *p_iod = calloc( 1, sizeof( iod_descriptor_t ) );
3137     if( !p_iod )
3138         return NULL;
3139
3140     if( i_data < 3 )
3141     {
3142         return p_iod;
3143     }
3144
3145     byte1 = IODGetBytes( &i_data, &p_data, 1 );
3146     byte2 = IODGetBytes( &i_data, &p_data, 1 );
3147     byte3 = IODGetBytes( &i_data, &p_data, 1 );
3148     if( byte2 == 0x02 ) //old vlc's buggy implementation of the IOD_descriptor
3149     {
3150         i_iod_label = byte1;
3151         i_iod_tag = byte2;
3152     }
3153     else  //correct implementation of the IOD_descriptor
3154     {
3155         i_iod_label = byte2;
3156         i_iod_tag = byte3;
3157     }
3158
3159     ts_debug( "\n* iod label:%d tag:0x%x", i_iod_label, i_iod_tag );
3160
3161     if( i_iod_tag != 0x02 )
3162     {
3163         ts_debug( "\n ERR: tag %02x != 0x02", i_iod_tag );
3164         return p_iod;
3165     }
3166
3167     IODDescriptorLength( &i_data, &p_data );
3168
3169     uint16_t i_od_id = ( IODGetBytes( &i_data, &p_data, 1 ) << 2 );
3170     uint8_t i_flags = IODGetBytes( &i_data, &p_data, 1 );
3171     i_od_id |= i_flags >> 6;
3172     ts_debug( "\n* od_id:%d", i_od_id );
3173     ts_debug( "\n* includeInlineProfileLevel flag:%d", ( i_flags >> 4 )&0x01 );
3174     if ((i_flags >> 5) & 0x01)
3175     {
3176         p_iod->psz_url = IODGetURL( &i_data, &p_data );
3177         ts_debug( "\n* url string:%s", p_iod->psz_url );
3178         ts_debug( "\n*****************************\n" );
3179         return p_iod;
3180     }
3181     else
3182     {
3183         p_iod->psz_url = NULL;
3184     }
3185
3186     /* Profile Level Indication */
3187     IODGetBytes( &i_data, &p_data, 1 ); /* OD */
3188     IODGetBytes( &i_data, &p_data, 1 ); /* scene */
3189     IODGetBytes( &i_data, &p_data, 1 ); /* audio */
3190     IODGetBytes( &i_data, &p_data, 1 ); /* visual */
3191     IODGetBytes( &i_data, &p_data, 1 ); /* graphics */
3192
3193     int i_length = 0;
3194     int i_data_sav = i_data;
3195     uint8_t *p_data_sav = p_data;
3196     for (int i = 0; i_data > 0 && i < ES_DESCRIPTOR_COUNT; i++)
3197     {
3198         es_mpeg4_descriptor_t *es_descr = &p_iod->es_descr[i];
3199
3200         p_data = p_data_sav + i_length;
3201         i_data = i_data_sav - i_length;
3202
3203         int i_tag = IODGetBytes( &i_data, &p_data, 1 );
3204         i_length = IODDescriptorLength( &i_data, &p_data );
3205
3206         i_data_sav = i_data;
3207         p_data_sav = p_data;
3208
3209         i_data = i_length;
3210
3211         if ( i_tag != 0x03 )
3212         {
3213             ts_debug( "\n* - OD tag:0x%x Unsupported", i_tag );
3214             continue;
3215         }
3216
3217         es_descr->i_es_id = IODGetBytes( &i_data, &p_data, 2 );
3218         int i_flags = IODGetBytes( &i_data, &p_data, 1 );
3219         bool b_streamDependenceFlag = ( i_flags >> 7 )&0x01;
3220         if( b_streamDependenceFlag )
3221             IODGetBytes( &i_data, &p_data, 2 ); /* dependOn_es_id */
3222
3223         if( (i_flags >> 6) & 0x01 )
3224             es_descr->psz_url = IODGetURL( &i_data, &p_data );
3225
3226         bool b_OCRStreamFlag = ( i_flags >> 5 )&0x01;
3227         if( b_OCRStreamFlag )
3228             IODGetBytes( &i_data, &p_data, 2 ); /* OCR_es_id */
3229
3230         if( IODGetBytes( &i_data, &p_data, 1 ) != 0x04 )
3231         {
3232             ts_debug( "\n* ERR missing DecoderConfigDescr" );
3233             continue;
3234         }
3235         int i_config_desc_length = IODDescriptorLength( &i_data, &p_data ); /* DecoderConfigDescr_length */
3236         decoder_config_descriptor_t *dec_descr = &es_descr->dec_descr;
3237         dec_descr->i_objectTypeIndication = IODGetBytes( &i_data, &p_data, 1 );
3238         i_flags = IODGetBytes( &i_data, &p_data, 1 );
3239         dec_descr->i_streamType = i_flags >> 2;
3240
3241         IODGetBytes( &i_data, &p_data, 3); /* bufferSizeDB */
3242         IODGetBytes( &i_data, &p_data, 4); /* maxBitrate */
3243         IODGetBytes( &i_data, &p_data, 4 ); /* avgBitrate */
3244
3245         if( i_config_desc_length > 13 && IODGetBytes( &i_data, &p_data, 1 ) == 0x05 )
3246         {
3247             dec_descr->i_extra = IODDescriptorLength( &i_data, &p_data );
3248             if( dec_descr->i_extra > 0 )
3249             {
3250                 dec_descr->p_extra = xmalloc( dec_descr->i_extra );
3251                 memcpy(dec_descr->p_extra, p_data, dec_descr->i_extra);
3252                 p_data += dec_descr->i_extra;
3253                 i_data -= dec_descr->i_extra;
3254             }
3255         }
3256         else
3257         {
3258             dec_descr->i_extra = 0;
3259             dec_descr->p_extra = NULL;
3260         }
3261
3262         if( IODGetBytes( &i_data, &p_data, 1 ) != 0x06 )
3263         {
3264             ts_debug( "\n* ERR missing SLConfigDescr" );
3265             continue;
3266         }
3267         IODDescriptorLength( &i_data, &p_data ); /* SLConfigDescr_length */
3268         switch( IODGetBytes( &i_data, &p_data, 1 ) /* predefined */ )
3269         {
3270         default:
3271             ts_debug( "\n* ERR unsupported SLConfigDescr predefined" );
3272         case 0x01:
3273             // FIXME
3274             break;
3275         }
3276         es_descr->b_ok = true;
3277     }
3278
3279     return p_iod;
3280 }
3281
3282 static void IODFree( iod_descriptor_t *p_iod )
3283 {
3284     if( p_iod->psz_url )
3285     {
3286         free( p_iod->psz_url );
3287         free( p_iod );
3288         return;
3289     }
3290
3291     for( int i = 0; i < 255; i++ )
3292     {
3293 #define es_descr p_iod->es_descr[i]
3294         if( es_descr.b_ok )
3295         {
3296             if( es_descr.psz_url )
3297                 free( es_descr.psz_url );
3298             else
3299                 free( es_descr.dec_descr.p_extra );
3300         }
3301 #undef  es_descr
3302     }
3303     free( p_iod );
3304 }
3305
3306 /****************************************************************************
3307  ****************************************************************************
3308  ** libdvbpsi callbacks
3309  ****************************************************************************
3310  ****************************************************************************/
3311 static bool ProgramIsSelected( demux_t *p_demux, uint16_t i_pgrm )
3312 {
3313     demux_sys_t          *p_sys = p_demux->p_sys;
3314
3315     if( ( p_sys->i_current_program == -1 && p_sys->programs_list.i_count == 0 ) ||
3316         p_sys->i_current_program == 0 )
3317         return true;
3318     if( p_sys->i_current_program == i_pgrm )
3319         return true;
3320
3321     if( p_sys->programs_list.i_count != 0 )
3322     {
3323         for( int i = 0; i < p_sys->programs_list.i_count; i++ )
3324         {
3325             if( i_pgrm == p_sys->programs_list.p_values[i].i_int )
3326                 return true;
3327         }
3328     }
3329     return false;
3330 }
3331
3332 static void ValidateDVBMeta( demux_t *p_demux, int i_pid )
3333 {
3334     demux_sys_t *p_sys = p_demux->p_sys;
3335
3336     if( !p_sys->b_dvb_meta || ( i_pid != 0x11 && i_pid != 0x12 && i_pid != 0x14 ) )
3337         return;
3338
3339     msg_Warn( p_demux, "Switching to non DVB mode" );
3340
3341     /* This doesn't look like a DVB stream so don't try
3342      * parsing the SDT/EDT/TDT */
3343
3344     for( int i = 0x11; i <= 0x14; i++ )
3345     {
3346         if( i == 0x13 ) continue;
3347         ts_pid_t *p_pid = &p_sys->pid[i];
3348         if( p_pid->psi )
3349         {
3350
3351 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3352             if( dvbpsi_decoder_present( p_pid->psi->handle ))
3353                 dvbpsi_DetachDemux( p_pid->psi->handle );
3354             dvbpsi_delete( p_pid->psi->handle );
3355 #else
3356             dvbpsi_DetachDemux( p_pid->psi->handle );
3357 #endif
3358             free( p_pid->psi );
3359             p_pid->psi = NULL;
3360             p_pid->b_valid = false;
3361         }
3362         SetPIDFilter( p_demux, i, false );
3363     }
3364     p_sys->b_dvb_meta = false;
3365 }
3366
3367 #include "dvb-text.h"
3368
3369 static char *EITConvertToUTF8( demux_t *p_demux,
3370                                const unsigned char *psz_instring,
3371                                size_t i_length,
3372                                bool b_broken )
3373 {
3374     demux_sys_t *p_sys = p_demux->p_sys;
3375 #ifdef HAVE_ARIBB24
3376     if( p_sys->arib.e_mode == ARIBMODE_ENABLED )
3377     {
3378         if ( !p_sys->arib.p_instance )
3379             p_sys->arib.p_instance = arib_instance_new( p_demux );
3380         if ( !p_sys->arib.p_instance )
3381             return NULL;
3382         arib_decoder_t *p_decoder = arib_get_decoder( p_sys->arib.p_instance );
3383         if ( !p_decoder )
3384             return NULL;
3385
3386         char *psz_outstring = NULL;
3387         size_t i_out;
3388
3389         i_out = i_length * 4;
3390         psz_outstring = (char*) calloc( i_out + 1, sizeof(char) );
3391         if( !psz_outstring )
3392             return NULL;
3393
3394         arib_initialize_decoder( p_decoder );
3395         i_out = arib_decode_buffer( p_decoder, psz_instring, i_length,
3396                                     psz_outstring, i_out );
3397         arib_finalize_decoder( p_decoder );
3398
3399         return psz_outstring;
3400     }
3401 #else
3402     VLC_UNUSED(p_sys);
3403 #endif
3404     /* Deal with no longer broken providers (no switch byte
3405       but sending ISO_8859-1 instead of ISO_6937) without
3406       removing them from the broken providers table
3407       (keep the entry for correctly handling recorded TS).
3408     */
3409     b_broken = b_broken && i_length && *psz_instring > 0x20;
3410
3411     if( b_broken )
3412         return FromCharset( "ISO_8859-1", psz_instring, i_length );
3413     return vlc_from_EIT( psz_instring, i_length );
3414 }
3415
3416 static void SDTCallBack( demux_t *p_demux, dvbpsi_sdt_t *p_sdt )
3417 {
3418     demux_sys_t          *p_sys = p_demux->p_sys;
3419     ts_pid_t             *sdt = &p_sys->pid[0x11];
3420     dvbpsi_sdt_service_t *p_srv;
3421
3422     msg_Dbg( p_demux, "SDTCallBack called" );
3423
3424     if( sdt->psi->i_sdt_version != -1 &&
3425         ( !p_sdt->b_current_next ||
3426           p_sdt->i_version == sdt->psi->i_sdt_version ) )
3427     {
3428         dvbpsi_DeleteSDT( p_sdt );
3429         return;
3430     }
3431
3432     msg_Dbg( p_demux, "new SDT ts_id=%d version=%d current_next=%d "
3433              "network_id=%d",
3434 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3435              p_sdt->i_extension,
3436 #else
3437              p_sdt->i_ts_id,
3438 #endif
3439              p_sdt->i_version, p_sdt->b_current_next,
3440              p_sdt->i_network_id );
3441
3442     p_sys->b_broken_charset = false;
3443
3444     for( p_srv = p_sdt->p_first_service; p_srv; p_srv = p_srv->p_next )
3445     {
3446         vlc_meta_t          *p_meta;
3447         dvbpsi_descriptor_t *p_dr;
3448
3449         const char *psz_type = NULL;
3450         const char *psz_status = NULL;
3451
3452         msg_Dbg( p_demux, "  * service id=%d eit schedule=%d present=%d "
3453                  "running=%d free_ca=%d",
3454                  p_srv->i_service_id, p_srv->b_eit_schedule,
3455                  p_srv->b_eit_present, p_srv->i_running_status,
3456                  p_srv->b_free_ca );
3457
3458         if( p_sys->vdr.i_service && p_srv->i_service_id != p_sys->vdr.i_service )
3459         {
3460             msg_Dbg( p_demux, "  * service id=%d skipped (not declared in vdr header)",
3461                      p_sys->vdr.i_service );
3462             continue;
3463         }
3464
3465         p_meta = vlc_meta_New();
3466         for( p_dr = p_srv->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
3467         {
3468             if( p_dr->i_tag == 0x48 )
3469             {
3470                 static const char *ppsz_type[17] = {
3471                     "Reserved",
3472                     "Digital television service",
3473                     "Digital radio sound service",
3474                     "Teletext service",
3475                     "NVOD reference service",
3476                     "NVOD time-shifted service",
3477                     "Mosaic service",
3478                     "PAL coded signal",
3479                     "SECAM coded signal",
3480                     "D/D2-MAC",
3481                     "FM Radio",
3482                     "NTSC coded signal",
3483                     "Data broadcast service",
3484                     "Reserved for Common Interface Usage",
3485                     "RCS Map (see EN 301 790 [35])",
3486                     "RCS FLS (see EN 301 790 [35])",
3487                     "DVB MHP service"
3488                 };
3489                 dvbpsi_service_dr_t *pD = dvbpsi_DecodeServiceDr( p_dr );
3490                 char *str1 = NULL;
3491                 char *str2 = NULL;
3492
3493                 /* Workarounds for broadcasters with broken EPG */
3494
3495                 if( p_sdt->i_network_id == 133 )
3496                     p_sys->b_broken_charset = true;  /* SKY DE & BetaDigital use ISO8859-1 */
3497
3498                 /* List of providers using ISO8859-1 */
3499                 static const char ppsz_broken_providers[][8] = {
3500                     "CSAT",     /* CanalSat FR */
3501                     "GR1",      /* France televisions */
3502                     "MULTI4",   /* NT1 */
3503                     "MR5",      /* France 2/M6 HD */
3504                     ""
3505                 };
3506                 for( int i = 0; *ppsz_broken_providers[i]; i++ )
3507                 {
3508                     const size_t i_length = strlen(ppsz_broken_providers[i]);
3509                     if( pD->i_service_provider_name_length == i_length &&
3510                         !strncmp( (char *)pD->i_service_provider_name, ppsz_broken_providers[i], i_length ) )
3511                         p_sys->b_broken_charset = true;
3512                 }
3513
3514                 /* FIXME: Digital+ ES also uses ISO8859-1 */
3515
3516                 str1 = EITConvertToUTF8(p_demux,
3517                                         pD->i_service_provider_name,
3518                                         pD->i_service_provider_name_length,
3519                                         p_sys->b_broken_charset );
3520                 str2 = EITConvertToUTF8(p_demux,
3521                                         pD->i_service_name,
3522                                         pD->i_service_name_length,
3523                                         p_sys->b_broken_charset );
3524
3525                 msg_Dbg( p_demux, "    - type=%d provider=%s name=%s",
3526                          pD->i_service_type, str1, str2 );
3527
3528                 vlc_meta_SetTitle( p_meta, str2 );
3529                 vlc_meta_SetPublisher( p_meta, str1 );
3530                 if( pD->i_service_type >= 0x01 && pD->i_service_type <= 0x10 )
3531                     psz_type = ppsz_type[pD->i_service_type];
3532                 free( str1 );
3533                 free( str2 );
3534             }
3535         }
3536
3537         if( p_srv->i_running_status >= 0x01 && p_srv->i_running_status <= 0x04 )
3538         {
3539             static const char *ppsz_status[5] = {
3540                 "Unknown",
3541                 "Not running",
3542                 "Starts in a few seconds",
3543                 "Pausing",
3544                 "Running"
3545             };
3546             psz_status = ppsz_status[p_srv->i_running_status];
3547         }
3548
3549         if( psz_type )
3550             vlc_meta_AddExtra( p_meta, "Type", psz_type );
3551         if( psz_status )
3552             vlc_meta_AddExtra( p_meta, "Status", psz_status );
3553
3554         es_out_Control( p_demux->out, ES_OUT_SET_GROUP_META,
3555                         p_srv->i_service_id, p_meta );
3556         vlc_meta_Delete( p_meta );
3557     }
3558
3559     sdt->psi->i_sdt_version = p_sdt->i_version;
3560     dvbpsi_DeleteSDT( p_sdt );
3561 }
3562
3563 /* i_year: year - 1900  i_month: 0-11  i_mday: 1-31 i_hour: 0-23 i_minute: 0-59 i_second: 0-59 */
3564 static int64_t vlc_timegm( int i_year, int i_month, int i_mday, int i_hour, int i_minute, int i_second )
3565 {
3566     static const int pn_day[12+1] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
3567     int64_t i_day;
3568
3569     if( i_year < 70 ||
3570         i_month < 0 || i_month > 11 || i_mday < 1 || i_mday > 31 ||
3571         i_hour < 0 || i_hour > 23 || i_minute < 0 || i_minute > 59 || i_second < 0 || i_second > 59 )
3572         return -1;
3573
3574     /* Count the number of days */
3575     i_day = 365 * (i_year-70) + pn_day[i_month] + i_mday - 1;
3576 #define LEAP(y) ( ((y)%4) == 0 && (((y)%100) != 0 || ((y)%400) == 0) ? 1 : 0)
3577     for( int i = 70; i < i_year; i++ )
3578         i_day += LEAP(1900+i);
3579     if( i_month > 1 )
3580         i_day += LEAP(1900+i_year);
3581 #undef LEAP
3582     /**/
3583     return ((24*i_day + i_hour)*60 + i_minute)*60 + i_second;
3584 }
3585
3586 static void EITDecodeMjd( int i_mjd, int *p_y, int *p_m, int *p_d )
3587 {
3588     const int yp = (int)( ( (double)i_mjd - 15078.2)/365.25 );
3589     const int mp = (int)( ((double)i_mjd - 14956.1 - (int)(yp * 365.25)) / 30.6001 );
3590     const int c = ( mp == 14 || mp == 15 ) ? 1 : 0;
3591
3592     *p_y = 1900 + yp + c*1;
3593     *p_m = mp - 1 - c*12;
3594     *p_d = i_mjd - 14956 - (int)(yp*365.25) - (int)(mp*30.6001);
3595 }
3596 #define CVT_FROM_BCD(v) ((((v) >> 4)&0xf)*10 + ((v)&0xf))
3597 static int64_t EITConvertStartTime( uint64_t i_date )
3598 {
3599     const int i_mjd = i_date >> 24;
3600     const int i_hour   = CVT_FROM_BCD(i_date >> 16);
3601     const int i_minute = CVT_FROM_BCD(i_date >>  8);
3602     const int i_second = CVT_FROM_BCD(i_date      );
3603     int i_year;
3604     int i_month;
3605     int i_day;
3606
3607     /* if all 40 bits are 1, the start is unknown */
3608     if( i_date == UINT64_C(0xffffffffff) )
3609         return -1;
3610
3611     EITDecodeMjd( i_mjd, &i_year, &i_month, &i_day );
3612     return vlc_timegm( i_year - 1900, i_month - 1, i_day, i_hour, i_minute, i_second );
3613 }
3614 static int EITConvertDuration( uint32_t i_duration )
3615 {
3616     return CVT_FROM_BCD(i_duration >> 16) * 3600 +
3617            CVT_FROM_BCD(i_duration >> 8 ) * 60 +
3618            CVT_FROM_BCD(i_duration      );
3619 }
3620 #undef CVT_FROM_BCD
3621
3622 static void TDTCallBack( demux_t *p_demux, dvbpsi_tot_t *p_tdt )
3623 {
3624     demux_sys_t        *p_sys = p_demux->p_sys;
3625
3626     p_sys->i_tdt_delta = CLOCK_FREQ * EITConvertStartTime( p_tdt->i_utc_time )
3627                          - mdate();
3628     dvbpsi_DeleteTOT(p_tdt);
3629 }
3630
3631
3632 static void EITCallBack( demux_t *p_demux,
3633                          dvbpsi_eit_t *p_eit, bool b_current_following )
3634 {
3635     demux_sys_t        *p_sys = p_demux->p_sys;
3636     dvbpsi_eit_event_t *p_evt;
3637     vlc_epg_t *p_epg;
3638
3639     msg_Dbg( p_demux, "EITCallBack called" );
3640     if( !p_eit->b_current_next )
3641     {
3642         dvbpsi_DeleteEIT( p_eit );
3643         return;
3644     }
3645
3646     msg_Dbg( p_demux, "new EIT service_id=%d version=%d current_next=%d "
3647              "ts_id=%d network_id=%d segment_last_section_number=%d "
3648              "last_table_id=%d",
3649 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3650              p_eit->i_extension,
3651 #else
3652              p_eit->i_service_id,
3653 #endif
3654              p_eit->i_version, p_eit->b_current_next,
3655              p_eit->i_ts_id, p_eit->i_network_id,
3656              p_eit->i_segment_last_section_number, p_eit->i_last_table_id );
3657
3658     p_epg = vlc_epg_New( NULL );
3659     for( p_evt = p_eit->p_first_event; p_evt; p_evt = p_evt->p_next )
3660     {
3661         dvbpsi_descriptor_t *p_dr;
3662         char                *psz_name = NULL;
3663         char                *psz_text = NULL;
3664         char                *psz_extra = strdup("");
3665         int64_t i_start;
3666         int i_duration;
3667         int i_min_age = 0;
3668         int64_t i_tot_time = 0;
3669
3670         i_start = EITConvertStartTime( p_evt->i_start_time );
3671         i_duration = EITConvertDuration( p_evt->i_duration );
3672
3673         if( p_sys->arib.e_mode == ARIBMODE_ENABLED )
3674         {
3675             if( p_sys->i_tdt_delta == 0 )
3676                 p_sys->i_tdt_delta = CLOCK_FREQ * (i_start + i_duration - 5) - mdate();
3677
3678             i_tot_time = (mdate() + p_sys->i_tdt_delta) / CLOCK_FREQ;
3679
3680             tzset(); // JST -> UTC
3681             i_start += timezone; // FIXME: what about DST?
3682             i_tot_time += timezone;
3683
3684             if( p_evt->i_running_status == 0x00 &&
3685                 (i_start - 5 < i_tot_time &&
3686                  i_tot_time < i_start + i_duration + 5) )
3687             {
3688                 p_evt->i_running_status = 0x04;
3689                 msg_Dbg( p_demux, "  EIT running status 0x00 -> 0x04" );
3690             }
3691         }
3692
3693         msg_Dbg( p_demux, "  * event id=%d start_time:%d duration=%d "
3694                           "running=%d free_ca=%d",
3695                  p_evt->i_event_id, (int)i_start, (int)i_duration,
3696                  p_evt->i_running_status, p_evt->b_free_ca );
3697
3698         for( p_dr = p_evt->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
3699         {
3700             switch(p_dr->i_tag)
3701             {
3702             case 0x4d:
3703             {
3704                 dvbpsi_short_event_dr_t *pE = dvbpsi_DecodeShortEventDr( p_dr );
3705
3706                 /* Only take first description, as we don't handle language-info
3707                    for epg atm*/
3708                 if( pE && psz_name == NULL )
3709                 {
3710                     psz_name = EITConvertToUTF8( p_demux,
3711                                                  pE->i_event_name, pE->i_event_name_length,
3712                                                  p_sys->b_broken_charset );
3713                     free( psz_text );
3714                     psz_text = EITConvertToUTF8( p_demux,
3715                                                  pE->i_text, pE->i_text_length,
3716                                                  p_sys->b_broken_charset );
3717                     msg_Dbg( p_demux, "    - short event lang=%3.3s '%s' : '%s'",
3718                              pE->i_iso_639_code, psz_name, psz_text );
3719                 }
3720             }
3721                 break;
3722
3723             case 0x4e:
3724             {
3725                 dvbpsi_extended_event_dr_t *pE = dvbpsi_DecodeExtendedEventDr( p_dr );
3726                 if( pE )
3727                 {
3728                     msg_Dbg( p_demux, "    - extended event lang=%3.3s [%d/%d]",
3729                              pE->i_iso_639_code,
3730                              pE->i_descriptor_number, pE->i_last_descriptor_number );
3731
3732                     if( pE->i_text_length > 0 )
3733                     {
3734                         char *psz_text = EITConvertToUTF8( p_demux,
3735                                                            pE->i_text, pE->i_text_length,
3736                                                            p_sys->b_broken_charset );
3737                         if( psz_text )
3738                         {
3739                             msg_Dbg( p_demux, "       - text='%s'", psz_text );
3740
3741                             psz_extra = xrealloc( psz_extra,
3742                                    strlen(psz_extra) + strlen(psz_text) + 1 );
3743                             strcat( psz_extra, psz_text );
3744                             free( psz_text );
3745                         }
3746                     }
3747
3748                     for( int i = 0; i < pE->i_entry_count; i++ )
3749                     {
3750                         char *psz_dsc = EITConvertToUTF8( p_demux,
3751                                                           pE->i_item_description[i],
3752                                                           pE->i_item_description_length[i],
3753                                                           p_sys->b_broken_charset );
3754                         char *psz_itm = EITConvertToUTF8( p_demux,
3755                                                           pE->i_item[i], pE->i_item_length[i],
3756                                                           p_sys->b_broken_charset );
3757
3758                         if( psz_dsc && psz_itm )
3759                         {
3760                             msg_Dbg( p_demux, "       - desc='%s' item='%s'", psz_dsc, psz_itm );
3761 #if 0
3762                             psz_extra = xrealloc( psz_extra,
3763                                          strlen(psz_extra) + strlen(psz_dsc) +
3764                                          strlen(psz_itm) + 3 + 1 );
3765                             strcat( psz_extra, "(" );
3766                             strcat( psz_extra, psz_dsc );
3767                             strcat( psz_extra, " " );
3768                             strcat( psz_extra, psz_itm );
3769                             strcat( psz_extra, ")" );
3770 #endif
3771                         }
3772                         free( psz_dsc );
3773                         free( psz_itm );
3774                     }
3775                 }
3776             }
3777                 break;
3778
3779             case 0x55:
3780             {
3781                 dvbpsi_parental_rating_dr_t *pR = dvbpsi_DecodeParentalRatingDr( p_dr );
3782                 if ( pR )
3783                 {
3784                     for ( int i = 0; i < pR->i_ratings_number; i++ )
3785                     {
3786                         const dvbpsi_parental_rating_t *p_rating = & pR->p_parental_rating[ i ];
3787                         if ( p_rating->i_rating > 0x00 && p_rating->i_rating <= 0x0F )
3788                         {
3789                             if ( p_rating->i_rating + 3 > i_min_age )
3790                                 i_min_age = p_rating->i_rating + 3;
3791                             msg_Dbg( p_demux, "    - parental control set to %d years",
3792                                      i_min_age );
3793                         }
3794                     }
3795                 }
3796             }
3797                 break;
3798
3799             default:
3800                 msg_Dbg( p_demux, "    - event unknown dr 0x%x(%d)", p_dr->i_tag, p_dr->i_tag );
3801                 break;
3802             }
3803         }
3804
3805         /* */
3806         if( i_start > 0 && psz_name && psz_text)
3807             vlc_epg_AddEvent( p_epg, i_start, i_duration, psz_name, psz_text,
3808                               *psz_extra ? psz_extra : NULL, i_min_age );
3809
3810         /* Update "now playing" field */
3811         if( p_evt->i_running_status == 0x04 && i_start > 0  && psz_name && psz_text )
3812             vlc_epg_SetCurrent( p_epg, i_start );
3813
3814         free( psz_name );
3815         free( psz_text );
3816
3817         free( psz_extra );
3818     }
3819     if( p_epg->i_event > 0 )
3820     {
3821         if( b_current_following &&
3822             (  p_sys->i_current_program == -1 ||
3823                p_sys->i_current_program ==
3824 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3825                     p_eit->i_extension
3826 #else
3827                     p_eit->i_service_id
3828 #endif
3829                 ) )
3830         {
3831             p_sys->i_dvb_length = 0;
3832             p_sys->i_dvb_start = 0;
3833
3834             if( p_epg->p_current )
3835             {
3836                 p_sys->i_dvb_start = CLOCK_FREQ * p_epg->p_current->i_start;
3837                 p_sys->i_dvb_length = CLOCK_FREQ * p_epg->p_current->i_duration;
3838             }
3839         }
3840         es_out_Control( p_demux->out, ES_OUT_SET_GROUP_EPG,
3841 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3842                         p_eit->i_extension,
3843 #else
3844                         p_eit->i_service_id,
3845 #endif
3846                         p_epg );
3847     }
3848     vlc_epg_Delete( p_epg );
3849
3850     dvbpsi_DeleteEIT( p_eit );
3851 }
3852 static void EITCallBackCurrentFollowing( demux_t *p_demux, dvbpsi_eit_t *p_eit )
3853 {
3854     EITCallBack( p_demux, p_eit, true );
3855 }
3856 static void EITCallBackSchedule( demux_t *p_demux, dvbpsi_eit_t *p_eit )
3857 {
3858     EITCallBack( p_demux, p_eit, false );
3859 }
3860
3861 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3862 static void PSINewTableCallBack( dvbpsi_t *h, uint8_t i_table_id,
3863                                  uint16_t i_extension, demux_t *p_demux )
3864 #else
3865 static void PSINewTableCallBack( demux_t *p_demux, dvbpsi_handle h,
3866                                  uint8_t  i_table_id, uint16_t i_extension )
3867 #endif
3868 {
3869     assert( h );
3870 #if 0
3871     msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3872              i_table_id, i_table_id, i_extension, i_extension );
3873 #endif
3874     if( p_demux->p_sys->pid[0].psi->i_pat_version != -1 && i_table_id == 0x42 )
3875     {
3876         msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3877                  i_table_id, i_table_id, i_extension, i_extension );
3878 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3879         if( !dvbpsi_sdt_attach( h, i_table_id, i_extension, (dvbpsi_sdt_callback)SDTCallBack, p_demux ) )
3880             msg_Err( p_demux, "PSINewTableCallback: failed attaching SDTCallback" );
3881 #else
3882         dvbpsi_AttachSDT( h, i_table_id, i_extension,
3883                           (dvbpsi_sdt_callback)SDTCallBack, p_demux );
3884 #endif
3885     }
3886     else if( p_demux->p_sys->pid[0x11].psi->i_sdt_version != -1 &&
3887              ( i_table_id == 0x4e || /* Current/Following */
3888                (i_table_id >= 0x50 && i_table_id <= 0x5f) ) ) /* Schedule */
3889     {
3890         msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3891                  i_table_id, i_table_id, i_extension, i_extension );
3892
3893         dvbpsi_eit_callback cb = i_table_id == 0x4e ?
3894                                     (dvbpsi_eit_callback)EITCallBackCurrentFollowing :
3895                                     (dvbpsi_eit_callback)EITCallBackSchedule;
3896 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3897         if( !dvbpsi_eit_attach( h, i_table_id, i_extension, cb, p_demux ) )
3898             msg_Err( p_demux, "PSINewTableCallback: failed attaching EITCallback" );
3899 #else
3900         dvbpsi_AttachEIT( h, i_table_id, i_extension, cb, p_demux );
3901 #endif
3902     }
3903     else if( p_demux->p_sys->pid[0x11].psi->i_sdt_version != -1 &&
3904             (i_table_id == 0x70 /* TDT */ || i_table_id == 0x73 /* TOT */) )
3905     {
3906          msg_Dbg( p_demux, "PSINewTableCallBack: table 0x%x(%d) ext=0x%x(%d)",
3907                  i_table_id, i_table_id, i_extension, i_extension );
3908 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
3909         if( !dvbpsi_tot_attach( h, i_table_id, i_extension, (dvbpsi_tot_callback)TDTCallBack, p_demux ) )
3910             msg_Err( p_demux, "PSINewTableCallback: failed attaching TDTCallback" );
3911 #else
3912          dvbpsi_AttachTOT( h, i_table_id, i_extension,
3913                            (dvbpsi_tot_callback)TDTCallBack, p_demux);
3914 #endif
3915     }
3916 }
3917
3918 /*****************************************************************************
3919  * PMT callback and helpers
3920  *****************************************************************************/
3921 static dvbpsi_descriptor_t *PMTEsFindDescriptor( const dvbpsi_pmt_es_t *p_es,
3922                                                  int i_tag )
3923 {
3924     dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
3925     while( p_dr && ( p_dr->i_tag != i_tag ) )
3926         p_dr = p_dr->p_next;
3927     return p_dr;
3928 }
3929 static bool PMTEsHasRegistration( demux_t *p_demux,
3930                                   const dvbpsi_pmt_es_t *p_es,
3931                                   const char *psz_tag )
3932 {
3933     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x05 );
3934     if( !p_dr )
3935         return false;
3936
3937     if( p_dr->i_length < 4 )
3938     {
3939         msg_Warn( p_demux, "invalid Registration Descriptor" );
3940         return false;
3941     }
3942
3943     assert( strlen(psz_tag) == 4 );
3944     return !memcmp( p_dr->p_data, psz_tag, 4 );
3945 }
3946
3947 static bool PMTEsHasComponentTag( const dvbpsi_pmt_es_t *p_es,
3948                                   int i_component_tag )
3949 {
3950     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x52 );
3951     if( !p_dr )
3952         return false;
3953     dvbpsi_stream_identifier_dr_t *p_si = dvbpsi_DecodeStreamIdentifierDr( p_dr );
3954     if( !p_si )
3955         return false;
3956
3957     return p_si->i_component_tag == i_component_tag;
3958 }
3959
3960 static void PMTSetupEsISO14496( demux_t *p_demux, ts_pid_t *pid,
3961                                 const ts_prg_psi_t *prg, const dvbpsi_pmt_es_t *p_es )
3962 {
3963     es_format_t *p_fmt = &pid->es->fmt;
3964
3965     /* MPEG-4 stream: search FMC_DESCRIPTOR (SL Packetized stream) */
3966     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x1f );
3967
3968     if( p_dr && p_dr->i_length == 2 )
3969     {
3970         const int i_es_id = ( p_dr->p_data[0] << 8 ) | p_dr->p_data[1];
3971
3972         msg_Dbg( p_demux, "found FMC_descriptor declaring sl packetization on es_id=%d", i_es_id );
3973
3974         pid->es->p_mpeg4desc = NULL;
3975
3976         for( int i = 0; i < ES_DESCRIPTOR_COUNT; i++ )
3977         {
3978             iod_descriptor_t *iod = prg->iod;
3979             if( iod->es_descr[i].i_es_id == i_es_id )
3980             {
3981                 if ( iod->es_descr[i].b_ok )
3982                     pid->es->p_mpeg4desc = &iod->es_descr[i];
3983                 else
3984                     msg_Dbg( p_demux, "MPEG-4 descriptor not yet available on es_id=%d", i_es_id );
3985                 break;
3986             }
3987         }
3988     }
3989     if( !pid->es->p_mpeg4desc )
3990     {
3991         switch( p_es->i_type )
3992         {
3993         /* non fatal, set by packetizer */
3994         case 0x0f: /* ADTS */
3995         case 0x11: /* LOAS */
3996             msg_Info( p_demux, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
3997                       pid->i_pid, p_es->i_type );
3998             break;
3999         default:
4000             msg_Err( p_demux, "MPEG-4 descriptor not found for pid 0x%x type 0x%x",
4001                      pid->i_pid, p_es->i_type );
4002             break;
4003         }
4004         return;
4005     }
4006
4007     const decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
4008     if( dcd->i_streamType == 0x04 )    /* VisualStream */
4009     {
4010         p_fmt->i_cat = VIDEO_ES;
4011         switch( dcd->i_objectTypeIndication )
4012         {
4013         case 0x0B: /* mpeg4 sub */
4014             p_fmt->i_cat = SPU_ES;
4015             p_fmt->i_codec = VLC_CODEC_SUBT;
4016             break;
4017
4018         case 0x20: /* mpeg4 */
4019             p_fmt->i_codec = VLC_CODEC_MP4V;
4020             break;
4021         case 0x21: /* h264 */
4022             p_fmt->i_codec = VLC_CODEC_H264;
4023             break;
4024         case 0x60:
4025         case 0x61:
4026         case 0x62:
4027         case 0x63:
4028         case 0x64:
4029         case 0x65: /* mpeg2 */
4030             p_fmt->i_codec = VLC_CODEC_MPGV;
4031             break;
4032         case 0x6a: /* mpeg1 */
4033             p_fmt->i_codec = VLC_CODEC_MPGV;
4034             break;
4035         case 0x6c: /* mpeg1 */
4036             p_fmt->i_codec = VLC_CODEC_JPEG;
4037             break;
4038         default:
4039             p_fmt->i_cat = UNKNOWN_ES;
4040             break;
4041         }
4042     }
4043     else if( dcd->i_streamType == 0x05 )    /* AudioStream */
4044     {
4045         p_fmt->i_cat = AUDIO_ES;
4046         switch( dcd->i_objectTypeIndication )
4047         {
4048         case 0x40: /* mpeg4 */
4049             p_fmt->i_codec = VLC_CODEC_MP4A;
4050             break;
4051         case 0x66:
4052         case 0x67:
4053         case 0x68: /* mpeg2 aac */
4054             p_fmt->i_codec = VLC_CODEC_MP4A;
4055             break;
4056         case 0x69: /* mpeg2 */
4057             p_fmt->i_codec = VLC_CODEC_MPGA;
4058             break;
4059         case 0x6b: /* mpeg1 */
4060             p_fmt->i_codec = VLC_CODEC_MPGA;
4061             break;
4062         default:
4063             p_fmt->i_cat = UNKNOWN_ES;
4064             break;
4065         }
4066     }
4067     else
4068     {
4069         p_fmt->i_cat = UNKNOWN_ES;
4070     }
4071
4072     if( p_fmt->i_cat != UNKNOWN_ES )
4073     {
4074         p_fmt->i_extra = dcd->i_extra;
4075         if( p_fmt->i_extra > 0 )
4076         {
4077             p_fmt->p_extra = malloc( p_fmt->i_extra );
4078             if( p_fmt->p_extra )
4079                 memcpy( p_fmt->p_extra, dcd->p_extra, p_fmt->i_extra );
4080             else
4081                 p_fmt->i_extra = 0;
4082         }
4083     }
4084 }
4085
4086 typedef struct
4087 {
4088     int  i_type;
4089     int  i_magazine;
4090     int  i_page;
4091     char p_iso639[3];
4092 } ts_teletext_page_t;
4093
4094 static void PMTSetupEsTeletext( demux_t *p_demux, ts_pid_t *pid,
4095                                 const dvbpsi_pmt_es_t *p_es )
4096 {
4097     es_format_t *p_fmt = &pid->es->fmt;
4098
4099     ts_teletext_page_t p_page[2 * 64 + 20];
4100     unsigned i_page = 0;
4101
4102     /* Gather pages information */
4103 #if defined _DVBPSI_DR_56_H_ && \
4104     defined DVBPSI_VERSION && DVBPSI_VERSION_INT > DVBPSI_VERSION_WANTED(0,1,5)
4105     for( unsigned i_tag_idx = 0; i_tag_idx < 2; i_tag_idx++ )
4106     {
4107         dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, i_tag_idx == 0 ? 0x46 : 0x56 );
4108         if( !p_dr )
4109             continue;
4110
4111         dvbpsi_teletext_dr_t *p_sub = dvbpsi_DecodeTeletextDr( p_dr );
4112         if( !p_sub )
4113             continue;
4114
4115         for( int i = 0; i < p_sub->i_pages_number; i++ )
4116         {
4117             const dvbpsi_teletextpage_t *p_src = &p_sub->p_pages[i];
4118
4119             if( p_src->i_teletext_type >= 0x06 )
4120                 continue;
4121
4122             assert( i_page < sizeof(p_page)/sizeof(*p_page) );
4123
4124             ts_teletext_page_t *p_dst = &p_page[i_page++];
4125
4126             p_dst->i_type = p_src->i_teletext_type;
4127             p_dst->i_magazine = p_src->i_teletext_magazine_number
4128                 ? p_src->i_teletext_magazine_number : 8;
4129             p_dst->i_page = p_src->i_teletext_page_number;
4130             memcpy( p_dst->p_iso639, p_src->i_iso6392_language_code, 3 );
4131         }
4132     }
4133 #endif
4134
4135     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
4136     if( p_dr )
4137     {
4138         dvbpsi_subtitling_dr_t *p_sub = dvbpsi_DecodeSubtitlingDr( p_dr );
4139         for( int i = 0; p_sub && i < p_sub->i_subtitles_number; i++ )
4140         {
4141             dvbpsi_subtitle_t *p_src = &p_sub->p_subtitle[i];
4142
4143             if( p_src->i_subtitling_type < 0x01 || p_src->i_subtitling_type > 0x03 )
4144                 continue;
4145
4146             assert( i_page < sizeof(p_page)/sizeof(*p_page) );
4147
4148             ts_teletext_page_t *p_dst = &p_page[i_page++];
4149
4150             switch( p_src->i_subtitling_type )
4151             {
4152             case 0x01:
4153                 p_dst->i_type = 0x02;
4154                 break;
4155             default:
4156                 p_dst->i_type = 0x03;
4157                 break;
4158             }
4159             /* FIXME check if it is the right split */
4160             p_dst->i_magazine = (p_src->i_composition_page_id >> 8)
4161                 ? (p_src->i_composition_page_id >> 8) : 8;
4162             p_dst->i_page = p_src->i_composition_page_id & 0xff;
4163             memcpy( p_dst->p_iso639, p_src->i_iso6392_language_code, 3 );
4164         }
4165     }
4166
4167     /* */
4168     es_format_Init( p_fmt, SPU_ES, VLC_CODEC_TELETEXT );
4169
4170     if( !p_demux->p_sys->b_split_es || i_page <= 0 )
4171     {
4172         p_fmt->subs.teletext.i_magazine = -1;
4173         p_fmt->subs.teletext.i_page = 0;
4174         p_fmt->psz_description = strdup( vlc_gettext(ppsz_teletext_type[1]) );
4175
4176         dvbpsi_descriptor_t *p_dr;
4177         p_dr = PMTEsFindDescriptor( p_es, 0x46 );
4178         if( !p_dr )
4179             p_dr = PMTEsFindDescriptor( p_es, 0x56 );
4180
4181         if( !p_demux->p_sys->b_split_es && p_dr && p_dr->i_length > 0 )
4182         {
4183             /* Descriptor pass-through */
4184             p_fmt->p_extra = malloc( p_dr->i_length );
4185             if( p_fmt->p_extra )
4186             {
4187                 p_fmt->i_extra = p_dr->i_length;
4188                 memcpy( p_fmt->p_extra, p_dr->p_data, p_dr->i_length );
4189             }
4190         }
4191     }
4192     else
4193     {
4194         for( unsigned i = 0; i < i_page; i++ )
4195         {
4196             ts_es_t *p_es;
4197
4198             /* */
4199             if( i == 0 )
4200             {
4201                 p_es = pid->es;
4202             }
4203             else
4204             {
4205                 p_es = malloc( sizeof(*p_es) );
4206                 if( !p_es )
4207                     break;
4208
4209                 es_format_Copy( &p_es->fmt, &pid->es->fmt );
4210                 free( p_es->fmt.psz_language );
4211                 free( p_es->fmt.psz_description );
4212                 p_es->fmt.psz_language = NULL;
4213                 p_es->fmt.psz_description = NULL;
4214
4215                 p_es->id      = NULL;
4216                 p_es->p_data  = NULL;
4217                 p_es->i_data_size = 0;
4218                 p_es->i_data_gathered = 0;
4219                 p_es->pp_last = &p_es->p_data;
4220                 p_es->data_type = TS_ES_DATA_PES;
4221                 p_es->p_mpeg4desc = NULL;
4222
4223                 TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
4224             }
4225
4226             /* */
4227             const ts_teletext_page_t *p = &p_page[i];
4228             p_es->fmt.i_priority = (p->i_type == 0x02 || p->i_type == 0x05) ?
4229                       ES_PRIORITY_SELECTABLE_MIN : ES_PRIORITY_NOT_DEFAULTABLE;
4230             p_es->fmt.psz_language = strndup( p->p_iso639, 3 );
4231             p_es->fmt.psz_description = strdup(vlc_gettext(ppsz_teletext_type[p->i_type]));
4232             p_es->fmt.subs.teletext.i_magazine = p->i_magazine;
4233             p_es->fmt.subs.teletext.i_page = p->i_page;
4234
4235             msg_Dbg( p_demux,
4236                          "    * ttxt type=%s lan=%s page=%d%02x",
4237                          p_es->fmt.psz_description,
4238                          p_es->fmt.psz_language,
4239                          p->i_magazine, p->i_page );
4240         }
4241     }
4242 }
4243 static void PMTSetupEsDvbSubtitle( demux_t *p_demux, ts_pid_t *pid,
4244                                    const dvbpsi_pmt_es_t *p_es )
4245 {
4246     es_format_t *p_fmt = &pid->es->fmt;
4247
4248     es_format_Init( p_fmt, SPU_ES, VLC_CODEC_DVBS );
4249
4250     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x59 );
4251     int i_page = 0;
4252     dvbpsi_subtitling_dr_t *p_sub = dvbpsi_DecodeSubtitlingDr( p_dr );
4253     for( int i = 0; p_sub && i < p_sub->i_subtitles_number; i++ )
4254     {
4255         const int i_type = p_sub->p_subtitle[i].i_subtitling_type;
4256         if( ( i_type >= 0x10 && i_type <= 0x14 ) ||
4257             ( i_type >= 0x20 && i_type <= 0x24 ) )
4258             i_page++;
4259     }
4260
4261     if( !p_demux->p_sys->b_split_es  || i_page <= 0 )
4262     {
4263         p_fmt->subs.dvb.i_id = -1;
4264         p_fmt->psz_description = strdup( _("DVB subtitles") );
4265
4266         if( !p_demux->p_sys->b_split_es && p_dr && p_dr->i_length > 0 )
4267         {
4268             /* Descriptor pass-through */
4269             p_fmt->p_extra = malloc( p_dr->i_length );
4270             if( p_fmt->p_extra )
4271             {
4272                 p_fmt->i_extra = p_dr->i_length;
4273                 memcpy( p_fmt->p_extra, p_dr->p_data, p_dr->i_length );
4274             }
4275         }
4276     }
4277     else
4278     {
4279         for( int i = 0; i < p_sub->i_subtitles_number; i++ )
4280         {
4281             ts_es_t *p_es;
4282
4283             /* */
4284             if( i == 0 )
4285             {
4286                 p_es = pid->es;
4287             }
4288             else
4289             {
4290                 p_es = malloc( sizeof(*p_es) );
4291                 if( !p_es )
4292                     break;
4293
4294                 es_format_Copy( &p_es->fmt, &pid->es->fmt );
4295                 free( p_es->fmt.psz_language );
4296                 free( p_es->fmt.psz_description );
4297                 p_es->fmt.psz_language = NULL;
4298                 p_es->fmt.psz_description = NULL;
4299
4300                 p_es->id      = NULL;
4301                 p_es->p_data   = NULL;
4302                 p_es->i_data_size = 0;
4303                 p_es->i_data_gathered = 0;
4304                 p_es->pp_last = &p_es->p_data;
4305                 p_es->data_type = TS_ES_DATA_PES;
4306                 p_es->p_mpeg4desc = NULL;
4307
4308                 TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
4309             }
4310
4311             /* */
4312             const dvbpsi_subtitle_t *p = &p_sub->p_subtitle[i];
4313             p_es->fmt.psz_language = strndup( (char *)p->i_iso6392_language_code, 3 );
4314             switch( p->i_subtitling_type )
4315             {
4316             case 0x10: /* unspec. */
4317             case 0x11: /* 4:3 */
4318             case 0x12: /* 16:9 */
4319             case 0x13: /* 2.21:1 */
4320             case 0x14: /* HD monitor */
4321                 p_es->fmt.psz_description = strdup( _("DVB subtitles") );
4322                 break;
4323             case 0x20: /* Hearing impaired unspec. */
4324             case 0x21: /* h.i. 4:3 */
4325             case 0x22: /* h.i. 16:9 */
4326             case 0x23: /* h.i. 2.21:1 */
4327             case 0x24: /* h.i. HD monitor */
4328                 p_es->fmt.psz_description = strdup( _("DVB subtitles: hearing impaired") );
4329                 break;
4330             default:
4331                 break;
4332             }
4333
4334             /* Hack, FIXME */
4335             p_es->fmt.subs.dvb.i_id = ( p->i_composition_page_id <<  0 ) |
4336                                       ( p->i_ancillary_page_id   << 16 );
4337         }
4338     }
4339 }
4340
4341 static int vlc_ceil_log2( const unsigned int val )
4342 {
4343     int n = 31 - clz(val);
4344     if ((1U << n) != val)
4345         n++;
4346
4347     return n;
4348 }
4349
4350 static void OpusSetup(demux_t *demux, uint8_t *p, size_t len, es_format_t *p_fmt)
4351 {
4352     OpusHeader h;
4353
4354     /* default mapping */
4355     static const unsigned char map[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
4356     memcpy(h.stream_map, map, sizeof(map));
4357
4358     int csc, mapping;
4359     int channels = 0;
4360     int stream_count = 0;
4361     int ccc = p[1]; // channel_config_code
4362     if (ccc <= 8) {
4363         channels = ccc;
4364         if (channels)
4365             mapping = channels > 2;
4366         else {
4367             mapping = 255;
4368             channels = 2; // dual mono
4369         }
4370         static const uint8_t p_csc[8] = { 0, 1, 1, 2, 2, 2, 3, 3 };
4371         csc = p_csc[channels - 1];
4372         stream_count = channels - csc;
4373
4374         static const uint8_t map[6][7] = {
4375             { 2,1 },
4376             { 1,2,3 },
4377             { 4,1,2,3 },
4378             { 4,1,2,3,5 },
4379             { 4,1,2,3,5,6 },
4380             { 6,1,2,3,4,5,7 },
4381         };
4382         if (channels > 2)
4383             memcpy(&h.stream_map[1], map[channels-3], channels - 1);
4384     } else if (ccc == 0x81) {
4385         if (len < 4)
4386             goto explicit_config_too_short;
4387
4388         channels = p[2];
4389         mapping = p[3];
4390         csc = 0;
4391         if (mapping) {
4392             bs_t s;
4393             bs_init(&s, &p[4], len - 4);
4394             stream_count = 1;
4395             if (channels) {
4396                 int bits = vlc_ceil_log2(channels);
4397                 if (s.i_left < bits)
4398                     goto explicit_config_too_short;
4399                 stream_count = bs_read(&s, bits) + 1;
4400                 bits = vlc_ceil_log2(stream_count + 1);
4401                 if (s.i_left < bits)
4402                     goto explicit_config_too_short;
4403                 csc = bs_read(&s, bits);
4404             }
4405             int channel_bits = vlc_ceil_log2(stream_count + csc + 1);
4406             if (s.i_left < channels * channel_bits)
4407                 goto explicit_config_too_short;
4408
4409             unsigned char silence = (1U << (stream_count + csc + 1)) - 1;
4410             for (int i = 0; i < channels; i++) {
4411                 unsigned char m = bs_read(&s, channel_bits);
4412                 if (m == silence)
4413                     m = 0xff;
4414                 h.stream_map[i] = m;
4415             }
4416         }
4417     } else if (ccc >= 0x80 && ccc <= 0x88) {
4418         channels = ccc - 0x80;
4419         if (channels)
4420             mapping = 1;
4421         else {
4422             mapping = 255;
4423             channels = 2; // dual mono
4424         }
4425         csc = 0;
4426         stream_count = channels;
4427     } else {
4428         msg_Err(demux, "Opus channel configuration 0x%.2x is reserved", ccc);
4429     }
4430
4431     if (!channels) {
4432         msg_Err(demux, "Opus channel configuration 0x%.2x not supported yet", p[1]);
4433         return;
4434     }
4435
4436     opus_prepare_header(channels, 0, &h);
4437     h.preskip = 0;
4438     h.input_sample_rate = 48000;
4439     h.nb_coupled = csc;
4440     h.nb_streams = channels - csc;
4441     h.channel_mapping = mapping;
4442
4443     if (h.channels) {
4444         opus_write_header((uint8_t**)&p_fmt->p_extra, &p_fmt->i_extra, &h, NULL /* FIXME */);
4445         if (p_fmt->p_extra) {
4446             p_fmt->i_cat = AUDIO_ES;
4447             p_fmt->i_codec = VLC_CODEC_OPUS;
4448             p_fmt->audio.i_channels = h.channels;
4449             p_fmt->audio.i_rate = 48000;
4450         }
4451     }
4452
4453     return;
4454
4455 explicit_config_too_short:
4456     msg_Err(demux, "Opus descriptor too short");
4457 }
4458
4459 static void PMTSetupEs0x06( demux_t *p_demux, ts_pid_t *pid,
4460                             const dvbpsi_pmt_es_t *p_es )
4461 {
4462     es_format_t *p_fmt = &pid->es->fmt;
4463     dvbpsi_descriptor_t *p_subs_dr = PMTEsFindDescriptor( p_es, 0x59 );
4464     dvbpsi_descriptor_t *desc;
4465
4466     if( PMTEsHasRegistration( p_demux, p_es, "AC-3" ) ||
4467         PMTEsFindDescriptor( p_es, 0x6a ) ||
4468         PMTEsFindDescriptor( p_es, 0x81 ) )
4469     {
4470         p_fmt->i_cat = AUDIO_ES;
4471         p_fmt->i_codec = VLC_CODEC_A52;
4472     }
4473     else if( (desc = PMTEsFindDescriptor( p_es, 0x7f ) ) && desc->i_length >= 2 &&
4474               PMTEsHasRegistration(p_demux, p_es, "Opus"))
4475     {
4476         OpusSetup(p_demux, desc->p_data, desc->i_length, p_fmt);
4477     }
4478     else if( PMTEsFindDescriptor( p_es, 0x7a ) )
4479     {
4480         /* DVB with stream_type 0x06 (ETS EN 300 468) */
4481         p_fmt->i_cat = AUDIO_ES;
4482         p_fmt->i_codec = VLC_CODEC_EAC3;
4483     }
4484     else if( PMTEsHasRegistration( p_demux, p_es, "DTS1" ) ||
4485              PMTEsHasRegistration( p_demux, p_es, "DTS2" ) ||
4486              PMTEsHasRegistration( p_demux, p_es, "DTS3" ) ||
4487              PMTEsFindDescriptor( p_es, 0x73 ) )
4488     {
4489         /*registration descriptor(ETSI TS 101 154 Annex F)*/
4490         p_fmt->i_cat = AUDIO_ES;
4491         p_fmt->i_codec = VLC_CODEC_DTS;
4492     }
4493     else if( PMTEsHasRegistration( p_demux, p_es, "BSSD" ) && !p_subs_dr )
4494     {
4495         /* BSSD is AES3 DATA, but could also be subtitles
4496          * we need to check for secondary descriptor then s*/
4497         p_fmt->i_cat = AUDIO_ES;
4498         p_fmt->b_packetized = true;
4499         p_fmt->i_codec = VLC_CODEC_302M;
4500     }
4501     else if( PMTEsHasRegistration( p_demux, p_es, "HEVC" ) )
4502     {
4503         p_fmt->i_cat = VIDEO_ES;
4504         p_fmt->i_codec = VLC_CODEC_HEVC;
4505     }
4506     else if ( p_demux->p_sys->arib.e_mode == ARIBMODE_ENABLED )
4507     {
4508         /* Lookup our data component descriptor first ARIB STD B10 6.4 */
4509         dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0xFD );
4510         /* and check that it maps to something ARIB STD B14 Table 5.1/5.2 */
4511         if ( p_dr && p_dr->i_length >= 2 )
4512         {
4513             if( !memcmp( p_dr->p_data, "\x00\x08", 2 ) &&  (
4514                     PMTEsHasComponentTag( p_es, 0x30 ) ||
4515                     PMTEsHasComponentTag( p_es, 0x31 ) ||
4516                     PMTEsHasComponentTag( p_es, 0x32 ) ||
4517                     PMTEsHasComponentTag( p_es, 0x33 ) ||
4518                     PMTEsHasComponentTag( p_es, 0x34 ) ||
4519                     PMTEsHasComponentTag( p_es, 0x35 ) ||
4520                     PMTEsHasComponentTag( p_es, 0x36 ) ||
4521                     PMTEsHasComponentTag( p_es, 0x37 ) ) )
4522             {
4523                 es_format_Init( &pid->es->fmt, SPU_ES, VLC_CODEC_ARIB_A );
4524                 p_fmt->psz_language = strndup ( "jpn", 3 );
4525                 p_fmt->psz_description = strdup( _("ARIB subtitles") );
4526             }
4527             else if( !memcmp( p_dr->p_data, "\x00\x12", 2 ) && (
4528                      PMTEsHasComponentTag( p_es, 0x87 ) ||
4529                      PMTEsHasComponentTag( p_es, 0x88 ) ) )
4530             {
4531                 es_format_Init( &pid->es->fmt, SPU_ES, VLC_CODEC_ARIB_C );
4532                 p_fmt->psz_language = strndup ( "jpn", 3 );
4533                 p_fmt->psz_description = strdup( _("ARIB subtitles") );
4534             }
4535         }
4536     }
4537     else
4538     {
4539         /* Subtitle/Teletext/VBI fallbacks */
4540         dvbpsi_subtitling_dr_t *p_sub;
4541         if( p_subs_dr && ( p_sub = dvbpsi_DecodeSubtitlingDr( p_subs_dr ) ) )
4542         {
4543             for( int i = 0; i < p_sub->i_subtitles_number; i++ )
4544             {
4545                 if( p_fmt->i_cat != UNKNOWN_ES )
4546                     break;
4547
4548                 switch( p_sub->p_subtitle[i].i_subtitling_type )
4549                 {
4550                 case 0x01: /* EBU Teletext subtitles */
4551                 case 0x02: /* Associated EBU Teletext */
4552                 case 0x03: /* VBI data */
4553                     PMTSetupEsTeletext( p_demux, pid, p_es );
4554                     break;
4555                 case 0x10: /* DVB Subtitle (normal) with no monitor AR critical */
4556                 case 0x11: /*                 ...   on 4:3 AR monitor */
4557                 case 0x12: /*                 ...   on 16:9 AR monitor */
4558                 case 0x13: /*                 ...   on 2.21:1 AR monitor */
4559                 case 0x14: /*                 ...   for display on a high definition monitor */
4560                 case 0x20: /* DVB Subtitle (impaired) with no monitor AR critical */
4561                 case 0x21: /*                 ...   on 4:3 AR monitor */
4562                 case 0x22: /*                 ...   on 16:9 AR monitor */
4563                 case 0x23: /*                 ...   on 2.21:1 AR monitor */
4564                 case 0x24: /*                 ...   for display on a high definition monitor */
4565                     PMTSetupEsDvbSubtitle( p_demux, pid, p_es );
4566                     break;
4567                 default:
4568                     msg_Err( p_demux, "Unrecognized DVB subtitle type (0x%x)",
4569                              p_sub->p_subtitle[i].i_subtitling_type );
4570                     break;
4571                 }
4572             }
4573         }
4574
4575         if( p_fmt->i_cat == UNKNOWN_ES &&
4576             ( PMTEsFindDescriptor( p_es, 0x45 ) ||  /* VBI Data descriptor */
4577               PMTEsFindDescriptor( p_es, 0x46 ) ||  /* VBI Teletext descriptor */
4578               PMTEsFindDescriptor( p_es, 0x56 ) ) ) /* EBU Teletext descriptor */
4579         {
4580             /* Teletext/VBI */
4581             PMTSetupEsTeletext( p_demux, pid, p_es );
4582         }
4583     }
4584
4585     /* FIXME is it useful ? */
4586     if( PMTEsFindDescriptor( p_es, 0x52 ) )
4587     {
4588         dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x52 );
4589         dvbpsi_stream_identifier_dr_t *p_si = dvbpsi_DecodeStreamIdentifierDr( p_dr );
4590
4591         msg_Dbg( p_demux, "    * Stream Component Identifier: %d", p_si->i_component_tag );
4592     }
4593 }
4594
4595 static void PMTSetupEs0xEA( demux_t *p_demux, ts_pid_t *pid,
4596                            const dvbpsi_pmt_es_t *p_es )
4597 {
4598     /* Registration Descriptor */
4599     if( !PMTEsHasRegistration( p_demux, p_es, "VC-1" ) )
4600     {
4601         msg_Err( p_demux, "Registration descriptor not found or invalid" );
4602         return;
4603     }
4604
4605     es_format_t *p_fmt = &pid->es->fmt;
4606
4607     /* registration descriptor for VC-1 (SMPTE rp227) */
4608     p_fmt->i_cat = VIDEO_ES;
4609     p_fmt->i_codec = VLC_CODEC_VC1;
4610
4611     /* XXX With Simple and Main profile the SEQUENCE
4612      * header is modified: video width and height are
4613      * inserted just after the start code as 2 int16_t
4614      * The packetizer will take care of that. */
4615 }
4616
4617 static void PMTSetupEs0xD1( demux_t *p_demux, ts_pid_t *pid,
4618                            const dvbpsi_pmt_es_t *p_es )
4619 {
4620     /* Registration Descriptor */
4621     if( !PMTEsHasRegistration( p_demux, p_es, "drac" ) )
4622     {
4623         msg_Err( p_demux, "Registration descriptor not found or invalid" );
4624         return;
4625     }
4626
4627     es_format_t *p_fmt = &pid->es->fmt;
4628
4629     /* registration descriptor for Dirac
4630      * (backwards compatable with VC-2 (SMPTE Sxxxx:2008)) */
4631     p_fmt->i_cat = VIDEO_ES;
4632     p_fmt->i_codec = VLC_CODEC_DIRAC;
4633 }
4634
4635 static void PMTSetupEs0xA0( demux_t *p_demux, ts_pid_t *pid,
4636                            const dvbpsi_pmt_es_t *p_es )
4637 {
4638     /* MSCODEC sent by vlc */
4639     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0xa0 );
4640     if( !p_dr || p_dr->i_length < 10 )
4641     {
4642         msg_Warn( p_demux,
4643                   "private MSCODEC (vlc) without bih private descriptor" );
4644         return;
4645     }
4646
4647     es_format_t *p_fmt = &pid->es->fmt;
4648     p_fmt->i_cat = VIDEO_ES;
4649     p_fmt->i_codec = VLC_FOURCC( p_dr->p_data[0], p_dr->p_data[1],
4650                                  p_dr->p_data[2], p_dr->p_data[3] );
4651     p_fmt->video.i_width = GetWBE( &p_dr->p_data[4] );
4652     p_fmt->video.i_height = GetWBE( &p_dr->p_data[6] );
4653     p_fmt->i_extra = GetWBE( &p_dr->p_data[8] );
4654
4655     if( p_fmt->i_extra > 0 )
4656     {
4657         p_fmt->p_extra = malloc( p_fmt->i_extra );
4658         if( p_fmt->p_extra )
4659             memcpy( p_fmt->p_extra, &p_dr->p_data[10],
4660                     __MIN( p_fmt->i_extra, p_dr->i_length - 10 ) );
4661         else
4662             p_fmt->i_extra = 0;
4663     }
4664     /* For such stream we will gather them ourself and don't launch a
4665      * packetizer.
4666      * Yes it's ugly but it's the only way to have DIV3 working */
4667     p_fmt->b_packetized = true;
4668 }
4669
4670 static void PMTSetupEs0x83( const dvbpsi_pmt_t *p_pmt, ts_pid_t *pid )
4671 {
4672     /* WiDi broadcasts without registration on PMT 0x1, PCR 0x1000 and
4673      * with audio track pid being 0x1100..0x11FF */
4674     if ( p_pmt->i_program_number == 0x1 &&
4675          p_pmt->i_pcr_pid == 0x1000 &&
4676         ( pid->i_pid >> 8 ) == 0x11 )
4677     {
4678         /* Not enough ? might contain 0x83 private descriptor, 2 bytes 0x473F */
4679         es_format_Init( &pid->es->fmt, AUDIO_ES, VLC_CODEC_WIDI_LPCM );
4680     }
4681     else
4682         es_format_Init( &pid->es->fmt, AUDIO_ES, VLC_CODEC_DVD_LPCM );
4683 }
4684
4685 static bool PMTSetupEsHDMV( demux_t *p_demux, ts_pid_t *pid,
4686                             const dvbpsi_pmt_es_t *p_es )
4687 {
4688     es_format_t *p_fmt = &pid->es->fmt;
4689
4690     /* Blu-Ray mapping */
4691     switch( p_es->i_type )
4692     {
4693     case 0x80:
4694         p_fmt->i_cat = AUDIO_ES;
4695         p_fmt->i_codec = VLC_CODEC_BD_LPCM;
4696         break;
4697     case 0x81:
4698         p_fmt->i_cat = AUDIO_ES;
4699         p_fmt->i_codec = VLC_CODEC_A52;
4700         break;
4701     case 0x82:
4702     case 0x85: /* DTS-HD High resolution audio */
4703     case 0x86: /* DTS-HD Master audio */
4704     case 0xA2: /* Secondary DTS audio */
4705         p_fmt->i_cat = AUDIO_ES;
4706         p_fmt->i_codec = VLC_CODEC_DTS;
4707         break;
4708
4709     case 0x83: /* TrueHD AC3 */
4710         p_fmt->i_cat = AUDIO_ES;
4711         p_fmt->i_codec = VLC_CODEC_TRUEHD;
4712         break;
4713
4714     case 0x84: /* E-AC3 */
4715     case 0xA1: /* Secondary E-AC3 */
4716         p_fmt->i_cat = AUDIO_ES;
4717         p_fmt->i_codec = VLC_CODEC_EAC3;
4718         break;
4719     case 0x90: /* Presentation graphics */
4720         p_fmt->i_cat = SPU_ES;
4721         p_fmt->i_codec = VLC_CODEC_BD_PG;
4722         break;
4723     case 0x91: /* Interactive graphics */
4724     case 0x92: /* Subtitle */
4725         return false;
4726     case 0xEA:
4727         p_fmt->i_cat = VIDEO_ES;
4728         p_fmt->i_codec = VLC_CODEC_VC1;
4729         break;
4730     default:
4731         msg_Info( p_demux, "HDMV registration not implemented for pid 0x%x type 0x%x",
4732                   p_es->i_pid, p_es->i_type );
4733         return false;
4734         break;
4735     }
4736     return true;
4737 }
4738
4739 static bool PMTSetupEsRegistration( demux_t *p_demux, ts_pid_t *pid,
4740                                     const dvbpsi_pmt_es_t *p_es )
4741 {
4742     static const struct
4743     {
4744         char         psz_tag[5];
4745         int          i_cat;
4746         vlc_fourcc_t i_codec;
4747     } p_regs[] = {
4748         { "AC-3", AUDIO_ES, VLC_CODEC_A52   },
4749         { "DTS1", AUDIO_ES, VLC_CODEC_DTS   },
4750         { "DTS2", AUDIO_ES, VLC_CODEC_DTS   },
4751         { "DTS3", AUDIO_ES, VLC_CODEC_DTS   },
4752         { "BSSD", AUDIO_ES, VLC_CODEC_302M  },
4753         { "VC-1", VIDEO_ES, VLC_CODEC_VC1   },
4754         { "drac", VIDEO_ES, VLC_CODEC_DIRAC },
4755         { "", UNKNOWN_ES, 0 }
4756     };
4757     es_format_t *p_fmt = &pid->es->fmt;
4758
4759     for( int i = 0; p_regs[i].i_cat != UNKNOWN_ES; i++ )
4760     {
4761         if( PMTEsHasRegistration( p_demux, p_es, p_regs[i].psz_tag ) )
4762         {
4763             p_fmt->i_cat   = p_regs[i].i_cat;
4764             p_fmt->i_codec = p_regs[i].i_codec;
4765             if (p_es->i_type == 0x87)
4766                 p_fmt->i_codec = VLC_CODEC_EAC3;
4767             return true;
4768         }
4769     }
4770     return false;
4771 }
4772
4773 static char *GetAudioTypeDesc(demux_t *p_demux, int type)
4774 {
4775     static const char *audio_type[] = {
4776         NULL,
4777         N_("clean effects"),
4778         N_("hearing impaired"),
4779         N_("visual impaired commentary"),
4780     };
4781
4782     if (type < 0 || type > 3)
4783         msg_Dbg( p_demux, "unknown audio type: %d", type);
4784     else if (type > 0)
4785         return strdup(audio_type[type]);
4786
4787     return NULL;
4788 }
4789 static void PMTParseEsIso639( demux_t *p_demux, ts_pid_t *pid,
4790                               const dvbpsi_pmt_es_t *p_es )
4791 {
4792     /* get language descriptor */
4793     dvbpsi_descriptor_t *p_dr = PMTEsFindDescriptor( p_es, 0x0a );
4794
4795     if( !p_dr )
4796         return;
4797
4798     dvbpsi_iso639_dr_t *p_decoded = dvbpsi_DecodeISO639Dr( p_dr );
4799     if( !p_decoded )
4800     {
4801         msg_Err( p_demux, "Failed to decode a ISO 639 descriptor" );
4802         return;
4803     }
4804
4805 #if defined(DR_0A_API_VER) && (DR_0A_API_VER >= 2)
4806     pid->es->fmt.psz_language = malloc( 4 );
4807     if( pid->es->fmt.psz_language )
4808     {
4809         memcpy( pid->es->fmt.psz_language, p_decoded->code[0].iso_639_code, 3 );
4810         pid->es->fmt.psz_language[3] = 0;
4811         msg_Dbg( p_demux, "found language: %s", pid->es->fmt.psz_language);
4812     }
4813     int type = p_decoded->code[0].i_audio_type;
4814     pid->es->fmt.psz_description = GetAudioTypeDesc(p_demux, type);
4815     if (type == 0)
4816         pid->es->fmt.i_priority = ES_PRIORITY_SELECTABLE_MIN + 1; // prioritize normal audio tracks
4817
4818     pid->es->fmt.i_extra_languages = p_decoded->i_code_count-1;
4819     if( pid->es->fmt.i_extra_languages > 0 )
4820         pid->es->fmt.p_extra_languages =
4821             malloc( sizeof(*pid->es->fmt.p_extra_languages) *
4822                     pid->es->fmt.i_extra_languages );
4823     if( pid->es->fmt.p_extra_languages )
4824     {
4825         for( int i = 0; i < pid->es->fmt.i_extra_languages; i++ )
4826         {
4827             pid->es->fmt.p_extra_languages[i].psz_language = malloc(4);
4828             if( pid->es->fmt.p_extra_languages[i].psz_language )
4829             {
4830                 memcpy( pid->es->fmt.p_extra_languages[i].psz_language,
4831                     p_decoded->code[i+1].iso_639_code, 3 );
4832                 pid->es->fmt.p_extra_languages[i].psz_language[3] = '\0';
4833             }
4834             int type = p_decoded->code[i].i_audio_type;
4835             pid->es->fmt.p_extra_languages[i].psz_description = GetAudioTypeDesc(p_demux, type);
4836         }
4837     }
4838 #else
4839     pid->es->fmt.psz_language = malloc( 4 );
4840     if( pid->es->fmt.psz_language )
4841     {
4842         memcpy( pid->es->fmt.psz_language,
4843                 p_decoded->i_iso_639_code, 3 );
4844         pid->es->fmt.psz_language[3] = 0;
4845     }
4846 #endif
4847 }
4848
4849 static void AddAndCreateES( demux_t *p_demux, ts_pid_t *pid )
4850 {
4851     demux_sys_t  *p_sys = p_demux->p_sys;
4852     bool b_create_delayed = false;
4853
4854     if( pid )
4855     {
4856         if( pid->b_seen && p_sys->b_delay_es_creation )
4857         {
4858             p_sys->b_delay_es_creation = false;
4859             b_create_delayed = true;
4860         }
4861
4862         if( !p_sys->b_delay_es_creation )
4863         {
4864             pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
4865             for( int i = 0; i < pid->i_extra_es; i++ )
4866             {
4867                 pid->extra_es[i]->id =
4868                     es_out_Add( p_demux->out, &pid->extra_es[i]->fmt );
4869             }
4870             p_sys->i_pmt_es += 1 + pid->i_extra_es;
4871         }
4872     }
4873     else if( p_sys->b_delay_es_creation )
4874     {
4875         p_sys->b_delay_es_creation = false;
4876         b_create_delayed = true;
4877     }
4878
4879     if( b_create_delayed )
4880     {
4881         for(int i=MIN_ES_PID; i<MAX_ES_PID; i++)
4882         {
4883             pid = &p_sys->pid[i];
4884             if(!pid->es || pid->es->id)
4885                 continue;
4886             pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
4887             for( int j = 0; j < pid->i_extra_es; j++ )
4888             {
4889                 pid->extra_es[j]->id =
4890                     es_out_Add( p_demux->out, &pid->extra_es[j]->fmt );
4891             }
4892             p_sys->i_pmt_es += 1 + pid->i_extra_es;
4893         }
4894     }
4895 }
4896
4897 static void PMTCallBack( void *data, dvbpsi_pmt_t *p_pmt )
4898 {
4899     demux_t      *p_demux = data;
4900     demux_sys_t  *p_sys = p_demux->p_sys;
4901
4902     ts_pid_t     *pmt = NULL;
4903     ts_prg_psi_t *prg;
4904
4905     msg_Dbg( p_demux, "PMTCallBack called" );
4906
4907     /* First find this PMT declared in PAT */
4908     for( int i = 0; !pmt && i < p_sys->i_pmt; i++ )
4909         for( int i_prg = 0; !pmt && i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
4910         {
4911             const int i_pmt_number = p_sys->pmt[i]->psi->prg[i_prg]->i_number;
4912             if( i_pmt_number != TS_USER_PMT_NUMBER &&
4913                 i_pmt_number == p_pmt->i_program_number )
4914             {
4915                 pmt = p_sys->pmt[i];
4916                 prg = p_sys->pmt[i]->psi->prg[i_prg];
4917             }
4918         }
4919
4920     if( pmt == NULL )
4921     {
4922         msg_Warn( p_demux, "unreferenced program (broken stream)" );
4923         dvbpsi_DeletePMT(p_pmt);
4924         return;
4925     }
4926
4927
4928     if( prg->i_version != -1 &&
4929         ( !p_pmt->b_current_next || prg->i_version == p_pmt->i_version ) )
4930     {
4931         dvbpsi_DeletePMT( p_pmt );
4932         return;
4933     }
4934
4935     ts_pid_t **pp_clean = NULL;
4936     int      i_clean = 0;
4937     /* Clean this program (remove all es) */
4938     for( int i = 0; i < 8192; i++ )
4939     {
4940         ts_pid_t *pid = &p_sys->pid[i];
4941
4942         if( pid->b_valid && pid->p_owner == pmt->psi &&
4943             pid->i_owner_number == prg->i_number && pid->psi == NULL )
4944         {
4945             TAB_APPEND( i_clean, pp_clean, pid );
4946         }
4947     }
4948     if( prg->iod )
4949     {
4950         IODFree( prg->iod );
4951         prg->iod = NULL;
4952     }
4953
4954     msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=%d",
4955              p_pmt->i_program_number, p_pmt->i_version, p_pmt->i_pcr_pid );
4956     prg->i_pid_pcr = p_pmt->i_pcr_pid;
4957     prg->i_version = p_pmt->i_version;
4958
4959     ValidateDVBMeta( p_demux, prg->i_pid_pcr );
4960     if( ProgramIsSelected( p_demux, prg->i_number ) )
4961         SetPIDFilter( p_demux, prg->i_pid_pcr, true ); /* Set demux filter */
4962
4963     /* Parse PMT descriptors */
4964     ts_pmt_registration_type_t registration_type = TS_PMT_REGISTRATION_NONE;
4965     dvbpsi_descriptor_t  *p_dr;
4966
4967     /* First pass for standard detection */
4968     if ( p_sys->arib.e_mode == ARIBMODE_AUTO )
4969     {
4970         int i_arib_flags = 0; /* Descriptors can be repeated */
4971         for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
4972         {
4973             switch(p_dr->i_tag)
4974             {
4975             case 0x09:
4976             {
4977                 dvbpsi_ca_dr_t *p_cadr = dvbpsi_DecodeCADr( p_dr );
4978                 i_arib_flags |= (p_cadr->i_ca_system_id == 0x05);
4979             }
4980                 break;
4981             case 0xF6:
4982                 i_arib_flags |= 1 << 1;
4983                 break;
4984             case 0xC1:
4985                 i_arib_flags |= 1 << 2;
4986                 break;
4987             default:
4988                 break;
4989             }
4990         }
4991         if ( i_arib_flags == 0x07 ) //0b111
4992             p_sys->arib.e_mode = ARIBMODE_ENABLED;
4993     }
4994
4995     for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
4996     {
4997         /* special descriptors handling */
4998         switch(p_dr->i_tag)
4999         {
5000         case 0x1d: /* We have found an IOD descriptor */
5001             msg_Dbg( p_demux, " * PMT descriptor : IOD (0x1d)" );
5002             prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
5003             break;
5004
5005         case 0x9:
5006             msg_Dbg( p_demux, " * PMT descriptor : CA (0x9) SysID 0x%x",
5007                     (p_dr->p_data[0] << 8) | p_dr->p_data[1] );
5008             break;
5009
5010         case 0x5: /* Registration Descriptor */
5011             if( p_dr->i_length != 4 )
5012             {
5013                 msg_Warn( p_demux, " * PMT invalid Registration Descriptor" );
5014             }
5015             else
5016             {
5017                 msg_Dbg( p_demux, " * PMT descriptor : registration %4.4s", p_dr->p_data );
5018                 if( !memcmp( p_dr->p_data, "HDMV", 4 ) || !memcmp( p_dr->p_data, "HDPR", 4 ) )
5019                     registration_type = TS_PMT_REGISTRATION_HDMV; /* Blu-Ray */
5020             }
5021             break;
5022
5023         case 0x0f:
5024             msg_Dbg( p_demux, " * PMT descriptor : Private Data (0x0f)" );
5025             break;
5026
5027         case 0xC1:
5028             msg_Dbg( p_demux, " * PMT descriptor : Digital copy control (0xC1)" );
5029             break;
5030
5031         case 0x88: /* EACEM Simulcast HD Logical channels ordering */
5032             msg_Dbg( p_demux, " * descriptor : EACEM Simulcast HD" );
5033             /* TODO: apply visibility flags */
5034             break;
5035
5036         default:
5037             msg_Dbg( p_demux, " * PMT descriptor : unknown (0x%x)", p_dr->i_tag );
5038         }
5039     }
5040     dvbpsi_pmt_es_t      *p_es;
5041     for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
5042     {
5043         ts_pid_t tmp_pid = {0}, *old_pid = {0}, *pid = &tmp_pid;
5044
5045         /* Find out if the PID was already declared */
5046         for( int i = 0; i < i_clean; i++ )
5047         {
5048             if( pp_clean[i] == &p_sys->pid[p_es->i_pid] )
5049             {
5050                 old_pid = pp_clean[i];
5051                 break;
5052             }
5053         }
5054         ValidateDVBMeta( p_demux, p_es->i_pid );
5055
5056         if( !old_pid && p_sys->pid[p_es->i_pid].b_valid )
5057         {
5058             msg_Warn( p_demux, " * PMT error: pid=%d already defined",
5059                       p_es->i_pid );
5060             continue;
5061         }
5062
5063         char const * psz_typedesc = "";
5064         switch(p_es->i_type)
5065         {
5066         case 0x00:
5067             psz_typedesc = "ISO/IEC Reserved";
5068             break;
5069         case 0x01:
5070             psz_typedesc = "ISO/IEC 11172 Video";
5071             break;
5072         case 0x02:
5073             psz_typedesc = "ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream";
5074             break;
5075         case 0x03:
5076             psz_typedesc = "ISO/IEC 11172 Audio";
5077             break;
5078         case 0x04:
5079             psz_typedesc = "ISO/IEC 13818-3 Audio";
5080             break;
5081         case 0x05:
5082             psz_typedesc = "ISO/IEC 13818-1 private_sections";
5083             break;
5084         case 0x06:
5085             psz_typedesc = "ISO/IEC 13818-1 PES packets containing private data";
5086             break;
5087         case 0x07:
5088             psz_typedesc = "ISO/IEC 13522 MHEG";
5089             break;
5090         case 0x08:
5091             psz_typedesc = "ISO/IEC 13818-1 Annex A DSM CC";
5092             break;
5093         case 0x09:
5094             psz_typedesc = "ITU-T Rec. H.222.1";
5095             break;
5096         case 0x0A:
5097             psz_typedesc = "ISO/IEC 13818-6 type A";
5098             break;
5099         case 0x0B:
5100             psz_typedesc = "ISO/IEC 13818-6 type B";
5101             break;
5102         case 0x0C:
5103             psz_typedesc = "ISO/IEC 13818-6 type C";
5104             break;
5105         case 0x0D:
5106             psz_typedesc = "ISO/IEC 13818-6 type D";
5107             break;
5108         case 0x0E:
5109             psz_typedesc = "ISO/IEC 13818-1 auxiliary";
5110             break;
5111         default:
5112             if (p_es->i_type >= 0x0F && p_es->i_type <=0x7F)
5113                 psz_typedesc = "ISO/IEC 13818-1 Reserved";
5114             else
5115                 psz_typedesc = "User Private";
5116         }
5117
5118         msg_Dbg( p_demux, "  * pid=%d type=0x%x %s",
5119                  p_es->i_pid, p_es->i_type, psz_typedesc );
5120
5121         for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
5122              p_dr = p_dr->p_next )
5123         {
5124             msg_Dbg( p_demux, "    - descriptor tag 0x%x",
5125                      p_dr->i_tag );
5126         }
5127
5128         PIDInit( pid, false, pmt->psi );
5129         PIDFillFormat( &pid->es->fmt, p_es->i_type );
5130         pid->i_owner_number = prg->i_number;
5131         pid->i_pid          = p_es->i_pid;
5132         pid->b_seen         = p_sys->pid[p_es->i_pid].b_seen;
5133
5134
5135         bool b_registration_applied = false;
5136         if ( p_es->i_type >= 0x80 ) /* non standard, extensions */
5137         {
5138             if ( registration_type == TS_PMT_REGISTRATION_HDMV )
5139             {
5140                 if (( b_registration_applied = PMTSetupEsHDMV( p_demux, pid, p_es ) ))
5141                     msg_Dbg( p_demux, "    + HDMV registration applied to pid %d type 0x%x",
5142                              p_es->i_pid, p_es->i_type );
5143             }
5144             else
5145             {
5146                 if (( b_registration_applied = PMTSetupEsRegistration( p_demux, pid, p_es ) ))
5147                     msg_Dbg( p_demux, "    + registration applied to pid %d type 0x%x",
5148                         p_es->i_pid, p_es->i_type );
5149             }
5150         }
5151
5152         if ( !b_registration_applied )
5153         {
5154             switch( p_es->i_type )
5155             {
5156             case 0x06:
5157                 /* Handle PES private data */
5158                 PMTSetupEs0x06( p_demux, pid, p_es );
5159                 break;
5160             /* All other private or reserved types */
5161             case 0x0f:
5162             case 0x10:
5163             case 0x11:
5164             case 0x12:
5165                 PMTSetupEsISO14496( p_demux, pid, prg, p_es );
5166                 break;
5167             case 0x83:
5168                 /* LPCM (audio) */
5169                 PMTSetupEs0x83( p_pmt, pid );
5170                 break;
5171             case 0xa0:
5172                 PMTSetupEs0xA0( p_demux, pid, p_es );
5173                 break;
5174             case 0xd1:
5175                 PMTSetupEs0xD1( p_demux, pid, p_es );
5176                 break;
5177             case 0xEA:
5178                 PMTSetupEs0xEA( p_demux, pid, p_es );
5179             default:
5180                 break;
5181             }
5182         }
5183
5184         if( pid->es->fmt.i_cat == AUDIO_ES ||
5185             ( pid->es->fmt.i_cat == SPU_ES &&
5186               pid->es->fmt.i_codec != VLC_CODEC_DVBS &&
5187               pid->es->fmt.i_codec != VLC_CODEC_TELETEXT ) )
5188         {
5189             PMTParseEsIso639( p_demux, pid, p_es );
5190         }
5191
5192         switch( pid->es->fmt.i_codec )
5193         {
5194         case VLC_CODEC_SCTE_27:
5195             pid->es->data_type = TS_ES_DATA_TABLE_SECTION;
5196             break;
5197         default:
5198             //pid->es->data_type = TS_ES_DATA_PES;
5199             break;
5200         }
5201
5202         pid->es->fmt.i_group = p_pmt->i_program_number;
5203         for( int i = 0; i < pid->i_extra_es; i++ )
5204             pid->extra_es[i]->fmt.i_group = p_pmt->i_program_number;
5205
5206         if( pid->es->fmt.i_cat == UNKNOWN_ES )
5207         {
5208             msg_Dbg( p_demux, "   => pid %d content is *unknown*",
5209                      p_es->i_pid );
5210         }
5211         else
5212         {
5213             msg_Dbg( p_demux, "   => pid %d has now es fcc=%4.4s",
5214                      p_es->i_pid, (char*)&pid->es->fmt.i_codec );
5215
5216             if( p_sys->b_es_id_pid ) pid->es->fmt.i_id = p_es->i_pid;
5217
5218             /* Check if we can avoid restarting the ES */
5219             if( old_pid &&
5220                 pid->es->fmt.i_codec == old_pid->es->fmt.i_codec &&
5221                 pid->es->fmt.i_extra == old_pid->es->fmt.i_extra &&
5222                 pid->es->fmt.i_extra == 0 &&
5223                 pid->i_extra_es == old_pid->i_extra_es &&
5224                 ( ( !pid->es->fmt.psz_language &&
5225                     !old_pid->es->fmt.psz_language ) ||
5226                   ( pid->es->fmt.psz_language &&
5227                     old_pid->es->fmt.psz_language &&
5228                     !strcmp( pid->es->fmt.psz_language,
5229                              old_pid->es->fmt.psz_language ) ) ) )
5230             {
5231                 pid->i_cc = old_pid->i_cc;
5232                 ts_es_t *e = pid->es;
5233                 pid->es = old_pid->es;
5234                 old_pid->es = e;
5235                 for( int i = 0; i < pid->i_extra_es; i++ )
5236                 {
5237                     e = pid->extra_es[i];
5238                     pid->extra_es[i] = old_pid->extra_es[i];
5239                     old_pid->extra_es[i] = e;
5240                 }
5241             }
5242             else
5243             {
5244                 AddAndCreateES( p_demux, pid );
5245             }
5246         }
5247
5248         /* Add ES to the list */
5249         if( old_pid )
5250         {
5251             PIDClean( p_demux, old_pid );
5252             TAB_REMOVE( i_clean, pp_clean, old_pid );
5253         }
5254         p_sys->pid[p_es->i_pid] = *pid;
5255
5256         p_dr = PMTEsFindDescriptor( p_es, 0x09 );
5257         if( p_dr && p_dr->i_length >= 2 )
5258         {
5259             msg_Dbg( p_demux, "   * PMT descriptor : CA (0x9) SysID 0x%x",
5260                      (p_dr->p_data[0] << 8) | p_dr->p_data[1] );
5261         }
5262
5263         if( ProgramIsSelected( p_demux, prg->i_number ) && pid->es->id != NULL )
5264             SetPIDFilter( p_demux, p_es->i_pid, true ); /* Set demux filter */
5265     }
5266
5267     /* Set CAM descrambling */
5268     if( !ProgramIsSelected( p_demux, prg->i_number ) )
5269     {
5270         dvbpsi_DeletePMT( p_pmt );
5271     }
5272     else if( stream_Control( p_sys->stream, STREAM_SET_PRIVATE_ID_CA,
5273                              p_pmt ) != VLC_SUCCESS )
5274     {
5275         if ( p_sys->arib.e_mode == ARIBMODE_ENABLED )
5276         {
5277             p_sys->arib.b25stream = stream_FilterNew( p_demux->s, "aribcam" );
5278             p_sys->stream = ( p_sys->arib.b25stream ) ? p_sys->arib.b25stream : p_demux->s;
5279             if (!p_sys->arib.b25stream)
5280                 dvbpsi_DeletePMT( p_pmt );
5281         } else dvbpsi_DeletePMT( p_pmt );
5282     }
5283
5284     for( int i = 0; i < i_clean; i++ )
5285     {
5286         if( ProgramIsSelected( p_demux, prg->i_number ) )
5287             SetPIDFilter( p_demux, pp_clean[i]->i_pid, false );
5288
5289         PIDClean( p_demux, pp_clean[i] );
5290     }
5291     if( i_clean )
5292         free( pp_clean );
5293 }
5294
5295 static void PATCallBack( void *data, dvbpsi_pat_t *p_pat )
5296 {
5297     demux_t              *p_demux = data;
5298     demux_sys_t          *p_sys = p_demux->p_sys;
5299     dvbpsi_pat_program_t *p_program;
5300     ts_pid_t             *pat = &p_sys->pid[0];
5301
5302     msg_Dbg( p_demux, "PATCallBack called" );
5303
5304     if( ( pat->psi->i_pat_version != -1 &&
5305             ( !p_pat->b_current_next ||
5306               p_pat->i_version == pat->psi->i_pat_version ) ) ||
5307         p_sys->b_user_pmt )
5308     {
5309         dvbpsi_DeletePAT( p_pat );
5310         return;
5311     }
5312
5313     msg_Dbg( p_demux, "new PAT ts_id=%d version=%d current_next=%d",
5314              p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
5315
5316     /* Clean old */
5317     if( p_sys->i_pmt > 0 )
5318     {
5319         int      i_pmt_rm = 0;
5320         ts_pid_t **pmt_rm = NULL;
5321
5322         /* Search pmt to be deleted */
5323         for( int i = 0; i < p_sys->i_pmt; i++ )
5324         {
5325             ts_pid_t *pmt = p_sys->pmt[i];
5326             bool b_keep = false;
5327
5328             for( p_program = p_pat->p_first_program; !b_keep && p_program;
5329                  p_program = p_program->p_next )
5330             {
5331                 if( p_program->i_pid != pmt->i_pid )
5332                     continue;
5333
5334                 for( int i_prg = 0; !b_keep && i_prg < pmt->psi->i_prg; i_prg++ )
5335                     if( p_program->i_number == pmt->psi->prg[i_prg]->i_number )
5336                         b_keep = true;
5337             }
5338
5339             if( b_keep )
5340                 continue;
5341
5342             TAB_APPEND( i_pmt_rm, pmt_rm, pmt );
5343         }
5344
5345         /* Delete all ES attached to thoses PMT */
5346         for( int i = 2; i < 8192; i++ )
5347         {
5348             ts_pid_t *pid = &p_sys->pid[i];
5349
5350             if( !pid->b_valid || pid->psi )
5351                 continue;
5352
5353             for( int j = 0; j < i_pmt_rm && pid->b_valid; j++ )
5354             {
5355                 for( int i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
5356                 {
5357                     /* We only remove es that aren't defined by extra pmt */
5358                     if( pid->p_owner->prg[i_prg]->i_pid_pmt != pmt_rm[j]->i_pid )
5359                         continue;
5360
5361                     if( pid->es->id )
5362                         SetPIDFilter( p_demux, i, false );
5363
5364                     PIDClean( p_demux, pid );
5365                     break;
5366                 }
5367             }
5368         }
5369
5370         /* Delete PMT pid */
5371         for( int i = 0; i < i_pmt_rm; i++ )
5372         {
5373             ts_pid_t *pid = pmt_rm[i];
5374             SetPIDFilter( p_demux, pid->i_pid, false );
5375
5376             for( int i_prg = 0; i_prg < pid->psi->i_prg; i_prg++ )
5377             {
5378                 const int i_number = pid->psi->prg[i_prg]->i_number;
5379                 es_out_Control( p_demux->out, ES_OUT_DEL_GROUP, i_number );
5380             }
5381
5382             PIDClean( p_demux, &p_sys->pid[pid->i_pid] );
5383             TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pid );
5384         }
5385
5386         free( pmt_rm );
5387     }
5388
5389     /* now create programs */
5390     for( p_program = p_pat->p_first_program; p_program != NULL;
5391          p_program = p_program->p_next )
5392     {
5393         msg_Dbg( p_demux, "  * number=%d pid=%d", p_program->i_number,
5394                  p_program->i_pid );
5395         if( p_program->i_number == 0 )
5396             continue;
5397
5398         ts_pid_t *pmt = &p_sys->pid[p_program->i_pid];
5399
5400         ValidateDVBMeta( p_demux, p_program->i_pid );
5401
5402         if( pmt->b_valid )
5403         {
5404             bool b_add = true;
5405             for( int i_prg = 0; b_add && i_prg < pmt->psi->i_prg; i_prg++ )
5406                 if( pmt->psi->prg[i_prg]->i_number == p_program->i_number )
5407                     b_add = false;
5408
5409             if( !b_add )
5410                 continue;
5411         }
5412         else
5413         {
5414             TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
5415         }
5416
5417         PIDInit( pmt, true, pat->psi );
5418         ts_prg_psi_t *prg = pmt->psi->prg[pmt->psi->i_prg-1];
5419 #if (DVBPSI_VERSION_INT >= DVBPSI_VERSION_WANTED(1,0,0))
5420         prg->handle = dvbpsi_new( &dvbpsi_messages, DVBPSI_MSG_DEBUG );
5421         if( !prg->handle )
5422         {
5423             dvbpsi_DeletePAT( p_pat );
5424             return;
5425         }
5426         prg->handle->p_sys = (void *) VLC_OBJECT(p_demux);
5427         if( !dvbpsi_pmt_attach( prg->handle, p_program->i_number, PMTCallBack, p_demux ) )
5428             msg_Err( p_demux, "PATCallback failed attaching PMTCallback to program %d",
5429                      p_program->i_number );
5430 #else
5431         prg->handle = dvbpsi_AttachPMT( p_program->i_number, PMTCallBack, p_demux );
5432 #endif
5433         prg->i_number = p_program->i_number;
5434         prg->i_pid_pmt = p_program->i_pid;
5435
5436         /* Now select PID at access level */
5437         if( ProgramIsSelected( p_demux, p_program->i_number ) )
5438         {
5439             if( p_sys->i_current_program == 0 )
5440                 p_sys->i_current_program = p_program->i_number;
5441
5442             if( SetPIDFilter( p_demux, p_program->i_pid, true ) )
5443                 p_sys->b_access_control = false;
5444         }
5445     }
5446     pat->psi->i_pat_version = p_pat->i_version;
5447
5448     dvbpsi_DeletePAT( p_pat );
5449 }