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

   1 /*****************************************************************************
   2  * ts.c
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: ts.c,v 1.16 2003/04/13 20:00:21 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 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35
  36 #include <vlc/vlc.h>
  37 #include <vlc/input.h>
  38 #include <vlc/sout.h>
  39
  40 #ifdef HAVE_UNISTD_H
  41 #   include <unistd.h>
  42 #endif
  43
  44 #include "codecs.h"
  45 #include "bits.h"
  46 #include "pes.h"
  47
  48 #if defined MODULE_NAME_IS_mux_ts_dvbpsi
  49 #   ifdef HAVE_DVBPSI_DR_H
  50 #       include <dvbpsi/dvbpsi.h>
  51 #       include <dvbpsi/descriptor.h>
  52 #       include <dvbpsi/pat.h>
  53 #       include <dvbpsi/pmt.h>
  54 #       include <dvbpsi/dr.h>
  55 #       include <dvbpsi/psi.h>
  56 #   else
  57 #       include "dvbpsi.h"
  58 #       include "descriptor.h"
  59 #       include "tables/pat.h"
  60 #       include "tables/pmt.h"
  61 #       include "descriptors/dr.h"
  62 #       include "psi.h"
  63 #   endif
  64 #endif
  65
  66 typedef struct ts_stream_s
  67 {
  68     int             i_pid;
  69     int             i_stream_type;
  70     int             i_stream_id;
  71     int             i_continuity_counter;
  72
  73     /* to be used for carriege of DIV3 */
  74     vlc_fourcc_t    i_bih_codec;
  75     int             i_bih_width, i_bih_height;
  76
  77     /* Specific to mpeg4 in mpeg2ts */
  78     int             i_es_id;
  79     int             i_sl_predefined;
  80
  81     int             i_decoder_specific_info_len;
  82     uint8_t         *p_decoder_specific_info;
  83 } ts_stream_t;
  84
  85 struct sout_mux_sys_t
  86 {
  87     int             i_pcr_pid;
  88     int             i_stream_id_mpga;
  89     int             i_stream_id_mpgv;
  90     int             i_stream_id_a52;
  91
  92     int             i_audio_bound;
  93     int             i_video_bound;
  94
  95     int             i_pid_free; // first usable pid
  96
  97     int             i_pat_version_number;
  98     ts_stream_t     pat;
  99
 100     int             i_pmt_version_number;
 101     ts_stream_t     pmt;        // Up to now only one program
 102
 103     int             i_ts_packet;// To known when to put pat/mpt
 104
 105     int             i_mpeg4_streams;
 106
 107 };
 108
 109
 110 /*****************************************************************************
 111  * Exported prototypes
 112  *****************************************************************************/
 113 static int     Open   ( vlc_object_t * );
 114 static void    Close  ( vlc_object_t * );
 115
 116
 117 static int     Capability(sout_mux_t *, int, void *, void * );
 118 static int     AddStream( sout_mux_t *, sout_input_t * );
 119 static int     DelStream( sout_mux_t *, sout_input_t * );
 120 static int     Mux      ( sout_mux_t * );
 121
 122
 123
 124 /* Reserve a pid and return it */
 125 static int     AllocatePID( sout_mux_sys_t *p_sys )
 126 {
 127     return( ++p_sys->i_pid_free );
 128 }
 129
 130 static int GetPAT( sout_mux_t *p_mux, sout_buffer_t **pp_ts );
 131 static int GetPMT( sout_mux_t *p_mux, sout_buffer_t **pp_ts );
 132
 133 /*****************************************************************************
 134  * Module descriptor
 135  *****************************************************************************/
 136 vlc_module_begin();
 137 #if defined MODULE_NAME_IS_mux_ts
 138     set_description( _("TS muxer") );
 139     set_capability( "sout mux", 100 );
 140     add_shortcut( "ts" );
 141     add_shortcut( "ts_nodvbpsi" );
 142 #elif defined MODULE_NAME_IS_mux_ts_dvbpsi
 143     set_description( _("TS muxer (libdvbpsi)") );
 144     set_capability( "sout mux", 120 );
 145     add_shortcut( "ts" );
 146     add_shortcut( "ts_dvbpsi" );
 147 #endif
 148     set_callbacks( Open, Close );
 149 vlc_module_end();
 150
 151 /*****************************************************************************
 152  * Open:
 153  *****************************************************************************/
 154 static int Open( vlc_object_t *p_this )
 155 {
 156     sout_mux_t          *p_mux =(sout_mux_t*)p_this;
 157     sout_mux_sys_t      *p_sys;
 158
 159     msg_Info( p_mux, "Open" );
 160
 161     p_sys = malloc( sizeof( sout_mux_sys_t ) );
 162
 163     p_mux->pf_capacity  = Capability;
 164     p_mux->pf_addstream = AddStream;
 165     p_mux->pf_delstream = DelStream;
 166     p_mux->pf_mux       = Mux;
 167     p_mux->p_sys        = p_sys;
 168     p_mux->i_preheader  = 30; // really enough for a pes header
 169
 170     srand( (uint32_t)mdate() );
 171
 172     p_sys->i_stream_id_mpga = 0xc0;
 173     p_sys->i_stream_id_a52  = 0x80;
 174     p_sys->i_stream_id_mpgv = 0xe0;
 175
 176     p_sys->i_audio_bound = 0;
 177     p_sys->i_video_bound = 0;
 178
 179     p_sys->i_pat_version_number = rand() % 32;
 180     p_sys->pat.i_pid = 0;
 181     p_sys->pat.i_continuity_counter = 0;
 182
 183     p_sys->i_pmt_version_number = rand() % 32;
 184     p_sys->pmt.i_pid = 0x10;
 185     p_sys->pmt.i_continuity_counter = 0;
 186
 187     p_sys->i_pid_free = 0x11;
 188     p_sys->i_pcr_pid = 0x1fff;
 189
 190     p_sys->i_mpeg4_streams = 0;
 191
 192     return VLC_SUCCESS;
 193 }
 194
 195 /*****************************************************************************
 196  * Close:
 197  *****************************************************************************/
 198
 199 static void Close( vlc_object_t * p_this )
 200 {
 201     sout_mux_t          *p_mux = (sout_mux_t*)p_this;
 202     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 203
 204     msg_Info( p_mux, "Close" );
 205
 206     free( p_sys );
 207     p_mux->p_sys = NULL;
 208 }
 209
 210 static int Capability( sout_mux_t *p_mux, int i_query, void *p_args, void *p_answer )
 211 {
 212    switch( i_query )
 213    {
 214         case SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME:
 215             *(vlc_bool_t*)p_answer = VLC_TRUE;
 216             return( SOUT_MUX_CAP_ERR_OK );
 217         default:
 218             return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED );
 219    }
 220 }
 221
 222 static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
 223 {
 224     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 225     ts_stream_t         *p_stream;
 226
 227     msg_Dbg( p_mux, "adding input" );
 228     p_input->p_sys = (void*)p_stream = malloc( sizeof( ts_stream_t ) );
 229
 230     p_stream->i_pid = AllocatePID( p_sys );
 231     if( p_sys->i_pcr_pid == 0x1fff )
 232     {
 233         p_sys->i_pcr_pid = p_stream->i_pid;
 234     }
 235     p_stream->i_continuity_counter = 0;
 236
 237     switch( p_input->p_fmt->i_cat )
 238     {
 239         case VIDEO_ES:
 240             switch( p_input->p_fmt->i_fourcc )
 241             {
 242                 case VLC_FOURCC( 'm', 'p','g', 'v' ):
 243                     p_stream->i_stream_type = 0x02;
 244                     p_stream->i_stream_id = p_sys->i_stream_id_mpgv;
 245                     p_sys->i_stream_id_mpgv++;
 246                     break;
 247                 case VLC_FOURCC( 'm', 'p','4', 'v' ):
 248                     p_stream->i_stream_type = 0x10;
 249                     p_stream->i_stream_id = 0xfa;
 250                     p_sys->i_mpeg4_streams++;
 251                     p_stream->i_es_id = p_stream->i_pid;
 252                     p_stream->i_sl_predefined = 0x01;   // NULL SL header
 253                     break;
 254                 /* XXX dirty dirty but somebody want that : using crapy MS-codec XXX */
 255                 /* I didn't want to do that :P */
 256                 case VLC_FOURCC( 'W', 'M', 'V', '2' ):
 257                 case VLC_FOURCC( 'H', '2', '6', '3' ):
 258                 case VLC_FOURCC( 'I', '2', '6', '3' ):
 259                 case VLC_FOURCC( 'W', 'M', 'V', '1' ):
 260                 case VLC_FOURCC( 'D', 'I', 'V', '3' ):
 261                 case VLC_FOURCC( 'D', 'I', 'V', '2' ):
 262                 case VLC_FOURCC( 'D', 'I', 'V', '1' ):
 263                     p_stream->i_stream_type = 0xa0; // private
 264                     p_stream->i_stream_id = 0xa0;   // beurk
 265                     break;
 266                 default:
 267                     return( -1 );
 268             }
 269             p_sys->i_video_bound++;
 270
 271             p_stream->i_bih_codec  = p_input->p_fmt->i_fourcc;
 272             p_stream->i_bih_width  = p_input->p_fmt->i_width;
 273             p_stream->i_bih_height = p_input->p_fmt->i_height;
 274
 275             p_stream->i_decoder_specific_info_len = p_input->p_fmt->i_extra_data;
 276             if( p_stream->i_decoder_specific_info_len > 0 )
 277             {
 278                 p_stream->p_decoder_specific_info =
 279                     malloc( p_stream->i_decoder_specific_info_len );
 280                 memcpy( p_stream->p_decoder_specific_info,
 281                         p_input->p_fmt->p_extra_data,
 282                         p_input->p_fmt->i_extra_data );
 283             }
 284             else
 285             {
 286                 p_stream->p_decoder_specific_info = NULL;
 287             }
 288             break;
 289
 290         case AUDIO_ES:
 291             switch( p_input->p_fmt->i_fourcc )
 292             {
 293                 case VLC_FOURCC( 'a', '5','2', ' ' ):
 294                 case VLC_FOURCC( 'a', '5','2', 'b' ):
 295                     p_stream->i_stream_type = 0x81;
 296                     p_stream->i_stream_id = p_sys->i_stream_id_a52;
 297                     p_sys->i_stream_id_a52++;
 298                     break;
 299                 case VLC_FOURCC( 'm', 'p','4', 'a' ):
 300                     p_stream->i_stream_type = 0x11;
 301                     p_stream->i_stream_id = 0xfa;
 302                     p_sys->i_mpeg4_streams++;
 303                     p_stream->i_es_id = p_stream->i_pid;
 304                     p_stream->i_sl_predefined = 0x01;   // NULL SL header
 305                     break;
 306                 case VLC_FOURCC( 'm', 'p','g', 'a' ):
 307                     p_stream->i_stream_type = 0x04;
 308                     p_stream->i_stream_id = p_sys->i_stream_id_mpga;
 309                     p_sys->i_stream_id_mpga++;
 310                     break;
 311                 default:
 312                     return( -1 );
 313             }
 314             p_sys->i_audio_bound++;
 315
 316             p_stream->i_decoder_specific_info_len = p_input->p_fmt->i_extra_data;
 317             if( p_stream->i_decoder_specific_info_len > 0 )
 318             {
 319                 p_stream->p_decoder_specific_info =
 320                     malloc( p_stream->i_decoder_specific_info_len );
 321                 memcpy( p_stream->p_decoder_specific_info,
 322                         p_input->p_fmt->p_extra_data,
 323                         p_input->p_fmt->i_extra_data );
 324             }
 325             else
 326             {
 327                 p_stream->p_decoder_specific_info = NULL;
 328             }
 329             break;
 330         default:
 331             return( -1 );
 332     }
 333
 334     p_sys->i_ts_packet = 0; // force pat/pmt recreation
 335     p_sys->i_pat_version_number++; p_sys->i_pat_version_number %= 32;
 336     p_sys->i_pmt_version_number++; p_sys->i_pmt_version_number %= 32;
 337
 338     return( 0 );
 339 }
 340
 341 static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
 342 {
 343     sout_mux_sys_t  *p_sys = p_mux->p_sys;
 344     ts_stream_t     *p_stream;
 345
 346     msg_Dbg( p_mux, "removing input" );
 347     p_stream = (ts_stream_t*)p_input->p_sys;
 348
 349     if( p_stream->p_decoder_specific_info )
 350     {
 351         free( p_stream->p_decoder_specific_info );
 352     }
 353     if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
 354     {
 355         p_sys->i_mpeg4_streams--;
 356     }
 357     p_sys->i_ts_packet = 0; // force pat/pmt recreation
 358     p_sys->i_pat_version_number++; p_sys->i_pat_version_number %= 32;
 359     p_sys->i_pmt_version_number++; p_sys->i_pmt_version_number %= 32;
 360
 361     return( 0 );
 362 }
 363
 364
 365
 366 static int MuxGetStream( sout_mux_t *p_mux,
 367                          int        *pi_stream,
 368                          mtime_t    *pi_dts )
 369 {
 370     mtime_t i_dts;
 371     int     i_stream;
 372     int     i;
 373
 374     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
 375     {
 376         sout_fifo_t  *p_fifo;
 377
 378         p_fifo = p_mux->pp_inputs[i]->p_fifo;
 379
 380         if( p_fifo->i_depth > 1 )
 381         {
 382             sout_buffer_t *p_buf;
 383
 384             p_buf = sout_FifoShow( p_fifo );
 385             if( i_stream < 0 || p_buf->i_dts < i_dts )
 386             {
 387                 i_dts = p_buf->i_dts;
 388                 i_stream = i;
 389             }
 390         }
 391         else
 392         {
 393             return( -1 ); // wait that all fifo have at least 2 packets
 394         }
 395     }
 396
 397     if( pi_stream )
 398     {
 399         *pi_stream = i_stream;
 400     }
 401     if( pi_dts )
 402     {
 403         *pi_dts = i_dts;
 404     }
 405
 406     return( i_stream );
 407 }
 408
 409 static int PEStoTS( sout_instance_t *p_sout,
 410                     sout_buffer_t **pp_ts, sout_buffer_t *p_pes,
 411                     ts_stream_t *p_stream )
 412 {
 413     int i_size;
 414     uint8_t       *p_data;
 415     int i_first;
 416     mtime_t       i_dts;
 417     int         b_new_pes;
 418
 419     *pp_ts = NULL;
 420
 421     /* get PES total size */
 422     i_size = p_pes->i_size;
 423     p_data = p_pes->p_buffer;
 424
 425     if( p_pes->i_dts == 0 && p_pes->i_length > 0 )
 426     {
 427         i_dts = 1; // XXX <french> kludge immonde </french>
 428     }
 429     else
 430     {
 431         i_dts = p_pes->i_dts;
 432     }
 433
 434     for( i_first = 1, b_new_pes = 1; p_pes != NULL; )
 435     {
 436         int           i_adaptation_field;
 437         int           i_payload;
 438         int           i_copy;
 439         bits_buffer_t bits;
 440         sout_buffer_t *p_ts;
 441
 442         p_ts = sout_BufferNew( p_sout, 188 );
 443
 444         p_ts->i_pts = 0;
 445         p_ts->i_dts = i_dts;
 446
 447
 448         i_payload = 184 - ( i_first && i_dts > 0 ? 8 : 0 );
 449         i_copy = __MIN( i_size, i_payload );
 450
 451         i_adaptation_field = ( ( i_first && i_dts > 0 ) ||
 452                                i_size < i_payload ) ? 1 : 0;
 453
 454         /* write headers */
 455         bits_initwrite( &bits, 188, p_ts->p_buffer );
 456         bits_write( &bits, 8, 0x47 ); /* sync byte */
 457         bits_write( &bits, 1, 0 ); /* transport_error_indicator */
 458         bits_write( &bits, 1, b_new_pes ? 1 : 0 ); /* payload_unit_start */
 459         b_new_pes = 0;
 460         bits_write( &bits, 1, 0 ); /* transport_priority */
 461         bits_write( &bits, 13, p_stream->i_pid );
 462         bits_write( &bits, 2, 0 ); /* transport_scrambling_control */
 463         bits_write( &bits, 2, ( i_adaptation_field ? 0x03 : 0x01 ) );
 464
 465         bits_write( &bits, 4, /* continuity_counter */
 466                     p_stream->i_continuity_counter );
 467         p_stream->i_continuity_counter++;
 468         p_stream->i_continuity_counter %= 16;
 469         if( i_adaptation_field )
 470         {
 471             int i;
 472             int i_stuffing;
 473
 474             if( i_first && i_dts > 0 )
 475             {
 476                 i_stuffing = i_payload - i_copy;
 477                 bits_write( &bits, 8, 7 + i_stuffing );
 478                 bits_write( &bits,  8, 0x10 ); /* various flags */
 479                 bits_write( &bits, 33, i_dts * 9 / 100);
 480                 bits_write( &bits,  6, 0 );
 481                 bits_write( &bits,  9, 0 );
 482                 i_dts = 0; /* XXX set dts only for first ts packet */
 483             }
 484             else
 485             {
 486                 i_stuffing = i_payload - i_copy;
 487                 bits_write( &bits, 8, i_stuffing - 1);
 488                 if( i_stuffing - 1 > 0 )
 489                 {
 490                     bits_write( &bits, 8, 0 );
 491                 }
 492                 i_stuffing -= 2;
 493             }
 494
 495             /* put stuffing */
 496             for( i = 0; i < i_stuffing; i++ )
 497             {
 498                 bits_write( &bits, 8, 0xff );
 499             }
 500         }
 501         /* copy payload */
 502         memcpy( p_ts->p_buffer + bits.i_data,
 503                 p_data,
 504                 i_copy );
 505         p_data += i_copy;
 506         i_size -= i_copy;
 507
 508         sout_BufferChain( pp_ts, p_ts );
 509
 510         i_first = 0;
 511
 512         if( i_size <= 0 )
 513         {
 514             sout_buffer_t *p_next;
 515
 516             p_next = p_pes->p_next;
 517             p_pes->p_next = NULL;
 518             sout_BufferDelete( p_sout, p_pes );
 519             p_pes = p_next;
 520             b_new_pes = 1;
 521             if( p_pes )
 522             {
 523                 i_size = p_pes->i_size;
 524                 p_data = p_pes->p_buffer;
 525             }
 526             else
 527             {
 528                 break;
 529             }
 530         }
 531     }
 532
 533     return 0;
 534 }
 535
 536 static void SetTSDate( sout_buffer_t *p_ts, mtime_t i_dts, mtime_t i_length )
 537 {
 538     int i_count;
 539     sout_buffer_t *p_tmp;
 540     mtime_t i_delta;
 541
 542     for( p_tmp = p_ts, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->p_next )
 543     {
 544         i_count++;
 545     }
 546     i_delta = i_length / i_count;
 547
 548     for( p_tmp = p_ts; p_tmp != NULL; p_tmp = p_tmp->p_next )
 549     {
 550         p_tmp->i_dts    = i_dts;
 551         p_tmp->i_length = i_delta;
 552
 553         i_dts += i_delta;
 554     }
 555 }
 556
 557 static int Mux( sout_mux_t *p_mux )
 558 {
 559     sout_mux_sys_t          *p_sys = p_mux->p_sys;
 560     int     i_stream;
 561
 562     sout_buffer_t *p_pat, *p_pmt, *p_ts;
 563
 564     for( ;; )
 565     {
 566         mtime_t i_dts, i_length;
 567
 568         sout_input_t *p_input;
 569         ts_stream_t *p_stream;
 570         sout_fifo_t  *p_fifo;
 571         sout_buffer_t *p_data;
 572
 573         if( MuxGetStream( p_mux, &i_stream, &i_dts ) < 0 )
 574         {
 575             return( 0 );
 576         }
 577
 578         p_input = p_mux->pp_inputs[i_stream];
 579         p_fifo = p_input->p_fifo;
 580         p_stream = (ts_stream_t*)p_input->p_sys;
 581
 582         p_data   = sout_FifoGet( p_fifo );
 583         i_dts    = p_data->i_dts;
 584         i_length = p_data->i_length;
 585
 586         E_( EStoPES )( p_mux->p_sout, &p_data, p_data, p_stream->i_stream_id, 1);
 587         PEStoTS( p_mux->p_sout, &p_data, p_data, p_stream );
 588
 589         if( p_sys->i_ts_packet % 30 == 0 )
 590         {
 591             /* create pat/pmt */
 592             GetPAT( p_mux, &p_pat );
 593             GetPMT( p_mux, &p_pmt );
 594
 595             p_ts = p_pat;
 596             sout_BufferChain( &p_ts, p_pmt );
 597             sout_BufferChain( &p_ts, p_data );
 598         }
 599         else
 600         {
 601             p_ts = p_data;
 602         }
 603
 604         p_sys->i_ts_packet++;
 605         SetTSDate( p_ts, i_dts, i_length );
 606
 607         sout_AccessOutWrite( p_mux->p_access, p_ts );
 608     }
 609
 610     return( 0 );
 611 }
 612
 613
 614 static uint32_t CalculateCRC( uint8_t *p_begin, int i_count )
 615 {
 616     static uint32_t CRC32[256] =
 617     {
 618         0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
 619         0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
 620         0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
 621         0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
 622         0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
 623         0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
 624         0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
 625         0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
 626         0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
 627         0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
 628         0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
 629         0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
 630         0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
 631         0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
 632         0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
 633         0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
 634         0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
 635         0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
 636         0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
 637         0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
 638         0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
 639         0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
 640         0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
 641         0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
 642         0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
 643         0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
 644         0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
 645         0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
 646         0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
 647         0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
 648         0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
 649         0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
 650         0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
 651         0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
 652         0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
 653         0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
 654         0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
 655         0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
 656         0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
 657         0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
 658         0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
 659         0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
 660         0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
 661         0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
 662         0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
 663         0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
 664         0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
 665         0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
 666         0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
 667         0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
 668         0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
 669         0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
 670         0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
 671         0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
 672         0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
 673         0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
 674         0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
 675         0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
 676         0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
 677         0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
 678         0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
 679         0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
 680         0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
 681         0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
 682     };
 683
 684     uint32_t i_crc = 0xffffffff;
 685
 686     /* Calculate the CRC */
 687     while( i_count > 0 )
 688     {
 689         i_crc = (i_crc<<8) ^ CRC32[ (i_crc>>24) ^ ((uint32_t)*p_begin) ];
 690         p_begin++;
 691         i_count--;
 692     }
 693
 694     return( i_crc );
 695 }
 696
 697 #if defined MODULE_NAME_IS_mux_ts
 698 static int GetPAT( sout_mux_t *p_mux,
 699                    sout_buffer_t **pp_ts )
 700 {
 701     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 702     sout_buffer_t       *p_pat;
 703     bits_buffer_t bits;
 704
 705     p_pat = sout_BufferNew( p_mux->p_sout, 1024 );
 706
 707     p_pat->i_pts = 0;
 708     p_pat->i_dts = 0;
 709     p_pat->i_length = 0;
 710
 711     bits_initwrite( &bits, 1024, p_pat->p_buffer );
 712
 713     bits_write( &bits, 8, 0 );      // pointer
 714     bits_write( &bits, 8, 0x00 );   // table id
 715     bits_write( &bits, 1,  1 );     // section_syntax_indicator
 716     bits_write( &bits, 1,  0 );     // 0
 717     bits_write( &bits, 2,  0x03 );     // reserved FIXME
 718     bits_write( &bits, 12, 13 );    // XXX for one program only XXX
 719     bits_write( &bits, 16, 0x01 );  // FIXME stream id
 720     bits_write( &bits, 2,  0x03 );     //  FIXME
 721     bits_write( &bits, 5,  p_sys->i_pat_version_number );
 722     bits_write( &bits, 1,  1 );     // current_next_indicator
 723     bits_write( &bits, 8,  0 );     // section number
 724     bits_write( &bits, 8,  0 );     // last section number
 725
 726     bits_write( &bits, 16, 1 );     // program number
 727     bits_write( &bits,  3, 0x07 );     // reserved
 728     bits_write( &bits, 13, p_sys->pmt.i_pid );  // program map pid
 729
 730     bits_write( &bits, 32, CalculateCRC( bits.p_data + 1, bits.i_data - 1) );
 731
 732     p_pat->i_size = bits.i_data;
 733
 734     return( PEStoTS( p_mux->p_sout, pp_ts, p_pat, &p_sys->pat ) );
 735 }
 736
 737 static int GetPMT( sout_mux_t *p_mux,
 738                    sout_buffer_t **pp_ts )
 739 {
 740     sout_mux_sys_t      *p_sys = p_mux->p_sys;
 741     sout_buffer_t       *p_pmt;
 742     bits_buffer_t bits;
 743     int           i_stream;
 744
 745     p_pmt = sout_BufferNew( p_mux->p_sout, 1024 );
 746
 747     p_pmt->i_pts = 0;
 748     p_pmt->i_dts = 0;
 749     p_pmt->i_length = 0;
 750
 751     bits_initwrite( &bits, 1024, p_pmt->p_buffer );
 752
 753     bits_write( &bits, 8, 0 );      // pointer
 754     bits_write( &bits, 8, 0x02 );   // table id
 755     bits_write( &bits, 1,  1 );     // section_syntax_indicator
 756     bits_write( &bits, 1,  0 );     // 0
 757     bits_write( &bits, 2,  0 );     // reserved FIXME
 758     bits_write( &bits, 12, 13 + 5 * p_mux->i_nb_inputs );
 759     bits_write( &bits, 16, 1 );     // FIXME program number
 760     bits_write( &bits, 2,  0 );     //  FIXME
 761     bits_write( &bits, 5,  p_sys->i_pmt_version_number );
 762     bits_write( &bits, 1,  0 );     // current_next_indicator
 763     bits_write( &bits, 8,  0 );     // section number
 764     bits_write( &bits, 8,  0 );     // last section number
 765
 766     bits_write( &bits,  3, 0 );     // reserved
 767
 768     bits_write( &bits, 13, p_sys->i_pcr_pid );     //  FIXME FXIME PCR_PID FIXME
 769     bits_write( &bits,  4, 0 );     // reserved FIXME
 770
 771     bits_write( &bits, 12, 0 );    // program info len FIXME
 772
 773     for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
 774     {
 775         ts_stream_t *p_stream;
 776
 777         p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
 778
 779         bits_write( &bits,  8, p_stream->i_stream_type ); // stream_type
 780         bits_write( &bits,  3, 0 );                 // reserved
 781         bits_write( &bits, 13, p_stream->i_pid );   // es pid
 782         bits_write( &bits,  4, 0 );                 //reserved
 783         bits_write( &bits, 12, 0 );                 // es info len FIXME
 784     }
 785
 786     bits_write( &bits, 32, CalculateCRC( bits.p_data + 1, bits.i_data - 1) );
 787
 788     p_pmt->i_size = bits.i_data;
 789
 790     return( PEStoTS( p_mux->p_sout, pp_ts, p_pmt, &p_sys->pmt ) );
 791
 792 }
 793 #elif defined MODULE_NAME_IS_mux_ts_dvbpsi
 794
 795 static sout_buffer_t *WritePSISection( sout_instance_t *p_sout,
 796                                        dvbpsi_psi_section_t* p_section )
 797 {
 798     sout_buffer_t   *p_psi, *p_first = NULL;
 799
 800
 801     while( p_section )
 802     {
 803         int             i_size;
 804
 805         i_size =  (uint32_t)( p_section->p_payload_end - p_section->p_data )+
 806                   ( p_section->b_syntax_indicator ? 4 : 0 );
 807
 808         p_psi = sout_BufferNew( p_sout, i_size + 1 );
 809         p_psi->i_pts = 0;
 810         p_psi->i_dts = 0;
 811         p_psi->i_length = 0;
 812         p_psi->i_size = i_size + 1;
 813
 814         p_psi->p_buffer[0] = 0; // pointer
 815         memcpy( p_psi->p_buffer + 1,
 816                 p_section->p_data,
 817                 i_size );
 818
 819         sout_BufferChain( &p_first, p_psi );
 820
 821         p_section = p_section->p_next;
 822     }
 823
 824     return( p_first );
 825 }
 826
 827 static int GetPAT( sout_mux_t *p_mux,
 828                    sout_buffer_t **pp_ts )
 829 {
 830     sout_mux_sys_t       *p_sys = p_mux->p_sys;
 831     sout_buffer_t        *p_pat;
 832     dvbpsi_pat_t         pat;
 833     dvbpsi_psi_section_t *p_section;
 834
 835     dvbpsi_InitPAT( &pat,
 836                     0x01,    // i_ts_id
 837                     p_sys->i_pat_version_number,
 838                     0);      // b_current_next
 839     /* add all program (only one) */
 840     dvbpsi_PATAddProgram( &pat,
 841                           1,                    // i_number
 842                           p_sys->pmt.i_pid );   // i_pid
 843
 844     p_section = dvbpsi_GenPATSections( &pat,
 845                                        0 );     // max program per section
 846
 847     p_pat = WritePSISection( p_mux->p_sout, p_section );
 848
 849     PEStoTS( p_mux->p_sout, pp_ts, p_pat, &p_sys->pat );
 850
 851     dvbpsi_DeletePSISections( p_section );
 852     dvbpsi_EmptyPAT( &pat );
 853     return( 0 );
 854 }
 855
 856 static uint32_t GetDescriptorLength24b( int i_length )
 857 {
 858     uint32_t    i_l1, i_l2, i_l3;
 859
 860     i_l1 = i_length&0x7f;
 861     i_l2 = ( i_length >> 7 )&0x7f;
 862     i_l3 = ( i_length >> 14 )&0x7f;
 863
 864     return( 0x808000 | ( i_l3 << 16 ) | ( i_l2 << 8 ) | i_l1 );
 865 }
 866
 867 static int GetPMT( sout_mux_t *p_mux,
 868                    sout_buffer_t **pp_ts )
 869 {
 870     sout_mux_sys_t  *p_sys = p_mux->p_sys;
 871     sout_buffer_t   *p_pmt;
 872
 873     dvbpsi_pmt_t        pmt;
 874     dvbpsi_pmt_es_t     *p_es;
 875     dvbpsi_psi_section_t *p_section;
 876
 877     int                 i_stream;
 878
 879     dvbpsi_InitPMT( &pmt,
 880                     0x01,   // program number
 881                     p_sys->i_pmt_version_number,
 882                     1,      // b_current_next
 883                     p_sys->i_pcr_pid );
 884
 885     if( p_sys->i_mpeg4_streams > 0 )
 886     {
 887         uint8_t iod[4096];
 888         bits_buffer_t bits;
 889         bits_buffer_t bits_fix_IOD;
 890
 891         bits_initwrite( &bits, 4096, iod );
 892         // IOD_label
 893         bits_write( &bits, 8,   0x01 );
 894         // InitialObjectDescriptor
 895         bits_align( &bits );
 896         bits_write( &bits, 8,   0x02 );     // tag
 897         bits_fix_IOD = bits;    // save states to fix length later
 898         bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) ); // variable length (fixed later)
 899         bits_write( &bits, 10,  0x01 );     // ObjectDescriptorID
 900         bits_write( &bits, 1,   0x00 );     // URL Flag
 901         bits_write( &bits, 1,   0x00 );     // includeInlineProfileLevelFlag
 902         bits_write( &bits, 4,   0x0f );     // reserved
 903         bits_write( &bits, 8,   0xff );     // ODProfile (no ODcapability )
 904         bits_write( &bits, 8,   0xff );     // sceneProfile
 905         bits_write( &bits, 8,   0xfe );     // audioProfile (unspecified)
 906         bits_write( &bits, 8,   0xfe );     // visualProfile( // )
 907         bits_write( &bits, 8,   0xff );     // graphicProfile (no )
 908         for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
 909         {
 910             ts_stream_t *p_stream;
 911             p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
 912
 913             if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
 914             {
 915                 bits_buffer_t bits_fix_ESDescr, bits_fix_Decoder;
 916                 /* ES descriptor */
 917                 bits_align( &bits );
 918                 bits_write( &bits, 8,   0x03 );     // ES_DescrTag
 919                 bits_fix_ESDescr = bits;
 920                 bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) ); // variable size
 921                 bits_write( &bits, 16,  p_stream->i_es_id );
 922                 bits_write( &bits, 1,   0x00 );     // streamDependency
 923                 bits_write( &bits, 1,   0x00 );     // URL Flag
 924                 bits_write( &bits, 1,   0x00 );     // OCRStreamFlag
 925                 bits_write( &bits, 5,   0x1f );     // streamPriority
 926
 927                     // DecoderConfigDesciptor
 928                 bits_align( &bits );
 929                 bits_write( &bits, 8,   0x04 ); // DecoderConfigDescrTag
 930                 bits_fix_Decoder = bits;
 931                 bits_write( &bits, 24,  GetDescriptorLength24b( 0 ) );
 932                 if( p_stream->i_stream_type == 0x10 )
 933                 {
 934                     bits_write( &bits, 8, 0x20 );   // Visual 14496-2
 935                     bits_write( &bits, 6, 0x04 );   // VisualStream
 936                 }
 937                 else if( p_stream->i_stream_type == 0x11 )
 938                 {
 939                     bits_write( &bits, 8, 0x40 );   // Audio 14496-3
 940                     bits_write( &bits, 6, 0x05 );   // AudioStream
 941                 }
 942                 else
 943                 {
 944                     bits_write( &bits, 8, 0x00 );
 945                     bits_write( &bits, 6, 0x00 );
 946
 947                     msg_Err( p_mux->p_sout,"Unsupported stream_type => broken IOD");
 948                 }
 949                 bits_write( &bits, 1,   0x00 );     // UpStream
 950                 bits_write( &bits, 1,   0x01 );     // reserved
 951                 bits_write( &bits, 24,  1024 * 1024 );  // bufferSizeDB
 952                 bits_write( &bits, 32,  0x7fffffff );   // maxBitrate
 953                 bits_write( &bits, 32,  0 );            // avgBitrate
 954
 955                 if( p_stream->i_decoder_specific_info_len > 0 )
 956                 {
 957                     int i;
 958                     // DecoderSpecificInfo
 959                     bits_align( &bits );
 960                     bits_write( &bits, 8,   0x05 ); // tag
 961                     bits_write( &bits, 24,
 962                                 GetDescriptorLength24b( p_stream->i_decoder_specific_info_len ) );
 963                     for( i = 0; i < p_stream->i_decoder_specific_info_len; i++ )
 964                     {
 965                         bits_write( &bits, 8,   ((uint8_t*)p_stream->p_decoder_specific_info)[i] );
 966                     }
 967                 }
 968                 /* fix Decoder length */
 969                 bits_write( &bits_fix_Decoder, 24,
 970                             GetDescriptorLength24b( bits.i_data - bits_fix_Decoder.i_data - 3 ) );
 971
 972                     // SLConfigDescriptor
 973                 switch( p_stream->i_sl_predefined )
 974                 {
 975                     case 0x01:
 976                         // FIXME
 977                         bits_align( &bits );
 978                         bits_write( &bits, 8,   0x06 ); // tag
 979                         bits_write( &bits, 24,  GetDescriptorLength24b( 8 ) );
 980                         bits_write( &bits, 8,   0x01 ); // predefined
 981                         bits_write( &bits, 1,   0 );   // durationFlag
 982                         bits_write( &bits, 32,  0 );   // OCRResolution
 983                         bits_write( &bits, 8,   0 );   // OCRLength
 984                         bits_write( &bits, 8,   0 );   // InstantBitrateLength
 985                         bits_align( &bits );
 986                         break;
 987                     default:
 988                         msg_Err( p_mux,"Unsupported SL profile => broken IOD");
 989                         break;
 990                 }
 991                 /* fix ESDescr length */
 992                 bits_write( &bits_fix_ESDescr, 24,
 993                             GetDescriptorLength24b( bits.i_data - bits_fix_ESDescr.i_data - 3 ) );
 994             }
 995         }
 996         bits_align( &bits );
 997         /* fix IOD length */
 998         bits_write( &bits_fix_IOD, 24,
 999                     GetDescriptorLength24b( bits.i_data - bits_fix_IOD.i_data - 3 ) );
