Merge commit '72f801619a1ae91969fee9a7d72519422433c998'
[ffmpeg.git] / libavformat / movenc.c
1 /*
2  * MOV, 3GP, MP4 muxer
3  * Copyright (c) 2003 Thomas Raivio
4  * Copyright (c) 2004 Gildas Bazin <gbazin at videolan dot org>
5  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg 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 GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include <stdint.h>
25 #include <inttypes.h>
26
27 #include "movenc.h"
28 #include "avformat.h"
29 #include "avio_internal.h"
30 #include "riff.h"
31 #include "avio.h"
32 #include "isom.h"
33 #include "avc.h"
34 #include "libavcodec/ac3_parser.h"
35 #include "libavcodec/get_bits.h"
36 #include "libavcodec/put_bits.h"
37 #include "libavcodec/vc1_common.h"
38 #include "libavcodec/raw.h"
39 #include "internal.h"
40 #include "libavutil/avstring.h"
41 #include "libavutil/intfloat.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/pixdesc.h"
46 #include "libavutil/timecode.h"
47 #include "hevc.h"
48 #include "rtpenc.h"
49 #include "mov_chan.h"
50
51 #undef NDEBUG
52 #include <assert.h>
53
54 static const AVOption options[] = {
55     { "movflags", "MOV muxer flags", offsetof(MOVMuxContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
56     { "rtphint", "Add RTP hint tracks", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_RTP_HINT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
57     { "moov_size", "maximum moov size so it can be placed at the begin", offsetof(MOVMuxContext, reserved_moov_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 },
58     { "empty_moov", "Make the initial moov atom empty (not supported by QuickTime)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_EMPTY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
59     { "frag_keyframe", "Fragment at video keyframes", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_KEYFRAME}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
60     { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
61     { "frag_custom", "Flush fragments on caller requests", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_CUSTOM}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
62     { "isml", "Create a live smooth streaming feed (for pushing to a publishing point)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_ISML}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
63     { "faststart", "Run a second pass to put the index (moov atom) at the beginning of the file", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FASTSTART}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
64     { "omit_tfhd_offset", "Omit the base data offset in tfhd atoms", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_OMIT_TFHD_OFFSET}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
65     { "disable_chpl", "Disable Nero chapter atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_DISABLE_CHPL}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
66     FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
67     { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
68     { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
69     { "iods_video_profile", "iods video profile atom.", offsetof(MOVMuxContext, iods_video_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
70     { "frag_duration", "Maximum fragment duration", offsetof(MOVMuxContext, max_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
71     { "min_frag_duration", "Minimum fragment duration", offsetof(MOVMuxContext, min_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
72     { "frag_size", "Maximum fragment size", offsetof(MOVMuxContext, max_fragment_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
73     { "ism_lookahead", "Number of lookahead entries for ISM files", offsetof(MOVMuxContext, ism_lookahead), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
74     { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
75     { "video_track_timescale", "set timescale of all video tracks", offsetof(MOVMuxContext, video_track_timescale), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
76     { "brand",    "Override major brand", offsetof(MOVMuxContext, major_brand),   AV_OPT_TYPE_STRING, {.str = NULL}, .flags = AV_OPT_FLAG_ENCODING_PARAM },
77     { NULL },
78 };
79
80 #define MOV_CLASS(flavor)\
81 static const AVClass flavor ## _muxer_class = {\
82     .class_name = #flavor " muxer",\
83     .item_name  = av_default_item_name,\
84     .option     = options,\
85     .version    = LIBAVUTIL_VERSION_INT,\
86 };
87
88 static int get_moov_size(AVFormatContext *s);
89
90 static int utf8len(const uint8_t *b)
91 {
92     int len = 0;
93     int val;
94     while (*b) {
95         GET_UTF8(val, *b++, return -1;)
96         len++;
97     }
98     return len;
99 }
100
101 //FIXME support 64 bit variant with wide placeholders
102 static int64_t update_size(AVIOContext *pb, int64_t pos)
103 {
104     int64_t curpos = avio_tell(pb);
105     avio_seek(pb, pos, SEEK_SET);
106     avio_wb32(pb, curpos - pos); /* rewrite size */
107     avio_seek(pb, curpos, SEEK_SET);
108
109     return curpos - pos;
110 }
111
112 static int supports_edts(MOVMuxContext *mov)
113 {
114     // EDTS with fragments is tricky as we don't know the duration when its written
115     return (mov->use_editlist<0 && !(mov->flags & FF_MOV_FLAG_FRAGMENT)) || mov->use_editlist>0;
116 }
117
118 static int co64_required(const MOVTrack *track)
119 {
120     if (track->entry > 0 && track->cluster[track->entry - 1].pos + track->data_offset > UINT32_MAX)
121         return 1;
122     return 0;
123 }
124
125 /* Chunk offset atom */
126 static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)
127 {
128     int i;
129     int mode64 = co64_required(track); // use 32 bit size variant if possible
130     int64_t pos = avio_tell(pb);
131     avio_wb32(pb, 0); /* size */
132     if (mode64)
133         ffio_wfourcc(pb, "co64");
134     else
135         ffio_wfourcc(pb, "stco");
136     avio_wb32(pb, 0); /* version & flags */
137     avio_wb32(pb, track->chunkCount); /* entry count */
138     for (i = 0; i < track->entry; i++) {
139         if (!track->cluster[i].chunkNum)
140             continue;
141         if (mode64 == 1)
142             avio_wb64(pb, track->cluster[i].pos + track->data_offset);
143         else
144             avio_wb32(pb, track->cluster[i].pos + track->data_offset);
145     }
146     return update_size(pb, pos);
147 }
148
149 /* Sample size atom */
150 static int mov_write_stsz_tag(AVIOContext *pb, MOVTrack *track)
151 {
152     int equalChunks = 1;
153     int i, j, entries = 0, tst = -1, oldtst = -1;
154
155     int64_t pos = avio_tell(pb);
156     avio_wb32(pb, 0); /* size */
157     ffio_wfourcc(pb, "stsz");
158     avio_wb32(pb, 0); /* version & flags */
159
160     for (i = 0; i < track->entry; i++) {
161         tst = track->cluster[i].size / track->cluster[i].entries;
162         if (oldtst != -1 && tst != oldtst)
163             equalChunks = 0;
164         oldtst = tst;
165         entries += track->cluster[i].entries;
166     }
167     if (equalChunks && track->entry) {
168         int sSize = track->entry ? track->cluster[0].size / track->cluster[0].entries : 0;
169         sSize = FFMAX(1, sSize); // adpcm mono case could make sSize == 0
170         avio_wb32(pb, sSize); // sample size
171         avio_wb32(pb, entries); // sample count
172     } else {
173         avio_wb32(pb, 0); // sample size
174         avio_wb32(pb, entries); // sample count
175         for (i = 0; i < track->entry; i++) {
176             for (j = 0; j < track->cluster[i].entries; j++) {
177                 avio_wb32(pb, track->cluster[i].size /
178                           track->cluster[i].entries);
179             }
180         }
181     }
182     return update_size(pb, pos);
183 }
184
185 /* Sample to chunk atom */
186 static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)
187 {
188     int index = 0, oldval = -1, i;
189     int64_t entryPos, curpos;
190
191     int64_t pos = avio_tell(pb);
192     avio_wb32(pb, 0); /* size */
193     ffio_wfourcc(pb, "stsc");
194     avio_wb32(pb, 0); // version & flags
195     entryPos = avio_tell(pb);
196     avio_wb32(pb, track->chunkCount); // entry count
197     for (i = 0; i < track->entry; i++) {
198         if (oldval != track->cluster[i].samples_in_chunk && track->cluster[i].chunkNum) {
199             avio_wb32(pb, track->cluster[i].chunkNum); // first chunk
200             avio_wb32(pb, track->cluster[i].samples_in_chunk); // samples per chunk
201             avio_wb32(pb, 0x1); // sample description index
202             oldval = track->cluster[i].samples_in_chunk;
203             index++;
204         }
205     }
206     curpos = avio_tell(pb);
207     avio_seek(pb, entryPos, SEEK_SET);
208     avio_wb32(pb, index); // rewrite size
209     avio_seek(pb, curpos, SEEK_SET);
210
211     return update_size(pb, pos);
212 }
213
214 /* Sync sample atom */
215 static int mov_write_stss_tag(AVIOContext *pb, MOVTrack *track, uint32_t flag)
216 {
217     int64_t curpos, entryPos;
218     int i, index = 0;
219     int64_t pos = avio_tell(pb);
220     avio_wb32(pb, 0); // size
221     ffio_wfourcc(pb, flag == MOV_SYNC_SAMPLE ? "stss" : "stps");
222     avio_wb32(pb, 0); // version & flags
223     entryPos = avio_tell(pb);
224     avio_wb32(pb, track->entry); // entry count
225     for (i = 0; i < track->entry; i++) {
226         if (track->cluster[i].flags & flag) {
227             avio_wb32(pb, i + 1);
228             index++;
229         }
230     }
231     curpos = avio_tell(pb);
232     avio_seek(pb, entryPos, SEEK_SET);
233     avio_wb32(pb, index); // rewrite size
234     avio_seek(pb, curpos, SEEK_SET);
235     return update_size(pb, pos);
236 }
237
238 static int mov_write_amr_tag(AVIOContext *pb, MOVTrack *track)
239 {
240     avio_wb32(pb, 0x11); /* size */
241     if (track->mode == MODE_MOV) ffio_wfourcc(pb, "samr");
242     else                         ffio_wfourcc(pb, "damr");
243     ffio_wfourcc(pb, "FFMP");
244     avio_w8(pb, 0); /* decoder version */
245
246     avio_wb16(pb, 0x81FF); /* Mode set (all modes for AMR_NB) */
247     avio_w8(pb, 0x00); /* Mode change period (no restriction) */
248     avio_w8(pb, 0x01); /* Frames per sample */
249     return 0x11;
250 }
251
252 static int mov_write_ac3_tag(AVIOContext *pb, MOVTrack *track)
253 {
254     GetBitContext gbc;
255     PutBitContext pbc;
256     uint8_t buf[3];
257     int fscod, bsid, bsmod, acmod, lfeon, frmsizecod;
258
259     if (track->vos_len < 7)
260         return -1;
261
262     avio_wb32(pb, 11);
263     ffio_wfourcc(pb, "dac3");
264
265     init_get_bits(&gbc, track->vos_data + 4, (track->vos_len - 4) * 8);
266     fscod      = get_bits(&gbc, 2);
267     frmsizecod = get_bits(&gbc, 6);
268     bsid       = get_bits(&gbc, 5);
269     bsmod      = get_bits(&gbc, 3);
270     acmod      = get_bits(&gbc, 3);
271     if (acmod == 2) {
272         skip_bits(&gbc, 2); // dsurmod
273     } else {
274         if ((acmod & 1) && acmod != 1)
275             skip_bits(&gbc, 2); // cmixlev
276         if (acmod & 4)
277             skip_bits(&gbc, 2); // surmixlev
278     }
279     lfeon = get_bits1(&gbc);
280
281     init_put_bits(&pbc, buf, sizeof(buf));
282     put_bits(&pbc, 2, fscod);
283     put_bits(&pbc, 5, bsid);
284     put_bits(&pbc, 3, bsmod);
285     put_bits(&pbc, 3, acmod);
286     put_bits(&pbc, 1, lfeon);
287     put_bits(&pbc, 5, frmsizecod >> 1); // bit_rate_code
288     put_bits(&pbc, 5, 0); // reserved
289
290     flush_put_bits(&pbc);
291     avio_write(pb, buf, sizeof(buf));
292
293     return 11;
294 }
295
296 struct eac3_info {
297     uint8_t ec3_done;
298
299     /* Layout of the EC3SpecificBox */
300     /* maximum bitrate */
301     uint16_t data_rate;
302     /* number of independent substreams */
303     uint8_t  num_ind_sub;
304     struct {
305         /* sample rate code (see ff_ac3_sample_rate_tab) 2 bits */
306         uint8_t fscod;
307         /* bit stream identification 5 bits */
308         uint8_t bsid;
309         /* one bit reserved */
310         /* audio service mixing (not supported yet) 1 bit */
311         /* bit stream mode 3 bits */
312         uint8_t bsmod;
313         /* audio coding mode 3 bits */
314         uint8_t acmod;
315         /* sub woofer on 1 bit */
316         uint8_t lfeon;
317         /* 3 bits reserved */
318         /* number of dependent substreams associated with this substream 4 bits */
319         uint8_t num_dep_sub;
320         /* channel locations of the dependent substream(s), if any, 9 bits */
321         uint16_t chan_loc;
322         /* if there is no dependent substream, then one bit reserved instead */
323     } substream[1]; /* TODO: support 8 independent substreams */
324 };
325
326 static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
327 {
328     GetBitContext gbc;
329     AC3HeaderInfo tmp, *hdr = &tmp;
330     struct eac3_info *info;
331     int num_blocks;
332
333     if (!track->eac3_priv && !(track->eac3_priv = av_mallocz(sizeof(*info))))
334         return AVERROR(ENOMEM);
335     info = track->eac3_priv;
336
337     init_get_bits(&gbc, pkt->data, pkt->size * 8);
338     if (avpriv_ac3_parse_header2(&gbc, &hdr) < 0) {
339         /* drop the packets until we see a good one */
340         if (!track->entry) {
341             av_log(mov, AV_LOG_WARNING, "Dropping invalid packet from start of the stream\n");
342             return 0;
343         }
344         return AVERROR_INVALIDDATA;
345     }
346
347     info->data_rate = FFMAX(info->data_rate, hdr->bit_rate / 1000);
348     num_blocks = hdr->num_blocks;
349
350     if (!info->ec3_done) {
351         /* AC-3 substream must be the first one */
352         if (hdr->bitstream_id <= 10 && hdr->substreamid != 0)
353             return AVERROR(EINVAL);
354
355         /* this should always be the case, given that our AC-3 parser
356          * concatenates dependent frames to their independent parent */
357         if (hdr->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) {
358             /* substream ids must be incremental */
359             if (hdr->substreamid > info->num_ind_sub + 1)
360                 return AVERROR(EINVAL);
361
362             if (hdr->substreamid == info->num_ind_sub + 1) {
363                 //info->num_ind_sub++;
364                 avpriv_request_sample(track->enc, "Multiple independent substreams");
365                 return AVERROR_PATCHWELCOME;
366             } else if (hdr->substreamid < info->num_ind_sub ||
367                        hdr->substreamid == 0 && info->substream[0].bsid) {
368                 info->ec3_done = 1;
369                 goto concatenate;
370             }
371         }
372
373         /* fill the info needed for the "dec3" atom */
374         info->substream[hdr->substreamid].fscod = hdr->sr_code;
375         info->substream[hdr->substreamid].bsid  = hdr->bitstream_id;
376         info->substream[hdr->substreamid].bsmod = hdr->bitstream_mode;
377         info->substream[hdr->substreamid].acmod = hdr->channel_mode;
378         info->substream[hdr->substreamid].lfeon = hdr->lfe_on;
379
380         /* Parse dependent substream(s), if any */
381         if (pkt->size != hdr->frame_size) {
382             int cumul_size = hdr->frame_size;
383             int parent = hdr->substreamid;
384
385             while (cumul_size != pkt->size) {
386                 int i;
387                 init_get_bits(&gbc, pkt->data + cumul_size, (pkt->size - cumul_size) * 8);
388                 if (avpriv_ac3_parse_header2(&gbc, &hdr) < 0)
389                     return AVERROR_INVALIDDATA;
390                 if (hdr->frame_type != EAC3_FRAME_TYPE_DEPENDENT)
391                     return AVERROR(EINVAL);
392                 cumul_size += hdr->frame_size;
393                 info->substream[parent].num_dep_sub++;
394
395                 /* header is parsed up to lfeon, but custom channel map may be needed */
396                 /* skip bsid */
397                 skip_bits(&gbc, 5);
398                 /* skip volume control params */
399                 for (i = 0; i < (hdr->channel_mode ? 1 : 2); i++) {
400                     skip_bits(&gbc, 5); // skip dialog normalization
401                     if (get_bits1(&gbc)) {
402                         skip_bits(&gbc, 8); // skip compression gain word
403                     }
404                 }
405                 /* get the dependent stream channel map, if exists */
406                 if (get_bits1(&gbc))
407                     info->substream[parent].chan_loc |= (get_bits(&gbc, 16) >> 5) & 0x1f;
408                 else
409                     info->substream[parent].chan_loc |= hdr->channel_mode;
410             }
411         }
412     }
413
414 /* TODO: concatenate syncframes to have 6 blocks per entry */
415 concatenate:
416     if (num_blocks != 6) {
417         avpriv_request_sample(track->enc, "%d block(s) in syncframe", num_blocks);
418         return AVERROR_PATCHWELCOME;
419     }
420
421     return pkt->size;
422 }
423
424 static int mov_write_eac3_tag(AVIOContext *pb, MOVTrack *track)
425 {
426     PutBitContext pbc;
427     uint8_t *buf;
428     struct eac3_info *info;
429     int size, i;
430
431     if (!track->eac3_priv)
432         return AVERROR(EINVAL);
433
434     info = track->eac3_priv;
435     size = 2 + 4 * (info->num_ind_sub + 1);
436     buf = av_malloc(size);
437     if (!buf) {
438         av_freep(&track->eac3_priv);
439         return AVERROR(ENOMEM);
440     }
441
442     init_put_bits(&pbc, buf, size);
443     put_bits(&pbc, 13, info->data_rate);
444     put_bits(&pbc,  3, info->num_ind_sub);
445     for (i = 0; i <= info->num_ind_sub; i++) {
446         put_bits(&pbc, 2, info->substream[i].fscod);
447         put_bits(&pbc, 5, info->substream[i].bsid);
448         put_bits(&pbc, 1, 0); /* reserved */
449         put_bits(&pbc, 1, 0); /* asvc */
450         put_bits(&pbc, 3, info->substream[i].bsmod);
451         put_bits(&pbc, 3, info->substream[i].acmod);
452         put_bits(&pbc, 1, info->substream[i].lfeon);
453         put_bits(&pbc, 5, 0); /* reserved */
454         put_bits(&pbc, 4, info->substream[i].num_dep_sub);
455         if (!info->substream[i].num_dep_sub) {
456             put_bits(&pbc, 1, 0); /* reserved */
457             size--;
458         } else {
459             put_bits(&pbc, 9, info->substream[i].chan_loc);
460         }
461     }
462     flush_put_bits(&pbc);
463
464     avio_wb32(pb, size + 8);
465     ffio_wfourcc(pb, "dec3");
466     avio_write(pb, buf, size);
467
468     av_free(buf);
469     av_freep(&track->eac3_priv);
470
471     return size;
472 }
473
474 /**
475  * This function writes extradata "as is".
476  * Extradata must be formatted like a valid atom (with size and tag).
477  */
478 static int mov_write_extradata_tag(AVIOContext *pb, MOVTrack *track)
479 {
480     avio_write(pb, track->enc->extradata, track->enc->extradata_size);
481     return track->enc->extradata_size;
482 }
483
484 static int mov_write_enda_tag(AVIOContext *pb)
485 {
486     avio_wb32(pb, 10);
487     ffio_wfourcc(pb, "enda");
488     avio_wb16(pb, 1); /* little endian */
489     return 10;
490 }
491
492 static int mov_write_enda_tag_be(AVIOContext *pb)
493 {
494   avio_wb32(pb, 10);
495   ffio_wfourcc(pb, "enda");
496   avio_wb16(pb, 0); /* big endian */
497   return 10;
498 }
499
500 static void put_descr(AVIOContext *pb, int tag, unsigned int size)
501 {
502     int i = 3;
503     avio_w8(pb, tag);
504     for (; i > 0; i--)
505         avio_w8(pb, (size >> (7 * i)) | 0x80);
506     avio_w8(pb, size & 0x7F);
507 }
508
509 static unsigned compute_avg_bitrate(MOVTrack *track)
510 {
511     uint64_t size = 0;
512     int i;
513     if (!track->track_duration)
514         return 0;
515     for (i = 0; i < track->entry; i++)
516         size += track->cluster[i].size;
517     return size * 8 * track->timescale / track->track_duration;
518 }
519
520 static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
521 {
522     int64_t pos = avio_tell(pb);
523     int decoder_specific_info_len = track->vos_len ? 5 + track->vos_len : 0;
524     unsigned avg_bitrate;
525
526     avio_wb32(pb, 0); // size
527     ffio_wfourcc(pb, "esds");
528     avio_wb32(pb, 0); // Version
529
530     // ES descriptor
531     put_descr(pb, 0x03, 3 + 5+13 + decoder_specific_info_len + 5+1);
532     avio_wb16(pb, track->track_id);
533     avio_w8(pb, 0x00); // flags (= no flags)
534
535     // DecoderConfig descriptor
536     put_descr(pb, 0x04, 13 + decoder_specific_info_len);
537
538     // Object type indication
539     if ((track->enc->codec_id == AV_CODEC_ID_MP2 ||
540          track->enc->codec_id == AV_CODEC_ID_MP3) &&
541         track->enc->sample_rate > 24000)
542         avio_w8(pb, 0x6B); // 11172-3
543     else
544         avio_w8(pb, ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id));
545
546     // the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
547     // plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
548     if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
549         avio_w8(pb, (0x38 << 2) | 1); // flags (= NeroSubpicStream)
550     else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
551         avio_w8(pb, 0x15); // flags (= Audiostream)
552     else
553         avio_w8(pb, 0x11); // flags (= Visualstream)
554
555     avio_wb24(pb, track->enc->rc_buffer_size >> 3); // Buffersize DB
556
557     avg_bitrate = compute_avg_bitrate(track);
558     // maxbitrate (FIXME should be max rate in any 1 sec window)
559     avio_wb32(pb, FFMAX3(track->enc->bit_rate, track->enc->rc_max_rate, avg_bitrate));
560     avio_wb32(pb, avg_bitrate);
561
562     if (track->vos_len) {
563         // DecoderSpecific info descriptor
564         put_descr(pb, 0x05, track->vos_len);
565         avio_write(pb, track->vos_data, track->vos_len);
566     }
567
568     // SL descriptor
569     put_descr(pb, 0x06, 1);
570     avio_w8(pb, 0x02);
571     return update_size(pb, pos);
572 }
573
574 static int mov_pcm_le_gt16(enum AVCodecID codec_id)
575 {
576     return codec_id == AV_CODEC_ID_PCM_S24LE ||
577            codec_id == AV_CODEC_ID_PCM_S32LE ||
578            codec_id == AV_CODEC_ID_PCM_F32LE ||
579            codec_id == AV_CODEC_ID_PCM_F64LE;
580 }
581
582 static int mov_pcm_be_gt16(enum AVCodecID codec_id)
583 {
584     return codec_id == AV_CODEC_ID_PCM_S24BE ||
585            codec_id == AV_CODEC_ID_PCM_S32BE ||
586            codec_id == AV_CODEC_ID_PCM_F32BE ||
587            codec_id == AV_CODEC_ID_PCM_F64BE;
588 }
589
590 static int mov_write_ms_tag(AVIOContext *pb, MOVTrack *track)
591 {
592     int ret;
593     int64_t pos = avio_tell(pb);
594     avio_wb32(pb, 0);
595     avio_wl32(pb, track->tag); // store it byteswapped
596     track->enc->codec_tag = av_bswap16(track->tag >> 16);
597     if ((ret = ff_put_wav_header(pb, track->enc, 0)) < 0)
598         return ret;
599     return update_size(pb, pos);
600 }
601
602 static int mov_write_wfex_tag(AVIOContext *pb, MOVTrack *track)
603 {
604     int ret;
605     int64_t pos = avio_tell(pb);
606     avio_wb32(pb, 0);
607     ffio_wfourcc(pb, "wfex");
608     if ((ret = ff_put_wav_header(pb, track->enc, FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX)) < 0)
609         return ret;
610     return update_size(pb, pos);
611 }
612
613 static int mov_write_chan_tag(AVIOContext *pb, MOVTrack *track)
614 {
615     uint32_t layout_tag, bitmap;
616     int64_t pos = avio_tell(pb);
617
618     layout_tag = ff_mov_get_channel_layout_tag(track->enc->codec_id,
619                                                track->enc->channel_layout,
620                                                &bitmap);
621     if (!layout_tag) {
622         av_log(track->enc, AV_LOG_WARNING, "not writing 'chan' tag due to "
623                "lack of channel information\n");
624         return 0;
625     }
626
627     if (track->multichannel_as_mono)
628         return 0;
629
630     avio_wb32(pb, 0);           // Size
631     ffio_wfourcc(pb, "chan");   // Type
632     avio_w8(pb, 0);             // Version
633     avio_wb24(pb, 0);           // Flags
634     avio_wb32(pb, layout_tag);  // mChannelLayoutTag
635     avio_wb32(pb, bitmap);      // mChannelBitmap
636     avio_wb32(pb, 0);           // mNumberChannelDescriptions
637
638     return update_size(pb, pos);
639 }
640
641 static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)
642 {
643     int64_t pos = avio_tell(pb);
644
645     avio_wb32(pb, 0);     /* size */
646     ffio_wfourcc(pb, "wave");
647
648     if (track->enc->codec_id != AV_CODEC_ID_QDM2) {
649     avio_wb32(pb, 12);    /* size */
650     ffio_wfourcc(pb, "frma");
651     avio_wl32(pb, track->tag);
652     }
653
654     if (track->enc->codec_id == AV_CODEC_ID_AAC) {
655         /* useless atom needed by mplayer, ipod, not needed by quicktime */
656         avio_wb32(pb, 12); /* size */
657         ffio_wfourcc(pb, "mp4a");
658         avio_wb32(pb, 0);
659         mov_write_esds_tag(pb, track);
660     } else if (mov_pcm_le_gt16(track->enc->codec_id))  {
661       mov_write_enda_tag(pb);
662     } else if (mov_pcm_be_gt16(track->enc->codec_id))  {
663       mov_write_enda_tag_be(pb);
664     } else if (track->enc->codec_id == AV_CODEC_ID_AMR_NB) {
665         mov_write_amr_tag(pb, track);
666     } else if (track->enc->codec_id == AV_CODEC_ID_AC3) {
667         mov_write_ac3_tag(pb, track);
668     } else if (track->enc->codec_id == AV_CODEC_ID_EAC3) {
669         mov_write_eac3_tag(pb, track);
670     } else if (track->enc->codec_id == AV_CODEC_ID_ALAC ||
671                track->enc->codec_id == AV_CODEC_ID_QDM2) {
672         mov_write_extradata_tag(pb, track);
673     } else if (track->enc->codec_id == AV_CODEC_ID_ADPCM_MS ||
674                track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
675         mov_write_ms_tag(pb, track);
676     }
677
678     avio_wb32(pb, 8);     /* size */
679     avio_wb32(pb, 0);     /* null tag */
680
681     return update_size(pb, pos);
682 }
683
684 static int mov_write_dvc1_structs(MOVTrack *track, uint8_t *buf)
685 {
686     uint8_t *unescaped;
687     const uint8_t *start, *next, *end = track->vos_data + track->vos_len;
688     int unescaped_size, seq_found = 0;
689     int level = 0, interlace = 0;
690     int packet_seq   = track->vc1_info.packet_seq;
691     int packet_entry = track->vc1_info.packet_entry;
692     int slices       = track->vc1_info.slices;
693     PutBitContext pbc;
694
695     if (track->start_dts == AV_NOPTS_VALUE) {
696         /* No packets written yet, vc1_info isn't authoritative yet. */
697         /* Assume inline sequence and entry headers. This will be
698          * overwritten at the end if the file is seekable. */
699         packet_seq = packet_entry = 1;
700     }
701
702     unescaped = av_mallocz(track->vos_len + FF_INPUT_BUFFER_PADDING_SIZE);
703     if (!unescaped)
704         return AVERROR(ENOMEM);
705     start = find_next_marker(track->vos_data, end);
706     for (next = start; next < end; start = next) {
707         GetBitContext gb;
708         int size;
709         next = find_next_marker(start + 4, end);
710         size = next - start - 4;
711         if (size <= 0)
712             continue;
713         unescaped_size = vc1_unescape_buffer(start + 4, size, unescaped);
714         init_get_bits(&gb, unescaped, 8 * unescaped_size);
715         if (AV_RB32(start) == VC1_CODE_SEQHDR) {
716             int profile = get_bits(&gb, 2);
717             if (profile != PROFILE_ADVANCED) {
718                 av_free(unescaped);
719                 return AVERROR(ENOSYS);
720             }
721             seq_found = 1;
722             level = get_bits(&gb, 3);
723             /* chromaformat, frmrtq_postproc, bitrtq_postproc, postprocflag,
724              * width, height */
725             skip_bits_long(&gb, 2 + 3 + 5 + 1 + 2*12);
726             skip_bits(&gb, 1); /* broadcast */
727             interlace = get_bits1(&gb);
728             skip_bits(&gb, 4); /* tfcntrflag, finterpflag, reserved, psf */
729         }
730     }
731     if (!seq_found) {
732         av_free(unescaped);
733         return AVERROR(ENOSYS);
734     }
735
736     init_put_bits(&pbc, buf, 7);
737     /* VC1DecSpecStruc */
738     put_bits(&pbc, 4, 12); /* profile - advanced */
739     put_bits(&pbc, 3, level);
740     put_bits(&pbc, 1, 0); /* reserved */
741     /* VC1AdvDecSpecStruc */
742     put_bits(&pbc, 3, level);
743     put_bits(&pbc, 1, 0); /* cbr */
744     put_bits(&pbc, 6, 0); /* reserved */
745     put_bits(&pbc, 1, !interlace); /* no interlace */
746     put_bits(&pbc, 1, !packet_seq); /* no multiple seq */
747     put_bits(&pbc, 1, !packet_entry); /* no multiple entry */
748     put_bits(&pbc, 1, !slices); /* no slice code */
749     put_bits(&pbc, 1, 0); /* no bframe */
750     put_bits(&pbc, 1, 0); /* reserved */
751
752     /* framerate */
753     if (track->st->avg_frame_rate.num > 0 && track->st->avg_frame_rate.den > 0)
754         put_bits32(&pbc, track->st->avg_frame_rate.num / track->st->avg_frame_rate.den);
755     else
756         put_bits32(&pbc, 0xffffffff);
757
758     flush_put_bits(&pbc);
759
760     av_free(unescaped);
761
762     return 0;
763 }
764
765 static int mov_write_dvc1_tag(AVIOContext *pb, MOVTrack *track)
766 {
767     uint8_t buf[7] = { 0 };
768     int ret;
769
770     if ((ret = mov_write_dvc1_structs(track, buf)) < 0)
771         return ret;
772
773     avio_wb32(pb, track->vos_len + 8 + sizeof(buf));
774     ffio_wfourcc(pb, "dvc1");
775     track->vc1_info.struct_offset = avio_tell(pb);
776     avio_write(pb, buf, sizeof(buf));
777     avio_write(pb, track->vos_data, track->vos_len);
778
779     return 0;
780 }
781
782 static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
783 {
784     avio_wb32(pb, track->vos_len + 8);
785     ffio_wfourcc(pb, "glbl");
786     avio_write(pb, track->vos_data, track->vos_len);
787     return 8 + track->vos_len;
788 }
789
790 /**
791  * Compute flags for 'lpcm' tag.
792  * See CoreAudioTypes and AudioStreamBasicDescription at Apple.
793  */
794 static int mov_get_lpcm_flags(enum AVCodecID codec_id)
795 {
796     switch (codec_id) {
797     case AV_CODEC_ID_PCM_F32BE:
798     case AV_CODEC_ID_PCM_F64BE:
799         return 11;
800     case AV_CODEC_ID_PCM_F32LE:
801     case AV_CODEC_ID_PCM_F64LE:
802         return 9;
803     case AV_CODEC_ID_PCM_U8:
804         return 10;
805     case AV_CODEC_ID_PCM_S16BE:
806     case AV_CODEC_ID_PCM_S24BE:
807     case AV_CODEC_ID_PCM_S32BE:
808         return 14;
809     case AV_CODEC_ID_PCM_S8:
810     case AV_CODEC_ID_PCM_S16LE:
811     case AV_CODEC_ID_PCM_S24LE:
812     case AV_CODEC_ID_PCM_S32LE:
813         return 12;
814     default:
815         return 0;
816     }
817 }
818
819 static int get_cluster_duration(MOVTrack *track, int cluster_idx)
820 {
821     int64_t next_dts;
822
823     if (cluster_idx >= track->entry)
824         return 0;
825
826     if (cluster_idx + 1 == track->entry)
827         next_dts = track->track_duration + track->start_dts;
828     else
829         next_dts = track->cluster[cluster_idx + 1].dts;
830
831     next_dts -= track->cluster[cluster_idx].dts;
832
833     av_assert0(next_dts >= 0);
834     av_assert0(next_dts <= INT_MAX);
835
836     return next_dts;
837 }
838
839 static int get_samples_per_packet(MOVTrack *track)
840 {
841     int i, first_duration;
842
843 // return track->enc->frame_size;
844
845     /* use 1 for raw PCM */
846     if (!track->audio_vbr)
847         return 1;
848
849     /* check to see if duration is constant for all clusters */
850     if (!track->entry)
851         return 0;
852     first_duration = get_cluster_duration(track, 0);
853     for (i = 1; i < track->entry; i++) {
854         if (get_cluster_duration(track, i) != first_duration)
855             return 0;
856     }
857     return first_duration;
858 }
859
860 static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)
861 {
862     int64_t pos = avio_tell(pb);
863     int version = 0;
864     uint32_t tag = track->tag;
865
866     if (track->mode == MODE_MOV) {
867         if (track->timescale > UINT16_MAX) {
868             if (mov_get_lpcm_flags(track->enc->codec_id))
869                 tag = AV_RL32("lpcm");
870             version = 2;
871         } else if (track->audio_vbr || mov_pcm_le_gt16(track->enc->codec_id) ||
872                    mov_pcm_be_gt16(track->enc->codec_id) ||
873                    track->enc->codec_id == AV_CODEC_ID_ADPCM_MS ||
874                    track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
875                    track->enc->codec_id == AV_CODEC_ID_QDM2) {
876             version = 1;
877         }
878     }
879
880     avio_wb32(pb, 0); /* size */
881     avio_wl32(pb, tag); // store it byteswapped
882     avio_wb32(pb, 0); /* Reserved */
883     avio_wb16(pb, 0); /* Reserved */
884     avio_wb16(pb, 1); /* Data-reference index, XXX  == 1 */
885
886     /* SoundDescription */
887     avio_wb16(pb, version); /* Version */
888     avio_wb16(pb, 0); /* Revision level */
889     avio_wb32(pb, 0); /* Reserved */
890
891     if (version == 2) {
892         avio_wb16(pb, 3);
893         avio_wb16(pb, 16);
894         avio_wb16(pb, 0xfffe);
895         avio_wb16(pb, 0);
896         avio_wb32(pb, 0x00010000);
897         avio_wb32(pb, 72);
898         avio_wb64(pb, av_double2int(track->enc->sample_rate));
899         avio_wb32(pb, track->enc->channels);
900         avio_wb32(pb, 0x7F000000);
901         avio_wb32(pb, av_get_bits_per_sample(track->enc->codec_id));
902         avio_wb32(pb, mov_get_lpcm_flags(track->enc->codec_id));
903         avio_wb32(pb, track->sample_size);
904         avio_wb32(pb, get_samples_per_packet(track));
905     } else {
906         if (track->mode == MODE_MOV) {
907             avio_wb16(pb, track->enc->channels);
908             if (track->enc->codec_id == AV_CODEC_ID_PCM_U8 ||
909                 track->enc->codec_id == AV_CODEC_ID_PCM_S8)
910                 avio_wb16(pb, 8); /* bits per sample */
911             else
912                 avio_wb16(pb, 16);
913             avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
914         } else { /* reserved for mp4/3gp */
915             avio_wb16(pb, 2);
916             avio_wb16(pb, 16);
917             avio_wb16(pb, 0);
918         }
919
920         avio_wb16(pb, 0); /* packet size (= 0) */
921         avio_wb16(pb, track->enc->sample_rate <= UINT16_MAX ?
922                       track->enc->sample_rate : 0);
923         avio_wb16(pb, 0); /* Reserved */
924     }
925
926     if (version == 1) { /* SoundDescription V1 extended info */
927         if (mov_pcm_le_gt16(track->enc->codec_id) ||
928             mov_pcm_be_gt16(track->enc->codec_id))
929             avio_wb32(pb, 1); /*  must be 1 for  uncompressed formats */
930         else
931             avio_wb32(pb, track->enc->frame_size); /* Samples per packet */
932         avio_wb32(pb, track->sample_size / track->enc->channels); /* Bytes per packet */
933         avio_wb32(pb, track->sample_size); /* Bytes per frame */
934         avio_wb32(pb, 2); /* Bytes per sample */
935     }
936
937     if (track->mode == MODE_MOV &&
938         (track->enc->codec_id == AV_CODEC_ID_AAC           ||
939          track->enc->codec_id == AV_CODEC_ID_AC3           ||
940          track->enc->codec_id == AV_CODEC_ID_EAC3          ||
941          track->enc->codec_id == AV_CODEC_ID_AMR_NB        ||
942          track->enc->codec_id == AV_CODEC_ID_ALAC          ||
943          track->enc->codec_id == AV_CODEC_ID_ADPCM_MS      ||
944          track->enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV ||
945          track->enc->codec_id == AV_CODEC_ID_QDM2          ||
946          (mov_pcm_le_gt16(track->enc->codec_id) && version==1) ||
947          (mov_pcm_be_gt16(track->enc->codec_id) && version==1)))
948         mov_write_wave_tag(pb, track);
949     else if (track->tag == MKTAG('m','p','4','a'))
950         mov_write_esds_tag(pb, track);
951     else if (track->enc->codec_id == AV_CODEC_ID_AMR_NB)
952         mov_write_amr_tag(pb, track);
953     else if (track->enc->codec_id == AV_CODEC_ID_AC3)
954         mov_write_ac3_tag(pb, track);
955     else if (track->enc->codec_id == AV_CODEC_ID_EAC3)
956         mov_write_eac3_tag(pb, track);
957     else if (track->enc->codec_id == AV_CODEC_ID_ALAC)
958         mov_write_extradata_tag(pb, track);
959     else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO)
960         mov_write_wfex_tag(pb, track);
961     else if (track->vos_len > 0)
962         mov_write_glbl_tag(pb, track);
963
964     if (track->mode == MODE_MOV && track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
965         mov_write_chan_tag(pb, track);
966
967     return update_size(pb, pos);
968 }
969
970 static int mov_write_d263_tag(AVIOContext *pb)
971 {
972     avio_wb32(pb, 0xf); /* size */
973     ffio_wfourcc(pb, "d263");
974     ffio_wfourcc(pb, "FFMP");
975     avio_w8(pb, 0); /* decoder version */
976     /* FIXME use AVCodecContext level/profile, when encoder will set values */
977     avio_w8(pb, 0xa); /* level */
978     avio_w8(pb, 0); /* profile */
979     return 0xf;
980 }
981
982 static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
983 {
984     int64_t pos = avio_tell(pb);
985
986     avio_wb32(pb, 0);
987     ffio_wfourcc(pb, "avcC");
988     ff_isom_write_avcc(pb, track->vos_data, track->vos_len);
989     return update_size(pb, pos);
990 }
991
992 static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
993 {
994     int64_t pos = avio_tell(pb);
995
996     avio_wb32(pb, 0);
997     ffio_wfourcc(pb, "hvcC");
998     ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0);
999     return update_size(pb, pos);
1000 }
1001
1002 /* also used by all avid codecs (dv, imx, meridien) and their variants */
1003 static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
1004 {
1005     int i;
1006     avio_wb32(pb, 24); /* size */
1007     ffio_wfourcc(pb, "ACLR");
1008     ffio_wfourcc(pb, "ACLR");
1009     ffio_wfourcc(pb, "0001");
1010     if (track->enc->color_range == AVCOL_RANGE_MPEG) { /* Legal range (16-235) */
1011         avio_wb32(pb, 1); /* Corresponds to 709 in official encoder */
1012     } else { /* Full range (0-255) */
1013         avio_wb32(pb, 2); /* Corresponds to RGB in official encoder */
1014     }
1015     avio_wb32(pb, 0); /* unknown */
1016
1017     avio_wb32(pb, 24); /* size */
1018     ffio_wfourcc(pb, "APRG");
1019     ffio_wfourcc(pb, "APRG");
1020     ffio_wfourcc(pb, "0001");
1021     avio_wb32(pb, 1); /* unknown */
1022     avio_wb32(pb, 0); /* unknown */
1023
1024     avio_wb32(pb, 120); /* size */
1025     ffio_wfourcc(pb, "ARES");
1026     ffio_wfourcc(pb, "ARES");
1027     ffio_wfourcc(pb, "0001");
1028     avio_wb32(pb, AV_RB32(track->vos_data + 0x28)); /* dnxhd cid, some id ? */
1029     avio_wb32(pb, track->enc->width);
1030     /* values below are based on samples created with quicktime and avid codecs */
1031     if (track->vos_data[5] & 2) { // interlaced
1032         avio_wb32(pb, track->enc->height / 2);
1033         avio_wb32(pb, 2); /* unknown */
1034         avio_wb32(pb, 0); /* unknown */
1035         avio_wb32(pb, 4); /* unknown */
1036     } else {
1037         avio_wb32(pb, track->enc->height);
1038         avio_wb32(pb, 1); /* unknown */
1039         avio_wb32(pb, 0); /* unknown */
1040         if (track->enc->height == 1080)
1041             avio_wb32(pb, 5); /* unknown */
1042         else
1043             avio_wb32(pb, 6); /* unknown */
1044     }
1045     /* padding */
1046     for (i = 0; i < 10; i++)
1047         avio_wb64(pb, 0);
1048
1049     /* extra padding for stsd needed */
1050     avio_wb32(pb, 0);
1051     return 0;
1052 }
1053
1054 static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track)
1055 {
1056     int tag = track->enc->codec_tag;
1057
1058     if (!ff_codec_get_tag(ff_mp4_obj_type, track->enc->codec_id))
1059         return 0;
1060
1061     if      (track->enc->codec_id == AV_CODEC_ID_H264)      tag = MKTAG('a','v','c','1');
1062     else if (track->enc->codec_id == AV_CODEC_ID_HEVC)      tag = MKTAG('h','e','v','1');
1063     else if (track->enc->codec_id == AV_CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
1064     else if (track->enc->codec_id == AV_CODEC_ID_EAC3)      tag = MKTAG('e','c','-','3');
1065     else if (track->enc->codec_id == AV_CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
1066     else if (track->enc->codec_id == AV_CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
1067     else if (track->enc->codec_id == AV_CODEC_ID_VC1)       tag = MKTAG('v','c','-','1');
1068     else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)  tag = MKTAG('m','p','4','v');
1069     else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)  tag = MKTAG('m','p','4','a');
1070     else if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE)  tag = MKTAG('m','p','4','s');
1071
1072     return tag;
1073 }
1074
1075 static const AVCodecTag codec_ipod_tags[] = {
1076     { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
1077     { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
1078     { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
1079     { AV_CODEC_ID_ALAC,     MKTAG('a','l','a','c') },
1080     { AV_CODEC_ID_AC3,      MKTAG('a','c','-','3') },
1081     { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
1082     { AV_CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
1083     { AV_CODEC_ID_NONE, 0 },
1084 };
1085
1086 static int ipod_get_codec_tag(AVFormatContext *s, MOVTrack *track)
1087 {
1088     int tag = track->enc->codec_tag;
1089
1090     // keep original tag for subs, ipod supports both formats
1091     if (!(track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1092           (tag == MKTAG('t', 'x', '3', 'g') ||
1093            tag == MKTAG('t', 'e', 'x', 't'))))
1094         tag = ff_codec_get_tag(codec_ipod_tags, track->enc->codec_id);
1095
1096     if (!av_match_ext(s->filename, "m4a") &&
1097         !av_match_ext(s->filename, "m4b") &&
1098         !av_match_ext(s->filename, "m4v"))
1099         av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a, .m4v nor  .m4b "
1100                "Quicktime/Ipod might not play the file\n");
1101
1102     return tag;
1103 }
1104
1105 static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track)
1106 {
1107     int tag;
1108
1109     if (track->enc->width == 720) { /* SD */
1110         if (track->enc->height == 480) { /* NTSC */
1111             if  (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','n');
1112             else                                            tag = MKTAG('d','v','c',' ');
1113        }else if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) tag = MKTAG('d','v','5','p');
1114         else if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P) tag = MKTAG('d','v','c','p');
1115         else                                                tag = MKTAG('d','v','p','p');
1116     } else if (track->enc->height == 720) { /* HD 720 line */
1117         if  (track->st->time_base.den == 50)                tag = MKTAG('d','v','h','q');
1118         else                                                tag = MKTAG('d','v','h','p');
1119     } else if (track->enc->height == 1080) { /* HD 1080 line */
1120         if  (track->st->time_base.den == 25)                tag = MKTAG('d','v','h','5');
1121         else                                                tag = MKTAG('d','v','h','6');
1122     } else {
1123         av_log(s, AV_LOG_ERROR, "unsupported height for dv codec\n");
1124         return 0;
1125     }
1126
1127     return tag;
1128 }
1129
1130 static AVRational find_fps(AVFormatContext *s, AVStream *st)
1131 {
1132     AVRational rate = {st->codec->time_base.den, st->codec->time_base.num};
1133     /* if the codec time base makes no sense, try to fallback on stream frame rate */
1134     if (av_timecode_check_frame_rate(rate) < 0) {
1135         av_log(s, AV_LOG_DEBUG, "timecode: tbc=%d/%d invalid, fallback on %d/%d\n",
1136                rate.num, rate.den, st->avg_frame_rate.num, st->avg_frame_rate.den);
1137         rate = st->avg_frame_rate;
1138     }
1139
1140     return rate;
1141 }
1142
1143 static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
1144 {
1145     int tag = track->enc->codec_tag;
1146     int interlaced = track->enc->field_order > AV_FIELD_PROGRESSIVE;
1147     AVStream *st = track->st;
1148     int rate = av_q2d(find_fps(s, st));
1149
1150     if (!tag)
1151         tag = MKTAG('m', '2', 'v', '1'); //fallback tag
1152
1153     if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P) {
1154         if (track->enc->width == 1280 && track->enc->height == 720) {
1155             if (!interlaced) {
1156                 if      (rate == 24) tag = MKTAG('x','d','v','4');
1157                 else if (rate == 25) tag = MKTAG('x','d','v','5');
1158                 else if (rate == 30) tag = MKTAG('x','d','v','1');
1159                 else if (rate == 50) tag = MKTAG('x','d','v','a');
1160                 else if (rate == 60) tag = MKTAG('x','d','v','9');
1161             }
1162         } else if (track->enc->width == 1440 && track->enc->height == 1080) {
1163             if (!interlaced) {
1164                 if      (rate == 24) tag = MKTAG('x','d','v','6');
1165                 else if (rate == 25) tag = MKTAG('x','d','v','7');
1166                 else if (rate == 30) tag = MKTAG('x','d','v','8');
1167             } else {
1168                 if      (rate == 25) tag = MKTAG('x','d','v','3');
1169                 else if (rate == 30) tag = MKTAG('x','d','v','2');
1170             }
1171         } else if (track->enc->width == 1920 && track->enc->height == 1080) {
1172             if (!interlaced) {
1173                 if      (rate == 24) tag = MKTAG('x','d','v','d');
1174                 else if (rate == 25) tag = MKTAG('x','d','v','e');
1175                 else if (rate == 30) tag = MKTAG('x','d','v','f');
1176             } else {
1177                 if      (rate == 25) tag = MKTAG('x','d','v','c');
1178                 else if (rate == 30) tag = MKTAG('x','d','v','b');
1179             }
1180         }
1181     } else if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) {
1182         if (track->enc->width == 1280 && track->enc->height == 720) {
1183             if (!interlaced) {
1184                 if      (rate == 24) tag = MKTAG('x','d','5','4');
1185                 else if (rate == 25) tag = MKTAG('x','d','5','5');
1186                 else if (rate == 30) tag = MKTAG('x','d','5','1');
1187                 else if (rate == 50) tag = MKTAG('x','d','5','a');
1188                 else if (rate == 60) tag = MKTAG('x','d','5','9');
1189             }
1190         } else if (track->enc->width == 1920 && track->enc->height == 1080) {
1191             if (!interlaced) {
1192                 if      (rate == 24) tag = MKTAG('x','d','5','d');
1193                 else if (rate == 25) tag = MKTAG('x','d','5','e');
1194                 else if (rate == 30) tag = MKTAG('x','d','5','f');
1195             } else {
1196                 if      (rate == 25) tag = MKTAG('x','d','5','c');
1197                 else if (rate == 30) tag = MKTAG('x','d','5','b');
1198             }
1199         }
1200     }
1201
1202     return tag;
1203 }
1204
1205 static int mov_get_h264_codec_tag(AVFormatContext *s, MOVTrack *track)
1206 {
1207     int tag = track->enc->codec_tag;
1208     int interlaced = track->enc->field_order > AV_FIELD_PROGRESSIVE;
1209     AVStream *st = track->st;
1210     int rate = av_q2d(find_fps(s, st));
1211
1212     if (!tag)
1213         tag = MKTAG('a', 'v', 'c', 'i'); //fallback tag
1214
1215     if (track->enc->pix_fmt == AV_PIX_FMT_YUV420P10) {
1216         if (track->enc->width == 960 && track->enc->height == 720) {
1217             if (!interlaced) {
1218                 if      (rate == 24) tag = MKTAG('a','i','5','p');
1219                 else if (rate == 25) tag = MKTAG('a','i','5','q');
1220                 else if (rate == 30) tag = MKTAG('a','i','5','p');
1221                 else if (rate == 50) tag = MKTAG('a','i','5','q');
1222                 else if (rate == 60) tag = MKTAG('a','i','5','p');
1223             }
1224         } else if (track->enc->width == 1440 && track->enc->height == 1080) {
1225             if (!interlaced) {
1226                 if      (rate == 24) tag = MKTAG('a','i','5','3');
1227                 else if (rate == 25) tag = MKTAG('a','i','5','2');
1228                 else if (rate == 30) tag = MKTAG('a','i','5','3');
1229             } else {
1230                 if      (rate == 50) tag = MKTAG('a','i','5','5');
1231                 else if (rate == 60) tag = MKTAG('a','i','5','6');
1232             }
1233         }
1234     } else if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P10) {
1235         if (track->enc->width == 1280 && track->enc->height == 720) {
1236             if (!interlaced) {
1237                 if      (rate == 24) tag = MKTAG('a','i','1','p');
1238                 else if (rate == 25) tag = MKTAG('a','i','1','q');
1239                 else if (rate == 30) tag = MKTAG('a','i','1','p');
1240                 else if (rate == 50) tag = MKTAG('a','i','1','q');
1241                 else if (rate == 60) tag = MKTAG('a','i','1','p');
1242             }
1243         } else if (track->enc->width == 1920 && track->enc->height == 1080) {
1244             if (!interlaced) {
1245                 if      (rate == 24) tag = MKTAG('a','i','1','3');
1246                 else if (rate == 25) tag = MKTAG('a','i','1','2');
1247                 else if (rate == 30) tag = MKTAG('a','i','1','3');
1248             } else {
1249                 if      (rate == 25) tag = MKTAG('a','i','1','5');
1250                 else if (rate == 50) tag = MKTAG('a','i','1','5');
1251                 else if (rate == 60) tag = MKTAG('a','i','1','6');
1252             }
1253         }
1254     }
1255
1256     return tag;
1257 }
1258
1259 static const struct {
1260     enum AVPixelFormat pix_fmt;
1261     uint32_t tag;
1262     unsigned bps;
1263 } mov_pix_fmt_tags[] = {
1264     { AV_PIX_FMT_YUYV422, MKTAG('y','u','v','2'),  0 },
1265     { AV_PIX_FMT_YUYV422, MKTAG('y','u','v','s'),  0 },
1266     { AV_PIX_FMT_UYVY422, MKTAG('2','v','u','y'),  0 },
1267     { AV_PIX_FMT_RGB555BE,MKTAG('r','a','w',' '), 16 },
1268     { AV_PIX_FMT_RGB555LE,MKTAG('L','5','5','5'), 16 },
1269     { AV_PIX_FMT_RGB565LE,MKTAG('L','5','6','5'), 16 },
1270     { AV_PIX_FMT_RGB565BE,MKTAG('B','5','6','5'), 16 },
1271     { AV_PIX_FMT_GRAY16BE,MKTAG('b','1','6','g'), 16 },
1272     { AV_PIX_FMT_RGB24,   MKTAG('r','a','w',' '), 24 },
1273     { AV_PIX_FMT_BGR24,   MKTAG('2','4','B','G'), 24 },
1274     { AV_PIX_FMT_ARGB,    MKTAG('r','a','w',' '), 32 },
1275     { AV_PIX_FMT_BGRA,    MKTAG('B','G','R','A'), 32 },
1276     { AV_PIX_FMT_RGBA,    MKTAG('R','G','B','A'), 32 },
1277     { AV_PIX_FMT_ABGR,    MKTAG('A','B','G','R'), 32 },
1278     { AV_PIX_FMT_RGB48BE, MKTAG('b','4','8','r'), 48 },
1279 };
1280
1281 static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)
1282 {
1283     int tag = track->enc->codec_tag;
1284     int i;
1285     enum AVPixelFormat pix_fmt;
1286
1287     for (i = 0; i < FF_ARRAY_ELEMS(mov_pix_fmt_tags); i++) {
1288         if (track->enc->pix_fmt == mov_pix_fmt_tags[i].pix_fmt) {
1289             tag = mov_pix_fmt_tags[i].tag;
1290             track->enc->bits_per_coded_sample = mov_pix_fmt_tags[i].bps;
1291             if (track->enc->codec_tag == mov_pix_fmt_tags[i].tag)
1292                 break;
1293         }
1294     }
1295
1296     pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
1297                                   track->enc->bits_per_coded_sample);
1298     if (tag == MKTAG('r','a','w',' ') &&
1299         track->enc->pix_fmt != pix_fmt &&
1300         track->enc->pix_fmt != AV_PIX_FMT_NONE)
1301         av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to mov, output file will be unreadable\n",
1302                av_get_pix_fmt_name(track->enc->pix_fmt));
1303     return tag;
1304 }
1305
1306 static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
1307 {
1308     int tag = track->enc->codec_tag;
1309
1310     if (!tag || (track->enc->strict_std_compliance >= FF_COMPLIANCE_NORMAL &&
1311                  (track->enc->codec_id == AV_CODEC_ID_DVVIDEO ||
1312                   track->enc->codec_id == AV_CODEC_ID_RAWVIDEO ||
1313                   track->enc->codec_id == AV_CODEC_ID_H263 ||
1314                   track->enc->codec_id == AV_CODEC_ID_H264 ||
1315                   track->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
1316                   av_get_bits_per_sample(track->enc->codec_id)))) { // pcm audio
1317         if (track->enc->codec_id == AV_CODEC_ID_DVVIDEO)
1318             tag = mov_get_dv_codec_tag(s, track);
1319         else if (track->enc->codec_id == AV_CODEC_ID_RAWVIDEO)
1320             tag = mov_get_rawvideo_codec_tag(s, track);
1321         else if (track->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO)
1322             tag = mov_get_mpeg2_xdcam_codec_tag(s, track);
1323         else if (track->enc->codec_id == AV_CODEC_ID_H264)
1324             tag = mov_get_h264_codec_tag(s, track);
1325         else if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1326             tag = ff_codec_get_tag(ff_codec_movvideo_tags, track->enc->codec_id);
1327             if (!tag) { // if no mac fcc found, try with Microsoft tags
1328                 tag = ff_codec_get_tag(ff_codec_bmp_tags, track->enc->codec_id);
1329                 if (tag)
1330                     av_log(s, AV_LOG_WARNING, "Using MS style video codec tag, "
1331                            "the file may be unplayable!\n");
1332             }
1333         } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
1334             tag = ff_codec_get_tag(ff_codec_movaudio_tags, track->enc->codec_id);
1335             if (!tag) { // if no mac fcc found, try with Microsoft tags
1336                 int ms_tag = ff_codec_get_tag(ff_codec_wav_tags, track->enc->codec_id);
1337                 if (ms_tag) {
1338                     tag = MKTAG('m', 's', ((ms_tag >> 8) & 0xff), (ms_tag & 0xff));
1339                     av_log(s, AV_LOG_WARNING, "Using MS style audio codec tag, "
1340                            "the file may be unplayable!\n");
1341                 }
1342             }
1343         } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
1344             tag = ff_codec_get_tag(ff_codec_movsubtitle_tags, track->enc->codec_id);
1345     }
1346
1347     return tag;
1348 }
1349
1350 static const AVCodecTag codec_3gp_tags[] = {
1351     { AV_CODEC_ID_H263,     MKTAG('s','2','6','3') },
1352     { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
1353     { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
1354     { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
1355     { AV_CODEC_ID_AMR_NB,   MKTAG('s','a','m','r') },
1356     { AV_CODEC_ID_AMR_WB,   MKTAG('s','a','w','b') },
1357     { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
1358     { AV_CODEC_ID_NONE, 0 },
1359 };
1360
1361 static const AVCodecTag codec_f4v_tags[] = { // XXX: add GIF/PNG/JPEG?
1362     { AV_CODEC_ID_MP3,    MKTAG('.','m','p','3') },
1363     { AV_CODEC_ID_AAC,    MKTAG('m','p','4','a') },
1364     { AV_CODEC_ID_H264,   MKTAG('a','v','c','1') },
1365     { AV_CODEC_ID_VP6A,   MKTAG('V','P','6','A') },
1366     { AV_CODEC_ID_VP6F,   MKTAG('V','P','6','F') },
1367     { AV_CODEC_ID_NONE, 0 },
1368 };
1369
1370 static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
1371 {
1372     int tag;
1373
1374     if (track->mode == MODE_MP4 || track->mode == MODE_PSP)
1375         tag = mp4_get_codec_tag(s, track);
1376     else if (track->mode == MODE_ISM) {
1377         tag = mp4_get_codec_tag(s, track);
1378         if (!tag && track->enc->codec_id == AV_CODEC_ID_WMAPRO)
1379             tag = MKTAG('w', 'm', 'a', ' ');
1380     } else if (track->mode == MODE_IPOD)
1381         tag = ipod_get_codec_tag(s, track);
1382     else if (track->mode & MODE_3GP)
1383         tag = ff_codec_get_tag(codec_3gp_tags, track->enc->codec_id);
1384     else if (track->mode == MODE_F4V)
1385         tag = ff_codec_get_tag(codec_f4v_tags, track->enc->codec_id);
1386     else
1387         tag = mov_get_codec_tag(s, track);
1388
1389     return tag;
1390 }
1391
1392 /** Write uuid atom.
1393  * Needed to make file play in iPods running newest firmware
1394  * goes after avcC atom in moov.trak.mdia.minf.stbl.stsd.avc1
1395  */
1396 static int mov_write_uuid_tag_ipod(AVIOContext *pb)
1397 {
1398     avio_wb32(pb, 28);
1399     ffio_wfourcc(pb, "uuid");
1400     avio_wb32(pb, 0x6b6840f2);
1401     avio_wb32(pb, 0x5f244fc5);
1402     avio_wb32(pb, 0xba39a51b);
1403     avio_wb32(pb, 0xcf0323f3);
1404     avio_wb32(pb, 0x0);
1405     return 28;
1406 }
1407
1408 static const uint16_t fiel_data[] = {
1409     0x0000, 0x0100, 0x0201, 0x0206, 0x0209, 0x020e
1410 };
1411
1412 static int mov_write_fiel_tag(AVIOContext *pb, MOVTrack *track)
1413 {
1414     unsigned mov_field_order = 0;
1415     if (track->enc->field_order < FF_ARRAY_ELEMS(fiel_data))
1416         mov_field_order = fiel_data[track->enc->field_order];
1417     else
1418         return 0;
1419     avio_wb32(pb, 10);
1420     ffio_wfourcc(pb, "fiel");
1421     avio_wb16(pb, mov_field_order);
1422     return 10;
1423 }
1424
1425 static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)
1426 {
1427     int64_t pos = avio_tell(pb);
1428     avio_wb32(pb, 0);    /* size */
1429     avio_wl32(pb, track->tag); // store it byteswapped
1430     avio_wb32(pb, 0);    /* Reserved */
1431     avio_wb16(pb, 0);    /* Reserved */
1432     avio_wb16(pb, 1);    /* Data-reference index */
1433
1434     if (track->enc->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
1435         mov_write_esds_tag(pb, track);
1436     else if (track->enc->extradata_size)
1437         avio_write(pb, track->enc->extradata, track->enc->extradata_size);
1438
1439     return update_size(pb, pos);
1440 }
1441
1442 static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)
1443 {
1444     AVRational sar;
1445     av_reduce(&sar.num, &sar.den, track->enc->sample_aspect_ratio.num,
1446               track->enc->sample_aspect_ratio.den, INT_MAX);
1447
1448     avio_wb32(pb, 16);
1449     ffio_wfourcc(pb, "pasp");
1450     avio_wb32(pb, sar.num);
1451     avio_wb32(pb, sar.den);
1452     return 16;
1453 }
1454
1455 static void find_compressor(char * compressor_name, int len, MOVTrack *track)
1456 {
1457     AVDictionaryEntry *encoder;
1458     int xdcam_res =  (track->enc->width == 1280 && track->enc->height == 720)
1459                   || (track->enc->width == 1440 && track->enc->height == 1080)
1460                   || (track->enc->width == 1920 && track->enc->height == 1080);
1461
1462     if (track->mode == MODE_MOV &&
1463         (encoder = av_dict_get(track->st->metadata, "encoder", NULL, 0))) {
1464         av_strlcpy(compressor_name, encoder->value, 32);
1465     } else if (track->enc->codec_id == AV_CODEC_ID_MPEG2VIDEO && xdcam_res) {
1466         int interlaced = track->enc->field_order > AV_FIELD_PROGRESSIVE;
1467         AVStream *st = track->st;
1468         int rate = av_q2d(find_fps(NULL, st));
1469         av_strlcatf(compressor_name, len, "XDCAM");
1470         if (track->enc->pix_fmt == AV_PIX_FMT_YUV422P) {
1471             av_strlcatf(compressor_name, len, " HD422");
1472         } else if(track->enc->width == 1440) {
1473             av_strlcatf(compressor_name, len, " HD");
1474         } else
1475             av_strlcatf(compressor_name, len, " EX");
1476
1477         av_strlcatf(compressor_name, len, " %d%c", track->enc->height, interlaced ? 'i' : 'p');
1478
1479         av_strlcatf(compressor_name, len, "%d", rate * (interlaced + 1));
1480     }
1481 }
1482
1483 static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
1484 {
1485     int64_t pos = avio_tell(pb);
1486     char compressor_name[32] = { 0 };
1487
1488     avio_wb32(pb, 0); /* size */
1489     avio_wl32(pb, track->tag); // store it byteswapped
1490     avio_wb32(pb, 0); /* Reserved */
1491     avio_wb16(pb, 0); /* Reserved */
1492     avio_wb16(pb, 1); /* Data-reference index */
1493
1494     avio_wb16(pb, 0); /* Codec stream version */
1495     avio_wb16(pb, 0); /* Codec stream revision (=0) */
1496     if (track->mode == MODE_MOV) {
1497         ffio_wfourcc(pb, "FFMP"); /* Vendor */
1498         if (track->enc->codec_id == AV_CODEC_ID_RAWVIDEO) {
1499             avio_wb32(pb, 0); /* Temporal Quality */
1500             avio_wb32(pb, 0x400); /* Spatial Quality = lossless*/
1501         } else {
1502             avio_wb32(pb, 0x200); /* Temporal Quality = normal */
1503             avio_wb32(pb, 0x200); /* Spatial Quality = normal */
1504         }
1505     } else {
1506         avio_wb32(pb, 0); /* Reserved */
1507         avio_wb32(pb, 0); /* Reserved */
1508         avio_wb32(pb, 0); /* Reserved */
1509     }
1510     avio_wb16(pb, track->enc->width); /* Video width */
1511     avio_wb16(pb, track->height); /* Video height */
1512     avio_wb32(pb, 0x00480000); /* Horizontal resolution 72dpi */
1513     avio_wb32(pb, 0x00480000); /* Vertical resolution 72dpi */
1514     avio_wb32(pb, 0); /* Data size (= 0) */
1515     avio_wb16(pb, 1); /* Frame count (= 1) */
1516
1517     /* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
1518     find_compressor(compressor_name, 32, track);
1519     avio_w8(pb, strlen(compressor_name));
1520     avio_write(pb, compressor_name, 31);
1521
1522     if (track->mode == MODE_MOV && track->enc->bits_per_coded_sample)
1523         avio_wb16(pb, track->enc->bits_per_coded_sample);
1524     else
1525         avio_wb16(pb, 0x18); /* Reserved */
1526     avio_wb16(pb, 0xffff); /* Reserved */
1527     if (track->tag == MKTAG('m','p','4','v'))
1528         mov_write_esds_tag(pb, track);
1529     else if (track->enc->codec_id == AV_CODEC_ID_H263)
1530         mov_write_d263_tag(pb);
1531     else if (track->enc->codec_id == AV_CODEC_ID_AVUI ||
1532             track->enc->codec_id == AV_CODEC_ID_SVQ3) {
1533         mov_write_extradata_tag(pb, track);
1534         avio_wb32(pb, 0);
1535     } else if (track->enc->codec_id == AV_CODEC_ID_DNXHD)
1536         mov_write_avid_tag(pb, track);
1537     else if (track->enc->codec_id == AV_CODEC_ID_HEVC)
1538         mov_write_hvcc_tag(pb, track);
1539     else if (track->enc->codec_id == AV_CODEC_ID_H264 && !TAG_IS_AVCI(track->tag)) {
1540         mov_write_avcc_tag(pb, track);
1541         if (track->mode == MODE_IPOD)
1542             mov_write_uuid_tag_ipod(pb);
1543     } else if (track->enc->codec_id == AV_CODEC_ID_VC1 && track->vos_len > 0)
1544         mov_write_dvc1_tag(pb, track);
1545     else if (track->enc->codec_id == AV_CODEC_ID_VP6F ||
1546              track->enc->codec_id == AV_CODEC_ID_VP6A) {
1547         /* Don't write any potential extradata here - the cropping
1548          * is signalled via the normal width/height fields. */
1549     } else if (track->vos_len > 0)
1550         mov_write_glbl_tag(pb, track);
1551
1552     if (track->enc->codec_id != AV_CODEC_ID_H264 &&
1553         track->enc->codec_id != AV_CODEC_ID_MPEG4 &&
1554         track->enc->codec_id != AV_CODEC_ID_DNXHD)
1555         if (track->enc->field_order != AV_FIELD_UNKNOWN)
1556             mov_write_fiel_tag(pb, track);
1557
1558     if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&
1559         track->enc->sample_aspect_ratio.den != track->enc->sample_aspect_ratio.num) {
1560         mov_write_pasp_tag(pb, track);
1561     }
1562
1563     return update_size(pb, pos);
1564 }
1565
1566 static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)
1567 {
1568     int64_t pos = avio_tell(pb);
1569     avio_wb32(pb, 0); /* size */
1570     ffio_wfourcc(pb, "rtp ");
1571     avio_wb32(pb, 0); /* Reserved */
1572     avio_wb16(pb, 0); /* Reserved */
1573     avio_wb16(pb, 1); /* Data-reference index */
1574
1575     avio_wb16(pb, 1); /* Hint track version */
1576     avio_wb16(pb, 1); /* Highest compatible version */
1577     avio_wb32(pb, track->max_packet_size); /* Max packet size */
1578
1579     avio_wb32(pb, 12); /* size */
1580     ffio_wfourcc(pb, "tims");
1581     avio_wb32(pb, track->timescale);
1582
1583     return update_size(pb, pos);
1584 }
1585
1586 static int mov_write_source_reference_tag(AVIOContext *pb, MOVTrack *track, const char *reel_name)
1587 {
1588     uint64_t str_size =strlen(reel_name);
1589     int64_t pos = avio_tell(pb);
1590
1591     if (str_size >= UINT16_MAX){
1592         av_log(NULL, AV_LOG_ERROR, "reel_name length %"PRIu64" is too large\n", str_size);
1593         avio_wb16(pb, 0);
1594         return AVERROR(EINVAL);
1595     }
1596
1597     avio_wb32(pb, 0);                              /* size */
1598     ffio_wfourcc(pb, "name");                      /* Data format */
1599     avio_wb16(pb, str_size);                       /* string size */
1600     avio_wb16(pb, track->language);                /* langcode */
1601     avio_write(pb, reel_name, str_size);           /* reel name */
1602     return update_size(pb,pos);
1603 }
1604
1605 static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track)
1606 {
1607     int64_t pos = avio_tell(pb);
1608 #if 1
1609     int frame_duration = av_rescale(track->timescale, track->enc->time_base.num, track->enc->time_base.den);
1610     int nb_frames = 1.0/av_q2d(track->enc->time_base) + 0.5;
1611     AVDictionaryEntry *t = NULL;
1612
1613     if (nb_frames > 255) {
1614         av_log(NULL, AV_LOG_ERROR, "fps %d is too large\n", nb_frames);
1615         return AVERROR(EINVAL);
1616     }
1617
1618     avio_wb32(pb, 0); /* size */
1619     ffio_wfourcc(pb, "tmcd");               /* Data format */
1620     avio_wb32(pb, 0);                       /* Reserved */
1621     avio_wb32(pb, 1);                       /* Data reference index */
1622     avio_wb32(pb, 0);                       /* Flags */
1623     avio_wb32(pb, track->timecode_flags);   /* Flags (timecode) */
1624     avio_wb32(pb, track->timescale);        /* Timescale */
1625     avio_wb32(pb, frame_duration);          /* Frame duration */
1626     avio_w8(pb, nb_frames);                 /* Number of frames */
1627     avio_w8(pb, 0);                         /* Reserved */
1628
1629     if (track->st)
1630         t = av_dict_get(track->st->metadata, "reel_name", NULL, 0);
1631
1632     if (t && utf8len(t->value))
1633         mov_write_source_reference_tag(pb, track, t->value);
1634     else
1635         avio_wb16(pb, 0); /* zero size */
1636 #else
1637
1638     avio_wb32(pb, 0); /* size */
1639     ffio_wfourcc(pb, "tmcd");               /* Data format */
1640     avio_wb32(pb, 0);                       /* Reserved */
1641     avio_wb32(pb, 1);                       /* Data reference index */
1642     if (track->enc->extradata_size)
1643         avio_write(pb, track->enc->extradata, track->enc->extradata_size);
1644 #endif
1645     return update_size(pb, pos);
1646 }
1647
1648 static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track)
1649 {
1650     int64_t pos = avio_tell(pb);
1651     avio_wb32(pb, 0); /* size */
1652     ffio_wfourcc(pb, "stsd");
1653     avio_wb32(pb, 0); /* version & flags */
1654     avio_wb32(pb, 1); /* entry count */
1655     if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
1656         mov_write_video_tag(pb, track);
1657     else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
1658         mov_write_audio_tag(pb, track);
1659     else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
1660         mov_write_subtitle_tag(pb, track);
1661     else if (track->enc->codec_tag == MKTAG('r','t','p',' '))
1662         mov_write_rtp_tag(pb, track);
1663     else if (track->enc->codec_tag == MKTAG('t','m','c','d'))
1664         mov_write_tmcd_tag(pb, track);
1665     return update_size(pb, pos);
1666 }
1667
1668 static int mov_write_ctts_tag(AVIOContext *pb, MOVTrack *track)
1669 {
1670     MOVStts *ctts_entries;
1671     uint32_t entries = 0;
1672     uint32_t atom_size;
1673     int i;
1674
1675     ctts_entries = av_malloc_array((track->entry + 1), sizeof(*ctts_entries)); /* worst case */
1676     ctts_entries[0].count = 1;
1677     ctts_entries[0].duration = track->cluster[0].cts;
1678     for (i = 1; i < track->entry; i++) {
1679         if (track->cluster[i].cts == ctts_entries[entries].duration) {
1680             ctts_entries[entries].count++; /* compress */
1681         } else {
1682             entries++;
1683             ctts_entries[entries].duration = track->cluster[i].cts;
1684             ctts_entries[entries].count = 1;
1685         }
1686     }
1687     entries++; /* last one */
1688     atom_size = 16 + (entries * 8);
1689     avio_wb32(pb, atom_size); /* size */
1690     ffio_wfourcc(pb, "ctts");
1691     avio_wb32(pb, 0); /* version & flags */
1692     avio_wb32(pb, entries); /* entry count */
1693     for (i = 0; i < entries; i++) {
1694         avio_wb32(pb, ctts_entries[i].count);
1695         avio_wb32(pb, ctts_entries[i].duration);
1696     }
1697     av_free(ctts_entries);
1698     return atom_size;
1699 }
1700
1701 /* Time to sample atom */
1702 static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
1703 {
1704     MOVStts *stts_entries;
1705     uint32_t entries = -1;
1706     uint32_t atom_size;
1707     int i;
1708
1709     if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO && !track->audio_vbr) {
1710         stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */
1711         stts_entries[0].count = track->sample_count;
1712         stts_entries[0].duration = 1;
1713         entries = 1;
1714     } else {
1715         stts_entries = track->entry ?
1716                        av_malloc_array(track->entry, sizeof(*stts_entries)) : /* worst case */
1717                        NULL;
1718         for (i = 0; i < track->entry; i++) {
1719             int duration = get_cluster_duration(track, i);
1720             if (i && duration == stts_entries[entries].duration) {
1721                 stts_entries[entries].count++; /* compress */
1722             } else {
1723                 entries++;
1724                 stts_entries[entries].duration = duration;
1725                 stts_entries[entries].count = 1;
1726             }
1727         }
1728         entries++; /* last one */
1729     }
1730     atom_size = 16 + (entries * 8);
1731     avio_wb32(pb, atom_size); /* size */
1732     ffio_wfourcc(pb, "stts");
1733     avio_wb32(pb, 0); /* version & flags */
1734     avio_wb32(pb, entries); /* entry count */
1735     for (i = 0; i < entries; i++) {
1736         avio_wb32(pb, stts_entries[i].count);
1737         avio_wb32(pb, stts_entries[i].duration);
1738     }
1739     av_free(stts_entries);
1740     return atom_size;
1741 }
1742
1743 static int mov_write_dref_tag(AVIOContext *pb)
1744 {
1745     avio_wb32(pb, 28); /* size */
1746     ffio_wfourcc(pb, "dref");
1747     avio_wb32(pb, 0); /* version & flags */
1748     avio_wb32(pb, 1); /* entry count */
1749
1750     avio_wb32(pb, 0xc); /* size */
1751     //FIXME add the alis and rsrc atom
1752     ffio_wfourcc(pb, "url ");
1753     avio_wb32(pb, 1); /* version & flags */
1754
1755     return 28;
1756 }
1757
1758 static int mov_write_stbl_tag(AVIOContext *pb, MOVTrack *track)
1759 {
1760     int64_t pos = avio_tell(pb);
1761     avio_wb32(pb, 0); /* size */
1762     ffio_wfourcc(pb, "stbl");
1763     mov_write_stsd_tag(pb, track);
1764     mov_write_stts_tag(pb, track);
1765     if ((track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
1766          track->enc->codec_tag == MKTAG('r','t','p',' ')) &&
1767         track->has_keyframes && track->has_keyframes < track->entry)
1768         mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
1769     if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
1770         mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
1771     if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO &&
1772         track->flags & MOV_TRACK_CTTS)
1773         mov_write_ctts_tag(pb, track);
1774     mov_write_stsc_tag(pb, track);
1775     mov_write_stsz_tag(pb, track);
1776     mov_write_stco_tag(pb, track);
1777     return update_size(pb, pos);
1778 }
1779
1780 static int mov_write_dinf_tag(AVIOContext *pb)
1781 {
1782     int64_t pos = avio_tell(pb);
1783     avio_wb32(pb, 0); /* size */
1784     ffio_wfourcc(pb, "dinf");
1785     mov_write_dref_tag(pb);
1786     return update_size(pb, pos);
1787 }
1788
1789 static int mov_write_nmhd_tag(AVIOContext *pb)
1790 {
1791     avio_wb32(pb, 12);
1792     ffio_wfourcc(pb, "nmhd");
1793     avio_wb32(pb, 0);
1794     return 12;
1795 }
1796
1797 static int mov_write_tcmi_tag(AVIOContext *pb, MOVTrack *track)
1798 {
1799     int64_t pos = avio_tell(pb);
1800     const char *font = "Lucida Grande";
1801     avio_wb32(pb, 0);                   /* size */
1802     ffio_wfourcc(pb, "tcmi");           /* timecode media information atom */
1803     avio_wb32(pb, 0);                   /* version & flags */
1804     avio_wb16(pb, 0);                   /* text font */
1805     avio_wb16(pb, 0);                   /* text face */
1806     avio_wb16(pb, 12);                  /* text size */
1807     avio_wb16(pb, 0);                   /* (unknown, not in the QT specs...) */
1808     avio_wb16(pb, 0x0000);              /* text color (red) */
1809     avio_wb16(pb, 0x0000);              /* text color (green) */
1810     avio_wb16(pb, 0x0000);              /* text color (blue) */
1811     avio_wb16(pb, 0xffff);              /* background color (red) */
1812     avio_wb16(pb, 0xffff);              /* background color (green) */
1813     avio_wb16(pb, 0xffff);              /* background color (blue) */
1814     avio_w8(pb, strlen(font));          /* font len (part of the pascal string) */
1815     avio_write(pb, font, strlen(font)); /* font name */
1816     return update_size(pb, pos);
1817 }
1818
1819 static int mov_write_gmhd_tag(AVIOContext *pb, MOVTrack *track)
1820 {
1821     int64_t pos = avio_tell(pb);
1822     avio_wb32(pb, 0);      /* size */
1823     ffio_wfourcc(pb, "gmhd");
1824     avio_wb32(pb, 0x18);   /* gmin size */
1825     ffio_wfourcc(pb, "gmin");/* generic media info */
1826     avio_wb32(pb, 0);      /* version & flags */
1827     avio_wb16(pb, 0x40);   /* graphics mode = */
1828     avio_wb16(pb, 0x8000); /* opColor (r?) */
1829     avio_wb16(pb, 0x8000); /* opColor (g?) */
1830     avio_wb16(pb, 0x8000); /* opColor (b?) */
1831     avio_wb16(pb, 0);      /* balance */
1832     avio_wb16(pb, 0);      /* reserved */
1833
1834     /*
1835      * This special text atom is required for
1836      * Apple Quicktime chapters. The contents
1837      * don't appear to be documented, so the
1838      * bytes are copied verbatim.
1839      */
1840     if (track->tag != MKTAG('c','6','0','8')) {
1841     avio_wb32(pb, 0x2C);   /* size */
1842     ffio_wfourcc(pb, "text");
1843     avio_wb16(pb, 0x01);
1844     avio_wb32(pb, 0x00);
1845     avio_wb32(pb, 0x00);
1846     avio_wb32(pb, 0x00);
1847     avio_wb32(pb, 0x01);
1848     avio_wb32(pb, 0x00);
1849     avio_wb32(pb, 0x00);
1850     avio_wb32(pb, 0x00);
1851     avio_wb32(pb, 0x00004000);
1852     avio_wb16(pb, 0x0000);
1853     }
1854
1855     if (track->enc->codec_tag == MKTAG('t','m','c','d')) {
1856         int64_t tmcd_pos = avio_tell(pb);
1857         avio_wb32(pb, 0); /* size */
1858         ffio_wfourcc(pb, "tmcd");
1859         mov_write_tcmi_tag(pb, track);
1860         update_size(pb, tmcd_pos);
1861     }
1862     return update_size(pb, pos);
1863 }
1864
1865 static int mov_write_smhd_tag(AVIOContext *pb)
1866 {
1867     avio_wb32(pb, 16); /* size */
1868     ffio_wfourcc(pb, "smhd");
1869     avio_wb32(pb, 0); /* version & flags */
1870     avio_wb16(pb, 0); /* reserved (balance, normally = 0) */
1871     avio_wb16(pb, 0); /* reserved */
1872     return 16;
1873 }
1874
1875 static int mov_write_vmhd_tag(AVIOContext *pb)
1876 {
1877     avio_wb32(pb, 0x14); /* size (always 0x14) */
1878     ffio_wfourcc(pb, "vmhd");
1879     avio_wb32(pb, 0x01); /* version & flags */
1880     avio_wb64(pb, 0); /* reserved (graphics mode = copy) */
1881     return 0x14;
1882 }
1883
1884 static int is_clcp_track(MOVTrack *track)
1885 {
1886     return track->tag == MKTAG('c','7','0','8') ||
1887            track->tag == MKTAG('c','6','0','8');
1888 }
1889
1890 static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track)
1891 {
1892     const char *hdlr, *descr = NULL, *hdlr_type = NULL;
1893     int64_t pos = avio_tell(pb);
1894
1895     hdlr      = "dhlr";
1896     hdlr_type = "url ";
1897     descr     = "DataHandler";
1898
1899     if (track) {
1900         hdlr = (track->mode == MODE_MOV) ? "mhlr" : "\0\0\0\0";
1901         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1902             hdlr_type = "vide";
1903             descr     = "VideoHandler";
1904         } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
1905             hdlr_type = "soun";
1906             descr     = "SoundHandler";
1907         } else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1908             if (is_clcp_track(track)) {
1909                 hdlr_type = "clcp";
1910                 descr = "ClosedCaptionHandler";
1911             } else {
1912                 if (track->tag == MKTAG('t','x','3','g')) {
1913                     hdlr_type = "sbtl";
1914                 } else if (track->tag == MKTAG('m','p','4','s')) {
1915                     hdlr_type = "subp";
1916                 } else {
1917                     hdlr_type = "text";
1918                 }
1919             descr = "SubtitleHandler";
1920             }
1921         } else if (track->enc->codec_tag == MKTAG('r','t','p',' ')) {
1922             hdlr_type = "hint";
1923             descr     = "HintHandler";
1924         } else if (track->enc->codec_tag == MKTAG('t','m','c','d')) {
1925             hdlr_type = "tmcd";
1926             descr = "TimeCodeHandler";
1927         } else {
1928             char tag_buf[32];
1929             av_get_codec_tag_string(tag_buf, sizeof(tag_buf),
1930                                     track->enc->codec_tag);
1931
1932             av_log(track->enc, AV_LOG_WARNING,
1933                    "Unknown hldr_type for %s / 0x%04X, writing dummy values\n",
1934                    tag_buf, track->enc->codec_tag);
1935         }
1936         if (track->st) {
1937             // hdlr.name is used by some players to identify the content title
1938             // of the track. So if an alternate handler description is
1939             // specified, use it.
1940             AVDictionaryEntry *t;
1941             t = av_dict_get(track->st->metadata, "handler", NULL, 0);
1942             if (t && utf8len(t->value))
1943                 descr = t->value;
1944         }
1945     }
1946
1947     avio_wb32(pb, 0); /* size */
1948     ffio_wfourcc(pb, "hdlr");
1949     avio_wb32(pb, 0); /* Version & flags */
1950     avio_write(pb, hdlr, 4); /* handler */
1951     ffio_wfourcc(pb, hdlr_type); /* handler type */
1952     avio_wb32(pb, 0); /* reserved */
1953     avio_wb32(pb, 0); /* reserved */
1954     avio_wb32(pb, 0); /* reserved */
1955     if (!track || track->mode == MODE_MOV)
1956         avio_w8(pb, strlen(descr)); /* pascal string */
1957     avio_write(pb, descr, strlen(descr)); /* handler description */
1958     if (track && track->mode != MODE_MOV)
1959         avio_w8(pb, 0); /* c string */
1960     return update_size(pb, pos);
1961 }
1962
1963 static int mov_write_hmhd_tag(AVIOContext *pb)
1964 {
1965     /* This atom must be present, but leaving the values at zero
1966      * seems harmless. */
1967     avio_wb32(pb, 28); /* size */
1968     ffio_wfourcc(pb, "hmhd");
1969     avio_wb32(pb, 0); /* version, flags */
1970     avio_wb16(pb, 0); /* maxPDUsize */
1971     avio_wb16(pb, 0); /* avgPDUsize */
1972     avio_wb32(pb, 0); /* maxbitrate */
1973     avio_wb32(pb, 0); /* avgbitrate */
1974     avio_wb32(pb, 0); /* reserved */
1975     return 28;
1976 }
1977
1978 static int mov_write_minf_tag(AVIOContext *pb, MOVTrack *track)
1979 {
1980     int64_t pos = avio_tell(pb);
1981     avio_wb32(pb, 0); /* size */
1982     ffio_wfourcc(pb, "minf");
1983     if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO)
1984         mov_write_vmhd_tag(pb);
1985     else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
1986         mov_write_smhd_tag(pb);
1987     else if (track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1988         if (track->tag == MKTAG('t','e','x','t') || is_clcp_track(track)) {
1989             mov_write_gmhd_tag(pb, track);
1990         } else {
1991             mov_write_nmhd_tag(pb);
1992         }
1993     } else if (track->tag == MKTAG('r','t','p',' ')) {
1994         mov_write_hmhd_tag(pb);
1995     } else if (track->tag == MKTAG('t','m','c','d')) {
1996         mov_write_gmhd_tag(pb, track);
1997     }
1998     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
1999         mov_write_hdlr_tag(pb, NULL);
2000     mov_write_dinf_tag(pb);
2001     mov_write_stbl_tag(pb, track);
2002     return update_size(pb, pos);
2003 }
2004
2005 static int mov_write_mdhd_tag(AVIOContext *pb, MOVTrack *track)
2006 {
2007     int version = track->track_duration < INT32_MAX ? 0 : 1;
2008
2009     if (track->mode == MODE_ISM)
2010         version = 1;
2011
2012     (version == 1) ? avio_wb32(pb, 44) : avio_wb32(pb, 32); /* size */
2013     ffio_wfourcc(pb, "mdhd");
2014     avio_w8(pb, version);
2015     avio_wb24(pb, 0); /* flags */
2016     if (version == 1) {
2017         avio_wb64(pb, track->time);
2018         avio_wb64(pb, track->time);
2019     } else {
2020         avio_wb32(pb, track->time); /* creation time */
2021         avio_wb32(pb, track->time); /* modification time */
2022     }
2023     avio_wb32(pb, track->timescale); /* time scale (sample rate for audio) */
2024     if (!track->entry)
2025         (version == 1) ? avio_wb64(pb, UINT64_C(0xffffffffffffffff)) : avio_wb32(pb, 0xffffffff);
2026     else
2027         (version == 1) ? avio_wb64(pb, track->track_duration) : avio_wb32(pb, track->track_duration); /* duration */
2028     avio_wb16(pb, track->language); /* language */
2029     avio_wb16(pb, 0); /* reserved (quality) */
2030
2031     if (version != 0 && track->mode == MODE_MOV) {
2032         av_log(NULL, AV_LOG_ERROR,
2033                "FATAL error, file duration too long for timebase, this file will not be\n"
2034                "playable with quicktime. Choose a different timebase or a different\n"
2035                "container format\n");
2036     }
2037
2038     return 32;
2039 }
2040
2041 static int mov_write_mdia_tag(AVIOContext *pb, MOVTrack *track)
2042 {
2043     int64_t pos = avio_tell(pb);
2044     avio_wb32(pb, 0); /* size */
2045     ffio_wfourcc(pb, "mdia");
2046     mov_write_mdhd_tag(pb, track);
2047     mov_write_hdlr_tag(pb, track);
2048     mov_write_minf_tag(pb, track);
2049     return update_size(pb, pos);
2050 }
2051
2052 /* transformation matrix
2053      |a  b  u|
2054      |c  d  v|
2055      |tx ty w| */
2056 static void write_matrix(AVIOContext *pb, int16_t a, int16_t b, int16_t c,
2057                          int16_t d, int16_t tx, int16_t ty)
2058 {
2059     avio_wb32(pb, a << 16);  /* 16.16 format */
2060     avio_wb32(pb, b << 16);  /* 16.16 format */
2061     avio_wb32(pb, 0);        /* u in 2.30 format */
2062     avio_wb32(pb, c << 16);  /* 16.16 format */
2063     avio_wb32(pb, d << 16);  /* 16.16 format */
2064     avio_wb32(pb, 0);        /* v in 2.30 format */
2065     avio_wb32(pb, tx << 16); /* 16.16 format */
2066     avio_wb32(pb, ty << 16); /* 16.16 format */
2067     avio_wb32(pb, 1 << 30);  /* w in 2.30 format */
2068 }
2069
2070 static int mov_write_tkhd_tag(AVIOContext *pb, MOVMuxContext *mov,
2071                               MOVTrack *track, AVStream *st)
2072 {
2073     int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE,
2074                                       track->timescale, AV_ROUND_UP);
2075     int version = duration < INT32_MAX ? 0 : 1;
2076     int flags   = MOV_TKHD_FLAG_IN_MOVIE;
2077     int rotation = 0;
2078     int group   = 0;
2079
2080
2081     if (st) {
2082         if (mov->per_stream_grouping)
2083             group = st->index;
2084         else
2085             group = st->codec->codec_type;
2086     }
2087
2088     if (track->flags & MOV_TRACK_ENABLED)
2089         flags |= MOV_TKHD_FLAG_ENABLED;
2090
2091     if (track->mode == MODE_ISM)
2092         version = 1;
2093
2094     (version == 1) ? avio_wb32(pb, 104) : avio_wb32(pb, 92); /* size */
2095     ffio_wfourcc(pb, "tkhd");
2096     avio_w8(pb, version);
2097     avio_wb24(pb, flags);
2098     if (version == 1) {
2099         avio_wb64(pb, track->time);
2100         avio_wb64(pb, track->time);
2101     } else {
2102         avio_wb32(pb, track->time); /* creation time */
2103         avio_wb32(pb, track->time); /* modification time */
2104     }
2105     avio_wb32(pb, track->track_id); /* track-id */
2106     avio_wb32(pb, 0); /* reserved */
2107     if (!track->entry)
2108         (version == 1) ? avio_wb64(pb, UINT64_C(0xffffffffffffffff)) : avio_wb32(pb, 0xffffffff);
2109     else
2110         (version == 1) ? avio_wb64(pb, duration) : avio_wb32(pb, duration);
2111
2112     avio_wb32(pb, 0); /* reserved */
2113     avio_wb32(pb, 0); /* reserved */
2114     avio_wb16(pb, 0); /* layer */
2115     avio_wb16(pb, group); /* alternate group) */
2116     /* Volume, only for audio */
2117     if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO)
2118         avio_wb16(pb, 0x0100);
2119     else
2120         avio_wb16(pb, 0);
2121     avio_wb16(pb, 0); /* reserved */
2122
2123     /* Matrix structure */
2124     if (st && st->metadata) {
2125         AVDictionaryEntry *rot = av_dict_get(st->metadata, "rotate", NULL, 0);
2126         rotation = (rot && rot->value) ? atoi(rot->value) : 0;
2127     }
2128     if (rotation == 90) {
2129         write_matrix(pb,  0,  1, -1,  0, track->enc->height, 0);
2130     } else if (rotation == 180) {
2131         write_matrix(pb, -1,  0,  0, -1, track->enc->width, track->enc->height);
2132     } else if (rotation == 270) {
2133         write_matrix(pb,  0, -1,  1,  0, 0, track->enc->width);
2134     } else {
2135         write_matrix(pb,  1,  0,  0,  1, 0, 0);
2136     }
2137     /* Track width and height, for visual only */
2138     if (st && (track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
2139                track->enc->codec_type == AVMEDIA_TYPE_SUBTITLE)) {
2140         if (track->mode == MODE_MOV) {
2141             avio_wb32(pb, track->enc->width << 16);
2142             avio_wb32(pb, track->height << 16);
2143         } else {
2144             double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
2145             if (!sample_aspect_ratio || track->height != track->enc->height)
2146                 sample_aspect_ratio = 1;
2147             avio_wb32(pb, sample_aspect_ratio * track->enc->width * 0x10000);
2148             avio_wb32(pb, track->height * 0x10000);
2149         }
2150     } else {
2151         avio_wb32(pb, 0);
2152         avio_wb32(pb, 0);
2153     }
2154     return 0x5c;
2155 }
2156
2157 static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)
2158 {
2159     int32_t width = av_rescale(track->enc->sample_aspect_ratio.num, track->enc->width,
2160                                track->enc->sample_aspect_ratio.den);
2161
2162     int64_t pos = avio_tell(pb);
2163
2164     avio_wb32(pb, 0); /* size */
2165     ffio_wfourcc(pb, "tapt");
2166
2167     avio_wb32(pb, 20);
2168     ffio_wfourcc(pb, "clef");
2169     avio_wb32(pb, 0);
2170     avio_wb32(pb, width << 16);
2171     avio_wb32(pb, track->enc->height << 16);
2172
2173     avio_wb32(pb, 20);
2174     ffio_wfourcc(pb, "prof");
2175     avio_wb32(pb, 0);
2176     avio_wb32(pb, width << 16);
2177     avio_wb32(pb, track->enc->height << 16);
2178
2179     avio_wb32(pb, 20);
2180     ffio_wfourcc(pb, "enof");
2181     avio_wb32(pb, 0);
2182     avio_wb32(pb, track->enc->width << 16);
2183     avio_wb32(pb, track->enc->height << 16);
2184
2185     return update_size(pb, pos);
2186 }
2187
2188 // This box seems important for the psp playback ... without it the movie seems to hang
2189 static int mov_write_edts_tag(AVIOContext *pb, MOVTrack *track)
2190 {
2191     int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE,
2192                                       track->timescale, AV_ROUND_UP);
2193     int version = duration < INT32_MAX ? 0 : 1;
2194     int entry_size, entry_count, size;
2195     int64_t delay, start_ct = track->cluster[0].cts;
2196     delay = av_rescale_rnd(track->cluster[0].dts + start_ct, MOV_TIMESCALE,
2197                            track->timescale, AV_ROUND_DOWN);
2198     version |= delay < INT32_MAX ? 0 : 1;
2199
2200     entry_size = (version == 1) ? 20 : 12;
2201     entry_count = 1 + (delay > 0);
2202     size = 24 + entry_count * entry_size;
2203
2204     /* write the atom data */
2205     avio_wb32(pb, size);
2206     ffio_wfourcc(pb, "edts");
2207     avio_wb32(pb, size - 8);
2208     ffio_wfourcc(pb, "elst");
2209     avio_w8(pb, version);
2210     avio_wb24(pb, 0); /* flags */
2211
2212     avio_wb32(pb, entry_count);
2213     if (delay > 0) { /* add an empty edit to delay presentation */
2214         if (version == 1) {
2215             avio_wb64(pb, delay);
2216             avio_wb64(pb, -1);
2217         } else {
2218             avio_wb32(pb, delay);
2219             avio_wb32(pb, -1);
2220         }
2221         avio_wb32(pb, 0x00010000);
2222     } else {
2223         /* Avoid accidentally ending up with start_ct = -1 which has got a
2224          * special meaning. Normally start_ct should end up positive or zero
2225          * here, but use FFMIN in case dts is a a small positive integer
2226          * rounded to 0 when represented in MOV_TIMESCALE units. */
2227         av_assert0(av_rescale_rnd(track->cluster[0].dts, MOV_TIMESCALE, track->timescale, AV_ROUND_DOWN) <= 0);
2228         start_ct  = -FFMIN(track->cluster[0].dts, 0);
2229         duration += delay;
2230     }
2231
2232     /* duration */
2233     if (version == 1) {
2234         avio_wb64(pb, duration);
2235         avio_wb64(pb, start_ct);
2236     } else {
2237         avio_wb32(pb, duration);
2238         avio_wb32(pb, start_ct);
2239     }
2240     avio_wb32(pb, 0x00010000);
2241     return size;
2242 }
2243
2244 static int mov_write_tref_tag(AVIOContext *pb, MOVTrack *track)
2245 {
2246     avio_wb32(pb, 20);   // size
2247     ffio_wfourcc(pb, "tref");
2248     avio_wb32(pb, 12);   // size (subatom)
2249     avio_wl32(pb, track->tref_tag);
2250     avio_wb32(pb, track->tref_id);
2251     return 20;
2252 }
2253
2254 // goes at the end of each track!  ... Critical for PSP playback ("Incompatible data" without it)
2255 static int mov_write_uuid_tag_psp(AVIOContext *pb, MOVTrack *mov)
2256 {
2257     avio_wb32(pb, 0x34); /* size ... reports as 28 in mp4box! */
2258     ffio_wfourcc(pb, "uuid");
2259     ffio_wfourcc(pb, "USMT");
2260     avio_wb32(pb, 0x21d24fce);
2261     avio_wb32(pb, 0xbb88695c);
2262     avio_wb32(pb, 0xfac9c740);
2263     avio_wb32(pb, 0x1c);     // another size here!
2264     ffio_wfourcc(pb, "MTDT");
2265     avio_wb32(pb, 0x00010012);
2266     avio_wb32(pb, 0x0a);
2267     avio_wb32(pb, 0x55c40000);
2268     avio_wb32(pb, 0x1);
2269     avio_wb32(pb, 0x0);
2270     return 0x34;
2271 }
2272
2273 static int mov_write_udta_sdp(AVIOContext *pb, MOVTrack *track)
2274 {
2275     AVFormatContext *ctx = track->rtp_ctx;
2276     char buf[1000] = "";
2277     int len;
2278
2279     ff_sdp_write_media(buf, sizeof(buf), ctx->streams[0], track->src_track,
2280                        NULL, NULL, 0, 0, ctx);
2281     av_strlcatf(buf, sizeof(buf), "a=control:streamid=%d\r\n", track->track_id);
2282     len = strlen(buf);
2283
2284     avio_wb32(pb, len + 24);
2285     ffio_wfourcc(pb, "udta");
2286     avio_wb32(pb, len + 16);
2287     ffio_wfourcc(pb, "hnti");
2288     avio_wb32(pb, len + 8);
2289     ffio_wfourcc(pb, "sdp ");
2290     avio_write(pb, buf, len);
2291     return len + 24;
2292 }
2293
2294 static int mov_write_track_metadata(AVIOContext *pb, AVStream *st,
2295                                     const char *tag, const char *str)
2296 {
2297     int64_t pos = avio_tell(pb);
2298     AVDictionaryEntry *t = av_dict_get(st->metadata, str, NULL, 0);
2299     if (!t || !utf8len(t->value))
2300         return 0;
2301
2302     avio_wb32(pb, 0);   /* size */
2303     ffio_wfourcc(pb, tag); /* type */
2304     avio_write(pb, t->value, strlen(t->value)); /* UTF8 string value */
2305     return update_size(pb, pos);
2306 }
2307
2308 static int mov_write_track_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
2309                                     AVStream *st)
2310 {
2311     AVIOContext *pb_buf;
2312     int ret, size;
2313     uint8_t *buf;
2314
2315     if (!st || mov->fc->flags & AVFMT_FLAG_BITEXACT)
2316         return 0;
2317
2318     ret = avio_open_dyn_buf(&pb_buf);
2319     if (ret < 0)
2320         return ret;
2321
2322     if (mov->mode & MODE_MP4)
2323         mov_write_track_metadata(pb_buf, st, "name", "title");
2324
2325     if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
2326         avio_wb32(pb, size + 8);
2327         ffio_wfourcc(pb, "udta");
2328         avio_write(pb, buf, size);
2329     }
2330     av_free(buf);
2331
2332     return 0;
2333 }
2334
2335 static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov,
2336                               MOVTrack *track, AVStream *st)
2337 {
2338     int64_t pos = avio_tell(pb);
2339     avio_wb32(pb, 0); /* size */
2340     ffio_wfourcc(pb, "trak");
2341     mov_write_tkhd_tag(pb, mov, track, st);
2342     if (supports_edts(mov))
2343         mov_write_edts_tag(pb, track);  // PSP Movies and several other cases require edts box
2344     if (track->tref_tag)
2345         mov_write_tref_tag(pb, track);
2346     mov_write_mdia_tag(pb, track);
2347     if (track->mode == MODE_PSP)
2348         mov_write_uuid_tag_psp(pb, track); // PSP Movies require this uuid box
2349     if (track->tag == MKTAG('r','t','p',' '))
2350         mov_write_udta_sdp(pb, track);
2351     if (track->mode == MODE_MOV) {
2352         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2353             double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
2354             if (st->sample_aspect_ratio.num && 1.0 != sample_aspect_ratio) {
2355                 mov_write_tapt_tag(pb, track);
2356             }
2357         }
2358         if (is_clcp_track(track) && st->sample_aspect_ratio.num) {
2359             mov_write_tapt_tag(pb, track);
2360         }
2361     }
2362     mov_write_track_udta_tag(pb, mov, st);
2363     return update_size(pb, pos);
2364 }
2365
2366 static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov)
2367 {
2368     int i, has_audio = 0, has_video = 0;
2369     int64_t pos = avio_tell(pb);
2370     int audio_profile = mov->iods_audio_profile;
2371     int video_profile = mov->iods_video_profile;
2372     for (i = 0; i < mov->nb_streams; i++) {
2373         if (mov->tracks[i].entry > 0) {
2374             has_audio |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_AUDIO;
2375             has_video |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_VIDEO;
2376         }
2377     }
2378     if (audio_profile < 0)
2379         audio_profile = 0xFF - has_audio;
2380     if (video_profile < 0)
2381         video_profile = 0xFF - has_video;
2382     avio_wb32(pb, 0x0); /* size */
2383     ffio_wfourcc(pb, "iods");
2384     avio_wb32(pb, 0);    /* version & flags */
2385     put_descr(pb, 0x10, 7);
2386     avio_wb16(pb, 0x004f);
2387     avio_w8(pb, 0xff);
2388     avio_w8(pb, 0xff);
2389     avio_w8(pb, audio_profile);
2390     avio_w8(pb, video_profile);
2391     avio_w8(pb, 0xff);
2392     return update_size(pb, pos);
2393 }
2394
2395 static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
2396 {
2397     avio_wb32(pb, 0x20); /* size */
2398     ffio_wfourcc(pb, "trex");
2399     avio_wb32(pb, 0);   /* version & flags */
2400     avio_wb32(pb, track->track_id); /* track ID */
2401     avio_wb32(pb, 1);   /* default sample description index */
2402     avio_wb32(pb, 0);   /* default sample duration */
2403     avio_wb32(pb, 0);   /* default sample size */
2404     avio_wb32(pb, 0);   /* default sample flags */
2405     return 0;
2406 }
2407
2408 static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov)
2409 {
2410     int64_t pos = avio_tell(pb);
2411     int i;
2412     avio_wb32(pb, 0x0); /* size */
2413     ffio_wfourcc(pb, "mvex");
2414     for (i = 0; i < mov->nb_streams; i++)
2415         mov_write_trex_tag(pb, &mov->tracks[i]);
2416     return update_size(pb, pos);
2417 }
2418
2419 static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
2420 {
2421     int max_track_id = 1, i;
2422     int64_t max_track_len_temp, max_track_len = 0;
2423     int version;
2424
2425     for (i = 0; i < mov->nb_streams; i++) {
2426         if (mov->tracks[i].entry > 0 && mov->tracks[i].timescale) {
2427             max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
2428                                                 MOV_TIMESCALE,
2429                                                 mov->tracks[i].timescale,
2430                                                 AV_ROUND_UP);
2431             if (max_track_len < max_track_len_temp)
2432                 max_track_len = max_track_len_temp;
2433             if (max_track_id < mov->tracks[i].track_id)
2434                 max_track_id = mov->tracks[i].track_id;
2435         }
2436     }
2437
2438     version = max_track_len < UINT32_MAX ? 0 : 1;
2439     (version == 1) ? avio_wb32(pb, 120) : avio_wb32(pb, 108); /* size */
2440     ffio_wfourcc(pb, "mvhd");
2441     avio_w8(pb, version);
2442     avio_wb24(pb, 0); /* flags */
2443     if (version == 1) {
2444         avio_wb64(pb, mov->time);
2445         avio_wb64(pb, mov->time);
2446     } else {
2447         avio_wb32(pb, mov->time); /* creation time */
2448         avio_wb32(pb, mov->time); /* modification time */
2449     }
2450     avio_wb32(pb, MOV_TIMESCALE);
2451     (version == 1) ? avio_wb64(pb, max_track_len) : avio_wb32(pb, max_track_len); /* duration of longest track */
2452
2453     avio_wb32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
2454     avio_wb16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
2455     avio_wb16(pb, 0); /* reserved */
2456     avio_wb32(pb, 0); /* reserved */
2457     avio_wb32(pb, 0); /* reserved */
2458
2459     /* Matrix structure */
2460     write_matrix(pb, 1, 0, 0, 1, 0, 0);
2461
2462     avio_wb32(pb, 0); /* reserved (preview time) */
2463     avio_wb32(pb, 0); /* reserved (preview duration) */
2464     avio_wb32(pb, 0); /* reserved (poster time) */
2465     avio_wb32(pb, 0); /* reserved (selection time) */
2466     avio_wb32(pb, 0); /* reserved (selection duration) */
2467     avio_wb32(pb, 0); /* reserved (current time) */
2468     avio_wb32(pb, max_track_id + 1); /* Next track id */
2469     return 0x6c;
2470 }
2471
2472 static int mov_write_itunes_hdlr_tag(AVIOContext *pb, MOVMuxContext *mov,
2473                                      AVFormatContext *s)
2474 {
2475     avio_wb32(pb, 33); /* size */
2476     ffio_wfourcc(pb, "hdlr");
2477     avio_wb32(pb, 0);
2478     avio_wb32(pb, 0);
2479     ffio_wfourcc(pb, "mdir");
2480     ffio_wfourcc(pb, "appl");
2481     avio_wb32(pb, 0);
2482     avio_wb32(pb, 0);
2483     avio_w8(pb, 0);
2484     return 33;
2485 }
2486
2487 /* helper function to write a data tag with the specified string as data */
2488 static int mov_write_string_data_tag(AVIOContext *pb, const char *data, int lang, int long_style)
2489 {
2490     if (long_style) {
2491         int size = 16 + strlen(data);
2492         avio_wb32(pb, size); /* size */
2493         ffio_wfourcc(pb, "data");
2494         avio_wb32(pb, 1);
2495         avio_wb32(pb, 0);
2496         avio_write(pb, data, strlen(data));
2497         return size;
2498     } else {
2499         if (!lang)
2500             lang = ff_mov_iso639_to_lang("und", 1);
2501         avio_wb16(pb, strlen(data)); /* string length */
2502         avio_wb16(pb, lang);
2503         avio_write(pb, data, strlen(data));
2504         return strlen(data) + 4;
2505     }
2506 }
2507
2508 static int mov_write_string_tag(AVIOContext *pb, const char *name,
2509                                 const char *value, int lang, int long_style)
2510 {
2511     int size = 0;
2512     if (value && value[0]) {
2513         int64_t pos = avio_tell(pb);
2514         avio_wb32(pb, 0); /* size */
2515         ffio_wfourcc(pb, name);
2516         mov_write_string_data_tag(pb, value, lang, long_style);
2517         size = update_size(pb, pos);
2518     }
2519     return size;
2520 }
2521
2522 static int mov_write_string_metadata(AVFormatContext *s, AVIOContext *pb,
2523                                      const char *name, const char *tag,
2524                                      int long_style)
2525 {
2526     int l, lang = 0, len, len2;
2527     AVDictionaryEntry *t, *t2 = NULL;
2528     char tag2[16];
2529
2530     if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
2531         return 0;
2532
2533     len = strlen(t->key);
2534     snprintf(tag2, sizeof(tag2), "%s-", tag);
2535     while ((t2 = av_dict_get(s->metadata, tag2, t2, AV_DICT_IGNORE_SUFFIX))) {
2536         len2 = strlen(t2->key);
2537         if (len2 == len + 4 && !strcmp(t->value, t2->value)
2538             && (l = ff_mov_iso639_to_lang(&t2->key[len2 - 3], 1)) >= 0) {
2539             lang = l;
2540             break;
2541         }
2542     }
2543     return mov_write_string_tag(pb, name, t->value, lang, long_style);
2544 }
2545
2546 /* iTunes bpm number */
2547 static int mov_write_tmpo_tag(AVIOContext *pb, AVFormatContext *s)
2548 {
2549     AVDictionaryEntry *t = av_dict_get(s->metadata, "tmpo", NULL, 0);
2550     int size = 0, tmpo = t ? atoi(t->value) : 0;
2551     if (tmpo) {
2552         size = 26;
2553         avio_wb32(pb, size);
2554         ffio_wfourcc(pb, "tmpo");
2555         avio_wb32(pb, size-8); /* size */
2556         ffio_wfourcc(pb, "data");
2557         avio_wb32(pb, 0x15);  //type specifier
2558         avio_wb32(pb, 0);
2559         avio_wb16(pb, tmpo);        // data
2560     }
2561     return size;
2562 }
2563
2564 /* iTunes track or disc number */
2565 static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov,
2566                               AVFormatContext *s, int disc)
2567 {
2568     AVDictionaryEntry *t = av_dict_get(s->metadata,
2569                                        disc ? "disc" : "track",
2570                                        NULL, 0);
2571     int size = 0, track = t ? atoi(t->value) : 0;
2572     if (track) {
2573         int tracks = 0;
2574         char *slash = strchr(t->value, '/');
2575         if (slash)
2576             tracks = atoi(slash + 1);
2577         avio_wb32(pb, 32); /* size */
2578         ffio_wfourcc(pb, disc ? "disk" : "trkn");
2579         avio_wb32(pb, 24); /* size */
2580         ffio_wfourcc(pb, "data");
2581         avio_wb32(pb, 0);        // 8 bytes empty
2582         avio_wb32(pb, 0);
2583         avio_wb16(pb, 0);        // empty
2584         avio_wb16(pb, track);    // track / disc number
2585         avio_wb16(pb, tracks);   // total track / disc number
2586         avio_wb16(pb, 0);        // empty
2587         size = 32;
2588     }
2589     return size;
2590 }
2591
2592 static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb,
2593                                    const char *name, const char *tag,
2594                                    int len)
2595 {
2596     AVDictionaryEntry *t = NULL;
2597     uint8_t num;
2598     int size = 24 + len;
2599
2600     if (len != 1 && len != 4)
2601         return -1;
2602
2603     if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
2604         return 0;
2605     num = atoi(t->value);
2606
2607     avio_wb32(pb, size);
2608     ffio_wfourcc(pb, name);
2609     avio_wb32(pb, size - 8);
2610     ffio_wfourcc(pb, "data");
2611     avio_wb32(pb, 0x15);
2612     avio_wb32(pb, 0);
2613     if (len==4) avio_wb32(pb, num);
2614     else        avio_w8 (pb, num);
2615
2616     return size;
2617 }
2618
2619 /* iTunes meta data list */
2620 static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
2621                               AVFormatContext *s)
2622 {
2623     int64_t pos = avio_tell(pb);
2624     avio_wb32(pb, 0); /* size */
2625     ffio_wfourcc(pb, "ilst");
2626     mov_write_string_metadata(s, pb, "\251nam", "title"    , 1);
2627     mov_write_string_metadata(s, pb, "\251ART", "artist"   , 1);
2628     mov_write_string_metadata(s, pb, "aART", "album_artist", 1);
2629     mov_write_string_metadata(s, pb, "\251wrt", "composer" , 1);
2630     mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);
2631     mov_write_string_metadata(s, pb, "\251day", "date"     , 1);
2632     if (!mov->exact &&
2633         !mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1))
2634         mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
2635     mov_write_string_metadata(s, pb, "\251cmt", "comment"  , 1);
2636     mov_write_string_metadata(s, pb, "\251gen", "genre"    , 1);
2637     mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1);
2638     mov_write_string_metadata(s, pb, "\251grp", "grouping" , 1);
2639     mov_write_string_metadata(s, pb, "\251lyr", "lyrics"   , 1);
2640     mov_write_string_metadata(s, pb, "desc",    "description",1);
2641     mov_write_string_metadata(s, pb, "ldes",    "synopsis" , 1);
2642     mov_write_string_metadata(s, pb, "tvsh",    "show"     , 1);
2643     mov_write_string_metadata(s, pb, "tven",    "episode_id",1);
2644     mov_write_string_metadata(s, pb, "tvnn",    "network"  , 1);
2645     mov_write_int8_metadata  (s, pb, "tves",    "episode_sort",4);
2646     mov_write_int8_metadata  (s, pb, "tvsn",    "season_number",4);
2647     mov_write_int8_metadata  (s, pb, "stik",    "media_type",1);
2648     mov_write_int8_metadata  (s, pb, "hdvd",    "hd_video",  1);
2649     mov_write_int8_metadata  (s, pb, "pgap",    "gapless_playback",1);
2650     mov_write_int8_metadata  (s, pb, "cpil",    "compilation", 1);
2651     mov_write_trkn_tag(pb, mov, s, 0); // track number
2652     mov_write_trkn_tag(pb, mov, s, 1); // disc number
2653     mov_write_tmpo_tag(pb, s);
2654     return update_size(pb, pos);
2655 }
2656
2657 /* iTunes meta data tag */
2658 static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov,
2659                               AVFormatContext *s)
2660 {
2661     int size = 0;
2662     int64_t pos = avio_tell(pb);
2663     avio_wb32(pb, 0); /* size */
2664     ffio_wfourcc(pb, "meta");
2665     avio_wb32(pb, 0);
2666     mov_write_itunes_hdlr_tag(pb, mov, s);
2667     mov_write_ilst_tag(pb, mov, s);
2668     size = update_size(pb, pos);
2669     return size;
2670 }
2671
2672 static int mov_write_raw_metadata_tag(AVFormatContext *s, AVIOContext *pb,
2673                                       const char *name, const char *key)
2674 {
2675     int len;
2676     AVDictionaryEntry *t;
2677
2678     if (!(t = av_dict_get(s->metadata, key, NULL, 0)))
2679         return 0;
2680
2681     len = strlen(t->value);
2682     if (len > 0) {
2683         int size = len + 8;
2684         avio_wb32(pb, size);
2685         ffio_wfourcc(pb, name);
2686         avio_write(pb, t->value, len);
2687         return size;
2688     }
2689     return 0;
2690 }
2691
2692 static int ascii_to_wc(AVIOContext *pb, const uint8_t *b)
2693 {
2694     int val;
2695     while (*b) {
2696         GET_UTF8(val, *b++, return -1;)
2697         avio_wb16(pb, val);
2698     }
2699     avio_wb16(pb, 0x00);
2700     return 0;
2701 }
2702
2703 static uint16_t language_code(const char *str)
2704 {
2705     return (((str[0] - 0x60) & 0x1F) << 10) +
2706            (((str[1] - 0x60) & 0x1F) <<  5) +
2707            (( str[2] - 0x60) & 0x1F);
2708 }
2709
2710 static int mov_write_3gp_udta_tag(AVIOContext *pb, AVFormatContext *s,
2711                                   const char *tag, const char *str)
2712 {
2713     int64_t pos = avio_tell(pb);
2714     AVDictionaryEntry *t = av_dict_get(s->metadata, str, NULL, 0);
2715     if (!t || !utf8len(t->value))
2716         return 0;
2717     avio_wb32(pb, 0);   /* size */
2718     ffio_wfourcc(pb, tag); /* type */
2719     avio_wb32(pb, 0);   /* version + flags */
2720     if (!strcmp(tag, "yrrc"))
2721         avio_wb16(pb, atoi(t->value));
2722     else {
2723         avio_wb16(pb, language_code("eng")); /* language */
2724         avio_write(pb, t->value, strlen(t->value) + 1); /* UTF8 string value */
2725         if (!strcmp(tag, "albm") &&
2726             (t = av_dict_get(s->metadata, "track", NULL, 0)))
2727             avio_w8(pb, atoi(t->value));
2728     }
2729     return update_size(pb, pos);
2730 }
2731
2732 static int mov_write_chpl_tag(AVIOContext *pb, AVFormatContext *s)
2733 {
2734     int64_t pos = avio_tell(pb);
2735     int i, nb_chapters = FFMIN(s->nb_chapters, 255);
2736
2737     avio_wb32(pb, 0);            // size
2738     ffio_wfourcc(pb, "chpl");
2739     avio_wb32(pb, 0x01000000);   // version + flags
2740     avio_wb32(pb, 0);            // unknown
2741     avio_w8(pb, nb_chapters);
2742
2743     for (i = 0; i < nb_chapters; i++) {
2744         AVChapter *c = s->chapters[i];
2745         AVDictionaryEntry *t;
2746         avio_wb64(pb, av_rescale_q(c->start, c->time_base, (AVRational){1,10000000}));
2747
2748         if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
2749             int len = FFMIN(strlen(t->value), 255);
2750             avio_w8(pb, len);
2751             avio_write(pb, t->value, len);
2752         } else
2753             avio_w8(pb, 0);
2754     }
2755     return update_size(pb, pos);
2756 }
2757
2758 static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
2759                               AVFormatContext *s)
2760 {
2761     AVIOContext *pb_buf;
2762     int ret, size;
2763     uint8_t *buf;
2764
2765     ret = avio_open_dyn_buf(&pb_buf);
2766     if (ret < 0)
2767         return ret;
2768
2769     if (mov->mode & MODE_3GP) {
2770         mov_write_3gp_udta_tag(pb_buf, s, "perf", "artist");
2771         mov_write_3gp_udta_tag(pb_buf, s, "titl", "title");
2772         mov_write_3gp_udta_tag(pb_buf, s, "auth", "author");
2773         mov_write_3gp_udta_tag(pb_buf, s, "gnre", "genre");
2774         mov_write_3gp_udta_tag(pb_buf, s, "dscp", "comment");
2775         mov_write_3gp_udta_tag(pb_buf, s, "albm", "album");
2776         mov_write_3gp_udta_tag(pb_buf, s, "cprt", "copyright");
2777         mov_write_3gp_udta_tag(pb_buf, s, "yrrc", "date");
2778     } else if (mov->mode == MODE_MOV) { // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
2779         mov_write_string_metadata(s, pb_buf, "\251ART", "artist",      0);
2780         mov_write_string_metadata(s, pb_buf, "\251nam", "title",       0);
2781         mov_write_string_metadata(s, pb_buf, "\251aut", "author",      0);
2782         mov_write_string_metadata(s, pb_buf, "\251alb", "album",       0);
2783         mov_write_string_metadata(s, pb_buf, "\251day", "date",        0);
2784         mov_write_string_metadata(s, pb_buf, "\251swr", "encoder",     0);
2785         // currently ignored by mov.c
2786         mov_write_string_metadata(s, pb_buf, "\251des", "comment",     0);
2787         // add support for libquicktime, this atom is also actually read by mov.c
2788         mov_write_string_metadata(s, pb_buf, "\251cmt", "comment",     0);
2789         mov_write_string_metadata(s, pb_buf, "\251gen", "genre",       0);
2790         mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright",   0);
2791         mov_write_raw_metadata_tag(s, pb_buf, "XMP_", "xmp");
2792     } else {
2793         /* iTunes meta data */
2794         mov_write_meta_tag(pb_buf, mov, s);
2795     }
2796
2797     if (s->nb_chapters && !(mov->flags & FF_MOV_FLAG_DISABLE_CHPL))
2798         mov_write_chpl_tag(pb_buf, s);
2799
2800     if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
2801         avio_wb32(pb, size + 8);
2802         ffio_wfourcc(pb, "udta");
2803         avio_write(pb, buf, size);
2804     }
2805     av_free(buf);
2806
2807     return 0;
2808 }
2809
2810 static void mov_write_psp_udta_tag(AVIOContext *pb,
2811                                    const char *str, const char *lang, int type)
2812 {
2813     int len = utf8len(str) + 1;
2814     if (len <= 0)
2815         return;
2816     avio_wb16(pb, len * 2 + 10);        /* size */
2817     avio_wb32(pb, type);                /* type */
2818     avio_wb16(pb, language_code(lang)); /* language */
2819     avio_wb16(pb, 0x01);                /* ? */
2820     ascii_to_wc(pb, str);
2821 }
2822
2823 static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
2824 {
2825     MOVMuxContext *mov = s->priv_data;
2826     AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
2827     int64_t pos, pos2;
2828
2829     if (title) {
2830         pos = avio_tell(pb);
2831         avio_wb32(pb, 0); /* size placeholder*/
2832         ffio_wfourcc(pb, "uuid");
2833         ffio_wfourcc(pb, "USMT");
2834         avio_wb32(pb, 0x21d24fce); /* 96 bit UUID */
2835         avio_wb32(pb, 0xbb88695c);
2836         avio_wb32(pb, 0xfac9c740);
2837
2838         pos2 = avio_tell(pb);
2839         avio_wb32(pb, 0); /* size placeholder*/
2840         ffio_wfourcc(pb, "MTDT");
2841         avio_wb16(pb, 4);
2842
2843         // ?
2844         avio_wb16(pb, 0x0C);                 /* size */
2845         avio_wb32(pb, 0x0B);                 /* type */
2846         avio_wb16(pb, language_code("und")); /* language */
2847         avio_wb16(pb, 0x0);                  /* ? */
2848         avio_wb16(pb, 0x021C);               /* data */
2849
2850         if (!mov->exact)
2851             mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
2852         mov_write_psp_udta_tag(pb, title->value,          "eng", 0x01);
2853         mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);
2854
2855         update_size(pb, pos2);
2856         return update_size(pb, pos);
2857     }
2858
2859     return 0;
2860 }
2861
2862 static void build_chunks(MOVTrack *trk)
2863 {
2864     int i;
2865     MOVIentry *chunk = &trk->cluster[0];
2866     uint64_t chunkSize = chunk->size;
2867     chunk->chunkNum = 1;
2868     if (trk->chunkCount)
2869         return;
2870     trk->chunkCount = 1;
2871     for (i = 1; i<trk->entry; i++){
2872         if (chunk->pos + chunkSize == trk->cluster[i].pos &&
2873             chunkSize + trk->cluster[i].size < (1<<20)){
2874             chunkSize             += trk->cluster[i].size;
2875             chunk->samples_in_chunk += trk->cluster[i].entries;
2876         } else {
2877             trk->cluster[i].chunkNum = chunk->chunkNum+1;
2878             chunk=&trk->cluster[i];
2879             chunkSize = chunk->size;
2880             trk->chunkCount++;
2881         }
2882     }
2883 }
2884
2885 static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
2886                               AVFormatContext *s)
2887 {
2888     int i;
2889     int64_t pos = avio_tell(pb);
2890     avio_wb32(pb, 0); /* size placeholder*/
2891     ffio_wfourcc(pb, "moov");
2892
2893     for (i = 0; i < mov->nb_streams; i++) {
2894         if (mov->tracks[i].entry <= 0 && !(mov->flags & FF_MOV_FLAG_FRAGMENT))
2895             continue;
2896
2897         mov->tracks[i].time     = mov->time;
2898         mov->tracks[i].track_id = i + 1;
2899
2900         if (mov->tracks[i].entry)
2901             build_chunks(&mov->tracks[i]);
2902     }
2903
2904     if (mov->chapter_track)
2905         for (i = 0; i < s->nb_streams; i++) {
2906             mov->tracks[i].tref_tag = MKTAG('c','h','a','p');
2907             mov->tracks[i].tref_id  = mov->tracks[mov->chapter_track].track_id;
2908         }
2909     for (i = 0; i < mov->nb_streams; i++) {
2910         if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) {
2911             mov->tracks[i].tref_tag = MKTAG('h','i','n','t');
2912             mov->tracks[i].tref_id =
2913                 mov->tracks[mov->tracks[i].src_track].track_id;
2914         }
2915     }
2916     for (i = 0; i < mov->nb_streams; i++) {
2917         if (mov->tracks[i].tag == MKTAG('t','m','c','d')) {
2918             int src_trk = mov->tracks[i].src_track;
2919             mov->tracks[src_trk].tref_tag = mov->tracks[i].tag;
2920             mov->tracks[src_trk].tref_id  = mov->tracks[i].track_id;
2921             //src_trk may have a different timescale than the tmcd track
2922             mov->tracks[i].track_duration = av_rescale(mov->tracks[src_trk].track_duration,
2923                                                        mov->tracks[i].timescale,
2924                                                        mov->tracks[src_trk].timescale);
2925         }
2926     }
2927
2928     mov_write_mvhd_tag(pb, mov);
2929     if (mov->mode != MODE_MOV && !mov->iods_skip)
2930         mov_write_iods_tag(pb, mov);
2931     for (i = 0; i < mov->nb_streams; i++) {
2932         if (mov->tracks[i].entry > 0 || mov->flags & FF_MOV_FLAG_FRAGMENT) {
2933             mov_write_trak_tag(pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL);
2934         }
2935     }
2936     if (mov->flags & FF_MOV_FLAG_FRAGMENT)
2937         mov_write_mvex_tag(pb, mov); /* QuickTime requires trak to precede this */
2938
2939     if (mov->mode == MODE_PSP)
2940         mov_write_uuidusmt_tag(pb, s);
2941     else
2942         mov_write_udta_tag(pb, mov, s);
2943
2944     return update_size(pb, pos);
2945 }
2946
2947 static void param_write_int(AVIOContext *pb, const char *name, int value)
2948 {
2949     avio_printf(pb, "<param name=\"%s\" value=\"%d\" valuetype=\"data\"/>\n", name, value);
2950 }
2951
2952 static void param_write_string(AVIOContext *pb, const char *name, const char *value)
2953 {
2954     avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, value);
2955 }
2956
2957 static void param_write_hex(AVIOContext *pb, const char *name, const uint8_t *value, int len)
2958 {
2959     char buf[150];
2960     len = FFMIN(sizeof(buf) / 2 - 1, len);
2961     ff_data_to_hex(buf, value, len, 0);
2962     buf[2 * len] = '\0';
2963     avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, buf);
2964 }
2965
2966 static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
2967 {
2968     int64_t pos = avio_tell(pb);
2969     int i;
2970     static const uint8_t uuid[] = {
2971         0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
2972         0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
2973     };
2974
2975     avio_wb32(pb, 0);
2976     ffio_wfourcc(pb, "uuid");
2977     avio_write(pb, uuid, sizeof(uuid));
2978     avio_wb32(pb, 0);
2979
2980     avio_printf(pb, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
2981     avio_printf(pb, "<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
2982     avio_printf(pb, "<head>\n");
2983     if (!mov->exact)
2984         avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
2985                     LIBAVFORMAT_IDENT);
2986     avio_printf(pb, "</head>\n");
2987     avio_printf(pb, "<body>\n");
2988     avio_printf(pb, "<switch>\n");
2989     for (i = 0; i < mov->nb_streams; i++) {
2990         MOVTrack *track = &mov->tracks[i];
2991         const char *type;
2992         /* track->track_id is initialized in write_moov, and thus isn't known
2993          * here yet */
2994         int track_id = i + 1;
2995
2996         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2997             type = "video";
2998         } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
2999             type = "audio";
3000         } else {
3001             continue;
3002         }
3003         avio_printf(pb, "<%s systemBitrate=\"%d\">\n", type,
3004                                                        track->enc->bit_rate);
3005         param_write_int(pb, "systemBitrate", track->enc->bit_rate);
3006         param_write_int(pb, "trackID", track_id);
3007         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
3008             if (track->enc->codec_id == AV_CODEC_ID_H264) {
3009                 uint8_t *ptr;
3010                 int size = track->enc->extradata_size;
3011                 if (!ff_avc_write_annexb_extradata(track->enc->extradata, &ptr,
3012                                                    &size)) {
3013                     param_write_hex(pb, "CodecPrivateData",
3014                                     ptr ? ptr : track->enc->extradata,
3015                                     size);
3016                     av_free(ptr);
3017                 }
3018                 param_write_string(pb, "FourCC", "H264");
3019             } else if (track->enc->codec_id == AV_CODEC_ID_VC1) {
3020                 param_write_string(pb, "FourCC", "WVC1");
3021                 param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
3022                                 track->enc->extradata_size);
3023             }
3024             param_write_int(pb, "MaxWidth", track->enc->width);
3025             param_write_int(pb, "MaxHeight", track->enc->height);
3026             param_write_int(pb, "DisplayWidth", track->enc->width);
3027             param_write_int(pb, "DisplayHeight", track->enc->height);
3028         } else {
3029             if (track->enc->codec_id == AV_CODEC_ID_AAC) {
3030                 param_write_string(pb, "FourCC", "AACL");
3031             } else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO) {
3032                 param_write_string(pb, "FourCC", "WMAP");
3033             }
3034             param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
3035                             track->enc->extradata_size);
3036             param_write_int(pb, "AudioTag", ff_codec_get_tag(ff_codec_wav_tags,
3037                                                              track->enc->codec_id));
3038             param_write_int(pb, "Channels", track->enc->channels);
3039             param_write_int(pb, "SamplingRate", track->enc->sample_rate);
3040             param_write_int(pb, "BitsPerSample", 16);
3041             param_write_int(pb, "PacketSize", track->enc->block_align ?
3042                                               track->enc->block_align : 4);
3043         }
3044         avio_printf(pb, "</%s>\n", type);
3045     }
3046     avio_printf(pb, "</switch>\n");
3047     avio_printf(pb, "</body>\n");
3048     avio_printf(pb, "</smil>\n");
3049
3050     return update_size(pb, pos);
3051 }
3052
3053 static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov)
3054 {
3055     avio_wb32(pb, 16);
3056     ffio_wfourcc(pb, "mfhd");
3057     avio_wb32(pb, 0);
3058     avio_wb32(pb, mov->fragments);
3059     return 0;
3060 }
3061
3062 static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov,
3063                               MOVTrack *track, int64_t moof_offset)
3064 {
3065     int64_t pos = avio_tell(pb);
3066     uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
3067                      MOV_TFHD_BASE_DATA_OFFSET;
3068     if (!track->entry) {
3069         flags |= MOV_TFHD_DURATION_IS_EMPTY;
3070     } else {
3071         flags |= MOV_TFHD_DEFAULT_FLAGS;
3072     }
3073     if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET)
3074         flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
3075
3076     /* Don't set a default sample size, the silverlight player refuses
3077      * to play files with that set. Don't set a default sample duration,
3078      * WMP freaks out if it is set. Don't set a base data offset, PIFF
3079      * file format says it MUST NOT be set. */
3080     if (track->mode == MODE_ISM)
3081         flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
3082                    MOV_TFHD_BASE_DATA_OFFSET);
3083
3084     avio_wb32(pb, 0); /* size placeholder */
3085     ffio_wfourcc(pb, "tfhd");
3086     avio_w8(pb, 0); /* version */
3087     avio_wb24(pb, flags);
3088
3089     avio_wb32(pb, track->track_id); /* track-id */
3090     if (flags & MOV_TFHD_BASE_DATA_OFFSET)
3091         avio_wb64(pb, moof_offset);
3092     if (flags & MOV_TFHD_DEFAULT_DURATION) {
3093         track->default_duration = get_cluster_duration(track, 0);
3094         avio_wb32(pb, track->default_duration);
3095     }
3096     if (flags & MOV_TFHD_DEFAULT_SIZE) {
3097         track->default_size = track->entry ? track->cluster[0].size : 1;
3098         avio_wb32(pb, track->default_size);
3099     } else
3100         track->default_size = -1;
3101
3102     if (flags & MOV_TFHD_DEFAULT_FLAGS) {
3103         track->default_sample_flags =
3104             track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
3105             (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
3106             MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
3107         avio_wb32(pb, track->default_sample_flags);
3108     }
3109
3110     return update_size(pb, pos);
3111 }
3112
3113 static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
3114 {
3115     return entry->flags & MOV_SYNC_SAMPLE ? MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO :
3116            (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC);
3117 }
3118
3119 static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov,
3120                               MOVTrack *track, int moof_size)
3121 {
3122     int64_t pos = avio_tell(pb);
3123     uint32_t flags = MOV_TRUN_DATA_OFFSET;
3124     int i;
3125
3126     for (i = 0; i < track->entry; i++) {
3127         if (get_cluster_duration(track, i) != track->default_duration)
3128             flags |= MOV_TRUN_SAMPLE_DURATION;
3129         if (track->cluster[i].size != track->default_size)
3130             flags |= MOV_TRUN_SAMPLE_SIZE;
3131         if (i > 0 && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
3132             flags |= MOV_TRUN_SAMPLE_FLAGS;
3133     }
3134     if (!(flags & MOV_TRUN_SAMPLE_FLAGS))
3135         flags |= MOV_TRUN_FIRST_SAMPLE_FLAGS;
3136     if (track->flags & MOV_TRACK_CTTS)
3137         flags |= MOV_TRUN_SAMPLE_CTS;
3138
3139     avio_wb32(pb, 0); /* size placeholder */
3140     ffio_wfourcc(pb, "trun");
3141     avio_w8(pb, 0); /* version */
3142     avio_wb24(pb, flags);
3143
3144     avio_wb32(pb, track->entry); /* sample count */
3145     if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
3146         !(mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) &&
3147         track->track_id != 1)
3148         avio_wb32(pb, 0); /* Later tracks follow immediately after the previous one */
3149     else
3150         avio_wb32(pb, moof_size + 8 + track->data_offset +
3151                       track->cluster[0].pos); /* data offset */
3152     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS)
3153         avio_wb32(pb, get_sample_flags(track, &track->cluster[0]));
3154
3155     for (i = 0; i < track->entry; i++) {
3156         if (flags & MOV_TRUN_SAMPLE_DURATION)
3157             avio_wb32(pb, get_cluster_duration(track, i));
3158         if (flags & MOV_TRUN_SAMPLE_SIZE)
3159             avio_wb32(pb, track->cluster[i].size);
3160         if (flags & MOV_TRUN_SAMPLE_FLAGS)
3161             avio_wb32(pb, get_sample_flags(track, &track->cluster[i]));
3162         if (flags & MOV_TRUN_SAMPLE_CTS)
3163             avio_wb32(pb, track->cluster[i].cts);
3164     }
3165
3166     return update_size(pb, pos);
3167 }
3168
3169 static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
3170 {
3171     int64_t pos = avio_tell(pb);
3172     static const uint8_t uuid[] = {
3173         0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
3174         0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
3175     };
3176
3177     avio_wb32(pb, 0); /* size placeholder */
3178     ffio_wfourcc(pb, "uuid");
3179     avio_write(pb, uuid, sizeof(uuid));
3180     avio_w8(pb, 1);
3181     avio_wb24(pb, 0);
3182     avio_wb64(pb, track->frag_start);
3183     avio_wb64(pb, track->start_dts + track->track_duration -
3184                   track->cluster[0].dts);
3185
3186     return update_size(pb, pos);
3187 }
3188
3189 static int mov_write_tfrf_tag(AVIOContext *pb, MOVMuxContext *mov,
3190                               MOVTrack *track, int entry)
3191 {
3192     int n = track->nb_frag_info - 1 - entry, i;
3193     int size = 8 + 16 + 4 + 1 + 16*n;
3194     static const uint8_t uuid[] = {
3195         0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
3196         0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
3197     };
3198
3199     if (entry < 0)
3200         return 0;
3201
3202     avio_seek(pb, track->frag_info[entry].tfrf_offset, SEEK_SET);
3203     avio_wb32(pb, size);
3204     ffio_wfourcc(pb, "uuid");
3205     avio_write(pb, uuid, sizeof(uuid));
3206     avio_w8(pb, 1);
3207     avio_wb24(pb, 0);
3208     avio_w8(pb, n);
3209     for (i = 0; i < n; i++) {
3210         int index = entry + 1 + i;
3211         avio_wb64(pb, track->frag_info[index].time);
3212         avio_wb64(pb, track->frag_info[index].duration);
3213     }
3214     if (n < mov->ism_lookahead) {
3215         int free_size = 16 * (mov->ism_lookahead - n);
3216         avio_wb32(pb, free_size);
3217         ffio_wfourcc(pb, "free");
3218         ffio_fill(pb, 0, free_size - 8);
3219     }
3220
3221     return 0;
3222 }
3223
3224 static int mov_write_tfrf_tags(AVIOContext *pb, MOVMuxContext *mov,
3225                                MOVTrack *track)
3226 {
3227     int64_t pos = avio_tell(pb);
3228     int i;
3229     for (i = 0; i < mov->ism_lookahead; i++) {
3230         /* Update the tfrf tag for the last ism_lookahead fragments,
3231          * nb_frag_info - 1 is the next fragment to be written. */
3232         mov_write_tfrf_tag(pb, mov, track, track->nb_frag_info - 2 - i);
3233     }
3234     avio_seek(pb, pos, SEEK_SET);
3235     return 0;
3236 }
3237
3238 static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov,
3239                               MOVTrack *track, int64_t moof_offset,
3240                               int moof_size)
3241 {
3242     int64_t pos = avio_tell(pb);
3243     avio_wb32(pb, 0); /* size placeholder */
3244     ffio_wfourcc(pb, "traf");
3245
3246     mov_write_tfhd_tag(pb, mov, track, moof_offset);
3247     mov_write_trun_tag(pb, mov, track, moof_size);
3248     if (mov->mode == MODE_ISM) {
3249         mov_write_tfxd_tag(pb, track);
3250
3251         if (mov->ism_lookahead) {
3252             int i, size = 16 + 4 + 1 + 16 * mov->ism_lookahead;
3253
3254             track->tfrf_offset = avio_tell(pb);
3255             avio_wb32(pb, 8 + size);
3256             ffio_wfourcc(pb, "free");
3257             for (i = 0; i < size; i++)
3258                 avio_w8(pb, 0);
3259         }
3260     }
3261
3262     return update_size(pb, pos);
3263 }
3264
3265 static int mov_write_moof_tag_internal(AVIOContext *pb, MOVMuxContext *mov,
3266                                        int tracks, int moof_size)
3267 {
3268     int64_t pos = avio_tell(pb);
3269     int i;
3270
3271     avio_wb32(pb, 0); /* size placeholder */
3272     ffio_wfourcc(pb, "moof");
3273
3274     mov_write_mfhd_tag(pb, mov);
3275     for (i = 0; i < mov->nb_streams; i++) {
3276         MOVTrack *track = &mov->tracks[i];
3277         if (tracks >= 0 && i != tracks)
3278             continue;
3279         if (!track->entry)
3280             continue;
3281         mov_write_traf_tag(pb, mov, track, pos, moof_size);
3282     }
3283
3284     return update_size(pb, pos);
3285 }
3286
3287 static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
3288 {
3289     AVIOContext *avio_buf;
3290     int ret, moof_size;
3291
3292     if ((ret = ffio_open_null_buf(&avio_buf)) < 0)
3293         return ret;
3294     mov_write_moof_tag_internal(avio_buf, mov, tracks, 0);
3295     moof_size = ffio_close_null_buf(avio_buf);
3296     return mov_write_moof_tag_internal(pb, mov, tracks, moof_size);
3297 }
3298
3299 static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
3300 {
3301     int64_t pos = avio_tell(pb);
3302     int i;
3303
3304     avio_wb32(pb, 0); /* size placeholder */
3305     ffio_wfourcc(pb, "tfra");
3306     avio_w8(pb, 1); /* version */
3307     avio_wb24(pb, 0);
3308
3309     avio_wb32(pb, track->track_id);
3310     avio_wb32(pb, 0); /* length of traf/trun/sample num */
3311     avio_wb32(pb, track->nb_frag_info);
3312     for (i = 0; i < track->nb_frag_info; i++) {
3313         avio_wb64(pb, track->frag_info[i].time);
3314         avio_wb64(pb, track->frag_info[i].offset);
3315         avio_w8(pb, 1); /* traf number */
3316         avio_w8(pb, 1); /* trun number */
3317         avio_w8(pb, 1); /* sample number */
3318     }
3319
3320     return update_size(pb, pos);
3321 }
3322
3323 static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
3324 {
3325     int64_t pos = avio_tell(pb);
3326     int i;
3327
3328     avio_wb32(pb, 0); /* size placeholder */
3329     ffio_wfourcc(pb, "mfra");
3330     /* An empty mfra atom is enough to indicate to the publishing point that
3331      * the stream has ended. */
3332     if (mov->flags & FF_MOV_FLAG_ISML)
3333         return update_size(pb, pos);
3334
3335     for (i = 0; i < mov->nb_streams; i++) {
3336         MOVTrack *track = &mov->tracks[i];
3337         if (track->nb_frag_info)
3338             mov_write_tfra_tag(pb, track);
3339     }
3340
3341     avio_wb32(pb, 16);
3342     ffio_wfourcc(pb, "mfro");
3343     avio_wb32(pb, 0); /* version + flags */
3344     avio_wb32(pb, avio_tell(pb) + 4 - pos);
3345
3346     return update_size(pb, pos);
3347 }
3348
3349 static int mov_write_mdat_tag(AVIOContext *pb, MOVMuxContext *mov)
3350 {
3351     avio_wb32(pb, 8);    // placeholder for extended size field (64 bit)
3352     ffio_wfourcc(pb, mov->mode == MODE_MOV ? "wide" : "free");
3353
3354     mov->mdat_pos = avio_tell(pb);
3355     avio_wb32(pb, 0); /* size placeholder*/
3356     ffio_wfourcc(pb, "mdat");
3357     return 0;
3358 }