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