* all: remove sout_format_t and use es_format_t instead.
[vlc.git] / modules / mux / mp4.c
1 /*****************************************************************************
2  * mp4.c: mp4/mov muxer
3  *****************************************************************************
4  * Copyright (C) 2001, 2002, 2003 VideoLAN
5  * $Id: mp4.c,v 1.7 2003/11/21 15:32:08 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>
28 #include <string.h>
29 #include <errno.h>
30
31 #include <vlc/vlc.h>
32 #include <vlc/input.h>
33 #include <vlc/sout.h>
34
35 #ifdef HAVE_TIME_H
36 #include <time.h>
37 #endif
38
39 #include "codecs.h"
40
41 /*****************************************************************************
42  * Exported prototypes
43  *****************************************************************************/
44 static int     Open   ( vlc_object_t * );
45 static void    Close  ( vlc_object_t * );
46
47 static int Capability(sout_mux_t *, int, void *, void * );
48 static int AddStream( sout_mux_t *, sout_input_t * );
49 static int DelStream( sout_mux_t *, sout_input_t * );
50 static int Mux      ( sout_mux_t * );
51
52 /*****************************************************************************
53  * Module descriptor
54  *****************************************************************************/
55 vlc_module_begin();
56     set_description( _("MP4/MOV muxer") );
57     set_capability( "sout mux", 5 );
58     add_shortcut( "mp4" );
59     add_shortcut( "mov" );
60     set_callbacks( Open, Close );
61 vlc_module_end();
62
63 typedef struct
64 {
65     uint64_t i_pos;
66     int      i_size;
67
68     mtime_t  i_pts;
69     mtime_t  i_dts;
70     mtime_t  i_length;
71
72 } mp4_entry_t;
73
74 typedef struct
75 {
76     es_format_t   *p_fmt;
77     int           i_track_id;
78
79     /* index */
80     unsigned int i_entry_count;
81     unsigned int i_entry_max;
82     mp4_entry_t  *entry;
83
84     /* stats */
85     mtime_t      i_duration;
86 } mp4_stream_t;
87
88 struct sout_mux_sys_t
89 {
90     vlc_bool_t b_mov;
91
92     uint64_t i_mdat_pos;
93     uint64_t i_pos;
94
95     mtime_t  i_start_dts;
96
97     int          i_nb_streams;
98     mp4_stream_t **pp_streams;
99 };
100
101
102 typedef struct bo_t bo_t;
103 struct bo_t
104 {
105     vlc_bool_t b_grow;
106
107     int        i_buffer_size;
108     int        i_buffer;
109     uint8_t    *p_buffer;
110
111 };
112
113 static void bo_init     ( bo_t *, int , uint8_t *, vlc_bool_t  );
114 static void bo_add_8    ( bo_t *, uint8_t );
115 static void bo_add_16be ( bo_t *, uint16_t );
116 static void bo_add_24be ( bo_t *, uint32_t );
117 static void bo_add_32be ( bo_t *, uint32_t );
118 static void bo_add_64be ( bo_t *, uint64_t );
119 static void bo_add_fourcc(bo_t *, char * );
120 static void bo_add_bo   ( bo_t *, bo_t * );
121 static void bo_add_mem  ( bo_t *, int , uint8_t * );
122 static void bo_add_descr ( bo_t *, uint8_t , uint32_t );
123
124 static void bo_fix_32be ( bo_t *, int , uint32_t );
125
126 static bo_t *box_new     ( char *fcc );
127 static bo_t *box_full_new( char *fcc, uint8_t v, uint32_t f );
128 static void  box_fix     ( bo_t *box );
129 static void  box_free    ( bo_t *box );
130 static void  box_gather  ( bo_t *box, bo_t *box2 );
131
132 static void box_send( sout_mux_t *p_mux,  bo_t *box );
133
134 static int64_t get_timestamp();
135
136 static sout_buffer_t * bo_to_sout( sout_instance_t *p_sout,  bo_t *box );
137
138 /*****************************************************************************
139  * Open:
140  *****************************************************************************/
141 static int Open( vlc_object_t *p_this )
142 {
143     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
144     sout_mux_sys_t  *p_sys;
145     bo_t            *box;
146
147     p_sys = malloc( sizeof( sout_mux_sys_t ) );
148     p_sys->i_pos        = 0;
149     p_sys->i_nb_streams = 0;
150     p_sys->pp_streams   = NULL;
151     p_sys->i_mdat_pos   = 0;
152     p_sys->b_mov        = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "mov" );
153     p_sys->i_start_dts  = 0;
154
155     msg_Info( p_mux, "Open" );
156
157     p_mux->pf_capacity  = Capability;
158     p_mux->pf_addstream = AddStream;
159     p_mux->pf_delstream = DelStream;
160     p_mux->pf_mux       = Mux;
161     p_mux->p_sys        = p_sys;
162
163     if( !p_sys->b_mov )
164     {
165         /* Now add ftyp header */
166         box = box_new( "ftyp" );
167         bo_add_fourcc( box, "isom" );
168         bo_add_32be  ( box, 0 );
169         bo_add_fourcc( box, "mp41" );
170         box_fix( box );
171
172         p_sys->i_pos += box->i_buffer;
173         p_sys->i_mdat_pos = p_sys->i_pos;
174
175         box_send( p_mux, box );
176
177         /* FIXME FIXME
178          * Quicktime actually doesn't like the 64 bits extensions !!! */
179         p_sys->b_mov = VLC_TRUE;
180     }
181
182     /* Now add mdat header */
183     box = box_new( "mdat" );
184     bo_add_64be  ( box, 0 ); // enough to store an extended size
185
186     p_sys->i_pos += box->i_buffer;
187
188     box_send( p_mux, box );
189
190     return VLC_SUCCESS;
191 }
192
193 static int GetDescrLength( int i_size )
194 {
195     if( i_size < 0x00000080 )
196         return 2 + i_size;
197     else if( i_size < 0x00004000 )
198         return 3 + i_size;
199     else if( i_size < 0x00200000 )
200         return 4 + i_size;
201     else
202         return 5 + i_size;
203 }
204
205 static bo_t *GetESDS( mp4_stream_t *p_stream )
206 {
207     bo_t *esds;
208     int  i_stream_type;
209     int  i_object_type_indication;
210     int  i_decoder_specific_info_size;
211
212     if( p_stream->p_fmt->i_extra > 0 )
213     {
214         i_decoder_specific_info_size =
215             GetDescrLength( p_stream->p_fmt->i_extra );
216     }
217     else
218     {
219         i_decoder_specific_info_size = 0;
220     }
221
222     esds = box_full_new( "esds", 0, 0 );
223
224     /* ES_Descr */
225     bo_add_descr( esds, 0x03, 3 +
226                   GetDescrLength( 13 + i_decoder_specific_info_size ) +
227                   GetDescrLength( 1 ) );
228     bo_add_16be( esds, p_stream->i_track_id );
229     bo_add_8   ( esds, 0x1f );      // flags=0|streamPriority=0x1f
230
231     /* DecoderConfigDescr */
232     bo_add_descr( esds, 0x04, 13 + i_decoder_specific_info_size );
233
234     switch( p_stream->p_fmt->i_codec )
235     {
236         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
237             i_object_type_indication = 0x20;
238             break;
239         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
240             /* FIXME MPEG-I=0x6b, MPEG-II = 0x60 -> 0x65 */
241             i_object_type_indication = 0x60;
242             break;
243         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
244             /* FIXME for mpeg2-aac == 0x66->0x68 */
245             i_object_type_indication = 0x40;
246             break;
247         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
248             i_object_type_indication =
249                 p_stream->p_fmt->audio.i_rate < 32000 ? 0x69 : 0x6b;
250             break;
251         default:
252             i_object_type_indication = 0x00;
253             break;
254     }
255     i_stream_type = p_stream->p_fmt->i_cat == VIDEO_ES ? 0x04 : 0x05;
256
257     bo_add_8   ( esds, i_object_type_indication );
258     bo_add_8   ( esds, ( i_stream_type << 2 ) | 1 );
259     bo_add_24be( esds, 1024 * 1024 );       // bufferSizeDB
260     bo_add_32be( esds, 0x7fffffff );        // maxBitrate
261     bo_add_32be( esds, 0 );                 // avgBitrate
262
263     if( p_stream->p_fmt->i_extra > 0 )
264     {
265         int i;
266
267         /* DecoderSpecificInfo */
268         bo_add_descr( esds, 0x05, p_stream->p_fmt->i_extra );
269
270         for( i = 0; i < p_stream->p_fmt->i_extra; i++ )
271         {
272             bo_add_8( esds, ((uint8_t*)p_stream->p_fmt->p_extra)[i] );
273         }
274     }
275
276     /* SL_Descr mandatory */
277     bo_add_descr( esds, 0x06, 1 );
278     bo_add_8    ( esds, 0x02 );  // sl_predefined
279
280     box_fix( esds );
281
282     return esds;
283 }
284
285 /*****************************************************************************
286  * Close:
287  *****************************************************************************/
288 static uint32_t mvhd_matrix[9] =
289     { 0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000 };
290
291 static void Close( vlc_object_t * p_this )
292 {
293     sout_mux_t *p_mux = (sout_mux_t*)p_this;
294     sout_mux_sys_t  *p_sys = p_mux->p_sys;
295     sout_buffer_t   *p_hdr;
296     bo_t            bo;
297     bo_t            *moov, *mvhd;
298     unsigned int    i;
299     int             i_trak, i_index;
300
301     uint32_t        i_movie_timescale = 90000;
302     int64_t         i_movie_duration  = 0;
303     msg_Info( p_mux, "Close" );
304
305     /* create general info */
306     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
307     {
308         mp4_stream_t *p_stream;
309
310         p_stream = p_sys->pp_streams[i_trak];
311
312         i_movie_duration = __MAX( i_movie_duration, p_stream->i_duration );
313     }
314     msg_Dbg( p_mux, "movie duration %ds",
315              (uint32_t)( i_movie_duration / (mtime_t)1000000 ) );
316
317     i_movie_duration = i_movie_duration *
318                        (int64_t)i_movie_timescale / (int64_t)1000000;
319
320     /* *** update mdat size *** */
321     bo_init      ( &bo, 0, NULL, VLC_TRUE );
322     if( p_sys->i_pos - p_sys->i_mdat_pos >= (((uint64_t)1)<<32) )
323     {
324         /* Extended size */
325         bo_add_32be  ( &bo, 1 );
326         bo_add_fourcc( &bo, "mdat" );
327         bo_add_64be  ( &bo, p_sys->i_pos - p_sys->i_mdat_pos );
328     }
329     else
330     {
331         bo_add_32be  ( &bo, 8 );
332         bo_add_fourcc( &bo, "wide" );
333         bo_add_32be  ( &bo, p_sys->i_pos - p_sys->i_mdat_pos - 8 );
334         bo_add_fourcc( &bo, "mdat" );
335     }
336
337     p_hdr = bo_to_sout( p_mux->p_sout, &bo );
338     free( bo.p_buffer );
339
340     /* seek to mdat */
341     sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos );
342     sout_AccessOutWrite( p_mux->p_access, p_hdr );
343
344     /* Now create header */
345     sout_AccessOutSeek( p_mux->p_access, p_sys->i_pos );
346
347     moov = box_new( "moov" );
348
349     /* *** add /moov/mvhd *** */
350     if( p_sys->b_mov )
351     {
352         mvhd = box_full_new( "mvhd", 0, 0 );
353         bo_add_32be( mvhd, get_timestamp() );   // creation time
354         bo_add_32be( mvhd, get_timestamp() );   // modification time
355         bo_add_32be( mvhd, i_movie_timescale);  // timescale
356         bo_add_32be( mvhd, i_movie_duration );  // duration
357     }
358     else
359     {
360         mvhd = box_full_new( "mvhd", 1, 0 );
361         bo_add_64be( mvhd, get_timestamp() );   // creation time
362         bo_add_64be( mvhd, get_timestamp() );   // modification time
363         bo_add_32be( mvhd, i_movie_timescale);  // timescale
364         bo_add_64be( mvhd, i_movie_duration );  // duration
365     }
366     bo_add_32be( mvhd, 0x10000 );           // rate
367     bo_add_16be( mvhd, 0x100 );             // volume
368     bo_add_16be( mvhd, 0 );                 // reserved
369     for( i = 0; i < 2; i++ )
370     {
371         bo_add_32be( mvhd, 0 );             // reserved
372     }
373     for( i = 0; i < 9; i++ )
374     {
375         bo_add_32be( mvhd, mvhd_matrix[i] );// matrix
376     }
377     for( i = 0; i < 6; i++ )
378     {
379         bo_add_32be( mvhd, 0 );             // pre-defined
380     }
381
382     /* Find the 1st track id */
383     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
384     {
385         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
386
387         if( p_stream->p_fmt->i_cat == AUDIO_ES ||
388             p_stream->p_fmt->i_cat == VIDEO_ES )
389         {
390             /* Found it */
391             bo_add_32be( mvhd, p_stream->i_track_id ); // next-track-id
392             break;
393         }
394     }
395     if( i_trak == p_sys->i_nb_streams ) /* Just for sanity reasons */
396         bo_add_32be( mvhd, 0xffffffff );
397
398     box_fix( mvhd );
399     box_gather( moov, mvhd );
400
401     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
402     {
403         mp4_stream_t *p_stream;
404         uint32_t     i_timescale;
405         uint32_t     i_chunk_count;
406
407         bo_t *trak;
408         bo_t *tkhd;
409         bo_t *mdia;
410         bo_t *mdhd, *hdlr;
411         bo_t *minf;
412         bo_t *dinf;
413         bo_t *dref;
414         bo_t *url;
415         bo_t *stbl;
416         bo_t *stsd;
417         bo_t *stts;
418         bo_t *stsz;
419
420         p_stream = p_sys->pp_streams[i_trak];
421
422         if( p_stream->p_fmt->i_cat != AUDIO_ES &&
423             p_stream->p_fmt->i_cat != VIDEO_ES )
424         {
425             msg_Err( p_mux, "FIXME ignoring trak (noaudio&&novideo)" );
426             continue;
427         }
428         if( p_stream->p_fmt->i_cat == AUDIO_ES )
429         {
430             i_timescale = p_stream->p_fmt->audio.i_rate;
431         }
432         else
433         {
434             i_timescale = 1001;
435         }
436
437         /* *** add /moov/trak *** */
438         trak = box_new( "trak" );
439
440         /* *** add /moov/trak/tkhd *** */
441         if( p_sys->b_mov )
442         {
443             tkhd = box_full_new( "tkhd", 0, 1 );
444             bo_add_32be( tkhd, get_timestamp() );       // creation time
445             bo_add_32be( tkhd, get_timestamp() );       // modification time
446             bo_add_32be( tkhd, p_stream->i_track_id );
447             bo_add_32be( tkhd, 0 );                     // reserved 0
448             bo_add_32be( tkhd, p_stream->i_duration *
449                          (int64_t)i_movie_timescale /
450                          (mtime_t)1000000 );            // duration
451         }
452         else
453         {
454             tkhd = box_full_new( "tkhd", 1, 1 );
455             bo_add_64be( tkhd, get_timestamp() );       // creation time
456             bo_add_64be( tkhd, get_timestamp() );       // modification time
457             bo_add_32be( tkhd, p_stream->i_track_id );
458             bo_add_32be( tkhd, 0 );                     // reserved 0
459             bo_add_64be( tkhd, p_stream->i_duration *
460                          (int64_t)i_movie_timescale /
461                          (mtime_t)1000000 );            // duration
462         }
463
464         for( i = 0; i < 2; i++ )
465         {
466             bo_add_32be( tkhd, 0 );                 // reserved
467         }
468         bo_add_16be( tkhd, 0 );                     // layer
469         bo_add_16be( tkhd, 0 );                     // pre-defined
470         bo_add_16be( tkhd, p_stream->p_fmt->i_cat == AUDIO_ES ? 0x100 : 0 ); // volume
471         bo_add_16be( tkhd, 0 );                     // reserved
472         for( i = 0; i < 9; i++ )
473         {
474             bo_add_32be( tkhd, mvhd_matrix[i] );    // matrix
475         }
476         if( p_stream->p_fmt->i_cat == AUDIO_ES )
477         {
478             bo_add_32be( tkhd, 0 );                 // width (presentation)
479             bo_add_32be( tkhd, 0 );                 // height(presentation)
480         }
481         else
482         {
483             bo_add_32be( tkhd, p_stream->p_fmt->video.i_width  << 16 );     // width (presentation)
484             bo_add_32be( tkhd, p_stream->p_fmt->video.i_height << 16 );     // height(presentation)
485         }
486         box_fix( tkhd );
487         box_gather( trak, tkhd );
488
489         /* *** add /moov/trak/mdia *** */
490         mdia = box_new( "mdia" );
491
492         /* media header */
493         if( p_sys->b_mov )
494         {
495             mdhd = box_full_new( "mdhd", 0, 0 );
496             bo_add_32be( mdhd, get_timestamp() );   // creation time
497             bo_add_32be( mdhd, get_timestamp() );   // modification time
498             bo_add_32be( mdhd, i_timescale);        // timescale
499             bo_add_32be( mdhd, p_stream->i_duration * (int64_t)i_timescale /
500                                (mtime_t)1000000 );  // duration
501         }
502         else
503         {
504             mdhd = box_full_new( "mdhd", 1, 0 );
505             bo_add_64be( mdhd, get_timestamp() );   // creation time
506             bo_add_64be( mdhd, get_timestamp() );   // modification time
507             bo_add_32be( mdhd, i_timescale);        // timescale
508             bo_add_64be( mdhd, p_stream->i_duration * (int64_t)i_timescale /
509                                (mtime_t)1000000 );  // duration
510         }
511
512         bo_add_16be( mdhd, 0    );              // language   FIXME
513         bo_add_16be( mdhd, 0    );              // predefined
514         box_fix( mdhd );
515         box_gather( mdia, mdhd );
516
517         /* handler reference */
518         hdlr = box_full_new( "hdlr", 0, 0 );
519
520         bo_add_fourcc( hdlr, "mhlr" );         // media handler
521         if( p_stream->p_fmt->i_cat == AUDIO_ES )
522         {
523             bo_add_fourcc( hdlr, "soun" );
524         }
525         else
526         {
527             bo_add_fourcc( hdlr, "vide" );
528         }
529
530         bo_add_32be( hdlr, 0 );         // reserved
531         bo_add_32be( hdlr, 0 );         // reserved
532         bo_add_32be( hdlr, 0 );         // reserved
533
534         if( p_stream->p_fmt->i_cat == AUDIO_ES )
535         {
536             bo_add_mem( hdlr, 13, "SoundHandler" );
537         }
538         else
539         {
540             bo_add_mem( hdlr, 13, "VideoHandler" );
541         }
542
543         box_fix( hdlr );
544         box_gather( mdia, hdlr );
545
546         /* minf*/
547         minf = box_new( "minf" );
548
549         /* add smhd|vmhd */
550         if( p_stream->p_fmt->i_cat == AUDIO_ES )
551         {
552             bo_t *smhd;
553
554             smhd = box_full_new( "smhd", 0, 0 );
555             bo_add_16be( smhd, 0 );     // balance
556             bo_add_16be( smhd, 0 );     // reserved
557             box_fix( smhd );
558
559             box_gather( minf, smhd );
560         }
561         else if( p_stream->p_fmt->i_cat == VIDEO_ES )
562         {
563             bo_t *vmhd;
564
565             vmhd = box_full_new( "vmhd", 0, 1 );
566             bo_add_16be( vmhd, 0 );     // graphicsmode
567             for( i = 0; i < 3; i++ )
568             {
569                 bo_add_16be( vmhd, 0 ); // opcolor
570             }
571             box_fix( vmhd );
572
573             box_gather( minf, vmhd );
574         }
575
576         /* dinf */
577         dinf = box_new( "dinf" );
578         dref = box_full_new( "dref", 0, 0 );
579         bo_add_32be( dref, 1 );
580         url = box_full_new( "url ", 0, 0x01 );
581         box_fix( url );
582         box_gather( dref, url );
583         box_fix( dref );
584         box_gather( dinf, dref );
585
586         /* append dinf to mdia */
587         box_fix( dinf );
588         box_gather( minf, dinf );
589
590         /* add stbl */
591         stbl = box_new( "stbl" );
592         stsd = box_full_new( "stsd", 0, 0 );
593         bo_add_32be( stsd, 1 );
594
595         if( p_stream->p_fmt->i_cat == AUDIO_ES )
596         {
597             bo_t *soun;
598             char fcc[4] = "    ";
599             int  i;
600             vlc_bool_t b_mpeg4_hdr;
601
602             switch( p_stream->p_fmt->i_codec )
603             {
604                 case VLC_FOURCC( 'm', 'p', '4', 'a' ):
605                     memcpy( fcc, "mp4a", 4 );
606                     b_mpeg4_hdr = VLC_TRUE;
607                     break;
608
609                 case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
610                     if( p_sys->b_mov )
611                         memcpy( fcc, ".mp3 ", 4 );
612                     else
613                         memcpy( fcc, "mp4a", 4 );
614                     b_mpeg4_hdr = VLC_FALSE;
615                     break;
616
617                 default:
618                     memcpy( fcc, (char*)&p_stream->p_fmt->i_codec, 4 );
619                     b_mpeg4_hdr = VLC_FALSE;
620                     break;
621             }
622
623             soun = box_new( fcc );
624             for( i = 0; i < 6; i++ )
625             {
626                 bo_add_8( soun, 0 );        // reserved;
627             }
628             bo_add_16be( soun, 1 );         // data-reference-index
629
630             /* SoundDescription */
631             bo_add_16be( soun, 0 );         // version;
632             bo_add_16be( soun, 0 );         // revision level (0)
633             bo_add_32be( soun, 0 );         // vendor
634             bo_add_16be( soun, p_stream->p_fmt->audio.i_channels );   // channel-count
635             bo_add_16be( soun, 16);         // FIXME sample size
636             bo_add_16be( soun, -2 );        // compression id
637             bo_add_16be( soun, 0 );         // packet size (0)
638             bo_add_16be( soun, p_stream->p_fmt->audio.i_rate ); // sampleratehi
639             bo_add_16be( soun, 0 );                              // sampleratelo
640
641             /* add an ES Descriptor */
642             if( b_mpeg4_hdr )
643             {
644                 bo_t *esds;
645
646                 esds = GetESDS( p_stream );
647
648                 box_fix( esds );
649                 box_gather( soun, esds );
650             }
651
652             box_fix( soun );
653             box_gather( stsd, soun );
654         }
655         else if( p_stream->p_fmt->i_cat == VIDEO_ES )
656         {
657             bo_t *vide;
658             char fcc[4] = "    ";
659             int  i;
660             vlc_bool_t b_mpeg4_hdr;
661
662             switch( p_stream->p_fmt->i_codec )
663             {
664                 case VLC_FOURCC( 'm', 'p', '4', 'v' ):
665                 case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
666                     memcpy( fcc, "mp4v", 4 );
667                     b_mpeg4_hdr = VLC_TRUE;
668                     break;
669
670                 case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
671                     memcpy( fcc, "mjpa", 4 );
672                     b_mpeg4_hdr = VLC_FALSE;
673                     break;
674
675                 default:
676                     memcpy( fcc, (char*)&p_stream->p_fmt->i_codec, 4 );
677                     b_mpeg4_hdr = VLC_FALSE;
678                     break;
679             }
680
681             vide = box_new( fcc );
682             for( i = 0; i < 6; i++ )
683             {
684                 bo_add_8( vide, 0 );        // reserved;
685             }
686             bo_add_16be( vide, 1 );         // data-reference-index
687
688             bo_add_16be( vide, 0 );         // predefined;
689             bo_add_16be( vide, 0 );         // reserved;
690             for( i = 0; i < 3; i++ )
691             {
692                 bo_add_32be( vide, 0 );     // predefined;
693             }
694
695             bo_add_16be( vide, p_stream->p_fmt->video.i_width );  // i_width
696             bo_add_16be( vide, p_stream->p_fmt->video.i_height ); // i_height
697
698             bo_add_32be( vide, 0x00480000 );                // h 72dpi
699             bo_add_32be( vide, 0x00480000 );                // v 72dpi
700
701             bo_add_32be( vide, 0 );         // data size, always 0
702             bo_add_16be( vide, 1 );         // frames count per sample
703
704             // compressor name;
705             for( i = 0; i < 32; i++ )
706             {
707                 bo_add_8( vide, 0 );
708             }
709
710             bo_add_16be( vide, 0x18 );      // depth
711             bo_add_16be( vide, 0xffff );    // predefined
712
713             /* add an ES Descriptor */
714             if( b_mpeg4_hdr )
715             {
716                 bo_t *esds;
717
718                 esds = GetESDS( p_stream );
719
720                 box_fix( esds );
721                 box_gather( vide, esds );
722             }
723
724             box_fix( vide );
725             box_gather( stsd, vide );
726         }
727
728         /* append stsd to stbl */
729         box_fix( stsd );
730         box_gather( stbl, stsd );
731
732         /* we will create chunk table and stsc table FIXME optim stsc table FIXME */
733         i_chunk_count = 0;
734         for( i = 0; i < p_stream->i_entry_count; )
735         {
736             while( i < p_stream->i_entry_count )
737             {
738                 if( i + 1 < p_stream->i_entry_count &&
739                     p_stream->entry[i].i_pos +
740                     p_stream->entry[i].i_size != p_stream->entry[i + 1].i_pos )
741                 {
742                     i++;
743                     break;
744                 }
745
746                 i++;
747             }
748             i_chunk_count++;
749         }
750
751         /* chunk offset table */
752         if( p_sys->i_pos >= (((uint64_t)0x1) << 32) )
753         {
754             /* 64 bits version */
755             bo_t *co64;
756             bo_t *stsc;
757
758             unsigned int  i_chunk;
759
760             msg_Dbg( p_mux, "creating %d chunk (co64)", i_chunk_count );
761
762             co64 = box_full_new( "co64", 0, 0 );
763             bo_add_32be( co64, i_chunk_count );
764
765             stsc = box_full_new( "stsc", 0, 0 );
766             bo_add_32be( stsc, i_chunk_count );     // entry-count
767             for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ )
768             {
769                 int i_first;
770                 bo_add_64be( co64, p_stream->entry[i].i_pos );
771
772                 i_first = i;
773
774                 while( i < p_stream->i_entry_count )
775                 {
776                     if( i + 1 < p_stream->i_entry_count &&
777                         p_stream->entry[i].i_pos + p_stream->entry[i].i_size
778                         != p_stream->entry[i + 1].i_pos )
779                     {
780                         i++;
781                         break;
782                     }
783
784                     i++;
785                 }
786                 bo_add_32be( stsc, 1 + i_chunk );   // first-chunk
787                 bo_add_32be( stsc, i - i_first ) ;  // samples-per-chunk
788                 bo_add_32be( stsc, 1 );             // sample-descr-index
789             }
790             /* append co64 to stbl */
791             box_fix( co64 );
792             box_gather( stbl, co64 );
793
794             /* append stsc to stbl */
795             box_fix( stsc );
796             box_gather( stbl, stsc );
797         }
798         else
799         {
800             /* 32 bits version */
801             bo_t *stco;
802             bo_t *stsc;
803
804             unsigned int  i_chunk;
805
806             msg_Dbg( p_mux, "creating %d chunk (stco)", i_chunk_count );
807
808             stco = box_full_new( "stco", 0, 0 );
809             bo_add_32be( stco, i_chunk_count );
810
811             stsc = box_full_new( "stsc", 0, 0 );
812             bo_add_32be( stsc, i_chunk_count );     // entry-count
813             for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ )
814             {
815                 int i_first;
816                 bo_add_32be( stco, p_stream->entry[i].i_pos );
817
818                 i_first = i;
819
820                 while( i < p_stream->i_entry_count )
821                 {
822                     if( i + 1 < p_stream->i_entry_count &&
823                         p_stream->entry[i].i_pos + p_stream->entry[i].i_size
824                         != p_stream->entry[i + 1].i_pos )
825                     {
826                         i++;
827                         break;
828                     }
829
830                     i++;
831                 }
832                 bo_add_32be( stsc, 1 + i_chunk );   // first-chunk
833                 bo_add_32be( stsc, i - i_first ) ;  // samples-per-chunk
834                 bo_add_32be( stsc, 1 );             // sample-descr-index
835             }
836             /* append stco to stbl */
837             box_fix( stco );
838             box_gather( stbl, stco );
839
840             /* append stsc to stbl */
841             box_fix( stsc );
842             box_gather( stbl, stsc );
843         }
844
845
846         /* add stts */
847         stts = box_full_new( "stts", 0, 0 );
848         bo_add_32be( stts, 0 );     // fixed latter
849         for( i = 0, i_index = 0; i < p_stream->i_entry_count; i_index++)
850         {
851             int64_t i_delta;
852             int     i_first;
853
854             i_first = i;
855             i_delta = p_stream->entry[i].i_length;
856
857             while( i < p_stream->i_entry_count )
858             {
859                 if( i + 1 < p_stream->i_entry_count &&
860                     p_stream->entry[i + 1].i_length != i_delta )
861                 {
862                     i++;
863                     break;
864                 }
865
866                 i++;
867             }
868
869             bo_add_32be( stts, i - i_first );           // sample-count
870             bo_add_32be( stts, i_delta * (int64_t)i_timescale /
871                                (int64_t)1000000 );      // sample-delta
872         }
873         bo_fix_32be( stts, 12, i_index );
874
875         /* append stts to stbl */
876         box_fix( stts );
877         box_gather( stbl, stts );
878
879         /* FIXME add ctts ?? FIXME */
880
881         stsz = box_full_new( "stsz", 0, 0 );
882         bo_add_32be( stsz, 0 );                             // sample-size
883         bo_add_32be( stsz, p_stream->i_entry_count );       // sample-count
884         for( i = 0; i < p_stream->i_entry_count; i++ )
885         {
886             bo_add_32be( stsz, p_stream->entry[i].i_size ); // sample-size
887         }
888         /* append stsz to stbl */
889         box_fix( stsz );
890         box_gather( stbl, stsz );
891
892         /* append stbl to minf */
893         box_fix( stbl );
894         box_gather( minf, stbl );
895
896         /* append minf to mdia */
897         box_fix( minf );
898         box_gather( mdia, minf );
899
900         /* append mdia to trak */
901         box_fix( mdia );
902         box_gather( trak, mdia );
903
904         /* append trak to moov */
905         box_fix( trak );
906         box_gather( moov, trak );
907     }
908
909     box_fix( moov );
910     box_send( p_mux, moov );
911
912     /* *** release memory *** */
913     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
914     {
915         mp4_stream_t *p_stream;
916
917         p_stream = p_sys->pp_streams[i_trak];
918
919         if( p_stream->p_fmt->p_extra )
920         {
921             free( p_stream->p_fmt->p_extra );
922         }
923         free( p_stream->p_fmt );
924         free( p_stream->entry );
925         free( p_stream );
926     }
927     free( p_sys );
928 }
929
930 static int Capability( sout_mux_t *p_mux, int i_query, void *p_args,
931                        void *p_answer )
932 {
933    switch( i_query )
934    {
935         case SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME:
936             *(vlc_bool_t*)p_answer = VLC_FALSE;
937             return( SOUT_MUX_CAP_ERR_OK );
938         default:
939             return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED );
940    }
941 }
942
943 static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
944 {
945     sout_mux_sys_t  *p_sys = p_mux->p_sys;
946     mp4_stream_t    *p_stream;
947
948     switch( p_input->p_fmt->i_codec )
949     {
950         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
951         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
952         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
953         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
954         case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
955         case VLC_FOURCC( 'm', 'j', 'p', 'b' ):
956             break;
957         default:
958             msg_Err( p_mux, "unsupported codec %4.4s in mp4",
959                      (char*)&p_input->p_fmt->i_codec );
960             return VLC_EGENERIC;
961     }
962
963     p_stream                = malloc( sizeof( mp4_stream_t ) );
964     p_stream->p_fmt         = malloc( sizeof( es_format_t ) );
965     memcpy( p_stream->p_fmt, p_input->p_fmt, sizeof( es_format_t ) );
966     if( p_stream->p_fmt->i_extra )
967     {
968         p_stream->p_fmt->p_extra =
969             malloc( p_stream->p_fmt->i_extra );
970         memcpy( p_stream->p_fmt->p_extra,
971                 p_input->p_fmt->p_extra,
972                 p_input->p_fmt->i_extra );
973     }
974     p_stream->i_track_id    = p_sys->i_nb_streams + 1;
975     p_stream->i_entry_count = 0;
976     p_stream->i_entry_max   = 1000;
977     p_stream->entry         =
978         calloc( p_stream->i_entry_max, sizeof( mp4_entry_t ) );
979     p_stream->i_duration    = 0;
980
981     p_input->p_sys          = p_stream;
982
983     msg_Dbg( p_mux, "adding input" );
984
985     TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, p_stream );
986     return( VLC_SUCCESS );
987 }
988
989 static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
990 {
991     msg_Dbg( p_mux, "removing input" );
992     return( 0 );
993 }
994
995 /****************************************************************************/
996
997 static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts )
998 {
999     mtime_t i_dts;
1000     int     i_stream;
1001     int     i;
1002
1003     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
1004     {
1005         sout_fifo_t  *p_fifo;
1006
1007         p_fifo = p_mux->pp_inputs[i]->p_fifo;
1008
1009         if( p_fifo->i_depth > 1 )
1010         {
1011             sout_buffer_t *p_buf;
1012
1013             p_buf = sout_FifoShow( p_fifo );
1014             if( i_stream < 0 || p_buf->i_dts < i_dts )
1015             {
1016                 i_dts = p_buf->i_dts;
1017                 i_stream = i;
1018             }
1019         }
1020         else
1021         {
1022             return( -1 ); // wait that all fifo have at least 2 packets
1023         }
1024     }
1025     if( pi_stream )
1026     {
1027         *pi_stream = i_stream;
1028     }
1029     if( pi_dts )
1030     {
1031         *pi_dts = i_dts;
1032     }
1033     return( i_stream );
1034 }
1035
1036 static int Mux( sout_mux_t *p_mux )
1037 {
1038     sout_mux_sys_t  *p_sys = p_mux->p_sys;
1039
1040     for( ;; )
1041     {
1042         sout_input_t    *p_input;
1043         int             i_stream;
1044         mp4_stream_t    *p_stream;
1045         sout_buffer_t   *p_data;
1046         mtime_t         i_dts;
1047
1048         if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 )
1049         {
1050             return( VLC_SUCCESS );
1051         }
1052
1053         if( !p_sys->i_start_dts )
1054             p_sys->i_start_dts = i_dts;
1055
1056         p_input  = p_mux->pp_inputs[i_stream];
1057         p_stream = (mp4_stream_t*)p_input->p_sys;
1058
1059         p_data  = sout_FifoGet( p_input->p_fifo );
1060         //msg_Dbg( p_mux, "stream=%d size=%6d pos=%8lld", i_stream, p_data->i_size, p_sys->i_pos );
1061
1062         /* add index entry */
1063         p_stream->entry[p_stream->i_entry_count].i_pos   = p_sys->i_pos;
1064         p_stream->entry[p_stream->i_entry_count].i_size  = p_data->i_size;
1065         p_stream->entry[p_stream->i_entry_count].i_pts   = p_data->i_pts;
1066         p_stream->entry[p_stream->i_entry_count].i_dts   = p_data->i_dts;
1067         p_stream->entry[p_stream->i_entry_count].i_length=
1068             __MAX( p_data->i_length, 0 );
1069
1070         if( p_stream->i_entry_count == 0 )
1071         {
1072             /* Here is another bad hack.
1073              * To make sure audio/video are in sync, we report a corrected
1074              * length for the 1st sample. */
1075             p_stream->entry[p_stream->i_entry_count].i_length =
1076                 __MAX( p_data->i_length, 0 ) +
1077                 p_data->i_pts - p_sys->i_start_dts;
1078         }
1079
1080         p_stream->i_entry_count++;
1081         if( p_stream->i_entry_count >= p_stream->i_entry_max )
1082         {
1083             p_stream->i_entry_max += 1000;
1084             p_stream->entry =
1085                 realloc( p_stream->entry,
1086                          p_stream->i_entry_max * sizeof( mp4_entry_t ) );
1087         }
1088
1089         /* update */
1090         p_stream->i_duration += __MAX( p_data->i_length, 0 );
1091         p_sys->i_pos += p_data->i_size;
1092
1093         /* write data */
1094         sout_AccessOutWrite( p_mux->p_access, p_data );
1095     }
1096
1097     return( VLC_SUCCESS );
1098 }
1099
1100
1101 /****************************************************************************/
1102
1103 static void bo_init( bo_t *p_bo, int i_size, uint8_t *p_buffer,
1104                      vlc_bool_t b_grow )
1105 {
1106     if( !p_buffer )
1107     {
1108         p_bo->i_buffer_size = __MAX( i_size, 1024 );
1109         p_bo->p_buffer = malloc( p_bo->i_buffer_size );
1110     }
1111     else
1112     {
1113         p_bo->i_buffer_size = i_size;
1114         p_bo->p_buffer = p_buffer;
1115     }
1116
1117     p_bo->b_grow = b_grow;
1118     p_bo->i_buffer = 0;
1119 }
1120
1121 static void bo_add_8( bo_t *p_bo, uint8_t i )
1122 {
1123     if( p_bo->i_buffer < p_bo->i_buffer_size )
1124     {
1125         p_bo->p_buffer[p_bo->i_buffer] = i;
1126     }
1127     else if( p_bo->b_grow )
1128     {
1129         p_bo->i_buffer_size += 1024;
1130         p_bo->p_buffer = realloc( p_bo->p_buffer, p_bo->i_buffer_size );
1131
1132         p_bo->p_buffer[p_bo->i_buffer] = i;
1133     }
1134
1135     p_bo->i_buffer++;
1136 }
1137
1138 static void bo_add_16be( bo_t *p_bo, uint16_t i )
1139 {
1140     bo_add_8( p_bo, ( ( i >> 8) &0xff ) );
1141     bo_add_8( p_bo, i &0xff );
1142 }
1143
1144 static void bo_add_24be( bo_t *p_bo, uint32_t i )
1145 {
1146     bo_add_8( p_bo, ( ( i >> 16) &0xff ) );
1147     bo_add_8( p_bo, ( ( i >> 8) &0xff ) );
1148     bo_add_8( p_bo, (   i &0xff ) );
1149 }
1150 static void bo_add_32be( bo_t *p_bo, uint32_t i )
1151 {
1152     bo_add_16be( p_bo, ( ( i >> 16) &0xffff ) );
1153     bo_add_16be( p_bo, i &0xffff );
1154 }
1155
1156 static void bo_fix_32be ( bo_t *p_bo, int i_pos, uint32_t i)
1157 {
1158     p_bo->p_buffer[i_pos    ] = ( i >> 24 )&0xff;
1159     p_bo->p_buffer[i_pos + 1] = ( i >> 16 )&0xff;
1160     p_bo->p_buffer[i_pos + 2] = ( i >>  8 )&0xff;
1161     p_bo->p_buffer[i_pos + 3] = ( i       )&0xff;
1162 }
1163
1164 static void bo_add_64be( bo_t *p_bo, uint64_t i )
1165 {
1166     bo_add_32be( p_bo, ( ( i >> 32) &0xffffffff ) );
1167     bo_add_32be( p_bo, i &0xffffffff );
1168 }
1169
1170 static void bo_add_fourcc( bo_t *p_bo, char *fcc )
1171 {
1172     bo_add_8( p_bo, fcc[0] );
1173     bo_add_8( p_bo, fcc[1] );
1174     bo_add_8( p_bo, fcc[2] );
1175     bo_add_8( p_bo, fcc[3] );
1176 }
1177
1178 static void bo_add_mem( bo_t *p_bo, int i_size, uint8_t *p_mem )
1179 {
1180     int i;
1181
1182     for( i = 0; i < i_size; i++ )
1183     {
1184         bo_add_8( p_bo, p_mem[i] );
1185     }
1186 }
1187
1188 static void bo_add_descr( bo_t *p_bo, uint8_t tag, uint32_t i_size )
1189 {
1190     uint32_t i_length;
1191     uint8_t  vals[4];
1192
1193     i_length = i_size;
1194     vals[3] = (unsigned char)(i_length & 0x7f);
1195     i_length >>= 7;
1196     vals[2] = (unsigned char)((i_length & 0x7f) | 0x80); 
1197     i_length >>= 7;
1198     vals[1] = (unsigned char)((i_length & 0x7f) | 0x80); 
1199     i_length >>= 7;
1200     vals[0] = (unsigned char)((i_length & 0x7f) | 0x80);
1201
1202     bo_add_8( p_bo, tag );
1203
1204     if( i_size < 0x00000080 )
1205     {
1206         bo_add_8( p_bo, vals[3] );
1207     }
1208     else if( i_size < 0x00004000 )
1209     {
1210         bo_add_8( p_bo, vals[2] );
1211         bo_add_8( p_bo, vals[3] );
1212     }
1213     else if( i_size < 0x00200000 )
1214     {
1215         bo_add_8( p_bo, vals[1] );
1216         bo_add_8( p_bo, vals[2] );
1217         bo_add_8( p_bo, vals[3] );
1218     }
1219     else if( i_size < 0x10000000 )
1220     {
1221         bo_add_8( p_bo, vals[0] );
1222         bo_add_8( p_bo, vals[1] );
1223         bo_add_8( p_bo, vals[2] );
1224         bo_add_8( p_bo, vals[3] );
1225     }
1226 }
1227
1228 static void bo_add_bo( bo_t *p_bo, bo_t *p_bo2 )
1229 {
1230     int i;
1231
1232     for( i = 0; i < p_bo2->i_buffer; i++ )
1233     {
1234         bo_add_8( p_bo, p_bo2->p_buffer[i] );
1235     }
1236 }
1237
1238 static bo_t * box_new( char *fcc )
1239 {
1240     bo_t *box;
1241
1242     if( ( box = malloc( sizeof( bo_t ) ) ) )
1243     {
1244         bo_init( box, 0, NULL, VLC_TRUE );
1245
1246         bo_add_32be  ( box, 0 );
1247         bo_add_fourcc( box, fcc );
1248     }
1249
1250     return box;
1251 }
1252
1253 static bo_t * box_full_new( char *fcc, uint8_t v, uint32_t f )
1254 {
1255     bo_t *box;
1256
1257     if( ( box = malloc( sizeof( bo_t ) ) ) )
1258     {
1259         bo_init( box, 0, NULL, VLC_TRUE );
1260
1261         bo_add_32be  ( box, 0 );
1262         bo_add_fourcc( box, fcc );
1263         bo_add_8     ( box, v );
1264         bo_add_24be  ( box, f );
1265     }
1266
1267     return box;
1268 }
1269
1270 static void box_fix( bo_t *box )
1271 {
1272     bo_t box_tmp;
1273
1274     memcpy( &box_tmp, box, sizeof( bo_t ) );
1275
1276     box_tmp.i_buffer = 0;
1277     bo_add_32be( &box_tmp, box->i_buffer );
1278 }
1279
1280 static void box_free( bo_t *box )
1281 {
1282     if( box->p_buffer )
1283     {
1284         free( box->p_buffer );
1285     }
1286
1287     free( box );
1288 }
1289
1290 static void box_gather ( bo_t *box, bo_t *box2 )
1291 {
1292     bo_add_bo( box, box2 );
1293     box_free( box2 );
1294 }
1295
1296
1297 static sout_buffer_t * bo_to_sout( sout_instance_t *p_sout,  bo_t *box )
1298 {
1299     sout_buffer_t *p_buf;
1300
1301     p_buf = sout_BufferNew( p_sout, box->i_buffer );
1302     if( box->i_buffer > 0 )
1303     {
1304         memcpy( p_buf->p_buffer, box->p_buffer, box->i_buffer );
1305     }
1306
1307     p_buf->i_size = box->i_buffer;
1308
1309     return p_buf;
1310 }
1311
1312 static void box_send( sout_mux_t *p_mux,  bo_t *box )
1313 {
1314     sout_buffer_t *p_buf;
1315
1316     p_buf = bo_to_sout( p_mux->p_sout, box );
1317     box_free( box );
1318
1319     sout_AccessOutWrite( p_mux->p_access, p_buf );
1320 }
1321
1322 static int64_t get_timestamp()
1323 {
1324     int64_t i_timestamp = 0;
1325
1326 #ifdef HAVE_TIME_H
1327     i_timestamp = time(NULL);
1328     i_timestamp += 2082844800; // MOV/MP4 start date is 1/1/1904
1329     // 208284480 is (((1970 - 1904) * 365) + 17) * 24 * 60 * 60
1330 #endif
1331
1332     return i_timestamp;
1333 }