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