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