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

   1 /*****************************************************************************
   2  * ts.c: MPEG-II TS Muxer
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: ts.c,v 1.43 2004/01/30 17:53:05 fenrir Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Eric Petit <titer@videolan.org>
   9  *
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include <stdlib.h>
  30
  31 #include <vlc/vlc.h>
  32 #include <vlc/input.h>
  33 #include <vlc/sout.h>
  34
  35 #include "iso_lang.h"
  36
  37 #include "bits.h"
  38 #include "pes.h"
  39 #include "csa.h"
  40
  41 #if defined MODULE_NAME_IS_mux_ts_dvbpsi
  42 #   ifdef HAVE_DVBPSI_DR_H
  43 #       include <dvbpsi/dvbpsi.h>
  44 #       include <dvbpsi/descriptor.h>
  45 #       include <dvbpsi/pat.h>
  46 #       include <dvbpsi/pmt.h>
  47 #       include <dvbpsi/dr.h>
  48 #       include <dvbpsi/psi.h>
  49 #   else
  50 #       include "dvbpsi.h"
  51 #       include "descriptor.h"
  52 #       include "tables/pat.h"
  53 #       include "tables/pmt.h"
  54 #       include "descriptors/dr.h"
  55 #       include "psi.h"
  56 #   endif
  57 #endif
  58
  59 /*
  60  * TODO:
  61  *  - check PCR frequency requirement
  62  *  - check PAT/PMT  "        "
  63  *  - check PCR/PCR "soft"
  64  *  - check if "registration" descriptor : "AC-3" should be a program
  65  *    descriptor or an es one. (xine want an es one)
  66  *
  67  *  - remove creation of PAT/PMT without dvbpsi
  68  *  - ?
  69  * FIXME:
  70  *  - subtitle support is far from perfect. I expect some subtitles drop
  71  *    if they arrive a bit late
  72  *    (We cannot rely on the fact that the fifo should be full)
  73  */
  74 /*****************************************************************************
  75  * Module descriptor
  76  *****************************************************************************/
  77 static int     Open   ( vlc_object_t * );
  78 static void    Close  ( vlc_object_t * );
  79
  80 vlc_module_begin();
  81 #if defined MODULE_NAME_IS_mux_ts
  82     set_description( _("TS muxer") );
  83     set_capability( "sout mux", 100 );
  84     add_shortcut( "ts" );
  85     add_shortcut( "ts_nodvbpsi" );
  86 #elif defined MODULE_NAME_IS_mux_ts_dvbpsi
  87     set_description( _("TS muxer (libdvbpsi)") );
  88     set_capability( "sout mux", 120 );
  89     add_shortcut( "ts" );
  90     add_shortcut( "ts_dvbpsi" );
  91 #endif
  92     set_callbacks( Open, Close );
  93 vlc_module_end();
  94
  95 /*****************************************************************************
  96  * Exported prototypes
  97  *****************************************************************************/
  98 static int     Capability(sout_mux_t *, int, void *, void * );
  99 static int     AddStream( sout_mux_t *, sout_input_t * );
 100 static int     DelStream( sout_mux_t *, sout_input_t * );
 101 static int     Mux      ( sout_mux_t * );
 102
 103 /*****************************************************************************
 104  * Local prototypes
 105  *****************************************************************************/
 106 #define SOUT_BUFFER_FLAGS_PRIVATE_PCR  ( 1 << SOUT_BUFFER_FLAGS_PRIVATE_SHIFT )
 107 #define SOUT_BUFFER_FLAGS_PRIVATE_CSA  ( 2 << SOUT_BUFFER_FLAGS_PRIVATE_SHIFT )
 108 typedef struct
 109 {
 110     int           i_depth;
 111     sout_buffer_t *p_first;
 112     sout_buffer_t **pp_last;
 113 } sout_buffer_chain_t;
 114
 115 static inline void BufferChainInit  ( sout_buffer_chain_t *c )
 116 {
 117     c->i_depth = 0;
 118     c->p_first = NULL;
 119     c->pp_last = &c->p_first;
 120 }
 121 static inline void BufferChainAppend( sout_buffer_chain_t *c, sout_buffer_t *b )
 122 {
 123     *c->pp_last = b;
 124     c->i_depth++;
 125
 126     while( b->p_next )
 127     {
 128         b = b->p_next;
 129         c->i_depth++;
 130     }
 131     c->pp_last = &b->p_next;
 132 }
 133 static inline sout_buffer_t *BufferChainGet( sout_buffer_chain_t *c )
 134 {
 135     sout_buffer_t *b = c->p_first;
 136
 137     if( b )
 138     {
 139         c->i_depth--;
 140         c->p_first = b->p_next;
 141
 142         if( c->p_first == NULL )
 143         {
 144             c->pp_last = &c->p_first;
 145         }
 146
 147         b->p_next = NULL;
 148     }
 149     return b;
 150 }
 151 static inline void BufferChainClean( sout_instance_t *p_sout, sout_buffer_chain_t *c )
 152 {
 153     sout_buffer_t *b;
 154
 155     while( ( b = BufferChainGet( c ) ) )
 156     {
 157         sout_BufferDelete( p_sout, b );
 158     }
 159     BufferChainInit( c );
 160 }
 161
 162 typedef struct ts_stream_s
 163 {
 164     int             i_pid;
 165     int             i_stream_type;
 166     int             i_stream_id;
 167     int             i_continuity_counter;
 168
 169     /* to be used for carriege of DIV3 */
 170     vlc_fourcc_t    i_bih_codec;
 171     int             i_bih_width, i_bih_height;
 172
 173     /* Specific to mpeg4 in mpeg2ts */
 174     int             i_es_id;
 175
 176     int             i_decoder_specific_info;
 177     uint8_t         *p_decoder_specific_info;
 178
 179     /* language is iso639-2T */
 180     uint8_t         lang[3];
 181
 182     sout_buffer_chain_t chain_pes;
 183     mtime_t             i_pes_dts;
 184     mtime_t             i_pes_length;
 185     int                 i_pes_used;
 186
 187 } ts_stream_t;
 188
 189 struct sout_mux_sys_t
 190 {
 191     int             i_pcr_pid;
 192     sout_input_t    *p_pcr_input;
 193
 194     int             i_audio_bound;
 195     int             i_video_bound;
 196
 197     int             i_pid_video;
 198     int             i_pid_audio;
 199     int             i_pid_free; // first usable pid
 200
 201     int             i_pat_version_number;
 202     ts_stream_t     pat;
 203
 204     int             i_pmt_version_number;
 205     ts_stream_t     pmt;        // Up to now only one program
 206
 207     int             i_mpeg4_streams;
 208
 209     int             i_null_continuity_counter;  /* Needed ? */
 210
 211     /* for TS building */
 212     int64_t             i_bitrate_min;
 213     int64_t             i_bitrate_max;
 214
 215     int64_t             i_caching_delay;
 216     int64_t             i_pcr_delay;
 217
 218     int64_t             i_dts_delay;
 219
 220     mtime_t             i_pcr;  /* last PCR emited */
 221
 222     csa_t               *csa;
 223 };
 224
 225
 226 /* Reserve a pid and return it */
 227 static int  AllocatePID( sout_mux_sys_t *p_sys, int i_cat )
 228 {
 229     int i_pid;
 230     if ( i_cat == VIDEO_ES && p_sys->i_pid_video )
 231     {
 232         i_pid = p_sys->i_pid_video;
 233         p_sys->i_pid_video = 0;
 234     }
 235     else if ( i_cat == AUDIO_ES && p_sys->i_pid_audio )
 236     {
 237         i_pid = p_sys->i_pid_audio;
 238         p_sys->i_pid_audio = 0;
 239     }
 240     else
 241     {
 242         i_pid = ++p_sys->i_pid_free;
 243     }
 244     return i_pid;
 245 }
 246
 247 static void GetPAT( sout_mux_t *p_mux, sout_buffer_chain_t *c );
 248 static void GetPMT( sout_mux_t *p_mux, sout_buffer_chain_t *c );
 249
 250 static sout_buffer_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream, vlc_bool_t b_pcr );
 251 static void TSSetPCR( sout_buffer_t *p_ts, mtime_t i_dts );
 252
 253 static void PEStoTS  ( sout_instance_t *, sout_buffer_chain_t *, sout_buffer_t *, ts_stream_t * );
 254
 255 /*****************************************************************************
 256  * Open:
 257  *****************************************************************************/
 258 static int Open( vlc_object_t *p_this )
 259 {
 260     sout_mux_t          *p_mux =(sout_mux_t*)p_this;
 261     sout_mux_sys_t      *p_sys;
 262     char                *val;
 263
 264     msg_Dbg( p_mux, "Open" );
 265
 266     p_sys = malloc( sizeof( sout_mux_sys_t ) );
 267
 268     p_mux->pf_capacity  = Capability;
 269     p_mux->pf_addstream = AddStream;
 270     p_mux->pf_delstream = DelStream;
 271     p_mux->pf_mux       = Mux;
 272     p_mux->p_sys        = p_sys;
 273     p_mux->i_preheader  = 30; // really enough for a pes header
 274
 275     srand( (uint32_t)mdate() );
 276
 277     p_sys->i_audio_bound = 0;
 278     p_sys->i_video_bound = 0;
 279
 280     p_sys->i_pat_version_number = rand() % 32;
 281     p_sys->pat.i_pid = 0;
 282     p_sys->pat.i_continuity_counter = 0;
 283
 284     p_sys->i_pmt_version_number = rand() % 32;
 285     p_sys->pmt.i_pid = 0x42;
 286     p_sys->pmt.i_continuity_counter = 0;
 287
 288     p_sys->i_pid_free = 0x43;
 289
 290     p_sys->i_pid_video = 0;
 291     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "pid-video" ) ) )
 292     {
 293         p_sys->i_pid_video = strtol( val, NULL, 0 );
 294         if ( p_sys->i_pid_video > p_sys->i_pid_free )
 295         {
 296             p_sys->i_pid_free = p_sys->i_pid_video + 1;
 297         }
 298     }
 299     p_sys->i_pid_audio = 0;
 300     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "pid-audio" ) ) )
 301     {
 302         p_sys->i_pid_audio = strtol( val, NULL, 0 );
 303         if ( p_sys->i_pid_audio > p_sys->i_pid_free )
 304         {
 305             p_sys->i_pid_free = p_sys->i_pid_audio + 1;
 306         }
 307     }
 308
 309     p_sys->i_pcr_pid = 0x1fff;
 310     p_sys->p_pcr_input = NULL;
 311
 312     p_sys->i_mpeg4_streams = 0;
 313
 314     p_sys->i_null_continuity_counter = 0;
 315
 316     /* Allow to create constrained stream */
 317     p_sys->i_bitrate_min = 0;
 318     p_sys->i_bitrate_max = 0;
 319     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "bmin" ) ) )
 320     {
 321         p_sys->i_bitrate_min = atoll( val );
 322     }
 323     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "bmax" ) ) )
 324     {
 325         p_sys->i_bitrate_max = atoll( val );
 326     }
 327     if( p_sys->i_bitrate_min > 0 && p_sys->i_bitrate_max > 0 &&
 328         p_sys->i_bitrate_min > p_sys->i_bitrate_max )
 329     {
 330         msg_Err( p_mux, "incompatible minimum and maximum bitrate, "
 331                  "disabling bitrate control" );
 332         p_sys->i_bitrate_min = 0;
 333         p_sys->i_bitrate_max = 0;
 334     }
 335     if( p_sys->i_bitrate_min > 0 || p_sys->i_bitrate_max > 0 )
 336     {
 337         msg_Err( p_mux, "bmin and bmax no more supported (if you need them report it)" );
 338     }
 339
 340     p_sys->i_caching_delay = 200000;
 341     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "caching" ) ) )
 342     {
 343         p_sys->i_caching_delay = (int64_t)atoi( val ) * 1000;
 344         if( p_sys->i_caching_delay <= 0 )
 345         {
 346             msg_Err( p_mux,
 347                      "invalid caching ("I64Fd"ms) reseting to 200ms",
 348                      p_sys->i_caching_delay / 1000 );
 349             p_sys->i_caching_delay = 200000;
 350         }
 351     }
 352     p_sys->i_pcr_delay = 30000;
 353     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "pcr" ) ) )
 354     {
 355         p_sys->i_pcr_delay = (int64_t)atoi( val ) * 1000;
 356         if( p_sys->i_pcr_delay <= 0 ||
 357             p_sys->i_pcr_delay >= p_sys->i_caching_delay )
 358         {
 359             msg_Err( p_mux,
 360                      "invalid pcr delay ("I64Fd"ms) reseting to 30ms",
 361                      p_sys->i_pcr_delay / 1000 );
 362             p_sys->i_pcr_delay = 30000;
 363         }
 364     }
 365
 366     msg_Dbg( p_mux, "caching="I64Fd" pcr="I64Fd,
 367              p_sys->i_caching_delay, p_sys->i_pcr_delay );
 368
 369     p_sys->i_dts_delay = 200000;
 370     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "dts-delay" ) ) )
 371     {
 372         p_sys->i_dts_delay = (int64_t)atoi( val ) * 1000;
 373     }
 374
 375     /* for TS generation */
 376     p_sys->i_pcr    = 0;
 377
 378     p_sys->csa      = NULL;
 379     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "csa-ck" ) ) )
 380     {
 381         /* skip 0x */
 382         if( val[0] == '0' && ( val[1] == 'x' || val[1] == 'X' ) )
 383         {
 384             val += 2;
 385         }
 386         if( strlen( val ) != 16 )
 387         {
 388             msg_Dbg( p_mux, "invalid csa ck (it must be 16 chars long)" );
 389         }
 390         else
 391         {
 392             uint64_t i_ck = strtoll( val, NULL, 16 );
 393             uint8_t ck[8];
 394             int     i;
 395             for( i = 0; i < 8; i++ )
 396             {
 397                 ck[i] = ( i_ck >> ( 56 - 8*i) )&0xff;
 398             }
 399
 400             msg_Dbg( p_mux, "using CSA scrambling with ck=%x:%x:%x:%x:%x:%x:%x:%x",
 401                      ck[0], ck[1], ck[2], ck[3], ck[4], ck[5], ck[6], ck[7] );
 402
 403             p_sys->csa = csa_New();
 404             csa_SetCW( p_sys->csa, ck, ck );
 405         }
 406     }
 407     return VLC_SUCCESS;
 408 }
 409
 410 /*****************************************************************************
 411  * Close:
 412  *****************************************************************************/
 413 static void Close( vlc_object_t * p_this )
 414 {
 415     sout_mux_t          *p_mux = (sout_mux_t*)p_this;
 416     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 417
 418     msg_Dbg( p_mux, "Close" );
 419     if( p_sys->csa )
 420     {
 421         csa_Delete( p_sys->csa );
 422     }
 423
 424     free( p_sys );
 425 }
 426
 427 /*****************************************************************************
 428  * Capability:
 429  *****************************************************************************/
 430 static int Capability( sout_mux_t *p_mux, int i_query, void *p_args, void *p_answer )
 431 {
 432    switch( i_query )
 433    {
 434         case SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME:
 435             *(vlc_bool_t*)p_answer = VLC_TRUE;
 436             return( SOUT_MUX_CAP_ERR_OK );
 437         default:
 438             return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED );
 439    }
 440 }
 441
 442 /*****************************************************************************
 443  * AddStream: called for each stream addition
 444  *****************************************************************************/
 445 static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
 446 {
 447     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 448     ts_stream_t         *p_stream;
 449
 450     p_input->p_sys = (void*)p_stream = malloc( sizeof( ts_stream_t ) );
 451
 452     /* Init this new stream */
 453     p_stream->i_pid = AllocatePID( p_sys, p_input->p_fmt->i_cat );
 454     p_stream->i_continuity_counter    = 0;
 455     p_stream->i_decoder_specific_info = 0;
 456     p_stream->p_decoder_specific_info = NULL;
 457
 458     msg_Dbg( p_mux, "adding input codec=%4.4s pid=%d", (char*)&p_input->p_fmt->i_codec, p_stream->i_pid );
 459
 460     /* All others fields depand on codec */
 461     switch( p_input->p_fmt->i_cat )
 462     {
 463         case VIDEO_ES:
 464             switch( p_input->p_fmt->i_codec )
 465             {
 466                 case VLC_FOURCC( 'm', 'p','g', 'v' ):
 467                     /* TODO: do we need to check MPEG-I/II ? */
 468                     p_stream->i_stream_type = 0x02;
 469                     p_stream->i_stream_id = 0xe0;
 470                     break;
 471                 case VLC_FOURCC( 'm', 'p','4', 'v' ):
 472                     p_stream->i_stream_type = 0x10;
 473                     p_stream->i_stream_id = 0xfa;
 474                     p_sys->i_mpeg4_streams++;
 475                     p_stream->i_es_id = p_stream->i_pid;
 476                     break;
 477                 /* XXX dirty dirty but somebody want that : using crapy MS-codec XXX */
 478                 /* I didn't want to do that :P */
 479                 case VLC_FOURCC( 'H', '2', '6', '3' ):
 480                 case VLC_FOURCC( 'I', '2', '6', '3' ):
 481                 case VLC_FOURCC( 'W', 'M', 'V', '2' ):
 482                 case VLC_FOURCC( 'W', 'M', 'V', '1' ):
 483                 case VLC_FOURCC( 'D', 'I', 'V', '3' ):
 484                 case VLC_FOURCC( 'D', 'I', 'V', '2' ):
 485                 case VLC_FOURCC( 'D', 'I', 'V', '1' ):
 486                 case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
 487                     p_stream->i_stream_type = 0xa0; // private
 488                     p_stream->i_stream_id = 0xa0;   // beurk
 489                     p_stream->i_bih_codec  = p_input->p_fmt->i_codec;
 490                     p_stream->i_bih_width  = p_input->p_fmt->video.i_width;
 491                     p_stream->i_bih_height = p_input->p_fmt->video.i_height;
 492                     break;
 493                 default:
 494                     free( p_stream );
 495                     return VLC_EGENERIC;
 496             }
 497             p_sys->i_video_bound++;
 498             break;
 499
 500         case AUDIO_ES:
 501             switch( p_input->p_fmt->i_codec )
 502             {
 503                 case VLC_FOURCC( 'm', 'p','g', 'a' ):
 504                     p_stream->i_stream_type = p_input->p_fmt->audio.i_rate >= 32000 ? 0x03 : 0x04;
 505                     p_stream->i_stream_id = 0xc0;
 506                     break;
 507                 case VLC_FOURCC( 'a', '5','2', ' ' ):
 508                     p_stream->i_stream_type = 0x81;
 509                     p_stream->i_stream_id = 0xbd;
 510                     break;
 511                 case VLC_FOURCC( 'l', 'p','c', 'm' ):
 512                     p_stream->i_stream_type = 0x83;
 513                     p_stream->i_stream_id = 0xbd;
 514                     break;
 515                 case VLC_FOURCC( 'd', 't','s', ' ' ):
 516                     p_stream->i_stream_type = 0x85;
 517                     p_stream->i_stream_id = 0xbd;
 518                     break;
 519
 520                 case VLC_FOURCC( 'm', 'p','4', 'a' ):
 521                     p_stream->i_stream_type = 0x11;
 522                     p_stream->i_stream_id = 0xfa;
 523                     p_sys->i_mpeg4_streams++;
 524                     p_stream->i_es_id = p_stream->i_pid;
 525                     break;
 526                 default:
 527                     free( p_stream );
 528                     return VLC_EGENERIC;
 529             }
 530             p_sys->i_audio_bound++;
 531             break;
 532
 533         case SPU_ES:
 534             switch( p_input->p_fmt->i_codec )
 535             {
 536                 case VLC_FOURCC( 's', 'p','u', ' ' ):
 537                     p_stream->i_stream_type = 0x82;
 538                     p_stream->i_stream_id = 0xbd;
 539                     break;
 540                 default:
 541                     free( p_stream );
 542                     return VLC_EGENERIC;
 543             }
 544             break;
 545
 546         default:
 547             free( p_stream );
 548             return VLC_EGENERIC;
 549     }
 550
 551     p_stream->lang[0] =
 552     p_stream->lang[1] =
 553     p_stream->lang[2] = '\0';
 554     if( p_input->p_fmt->psz_language )
 555     {
 556         char *psz = p_input->p_fmt->psz_language;
 557         const iso639_lang_t *pl = NULL;
 558
 559         if( strlen( psz ) == 2 )
 560         {
 561             pl = GetLang_1( psz );
 562         }
 563         else if( strlen( psz ) == 3 )
 564         {
 565             pl = GetLang_2B( psz );
 566             if( !strcmp( pl->psz_iso639_1, "??" ) )
 567             {
 568                 pl = GetLang_2T( psz );
 569             }
 570         }
 571         if( pl && strcmp( pl->psz_iso639_1, "??" ) )
 572         {
 573             p_stream->lang[0] = pl->psz_iso639_2T[0];
 574             p_stream->lang[1] = pl->psz_iso639_2T[1];
 575             p_stream->lang[2] = pl->psz_iso639_2T[2];
 576
 577             msg_Dbg( p_mux, "    - lang=%c%c%c",
 578                      p_stream->lang[0],
 579                      p_stream->lang[1],
 580                      p_stream->lang[2] );
 581         }
 582     }
 583
 584
 585     /* Copy extra data (VOL for MPEG-4 and extra BitMapInfoHeader for VFW */
 586     p_stream->i_decoder_specific_info = p_input->p_fmt->i_extra;
 587     if( p_stream->i_decoder_specific_info > 0 )
 588     {
 589         p_stream->p_decoder_specific_info =
 590             malloc( p_stream->i_decoder_specific_info );
 591         memcpy( p_stream->p_decoder_specific_info,
 592                 p_input->p_fmt->p_extra,
 593                 p_input->p_fmt->i_extra );
 594     }
 595
 596     /* Init pes chain */
 597     BufferChainInit( &p_stream->chain_pes );
 598     p_stream->i_pes_dts    = 0;
 599     p_stream->i_pes_length = 0;
 600     p_stream->i_pes_used   = 0;
 601
 602     /* We only change PMT version (PAT isn't changed) */
 603     p_sys->i_pmt_version_number = ( p_sys->i_pmt_version_number + 1 )%32;
 604
 605     /* Update pcr_pid */
 606     if( p_input->p_fmt->i_cat != SPU_ES &&
 607         ( p_sys->i_pcr_pid == 0x1fff || p_input->p_fmt->i_cat == VIDEO_ES ) )
 608     {
 609         if( p_sys->p_pcr_input )
 610         {
 611             /* There was already a PCR stream, so clean context */
 612             /* FIXME */
 613         }
 614         p_sys->i_pcr_pid   = p_stream->i_pid;
 615         p_sys->p_pcr_input = p_input;
 616
 617         msg_Dbg( p_mux, "new PCR PID is %d", p_sys->i_pcr_pid );
 618     }
 619
 620     return VLC_SUCCESS;
 621 }
 622
 623 /*****************************************************************************
 624  * DelStream: called before a stream deletion
 625  *****************************************************************************/
 626 static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
 627 {
 628     sout_mux_sys_t  *p_sys = p_mux->p_sys;
 629     ts_stream_t     *p_stream;
 630     char            *val;
 631
 632     p_stream = (ts_stream_t*)p_input->p_sys;
 633     msg_Dbg( p_mux, "removing input pid=%d", p_stream->i_pid );
 634
 635     if( p_sys->i_pcr_pid == p_stream->i_pid )
 636     {
 637         int i;
 638
 639         /* Find a new pcr stream (Prefer Video Stream) */
 640         p_sys->i_pcr_pid = 0x1fff;
 641         p_sys->p_pcr_input = NULL;
 642         for( i = 0; i < p_mux->i_nb_inputs; i++ )
 643         {
 644             if( p_mux->pp_inputs[i] == p_input )
 645             {
 646                 continue;
 647             }
 648
 649             if( p_mux->pp_inputs[i]->p_fmt->i_cat == VIDEO_ES )
 650             {
 651                 p_sys->i_pcr_pid  =
 652                     ((ts_stream_t*)p_mux->pp_inputs[i]->p_sys)->i_pid;
 653                 p_sys->p_pcr_input= p_mux->pp_inputs[i];
 654                 break;
 655             }
 656             else if( p_mux->pp_inputs[i]->p_fmt->i_cat != SPU_ES &&
 657                      p_sys->i_pcr_pid == 0x1fff )
 658             {
 659                 p_sys->i_pcr_pid  =
 660                     ((ts_stream_t*)p_mux->pp_inputs[i]->p_sys)->i_pid;
 661                 p_sys->p_pcr_input= p_mux->pp_inputs[i];
 662             }
 663         }
 664         if( p_sys->p_pcr_input )
 665         {
 666             /* Empty TS buffer */
 667             /* FIXME */
 668         }
 669         msg_Dbg( p_mux, "new PCR PID is %d", p_sys->i_pcr_pid );
 670     }
 671
 672     /* Empty all data in chain_pes */
 673     BufferChainClean( p_mux->p_sout, &p_stream->chain_pes );
 674
 675     if( p_stream->p_decoder_specific_info )
 676     {
 677         free( p_stream->p_decoder_specific_info );
 678     }
 679     if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
 680     {
 681         p_sys->i_mpeg4_streams--;
 682     }
 683     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "pid-video" ) ) )
 684     {
 685         int i_pid_video = strtol( val, NULL, 0 );
 686         if ( i_pid_video == p_stream->i_pid )
 687         {
 688             p_sys->i_pid_video = i_pid_video;
 689             msg_Dbg( p_mux, "freeing video PID %d", i_pid_video );
 690         }
 691     }
 692     if( ( val = sout_cfg_find_value( p_mux->p_cfg, "pid-audio" ) ) )
 693     {
 694         int i_pid_audio = strtol( val, NULL, 0 );
 695         if ( i_pid_audio == p_stream->i_pid )
 696         {
 697             p_sys->i_pid_audio = i_pid_audio;
 698             msg_Dbg( p_mux, "freeing audio PID %d", i_pid_audio );
 699         }
 700     }
 701     free( p_stream );
 702
 703     /* We only change PMT version (PAT isn't changed) */
 704     p_sys->i_pmt_version_number++; p_sys->i_pmt_version_number %= 32;
 705
 706     return VLC_SUCCESS;
 707 }
 708
 709 /*****************************************************************************
 710  * Mux: Call each time there is new data for at least one stream
 711  *****************************************************************************
 712  *
 713  *****************************************************************************/
 714 static int Mux( sout_mux_t *p_mux )
 715 {
 716     sout_mux_sys_t  *p_sys = p_mux->p_sys;
 717     ts_stream_t     *p_pcr_stream;
 718
 719     if( p_sys->i_pcr_pid == 0x1fff )
 720     {
 721         msg_Dbg( p_mux, "waiting PCR streams" );
 722         msleep( 1000 );
 723         return VLC_SUCCESS;
 724     }
 725     p_pcr_stream = (ts_stream_t*)p_sys->p_pcr_input->p_sys;
 726
 727     for( ;; )
 728     {
 729         sout_buffer_chain_t chain_ts;
 730         int                 i_packet_count;
 731         int                 i_packet_pos;
 732         mtime_t             i_pcr_dts;
 733         mtime_t             i_pcr_length;
 734         int i;
 735
 736         /* 1: get enough PES packet for all input */
 737         for( ;; )
 738         {
 739             vlc_bool_t b_ok = VLC_TRUE;
 740             sout_buffer_t *p_data;
 741
 742             /* Accumulate enough data in the pcr stream (>i_caching_delay) */
 743             /* Accumulate enough data in all other stream ( >= length of pcr) */
 744             for( i = 0; i < p_mux->i_nb_inputs; i++ )
 745             {
 746                 sout_input_t *p_input = p_mux->pp_inputs[i];
 747                 ts_stream_t *p_stream = (ts_stream_t*)p_input->p_sys;
 748
 749                 if( ( p_stream == p_pcr_stream && p_stream->i_pes_length <= p_sys->i_caching_delay ) ||
 750                     p_stream->i_pes_dts + p_stream->i_pes_length < p_pcr_stream->i_pes_dts + p_pcr_stream->i_pes_length )
 751                 {
 752                     /* Need more data */
 753                     if( p_input->p_fifo->i_depth <= 1 )
 754                     {
 755                         if( p_input->p_fmt->i_cat == AUDIO_ES ||
 756                             p_input->p_fmt->i_cat == VIDEO_ES )
 757                         {
 758                             /* We need more data */
 759                             return VLC_SUCCESS;
 760                         }
 761                         else if( p_input->p_fifo->i_depth <= 0 )
 762                         {
 763                             /* spu, only one packet is needed */
 764                             continue;
 765                         }
 766                     }
 767                     b_ok = VLC_FALSE;
 768
 769                     p_data = sout_FifoGet( p_input->p_fifo );
 770                     if( p_input->p_fifo->i_depth > 0 )
 771                     {
 772                         sout_buffer_t *p_next = sout_FifoShow( p_input->p_fifo );
 773
 774                         p_data->i_length = p_next->i_dts - p_data->i_dts;
 775                     }
 776
 777                     if( ( p_pcr_stream->i_pes_dts > 0 && p_data->i_dts - 2000000 > p_pcr_stream->i_pes_dts + p_pcr_stream->i_pes_length ) ||
 778                         p_data->i_dts < p_stream->i_pes_dts ||
 779                         ( p_stream->i_pes_dts > 0 && p_data->i_dts - 2000000 > p_stream->i_pes_dts + p_stream->i_pes_length ) )
 780                     {
 781                         msg_Warn( p_mux, "packet with too strange dts (dts=%lld,old=%lld,pcr=%lld)",
 782                                   p_data->i_dts,
 783                                   p_stream->i_pes_dts,
 784                                   p_pcr_stream->i_pes_dts );
 785                         sout_BufferDelete( p_mux->p_sout, p_data );
 786
 787                         BufferChainClean( p_mux->p_sout, &p_stream->chain_pes );
 788                         p_stream->i_pes_dts = 0;
 789                         p_stream->i_pes_used = 0;
 790                         p_stream->i_pes_length = 0;
 791
 792                         BufferChainClean( p_mux->p_sout, &p_pcr_stream->chain_pes );
 793                         p_pcr_stream->i_pes_dts = 0;
 794                         p_pcr_stream->i_pes_used = 0;
 795                         p_pcr_stream->i_pes_length = 0;
 796
 797                     }
 798                     else
 799                     {
 800                         if( p_data->i_length < 0 || p_data->i_length > 2000000 )
 801                         {
 802                             /* FIXME choose a better value, but anyway we should never
 803                              * have to do that */
 804                             p_data->i_length = 1000;
 805                         }
 806                         p_stream->i_pes_length += p_data->i_length;
 807                         if( p_stream->i_pes_dts == 0 )
 808                         {
 809                             p_stream->i_pes_dts = p_data->i_dts;
 810                         }
 811
 812                         /* Convert to pes */
 813                         E_( EStoPES )( p_mux->p_sout, &p_data, p_data, p_stream->i_stream_id, 1 );
 814
 815                         BufferChainAppend( &p_stream->chain_pes, p_data );
 816                     }
 817                 }
 818             }
 819
 820             if( b_ok )
 821             {
 822                 break;
 823             }
 824         }
 825
 826         /* save */
 827         i_pcr_dts      = p_pcr_stream->i_pes_dts;
 828         i_pcr_length   = p_pcr_stream->i_pes_length;
 829
 830         /* msg_Dbg( p_mux, "starting muxing %lldms", i_pcr_length / 1000 ); */
 831         /* 2: calculate non accurate total size of muxed ts */
 832         i_packet_count = 0;
 833         for( i = 0; i < p_mux->i_nb_inputs; i++ )
 834         {
 835             ts_stream_t *p_stream = (ts_stream_t*)p_mux->pp_inputs[i]->p_sys;
 836             sout_buffer_t *p_pes;
 837
 838             /* False for pcr stream but it will be eough to do PCR algo */
 839             for( p_pes = p_stream->chain_pes.p_first; p_pes != NULL; p_pes = p_pes->p_next )
 840             {
 841                 int i_size = p_pes->i_size;
 842                 if( p_pes->i_dts + p_pes->i_length > p_pcr_stream->i_pes_dts + p_pcr_stream->i_pes_length )
 843                 {
 844                     mtime_t i_frag = p_pcr_stream->i_pes_dts + p_pcr_stream->i_pes_length - p_pes->i_dts;
 845                     if( i_frag < 0 )
 846                     {
 847                         /* Next stream */
 848                         break;
 849                     }
 850                     i_size = p_pes->i_size * i_frag / p_pes->i_length;
 851                 }
 852                 i_packet_count += ( i_size + 183 ) / 184;
 853             }
 854         }
 855         /* add overhead for PCR (not really exact) */
 856         i_packet_count += ( 8 * i_pcr_length / p_sys->i_pcr_delay + 175 ) / 176;
 857
 858
 859         /* 3: mux PES into TS */
 860         BufferChainInit( &chain_ts );
 861         /* append PAT/PMT  -> FIXME with big pcr delay it won't have enough pat/pmt */
 862         GetPAT( p_mux, &chain_ts);
 863         GetPMT( p_mux, &chain_ts );
 864         i_packet_pos = 0;
 865         i_packet_count += chain_ts.i_depth;
 866         /* msg_Dbg( p_mux, "estimated pck=%d", i_packet_count ); */
 867
 868         for( ;; )
 869         {
 870             int         i_stream;
 871             mtime_t     i_dts;
 872             ts_stream_t *p_stream;
 873             sout_buffer_t *p_ts;
 874             vlc_bool_t   b_pcr;
 875
 876             /* Select stream (lowest dts)*/
 877             for( i = 0, i_stream = -1, i_dts = 0; i < p_mux->i_nb_inputs; i++ )
 878             {
 879                 p_stream = (ts_stream_t*)p_mux->pp_inputs[i]->p_sys;
 880
 881                 if( p_stream->i_pes_dts == 0 )
 882                 {
 883                     continue;
 884                 }
 885
 886                 if( i_stream == -1 ||
 887                     p_stream->i_pes_dts < i_dts )
 888                 {
 889                     i_stream = i;
 890                     i_dts = p_stream->i_pes_dts;
 891                 }
 892             }
 893             if( i_stream == -1 )
 894             {
 895                 break;
 896             }
 897             p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
 898
 899             /* do we need to issue pcr */
 900             b_pcr = VLC_FALSE;
 901             if( p_stream == p_pcr_stream &&
 902                 i_pcr_dts + i_packet_pos * i_pcr_length / i_packet_count >= p_sys->i_pcr + p_sys->i_pcr_delay )
 903             {
 904                 b_pcr = VLC_TRUE;
 905                 p_sys->i_pcr = i_pcr_dts + i_packet_pos * i_pcr_length / i_packet_count;
 906             }
 907
 908             /* Build the TS packet */
 909             p_ts = TSNew( p_mux, p_stream, b_pcr );
 910             if( p_sys->csa )
 911             {
 912                 p_ts->i_flags |= SOUT_BUFFER_FLAGS_PRIVATE_CSA;
 913             }
 914             i_packet_pos++;
 915
 916             /* */
 917             BufferChainAppend( &chain_ts, p_ts );
 918         }
 919
 920         /* 4: date and send */
 921         i_packet_count = chain_ts.i_depth;
 922         /* msg_Dbg( p_mux, "real pck=%d", i_packet_count ); */
 923         for( i = 0; i < i_packet_count; i++ )
 924         {
 925             sout_buffer_t *p_ts = BufferChainGet( &chain_ts );
 926
 927             p_ts->i_dts    = i_pcr_dts + i_pcr_length * i / i_packet_count;
 928             p_ts->i_length = i_pcr_length / i_packet_count;
 929
 930             if( p_ts->i_flags&SOUT_BUFFER_FLAGS_PRIVATE_PCR )
 931             {
 932                 /* msg_Dbg( p_mux, "pcr=%lld ms", p_ts->i_dts / 1000 ); */
 933                 TSSetPCR( p_ts, p_ts->i_dts - p_sys->i_dts_delay );
 934             }
 935             if( p_ts->i_flags&SOUT_BUFFER_FLAGS_PRIVATE_CSA )
 936             {
 937                 csa_Encrypt( p_sys->csa, p_ts->p_buffer, 0 );
 938             }
 939
 940             /* latency */
 941             p_ts->i_dts += 3*p_sys->i_caching_delay/2;
 942
 943             sout_AccessOutWrite( p_mux->p_access, p_ts );
 944         }
 945     }
 946 }
 947
 948 static sout_buffer_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream, vlc_bool_t b_pcr )
 949 {
 950     sout_buffer_t *p_pes = p_stream->chain_pes.p_first;
 951     sout_buffer_t *p_ts;
 952
 953     vlc_bool_t b_new_pes = VLC_FALSE;
 954     vlc_bool_t b_adaptation_field = VLC_FALSE;
 955
 956     int        i_payload_max = 184 - ( b_pcr ? 8 : 0 );
 957     int        i_payload;
 958
 959     if( p_stream->i_pes_used <= 0 )
 960     {
 961         b_new_pes = VLC_TRUE;
 962     }
 963     i_payload = __MIN( (int)p_pes->i_size - p_stream->i_pes_used, i_payload_max );
 964
 965     if( b_pcr || i_payload < i_payload_max )
 966     {
 967         b_adaptation_field = VLC_TRUE;
 968     }
 969
 970     p_ts = sout_BufferNew( p_mux->p_sout, 188 );
 971
 972     p_ts->p_buffer[0] = 0x47;
 973     p_ts->p_buffer[1] = ( b_new_pes ? 0x40 : 0x00 )|( ( p_stream->i_pid >> 8 )&0x1f );
 974     p_ts->p_buffer[2] = p_stream->i_pid & 0xff;
 975     p_ts->p_buffer[3] = ( b_adaptation_field ? 0x30 : 0x10 )|p_stream->i_continuity_counter;
 976
 977     p_stream->i_continuity_counter = (p_stream->i_continuity_counter+1)%16;
 978
 979     if( b_adaptation_field )
 980     {
 981         int i;
 982
 983         if( b_pcr )
 984         {
 985             int     i_stuffing = i_payload_max - i_payload;
 986
 987             p_ts->i_flags |= SOUT_BUFFER_FLAGS_PRIVATE_PCR;
 988
 989             p_ts->p_buffer[4] = 7 + i_stuffing;
 990             p_ts->p_buffer[5] = 0x10;   /* flags */
 991             p_ts->p_buffer[6] = ( 0 )&0xff;
 992             p_ts->p_buffer[7] = ( 0 )&0xff;
 993             p_ts->p_buffer[8] = ( 0 )&0xff;
 994             p_ts->p_buffer[9] = ( 0 )&0xff;
 995             p_ts->p_buffer[10]= ( 0 )&0x80;
 996             p_ts->p_buffer[11]= 0;
 997
 998             for( i = 12; i < 12 + i_stuffing; i++ )
 999             {
1000                 p_ts->p_buffer[i] = 0xff;
1001             }
1002         }
1003         else
1004         {
1005             int i_stuffing = i_payload_max - i_payload;
1006
1007             p_ts->p_buffer[4] = i_stuffing - 1;
1008             if( i_stuffing > 1 )
1009             {
1010                 p_ts->p_buffer[5] = 0x00;
1011                 for( i = 6; i < 6 + i_stuffing - 2; i++ )
1012                 {
1013                     p_ts->p_buffer[i] = 0xff;
1014                 }
1015             }
1016         }
1017     }
1018
1019     /* copy payload */
1020     memcpy( &p_ts->p_buffer[188 - i_payload], &p_pes->p_buffer[p_stream->i_pes_used], i_payload );
1021
1022     p_stream->i_pes_used += i_payload;
1023     p_stream->i_pes_dts      = p_pes->i_dts + p_pes->i_length * p_stream->i_pes_used / p_pes->i_size;
1024     p_stream->i_pes_length  -= p_pes->i_length * i_payload / p_pes->i_size;
1025
1026     if( p_stream->i_pes_used >= (int)p_pes->i_size )
1027     {
1028         p_pes = BufferChainGet( &p_stream->chain_pes );
1029         sout_BufferDelete( p_mux->p_sout, p_pes );
1030
1031         p_pes = p_stream->chain_pes.p_first;
1032         if( p_pes )
1033         {
1034             p_stream->i_pes_dts    = p_pes->i_dts;
1035             p_stream->i_pes_length = 0;
1036             while( p_pes )
1037             {
1038                 p_stream->i_pes_length += p_pes->i_length;
1039
1040                 p_pes = p_pes->p_next;
1041             }
1042         }
1043         else
1044         {
1045             p_stream->i_pes_dts = 0;
1046             p_stream->i_pes_length = 0;
1047         }
1048         p_stream->i_pes_used = 0;
1049     }
1050
1051     return p_ts;
1052 }
1053
1054
1055 static void TSSetPCR( sout_buffer_t *p_ts, mtime_t i_dts )
1056 {
1057     mtime_t i_pcr = 9 * i_dts / 100;
1058
1059     p_ts->p_buffer[6]  = ( i_pcr >> 25 )&0xff;
1060     p_ts->p_buffer[7]  = ( i_pcr >> 17 )&0xff;
1061     p_ts->p_buffer[8]  = ( i_pcr >> 9  )&0xff;
1062     p_ts->p_buffer[9]  = ( i_pcr >> 1  )&0xff;
1063     p_ts->p_buffer[10]|= ( i_pcr << 7  )&0x80;
1064 }
1065
1066 #if 0
1067 static void TSSetConstraints( sout_mux_t *p_mux, sout_buffer_chain_t *c, mtime_t i_length, int i_bitrate_min, int i_bitrate_max )
1068 {
1069     sout_mux_sys_t  *p_sys = p_mux->p_sys;
1070     sout_buffer_chain_t s = *c;
1071
1072     int i_packets = 0;
1073     int i_packets_min = 0;
1074     int i_packets_max = 0;
1075
1076     if( i_length <= 0 )
1077     {
1078         return;
1079     }
1080
1081     i_packets     = c->i_depth;
1082     i_packets_min = ( (int64_t)i_bitrate_min * i_length / 8 / 1000000  + 187 ) / 188;
1083     i_packets_max = ( (int64_t)i_bitrate_max * i_length / 8 / 1000000  + 187 ) / 188;
1084
1085     if( i_packets < i_packets_min && i_packets_min > 0 )
1086     {
1087         sout_buffer_t *p_pk;
1088         int i_div = ( i_packets_min - i_packets ) / i_packets;
1089         int i_mod = ( i_packets_min - i_packets ) % i_packets;
1090         int i_rest = 0;
1091
1092         /* We need to pad with null packets (pid=0x1fff)
1093          * We try to melt null packets with true packets */
1094         msg_Dbg( p_mux,
1095                  "packets=%d but min=%d -> adding %d packets of padding",
1096                  i_packets, i_packets_min, i_packets_min - i_packets );
1097
1098         BufferChainInit( c );
1099         while( ( p_pk = BufferChainGet( &s ) ) )
1100         {
1101             int i, i_null;
1102
1103             BufferChainAppend( c, p_pk );
1104
1105             i_null = i_div + ( i_rest + i_mod ) / i_packets;
1106
1107             for( i = 0; i < i_null; i++ )
1108             {
1109                 sout_buffer_t *p_null;
1110
1111                 p_null = sout_BufferNew( p_mux->p_sout, 188 );
1112                 p_null->p_buffer[0] = 0x47;
1113                 p_null->p_buffer[1] = 0x1f;
1114                 p_null->p_buffer[2] = 0xff;
1115                 p_null->p_buffer[3] = 0x10 | p_sys->i_null_continuity_counter;
1116                 memset( &p_null->p_buffer[4], 0, 184 );
1117                 p_sys->i_null_continuity_counter =
1118                     ( p_sys->i_null_continuity_counter + 1 ) % 16;
1119
1120                 BufferChainAppend( c, p_null );
1121             }
1122
1123             i_rest = ( i_rest + i_mod ) % i_packets;
1124         }
1125     }
1126     else if( i_packets > i_packets_max && i_packets_max > 0 )
1127     {
1128         sout_buffer_t *p_pk;
1129         int           i;
1130
1131         /* Arg, we need to drop packets, I don't do something clever (like
1132          * dropping complete pid, b frames, ... ), I just get the right amount
1133          * of packets and discard the others */
1134         msg_Warn( p_mux,
1135                   "packets=%d but max=%d -> removing %d packets -> stream broken",
1136                   i_packets, i_packets_max, i_packets - i_packets_max );
1137
1138         BufferChainInit( c );
1139         for( i = 0; i < i_packets_max; i++ )
1140         {
1141             BufferChainAppend( c, BufferChainGet( &s ) );
1142         }
1143
1144         while( ( p_pk = BufferChainGet( &s ) ) )
1145         {
1146             sout_BufferDelete( p_mux->p_sout, p_pk );
1147         }
1148     }
1149 }
1150 #endif
1151
1152 static void PEStoTS( sout_instance_t *p_sout,
1153                      sout_buffer_chain_t *c, sout_buffer_t *p_pes,
1154                      ts_stream_t *p_stream )
1155 {
1156     uint8_t *p_data;
1157     int     i_size;
1158     int     b_new_pes;
1159
1160     /* get PES total size */
1161     i_size = p_pes->i_size;
1162     p_data = p_pes->p_buffer;
1163
1164     b_new_pes = VLC_TRUE;
1165
1166     for( ;; )
1167     {
1168         int           b_adaptation_field;
1169         int           i_copy;
1170         sout_buffer_t *p_ts;
1171
1172         p_ts = sout_BufferNew( p_sout, 188 );
1173         /* write header
1174          * 8b   0x47    sync byte
1175          * 1b           transport_error_indicator
1176          * 1b           payload_unit_start
1177          * 1b           transport_priority
1178          * 13b          pid
1179          * 2b           transport_scrambling_control
1180          * 2b           if adaptation_field 0x03 else 0x01
1181          * 4b           continuity_counter
1182          */
1183
1184         i_copy    = __MIN( i_size, 184 );
1185         b_adaptation_field = i_size < 184 ? VLC_TRUE : VLC_FALSE;
1186
1187         p_ts->p_buffer[0] = 0x47;
1188         p_ts->p_buffer[1] = ( b_new_pes ? 0x40 : 0x00 )|
1189                             ( ( p_stream->i_pid >> 8 )&0x1f );
1190         p_ts->p_buffer[2] = p_stream->i_pid & 0xff;
1191         p_ts->p_buffer[3] = ( b_adaptation_field ? 0x30 : 0x10 )|
1192                             p_stream->i_continuity_counter;
1193
1194         b_new_pes = VLC_FALSE;
1195         p_stream->i_continuity_counter = (p_stream->i_continuity_counter+1)%16;
1196
1197         if( b_adaptation_field )
1198         {
1199             int i_stuffing = 184 - i_copy;
1200             int i;
1201
1202             p_ts->p_buffer[4] = i_stuffing - 1;
1203             if( i_stuffing > 1 )
1204             {
1205                 p_ts->p_buffer[5] = 0x00;
1206                 for( i = 6; i < 6 + i_stuffing - 2; i++ )
1207                 {
1208                     p_ts->p_buffer[i] = 0xff;
1209                 }
1210             }
1211         }
1212         /* copy payload */
1213         memcpy( &p_ts->p_buffer[188 - i_copy], p_data, i_copy );
1214         p_data += i_copy;
1215         i_size -= i_copy;
1216
1217         BufferChainAppend( c, p_ts );
1218
1219         if( i_size <= 0 )
1220         {
1221             sout_buffer_t *p_next = p_pes->p_next;
1222
1223             p_pes->p_next = NULL;
1224             sout_BufferDelete( p_sout, p_pes );
1225             if( p_next == NULL )
1226             {
1227                 break;
1228             }
1229             b_new_pes = VLC_TRUE;
1230             p_pes = p_next;
1231             i_size = p_pes->i_size;
1232             p_data = p_pes->p_buffer;
1233         }
1234     }
1235
1236     return;
1237 }
1238
1239 #if defined MODULE_NAME_IS_mux_ts
1240 static uint32_t CalculateCRC( uint8_t *p_begin, int i_count )
1241 {
1242     static uint32_t CRC32[256] =
1243     {
1244         0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
1245         0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
1246         0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
1247         0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
1248         0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
1249         0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
1250         0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
1251         0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
1252         0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
1253         0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
1254         0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
1255         0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
1256         0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
1257         0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
1258         0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
1259         0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
1260         0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
1261         0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
1262         0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
1263         0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
1264         0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
1265         0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
1266         0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
1267         0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
1268         0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
1269         0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
1270         0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
1271         0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
1272         0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
1273         0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
1274         0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
1275         0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
1276         0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
1277         0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
1278         0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
1279         0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
1280         0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
1281         0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
1282         0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
1283         0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
1284         0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
1285         0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
1286         0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
1287         0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
1288         0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
1289         0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
1290         0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
1291         0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
1292         0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
1293         0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
1294         0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
1295         0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
1296         0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
1297         0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
1298         0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
1299         0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
1300         0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
1301         0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
1302         0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
1303         0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
1304         0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
1305         0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
1306         0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
1307         0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
1308     };
1309
1310     uint32_t i_crc = 0xffffffff;
1311
1312     /* Calculate the CRC */
1313     while( i_count > 0 )
1314     {
1315         i_crc = (i_crc<<8) ^ CRC32[ (i_crc>>24) ^ ((uint32_t)*p_begin) ];
1316         p_begin++;
1317         i_count--;
1318     }
1319
1320     return( i_crc );
1321 }
1322
1323 static void GetPAT( sout_mux_t *p_mux,
1324                     sout_buffer_chain_t *c )
1325 {
1326     sout_mux_sys_t      *p_sys = p_mux->p_sys;
1327     sout_buffer_t       *p_pat;
1328     bits_buffer_t bits;
1329
1330     p_pat = sout_BufferNew( p_mux->p_sout, 1024 );
1331
1332     p_pat->i_pts = 0;
1333     p_pat->i_dts = 0;
1334     p_pat->i_length = 0;
1335
1336     bits_initwrite( &bits, 1024, p_pat->p_buffer );
1337
1338     bits_write( &bits, 8, 0 );      // pointer
1339     bits_write( &bits, 8, 0x00 );   // table id
1340     bits_write( &bits, 1,  1 );     // section_syntax_indicator
1341     bits_write( &bits, 1,  0 );     // 0
1342     bits_write( &bits, 2,  0x03 );     // reserved FIXME
1343     bits_write( &bits, 12, 13 );    // XXX for one program only XXX
1344     bits_write( &bits, 16, 0x01 );  // FIXME stream id
1345     bits_write( &bits, 2,  0x03 );     //  FIXME
1346     bits_write( &bits, 5,  p_sys->i_pat_version_number );
1347     bits_write( &bits, 1,  1 );     // current_next_indicator
1348     bits_write( &bits, 8,  0 );     // section number
1349     bits_write( &bits, 8,  0 );     // last section number
1350
1351     bits_write( &bits, 16, 1 );     // program number
1352     bits_write( &bits,  3, 0x07 );     // reserved
1353     bits_write( &bits, 13, p_sys->pmt.i_pid );  // program map pid
1354
1355     bits_write( &bits, 32, CalculateCRC( bits.p_data + 1, bits.i_data - 1) );
1356
1357     p_pat->i_size = bits.i_data;
1358
1359     PEStoTS( p_mux->p_sout, c, p_pat, &p_sys->pat );
1360 }
1361
1362 static void GetPMT( sout_mux_t *p_mux,
1363                     sout_buffer_chain_t *c )
1364 {
1365     sout_mux_sys_t      *p_sys = p_mux->p_sys;
1366     sout_buffer_t       *p_pmt;
1367     bits_buffer_t bits;
1368     int           i_stream;
1369
1370     p_pmt = sout_BufferNew( p_mux->p_sout, 1024 );
1371
1372     p_pmt->i_pts = 0;
1373     p_pmt->i_dts = 0;
1374     p_pmt->i_length = 0;
1375
1376     bits_initwrite( &bits, 1024, p_pmt->p_buffer );
1377
1378     bits_write( &bits, 8, 0 );      // pointer
1379     bits_write( &bits, 8, 0x02 );   // table id
1380     bits_write( &bits, 1,  1 );     // section_syntax_indicator
1381     bits_write( &bits, 1,  0 );     // 0
1382     bits_write( &bits, 2,  0 );     // reserved FIXME
1383     bits_write( &bits, 12, 13 + 5 * p_mux->i_nb_inputs );
1384     bits_write( &bits, 16, 1 );     // FIXME program number
1385     bits_write( &bits, 2,  0 );     //  FIXME
1386     bits_write( &bits, 5,  p_sys->i_pmt_version_number );
1387     bits_write( &bits, 1,  1 );     // current_next_indicator
1388     bits_write( &bits, 8,  0 );     // section number
1389     bits_write( &bits, 8,  0 );     // last section number
1390
1391     bits_write( &bits,  3, 0 );     // reserved
1392
1393     bits_write( &bits, 13, p_sys->i_pcr_pid );     //  FIXME FXIME PCR_PID FIXME
1394     bits_write( &bits,  4, 0 );     // reserved FIXME
1395
1396     bits_write( &bits, 12, 0 );    // program info len FIXME
1397
1398     for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
1399     {
1400         ts_stream_t *p_stream;
1401
1402         p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
1403
1404         bits_write( &bits,  8, p_stream->i_stream_type ); // stream_type
1405         bits_write( &bits,  3, 0 );                 // reserved
1406         bits_write( &bits, 13, p_stream->i_pid );   // es pid
1407         bits_write( &bits,  4, 0 );                 //reserved
1408         bits_write( &bits, 12, 0 );                 // es info len FIXME
1409     }
1410
1411     bits_write( &bits, 32, CalculateCRC( bits.p_data + 1, bits.i_data - 1) );
1412
1413     p_pmt->i_size = bits.i_data;
1414
1415     PEStoTS( p_mux->p_sout, c, p_pmt, &p_sys->pmt );
1416 }
1417 #elif defined MODULE_NAME_IS_mux_ts_dvbpsi
1418
1419 static sout_buffer_t *WritePSISection( sout_instance_t *p_sout,
1420                                        dvbpsi_psi_section_t* p_section )
1421 {
1422     sout_buffer_t   *p_psi, *p_first = NULL;
1423
1424
1425     while( p_section )
1426     {
1427         int             i_size;
1428
1429         i_size =  (uint32_t)( p_section->p_payload_end - p_section->p_data )+
1430                   ( p_section->b_syntax_indicator ? 4 : 0 );
1431
1432         p_psi = sout_BufferNew( p_sout, i_size + 1 );
1433         p_psi->i_pts = 0;
1434         p_psi->i_dts = 0;
1435         p_psi->i_length = 0;
1436         p_psi->i_size = i_size + 1;
1437
1438         p_psi->p_buffer[0] = 0; // pointer
1439         memcpy( p_psi->p_buffer + 1,
1440                 p_section->p_data,
1441                 i_size );
1442
1443         sout_BufferChain( &p_first, p_psi );
1444
1445         p_section = p_section->p_next;
1446     }
1447
1448     return( p_first );
1449 }
1450
1451 static void GetPAT( sout_mux_t *p_mux,
1452                     sout_buffer_chain_t *c )
1453 {
1454     sout_mux_sys_t       *p_sys = p_mux->p_sys;
1455     sout_buffer_t        *p_pat;
1456     dvbpsi_pat_t         pat;
1457     dvbpsi_psi_section_t *p_section;
1458
1459     dvbpsi_InitPAT( &pat,
1460                     0x01,    // i_ts_id
1461                     p_sys->i_pat_version_number,
1462                     1 );      // b_current_next
1463     /* add all program (only one) */
1464     dvbpsi_PATAddProgram( &pat,
1465                           1,                    // i_number
1466                           p_sys->pmt.i_pid );   // i_pid
1467
1468     p_section = dvbpsi_GenPATSections( &pat,
1469                                        0 );     // max program per section
1470
1471     p_pat = WritePSISection( p_mux->p_sout, p_section );
1472
1473     PEStoTS( p_mux->p_sout, c, p_pat, &p_sys->pat );
1474
1475     dvbpsi_DeletePSISections( p_section );
1476     dvbpsi_EmptyPAT( &pat );
1477 }
1478
1479 static uint32_t GetDescriptorLength24b( int i_length )
1480 {
1481     uint32_t    i_l1, i_l2, i_l3;
1482
1483     i_l1 = i_length&0x7f;
1484     i_l2 = ( i_length >> 7 )&0x7f;
1485     i_l3 = ( i_length >> 14 )&0x7f;
1486
1487     return( 0x808000 | ( i_l3 << 16 ) | ( i_l2 << 8 ) | i_l1 );
1488 }
1489
1490 static void GetPMT( sout_mux_t *p_mux,
1491                     sout_buffer_chain_t *c )
1492 {
1493     sout_mux_sys_t  *p_sys = p_mux->p_sys;
1494     sout_buffer_t   *p_pmt;
1495
1496     dvbpsi_pmt_t        pmt;
1497     dvbpsi_pmt_es_t     *p_es;
1498     dvbpsi_psi_section_t *p_section;
1499
1500     int                 i_stream;
1501
1502     dvbpsi_InitPMT( &pmt,
1503                     0x01,   // program number
1504                     p_sys->i_pmt_version_number,
1505                     1,      // b_current_next
1506                     p_sys->i_pcr_pid );
1507
1508     if( p_sys->i_mpeg4_streams > 0 )
1509     {
1510         uint8_t iod[4096];
1511         bits_buffer_t bits;
1512         bits_buffer_t bits_fix_IOD;
1513
1514         /* Make valgrind happy : it works at byte level not bit one so
1515          * bit_write confuse it (but DON'T CHANGE the way that bit_write is
1516          * working (needed when fixing some bits) */
1517         memset( iod, 0, 4096 );
1518
1519         bits_initwrite( &bits, 4096, iod );
1520         // IOD_label
1521         bits_write( &bits, 8,   0x01 );
1522         // InitialObjectDescriptor
1523         bits_align( &bits );
1524         bits_write( &bits, 8,   0x02 );     // tag
1525         bits_fix_IOD = bits;    // save states to fix length later
1526         bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) ); // variable length (fixed later)
1527         bits_write( &bits, 10,  0x01 );     // ObjectDescriptorID
1528         bits_write( &bits, 1,   0x00 );     // URL Flag
1529         bits_write( &bits, 1,   0x00 );     // includeInlineProfileLevelFlag
1530         bits_write( &bits, 4,   0x0f );     // reserved
1531         bits_write( &bits, 8,   0xff );     // ODProfile (no ODcapability )
1532         bits_write( &bits, 8,   0xff );     // sceneProfile
1533         bits_write( &bits, 8,   0xfe );     // audioProfile (unspecified)
1534         bits_write( &bits, 8,   0xfe );     // visualProfile( // )
1535         bits_write( &bits, 8,   0xff );     // graphicProfile (no )
1536         for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
1537         {
1538             ts_stream_t *p_stream;
1539             p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
1540
1541             if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
1542             {
1543                 bits_buffer_t bits_fix_ESDescr, bits_fix_Decoder;
1544                 /* ES descriptor */
1545                 bits_align( &bits );
1546                 bits_write( &bits, 8,   0x03 );     // ES_DescrTag
1547                 bits_fix_ESDescr = bits;
1548                 bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) ); // variable size
1549                 bits_write( &bits, 16,  p_stream->i_es_id );
1550                 bits_write( &bits, 1,   0x00 );     // streamDependency
1551                 bits_write( &bits, 1,   0x00 );     // URL Flag
1552                 bits_write( &bits, 1,   0x00 );     // OCRStreamFlag
1553                 bits_write( &bits, 5,   0x1f );     // streamPriority
1554
1555                     // DecoderConfigDesciptor
1556                 bits_align( &bits );
1557                 bits_write( &bits, 8,   0x04 ); // DecoderConfigDescrTag
1558                 bits_fix_Decoder = bits;
1559                 bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) );
1560                 if( p_stream->i_stream_type == 0x10 )
1561                 {
1562                     bits_write( &bits, 8, 0x20 );   // Visual 14496-2
1563                     bits_write( &bits, 6, 0x04 );   // VisualStream
1564                 }
1565                 else if( p_stream->i_stream_type == 0x11 )
1566                 {
1567                     bits_write( &bits, 8, 0x40 );   // Audio 14496-3
1568                     bits_write( &bits, 6, 0x05 );   // AudioStream
1569                 }
1570                 else
1571                 {
1572                     bits_write( &bits, 8, 0x00 );
1573                     bits_write( &bits, 6, 0x00 );
1574
1575                     msg_Err( p_mux->p_sout,"Unsupported stream_type => broken IOD");
1576                 }
1577                 bits_write( &bits, 1,   0x00 );     // UpStream
1578                 bits_write( &bits, 1,   0x01 );     // reserved
1579                 bits_write( &bits, 24,  1024 * 1024 );  // bufferSizeDB
1580                 bits_write( &bits, 32,  0x7fffffff );   // maxBitrate
1581                 bits_write( &bits, 32,  0 );            // avgBitrate
1582
1583                 if( p_stream->i_decoder_specific_info > 0 )
1584                 {
1585                     int i;
1586                     // DecoderSpecificInfo
1587                     bits_align( &bits );
1588                     bits_write( &bits, 8,   0x05 ); // tag
1589                     bits_write( &bits, 24,
1590                                 GetDescriptorLength24b( p_stream->i_decoder_specific_info ) );
1591                     for( i = 0; i < p_stream->i_decoder_specific_info; i++ )
1592                     {
1593                         bits_write( &bits, 8,   ((uint8_t*)p_stream->p_decoder_specific_info)[i] );
1594                     }
1595                 }
1596                 /* fix Decoder length */
1597                 bits_write( &bits_fix_Decoder, 24,
1598                             GetDescriptorLength24b( bits.i_data - bits_fix_Decoder.i_data - 3 ) );
1599
1600                 /* SLConfigDescriptor : predifined (0x01) */
1601                 bits_align( &bits );
1602                 bits_write( &bits, 8,   0x06 ); // tag
1603                 bits_write( &bits, 24,  GetDescriptorLength24b( 8 ) );
1604                 bits_write( &bits, 8,   0x01 ); // predefined
1605                 bits_write( &bits, 1,   0 );   // durationFlag
1606                 bits_write( &bits, 32,  0 );   // OCRResolution
1607                 bits_write( &bits, 8,   0 );   // OCRLength
1608                 bits_write( &bits, 8,   0 );   // InstantBitrateLength
1609                 bits_align( &bits );
1610
1611                 /* fix ESDescr length */
1612                 bits_write( &bits_fix_ESDescr, 24,
1613                             GetDescriptorLength24b( bits.i_data - bits_fix_ESDescr.i_data - 3 ) );
1614             }
1615         }
1616         bits_align( &bits );
1617         /* fix IOD length */
1618         bits_write( &bits_fix_IOD, 24,
1619                     GetDescriptorLength24b( bits.i_data - bits_fix_IOD.i_data - 3 ) );
1620         dvbpsi_PMTAddDescriptor( &pmt,
1621                                  0x1d,
1622                                  bits.i_data,
1623                                  bits.p_data );
1624     }
1625
1626     for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
1627     {
1628         ts_stream_t *p_stream;
1629
1630         p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
1631
1632         p_es = dvbpsi_PMTAddES( &pmt,
1633                                 p_stream->i_stream_type,
1634                                 p_stream->i_pid );
1635         if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
1636         {
1637             uint8_t     es_id[2];
1638
1639             /* SL descriptor */
1640             es_id[0] = (p_stream->i_es_id >> 8)&0xff;
1641             es_id[1] = (p_stream->i_es_id)&0xff;
1642             dvbpsi_PMTESAddDescriptor( p_es, 0x1f, 2, es_id );
1643         }
1644         else if( p_stream->i_stream_type == 0xa0 )
1645         {
1646             uint8_t     data[512];
1647             int         i_extra = __MIN( p_stream->i_decoder_specific_info,
1648                                         502 );
1649
1650             /* private DIV3 descripor */
1651             memcpy( &data[0], &p_stream->i_bih_codec, 4 );
1652             data[4] = ( p_stream->i_bih_width >> 8 )&0xff;
1653             data[5] = ( p_stream->i_bih_width      )&0xff;
1654             data[6] = ( p_stream->i_bih_height>> 8 )&0xff;
1655             data[7] = ( p_stream->i_bih_height     )&0xff;
1656             data[8] = ( i_extra >> 8 )&0xff;
1657             data[9] = ( i_extra      )&0xff;
1658             if( i_extra > 0 )
1659             {
1660                 memcpy( &data[10], p_stream->p_decoder_specific_info, i_extra );
1661             }
1662
1663             /* 0xa0 is private */
1664             dvbpsi_PMTESAddDescriptor( p_es, 0xa0, i_extra  + 10, data );
1665         }
1666         else if( p_stream->i_stream_type == 0x81 )
1667         {
1668             uint8_t format[4] = { 0x41, 0x43, 0x2d, 0x33 };
1669
1670             /* "registration" descriptor : "AC-3" */
1671             dvbpsi_PMTESAddDescriptor( p_es, 0x05, 4, format );
1672         }
1673
1674         if( p_stream->lang[0] != 0 )
1675         {
1676             uint8_t data[4];
1677
1678             /* I construct the content myself, way faster than looking at
1679              * over complicated/mind broken libdvbpsi way */
1680             data[0] = p_stream->lang[0];
1681             data[1] = p_stream->lang[1];
1682             data[2] = p_stream->lang[2];
1683             data[3] = 0x00; /* audio type: 0x00 undefined */
1684
1685             dvbpsi_PMTESAddDescriptor( p_es, 0x0a, 4, data );
1686         }
1687     }
1688
1689     p_section = dvbpsi_GenPMTSections( &pmt );
1690
1691     p_pmt = WritePSISection( p_mux->p_sout, p_section );
1692
1693     PEStoTS( p_mux->p_sout, c, p_pmt, &p_sys->pmt );
1694
1695     dvbpsi_DeletePSISections( p_section );
1696     dvbpsi_EmptyPMT( &pmt );
1697 }
1698
1699 #endif
1700