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