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