Merge commit '95ee4e2ce774e0339632d067161596bf3dadfc72'
[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         /* In the positive delay case, the delay includes the cts
2215          * offset, and the second edit list entry below trims out
2216          * the same amount from the actual content. This makes sure
2217          * that the offsetted last sample is included in the edit
2218          * list duration as well. */
2219         if (version == 1) {
2220             avio_wb64(pb, delay);
2221             avio_wb64(pb, -1);
2222         } else {
2223             avio_wb32(pb, delay);
2224             avio_wb32(pb, -1);
2225         }
2226         avio_wb32(pb, 0x00010000);
2227     } else {
2228         /* Avoid accidentally ending up with start_ct = -1 which has got a
2229          * special meaning. Normally start_ct should end up positive or zero
2230          * here, but use FFMIN in case dts is a a small positive integer
2231          * rounded to 0 when represented in MOV_TIMESCALE units. */
2232         av_assert0(av_rescale_rnd(track->cluster[0].dts, MOV_TIMESCALE, track->timescale, AV_ROUND_DOWN) <= 0);
2233         start_ct  = -FFMIN(track->cluster[0].dts, 0);
2234         /* Note, this delay is calculated from the pts of the first sample,
2235          * ensuring that we don't reduce the duration for cases with
2236          * dts<0 pts=0. */
2237         duration += delay;
2238     }
2239
2240     /* duration */
2241     if (version == 1) {
2242         avio_wb64(pb, duration);
2243         avio_wb64(pb, start_ct);
2244     } else {
2245         avio_wb32(pb, duration);
2246         avio_wb32(pb, start_ct);
2247     }
2248     avio_wb32(pb, 0x00010000);
2249     return size;
2250 }
2251
2252 static int mov_write_tref_tag(AVIOContext *pb, MOVTrack *track)
2253 {
2254     avio_wb32(pb, 20);   // size
2255     ffio_wfourcc(pb, "tref");
2256     avio_wb32(pb, 12);   // size (subatom)
2257     avio_wl32(pb, track->tref_tag);
2258     avio_wb32(pb, track->tref_id);
2259     return 20;
2260 }
2261
2262 // goes at the end of each track!  ... Critical for PSP playback ("Incompatible data" without it)
2263 static int mov_write_uuid_tag_psp(AVIOContext *pb, MOVTrack *mov)
2264 {
2265     avio_wb32(pb, 0x34); /* size ... reports as 28 in mp4box! */
2266     ffio_wfourcc(pb, "uuid");
2267     ffio_wfourcc(pb, "USMT");
2268     avio_wb32(pb, 0x21d24fce);
2269     avio_wb32(pb, 0xbb88695c);
2270     avio_wb32(pb, 0xfac9c740);
2271     avio_wb32(pb, 0x1c);     // another size here!
2272     ffio_wfourcc(pb, "MTDT");
2273     avio_wb32(pb, 0x00010012);
2274     avio_wb32(pb, 0x0a);
2275     avio_wb32(pb, 0x55c40000);
2276     avio_wb32(pb, 0x1);
2277     avio_wb32(pb, 0x0);
2278     return 0x34;
2279 }
2280
2281 static int mov_write_udta_sdp(AVIOContext *pb, MOVTrack *track)
2282 {
2283     AVFormatContext *ctx = track->rtp_ctx;
2284     char buf[1000] = "";
2285     int len;
2286
2287     ff_sdp_write_media(buf, sizeof(buf), ctx->streams[0], track->src_track,
2288                        NULL, NULL, 0, 0, ctx);
2289     av_strlcatf(buf, sizeof(buf), "a=control:streamid=%d\r\n", track->track_id);
2290     len = strlen(buf);
2291
2292     avio_wb32(pb, len + 24);
2293     ffio_wfourcc(pb, "udta");
2294     avio_wb32(pb, len + 16);
2295     ffio_wfourcc(pb, "hnti");
2296     avio_wb32(pb, len + 8);
2297     ffio_wfourcc(pb, "sdp ");
2298     avio_write(pb, buf, len);
2299     return len + 24;
2300 }
2301
2302 static int mov_write_track_metadata(AVIOContext *pb, AVStream *st,
2303                                     const char *tag, const char *str)
2304 {
2305     int64_t pos = avio_tell(pb);
2306     AVDictionaryEntry *t = av_dict_get(st->metadata, str, NULL, 0);
2307     if (!t || !utf8len(t->value))
2308         return 0;
2309
2310     avio_wb32(pb, 0);   /* size */
2311     ffio_wfourcc(pb, tag); /* type */
2312     avio_write(pb, t->value, strlen(t->value)); /* UTF8 string value */
2313     return update_size(pb, pos);
2314 }
2315
2316 static int mov_write_track_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
2317                                     AVStream *st)
2318 {
2319     AVIOContext *pb_buf;
2320     int ret, size;
2321     uint8_t *buf;
2322
2323     if (!st || mov->fc->flags & AVFMT_FLAG_BITEXACT)
2324         return 0;
2325
2326     ret = avio_open_dyn_buf(&pb_buf);
2327     if (ret < 0)
2328         return ret;
2329
2330     if (mov->mode & MODE_MP4)
2331         mov_write_track_metadata(pb_buf, st, "name", "title");
2332
2333     if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
2334         avio_wb32(pb, size + 8);
2335         ffio_wfourcc(pb, "udta");
2336         avio_write(pb, buf, size);
2337     }
2338     av_free(buf);
2339
2340     return 0;
2341 }
2342
2343 static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov,
2344                               MOVTrack *track, AVStream *st)
2345 {
2346     int64_t pos = avio_tell(pb);
2347     avio_wb32(pb, 0); /* size */
2348     ffio_wfourcc(pb, "trak");
2349     mov_write_tkhd_tag(pb, mov, track, st);
2350     if (supports_edts(mov))
2351         mov_write_edts_tag(pb, track);  // PSP Movies and several other cases require edts box
2352     if (track->tref_tag)
2353         mov_write_tref_tag(pb, track);
2354     mov_write_mdia_tag(pb, track);
2355     if (track->mode == MODE_PSP)
2356         mov_write_uuid_tag_psp(pb, track); // PSP Movies require this uuid box
2357     if (track->tag == MKTAG('r','t','p',' '))
2358         mov_write_udta_sdp(pb, track);
2359     if (track->mode == MODE_MOV) {
2360         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2361             double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
2362             if (st->sample_aspect_ratio.num && 1.0 != sample_aspect_ratio) {
2363                 mov_write_tapt_tag(pb, track);
2364             }
2365         }
2366         if (is_clcp_track(track) && st->sample_aspect_ratio.num) {
2367             mov_write_tapt_tag(pb, track);
2368         }
2369     }
2370     mov_write_track_udta_tag(pb, mov, st);
2371     return update_size(pb, pos);
2372 }
2373
2374 static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov)
2375 {
2376     int i, has_audio = 0, has_video = 0;
2377     int64_t pos = avio_tell(pb);
2378     int audio_profile = mov->iods_audio_profile;
2379     int video_profile = mov->iods_video_profile;
2380     for (i = 0; i < mov->nb_streams; i++) {
2381         if (mov->tracks[i].entry > 0) {
2382             has_audio |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_AUDIO;
2383             has_video |= mov->tracks[i].enc->codec_type == AVMEDIA_TYPE_VIDEO;
2384         }
2385     }
2386     if (audio_profile < 0)
2387         audio_profile = 0xFF - has_audio;
2388     if (video_profile < 0)
2389         video_profile = 0xFF - has_video;
2390     avio_wb32(pb, 0x0); /* size */
2391     ffio_wfourcc(pb, "iods");
2392     avio_wb32(pb, 0);    /* version & flags */
2393     put_descr(pb, 0x10, 7);
2394     avio_wb16(pb, 0x004f);
2395     avio_w8(pb, 0xff);
2396     avio_w8(pb, 0xff);
2397     avio_w8(pb, audio_profile);
2398     avio_w8(pb, video_profile);
2399     avio_w8(pb, 0xff);
2400     return update_size(pb, pos);
2401 }
2402
2403 static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
2404 {
2405     avio_wb32(pb, 0x20); /* size */
2406     ffio_wfourcc(pb, "trex");
2407     avio_wb32(pb, 0);   /* version & flags */
2408     avio_wb32(pb, track->track_id); /* track ID */
2409     avio_wb32(pb, 1);   /* default sample description index */
2410     avio_wb32(pb, 0);   /* default sample duration */
2411     avio_wb32(pb, 0);   /* default sample size */
2412     avio_wb32(pb, 0);   /* default sample flags */
2413     return 0;
2414 }
2415
2416 static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov)
2417 {
2418     int64_t pos = avio_tell(pb);
2419     int i;
2420     avio_wb32(pb, 0x0); /* size */
2421     ffio_wfourcc(pb, "mvex");
2422     for (i = 0; i < mov->nb_streams; i++)
2423         mov_write_trex_tag(pb, &mov->tracks[i]);
2424     return update_size(pb, pos);
2425 }
2426
2427 static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
2428 {
2429     int max_track_id = 1, i;
2430     int64_t max_track_len_temp, max_track_len = 0;
2431     int version;
2432
2433     for (i = 0; i < mov->nb_streams; i++) {
2434         if (mov->tracks[i].entry > 0 && mov->tracks[i].timescale) {
2435             max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
2436                                                 MOV_TIMESCALE,
2437                                                 mov->tracks[i].timescale,
2438                                                 AV_ROUND_UP);
2439             if (max_track_len < max_track_len_temp)
2440                 max_track_len = max_track_len_temp;
2441             if (max_track_id < mov->tracks[i].track_id)
2442                 max_track_id = mov->tracks[i].track_id;
2443         }
2444     }
2445
2446     version = max_track_len < UINT32_MAX ? 0 : 1;
2447     (version == 1) ? avio_wb32(pb, 120) : avio_wb32(pb, 108); /* size */
2448     ffio_wfourcc(pb, "mvhd");
2449     avio_w8(pb, version);
2450     avio_wb24(pb, 0); /* flags */
2451     if (version == 1) {
2452         avio_wb64(pb, mov->time);
2453         avio_wb64(pb, mov->time);
2454     } else {
2455         avio_wb32(pb, mov->time); /* creation time */
2456         avio_wb32(pb, mov->time); /* modification time */
2457     }
2458     avio_wb32(pb, MOV_TIMESCALE);
2459     (version == 1) ? avio_wb64(pb, max_track_len) : avio_wb32(pb, max_track_len); /* duration of longest track */
2460
2461     avio_wb32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
2462     avio_wb16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
2463     avio_wb16(pb, 0); /* reserved */
2464     avio_wb32(pb, 0); /* reserved */
2465     avio_wb32(pb, 0); /* reserved */
2466
2467     /* Matrix structure */
2468     write_matrix(pb, 1, 0, 0, 1, 0, 0);
2469
2470     avio_wb32(pb, 0); /* reserved (preview time) */
2471     avio_wb32(pb, 0); /* reserved (preview duration) */
2472     avio_wb32(pb, 0); /* reserved (poster time) */
2473     avio_wb32(pb, 0); /* reserved (selection time) */
2474     avio_wb32(pb, 0); /* reserved (selection duration) */
2475     avio_wb32(pb, 0); /* reserved (current time) */
2476     avio_wb32(pb, max_track_id + 1); /* Next track id */
2477     return 0x6c;
2478 }
2479
2480 static int mov_write_itunes_hdlr_tag(AVIOContext *pb, MOVMuxContext *mov,
2481                                      AVFormatContext *s)
2482 {
2483     avio_wb32(pb, 33); /* size */
2484     ffio_wfourcc(pb, "hdlr");
2485     avio_wb32(pb, 0);
2486     avio_wb32(pb, 0);
2487     ffio_wfourcc(pb, "mdir");
2488     ffio_wfourcc(pb, "appl");
2489     avio_wb32(pb, 0);
2490     avio_wb32(pb, 0);
2491     avio_w8(pb, 0);
2492     return 33;
2493 }
2494
2495 /* helper function to write a data tag with the specified string as data */
2496 static int mov_write_string_data_tag(AVIOContext *pb, const char *data, int lang, int long_style)
2497 {
2498     if (long_style) {
2499         int size = 16 + strlen(data);
2500         avio_wb32(pb, size); /* size */
2501         ffio_wfourcc(pb, "data");
2502         avio_wb32(pb, 1);
2503         avio_wb32(pb, 0);
2504         avio_write(pb, data, strlen(data));
2505         return size;
2506     } else {
2507         if (!lang)
2508             lang = ff_mov_iso639_to_lang("und", 1);
2509         avio_wb16(pb, strlen(data)); /* string length */
2510         avio_wb16(pb, lang);
2511         avio_write(pb, data, strlen(data));
2512         return strlen(data) + 4;
2513     }
2514 }
2515
2516 static int mov_write_string_tag(AVIOContext *pb, const char *name,
2517                                 const char *value, int lang, int long_style)
2518 {
2519     int size = 0;
2520     if (value && value[0]) {
2521         int64_t pos = avio_tell(pb);
2522         avio_wb32(pb, 0); /* size */
2523         ffio_wfourcc(pb, name);
2524         mov_write_string_data_tag(pb, value, lang, long_style);
2525         size = update_size(pb, pos);
2526     }
2527     return size;
2528 }
2529
2530 static int mov_write_string_metadata(AVFormatContext *s, AVIOContext *pb,
2531                                      const char *name, const char *tag,
2532                                      int long_style)
2533 {
2534     int l, lang = 0, len, len2;
2535     AVDictionaryEntry *t, *t2 = NULL;
2536     char tag2[16];
2537
2538     if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
2539         return 0;
2540
2541     len = strlen(t->key);
2542     snprintf(tag2, sizeof(tag2), "%s-", tag);
2543     while ((t2 = av_dict_get(s->metadata, tag2, t2, AV_DICT_IGNORE_SUFFIX))) {
2544         len2 = strlen(t2->key);
2545         if (len2 == len + 4 && !strcmp(t->value, t2->value)
2546             && (l = ff_mov_iso639_to_lang(&t2->key[len2 - 3], 1)) >= 0) {
2547             lang = l;
2548             break;
2549         }
2550     }
2551     return mov_write_string_tag(pb, name, t->value, lang, long_style);
2552 }
2553
2554 /* iTunes bpm number */
2555 static int mov_write_tmpo_tag(AVIOContext *pb, AVFormatContext *s)
2556 {
2557     AVDictionaryEntry *t = av_dict_get(s->metadata, "tmpo", NULL, 0);
2558     int size = 0, tmpo = t ? atoi(t->value) : 0;
2559     if (tmpo) {
2560         size = 26;
2561         avio_wb32(pb, size);
2562         ffio_wfourcc(pb, "tmpo");
2563         avio_wb32(pb, size-8); /* size */
2564         ffio_wfourcc(pb, "data");
2565         avio_wb32(pb, 0x15);  //type specifier
2566         avio_wb32(pb, 0);
2567         avio_wb16(pb, tmpo);        // data
2568     }
2569     return size;
2570 }
2571
2572 /* iTunes track or disc number */
2573 static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov,
2574                               AVFormatContext *s, int disc)
2575 {
2576     AVDictionaryEntry *t = av_dict_get(s->metadata,
2577                                        disc ? "disc" : "track",
2578                                        NULL, 0);
2579     int size = 0, track = t ? atoi(t->value) : 0;
2580     if (track) {
2581         int tracks = 0;
2582         char *slash = strchr(t->value, '/');
2583         if (slash)
2584             tracks = atoi(slash + 1);
2585         avio_wb32(pb, 32); /* size */
2586         ffio_wfourcc(pb, disc ? "disk" : "trkn");
2587         avio_wb32(pb, 24); /* size */
2588         ffio_wfourcc(pb, "data");
2589         avio_wb32(pb, 0);        // 8 bytes empty
2590         avio_wb32(pb, 0);
2591         avio_wb16(pb, 0);        // empty
2592         avio_wb16(pb, track);    // track / disc number
2593         avio_wb16(pb, tracks);   // total track / disc number
2594         avio_wb16(pb, 0);        // empty
2595         size = 32;
2596     }
2597     return size;
2598 }
2599
2600 static int mov_write_int8_metadata(AVFormatContext *s, AVIOContext *pb,
2601                                    const char *name, const char *tag,
2602                                    int len)
2603 {
2604     AVDictionaryEntry *t = NULL;
2605     uint8_t num;
2606     int size = 24 + len;
2607
2608     if (len != 1 && len != 4)
2609         return -1;
2610
2611     if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
2612         return 0;
2613     num = atoi(t->value);
2614
2615     avio_wb32(pb, size);
2616     ffio_wfourcc(pb, name);
2617     avio_wb32(pb, size - 8);
2618     ffio_wfourcc(pb, "data");
2619     avio_wb32(pb, 0x15);
2620     avio_wb32(pb, 0);
2621     if (len==4) avio_wb32(pb, num);
2622     else        avio_w8 (pb, num);
2623
2624     return size;
2625 }
2626
2627 /* iTunes meta data list */
2628 static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
2629                               AVFormatContext *s)
2630 {
2631     int64_t pos = avio_tell(pb);
2632     avio_wb32(pb, 0); /* size */
2633     ffio_wfourcc(pb, "ilst");
2634     mov_write_string_metadata(s, pb, "\251nam", "title"    , 1);
2635     mov_write_string_metadata(s, pb, "\251ART", "artist"   , 1);
2636     mov_write_string_metadata(s, pb, "aART", "album_artist", 1);
2637     mov_write_string_metadata(s, pb, "\251wrt", "composer" , 1);
2638     mov_write_string_metadata(s, pb, "\251alb", "album"    , 1);
2639     mov_write_string_metadata(s, pb, "\251day", "date"     , 1);
2640     if (!mov->exact &&
2641         !mov_write_string_metadata(s, pb, "\251too", "encoding_tool", 1))
2642         mov_write_string_tag(pb, "\251too", LIBAVFORMAT_IDENT, 0, 1);
2643     mov_write_string_metadata(s, pb, "\251cmt", "comment"  , 1);
2644     mov_write_string_metadata(s, pb, "\251gen", "genre"    , 1);
2645     mov_write_string_metadata(s, pb, "\251cpy", "copyright", 1);
2646     mov_write_string_metadata(s, pb, "\251grp", "grouping" , 1);
2647     mov_write_string_metadata(s, pb, "\251lyr", "lyrics"   , 1);
2648     mov_write_string_metadata(s, pb, "desc",    "description",1);
2649     mov_write_string_metadata(s, pb, "ldes",    "synopsis" , 1);
2650     mov_write_string_metadata(s, pb, "tvsh",    "show"     , 1);
2651     mov_write_string_metadata(s, pb, "tven",    "episode_id",1);
2652     mov_write_string_metadata(s, pb, "tvnn",    "network"  , 1);
2653     mov_write_int8_metadata  (s, pb, "tves",    "episode_sort",4);
2654     mov_write_int8_metadata  (s, pb, "tvsn",    "season_number",4);
2655     mov_write_int8_metadata  (s, pb, "stik",    "media_type",1);
2656     mov_write_int8_metadata  (s, pb, "hdvd",    "hd_video",  1);
2657     mov_write_int8_metadata  (s, pb, "pgap",    "gapless_playback",1);
2658     mov_write_int8_metadata  (s, pb, "cpil",    "compilation", 1);
2659     mov_write_trkn_tag(pb, mov, s, 0); // track number
2660     mov_write_trkn_tag(pb, mov, s, 1); // disc number
2661     mov_write_tmpo_tag(pb, s);
2662     return update_size(pb, pos);
2663 }
2664
2665 /* iTunes meta data tag */
2666 static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov,
2667                               AVFormatContext *s)
2668 {
2669     int size = 0;
2670     int64_t pos = avio_tell(pb);
2671     avio_wb32(pb, 0); /* size */
2672     ffio_wfourcc(pb, "meta");
2673     avio_wb32(pb, 0);
2674     mov_write_itunes_hdlr_tag(pb, mov, s);
2675     mov_write_ilst_tag(pb, mov, s);
2676     size = update_size(pb, pos);
2677     return size;
2678 }
2679
2680 static int mov_write_raw_metadata_tag(AVFormatContext *s, AVIOContext *pb,
2681                                       const char *name, const char *key)
2682 {
2683     int len;
2684     AVDictionaryEntry *t;
2685
2686     if (!(t = av_dict_get(s->metadata, key, NULL, 0)))
2687         return 0;
2688
2689     len = strlen(t->value);
2690     if (len > 0) {
2691         int size = len + 8;
2692         avio_wb32(pb, size);
2693         ffio_wfourcc(pb, name);
2694         avio_write(pb, t->value, len);
2695         return size;
2696     }
2697     return 0;
2698 }
2699
2700 static int ascii_to_wc(AVIOContext *pb, const uint8_t *b)
2701 {
2702     int val;
2703     while (*b) {
2704         GET_UTF8(val, *b++, return -1;)
2705         avio_wb16(pb, val);
2706     }
2707     avio_wb16(pb, 0x00);
2708     return 0;
2709 }
2710
2711 static uint16_t language_code(const char *str)
2712 {
2713     return (((str[0] - 0x60) & 0x1F) << 10) +
2714            (((str[1] - 0x60) & 0x1F) <<  5) +
2715            (( str[2] - 0x60) & 0x1F);
2716 }
2717
2718 static int mov_write_3gp_udta_tag(AVIOContext *pb, AVFormatContext *s,
2719                                   const char *tag, const char *str)
2720 {
2721     int64_t pos = avio_tell(pb);
2722     AVDictionaryEntry *t = av_dict_get(s->metadata, str, NULL, 0);
2723     if (!t || !utf8len(t->value))
2724         return 0;
2725     avio_wb32(pb, 0);   /* size */
2726     ffio_wfourcc(pb, tag); /* type */
2727     avio_wb32(pb, 0);   /* version + flags */
2728     if (!strcmp(tag, "yrrc"))
2729         avio_wb16(pb, atoi(t->value));
2730     else {
2731         avio_wb16(pb, language_code("eng")); /* language */
2732         avio_write(pb, t->value, strlen(t->value) + 1); /* UTF8 string value */
2733         if (!strcmp(tag, "albm") &&
2734             (t = av_dict_get(s->metadata, "track", NULL, 0)))
2735             avio_w8(pb, atoi(t->value));
2736     }
2737     return update_size(pb, pos);
2738 }
2739
2740 static int mov_write_chpl_tag(AVIOContext *pb, AVFormatContext *s)
2741 {
2742     int64_t pos = avio_tell(pb);
2743     int i, nb_chapters = FFMIN(s->nb_chapters, 255);
2744
2745     avio_wb32(pb, 0);            // size
2746     ffio_wfourcc(pb, "chpl");
2747     avio_wb32(pb, 0x01000000);   // version + flags
2748     avio_wb32(pb, 0);            // unknown
2749     avio_w8(pb, nb_chapters);
2750
2751     for (i = 0; i < nb_chapters; i++) {
2752         AVChapter *c = s->chapters[i];
2753         AVDictionaryEntry *t;
2754         avio_wb64(pb, av_rescale_q(c->start, c->time_base, (AVRational){1,10000000}));
2755
2756         if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
2757             int len = FFMIN(strlen(t->value), 255);
2758             avio_w8(pb, len);
2759             avio_write(pb, t->value, len);
2760         } else
2761             avio_w8(pb, 0);
2762     }
2763     return update_size(pb, pos);
2764 }
2765
2766 static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
2767                               AVFormatContext *s)
2768 {
2769     AVIOContext *pb_buf;
2770     int ret, size;
2771     uint8_t *buf;
2772
2773     ret = avio_open_dyn_buf(&pb_buf);
2774     if (ret < 0)
2775         return ret;
2776
2777     if (mov->mode & MODE_3GP) {
2778         mov_write_3gp_udta_tag(pb_buf, s, "perf", "artist");
2779         mov_write_3gp_udta_tag(pb_buf, s, "titl", "title");
2780         mov_write_3gp_udta_tag(pb_buf, s, "auth", "author");
2781         mov_write_3gp_udta_tag(pb_buf, s, "gnre", "genre");
2782         mov_write_3gp_udta_tag(pb_buf, s, "dscp", "comment");
2783         mov_write_3gp_udta_tag(pb_buf, s, "albm", "album");
2784         mov_write_3gp_udta_tag(pb_buf, s, "cprt", "copyright");
2785         mov_write_3gp_udta_tag(pb_buf, s, "yrrc", "date");
2786     } else if (mov->mode == MODE_MOV) { // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
2787         mov_write_string_metadata(s, pb_buf, "\251ART", "artist",      0);
2788         mov_write_string_metadata(s, pb_buf, "\251nam", "title",       0);
2789         mov_write_string_metadata(s, pb_buf, "\251aut", "author",      0);
2790         mov_write_string_metadata(s, pb_buf, "\251alb", "album",       0);
2791         mov_write_string_metadata(s, pb_buf, "\251day", "date",        0);
2792         mov_write_string_metadata(s, pb_buf, "\251swr", "encoder",     0);
2793         // currently ignored by mov.c
2794         mov_write_string_metadata(s, pb_buf, "\251des", "comment",     0);
2795         // add support for libquicktime, this atom is also actually read by mov.c
2796         mov_write_string_metadata(s, pb_buf, "\251cmt", "comment",     0);
2797         mov_write_string_metadata(s, pb_buf, "\251gen", "genre",       0);
2798         mov_write_string_metadata(s, pb_buf, "\251cpy", "copyright",   0);
2799         mov_write_raw_metadata_tag(s, pb_buf, "XMP_", "xmp");
2800     } else {
2801         /* iTunes meta data */
2802         mov_write_meta_tag(pb_buf, mov, s);
2803     }
2804
2805     if (s->nb_chapters && !(mov->flags & FF_MOV_FLAG_DISABLE_CHPL))
2806         mov_write_chpl_tag(pb_buf, s);
2807
2808     if ((size = avio_close_dyn_buf(pb_buf, &buf)) > 0) {
2809         avio_wb32(pb, size + 8);
2810         ffio_wfourcc(pb, "udta");
2811         avio_write(pb, buf, size);
2812     }
2813     av_free(buf);
2814
2815     return 0;
2816 }
2817
2818 static void mov_write_psp_udta_tag(AVIOContext *pb,
2819                                    const char *str, const char *lang, int type)
2820 {
2821     int len = utf8len(str) + 1;
2822     if (len <= 0)
2823         return;
2824     avio_wb16(pb, len * 2 + 10);        /* size */
2825     avio_wb32(pb, type);                /* type */
2826     avio_wb16(pb, language_code(lang)); /* language */
2827     avio_wb16(pb, 0x01);                /* ? */
2828     ascii_to_wc(pb, str);
2829 }
2830
2831 static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
2832 {
2833     MOVMuxContext *mov = s->priv_data;
2834     AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
2835     int64_t pos, pos2;
2836
2837     if (title) {
2838         pos = avio_tell(pb);
2839         avio_wb32(pb, 0); /* size placeholder*/
2840         ffio_wfourcc(pb, "uuid");
2841         ffio_wfourcc(pb, "USMT");
2842         avio_wb32(pb, 0x21d24fce); /* 96 bit UUID */
2843         avio_wb32(pb, 0xbb88695c);
2844         avio_wb32(pb, 0xfac9c740);
2845
2846         pos2 = avio_tell(pb);
2847         avio_wb32(pb, 0); /* size placeholder*/
2848         ffio_wfourcc(pb, "MTDT");
2849         avio_wb16(pb, 4);
2850
2851         // ?
2852         avio_wb16(pb, 0x0C);                 /* size */
2853         avio_wb32(pb, 0x0B);                 /* type */
2854         avio_wb16(pb, language_code("und")); /* language */
2855         avio_wb16(pb, 0x0);                  /* ? */
2856         avio_wb16(pb, 0x021C);               /* data */
2857
2858         if (!mov->exact)
2859             mov_write_psp_udta_tag(pb, LIBAVCODEC_IDENT,      "eng", 0x04);
2860         mov_write_psp_udta_tag(pb, title->value,          "eng", 0x01);
2861         mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);
2862
2863         update_size(pb, pos2);
2864         return update_size(pb, pos);
2865     }
2866
2867     return 0;
2868 }
2869
2870 static void build_chunks(MOVTrack *trk)
2871 {
2872     int i;
2873     MOVIentry *chunk = &trk->cluster[0];
2874     uint64_t chunkSize = chunk->size;
2875     chunk->chunkNum = 1;
2876     if (trk->chunkCount)
2877         return;
2878     trk->chunkCount = 1;
2879     for (i = 1; i<trk->entry; i++){
2880         if (chunk->pos + chunkSize == trk->cluster[i].pos &&
2881             chunkSize + trk->cluster[i].size < (1<<20)){
2882             chunkSize             += trk->cluster[i].size;
2883             chunk->samples_in_chunk += trk->cluster[i].entries;
2884         } else {
2885             trk->cluster[i].chunkNum = chunk->chunkNum+1;
2886             chunk=&trk->cluster[i];
2887             chunkSize = chunk->size;
2888             trk->chunkCount++;
2889         }
2890     }
2891 }
2892
2893 static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
2894                               AVFormatContext *s)
2895 {
2896     int i;
2897     int64_t pos = avio_tell(pb);
2898     avio_wb32(pb, 0); /* size placeholder*/
2899     ffio_wfourcc(pb, "moov");
2900
2901     for (i = 0; i < mov->nb_streams; i++) {
2902         if (mov->tracks[i].entry <= 0 && !(mov->flags & FF_MOV_FLAG_FRAGMENT))
2903             continue;
2904
2905         mov->tracks[i].time     = mov->time;
2906         mov->tracks[i].track_id = i + 1;
2907
2908         if (mov->tracks[i].entry)
2909             build_chunks(&mov->tracks[i]);
2910     }
2911
2912     if (mov->chapter_track)
2913         for (i = 0; i < s->nb_streams; i++) {
2914             mov->tracks[i].tref_tag = MKTAG('c','h','a','p');
2915             mov->tracks[i].tref_id  = mov->tracks[mov->chapter_track].track_id;
2916         }
2917     for (i = 0; i < mov->nb_streams; i++) {
2918         if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) {
2919             mov->tracks[i].tref_tag = MKTAG('h','i','n','t');
2920             mov->tracks[i].tref_id =
2921                 mov->tracks[mov->tracks[i].src_track].track_id;
2922         }
2923     }
2924     for (i = 0; i < mov->nb_streams; i++) {
2925         if (mov->tracks[i].tag == MKTAG('t','m','c','d')) {
2926             int src_trk = mov->tracks[i].src_track;
2927             mov->tracks[src_trk].tref_tag = mov->tracks[i].tag;
2928             mov->tracks[src_trk].tref_id  = mov->tracks[i].track_id;
2929             //src_trk may have a different timescale than the tmcd track
2930             mov->tracks[i].track_duration = av_rescale(mov->tracks[src_trk].track_duration,
2931                                                        mov->tracks[i].timescale,
2932                                                        mov->tracks[src_trk].timescale);
2933         }
2934     }
2935
2936     mov_write_mvhd_tag(pb, mov);
2937     if (mov->mode != MODE_MOV && !mov->iods_skip)
2938         mov_write_iods_tag(pb, mov);
2939     for (i = 0; i < mov->nb_streams; i++) {
2940         if (mov->tracks[i].entry > 0 || mov->flags & FF_MOV_FLAG_FRAGMENT) {
2941             mov_write_trak_tag(pb, mov, &(mov->tracks[i]), i < s->nb_streams ? s->streams[i] : NULL);
2942         }
2943     }
2944     if (mov->flags & FF_MOV_FLAG_FRAGMENT)
2945         mov_write_mvex_tag(pb, mov); /* QuickTime requires trak to precede this */
2946
2947     if (mov->mode == MODE_PSP)
2948         mov_write_uuidusmt_tag(pb, s);
2949     else
2950         mov_write_udta_tag(pb, mov, s);
2951
2952     return update_size(pb, pos);
2953 }
2954
2955 static void param_write_int(AVIOContext *pb, const char *name, int value)
2956 {
2957     avio_printf(pb, "<param name=\"%s\" value=\"%d\" valuetype=\"data\"/>\n", name, value);
2958 }
2959
2960 static void param_write_string(AVIOContext *pb, const char *name, const char *value)
2961 {
2962     avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, value);
2963 }
2964
2965 static void param_write_hex(AVIOContext *pb, const char *name, const uint8_t *value, int len)
2966 {
2967     char buf[150];
2968     len = FFMIN(sizeof(buf) / 2 - 1, len);
2969     ff_data_to_hex(buf, value, len, 0);
2970     buf[2 * len] = '\0';
2971     avio_printf(pb, "<param name=\"%s\" value=\"%s\" valuetype=\"data\"/>\n", name, buf);
2972 }
2973
2974 static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
2975 {
2976     int64_t pos = avio_tell(pb);
2977     int i;
2978     static const uint8_t uuid[] = {
2979         0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
2980         0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
2981     };
2982
2983     avio_wb32(pb, 0);
2984     ffio_wfourcc(pb, "uuid");
2985     avio_write(pb, uuid, sizeof(uuid));
2986     avio_wb32(pb, 0);
2987
2988     avio_printf(pb, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
2989     avio_printf(pb, "<smil xmlns=\"http://www.w3.org/2001/SMIL20/Language\">\n");
2990     avio_printf(pb, "<head>\n");
2991     if (!mov->exact)
2992         avio_printf(pb, "<meta name=\"creator\" content=\"%s\" />\n",
2993                     LIBAVFORMAT_IDENT);
2994     avio_printf(pb, "</head>\n");
2995     avio_printf(pb, "<body>\n");
2996     avio_printf(pb, "<switch>\n");
2997     for (i = 0; i < mov->nb_streams; i++) {
2998         MOVTrack *track = &mov->tracks[i];
2999         const char *type;
3000         /* track->track_id is initialized in write_moov, and thus isn't known
3001          * here yet */
3002         int track_id = i + 1;
3003
3004         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
3005             type = "video";
3006         } else if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO) {
3007             type = "audio";
3008         } else {
3009             continue;
3010         }
3011         avio_printf(pb, "<%s systemBitrate=\"%d\">\n", type,
3012                                                        track->enc->bit_rate);
3013         param_write_int(pb, "systemBitrate", track->enc->bit_rate);
3014         param_write_int(pb, "trackID", track_id);
3015         if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO) {
3016             if (track->enc->codec_id == AV_CODEC_ID_H264) {
3017                 uint8_t *ptr;
3018                 int size = track->enc->extradata_size;
3019                 if (!ff_avc_write_annexb_extradata(track->enc->extradata, &ptr,
3020                                                    &size)) {
3021                     param_write_hex(pb, "CodecPrivateData",
3022                                     ptr ? ptr : track->enc->extradata,
3023                                     size);
3024                     av_free(ptr);
3025                 }
3026                 param_write_string(pb, "FourCC", "H264");
3027             } else if (track->enc->codec_id == AV_CODEC_ID_VC1) {
3028                 param_write_string(pb, "FourCC", "WVC1");
3029                 param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
3030                                 track->enc->extradata_size);
3031             }
3032             param_write_int(pb, "MaxWidth", track->enc->width);
3033             param_write_int(pb, "MaxHeight", track->enc->height);
3034             param_write_int(pb, "DisplayWidth", track->enc->width);
3035             param_write_int(pb, "DisplayHeight", track->enc->height);
3036         } else {
3037             if (track->enc->codec_id == AV_CODEC_ID_AAC) {
3038                 param_write_string(pb, "FourCC", "AACL");
3039             } else if (track->enc->codec_id == AV_CODEC_ID_WMAPRO) {
3040                 param_write_string(pb, "FourCC", "WMAP");
3041             }
3042             param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
3043                             track->enc->extradata_size);
3044             param_write_int(pb, "AudioTag", ff_codec_get_tag(ff_codec_wav_tags,
3045                                                              track->enc->codec_id));
3046             param_write_int(pb, "Channels", track->enc->channels);
3047             param_write_int(pb, "SamplingRate", track->enc->sample_rate);
3048             param_write_int(pb, "BitsPerSample", 16);
3049             param_write_int(pb, "PacketSize", track->enc->block_align ?
3050                                               track->enc->block_align : 4);
3051         }
3052         avio_printf(pb, "</%s>\n", type);
3053     }
3054     avio_printf(pb, "</switch>\n");
3055     avio_printf(pb, "</body>\n");
3056     avio_printf(pb, "</smil>\n");
3057
3058     return update_size(pb, pos);
3059 }
3060
3061 static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov)
3062 {
3063     avio_wb32(pb, 16);
3064     ffio_wfourcc(pb, "mfhd");
3065     avio_wb32(pb, 0);
3066     avio_wb32(pb, mov->fragments);
3067     return 0;
3068 }
3069
3070 static int mov_write_tfhd_tag(AVIOContext *pb, MOVMuxContext *mov,
3071                               MOVTrack *track, int64_t moof_offset)
3072 {
3073     int64_t pos = avio_tell(pb);
3074     uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
3075                      MOV_TFHD_BASE_DATA_OFFSET;
3076     if (!track->entry) {
3077         flags |= MOV_TFHD_DURATION_IS_EMPTY;
3078     } else {
3079         flags |= MOV_TFHD_DEFAULT_FLAGS;
3080     }
3081     if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET)
3082         flags &= ~MOV_TFHD_BASE_DATA_OFFSET;
3083
3084     /* Don't set a default sample size, the silverlight player refuses
3085      * to play files with that set. Don't set a default sample duration,
3086      * WMP freaks out if it is set. Don't set a base data offset, PIFF
3087      * file format says it MUST NOT be set. */
3088     if (track->mode == MODE_ISM)
3089         flags &= ~(MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
3090                    MOV_TFHD_BASE_DATA_OFFSET);
3091
3092     avio_wb32(pb, 0); /* size placeholder */
3093     ffio_wfourcc(pb, "tfhd");
3094     avio_w8(pb, 0); /* version */
3095     avio_wb24(pb, flags);
3096
3097     avio_wb32(pb, track->track_id); /* track-id */
3098     if (flags & MOV_TFHD_BASE_DATA_OFFSET)
3099         avio_wb64(pb, moof_offset);
3100     if (flags & MOV_TFHD_DEFAULT_DURATION) {
3101         track->default_duration = get_cluster_duration(track, 0);
3102         avio_wb32(pb, track->default_duration);
3103     }
3104     if (flags & MOV_TFHD_DEFAULT_SIZE) {
3105         track->default_size = track->entry ? track->cluster[0].size : 1;
3106         avio_wb32(pb, track->default_size);
3107     } else
3108         track->default_size = -1;
3109
3110     if (flags & MOV_TFHD_DEFAULT_FLAGS) {
3111         track->default_sample_flags =
3112             track->enc->codec_type == AVMEDIA_TYPE_VIDEO ?
3113             (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC) :
3114             MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO;
3115         avio_wb32(pb, track->default_sample_flags);
3116     }
3117
3118     return update_size(pb, pos);
3119 }
3120
3121 static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
3122 {
3123     return entry->flags & MOV_SYNC_SAMPLE ? MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO :
3124            (MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC);
3125 }
3126
3127 static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov,
3128                               MOVTrack *track, int moof_size)
3129 {
3130     int64_t pos = avio_tell(pb);
3131     uint32_t flags = MOV_TRUN_DATA_OFFSET;
3132     int i;
3133
3134     for (i = 0; i < track->entry; i++) {
3135         if (get_cluster_duration(track, i) != track->default_duration)
3136             flags |= MOV_TRUN_SAMPLE_DURATION;
3137         if (track->cluster[i].size != track->default_size)
3138             flags |= MOV_TRUN_SAMPLE_SIZE;
3139         if (i > 0 && get_sample_flags(track, &track->cluster[i]) != track->default_sample_flags)
3140             flags |= MOV_TRUN_SAMPLE_FLAGS;
3141     }
3142     if (!(flags & MOV_TRUN_SAMPLE_FLAGS))
3143         flags |= MOV_TRUN_FIRST_SAMPLE_FLAGS;
3144     if (track->flags & MOV_TRACK_CTTS)
3145         flags |= MOV_TRUN_SAMPLE_CTS;
3146
3147     avio_wb32(pb, 0); /* size placeholder */
3148     ffio_wfourcc(pb, "trun");
3149     avio_w8(pb, 0); /* version */
3150     avio_wb24(pb, flags);
3151
3152     avio_wb32(pb, track->entry); /* sample count */
3153     if (mov->flags & FF_MOV_FLAG_OMIT_TFHD_OFFSET &&
3154         !(mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) &&
3155         track->track_id != 1)
3156         avio_wb32(pb, 0); /* Later tracks follow immediately after the previous one */
3157     else
3158         avio_wb32(pb, moof_size + 8 + track->data_offset +
3159                       track->cluster[0].pos); /* data offset */
3160     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS)
3161         avio_wb32(pb, get_sample_flags(track, &track->cluster[0]));
3162
3163     for (i = 0; i < track->entry; i++) {
3164         if (flags & MOV_TRUN_SAMPLE_DURATION)
3165             avio_wb32(pb, get_cluster_duration(track, i));
3166         if (flags & MOV_TRUN_SAMPLE_SIZE)
3167             avio_wb32(pb, track->cluster[i].size);
3168         if (flags & MOV_TRUN_SAMPLE_FLAGS)
3169             avio_wb32(pb, get_sample_flags(track, &track->cluster[i]));
3170         if (flags & MOV_TRUN_SAMPLE_CTS)
3171             avio_wb32(pb, track->cluster[i].cts);
3172     }
3173
3174     return update_size(pb, pos);
3175 }
3176
3177 static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
3178 {
3179     int64_t pos = avio_tell(pb);
3180     static const uint8_t uuid[] = {
3181         0x6d, 0x1d, 0x9b, 0x05, 0x42, 0xd5, 0x44, 0xe6,
3182         0x80, 0xe2, 0x14, 0x1d, 0xaf, 0xf7, 0x57, 0xb2
3183     };
3184
3185     avio_wb32(pb, 0); /* size placeholder */
3186     ffio_wfourcc(pb, "uuid");
3187     avio_write(pb, uuid, sizeof(uuid));
3188     avio_w8(pb, 1);
3189     avio_wb24(pb, 0);
3190     avio_wb64(pb, track->frag_start);
3191     avio_wb64(pb, track->start_dts + track->track_duration -
3192                   track->cluster[0].dts);
3193
3194     return update_size(pb, pos);
3195 }
3196
3197 static int mov_write_tfrf_tag(AVIOContext *pb, MOVMuxContext *mov,
3198                               MOVTrack *track, int entry)
3199 {
3200     int n = track->nb_frag_info - 1 - entry, i;
3201     int size = 8 + 16 + 4 + 1 + 16*n;
3202     static const uint8_t uuid[] = {
3203         0xd4, 0x80, 0x7e, 0xf2, 0xca, 0x39, 0x46, 0x95,
3204         0x8e, 0x54, 0x26, 0xcb, 0x9e, 0x46, 0xa7, 0x9f
3205     };
3206
3207     if (entry < 0)
3208         return 0;
3209
3210     avio_seek(pb, track->frag_info[entry].tfrf_offset, SEEK_SET);
3211     avio_wb32(pb, size);
3212     ffio_wfourcc(pb, "uuid");
3213     avio_write(pb, uuid, sizeof(uuid));
3214     avio_w8(pb, 1);
3215     avio_wb24(pb, 0);
3216     avio_w8(pb, n);
3217     for (i = 0; i < n; i++) {
3218         int index = entry + 1 + i;
3219         avio_wb64(pb, track->frag_info[index].time);
3220         avio_wb64(pb, track->frag_info[index].duration);
3221     }
3222     if (n < mov->ism_lookahead) {
3223         int free_size = 16 * (mov->ism_lookahead - n);
3224         avio_wb32(pb, free_size);
3225         ffio_wfourcc(pb, "free");
3226         ffio_fill(pb, 0, free_size - 8);
3227     }
3228
3229     return 0;
3230 }
3231
3232 static int mov_write_tfrf_tags(AVIOContext *pb, MOVMuxContext *mov,
3233                                MOVTrack *track)
3234 {
3235     int64_t pos = avio_tell(pb);
3236     int i;
3237     for (i = 0; i < mov->ism_lookahead; i++) {
3238         /* Update the tfrf tag for the last ism_lookahead fragments,
3239          * nb_frag_info - 1 is the next fragment to be written. */
3240         mov_write_tfrf_tag(pb, mov, track, track->nb_frag_info - 2 - i);
3241     }
3242     avio_seek(pb, pos, SEEK_SET);
3243     return 0;
3244 }
3245
3246 static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov,
3247                               MOVTrack *track, int64_t moof_offset,
3248                               int moof_size)
3249 {
3250     int64_t pos = avio_tell(pb);
3251     avio_wb32(pb, 0); /* size placeholder */
3252     ffio_wfourcc(pb, "traf");
3253
3254     mov_write_tfhd_tag(pb, mov, track, moof_offset);
3255     mov_write_trun_tag(pb, mov, track, moof_size);
3256     if (mov->mode == MODE_ISM) {
3257         mov_write_tfxd_tag(pb, track);
3258
3259         if (mov->ism_lookahead) {
3260             int i, size = 16 + 4 + 1 + 16 * mov->ism_lookahead;
3261
3262             track->tfrf_offset = avio_tell(pb);
3263             avio_wb32(pb, 8 + size);
3264             ffio_wfourcc(pb, "free");
3265             for (i = 0; i < size; i++)
3266                 avio_w8(pb, 0);
3267         }
3268     }
3269
3270     return update_size(pb, pos);
3271 }
3272
3273 static int mov_write_moof_tag_internal(AVIOContext *pb, MOVMuxContext *mov,
3274                                        int tracks, int moof_size)
3275 {
3276     int64_t pos = avio_tell(pb);
3277     int i;
3278
3279     avio_wb32(pb, 0); /* size placeholder */
3280     ffio_wfourcc(pb, "moof");
3281
3282     mov_write_mfhd_tag(pb, mov);
3283     for (i = 0; i < mov->nb_streams; i++) {
3284         MOVTrack *track = &mov->tracks[i];
3285         if (tracks >= 0 && i != tracks)
3286             continue;
3287         if (!track->entry)
3288             continue;
3289         mov_write_traf_tag(pb, mov, track, pos, moof_size);
3290     }
3291
3292     return update_size(pb, pos);
3293 }
3294
3295 static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
3296 {
3297     AVIOContext *avio_buf;
3298     int ret, moof_size;
3299
3300     if ((ret = ffio_open_null_buf(&avio_buf)) < 0)
3301         return ret;
3302     mov_write_moof_tag_internal(avio_buf, mov, tracks, 0);
3303     moof_size = ffio_close_null_buf(avio_buf);
3304     return mov_write_moof_tag_internal(pb, mov, tracks, moof_size);
3305 }
3306
3307 static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
3308 {
3309     int64_t pos = avio_tell(pb);
3310     int i;
3311
3312     avio_wb32(pb, 0); /* size placeholder */
3313     ffio_wfourcc(pb, "tfra");
3314     avio_w8(pb, 1); /* version */
3315     avio_wb24(pb, 0);
3316
3317     avio_wb32(pb, track->track_id);
3318     avio_wb32(pb, 0); /* length of traf/trun/sample num */
3319     avio_wb32(pb, track->nb_frag_info);
3320     for (i = 0; i < track->nb_frag_info; i++) {
3321         avio_wb64(pb, track->frag_info[i].time);
3322         avio_wb64(pb, track->frag_info[i].offset);
3323         avio_w8(pb, 1); /* traf number */
3324         avio_w8(pb, 1); /* trun number */
3325         avio_w8(pb, 1); /* sample number */
3326     }
3327
3328     return update_size(pb, pos);
3329 }
3330
3331 static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
3332 {
3333     int64_t pos = avio_tell(pb);
3334     int i;
3335
3336     avio_wb32(pb, 0); /* size placeholder */
3337     ffio_wfourcc(pb, "mfra");
3338     /* An empty mfra atom is enough to indicate to the publishing point that
3339      * the stream has ended. */
3340     if (mov->flags & FF_MOV_FLAG_ISML)
3341         return update_size(pb, pos);
3342
3343     for (i = 0; i < mov->nb_streams; i++) {
3344         MOVTrack *track = &mov->tracks[i];
3345         if (track->nb_frag_info)
3346             mov_write_tfra_tag(pb, track);
3347     }
3348
3349     avio_wb32(pb, 16);
3350     ffio_wfourcc(pb, "mfro");
3351     avio_wb32(pb, 0); /* version + flags */
3352     avio_wb32(pb, avio_tell(pb) + 4 - pos);
3353
3354     return update_size(pb, pos);
3355 }