* all: new sout scheme. Now a chain of module are created that can
[vlc.git] / 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