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