1000         dvbpsi_PMTAddDescriptor( &pmt,
1001                                  0x1d,
1002                                  bits.i_data,
1003                                  bits.p_data );
1004     }
1005
1006     for( i_stream = 0; i_stream < p_mux->i_nb_inputs; i_stream++ )
1007     {
1008         ts_stream_t *p_stream;
1009
1010         p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;
1011
1012         p_es = dvbpsi_PMTAddES( &pmt,
1013                                 p_stream->i_stream_type,
1014                                 p_stream->i_pid );
1015         if( p_stream->i_stream_id == 0xfa || p_stream->i_stream_id == 0xfb )
1016         {
1017             uint8_t     data[512];
1018             bits_buffer_t bits;
1019
1020             /* SL descriptor */
1021             bits_initwrite( &bits, 512, data );
1022             bits_write( &bits, 16, p_stream->i_es_id );
1023
1024             dvbpsi_PMTESAddDescriptor( p_es,
1025                                        0x1f,
1026                                        bits.i_data,
1027                                        bits.p_data );
1028         }
1029         else if( p_stream->i_stream_id == 0xa0 )
1030         {
1031             uint8_t     data[512];
1032             bits_buffer_t bits;
1033
1034             /* private DIV3 descripor */
1035             bits_initwrite( &bits, 512, data );
1036             bits_write( &bits, 32, p_stream->i_bih_codec );
1037             bits_write( &bits, 16, p_stream->i_bih_width );
1038             bits_write( &bits, 16, p_stream->i_bih_height );
1039             bits_write( &bits, 16, p_stream->i_decoder_specific_info_len );
1040             if( p_stream->i_decoder_specific_info_len > 0 )
1041             {
1042                 int i;
1043                 for( i = 0; i < p_stream->i_decoder_specific_info_len; i++ )
1044                 {
1045                     bits_write( &bits, 8, p_stream->p_decoder_specific_info[i] );
1046                 }
1047             }
1048             dvbpsi_PMTESAddDescriptor( p_es,
1049                                        0xa0,    // private
1050                                        bits.i_data,
1051                                        bits.p_data );
1052         }
1053     }
1054
1055     p_section = dvbpsi_GenPMTSections( &pmt );
1056
1057     p_pmt = WritePSISection( p_mux->p_sout, p_section );
1058
1059     PEStoTS( p_mux->p_sout, pp_ts, p_pmt, &p_sys->pmt );
1060
1061     dvbpsi_DeletePSISections( p_section );
1062     dvbpsi_EmptyPMT( &pmt );
1063     return( 0 );
1064 }
1065
1066 #endif
1067