lavf: Constify the probe function argument.
[ffmpeg.git] / libavformat / mov.c
1 /*
2  * MOV demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2009 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
5  *
6  * first version by Francois Revol <revol@free.fr>
7  * seek function by Gael Chardon <gael.dev@4now.net>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25
26 #include <inttypes.h>
27 #include <limits.h>
28 #include <stdint.h>
29
30 #include "libavutil/attributes.h"
31 #include "libavutil/channel_layout.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/intfloat.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/time_internal.h"
37 #include "libavutil/avassert.h"
38 #include "libavutil/avstring.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/display.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/aes.h"
43 #include "libavutil/aes_ctr.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/sha.h"
46 #include "libavutil/spherical.h"
47 #include "libavutil/stereo3d.h"
48 #include "libavutil/timecode.h"
49 #include "libavcodec/ac3tab.h"
50 #include "libavcodec/flac.h"
51 #include "libavcodec/mpegaudiodecheader.h"
52 #include "avformat.h"
53 #include "internal.h"
54 #include "avio_internal.h"
55 #include "riff.h"
56 #include "isom.h"
57 #include "libavcodec/get_bits.h"
58 #include "id3v1.h"
59 #include "mov_chan.h"
60 #include "replaygain.h"
61
62 #if CONFIG_ZLIB
63 #include <zlib.h>
64 #endif
65
66 #include "qtpalette.h"
67
68 /* those functions parse an atom */
69 /* links atom IDs to parse functions */
70 typedef struct MOVParseTableEntry {
71     uint32_t type;
72     int (*parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom);
73 } MOVParseTableEntry;
74
75 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
76 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
77 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
78                               int count, int duration);
79
80 static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
81                                              unsigned len, const char *key)
82 {
83     char buf[16];
84
85     short current, total = 0;
86     avio_rb16(pb); // unknown
87     current = avio_rb16(pb);
88     if (len >= 6)
89         total = avio_rb16(pb);
90     if (!total)
91         snprintf(buf, sizeof(buf), "%d", current);
92     else
93         snprintf(buf, sizeof(buf), "%d/%d", current, total);
94     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
95     av_dict_set(&c->fc->metadata, key, buf, 0);
96
97     return 0;
98 }
99
100 static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
101                                             unsigned len, const char *key)
102 {
103     /* bypass padding bytes */
104     avio_r8(pb);
105     avio_r8(pb);
106     avio_r8(pb);
107
108     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
109     av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
110
111     return 0;
112 }
113
114 static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
115                                         unsigned len, const char *key)
116 {
117     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
118     av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
119
120     return 0;
121 }
122
123 static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
124                              unsigned len, const char *key)
125 {
126     short genre;
127
128     avio_r8(pb); // unknown
129
130     genre = avio_r8(pb);
131     if (genre < 1 || genre > ID3v1_GENRE_MAX)
132         return 0;
133     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
134     av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
135
136     return 0;
137 }
138
139 static const uint32_t mac_to_unicode[128] = {
140     0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
141     0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
142     0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
143     0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
144     0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
145     0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
146     0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
147     0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
148     0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
149     0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
150     0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
151     0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
152     0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
153     0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
154     0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
155     0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
156 };
157
158 static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
159                                char *dst, int dstlen)
160 {
161     char *p = dst;
162     char *end = dst+dstlen-1;
163     int i;
164
165     for (i = 0; i < len; i++) {
166         uint8_t t, c = avio_r8(pb);
167
168         if (p >= end)
169             continue;
170
171         if (c < 0x80)
172             *p++ = c;
173         else if (p < end)
174             PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
175     }
176     *p = 0;
177     return p - dst;
178 }
179
180 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
181 {
182     AVPacket pkt;
183     AVStream *st;
184     MOVStreamContext *sc;
185     enum AVCodecID id;
186     int ret;
187
188     switch (type) {
189     case 0xd:  id = AV_CODEC_ID_MJPEG; break;
190     case 0xe:  id = AV_CODEC_ID_PNG;   break;
191     case 0x1b: id = AV_CODEC_ID_BMP;   break;
192     default:
193         av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
194         avio_skip(pb, len);
195         return 0;
196     }
197
198     st = avformat_new_stream(c->fc, NULL);
199     if (!st)
200         return AVERROR(ENOMEM);
201     sc = av_mallocz(sizeof(*sc));
202     if (!sc)
203         return AVERROR(ENOMEM);
204     st->priv_data = sc;
205
206     ret = av_get_packet(pb, &pkt, len);
207     if (ret < 0)
208         return ret;
209
210     if (pkt.size >= 8 && id != AV_CODEC_ID_BMP) {
211         if (AV_RB64(pkt.data) == 0x89504e470d0a1a0a) {
212             id = AV_CODEC_ID_PNG;
213         } else {
214             id = AV_CODEC_ID_MJPEG;
215         }
216     }
217
218     st->disposition              |= AV_DISPOSITION_ATTACHED_PIC;
219
220     st->attached_pic              = pkt;
221     st->attached_pic.stream_index = st->index;
222     st->attached_pic.flags       |= AV_PKT_FLAG_KEY;
223
224     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
225     st->codecpar->codec_id   = id;
226
227     return 0;
228 }
229
230 // 3GPP TS 26.244
231 static int mov_metadata_loci(MOVContext *c, AVIOContext *pb, unsigned len)
232 {
233     char language[4] = { 0 };
234     char buf[200], place[100];
235     uint16_t langcode = 0;
236     double longitude, latitude, altitude;
237     const char *key = "location";
238
239     if (len < 4 + 2 + 1 + 1 + 4 + 4 + 4) {
240         av_log(c->fc, AV_LOG_ERROR, "loci too short\n");
241         return AVERROR_INVALIDDATA;
242     }
243
244     avio_skip(pb, 4); // version+flags
245     langcode = avio_rb16(pb);
246     ff_mov_lang_to_iso639(langcode, language);
247     len -= 6;
248
249     len -= avio_get_str(pb, len, place, sizeof(place));
250     if (len < 1) {
251         av_log(c->fc, AV_LOG_ERROR, "place name too long\n");
252         return AVERROR_INVALIDDATA;
253     }
254     avio_skip(pb, 1); // role
255     len -= 1;
256
257     if (len < 12) {
258         av_log(c->fc, AV_LOG_ERROR,
259                "loci too short (%u bytes left, need at least %d)\n", len, 12);
260         return AVERROR_INVALIDDATA;
261     }
262     longitude = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
263     latitude  = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
264     altitude  = ((int32_t) avio_rb32(pb)) / (float) (1 << 16);
265
266     // Try to output in the same format as the ?xyz field
267     snprintf(buf, sizeof(buf), "%+08.4f%+09.4f",  latitude, longitude);
268     if (altitude)
269         av_strlcatf(buf, sizeof(buf), "%+f", altitude);
270     av_strlcatf(buf, sizeof(buf), "/%s", place);
271
272     if (*language && strcmp(language, "und")) {
273         char key2[16];
274         snprintf(key2, sizeof(key2), "%s-%s", key, language);
275         av_dict_set(&c->fc->metadata, key2, buf, 0);
276     }
277     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
278     return av_dict_set(&c->fc->metadata, key, buf, 0);
279 }
280
281 static int mov_metadata_hmmt(MOVContext *c, AVIOContext *pb, unsigned len)
282 {
283     int i, n_hmmt;
284
285     if (len < 2)
286         return 0;
287     if (c->ignore_chapters)
288         return 0;
289
290     n_hmmt = avio_rb32(pb);
291     for (i = 0; i < n_hmmt && !pb->eof_reached; i++) {
292         int moment_time = avio_rb32(pb);
293         avpriv_new_chapter(c->fc, i, av_make_q(1, 1000), moment_time, AV_NOPTS_VALUE, NULL);
294     }
295     return 0;
296 }
297
298 static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
299 {
300     char tmp_key[5];
301     char key2[32], language[4] = {0};
302     char *str = NULL;
303     const char *key = NULL;
304     uint16_t langcode = 0;
305     uint32_t data_type = 0, str_size, str_size_alloc;
306     int (*parse)(MOVContext*, AVIOContext*, unsigned, const char*) = NULL;
307     int raw = 0;
308     int num = 0;
309
310     switch (atom.type) {
311     case MKTAG( '@','P','R','M'): key = "premiere_version"; raw = 1; break;
312     case MKTAG( '@','P','R','Q'): key = "quicktime_version"; raw = 1; break;
313     case MKTAG( 'X','M','P','_'):
314         if (c->export_xmp) { key = "xmp"; raw = 1; } break;
315     case MKTAG( 'a','A','R','T'): key = "album_artist";    break;
316     case MKTAG( 'a','k','I','D'): key = "account_type";
317         parse = mov_metadata_int8_no_padding; break;
318     case MKTAG( 'a','p','I','D'): key = "account_id"; break;
319     case MKTAG( 'c','a','t','g'): key = "category"; break;
320     case MKTAG( 'c','p','i','l'): key = "compilation";
321         parse = mov_metadata_int8_no_padding; break;
322     case MKTAG( 'c','p','r','t'): key = "copyright"; break;
323     case MKTAG( 'd','e','s','c'): key = "description"; break;
324     case MKTAG( 'd','i','s','k'): key = "disc";
325         parse = mov_metadata_track_or_disc_number; break;
326     case MKTAG( 'e','g','i','d'): key = "episode_uid";
327         parse = mov_metadata_int8_no_padding; break;
328     case MKTAG( 'F','I','R','M'): key = "firmware"; raw = 1; break;
329     case MKTAG( 'g','n','r','e'): key = "genre";
330         parse = mov_metadata_gnre; break;
331     case MKTAG( 'h','d','v','d'): key = "hd_video";
332         parse = mov_metadata_int8_no_padding; break;
333     case MKTAG( 'H','M','M','T'):
334         return mov_metadata_hmmt(c, pb, atom.size);
335     case MKTAG( 'k','e','y','w'): key = "keywords";  break;
336     case MKTAG( 'l','d','e','s'): key = "synopsis";  break;
337     case MKTAG( 'l','o','c','i'):
338         return mov_metadata_loci(c, pb, atom.size);
339     case MKTAG( 'm','a','n','u'): key = "make"; break;
340     case MKTAG( 'm','o','d','l'): key = "model"; break;
341     case MKTAG( 'p','c','s','t'): key = "podcast";
342         parse = mov_metadata_int8_no_padding; break;
343     case MKTAG( 'p','g','a','p'): key = "gapless_playback";
344         parse = mov_metadata_int8_no_padding; break;
345     case MKTAG( 'p','u','r','d'): key = "purchase_date"; break;
346     case MKTAG( 'r','t','n','g'): key = "rating";
347         parse = mov_metadata_int8_no_padding; break;
348     case MKTAG( 's','o','a','a'): key = "sort_album_artist"; break;
349     case MKTAG( 's','o','a','l'): key = "sort_album";   break;
350     case MKTAG( 's','o','a','r'): key = "sort_artist";  break;
351     case MKTAG( 's','o','c','o'): key = "sort_composer"; break;
352     case MKTAG( 's','o','n','m'): key = "sort_name";    break;
353     case MKTAG( 's','o','s','n'): key = "sort_show";    break;
354     case MKTAG( 's','t','i','k'): key = "media_type";
355         parse = mov_metadata_int8_no_padding; break;
356     case MKTAG( 't','r','k','n'): key = "track";
357         parse = mov_metadata_track_or_disc_number; break;
358     case MKTAG( 't','v','e','n'): key = "episode_id"; break;
359     case MKTAG( 't','v','e','s'): key = "episode_sort";
360         parse = mov_metadata_int8_bypass_padding; break;
361     case MKTAG( 't','v','n','n'): key = "network";   break;
362     case MKTAG( 't','v','s','h'): key = "show";      break;
363     case MKTAG( 't','v','s','n'): key = "season_number";
364         parse = mov_metadata_int8_bypass_padding; break;
365     case MKTAG(0xa9,'A','R','T'): key = "artist";    break;
366     case MKTAG(0xa9,'P','R','D'): key = "producer";  break;
367     case MKTAG(0xa9,'a','l','b'): key = "album";     break;
368     case MKTAG(0xa9,'a','u','t'): key = "artist";    break;
369     case MKTAG(0xa9,'c','h','p'): key = "chapter";   break;
370     case MKTAG(0xa9,'c','m','t'): key = "comment";   break;
371     case MKTAG(0xa9,'c','o','m'): key = "composer";  break;
372     case MKTAG(0xa9,'c','p','y'): key = "copyright"; break;
373     case MKTAG(0xa9,'d','a','y'): key = "date";      break;
374     case MKTAG(0xa9,'d','i','r'): key = "director";  break;
375     case MKTAG(0xa9,'d','i','s'): key = "disclaimer"; break;
376     case MKTAG(0xa9,'e','d','1'): key = "edit_date"; break;
377     case MKTAG(0xa9,'e','n','c'): key = "encoder";   break;
378     case MKTAG(0xa9,'f','m','t'): key = "original_format"; break;
379     case MKTAG(0xa9,'g','e','n'): key = "genre";     break;
380     case MKTAG(0xa9,'g','r','p'): key = "grouping";  break;
381     case MKTAG(0xa9,'h','s','t'): key = "host_computer"; break;
382     case MKTAG(0xa9,'i','n','f'): key = "comment";   break;
383     case MKTAG(0xa9,'l','y','r'): key = "lyrics";    break;
384     case MKTAG(0xa9,'m','a','k'): key = "make";      break;
385     case MKTAG(0xa9,'m','o','d'): key = "model";     break;
386     case MKTAG(0xa9,'n','a','m'): key = "title";     break;
387     case MKTAG(0xa9,'o','p','e'): key = "original_artist"; break;
388     case MKTAG(0xa9,'p','r','d'): key = "producer";  break;
389     case MKTAG(0xa9,'p','r','f'): key = "performers"; break;
390     case MKTAG(0xa9,'r','e','q'): key = "playback_requirements"; break;
391     case MKTAG(0xa9,'s','r','c'): key = "original_source"; break;
392     case MKTAG(0xa9,'s','t','3'): key = "subtitle";  break;
393     case MKTAG(0xa9,'s','w','r'): key = "encoder";   break;
394     case MKTAG(0xa9,'t','o','o'): key = "encoder";   break;
395     case MKTAG(0xa9,'t','r','k'): key = "track";     break;
396     case MKTAG(0xa9,'u','r','l'): key = "URL";       break;
397     case MKTAG(0xa9,'w','r','n'): key = "warning";   break;
398     case MKTAG(0xa9,'w','r','t'): key = "composer";  break;
399     case MKTAG(0xa9,'x','y','z'): key = "location";  break;
400     }
401 retry:
402     if (c->itunes_metadata && atom.size > 8) {
403         int data_size = avio_rb32(pb);
404         int tag = avio_rl32(pb);
405         if (tag == MKTAG('d','a','t','a') && data_size <= atom.size) {
406             data_type = avio_rb32(pb); // type
407             avio_rb32(pb); // unknown
408             str_size = data_size - 16;
409             atom.size -= 16;
410
411             if (atom.type == MKTAG('c', 'o', 'v', 'r')) {
412                 int ret = mov_read_covr(c, pb, data_type, str_size);
413                 if (ret < 0) {
414                     av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
415                     return ret;
416                 }
417                 atom.size -= str_size;
418                 if (atom.size > 8)
419                     goto retry;
420                 return ret;
421             } else if (!key && c->found_hdlr_mdta && c->meta_keys) {
422                 uint32_t index = AV_RB32(&atom.type);
423                 if (index < c->meta_keys_count && index > 0) {
424                     key = c->meta_keys[index];
425                 } else {
426                     av_log(c->fc, AV_LOG_WARNING,
427                            "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
428                            index, c->meta_keys_count);
429                 }
430             }
431         } else return 0;
432     } else if (atom.size > 4 && key && !c->itunes_metadata && !raw) {
433         str_size = avio_rb16(pb); // string length
434         if (str_size > atom.size) {
435             raw = 1;
436             avio_seek(pb, -2, SEEK_CUR);
437             av_log(c->fc, AV_LOG_WARNING, "UDTA parsing failed retrying raw\n");
438             goto retry;
439         }
440         langcode = avio_rb16(pb);
441         ff_mov_lang_to_iso639(langcode, language);
442         atom.size -= 4;
443     } else
444         str_size = atom.size;
445
446     if (c->export_all && !key) {
447         snprintf(tmp_key, 5, "%.4s", (char*)&atom.type);
448         key = tmp_key;
449     }
450
451     if (!key)
452         return 0;
453     if (atom.size < 0 || str_size >= INT_MAX/2)
454         return AVERROR_INVALIDDATA;
455
456     // Allocates enough space if data_type is a int32 or float32 number, otherwise
457     // worst-case requirement for output string in case of utf8 coded input
458     num = (data_type >= 21 && data_type <= 23);
459     str_size_alloc = (num ? 512 : (raw ? str_size : str_size * 2)) + 1;
460     str = av_mallocz(str_size_alloc);
461     if (!str)
462         return AVERROR(ENOMEM);
463
464     if (parse)
465         parse(c, pb, str_size, key);
466     else {
467         if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
468             mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
469         } else if (data_type == 21) { // BE signed integer, variable size
470             int val = 0;
471             if (str_size == 1)
472                 val = (int8_t)avio_r8(pb);
473             else if (str_size == 2)
474                 val = (int16_t)avio_rb16(pb);
475             else if (str_size == 3)
476                 val = ((int32_t)(avio_rb24(pb)<<8))>>8;
477             else if (str_size == 4)
478                 val = (int32_t)avio_rb32(pb);
479             if (snprintf(str, str_size_alloc, "%d", val) >= str_size_alloc) {
480                 av_log(c->fc, AV_LOG_ERROR,
481                        "Failed to store the number (%d) in string.\n", val);
482                 av_free(str);
483                 return AVERROR_INVALIDDATA;
484             }
485         } else if (data_type == 22) { // BE unsigned integer, variable size
486             unsigned int val = 0;
487             if (str_size == 1)
488                 val = avio_r8(pb);
489             else if (str_size == 2)
490                 val = avio_rb16(pb);
491             else if (str_size == 3)
492                 val = avio_rb24(pb);
493             else if (str_size == 4)
494                 val = avio_rb32(pb);
495             if (snprintf(str, str_size_alloc, "%u", val) >= str_size_alloc) {
496                 av_log(c->fc, AV_LOG_ERROR,
497                        "Failed to store the number (%u) in string.\n", val);
498                 av_free(str);
499                 return AVERROR_INVALIDDATA;
500             }
501         } else if (data_type == 23 && str_size >= 4) {  // BE float32
502             float val = av_int2float(avio_rb32(pb));
503             if (snprintf(str, str_size_alloc, "%f", val) >= str_size_alloc) {
504                 av_log(c->fc, AV_LOG_ERROR,
505                        "Failed to store the float32 number (%f) in string.\n", val);
506                 av_free(str);
507                 return AVERROR_INVALIDDATA;
508             }
509         } else {
510             int ret = ffio_read_size(pb, str, str_size);
511             if (ret < 0) {
512                 av_free(str);
513                 return ret;
514             }
515             str[str_size] = 0;
516         }
517         c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
518         av_dict_set(&c->fc->metadata, key, str, 0);
519         if (*language && strcmp(language, "und")) {
520             snprintf(key2, sizeof(key2), "%s-%s", key, language);
521             av_dict_set(&c->fc->metadata, key2, str, 0);
522         }
523         if (!strcmp(key, "encoder")) {
524             int major, minor, micro;
525             if (sscanf(str, "HandBrake %d.%d.%d", &major, &minor, &micro) == 3) {
526                 c->handbrake_version = 1000000*major + 1000*minor + micro;
527             }
528         }
529     }
530
531     av_freep(&str);
532     return 0;
533 }
534
535 static int mov_read_chpl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
536 {
537     int64_t start;
538     int i, nb_chapters, str_len, version;
539     char str[256+1];
540     int ret;
541
542     if (c->ignore_chapters)
543         return 0;
544
545     if ((atom.size -= 5) < 0)
546         return 0;
547
548     version = avio_r8(pb);
549     avio_rb24(pb);
550     if (version)
551         avio_rb32(pb); // ???
552     nb_chapters = avio_r8(pb);
553
554     for (i = 0; i < nb_chapters; i++) {
555         if (atom.size < 9)
556             return 0;
557
558         start = avio_rb64(pb);
559         str_len = avio_r8(pb);
560
561         if ((atom.size -= 9+str_len) < 0)
562             return 0;
563
564         ret = ffio_read_size(pb, str, str_len);
565         if (ret < 0)
566             return ret;
567         str[str_len] = 0;
568         avpriv_new_chapter(c->fc, i, (AVRational){1,10000000}, start, AV_NOPTS_VALUE, str);
569     }
570     return 0;
571 }
572
573 #define MIN_DATA_ENTRY_BOX_SIZE 12
574 static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
575 {
576     AVStream *st;
577     MOVStreamContext *sc;
578     int entries, i, j;
579
580     if (c->fc->nb_streams < 1)
581         return 0;
582     st = c->fc->streams[c->fc->nb_streams-1];
583     sc = st->priv_data;
584
585     avio_rb32(pb); // version + flags
586     entries = avio_rb32(pb);
587     if (!entries ||
588         entries >  (atom.size - 1) / MIN_DATA_ENTRY_BOX_SIZE + 1 ||
589         entries >= UINT_MAX / sizeof(*sc->drefs))
590         return AVERROR_INVALIDDATA;
591     sc->drefs_count = 0;
592     av_free(sc->drefs);
593     sc->drefs_count = 0;
594     sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
595     if (!sc->drefs)
596         return AVERROR(ENOMEM);
597     sc->drefs_count = entries;
598
599     for (i = 0; i < entries; i++) {
600         MOVDref *dref = &sc->drefs[i];
601         uint32_t size = avio_rb32(pb);
602         int64_t next = avio_tell(pb) + size - 4;
603
604         if (size < 12)
605             return AVERROR_INVALIDDATA;
606
607         dref->type = avio_rl32(pb);
608         avio_rb32(pb); // version + flags
609
610         if (dref->type == MKTAG('a','l','i','s') && size > 150) {
611             /* macintosh alias record */
612             uint16_t volume_len, len;
613             int16_t type;
614             int ret;
615
616             avio_skip(pb, 10);
617
618             volume_len = avio_r8(pb);
619             volume_len = FFMIN(volume_len, 27);
620             ret = ffio_read_size(pb, dref->volume, 27);
621             if (ret < 0)
622                 return ret;
623             dref->volume[volume_len] = 0;
624             av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
625
626             avio_skip(pb, 12);
627
628             len = avio_r8(pb);
629             len = FFMIN(len, 63);
630             ret = ffio_read_size(pb, dref->filename, 63);
631             if (ret < 0)
632                 return ret;
633             dref->filename[len] = 0;
634             av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
635
636             avio_skip(pb, 16);
637
638             /* read next level up_from_alias/down_to_target */
639             dref->nlvl_from = avio_rb16(pb);
640             dref->nlvl_to   = avio_rb16(pb);
641             av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
642                    dref->nlvl_from, dref->nlvl_to);
643
644             avio_skip(pb, 16);
645
646             for (type = 0; type != -1 && avio_tell(pb) < next; ) {
647                 if(avio_feof(pb))
648                     return AVERROR_EOF;
649                 type = avio_rb16(pb);
650                 len = avio_rb16(pb);
651                 av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
652                 if (len&1)
653                     len += 1;
654                 if (type == 2) { // absolute path
655                     av_free(dref->path);
656                     dref->path = av_mallocz(len+1);
657                     if (!dref->path)
658                         return AVERROR(ENOMEM);
659
660                     ret = ffio_read_size(pb, dref->path, len);
661                     if (ret < 0) {
662                         av_freep(&dref->path);
663                         return ret;
664                     }
665                     if (len > volume_len && !strncmp(dref->path, dref->volume, volume_len)) {
666                         len -= volume_len;
667                         memmove(dref->path, dref->path+volume_len, len);
668                         dref->path[len] = 0;
669                     }
670                     // trim string of any ending zeros
671                     for (j = len - 1; j >= 0; j--) {
672                         if (dref->path[j] == 0)
673                             len--;
674                         else
675                             break;
676                     }
677                     for (j = 0; j < len; j++)
678                         if (dref->path[j] == ':' || dref->path[j] == 0)
679                             dref->path[j] = '/';
680                     av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
681                 } else if (type == 0) { // directory name
682                     av_free(dref->dir);
683                     dref->dir = av_malloc(len+1);
684                     if (!dref->dir)
685                         return AVERROR(ENOMEM);
686
687                     ret = ffio_read_size(pb, dref->dir, len);
688                     if (ret < 0) {
689                         av_freep(&dref->dir);
690                         return ret;
691                     }
692                     dref->dir[len] = 0;
693                     for (j = 0; j < len; j++)
694                         if (dref->dir[j] == ':')
695                             dref->dir[j] = '/';
696                     av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
697                 } else
698                     avio_skip(pb, len);
699             }
700         } else {
701             av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
702                    dref->type, size);
703             entries--;
704             i--;
705         }
706         avio_seek(pb, next, SEEK_SET);
707     }
708     return 0;
709 }
710
711 static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
712 {
713     AVStream *st;
714     uint32_t type;
715     uint32_t ctype;
716     int64_t title_size;
717     char *title_str;
718     int ret;
719
720     avio_r8(pb); /* version */
721     avio_rb24(pb); /* flags */
722
723     /* component type */
724     ctype = avio_rl32(pb);
725     type = avio_rl32(pb); /* component subtype */
726
727     av_log(c->fc, AV_LOG_TRACE, "ctype=%s\n", av_fourcc2str(ctype));
728     av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
729
730     if (c->trak_index < 0) {  // meta not inside a trak
731         if (type == MKTAG('m','d','t','a')) {
732             c->found_hdlr_mdta = 1;
733         }
734         return 0;
735     }
736
737     st = c->fc->streams[c->fc->nb_streams-1];
738
739     if     (type == MKTAG('v','i','d','e'))
740         st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
741     else if (type == MKTAG('s','o','u','n'))
742         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
743     else if (type == MKTAG('m','1','a',' '))
744         st->codecpar->codec_id = AV_CODEC_ID_MP2;
745     else if ((type == MKTAG('s','u','b','p')) || (type == MKTAG('c','l','c','p')))
746         st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
747
748     avio_rb32(pb); /* component  manufacture */
749     avio_rb32(pb); /* component flags */
750     avio_rb32(pb); /* component flags mask */
751
752     title_size = atom.size - 24;
753     if (title_size > 0) {
754         if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
755             return AVERROR_INVALIDDATA;
756         title_str = av_malloc(title_size + 1); /* Add null terminator */
757         if (!title_str)
758             return AVERROR(ENOMEM);
759
760         ret = ffio_read_size(pb, title_str, title_size);
761         if (ret < 0) {
762             av_freep(&title_str);
763             return ret;
764         }
765         title_str[title_size] = 0;
766         if (title_str[0]) {
767             int off = (!c->isom && title_str[0] == title_size - 1);
768             // flag added so as to not set stream handler name if already set from mdia->hdlr
769             av_dict_set(&st->metadata, "handler_name", title_str + off, AV_DICT_DONT_OVERWRITE);
770         }
771         av_freep(&title_str);
772     }
773
774     return 0;
775 }
776
777 static int mov_read_esds(MOVContext *c, AVIOContext *pb, MOVAtom atom)
778 {
779     return ff_mov_read_esds(c->fc, pb);
780 }
781
782 static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
783 {
784     AVStream *st;
785     enum AVAudioServiceType *ast;
786     int ac3info, acmod, lfeon, bsmod;
787
788     if (c->fc->nb_streams < 1)
789         return 0;
790     st = c->fc->streams[c->fc->nb_streams-1];
791
792     ast = (enum AVAudioServiceType*)av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
793                                                             sizeof(*ast));
794     if (!ast)
795         return AVERROR(ENOMEM);
796
797     ac3info = avio_rb24(pb);
798     bsmod = (ac3info >> 14) & 0x7;
799     acmod = (ac3info >> 11) & 0x7;
800     lfeon = (ac3info >> 10) & 0x1;
801     st->codecpar->channels = ((int[]){2,1,2,3,3,4,4,5})[acmod] + lfeon;
802     st->codecpar->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
803     if (lfeon)
804         st->codecpar->channel_layout |= AV_CH_LOW_FREQUENCY;
805     *ast = bsmod;
806     if (st->codecpar->channels > 1 && bsmod == 0x7)
807         *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
808
809 #if FF_API_LAVF_AVCTX
810     FF_DISABLE_DEPRECATION_WARNINGS
811     st->codec->audio_service_type = *ast;
812     FF_ENABLE_DEPRECATION_WARNINGS
813 #endif
814
815     return 0;
816 }
817
818 static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
819 {
820     AVStream *st;
821     enum AVAudioServiceType *ast;
822     int eac3info, acmod, lfeon, bsmod;
823
824     if (c->fc->nb_streams < 1)
825         return 0;
826     st = c->fc->streams[c->fc->nb_streams-1];
827
828     ast = (enum AVAudioServiceType*)av_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
829                                                             sizeof(*ast));
830     if (!ast)
831         return AVERROR(ENOMEM);
832
833     /* No need to parse fields for additional independent substreams and its
834      * associated dependent substreams since libavcodec's E-AC-3 decoder
835      * does not support them yet. */
836     avio_rb16(pb); /* data_rate and num_ind_sub */
837     eac3info = avio_rb24(pb);
838     bsmod = (eac3info >> 12) & 0x1f;
839     acmod = (eac3info >>  9) & 0x7;
840     lfeon = (eac3info >>  8) & 0x1;
841     st->codecpar->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
842     if (lfeon)
843         st->codecpar->channel_layout |= AV_CH_LOW_FREQUENCY;
844     st->codecpar->channels = av_get_channel_layout_nb_channels(st->codecpar->channel_layout);
845     *ast = bsmod;
846     if (st->codecpar->channels > 1 && bsmod == 0x7)
847         *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
848
849 #if FF_API_LAVF_AVCTX
850     FF_DISABLE_DEPRECATION_WARNINGS
851     st->codec->audio_service_type = *ast;
852     FF_ENABLE_DEPRECATION_WARNINGS
853 #endif
854
855     return 0;
856 }
857
858 static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
859 {
860     const uint32_t ddts_size = 20;
861     AVStream *st = NULL;
862     uint8_t *buf = NULL;
863     uint32_t frame_duration_code = 0;
864     uint32_t channel_layout_code = 0;
865     GetBitContext gb;
866
867     buf = av_malloc(ddts_size + AV_INPUT_BUFFER_PADDING_SIZE);
868     if (!buf) {
869         return AVERROR(ENOMEM);
870     }
871     if (avio_read(pb, buf, ddts_size) < ddts_size) {
872         av_free(buf);
873         return AVERROR_INVALIDDATA;
874     }
875
876     init_get_bits(&gb, buf, 8*ddts_size);
877
878     if (c->fc->nb_streams < 1) {
879         av_free(buf);
880         return 0;
881     }
882     st = c->fc->streams[c->fc->nb_streams-1];
883
884     st->codecpar->sample_rate = get_bits_long(&gb, 32);
885     if (st->codecpar->sample_rate <= 0) {
886         av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
887         av_free(buf);
888         return AVERROR_INVALIDDATA;
889     }
890     skip_bits_long(&gb, 32); /* max bitrate */
891     st->codecpar->bit_rate = get_bits_long(&gb, 32);
892     st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
893     frame_duration_code = get_bits(&gb, 2);
894     skip_bits(&gb, 30); /* various fields */
895     channel_layout_code = get_bits(&gb, 16);
896
897     st->codecpar->frame_size =
898             (frame_duration_code == 0) ? 512 :
899             (frame_duration_code == 1) ? 1024 :
900             (frame_duration_code == 2) ? 2048 :
901             (frame_duration_code == 3) ? 4096 : 0;
902
903     if (channel_layout_code > 0xff) {
904         av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout");
905     }
906     st->codecpar->channel_layout =
907             ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
908             ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
909             ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
910             ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
911             ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
912             ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
913
914     st->codecpar->channels = av_get_channel_layout_nb_channels(st->codecpar->channel_layout);
915     av_free(buf);
916
917     return 0;
918 }
919
920 static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
921 {
922     AVStream *st;
923
924     if (c->fc->nb_streams < 1)
925         return 0;
926     st = c->fc->streams[c->fc->nb_streams-1];
927
928     if (atom.size < 16)
929         return 0;
930
931     /* skip version and flags */
932     avio_skip(pb, 4);
933
934     ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
935
936     return 0;
937 }
938
939 static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
940 {
941     AVStream *st;
942     int ret;
943
944     if (c->fc->nb_streams < 1)
945         return 0;
946     st = c->fc->streams[c->fc->nb_streams-1];
947
948     if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
949         av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
950
951     return ret;
952 }
953
954 static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
955 {
956     const int num = avio_rb32(pb);
957     const int den = avio_rb32(pb);
958     AVStream *st;
959
960     if (c->fc->nb_streams < 1)
961         return 0;
962     st = c->fc->streams[c->fc->nb_streams-1];
963
964     if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
965         (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
966         av_log(c->fc, AV_LOG_WARNING,
967                "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
968                st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
969                num, den);
970     } else if (den != 0) {
971         av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den,
972                   num, den, 32767);
973     }
974     return 0;
975 }
976
977 /* this atom contains actual media data */
978 static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
979 {
980     if (atom.size == 0) /* wrong one (MP4) */
981         return 0;
982     c->found_mdat=1;
983     return 0; /* now go for moov */
984 }
985
986 #define DRM_BLOB_SIZE 56
987
988 static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
989 {
990     uint8_t intermediate_key[20];
991     uint8_t intermediate_iv[20];
992     uint8_t input[64];
993     uint8_t output[64];
994     uint8_t file_checksum[20];
995     uint8_t calculated_checksum[20];
996     struct AVSHA *sha;
997     int i;
998     int ret = 0;
999     uint8_t *activation_bytes = c->activation_bytes;
1000     uint8_t *fixed_key = c->audible_fixed_key;
1001
1002     c->aax_mode = 1;
1003
1004     sha = av_sha_alloc();
1005     if (!sha)
1006         return AVERROR(ENOMEM);
1007     c->aes_decrypt = av_aes_alloc();
1008     if (!c->aes_decrypt) {
1009         ret = AVERROR(ENOMEM);
1010         goto fail;
1011     }
1012
1013     /* drm blob processing */
1014     avio_read(pb, output, 8); // go to offset 8, absolute position 0x251
1015     avio_read(pb, input, DRM_BLOB_SIZE);
1016     avio_read(pb, output, 4); // go to offset 4, absolute position 0x28d
1017     avio_read(pb, file_checksum, 20);
1018
1019     av_log(c->fc, AV_LOG_INFO, "[aax] file checksum == "); // required by external tools
1020     for (i = 0; i < 20; i++)
1021         av_log(c->fc, AV_LOG_INFO, "%02x", file_checksum[i]);
1022     av_log(c->fc, AV_LOG_INFO, "\n");
1023
1024     /* verify activation data */
1025     if (!activation_bytes) {
1026         av_log(c->fc, AV_LOG_WARNING, "[aax] activation_bytes option is missing!\n");
1027         ret = 0;  /* allow ffprobe to continue working on .aax files */
1028         goto fail;
1029     }
1030     if (c->activation_bytes_size != 4) {
1031         av_log(c->fc, AV_LOG_FATAL, "[aax] activation_bytes value needs to be 4 bytes!\n");
1032         ret = AVERROR(EINVAL);
1033         goto fail;
1034     }
1035
1036     /* verify fixed key */
1037     if (c->audible_fixed_key_size != 16) {
1038         av_log(c->fc, AV_LOG_FATAL, "[aax] audible_fixed_key value needs to be 16 bytes!\n");
1039         ret = AVERROR(EINVAL);
1040         goto fail;
1041     }
1042
1043     /* AAX (and AAX+) key derivation */
1044     av_sha_init(sha, 160);
1045     av_sha_update(sha, fixed_key, 16);
1046     av_sha_update(sha, activation_bytes, 4);
1047     av_sha_final(sha, intermediate_key);
1048     av_sha_init(sha, 160);
1049     av_sha_update(sha, fixed_key, 16);
1050     av_sha_update(sha, intermediate_key, 20);
1051     av_sha_update(sha, activation_bytes, 4);
1052     av_sha_final(sha, intermediate_iv);
1053     av_sha_init(sha, 160);
1054     av_sha_update(sha, intermediate_key, 16);
1055     av_sha_update(sha, intermediate_iv, 16);
1056     av_sha_final(sha, calculated_checksum);
1057     if (memcmp(calculated_checksum, file_checksum, 20)) { // critical error
1058         av_log(c->fc, AV_LOG_ERROR, "[aax] mismatch in checksums!\n");
1059         ret = AVERROR_INVALIDDATA;
1060         goto fail;
1061     }
1062     av_aes_init(c->aes_decrypt, intermediate_key, 128, 1);
1063     av_aes_crypt(c->aes_decrypt, output, input, DRM_BLOB_SIZE >> 4, intermediate_iv, 1);
1064     for (i = 0; i < 4; i++) {
1065         // file data (in output) is stored in big-endian mode
1066         if (activation_bytes[i] != output[3 - i]) { // critical error
1067             av_log(c->fc, AV_LOG_ERROR, "[aax] error in drm blob decryption!\n");
1068             ret = AVERROR_INVALIDDATA;
1069             goto fail;
1070         }
1071     }
1072     memcpy(c->file_key, output + 8, 16);
1073     memcpy(input, output + 26, 16);
1074     av_sha_init(sha, 160);
1075     av_sha_update(sha, input, 16);
1076     av_sha_update(sha, c->file_key, 16);
1077     av_sha_update(sha, fixed_key, 16);
1078     av_sha_final(sha, c->file_iv);
1079
1080 fail:
1081     av_free(sha);
1082
1083     return ret;
1084 }
1085
1086 // Audible AAX (and AAX+) bytestream decryption
1087 static int aax_filter(uint8_t *input, int size, MOVContext *c)
1088 {
1089     int blocks = 0;
1090     unsigned char iv[16];
1091
1092     memcpy(iv, c->file_iv, 16); // iv is overwritten
1093     blocks = size >> 4; // trailing bytes are not encrypted!
1094     av_aes_init(c->aes_decrypt, c->file_key, 128, 1);
1095     av_aes_crypt(c->aes_decrypt, input, input, blocks, iv, 1);
1096
1097     return 0;
1098 }
1099
1100 /* read major brand, minor version and compatible brands and store them as metadata */
1101 static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1102 {
1103     uint32_t minor_ver;
1104     int comp_brand_size;
1105     char* comp_brands_str;
1106     uint8_t type[5] = {0};
1107     int ret = ffio_read_size(pb, type, 4);
1108     if (ret < 0)
1109         return ret;
1110
1111     if (strcmp(type, "qt  "))
1112         c->isom = 1;
1113     av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
1114     av_dict_set(&c->fc->metadata, "major_brand", type, 0);
1115     minor_ver = avio_rb32(pb); /* minor version */
1116     av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
1117
1118     comp_brand_size = atom.size - 8;
1119     if (comp_brand_size < 0)
1120         return AVERROR_INVALIDDATA;
1121     comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
1122     if (!comp_brands_str)
1123         return AVERROR(ENOMEM);
1124
1125     ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
1126     if (ret < 0) {
1127         av_freep(&comp_brands_str);
1128         return ret;
1129     }
1130     comp_brands_str[comp_brand_size] = 0;
1131     av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
1132     av_freep(&comp_brands_str);
1133
1134     return 0;
1135 }
1136
1137 /* this atom should contain all header atoms */
1138 static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1139 {
1140     int ret;
1141
1142     if (c->found_moov) {
1143         av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1144         avio_skip(pb, atom.size);
1145         return 0;
1146     }
1147
1148     if ((ret = mov_read_default(c, pb, atom)) < 0)
1149         return ret;
1150     /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1151     /* so we don't parse the whole file if over a network */
1152     c->found_moov=1;
1153     return 0; /* now go for mdat */
1154 }
1155
1156 static MOVFragmentStreamInfo * get_frag_stream_info(
1157     MOVFragmentIndex *frag_index,
1158     int index,
1159     int id)
1160 {
1161     int i;
1162     MOVFragmentIndexItem * item;
1163
1164     if (index < 0 || index >= frag_index->nb_items)
1165         return NULL;
1166     item = &frag_index->item[index];
1167     for (i = 0; i < item->nb_stream_info; i++)
1168         if (item->stream_info[i].id == id)
1169             return &item->stream_info[i];
1170
1171     // This shouldn't happen
1172     return NULL;
1173 }
1174
1175 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1176 {
1177     int i;
1178     MOVFragmentIndexItem * item;
1179
1180     if (frag_index->current < 0 ||
1181         frag_index->current >= frag_index->nb_items)
1182         return;
1183
1184     item = &frag_index->item[frag_index->current];
1185     for (i = 0; i < item->nb_stream_info; i++)
1186         if (item->stream_info[i].id == id) {
1187             item->current = i;
1188             return;
1189         }
1190
1191     // id not found.  This shouldn't happen.
1192     item->current = -1;
1193 }
1194
1195 static MOVFragmentStreamInfo * get_current_frag_stream_info(
1196     MOVFragmentIndex *frag_index)
1197 {
1198     MOVFragmentIndexItem *item;
1199     if (frag_index->current < 0 ||
1200         frag_index->current >= frag_index->nb_items)
1201         return NULL;
1202
1203     item = &frag_index->item[frag_index->current];
1204     if (item->current >= 0 && item->current < item->nb_stream_info)
1205         return &item->stream_info[item->current];
1206
1207     // This shouldn't happen
1208     return NULL;
1209 }
1210
1211 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1212 {
1213     int a, b, m;
1214     int64_t moof_offset;
1215
1216     // Optimize for appending new entries
1217     if (!frag_index->nb_items ||
1218         frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1219         return frag_index->nb_items;
1220
1221     a = -1;
1222     b = frag_index->nb_items;
1223
1224     while (b - a > 1) {
1225         m = (a + b) >> 1;
1226         moof_offset = frag_index->item[m].moof_offset;
1227         if (moof_offset >= offset)
1228             b = m;
1229         if (moof_offset <= offset)
1230             a = m;
1231     }
1232     return b;
1233 }
1234
1235 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1236 {
1237     av_assert0(frag_stream_info);
1238     if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1239         return frag_stream_info->sidx_pts;
1240     if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1241         return frag_stream_info->first_tfra_pts;
1242     return frag_stream_info->tfdt_dts;
1243 }
1244
1245 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1246                              int index, int track_id)
1247 {
1248     MOVFragmentStreamInfo * frag_stream_info;
1249     int64_t timestamp;
1250     int i;
1251
1252     if (track_id >= 0) {
1253         frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1254         return frag_stream_info->sidx_pts;
1255     }
1256
1257     for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1258         frag_stream_info = &frag_index->item[index].stream_info[i];
1259         timestamp = get_stream_info_time(frag_stream_info);
1260         if (timestamp != AV_NOPTS_VALUE)
1261             return timestamp;
1262     }
1263     return AV_NOPTS_VALUE;
1264 }
1265
1266 static int search_frag_timestamp(MOVFragmentIndex *frag_index,
1267                                  AVStream *st, int64_t timestamp)
1268 {
1269     int a, b, m, m0;
1270     int64_t frag_time;
1271     int id = -1;
1272
1273     if (st) {
1274         // If the stream is referenced by any sidx, limit the search
1275         // to fragments that referenced this stream in the sidx
1276         MOVStreamContext *sc = st->priv_data;
1277         if (sc->has_sidx)
1278             id = st->id;
1279     }
1280
1281     a = -1;
1282     b = frag_index->nb_items;
1283
1284     while (b - a > 1) {
1285         m0 = m = (a + b) >> 1;
1286
1287         while (m < b &&
1288                (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1289             m++;
1290
1291         if (m < b && frag_time <= timestamp)
1292             a = m;
1293         else
1294             b = m0;
1295     }
1296
1297     return a;
1298 }
1299
1300 static int update_frag_index(MOVContext *c, int64_t offset)
1301 {
1302     int index, i;
1303     MOVFragmentIndexItem * item;
1304     MOVFragmentStreamInfo * frag_stream_info;
1305
1306     // If moof_offset already exists in frag_index, return index to it
1307     index = search_frag_moof_offset(&c->frag_index, offset);
1308     if (index < c->frag_index.nb_items &&
1309         c->frag_index.item[index].moof_offset == offset)
1310         return index;
1311
1312     // offset is not yet in frag index.
1313     // Insert new item at index (sorted by moof offset)
1314     item = av_fast_realloc(c->frag_index.item,
1315                            &c->frag_index.allocated_size,
1316                            (c->frag_index.nb_items + 1) *
1317                            sizeof(*c->frag_index.item));
1318     if(!item)
1319         return -1;
1320     c->frag_index.item = item;
1321
1322     frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1323                                         sizeof(*item->stream_info));
1324     if (!frag_stream_info)
1325         return -1;
1326
1327     for (i = 0; i < c->fc->nb_streams; i++) {
1328         // Avoid building frag index if streams lack track id.
1329         if (c->fc->streams[i]->id < 0)
1330             return AVERROR_INVALIDDATA;
1331
1332         frag_stream_info[i].id = c->fc->streams[i]->id;
1333         frag_stream_info[i].sidx_pts = AV_NOPTS_VALUE;
1334         frag_stream_info[i].tfdt_dts = AV_NOPTS_VALUE;
1335         frag_stream_info[i].first_tfra_pts = AV_NOPTS_VALUE;
1336         frag_stream_info[i].index_entry = -1;
1337         frag_stream_info[i].encryption_index = NULL;
1338     }
1339
1340     if (index < c->frag_index.nb_items)
1341         memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
1342                 (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
1343
1344     item = &c->frag_index.item[index];
1345     item->headers_read = 0;
1346     item->current = 0;
1347     item->nb_stream_info = c->fc->nb_streams;
1348     item->moof_offset = offset;
1349     item->stream_info = frag_stream_info;
1350     c->frag_index.nb_items++;
1351
1352     return index;
1353 }
1354
1355 static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
1356                                    int id, int entries)
1357 {
1358     int i;
1359     MOVFragmentStreamInfo * frag_stream_info;
1360
1361     if (index < 0)
1362         return;
1363     for (i = index; i < frag_index->nb_items; i++) {
1364         frag_stream_info = get_frag_stream_info(frag_index, i, id);
1365         if (frag_stream_info && frag_stream_info->index_entry >= 0)
1366             frag_stream_info->index_entry += entries;
1367     }
1368 }
1369
1370 static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1371 {
1372     // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
1373     c->fragment.found_tfhd = 0;
1374
1375     if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
1376         c->has_looked_for_mfra = 1;
1377         if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1378             int ret;
1379             av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
1380                     "for a mfra\n");
1381             if ((ret = mov_read_mfra(c, pb)) < 0) {
1382                 av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
1383                         "read the mfra (may be a live ismv)\n");
1384             }
1385         } else {
1386             av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
1387                     "seekable, can not look for mfra\n");
1388         }
1389     }
1390     c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8;
1391     av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
1392     c->frag_index.current = update_frag_index(c, c->fragment.moof_offset);
1393     return mov_read_default(c, pb, atom);
1394 }
1395
1396 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
1397 {
1398     if (time) {
1399         if(time >= 2082844800)
1400             time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
1401
1402         if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1403             av_log(NULL, AV_LOG_DEBUG, "creation_time is not representable\n");
1404             return;
1405         }
1406
1407         avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
1408     }
1409 }
1410
1411 static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1412 {
1413     AVStream *st;
1414     MOVStreamContext *sc;
1415     int version;
1416     char language[4] = {0};
1417     unsigned lang;
1418     int64_t creation_time;
1419
1420     if (c->fc->nb_streams < 1)
1421         return 0;
1422     st = c->fc->streams[c->fc->nb_streams-1];
1423     sc = st->priv_data;
1424
1425     if (sc->time_scale) {
1426         av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
1427         return AVERROR_INVALIDDATA;
1428     }
1429
1430     version = avio_r8(pb);
1431     if (version > 1) {
1432         avpriv_request_sample(c->fc, "Version %d", version);
1433         return AVERROR_PATCHWELCOME;
1434     }
1435     avio_rb24(pb); /* flags */
1436     if (version == 1) {
1437         creation_time = avio_rb64(pb);
1438         avio_rb64(pb);
1439     } else {
1440         creation_time = avio_rb32(pb);
1441         avio_rb32(pb); /* modification time */
1442     }
1443     mov_metadata_creation_time(&st->metadata, creation_time);
1444
1445     sc->time_scale = avio_rb32(pb);
1446     if (sc->time_scale <= 0) {
1447         av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
1448         sc->time_scale = 1;
1449     }
1450     st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1451
1452     lang = avio_rb16(pb); /* language */
1453     if (ff_mov_lang_to_iso639(lang, language))
1454         av_dict_set(&st->metadata, "language", language, 0);
1455     avio_rb16(pb); /* quality */
1456
1457     return 0;
1458 }
1459
1460 static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1461 {
1462     int i;
1463     int64_t creation_time;
1464     int version = avio_r8(pb); /* version */
1465     avio_rb24(pb); /* flags */
1466
1467     if (version == 1) {
1468         creation_time = avio_rb64(pb);
1469         avio_rb64(pb);
1470     } else {
1471         creation_time = avio_rb32(pb);
1472         avio_rb32(pb); /* modification time */
1473     }
1474     mov_metadata_creation_time(&c->fc->metadata, creation_time);
1475     c->time_scale = avio_rb32(pb); /* time scale */
1476     if (c->time_scale <= 0) {
1477         av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
1478         c->time_scale = 1;
1479     }
1480     av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
1481
1482     c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1483     // set the AVCodecContext duration because the duration of individual tracks
1484     // may be inaccurate
1485     if (c->time_scale > 0 && !c->trex_data)
1486         c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
1487     avio_rb32(pb); /* preferred scale */
1488
1489     avio_rb16(pb); /* preferred volume */
1490
1491     avio_skip(pb, 10); /* reserved */
1492
1493     /* movie display matrix, store it in main context and use it later on */
1494     for (i = 0; i < 3; i++) {
1495         c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1496         c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1497         c->movie_display_matrix[i][2] = avio_rb32(pb); //  2.30 fixed point
1498     }
1499
1500     avio_rb32(pb); /* preview time */
1501     avio_rb32(pb); /* preview duration */
1502     avio_rb32(pb); /* poster time */
1503     avio_rb32(pb); /* selection time */
1504     avio_rb32(pb); /* selection duration */
1505     avio_rb32(pb); /* current time */
1506     avio_rb32(pb); /* next track ID */
1507
1508     return 0;
1509 }
1510
1511 static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1512 {
1513     AVStream *st;
1514     int little_endian;
1515
1516     if (c->fc->nb_streams < 1)
1517         return 0;
1518     st = c->fc->streams[c->fc->nb_streams-1];
1519
1520     little_endian = avio_rb16(pb) & 0xFF;
1521     av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
1522     if (little_endian == 1) {
1523         switch (st->codecpar->codec_id) {
1524         case AV_CODEC_ID_PCM_S24BE:
1525             st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
1526             break;
1527         case AV_CODEC_ID_PCM_S32BE:
1528             st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
1529             break;
1530         case AV_CODEC_ID_PCM_F32BE:
1531             st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE;
1532             break;
1533         case AV_CODEC_ID_PCM_F64BE:
1534             st->codecpar->codec_id = AV_CODEC_ID_PCM_F64LE;
1535             break;
1536         default:
1537             break;
1538         }
1539     }
1540     return 0;
1541 }
1542
1543 static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1544 {
1545     AVStream *st;
1546     char color_parameter_type[5] = { 0 };
1547     uint16_t color_primaries, color_trc, color_matrix;
1548     int ret;
1549
1550     if (c->fc->nb_streams < 1)
1551         return 0;
1552     st = c->fc->streams[c->fc->nb_streams - 1];
1553
1554     ret = ffio_read_size(pb, color_parameter_type, 4);
1555     if (ret < 0)
1556         return ret;
1557     if (strncmp(color_parameter_type, "nclx", 4) &&
1558         strncmp(color_parameter_type, "nclc", 4)) {
1559         av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
1560                color_parameter_type);
1561         return 0;
1562     }
1563
1564     color_primaries = avio_rb16(pb);
1565     color_trc = avio_rb16(pb);
1566     color_matrix = avio_rb16(pb);
1567
1568     av_log(c->fc, AV_LOG_TRACE,
1569            "%s: pri %d trc %d matrix %d",
1570            color_parameter_type, color_primaries, color_trc, color_matrix);
1571
1572     if (!strncmp(color_parameter_type, "nclx", 4)) {
1573         uint8_t color_range = avio_r8(pb) >> 7;
1574         av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range);
1575         if (color_range)
1576             st->codecpar->color_range = AVCOL_RANGE_JPEG;
1577         else
1578             st->codecpar->color_range = AVCOL_RANGE_MPEG;
1579     }
1580
1581     if (!av_color_primaries_name(color_primaries))
1582         color_primaries = AVCOL_PRI_UNSPECIFIED;
1583     if (!av_color_transfer_name(color_trc))
1584         color_trc = AVCOL_TRC_UNSPECIFIED;
1585     if (!av_color_space_name(color_matrix))
1586         color_matrix = AVCOL_SPC_UNSPECIFIED;
1587
1588     st->codecpar->color_primaries = color_primaries;
1589     st->codecpar->color_trc       = color_trc;
1590     st->codecpar->color_space     = color_matrix;
1591     av_log(c->fc, AV_LOG_TRACE, "\n");
1592
1593     return 0;
1594 }
1595
1596 static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1597 {
1598     AVStream *st;
1599     unsigned mov_field_order;
1600     enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
1601
1602     if (c->fc->nb_streams < 1) // will happen with jp2 files
1603         return 0;
1604     st = c->fc->streams[c->fc->nb_streams-1];
1605     if (atom.size < 2)
1606         return AVERROR_INVALIDDATA;
1607     mov_field_order = avio_rb16(pb);
1608     if ((mov_field_order & 0xFF00) == 0x0100)
1609         decoded_field_order = AV_FIELD_PROGRESSIVE;
1610     else if ((mov_field_order & 0xFF00) == 0x0200) {
1611         switch (mov_field_order & 0xFF) {
1612         case 0x01: decoded_field_order = AV_FIELD_TT;
1613                    break;
1614         case 0x06: decoded_field_order = AV_FIELD_BB;
1615                    break;
1616         case 0x09: decoded_field_order = AV_FIELD_TB;
1617                    break;
1618         case 0x0E: decoded_field_order = AV_FIELD_BT;
1619                    break;
1620         }
1621     }
1622     if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
1623         av_log(NULL, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
1624     }
1625     st->codecpar->field_order = decoded_field_order;
1626
1627     return 0;
1628 }
1629
1630 static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
1631 {
1632     int err = 0;
1633     uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
1634     if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
1635         return AVERROR_INVALIDDATA;
1636     if ((err = av_reallocp(&par->extradata, size)) < 0) {
1637         par->extradata_size = 0;
1638         return err;
1639     }
1640     par->extradata_size = size - AV_INPUT_BUFFER_PADDING_SIZE;
1641     return 0;
1642 }
1643
1644 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
1645 static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
1646                                         AVCodecParameters *par, uint8_t *buf)
1647 {
1648     int64_t result = atom.size;
1649     int err;
1650
1651     AV_WB32(buf    , atom.size + 8);
1652     AV_WL32(buf + 4, atom.type);
1653     err = ffio_read_size(pb, buf + 8, atom.size);
1654     if (err < 0) {
1655         par->extradata_size -= atom.size;
1656         return err;
1657     } else if (err < atom.size) {
1658         av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
1659         par->extradata_size -= atom.size - err;
1660         result = err;
1661     }
1662     memset(buf + 8 + err, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1663     return result;
1664 }
1665
1666 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
1667 static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
1668                               enum AVCodecID codec_id)
1669 {
1670     AVStream *st;
1671     uint64_t original_size;
1672     int err;
1673
1674     if (c->fc->nb_streams < 1) // will happen with jp2 files
1675         return 0;
1676     st = c->fc->streams[c->fc->nb_streams-1];
1677
1678     if (st->codecpar->codec_id != codec_id)
1679         return 0; /* unexpected codec_id - don't mess with extradata */
1680
1681     original_size = st->codecpar->extradata_size;
1682     err = mov_realloc_extradata(st->codecpar, atom);
1683     if (err)
1684         return err;
1685
1686     err =  mov_read_atom_into_extradata(c, pb, atom, st->codecpar,  st->codecpar->extradata + original_size);
1687     if (err < 0)
1688         return err;
1689     return 0; // Note: this is the original behavior to ignore truncation.
1690 }
1691
1692 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
1693 static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1694 {
1695     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
1696 }
1697
1698 static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1699 {
1700     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
1701 }
1702
1703 static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1704 {
1705     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
1706 }
1707
1708 static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1709 {
1710     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
1711 }
1712
1713 static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1714 {
1715     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
1716     if(ret == 0)
1717         ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
1718     return ret;
1719 }
1720
1721 static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1722 {
1723     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
1724
1725     if (!ret && c->fc->nb_streams >= 1) {
1726         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1727         if (par->extradata_size >= 40) {
1728             par->height = AV_RB16(&par->extradata[36]);
1729             par->width  = AV_RB16(&par->extradata[38]);
1730         }
1731     }
1732     return ret;
1733 }
1734
1735 static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1736 {
1737     if (c->fc->nb_streams >= 1) {
1738         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1739         if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
1740             par->codec_id == AV_CODEC_ID_H264 &&
1741             atom.size > 11) {
1742             int cid;
1743             avio_skip(pb, 10);
1744             cid = avio_rb16(pb);
1745             /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
1746             if (cid == 0xd4d || cid == 0xd4e)
1747                 par->width = 1440;
1748             return 0;
1749         } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
1750                     par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
1751                     par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
1752                    atom.size >= 24) {
1753             int num, den;
1754             avio_skip(pb, 12);
1755             num = avio_rb32(pb);
1756             den = avio_rb32(pb);
1757             if (num <= 0 || den <= 0)
1758                 return 0;
1759             switch (avio_rb32(pb)) {
1760             case 2:
1761                 if (den >= INT_MAX / 2)
1762                     return 0;
1763                 den *= 2;
1764             case 1:
1765                 c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.num = num;
1766                 c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.den = den;
1767             default:
1768                 return 0;
1769             }
1770         }
1771     }
1772
1773     return mov_read_avid(c, pb, atom);
1774 }
1775
1776 static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1777 {
1778     int ret = 0;
1779     int length = 0;
1780     uint64_t original_size;
1781     if (c->fc->nb_streams >= 1) {
1782         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1783         if (par->codec_id == AV_CODEC_ID_H264)
1784             return 0;
1785         if (atom.size == 16) {
1786             original_size = par->extradata_size;
1787             ret = mov_realloc_extradata(par, atom);
1788             if (!ret) {
1789                 length =  mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
1790                 if (length == atom.size) {
1791                     const uint8_t range_value = par->extradata[original_size + 19];
1792                     switch (range_value) {
1793                     case 1:
1794                         par->color_range = AVCOL_RANGE_MPEG;
1795                         break;
1796                     case 2:
1797                         par->color_range = AVCOL_RANGE_JPEG;
1798                         break;
1799                     default:
1800                         av_log(c, AV_LOG_WARNING, "ignored unknown aclr value (%d)\n", range_value);
1801                         break;
1802                     }
1803                     ff_dlog(c, "color_range: %d\n", par->color_range);
1804                 } else {
1805                   /* For some reason the whole atom was not added to the extradata */
1806                   av_log(c, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
1807                 }
1808             } else {
1809                 av_log(c, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
1810             }
1811         } else {
1812             av_log(c, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
1813         }
1814     }
1815
1816     return ret;
1817 }
1818
1819 static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1820 {
1821     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
1822 }
1823
1824 static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1825 {
1826     AVStream *st;
1827     int ret;
1828
1829     if (c->fc->nb_streams < 1)
1830         return 0;
1831     st = c->fc->streams[c->fc->nb_streams-1];
1832
1833     if ((uint64_t)atom.size > (1<<30))
1834         return AVERROR_INVALIDDATA;
1835
1836     if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
1837         st->codecpar->codec_id == AV_CODEC_ID_QDMC ||
1838         st->codecpar->codec_id == AV_CODEC_ID_SPEEX) {
1839         // pass all frma atom to codec, needed at least for QDMC and QDM2
1840         av_freep(&st->codecpar->extradata);
1841         ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1842         if (ret < 0)
1843             return ret;
1844     } else if (atom.size > 8) { /* to read frma, esds atoms */
1845         if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1846             uint64_t buffer;
1847             ret = ffio_ensure_seekback(pb, 8);
1848             if (ret < 0)
1849                 return ret;
1850             buffer = avio_rb64(pb);
1851             atom.size -= 8;
1852             if (  (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1853                 && buffer >> 32 <= atom.size
1854                 && buffer >> 32 >= 8) {
1855                 avio_skip(pb, -8);
1856                 atom.size += 8;
1857             } else if (!st->codecpar->extradata_size) {
1858 #define ALAC_EXTRADATA_SIZE 36
1859                 st->codecpar->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
1860                 if (!st->codecpar->extradata)
1861                     return AVERROR(ENOMEM);
1862                 st->codecpar->extradata_size = ALAC_EXTRADATA_SIZE;
1863                 AV_WB32(st->codecpar->extradata    , ALAC_EXTRADATA_SIZE);
1864                 AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1865                 AV_WB64(st->codecpar->extradata + 12, buffer);
1866                 avio_read(pb, st->codecpar->extradata + 20, 16);
1867                 avio_skip(pb, atom.size - 24);
1868                 return 0;
1869             }
1870         }
1871         if ((ret = mov_read_default(c, pb, atom)) < 0)
1872             return ret;
1873     } else
1874         avio_skip(pb, atom.size);
1875     return 0;
1876 }
1877
1878 /**
1879  * This function reads atom content and puts data in extradata without tag
1880  * nor size unlike mov_read_extradata.
1881  */
1882 static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1883 {
1884     AVStream *st;
1885     int ret;
1886
1887     if (c->fc->nb_streams < 1)
1888         return 0;
1889     st = c->fc->streams[c->fc->nb_streams-1];
1890
1891     if ((uint64_t)atom.size > (1<<30))
1892         return AVERROR_INVALIDDATA;
1893
1894     if (atom.size >= 10) {
1895         // Broken files created by legacy versions of libavformat will
1896         // wrap a whole fiel atom inside of a glbl atom.
1897         unsigned size = avio_rb32(pb);
1898         unsigned type = avio_rl32(pb);
1899         avio_seek(pb, -8, SEEK_CUR);
1900         if (type == MKTAG('f','i','e','l') && size == atom.size)
1901             return mov_read_default(c, pb, atom);
1902     }
1903     if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1904         av_log(c, AV_LOG_WARNING, "ignoring multiple glbl\n");
1905         return 0;
1906     }
1907     av_freep(&st->codecpar->extradata);
1908     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1909     if (ret < 0)
1910         return ret;
1911     if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
1912         /* HEVC-based Dolby Vision derived from hvc1.
1913            Happens to match with an identifier
1914            previously utilized for DV. Thus, if we have
1915            the hvcC extradata box available as specified,
1916            set codec to HEVC */
1917         st->codecpar->codec_id = AV_CODEC_ID_HEVC;
1918
1919     return 0;
1920 }
1921
1922 static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1923 {
1924     AVStream *st;
1925     uint8_t profile_level;
1926     int ret;
1927
1928     if (c->fc->nb_streams < 1)
1929         return 0;
1930     st = c->fc->streams[c->fc->nb_streams-1];
1931
1932     if (atom.size >= (1<<28) || atom.size < 7)
1933         return AVERROR_INVALIDDATA;
1934
1935     profile_level = avio_r8(pb);
1936     if ((profile_level & 0xf0) != 0xc0)
1937         return 0;
1938
1939     avio_seek(pb, 6, SEEK_CUR);
1940     av_freep(&st->codecpar->extradata);
1941     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1942     if (ret < 0)
1943         return ret;
1944
1945     return 0;
1946 }
1947
1948 /**
1949  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1950  * but can have extradata appended at the end after the 40 bytes belonging
1951  * to the struct.
1952  */
1953 static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1954 {
1955     AVStream *st;
1956     int ret;
1957
1958     if (c->fc->nb_streams < 1)
1959         return 0;
1960     if (atom.size <= 40)
1961         return 0;
1962     st = c->fc->streams[c->fc->nb_streams-1];
1963
1964     if ((uint64_t)atom.size > (1<<30))
1965         return AVERROR_INVALIDDATA;
1966
1967     avio_skip(pb, 40);
1968     av_freep(&st->codecpar->extradata);
1969     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
1970     if (ret < 0)
1971         return ret;
1972
1973     return 0;
1974 }
1975
1976 static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1977 {
1978     AVStream *st;
1979     MOVStreamContext *sc;
1980     unsigned int i, entries;
1981
1982     if (c->fc->nb_streams < 1)
1983         return 0;
1984     st = c->fc->streams[c->fc->nb_streams-1];
1985     sc = st->priv_data;
1986
1987     avio_r8(pb); /* version */
1988     avio_rb24(pb); /* flags */
1989
1990     entries = avio_rb32(pb);
1991
1992     if (!entries)
1993         return 0;
1994
1995     if (sc->chunk_offsets)
1996         av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
1997     av_free(sc->chunk_offsets);
1998     sc->chunk_count = 0;
1999     sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2000     if (!sc->chunk_offsets)
2001         return AVERROR(ENOMEM);
2002     sc->chunk_count = entries;
2003
2004     if      (atom.type == MKTAG('s','t','c','o'))
2005         for (i = 0; i < entries && !pb->eof_reached; i++)
2006             sc->chunk_offsets[i] = avio_rb32(pb);
2007     else if (atom.type == MKTAG('c','o','6','4'))
2008         for (i = 0; i < entries && !pb->eof_reached; i++)
2009             sc->chunk_offsets[i] = avio_rb64(pb);
2010     else
2011         return AVERROR_INVALIDDATA;
2012
2013     sc->chunk_count = i;
2014
2015     if (pb->eof_reached) {
2016         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2017         return AVERROR_EOF;
2018     }
2019
2020     return 0;
2021 }
2022
2023 static int mov_codec_id(AVStream *st, uint32_t format)
2024 {
2025     int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
2026
2027     if (id <= 0 &&
2028         ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2029          (format & 0xFFFF) == 'T' + ('S' << 8)))
2030         id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
2031
2032     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2033         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
2034     } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2035                /* skip old ASF MPEG-4 tag */
2036                format && format != MKTAG('m','p','4','s')) {
2037         id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2038         if (id <= 0)
2039             id = ff_codec_get_id(ff_codec_bmp_tags, format);
2040         if (id > 0)
2041             st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
2042         else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2043                     (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
2044                     st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2045             id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
2046             if (id > 0)
2047                 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2048             else
2049                 id = ff_codec_get_id(ff_codec_movdata_tags, format);
2050         }
2051     }
2052
2053     st->codecpar->codec_tag = format;
2054
2055     return id;
2056 }
2057
2058 static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
2059                                  AVStream *st, MOVStreamContext *sc)
2060 {
2061     uint8_t codec_name[32] = { 0 };
2062     int64_t stsd_start;
2063     unsigned int len;
2064
2065     /* The first 16 bytes of the video sample description are already
2066      * read in ff_mov_read_stsd_entries() */
2067     stsd_start = avio_tell(pb) - 16;
2068
2069     avio_rb16(pb); /* version */
2070     avio_rb16(pb); /* revision level */
2071     avio_rb32(pb); /* vendor */
2072     avio_rb32(pb); /* temporal quality */
2073     avio_rb32(pb); /* spatial quality */
2074
2075     st->codecpar->width  = avio_rb16(pb); /* width */
2076     st->codecpar->height = avio_rb16(pb); /* height */
2077
2078     avio_rb32(pb); /* horiz resolution */
2079     avio_rb32(pb); /* vert resolution */
2080     avio_rb32(pb); /* data size, always 0 */
2081     avio_rb16(pb); /* frames per samples */
2082
2083     len = avio_r8(pb); /* codec name, pascal string */
2084     if (len > 31)
2085         len = 31;
2086     mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2087     if (len < 31)
2088         avio_skip(pb, 31 - len);
2089
2090     if (codec_name[0])
2091         av_dict_set(&st->metadata, "encoder", codec_name, 0);
2092
2093     /* codec_tag YV12 triggers an UV swap in rawdec.c */
2094     if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2095         st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2096         st->codecpar->width &= ~1;
2097         st->codecpar->height &= ~1;
2098     }
2099     /* Flash Media Server uses tag H.263 with Sorenson Spark */
2100     if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2101         !strncmp(codec_name, "Sorenson H263", 13))
2102         st->codecpar->codec_id = AV_CODEC_ID_FLV1;
2103
2104     st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2105
2106     avio_seek(pb, stsd_start, SEEK_SET);
2107
2108     if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2109         st->codecpar->bits_per_coded_sample &= 0x1F;
2110         sc->has_palette = 1;
2111     }
2112 }
2113
2114 static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
2115                                  AVStream *st, MOVStreamContext *sc)
2116 {
2117     int bits_per_sample, flags;
2118     uint16_t version = avio_rb16(pb);
2119     AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2120
2121     avio_rb16(pb); /* revision level */
2122     avio_rb32(pb); /* vendor */
2123
2124     st->codecpar->channels              = avio_rb16(pb); /* channel count */
2125     st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2126     av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2127
2128     sc->audio_cid = avio_rb16(pb);
2129     avio_rb16(pb); /* packet size = 0 */
2130
2131     st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2132
2133     // Read QT version 1 fields. In version 0 these do not exist.
2134     av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2135     if (!c->isom ||
2136         (compatible_brands && strstr(compatible_brands->value, "qt  ")) ||
2137         (sc->stsd_version == 0 && version > 0)) {
2138         if (version == 1) {
2139             sc->samples_per_frame = avio_rb32(pb);
2140             avio_rb32(pb); /* bytes per packet */
2141             sc->bytes_per_frame = avio_rb32(pb);
2142             avio_rb32(pb); /* bytes per sample */
2143         } else if (version == 2) {
2144             avio_rb32(pb); /* sizeof struct only */
2145             st->codecpar->sample_rate = av_int2double(avio_rb64(pb));
2146             st->codecpar->channels    = avio_rb32(pb);
2147             avio_rb32(pb); /* always 0x7F000000 */
2148             st->codecpar->bits_per_coded_sample = avio_rb32(pb);
2149
2150             flags = avio_rb32(pb); /* lpcm format specific flag */
2151             sc->bytes_per_frame   = avio_rb32(pb);
2152             sc->samples_per_frame = avio_rb32(pb);
2153             if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2154                 st->codecpar->codec_id =
2155                     ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample,
2156                                              flags);
2157         }
2158         if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2159             /* can't correctly handle variable sized packet as audio unit */
2160             switch (st->codecpar->codec_id) {
2161             case AV_CODEC_ID_MP2:
2162             case AV_CODEC_ID_MP3:
2163                 st->need_parsing = AVSTREAM_PARSE_FULL;
2164                 break;
2165             }
2166         }
2167     }
2168
2169     if (sc->format == 0) {
2170         if (st->codecpar->bits_per_coded_sample == 8)
2171             st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2172         else if (st->codecpar->bits_per_coded_sample == 16)
2173             st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2174     }
2175
2176     switch (st->codecpar->codec_id) {
2177     case AV_CODEC_ID_PCM_S8:
2178     case AV_CODEC_ID_PCM_U8:
2179         if (st->codecpar->bits_per_coded_sample == 16)
2180             st->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
2181         break;
2182     case AV_CODEC_ID_PCM_S16LE:
2183     case AV_CODEC_ID_PCM_S16BE:
2184         if (st->codecpar->bits_per_coded_sample == 8)
2185             st->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
2186         else if (st->codecpar->bits_per_coded_sample == 24)
2187             st->codecpar->codec_id =
2188                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
2189                 AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2190         else if (st->codecpar->bits_per_coded_sample == 32)
2191              st->codecpar->codec_id =
2192                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
2193                 AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2194         break;
2195     /* set values for old format before stsd version 1 appeared */
2196     case AV_CODEC_ID_MACE3:
2197         sc->samples_per_frame = 6;
2198         sc->bytes_per_frame   = 2 * st->codecpar->channels;
2199         break;
2200     case AV_CODEC_ID_MACE6:
2201         sc->samples_per_frame = 6;
2202         sc->bytes_per_frame   = 1 * st->codecpar->channels;
2203         break;
2204     case AV_CODEC_ID_ADPCM_IMA_QT:
2205         sc->samples_per_frame = 64;
2206         sc->bytes_per_frame   = 34 * st->codecpar->channels;
2207         break;
2208     case AV_CODEC_ID_GSM:
2209         sc->samples_per_frame = 160;
2210         sc->bytes_per_frame   = 33;
2211         break;
2212     default:
2213         break;
2214     }
2215
2216     bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2217     if (bits_per_sample) {
2218         st->codecpar->bits_per_coded_sample = bits_per_sample;
2219         sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2220     }
2221 }
2222
2223 static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
2224                                     AVStream *st, MOVStreamContext *sc,
2225                                     int64_t size)
2226 {
2227     // ttxt stsd contains display flags, justification, background
2228     // color, fonts, and default styles, so fake an atom to read it
2229     MOVAtom fake_atom = { .size = size };
2230     // mp4s contains a regular esds atom
2231     if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2232         mov_read_glbl(c, pb, fake_atom);
2233     st->codecpar->width  = sc->width;
2234     st->codecpar->height = sc->height;
2235 }
2236
2237 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2238 {
2239     uint8_t r, g, b;
2240     int y, cb, cr;
2241
2242     y  = (ycbcr >> 16) & 0xFF;
2243     cr = (ycbcr >> 8)  & 0xFF;
2244     cb =  ycbcr        & 0xFF;
2245
2246     b = av_clip_uint8((1164 * (y - 16)                     + 2018 * (cb - 128)) / 1000);
2247     g = av_clip_uint8((1164 * (y - 16) -  813 * (cr - 128) -  391 * (cb - 128)) / 1000);
2248     r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128)                    ) / 1000);
2249
2250     return (r << 16) | (g << 8) | b;
2251 }
2252
2253 static int mov_rewrite_dvd_sub_extradata(AVStream *st)
2254 {
2255     char buf[256] = {0};
2256     uint8_t *src = st->codecpar->extradata;
2257     int i;
2258
2259     if (st->codecpar->extradata_size != 64)
2260         return 0;
2261
2262     if (st->codecpar->width > 0 &&  st->codecpar->height > 0)
2263         snprintf(buf, sizeof(buf), "size: %dx%d\n",
2264                  st->codecpar->width, st->codecpar->height);
2265     av_strlcat(buf, "palette: ", sizeof(buf));
2266
2267     for (i = 0; i < 16; i++) {
2268         uint32_t yuv = AV_RB32(src + i * 4);
2269         uint32_t rgba = yuv_to_rgba(yuv);
2270
2271         av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2272     }
2273
2274     if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2275         return 0;
2276
2277     av_freep(&st->codecpar->extradata);
2278     st->codecpar->extradata_size = 0;
2279     st->codecpar->extradata = av_mallocz(strlen(buf) + AV_INPUT_BUFFER_PADDING_SIZE);
2280     if (!st->codecpar->extradata)
2281         return AVERROR(ENOMEM);
2282     st->codecpar->extradata_size = strlen(buf);
2283     memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2284
2285     return 0;
2286 }
2287
2288 static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
2289                                 AVStream *st, MOVStreamContext *sc,
2290                                 int64_t size)
2291 {
2292     int ret;
2293
2294     if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2295         if ((int)size != size)
2296             return AVERROR(ENOMEM);
2297
2298         ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2299         if (ret < 0)
2300             return ret;
2301         if (size > 16) {
2302             MOVStreamContext *tmcd_ctx = st->priv_data;
2303             int val;
2304             val = AV_RB32(st->codecpar->extradata + 4);
2305             tmcd_ctx->tmcd_flags = val;
2306             st->avg_frame_rate.num = st->codecpar->extradata[16]; /* number of frame */
2307             st->avg_frame_rate.den = 1;
2308 #if FF_API_LAVF_AVCTX
2309 FF_DISABLE_DEPRECATION_WARNINGS
2310             st->codec->time_base = av_inv_q(st->avg_frame_rate);
2311 FF_ENABLE_DEPRECATION_WARNINGS
2312 #endif
2313             /* adjust for per frame dur in counter mode */
2314             if (tmcd_ctx->tmcd_flags & 0x0008) {
2315                 int timescale = AV_RB32(st->codecpar->extradata + 8);
2316                 int framedur = AV_RB32(st->codecpar->extradata + 12);
2317                 st->avg_frame_rate.num *= timescale;
2318                 st->avg_frame_rate.den *= framedur;
2319 #if FF_API_LAVF_AVCTX
2320 FF_DISABLE_DEPRECATION_WARNINGS
2321                 st->codec->time_base.den *= timescale;
2322                 st->codec->time_base.num *= framedur;
2323 FF_ENABLE_DEPRECATION_WARNINGS
2324 #endif
2325             }
2326             if (size > 30) {
2327                 uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2328                 uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2329                 if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2330                     uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2331                     if (str_size > 0 && size >= (int)str_size + 26) {
2332                         char *reel_name = av_malloc(str_size + 1);
2333                         if (!reel_name)
2334                             return AVERROR(ENOMEM);
2335                         memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2336                         reel_name[str_size] = 0; /* Add null terminator */
2337                         /* don't add reel_name if emtpy string */
2338                         if (*reel_name == 0) {
2339                             av_free(reel_name);
2340                         } else {
2341                             av_dict_set(&st->metadata, "reel_name", reel_name,  AV_DICT_DONT_STRDUP_VAL);
2342                         }
2343                     }
2344                 }
2345             }
2346         }
2347     } else {
2348         /* other codec type, just skip (rtp, mp4s ...) */
2349         avio_skip(pb, size);
2350     }
2351     return 0;
2352 }
2353
2354 static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
2355                                    AVStream *st, MOVStreamContext *sc)
2356 {
2357     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2358         !st->codecpar->sample_rate && sc->time_scale > 1)
2359         st->codecpar->sample_rate = sc->time_scale;
2360
2361     /* special codec parameters handling */
2362     switch (st->codecpar->codec_id) {
2363 #if CONFIG_DV_DEMUXER
2364     case AV_CODEC_ID_DVAUDIO:
2365         c->dv_fctx = avformat_alloc_context();
2366         if (!c->dv_fctx) {
2367             av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2368             return AVERROR(ENOMEM);
2369         }
2370         c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
2371         if (!c->dv_demux) {
2372             av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2373             return AVERROR(ENOMEM);
2374         }
2375         sc->dv_audio_container = 1;
2376         st->codecpar->codec_id    = AV_CODEC_ID_PCM_S16LE;
2377         break;
2378 #endif
2379     /* no ifdef since parameters are always those */
2380     case AV_CODEC_ID_QCELP:
2381         st->codecpar->channels = 1;
2382         // force sample rate for qcelp when not stored in mov
2383         if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2384             st->codecpar->sample_rate = 8000;
2385         // FIXME: Why is the following needed for some files?
2386         sc->samples_per_frame = 160;
2387         if (!sc->bytes_per_frame)
2388             sc->bytes_per_frame = 35;
2389         break;
2390     case AV_CODEC_ID_AMR_NB:
2391         st->codecpar->channels    = 1;
2392         /* force sample rate for amr, stsd in 3gp does not store sample rate */
2393         st->codecpar->sample_rate = 8000;
2394         break;
2395     case AV_CODEC_ID_AMR_WB:
2396         st->codecpar->channels    = 1;
2397         st->codecpar->sample_rate = 16000;
2398         break;
2399     case AV_CODEC_ID_MP2:
2400     case AV_CODEC_ID_MP3:
2401         /* force type after stsd for m1a hdlr */
2402         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
2403         break;
2404     case AV_CODEC_ID_GSM:
2405     case AV_CODEC_ID_ADPCM_MS:
2406     case AV_CODEC_ID_ADPCM_IMA_WAV:
2407     case AV_CODEC_ID_ILBC:
2408     case AV_CODEC_ID_MACE3:
2409     case AV_CODEC_ID_MACE6:
2410     case AV_CODEC_ID_QDM2:
2411         st->codecpar->block_align = sc->bytes_per_frame;
2412         break;
2413     case AV_CODEC_ID_ALAC:
2414         if (st->codecpar->extradata_size == 36) {
2415             st->codecpar->channels    = AV_RB8 (st->codecpar->extradata + 21);
2416             st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2417         }
2418         break;
2419     case AV_CODEC_ID_AC3:
2420     case AV_CODEC_ID_EAC3:
2421     case AV_CODEC_ID_MPEG1VIDEO:
2422     case AV_CODEC_ID_VC1:
2423     case AV_CODEC_ID_VP8:
2424     case AV_CODEC_ID_VP9:
2425         st->need_parsing = AVSTREAM_PARSE_FULL;
2426         break;
2427     default:
2428         break;
2429     }
2430     return 0;
2431 }
2432
2433 static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
2434                                   int codec_tag, int format,
2435                                   int64_t size)
2436 {
2437     int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2438
2439     if (codec_tag &&
2440          (codec_tag != format &&
2441           // AVID 1:1 samples with differing data format and codec tag exist
2442           (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2443           // prores is allowed to have differing data format and codec tag
2444           codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2445           // so is dv (sigh)
2446           codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2447           (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2448                                  : codec_tag != MKTAG('j','p','e','g')))) {
2449         /* Multiple fourcc, we skip JPEG. This is not correct, we should
2450          * export it as a separate AVStream but this needs a few changes
2451          * in the MOV demuxer, patch welcome. */
2452
2453         av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2454         avio_skip(pb, size);
2455         return 1;
2456     }
2457
2458     return 0;
2459 }
2460
2461 int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
2462 {
2463     AVStream *st;
2464     MOVStreamContext *sc;
2465     int pseudo_stream_id;
2466
2467     av_assert0 (c->fc->nb_streams >= 1);
2468     st = c->fc->streams[c->fc->nb_streams-1];
2469     sc = st->priv_data;
2470
2471     for (pseudo_stream_id = 0;
2472          pseudo_stream_id < entries && !pb->eof_reached;
2473          pseudo_stream_id++) {
2474         //Parsing Sample description table
2475         enum AVCodecID id;
2476         int ret, dref_id = 1;
2477         MOVAtom a = { AV_RL32("stsd") };
2478         int64_t start_pos = avio_tell(pb);
2479         int64_t size    = avio_rb32(pb); /* size */
2480         uint32_t format = avio_rl32(pb); /* data format */
2481
2482         if (size >= 16) {
2483             avio_rb32(pb); /* reserved */
2484             avio_rb16(pb); /* reserved */
2485             dref_id = avio_rb16(pb);
2486         } else if (size <= 7) {
2487             av_log(c->fc, AV_LOG_ERROR,
2488                    "invalid size %"PRId64" in stsd\n", size);
2489             return AVERROR_INVALIDDATA;
2490         }
2491
2492         if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
2493                                    size - (avio_tell(pb) - start_pos))) {
2494             sc->stsd_count++;
2495             continue;
2496         }
2497
2498         sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2499         sc->dref_id= dref_id;
2500         sc->format = format;
2501
2502         id = mov_codec_id(st, format);
2503
2504         av_log(c->fc, AV_LOG_TRACE,
2505                "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2506                av_fourcc2str(format), st->codecpar->codec_type);
2507
2508         st->codecpar->codec_id = id;
2509         if (st->codecpar->codec_type==AVMEDIA_TYPE_VIDEO) {
2510             mov_parse_stsd_video(c, pb, st, sc);
2511         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2512             mov_parse_stsd_audio(c, pb, st, sc);
2513             if (st->codecpar->sample_rate < 0) {
2514                 av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2515                 return AVERROR_INVALIDDATA;
2516             }
2517         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2518             mov_parse_stsd_subtitle(c, pb, st, sc,
2519                                     size - (avio_tell(pb) - start_pos));
2520         } else {
2521             ret = mov_parse_stsd_data(c, pb, st, sc,
2522                                       size - (avio_tell(pb) - start_pos));
2523             if (ret < 0)
2524                 return ret;
2525         }
2526         /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2527         a.size = size - (avio_tell(pb) - start_pos);
2528         if (a.size > 8) {
2529             if ((ret = mov_read_default(c, pb, a)) < 0)
2530                 return ret;
2531         } else if (a.size > 0)
2532             avio_skip(pb, a.size);
2533
2534         if (sc->extradata && st->codecpar->extradata) {
2535             int extra_size = st->codecpar->extradata_size;
2536
2537             /* Move the current stream extradata to the stream context one. */
2538             sc->extradata_size[pseudo_stream_id] = extra_size;
2539             sc->extradata[pseudo_stream_id] = av_malloc(extra_size + AV_INPUT_BUFFER_PADDING_SIZE);
2540             if (!sc->extradata[pseudo_stream_id])
2541                 return AVERROR(ENOMEM);
2542             memcpy(sc->extradata[pseudo_stream_id], st->codecpar->extradata, extra_size);
2543             av_freep(&st->codecpar->extradata);
2544             st->codecpar->extradata_size = 0;
2545         }
2546         sc->stsd_count++;
2547     }
2548
2549     if (pb->eof_reached) {
2550         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2551         return AVERROR_EOF;
2552     }
2553
2554     return 0;
2555 }
2556
2557 static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2558 {
2559     AVStream *st;
2560     MOVStreamContext *sc;
2561     int ret, entries;
2562
2563     if (c->fc->nb_streams < 1)
2564         return 0;
2565     st = c->fc->streams[c->fc->nb_streams - 1];
2566     sc = st->priv_data;
2567
2568     sc->stsd_version = avio_r8(pb);
2569     avio_rb24(pb); /* flags */
2570     entries = avio_rb32(pb);
2571
2572     /* Each entry contains a size (4 bytes) and format (4 bytes). */
2573     if (entries <= 0 || entries > atom.size / 8) {
2574         av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2575         return AVERROR_INVALIDDATA;
2576     }
2577
2578     if (sc->extradata) {
2579         av_log(c->fc, AV_LOG_ERROR,
2580                "Duplicate stsd found in this track.\n");
2581         return AVERROR_INVALIDDATA;
2582     }
2583
2584     /* Prepare space for hosting multiple extradata. */
2585     sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2586     if (!sc->extradata)
2587         return AVERROR(ENOMEM);
2588
2589     sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2590     if (!sc->extradata_size) {
2591         ret = AVERROR(ENOMEM);
2592         goto fail;
2593     }
2594
2595     ret = ff_mov_read_stsd_entries(c, pb, entries);
2596     if (ret < 0)
2597         goto fail;
2598
2599     /* Restore back the primary extradata. */
2600     av_freep(&st->codecpar->extradata);
2601     st->codecpar->extradata_size = sc->extradata_size[0];
2602     if (sc->extradata_size[0]) {
2603         st->codecpar->extradata = av_mallocz(sc->extradata_size[0] + AV_INPUT_BUFFER_PADDING_SIZE);
2604         if (!st->codecpar->extradata)
2605             return AVERROR(ENOMEM);
2606         memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2607     }
2608
2609     return mov_finalize_stsd_codec(c, pb, st, sc);
2610 fail:
2611     if (sc->extradata) {
2612         int j;
2613         for (j = 0; j < sc->stsd_count; j++)
2614             av_freep(&sc->extradata[j]);
2615     }
2616
2617     av_freep(&sc->extradata);
2618     av_freep(&sc->extradata_size);
2619     return ret;
2620 }
2621
2622 static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2623 {
2624     AVStream *st;
2625     MOVStreamContext *sc;
2626     unsigned int i, entries;
2627
2628     if (c->fc->nb_streams < 1)
2629         return 0;
2630     st = c->fc->streams[c->fc->nb_streams-1];
2631     sc = st->priv_data;
2632
2633     avio_r8(pb); /* version */
2634     avio_rb24(pb); /* flags */
2635
2636     entries = avio_rb32(pb);
2637     if ((uint64_t)entries * 12 + 4 > atom.size)
2638         return AVERROR_INVALIDDATA;
2639
2640     av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2641
2642     if (!entries)
2643         return 0;
2644     if (sc->stsc_data)
2645         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
2646     av_free(sc->stsc_data);
2647     sc->stsc_count = 0;
2648     sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2649     if (!sc->stsc_data)
2650         return AVERROR(ENOMEM);
2651
2652     for (i = 0; i < entries && !pb->eof_reached; i++) {
2653         sc->stsc_data[i].first = avio_rb32(pb);
2654         sc->stsc_data[i].count = avio_rb32(pb);
2655         sc->stsc_data[i].id = avio_rb32(pb);
2656     }
2657
2658     sc->stsc_count = i;
2659     for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2660         int64_t first_min = i + 1;
2661         if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2662             (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2663             sc->stsc_data[i].first < first_min ||
2664             sc->stsc_data[i].count < 1 ||
2665             sc->stsc_data[i].id < 1) {
2666             av_log(c->fc, AV_LOG_WARNING, "STSC entry %d is invalid (first=%d count=%d id=%d)\n", i, sc->stsc_data[i].first, sc->stsc_data[i].count, sc->stsc_data[i].id);
2667             if (i+1 >= sc->stsc_count) {
2668                 sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2669                 if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2670                     sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2671                 sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2672                 sc->stsc_data[i].id    = FFMAX(sc->stsc_data[i].id, 1);
2673                 continue;
2674             }
2675             av_assert0(sc->stsc_data[i+1].first >= 2);
2676             // We replace this entry by the next valid
2677             sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2678             sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2679             sc->stsc_data[i].id    = sc->stsc_data[i+1].id;
2680         }
2681     }
2682
2683     if (pb->eof_reached) {
2684         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2685         return AVERROR_EOF;
2686     }
2687
2688     return 0;
2689 }
2690
2691 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2692 {
2693     return index < count - 1;
2694 }
2695
2696 /* Compute the samples value for the stsc entry at the given index. */
2697 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2698 {
2699     int chunk_count;
2700
2701     if (mov_stsc_index_valid(index, sc->stsc_count))
2702         chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2703     else {
2704         // Validation for stsc / stco  happens earlier in mov_read_stsc + mov_read_trak.
2705         av_assert0(sc->stsc_data[index].first <= sc->chunk_count);
2706         chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2707     }
2708
2709     return sc->stsc_data[index].count * (int64_t)chunk_count;
2710 }
2711
2712 static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2713 {
2714     AVStream *st;
2715     MOVStreamContext *sc;
2716     unsigned i, entries;
2717
2718     if (c->fc->nb_streams < 1)
2719         return 0;
2720     st = c->fc->streams[c->fc->nb_streams-1];
2721     sc = st->priv_data;
2722
2723     avio_rb32(pb); // version + flags
2724
2725     entries = avio_rb32(pb);
2726     if (sc->stps_data)
2727         av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2728     av_free(sc->stps_data);
2729     sc->stps_count = 0;
2730     sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2731     if (!sc->stps_data)
2732         return AVERROR(ENOMEM);
2733
2734     for (i = 0; i < entries && !pb->eof_reached; i++) {
2735         sc->stps_data[i] = avio_rb32(pb);
2736     }
2737
2738     sc->stps_count = i;
2739
2740     if (pb->eof_reached) {
2741         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2742         return AVERROR_EOF;
2743     }
2744
2745     return 0;
2746 }
2747
2748 static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2749 {
2750     AVStream *st;
2751     MOVStreamContext *sc;
2752     unsigned int i, entries;
2753
2754     if (c->fc->nb_streams < 1)
2755         return 0;
2756     st = c->fc->streams[c->fc->nb_streams-1];
2757     sc = st->priv_data;
2758
2759     avio_r8(pb); /* version */
2760     avio_rb24(pb); /* flags */
2761
2762     entries = avio_rb32(pb);
2763
2764     av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2765
2766     if (!entries)
2767     {
2768         sc->keyframe_absent = 1;
2769         if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2770             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2771         return 0;
2772     }
2773     if (sc->keyframes)
2774         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2775     if (entries >= UINT_MAX / sizeof(int))
2776         return AVERROR_INVALIDDATA;
2777     av_freep(&sc->keyframes);
2778     sc->keyframe_count = 0;
2779     sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2780     if (!sc->keyframes)
2781         return AVERROR(ENOMEM);
2782
2783     for (i = 0; i < entries && !pb->eof_reached; i++) {
2784         sc->keyframes[i] = avio_rb32(pb);
2785     }
2786
2787     sc->keyframe_count = i;
2788
2789     if (pb->eof_reached) {
2790         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2791         return AVERROR_EOF;
2792     }
2793
2794     return 0;
2795 }
2796
2797 static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2798 {
2799     AVStream *st;
2800     MOVStreamContext *sc;
2801     unsigned int i, entries, sample_size, field_size, num_bytes;
2802     GetBitContext gb;
2803     unsigned char* buf;
2804     int ret;
2805
2806     if (c->fc->nb_streams < 1)
2807         return 0;
2808     st = c->fc->streams[c->fc->nb_streams-1];
2809     sc = st->priv_data;
2810
2811     avio_r8(pb); /* version */
2812     avio_rb24(pb); /* flags */
2813
2814     if (atom.type == MKTAG('s','t','s','z')) {
2815         sample_size = avio_rb32(pb);
2816         if (!sc->sample_size) /* do not overwrite value computed in stsd */
2817             sc->sample_size = sample_size;
2818         sc->stsz_sample_size = sample_size;
2819         field_size = 32;
2820     } else {
2821         sample_size = 0;
2822         avio_rb24(pb); /* reserved */
2823         field_size = avio_r8(pb);
2824     }
2825     entries = avio_rb32(pb);
2826
2827     av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2828
2829     sc->sample_count = entries;
2830     if (sample_size)
2831         return 0;
2832
2833     if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2834         av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2835         return AVERROR_INVALIDDATA;
2836     }
2837
2838     if (!entries)
2839         return 0;
2840     if (entries >= (UINT_MAX - 4) / field_size)
2841         return AVERROR_INVALIDDATA;
2842     if (sc->sample_sizes)
2843         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2844     av_free(sc->sample_sizes);
2845     sc->sample_count = 0;
2846     sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2847     if (!sc->sample_sizes)
2848         return AVERROR(ENOMEM);
2849
2850     num_bytes = (entries*field_size+4)>>3;
2851
2852     buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2853     if (!buf) {
2854         av_freep(&sc->sample_sizes);
2855         return AVERROR(ENOMEM);
2856     }
2857
2858     ret = ffio_read_size(pb, buf, num_bytes);
2859     if (ret < 0) {
2860         av_freep(&sc->sample_sizes);
2861         av_free(buf);
2862         av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2863         return 0;
2864     }
2865
2866     init_get_bits(&gb, buf, 8*num_bytes);
2867
2868     for (i = 0; i < entries && !pb->eof_reached; i++) {
2869         sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2870         sc->data_size += sc->sample_sizes[i];
2871     }
2872
2873     sc->sample_count = i;
2874
2875     av_free(buf);
2876
2877     if (pb->eof_reached) {
2878         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2879         return AVERROR_EOF;
2880     }
2881
2882     return 0;
2883 }
2884
2885 static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2886 {
2887     AVStream *st;
2888     MOVStreamContext *sc;
2889     unsigned int i, entries, alloc_size = 0;
2890     int64_t duration=0;
2891     int64_t total_sample_count=0;
2892
2893     if (c->fc->nb_streams < 1)
2894         return 0;
2895     st = c->fc->streams[c->fc->nb_streams-1];
2896     sc = st->priv_data;
2897
2898     avio_r8(pb); /* version */
2899     avio_rb24(pb); /* flags */
2900     entries = avio_rb32(pb);
2901
2902     av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2903             c->fc->nb_streams-1, entries);
2904
2905     if (sc->stts_data)
2906         av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2907     av_freep(&sc->stts_data);
2908     sc->stts_count = 0;
2909     if (entries >= INT_MAX / sizeof(*sc->stts_data))
2910         return AVERROR(ENOMEM);
2911
2912     for (i = 0; i < entries && !pb->eof_reached; i++) {
2913         int sample_duration;
2914         unsigned int sample_count;
2915         unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2916         MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2917                                              min_entries * sizeof(*sc->stts_data));
2918         if (!stts_data) {
2919             av_freep(&sc->stts_data);
2920             sc->stts_count = 0;
2921             return AVERROR(ENOMEM);
2922         }
2923         sc->stts_count = min_entries;
2924         sc->stts_data = stts_data;
2925
2926         sample_count=avio_rb32(pb);
2927         sample_duration = avio_rb32(pb);
2928
2929         sc->stts_data[i].count= sample_count;
2930         sc->stts_data[i].duration= sample_duration;
2931
2932         av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2933                 sample_count, sample_duration);
2934
2935         duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2936         total_sample_count+=sample_count;
2937     }
2938
2939     sc->stts_count = i;
2940
2941     if (duration > 0 &&
2942         duration <= INT64_MAX - sc->duration_for_fps &&
2943         total_sample_count <= INT64_MAX - sc->nb_frames_for_fps
2944     ) {
2945         sc->duration_for_fps  += duration;
2946         sc->nb_frames_for_fps += total_sample_count;
2947     }
2948
2949     if (pb->eof_reached) {
2950         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2951         return AVERROR_EOF;
2952     }
2953
2954     st->nb_frames= total_sample_count;
2955     if (duration)
2956         st->duration= FFMIN(st->duration, duration);
2957     sc->track_end = duration;
2958     return 0;
2959 }
2960
2961 static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
2962 {
2963     if (duration < 0) {
2964         if (duration == INT_MIN) {
2965             av_log(NULL, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
2966             duration++;
2967         }
2968         sc->dts_shift = FFMAX(sc->dts_shift, -duration);
2969     }
2970 }
2971
2972 static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2973 {
2974     AVStream *st;
2975     MOVStreamContext *sc;
2976     unsigned int i, entries, ctts_count = 0;
2977
2978     if (c->fc->nb_streams < 1)
2979         return 0;
2980     st = c->fc->streams[c->fc->nb_streams-1];
2981     sc = st->priv_data;
2982
2983     avio_r8(pb); /* version */
2984     avio_rb24(pb); /* flags */
2985     entries = avio_rb32(pb);
2986
2987     av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
2988
2989     if (!entries)
2990         return 0;
2991     if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
2992         return AVERROR_INVALIDDATA;
2993     av_freep(&sc->ctts_data);
2994     sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
2995     if (!sc->ctts_data)
2996         return AVERROR(ENOMEM);
2997
2998     for (i = 0; i < entries && !pb->eof_reached; i++) {
2999         int count    =avio_rb32(pb);
3000         int duration =avio_rb32(pb);
3001
3002         if (count <= 0) {
3003             av_log(c->fc, AV_LOG_TRACE,
3004                    "ignoring CTTS entry with count=%d duration=%d\n",
3005                    count, duration);
3006             continue;
3007         }
3008
3009         add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3010                        count, duration);
3011
3012         av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3013                 count, duration);
3014
3015         if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3016             av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3017             av_freep(&sc->ctts_data);
3018             sc->ctts_count = 0;
3019             return 0;
3020         }
3021
3022         if (i+2<entries)
3023             mov_update_dts_shift(sc, duration);
3024     }
3025
3026     sc->ctts_count = ctts_count;
3027
3028     if (pb->eof_reached) {
3029         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3030         return AVERROR_EOF;
3031     }
3032
3033     av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3034
3035     return 0;
3036 }
3037
3038 static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
3039 {
3040     AVStream *st;
3041     MOVStreamContext *sc;
3042     unsigned int i, entries;
3043     uint8_t version;
3044     uint32_t grouping_type;
3045
3046     if (c->fc->nb_streams < 1)
3047         return 0;
3048     st = c->fc->streams[c->fc->nb_streams-1];
3049     sc = st->priv_data;
3050
3051     version = avio_r8(pb); /* version */
3052     avio_rb24(pb); /* flags */
3053     grouping_type = avio_rl32(pb);
3054     if (grouping_type != MKTAG( 'r','a','p',' '))
3055         return 0; /* only support 'rap ' grouping */
3056     if (version == 1)
3057         avio_rb32(pb); /* grouping_type_parameter */
3058
3059     entries = avio_rb32(pb);
3060     if (!entries)
3061         return 0;
3062     if (sc->rap_group)
3063         av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3064     av_free(sc->rap_group);
3065     sc->rap_group_count = 0;
3066     sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3067     if (!sc->rap_group)
3068         return AVERROR(ENOMEM);
3069
3070     for (i = 0; i < entries && !pb->eof_reached; i++) {
3071         sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3072         sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3073     }
3074
3075     sc->rap_group_count = i;
3076
3077     if (pb->eof_reached) {
3078         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3079         return AVERROR_EOF;
3080     }
3081
3082     return 0;
3083 }
3084
3085 /**
3086  * Get ith edit list entry (media time, duration).
3087  */
3088 static int get_edit_list_entry(MOVContext *mov,
3089                                const MOVStreamContext *msc,
3090                                unsigned int edit_list_index,
3091                                int64_t *edit_list_media_time,
3092                                int64_t *edit_list_duration,
3093                                int64_t global_timescale)
3094 {
3095     if (edit_list_index == msc->elst_count) {
3096         return 0;
3097     }
3098     *edit_list_media_time = msc->elst_data[edit_list_index].time;
3099     *edit_list_duration = msc->elst_data[edit_list_index].duration;
3100
3101     /* duration is in global timescale units;convert to msc timescale */
3102     if (global_timescale == 0) {
3103       avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3104       return 0;
3105     }
3106     *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3107                                      global_timescale);
3108     return 1;
3109 }
3110
3111 /**
3112  * Find the closest previous frame to the timestamp_pts, in e_old index
3113  * entries. Searching for just any frame / just key frames can be controlled by
3114  * last argument 'flag'.
3115  * Note that if ctts_data is not NULL, we will always search for a key frame
3116  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3117  * return the first frame of the video.
3118  *
3119  * Here the timestamp_pts is considered to be a presentation timestamp and
3120  * the timestamp of index entries are considered to be decoding timestamps.
3121  *
3122  * Returns 0 if successful in finding a frame, else returns -1.
3123  * Places the found index corresponding output arg.
3124  *
3125  * If ctts_old is not NULL, then refines the searched entry by searching
3126  * backwards from the found timestamp, to find the frame with correct PTS.
3127  *
3128  * Places the found ctts_index and ctts_sample in corresponding output args.
3129  */
3130 static int find_prev_closest_index(AVStream *st,
3131                                    AVIndexEntry *e_old,
3132                                    int nb_old,
3133                                    MOVStts* ctts_data,
3134                                    int64_t ctts_count,
3135                                    int64_t timestamp_pts,
3136                                    int flag,
3137                                    int64_t* index,
3138                                    int64_t* ctts_index,
3139                                    int64_t* ctts_sample)
3140 {
3141     MOVStreamContext *msc = st->priv_data;
3142     AVIndexEntry *e_keep = st->index_entries;
3143     int nb_keep = st->nb_index_entries;
3144     int64_t i = 0;
3145     int64_t index_ctts_count;
3146
3147     av_assert0(index);
3148
3149     // If dts_shift > 0, then all the index timestamps will have to be offset by
3150     // at least dts_shift amount to obtain PTS.
3151     // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3152     if (msc->dts_shift > 0) {
3153         timestamp_pts -= msc->dts_shift;
3154     }
3155
3156     st->index_entries = e_old;
3157     st->nb_index_entries = nb_old;
3158     *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3159
3160     // Keep going backwards in the index entries until the timestamp is the same.
3161     if (*index >= 0) {
3162         for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3163              i--) {
3164             if ((flag & AVSEEK_FLAG_ANY) ||
3165                 (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3166                 *index = i - 1;
3167             }
3168         }
3169     }
3170
3171     // If we have CTTS then refine the search, by searching backwards over PTS
3172     // computed by adding corresponding CTTS durations to index timestamps.
3173     if (ctts_data && *index >= 0) {
3174         av_assert0(ctts_index);
3175         av_assert0(ctts_sample);
3176         // Find out the ctts_index for the found frame.
3177         *ctts_index = 0;
3178         *ctts_sample = 0;
3179         for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3180             if (*ctts_index < ctts_count) {
3181                 (*ctts_sample)++;
3182                 if (ctts_data[*ctts_index].count == *ctts_sample) {
3183                     (*ctts_index)++;
3184                     *ctts_sample = 0;
3185                 }
3186             }
3187         }
3188
3189         while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3190             // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3191             // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3192             // compensated by dts_shift above.
3193             if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3194                 (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3195                 break;
3196             }
3197
3198             (*index)--;
3199             if (*ctts_sample == 0) {
3200                 (*ctts_index)--;
3201                 if (*ctts_index >= 0)
3202                   *ctts_sample = ctts_data[*ctts_index].count - 1;
3203             } else {
3204                 (*ctts_sample)--;
3205             }
3206         }
3207     }
3208
3209     /* restore AVStream state*/
3210     st->index_entries = e_keep;
3211     st->nb_index_entries = nb_keep;
3212     return *index >= 0 ? 0 : -1;
3213 }
3214
3215 /**
3216  * Add index entry with the given values, to the end of st->index_entries.
3217  * Returns the new size st->index_entries if successful, else returns -1.
3218  *
3219  * This function is similar to ff_add_index_entry in libavformat/utils.c
3220  * except that here we are always unconditionally adding an index entry to
3221  * the end, instead of searching the entries list and skipping the add if
3222  * there is an existing entry with the same timestamp.
3223  * This is needed because the mov_fix_index calls this func with the same
3224  * unincremented timestamp for successive discarded frames.
3225  */
3226 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3227                                int size, int distance, int flags)
3228 {
3229     AVIndexEntry *entries, *ie;
3230     int64_t index = -1;
3231     const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3232
3233     // Double the allocation each time, to lower memory fragmentation.
3234     // Another difference from ff_add_index_entry function.
3235     const size_t requested_size =
3236         min_size_needed > st->index_entries_allocated_size ?
3237         FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3238         min_size_needed;
3239
3240     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
3241         return -1;
3242
3243     entries = av_fast_realloc(st->index_entries,
3244                               &st->index_entries_allocated_size,
3245                               requested_size);
3246     if(!entries)
3247         return -1;
3248
3249     st->index_entries= entries;
3250
3251     index= st->nb_index_entries++;
3252     ie= &entries[index];
3253
3254     ie->pos = pos;
3255     ie->timestamp = timestamp;
3256     ie->min_distance= distance;
3257     ie->size= size;
3258     ie->flags = flags;
3259     return index;
3260 }
3261
3262 /**
3263  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3264  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3265  */
3266 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3267                                        int64_t* frame_duration_buffer,
3268                                        int frame_duration_buffer_size) {
3269     int i = 0;
3270     av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3271     for (i = 0; i < frame_duration_buffer_size; i++) {
3272         end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3273         st->index_entries[end_index - 1 - i].timestamp = end_ts;
3274     }
3275 }
3276
3277 /**
3278  * Append a new ctts entry to ctts_data.
3279  * Returns the new ctts_count if successful, else returns -1.
3280  */
3281 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3282                               int count, int duration)
3283 {
3284     MOVStts *ctts_buf_new;
3285     const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3286     const size_t requested_size =
3287         min_size_needed > *allocated_size ?
3288         FFMAX(min_size_needed, 2 * (*allocated_size)) :
3289         min_size_needed;
3290
3291     if((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3292         return -1;
3293
3294     ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3295
3296     if(!ctts_buf_new)
3297         return -1;
3298
3299     *ctts_data = ctts_buf_new;
3300
3301     ctts_buf_new[*ctts_count].count = count;
3302     ctts_buf_new[*ctts_count].duration = duration;
3303
3304     *ctts_count = (*ctts_count) + 1;
3305     return *ctts_count;
3306 }
3307
3308 #define MAX_REORDER_DELAY 16
3309 static void mov_estimate_video_delay(MOVContext *c, AVStream* st) {
3310     MOVStreamContext *msc = st->priv_data;
3311     int ind;
3312     int ctts_ind = 0;
3313     int ctts_sample = 0;
3314     int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3315     int buf_start = 0;
3316     int j, r, num_swaps;
3317
3318     for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3319         pts_buf[j] = INT64_MIN;
3320
3321     if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3322         st->codecpar->codec_id == AV_CODEC_ID_H264) {
3323         st->codecpar->video_delay = 0;
3324         for(ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3325             // Point j to the last elem of the buffer and insert the current pts there.
3326             j = buf_start;
3327             buf_start = (buf_start + 1);
3328             if (buf_start == MAX_REORDER_DELAY + 1)
3329                 buf_start = 0;
3330
3331             pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3332
3333             // The timestamps that are already in the sorted buffer, and are greater than the
3334             // current pts, are exactly the timestamps that need to be buffered to output PTS
3335             // in correct sorted order.
3336             // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3337             // can be computed as the maximum no. of swaps any particular timestamp needs to
3338             // go through, to keep this buffer in sorted order.
3339             num_swaps = 0;
3340             while (j != buf_start) {
3341                 r = j - 1;
3342                 if (r < 0) r = MAX_REORDER_DELAY;
3343                 if (pts_buf[j] < pts_buf[r]) {
3344                     FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3345                     ++num_swaps;
3346                 } else {
3347                     break;
3348                 }
3349                 j = r;
3350             }
3351             st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3352
3353             ctts_sample++;
3354             if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3355                 ctts_ind++;
3356                 ctts_sample = 0;
3357             }
3358         }
3359         av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3360                st->codecpar->video_delay, st->index);
3361     }
3362 }
3363
3364 static void mov_current_sample_inc(MOVStreamContext *sc)
3365 {
3366     sc->current_sample++;
3367     sc->current_index++;
3368     if (sc->index_ranges &&
3369         sc->current_index >= sc->current_index_range->end &&
3370         sc->current_index_range->end) {
3371         sc->current_index_range++;
3372         sc->current_index = sc->current_index_range->start;
3373     }
3374 }
3375
3376 static void mov_current_sample_dec(MOVStreamContext *sc)
3377 {
3378     sc->current_sample--;
3379     sc->current_index--;
3380     if (sc->index_ranges &&
3381         sc->current_index < sc->current_index_range->start &&
3382         sc->current_index_range > sc->index_ranges) {
3383         sc->current_index_range--;
3384         sc->current_index = sc->current_index_range->end - 1;
3385     }
3386 }
3387
3388 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3389 {
3390     int64_t range_size;
3391
3392     sc->current_sample = current_sample;
3393     sc->current_index = current_sample;
3394     if (!sc->index_ranges) {
3395         return;
3396     }
3397
3398     for (sc->current_index_range = sc->index_ranges;
3399         sc->current_index_range->end;
3400         sc->current_index_range++) {
3401         range_size = sc->current_index_range->end - sc->current_index_range->start;
3402         if (range_size > current_sample) {
3403             sc->current_index = sc->current_index_range->start + current_sample;
3404             break;
3405         }
3406         current_sample -= range_size;
3407     }
3408 }
3409
3410 /**
3411  * Fix st->index_entries, so that it contains only the entries (and the entries
3412  * which are needed to decode them) that fall in the edit list time ranges.
3413  * Also fixes the timestamps of the index entries to match the timeline
3414  * specified the edit lists.
3415  */
3416 static void mov_fix_index(MOVContext *mov, AVStream *st)
3417 {
3418     MOVStreamContext *msc = st->priv_data;
3419     AVIndexEntry *e_old = st->index_entries;
3420     int nb_old = st->nb_index_entries;
3421     const AVIndexEntry *e_old_end = e_old + nb_old;
3422     const AVIndexEntry *current = NULL;
3423     MOVStts *ctts_data_old = msc->ctts_data;
3424     int64_t ctts_index_old = 0;
3425     int64_t ctts_sample_old = 0;
3426     int64_t ctts_count_old = msc->ctts_count;
3427     int64_t edit_list_media_time = 0;
3428     int64_t edit_list_duration = 0;
3429     int64_t frame_duration = 0;
3430     int64_t edit_list_dts_counter = 0;
3431     int64_t edit_list_dts_entry_end = 0;
3432     int64_t edit_list_start_ctts_sample = 0;
3433     int64_t curr_cts;
3434     int64_t curr_ctts = 0;
3435     int64_t empty_edits_sum_duration = 0;
3436     int64_t edit_list_index = 0;
3437     int64_t index;
3438     int flags;
3439     int64_t start_dts = 0;
3440     int64_t edit_list_start_encountered = 0;
3441     int64_t search_timestamp = 0;
3442     int64_t* frame_duration_buffer = NULL;
3443     int num_discarded_begin = 0;
3444     int first_non_zero_audio_edit = -1;
3445     int packet_skip_samples = 0;
3446     MOVIndexRange *current_index_range;
3447     int i;
3448     int found_keyframe_after_edit = 0;
3449     int found_non_empty_edit = 0;
3450
3451     if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3452         return;
3453     }
3454
3455     // allocate the index ranges array
3456     msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3457     if (!msc->index_ranges) {
3458         av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3459         return;
3460     }
3461     msc->current_index_range = msc->index_ranges;
3462     current_index_range = msc->index_ranges - 1;
3463
3464     // Clean AVStream from traces of old index
3465     st->index_entries = NULL;
3466     st->index_entries_allocated_size = 0;
3467     st->nb_index_entries = 0;
3468
3469     // Clean ctts fields of MOVStreamContext
3470     msc->ctts_data = NULL;
3471     msc->ctts_count = 0;
3472     msc->ctts_index = 0;
3473     msc->ctts_sample = 0;
3474     msc->ctts_allocated_size = 0;
3475
3476     // Reinitialize min_corrected_pts so that it can be computed again.
3477     msc->min_corrected_pts = -1;
3478
3479     // If the dts_shift is positive (in case of negative ctts values in mov),
3480     // then negate the DTS by dts_shift
3481     if (msc->dts_shift > 0) {
3482         edit_list_dts_entry_end -= msc->dts_shift;
3483         av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3484     }
3485
3486     start_dts = edit_list_dts_entry_end;
3487
3488     while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3489                                &edit_list_duration, mov->time_scale)) {
3490         av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3491                st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3492         edit_list_index++;
3493         edit_list_dts_counter = edit_list_dts_entry_end;
3494         edit_list_dts_entry_end += edit_list_duration;
3495         num_discarded_begin = 0;
3496         if (!found_non_empty_edit && edit_list_media_time == -1) {
3497             empty_edits_sum_duration += edit_list_duration;
3498             continue;
3499         }
3500         found_non_empty_edit = 1;
3501
3502         // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3503         // according to the edit list below.
3504         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3505             if (first_non_zero_audio_edit < 0) {
3506                 first_non_zero_audio_edit = 1;
3507             } else {
3508                 first_non_zero_audio_edit = 0;
3509             }
3510
3511             if (first_non_zero_audio_edit > 0)
3512                 st->skip_samples = msc->start_pad = 0;
3513         }
3514
3515         // While reordering frame index according to edit list we must handle properly
3516         // the scenario when edit list entry starts from none key frame.
3517         // We find closest previous key frame and preserve it and consequent frames in index.
3518         // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3519         search_timestamp = edit_list_media_time;
3520         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3521             // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3522             // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3523             // edit_list_media_time to cover the decoder delay.
3524             search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3525         }
3526
3527         if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3528                                     &index, &ctts_index_old, &ctts_sample_old) < 0) {
3529             av_log(mov->fc, AV_LOG_WARNING,
3530                    "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3531                    st->index, edit_list_index, search_timestamp);
3532             if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3533                                         &index, &ctts_index_old, &ctts_sample_old) < 0) {
3534                 av_log(mov->fc, AV_LOG_WARNING,
3535                        "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3536                        st->index, edit_list_index, search_timestamp);
3537                 index = 0;
3538                 ctts_index_old = 0;
3539                 ctts_sample_old = 0;
3540             }
3541         }
3542         current = e_old + index;
3543         edit_list_start_ctts_sample = ctts_sample_old;
3544
3545         // Iterate over index and arrange it according to edit list
3546         edit_list_start_encountered = 0;
3547         found_keyframe_after_edit = 0;
3548         for (; current < e_old_end; current++, index++) {
3549             // check  if frame outside edit list mark it for discard
3550             frame_duration = (current + 1 <  e_old_end) ?
3551                              ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3552
3553             flags = current->flags;
3554
3555             // frames (pts) before or after edit list
3556             curr_cts = current->timestamp + msc->dts_shift;
3557             curr_ctts = 0;
3558
3559             if (ctts_data_old && ctts_index_old < ctts_count_old) {
3560                 curr_ctts = ctts_data_old[ctts_index_old].duration;
3561                 av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3562                        curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3563                 curr_cts += curr_ctts;
3564                 ctts_sample_old++;
3565                 if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3566                     if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3567                                        &msc->ctts_allocated_size,
3568                                        ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3569                                        ctts_data_old[ctts_index_old].duration) == -1) {
3570                         av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3571                                ctts_index_old,
3572                                ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3573                                ctts_data_old[ctts_index_old].duration);
3574                         break;
3575                     }
3576                     ctts_index_old++;
3577                     ctts_sample_old = 0;
3578                     edit_list_start_ctts_sample = 0;
3579                 }
3580             }
3581
3582             if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3583                 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->codec_id != AV_CODEC_ID_VORBIS &&
3584                     curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3585                     first_non_zero_audio_edit > 0) {
3586                     packet_skip_samples = edit_list_media_time - curr_cts;
3587                     st->skip_samples += packet_skip_samples;
3588
3589                     // Shift the index entry timestamp by packet_skip_samples to be correct.
3590                     edit_list_dts_counter -= packet_skip_samples;
3591                     if (edit_list_start_encountered == 0)  {
3592                         edit_list_start_encountered = 1;
3593                         // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3594                         // discarded packets.
3595                         if (frame_duration_buffer) {
3596                             fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3597                                                        frame_duration_buffer, num_discarded_begin);
3598                             av_freep(&frame_duration_buffer);
3599                         }
3600                     }
3601
3602                     av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3603                 } else {
3604                     flags |= AVINDEX_DISCARD_FRAME;
3605                     av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3606
3607                     if (edit_list_start_encountered == 0) {
3608                         num_discarded_begin++;
3609                         frame_duration_buffer = av_realloc(frame_duration_buffer,
3610                                                            num_discarded_begin * sizeof(int64_t));
3611                         if (!frame_duration_buffer) {
3612                             av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3613                             break;
3614                         }
3615                         frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3616
3617                         // Increment skip_samples for the first non-zero audio edit list
3618                         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3619                             first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3620                             st->skip_samples += frame_duration;
3621                         }
3622                     }
3623                 }
3624             } else {
3625                 if (msc->min_corrected_pts < 0) {
3626                     msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3627                 } else {
3628                     msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3629                 }
3630                 if (edit_list_start_encountered == 0) {
3631                     edit_list_start_encountered = 1;
3632                     // Make timestamps strictly monotonically increasing by rewriting timestamps for
3633                     // discarded packets.
3634                     if (frame_duration_buffer) {
3635                         fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3636                                                    frame_duration_buffer, num_discarded_begin);
3637                         av_freep(&frame_duration_buffer);
3638                     }
3639                 }
3640             }
3641
3642             if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3643                                 current->min_distance, flags) == -1) {
3644                 av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3645                 break;
3646             }
3647
3648         &n