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