>4gb fixes by (Dirk Musfeldt | d.musfeldt meilenstein de)
[ffmpeg.git] / libavformat / movenc.c
1 /*
2  * MOV, 3GP, MP4 encoder.
3  * Copyright (c) 2003 Thomas Raivio.
4  * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 #include "avformat.h"
21 #include "avi.h"
22 #include "avio.h"
23
24 #undef NDEBUG
25 #include <assert.h>
26
27 #define MOV_INDEX_CLUSTER_SIZE 16384
28 #define globalTimescale 1000
29
30 #define MODE_MP4 0
31 #define MODE_MOV 1
32 #define MODE_3GP 2
33 #define MODE_PSP 3 // example working PSP command line:
34 // ffmpeg -i testinput.avi  -f psp -r 14.985 -s 320x240 -b 768 -ar 24000 -ab 32 M4V00001.MP4
35 #define MODE_3G2 4
36
37 typedef struct MOVIentry {
38     unsigned int flags, size;
39     uint64_t     pos;
40     unsigned int samplesInChunk;
41     char         key_frame;
42     unsigned int entries;
43 } MOVIentry;
44
45 typedef struct MOVIndex {
46     int         mode;
47     int         entry;
48     uint64_t    mdat_size;
49     int         ents_allocated;
50     long        timescale;
51     long        time;
52     long        trackDuration;
53     long        sampleCount;
54     long        sampleDuration;
55     int         hasKeyframes;
56     int         language;
57     int         trackID;
58     AVCodecContext *enc;
59
60     int         vosLen;
61     uint8_t     *vosData;
62     MOVIentry** cluster;
63 } MOVTrack;
64
65 typedef struct MOVContext {
66     int     mode;
67     long    time;
68     int     nb_streams;
69     int     mdat_written;
70     offset_t mdat_pos;
71     long    timescale;
72     MOVTrack tracks[MAX_STREAMS];
73 } MOVContext;
74
75 static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track);
76
77 /* output language code from iso639 language name */
78 extern int ff_mov_iso639_to_lang(const char *lang, int mp4);
79
80 const CodecTag ff_mov_obj_type[] = {
81     { CODEC_ID_MPEG4     ,  32 },
82     { CODEC_ID_AAC       ,  64 },
83     { CODEC_ID_MPEG1VIDEO, 106 },
84     { CODEC_ID_MPEG2VIDEO,  96 },//mpeg2 profiles
85     { CODEC_ID_MP2       , 107 },//FIXME mpeg2 mpeg audio -> 105
86     { CODEC_ID_MP3       , 107 },//FIXME mpeg2 mpeg audio -> 105
87     { CODEC_ID_H264      ,  33 },
88     { CODEC_ID_H263      , 242 },
89     { CODEC_ID_H261      , 243 },
90     { CODEC_ID_MJPEG     , 108 },
91     { CODEC_ID_PCM_S16LE , 224 },
92     { CODEC_ID_VORBIS    , 225 },
93     { CODEC_ID_AC3       , 226 },
94     { CODEC_ID_PCM_ALAW  , 227 },
95     { CODEC_ID_PCM_MULAW , 228 },
96     { CODEC_ID_PCM_S16BE , 230 },
97     { 0,0  },
98 };
99
100 //FIXME supprt 64bit varaint with wide placeholders
101 static offset_t updateSize (ByteIOContext *pb, offset_t pos)
102 {
103     offset_t curpos = url_ftell(pb);
104     url_fseek(pb, pos, SEEK_SET);
105     put_be32(pb, curpos - pos); /* rewrite size */
106     url_fseek(pb, curpos, SEEK_SET);
107
108     return curpos - pos;
109 }
110
111 /* Chunk offset atom */
112 static int mov_write_stco_tag(ByteIOContext *pb, MOVTrack* track)
113 {
114     int i;
115     offset_t pos = url_ftell(pb);
116     put_be32(pb, 0); /* size */
117     int mode64 = 0; //   use 32 bit size variant if possible
118     if (pos > UINT32_MAX) {
119         mode64 = 1;
120         put_tag(pb, "co64");
121     } else
122         put_tag(pb, "stco");
123     put_be32(pb, 0); /* version & flags */
124     put_be32(pb, track->entry); /* entry count */
125     for (i=0; i<track->entry; i++) {
126         int cl = i / MOV_INDEX_CLUSTER_SIZE;
127         int id = i % MOV_INDEX_CLUSTER_SIZE;
128         if(mode64 == 1)
129             put_be64(pb, track->cluster[cl][id].pos);
130         else
131             put_be32(pb, track->cluster[cl][id].pos);
132     }
133     return updateSize (pb, pos);
134 }
135
136 /* Sample size atom */
137 static int mov_write_stsz_tag(ByteIOContext *pb, MOVTrack* track)
138 {
139     int equalChunks = 1;
140     int i, j, entries = 0, tst = -1, oldtst = -1;
141
142     offset_t pos = url_ftell(pb);
143     put_be32(pb, 0); /* size */
144     put_tag(pb, "stsz");
145     put_be32(pb, 0); /* version & flags */
146
147     for (i=0; i<track->entry; i++) {
148         int cl = i / MOV_INDEX_CLUSTER_SIZE;
149         int id = i % MOV_INDEX_CLUSTER_SIZE;
150         tst = track->cluster[cl][id].size/track->cluster[cl][id].entries;
151         if(oldtst != -1 && tst != oldtst) {
152             equalChunks = 0;
153         }
154         oldtst = tst;
155         entries += track->cluster[cl][id].entries;
156     }
157     if (equalChunks) {
158         int sSize = track->cluster[0][0].size/track->cluster[0][0].entries;
159         put_be32(pb, sSize); // sample size
160         put_be32(pb, entries); // sample count
161     }
162     else {
163         put_be32(pb, 0); // sample size
164         put_be32(pb, entries); // sample count
165         for (i=0; i<track->entry; i++) {
166             int cl = i / MOV_INDEX_CLUSTER_SIZE;
167             int id = i % MOV_INDEX_CLUSTER_SIZE;
168             for ( j=0; j<track->cluster[cl][id].entries; j++) {
169                 put_be32(pb, track->cluster[cl][id].size /
170                          track->cluster[cl][id].entries);
171             }
172         }
173     }
174     return updateSize (pb, pos);
175 }
176
177 /* Sample to chunk atom */
178 static int mov_write_stsc_tag(ByteIOContext *pb, MOVTrack* track)
179 {
180     int index = 0, oldval = -1, i;
181     offset_t entryPos, curpos;
182
183     offset_t pos = url_ftell(pb);
184     put_be32(pb, 0); /* size */
185     put_tag(pb, "stsc");
186     put_be32(pb, 0); // version & flags
187     entryPos = url_ftell(pb);
188     put_be32(pb, track->entry); // entry count
189     for (i=0; i<track->entry; i++) {
190         int cl = i / MOV_INDEX_CLUSTER_SIZE;
191         int id = i % MOV_INDEX_CLUSTER_SIZE;
192         if(oldval != track->cluster[cl][id].samplesInChunk)
193         {
194             put_be32(pb, i+1); // first chunk
195             put_be32(pb, track->cluster[cl][id].samplesInChunk); // samples per chunk
196             put_be32(pb, 0x1); // sample description index
197             oldval = track->cluster[cl][id].samplesInChunk;
198             index++;
199         }
200     }
201     curpos = url_ftell(pb);
202     url_fseek(pb, entryPos, SEEK_SET);
203     put_be32(pb, index); // rewrite size
204     url_fseek(pb, curpos, SEEK_SET);
205
206     return updateSize (pb, pos);
207 }
208
209 /* Sync sample atom */
210 static int mov_write_stss_tag(ByteIOContext *pb, MOVTrack* track)
211 {
212     offset_t curpos, entryPos;
213     int i, index = 0;
214     offset_t pos = url_ftell(pb);
215     put_be32(pb, 0); // size
216     put_tag(pb, "stss");
217     put_be32(pb, 0); // version & flags
218     entryPos = url_ftell(pb);
219     put_be32(pb, track->entry); // entry count
220     for (i=0; i<track->entry; i++) {
221         int cl = i / MOV_INDEX_CLUSTER_SIZE;
222         int id = i % MOV_INDEX_CLUSTER_SIZE;
223         if(track->cluster[cl][id].key_frame == 1) {
224             put_be32(pb, i+1);
225             index++;
226         }
227     }
228     curpos = url_ftell(pb);
229     url_fseek(pb, entryPos, SEEK_SET);
230     put_be32(pb, index); // rewrite size
231     url_fseek(pb, curpos, SEEK_SET);
232     return updateSize (pb, pos);
233 }
234
235 static int mov_write_damr_tag(ByteIOContext *pb)
236 {
237     put_be32(pb, 0x11); /* size */
238     put_tag(pb, "damr");
239     put_tag(pb, "FFMP");
240     put_byte(pb, 0);
241
242     put_be16(pb, 0x80); /* Mode set (all modes for AMR_NB) */
243     put_be16(pb, 0xa); /* Mode change period (no restriction) */
244     //put_be16(pb, 0x81ff); /* Mode set (all modes for AMR_NB) */
245     //put_be16(pb, 1); /* Mode change period (no restriction) */
246     return 0x11;
247 }
248
249 static int mov_write_wave_tag(ByteIOContext *pb, MOVTrack* track)
250 {
251     offset_t pos = url_ftell(pb);
252
253     put_be32(pb, 0);     /* size */
254     put_tag(pb, "wave");
255
256     put_be32(pb, 12);    /* size */
257     put_tag(pb, "frma");
258     put_tag(pb, "mp4a");
259
260     put_be32(pb, 12);    /* size */
261     put_tag(pb, "mp4a");
262     put_be32(pb, 0);
263
264     mov_write_esds_tag(pb, track);
265
266     put_be32(pb, 12);    /* size */
267     put_tag(pb, "srcq");
268     put_be32(pb, 0x40);
269
270     put_be32(pb, 8);     /* size */
271     put_be32(pb, 0);     /* null tag */
272
273     return updateSize (pb, pos);
274 }
275
276 static const CodecTag codec_movaudio_tags[] = {
277     { CODEC_ID_PCM_MULAW, MKTAG('u', 'l', 'a', 'w') },
278     { CODEC_ID_PCM_ALAW, MKTAG('a', 'l', 'a', 'w') },
279     { CODEC_ID_ADPCM_IMA_QT, MKTAG('i', 'm', 'a', '4') },
280     { CODEC_ID_MACE3, MKTAG('M', 'A', 'C', '3') },
281     { CODEC_ID_MACE6, MKTAG('M', 'A', 'C', '6') },
282     { CODEC_ID_AAC, MKTAG('m', 'p', '4', 'a') },
283     { CODEC_ID_AMR_NB, MKTAG('s', 'a', 'm', 'r') },
284     { CODEC_ID_AMR_WB, MKTAG('s', 'a', 'w', 'b') },
285     { CODEC_ID_PCM_S16BE, MKTAG('t', 'w', 'o', 's') },
286     { CODEC_ID_PCM_S16LE, MKTAG('s', 'o', 'w', 't') },
287     { CODEC_ID_MP3, MKTAG('.', 'm', 'p', '3') },
288     { 0, 0 },
289 };
290
291 static int mov_write_audio_tag(ByteIOContext *pb, MOVTrack* track)
292 {
293     offset_t pos = url_ftell(pb);
294     int tag;
295
296     put_be32(pb, 0); /* size */
297
298     tag = track->enc->codec_tag;
299     if (!tag)
300     tag = codec_get_tag(codec_movaudio_tags, track->enc->codec_id);
301     // if no mac fcc found, try with Microsoft tags
302     if (!tag)
303     {
304         int tmp = codec_get_tag(codec_wav_tags, track->enc->codec_id);
305         tag = MKTAG('m', 's', ((tmp >> 8) & 0xff), (tmp & 0xff));
306     }
307     put_le32(pb, tag); // store it byteswapped
308
309     put_be32(pb, 0); /* Reserved */
310     put_be16(pb, 0); /* Reserved */
311     put_be16(pb, 1); /* Data-reference index, XXX  == 1 */
312
313     /* SoundDescription */
314     if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)
315         put_be16(pb, 1); /* Version 1 */
316     else
317         put_be16(pb, 0); /* Version 0 */
318     put_be16(pb, 0); /* Revision level */
319     put_be32(pb, 0); /* Reserved */
320
321     put_be16(pb, track->enc->channels); /* Number of channels */
322     /* TODO: Currently hard-coded to 16-bit, there doesn't seem
323                  to be a good way to get number of bits of audio */
324     put_be16(pb, 0x10); /* Reserved */
325
326     if(track->enc->codec_id == CODEC_ID_AAC ||
327        track->enc->codec_id == CODEC_ID_MP3)
328     {
329         put_be16(pb, 0xfffe); /* compression ID (vbr)*/
330     }
331     else
332     {
333         put_be16(pb, 0); /* compression ID (= 0) */
334     }
335     put_be16(pb, 0); /* packet size (= 0) */
336     put_be16(pb, track->timescale); /* Time scale */
337     put_be16(pb, 0); /* Reserved */
338
339     if(track->mode == MODE_MOV && track->enc->codec_id == CODEC_ID_AAC)
340     {
341         /* SoundDescription V1 extended info */
342         put_be32(pb, track->enc->frame_size); /* Samples per packet  */
343         put_be32(pb, 1536); /* Bytes per packet */
344         put_be32(pb, 2); /* Bytes per frame */
345         put_be32(pb, 2); /* Bytes per sample */
346     }
347
348     if(track->enc->codec_id == CODEC_ID_AAC) {
349         if( track->mode == MODE_MOV ) mov_write_wave_tag(pb, track);
350         else mov_write_esds_tag(pb, track);
351     }
352     if(track->enc->codec_id == CODEC_ID_AMR_NB)
353         mov_write_damr_tag(pb);
354     return updateSize (pb, pos);
355 }
356
357 static int mov_write_d263_tag(ByteIOContext *pb)
358 {
359     put_be32(pb, 0xf); /* size */
360     put_tag(pb, "d263");
361     put_tag(pb, "FFMP");
362     put_be16(pb, 0x0a);
363     put_byte(pb, 0);
364     return 0xf;
365 }
366
367 /* TODO: No idea about these values */
368 static int mov_write_svq3_tag(ByteIOContext *pb)
369 {
370     put_be32(pb, 0x15);
371     put_tag(pb, "SMI ");
372     put_tag(pb, "SEQH");
373     put_be32(pb, 0x5);
374     put_be32(pb, 0xe2c0211d);
375     put_be32(pb, 0xc0000000);
376     put_byte(pb, 0);
377     return 0x15;
378 }
379
380 static unsigned int descrLength(unsigned int len)
381 {
382     if (len < 0x00000080)
383         return 2 + len;
384     else if (len < 0x00004000)
385         return 3 + len;
386     else if(len < 0x00200000)
387         return 4 + len;
388     else
389         return 5 + len;
390 }
391
392 static void putDescr(ByteIOContext *pb, int tag, int size)
393 {
394     uint32_t len;
395     uint8_t  vals[4];
396
397     len = size;
398     vals[3] = (uint8_t)(len & 0x7f);
399     len >>= 7;
400     vals[2] = (uint8_t)((len & 0x7f) | 0x80);
401     len >>= 7;
402     vals[1] = (uint8_t)((len & 0x7f) | 0x80);
403     len >>= 7;
404     vals[0] = (uint8_t)((len & 0x7f) | 0x80);
405
406     put_byte(pb, tag); // DescriptorTag
407
408     if (size < 0x00000080)
409     {
410         put_byte(pb, vals[3]);
411     }
412     else if (size < 0x00004000)
413     {
414         put_byte(pb, vals[2]);
415         put_byte(pb, vals[3]);
416     }
417     else if (size < 0x00200000)
418     {
419         put_byte(pb, vals[1]);
420         put_byte(pb, vals[2]);
421         put_byte(pb, vals[3]);
422     }
423     else if (size < 0x10000000)
424     {
425         put_byte(pb, vals[0]);
426         put_byte(pb, vals[1]);
427         put_byte(pb, vals[2]);
428         put_byte(pb, vals[3]);
429     }
430 }
431
432 static int mov_write_esds_tag(ByteIOContext *pb, MOVTrack* track) // Basic
433 {
434     int decoderSpecificInfoLen;
435     offset_t pos = url_ftell(pb);
436     void *vosDataBackup=track->vosData;
437     int vosLenBackup=track->vosLen;
438
439     // we should be able to have these passed in, via vosData, then we wouldn't need to attack this routine at all
440     static const char PSPAACData[]={0x13,0x10};
441     static const char PSPMP4Data[]={0x00,0x00,0x01,0xB0,0x03,0x00,0x00,0x01,0xB5,0x09,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x20,0x00,0x84,0x5D,0x4C,0x28,0x50,0x20,0xF0,0xA3,0x1F };
442
443
444     if (track->mode == MODE_PSP)  // fails on psp if this is not here
445     {
446         if (track->enc->codec_id == CODEC_ID_AAC)
447         {
448             track->vosLen = 2;
449             track->vosData = (uint8_t *) PSPAACData;
450         }
451
452         if (track->enc->codec_id == CODEC_ID_MPEG4)
453         {
454             track->vosLen = 28;
455             track->vosData = (uint8_t *) PSPMP4Data;
456         }
457     }
458
459     decoderSpecificInfoLen = track->vosLen ? descrLength(track->vosLen):0;
460
461     put_be32(pb, 0);               // size
462     put_tag(pb, "esds");
463     put_be32(pb, 0);               // Version
464
465     // ES descriptor
466     putDescr(pb, 0x03, 3 + descrLength(13 + decoderSpecificInfoLen) +
467              descrLength(1));
468     put_be16(pb, track->trackID);
469     put_byte(pb, 0x00);            // flags (= no flags)
470
471     // DecoderConfig descriptor
472     putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);
473
474     // Object type indication
475     put_byte(pb, codec_get_tag(ff_mov_obj_type, track->enc->codec_id));
476
477     // the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
478     // plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
479     if(track->enc->codec_type == CODEC_TYPE_AUDIO)
480         put_byte(pb, 0x15);            // flags (= Audiostream)
481     else
482         put_byte(pb, 0x11);            // flags (= Visualstream)
483
484     put_byte(pb,  track->enc->rc_buffer_size>>(3+16));             // Buffersize DB (24 bits)
485     put_be16(pb, (track->enc->rc_buffer_size>>3)&0xFFFF);          // Buffersize DB
486
487     put_be32(pb, FFMAX(track->enc->bit_rate, track->enc->rc_max_rate));     // maxbitrate  (FIXME should be max rate in any 1 sec window)
488     if(track->enc->rc_max_rate != track->enc->rc_min_rate || track->enc->rc_min_rate==0)
489         put_be32(pb, 0);     // vbr
490     else
491         put_be32(pb, track->enc->rc_max_rate);     // avg bitrate
492
493     if (track->vosLen)
494     {
495         // DecoderSpecific info descriptor
496         putDescr(pb, 0x05, track->vosLen);
497         put_buffer(pb, track->vosData, track->vosLen);
498     }
499
500     track->vosData = vosDataBackup;
501     track->vosLen = vosLenBackup;
502
503     // SL descriptor
504     putDescr(pb, 0x06, 1);
505     put_byte(pb, 0x02);
506     return updateSize (pb, pos);
507 }
508
509 static const CodecTag codec_movvideo_tags[] = {
510     { CODEC_ID_SVQ1, MKTAG('S', 'V', 'Q', '1') },
511     { CODEC_ID_SVQ3, MKTAG('S', 'V', 'Q', '3') },
512     { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
513     { CODEC_ID_H263, MKTAG('s', '2', '6', '3') },
514     { CODEC_ID_H264, MKTAG('a', 'v', 'c', '1') },
515     { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'c', ' ') },
516     { 0, 0 },
517 };
518
519 static int mov_write_video_tag(ByteIOContext *pb, MOVTrack* track)
520 {
521     offset_t pos = url_ftell(pb);
522     char compressor_name[32];
523     int tag;
524
525     put_be32(pb, 0); /* size */
526
527     tag = track->enc->codec_tag;
528     if (!tag)
529     tag = codec_get_tag(codec_movvideo_tags, track->enc->codec_id);
530     // if no mac fcc found, try with Microsoft tags
531     if (!tag)
532         tag = codec_get_tag(codec_bmp_tags, track->enc->codec_id);
533     put_le32(pb, tag); // store it byteswapped
534
535     put_be32(pb, 0); /* Reserved */
536     put_be16(pb, 0); /* Reserved */
537     put_be16(pb, 1); /* Data-reference index */
538
539     put_be16(pb, 0); /* Codec stream version */
540     put_be16(pb, 0); /* Codec stream revision (=0) */
541     put_tag(pb, "FFMP"); /* Vendor */
542     if(track->enc->codec_id == CODEC_ID_RAWVIDEO) {
543         put_be32(pb, 0); /* Temporal Quality */
544         put_be32(pb, 0x400); /* Spatial Quality = lossless*/
545     } else {
546         put_be32(pb, 0x200); /* Temporal Quality = normal */
547         put_be32(pb, 0x200); /* Spatial Quality = normal */
548     }
549     put_be16(pb, track->enc->width); /* Video width */
550     put_be16(pb, track->enc->height); /* Video height */
551     put_be32(pb, 0x00480000); /* Horizontal resolution 72dpi */
552     put_be32(pb, 0x00480000); /* Vertical resolution 72dpi */
553     put_be32(pb, 0); /* Data size (= 0) */
554     put_be16(pb, 1); /* Frame count (= 1) */
555
556     memset(compressor_name,0,32);
557     if (track->enc->codec && track->enc->codec->name)
558         strncpy(compressor_name,track->enc->codec->name,31);
559     put_byte(pb, strlen(compressor_name));
560     put_buffer(pb, compressor_name, 31);
561
562     put_be16(pb, 0x18); /* Reserved */
563     put_be16(pb, 0xffff); /* Reserved */
564     if(track->enc->codec_id == CODEC_ID_MPEG4)
565         mov_write_esds_tag(pb, track);
566     else if(track->enc->codec_id == CODEC_ID_H263)
567         mov_write_d263_tag(pb);
568     else if(track->enc->codec_id == CODEC_ID_SVQ3)
569         mov_write_svq3_tag(pb);
570
571     return updateSize (pb, pos);
572 }
573
574 static int mov_write_stsd_tag(ByteIOContext *pb, MOVTrack* track)
575 {
576     offset_t pos = url_ftell(pb);
577     put_be32(pb, 0); /* size */
578     put_tag(pb, "stsd");
579     put_be32(pb, 0); /* version & flags */
580     put_be32(pb, 1); /* entry count */
581     if (track->enc->codec_type == CODEC_TYPE_VIDEO)
582         mov_write_video_tag(pb, track);
583     else if (track->enc->codec_type == CODEC_TYPE_AUDIO)
584         mov_write_audio_tag(pb, track);
585     return updateSize(pb, pos);
586 }
587
588 /* TODO: */
589 /* Time to sample atom */
590 static int mov_write_stts_tag(ByteIOContext *pb, MOVTrack* track)
591 {
592     put_be32(pb, 0x18); /* size */
593     put_tag(pb, "stts");
594     put_be32(pb, 0); /* version & flags */
595     put_be32(pb, 1); /* entry count */
596
597     put_be32(pb, track->sampleCount); /* sample count */
598     put_be32(pb, track->sampleDuration); /* sample duration */
599     return 0x18;
600 }
601
602 static int mov_write_dref_tag(ByteIOContext *pb)
603 {
604     put_be32(pb, 28); /* size */
605     put_tag(pb, "dref");
606     put_be32(pb, 0); /* version & flags */
607     put_be32(pb, 1); /* entry count */
608
609     put_be32(pb, 0xc); /* size */
610     put_tag(pb, "url ");
611     put_be32(pb, 1); /* version & flags */
612
613     return 28;
614 }
615
616 static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack* track)
617 {
618     offset_t pos = url_ftell(pb);
619     put_be32(pb, 0); /* size */
620     put_tag(pb, "stbl");
621     mov_write_stsd_tag(pb, track);
622     mov_write_stts_tag(pb, track);
623     if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
624         track->hasKeyframes)
625         mov_write_stss_tag(pb, track);
626     mov_write_stsc_tag(pb, track);
627     mov_write_stsz_tag(pb, track);
628     mov_write_stco_tag(pb, track);
629     return updateSize(pb, pos);
630 }
631
632 static int mov_write_dinf_tag(ByteIOContext *pb)
633 {
634     offset_t pos = url_ftell(pb);
635     put_be32(pb, 0); /* size */
636     put_tag(pb, "dinf");
637     mov_write_dref_tag(pb);
638     return updateSize(pb, pos);
639 }
640
641 static int mov_write_smhd_tag(ByteIOContext *pb)
642 {
643     put_be32(pb, 16); /* size */
644     put_tag(pb, "smhd");
645     put_be32(pb, 0); /* version & flags */
646     put_be16(pb, 0); /* reserved (balance, normally = 0) */
647     put_be16(pb, 0); /* reserved */
648     return 16;
649 }
650
651 static int mov_write_vmhd_tag(ByteIOContext *pb)
652 {
653     put_be32(pb, 0x14); /* size (always 0x14) */
654     put_tag(pb, "vmhd");
655     put_be32(pb, 0x01); /* version & flags */
656     put_be64(pb, 0); /* reserved (graphics mode = copy) */
657     return 0x14;
658 }
659
660 static int mov_write_hdlr_tag(ByteIOContext *pb, MOVTrack* track)
661 {
662     char *descr, *hdlr, *hdlr_type;
663     offset_t pos = url_ftell(pb);
664
665     if (!track) { /* no media --> data handler */
666         hdlr = "dhlr";
667         hdlr_type = "url ";
668         descr = "DataHandler";
669     } else {
670         hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
671         if (track->enc->codec_type == CODEC_TYPE_VIDEO) {
672             hdlr_type = "vide";
673             descr = "VideoHandler";
674         } else {
675             hdlr_type = "soun";
676             descr = "SoundHandler";
677         }
678     }
679
680     put_be32(pb, 0); /* size */
681     put_tag(pb, "hdlr");
682     put_be32(pb, 0); /* Version & flags */
683     put_buffer(pb, hdlr, 4); /* handler */
684     put_tag(pb, hdlr_type); /* handler type */
685     put_be32(pb ,0); /* reserved */
686     put_be32(pb ,0); /* reserved */
687     put_be32(pb ,0); /* reserved */
688     put_byte(pb, strlen(descr)); /* string counter */
689     put_buffer(pb, descr, strlen(descr)); /* handler description */
690     return updateSize(pb, pos);
691 }
692
693 static int mov_write_minf_tag(ByteIOContext *pb, MOVTrack* track)
694 {
695     offset_t pos = url_ftell(pb);
696     put_be32(pb, 0); /* size */
697     put_tag(pb, "minf");
698     if(track->enc->codec_type == CODEC_TYPE_VIDEO)
699         mov_write_vmhd_tag(pb);
700     else
701         mov_write_smhd_tag(pb);
702     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
703         mov_write_hdlr_tag(pb, NULL);
704     mov_write_dinf_tag(pb);
705     mov_write_stbl_tag(pb, track);
706     return updateSize(pb, pos);
707 }
708
709 static int mov_write_mdhd_tag(ByteIOContext *pb, MOVTrack* track)
710 {
711     put_be32(pb, 32); /* size */
712     put_tag(pb, "mdhd");
713     put_be32(pb, 0); /* Version & flags */
714     put_be32(pb, track->time); /* creation time */
715     put_be32(pb, track->time); /* modification time */
716     put_be32(pb, track->timescale); /* time scale (sample rate for audio) */
717     put_be32(pb, track->trackDuration); /* duration */
718     put_be16(pb, track->language); /* language */
719     put_be16(pb, 0); /* reserved (quality) */
720     return 32;
721 }
722
723 static int mov_write_mdia_tag(ByteIOContext *pb, MOVTrack* track)
724 {
725     offset_t pos = url_ftell(pb);
726     put_be32(pb, 0); /* size */
727     put_tag(pb, "mdia");
728     mov_write_mdhd_tag(pb, track);
729     mov_write_hdlr_tag(pb, track);
730     mov_write_minf_tag(pb, track);
731     return updateSize(pb, pos);
732 }
733
734 static int mov_write_tkhd_tag(ByteIOContext *pb, MOVTrack* track)
735 {
736     put_be32(pb, 0x5c); /* size (always 0x5c) */
737     put_tag(pb, "tkhd");
738     put_be32(pb, 0xf); /* version & flags (track enabled) */
739     put_be32(pb, track->time); /* creation time */
740     put_be32(pb, track->time); /* modification time */
741     put_be32(pb, track->trackID); /* track-id */
742     put_be32(pb, 0); /* reserved */
743     put_be32(pb, av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP)); /* duration */
744
745     put_be32(pb, 0); /* reserved */
746     put_be32(pb, 0); /* reserved */
747     put_be32(pb, 0x0); /* reserved (Layer & Alternate group) */
748     /* Volume, only for audio */
749     if(track->enc->codec_type == CODEC_TYPE_AUDIO)
750         put_be16(pb, 0x0100);
751     else
752         put_be16(pb, 0);
753     put_be16(pb, 0); /* reserved */
754
755     /* Matrix structure */
756     put_be32(pb, 0x00010000); /* reserved */
757     put_be32(pb, 0x0); /* reserved */
758     put_be32(pb, 0x0); /* reserved */
759     put_be32(pb, 0x0); /* reserved */
760     put_be32(pb, 0x00010000); /* reserved */
761     put_be32(pb, 0x0); /* reserved */
762     put_be32(pb, 0x0); /* reserved */
763     put_be32(pb, 0x0); /* reserved */
764     put_be32(pb, 0x40000000); /* reserved */
765
766     /* Track width and height, for visual only */
767     if(track->enc->codec_type == CODEC_TYPE_VIDEO) {
768         double sample_aspect_ratio = av_q2d(track->enc->sample_aspect_ratio);
769         if( !sample_aspect_ratio ) sample_aspect_ratio = 1;
770         put_be32(pb, sample_aspect_ratio * track->enc->width*0x10000);
771         put_be32(pb, track->enc->height*0x10000);
772     }
773     else {
774         put_be32(pb, 0);
775         put_be32(pb, 0);
776     }
777     return 0x5c;
778 }
779
780 // This box seems important for the psp playback ... without it the movie seems to hang
781 static int mov_write_edts_tag(ByteIOContext *pb, MOVTrack *track)
782 {
783     put_be32(pb, 0x24); /* size  */
784     put_tag(pb, "edts");
785     put_be32(pb, 0x1c); /* size  */
786     put_tag(pb, "elst");
787     put_be32(pb, 0x0);
788     put_be32(pb, 0x1);
789
790     put_be32(pb, av_rescale_rnd(track->trackDuration, globalTimescale, track->timescale, AV_ROUND_UP)); /* duration   ... doesn't seem to effect psp */
791
792     put_be32(pb, 0x0);
793     put_be32(pb, 0x00010000);
794     return 0x24;
795 }
796
797 // goes at the end of each track!  ... Critical for PSP playback ("Incompatible data" without it)
798 static int mov_write_uuid_tag_psp(ByteIOContext *pb, MOVTrack *mov)
799 {
800     put_be32(pb, 0x34); /* size ... reports as 28 in mp4box! */
801     put_tag(pb, "uuid");
802     put_tag(pb, "USMT");
803     put_be32(pb, 0x21d24fce);
804     put_be32(pb, 0xbb88695c);
805     put_be32(pb, 0xfac9c740);
806     put_be32(pb, 0x1c);     // another size here!
807     put_tag(pb, "MTDT");
808     put_be32(pb, 0x00010012);
809     put_be32(pb, 0x0a);
810     put_be32(pb, 0x55c40000);
811     put_be32(pb, 0x1);
812     put_be32(pb, 0x0);
813     return 0x34;
814 }
815
816 static int mov_write_trak_tag(ByteIOContext *pb, MOVTrack* track)
817 {
818     offset_t pos = url_ftell(pb);
819     put_be32(pb, 0); /* size */
820     put_tag(pb, "trak");
821     mov_write_tkhd_tag(pb, track);
822     if (track->mode == MODE_PSP)
823         mov_write_edts_tag(pb, track);  // PSP Movies require edts box
824     mov_write_mdia_tag(pb, track);
825     if (track->mode == MODE_PSP)
826         mov_write_uuid_tag_psp(pb,track);  // PSP Movies require this uuid box
827     return updateSize(pb, pos);
828 }
829
830 #if 0
831 /* TODO: Not sorted out, but not necessary either */
832 static int mov_write_iods_tag(ByteIOContext *pb, MOVContext *mov)
833 {
834     put_be32(pb, 0x15); /* size */
835     put_tag(pb, "iods");
836     put_be32(pb, 0);    /* version & flags */
837     put_be16(pb, 0x1007);
838     put_byte(pb, 0);
839     put_be16(pb, 0x4fff);
840     put_be16(pb, 0xfffe);
841     put_be16(pb, 0x01ff);
842     return 0x15;
843 }
844 #endif
845
846 static int mov_write_mvhd_tag(ByteIOContext *pb, MOVContext *mov)
847 {
848     int maxTrackID = 1, i;
849     int64_t maxTrackLenTemp, maxTrackLen = 0;
850
851     put_be32(pb, 0x6c); /* size (always 0x6c) */
852     put_tag(pb, "mvhd");
853     put_be32(pb, 0); /* version & flags */
854     put_be32(pb, mov->time); /* creation time */
855     put_be32(pb, mov->time); /* modification time */
856     put_be32(pb, mov->timescale); /* timescale */
857     for (i=0; i<MAX_STREAMS; i++) {
858         if(mov->tracks[i].entry > 0) {
859             maxTrackLenTemp = av_rescale_rnd(mov->tracks[i].trackDuration, globalTimescale, mov->tracks[i].timescale, AV_ROUND_UP);
860             if(maxTrackLen < maxTrackLenTemp)
861                 maxTrackLen = maxTrackLenTemp;
862             if(maxTrackID < mov->tracks[i].trackID)
863                 maxTrackID = mov->tracks[i].trackID;
864         }
865     }
866     put_be32(pb, maxTrackLen); /* duration of longest track */
867
868     put_be32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
869     put_be16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
870     put_be16(pb, 0); /* reserved */
871     put_be32(pb, 0); /* reserved */
872     put_be32(pb, 0); /* reserved */
873
874     /* Matrix structure */
875     put_be32(pb, 0x00010000); /* reserved */
876     put_be32(pb, 0x0); /* reserved */
877     put_be32(pb, 0x0); /* reserved */
878     put_be32(pb, 0x0); /* reserved */
879     put_be32(pb, 0x00010000); /* reserved */
880     put_be32(pb, 0x0); /* reserved */
881     put_be32(pb, 0x0); /* reserved */
882     put_be32(pb, 0x0); /* reserved */
883     put_be32(pb, 0x40000000); /* reserved */
884
885     put_be32(pb, 0); /* reserved (preview time) */
886     put_be32(pb, 0); /* reserved (preview duration) */
887     put_be32(pb, 0); /* reserved (poster time) */
888     put_be32(pb, 0); /* reserved (selection time) */
889     put_be32(pb, 0); /* reserved (selection duration) */
890     put_be32(pb, 0); /* reserved (current time) */
891     put_be32(pb, maxTrackID+1); /* Next track id */
892     return 0x6c;
893 }
894
895 static int mov_write_itunes_hdlr_tag(ByteIOContext *pb, MOVContext* mov,
896                                      AVFormatContext *s)
897 {
898     offset_t pos = url_ftell(pb);
899     put_be32(pb, 0); /* size */
900     put_tag(pb, "hdlr");
901     put_be32(pb, 0);
902     put_be32(pb, 0);
903     put_tag(pb, "mdir");
904     put_tag(pb, "appl");
905     put_be32(pb, 0);
906     put_be32(pb, 0);
907     put_be16(pb, 0);
908     return updateSize(pb, pos);
909 }
910
911 /* helper function to write a data tag with the specified string as data */
912 static int mov_write_string_data_tag(ByteIOContext *pb, MOVContext* mov,
913                                      AVFormatContext *s, const char *data)
914 {
915     offset_t pos = url_ftell(pb);
916     put_be32(pb, 0); /* size */
917     put_tag(pb, "data");
918     put_be32(pb, 1);
919     put_be32(pb, 0);
920     put_buffer(pb, data, strlen(data));
921     return updateSize(pb, pos);
922 }
923
924 /* iTunes name of the song/movie */
925 static int mov_write_nam_tag(ByteIOContext *pb, MOVContext* mov,
926                              AVFormatContext *s)
927 {
928     int size = 0;
929     if ( s->title[0] ) {
930         offset_t pos = url_ftell(pb);
931         put_be32(pb, 0); /* size */
932         put_tag(pb, "\251nam");
933         mov_write_string_data_tag(pb, mov, s, s->title);
934         size = updateSize(pb, pos);
935     }
936     return size;
937 }
938
939 /* iTunes name of the artist/performer */
940 static int mov_write_ART_tag(ByteIOContext *pb, MOVContext* mov,
941                              AVFormatContext *s)
942 {
943     int size = 0;
944     if ( s->author[0] ) {
945         offset_t pos = url_ftell(pb);
946         put_be32(pb, 0); /* size */
947         put_tag(pb, "\251ART");
948         // we use the author here as this is the only thing that we have...
949         mov_write_string_data_tag(pb, mov, s, s->author);
950         size = updateSize(pb, pos);
951     }
952     return size;
953 }
954
955 /* iTunes name of the writer */
956 static int mov_write_wrt_tag(ByteIOContext *pb, MOVContext* mov,
957                              AVFormatContext *s)
958 {
959     int size = 0;
960     if ( s->author[0] ) {
961         offset_t pos = url_ftell(pb);
962         put_be32(pb, 0); /* size */
963         put_tag(pb, "\251wrt");
964         mov_write_string_data_tag(pb, mov, s, s->author);
965         size = updateSize(pb, pos);
966     }
967     return size;
968 }
969
970 /* iTunes name of the album */
971 static int mov_write_alb_tag(ByteIOContext *pb, MOVContext* mov,
972                              AVFormatContext *s)
973 {
974     int size = 0;
975     if ( s->album[0] ) {
976         offset_t pos = url_ftell(pb);
977         put_be32(pb, 0); /* size */
978         put_tag(pb, "\251alb");
979         mov_write_string_data_tag(pb, mov, s, s->album);
980         size = updateSize(pb, pos);
981     }
982     return size;
983 }
984
985 /* iTunes year */
986 static int mov_write_day_tag(ByteIOContext *pb, MOVContext* mov,
987                              AVFormatContext *s)
988 {
989     char year[5];
990     int size = 0;
991     if ( s->year ) {
992         offset_t pos = url_ftell(pb);
993         put_be32(pb, 0); /* size */
994         put_tag(pb, "\251day");
995         snprintf(year, 5, "%04d", s->year);
996         mov_write_string_data_tag(pb, mov, s, year);
997         size = updateSize(pb, pos);
998     }
999     return size;
1000 }
1001
1002 /* iTunes tool used to create the file */
1003 static int mov_write_too_tag(ByteIOContext *pb, MOVContext* mov,
1004                              AVFormatContext *s)
1005 {
1006     offset_t pos = url_ftell(pb);
1007     put_be32(pb, 0); /* size */
1008     put_tag(pb, "\251too");
1009     mov_write_string_data_tag(pb, mov, s, LIBAVFORMAT_IDENT);
1010     return updateSize(pb, pos);
1011 }
1012
1013 /* iTunes comment */
1014 static int mov_write_cmt_tag(ByteIOContext *pb, MOVContext* mov,
1015                              AVFormatContext *s)
1016 {
1017     int size = 0;
1018     if ( s->comment[0] ) {
1019         offset_t pos = url_ftell(pb);
1020         put_be32(pb, 0); /* size */
1021         put_tag(pb, "\251cmt");
1022         mov_write_string_data_tag(pb, mov, s, s->comment);
1023         size = updateSize(pb, pos);
1024     }
1025     return size;
1026 }
1027
1028 /* iTunes custom genre */
1029 static int mov_write_gen_tag(ByteIOContext *pb, MOVContext* mov,
1030                              AVFormatContext *s)
1031 {
1032     int size = 0;
1033     if ( s->genre[0] ) {
1034         offset_t pos = url_ftell(pb);
1035         put_be32(pb, 0); /* size */
1036         put_tag(pb, "\251gen");
1037         mov_write_string_data_tag(pb, mov, s, s->genre);
1038         size = updateSize(pb, pos);
1039     }
1040     return size;
1041 }
1042
1043 /* iTunes track number */
1044 static int mov_write_trkn_tag(ByteIOContext *pb, MOVContext* mov,
1045                               AVFormatContext *s)
1046 {
1047     int size = 0;
1048     if ( s->track ) {
1049         offset_t pos = url_ftell(pb);
1050         put_be32(pb, 0); /* size */
1051         put_tag(pb, "trkn");
1052         {
1053             offset_t pos = url_ftell(pb);
1054             put_be32(pb, 0); /* size */
1055             put_tag(pb, "data");
1056             put_be32(pb, 0);        // 8 bytes empty
1057             put_be32(pb, 0);
1058             put_be16(pb, 0);        // empty
1059             put_be16(pb, s->track); // track number
1060             put_be16(pb, 0);        // total track number
1061             put_be16(pb, 0);        // empty
1062             updateSize(pb, pos);
1063         }
1064         size = updateSize(pb, pos);
1065     }
1066     return size;
1067 }
1068
1069 /* iTunes meta data list */
1070 static int mov_write_ilst_tag(ByteIOContext *pb, MOVContext* mov,
1071                               AVFormatContext *s)
1072 {
1073     offset_t pos = url_ftell(pb);
1074     put_be32(pb, 0); /* size */
1075     put_tag(pb, "ilst");
1076     mov_write_nam_tag(pb, mov, s);
1077     mov_write_ART_tag(pb, mov, s);
1078     mov_write_wrt_tag(pb, mov, s);
1079     mov_write_alb_tag(pb, mov, s);
1080     mov_write_day_tag(pb, mov, s);
1081     mov_write_too_tag(pb, mov, s);
1082     mov_write_cmt_tag(pb, mov, s);
1083     mov_write_gen_tag(pb, mov, s);
1084     mov_write_trkn_tag(pb, mov, s);
1085     return updateSize(pb, pos);
1086 }
1087
1088 /* iTunes meta data tag */
1089 static int mov_write_meta_tag(ByteIOContext *pb, MOVContext* mov,
1090                               AVFormatContext *s)
1091 {
1092     int size = 0;
1093
1094     // only save meta tag if required
1095     if ( s->title[0] || s->author[0] || s->album[0] || s->year ||
1096          s->comment[0] || s->genre[0] || s->track ) {
1097         offset_t pos = url_ftell(pb);
1098         put_be32(pb, 0); /* size */
1099         put_tag(pb, "meta");
1100         put_be32(pb, 0);
1101         mov_write_itunes_hdlr_tag(pb, mov, s);
1102         mov_write_ilst_tag(pb, mov, s);
1103         size = updateSize(pb, pos);
1104     }
1105     return size;
1106 }
1107
1108 static int mov_write_udta_tag(ByteIOContext *pb, MOVContext* mov,
1109                               AVFormatContext *s)
1110 {
1111     offset_t pos = url_ftell(pb);
1112     int i;
1113
1114     put_be32(pb, 0); /* size */
1115     put_tag(pb, "udta");
1116
1117     /* iTunes meta data */
1118     mov_write_meta_tag(pb, mov, s);
1119
1120     /* Requirements */
1121     for (i=0; i<MAX_STREAMS; i++) {
1122         if(mov->tracks[i].entry <= 0) continue;
1123         if (mov->tracks[i].enc->codec_id == CODEC_ID_AAC ||
1124             mov->tracks[i].enc->codec_id == CODEC_ID_MPEG4) {
1125             offset_t pos = url_ftell(pb);
1126             put_be32(pb, 0); /* size */
1127             put_tag(pb, "\251req");
1128             put_be16(pb, sizeof("QuickTime 6.0 or greater") - 1);
1129             put_be16(pb, 0);
1130             put_buffer(pb, "QuickTime 6.0 or greater",
1131                        sizeof("QuickTime 6.0 or greater") - 1);
1132             updateSize(pb, pos);
1133             break;
1134         }
1135     }
1136
1137     /* Encoder */
1138     if(mov->tracks[0].enc && !(mov->tracks[0].enc->flags & CODEC_FLAG_BITEXACT))
1139     {
1140         offset_t pos = url_ftell(pb);
1141         put_be32(pb, 0); /* size */
1142         put_tag(pb, "\251enc");
1143         put_be16(pb, sizeof(LIBAVFORMAT_IDENT) - 1); /* string length */
1144         put_be16(pb, 0);
1145         put_buffer(pb, LIBAVFORMAT_IDENT, sizeof(LIBAVFORMAT_IDENT) - 1);
1146         updateSize(pb, pos);
1147     }
1148
1149     if( s->title[0] )
1150     {
1151         offset_t pos = url_ftell(pb);
1152         put_be32(pb, 0); /* size */
1153         put_tag(pb, "\251nam");
1154         put_be16(pb, strlen(s->title)); /* string length */
1155         put_be16(pb, 0);
1156         put_buffer(pb, s->title, strlen(s->title));
1157         updateSize(pb, pos);
1158     }
1159
1160     if( s->author[0] )
1161     {
1162         offset_t pos = url_ftell(pb);
1163         put_be32(pb, 0); /* size */
1164         put_tag(pb, /*"\251aut"*/ "\251day" );
1165         put_be16(pb, strlen(s->author)); /* string length */
1166         put_be16(pb, 0);
1167         put_buffer(pb, s->author, strlen(s->author));
1168         updateSize(pb, pos);
1169     }
1170
1171     if( s->comment[0] )
1172     {
1173         offset_t pos = url_ftell(pb);
1174         put_be32(pb, 0); /* size */
1175         put_tag(pb, "\251des");
1176         put_be16(pb, strlen(s->comment)); /* string length */
1177         put_be16(pb, 0);
1178         put_buffer(pb, s->comment, strlen(s->comment));
1179         updateSize(pb, pos);
1180     }
1181
1182     return updateSize(pb, pos);
1183 }
1184
1185 static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov,
1186                               AVFormatContext *s)
1187 {
1188     int i;
1189     offset_t pos = url_ftell(pb);
1190     put_be32(pb, 0); /* size placeholder*/
1191     put_tag(pb, "moov");
1192     mov->timescale = globalTimescale;
1193
1194     for (i=0; i<MAX_STREAMS; i++) {
1195         if(mov->tracks[i].entry <= 0) continue;
1196
1197         if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO) {
1198             mov->tracks[i].timescale = mov->tracks[i].enc->time_base.den;
1199             mov->tracks[i].sampleDuration = mov->tracks[i].enc->time_base.num;
1200         }
1201         else if(mov->tracks[i].enc->codec_type == CODEC_TYPE_AUDIO) {
1202             /* If AMR, track timescale = 8000, AMR_WB = 16000 */
1203             if(mov->tracks[i].enc->codec_id == CODEC_ID_AMR_NB) {
1204                 mov->tracks[i].sampleDuration = 160;  // Bytes per chunk
1205                 mov->tracks[i].timescale = 8000;
1206             }
1207             else {
1208                 mov->tracks[i].timescale = mov->tracks[i].enc->sample_rate;
1209                 mov->tracks[i].sampleDuration = mov->tracks[i].enc->frame_size;
1210             }
1211         }
1212
1213         mov->tracks[i].trackDuration =
1214             mov->tracks[i].sampleCount * mov->tracks[i].sampleDuration;
1215         mov->tracks[i].time = mov->time;
1216         mov->tracks[i].trackID = i+1;
1217     }
1218
1219     mov_write_mvhd_tag(pb, mov);
1220     //mov_write_iods_tag(pb, mov);
1221     for (i=0; i<MAX_STREAMS; i++) {
1222         if(mov->tracks[i].entry > 0) {
1223             mov_write_trak_tag(pb, &(mov->tracks[i]));
1224         }
1225     }
1226
1227     mov_write_udta_tag(pb, mov, s);
1228
1229     return updateSize(pb, pos);
1230 }
1231
1232 int mov_write_mdat_tag(ByteIOContext *pb, MOVContext* mov)
1233 {
1234     put_be32(pb, 8);    // placeholder for extended size field (64 bit)
1235     put_tag(pb, "wide");
1236
1237     mov->mdat_pos = url_ftell(pb);
1238     put_be32(pb, 0); /* size placeholder*/
1239     put_tag(pb, "mdat");
1240     return 0;
1241 }
1242
1243 /* TODO: This needs to be more general */
1244 int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
1245 {
1246     MOVContext *mov = s->priv_data;
1247
1248     put_be32(pb, 0x14 ); /* size */
1249     put_tag(pb, "ftyp");
1250
1251     if ( mov->mode == MODE_3GP )
1252         put_tag(pb, "3gp4");
1253     else if ( mov->mode == MODE_3G2 )
1254         put_tag(pb, "3g2a");
1255     else if ( mov->mode == MODE_PSP )
1256         put_tag(pb, "MSNV");
1257     else
1258         put_tag(pb, "isom");
1259
1260     put_be32(pb, 0x200 );
1261
1262     if ( mov->mode == MODE_3GP )
1263         put_tag(pb, "3gp4");
1264     else if ( mov->mode == MODE_3G2 )
1265         put_tag(pb, "3g2a");
1266     else if ( mov->mode == MODE_PSP )
1267         put_tag(pb, "MSNV");
1268     else
1269         put_tag(pb, "mp41");
1270
1271     return 0x14;
1272 }
1273
1274 static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
1275 {
1276     int AudioRate = s->streams[1]->codec->sample_rate;
1277     int FrameRate = ((s->streams[0]->codec->time_base.den) * (0x10000))/ (s->streams[0]->codec->time_base.num);
1278
1279     //printf("audiorate = %d\n",AudioRate);
1280     //printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec->time_base.den,s->streams[0]->codec->time_base.num,FrameRate);
1281
1282     put_be32(pb, 0x94 ); /* size */
1283     put_tag(pb, "uuid");
1284     put_tag(pb, "PROF");
1285
1286     put_be32(pb, 0x21d24fce ); /* 96 bit UUID */
1287     put_be32(pb, 0xbb88695c );
1288     put_be32(pb, 0xfac9c740 );
1289
1290     put_be32(pb, 0x0 );  /* ? */
1291     put_be32(pb, 0x3 );  /* 3 sections ? */
1292
1293     put_be32(pb, 0x14 ); /* size */
1294     put_tag(pb, "FPRF");
1295     put_be32(pb, 0x0 );  /* ? */
1296     put_be32(pb, 0x0 );  /* ? */
1297     put_be32(pb, 0x0 );  /* ? */
1298
1299     put_be32(pb, 0x2c );  /* size */
1300     put_tag(pb, "APRF");   /* audio */
1301     put_be32(pb, 0x0 );
1302     put_be32(pb, 0x2 );
1303     put_tag(pb, "mp4a");
1304     put_be32(pb, 0x20f );
1305     put_be32(pb, 0x0 );
1306     put_be32(pb, 0x40 );
1307     put_be32(pb, 0x40 );
1308     put_be32(pb, AudioRate ); //24000   ... audio rate?
1309     put_be32(pb, 0x2 );
1310
1311     put_be32(pb, 0x34 );  /* size */
1312     put_tag(pb, "VPRF");   /* video */
1313     put_be32(pb, 0x0 );
1314     put_be32(pb, 0x1 );
1315     put_tag(pb, "mp4v");
1316     put_be32(pb, 0x103 );
1317     put_be32(pb, 0x0 );
1318     put_be32(pb, 0xc0 );
1319     put_be32(pb, 0xc0 );
1320     put_be32(pb, FrameRate);  // was 0xefc29
1321     put_be32(pb, FrameRate );  // was 0xefc29
1322     put_be16(pb, s->streams[0]->codec->width);
1323     put_be16(pb, s->streams[0]->codec->height);
1324     put_be32(pb, 0x010001 );
1325 }
1326
1327 static int mov_write_header(AVFormatContext *s)
1328 {
1329     ByteIOContext *pb = &s->pb;
1330     MOVContext *mov = s->priv_data;
1331     int i;
1332
1333     for(i=0; i<s->nb_streams; i++){
1334         AVCodecContext *c= s->streams[i]->codec;
1335
1336         if      (c->codec_type == CODEC_TYPE_VIDEO){
1337             if (!codec_get_tag(codec_movvideo_tags, c->codec_id)){
1338                 if(!codec_get_tag(codec_bmp_tags, c->codec_id))
1339                     return -1;
1340                 else
1341                     av_log(s, AV_LOG_INFO, "Warning, using MS style video codec tag, the file may be unplayable!\n");
1342             }
1343         }else if(c->codec_type == CODEC_TYPE_AUDIO){
1344             if (!codec_get_tag(codec_movaudio_tags, c->codec_id)){
1345                 if(!codec_get_tag(codec_wav_tags, c->codec_id))
1346                     return -1;
1347                 else
1348                     av_log(s, AV_LOG_INFO, "Warning, using MS style audio codec tag, the file may be unplayable!\n");
1349             }
1350         }
1351         /* don't know yet if mp4 or not */
1352         mov->tracks[i].language = ff_mov_iso639_to_lang(s->streams[i]->language, 1);
1353     }
1354
1355     /* Default mode == MP4 */
1356     mov->mode = MODE_MP4;
1357
1358     if (s->oformat != NULL) {
1359         if (!strcmp("3gp", s->oformat->name)) mov->mode = MODE_3GP;
1360         else if (!strcmp("3g2", s->oformat->name)) mov->mode = MODE_3G2;
1361         else if (!strcmp("mov", s->oformat->name)) mov->mode = MODE_MOV;
1362         else if (!strcmp("psp", s->oformat->name)) mov->mode = MODE_PSP;
1363
1364         if ( mov->mode == MODE_3GP || mov->mode == MODE_3G2 ||
1365              mov->mode == MODE_MP4 || mov->mode == MODE_PSP )
1366             mov_write_ftyp_tag(pb,s);
1367         if ( mov->mode == MODE_PSP ) {
1368             if ( s->nb_streams != 2 ) {
1369                 av_log(s, AV_LOG_ERROR, "PSP mode need one video and one audio stream\n");
1370                 return -1;
1371             }
1372             mov_write_uuidprof_tag(pb,s);
1373         }
1374     }
1375
1376     for (i=0; i<MAX_STREAMS; i++) {
1377         mov->tracks[i].mode = mov->mode;
1378     }
1379
1380     put_flush_packet(pb);
1381
1382     return 0;
1383 }
1384
1385 static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
1386 {
1387     MOVContext *mov = s->priv_data;
1388     ByteIOContext *pb = &s->pb;
1389     AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
1390     MOVTrack* trk = &mov->tracks[pkt->stream_index];
1391     int cl, id;
1392     unsigned int samplesInChunk = 0;
1393     int size= pkt->size;
1394
1395     if (url_is_streamed(&s->pb)) return 0; /* Can't handle that */
1396     if (!size) return 0; /* Discard 0 sized packets */
1397
1398     if (enc->codec_type == CODEC_TYPE_VIDEO ) {
1399         samplesInChunk = 1;
1400     }
1401     else if (enc->codec_type == CODEC_TYPE_AUDIO ) {
1402         if( enc->codec_id == CODEC_ID_AMR_NB) {
1403             /* We must find out how many AMR blocks there are in one packet */
1404             static uint16_t packed_size[16] =
1405                 {13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 0};
1406             int len = 0;
1407
1408             while (len < size && samplesInChunk < 100) {
1409                 len += packed_size[(pkt->data[len] >> 3) & 0x0F];
1410                 samplesInChunk++;
1411             }
1412         }
1413         else if(enc->codec_id == CODEC_ID_PCM_ALAW) {
1414             samplesInChunk = size/enc->channels;
1415         }
1416         else if(enc->codec_id == CODEC_ID_PCM_S16BE || enc->codec_id == CODEC_ID_PCM_S16LE) {
1417             samplesInChunk = size/(2*enc->channels);
1418         }
1419         else {
1420             samplesInChunk = 1;
1421         }
1422     }
1423
1424     if ((enc->codec_id == CODEC_ID_MPEG4 || enc->codec_id == CODEC_ID_AAC)
1425         && trk->vosLen == 0) {
1426 //        assert(enc->extradata_size);
1427
1428         trk->vosLen = enc->extradata_size;
1429         trk->vosData = av_malloc(trk->vosLen);
1430         memcpy(trk->vosData, enc->extradata, trk->vosLen);
1431     }
1432
1433     cl = trk->entry / MOV_INDEX_CLUSTER_SIZE;
1434     id = trk->entry % MOV_INDEX_CLUSTER_SIZE;
1435
1436     if (trk->ents_allocated <= trk->entry) {
1437         trk->cluster = av_realloc(trk->cluster, (cl+1)*sizeof(void*));
1438         if (!trk->cluster)
1439             return -1;
1440         trk->cluster[cl] = av_malloc(MOV_INDEX_CLUSTER_SIZE*sizeof(MOVIentry));
1441         if (!trk->cluster[cl])
1442             return -1;
1443         trk->ents_allocated += MOV_INDEX_CLUSTER_SIZE;
1444     }
1445     if (mov->mdat_written == 0) {
1446         mov_write_mdat_tag(pb, mov);
1447         mov->mdat_written = 1;
1448         mov->time = s->timestamp + 0x7C25B080; //1970 based -> 1904 based
1449     }
1450
1451     trk->cluster[cl][id].pos = url_ftell(pb);
1452     trk->cluster[cl][id].samplesInChunk = samplesInChunk;
1453     trk->cluster[cl][id].size = size;
1454     trk->cluster[cl][id].entries = samplesInChunk;
1455     if(enc->codec_type == CODEC_TYPE_VIDEO) {
1456         trk->cluster[cl][id].key_frame = !!(pkt->flags & PKT_FLAG_KEY);
1457         if(trk->cluster[cl][id].key_frame)
1458             trk->hasKeyframes = 1;
1459     }
1460     trk->enc = enc;
1461     trk->entry++;
1462     trk->sampleCount += samplesInChunk;
1463     trk->mdat_size += size;
1464
1465     put_buffer(pb, pkt->data, size);
1466
1467     put_flush_packet(pb);
1468     return 0;
1469 }
1470
1471 static int mov_write_trailer(AVFormatContext *s)
1472 {
1473     MOVContext *mov = s->priv_data;
1474     ByteIOContext *pb = &s->pb;
1475     int res = 0;
1476     int i;
1477     uint64_t j;
1478
1479     offset_t moov_pos = url_ftell(pb);
1480
1481     /* Write size of mdat tag */
1482     for (i=0, j=0; i<MAX_STREAMS; i++) {
1483         if(mov->tracks[i].ents_allocated > 0) {
1484             j += mov->tracks[i].mdat_size;
1485         }
1486     }
1487     if (j+8 <= UINT32_MAX) {
1488         url_fseek(pb, mov->mdat_pos, SEEK_SET);
1489         put_be32(pb, j+8);
1490     } else {
1491         /* overwrite 'wide' placeholder atom */
1492         url_fseek(pb, mov->mdat_pos - 8, SEEK_SET);
1493         put_be32(pb, 1); /* special value: real atom size will be 64 bit value after tag field */
1494         put_tag(pb, "mdat");
1495         put_be64(pb, j+16);
1496     }
1497     url_fseek(pb, moov_pos, SEEK_SET);
1498
1499     mov_write_moov_tag(pb, mov, s);
1500
1501     for (i=0; i<MAX_STREAMS; i++) {
1502         for (j=0; j<mov->tracks[i].ents_allocated/MOV_INDEX_CLUSTER_SIZE; j++) {
1503             av_free(mov->tracks[i].cluster[j]);
1504         }
1505         av_free(mov->tracks[i].cluster);
1506         if( mov->tracks[i].vosLen ) av_free( mov->tracks[i].vosData );
1507
1508         mov->tracks[i].cluster = NULL;
1509         mov->tracks[i].ents_allocated = mov->tracks[i].entry = 0;
1510     }
1511
1512     put_flush_packet(pb);
1513
1514     return res;
1515 }
1516
1517 static AVOutputFormat mov_oformat = {
1518     "mov",
1519     "mov format",
1520     NULL,
1521     "mov",
1522     sizeof(MOVContext),
1523     CODEC_ID_AAC,
1524     CODEC_ID_MPEG4,
1525     mov_write_header,
1526     mov_write_packet,
1527     mov_write_trailer,
1528     .flags = AVFMT_GLOBALHEADER,
1529 };
1530
1531 static AVOutputFormat _3gp_oformat = {
1532     "3gp",
1533     "3gp format",
1534     NULL,
1535     "3gp",
1536     sizeof(MOVContext),
1537     CODEC_ID_AMR_NB,
1538     CODEC_ID_H263,
1539     mov_write_header,
1540     mov_write_packet,
1541     mov_write_trailer,
1542     .flags = AVFMT_GLOBALHEADER,
1543 };
1544
1545 static AVOutputFormat mp4_oformat = {
1546     "mp4",
1547     "mp4 format",
1548     "application/mp4",
1549     "mp4,m4a",
1550     sizeof(MOVContext),
1551     CODEC_ID_AAC,
1552     CODEC_ID_MPEG4,
1553     mov_write_header,
1554     mov_write_packet,
1555     mov_write_trailer,
1556     .flags = AVFMT_GLOBALHEADER,
1557 };
1558
1559 static AVOutputFormat psp_oformat = {
1560     "psp",
1561     "psp mp4 format",
1562     NULL,
1563     "mp4,psp",
1564     sizeof(MOVContext),
1565     CODEC_ID_AAC,
1566     CODEC_ID_MPEG4,
1567     mov_write_header,
1568     mov_write_packet,
1569     mov_write_trailer,
1570 //    .flags = AVFMT_GLOBALHEADER,
1571 };
1572
1573 static AVOutputFormat _3g2_oformat = {
1574     "3g2",
1575     "3gp2 format",
1576     NULL,
1577     "3g2",
1578     sizeof(MOVContext),
1579     CODEC_ID_AMR_NB,
1580     CODEC_ID_H263,
1581     mov_write_header,
1582     mov_write_packet,
1583     mov_write_trailer,
1584     .flags = AVFMT_GLOBALHEADER,
1585 };
1586
1587 int movenc_init(void)
1588 {
1589     av_register_output_format(&mov_oformat);
1590     av_register_output_format(&_3gp_oformat);
1591     av_register_output_format(&mp4_oformat);
1592     av_register_output_format(&psp_oformat);
1593     av_register_output_format(&_3g2_oformat);
1594     return 0;
1595 }