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 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <stdlib.h>                                      /* malloc(), free() */
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc/input.h>
  31
  32 #include "iso_lang.h"
  33 #include "network.h"
  34
  35 #include "../mux/mpeg/csa.h"
  36
  37 /* Include dvbpsi headers */
  38 #ifdef HAVE_DVBPSI_DR_H
  39 #   include <dvbpsi/dvbpsi.h>
  40 #   include <dvbpsi/descriptor.h>
  41 #   include <dvbpsi/pat.h>
  42 #   include <dvbpsi/pmt.h>
  43 #   include <dvbpsi/dr.h>
  44 #   include <dvbpsi/psi.h>
  45 #else
  46 #   include "dvbpsi.h"
  47 #   include "descriptor.h"
  48 #   include "tables/pat.h"
  49 #   include "tables/pmt.h"
  50 #   include "descriptors/dr.h"
  51 #   include "psi.h"
  52 #endif
  53
  54 /* TODO:
  55  *  - XXX: do not mark options message to be translated, they are too osbcure for now ...
  56  *  - test it
  57  *  - ...
  58  */
  59
  60 /*****************************************************************************
  61  * Module descriptor
  62  *****************************************************************************/
  63 static int  Open  ( vlc_object_t * );
  64 static void Close ( vlc_object_t * );
  65
  66 vlc_module_begin();
  67     set_description( _("ISO 13818-1 MPEG Transport Stream input - new" ) );
  68     add_string( "ts-extra-pmt", NULL, NULL, "extra PMT", "allow user to specify an extra pmt (pmt_pid=pid:stream_type[,...])", VLC_TRUE );
  69     add_bool( "ts-es-id-pid", 0, NULL, "set id of es to pid", "set id of es to pid", VLC_TRUE );
  70     add_string( "ts-out", NULL, NULL, "fast udp streaming", "send TS to specific ip:port by udp (you must know what you are doing)", VLC_TRUE );
  71     add_integer( "ts-out-mtu", 1500, NULL, "MTU for out mode", "MTU for out mode", VLC_TRUE );
  72     add_string( "ts-csa-ck", NULL, NULL, "CSA ck", "CSA ck", VLC_TRUE );
  73     add_bool( "ts-silent", 0, NULL, "Silent mode", "do not complain on encrypted PES", VLC_TRUE );
  74     set_capability( "demux2", 10 );
  75     set_callbacks( Open, Close );
  76     add_shortcut( "ts" );
  77 vlc_module_end();
  78
  79 /*****************************************************************************
  80  * Local prototypes
  81  *****************************************************************************/
  82
  83 typedef struct
  84 {
  85     uint8_t                 i_objectTypeIndication;
  86     uint8_t                 i_streamType;
  87     vlc_bool_t              b_upStream;
  88     uint32_t                i_bufferSizeDB;
  89     uint32_t                i_maxBitrate;
  90     uint32_t                i_avgBitrate;
  91
  92     int                     i_decoder_specific_info_len;
  93     uint8_t                 *p_decoder_specific_info;
  94
  95 } decoder_config_descriptor_t;
  96
  97 typedef struct
  98 {
  99     vlc_bool_t              b_useAccessUnitStartFlag;
 100     vlc_bool_t              b_useAccessUnitEndFlag;
 101     vlc_bool_t              b_useRandomAccessPointFlag;
 102     vlc_bool_t              b_useRandomAccessUnitsOnlyFlag;
 103     vlc_bool_t              b_usePaddingFlag;
 104     vlc_bool_t              b_useTimeStampsFlags;
 105     vlc_bool_t              b_useIdleFlag;
 106     vlc_bool_t              b_durationFlag;
 107     uint32_t                i_timeStampResolution;
 108     uint32_t                i_OCRResolution;
 109     uint8_t                 i_timeStampLength;
 110     uint8_t                 i_OCRLength;
 111     uint8_t                 i_AU_Length;
 112     uint8_t                 i_instantBitrateLength;
 113     uint8_t                 i_degradationPriorityLength;
 114     uint8_t                 i_AU_seqNumLength;
 115     uint8_t                 i_packetSeqNumLength;
 116
 117     uint32_t                i_timeScale;
 118     uint16_t                i_accessUnitDuration;
 119     uint16_t                i_compositionUnitDuration;
 120
 121     uint64_t                i_startDecodingTimeStamp;
 122     uint64_t                i_startCompositionTimeStamp;
 123
 124 } sl_config_descriptor_t;
 125
 126 typedef struct
 127 {
 128     vlc_bool_t              b_ok;
 129     uint16_t                i_es_id;
 130
 131     vlc_bool_t              b_streamDependenceFlag;
 132     vlc_bool_t              b_OCRStreamFlag;
 133     uint8_t                 i_streamPriority;
 134
 135     char                    *psz_url;
 136
 137     uint16_t                i_dependOn_es_id;
 138     uint16_t                i_OCR_es_id;
 139
 140     decoder_config_descriptor_t    dec_descr;
 141     sl_config_descriptor_t         sl_descr;
 142 } es_mpeg4_descriptor_t;
 143
 144 typedef struct
 145 {
 146     uint8_t                i_iod_label;
 147
 148     /* IOD */
 149     uint16_t                i_od_id;
 150     char                    *psz_url;
 151
 152     uint8_t                 i_ODProfileLevelIndication;
 153     uint8_t                 i_sceneProfileLevelIndication;
 154     uint8_t                 i_audioProfileLevelIndication;
 155     uint8_t                 i_visualProfileLevelIndication;
 156     uint8_t                 i_graphicsProfileLevelIndication;
 157
 158     es_mpeg4_descriptor_t   es_descr[255];
 159
 160 } iod_descriptor_t;
 161
 162 typedef struct
 163 {
 164     dvbpsi_handle   handle;
 165
 166     int             i_version;
 167     int             i_number;
 168     int             i_pid_pcr;
 169     /* IOD stuff (mpeg4) */
 170     iod_descriptor_t *iod;
 171 } ts_prg_psi_t;
 172
 173 typedef struct
 174 {
 175     /* for special PAT case */
 176     dvbpsi_handle   handle;
 177     int             i_pat_version;
 178
 179     /* For PMT */
 180     int             i_prg;
 181     ts_prg_psi_t    **prg;
 182 } ts_psi_t;
 183
 184 typedef struct
 185 {
 186     es_format_t  fmt;
 187     es_out_id_t *id;
 188     int         i_pes_size;
 189     int         i_pes_gathered;
 190     block_t     *p_pes;
 191     block_t     **pp_last;
 192
 193     es_mpeg4_descriptor_t *p_mpeg4desc;
 194     int         b_gather;
 195 } ts_es_t;
 196
 197 typedef struct
 198 {
 199     int         i_pid;
 200
 201     vlc_bool_t  b_seen;
 202     vlc_bool_t  b_valid;
 203     int         i_cc;   /* countinuity counter */
 204
 205     /* PSI owner (ie PMT -> PAT, ES -> PMT */
 206     ts_psi_t   *p_owner;
 207     int         i_owner_number;
 208
 209     /* */
 210     ts_psi_t    *psi;
 211     ts_es_t     *es;
 212
 213     /* Some private streams encapsulate several ES (eg. DVB subtitles)*/
 214     ts_es_t     **extra_es;
 215     int         i_extra_es;
 216
 217 } ts_pid_t;
 218
 219 struct demux_sys_t
 220 {
 221     /* how many TS packet we read at once */
 222     int         i_ts_read;
 223
 224     /* All pid */
 225     ts_pid_t    pid[8192];
 226
 227     /* All PMT */
 228     int         i_pmt;
 229     ts_pid_t    **pmt;
 230
 231     /* */
 232     vlc_bool_t  b_es_id_pid;
 233     csa_t       *csa;
 234     vlc_bool_t  b_silent;
 235
 236     vlc_bool_t  b_udp_out;
 237     int         fd; /* udp socket */
 238     uint8_t     *buffer;
 239 };
 240
 241 static int Demux  ( demux_t *p_demux );
 242 static int Control( demux_t *p_demux, int i_query, va_list args );
 243
 244
 245 static void PIDInit ( ts_pid_t *pid, vlc_bool_t b_psi, ts_psi_t *p_owner );
 246 static void PIDClean( es_out_t *out, ts_pid_t *pid );
 247 static int  PIDFillFormat( ts_pid_t *pid, int i_stream_type );
 248
 249 static void PATCallBack( demux_t *, dvbpsi_pat_t * );
 250 static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt );
 251
 252 static inline int PIDGet( block_t *p )
 253 {
 254     return ( (p->p_buffer[1]&0x1f)<<8 )|p->p_buffer[2];
 255 }
 256
 257 static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk );
 258
 259 static void PCRHandle( demux_t *p_demux, ts_pid_t *, block_t * );
 260
 261 static iod_descriptor_t *IODNew( int , uint8_t * );
 262 static void              IODFree( iod_descriptor_t * );
 263
 264
 265 /*****************************************************************************
 266  * Open
 267  *****************************************************************************/
 268 static int Open( vlc_object_t *p_this )
 269 {
 270     demux_t     *p_demux = (demux_t*)p_this;
 271     demux_sys_t *p_sys;
 272
 273     uint8_t     *p_peek;
 274     int          i_peek;
 275     int          i_sync;
 276     int          i;
 277
 278     ts_pid_t     *pat;
 279
 280     vlc_value_t  val;
 281
 282     if( ( i_peek = stream_Peek( p_demux->s, &p_peek, 189 ) ) < 1 )
 283     {
 284         msg_Err( p_demux, "cannot peek" );
 285         return VLC_EGENERIC;
 286     }
 287
 288     /* Search first synch */
 289     for( i_sync = 0; i_sync < i_peek; i_sync++ )
 290     {
 291         if( p_peek[i_sync] == 0x47 ) break;
 292     }
 293     if( i_sync >= i_peek )
 294     {
 295         if( strcmp( p_demux->psz_demux, "ts" ) )
 296         {
 297             msg_Warn( p_demux, "TS module discarded" );
 298             return VLC_EGENERIC;
 299         }
 300         msg_Warn( p_demux, "this does not look like a TS stream, continuing" );
 301     }
 302     if( strcmp( p_demux->psz_demux, "ts" ) )
 303     {
 304         /* Check next 3 sync points */
 305         i_peek = 188*3 + 1 + i_sync;
 306         if( ( stream_Peek( p_demux->s, &p_peek, i_peek ) ) < i_peek )
 307         {
 308             msg_Err( p_demux, "cannot peek" );
 309             return VLC_EGENERIC;
 310         }
 311         if( p_peek[i_sync+  188] != 0x47 || p_peek[i_sync+2*188] != 0x47 ||
 312             p_peek[i_sync+3*188] != 0x47 )
 313         {
 314             msg_Warn( p_demux, "TS module discarded (lost sync)" );
 315             return VLC_EGENERIC;
 316         }
 317     }
 318
 319     /* Fill p_demux field */
 320     p_demux->pf_demux = Demux;
 321     p_demux->pf_control = Control;
 322     p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
 323     memset( p_sys, 0, sizeof( demux_sys_t ) );
 324
 325     /* Init p_sys field */
 326     for( i = 0; i < 8192; i++ )
 327     {
 328         ts_pid_t *pid = &p_sys->pid[i];
 329
 330         pid->i_pid      = i;
 331         pid->b_seen     = VLC_FALSE;
 332         pid->b_valid    = VLC_FALSE;
 333     }
 334     p_sys->b_udp_out = VLC_FALSE;
 335     p_sys->i_ts_read = 50;
 336     p_sys->csa = NULL;
 337
 338     /* Init PAT handler */
 339     pat = &p_sys->pid[0];
 340     PIDInit( pat, VLC_TRUE, NULL );
 341     pat->psi->handle = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack,
 342                                          p_demux );
 343
 344     /* Init PMT array */
 345     p_sys->i_pmt = 0;
 346     p_sys->pmt   = NULL;
 347
 348     /* Read config */
 349     var_Create( p_demux, "ts-es-id-pid", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 350     var_Get( p_demux, "ts-es-id-pid", &val );
 351     p_sys->b_es_id_pid = val.b_bool,
 352
 353     var_Create( p_demux, "ts-out", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 354     var_Get( p_demux, "ts-out", &val );
 355     if( val.psz_string && *val.psz_string )
 356     {
 357         vlc_value_t mtu;
 358         char *psz = strchr( val.psz_string, ':' );
 359         int   i_port = 0;
 360
 361         p_sys->b_udp_out = VLC_TRUE;
 362
 363         if( psz )
 364         {
 365             *psz++ = '\0';
 366             i_port = atoi( psz );
 367         }
 368         if( i_port <= 0 ) i_port  = 1234;
 369         msg_Dbg( p_demux, "resend ts to '%s:%d'", val.psz_string, i_port );
 370
 371         p_sys->fd = net_OpenUDP( p_demux, "", 0, val.psz_string, i_port );
 372         if( p_sys->fd < 0 )
 373         {
 374             msg_Err( p_demux, "failed to open udp socket, send disabled" );
 375             p_sys->b_udp_out = VLC_FALSE;
 376         }
 377         else
 378         {
 379             var_Create( p_demux, "ts-out-mtu",
 380                         VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 381             var_Get( p_demux, "ts-out-mtu", &mtu );
 382             p_sys->i_ts_read = mtu.i_int / 188;
 383             if( p_sys->i_ts_read <= 0 )
 384             {
 385                 p_sys->i_ts_read = 1500 / 188;
 386             }
 387             p_sys->buffer = malloc( 188 * p_sys->i_ts_read );
 388         }
 389     }
 390     if( val.psz_string )
 391     {
 392         free( val.psz_string );
 393     }
 394
 395
 396     /* We handle description of an extra PMT */
 397     var_Create( p_demux, "ts-extra-pmt", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 398     var_Get( p_demux, "ts-extra-pmt", &val );
 399     if( val.psz_string && strchr( val.psz_string, '=' ) != NULL )
 400     {
 401         char *psz = val.psz_string;
 402         int  i_pid = strtol( psz, &psz, 0 );
 403
 404         if( i_pid >= 2 && i_pid < 8192 )
 405         {
 406             ts_pid_t *pmt = &p_sys->pid[i_pid];
 407
 408             msg_Dbg( p_demux, "extra pmt specified (pid=0x%x)", i_pid );
 409             PIDInit( pmt, VLC_TRUE, NULL );
 410             /* FIXME we should also ask for a number */
 411             pmt->psi->prg[0]->handle =
 412                 dvbpsi_AttachPMT( 1, (dvbpsi_pmt_callback)PMTCallBack,
 413                                   p_demux );
 414             pmt->psi->prg[0]->i_number = 0; /* special one */
 415
 416             psz = strchr( psz, '=' ) + 1;   /* can't failed */
 417             while( psz && *psz )
 418             {
 419                 char *psz_next = strchr( psz, ',' );
 420                 int i_pid, i_stream_type;
 421
 422                 if( psz_next )
 423                 {
 424                     *psz_next++ = '\0';
 425                 }
 426
 427                 i_pid = strtol( psz, &psz, 0 );
 428                 if( *psz == ':' )
 429                 {
 430                     i_stream_type = strtol( psz + 1, &psz, 0 );
 431                     if( i_pid >= 2 && i_pid < 8192 &&
 432                         !p_sys->pid[i_pid].b_valid )
 433                     {
 434                         ts_pid_t *pid = &p_sys->pid[i_pid];
 435
 436                         PIDInit( pid, VLC_FALSE, pmt->psi);
 437                         if( pmt->psi->prg[0]->i_pid_pcr <= 0 )
 438                         {
 439                             pmt->psi->prg[0]->i_pid_pcr = i_pid;
 440                         }
 441                         PIDFillFormat( pid, i_stream_type);
 442                         if( pid->es->fmt.i_cat != UNKNOWN_ES )
 443                         {
 444                             if( p_sys->b_es_id_pid )
 445                             {
 446                                 pid->es->fmt.i_id = i_pid;
 447                             }
 448                             msg_Dbg( p_demux, "  * es pid=0x%x type=0x%x "
 449                                      "fcc=%4.4s", i_pid, i_stream_type,
 450                                      (char*)&pid->es->fmt.i_codec );
 451                             pid->es->id = es_out_Add( p_demux->out,
 452                                                       &pid->es->fmt );
 453                         }
 454                     }
 455                 }
 456                 psz = psz_next;
 457             }
 458         }
 459     }
 460     if( val.psz_string )
 461     {
 462         free( val.psz_string );
 463     }
 464
 465     var_Create( p_demux, "ts-csa-ck", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 466     var_Get( p_demux, "ts-csa-ck", &val );
 467     if( val.psz_string && *val.psz_string )
 468     {
 469         char *psz = val.psz_string;
 470         if( psz[0] == '0' && ( psz[1] == 'x' || psz[1] == 'X' ) )
 471         {
 472             psz += 2;
 473         }
 474         if( strlen( psz ) != 16 )
 475         {
 476             msg_Warn( p_demux, "invalid csa ck (it must be 16 chars long)" );
 477         }
 478         else
 479         {
 480             uint64_t i_ck = strtoll( psz, NULL, 16 );
 481             uint8_t ck[8];
 482             int     i;
 483             for( i = 0; i < 8; i++ )
 484             {
 485                 ck[i] = ( i_ck >> ( 56 - 8*i) )&0xff;
 486             }
 487
 488             msg_Dbg( p_demux, "using CSA scrambling with "
 489                      "ck=%x:%x:%x:%x:%x:%x:%x:%x",
 490                      ck[0], ck[1], ck[2], ck[3], ck[4], ck[5], ck[6], ck[7] );
 491
 492             p_sys->csa = csa_New();
 493             csa_SetCW( p_sys->csa, ck, ck );
 494         }
 495     }
 496     if( val.psz_string )
 497     {
 498         free( val.psz_string );
 499     }
 500
 501     var_Create( p_demux, "ts-silent", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 502     var_Get( p_demux, "ts-silent", &val );
 503     p_sys->b_silent = val.b_bool;
 504
 505     return VLC_SUCCESS;
 506 }
 507
 508 /*****************************************************************************
 509  * Close
 510  *****************************************************************************/
 511 static void Close( vlc_object_t *p_this )
 512 {
 513     demux_t     *p_demux = (demux_t*)p_this;
 514     demux_sys_t *p_sys = p_demux->p_sys;
 515
 516     int          i;
 517
 518     msg_Dbg( p_demux, "pid list:" );
 519     for( i = 0; i < 8192; i++ )
 520     {
 521         ts_pid_t *pid = &p_sys->pid[i];
 522
 523         if( pid->b_valid && pid->psi )
 524         {
 525             switch( pid->i_pid )
 526             {
 527                 case 0: /* PAT */
 528                     dvbpsi_DetachPAT( pid->psi->handle );
 529                     free( pid->psi );
 530                     break;
 531                 case 1: /* CAT */
 532                     free( pid->psi );
 533                     break;
 534                 default:
 535                     PIDClean( p_demux->out, pid );
 536                     break;
 537             }
 538         }
 539         else if( pid->b_valid && pid->es )
 540         {
 541             PIDClean( p_demux->out, pid );
 542         }
 543
 544         if( pid->b_seen )
 545         {
 546             msg_Dbg( p_demux, "  - pid[0x%x] seen", pid->i_pid );
 547         }
 548     }
 549
 550     if( p_sys->b_udp_out )
 551     {
 552         net_Close( p_sys->fd );
 553         free( p_sys->buffer );
 554     }
 555     if( p_sys->csa )
 556     {
 557         csa_Delete( p_sys->csa );
 558     }
 559
 560     if( p_sys->i_pmt ) free( p_sys->pmt );
 561     free( p_sys );
 562 }
 563
 564 /*****************************************************************************
 565  * Demux:
 566  *****************************************************************************/
 567 static int Demux( demux_t *p_demux )
 568 {
 569     demux_sys_t *p_sys = p_demux->p_sys;
 570     int          i_pkt;
 571
 572     /* We read at most 100 TS packet or until a frame is completed */
 573     for( i_pkt = 0; i_pkt < p_sys->i_ts_read; i_pkt++ )
 574     {
 575         vlc_bool_t  b_frame = VLC_FALSE;
 576         block_t     *p_pkt;
 577         ts_pid_t    *p_pid;
 578
 579         /* Get a new TS packet */
 580         if( ( p_pkt = stream_Block( p_demux->s, 188 ) ) == NULL )
 581         {
 582             msg_Dbg( p_demux, "eof ?" );
 583             return 0;
 584         }
 585         if( p_pkt->p_buffer[0] != 0x47 )
 586         {
 587             msg_Warn( p_demux, "lost synchro" );
 588             block_Release( p_pkt );
 589
 590             /* Resynch */
 591             while( !p_demux->b_die )
 592             {
 593                 uint8_t    *p_peek;
 594                 int         i_peek = stream_Peek( p_demux->s, &p_peek, 1880 );
 595                 int         i_skip = 0;
 596                 vlc_bool_t  b_ok = VLC_FALSE;
 597
 598                 if( i_peek < 189 )
 599                 {
 600                     msg_Dbg( p_demux, "eof ?" );
 601                     return 0;
 602                 }
 603
 604                 while( i_skip < i_peek - 188 )
 605                 {
 606                     if( p_peek[i_skip] == 0x47 && p_peek[i_skip+188] == 0x47 )
 607                     {
 608                         b_ok = VLC_TRUE;
 609                         break;
 610                     }
 611                     i_skip++;
 612                 }
 613                 stream_Read( p_demux->s, NULL, i_skip );
 614                 msg_Dbg( p_demux, "%d bytes of garbage", i_skip );
 615                 if( b_ok )
 616                 {
 617                     break;
 618                 }
 619             }
 620             if( ( p_pkt = stream_Block( p_demux->s, 188 ) ) == NULL )
 621             {
 622                 msg_Dbg( p_demux, "eof ?" );
 623                 return 0;
 624             }
 625         }
 626
 627         if( p_sys->b_udp_out )
 628         {
 629             memcpy( &p_sys->buffer[i_pkt*188], p_pkt->p_buffer, 188 );
 630         }
 631
 632         /* Parse the TS packet */
 633         p_pid = &p_sys->pid[PIDGet( p_pkt )];
 634
 635         if( p_pid->b_valid )
 636         {
 637             if( p_pid->psi )
 638             {
 639                 if( p_pid->i_pid == 0 )
 640                 {
 641                     dvbpsi_PushPacket( p_pid->psi->handle, p_pkt->p_buffer );
 642                 }
 643                 else
 644                 {
 645                     int i_prg;
 646                     for( i_prg = 0; i_prg < p_pid->psi->i_prg; i_prg++ )
 647                     {
 648                         dvbpsi_PushPacket( p_pid->psi->prg[i_prg]->handle, p_pkt->p_buffer );
 649                     }
 650                 }
 651                 block_Release( p_pkt );
 652             }
 653             else if( !p_sys->b_udp_out )
 654             {
 655                 b_frame = GatherPES( p_demux, p_pid, p_pkt );
 656             }
 657             else
 658             {
 659                 block_Release( p_pkt );
 660             }
 661         }
 662         else
 663         {
 664             if( !p_pid->b_seen )
 665             {
 666                 msg_Dbg( p_demux, "pid[0x%x] unknown", p_pid->i_pid );
 667             }
 668             /* We have to handle PCR if present */
 669             PCRHandle( p_demux, p_pid, p_pkt );
 670             block_Release( p_pkt );
 671         }
 672         p_pid->b_seen = VLC_TRUE;
 673
 674         if( b_frame )
 675         {
 676             break;
 677         }
 678     }
 679
 680     if( p_sys->b_udp_out )
 681     {
 682         /* Send the complete block */
 683         net_Write( p_demux, p_sys->fd, p_sys->buffer, p_sys->i_ts_read * 188 );
 684     }
 685
 686     return 1;
 687 }
 688
 689 /*****************************************************************************
 690  * Control:
 691  *****************************************************************************/
 692 static int Control( demux_t *p_demux, int i_query, va_list args )
 693 {
 694     /* demux_sys_t *p_sys = p_demux->p_sys; */
 695     double f, *pf;
 696     int64_t i64;
 697
 698     switch( i_query )
 699     {
 700         case DEMUX_GET_POSITION:
 701             pf = (double*) va_arg( args, double* );
 702             i64 = stream_Size( p_demux->s );
 703             if( i64 > 0 )
 704             {
 705                 *pf = (double)stream_Tell( p_demux->s ) / (double)i64;
 706             }
 707             else
 708             {
 709                 *pf = 0.0;
 710             }
 711             return VLC_SUCCESS;
 712         case DEMUX_SET_POSITION:
 713             f = (double) va_arg( args, double );
 714             i64 = stream_Size( p_demux->s );
 715
 716             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
 717             if( stream_Seek( p_demux->s, (int64_t)(i64 * f) ) )
 718             {
 719                 return VLC_EGENERIC;
 720             }
 721             return VLC_SUCCESS;
 722 #if 0
 723
 724         case DEMUX_GET_TIME:
 725             pi64 = (int64_t*)va_arg( args, int64_t * );
 726             if( p_sys->i_time < 0 )
 727             {
 728                 *pi64 = 0;
 729                 return VLC_EGENERIC;
 730             }
 731             *pi64 = p_sys->i_time;
 732             return VLC_SUCCESS;
 733
 734         case DEMUX_GET_LENGTH:
 735             pi64 = (int64_t*)va_arg( args, int64_t * );
 736             if( p_sys->i_mux_rate > 0 )
 737             {
 738                 *pi64 = I64C(1000000) * ( stream_Size( p_demux->s ) / 50 ) /
 739                         p_sys->i_mux_rate;
 740                 return VLC_SUCCESS;
 741             }
 742             *pi64 = 0;
 743             return VLC_EGENERIC;
 744 #endif
 745         case DEMUX_GET_FPS:
 746         case DEMUX_SET_TIME:
 747         default:
 748             return VLC_EGENERIC;
 749     }
 750 }
 751
 752 static void PIDInit( ts_pid_t *pid, vlc_bool_t b_psi, ts_psi_t *p_owner )
 753 {
 754     vlc_bool_t b_old_valid = pid->b_valid;
 755
 756     pid->b_valid    = VLC_TRUE;
 757     pid->i_cc       = 0xff;
 758     pid->p_owner    = p_owner;
 759     pid->i_owner_number = 0;
 760
 761     pid->extra_es   = NULL;
 762     pid->i_extra_es = 0;
 763
 764     if( b_psi )
 765     {
 766         pid->es  = NULL;
 767
 768         if( !b_old_valid )
 769         {
 770             pid->psi = malloc( sizeof( ts_psi_t ) );
 771             pid->psi->i_prg = 0;
 772             pid->psi->prg   = NULL;
 773             pid->psi->handle= NULL;
 774         }
 775         pid->psi->i_pat_version  = -1;
 776         if( p_owner )
 777         {
 778             ts_prg_psi_t *prg = malloc( sizeof( ts_prg_psi_t ) );
 779             /* PMT */
 780             prg->i_version  = -1;
 781             prg->i_number   = -1;
 782             prg->i_pid_pcr  = -1;
 783             prg->iod        = NULL;
 784             prg->handle     = NULL;
 785
 786             TAB_APPEND( pid->psi->i_prg, pid->psi->prg, prg );
 787         }
 788     }
 789     else
 790     {
 791         pid->psi = NULL;
 792         pid->es  = malloc( sizeof( ts_es_t ) );
 793
 794         es_format_Init( &pid->es->fmt, UNKNOWN_ES, 0 );
 795         pid->es->id      = NULL;
 796         pid->es->p_pes   = NULL;
 797         pid->es->i_pes_size= 0;
 798         pid->es->i_pes_gathered= 0;
 799         pid->es->pp_last = &pid->es->p_pes;
 800         pid->es->p_mpeg4desc = NULL;
 801         pid->es->b_gather = VLC_FALSE;
 802     }
 803 }
 804
 805 static void PIDClean( es_out_t *out, ts_pid_t *pid )
 806 {
 807     if( pid->psi )
 808     {
 809         int i;
 810
 811         if( pid->psi->handle ) dvbpsi_DetachPMT( pid->psi->handle );
 812         for( i = 0; i < pid->psi->i_prg; i++ )
 813         {
 814             if( pid->psi->prg[i]->iod ) IODFree( pid->psi->prg[i]->iod );
 815             if( pid->psi->prg[i]->handle ) dvbpsi_DetachPMT( pid->psi->prg[i]->handle );
 816             free( pid->psi->prg[i] );
 817         }
 818         if( pid->psi->prg ) free( pid->psi->prg );
 819         free( pid->psi );
 820     }
 821     else
 822     {
 823         int i;
 824
 825         if( pid->es->id )
 826             es_out_Del( out, pid->es->id );
 827
 828         if( pid->es->p_pes )
 829             block_ChainRelease( pid->es->p_pes );
 830
 831         es_format_Clean( &pid->es->fmt );
 832
 833         free( pid->es );
 834
 835         for( i = 0; i < pid->i_extra_es; i++ )
 836         {
 837             if( pid->extra_es[i]->id )
 838                 es_out_Del( out, pid->extra_es[i]->id );
 839
 840             if( pid->extra_es[i]->p_pes )
 841                 block_ChainRelease( pid->extra_es[i]->p_pes );
 842
 843             es_format_Clean( &pid->extra_es[i]->fmt );
 844
 845             free( pid->extra_es[i] );
 846         }
 847         if( pid->i_extra_es ) free( pid->extra_es );
 848     }
 849
 850     pid->b_valid = VLC_FALSE;
 851 }
 852
 853 /****************************************************************************
 854  * gathering stuff
 855  ****************************************************************************/
 856 static void ParsePES ( demux_t *p_demux, ts_pid_t *pid )
 857 {
 858     block_t *p_pes = pid->es->p_pes;
 859     uint8_t header[30];
 860     int     i_pes_size = 0;
 861     int     i_skip = 0;
 862     mtime_t i_dts = -1;
 863     mtime_t i_pts = -1;
 864     mtime_t i_length = 0;
 865     int i_max;
 866
 867     /* remove the pes from pid */
 868     pid->es->p_pes = NULL;
 869     pid->es->i_pes_size= 0;
 870     pid->es->i_pes_gathered= 0;
 871     pid->es->pp_last = &pid->es->p_pes;
 872
 873     /* FIXME find real max size */
 874     i_max = block_ChainExtract( p_pes, header, 30 );
 875
 876     if( header[0] != 0 || header[1] != 0 || header[2] != 1 )
 877     {
 878         if ( !p_demux->p_sys->b_silent )
 879             msg_Warn( p_demux, "invalid header [0x%x:%x:%x:%x]", header[0],
 880                       header[1],header[2],header[3] );
 881         block_ChainRelease( p_pes );
 882         return;
 883     }
 884
 885     /* TODO check size */
 886     switch( header[3] )
 887     {
 888         case 0xBC:  /* Program stream map */
 889         case 0xBE:  /* Padding */
 890         case 0xBF:  /* Private stream 2 */
 891         case 0xB0:  /* ECM */
 892         case 0xB1:  /* EMM */
 893         case 0xFF:  /* Program stream directory */
 894         case 0xF2:  /* DSMCC stream */
 895         case 0xF8:  /* ITU-T H.222.1 type E stream */
 896             i_skip = 6;
 897             break;
 898         default:
 899             if( ( header[6]&0xC0 ) == 0x80 )
 900             {
 901                 /* mpeg2 PES */
 902                 i_skip = header[8] + 9;
 903
 904                 if( header[7]&0x80 )    /* has pts */
 905                 {
 906                     i_pts = ((mtime_t)(header[ 9]&0x0e ) << 29)|
 907                              (mtime_t)(header[10] << 22)|
 908                             ((mtime_t)(header[11]&0xfe) << 14)|
 909                              (mtime_t)(header[12] << 7)|
 910                              (mtime_t)(header[13] >> 1);
 911
 912                     if( header[7]&0x40 )    /* has dts */
 913                     {
 914                          i_dts = ((mtime_t)(header[14]&0x0e ) << 29)|
 915                                  (mtime_t)(header[15] << 22)|
 916                                 ((mtime_t)(header[16]&0xfe) << 14)|
 917                                  (mtime_t)(header[17] << 7)|
 918                                  (mtime_t)(header[18] >> 1);
 919                     }
 920                 }
 921             }
 922             else
 923             {
 924                 i_skip = 6;
 925                 while( i_skip < 23 && header[i_skip] == 0xff )
 926                 {
 927                     i_skip++;
 928                 }
 929                 if( i_skip == 23 )
 930                 {
 931                     msg_Err( p_demux, "too much MPEG-1 stuffing" );
 932                     block_ChainRelease( p_pes );
 933                     return;
 934                 }
 935                 if( ( header[i_skip] & 0xC0 ) == 0x40 )
 936                 {
 937                     i_skip += 2;
 938                 }
 939
 940                 if(  header[i_skip]&0x20 )
 941                 {
 942                      i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
 943                               (mtime_t)(header[i_skip+1] << 22)|
 944                              ((mtime_t)(header[i_skip+2]&0xfe) << 14)|
 945                               (mtime_t)(header[i_skip+3] << 7)|
 946                               (mtime_t)(header[i_skip+4] >> 1);
 947
 948                     if( header[i_skip]&0x10 )    /* has dts */
 949                     {
 950                          i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
 951                                   (mtime_t)(header[i_skip+6] << 22)|
 952                                  ((mtime_t)(header[i_skip+7]&0xfe) << 14)|
 953                                   (mtime_t)(header[i_skip+8] << 7)|
 954                                   (mtime_t)(header[i_skip+9] >> 1);
 955                          i_skip += 10;
 956                     }
 957                     else
 958                     {
 959                         i_skip += 5;
 960                     }
 961                 }
 962                 else
 963                 {
 964                     i_skip += 1;
 965                 }
 966             }
 967             break;
 968     }
 969
 970     if( pid->es->fmt.i_codec == VLC_FOURCC( 'a', '5', '2', 'b' ) ||
 971         pid->es->fmt.i_codec == VLC_FOURCC( 'd', 't', 's', 'b' ) )
 972     {
 973         i_skip += 4;
 974     }
 975     else if( pid->es->fmt.i_codec == VLC_FOURCC( 'l', 'p', 'c', 'b' ) ||
 976              pid->es->fmt.i_codec == VLC_FOURCC( 's', 'p', 'u', 'b' ) ||
 977              pid->es->fmt.i_codec == VLC_FOURCC( 's', 'd', 'd', 'b' ) )
 978     {
 979         i_skip += 1;
 980     }
 981     else if( pid->es->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) && pid->es->p_mpeg4desc )
 982     {
 983         decoder_config_descriptor_t *dcd = &pid->es->p_mpeg4desc->dec_descr;
 984
 985         if( dcd->i_decoder_specific_info_len > 2 &&
 986             dcd->p_decoder_specific_info[0] == 0x10 &&
 987             ( dcd->p_decoder_specific_info[1]&0x10 ) )
 988         {
 989             /* display length */
 990             if( p_pes->i_buffer + 2 <= i_skip )
 991             {
 992                 i_length = GetWBE( &p_pes->p_buffer[i_skip] );
 993             }
 994
 995             i_skip += 2;
 996         }
 997         if( p_pes->i_buffer + 2 <= i_skip )
 998         {
 999             i_pes_size = GetWBE( &p_pes->p_buffer[i_skip] );
1000         }
1001         /* */
1002         i_skip += 2;
1003     }
1004
1005     /* skip header */
1006     while( p_pes && i_skip > 0 )
1007     {
1008         if( p_pes->i_buffer <= i_skip )
1009         {
1010             block_t *p_next = p_pes->p_next;
1011
1012             i_skip -= p_pes->i_buffer;
1013             block_Release( p_pes );
1014             p_pes = p_next;
1015         }
1016         else
1017         {
1018             p_pes->i_buffer -= i_skip;
1019             p_pes->p_buffer += i_skip;
1020             break;
1021         }
1022     }
1023
1024     if( p_pes )
1025     {
1026         block_t *p_block;
1027         int i;
1028
1029         if( i_dts >= 0 )
1030         {
1031             p_pes->i_dts = i_dts * 100 / 9;
1032         }
1033         if( i_pts >= 0 )
1034         {
1035             p_pes->i_pts = i_pts * 100 / 9;
1036         }
1037         p_pes->i_length = i_length * 100 / 9;
1038
1039         p_block = block_ChainGather( p_pes );
1040         if( pid->es->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) )
1041         {
1042             if( i_pes_size > 0 && p_block->i_buffer > i_pes_size )
1043             {
1044                 p_block->i_buffer = i_pes_size;
1045             }
1046             /* Append a \0 */
1047             p_block = block_Realloc( p_block, 0, p_block->i_buffer + 1 );
1048             p_block->p_buffer[p_block->i_buffer -1] = '\0';
1049         }
1050
1051         for( i = 0; i < pid->i_extra_es; i++ )
1052         {
1053             es_out_Send( p_demux->out, pid->extra_es[i]->id,
1054                          block_Duplicate( p_block ) );
1055         }
1056
1057         es_out_Send( p_demux->out, pid->es->id, p_block );
1058     }
1059     else
1060     {
1061         msg_Warn( p_demux, "empty pes" );
1062     }
1063 }
1064
1065 static void PCRHandle( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
1066 {
1067     demux_sys_t   *p_sys = p_demux->p_sys;
1068     const uint8_t *p = p_bk->p_buffer;
1069
1070     if( ( p[3]&0x20 ) && /* adaptation */
1071         ( p[5]&0x10 ) &&
1072         ( p[4] >= 7 ) )
1073     {
1074         int i;
1075         mtime_t i_pcr;  /* 33 bits */
1076
1077         i_pcr = ( (mtime_t)p[6] << 25 ) |
1078                 ( (mtime_t)p[7] << 17 ) |
1079                 ( (mtime_t)p[8] << 9 ) |
1080                 ( (mtime_t)p[9] << 1 ) |
1081                 ( (mtime_t)p[10] >> 7 );
1082
1083         /* Search program and set the PCR */
1084         for( i = 0; i < p_sys->i_pmt; i++ )
1085         {
1086             int i_prg;
1087             for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
1088             {
1089                 if( pid->i_pid == p_sys->pmt[i]->psi->prg[i_prg]->i_pid_pcr )
1090                 {
1091                     es_out_Control( p_demux->out, ES_OUT_SET_GROUP_PCR,
1092                                     (int)p_sys->pmt[i]->psi->prg[i_prg]->i_number,
1093                                     (int64_t)(i_pcr * 100 / 9) );
1094                 }
1095             }
1096         }
1097     }
1098 }
1099
1100 static vlc_bool_t GatherPES( demux_t *p_demux, ts_pid_t *pid, block_t *p_bk )
1101 {
1102     const uint8_t    *p = p_bk->p_buffer;
1103     const vlc_bool_t  b_adaptation= p[3]&0x20;
1104     const vlc_bool_t  b_payload   = p[3]&0x10;
1105     const int         i_cc        = p[3]&0x0f;   /* continuity counter */
1106     /* transport_scrambling_control is ignored */
1107
1108     int         i_skip = 0;
1109     vlc_bool_t  i_ret   = VLC_FALSE;
1110
1111     int         i_diff;
1112
1113     //msg_Dbg( p_demux, "pid=0x%x unit_start=%d adaptation=%d payload=%d cc=0x%x", i_pid, b_unit_start, b_adaptation, b_payload, i_continuity_counter);
1114     if( p[1]&0x80 )
1115     {
1116         msg_Dbg( p_demux, "transport_error_indicator set (pid=0x%x)", pid->i_pid );
1117     }
1118
1119     if( p_demux->p_sys->csa )
1120     {
1121         csa_Decrypt( p_demux->p_sys->csa, p_bk->p_buffer );
1122     }
1123
1124     if( !b_adaptation )
1125     {
1126         i_skip = 4;
1127     }
1128     else
1129     {
1130         /* p[4] is adaptation length */
1131         i_skip = 5 + p[4];
1132         if( p[4] > 0 )
1133         {
1134             if( p[5]&0x80 )
1135             {
1136                 msg_Warn( p_demux, "discontinuity_indicator (pid=0x%x) "
1137                           "ignored", pid->i_pid );
1138             }
1139         }
1140     }
1141     /* test continuity counter */
1142     /* continuous when (one of this):
1143         * diff == 1
1144         * diff == 0 and payload == 0
1145         * diff == 0 and duplicate packet (playload != 0) <- do we should test the content ?
1146      */
1147
1148     i_diff = ( i_cc - pid->i_cc )&0x0f;
1149     if( b_payload && i_diff == 1 )
1150     {
1151         pid->i_cc++;
1152     }
1153     else
1154     {
1155         if( pid->i_cc == 0xff )
1156         {
1157             msg_Warn( p_demux, "first packet for pid=0x%x cc=0x%x",
1158                       pid->i_pid, i_cc );
1159             pid->i_cc = i_cc;
1160         }
1161         else if( i_diff != 0 )
1162         {
1163             /* FIXME what to do when discontinuity_indicator is set ? */
1164             msg_Warn( p_demux, "discontinuity received 0x%x instead of 0x%x",
1165                       i_cc, ( pid->i_cc + 1 )&0x0f );
1166
1167             pid->i_cc = i_cc;
1168
1169             if( pid->es->p_pes )
1170             {
1171                 pid->es->p_pes->i_flags |= BLOCK_FLAG_DISCONTINUITY;
1172             }
1173         }
1174     }
1175
1176     PCRHandle( p_demux, pid, p_bk );
1177
1178     if( i_skip >= 188 || pid->es->id == NULL || p_demux->p_sys->b_udp_out )
1179     {
1180         block_Release( p_bk );
1181     }
1182     else
1183     {
1184         const vlc_bool_t b_unit_start= p[1]&0x40;
1185
1186         /* we have to gather it */
1187         p_bk->p_buffer += i_skip;
1188         p_bk->i_buffer -= i_skip;
1189
1190         if( b_unit_start )
1191         {
1192             if( pid->es->p_pes )
1193             {
1194                 ParsePES( p_demux, pid );
1195                 i_ret = VLC_TRUE;
1196             }
1197
1198             block_ChainLastAppend( &pid->es->pp_last, p_bk );
1199             if( p_bk->i_buffer > 6 )
1200             {
1201                 pid->es->i_pes_size = GetWBE( &p_bk->p_buffer[4] );
1202                 if( pid->es->i_pes_size > 0 )
1203                 {
1204                     pid->es->i_pes_size += 6;
1205                 }
1206             }
1207             pid->es->i_pes_gathered += p_bk->i_buffer;
1208             if( pid->es->i_pes_size > 0 &&
1209                 pid->es->i_pes_gathered >= pid->es->i_pes_size )
1210             {
1211                 ParsePES( p_demux, pid );
1212                 i_ret = VLC_TRUE;
1213             }
1214         }
1215         else
1216         {
1217             if( pid->es->p_pes == NULL )
1218             {
1219                 /* msg_Dbg( p_demux, "broken packet" ); */
1220                 block_Release( p_bk );
1221             }
1222             else
1223             {
1224                 block_ChainLastAppend( &pid->es->pp_last, p_bk );
1225                 pid->es->i_pes_gathered += p_bk->i_buffer;
1226                 if( pid->es->i_pes_size > 0 &&
1227                     pid->es->i_pes_gathered >= pid->es->i_pes_size )
1228                 {
1229                     ParsePES( p_demux, pid );
1230                     i_ret = VLC_TRUE;
1231                 }
1232             }
1233         }
1234     }
1235
1236     return i_ret;
1237 }
1238
1239 static int PIDFillFormat( ts_pid_t *pid, int i_stream_type )
1240 {
1241     es_format_t *fmt = &pid->es->fmt;
1242
1243     switch( i_stream_type )
1244     {
1245         case 0x01:  /* MPEG-1 video */
1246         case 0x02:  /* MPEG-2 video */
1247         case 0x80:  /* MPEG-2 MOTO video */
1248             es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) );
1249             break;
1250         case 0x03:  /* MPEG-1 audio */
1251         case 0x04:  /* MPEG-2 audio */
1252             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', 'g', 'a' ) );
1253             break;
1254         case 0x11:  /* MPEG4 (audio) */
1255         case 0x0f:  /* ISO/IEC 13818-7 Audio with ADTS transport syntax */
1256             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', '4', 'a' ) );
1257             break;
1258         case 0x10:  /* MPEG4 (video) */
1259             es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', '4', 'v' ) );
1260             pid->es->b_gather = VLC_TRUE;
1261             break;
1262         case 0x1B:  /* H264 <- check transport syntax/needed descriptor */
1263             es_format_Init( fmt, VIDEO_ES, VLC_FOURCC( 'h', '2', '6', '4' ) );
1264             break;
1265
1266         case 0x81:  /* A52 (audio) */
1267             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', ' ' ) );
1268             break;
1269         case 0x82:  /* DVD_SPU (sub) */
1270             es_format_Init( fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', ' ' ) );
1271             break;
1272         case 0x83:  /* LPCM (audio) */
1273             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'l', 'p', 'c', 'm' ) );
1274             break;
1275         case 0x84:  /* SDDS (audio) */
1276             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 's', 'd', 'd', 's' ) );
1277             break;
1278         case 0x85:  /* DTS (audio) */
1279             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'd', 't', 's', ' ' ) );
1280             break;
1281
1282         case 0x91:  /* A52 vls (audio) */
1283             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', 'b' ) );
1284             break;
1285         case 0x92:  /* DVD_SPU vls (sub) */
1286             es_format_Init( fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', 'b' ) );
1287             break;
1288         case 0x93:  /* LPCM vls (audio) */
1289             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 'l', 'p', 'c', 'b' ) );
1290             break;
1291         case 0x94:  /* SDDS (audio) */
1292             es_format_Init( fmt, AUDIO_ES, VLC_FOURCC( 's', 'd', 'd', 'b' ) );
1293             break;
1294
1295         case 0xa0:  /* MSCODEC vlc (video) (fixed later) */
1296             es_format_Init( fmt, UNKNOWN_ES, 0 );
1297             pid->es->b_gather = VLC_TRUE;
1298             break;
1299
1300         case 0x06:  /* PES_PRIVATE  (fixed later) */
1301         case 0x12:  /* MPEG-4 generic (sub/scene/...) (fixed later) */
1302         default:
1303             es_format_Init( fmt, UNKNOWN_ES, 0 );
1304             break;
1305     }
1306
1307     /* PES packets usually contain truncated frames */
1308     fmt->b_packetized = VLC_FALSE;
1309
1310     return fmt->i_cat == UNKNOWN_ES ? VLC_EGENERIC : VLC_SUCCESS ;
1311 }
1312
1313 /*****************************************************************************
1314  * MP4 specific functions (IOD parser)
1315  *****************************************************************************/
1316 static int  IODDescriptorLength( int *pi_data, uint8_t **pp_data )
1317 {
1318     unsigned int i_b;
1319     unsigned int i_len = 0;
1320     do
1321     {
1322         i_b = **pp_data;
1323         (*pp_data)++;
1324         (*pi_data)--;
1325         i_len = ( i_len << 7 ) + ( i_b&0x7f );
1326
1327     } while( i_b&0x80 );
1328
1329     return( i_len );
1330 }
1331 static int IODGetByte( int *pi_data, uint8_t **pp_data )
1332 {
1333     if( *pi_data > 0 )
1334     {
1335         const int i_b = **pp_data;
1336         (*pp_data)++;
1337         (*pi_data)--;
1338         return( i_b );
1339     }
1340     return( 0 );
1341 }
1342 static int IODGetWord( int *pi_data, uint8_t **pp_data )
1343 {
1344     const int i1 = IODGetByte( pi_data, pp_data );
1345     const int i2 = IODGetByte( pi_data, pp_data );
1346     return( ( i1 << 8 ) | i2 );
1347 }
1348 static int IODGet3Bytes( int *pi_data, uint8_t **pp_data )
1349 {
1350     const int i1 = IODGetByte( pi_data, pp_data );
1351     const int i2 = IODGetByte( pi_data, pp_data );
1352     const int i3 = IODGetByte( pi_data, pp_data );
1353
1354     return( ( i1 << 16 ) | ( i2 << 8) | i3 );
1355 }
1356
1357 static uint32_t IODGetDWord( int *pi_data, uint8_t **pp_data )
1358 {
1359     const uint32_t i1 = IODGetWord( pi_data, pp_data );
1360     const uint32_t i2 = IODGetWord( pi_data, pp_data );
1361     return( ( i1 << 16 ) | i2 );
1362 }
1363
1364 static char* IODGetURL( int *pi_data, uint8_t **pp_data )
1365 {
1366     char *url;
1367     int i_url_len, i;
1368
1369     i_url_len = IODGetByte( pi_data, pp_data );
1370     url = malloc( i_url_len + 1 );
1371     for( i = 0; i < i_url_len; i++ )
1372     {
1373         url[i] = IODGetByte( pi_data, pp_data );
1374     }
1375     url[i_url_len] = '\0';
1376     return( url );
1377 }
1378
1379 static iod_descriptor_t *IODNew( int i_data, uint8_t *p_data )
1380 {
1381     iod_descriptor_t *p_iod;
1382     int i;
1383     int i_es_index;
1384     uint8_t     i_flags;
1385     vlc_bool_t  b_url;
1386     int         i_iod_length;
1387
1388     p_iod = malloc( sizeof( iod_descriptor_t ) );
1389     memset( p_iod, 0, sizeof( iod_descriptor_t ) );
1390
1391     fprintf( stderr, "\n************ IOD ************" );
1392     for( i = 0; i < 255; i++ )
1393     {
1394         p_iod->es_descr[i].b_ok = 0;
1395     }
1396     i_es_index = 0;
1397
1398     if( i_data < 3 )
1399     {
1400         return p_iod;
1401     }
1402
1403     p_iod->i_iod_label = IODGetByte( &i_data, &p_data );
1404     fprintf( stderr, "\n* iod_label:%d", p_iod->i_iod_label );
1405     fprintf( stderr, "\n* ===========" );
1406     fprintf( stderr, "\n* tag:0x%x", p_data[0] );
1407
1408     if( IODGetByte( &i_data, &p_data ) != 0x02 )
1409     {
1410         fprintf( stderr, "\n ERR: tag != 0x02" );
1411         return p_iod;
1412     }
1413
1414     i_iod_length = IODDescriptorLength( &i_data, &p_data );
1415     fprintf( stderr, "\n* length:%d", i_iod_length );
1416     if( i_iod_length > i_data )
1417     {
1418         i_iod_length = i_data;
1419     }
1420
1421     p_iod->i_od_id = ( IODGetByte( &i_data, &p_data ) << 2 );
1422     i_flags = IODGetByte( &i_data, &p_data );
1423     p_iod->i_od_id |= i_flags >> 6;
1424     b_url = ( i_flags >> 5  )&0x01;
1425
1426     fprintf( stderr, "\n* od_id:%d", p_iod->i_od_id );
1427     fprintf( stderr, "\n* url flag:%d", b_url );
1428     fprintf( stderr, "\n* includeInlineProfileLevel flag:%d", ( i_flags >> 4 )&0x01 );
1429
1430     if( b_url )
1431     {
1432         p_iod->psz_url = IODGetURL( &i_data, &p_data );
1433         fprintf( stderr, "\n* url string:%s", p_iod->psz_url );
1434         fprintf( stderr, "\n*****************************\n" );
1435         return p_iod;
1436     }
1437     else
1438     {
1439         p_iod->psz_url = NULL;
1440     }
1441
1442     p_iod->i_ODProfileLevelIndication = IODGetByte( &i_data, &p_data );
1443     p_iod->i_sceneProfileLevelIndication = IODGetByte( &i_data, &p_data );
1444     p_iod->i_audioProfileLevelIndication = IODGetByte( &i_data, &p_data );
1445     p_iod->i_visualProfileLevelIndication = IODGetByte( &i_data, &p_data );
1446     p_iod->i_graphicsProfileLevelIndication = IODGetByte( &i_data, &p_data );
1447
1448     fprintf( stderr, "\n* ODProfileLevelIndication:%d", p_iod->i_ODProfileLevelIndication );
1449     fprintf( stderr, "\n* sceneProfileLevelIndication:%d", p_iod->i_sceneProfileLevelIndication );
1450     fprintf( stderr, "\n* audioProfileLevelIndication:%d", p_iod->i_audioProfileLevelIndication );
1451     fprintf( stderr, "\n* visualProfileLevelIndication:%d", p_iod->i_visualProfileLevelIndication );
1452     fprintf( stderr, "\n* graphicsProfileLevelIndication:%d", p_iod->i_graphicsProfileLevelIndication );
1453
1454
1455     while( i_data > 0 && i_es_index < 255)
1456     {
1457         int i_tag, i_length;
1458         int     i_data_sav;
1459         uint8_t *p_data_sav;
1460
1461         i_tag = IODGetByte( &i_data, &p_data );
1462         i_length = IODDescriptorLength( &i_data, &p_data );
1463
1464         i_data_sav = i_data;
1465         p_data_sav = p_data;
1466
1467         i_data = i_length;
1468
1469         switch( i_tag )
1470         {
1471             case 0x03:
1472                 {
1473 #define es_descr    p_iod->es_descr[i_es_index]
1474                     int i_decoderConfigDescr_length;
1475                     fprintf( stderr, "\n* - ES_Descriptor length:%d", i_length );
1476                     es_descr.b_ok = 1;
1477
1478                     es_descr.i_es_id = IODGetWord( &i_data, &p_data );
1479                     i_flags = IODGetByte( &i_data, &p_data );
1480                     es_descr.b_streamDependenceFlag = ( i_flags >> 7 )&0x01;
1481                     b_url = ( i_flags >> 6 )&0x01;
1482                     es_descr.b_OCRStreamFlag = ( i_flags >> 5 )&0x01;
1483                     es_descr.i_streamPriority = i_flags & 0x1f;
1484                     fprintf( stderr, "\n*   * streamDependenceFlag:%d", es_descr.b_streamDependenceFlag );
1485                     fprintf( stderr, "\n*   * OCRStreamFlag:%d", es_descr.b_OCRStreamFlag );
1486                     fprintf( stderr, "\n*   * streamPriority:%d", es_descr.i_streamPriority );
1487
1488                     if( es_descr.b_streamDependenceFlag )
1489                     {
1490                         es_descr.i_dependOn_es_id = IODGetWord( &i_data, &p_data );
1491                         fprintf( stderr, "\n*   * dependOn_es_id:%d", es_descr.i_dependOn_es_id );
1492                     }
1493
1494                     if( b_url )
1495                     {
1496                         es_descr.psz_url = IODGetURL( &i_data, &p_data );
1497                         fprintf( stderr, "\n* url string:%s", es_descr.psz_url );
1498                     }
1499                     else
1500                     {
1501                         es_descr.psz_url = NULL;
1502                     }
1503
1504                     if( es_descr.b_OCRStreamFlag )
1505                     {
1506                         es_descr.i_OCR_es_id = IODGetWord( &i_data, &p_data );
1507                         fprintf( stderr, "\n*   * OCR_es_id:%d", es_descr.i_OCR_es_id );
1508                     }
1509
1510                     if( IODGetByte( &i_data, &p_data ) != 0x04 )
1511                     {
1512                         fprintf( stderr, "\n* ERR missing DecoderConfigDescr" );
1513                         es_descr.b_ok = 0;
1514                         break;
1515                     }
1516                     i_decoderConfigDescr_length = IODDescriptorLength( &i_data, &p_data );
1517
1518                     fprintf( stderr, "\n*   - DecoderConfigDesc length:%d", i_decoderConfigDescr_length );
1519 #define dec_descr   es_descr.dec_descr
1520                     dec_descr.i_objectTypeIndication = IODGetByte( &i_data, &p_data );
1521                     i_flags = IODGetByte( &i_data, &p_data );
1522                     dec_descr.i_streamType = i_flags >> 2;
1523                     dec_descr.b_upStream = ( i_flags >> 1 )&0x01;
1524                     dec_descr.i_bufferSizeDB = IODGet3Bytes( &i_data, &p_data );
1525                     dec_descr.i_maxBitrate = IODGetDWord( &i_data, &p_data );
1526                     dec_descr.i_avgBitrate = IODGetDWord( &i_data, &p_data );
1527                     fprintf( stderr, "\n*     * objectTypeIndication:0x%x", dec_descr.i_objectTypeIndication  );
1528                     fprintf( stderr, "\n*     * streamType:0x%x", dec_descr.i_streamType );
1529                     fprintf( stderr, "\n*     * upStream:%d", dec_descr.b_upStream );
1530                     fprintf( stderr, "\n*     * bufferSizeDB:%d", dec_descr.i_bufferSizeDB );
1531                     fprintf( stderr, "\n*     * maxBitrate:%d", dec_descr.i_maxBitrate );
1532                     fprintf( stderr, "\n*     * avgBitrate:%d", dec_descr.i_avgBitrate );
1533                     if( i_decoderConfigDescr_length > 13 && IODGetByte( &i_data, &p_data ) == 0x05 )
1534                     {
1535                         int i;
1536                         dec_descr.i_decoder_specific_info_len =
1537                             IODDescriptorLength( &i_data, &p_data );
1538                         if( dec_descr.i_decoder_specific_info_len > 0 )
1539                         {
1540                             dec_descr.p_decoder_specific_info =
1541                                 malloc( dec_descr.i_decoder_specific_info_len );
1542                         }
1543                         for( i = 0; i < dec_descr.i_decoder_specific_info_len; i++ )
1544                         {
1545                             dec_descr.p_decoder_specific_info[i] = IODGetByte( &i_data, &p_data );
1546                         }
1547                     }
1548                     else
1549                     {
1550                         dec_descr.i_decoder_specific_info_len = 0;
1551                         dec_descr.p_decoder_specific_info = NULL;
1552                     }
1553                 }
1554 #undef  dec_descr
1555 #define sl_descr    es_descr.sl_descr
1556                 {
1557                     int i_SLConfigDescr_length;
1558                     int i_predefined;
1559
1560                     if( IODGetByte( &i_data, &p_data ) != 0x06 )
1561                     {
1562                         fprintf( stderr, "\n* ERR missing SLConfigDescr" );
1563                         es_descr.b_ok = 0;
1564                         break;
1565                     }
1566                     i_SLConfigDescr_length = IODDescriptorLength( &i_data, &p_data );
1567
1568                     fprintf( stderr, "\n*   - SLConfigDescr length:%d", i_SLConfigDescr_length );
1569                     i_predefined = IODGetByte( &i_data, &p_data );
1570                     fprintf( stderr, "\n*     * i_predefined:0x%x", i_predefined  );
1571                     switch( i_predefined )
1572                     {
1573                         case 0x01:
1574                             {
1575                                 sl_descr.b_useAccessUnitStartFlag   = 0;
1576                                 sl_descr.b_useAccessUnitEndFlag     = 0;
1577                                 sl_descr.b_useRandomAccessPointFlag = 0;
1578                                 //sl_descr.b_useRandomAccessUnitsOnlyFlag = 0;
1579                                 sl_descr.b_usePaddingFlag           = 0;
1580                                 sl_descr.b_useTimeStampsFlags       = 0;
1581                                 sl_descr.b_useIdleFlag              = 0;
1582                                 sl_descr.b_durationFlag     = 0;    // FIXME FIXME
1583                                 sl_descr.i_timeStampResolution      = 1000;
1584                                 sl_descr.i_OCRResolution    = 0;    // FIXME FIXME
1585                                 sl_descr.i_timeStampLength          = 32;
1586                                 sl_descr.i_OCRLength        = 0;    // FIXME FIXME
1587                                 sl_descr.i_AU_Length                = 0;
1588                                 sl_descr.i_instantBitrateLength= 0; // FIXME FIXME
1589                                 sl_descr.i_degradationPriorityLength= 0;
1590                                 sl_descr.i_AU_seqNumLength          = 0;
1591                                 sl_descr.i_packetSeqNumLength       = 0;
1592                                 if( sl_descr.b_durationFlag )
1593                                 {
1594                                     sl_descr.i_timeScale            = 0;    // FIXME FIXME
1595                                     sl_descr.i_accessUnitDuration   = 0;    // FIXME FIXME
1596                                     sl_descr.i_compositionUnitDuration= 0;    // FIXME FIXME
1597                                 }
1598                                 if( !sl_descr.b_useTimeStampsFlags )
1599                                 {
1600                                     sl_descr.i_startDecodingTimeStamp   = 0;    // FIXME FIXME
1601                                     sl_descr.i_startCompositionTimeStamp= 0;    // FIXME FIXME
1602                                 }
1603                             }
1604                             break;
1605                         default:
1606                             fprintf( stderr, "\n* ERR unsupported SLConfigDescr predefined" );
1607                             es_descr.b_ok = 0;
1608                             break;
1609                     }
1610                 }
1611                 break;
1612 #undef  sl_descr
1613 #undef  es_descr
1614             default:
1615                 fprintf( stderr, "\n* - OD tag:0x%x length:%d (Unsupported)", i_tag, i_length );
1616                 break;
1617         }
1618
1619         p_data = p_data_sav + i_length;
1620         i_data = i_data_sav - i_length;
1621         i_es_index++;
1622     }
1623
1624
1625     fprintf( stderr, "\n*****************************\n" );
1626     return p_iod;
1627 }
1628
1629 static void IODFree( iod_descriptor_t *p_iod )
1630 {
1631     int i;
1632
1633     if( p_iod->psz_url )
1634     {
1635         free( p_iod->psz_url );
1636         p_iod->psz_url = NULL;
1637         free( p_iod );
1638         return;
1639     }
1640
1641     for( i = 0; i < 255; i++ )
1642     {
1643 #define es_descr p_iod->es_descr[i]
1644         if( es_descr.b_ok )
1645         {
1646             if( es_descr.psz_url )
1647             {
1648                 free( es_descr.psz_url );
1649                 es_descr.psz_url = NULL;
1650             }
1651             else
1652             {
1653                 if( es_descr.dec_descr.p_decoder_specific_info != NULL )
1654                 {
1655                     free( es_descr.dec_descr.p_decoder_specific_info );
1656                     es_descr.dec_descr.p_decoder_specific_info = NULL;
1657                     es_descr.dec_descr.i_decoder_specific_info_len = 0;
1658                 }
1659             }
1660         }
1661         es_descr.b_ok = 0;
1662 #undef  es_descr
1663     }
1664     free( p_iod );
1665 }
1666
1667 /****************************************************************************
1668  ****************************************************************************
1669  ** libdvbpsi callbacks
1670  ****************************************************************************
1671  ****************************************************************************/
1672 static void PMTCallBack( demux_t *p_demux, dvbpsi_pmt_t *p_pmt )
1673 {
1674     demux_sys_t          *p_sys = p_demux->p_sys;
1675     dvbpsi_descriptor_t  *p_dr;
1676     dvbpsi_pmt_es_t      *p_es;
1677
1678     ts_pid_t             *pmt = NULL;
1679     ts_prg_psi_t         *prg = NULL;
1680     int                  i;
1681
1682     msg_Dbg( p_demux, "PMTCallBack called" );
1683
1684     /* First find this PMT declared in PAT */
1685     for( i = 0; i < p_sys->i_pmt; i++ )
1686     {
1687         int i_prg;
1688         for( i_prg = 0; i_prg < p_sys->pmt[i]->psi->i_prg; i_prg++ )
1689         {
1690             if( p_sys->pmt[i]->psi->prg[i_prg]->i_number == p_pmt->i_program_number )
1691             {
1692                 pmt = p_sys->pmt[i];
1693                 prg = p_sys->pmt[i]->psi->prg[i_prg];
1694                 break;
1695             }
1696         }
1697         if( pmt )
1698             break;
1699     }
1700
1701     if( pmt == NULL )
1702     {
1703         msg_Warn( p_demux, "unreferenced program (broken stream)" );
1704         dvbpsi_DeletePMT(p_pmt);
1705         return;
1706     }
1707
1708     if( prg->i_version != -1 &&
1709         ( !p_pmt->b_current_next || prg->i_version == p_pmt->i_version ) )
1710     {
1711         dvbpsi_DeletePMT( p_pmt );
1712         return;
1713     }
1714
1715     /* Clean this program (remove all es) */
1716     for( i = 0; i < 8192; i++ )
1717     {
1718         ts_pid_t *pid = &p_sys->pid[i];
1719
1720         if( pid->b_valid && pid->p_owner == pmt->psi && pid->i_owner_number == prg->i_number && pid->psi == NULL )
1721         {
1722             PIDClean( p_demux->out, pid );
1723         }
1724     }
1725     if( prg->iod )
1726     {
1727         IODFree( prg->iod );
1728         prg->iod = NULL;
1729     }
1730
1731     msg_Dbg( p_demux, "new PMT program number=%d version=%d pid_pcr=0x%x",
1732              p_pmt->i_program_number, p_pmt->i_version, p_pmt->i_pcr_pid );
1733     prg->i_pid_pcr = p_pmt->i_pcr_pid;
1734     prg->i_version = p_pmt->i_version;
1735
1736     /* Parse descriptor */
1737     for( p_dr = p_pmt->p_first_descriptor; p_dr != NULL; p_dr = p_dr->p_next )
1738     {
1739         if( p_dr->i_tag == 0x1d )
1740         {
1741             /* We have found an IOD descriptor */
1742             msg_Warn( p_demux, " * descriptor : IOD (0x1d)" );
1743
1744             prg->iod = IODNew( p_dr->i_length, p_dr->p_data );
1745         }
1746         else
1747         {
1748             msg_Dbg( p_demux, " * descriptor : unknown (0x%x)", p_dr->i_tag );
1749         }
1750     }
1751
1752     for( p_es = p_pmt->p_first_es; p_es != NULL; p_es = p_es->p_next )
1753     {
1754         ts_pid_t *pid = &p_sys->pid[p_es->i_pid];
1755
1756         if( pid->b_valid )
1757         {
1758             msg_Warn( p_demux, "pmt error: pid=0x%x already defined",
1759                       p_es->i_pid );
1760             continue;
1761         }
1762
1763         PIDInit( pid, VLC_FALSE, pmt->psi );
1764         PIDFillFormat( pid, p_es->i_type );
1765         pid->i_owner_number = prg->i_number;
1766
1767         if( p_es->i_type == 0x10 || p_es->i_type == 0x11 || p_es->i_type == 0x12 )
1768         {
1769             /* MPEG-4 stream: search SL_DESCRIPTOR */
1770             dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;;
1771
1772             while( p_dr && ( p_dr->i_tag != 0x1f ) ) p_dr = p_dr->p_next;
1773
1774             if( p_dr && p_dr->i_length == 2 )
1775             {
1776                 int i;
1777                 int i_es_id = ( p_dr->p_data[0] << 8 ) | p_dr->p_data[1];
1778
1779                 msg_Warn( p_demux, "found SL_descriptor es_id=%d", i_es_id );
1780
1781                 pid->es->p_mpeg4desc = NULL;
1782
1783                 for( i = 0; i < 255; i++ )
1784                 {
1785                     iod_descriptor_t *iod = prg->iod;
1786
1787                     if( iod->es_descr[i].b_ok &&
1788                         iod->es_descr[i].i_es_id == i_es_id )
1789                     {
1790                         pid->es->p_mpeg4desc = &iod->es_descr[i];
1791                         break;
1792                     }
1793                 }
1794             }
1795
1796             if( pid->es->p_mpeg4desc != NULL )
1797             {
1798                 decoder_config_descriptor_t *dcd =
1799                     &pid->es->p_mpeg4desc->dec_descr;
1800
1801                 if( dcd->i_streamType == 0x04 )    /* VisualStream */
1802                 {
1803                     pid->es->fmt.i_cat = VIDEO_ES;
1804                     switch( dcd->i_objectTypeIndication )
1805                     {
1806                     case 0x0B: /* mpeg4 sub */
1807                         pid->es->fmt.i_cat = SPU_ES;
1808                         pid->es->fmt.i_codec = VLC_FOURCC('s','u','b','t');
1809                         break;
1810
1811                     case 0x20: /* mpeg4 */
1812                         pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','v');
1813                         break;
1814                     case 0x60:
1815                     case 0x61:
1816                     case 0x62:
1817                     case 0x63:
1818                     case 0x64:
1819                     case 0x65: /* mpeg2 */
1820                         pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
1821                         break;
1822                     case 0x6a: /* mpeg1 */
1823                         pid->es->fmt.i_codec = VLC_FOURCC( 'm','p','g','v' );
1824                         break;
1825                     case 0x6c: /* mpeg1 */
1826                         pid->es->fmt.i_codec = VLC_FOURCC( 'j','p','e','g' );
1827                         break;
1828                     default:
1829                         pid->es->fmt.i_cat = UNKNOWN_ES;
1830                         break;
1831                     }
1832                 }
1833                 else if( dcd->i_streamType == 0x05 )    /* AudioStream */
1834                 {
1835                     pid->es->fmt.i_cat = AUDIO_ES;
1836                     switch( dcd->i_objectTypeIndication )
1837                     {
1838                     case 0x40: /* mpeg4 */
1839                         pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a');
1840                         break;
1841                     case 0x66:
1842                     case 0x67:
1843                     case 0x68: /* mpeg2 aac */
1844                         pid->es->fmt.i_codec = VLC_FOURCC('m','p','4','a');
1845                         break;
1846                     case 0x69: /* mpeg2 */
1847                         pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a');
1848                         break;
1849                     case 0x6b: /* mpeg1 */
1850                         pid->es->fmt.i_codec = VLC_FOURCC('m','p','g','a');
1851                         break;
1852                     default:
1853                         pid->es->fmt.i_cat = UNKNOWN_ES;
1854                         break;
1855                     }
1856                 }
1857                 else
1858                 {
1859                     pid->es->fmt.i_cat = UNKNOWN_ES;
1860                 }
1861
1862                 if( pid->es->fmt.i_cat != UNKNOWN_ES )
1863                 {
1864                     pid->es->fmt.i_extra = dcd->i_decoder_specific_info_len;
1865                     if( pid->es->fmt.i_extra > 0 )
1866                     {
1867                         pid->es->fmt.p_extra = malloc( pid->es->fmt.i_extra );
1868                         memcpy( pid->es->fmt.p_extra,
1869                                 dcd->p_decoder_specific_info,
1870                                 pid->es->fmt.i_extra );
1871                     }
1872                 }
1873             }
1874         }
1875         else if( p_es->i_type == 0x06 )
1876         {
1877             dvbpsi_descriptor_t *p_dr;
1878
1879             for( p_dr = p_es->p_first_descriptor; p_dr != NULL;
1880                  p_dr = p_dr->p_next )
1881             {
1882                 msg_Dbg( p_demux, "  * es pid=0x%x type=0x%x dr->i_tag=0x%x",
1883                          p_es->i_pid, p_es->i_type, p_dr->i_tag );
1884
1885                 if( p_dr->i_tag == 0x6a )
1886                 {
1887                     pid->es->fmt.i_cat = AUDIO_ES;
1888                     pid->es->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
1889                 }
1890 #ifdef _DVBPSI_DR_59_H_
1891                 else if( p_dr->i_tag == 0x59 )
1892                 {
1893                     uint16_t n;
1894                     dvbpsi_subtitling_dr_t *sub;
1895
1896                     /* DVB subtitles */
1897                     pid->es->fmt.i_cat = SPU_ES;
1898                     pid->es->fmt.i_codec = VLC_FOURCC( 'd', 'v', 'b', 's' );
1899                     pid->es->fmt.i_group = p_pmt->i_program_number;
1900
1901                     sub = dvbpsi_DecodeSubtitlingDr( p_dr );
1902                     if( !sub ) continue;
1903
1904                     /* Each subtitle ES contains n languages,
1905                      * We are going to create n ES for the n tracks */
1906                     if( sub->i_subtitles_number > 0 )
1907                     {
1908                         pid->es->fmt.psz_language = malloc( 4 );
1909                         memcpy( pid->es->fmt.psz_language,
1910                                 sub->p_subtitle[0].i_iso6392_language_code, 3);
1911                         pid->es->fmt.psz_language[3] = 0;
1912
1913                         pid->es->fmt.subs.dvb.i_id =
1914                             sub->p_subtitle[0].i_composition_page_id;
1915                     }
1916                     else pid->es->fmt.i_cat = UNKNOWN_ES;
1917
1918                     for( n = 1; n < sub->i_subtitles_number; n++ )
1919                     {
1920                         ts_es_t *p_es = malloc( sizeof( ts_es_t ) );
1921                         p_es->fmt = pid->es->fmt;
1922                         p_es->id = NULL;
1923                         p_es->p_pes = NULL;
1924                         p_es->i_pes_size = 0;
1925                         p_es->i_pes_gathered = 0;
1926                         p_es->pp_last = &p_es->p_pes;
1927                         p_es->p_mpeg4desc = NULL;
1928
1929                         p_es->fmt.psz_language = malloc( 4 );
1930                         memcpy( p_es->fmt.psz_language,
1931                                 sub->p_subtitle[n].i_iso6392_language_code, 3);
1932                         p_es->fmt.psz_language[3] = 0;
1933
1934                         p_es->fmt.subs.dvb.i_id =
1935                             sub->p_subtitle[n].i_composition_page_id;
1936
1937                         TAB_APPEND( pid->i_extra_es, pid->extra_es, p_es );
1938                     }
1939                 }
1940 #endif /* _DVBPSI_DR_59_H_ */
1941             }
1942         }
1943         else if( p_es->i_type == 0xa0 )
1944         {
1945             /* MSCODEC sent by vlc */
1946             dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;
1947
1948             while( p_dr && ( p_dr->i_tag != 0xa0 ) ) p_dr = p_dr->p_next;
1949
1950             if( p_dr && p_dr->i_length >= 8 )
1951             {
1952                 pid->es->fmt.i_cat = VIDEO_ES;
1953                 pid->es->fmt.i_codec =
1954                     VLC_FOURCC( p_dr->p_data[0], p_dr->p_data[1],
1955                                 p_dr->p_data[2], p_dr->p_data[3] );
1956                 pid->es->fmt.video.i_width =
1957                     ( p_dr->p_data[4] << 8 ) | p_dr->p_data[5];
1958                 pid->es->fmt.video.i_height =
1959                     ( p_dr->p_data[6] << 8 ) | p_dr->p_data[7];
1960                 pid->es->fmt.i_extra =
1961                     (p_dr->p_data[8] << 8) | p_dr->p_data[9];
1962
1963                 if( pid->es->fmt.i_extra > 0 )
1964                 {
1965                     pid->es->fmt.p_extra = malloc( pid->es->fmt.i_extra );
1966                     memcpy( pid->es->fmt.p_extra, &p_dr->p_data[10],
1967                             pid->es->fmt.i_extra );
1968                 }
1969             }
1970             else
1971             {
1972                 msg_Warn( p_demux, "private MSCODEC (vlc) without bih private "
1973                           "descriptor" );
1974             }
1975             /* For such stream we will gather them ourself and don't launch a
1976              * packetizer.
1977              * Yes it's ugly but it's the only way to have DIV3 working */
1978             pid->es->fmt.b_packetized = VLC_TRUE;
1979         }
1980
1981         if( pid->es->fmt.i_cat == AUDIO_ES ||
1982             ( pid->es->fmt.i_cat == SPU_ES &&
1983               pid->es->fmt.i_codec != VLC_FOURCC('d','v','b','s') ) )
1984         {
1985             /* get language descriptor */
1986             dvbpsi_descriptor_t *p_dr = p_es->p_first_descriptor;
1987             while( p_dr && ( p_dr->i_tag != 0x0a ) ) p_dr = p_dr->p_next;
1988
1989             if( p_dr )
1990             {
1991                 dvbpsi_iso639_dr_t *p_decoded = dvbpsi_DecodeISO639Dr( p_dr );
1992
1993                 if( p_decoded )
1994                 {
1995                     pid->es->fmt.psz_language = malloc( 4 );
1996                     memcpy( pid->es->fmt.psz_language,
1997                             p_decoded->i_iso_639_code, 3 );
1998                     pid->es->fmt.psz_language[3] = 0;
1999                 }
2000             }
2001         }
2002
2003         pid->es->fmt.i_group = p_pmt->i_program_number;
2004         if( pid->es->fmt.i_cat == UNKNOWN_ES )
2005         {
2006             msg_Dbg( p_demux, "  * es pid=0x%x type=0x%x *unknown*",
2007                      p_es->i_pid, p_es->i_type );
2008         }
2009         else if( !p_sys->b_udp_out )
2010         {
2011             int i;
2012
2013             msg_Dbg( p_demux, "  * es pid=0x%x type=0x%x fcc=%4.4s",
2014                      p_es->i_pid, p_es->i_type, (char*)&pid->es->fmt.i_codec );
2015
2016             if( p_sys->b_es_id_pid )
2017             {
2018                 pid->es->fmt.i_id = p_es->i_pid;
2019             }
2020
2021             pid->es->id = es_out_Add( p_demux->out, &pid->es->fmt );
2022
2023             for( i = 0; i < pid->i_extra_es; i++ )
2024             {
2025                 pid->extra_es[i]->id =
2026                     es_out_Add( p_demux->out, &pid->extra_es[i]->fmt);
2027             }
2028         }
2029     }
2030     dvbpsi_DeletePMT(p_pmt);
2031 }
2032
2033 static void PATCallBack( demux_t *p_demux, dvbpsi_pat_t *p_pat )
2034 {
2035     demux_sys_t          *p_sys = p_demux->p_sys;
2036     dvbpsi_pat_program_t *p_program;
2037     ts_pid_t             *pat = &p_sys->pid[0];
2038     int                  i, j;
2039
2040     msg_Dbg( p_demux, "PATCallBack called" );
2041
2042     if( pat->psi->i_pat_version != -1 &&
2043         ( !p_pat->b_current_next || p_pat->i_version == pat->psi->i_pat_version ) )
2044     {
2045         dvbpsi_DeletePAT( p_pat );
2046         return;
2047     }
2048
2049     msg_Dbg( p_demux, "new PAT ts_id=0x%x version=%d current_next=%d",
2050              p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
2051
2052     /* Clean old */
2053     if( p_sys->i_pmt > 0 )
2054     {
2055         int      i_pmt_rm = 0;
2056         ts_pid_t **pmt_rm = NULL;
2057
2058         /* Search pmt to be deleted */
2059         for( i = 0; i < p_sys->i_pmt; i++ )
2060         {
2061             ts_pid_t *pmt = p_sys->pmt[i];
2062             vlc_bool_t b_keep = VLC_FALSE;
2063
2064             for( p_program = p_pat->p_first_program; p_program != NULL;
2065                  p_program = p_program->p_next )
2066             {
2067                 if( p_program->i_pid == pmt->i_pid )
2068                 {
2069                     int i_prg;
2070                     for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
2071                     {
2072                         if( p_program->i_number == pmt->psi->prg[i_prg]->i_number )
2073                         {
2074                             b_keep = VLC_TRUE;
2075                             break;
2076                         }
2077                     }
2078                     if( b_keep )
2079                         break;
2080                 }
2081             }
2082             if( !b_keep )
2083             {
2084                 TAB_APPEND( i_pmt_rm, pmt_rm, pmt );
2085             }
2086         }
2087
2088         /* Delete all ES attached to thoses PMT */
2089         for( i = 2; i < 8192; i++ )
2090         {
2091             ts_pid_t *pid = &p_sys->pid[i];
2092
2093             if( !pid->b_valid || pid->psi ) continue;
2094
2095             for( j = 0; j < i_pmt_rm; j++ )
2096             {
2097                 int i_prg;
2098                 for( i_prg = 0; i_prg < pid->p_owner->i_prg; i_prg++ )
2099                 {
2100                     if( pid->p_owner->prg[i_prg]->i_pid_pcr == pmt_rm[j]->i_pid &&
2101                         pid->es->id )
2102                     {
2103                         /* We only remove es that aren't defined by extra pmt */
2104                         PIDClean( p_demux->out, pid );
2105                         break;
2106                     }
2107                 }
2108                 if( !pid->b_valid )
2109                     break;
2110             }
2111         }
2112
2113         /* Delete PMT pid */
2114         for( i = 0; i < i_pmt_rm; i++ )
2115         {
2116             PIDClean( p_demux->out, &p_sys->pid[pmt_rm[i]->i_pid] );
2117             TAB_REMOVE( p_sys->i_pmt, p_sys->pmt, pmt_rm[i] );
2118         }
2119         if( pmt_rm )
2120         {
2121             free( pmt_rm );
2122         }
2123     }
2124
2125     /* now create programs */
2126     for( p_program = p_pat->p_first_program; p_program != NULL;
2127          p_program = p_program->p_next )
2128     {
2129         msg_Dbg( p_demux, "  * number=%d pid=0x%x", p_program->i_number,
2130                  p_program->i_pid );
2131         if( p_program->i_number != 0 )
2132         {
2133             ts_pid_t *pmt = &p_sys->pid[p_program->i_pid];
2134             vlc_bool_t b_add = VLC_TRUE;
2135
2136             if( pmt->b_valid )
2137             {
2138                 int i_prg;
2139                 for( i_prg = 0; i_prg < pmt->psi->i_prg; i_prg++ )
2140                 {
2141                     if( pmt->psi->prg[i_prg]->i_number == p_program->i_number )
2142                     {
2143                         b_add = VLC_FALSE;
2144                         break;
2145                     }
2146                 }
2147             }
2148             else
2149             {
2150                 TAB_APPEND( p_sys->i_pmt, p_sys->pmt, pmt );
2151             }
2152
2153             if( b_add )
2154             {
2155                 PIDInit( pmt, VLC_TRUE, pat->psi );
2156                 pmt->psi->prg[pmt->psi->i_prg-1]->handle =
2157                     dvbpsi_AttachPMT( p_program->i_number,
2158                                       (dvbpsi_pmt_callback)PMTCallBack, p_demux );
2159                 pmt->psi->prg[pmt->psi->i_prg-1]->i_number = p_program->i_number;
2160             }
2161         }
2162     }
2163     pat->psi->i_pat_version = p_pat->i_version;
2164
2165     dvbpsi_DeletePAT( p_pat );
2166 }
2167