git.sesse.net Git - ffmpeg/blob - 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 "libavutil/dovi_meta.h"
  50 #include "libavcodec/ac3tab.h"
  51 #include "libavcodec/flac.h"
  52 #include "libavcodec/mpegaudiodecheader.h"
  53 #include "libavcodec/mlp_parse.h"
  54 #include "avformat.h"
  55 #include "internal.h"
  56 #include "avio_internal.h"
  57 #include "riff.h"
  58 #include "isom.h"
  59 #include "libavcodec/get_bits.h"
  60 #include "id3v1.h"
  61 #include "mov_chan.h"
  62 #include "replaygain.h"
  63
  64 #if CONFIG_ZLIB
  65 #include <zlib.h>
  66 #endif
  67
  68 #include "qtpalette.h"
  69
  70 /* those functions parse an atom */
  71 /* links atom IDs to parse functions */
  72 typedef struct MOVParseTableEntry {
  73     uint32_t type;
  74     int (*parse)(MOVContext *ctx, AVIOContext *pb, MOVAtom atom);
  75 } MOVParseTableEntry;
  76
  77 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
  78 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
  79 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
  80                               int count, int duration);
  81
  82 static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
  83                                              unsigned len, const char *key)
  84 {
  85     char buf[16];
  86
  87     short current, total = 0;
  88     avio_rb16(pb); // unknown
  89     current = avio_rb16(pb);
  90     if (len >= 6)
  91         total = avio_rb16(pb);
  92     if (!total)
  93         snprintf(buf, sizeof(buf), "%d", current);
  94     else
  95         snprintf(buf, sizeof(buf), "%d/%d", current, total);
  96     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
  97     av_dict_set(&c->fc->metadata, key, buf, 0);
  98
  99     return 0;
 100 }
 101
 102 static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
 103                                             unsigned len, const char *key)
 104 {
 105     /* bypass padding bytes */
 106     avio_r8(pb);
 107     avio_r8(pb);
 108     avio_r8(pb);
 109
 110     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 111     av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
 112
 113     return 0;
 114 }
 115
 116 static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
 117                                         unsigned len, const char *key)
 118 {
 119     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 120     av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
 121
 122     return 0;
 123 }
 124
 125 static int mov_metadata_gnre(MOVContext *c, AVIOContext *pb,
 126                              unsigned len, const char *key)
 127 {
 128     short genre;
 129
 130     avio_r8(pb); // unknown
 131
 132     genre = avio_r8(pb);
 133     if (genre < 1 || genre > ID3v1_GENRE_MAX)
 134         return 0;
 135     c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 136     av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
 137
 138     return 0;
 139 }
 140
 141 static const uint32_t mac_to_unicode[128] = {
 142     0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
 143     0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
 144     0x00EA,0x00EB,0x00ED,0x00EC,0x00EE,0x00EF,0x00F1,0x00F3,
 145     0x00F2,0x00F4,0x00F6,0x00F5,0x00FA,0x00F9,0x00FB,0x00FC,
 146     0x2020,0x00B0,0x00A2,0x00A3,0x00A7,0x2022,0x00B6,0x00DF,
 147     0x00AE,0x00A9,0x2122,0x00B4,0x00A8,0x2260,0x00C6,0x00D8,
 148     0x221E,0x00B1,0x2264,0x2265,0x00A5,0x00B5,0x2202,0x2211,
 149     0x220F,0x03C0,0x222B,0x00AA,0x00BA,0x03A9,0x00E6,0x00F8,
 150     0x00BF,0x00A1,0x00AC,0x221A,0x0192,0x2248,0x2206,0x00AB,
 151     0x00BB,0x2026,0x00A0,0x00C0,0x00C3,0x00D5,0x0152,0x0153,
 152     0x2013,0x2014,0x201C,0x201D,0x2018,0x2019,0x00F7,0x25CA,
 153     0x00FF,0x0178,0x2044,0x20AC,0x2039,0x203A,0xFB01,0xFB02,
 154     0x2021,0x00B7,0x201A,0x201E,0x2030,0x00C2,0x00CA,0x00C1,
 155     0x00CB,0x00C8,0x00CD,0x00CE,0x00CF,0x00CC,0x00D3,0x00D4,
 156     0xF8FF,0x00D2,0x00DA,0x00DB,0x00D9,0x0131,0x02C6,0x02DC,
 157     0x00AF,0x02D8,0x02D9,0x02DA,0x00B8,0x02DD,0x02DB,0x02C7,
 158 };
 159
 160 static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
 161                                char *dst, int dstlen)
 162 {
 163     char *p = dst;
 164     char *end = dst+dstlen-1;
 165     int i;
 166
 167     for (i = 0; i < len; i++) {
 168         uint8_t t, c = avio_r8(pb);
 169
 170         if (p >= end)
 171             continue;
 172
 173         if (c < 0x80)
 174             *p++ = c;
 175         else if (p < end)
 176             PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
 177     }
 178     *p = 0;
 179     return p - dst;
 180 }
 181
 182 static int mov_read_covr(MOVContext *c, AVIOContext *pb, int type, int len)
 183 {
 184     AVStream *st;
 185     MOVStreamContext *sc;
 186     enum AVCodecID id;
 187     int ret;
 188
 189     switch (type) {
 190     case 0xd:  id = AV_CODEC_ID_MJPEG; break;
 191     case 0xe:  id = AV_CODEC_ID_PNG;   break;
 192     case 0x1b: id = AV_CODEC_ID_BMP;   break;
 193     default:
 194         av_log(c->fc, AV_LOG_WARNING, "Unknown cover type: 0x%x.\n", type);
 195         avio_skip(pb, len);
 196         return 0;
 197     }
 198
 199     st = avformat_new_stream(c->fc, NULL);
 200     if (!st)
 201         return AVERROR(ENOMEM);
 202     sc = av_mallocz(sizeof(*sc));
 203     if (!sc)
 204         return AVERROR(ENOMEM);
 205     st->priv_data = sc;
 206
 207     ret = av_get_packet(pb, &st->attached_pic, len);
 208     if (ret < 0)
 209         return ret;
 210
 211     if (st->attached_pic.size >= 8 && id != AV_CODEC_ID_BMP) {
 212         if (AV_RB64(st->attached_pic.data) == 0x89504e470d0a1a0a) {
 213             id = AV_CODEC_ID_PNG;
 214         } else {
 215             id = AV_CODEC_ID_MJPEG;
 216         }
 217     }
 218
 219     st->disposition              |= AV_DISPOSITION_ATTACHED_PIC;
 220
 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 #define DDTS_SIZE 20
 861     uint8_t buf[DDTS_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
 862     AVStream *st = NULL;
 863     uint32_t frame_duration_code = 0;
 864     uint32_t channel_layout_code = 0;
 865     GetBitContext gb;
 866     int ret;
 867
 868     if ((ret = ffio_read_size(pb, buf, DDTS_SIZE)) < 0)
 869         return ret;
 870
 871     init_get_bits(&gb, buf, 8 * DDTS_SIZE);
 872
 873     if (c->fc->nb_streams < 1) {
 874         return 0;
 875     }
 876     st = c->fc->streams[c->fc->nb_streams-1];
 877
 878     st->codecpar->sample_rate = get_bits_long(&gb, 32);
 879     if (st->codecpar->sample_rate <= 0) {
 880         av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
 881         return AVERROR_INVALIDDATA;
 882     }
 883     skip_bits_long(&gb, 32); /* max bitrate */
 884     st->codecpar->bit_rate = get_bits_long(&gb, 32);
 885     st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
 886     frame_duration_code = get_bits(&gb, 2);
 887     skip_bits(&gb, 30); /* various fields */
 888     channel_layout_code = get_bits(&gb, 16);
 889
 890     st->codecpar->frame_size =
 891             (frame_duration_code == 0) ? 512 :
 892             (frame_duration_code == 1) ? 1024 :
 893             (frame_duration_code == 2) ? 2048 :
 894             (frame_duration_code == 3) ? 4096 : 0;
 895
 896     if (channel_layout_code > 0xff) {
 897         av_log(c->fc, AV_LOG_WARNING, "Unsupported DTS audio channel layout");
 898     }
 899     st->codecpar->channel_layout =
 900             ((channel_layout_code & 0x1) ? AV_CH_FRONT_CENTER : 0) |
 901             ((channel_layout_code & 0x2) ? AV_CH_FRONT_LEFT : 0) |
 902             ((channel_layout_code & 0x2) ? AV_CH_FRONT_RIGHT : 0) |
 903             ((channel_layout_code & 0x4) ? AV_CH_SIDE_LEFT : 0) |
 904             ((channel_layout_code & 0x4) ? AV_CH_SIDE_RIGHT : 0) |
 905             ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
 906
 907     st->codecpar->channels = av_get_channel_layout_nb_channels(st->codecpar->channel_layout);
 908
 909     return 0;
 910 }
 911
 912 static int mov_read_chan(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 913 {
 914     AVStream *st;
 915
 916     if (c->fc->nb_streams < 1)
 917         return 0;
 918     st = c->fc->streams[c->fc->nb_streams-1];
 919
 920     if (atom.size < 16)
 921         return 0;
 922
 923     /* skip version and flags */
 924     avio_skip(pb, 4);
 925
 926     ff_mov_read_chan(c->fc, pb, st, atom.size - 4);
 927
 928     return 0;
 929 }
 930
 931 static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 932 {
 933     AVStream *st;
 934     int ret;
 935
 936     if (c->fc->nb_streams < 1)
 937         return 0;
 938     st = c->fc->streams[c->fc->nb_streams-1];
 939
 940     if ((ret = ff_get_wav_header(c->fc, pb, st->codecpar, atom.size, 0)) < 0)
 941         av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
 942
 943     return ret;
 944 }
 945
 946 static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 947 {
 948     const int num = avio_rb32(pb);
 949     const int den = avio_rb32(pb);
 950     AVStream *st;
 951
 952     if (c->fc->nb_streams < 1)
 953         return 0;
 954     st = c->fc->streams[c->fc->nb_streams-1];
 955
 956     if ((st->sample_aspect_ratio.den != 1 || st->sample_aspect_ratio.num) && // default
 957         (den != st->sample_aspect_ratio.den || num != st->sample_aspect_ratio.num)) {
 958         av_log(c->fc, AV_LOG_WARNING,
 959                "sample aspect ratio already set to %d:%d, ignoring 'pasp' atom (%d:%d)\n",
 960                st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
 961                num, den);
 962     } else if (den != 0) {
 963         av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den,
 964                   num, den, 32767);
 965     }
 966     return 0;
 967 }
 968
 969 /* this atom contains actual media data */
 970 static int mov_read_mdat(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 971 {
 972     if (atom.size == 0) /* wrong one (MP4) */
 973         return 0;
 974     c->found_mdat=1;
 975     return 0; /* now go for moov */
 976 }
 977
 978 #define DRM_BLOB_SIZE 56
 979
 980 static int mov_read_adrm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 981 {
 982     uint8_t intermediate_key[20];
 983     uint8_t intermediate_iv[20];
 984     uint8_t input[64];
 985     uint8_t output[64];
 986     uint8_t file_checksum[20];
 987     uint8_t calculated_checksum[20];
 988     struct AVSHA *sha;
 989     int i;
 990     int ret = 0;
 991     uint8_t *activation_bytes = c->activation_bytes;
 992     uint8_t *fixed_key = c->audible_fixed_key;
 993
 994     c->aax_mode = 1;
 995
 996     sha = av_sha_alloc();
 997     if (!sha)
 998         return AVERROR(ENOMEM);
 999     av_free(c->aes_decrypt);
1000     c->aes_decrypt = av_aes_alloc();
1001     if (!c->aes_decrypt) {
1002         ret = AVERROR(ENOMEM);
1003         goto fail;
1004     }
1005
1006     /* drm blob processing */
1007     avio_read(pb, output, 8); // go to offset 8, absolute position 0x251
1008     avio_read(pb, input, DRM_BLOB_SIZE);
1009     avio_read(pb, output, 4); // go to offset 4, absolute position 0x28d
1010     avio_read(pb, file_checksum, 20);
1011
1012     av_log(c->fc, AV_LOG_INFO, "[aax] file checksum == "); // required by external tools
1013     for (i = 0; i < 20; i++)
1014         av_log(c->fc, AV_LOG_INFO, "%02x", file_checksum[i]);
1015     av_log(c->fc, AV_LOG_INFO, "\n");
1016
1017     /* verify activation data */
1018     if (!activation_bytes) {
1019         av_log(c->fc, AV_LOG_WARNING, "[aax] activation_bytes option is missing!\n");
1020         ret = 0;  /* allow ffprobe to continue working on .aax files */
1021         goto fail;
1022     }
1023     if (c->activation_bytes_size != 4) {
1024         av_log(c->fc, AV_LOG_FATAL, "[aax] activation_bytes value needs to be 4 bytes!\n");
1025         ret = AVERROR(EINVAL);
1026         goto fail;
1027     }
1028
1029     /* verify fixed key */
1030     if (c->audible_fixed_key_size != 16) {
1031         av_log(c->fc, AV_LOG_FATAL, "[aax] audible_fixed_key value needs to be 16 bytes!\n");
1032         ret = AVERROR(EINVAL);
1033         goto fail;
1034     }
1035
1036     /* AAX (and AAX+) key derivation */
1037     av_sha_init(sha, 160);
1038     av_sha_update(sha, fixed_key, 16);
1039     av_sha_update(sha, activation_bytes, 4);
1040     av_sha_final(sha, intermediate_key);
1041     av_sha_init(sha, 160);
1042     av_sha_update(sha, fixed_key, 16);
1043     av_sha_update(sha, intermediate_key, 20);
1044     av_sha_update(sha, activation_bytes, 4);
1045     av_sha_final(sha, intermediate_iv);
1046     av_sha_init(sha, 160);
1047     av_sha_update(sha, intermediate_key, 16);
1048     av_sha_update(sha, intermediate_iv, 16);
1049     av_sha_final(sha, calculated_checksum);
1050     if (memcmp(calculated_checksum, file_checksum, 20)) { // critical error
1051         av_log(c->fc, AV_LOG_ERROR, "[aax] mismatch in checksums!\n");
1052         ret = AVERROR_INVALIDDATA;
1053         goto fail;
1054     }
1055     av_aes_init(c->aes_decrypt, intermediate_key, 128, 1);
1056     av_aes_crypt(c->aes_decrypt, output, input, DRM_BLOB_SIZE >> 4, intermediate_iv, 1);
1057     for (i = 0; i < 4; i++) {
1058         // file data (in output) is stored in big-endian mode
1059         if (activation_bytes[i] != output[3 - i]) { // critical error
1060             av_log(c->fc, AV_LOG_ERROR, "[aax] error in drm blob decryption!\n");
1061             ret = AVERROR_INVALIDDATA;
1062             goto fail;
1063         }
1064     }
1065     memcpy(c->file_key, output + 8, 16);
1066     memcpy(input, output + 26, 16);
1067     av_sha_init(sha, 160);
1068     av_sha_update(sha, input, 16);
1069     av_sha_update(sha, c->file_key, 16);
1070     av_sha_update(sha, fixed_key, 16);
1071     av_sha_final(sha, c->file_iv);
1072
1073 fail:
1074     av_free(sha);
1075
1076     return ret;
1077 }
1078
1079 // Audible AAX (and AAX+) bytestream decryption
1080 static int aax_filter(uint8_t *input, int size, MOVContext *c)
1081 {
1082     int blocks = 0;
1083     unsigned char iv[16];
1084
1085     memcpy(iv, c->file_iv, 16); // iv is overwritten
1086     blocks = size >> 4; // trailing bytes are not encrypted!
1087     av_aes_init(c->aes_decrypt, c->file_key, 128, 1);
1088     av_aes_crypt(c->aes_decrypt, input, input, blocks, iv, 1);
1089
1090     return 0;
1091 }
1092
1093 /* read major brand, minor version and compatible brands and store them as metadata */
1094 static int mov_read_ftyp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1095 {
1096     uint32_t minor_ver;
1097     int comp_brand_size;
1098     char* comp_brands_str;
1099     uint8_t type[5] = {0};
1100     int ret = ffio_read_size(pb, type, 4);
1101     if (ret < 0)
1102         return ret;
1103
1104     if (strcmp(type, "qt  "))
1105         c->isom = 1;
1106     av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
1107     av_dict_set(&c->fc->metadata, "major_brand", type, 0);
1108     minor_ver = avio_rb32(pb); /* minor version */
1109     av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
1110
1111     comp_brand_size = atom.size - 8;
1112     if (comp_brand_size < 0)
1113         return AVERROR_INVALIDDATA;
1114     comp_brands_str = av_malloc(comp_brand_size + 1); /* Add null terminator */
1115     if (!comp_brands_str)
1116         return AVERROR(ENOMEM);
1117
1118     ret = ffio_read_size(pb, comp_brands_str, comp_brand_size);
1119     if (ret < 0) {
1120         av_freep(&comp_brands_str);
1121         return ret;
1122     }
1123     comp_brands_str[comp_brand_size] = 0;
1124     av_dict_set(&c->fc->metadata, "compatible_brands",
1125                 comp_brands_str, AV_DICT_DONT_STRDUP_VAL);
1126
1127     return 0;
1128 }
1129
1130 /* this atom should contain all header atoms */
1131 static int mov_read_moov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1132 {
1133     int ret;
1134
1135     if (c->found_moov) {
1136         av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
1137         avio_skip(pb, atom.size);
1138         return 0;
1139     }
1140
1141     if ((ret = mov_read_default(c, pb, atom)) < 0)
1142         return ret;
1143     /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
1144     /* so we don't parse the whole file if over a network */
1145     c->found_moov=1;
1146     return 0; /* now go for mdat */
1147 }
1148
1149 static MOVFragmentStreamInfo * get_frag_stream_info(
1150     MOVFragmentIndex *frag_index,
1151     int index,
1152     int id)
1153 {
1154     int i;
1155     MOVFragmentIndexItem * item;
1156
1157     if (index < 0 || index >= frag_index->nb_items)
1158         return NULL;
1159     item = &frag_index->item[index];
1160     for (i = 0; i < item->nb_stream_info; i++)
1161         if (item->stream_info[i].id == id)
1162             return &item->stream_info[i];
1163
1164     // This shouldn't happen
1165     return NULL;
1166 }
1167
1168 static void set_frag_stream(MOVFragmentIndex *frag_index, int id)
1169 {
1170     int i;
1171     MOVFragmentIndexItem * item;
1172
1173     if (frag_index->current < 0 ||
1174         frag_index->current >= frag_index->nb_items)
1175         return;
1176
1177     item = &frag_index->item[frag_index->current];
1178     for (i = 0; i < item->nb_stream_info; i++)
1179         if (item->stream_info[i].id == id) {
1180             item->current = i;
1181             return;
1182         }
1183
1184     // id not found.  This shouldn't happen.
1185     item->current = -1;
1186 }
1187
1188 static MOVFragmentStreamInfo * get_current_frag_stream_info(
1189     MOVFragmentIndex *frag_index)
1190 {
1191     MOVFragmentIndexItem *item;
1192     if (frag_index->current < 0 ||
1193         frag_index->current >= frag_index->nb_items)
1194         return NULL;
1195
1196     item = &frag_index->item[frag_index->current];
1197     if (item->current >= 0 && item->current < item->nb_stream_info)
1198         return &item->stream_info[item->current];
1199
1200     // This shouldn't happen
1201     return NULL;
1202 }
1203
1204 static int search_frag_moof_offset(MOVFragmentIndex *frag_index, int64_t offset)
1205 {
1206     int a, b, m;
1207     int64_t moof_offset;
1208
1209     // Optimize for appending new entries
1210     if (!frag_index->nb_items ||
1211         frag_index->item[frag_index->nb_items - 1].moof_offset < offset)
1212         return frag_index->nb_items;
1213
1214     a = -1;
1215     b = frag_index->nb_items;
1216
1217     while (b - a > 1) {
1218         m = (a + b) >> 1;
1219         moof_offset = frag_index->item[m].moof_offset;
1220         if (moof_offset >= offset)
1221             b = m;
1222         if (moof_offset <= offset)
1223             a = m;
1224     }
1225     return b;
1226 }
1227
1228 static int64_t get_stream_info_time(MOVFragmentStreamInfo * frag_stream_info)
1229 {
1230     av_assert0(frag_stream_info);
1231     if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE)
1232         return frag_stream_info->sidx_pts;
1233     if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE)
1234         return frag_stream_info->first_tfra_pts;
1235     return frag_stream_info->tfdt_dts;
1236 }
1237
1238 static int64_t get_frag_time(MOVFragmentIndex *frag_index,
1239                              int index, int track_id)
1240 {
1241     MOVFragmentStreamInfo * frag_stream_info;
1242     int64_t timestamp;
1243     int i;
1244
1245     if (track_id >= 0) {
1246         frag_stream_info = get_frag_stream_info(frag_index, index, track_id);
1247         return frag_stream_info->sidx_pts;
1248     }
1249
1250     for (i = 0; i < frag_index->item[index].nb_stream_info; i++) {
1251         frag_stream_info = &frag_index->item[index].stream_info[i];
1252         timestamp = get_stream_info_time(frag_stream_info);
1253         if (timestamp != AV_NOPTS_VALUE)
1254             return timestamp;
1255     }
1256     return AV_NOPTS_VALUE;
1257 }
1258
1259 static int search_frag_timestamp(MOVFragmentIndex *frag_index,
1260                                  AVStream *st, int64_t timestamp)
1261 {
1262     int a, b, m, m0;
1263     int64_t frag_time;
1264     int id = -1;
1265
1266     if (st) {
1267         // If the stream is referenced by any sidx, limit the search
1268         // to fragments that referenced this stream in the sidx
1269         MOVStreamContext *sc = st->priv_data;
1270         if (sc->has_sidx)
1271             id = st->id;
1272     }
1273
1274     a = -1;
1275     b = frag_index->nb_items;
1276
1277     while (b - a > 1) {
1278         m0 = m = (a + b) >> 1;
1279
1280         while (m < b &&
1281                (frag_time = get_frag_time(frag_index, m, id)) == AV_NOPTS_VALUE)
1282             m++;
1283
1284         if (m < b && frag_time <= timestamp)
1285             a = m;
1286         else
1287             b = m0;
1288     }
1289
1290     return a;
1291 }
1292
1293 static int update_frag_index(MOVContext *c, int64_t offset)
1294 {
1295     int index, i;
1296     MOVFragmentIndexItem * item;
1297     MOVFragmentStreamInfo * frag_stream_info;
1298
1299     // If moof_offset already exists in frag_index, return index to it
1300     index = search_frag_moof_offset(&c->frag_index, offset);
1301     if (index < c->frag_index.nb_items &&
1302         c->frag_index.item[index].moof_offset == offset)
1303         return index;
1304
1305     // offset is not yet in frag index.
1306     // Insert new item at index (sorted by moof offset)
1307     item = av_fast_realloc(c->frag_index.item,
1308                            &c->frag_index.allocated_size,
1309                            (c->frag_index.nb_items + 1) *
1310                            sizeof(*c->frag_index.item));
1311     if(!item)
1312         return -1;
1313     c->frag_index.item = item;
1314
1315     frag_stream_info = av_realloc_array(NULL, c->fc->nb_streams,
1316                                         sizeof(*item->stream_info));
1317     if (!frag_stream_info)
1318         return -1;
1319
1320     for (i = 0; i < c->fc->nb_streams; i++) {
1321         // Avoid building frag index if streams lack track id.
1322         if (c->fc->streams[i]->id < 0) {
1323             av_free(frag_stream_info);
1324             return AVERROR_INVALIDDATA;
1325         }
1326
1327         frag_stream_info[i].id = c->fc->streams[i]->id;
1328         frag_stream_info[i].sidx_pts = AV_NOPTS_VALUE;
1329         frag_stream_info[i].tfdt_dts = AV_NOPTS_VALUE;
1330         frag_stream_info[i].next_trun_dts = AV_NOPTS_VALUE;
1331         frag_stream_info[i].first_tfra_pts = AV_NOPTS_VALUE;
1332         frag_stream_info[i].index_entry = -1;
1333         frag_stream_info[i].encryption_index = NULL;
1334     }
1335
1336     if (index < c->frag_index.nb_items)
1337         memmove(c->frag_index.item + index + 1, c->frag_index.item + index,
1338                 (c->frag_index.nb_items - index) * sizeof(*c->frag_index.item));
1339
1340     item = &c->frag_index.item[index];
1341     item->headers_read = 0;
1342     item->current = 0;
1343     item->nb_stream_info = c->fc->nb_streams;
1344     item->moof_offset = offset;
1345     item->stream_info = frag_stream_info;
1346     c->frag_index.nb_items++;
1347
1348     return index;
1349 }
1350
1351 static void fix_frag_index_entries(MOVFragmentIndex *frag_index, int index,
1352                                    int id, int entries)
1353 {
1354     int i;
1355     MOVFragmentStreamInfo * frag_stream_info;
1356
1357     if (index < 0)
1358         return;
1359     for (i = index; i < frag_index->nb_items; i++) {
1360         frag_stream_info = get_frag_stream_info(frag_index, i, id);
1361         if (frag_stream_info && frag_stream_info->index_entry >= 0)
1362             frag_stream_info->index_entry += entries;
1363     }
1364 }
1365
1366 static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1367 {
1368     // Set by mov_read_tfhd(). mov_read_trun() will reject files missing tfhd.
1369     c->fragment.found_tfhd = 0;
1370
1371     if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
1372         c->has_looked_for_mfra = 1;
1373         if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
1374             int ret;
1375             av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
1376                     "for a mfra\n");
1377             if ((ret = mov_read_mfra(c, pb)) < 0) {
1378                 av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
1379                         "read the mfra (may be a live ismv)\n");
1380             }
1381         } else {
1382             av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
1383                     "seekable, can not look for mfra\n");
1384         }
1385     }
1386     c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8;
1387     av_log(c->fc, AV_LOG_TRACE, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
1388     c->frag_index.current = update_frag_index(c, c->fragment.moof_offset);
1389     return mov_read_default(c, pb, atom);
1390 }
1391
1392 static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time, void *logctx)
1393 {
1394     if (time) {
1395         if(time >= 2082844800)
1396             time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
1397
1398         if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
1399             av_log(logctx, AV_LOG_DEBUG, "creation_time is not representable\n");
1400             return;
1401         }
1402
1403         avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
1404     }
1405 }
1406
1407 static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1408 {
1409     AVStream *st;
1410     MOVStreamContext *sc;
1411     int version;
1412     char language[4] = {0};
1413     unsigned lang;
1414     int64_t creation_time;
1415
1416     if (c->fc->nb_streams < 1)
1417         return 0;
1418     st = c->fc->streams[c->fc->nb_streams-1];
1419     sc = st->priv_data;
1420
1421     if (sc->time_scale) {
1422         av_log(c->fc, AV_LOG_ERROR, "Multiple mdhd?\n");
1423         return AVERROR_INVALIDDATA;
1424     }
1425
1426     version = avio_r8(pb);
1427     if (version > 1) {
1428         avpriv_request_sample(c->fc, "Version %d", version);
1429         return AVERROR_PATCHWELCOME;
1430     }
1431     avio_rb24(pb); /* flags */
1432     if (version == 1) {
1433         creation_time = avio_rb64(pb);
1434         avio_rb64(pb);
1435     } else {
1436         creation_time = avio_rb32(pb);
1437         avio_rb32(pb); /* modification time */
1438     }
1439     mov_metadata_creation_time(&st->metadata, creation_time, c->fc);
1440
1441     sc->time_scale = avio_rb32(pb);
1442     if (sc->time_scale <= 0) {
1443         av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
1444         sc->time_scale = 1;
1445     }
1446     st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1447
1448     lang = avio_rb16(pb); /* language */
1449     if (ff_mov_lang_to_iso639(lang, language))
1450         av_dict_set(&st->metadata, "language", language, 0);
1451     avio_rb16(pb); /* quality */
1452
1453     return 0;
1454 }
1455
1456 static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1457 {
1458     int i;
1459     int64_t creation_time;
1460     int version = avio_r8(pb); /* version */
1461     avio_rb24(pb); /* flags */
1462
1463     if (version == 1) {
1464         creation_time = avio_rb64(pb);
1465         avio_rb64(pb);
1466     } else {
1467         creation_time = avio_rb32(pb);
1468         avio_rb32(pb); /* modification time */
1469     }
1470     mov_metadata_creation_time(&c->fc->metadata, creation_time, c->fc);
1471     c->time_scale = avio_rb32(pb); /* time scale */
1472     if (c->time_scale <= 0) {
1473         av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
1474         c->time_scale = 1;
1475     }
1476     av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
1477
1478     c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
1479     // set the AVCodecContext duration because the duration of individual tracks
1480     // may be inaccurate
1481     if (c->time_scale > 0 && !c->trex_data)
1482         c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
1483     avio_rb32(pb); /* preferred scale */
1484
1485     avio_rb16(pb); /* preferred volume */
1486
1487     avio_skip(pb, 10); /* reserved */
1488
1489     /* movie display matrix, store it in main context and use it later on */
1490     for (i = 0; i < 3; i++) {
1491         c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
1492         c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
1493         c->movie_display_matrix[i][2] = avio_rb32(pb); //  2.30 fixed point
1494     }
1495
1496     avio_rb32(pb); /* preview time */
1497     avio_rb32(pb); /* preview duration */
1498     avio_rb32(pb); /* poster time */
1499     avio_rb32(pb); /* selection time */
1500     avio_rb32(pb); /* selection duration */
1501     avio_rb32(pb); /* current time */
1502     avio_rb32(pb); /* next track ID */
1503
1504     return 0;
1505 }
1506
1507 static int mov_read_enda(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1508 {
1509     AVStream *st;
1510     int little_endian;
1511
1512     if (c->fc->nb_streams < 1)
1513         return 0;
1514     st = c->fc->streams[c->fc->nb_streams-1];
1515
1516     little_endian = avio_rb16(pb) & 0xFF;
1517     av_log(c->fc, AV_LOG_TRACE, "enda %d\n", little_endian);
1518     if (little_endian == 1) {
1519         switch (st->codecpar->codec_id) {
1520         case AV_CODEC_ID_PCM_S24BE:
1521             st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
1522             break;
1523         case AV_CODEC_ID_PCM_S32BE:
1524             st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
1525             break;
1526         case AV_CODEC_ID_PCM_F32BE:
1527             st->codecpar->codec_id = AV_CODEC_ID_PCM_F32LE;
1528             break;
1529         case AV_CODEC_ID_PCM_F64BE:
1530             st->codecpar->codec_id = AV_CODEC_ID_PCM_F64LE;
1531             break;
1532         default:
1533             break;
1534         }
1535     }
1536     return 0;
1537 }
1538
1539 static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1540 {
1541     AVStream *st;
1542     uint8_t *icc_profile;
1543     char color_parameter_type[5] = { 0 };
1544     uint16_t color_primaries, color_trc, color_matrix;
1545     int ret;
1546
1547     if (c->fc->nb_streams < 1)
1548         return 0;
1549     st = c->fc->streams[c->fc->nb_streams - 1];
1550
1551     ret = ffio_read_size(pb, color_parameter_type, 4);
1552     if (ret < 0)
1553         return ret;
1554     if (strncmp(color_parameter_type, "nclx", 4) &&
1555         strncmp(color_parameter_type, "nclc", 4) &&
1556         strncmp(color_parameter_type, "prof", 4)) {
1557         av_log(c->fc, AV_LOG_WARNING, "unsupported color_parameter_type %s\n",
1558                color_parameter_type);
1559         return 0;
1560     }
1561
1562     if (!strncmp(color_parameter_type, "prof", 4)) {
1563         icc_profile = av_stream_new_side_data(st, AV_PKT_DATA_ICC_PROFILE, atom.size - 4);
1564         if (!icc_profile)
1565             return AVERROR(ENOMEM);
1566         ret = ffio_read_size(pb, icc_profile, atom.size - 4);
1567         if (ret < 0)
1568             return ret;
1569     }
1570     else {
1571         color_primaries = avio_rb16(pb);
1572         color_trc = avio_rb16(pb);
1573         color_matrix = avio_rb16(pb);
1574
1575         av_log(c->fc, AV_LOG_TRACE,
1576                "%s: pri %d trc %d matrix %d",
1577                color_parameter_type, color_primaries, color_trc, color_matrix);
1578
1579         if (!strncmp(color_parameter_type, "nclx", 4)) {
1580             uint8_t color_range = avio_r8(pb) >> 7;
1581             av_log(c->fc, AV_LOG_TRACE, " full %"PRIu8"", color_range);
1582             if (color_range)
1583                 st->codecpar->color_range = AVCOL_RANGE_JPEG;
1584             else
1585                 st->codecpar->color_range = AVCOL_RANGE_MPEG;
1586         }
1587
1588         if (!av_color_primaries_name(color_primaries))
1589             color_primaries = AVCOL_PRI_UNSPECIFIED;
1590         if (!av_color_transfer_name(color_trc))
1591             color_trc = AVCOL_TRC_UNSPECIFIED;
1592         if (!av_color_space_name(color_matrix))
1593             color_matrix = AVCOL_SPC_UNSPECIFIED;
1594
1595         st->codecpar->color_primaries = color_primaries;
1596         st->codecpar->color_trc       = color_trc;
1597         st->codecpar->color_space     = color_matrix;
1598         av_log(c->fc, AV_LOG_TRACE, "\n");
1599     }
1600     return 0;
1601 }
1602
1603 static int mov_read_fiel(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1604 {
1605     AVStream *st;
1606     unsigned mov_field_order;
1607     enum AVFieldOrder decoded_field_order = AV_FIELD_UNKNOWN;
1608
1609     if (c->fc->nb_streams < 1) // will happen with jp2 files
1610         return 0;
1611     st = c->fc->streams[c->fc->nb_streams-1];
1612     if (atom.size < 2)
1613         return AVERROR_INVALIDDATA;
1614     mov_field_order = avio_rb16(pb);
1615     if ((mov_field_order & 0xFF00) == 0x0100)
1616         decoded_field_order = AV_FIELD_PROGRESSIVE;
1617     else if ((mov_field_order & 0xFF00) == 0x0200) {
1618         switch (mov_field_order & 0xFF) {
1619         case 0x01: decoded_field_order = AV_FIELD_TT;
1620                    break;
1621         case 0x06: decoded_field_order = AV_FIELD_BB;
1622                    break;
1623         case 0x09: decoded_field_order = AV_FIELD_TB;
1624                    break;
1625         case 0x0E: decoded_field_order = AV_FIELD_BT;
1626                    break;
1627         }
1628     }
1629     if (decoded_field_order == AV_FIELD_UNKNOWN && mov_field_order) {
1630         av_log(c->fc, AV_LOG_ERROR, "Unknown MOV field order 0x%04x\n", mov_field_order);
1631     }
1632     st->codecpar->field_order = decoded_field_order;
1633
1634     return 0;
1635 }
1636
1637 static int mov_realloc_extradata(AVCodecParameters *par, MOVAtom atom)
1638 {
1639     int err = 0;
1640     uint64_t size = (uint64_t)par->extradata_size + atom.size + 8 + AV_INPUT_BUFFER_PADDING_SIZE;
1641     if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
1642         return AVERROR_INVALIDDATA;
1643     if ((err = av_reallocp(&par->extradata, size)) < 0) {
1644         par->extradata_size = 0;
1645         return err;
1646     }
1647     par->extradata_size = size - AV_INPUT_BUFFER_PADDING_SIZE;
1648     return 0;
1649 }
1650
1651 /* Read a whole atom into the extradata return the size of the atom read, possibly truncated if != atom.size */
1652 static int64_t mov_read_atom_into_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
1653                                         AVCodecParameters *par, uint8_t *buf)
1654 {
1655     int64_t result = atom.size;
1656     int err;
1657
1658     AV_WB32(buf    , atom.size + 8);
1659     AV_WL32(buf + 4, atom.type);
1660     err = ffio_read_size(pb, buf + 8, atom.size);
1661     if (err < 0) {
1662         par->extradata_size -= atom.size;
1663         return err;
1664     } else if (err < atom.size) {
1665         av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
1666         par->extradata_size -= atom.size - err;
1667         result = err;
1668     }
1669     memset(buf + 8 + err, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1670     return result;
1671 }
1672
1673 /* FIXME modify QDM2/SVQ3/H.264 decoders to take full atom as extradata */
1674 static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
1675                               enum AVCodecID codec_id)
1676 {
1677     AVStream *st;
1678     uint64_t original_size;
1679     int err;
1680
1681     if (c->fc->nb_streams < 1) // will happen with jp2 files
1682         return 0;
1683     st = c->fc->streams[c->fc->nb_streams-1];
1684
1685     if (st->codecpar->codec_id != codec_id)
1686         return 0; /* unexpected codec_id - don't mess with extradata */
1687
1688     original_size = st->codecpar->extradata_size;
1689     err = mov_realloc_extradata(st->codecpar, atom);
1690     if (err)
1691         return err;
1692
1693     err =  mov_read_atom_into_extradata(c, pb, atom, st->codecpar,  st->codecpar->extradata + original_size);
1694     if (err < 0)
1695         return err;
1696     return 0; // Note: this is the original behavior to ignore truncation.
1697 }
1698
1699 /* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
1700 static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1701 {
1702     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
1703 }
1704
1705 static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1706 {
1707     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
1708 }
1709
1710 static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1711 {
1712     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
1713 }
1714
1715 static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1716 {
1717     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
1718 }
1719
1720 static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1721 {
1722     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
1723     if(ret == 0)
1724         ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
1725     return ret;
1726 }
1727
1728 static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1729 {
1730     int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
1731
1732     if (!ret && c->fc->nb_streams >= 1) {
1733         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1734         if (par->extradata_size >= 40) {
1735             par->height = AV_RB16(&par->extradata[36]);
1736             par->width  = AV_RB16(&par->extradata[38]);
1737         }
1738     }
1739     return ret;
1740 }
1741
1742 static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1743 {
1744     if (c->fc->nb_streams >= 1) {
1745         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1746         if (par->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
1747             par->codec_id == AV_CODEC_ID_H264 &&
1748             atom.size > 11) {
1749             int cid;
1750             avio_skip(pb, 10);
1751             cid = avio_rb16(pb);
1752             /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
1753             if (cid == 0xd4d || cid == 0xd4e)
1754                 par->width = 1440;
1755             return 0;
1756         } else if ((par->codec_tag == MKTAG('A', 'V', 'd', '1') ||
1757                     par->codec_tag == MKTAG('A', 'V', 'j', '2') ||
1758                     par->codec_tag == MKTAG('A', 'V', 'd', 'n')) &&
1759                    atom.size >= 24) {
1760             int num, den;
1761             avio_skip(pb, 12);
1762             num = avio_rb32(pb);
1763             den = avio_rb32(pb);
1764             if (num <= 0 || den <= 0)
1765                 return 0;
1766             switch (avio_rb32(pb)) {
1767             case 2:
1768                 if (den >= INT_MAX / 2)
1769                     return 0;
1770                 den *= 2;
1771             case 1:
1772                 c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.num = num;
1773                 c->fc->streams[c->fc->nb_streams-1]->display_aspect_ratio.den = den;
1774             default:
1775                 return 0;
1776             }
1777         }
1778     }
1779
1780     return mov_read_avid(c, pb, atom);
1781 }
1782
1783 static int mov_read_aclr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1784 {
1785     int ret = 0;
1786     int length = 0;
1787     uint64_t original_size;
1788     if (c->fc->nb_streams >= 1) {
1789         AVCodecParameters *par = c->fc->streams[c->fc->nb_streams-1]->codecpar;
1790         if (par->codec_id == AV_CODEC_ID_H264)
1791             return 0;
1792         if (atom.size == 16) {
1793             original_size = par->extradata_size;
1794             ret = mov_realloc_extradata(par, atom);
1795             if (!ret) {
1796                 length =  mov_read_atom_into_extradata(c, pb, atom, par, par->extradata + original_size);
1797                 if (length == atom.size) {
1798                     const uint8_t range_value = par->extradata[original_size + 19];
1799                     switch (range_value) {
1800                     case 1:
1801                         par->color_range = AVCOL_RANGE_MPEG;
1802                         break;
1803                     case 2:
1804                         par->color_range = AVCOL_RANGE_JPEG;
1805                         break;
1806                     default:
1807                         av_log(c->fc, AV_LOG_WARNING, "ignored unknown aclr value (%d)\n", range_value);
1808                         break;
1809                     }
1810                     ff_dlog(c->fc, "color_range: %d\n", par->color_range);
1811                 } else {
1812                   /* For some reason the whole atom was not added to the extradata */
1813                   av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - incomplete atom\n");
1814                 }
1815             } else {
1816                 av_log(c->fc, AV_LOG_ERROR, "aclr not decoded - unable to add atom to extradata\n");
1817             }
1818         } else {
1819             av_log(c->fc, AV_LOG_WARNING, "aclr not decoded - unexpected size %"PRId64"\n", atom.size);
1820         }
1821     }
1822
1823     return ret;
1824 }
1825
1826 static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1827 {
1828     return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
1829 }
1830
1831 static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1832 {
1833     AVStream *st;
1834     int ret;
1835
1836     if (c->fc->nb_streams < 1)
1837         return 0;
1838     st = c->fc->streams[c->fc->nb_streams-1];
1839
1840     if ((uint64_t)atom.size > (1<<30))
1841         return AVERROR_INVALIDDATA;
1842
1843     if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
1844         st->codecpar->codec_id == AV_CODEC_ID_QDMC ||
1845         st->codecpar->codec_id == AV_CODEC_ID_SPEEX) {
1846         // pass all frma atom to codec, needed at least for QDMC and QDM2
1847         ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1848         if (ret < 0)
1849             return ret;
1850     } else if (atom.size > 8) { /* to read frma, esds atoms */
1851         if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
1852             uint64_t buffer;
1853             ret = ffio_ensure_seekback(pb, 8);
1854             if (ret < 0)
1855                 return ret;
1856             buffer = avio_rb64(pb);
1857             atom.size -= 8;
1858             if (  (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
1859                 && buffer >> 32 <= atom.size
1860                 && buffer >> 32 >= 8) {
1861                 avio_skip(pb, -8);
1862                 atom.size += 8;
1863             } else if (!st->codecpar->extradata_size) {
1864 #define ALAC_EXTRADATA_SIZE 36
1865                 st->codecpar->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
1866                 if (!st->codecpar->extradata)
1867                     return AVERROR(ENOMEM);
1868                 st->codecpar->extradata_size = ALAC_EXTRADATA_SIZE;
1869                 AV_WB32(st->codecpar->extradata    , ALAC_EXTRADATA_SIZE);
1870                 AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
1871                 AV_WB64(st->codecpar->extradata + 12, buffer);
1872                 avio_read(pb, st->codecpar->extradata + 20, 16);
1873                 avio_skip(pb, atom.size - 24);
1874                 return 0;
1875             }
1876         }
1877         if ((ret = mov_read_default(c, pb, atom)) < 0)
1878             return ret;
1879     } else
1880         avio_skip(pb, atom.size);
1881     return 0;
1882 }
1883
1884 /**
1885  * This function reads atom content and puts data in extradata without tag
1886  * nor size unlike mov_read_extradata.
1887  */
1888 static int mov_read_glbl(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1889 {
1890     AVStream *st;
1891     int ret;
1892
1893     if (c->fc->nb_streams < 1)
1894         return 0;
1895     st = c->fc->streams[c->fc->nb_streams-1];
1896
1897     if ((uint64_t)atom.size > (1<<30))
1898         return AVERROR_INVALIDDATA;
1899
1900     if (atom.size >= 10) {
1901         // Broken files created by legacy versions of libavformat will
1902         // wrap a whole fiel atom inside of a glbl atom.
1903         unsigned size = avio_rb32(pb);
1904         unsigned type = avio_rl32(pb);
1905         avio_seek(pb, -8, SEEK_CUR);
1906         if (type == MKTAG('f','i','e','l') && size == atom.size)
1907             return mov_read_default(c, pb, atom);
1908     }
1909     if (st->codecpar->extradata_size > 1 && st->codecpar->extradata) {
1910         av_log(c->fc, AV_LOG_WARNING, "ignoring multiple glbl\n");
1911         return 0;
1912     }
1913     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
1914     if (ret < 0)
1915         return ret;
1916     if (atom.type == MKTAG('h','v','c','C') && st->codecpar->codec_tag == MKTAG('d','v','h','1'))
1917         /* HEVC-based Dolby Vision derived from hvc1.
1918            Happens to match with an identifier
1919            previously utilized for DV. Thus, if we have
1920            the hvcC extradata box available as specified,
1921            set codec to HEVC */
1922         st->codecpar->codec_id = AV_CODEC_ID_HEVC;
1923
1924     return 0;
1925 }
1926
1927 static int mov_read_dvc1(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1928 {
1929     AVStream *st;
1930     uint8_t profile_level;
1931     int ret;
1932
1933     if (c->fc->nb_streams < 1)
1934         return 0;
1935     st = c->fc->streams[c->fc->nb_streams-1];
1936
1937     if (atom.size >= (1<<28) || atom.size < 7)
1938         return AVERROR_INVALIDDATA;
1939
1940     profile_level = avio_r8(pb);
1941     if ((profile_level & 0xf0) != 0xc0)
1942         return 0;
1943
1944     avio_seek(pb, 6, SEEK_CUR);
1945     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 7);
1946     if (ret < 0)
1947         return ret;
1948
1949     return 0;
1950 }
1951
1952 /**
1953  * An strf atom is a BITMAPINFOHEADER struct. This struct is 40 bytes itself,
1954  * but can have extradata appended at the end after the 40 bytes belonging
1955  * to the struct.
1956  */
1957 static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1958 {
1959     AVStream *st;
1960     int ret;
1961
1962     if (c->fc->nb_streams < 1)
1963         return 0;
1964     if (atom.size <= 40)
1965         return 0;
1966     st = c->fc->streams[c->fc->nb_streams-1];
1967
1968     if ((uint64_t)atom.size > (1<<30))
1969         return AVERROR_INVALIDDATA;
1970
1971     avio_skip(pb, 40);
1972     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 40);
1973     if (ret < 0)
1974         return ret;
1975
1976     return 0;
1977 }
1978
1979 static int mov_read_stco(MOVContext *c, AVIOContext *pb, MOVAtom atom)
1980 {
1981     AVStream *st;
1982     MOVStreamContext *sc;
1983     unsigned int i, entries;
1984
1985     if (c->trak_index < 0) {
1986         av_log(c->fc, AV_LOG_WARNING, "STCO outside TRAK\n");
1987         return 0;
1988     }
1989     if (c->fc->nb_streams < 1)
1990         return 0;
1991     st = c->fc->streams[c->fc->nb_streams-1];
1992     sc = st->priv_data;
1993
1994     avio_r8(pb); /* version */
1995     avio_rb24(pb); /* flags */
1996
1997     entries = avio_rb32(pb);
1998
1999     if (!entries)
2000         return 0;
2001
2002     if (sc->chunk_offsets)
2003         av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
2004     av_free(sc->chunk_offsets);
2005     sc->chunk_count = 0;
2006     sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
2007     if (!sc->chunk_offsets)
2008         return AVERROR(ENOMEM);
2009     sc->chunk_count = entries;
2010
2011     if      (atom.type == MKTAG('s','t','c','o'))
2012         for (i = 0; i < entries && !pb->eof_reached; i++)
2013             sc->chunk_offsets[i] = avio_rb32(pb);
2014     else if (atom.type == MKTAG('c','o','6','4'))
2015         for (i = 0; i < entries && !pb->eof_reached; i++)
2016             sc->chunk_offsets[i] = avio_rb64(pb);
2017     else
2018         return AVERROR_INVALIDDATA;
2019
2020     sc->chunk_count = i;
2021
2022     if (pb->eof_reached) {
2023         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STCO atom\n");
2024         return AVERROR_EOF;
2025     }
2026
2027     return 0;
2028 }
2029
2030 static int mov_codec_id(AVStream *st, uint32_t format)
2031 {
2032     int id = ff_codec_get_id(ff_codec_movaudio_tags, format);
2033
2034     if (id <= 0 &&
2035         ((format & 0xFFFF) == 'm' + ('s' << 8) ||
2036          (format & 0xFFFF) == 'T' + ('S' << 8)))
2037         id = ff_codec_get_id(ff_codec_wav_tags, av_bswap32(format) & 0xFFFF);
2038
2039     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO && id > 0) {
2040         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
2041     } else if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
2042                /* skip old ASF MPEG-4 tag */
2043                format && format != MKTAG('m','p','4','s')) {
2044         id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2045         if (id <= 0)
2046             id = ff_codec_get_id(ff_codec_bmp_tags, format);
2047         if (id > 0)
2048             st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
2049         else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA ||
2050                     (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
2051                     st->codecpar->codec_id == AV_CODEC_ID_NONE)) {
2052             id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
2053             if (id > 0)
2054                 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2055             else
2056                 id = ff_codec_get_id(ff_codec_movdata_tags, format);
2057         }
2058     }
2059
2060     st->codecpar->codec_tag = format;
2061
2062     return id;
2063 }
2064
2065 static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
2066                                  AVStream *st, MOVStreamContext *sc)
2067 {
2068     uint8_t codec_name[32] = { 0 };
2069     int64_t stsd_start;
2070     unsigned int len;
2071
2072     /* The first 16 bytes of the video sample description are already
2073      * read in ff_mov_read_stsd_entries() */
2074     stsd_start = avio_tell(pb) - 16;
2075
2076     avio_rb16(pb); /* version */
2077     avio_rb16(pb); /* revision level */
2078     avio_rb32(pb); /* vendor */
2079     avio_rb32(pb); /* temporal quality */
2080     avio_rb32(pb); /* spatial quality */
2081
2082     st->codecpar->width  = avio_rb16(pb); /* width */
2083     st->codecpar->height = avio_rb16(pb); /* height */
2084
2085     avio_rb32(pb); /* horiz resolution */
2086     avio_rb32(pb); /* vert resolution */
2087     avio_rb32(pb); /* data size, always 0 */
2088     avio_rb16(pb); /* frames per samples */
2089
2090     len = avio_r8(pb); /* codec name, pascal string */
2091     if (len > 31)
2092         len = 31;
2093     mov_read_mac_string(c, pb, len, codec_name, sizeof(codec_name));
2094     if (len < 31)
2095         avio_skip(pb, 31 - len);
2096
2097     if (codec_name[0])
2098         av_dict_set(&st->metadata, "encoder", codec_name, 0);
2099
2100     /* codec_tag YV12 triggers an UV swap in rawdec.c */
2101     if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
2102         st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
2103         st->codecpar->width &= ~1;
2104         st->codecpar->height &= ~1;
2105     }
2106     /* Flash Media Server uses tag H.263 with Sorenson Spark */
2107     if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
2108         !strncmp(codec_name, "Sorenson H263", 13))
2109         st->codecpar->codec_id = AV_CODEC_ID_FLV1;
2110
2111     st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
2112
2113     avio_seek(pb, stsd_start, SEEK_SET);
2114
2115     if (ff_get_qtpalette(st->codecpar->codec_id, pb, sc->palette)) {
2116         st->codecpar->bits_per_coded_sample &= 0x1F;
2117         sc->has_palette = 1;
2118     }
2119 }
2120
2121 static void mov_parse_stsd_audio(MOVContext *c, AVIOContext *pb,
2122                                  AVStream *st, MOVStreamContext *sc)
2123 {
2124     int bits_per_sample, flags;
2125     uint16_t version = avio_rb16(pb);
2126     AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
2127
2128     avio_rb16(pb); /* revision level */
2129     avio_rb32(pb); /* vendor */
2130
2131     st->codecpar->channels              = avio_rb16(pb); /* channel count */
2132     st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* sample size */
2133     av_log(c->fc, AV_LOG_TRACE, "audio channels %d\n", st->codecpar->channels);
2134
2135     sc->audio_cid = avio_rb16(pb);
2136     avio_rb16(pb); /* packet size = 0 */
2137
2138     st->codecpar->sample_rate = ((avio_rb32(pb) >> 16));
2139
2140     // Read QT version 1 fields. In version 0 these do not exist.
2141     av_log(c->fc, AV_LOG_TRACE, "version =%d, isom =%d\n", version, c->isom);
2142     if (!c->isom ||
2143         (compatible_brands && strstr(compatible_brands->value, "qt  ")) ||
2144         (sc->stsd_version == 0 && version > 0)) {
2145         if (version == 1) {
2146             sc->samples_per_frame = avio_rb32(pb);
2147             avio_rb32(pb); /* bytes per packet */
2148             sc->bytes_per_frame = avio_rb32(pb);
2149             avio_rb32(pb); /* bytes per sample */
2150         } else if (version == 2) {
2151             avio_rb32(pb); /* sizeof struct only */
2152             st->codecpar->sample_rate = av_int2double(avio_rb64(pb));
2153             st->codecpar->channels    = avio_rb32(pb);
2154             avio_rb32(pb); /* always 0x7F000000 */
2155             st->codecpar->bits_per_coded_sample = avio_rb32(pb);
2156
2157             flags = avio_rb32(pb); /* lpcm format specific flag */
2158             sc->bytes_per_frame   = avio_rb32(pb);
2159             sc->samples_per_frame = avio_rb32(pb);
2160             if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
2161                 st->codecpar->codec_id =
2162                     ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample,
2163                                              flags);
2164         }
2165         if (version == 0 || (version == 1 && sc->audio_cid != -2)) {
2166             /* can't correctly handle variable sized packet as audio unit */
2167             switch (st->codecpar->codec_id) {
2168             case AV_CODEC_ID_MP2:
2169             case AV_CODEC_ID_MP3:
2170                 st->need_parsing = AVSTREAM_PARSE_FULL;
2171                 break;
2172             }
2173         }
2174     }
2175
2176     if (sc->format == 0) {
2177         if (st->codecpar->bits_per_coded_sample == 8)
2178             st->codecpar->codec_id = mov_codec_id(st, MKTAG('r','a','w',' '));
2179         else if (st->codecpar->bits_per_coded_sample == 16)
2180             st->codecpar->codec_id = mov_codec_id(st, MKTAG('t','w','o','s'));
2181     }
2182
2183     switch (st->codecpar->codec_id) {
2184     case AV_CODEC_ID_PCM_S8:
2185     case AV_CODEC_ID_PCM_U8:
2186         if (st->codecpar->bits_per_coded_sample == 16)
2187             st->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE;
2188         break;
2189     case AV_CODEC_ID_PCM_S16LE:
2190     case AV_CODEC_ID_PCM_S16BE:
2191         if (st->codecpar->bits_per_coded_sample == 8)
2192             st->codecpar->codec_id = AV_CODEC_ID_PCM_S8;
2193         else if (st->codecpar->bits_per_coded_sample == 24)
2194             st->codecpar->codec_id =
2195                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
2196                 AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2197         else if (st->codecpar->bits_per_coded_sample == 32)
2198              st->codecpar->codec_id =
2199                 st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE ?
2200                 AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2201         break;
2202     /* set values for old format before stsd version 1 appeared */
2203     case AV_CODEC_ID_MACE3:
2204         sc->samples_per_frame = 6;
2205         sc->bytes_per_frame   = 2 * st->codecpar->channels;
2206         break;
2207     case AV_CODEC_ID_MACE6:
2208         sc->samples_per_frame = 6;
2209         sc->bytes_per_frame   = 1 * st->codecpar->channels;
2210         break;
2211     case AV_CODEC_ID_ADPCM_IMA_QT:
2212         sc->samples_per_frame = 64;
2213         sc->bytes_per_frame   = 34 * st->codecpar->channels;
2214         break;
2215     case AV_CODEC_ID_GSM:
2216         sc->samples_per_frame = 160;
2217         sc->bytes_per_frame   = 33;
2218         break;
2219     default:
2220         break;
2221     }
2222
2223     bits_per_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2224     if (bits_per_sample) {
2225         st->codecpar->bits_per_coded_sample = bits_per_sample;
2226         sc->sample_size = (bits_per_sample >> 3) * st->codecpar->channels;
2227     }
2228 }
2229
2230 static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
2231                                     AVStream *st, MOVStreamContext *sc,
2232                                     int64_t size)
2233 {
2234     // ttxt stsd contains display flags, justification, background
2235     // color, fonts, and default styles, so fake an atom to read it
2236     MOVAtom fake_atom = { .size = size };
2237     // mp4s contains a regular esds atom
2238     if (st->codecpar->codec_tag != AV_RL32("mp4s"))
2239         mov_read_glbl(c, pb, fake_atom);
2240     st->codecpar->width  = sc->width;
2241     st->codecpar->height = sc->height;
2242 }
2243
2244 static uint32_t yuv_to_rgba(uint32_t ycbcr)
2245 {
2246     uint8_t r, g, b;
2247     int y, cb, cr;
2248
2249     y  = (ycbcr >> 16) & 0xFF;
2250     cr = (ycbcr >> 8)  & 0xFF;
2251     cb =  ycbcr        & 0xFF;
2252
2253     b = av_clip_uint8((1164 * (y - 16)                     + 2018 * (cb - 128)) / 1000);
2254     g = av_clip_uint8((1164 * (y - 16) -  813 * (cr - 128) -  391 * (cb - 128)) / 1000);
2255     r = av_clip_uint8((1164 * (y - 16) + 1596 * (cr - 128)                    ) / 1000);
2256
2257     return (r << 16) | (g << 8) | b;
2258 }
2259
2260 static int mov_rewrite_dvd_sub_extradata(AVStream *st)
2261 {
2262     char buf[256] = {0};
2263     uint8_t *src = st->codecpar->extradata;
2264     int i, ret;
2265
2266     if (st->codecpar->extradata_size != 64)
2267         return 0;
2268
2269     if (st->codecpar->width > 0 &&  st->codecpar->height > 0)
2270         snprintf(buf, sizeof(buf), "size: %dx%d\n",
2271                  st->codecpar->width, st->codecpar->height);
2272     av_strlcat(buf, "palette: ", sizeof(buf));
2273
2274     for (i = 0; i < 16; i++) {
2275         uint32_t yuv = AV_RB32(src + i * 4);
2276         uint32_t rgba = yuv_to_rgba(yuv);
2277
2278         av_strlcatf(buf, sizeof(buf), "%06"PRIx32"%s", rgba, i != 15 ? ", " : "");
2279     }
2280
2281     if (av_strlcat(buf, "\n", sizeof(buf)) >= sizeof(buf))
2282         return 0;
2283
2284     ret = ff_alloc_extradata(st->codecpar, strlen(buf));
2285     if (ret < 0)
2286         return ret;
2287     memcpy(st->codecpar->extradata, buf, st->codecpar->extradata_size);
2288
2289     return 0;
2290 }
2291
2292 static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
2293                                 AVStream *st, MOVStreamContext *sc,
2294                                 int64_t size)
2295 {
2296     int ret;
2297
2298     if (st->codecpar->codec_tag == MKTAG('t','m','c','d')) {
2299         if ((int)size != size)
2300             return AVERROR(ENOMEM);
2301
2302         ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
2303         if (ret < 0)
2304             return ret;
2305         if (size > 16) {
2306             MOVStreamContext *tmcd_ctx = st->priv_data;
2307             int val;
2308             val = AV_RB32(st->codecpar->extradata + 4);
2309             tmcd_ctx->tmcd_flags = val;
2310             st->avg_frame_rate.num = AV_RB32(st->codecpar->extradata + 8); /* timescale */
2311             st->avg_frame_rate.den = AV_RB32(st->codecpar->extradata + 12); /* frameDuration */
2312 #if FF_API_LAVF_AVCTX
2313 FF_DISABLE_DEPRECATION_WARNINGS
2314             st->codec->time_base = av_inv_q(st->avg_frame_rate);
2315 FF_ENABLE_DEPRECATION_WARNINGS
2316 #endif
2317             /* adjust for per frame dur in counter mode */
2318             if (tmcd_ctx->tmcd_flags & 0x0008) {
2319                 int timescale = AV_RB32(st->codecpar->extradata + 8);
2320                 int framedur = AV_RB32(st->codecpar->extradata + 12);
2321                 st->avg_frame_rate.num *= timescale;
2322                 st->avg_frame_rate.den *= framedur;
2323 #if FF_API_LAVF_AVCTX
2324 FF_DISABLE_DEPRECATION_WARNINGS
2325                 st->codec->time_base.den *= timescale;
2326                 st->codec->time_base.num *= framedur;
2327 FF_ENABLE_DEPRECATION_WARNINGS
2328 #endif
2329             }
2330             if (size > 30) {
2331                 uint32_t len = AV_RB32(st->codecpar->extradata + 18); /* name atom length */
2332                 uint32_t format = AV_RB32(st->codecpar->extradata + 22);
2333                 if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
2334                     uint16_t str_size = AV_RB16(st->codecpar->extradata + 26); /* string length */
2335                     if (str_size > 0 && size >= (int)str_size + 30 &&
2336                         st->codecpar->extradata[30] /* Don't add empty string */) {
2337                         char *reel_name = av_malloc(str_size + 1);
2338                         if (!reel_name)
2339                             return AVERROR(ENOMEM);
2340                         memcpy(reel_name, st->codecpar->extradata + 30, str_size);
2341                         reel_name[str_size] = 0; /* Add null terminator */
2342                         av_dict_set(&st->metadata, "reel_name", reel_name,
2343                                     AV_DICT_DONT_STRDUP_VAL);
2344                     }
2345                 }
2346             }
2347         }
2348     } else {
2349         /* other codec type, just skip (rtp, mp4s ...) */
2350         avio_skip(pb, size);
2351     }
2352     return 0;
2353 }
2354
2355 static int mov_finalize_stsd_codec(MOVContext *c, AVIOContext *pb,
2356                                    AVStream *st, MOVStreamContext *sc)
2357 {
2358     if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2359         !st->codecpar->sample_rate && sc->time_scale > 1)
2360         st->codecpar->sample_rate = sc->time_scale;
2361
2362     /* special codec parameters handling */
2363     switch (st->codecpar->codec_id) {
2364 #if CONFIG_DV_DEMUXER
2365     case AV_CODEC_ID_DVAUDIO:
2366         c->dv_fctx = avformat_alloc_context();
2367         if (!c->dv_fctx) {
2368             av_log(c->fc, AV_LOG_ERROR, "dv demux context alloc error\n");
2369             return AVERROR(ENOMEM);
2370         }
2371         c->dv_demux = avpriv_dv_init_demux(c->dv_fctx);
2372         if (!c->dv_demux) {
2373             av_log(c->fc, AV_LOG_ERROR, "dv demux context init error\n");
2374             return AVERROR(ENOMEM);
2375         }
2376         sc->dv_audio_container = 1;
2377         st->codecpar->codec_id    = AV_CODEC_ID_PCM_S16LE;
2378         break;
2379 #endif
2380     /* no ifdef since parameters are always those */
2381     case AV_CODEC_ID_QCELP:
2382         st->codecpar->channels = 1;
2383         // force sample rate for qcelp when not stored in mov
2384         if (st->codecpar->codec_tag != MKTAG('Q','c','l','p'))
2385             st->codecpar->sample_rate = 8000;
2386         // FIXME: Why is the following needed for some files?
2387         sc->samples_per_frame = 160;
2388         if (!sc->bytes_per_frame)
2389             sc->bytes_per_frame = 35;
2390         break;
2391     case AV_CODEC_ID_AMR_NB:
2392         st->codecpar->channels    = 1;
2393         /* force sample rate for amr, stsd in 3gp does not store sample rate */
2394         st->codecpar->sample_rate = 8000;
2395         break;
2396     case AV_CODEC_ID_AMR_WB:
2397         st->codecpar->channels    = 1;
2398         st->codecpar->sample_rate = 16000;
2399         break;
2400     case AV_CODEC_ID_MP2:
2401     case AV_CODEC_ID_MP3:
2402         /* force type after stsd for m1a hdlr */
2403         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
2404         break;
2405     case AV_CODEC_ID_GSM:
2406     case AV_CODEC_ID_ADPCM_MS:
2407     case AV_CODEC_ID_ADPCM_IMA_WAV:
2408     case AV_CODEC_ID_ILBC:
2409     case AV_CODEC_ID_MACE3:
2410     case AV_CODEC_ID_MACE6:
2411     case AV_CODEC_ID_QDM2:
2412         st->codecpar->block_align = sc->bytes_per_frame;
2413         break;
2414     case AV_CODEC_ID_ALAC:
2415         if (st->codecpar->extradata_size == 36) {
2416             st->codecpar->channels    = AV_RB8 (st->codecpar->extradata + 21);
2417             st->codecpar->sample_rate = AV_RB32(st->codecpar->extradata + 32);
2418         }
2419         break;
2420     case AV_CODEC_ID_AC3:
2421     case AV_CODEC_ID_EAC3:
2422     case AV_CODEC_ID_MPEG1VIDEO:
2423     case AV_CODEC_ID_VC1:
2424     case AV_CODEC_ID_VP8:
2425     case AV_CODEC_ID_VP9:
2426         st->need_parsing = AVSTREAM_PARSE_FULL;
2427         break;
2428     default:
2429         break;
2430     }
2431     return 0;
2432 }
2433
2434 static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
2435                                   int codec_tag, int format,
2436                                   int64_t size)
2437 {
2438     int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
2439
2440     if (codec_tag &&
2441          (codec_tag != format &&
2442           // AVID 1:1 samples with differing data format and codec tag exist
2443           (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
2444           // prores is allowed to have differing data format and codec tag
2445           codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
2446           // so is dv (sigh)
2447           codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
2448           (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
2449                                  : codec_tag != MKTAG('j','p','e','g')))) {
2450         /* Multiple fourcc, we skip JPEG. This is not correct, we should
2451          * export it as a separate AVStream but this needs a few changes
2452          * in the MOV demuxer, patch welcome. */
2453
2454         av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
2455         avio_skip(pb, size);
2456         return 1;
2457     }
2458
2459     return 0;
2460 }
2461
2462 int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
2463 {
2464     AVStream *st;
2465     MOVStreamContext *sc;
2466     int pseudo_stream_id;
2467
2468     av_assert0 (c->fc->nb_streams >= 1);
2469     st = c->fc->streams[c->fc->nb_streams-1];
2470     sc = st->priv_data;
2471
2472     for (pseudo_stream_id = 0;
2473          pseudo_stream_id < entries && !pb->eof_reached;
2474          pseudo_stream_id++) {
2475         //Parsing Sample description table
2476         enum AVCodecID id;
2477         int ret, dref_id = 1;
2478         MOVAtom a = { AV_RL32("stsd") };
2479         int64_t start_pos = avio_tell(pb);
2480         int64_t size    = avio_rb32(pb); /* size */
2481         uint32_t format = avio_rl32(pb); /* data format */
2482
2483         if (size >= 16) {
2484             avio_rb32(pb); /* reserved */
2485             avio_rb16(pb); /* reserved */
2486             dref_id = avio_rb16(pb);
2487         } else if (size <= 7) {
2488             av_log(c->fc, AV_LOG_ERROR,
2489                    "invalid size %"PRId64" in stsd\n", size);
2490             return AVERROR_INVALIDDATA;
2491         }
2492
2493         if (mov_skip_multiple_stsd(c, pb, st->codecpar->codec_tag, format,
2494                                    size - (avio_tell(pb) - start_pos))) {
2495             sc->stsd_count++;
2496             continue;
2497         }
2498
2499         sc->pseudo_stream_id = st->codecpar->codec_tag ? -1 : pseudo_stream_id;
2500         sc->dref_id= dref_id;
2501         sc->format = format;
2502
2503         id = mov_codec_id(st, format);
2504
2505         av_log(c->fc, AV_LOG_TRACE,
2506                "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
2507                av_fourcc2str(format), st->codecpar->codec_type);
2508
2509         st->codecpar->codec_id = id;
2510         if (st->codecpar->codec_type==AVMEDIA_TYPE_VIDEO) {
2511             mov_parse_stsd_video(c, pb, st, sc);
2512         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
2513             mov_parse_stsd_audio(c, pb, st, sc);
2514             if (st->codecpar->sample_rate < 0) {
2515                 av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
2516                 return AVERROR_INVALIDDATA;
2517             }
2518         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
2519             mov_parse_stsd_subtitle(c, pb, st, sc,
2520                                     size - (avio_tell(pb) - start_pos));
2521         } else {
2522             ret = mov_parse_stsd_data(c, pb, st, sc,
2523                                       size - (avio_tell(pb) - start_pos));
2524             if (ret < 0)
2525                 return ret;
2526         }
2527         /* this will read extra atoms at the end (wave, alac, damr, avcC, hvcC, SMI ...) */
2528         a.size = size - (avio_tell(pb) - start_pos);
2529         if (a.size > 8) {
2530             if ((ret = mov_read_default(c, pb, a)) < 0)
2531                 return ret;
2532         } else if (a.size > 0)
2533             avio_skip(pb, a.size);
2534
2535         if (sc->extradata && st->codecpar->extradata) {
2536             int extra_size = st->codecpar->extradata_size;
2537
2538             /* Move the current stream extradata to the stream context one. */
2539             sc->extradata_size[pseudo_stream_id] = extra_size;
2540             sc->extradata[pseudo_stream_id] = st->codecpar->extradata;
2541             st->codecpar->extradata      = NULL;
2542             st->codecpar->extradata_size = 0;
2543         }
2544         sc->stsd_count++;
2545     }
2546
2547     if (pb->eof_reached) {
2548         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSD atom\n");
2549         return AVERROR_EOF;
2550     }
2551
2552     return 0;
2553 }
2554
2555 static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2556 {
2557     AVStream *st;
2558     MOVStreamContext *sc;
2559     int ret, entries;
2560
2561     if (c->fc->nb_streams < 1)
2562         return 0;
2563     st = c->fc->streams[c->fc->nb_streams - 1];
2564     sc = st->priv_data;
2565
2566     sc->stsd_version = avio_r8(pb);
2567     avio_rb24(pb); /* flags */
2568     entries = avio_rb32(pb);
2569
2570     /* Each entry contains a size (4 bytes) and format (4 bytes). */
2571     if (entries <= 0 || entries > atom.size / 8) {
2572         av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
2573         return AVERROR_INVALIDDATA;
2574     }
2575
2576     if (sc->extradata) {
2577         av_log(c->fc, AV_LOG_ERROR,
2578                "Duplicate stsd found in this track.\n");
2579         return AVERROR_INVALIDDATA;
2580     }
2581
2582     /* Prepare space for hosting multiple extradata. */
2583     sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
2584     if (!sc->extradata)
2585         return AVERROR(ENOMEM);
2586
2587     sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
2588     if (!sc->extradata_size) {
2589         ret = AVERROR(ENOMEM);
2590         goto fail;
2591     }
2592
2593     ret = ff_mov_read_stsd_entries(c, pb, entries);
2594     if (ret < 0)
2595         goto fail;
2596
2597     /* Restore back the primary extradata. */
2598     av_freep(&st->codecpar->extradata);
2599     st->codecpar->extradata_size = sc->extradata_size[0];
2600     if (sc->extradata_size[0]) {
2601         st->codecpar->extradata = av_mallocz(sc->extradata_size[0] + AV_INPUT_BUFFER_PADDING_SIZE);
2602         if (!st->codecpar->extradata)
2603             return AVERROR(ENOMEM);
2604         memcpy(st->codecpar->extradata, sc->extradata[0], sc->extradata_size[0]);
2605     }
2606
2607     return mov_finalize_stsd_codec(c, pb, st, sc);
2608 fail:
2609     if (sc->extradata) {
2610         int j;
2611         for (j = 0; j < sc->stsd_count; j++)
2612             av_freep(&sc->extradata[j]);
2613     }
2614
2615     av_freep(&sc->extradata);
2616     av_freep(&sc->extradata_size);
2617     return ret;
2618 }
2619
2620 static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2621 {
2622     AVStream *st;
2623     MOVStreamContext *sc;
2624     unsigned int i, entries;
2625
2626     if (c->fc->nb_streams < 1)
2627         return 0;
2628     st = c->fc->streams[c->fc->nb_streams-1];
2629     sc = st->priv_data;
2630
2631     avio_r8(pb); /* version */
2632     avio_rb24(pb); /* flags */
2633
2634     entries = avio_rb32(pb);
2635     if ((uint64_t)entries * 12 + 4 > atom.size)
2636         return AVERROR_INVALIDDATA;
2637
2638     av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
2639
2640     if (!entries)
2641         return 0;
2642     if (sc->stsc_data)
2643         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
2644     av_free(sc->stsc_data);
2645     sc->stsc_count = 0;
2646     sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
2647     if (!sc->stsc_data)
2648         return AVERROR(ENOMEM);
2649
2650     for (i = 0; i < entries && !pb->eof_reached; i++) {
2651         sc->stsc_data[i].first = avio_rb32(pb);
2652         sc->stsc_data[i].count = avio_rb32(pb);
2653         sc->stsc_data[i].id = avio_rb32(pb);
2654     }
2655
2656     sc->stsc_count = i;
2657     for (i = sc->stsc_count - 1; i < UINT_MAX; i--) {
2658         int64_t first_min = i + 1;
2659         if ((i+1 < sc->stsc_count && sc->stsc_data[i].first >= sc->stsc_data[i+1].first) ||
2660             (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first) ||
2661             sc->stsc_data[i].first < first_min ||
2662             sc->stsc_data[i].count < 1 ||
2663             sc->stsc_data[i].id < 1) {
2664             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);
2665             if (i+1 >= sc->stsc_count) {
2666                 if (sc->stsc_data[i].count == 0 && i > 0) {
2667                     sc->stsc_count --;
2668                     continue;
2669                 }
2670                 sc->stsc_data[i].first = FFMAX(sc->stsc_data[i].first, first_min);
2671                 if (i > 0 && sc->stsc_data[i].first <= sc->stsc_data[i-1].first)
2672                     sc->stsc_data[i].first = FFMIN(sc->stsc_data[i-1].first + 1LL, INT_MAX);
2673                 sc->stsc_data[i].count = FFMAX(sc->stsc_data[i].count, 1);
2674                 sc->stsc_data[i].id    = FFMAX(sc->stsc_data[i].id, 1);
2675                 continue;
2676             }
2677             av_assert0(sc->stsc_data[i+1].first >= 2);
2678             // We replace this entry by the next valid
2679             sc->stsc_data[i].first = sc->stsc_data[i+1].first - 1;
2680             sc->stsc_data[i].count = sc->stsc_data[i+1].count;
2681             sc->stsc_data[i].id    = sc->stsc_data[i+1].id;
2682         }
2683     }
2684
2685     if (pb->eof_reached) {
2686         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSC atom\n");
2687         return AVERROR_EOF;
2688     }
2689
2690     return 0;
2691 }
2692
2693 static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
2694 {
2695     return index < count - 1;
2696 }
2697
2698 /* Compute the samples value for the stsc entry at the given index. */
2699 static inline int64_t mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
2700 {
2701     int chunk_count;
2702
2703     if (mov_stsc_index_valid(index, sc->stsc_count))
2704         chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
2705     else {
2706         // Validation for stsc / stco  happens earlier in mov_read_stsc + mov_read_trak.
2707         av_assert0(sc->stsc_data[index].first <= sc->chunk_count);
2708         chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
2709     }
2710
2711     return sc->stsc_data[index].count * (int64_t)chunk_count;
2712 }
2713
2714 static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2715 {
2716     AVStream *st;
2717     MOVStreamContext *sc;
2718     unsigned i, entries;
2719
2720     if (c->fc->nb_streams < 1)
2721         return 0;
2722     st = c->fc->streams[c->fc->nb_streams-1];
2723     sc = st->priv_data;
2724
2725     avio_rb32(pb); // version + flags
2726
2727     entries = avio_rb32(pb);
2728     if (sc->stps_data)
2729         av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
2730     av_free(sc->stps_data);
2731     sc->stps_count = 0;
2732     sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
2733     if (!sc->stps_data)
2734         return AVERROR(ENOMEM);
2735
2736     for (i = 0; i < entries && !pb->eof_reached; i++) {
2737         sc->stps_data[i] = avio_rb32(pb);
2738     }
2739
2740     sc->stps_count = i;
2741
2742     if (pb->eof_reached) {
2743         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STPS atom\n");
2744         return AVERROR_EOF;
2745     }
2746
2747     return 0;
2748 }
2749
2750 static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2751 {
2752     AVStream *st;
2753     MOVStreamContext *sc;
2754     unsigned int i, entries;
2755
2756     if (c->fc->nb_streams < 1)
2757         return 0;
2758     st = c->fc->streams[c->fc->nb_streams-1];
2759     sc = st->priv_data;
2760
2761     avio_r8(pb); /* version */
2762     avio_rb24(pb); /* flags */
2763
2764     entries = avio_rb32(pb);
2765
2766     av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
2767
2768     if (!entries)
2769     {
2770         sc->keyframe_absent = 1;
2771         if (!st->need_parsing && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2772             st->need_parsing = AVSTREAM_PARSE_HEADERS;
2773         return 0;
2774     }
2775     if (sc->keyframes)
2776         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
2777     if (entries >= UINT_MAX / sizeof(int))
2778         return AVERROR_INVALIDDATA;
2779     av_freep(&sc->keyframes);
2780     sc->keyframe_count = 0;
2781     sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
2782     if (!sc->keyframes)
2783         return AVERROR(ENOMEM);
2784
2785     for (i = 0; i < entries && !pb->eof_reached; i++) {
2786         sc->keyframes[i] = avio_rb32(pb);
2787     }
2788
2789     sc->keyframe_count = i;
2790
2791     if (pb->eof_reached) {
2792         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSS atom\n");
2793         return AVERROR_EOF;
2794     }
2795
2796     return 0;
2797 }
2798
2799 static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2800 {
2801     AVStream *st;
2802     MOVStreamContext *sc;
2803     unsigned int i, entries, sample_size, field_size, num_bytes;
2804     GetBitContext gb;
2805     unsigned char* buf;
2806     int ret;
2807
2808     if (c->fc->nb_streams < 1)
2809         return 0;
2810     st = c->fc->streams[c->fc->nb_streams-1];
2811     sc = st->priv_data;
2812
2813     avio_r8(pb); /* version */
2814     avio_rb24(pb); /* flags */
2815
2816     if (atom.type == MKTAG('s','t','s','z')) {
2817         sample_size = avio_rb32(pb);
2818         if (!sc->sample_size) /* do not overwrite value computed in stsd */
2819             sc->sample_size = sample_size;
2820         sc->stsz_sample_size = sample_size;
2821         field_size = 32;
2822     } else {
2823         sample_size = 0;
2824         avio_rb24(pb); /* reserved */
2825         field_size = avio_r8(pb);
2826     }
2827     entries = avio_rb32(pb);
2828
2829     av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
2830
2831     sc->sample_count = entries;
2832     if (sample_size)
2833         return 0;
2834
2835     if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
2836         av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
2837         return AVERROR_INVALIDDATA;
2838     }
2839
2840     if (!entries)
2841         return 0;
2842     if (entries >= (UINT_MAX - 4) / field_size)
2843         return AVERROR_INVALIDDATA;
2844     if (sc->sample_sizes)
2845         av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
2846     av_free(sc->sample_sizes);
2847     sc->sample_count = 0;
2848     sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
2849     if (!sc->sample_sizes)
2850         return AVERROR(ENOMEM);
2851
2852     num_bytes = (entries*field_size+4)>>3;
2853
2854     buf = av_malloc(num_bytes+AV_INPUT_BUFFER_PADDING_SIZE);
2855     if (!buf) {
2856         av_freep(&sc->sample_sizes);
2857         return AVERROR(ENOMEM);
2858     }
2859
2860     ret = ffio_read_size(pb, buf, num_bytes);
2861     if (ret < 0) {
2862         av_freep(&sc->sample_sizes);
2863         av_free(buf);
2864         av_log(c->fc, AV_LOG_WARNING, "STSZ atom truncated\n");
2865         return 0;
2866     }
2867
2868     init_get_bits(&gb, buf, 8*num_bytes);
2869
2870     for (i = 0; i < entries && !pb->eof_reached; i++) {
2871         sc->sample_sizes[i] = get_bits_long(&gb, field_size);
2872         if (sc->sample_sizes[i] < 0) {
2873             av_free(buf);
2874             av_log(c->fc, AV_LOG_ERROR, "Invalid sample size %d\n", sc->sample_sizes[i]);
2875             return AVERROR_INVALIDDATA;
2876         }
2877         sc->data_size += sc->sample_sizes[i];
2878     }
2879
2880     sc->sample_count = i;
2881
2882     av_free(buf);
2883
2884     if (pb->eof_reached) {
2885         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STSZ atom\n");
2886         return AVERROR_EOF;
2887     }
2888
2889     return 0;
2890 }
2891
2892 static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2893 {
2894     AVStream *st;
2895     MOVStreamContext *sc;
2896     unsigned int i, entries, alloc_size = 0;
2897     int64_t duration=0;
2898     int64_t total_sample_count=0;
2899
2900     if (c->fc->nb_streams < 1)
2901         return 0;
2902     st = c->fc->streams[c->fc->nb_streams-1];
2903     sc = st->priv_data;
2904
2905     avio_r8(pb); /* version */
2906     avio_rb24(pb); /* flags */
2907     entries = avio_rb32(pb);
2908
2909     av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
2910             c->fc->nb_streams-1, entries);
2911
2912     if (sc->stts_data)
2913         av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
2914     av_freep(&sc->stts_data);
2915     sc->stts_count = 0;
2916     if (entries >= INT_MAX / sizeof(*sc->stts_data))
2917         return AVERROR(ENOMEM);
2918
2919     for (i = 0; i < entries && !pb->eof_reached; i++) {
2920         int sample_duration;
2921         unsigned int sample_count;
2922         unsigned int min_entries = FFMIN(FFMAX(i + 1, 1024 * 1024), entries);
2923         MOVStts *stts_data = av_fast_realloc(sc->stts_data, &alloc_size,
2924                                              min_entries * sizeof(*sc->stts_data));
2925         if (!stts_data) {
2926             av_freep(&sc->stts_data);
2927             sc->stts_count = 0;
2928             return AVERROR(ENOMEM);
2929         }
2930         sc->stts_count = min_entries;
2931         sc->stts_data = stts_data;
2932
2933         sample_count=avio_rb32(pb);
2934         sample_duration = avio_rb32(pb);
2935
2936         sc->stts_data[i].count= sample_count;
2937         sc->stts_data[i].duration= sample_duration;
2938
2939         av_log(c->fc, AV_LOG_TRACE, "sample_count=%d, sample_duration=%d\n",
2940                 sample_count, sample_duration);
2941
2942         duration+=(int64_t)sample_duration*(uint64_t)sample_count;
2943         total_sample_count+=sample_count;
2944     }
2945
2946     sc->stts_count = i;
2947
2948     if (duration > 0 &&
2949         duration <= INT64_MAX - sc->duration_for_fps &&
2950         total_sample_count <= INT_MAX - sc->nb_frames_for_fps
2951     ) {
2952         sc->duration_for_fps  += duration;
2953         sc->nb_frames_for_fps += total_sample_count;
2954     }
2955
2956     if (pb->eof_reached) {
2957         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted STTS atom\n");
2958         return AVERROR_EOF;
2959     }
2960
2961     st->nb_frames= total_sample_count;
2962     if (duration)
2963         st->duration= FFMIN(st->duration, duration);
2964     sc->track_end = duration;
2965     return 0;
2966 }
2967
2968 static int mov_read_sdtp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
2969 {
2970     AVStream *st;
2971     MOVStreamContext *sc;
2972     int64_t i, entries;
2973
2974     if (c->fc->nb_streams < 1)
2975         return 0;
2976     st = c->fc->streams[c->fc->nb_streams - 1];
2977     sc = st->priv_data;
2978
2979     avio_r8(pb); /* version */
2980     avio_rb24(pb); /* flags */
2981     entries = atom.size - 4;
2982
2983     av_log(c->fc, AV_LOG_TRACE, "track[%u].sdtp.entries = %" PRId64 "\n",
2984            c->fc->nb_streams - 1, entries);
2985
2986     if (sc->sdtp_data)
2987         av_log(c->fc, AV_LOG_WARNING, "Duplicated SDTP atom\n");
2988     av_freep(&sc->sdtp_data);
2989     sc->sdtp_count = 0;
2990
2991     sc->sdtp_data = av_mallocz(entries);
2992     if (!sc->sdtp_data)
2993         return AVERROR(ENOMEM);
2994
2995     for (i = 0; i < entries && !pb->eof_reached; i++)
2996         sc->sdtp_data[i] = avio_r8(pb);
2997     sc->sdtp_count = i;
2998
2999     return 0;
3000 }
3001
3002 static void mov_update_dts_shift(MOVStreamContext *sc, int duration, void *logctx)
3003 {
3004     if (duration < 0) {
3005         if (duration == INT_MIN) {
3006             av_log(logctx, AV_LOG_WARNING, "mov_update_dts_shift(): dts_shift set to %d\n", INT_MAX);
3007             duration++;
3008         }
3009         sc->dts_shift = FFMAX(sc->dts_shift, -duration);
3010     }
3011 }
3012
3013 static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
3014 {
3015     AVStream *st;
3016     MOVStreamContext *sc;
3017     unsigned int i, entries, ctts_count = 0;
3018
3019     if (c->fc->nb_streams < 1)
3020         return 0;
3021     st = c->fc->streams[c->fc->nb_streams-1];
3022     sc = st->priv_data;
3023
3024     avio_r8(pb); /* version */
3025     avio_rb24(pb); /* flags */
3026     entries = avio_rb32(pb);
3027
3028     av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
3029
3030     if (!entries)
3031         return 0;
3032     if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
3033         return AVERROR_INVALIDDATA;
3034     av_freep(&sc->ctts_data);
3035     sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
3036     if (!sc->ctts_data)
3037         return AVERROR(ENOMEM);
3038
3039     for (i = 0; i < entries && !pb->eof_reached; i++) {
3040         int count    =avio_rb32(pb);
3041         int duration =avio_rb32(pb);
3042
3043         if (count <= 0) {
3044             av_log(c->fc, AV_LOG_TRACE,
3045                    "ignoring CTTS entry with count=%d duration=%d\n",
3046                    count, duration);
3047             continue;
3048         }
3049
3050         add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
3051                        count, duration);
3052
3053         av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
3054                 count, duration);
3055
3056         if (FFNABS(duration) < -(1<<28) && i+2<entries) {
3057             av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
3058             av_freep(&sc->ctts_data);
3059             sc->ctts_count = 0;
3060             return 0;
3061         }
3062
3063         if (i+2<entries)
3064             mov_update_dts_shift(sc, duration, c->fc);
3065     }
3066
3067     sc->ctts_count = ctts_count;
3068
3069     if (pb->eof_reached) {
3070         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted CTTS atom\n");
3071         return AVERROR_EOF;
3072     }
3073
3074     av_log(c->fc, AV_LOG_TRACE, "dts shift %d\n", sc->dts_shift);
3075
3076     return 0;
3077 }
3078
3079 static int mov_read_sbgp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
3080 {
3081     AVStream *st;
3082     MOVStreamContext *sc;
3083     unsigned int i, entries;
3084     uint8_t version;
3085     uint32_t grouping_type;
3086
3087     if (c->fc->nb_streams < 1)
3088         return 0;
3089     st = c->fc->streams[c->fc->nb_streams-1];
3090     sc = st->priv_data;
3091
3092     version = avio_r8(pb); /* version */
3093     avio_rb24(pb); /* flags */
3094     grouping_type = avio_rl32(pb);
3095     if (grouping_type != MKTAG( 'r','a','p',' '))
3096         return 0; /* only support 'rap ' grouping */
3097     if (version == 1)
3098         avio_rb32(pb); /* grouping_type_parameter */
3099
3100     entries = avio_rb32(pb);
3101     if (!entries)
3102         return 0;
3103     if (sc->rap_group)
3104         av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
3105     av_free(sc->rap_group);
3106     sc->rap_group_count = 0;
3107     sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
3108     if (!sc->rap_group)
3109         return AVERROR(ENOMEM);
3110
3111     for (i = 0; i < entries && !pb->eof_reached; i++) {
3112         sc->rap_group[i].count = avio_rb32(pb); /* sample_count */
3113         sc->rap_group[i].index = avio_rb32(pb); /* group_description_index */
3114     }
3115
3116     sc->rap_group_count = i;
3117
3118     if (pb->eof_reached) {
3119         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted SBGP atom\n");
3120         return AVERROR_EOF;
3121     }
3122
3123     return 0;
3124 }
3125
3126 /**
3127  * Get ith edit list entry (media time, duration).
3128  */
3129 static int get_edit_list_entry(MOVContext *mov,
3130                                const MOVStreamContext *msc,
3131                                unsigned int edit_list_index,
3132                                int64_t *edit_list_media_time,
3133                                int64_t *edit_list_duration,
3134                                int64_t global_timescale)
3135 {
3136     if (edit_list_index == msc->elst_count) {
3137         return 0;
3138     }
3139     *edit_list_media_time = msc->elst_data[edit_list_index].time;
3140     *edit_list_duration = msc->elst_data[edit_list_index].duration;
3141
3142     /* duration is in global timescale units;convert to msc timescale */
3143     if (global_timescale == 0) {
3144       avpriv_request_sample(mov->fc, "Support for mvhd.timescale = 0 with editlists");
3145       return 0;
3146     }
3147     *edit_list_duration = av_rescale(*edit_list_duration, msc->time_scale,
3148                                      global_timescale);
3149     return 1;
3150 }
3151
3152 /**
3153  * Find the closest previous frame to the timestamp_pts, in e_old index
3154  * entries. Searching for just any frame / just key frames can be controlled by
3155  * last argument 'flag'.
3156  * Note that if ctts_data is not NULL, we will always search for a key frame
3157  * irrespective of the value of 'flag'. If we don't find any keyframe, we will
3158  * return the first frame of the video.
3159  *
3160  * Here the timestamp_pts is considered to be a presentation timestamp and
3161  * the timestamp of index entries are considered to be decoding timestamps.
3162  *
3163  * Returns 0 if successful in finding a frame, else returns -1.
3164  * Places the found index corresponding output arg.
3165  *
3166  * If ctts_old is not NULL, then refines the searched entry by searching
3167  * backwards from the found timestamp, to find the frame with correct PTS.
3168  *
3169  * Places the found ctts_index and ctts_sample in corresponding output args.
3170  */
3171 static int find_prev_closest_index(AVStream *st,
3172                                    AVIndexEntry *e_old,
3173                                    int nb_old,
3174                                    MOVStts* ctts_data,
3175                                    int64_t ctts_count,
3176                                    int64_t timestamp_pts,
3177                                    int flag,
3178                                    int64_t* index,
3179                                    int64_t* ctts_index,
3180                                    int64_t* ctts_sample)
3181 {
3182     MOVStreamContext *msc = st->priv_data;
3183     AVIndexEntry *e_keep = st->index_entries;
3184     int nb_keep = st->nb_index_entries;
3185     int64_t i = 0;
3186     int64_t index_ctts_count;
3187
3188     av_assert0(index);
3189
3190     // If dts_shift > 0, then all the index timestamps will have to be offset by
3191     // at least dts_shift amount to obtain PTS.
3192     // Hence we decrement the searched timestamp_pts by dts_shift to find the closest index element.
3193     if (msc->dts_shift > 0) {
3194         timestamp_pts -= msc->dts_shift;
3195     }
3196
3197     st->index_entries = e_old;
3198     st->nb_index_entries = nb_old;
3199     *index = av_index_search_timestamp(st, timestamp_pts, flag | AVSEEK_FLAG_BACKWARD);
3200
3201     // Keep going backwards in the index entries until the timestamp is the same.
3202     if (*index >= 0) {
3203         for (i = *index; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
3204              i--) {
3205             if ((flag & AVSEEK_FLAG_ANY) ||
3206                 (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
3207                 *index = i - 1;
3208             }
3209         }
3210     }
3211
3212     // If we have CTTS then refine the search, by searching backwards over PTS
3213     // computed by adding corresponding CTTS durations to index timestamps.
3214     if (ctts_data && *index >= 0) {
3215         av_assert0(ctts_index);
3216         av_assert0(ctts_sample);
3217         // Find out the ctts_index for the found frame.
3218         *ctts_index = 0;
3219         *ctts_sample = 0;
3220         for (index_ctts_count = 0; index_ctts_count < *index; index_ctts_count++) {
3221             if (*ctts_index < ctts_count) {
3222                 (*ctts_sample)++;
3223                 if (ctts_data[*ctts_index].count == *ctts_sample) {
3224                     (*ctts_index)++;
3225                     *ctts_sample = 0;
3226                 }
3227             }
3228         }
3229
3230         while (*index >= 0 && (*ctts_index) >= 0 && (*ctts_index) < ctts_count) {
3231             // Find a "key frame" with PTS <= timestamp_pts (So that we can decode B-frames correctly).
3232             // No need to add dts_shift to the timestamp here becase timestamp_pts has already been
3233             // compensated by dts_shift above.
3234             if ((e_old[*index].timestamp + ctts_data[*ctts_index].duration) <= timestamp_pts &&
3235                 (e_old[*index].flags & AVINDEX_KEYFRAME)) {
3236                 break;
3237             }
3238
3239             (*index)--;
3240             if (*ctts_sample == 0) {
3241                 (*ctts_index)--;
3242                 if (*ctts_index >= 0)
3243                   *ctts_sample = ctts_data[*ctts_index].count - 1;
3244             } else {
3245                 (*ctts_sample)--;
3246             }
3247         }
3248     }
3249
3250     /* restore AVStream state*/
3251     st->index_entries = e_keep;
3252     st->nb_index_entries = nb_keep;
3253     return *index >= 0 ? 0 : -1;
3254 }
3255
3256 /**
3257  * Add index entry with the given values, to the end of st->index_entries.
3258  * Returns the new size st->index_entries if successful, else returns -1.
3259  *
3260  * This function is similar to ff_add_index_entry in libavformat/utils.c
3261  * except that here we are always unconditionally adding an index entry to
3262  * the end, instead of searching the entries list and skipping the add if
3263  * there is an existing entry with the same timestamp.
3264  * This is needed because the mov_fix_index calls this func with the same
3265  * unincremented timestamp for successive discarded frames.
3266  */
3267 static int64_t add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
3268                                int size, int distance, int flags)
3269 {
3270     AVIndexEntry *entries, *ie;
3271     int64_t index = -1;
3272     const size_t min_size_needed = (st->nb_index_entries + 1) * sizeof(AVIndexEntry);
3273
3274     // Double the allocation each time, to lower memory fragmentation.
3275     // Another difference from ff_add_index_entry function.
3276     const size_t requested_size =
3277         min_size_needed > st->index_entries_allocated_size ?
3278         FFMAX(min_size_needed, 2 * st->index_entries_allocated_size) :
3279         min_size_needed;
3280
3281     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
3282         return -1;
3283
3284     entries = av_fast_realloc(st->index_entries,
3285                               &st->index_entries_allocated_size,
3286                               requested_size);
3287     if(!entries)
3288         return -1;
3289
3290     st->index_entries= entries;
3291
3292     index= st->nb_index_entries++;
3293     ie= &entries[index];
3294
3295     ie->pos = pos;
3296     ie->timestamp = timestamp;
3297     ie->min_distance= distance;
3298     ie->size= size;
3299     ie->flags = flags;
3300     return index;
3301 }
3302
3303 /**
3304  * Rewrite timestamps of index entries in the range [end_index - frame_duration_buffer_size, end_index)
3305  * by subtracting end_ts successively by the amounts given in frame_duration_buffer.
3306  */
3307 static void fix_index_entry_timestamps(AVStream* st, int end_index, int64_t end_ts,
3308                                        int64_t* frame_duration_buffer,
3309                                        int frame_duration_buffer_size) {
3310     int i = 0;
3311     av_assert0(end_index >= 0 && end_index <= st->nb_index_entries);
3312     for (i = 0; i < frame_duration_buffer_size; i++) {
3313         end_ts -= frame_duration_buffer[frame_duration_buffer_size - 1 - i];
3314         st->index_entries[end_index - 1 - i].timestamp = end_ts;
3315     }
3316 }
3317
3318 /**
3319  * Append a new ctts entry to ctts_data.
3320  * Returns the new ctts_count if successful, else returns -1.
3321  */
3322 static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
3323                               int count, int duration)
3324 {
3325     MOVStts *ctts_buf_new;
3326     const size_t min_size_needed = (*ctts_count + 1) * sizeof(MOVStts);
3327     const size_t requested_size =
3328         min_size_needed > *allocated_size ?
3329         FFMAX(min_size_needed, 2 * (*allocated_size)) :
3330         min_size_needed;
3331
3332     if((unsigned)(*ctts_count) >= UINT_MAX / sizeof(MOVStts) - 1)
3333         return -1;
3334
3335     ctts_buf_new = av_fast_realloc(*ctts_data, allocated_size, requested_size);
3336
3337     if(!ctts_buf_new)
3338         return -1;
3339
3340     *ctts_data = ctts_buf_new;
3341
3342     ctts_buf_new[*ctts_count].count = count;
3343     ctts_buf_new[*ctts_count].duration = duration;
3344
3345     *ctts_count = (*ctts_count) + 1;
3346     return *ctts_count;
3347 }
3348
3349 #define MAX_REORDER_DELAY 16
3350 static void mov_estimate_video_delay(MOVContext *c, AVStream* st) {
3351     MOVStreamContext *msc = st->priv_data;
3352     int ind;
3353     int ctts_ind = 0;
3354     int ctts_sample = 0;
3355     int64_t pts_buf[MAX_REORDER_DELAY + 1]; // Circular buffer to sort pts.
3356     int buf_start = 0;
3357     int j, r, num_swaps;
3358
3359     for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
3360         pts_buf[j] = INT64_MIN;
3361
3362     if (st->codecpar->video_delay <= 0 && msc->ctts_data &&
3363         st->codecpar->codec_id == AV_CODEC_ID_H264) {
3364         st->codecpar->video_delay = 0;
3365         for(ind = 0; ind < st->nb_index_entries && ctts_ind < msc->ctts_count; ++ind) {
3366             // Point j to the last elem of the buffer and insert the current pts there.
3367             j = buf_start;
3368             buf_start = (buf_start + 1);
3369             if (buf_start == MAX_REORDER_DELAY + 1)
3370                 buf_start = 0;
3371
3372             pts_buf[j] = st->index_entries[ind].timestamp + msc->ctts_data[ctts_ind].duration;
3373
3374             // The timestamps that are already in the sorted buffer, and are greater than the
3375             // current pts, are exactly the timestamps that need to be buffered to output PTS
3376             // in correct sorted order.
3377             // Hence the video delay (which is the buffer size used to sort DTS and output PTS),
3378             // can be computed as the maximum no. of swaps any particular timestamp needs to
3379             // go through, to keep this buffer in sorted order.
3380             num_swaps = 0;
3381             while (j != buf_start) {
3382                 r = j - 1;
3383                 if (r < 0) r = MAX_REORDER_DELAY;
3384                 if (pts_buf[j] < pts_buf[r]) {
3385                     FFSWAP(int64_t, pts_buf[j], pts_buf[r]);
3386                     ++num_swaps;
3387                 } else {
3388                     break;
3389                 }
3390                 j = r;
3391             }
3392             st->codecpar->video_delay = FFMAX(st->codecpar->video_delay, num_swaps);
3393
3394             ctts_sample++;
3395             if (ctts_sample == msc->ctts_data[ctts_ind].count) {
3396                 ctts_ind++;
3397                 ctts_sample = 0;
3398             }
3399         }
3400         av_log(c->fc, AV_LOG_DEBUG, "Setting codecpar->delay to %d for stream st: %d\n",
3401                st->codecpar->video_delay, st->index);
3402     }
3403 }
3404
3405 static void mov_current_sample_inc(MOVStreamContext *sc)
3406 {
3407     sc->current_sample++;
3408     sc->current_index++;
3409     if (sc->index_ranges &&
3410         sc->current_index >= sc->current_index_range->end &&
3411         sc->current_index_range->end) {
3412         sc->current_index_range++;
3413         sc->current_index = sc->current_index_range->start;
3414     }
3415 }
3416
3417 static void mov_current_sample_dec(MOVStreamContext *sc)
3418 {
3419     sc->current_sample--;
3420     sc->current_index--;
3421     if (sc->index_ranges &&
3422         sc->current_index < sc->current_index_range->start &&
3423         sc->current_index_range > sc->index_ranges) {
3424         sc->current_index_range--;
3425         sc->current_index = sc->current_index_range->end - 1;
3426     }
3427 }
3428
3429 static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
3430 {
3431     int64_t range_size;
3432
3433     sc->current_sample = current_sample;
3434     sc->current_index = current_sample;
3435     if (!sc->index_ranges) {
3436         return;
3437     }
3438
3439     for (sc->current_index_range = sc->index_ranges;
3440         sc->current_index_range->end;
3441         sc->current_index_range++) {
3442         range_size = sc->current_index_range->end - sc->current_index_range->start;
3443         if (range_size > current_sample) {
3444             sc->current_index = sc->current_index_range->start + current_sample;
3445             break;
3446         }
3447         current_sample -= range_size;
3448     }
3449 }
3450
3451 /**
3452  * Fix st->index_entries, so that it contains only the entries (and the entries
3453  * which are needed to decode them) that fall in the edit list time ranges.
3454  * Also fixes the timestamps of the index entries to match the timeline
3455  * specified the edit lists.
3456  */
3457 static void mov_fix_index(MOVContext *mov, AVStream *st)
3458 {
3459     MOVStreamContext *msc = st->priv_data;
3460     AVIndexEntry *e_old = st->index_entries;
3461     int nb_old = st->nb_index_entries;
3462     const AVIndexEntry *e_old_end = e_old + nb_old;
3463     const AVIndexEntry *current = NULL;
3464     MOVStts *ctts_data_old = msc->ctts_data;
3465     int64_t ctts_index_old = 0;
3466     int64_t ctts_sample_old = 0;
3467     int64_t ctts_count_old = msc->ctts_count;
3468     int64_t edit_list_media_time = 0;
3469     int64_t edit_list_duration = 0;
3470     int64_t frame_duration = 0;
3471     int64_t edit_list_dts_counter = 0;
3472     int64_t edit_list_dts_entry_end = 0;
3473     int64_t edit_list_start_ctts_sample = 0;
3474     int64_t curr_cts;
3475     int64_t curr_ctts = 0;
3476     int64_t empty_edits_sum_duration = 0;
3477     int64_t edit_list_index = 0;
3478     int64_t index;
3479     int flags;
3480     int64_t start_dts = 0;
3481     int64_t edit_list_start_encountered = 0;
3482     int64_t search_timestamp = 0;
3483     int64_t* frame_duration_buffer = NULL;
3484     int num_discarded_begin = 0;
3485     int first_non_zero_audio_edit = -1;
3486     int packet_skip_samples = 0;
3487     MOVIndexRange *current_index_range;
3488     int i;
3489     int found_keyframe_after_edit = 0;
3490     int found_non_empty_edit = 0;
3491
3492     if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
3493         return;
3494     }
3495
3496     // allocate the index ranges array
3497     msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
3498     if (!msc->index_ranges) {
3499         av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
3500         return;
3501     }
3502     msc->current_index_range = msc->index_ranges;
3503     current_index_range = msc->index_ranges - 1;
3504
3505     // Clean AVStream from traces of old index
3506     st->index_entries = NULL;
3507     st->index_entries_allocated_size = 0;
3508     st->nb_index_entries = 0;
3509
3510     // Clean ctts fields of MOVStreamContext
3511     msc->ctts_data = NULL;
3512     msc->ctts_count = 0;
3513     msc->ctts_index = 0;
3514     msc->ctts_sample = 0;
3515     msc->ctts_allocated_size = 0;
3516
3517     // Reinitialize min_corrected_pts so that it can be computed again.
3518     msc->min_corrected_pts = -1;
3519
3520     // If the dts_shift is positive (in case of negative ctts values in mov),
3521     // then negate the DTS by dts_shift
3522     if (msc->dts_shift > 0) {
3523         edit_list_dts_entry_end -= msc->dts_shift;
3524         av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
3525     }
3526
3527     start_dts = edit_list_dts_entry_end;
3528
3529     while (get_edit_list_entry(mov, msc, edit_list_index, &edit_list_media_time,
3530                                &edit_list_duration, mov->time_scale)) {
3531         av_log(mov->fc, AV_LOG_DEBUG, "Processing st: %d, edit list %"PRId64" - media time: %"PRId64", duration: %"PRId64"\n",
3532                st->index, edit_list_index, edit_list_media_time, edit_list_duration);
3533         edit_list_index++;
3534         edit_list_dts_counter = edit_list_dts_entry_end;
3535         edit_list_dts_entry_end += edit_list_duration;
3536         num_discarded_begin = 0;
3537         if (!found_non_empty_edit && edit_list_media_time == -1) {
3538             empty_edits_sum_duration += edit_list_duration;
3539             continue;
3540         }
3541         found_non_empty_edit = 1;
3542
3543         // If we encounter a non-negative edit list reset the skip_samples/start_pad fields and set them
3544         // according to the edit list below.
3545         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3546             if (first_non_zero_audio_edit < 0) {
3547                 first_non_zero_audio_edit = 1;
3548             } else {
3549                 first_non_zero_audio_edit = 0;
3550             }
3551
3552             if (first_non_zero_audio_edit > 0)
3553                 st->skip_samples = msc->start_pad = 0;
3554         }
3555
3556         // While reordering frame index according to edit list we must handle properly
3557         // the scenario when edit list entry starts from none key frame.
3558         // We find closest previous key frame and preserve it and consequent frames in index.
3559         // All frames which are outside edit list entry time boundaries will be dropped after decoding.
3560         search_timestamp = edit_list_media_time;
3561         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3562             // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
3563             // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
3564             // edit_list_media_time to cover the decoder delay.
3565             search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
3566         }
3567
3568         if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, 0,
3569                                     &index, &ctts_index_old, &ctts_sample_old) < 0) {
3570             av_log(mov->fc, AV_LOG_WARNING,
3571                    "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
3572                    st->index, edit_list_index, search_timestamp);
3573             if (find_prev_closest_index(st, e_old, nb_old, ctts_data_old, ctts_count_old, search_timestamp, AVSEEK_FLAG_ANY,
3574                                         &index, &ctts_index_old, &ctts_sample_old) < 0) {
3575                 av_log(mov->fc, AV_LOG_WARNING,
3576                        "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n",
3577                        st->index, edit_list_index, search_timestamp);
3578                 index = 0;
3579                 ctts_index_old = 0;
3580                 ctts_sample_old = 0;
3581             }
3582         }
3583         current = e_old + index;
3584         edit_list_start_ctts_sample = ctts_sample_old;
3585
3586         // Iterate over index and arrange it according to edit list
3587         edit_list_start_encountered = 0;
3588         found_keyframe_after_edit = 0;
3589         for (; current < e_old_end; current++, index++) {
3590             // check  if frame outside edit list mark it for discard
3591             frame_duration = (current + 1 <  e_old_end) ?
3592                              ((current + 1)->timestamp - current->timestamp) : edit_list_duration;
3593
3594             flags = current->flags;
3595
3596             // frames (pts) before or after edit list
3597             curr_cts = current->timestamp + msc->dts_shift;
3598             curr_ctts = 0;
3599
3600             if (ctts_data_old && ctts_index_old < ctts_count_old) {
3601                 curr_ctts = ctts_data_old[ctts_index_old].duration;
3602                 av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
3603                        curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
3604                 curr_cts += curr_ctts;
3605                 ctts_sample_old++;
3606                 if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
3607                     if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3608                                        &msc->ctts_allocated_size,
3609                                        ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3610                                        ctts_data_old[ctts_index_old].duration) == -1) {
3611                         av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3612                                ctts_index_old,
3613                                ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
3614                                ctts_data_old[ctts_index_old].duration);
3615                         break;
3616                     }
3617                     ctts_index_old++;
3618                     ctts_sample_old = 0;
3619                     edit_list_start_ctts_sample = 0;
3620                 }
3621             }
3622
3623             if (curr_cts < edit_list_media_time || curr_cts >= (edit_list_duration + edit_list_media_time)) {
3624                 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->codec_id != AV_CODEC_ID_VORBIS &&
3625                     curr_cts < edit_list_media_time && curr_cts + frame_duration > edit_list_media_time &&
3626                     first_non_zero_audio_edit > 0) {
3627                     packet_skip_samples = edit_list_media_time - curr_cts;
3628                     st->skip_samples += packet_skip_samples;
3629
3630                     // Shift the index entry timestamp by packet_skip_samples to be correct.
3631                     edit_list_dts_counter -= packet_skip_samples;
3632                     if (edit_list_start_encountered == 0)  {
3633                         edit_list_start_encountered = 1;
3634                         // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
3635                         // discarded packets.
3636                         if (frame_duration_buffer) {
3637                             fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3638                                                        frame_duration_buffer, num_discarded_begin);
3639                             av_freep(&frame_duration_buffer);
3640                         }
3641                     }
3642
3643                     av_log(mov->fc, AV_LOG_DEBUG, "skip %d audio samples from curr_cts: %"PRId64"\n", packet_skip_samples, curr_cts);
3644                 } else {
3645                     flags |= AVINDEX_DISCARD_FRAME;
3646                     av_log(mov->fc, AV_LOG_DEBUG, "drop a frame at curr_cts: %"PRId64" @ %"PRId64"\n", curr_cts, index);
3647
3648                     if (edit_list_start_encountered == 0) {
3649                         num_discarded_begin++;
3650                         frame_duration_buffer = av_realloc(frame_duration_buffer,
3651                                                            num_discarded_begin * sizeof(int64_t));
3652                         if (!frame_duration_buffer) {
3653                             av_log(mov->fc, AV_LOG_ERROR, "Cannot reallocate frame duration buffer\n");
3654                             break;
3655                         }
3656                         frame_duration_buffer[num_discarded_begin - 1] = frame_duration;
3657
3658                         // Increment skip_samples for the first non-zero audio edit list
3659                         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3660                             first_non_zero_audio_edit > 0 && st->codecpar->codec_id != AV_CODEC_ID_VORBIS) {
3661                             st->skip_samples += frame_duration;
3662                         }
3663                     }
3664                 }
3665             } else {
3666                 if (msc->min_corrected_pts < 0) {
3667                     msc->min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
3668                 } else {
3669                     msc->min_corrected_pts = FFMIN(msc->min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
3670                 }
3671                 if (edit_list_start_encountered == 0) {
3672                     edit_list_start_encountered = 1;
3673                     // Make timestamps strictly monotonically increasing by rewriting timestamps for
3674                     // discarded packets.
3675                     if (frame_duration_buffer) {
3676                         fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
3677                                                    frame_duration_buffer, num_discarded_begin);
3678                         av_freep(&frame_duration_buffer);
3679                     }
3680                 }
3681             }
3682
3683             if (add_index_entry(st, current->pos, edit_list_dts_counter, current->size,
3684                                 current->min_distance, flags) == -1) {
3685                 av_log(mov->fc, AV_LOG_ERROR, "Cannot add index entry\n");
3686                 break;
3687             }
3688
3689             // Update the index ranges array
3690             if (current_index_range < msc->index_ranges || index != current_index_range->end) {
3691                 current_index_range++;
3692                 current_index_range->start = index;
3693             }
3694             current_index_range->end = index + 1;
3695
3696             // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
3697             if (edit_list_start_encountered > 0) {
3698                 edit_list_dts_counter = edit_list_dts_counter + frame_duration;
3699             }
3700
3701             // Break when found first key frame after edit entry completion
3702             if ((curr_cts + frame_duration >= (edit_list_duration + edit_list_media_time)) &&
3703                 ((flags & AVINDEX_KEYFRAME) || ((st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)))) {
3704                 if (ctts_data_old) {
3705                     // If we have CTTS and this is the first keyframe after edit elist,
3706                     // wait for one more, because there might be trailing B-frames after this I-frame
3707                     // that do belong to the edit.
3708                     if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO && found_keyframe_after_edit == 0) {
3709                         found_keyframe_after_edit = 1;
3710                         continue;
3711                     }
3712                     if (ctts_sample_old != 0) {
3713                         if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
3714                                            &msc->ctts_allocated_size,
3715                                            ctts_sample_old - edit_list_start_ctts_sample,
3716                                            ctts_data_old[ctts_index_old].duration) == -1) {
3717                             av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
3718                                    ctts_index_old, ctts_sample_old - edit_list_start_ctts_sample,
3719                                    ctts_data_old[ctts_index_old].duration);
3720                             break;
3721                         }
3722                     }
3723                 }
3724                 break;
3725             }
3726         }
3727     }
3728     // If there are empty edits, then msc->min_corrected_pts might be positive
3729     // intentionally. So we subtract the sum duration of emtpy edits here.
3730     msc->min_corrected_pts -= empty_edits_sum_duration;
3731
3732     // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
3733     // dts by that amount to make the first pts zero.
3734     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3735         if (msc->min_corrected_pts > 0) {
3736             av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", msc->min_corrected_pts);
3737             for (i = 0; i < st->nb_index_entries; ++i) {
3738                 st->index_entries[i].timestamp -= msc->min_corrected_pts;
3739             }
3740         }
3741     }
3742     // Start time should be equal to zero or the duration of any empty edits.
3743     st->start_time = empty_edits_sum_duration;
3744
3745     // Update av stream length, if it ends up shorter than the track's media duration
3746     st->duration = FFMIN(st->duration, edit_list_dts_entry_end - start_dts);
3747     msc->start_pad = st->skip_samples;
3748
3749     // Free the old index and the old CTTS structures
3750     av_free(e_old);
3751     av_free(ctts_data_old);
3752     av_freep(&frame_duration_buffer);
3753
3754     // Null terminate the index ranges array
3755     current_index_range++;
3756     current_index_range->start = 0;
3757     current_index_range->end = 0;
3758     msc->current_index = msc->index_ranges[0].start;
3759 }
3760
3761 static void mov_build_index(MOVContext *mov, AVStream *st)
3762 {
3763     MOVStreamContext *sc = st->priv_data;
3764     int64_t current_offset;
3765     int64_t current_dts = 0;
3766     unsigned int stts_index = 0;
3767     unsigned int stsc_index = 0;
3768     unsigned int stss_index = 0;
3769     unsigned int stps_index = 0;
3770     unsigned int i, j;
3771     uint64_t stream_size = 0;
3772     MOVStts *ctts_data_old = sc->ctts_data;
3773     unsigned int ctts_count_old = sc->ctts_count;
3774
3775     if (sc->elst_count) {
3776         int i, edit_start_index = 0, multiple_edits = 0;
3777         int64_t empty_duration = 0; // empty duration of the first edit list entry
3778         int64_t start_time = 0; // start time of the media
3779
3780         for (i = 0; i < sc->elst_count; i++) {
3781             const MOVElst *e = &sc->elst_data[i];
3782             if (i == 0 && e->time == -1) {
3783                 /* if empty, the first entry is the start time of the stream
3784                  * relative to the presentation itself */
3785                 empty_duration = e->duration;
3786                 edit_start_index = 1;
3787             } else if (i == edit_start_index && e->time >= 0) {
3788                 start_time = e->time;
3789             } else {
3790                 multiple_edits = 1;
3791             }
3792         }
3793
3794         if (multiple_edits && !mov->advanced_editlist)
3795             av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
3796                    "Use -advanced_editlist to correctly decode otherwise "
3797                    "a/v desync might occur\n");
3798
3799         /* adjust first dts according to edit list */
3800         if ((empty_duration || start_time) && mov->time_scale > 0) {
3801             if (empty_duration)
3802                 empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
3803             sc->time_offset = start_time - empty_duration;
3804             sc->min_corrected_pts = start_time;
3805             if (!mov->advanced_editlist)
3806                 current_dts = -sc->time_offset;
3807         }
3808
3809         if (!multiple_edits && !mov->advanced_editlist &&
3810             st->codecpar->codec_id == AV_CODEC_ID_AAC && start_time > 0)
3811             sc->start_pad = start_time;
3812     }
3813
3814     /* only use old uncompressed audio chunk demuxing when stts specifies it */
3815     if (!(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3816           sc->stts_count == 1 && sc->stts_data[0].duration == 1)) {
3817         unsigned int current_sample = 0;
3818         unsigned int stts_sample = 0;
3819         unsigned int sample_size;
3820         unsigned int distance = 0;
3821         unsigned int rap_group_index = 0;
3822         unsigned int rap_group_sample = 0;
3823         int64_t last_dts = 0;
3824         int64_t dts_correction = 0;
3825         int rap_group_present = sc->rap_group_count && sc->rap_group;
3826         int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
3827
3828         current_dts -= sc->dts_shift;
3829         last_dts     = current_dts;
3830
3831         if (!sc->sample_count || st->nb_index_entries)
3832             return;
3833         if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
3834             return;
3835         if (av_reallocp_array(&st->index_entries,
3836                               st->nb_index_entries + sc->sample_count,
3837                               sizeof(*st->index_entries)) < 0) {
3838             st->nb_index_entries = 0;
3839             return;
3840         }
3841         st->index_entries_allocated_size = (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries);
3842
3843         if (ctts_data_old) {
3844             // Expand ctts entries such that we have a 1-1 mapping with samples
3845             if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
3846                 return;
3847             sc->ctts_count = 0;
3848             sc->ctts_allocated_size = 0;
3849             sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size,
3850                                     sc->sample_count * sizeof(*sc->ctts_data));
3851             if (!sc->ctts_data) {
3852                 av_free(ctts_data_old);
3853                 return;
3854             }
3855
3856             memset((uint8_t*)(sc->ctts_data), 0, sc->ctts_allocated_size);
3857
3858             for (i = 0; i < ctts_count_old &&
3859                         sc->ctts_count < sc->sample_count; i++)
3860                 for (j = 0; j < ctts_data_old[i].count &&
3861                             sc->ctts_count < sc->sample_count; j++)
3862                     add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
3863                                    &sc->ctts_allocated_size, 1,
3864                                    ctts_data_old[i].duration);
3865             av_free(ctts_data_old);
3866         }
3867
3868         for (i = 0; i < sc->chunk_count; i++) {
3869             int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
3870             current_offset = sc->chunk_offsets[i];
3871             while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
3872                 i + 1 == sc->stsc_data[stsc_index + 1].first)
3873                 stsc_index++;
3874
3875             if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
3876                 sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
3877                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
3878                 sc->stsz_sample_size = sc->sample_size;
3879             }
3880             if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
3881                 av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
3882                 sc->stsz_sample_size = sc->sample_size;
3883             }
3884
3885             for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
3886                 int keyframe = 0;
3887                 if (current_sample >= sc->sample_count) {
3888                     av_log(mov->fc, AV_LOG_ERROR, "wrong sample count\n");
3889                     return;
3890                 }
3891
3892                 if (!sc->keyframe_absent && (!sc->keyframe_count || current_sample+key_off == sc->keyframes[stss_index])) {
3893                     keyframe = 1;
3894                     if (stss_index + 1 < sc->keyframe_count)
3895                         stss_index++;
3896                 } else if (sc->stps_count && current_sample+key_off == sc->stps_data[stps_index]) {
3897                     keyframe = 1;
3898                     if (stps_index + 1 < sc->stps_count)
3899                         stps_index++;
3900                 }
3901                 if (rap_group_present && rap_group_index < sc->rap_group_count) {
3902                     if (sc->rap_group[rap_group_index].index > 0)
3903                         keyframe = 1;
3904                     if (++rap_group_sample == sc->rap_group[rap_group_index].count) {
3905                         rap_group_sample = 0;
3906                         rap_group_index++;
3907                     }
3908                 }
3909                 if (sc->keyframe_absent
3910                     && !sc->stps_count
3911                     && !rap_group_present
3912                     && (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
3913                      keyframe = 1;
3914                 if (keyframe)
3915                     distance = 0;
3916                 sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
3917                 if (sc->pseudo_stream_id == -1 ||
3918                    sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
3919                     AVIndexEntry *e;
3920                     if (sample_size > 0x3FFFFFFF) {
3921                         av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", sample_size);
3922                         return;
3923                     }
3924                     e = &st->index_entries[st->nb_index_entries++];
3925                     e->pos = current_offset;
3926                     e->timestamp = current_dts;
3927                     e->size = sample_size;
3928                     e->min_distance = distance;
3929                     e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
3930                     av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
3931                             "size %u, distance %u, keyframe %d\n", st->index, current_sample,
3932                             current_offset, current_dts, sample_size, distance, keyframe);
3933                     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
3934                         ff_rfps_add_frame(mov->fc, st, current_dts);
3935                 }
3936
3937                 current_offset += sample_size;
3938                 stream_size += sample_size;
3939
3940                 /* A negative sample duration is invalid based on the spec,
3941                  * but some samples need it to correct the DTS. */
3942                 if (sc->stts_data[stts_index].duration < 0) {
3943                     av_log(mov->fc, AV_LOG_WARNING,
3944                            "Invalid SampleDelta %d in STTS, at %d st:%d\n",
3945                            sc->stts_data[stts_index].duration, stts_index,
3946                            st->index);
3947                     dts_correction += sc->stts_data[stts_index].duration - 1;
3948                     sc->stts_data[stts_index].duration = 1;
3949                 }
3950                 current_dts += sc->stts_data[stts_index].duration;
3951                 if (!dts_correction || current_dts + dts_correction > last_dts) {
3952                     current_dts += dts_correction;
3953                     dts_correction = 0;
3954                 } else {
3955                     /* Avoid creating non-monotonous DTS */
3956                     dts_correction += current_dts - last_dts - 1;
3957                     current_dts = last_dts + 1;
3958                 }
3959                 last_dts = current_dts;
3960                 distance++;
3961                 stts_sample++;
3962                 current_sample++;
3963                 if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) {
3964                     stts_sample = 0;
3965                     stts_index++;
3966                 }
3967             }
3968         }
3969         if (st->duration > 0)
3970             st->codecpar->bit_rate = stream_size*8*sc->time_scale/st->duration;
3971     } else {
3972         unsigned chunk_samples, total = 0;
3973
3974         if (!sc->chunk_count)
3975             return;
3976
3977         // compute total chunk count
3978         for (i = 0; i < sc->stsc_count; i++) {
3979             unsigned count, chunk_count;
3980
3981             chunk_samples = sc->stsc_data[i].count;
3982             if (i != sc->stsc_count - 1 &&
3983                 sc->samples_per_frame && chunk_samples % sc->samples_per_frame) {
3984                 av_log(mov->fc, AV_LOG_ERROR, "error unaligned chunk\n");
3985                 return;
3986             }
3987
3988             if (sc->samples_per_frame >= 160) { // gsm
3989                 count = chunk_samples / sc->samples_per_frame;
3990             } else if (sc->samples_per_frame > 1) {
3991                 unsigned samples = (1024/sc->samples_per_frame)*sc->samples_per_frame;
3992                 count = (chunk_samples+samples-1) / samples;
3993             } else {
3994                 count = (chunk_samples+1023) / 1024;
3995             }
3996
3997             if (mov_stsc_index_valid(i, sc->stsc_count))
3998                 chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
3999             else
4000                 chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
4001             total += chunk_count * count;
4002         }
4003
4004         av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
4005         if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
4006             return;
4007         if (av_reallocp_array(&st->index_entries,
4008                               st->nb_index_entries + total,
4009                               sizeof(*st->index_entries)) < 0) {
4010             st->nb_index_entries = 0;
4011             return;
4012         }
4013         st->index_entries_allocated_size = (st->nb_index_entries + total) * sizeof(*st->index_entries);
4014
4015         // populate index
4016         for (i = 0; i < sc->chunk_count; i++) {
4017             current_offset = sc->chunk_offsets[i];
4018             if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
4019                 i + 1 == sc->stsc_data[stsc_index + 1].first)
4020                 stsc_index++;
4021             chunk_samples = sc->stsc_data[stsc_index].count;
4022
4023             while (chunk_samples > 0) {
4024                 AVIndexEntry *e;
4025                 unsigned size, samples;
4026
4027                 if (sc->samples_per_frame > 1 && !sc->bytes_per_frame) {
4028                     avpriv_request_sample(mov->fc,
4029                            "Zero bytes per frame, but %d samples per frame",
4030                            sc->samples_per_frame);
4031                     return;
4032                 }
4033
4034                 if (sc->samples_per_frame >= 160) { // gsm
4035                     samples = sc->samples_per_frame;
4036                     size = sc->bytes_per_frame;
4037                 } else {
4038                     if (sc->samples_per_frame > 1) {
4039                         samples = FFMIN((1024 / sc->samples_per_frame)*
4040                                         sc->samples_per_frame, chunk_samples);
4041                         size = (samples / sc->samples_per_frame) * sc->bytes_per_frame;
4042                     } else {
4043                         samples = FFMIN(1024, chunk_samples);
4044                         size = samples * sc->sample_size;
4045                     }
4046                 }
4047
4048                 if (st->nb_index_entries >= total) {
4049                     av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
4050                     return;
4051                 }
4052                 if (size > 0x3FFFFFFF) {
4053                     av_log(mov->fc, AV_LOG_ERROR, "Sample size %u is too large\n", size);
4054                     return;
4055                 }
4056                 e = &st->index_entries[st->nb_index_entries++];
4057                 e->pos = current_offset;
4058                 e->timestamp = current_dts;
4059                 e->size = size;
4060                 e->min_distance = 0;
4061                 e->flags = AVINDEX_KEYFRAME;
4062                 av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
4063                        "size %u, duration %u\n", st->index, i, current_offset, current_dts,
4064                        size, samples);
4065
4066                 current_offset += size;
4067                 current_dts += samples;
4068                 chunk_samples -= samples;
4069             }
4070         }
4071     }
4072
4073     if (!mov->ignore_editlist && mov->advanced_editlist) {
4074         // Fix index according to edit lists.
4075         mov_fix_index(mov, st);
4076     }
4077
4078     // Update start time of the stream.
4079     if (st->start_time == AV_NOPTS_VALUE && st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries > 0) {
4080         st->start_time = st->index_entries[0].timestamp + sc->dts_shift;
4081         if (sc->ctts_data) {
4082             st->start_time += sc->ctts_data[0].duration;
4083         }
4084     }
4085
4086     mov_estimate_video_delay(mov, st);
4087 }
4088
4089 static int test_same_origin(const char *src, const char *ref) {
4090     char src_proto[64];
4091     char ref_proto[64];
4092     char src_auth[256];
4093     char ref_auth[256];
4094     char src_host[256];
4095     char ref_host[256];
4096     int src_port=-1;
4097     int ref_port=-1;
4098
4099     av_url_split(src_proto, sizeof(src_proto), src_auth, sizeof(src_auth), src_host, sizeof(src_host), &src_port, NULL, 0, src);
4100     av_url_split(ref_proto, sizeof(ref_proto), ref_auth, sizeof(ref_auth), ref_host, sizeof(ref_host), &ref_port, NULL, 0, ref);
4101
4102     if (strlen(src) == 0) {
4103         return -1;
4104     } else if (strlen(src_auth) + 1 >= sizeof(src_auth) ||
4105         strlen(ref_auth) + 1 >= sizeof(ref_auth) ||
4106         strlen(src_host) + 1 >= sizeof(src_host) ||
4107         strlen(ref_host) + 1 >= sizeof(ref_host)) {
4108         return 0;
4109     } else if (strcmp(src_proto, ref_proto) ||
4110                strcmp(src_auth, ref_auth) ||
4111                strcmp(src_host, ref_host) ||
4112                src_port != ref_port) {
4113         return 0;
4114     } else
4115         return 1;
4116 }
4117
4118 static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref)
4119 {
4120     /* try relative path, we do not try the absolute because it can leak information about our
4121        system to an attacker */
4122     if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
4123         char filename[1025];
4124         const char *src_path;
4125         int i, l;
4126
4127         /* find a source dir */
4128         src_path = strrchr(src, '/');
4129         if (src_path)
4130             src_path++;
4131         else
4132             src_path = src;
4133
4134         /* find a next level down to target */
4135         for (i = 0, l = strlen(ref->path) - 1; l >= 0; l--)
4136             if (ref->path[l] == '/') {
4137                 if (i == ref->nlvl_to - 1)
4138                     break;
4139                 else
4140                     i++;
4141             }
4142
4143         /* compose filename if next level down to target was found */
4144         if (i == ref->nlvl_to - 1 && src_path - src  < sizeof(filename)) {
4145             memcpy(filename, src, src_path - src);
4146             filename[src_path - src] = 0;
4147
4148             for (i = 1; i < ref->nlvl_from; i++)
4149                 av_strlcat(filename, "../", sizeof(filename));
4150
4151             av_strlcat(filename, ref->path + l + 1, sizeof(filename));
4152             if (!c->use_absolute_path) {
4153                 int same_origin = test_same_origin(src, filename);
4154
4155                 if (!same_origin) {
4156                     av_log(c->fc, AV_LOG_ERROR,
4157                         "Reference with mismatching origin, %s not tried for security reasons, "
4158                         "set demuxer option use_absolute_path to allow it anyway\n",
4159                         ref->path);
4160                     return AVERROR(ENOENT);
4161                 }
4162
4163                 if(strstr(ref->path + l + 1, "..") ||
4164                    strstr(ref->path + l + 1, ":") ||
4165                    (ref->nlvl_from > 1 && same_origin < 0) ||
4166                    (filename[0] == '/' && src_path == src))
4167                     return AVERROR(ENOENT);
4168             }
4169
4170             if (strlen(filename) + 1 == sizeof(filename))
4171                 return AVERROR(ENOENT);
4172             if (!c->fc->io_open(c->fc, pb, filename, AVIO_FLAG_READ, NULL))
4173                 return 0;
4174         }
4175     } else if (c->use_absolute_path) {
4176         av_log(c->fc, AV_LOG_WARNING, "Using absolute path on user request, "
4177                "this is a possible security issue\n");
4178         if (!c->fc->io_open(c->fc, pb, ref->path, AVIO_FLAG_READ, NULL))
4179             return 0;
4180     } else {
4181         av_log(c->fc, AV_LOG_ERROR,
4182                "Absolute path %s not tried for security reasons, "
4183                "set demuxer option use_absolute_path to allow absolute paths\n",
4184                ref->path);
4185     }
4186
4187     return AVERROR(ENOENT);
4188 }
4189
4190 static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
4191 {
4192     if (sc->time_scale <= 0) {
4193         av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
4194         sc->time_scale = c->time_scale;
4195         if (sc->time_scale <= 0)
4196             sc->time_scale = 1;
4197     }
4198 }
4199
4200 static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4201 {
4202     AVStream *st;
4203     MOVStreamContext *sc;
4204     int ret;
4205
4206     st = avformat_new_stream(c->fc, NULL);
4207     if (!st) return AVERROR(ENOMEM);
4208     st->id = -1;
4209     sc = av_mallocz(sizeof(MOVStreamContext));
4210     if (!sc) return AVERROR(ENOMEM);
4211
4212     st->priv_data = sc;
4213     st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
4214     sc->ffindex = st->index;
4215     c->trak_index = st->index;
4216
4217     if ((ret = mov_read_default(c, pb, atom)) < 0)
4218         return ret;
4219
4220     c->trak_index = -1;
4221
4222     // Here stsc refers to a chunk not described in stco. This is technically invalid,
4223     // but we can overlook it (clearing stsc) whenever stts_count == 0 (indicating no samples).
4224     if (!sc->chunk_count && !sc->stts_count && sc->stsc_count) {
4225         sc->stsc_count = 0;
4226         av_freep(&sc->stsc_data);
4227     }
4228
4229     /* sanity checks */
4230     if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
4231                             (!sc->sample_size && !sc->sample_count))) ||
4232         (!sc->chunk_count && sc->sample_count)) {
4233         av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
4234                st->index);
4235         return 0;
4236     }
4237     if (sc->stsc_count && sc->stsc_data[ sc->stsc_count - 1 ].first > sc->chunk_count) {
4238         av_log(c->fc, AV_LOG_ERROR, "stream %d, contradictionary STSC and STCO\n",
4239                st->index);
4240         return AVERROR_INVALIDDATA;
4241     }
4242
4243     fix_timescale(c, sc);
4244
4245     avpriv_set_pts_info(st, 64, 1, sc->time_scale);
4246
4247     mov_build_index(c, st);
4248
4249     if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
4250         MOVDref *dref = &sc->drefs[sc->dref_id - 1];
4251         if (c->enable_drefs) {
4252             if (mov_open_dref(c, &sc->pb, c->fc->url, dref) < 0)
4253                 av_log(c->fc, AV_LOG_ERROR,
4254                        "stream %d, error opening alias: path='%s', dir='%s', "
4255                        "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
4256                        st->index, dref->path, dref->dir, dref->filename,
4257                        dref->volume, dref->nlvl_from, dref->nlvl_to);
4258         } else {
4259             av_log(c->fc, AV_LOG_WARNING,
4260                    "Skipped opening external track: "
4261                    "stream %d, alias: path='%s', dir='%s', "
4262                    "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d."
4263                    "Set enable_drefs to allow this.\n",
4264                    st->index, dref->path, dref->dir, dref->filename,
4265                    dref->volume, dref->nlvl_from, dref->nlvl_to);
4266         }
4267     } else {
4268         sc->pb = c->fc->pb;
4269         sc->pb_is_copied = 1;
4270     }
4271
4272     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
4273         if (!st->sample_aspect_ratio.num && st->codecpar->width && st->codecpar->height &&
4274             sc->height && sc->width &&
4275             (st->codecpar->width != sc->width || st->codecpar->height != sc->height)) {
4276             st->sample_aspect_ratio = av_d2q(((double)st->codecpar->height * sc->width) /
4277                                              ((double)st->codecpar->width * sc->height), INT_MAX);
4278         }
4279
4280 #if FF_API_R_FRAME_RATE
4281         if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
4282             av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4283                       sc->time_scale, sc->stts_data[0].duration, INT_MAX);
4284 #endif
4285     }
4286
4287     // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
4288     if (!st->codecpar->extradata_size && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
4289         TAG_IS_AVCI(st->codecpar->codec_tag)) {
4290         ret = ff_generate_avci_extradata(st);
4291         if (ret < 0)
4292             return ret;
4293     }
4294
4295     switch (st->codecpar->codec_id) {
4296 #if CONFIG_H261_DECODER
4297     case AV_CODEC_ID_H261:
4298 #endif
4299 #if CONFIG_H263_DECODER
4300     case AV_CODEC_ID_H263:
4301 #endif
4302 #if CONFIG_MPEG4_DECODER
4303     case AV_CODEC_ID_MPEG4:
4304 #endif
4305         st->codecpar->width = 0; /* let decoder init width/height */
4306         st->codecpar->height= 0;
4307         break;
4308     }
4309
4310     // If the duration of the mp3 packets is not constant, then they could need a parser
4311     if (st->codecpar->codec_id == AV_CODEC_ID_MP3
4312         && sc->stts_count > 3
4313         && sc->stts_count*10 > st->nb_frames
4314         && sc->time_scale == st->codecpar->sample_rate) {
4315             st->need_parsing = AVSTREAM_PARSE_FULL;
4316     }
4317     /* Do not need those anymore. */
4318     av_freep(&sc->chunk_offsets);
4319     av_freep(&sc->sample_sizes);
4320     av_freep(&sc->keyframes);
4321     av_freep(&sc->stts_data);
4322     av_freep(&sc->stps_data);
4323     av_freep(&sc->elst_data);
4324     av_freep(&sc->rap_group);
4325
4326     return 0;
4327 }
4328
4329 static int mov_read_ilst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4330 {
4331     int ret;
4332     c->itunes_metadata = 1;
4333     ret = mov_read_default(c, pb, atom);
4334     c->itunes_metadata = 0;
4335     return ret;
4336 }
4337
4338 static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4339 {
4340     uint32_t count;
4341     uint32_t i;
4342
4343     if (atom.size < 8)
4344         return 0;
4345
4346     avio_skip(pb, 4);
4347     count = avio_rb32(pb);
4348     if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
4349         av_log(c->fc, AV_LOG_ERROR,
4350                "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
4351         return AVERROR_INVALIDDATA;
4352     }
4353
4354     c->meta_keys_count = count + 1;
4355     c->meta_keys = av_mallocz(c->meta_keys_count * sizeof(*c->meta_keys));
4356     if (!c->meta_keys)
4357         return AVERROR(ENOMEM);
4358
4359     for (i = 1; i <= count; ++i) {
4360         uint32_t key_size = avio_rb32(pb);
4361         uint32_t type = avio_rl32(pb);
4362         if (key_size < 8) {
4363             av_log(c->fc, AV_LOG_ERROR,
4364                    "The key# %"PRIu32" in meta has invalid size:"
4365                    "%"PRIu32"\n", i, key_size);
4366             return AVERROR_INVALIDDATA;
4367         }
4368         key_size -= 8;
4369         if (type != MKTAG('m','d','t','a')) {
4370             avio_skip(pb, key_size);
4371         }
4372         c->meta_keys[i] = av_mallocz(key_size + 1);
4373         if (!c->meta_keys[i])
4374             return AVERROR(ENOMEM);
4375         avio_read(pb, c->meta_keys[i], key_size);
4376     }
4377
4378     return 0;
4379 }
4380
4381 static int mov_read_custom(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4382 {
4383     int64_t end = avio_tell(pb) + atom.size;
4384     uint8_t *key = NULL, *val = NULL, *mean = NULL;
4385     int i;
4386     int ret = 0;
4387     AVStream *st;
4388     MOVStreamContext *sc;
4389
4390     if (c->fc->nb_streams < 1)
4391         return 0;
4392     st = c->fc->streams[c->fc->nb_streams-1];
4393     sc = st->priv_data;
4394
4395     for (i = 0; i < 3; i++) {
4396         uint8_t **p;
4397         uint32_t len, tag;
4398
4399         if (end - avio_tell(pb) <= 12)
4400             break;
4401
4402         len = avio_rb32(pb);
4403         tag = avio_rl32(pb);
4404         avio_skip(pb, 4); // flags
4405
4406         if (len < 12 || len - 12 > end - avio_tell(pb))
4407             break;
4408         len -= 12;
4409
4410         if (tag == MKTAG('m', 'e', 'a', 'n'))
4411             p = &mean;
4412         else if (tag == MKTAG('n', 'a', 'm', 'e'))
4413             p = &key;
4414         else if (tag == MKTAG('d', 'a', 't', 'a') && len > 4) {
4415             avio_skip(pb, 4);
4416             len -= 4;
4417             p = &val;
4418         } else
4419             break;
4420
4421         if (*p)
4422             break;
4423
4424         *p = av_malloc(len + 1);
4425         if (!*p) {
4426             ret = AVERROR(ENOMEM);
4427             break;
4428         }
4429         ret = ffio_read_size(pb, *p, len);
4430         if (ret < 0) {
4431             av_freep(p);
4432             break;
4433         }
4434         (*p)[len] = 0;
4435     }
4436
4437     if (mean && key && val) {
4438         if (strcmp(key, "iTunSMPB") == 0) {
4439             int priming, remainder, samples;
4440             if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
4441                 if(priming>0 && priming<16384)
4442                     sc->start_pad = priming;
4443             }
4444         }
4445         if (strcmp(key, "cdec") != 0) {
4446             av_dict_set(&c->fc->metadata, key, val,
4447                         AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
4448             key = val = NULL;
4449         }
4450     } else {
4451         av_log(c->fc, AV_LOG_VERBOSE,
4452                "Unhandled or malformed custom metadata of size %"PRId64"\n", atom.size);
4453     }
4454
4455     avio_seek(pb, end, SEEK_SET);
4456     av_freep(&key);
4457     av_freep(&val);
4458     av_freep(&mean);
4459     return ret;
4460 }
4461
4462 static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4463 {
4464     while (atom.size > 8) {
4465         uint32_t tag;
4466         if (avio_feof(pb))
4467             return AVERROR_EOF;
4468         tag = avio_rl32(pb);
4469         atom.size -= 4;
4470         if (tag == MKTAG('h','d','l','r')) {
4471             avio_seek(pb, -8, SEEK_CUR);
4472             atom.size += 8;
4473             return mov_read_default(c, pb, atom);
4474         }
4475     }
4476     return 0;
4477 }
4478
4479 // return 1 when matrix is identity, 0 otherwise
4480 #define IS_MATRIX_IDENT(matrix)            \
4481     ( (matrix)[0][0] == (1 << 16) &&       \
4482       (matrix)[1][1] == (1 << 16) &&       \
4483       (matrix)[2][2] == (1 << 30) &&       \
4484      !(matrix)[0][1] && !(matrix)[0][2] && \
4485      !(matrix)[1][0] && !(matrix)[1][2] && \
4486      !(matrix)[2][0] && !(matrix)[2][1])
4487
4488 static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4489 {
4490     int i, j, e;
4491     int width;
4492     int height;
4493     int display_matrix[3][3];
4494     int res_display_matrix[3][3] = { { 0 } };
4495     AVStream *st;
4496     MOVStreamContext *sc;
4497     int version;
4498     int flags;
4499
4500     if (c->fc->nb_streams < 1)
4501         return 0;
4502     st = c->fc->streams[c->fc->nb_streams-1];
4503     sc = st->priv_data;
4504
4505     // Each stream (trak) should have exactly 1 tkhd. This catches bad files and
4506     // avoids corrupting AVStreams mapped to an earlier tkhd.
4507     if (st->id != -1)
4508         return AVERROR_INVALIDDATA;
4509
4510     version = avio_r8(pb);
4511     flags = avio_rb24(pb);
4512     st->disposition |= (flags & MOV_TKHD_FLAG_ENABLED) ? AV_DISPOSITION_DEFAULT : 0;
4513
4514     if (version == 1) {
4515         avio_rb64(pb);
4516         avio_rb64(pb);
4517     } else {
4518         avio_rb32(pb); /* creation time */
4519         avio_rb32(pb); /* modification time */
4520     }
4521     st->id = (int)avio_rb32(pb); /* track id (NOT 0 !)*/
4522     avio_rb32(pb); /* reserved */
4523
4524     /* highlevel (considering edits) duration in movie timebase */
4525     (version == 1) ? avio_rb64(pb) : avio_rb32(pb);
4526     avio_rb32(pb); /* reserved */
4527     avio_rb32(pb); /* reserved */
4528
4529     avio_rb16(pb); /* layer */
4530     avio_rb16(pb); /* alternate group */
4531     avio_rb16(pb); /* volume */
4532     avio_rb16(pb); /* reserved */
4533
4534     //read in the display matrix (outlined in ISO 14496-12, Section 6.2.2)
4535     // they're kept in fixed point format through all calculations
4536     // save u,v,z to store the whole matrix in the AV_PKT_DATA_DISPLAYMATRIX
4537     // side data, but the scale factor is not needed to calculate aspect ratio
4538     for (i = 0; i < 3; i++) {
4539         display_matrix[i][0] = avio_rb32(pb);   // 16.16 fixed point
4540         display_matrix[i][1] = avio_rb32(pb);   // 16.16 fixed point
4541         display_matrix[i][2] = avio_rb32(pb);   //  2.30 fixed point
4542     }
4543
4544     width = avio_rb32(pb);       // 16.16 fixed point track width
4545     height = avio_rb32(pb);      // 16.16 fixed point track height
4546     sc->width = width >> 16;
4547     sc->height = height >> 16;
4548
4549     // apply the moov display matrix (after the tkhd one)
4550     for (i = 0; i < 3; i++) {
4551         const int sh[3] = { 16, 16, 30 };
4552         for (j = 0; j < 3; j++) {
4553             for (e = 0; e < 3; e++) {
4554                 res_display_matrix[i][j] +=
4555                     ((int64_t) display_matrix[i][e] *
4556                      c->movie_display_matrix[e][j]) >> sh[e];
4557             }
4558         }
4559     }
4560
4561     // save the matrix when it is not the default identity
4562     if (!IS_MATRIX_IDENT(res_display_matrix)) {
4563         double rotate;
4564
4565         av_freep(&sc->display_matrix);
4566         sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
4567         if (!sc->display_matrix)
4568             return AVERROR(ENOMEM);
4569
4570         for (i = 0; i < 3; i++)
4571             for (j = 0; j < 3; j++)
4572                 sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
4573
4574 #if FF_API_OLD_ROTATE_API
4575         rotate = av_display_rotation_get(sc->display_matrix);
4576         if (!isnan(rotate)) {
4577             char rotate_buf[64];
4578             rotate = -rotate;
4579             if (rotate < 0) // for backward compatibility
4580                 rotate += 360;
4581             snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
4582             av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
4583         }
4584 #endif
4585     }
4586
4587     // transform the display width/height according to the matrix
4588     // to keep the same scale, use [width height 1<<16]
4589     if (width && height && sc->display_matrix) {
4590         double disp_transform[2];
4591
4592         for (i = 0; i < 2; i++)
4593             disp_transform[i] = hypot(sc->display_matrix[0 + i],
4594                                       sc->display_matrix[3 + i]);
4595
4596         if (disp_transform[0] > 0       && disp_transform[1] > 0 &&
4597             disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
4598             fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
4599             st->sample_aspect_ratio = av_d2q(
4600                 disp_transform[0] / disp_transform[1],
4601                 INT_MAX);
4602     }
4603     return 0;
4604 }
4605
4606 static int mov_read_tfhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4607 {
4608     MOVFragment *frag = &c->fragment;
4609     MOVTrackExt *trex = NULL;
4610     int flags, track_id, i;
4611     MOVFragmentStreamInfo * frag_stream_info;
4612
4613     avio_r8(pb); /* version */
4614     flags = avio_rb24(pb);
4615
4616     track_id = avio_rb32(pb);
4617     if (!track_id)
4618         return AVERROR_INVALIDDATA;
4619     for (i = 0; i < c->trex_count; i++)
4620         if (c->trex_data[i].track_id == track_id) {
4621             trex = &c->trex_data[i];
4622             break;
4623         }
4624     if (!trex) {
4625         av_log(c->fc, AV_LOG_WARNING, "could not find corresponding trex (id %u)\n", track_id);
4626         return 0;
4627     }
4628     c->fragment.found_tfhd = 1;
4629     frag->track_id = track_id;
4630     set_frag_stream(&c->frag_index, track_id);
4631
4632     frag->base_data_offset = flags & MOV_TFHD_BASE_DATA_OFFSET ?
4633                              avio_rb64(pb) : flags & MOV_TFHD_DEFAULT_BASE_IS_MOOF ?
4634                              frag->moof_offset : frag->implicit_offset;
4635     frag->stsd_id  = flags & MOV_TFHD_STSD_ID ? avio_rb32(pb) : trex->stsd_id;
4636
4637     frag->duration = flags & MOV_TFHD_DEFAULT_DURATION ?
4638                      avio_rb32(pb) : trex->duration;
4639     frag->size     = flags & MOV_TFHD_DEFAULT_SIZE ?
4640                      avio_rb32(pb) : trex->size;
4641     frag->flags    = flags & MOV_TFHD_DEFAULT_FLAGS ?
4642                      avio_rb32(pb) : trex->flags;
4643     av_log(c->fc, AV_LOG_TRACE, "frag flags 0x%x\n", frag->flags);
4644
4645     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4646     if (frag_stream_info)
4647         frag_stream_info->next_trun_dts = AV_NOPTS_VALUE;
4648
4649     return 0;
4650 }
4651
4652 static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4653 {
4654     unsigned i, num;
4655     void *new_tracks;
4656
4657     num = atom.size / 4;
4658     if (!(new_tracks = av_malloc_array(num, sizeof(int))))
4659         return AVERROR(ENOMEM);
4660
4661     av_free(c->chapter_tracks);
4662     c->chapter_tracks = new_tracks;
4663     c->nb_chapter_tracks = num;
4664
4665     for (i = 0; i < num && !pb->eof_reached; i++)
4666         c->chapter_tracks[i] = avio_rb32(pb);
4667
4668     return 0;
4669 }
4670
4671 static int mov_read_trex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4672 {
4673     MOVTrackExt *trex;
4674     int err;
4675
4676     if ((uint64_t)c->trex_count+1 >= UINT_MAX / sizeof(*c->trex_data))
4677         return AVERROR_INVALIDDATA;
4678     if ((err = av_reallocp_array(&c->trex_data, c->trex_count + 1,
4679                                  sizeof(*c->trex_data))) < 0) {
4680         c->trex_count = 0;
4681         return err;
4682     }
4683
4684     c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
4685
4686     trex = &c->trex_data[c->trex_count++];
4687     avio_r8(pb); /* version */
4688     avio_rb24(pb); /* flags */
4689     trex->track_id = avio_rb32(pb);
4690     trex->stsd_id  = avio_rb32(pb);
4691     trex->duration = avio_rb32(pb);
4692     trex->size     = avio_rb32(pb);
4693     trex->flags    = avio_rb32(pb);
4694     return 0;
4695 }
4696
4697 static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4698 {
4699     MOVFragment *frag = &c->fragment;
4700     AVStream *st = NULL;
4701     MOVStreamContext *sc;
4702     int version, i;
4703     MOVFragmentStreamInfo * frag_stream_info;
4704     int64_t base_media_decode_time;
4705
4706     for (i = 0; i < c->fc->nb_streams; i++) {
4707         if (c->fc->streams[i]->id == frag->track_id) {
4708             st = c->fc->streams[i];
4709             break;
4710         }
4711     }
4712     if (!st) {
4713         av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4714         return 0;
4715     }
4716     sc = st->priv_data;
4717     if (sc->pseudo_stream_id + 1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4718         return 0;
4719     version = avio_r8(pb);
4720     avio_rb24(pb); /* flags */
4721     if (version) {
4722         base_media_decode_time = avio_rb64(pb);
4723     } else {
4724         base_media_decode_time = avio_rb32(pb);
4725     }
4726
4727     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4728     if (frag_stream_info)
4729         frag_stream_info->tfdt_dts = base_media_decode_time;
4730     sc->track_end = base_media_decode_time;
4731
4732     return 0;
4733 }
4734
4735 static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
4736 {
4737     MOVFragment *frag = &c->fragment;
4738     AVStream *st = NULL;
4739     MOVStreamContext *sc;
4740     MOVStts *ctts_data;
4741     uint64_t offset;
4742     int64_t dts, pts = AV_NOPTS_VALUE;
4743     int data_offset = 0;
4744     unsigned entries, first_sample_flags = frag->flags;
4745     int flags, distance, i;
4746     int64_t prev_dts = AV_NOPTS_VALUE;
4747     int next_frag_index = -1, index_entry_pos;
4748     size_t requested_size;
4749     size_t old_ctts_allocated_size;
4750     AVIndexEntry *new_entries;
4751     MOVFragmentStreamInfo * frag_stream_info;
4752
4753     if (!frag->found_tfhd) {
4754         av_log(c->fc, AV_LOG_ERROR, "trun track id unknown, no tfhd was found\n");
4755         return AVERROR_INVALIDDATA;
4756     }
4757
4758     for (i = 0; i < c->fc->nb_streams; i++) {
4759         if (c->fc->streams[i]->id == frag->track_id) {
4760             st = c->fc->streams[i];
4761             break;
4762         }
4763     }
4764     if (!st) {
4765         av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %u\n", frag->track_id);
4766         return 0;
4767     }
4768     sc = st->priv_data;
4769     if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
4770         return 0;
4771
4772     // Find the next frag_index index that has a valid index_entry for
4773     // the current track_id.
4774     //
4775     // A valid index_entry means the trun for the fragment was read
4776     // and it's samples are in index_entries at the given position.
4777     // New index entries will be inserted before the index_entry found.
4778     index_entry_pos = st->nb_index_entries;
4779     for (i = c->frag_index.current + 1; i < c->frag_index.nb_items; i++) {
4780         frag_stream_info = get_frag_stream_info(&c->frag_index, i, frag->track_id);
4781         if (frag_stream_info && frag_stream_info->index_entry >= 0) {
4782             next_frag_index = i;
4783             index_entry_pos = frag_stream_info->index_entry;
4784             break;
4785         }
4786     }
4787     av_assert0(index_entry_pos <= st->nb_index_entries);
4788
4789     avio_r8(pb); /* version */
4790     flags = avio_rb24(pb);
4791     entries = avio_rb32(pb);
4792     av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
4793
4794     if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
4795         return AVERROR_INVALIDDATA;
4796     if (flags & MOV_TRUN_DATA_OFFSET)        data_offset        = avio_rb32(pb);
4797     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
4798
4799     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
4800     if (frag_stream_info)
4801     {
4802         if (frag_stream_info->next_trun_dts != AV_NOPTS_VALUE) {
4803             dts = frag_stream_info->next_trun_dts - sc->time_offset;
4804         } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4805             c->use_mfra_for == FF_MOV_FLAG_MFRA_PTS) {
4806             pts = frag_stream_info->first_tfra_pts;
4807             av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4808                     ", using it for pts\n", pts);
4809         } else if (frag_stream_info->first_tfra_pts != AV_NOPTS_VALUE &&
4810             c->use_mfra_for == FF_MOV_FLAG_MFRA_DTS) {
4811             dts = frag_stream_info->first_tfra_pts;
4812             av_log(c->fc, AV_LOG_DEBUG, "found mfra time %"PRId64
4813                     ", using it for dts\n", pts);
4814         } else if (frag_stream_info->sidx_pts != AV_NOPTS_VALUE) {
4815             // FIXME: sidx earliest_presentation_time is *PTS*, s.b.
4816             // pts = frag_stream_info->sidx_pts;
4817             dts = frag_stream_info->sidx_pts - sc->time_offset;
4818             av_log(c->fc, AV_LOG_DEBUG, "found sidx time %"PRId64
4819                     ", using it for pts\n", pts);
4820         } else if (frag_stream_info->tfdt_dts != AV_NOPTS_VALUE) {
4821             dts = frag_stream_info->tfdt_dts - sc->time_offset;
4822             av_log(c->fc, AV_LOG_DEBUG, "found tfdt time %"PRId64
4823                     ", using it for dts\n", dts);
4824         } else {
4825             dts = sc->track_end - sc->time_offset;
4826             av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4827                     ", using it for dts\n", dts);
4828         }
4829     } else {
4830         dts = sc->track_end - sc->time_offset;
4831         av_log(c->fc, AV_LOG_DEBUG, "found track end time %"PRId64
4832                 ", using it for dts\n", dts);
4833     }
4834     offset   = frag->base_data_offset + data_offset;
4835     distance = 0;
4836     av_log(c->fc, AV_LOG_TRACE, "first sample flags 0x%x\n", first_sample_flags);
4837
4838     // realloc space for new index entries
4839     if((uint64_t)st->nb_index_entries + entries >= UINT_MAX / sizeof(AVIndexEntry)) {
4840         entries = UINT_MAX / sizeof(AVIndexEntry) - st->nb_index_entries;
4841         av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n");
4842     }
4843     if (entries == 0)
4844         return 0;
4845
4846     requested_size = (st->nb_index_entries + entries) * sizeof(AVIndexEntry);
4847     new_entries = av_fast_realloc(st->index_entries,
4848                                   &st->index_entries_allocated_size,
4849                                   requested_size);
4850     if(!new_entries)
4851         return AVERROR(ENOMEM);
4852     st->index_entries= new_entries;
4853
4854     requested_size = (st->nb_index_entries + entries) * sizeof(*sc->ctts_data);
4855     old_ctts_allocated_size = sc->ctts_allocated_size;
4856     ctts_data = av_fast_realloc(sc->ctts_data, &sc->ctts_allocated_size,
4857                                 requested_size);
4858     if (!ctts_data)
4859         return AVERROR(ENOMEM);
4860     sc->ctts_data = ctts_data;
4861
4862     // In case there were samples without ctts entries, ensure they get
4863     // zero valued entries. This ensures clips which mix boxes with and
4864     // without ctts entries don't pickup uninitialized data.
4865     memset((uint8_t*)(sc->ctts_data) + old_ctts_allocated_size, 0,
4866            sc->ctts_allocated_size - old_ctts_allocated_size);
4867
4868     if (index_entry_pos < st->nb_index_entries) {
4869         // Make hole in index_entries and ctts_data for new samples
4870         memmove(st->index_entries + index_entry_pos + entries,
4871                 st->index_entries + index_entry_pos,
4872                 sizeof(*st->index_entries) *
4873                 (st->nb_index_entries - index_entry_pos));
4874         memmove(sc->ctts_data + index_entry_pos + entries,
4875                 sc->ctts_data + index_entry_pos,
4876                 sizeof(*sc->ctts_data) * (sc->ctts_count - index_entry_pos));
4877         if (index_entry_pos < sc->current_sample) {
4878             sc->current_sample += entries;
4879         }
4880     }
4881
4882     st->nb_index_entries += entries;
4883     sc->ctts_count = st->nb_index_entries;
4884
4885     // Record the index_entry position in frag_index of this fragment
4886     if (frag_stream_info)
4887         frag_stream_info->index_entry = index_entry_pos;
4888
4889     if (index_entry_pos > 0)
4890         prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4891
4892     for (i = 0; i < entries && !pb->eof_reached; i++) {
4893         unsigned sample_size = frag->size;
4894         int sample_flags = i ? frag->flags : first_sample_flags;
4895         unsigned sample_duration = frag->duration;
4896         unsigned ctts_duration = 0;
4897         int keyframe = 0;
4898         int index_entry_flags = 0;
4899
4900         if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
4901         if (flags & MOV_TRUN_SAMPLE_SIZE)     sample_size     = avio_rb32(pb);
4902         if (flags & MOV_TRUN_SAMPLE_FLAGS)    sample_flags    = avio_rb32(pb);
4903         if (flags & MOV_TRUN_SAMPLE_CTS)      ctts_duration   = avio_rb32(pb);
4904
4905         mov_update_dts_shift(sc, ctts_duration, c->fc);
4906         if (pts != AV_NOPTS_VALUE) {
4907             dts = pts - sc->dts_shift;
4908             if (flags & MOV_TRUN_SAMPLE_CTS) {
4909                 dts -= ctts_duration;
4910             } else {
4911                 dts -= sc->time_offset;
4912             }
4913             av_log(c->fc, AV_LOG_DEBUG,
4914                    "pts %"PRId64" calculated dts %"PRId64
4915                    " sc->dts_shift %d ctts.duration %d"
4916                    " sc->time_offset %"PRId64
4917                    " flags & MOV_TRUN_SAMPLE_CTS %d\n",
4918                    pts, dts,
4919                    sc->dts_shift, ctts_duration,
4920                    sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
4921             pts = AV_NOPTS_VALUE;
4922         }
4923
4924         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
4925             keyframe = 1;
4926         else
4927             keyframe =
4928                 !(sample_flags & (MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC |
4929                                   MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
4930         if (keyframe) {
4931             distance = 0;
4932             index_entry_flags |= AVINDEX_KEYFRAME;
4933         }
4934         // Fragments can overlap in time.  Discard overlapping frames after
4935         // decoding.
4936         if (prev_dts >= dts)
4937             index_entry_flags |= AVINDEX_DISCARD_FRAME;
4938
4939         st->index_entries[index_entry_pos].pos = offset;
4940         st->index_entries[index_entry_pos].timestamp = dts;
4941         st->index_entries[index_entry_pos].size= sample_size;
4942         st->index_entries[index_entry_pos].min_distance= distance;
4943         st->index_entries[index_entry_pos].flags = index_entry_flags;
4944
4945         sc->ctts_data[index_entry_pos].count = 1;
4946         sc->ctts_data[index_entry_pos].duration = ctts_duration;
4947         index_entry_pos++;
4948
4949         av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
4950                 "size %u, distance %d, keyframe %d\n", st->index,
4951                 index_entry_pos, offset, dts, sample_size, distance, keyframe);
4952         distance++;
4953         dts += sample_duration;
4954         offset += sample_size;
4955         sc->data_size += sample_size;
4956
4957         if (sample_duration <= INT64_MAX - sc->duration_for_fps &&
4958             1 <= INT_MAX - sc->nb_frames_for_fps
4959         ) {
4960             sc->duration_for_fps += sample_duration;
4961             sc->nb_frames_for_fps ++;
4962         }
4963     }
4964     if (frag_stream_info)
4965         frag_stream_info->next_trun_dts = dts + sc->time_offset;
4966     if (i < entries) {
4967         // EOF found before reading all entries.  Fix the hole this would
4968         // leave in index_entries and ctts_data
4969         int gap = entries - i;
4970         memmove(st->index_entries + index_entry_pos,
4971                 st->index_entries + index_entry_pos + gap,
4972                 sizeof(*st->index_entries) *
4973                 (st->nb_index_entries - (index_entry_pos + gap)));
4974         memmove(sc->ctts_data + index_entry_pos,
4975                 sc->ctts_data + index_entry_pos + gap,
4976                 sizeof(*sc->ctts_data) *
4977                 (sc->ctts_count - (index_entry_pos + gap)));
4978
4979         st->nb_index_entries -= gap;
4980         sc->ctts_count -= gap;
4981         if (index_entry_pos < sc->current_sample) {
4982             sc->current_sample -= gap;
4983         }
4984         entries = i;
4985     }
4986
4987     // The end of this new fragment may overlap in time with the start
4988     // of the next fragment in index_entries. Mark the samples in the next
4989     // fragment that overlap with AVINDEX_DISCARD_FRAME
4990     prev_dts = AV_NOPTS_VALUE;
4991     if (index_entry_pos > 0)
4992         prev_dts = st->index_entries[index_entry_pos-1].timestamp;
4993     for (i = index_entry_pos; i < st->nb_index_entries; i++) {
4994         if (prev_dts < st->index_entries[i].timestamp)
4995             break;
4996         st->index_entries[i].flags |= AVINDEX_DISCARD_FRAME;
4997     }
4998
4999     // If a hole was created to insert the new index_entries into,
5000     // the index_entry recorded for all subsequent moof must
5001     // be incremented by the number of entries inserted.
5002     fix_frag_index_entries(&c->frag_index, next_frag_index,
5003                            frag->track_id, entries);
5004
5005     if (pb->eof_reached) {
5006         av_log(c->fc, AV_LOG_WARNING, "reached eof, corrupted TRUN atom\n");
5007         return AVERROR_EOF;
5008     }
5009
5010     frag->implicit_offset = offset;
5011
5012     sc->track_end = dts + sc->time_offset;
5013     if (st->duration < sc->track_end)
5014         st->duration = sc->track_end;
5015
5016     return 0;
5017 }
5018
5019 static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5020 {
5021     int64_t offset = avio_tell(pb) + atom.size, pts, timestamp;
5022     uint8_t version;
5023     unsigned i, j, track_id, item_count;
5024     AVStream *st = NULL;
5025     AVStream *ref_st = NULL;
5026     MOVStreamContext *sc, *ref_sc = NULL;
5027     AVRational timescale;
5028
5029     version = avio_r8(pb);
5030     if (version > 1) {
5031         avpriv_request_sample(c->fc, "sidx version %u", version);
5032         return 0;
5033     }
5034
5035     avio_rb24(pb); // flags
5036
5037     track_id = avio_rb32(pb); // Reference ID
5038     for (i = 0; i < c->fc->nb_streams; i++) {
5039         if (c->fc->streams[i]->id == track_id) {
5040             st = c->fc->streams[i];
5041             break;
5042         }
5043     }
5044     if (!st) {
5045         av_log(c->fc, AV_LOG_WARNING, "could not find corresponding track id %d\n", track_id);
5046         return 0;
5047     }
5048
5049     sc = st->priv_data;
5050
5051     timescale = av_make_q(1, avio_rb32(pb));
5052
5053     if (timescale.den <= 0) {
5054         av_log(c->fc, AV_LOG_ERROR, "Invalid sidx timescale 1/%d\n", timescale.den);
5055         return AVERROR_INVALIDDATA;
5056     }
5057
5058     if (version == 0) {
5059         pts = avio_rb32(pb);
5060         offset += avio_rb32(pb);
5061     } else {
5062         pts = avio_rb64(pb);
5063         offset += avio_rb64(pb);
5064     }
5065
5066     avio_rb16(pb); // reserved
5067
5068     item_count = avio_rb16(pb);
5069
5070     for (i = 0; i < item_count; i++) {
5071         int index;
5072         MOVFragmentStreamInfo * frag_stream_info;
5073         uint32_t size = avio_rb32(pb);
5074         uint32_t duration = avio_rb32(pb);
5075         if (size & 0x80000000) {
5076             avpriv_request_sample(c->fc, "sidx reference_type 1");
5077             return AVERROR_PATCHWELCOME;
5078         }
5079         avio_rb32(pb); // sap_flags
5080         timestamp = av_rescale_q(pts, timescale, st->time_base);
5081
5082         index = update_frag_index(c, offset);
5083         frag_stream_info = get_frag_stream_info(&c->frag_index, index, track_id);
5084         if (frag_stream_info)
5085             frag_stream_info->sidx_pts = timestamp;
5086
5087         offset += size;
5088         pts += duration;
5089     }
5090
5091     st->duration = sc->track_end = pts;
5092
5093     sc->has_sidx = 1;
5094
5095     if (offset == avio_size(pb)) {
5096         // Find first entry in fragment index that came from an sidx.
5097         // This will pretty much always be the first entry.
5098         for (i = 0; i < c->frag_index.nb_items; i++) {
5099             MOVFragmentIndexItem * item = &c->frag_index.item[i];
5100             for (j = 0; ref_st == NULL && j < item->nb_stream_info; j++) {
5101                 MOVFragmentStreamInfo * si;
5102                 si = &item->stream_info[j];
5103                 if (si->sidx_pts != AV_NOPTS_VALUE) {
5104                     ref_st = c->fc->streams[j];
5105                     ref_sc = ref_st->priv_data;
5106                     break;
5107                 }
5108             }
5109         }
5110         if (ref_st) for (i = 0; i < c->fc->nb_streams; i++) {
5111             st = c->fc->streams[i];
5112             sc = st->priv_data;
5113             if (!sc->has_sidx) {
5114                 st->duration = sc->track_end = av_rescale(ref_st->duration, sc->time_scale, ref_sc->time_scale);
5115             }
5116         }
5117
5118         c->frag_index.complete = 1;
5119     }
5120
5121     return 0;
5122 }
5123
5124 /* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
5125 /* like the files created with Adobe Premiere 5.0, for samples see */
5126 /* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
5127 static int mov_read_wide(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5128 {
5129     int err;
5130
5131     if (atom.size < 8)
5132         return 0; /* continue */
5133     if (avio_rb32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom size */
5134         avio_skip(pb, atom.size - 4);
5135         return 0;
5136     }
5137     atom.type = avio_rl32(pb);
5138     atom.size -= 8;
5139     if (atom.type != MKTAG('m','d','a','t')) {
5140         avio_skip(pb, atom.size);
5141         return 0;
5142     }
5143     err = mov_read_mdat(c, pb, atom);
5144     return err;
5145 }
5146
5147 static int mov_read_cmov(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5148 {
5149 #if CONFIG_ZLIB
5150     AVIOContext ctx;
5151     uint8_t *cmov_data;
5152     uint8_t *moov_data; /* uncompressed data */
5153     long cmov_len, moov_len;
5154     int ret = -1;
5155
5156     avio_rb32(pb); /* dcom atom */
5157     if (avio_rl32(pb) != MKTAG('d','c','o','m'))
5158         return AVERROR_INVALIDDATA;
5159     if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
5160         av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
5161         return AVERROR_INVALIDDATA;
5162     }
5163     avio_rb32(pb); /* cmvd atom */
5164     if (avio_rl32(pb) != MKTAG('c','m','v','d'))
5165         return AVERROR_INVALIDDATA;
5166     moov_len = avio_rb32(pb); /* uncompressed size */
5167     cmov_len = atom.size - 6 * 4;
5168
5169     cmov_data = av_malloc(cmov_len);
5170     if (!cmov_data)
5171         return AVERROR(ENOMEM);
5172     moov_data = av_malloc(moov_len);
5173     if (!moov_data) {
5174         av_free(cmov_data);
5175         return AVERROR(ENOMEM);
5176     }
5177     ret = ffio_read_size(pb, cmov_data, cmov_len);
5178     if (ret < 0)
5179         goto free_and_return;
5180
5181     ret = AVERROR_INVALIDDATA;
5182     if (uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
5183         goto free_and_return;
5184     if (ffio_init_context(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
5185         goto free_and_return;
5186     ctx.seekable = AVIO_SEEKABLE_NORMAL;
5187     atom.type = MKTAG('m','o','o','v');
5188     atom.size = moov_len;
5189     ret = mov_read_default(c, &ctx, atom);
5190 free_and_return:
5191     av_free(moov_data);
5192     av_free(cmov_data);
5193     return ret;
5194 #else
5195     av_log(c->fc, AV_LOG_ERROR, "this file requires zlib support compiled in\n");
5196     return AVERROR(ENOSYS);
5197 #endif
5198 }
5199
5200 /* edit list atom */
5201 static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5202 {
5203     MOVStreamContext *sc;
5204     int i, edit_count, version;
5205     int64_t elst_entry_size;
5206
5207     if (c->fc->nb_streams < 1 || c->ignore_editlist)
5208         return 0;
5209     sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
5210
5211     version = avio_r8(pb); /* version */
5212     avio_rb24(pb); /* flags */
5213     edit_count = avio_rb32(pb); /* entries */
5214     atom.size -= 8;
5215
5216     elst_entry_size = version == 1 ? 20 : 12;
5217     if (atom.size != edit_count * elst_entry_size) {
5218         if (c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
5219             av_log(c->fc, AV_LOG_ERROR, "Invalid edit list entry_count: %d for elst atom of size: %"PRId64" bytes.\n",
5220                    edit_count, atom.size + 8);
5221             return AVERROR_INVALIDDATA;
5222         } else {
5223             edit_count = atom.size / elst_entry_size;
5224             if (edit_count * elst_entry_size != atom.size) {
5225                 av_log(c->fc, AV_LOG_WARNING, "ELST atom of %"PRId64" bytes, bigger than %d entries.", atom.size, edit_count);
5226             }
5227         }
5228     }
5229
5230     if (!edit_count)
5231         return 0;
5232     if (sc->elst_data)
5233         av_log(c->fc, AV_LOG_WARNING, "Duplicated ELST atom\n");
5234     av_free(sc->elst_data);
5235     sc->elst_count = 0;
5236     sc->elst_data = av_malloc_array(edit_count, sizeof(*sc->elst_data));
5237     if (!sc->elst_data)
5238         return AVERROR(ENOMEM);
5239
5240     av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
5241     for (i = 0; i < edit_count && atom.size > 0 && !pb->eof_reached; i++) {
5242         MOVElst *e = &sc->elst_data[i];
5243
5244         if (version == 1) {
5245             e->duration = avio_rb64(pb);
5246             e->time     = avio_rb64(pb);
5247             atom.size -= 16;
5248         } else {
5249             e->duration = avio_rb32(pb); /* segment duration */
5250             e->time     = (int32_t)avio_rb32(pb); /* media time */
5251             atom.size -= 8;
5252         }
5253         e->rate = avio_rb32(pb) / 65536.0;
5254         atom.size -= 4;
5255         av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
5256                e->duration, e->time, e->rate);
5257
5258         if (e->time < 0 && e->time != -1 &&
5259             c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
5260             av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
5261                    c->fc->nb_streams-1, i, e->time);
5262             return AVERROR_INVALIDDATA;
5263         }
5264     }
5265     sc->elst_count = i;
5266
5267     return 0;
5268 }
5269
5270 static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5271 {
5272     MOVStreamContext *sc;
5273
5274     if (c->fc->nb_streams < 1)
5275         return AVERROR_INVALIDDATA;
5276     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5277     sc->timecode_track = avio_rb32(pb);
5278     return 0;
5279 }
5280
5281 static int mov_read_av1c(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5282 {
5283     AVStream *st;
5284     int ret;
5285
5286     if (c->fc->nb_streams < 1)
5287         return 0;
5288     st = c->fc->streams[c->fc->nb_streams - 1];
5289
5290     if (atom.size < 4) {
5291         av_log(c->fc, AV_LOG_ERROR, "Empty AV1 Codec Configuration Box\n");
5292         return AVERROR_INVALIDDATA;
5293     }
5294
5295     /* For now, propagate only the OBUs, if any. Once libavcodec is
5296        updated to handle isobmff style extradata this can be removed. */
5297     avio_skip(pb, 4);
5298
5299     if (atom.size == 4)
5300         return 0;
5301
5302     ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size - 4);
5303     if (ret < 0)
5304         return ret;
5305
5306     return 0;
5307 }
5308
5309 static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5310 {
5311     AVStream *st;
5312     int version, color_range, color_primaries, color_trc, color_space;
5313
5314     if (c->fc->nb_streams < 1)
5315         return 0;
5316     st = c->fc->streams[c->fc->nb_streams - 1];
5317
5318     if (atom.size < 5) {
5319         av_log(c->fc, AV_LOG_ERROR, "Empty VP Codec Configuration box\n");
5320         return AVERROR_INVALIDDATA;
5321     }
5322
5323     version = avio_r8(pb);
5324     if (version != 1) {
5325         av_log(c->fc, AV_LOG_WARNING, "Unsupported VP Codec Configuration box version %d\n", version);
5326         return 0;
5327     }
5328     avio_skip(pb, 3); /* flags */
5329
5330     avio_skip(pb, 2); /* profile + level */
5331     color_range     = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
5332     color_primaries = avio_r8(pb);
5333     color_trc       = avio_r8(pb);
5334     color_space     = avio_r8(pb);
5335     if (avio_rb16(pb)) /* codecIntializationDataSize */
5336         return AVERROR_INVALIDDATA;
5337
5338     if (!av_color_primaries_name(color_primaries))
5339         color_primaries = AVCOL_PRI_UNSPECIFIED;
5340     if (!av_color_transfer_name(color_trc))
5341         color_trc = AVCOL_TRC_UNSPECIFIED;
5342     if (!av_color_space_name(color_space))
5343         color_space = AVCOL_SPC_UNSPECIFIED;
5344
5345     st->codecpar->color_range     = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
5346     st->codecpar->color_primaries = color_primaries;
5347     st->codecpar->color_trc       = color_trc;
5348     st->codecpar->color_space     = color_space;
5349
5350     return 0;
5351 }
5352
5353 static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5354 {
5355     MOVStreamContext *sc;
5356     int i, version;
5357
5358     if (c->fc->nb_streams < 1)
5359         return AVERROR_INVALIDDATA;
5360
5361     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5362
5363     if (atom.size < 5) {
5364         av_log(c->fc, AV_LOG_ERROR, "Empty Mastering Display Metadata box\n");
5365         return AVERROR_INVALIDDATA;
5366     }
5367
5368     version = avio_r8(pb);
5369     if (version) {
5370         av_log(c->fc, AV_LOG_WARNING, "Unsupported Mastering Display Metadata box version %d\n", version);
5371         return 0;
5372     }
5373     avio_skip(pb, 3); /* flags */
5374
5375     sc->mastering = av_mastering_display_metadata_alloc();
5376     if (!sc->mastering)
5377         return AVERROR(ENOMEM);
5378
5379     for (i = 0; i < 3; i++) {
5380         sc->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), 1 << 16);
5381         sc->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), 1 << 16);
5382     }
5383     sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), 1 << 16);
5384     sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), 1 << 16);
5385
5386     sc->mastering->max_luminance = av_make_q(avio_rb32(pb), 1 << 8);
5387     sc->mastering->min_luminance = av_make_q(avio_rb32(pb), 1 << 14);
5388
5389     sc->mastering->has_primaries = 1;
5390     sc->mastering->has_luminance = 1;
5391
5392     return 0;
5393 }
5394
5395 static int mov_read_mdcv(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5396 {
5397     MOVStreamContext *sc;
5398     const int mapping[3] = {1, 2, 0};
5399     const int chroma_den = 50000;
5400     const int luma_den = 10000;
5401     int i;
5402
5403     if (c->fc->nb_streams < 1)
5404         return AVERROR_INVALIDDATA;
5405
5406     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5407
5408     if (atom.size < 24) {
5409         av_log(c->fc, AV_LOG_ERROR, "Invalid Mastering Display Color Volume box\n");
5410         return AVERROR_INVALIDDATA;
5411     }
5412
5413     sc->mastering = av_mastering_display_metadata_alloc();
5414     if (!sc->mastering)
5415         return AVERROR(ENOMEM);
5416
5417     for (i = 0; i < 3; i++) {
5418         const int j = mapping[i];
5419         sc->mastering->display_primaries[j][0] = av_make_q(avio_rb16(pb), chroma_den);
5420         sc->mastering->display_primaries[j][1] = av_make_q(avio_rb16(pb), chroma_den);
5421     }
5422     sc->mastering->white_point[0] = av_make_q(avio_rb16(pb), chroma_den);
5423     sc->mastering->white_point[1] = av_make_q(avio_rb16(pb), chroma_den);
5424
5425     sc->mastering->max_luminance = av_make_q(avio_rb32(pb), luma_den);
5426     sc->mastering->min_luminance = av_make_q(avio_rb32(pb), luma_den);
5427
5428     sc->mastering->has_luminance = 1;
5429     sc->mastering->has_primaries = 1;
5430
5431     return 0;
5432 }
5433
5434 static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5435 {
5436     MOVStreamContext *sc;
5437     int version;
5438
5439     if (c->fc->nb_streams < 1)
5440         return AVERROR_INVALIDDATA;
5441
5442     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5443
5444     if (atom.size < 5) {
5445         av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level box\n");
5446         return AVERROR_INVALIDDATA;
5447     }
5448
5449     version = avio_r8(pb);
5450     if (version) {
5451         av_log(c->fc, AV_LOG_WARNING, "Unsupported Content Light Level box version %d\n", version);
5452         return 0;
5453     }
5454     avio_skip(pb, 3); /* flags */
5455
5456     sc->coll = av_content_light_metadata_alloc(&sc->coll_size);
5457     if (!sc->coll)
5458         return AVERROR(ENOMEM);
5459
5460     sc->coll->MaxCLL  = avio_rb16(pb);
5461     sc->coll->MaxFALL = avio_rb16(pb);
5462
5463     return 0;
5464 }
5465
5466 static int mov_read_clli(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5467 {
5468     MOVStreamContext *sc;
5469
5470     if (c->fc->nb_streams < 1)
5471         return AVERROR_INVALIDDATA;
5472
5473     sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
5474
5475     if (atom.size < 4) {
5476         av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level Info box\n");
5477         return AVERROR_INVALIDDATA;
5478     }
5479
5480     sc->coll = av_content_light_metadata_alloc(&sc->coll_size);
5481     if (!sc->coll)
5482         return AVERROR(ENOMEM);
5483
5484     sc->coll->MaxCLL  = avio_rb16(pb);
5485     sc->coll->MaxFALL = avio_rb16(pb);
5486
5487     return 0;
5488 }
5489
5490 static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5491 {
5492     AVStream *st;
5493     MOVStreamContext *sc;
5494     enum AVStereo3DType type;
5495     int mode;
5496
5497     if (c->fc->nb_streams < 1)
5498         return 0;
5499
5500     st = c->fc->streams[c->fc->nb_streams - 1];
5501     sc = st->priv_data;
5502
5503     if (atom.size < 5) {
5504         av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
5505         return AVERROR_INVALIDDATA;
5506     }
5507     avio_skip(pb, 4); /* version + flags */
5508
5509     mode = avio_r8(pb);
5510     switch (mode) {
5511     case 0:
5512         type = AV_STEREO3D_2D;
5513         break;
5514     case 1:
5515         type = AV_STEREO3D_TOPBOTTOM;
5516         break;
5517     case 2:
5518         type = AV_STEREO3D_SIDEBYSIDE;
5519         break;
5520     default:
5521         av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
5522         return 0;
5523     }
5524
5525     sc->stereo3d = av_stereo3d_alloc();
5526     if (!sc->stereo3d)
5527         return AVERROR(ENOMEM);
5528
5529     sc->stereo3d->type = type;
5530     return 0;
5531 }
5532
5533 static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5534 {
5535     AVStream *st;
5536     MOVStreamContext *sc;
5537     int size, version, layout;
5538     int32_t yaw, pitch, roll;
5539     uint32_t l = 0, t = 0, r = 0, b = 0;
5540     uint32_t tag, padding = 0;
5541     enum AVSphericalProjection projection;
5542
5543     if (c->fc->nb_streams < 1)
5544         return 0;
5545
5546     st = c->fc->streams[c->fc->nb_streams - 1];
5547     sc = st->priv_data;
5548
5549     if (atom.size < 8) {
5550         av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
5551         return AVERROR_INVALIDDATA;
5552     }
5553
5554     size = avio_rb32(pb);
5555     if (size <= 12 || size > atom.size)
5556         return AVERROR_INVALIDDATA;
5557
5558     tag = avio_rl32(pb);
5559     if (tag != MKTAG('s','v','h','d')) {
5560         av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
5561         return 0;
5562     }
5563     version = avio_r8(pb);
5564     if (version != 0) {
5565         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5566                version);
5567         return 0;
5568     }
5569     avio_skip(pb, 3); /* flags */
5570     avio_skip(pb, size - 12); /* metadata_source */
5571
5572     size = avio_rb32(pb);
5573     if (size > atom.size)
5574         return AVERROR_INVALIDDATA;
5575
5576     tag = avio_rl32(pb);
5577     if (tag != MKTAG('p','r','o','j')) {
5578         av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
5579         return 0;
5580     }
5581
5582     size = avio_rb32(pb);
5583     if (size > atom.size)
5584         return AVERROR_INVALIDDATA;
5585
5586     tag = avio_rl32(pb);
5587     if (tag != MKTAG('p','r','h','d')) {
5588         av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
5589         return 0;
5590     }
5591     version = avio_r8(pb);
5592     if (version != 0) {
5593         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5594                version);
5595         return 0;
5596     }
5597     avio_skip(pb, 3); /* flags */
5598
5599     /* 16.16 fixed point */
5600     yaw   = avio_rb32(pb);
5601     pitch = avio_rb32(pb);
5602     roll  = avio_rb32(pb);
5603
5604     size = avio_rb32(pb);
5605     if (size > atom.size)
5606         return AVERROR_INVALIDDATA;
5607
5608     tag = avio_rl32(pb);
5609     version = avio_r8(pb);
5610     if (version != 0) {
5611         av_log(c->fc, AV_LOG_WARNING, "Unknown spherical version %d\n",
5612                version);
5613         return 0;
5614     }
5615     avio_skip(pb, 3); /* flags */
5616     switch (tag) {
5617     case MKTAG('c','b','m','p'):
5618         layout = avio_rb32(pb);
5619         if (layout) {
5620             av_log(c->fc, AV_LOG_WARNING,
5621                    "Unsupported cubemap layout %d\n", layout);
5622             return 0;
5623         }
5624         projection = AV_SPHERICAL_CUBEMAP;
5625         padding = avio_rb32(pb);
5626         break;
5627     case MKTAG('e','q','u','i'):
5628         t = avio_rb32(pb);
5629         b = avio_rb32(pb);
5630         l = avio_rb32(pb);
5631         r = avio_rb32(pb);
5632
5633         if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
5634             av_log(c->fc, AV_LOG_ERROR,
5635                    "Invalid bounding rectangle coordinates "
5636                    "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
5637             return AVERROR_INVALIDDATA;
5638         }
5639
5640         if (l || t || r || b)
5641             projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
5642         else
5643             projection = AV_SPHERICAL_EQUIRECTANGULAR;
5644         break;
5645     default:
5646         av_log(c->fc, AV_LOG_ERROR, "Unknown projection type: %s\n", av_fourcc2str(tag));
5647         return 0;
5648     }
5649
5650     sc->spherical = av_spherical_alloc(&sc->spherical_size);
5651     if (!sc->spherical)
5652         return AVERROR(ENOMEM);
5653
5654     sc->spherical->projection = projection;
5655
5656     sc->spherical->yaw   = yaw;
5657     sc->spherical->pitch = pitch;
5658     sc->spherical->roll  = roll;
5659
5660     sc->spherical->padding = padding;
5661
5662     sc->spherical->bound_left   = l;
5663     sc->spherical->bound_top    = t;
5664     sc->spherical->bound_right  = r;
5665     sc->spherical->bound_bottom = b;
5666
5667     return 0;
5668 }
5669
5670 static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
5671 {
5672     int ret = 0;
5673     uint8_t *buffer = av_malloc(len + 1);
5674     const char *val;
5675
5676     if (!buffer)
5677         return AVERROR(ENOMEM);
5678     buffer[len] = '\0';
5679
5680     ret = ffio_read_size(pb, buffer, len);
5681     if (ret < 0)
5682         goto out;
5683
5684     /* Check for mandatory keys and values, try to support XML as best-effort */
5685     if (!sc->spherical &&
5686         av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
5687         (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
5688         av_stristr(val, "true") &&
5689         (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
5690         av_stristr(val, "true") &&
5691         (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
5692         av_stristr(val, "equirectangular")) {
5693         sc->spherical = av_spherical_alloc(&sc->spherical_size);
5694         if (!sc->spherical)
5695             goto out;
5696
5697         sc->spherical->projection = AV_SPHERICAL_EQUIRECTANGULAR;
5698
5699         if (av_stristr(buffer, "<GSpherical:StereoMode>") && !sc->stereo3d) {
5700             enum AVStereo3DType mode;
5701
5702             if (av_stristr(buffer, "left-right"))
5703                 mode = AV_STEREO3D_SIDEBYSIDE;
5704             else if (av_stristr(buffer, "top-bottom"))
5705                 mode = AV_STEREO3D_TOPBOTTOM;
5706             else
5707                 mode = AV_STEREO3D_2D;
5708
5709             sc->stereo3d = av_stereo3d_alloc();
5710             if (!sc->stereo3d)
5711                 goto out;
5712
5713             sc->stereo3d->type = mode;
5714         }
5715
5716         /* orientation */
5717         val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
5718         if (val)
5719             sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
5720         val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
5721         if (val)
5722             sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
5723         val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
5724         if (val)
5725             sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
5726     }
5727
5728 out:
5729     av_free(buffer);
5730     return ret;
5731 }
5732
5733 static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5734 {
5735     AVStream *st;
5736     MOVStreamContext *sc;
5737     int64_t ret;
5738     uint8_t uuid[16];
5739     static const uint8_t uuid_isml_manifest[] = {
5740         0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
5741         0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
5742     };
5743     static const uint8_t uuid_xmp[] = {
5744         0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
5745         0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
5746     };
5747     static const uint8_t uuid_spherical[] = {
5748         0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
5749         0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
5750     };
5751
5752     if (atom.size < sizeof(uuid) || atom.size >= FFMIN(INT_MAX, SIZE_MAX))
5753         return AVERROR_INVALIDDATA;
5754
5755     if (c->fc->nb_streams < 1)
5756         return 0;
5757     st = c->fc->streams[c->fc->nb_streams - 1];
5758     sc = st->priv_data;
5759
5760     ret = ffio_read_size(pb, uuid, sizeof(uuid));
5761     if (ret < 0)
5762         return ret;
5763     if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
5764         uint8_t *buffer, *ptr;
5765         char *endptr;
5766         size_t len = atom.size - sizeof(uuid);
5767
5768         if (len < 4) {
5769             return AVERROR_INVALIDDATA;
5770         }
5771         ret = avio_skip(pb, 4); // zeroes
5772         len -= 4;
5773
5774         buffer = av_mallocz(len + 1);
5775         if (!buffer) {
5776             return AVERROR(ENOMEM);
5777         }
5778         ret = ffio_read_size(pb, buffer, len);
5779         if (ret < 0) {
5780             av_free(buffer);
5781             return ret;
5782         }
5783
5784         ptr = buffer;
5785         while ((ptr = av_stristr(ptr, "systemBitrate=\""))) {
5786             ptr += sizeof("systemBitrate=\"") - 1;
5787             c->bitrates_count++;
5788             c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
5789             if (!c->bitrates) {
5790                 c->bitrates_count = 0;
5791                 av_free(buffer);
5792                 return AVERROR(ENOMEM);
5793             }
5794             errno = 0;
5795             ret = strtol(ptr, &endptr, 10);
5796             if (ret < 0 || errno || *endptr != '"') {
5797                 c->bitrates[c->bitrates_count - 1] = 0;
5798             } else {
5799                 c->bitrates[c->bitrates_count - 1] = ret;
5800             }
5801         }
5802
5803         av_free(buffer);
5804     } else if (!memcmp(uuid, uuid_xmp, sizeof(uuid))) {
5805         uint8_t *buffer;
5806         size_t len = atom.size - sizeof(uuid);
5807         if (c->export_xmp) {
5808             buffer = av_mallocz(len + 1);
5809             if (!buffer) {
5810                 return AVERROR(ENOMEM);
5811             }
5812             ret = ffio_read_size(pb, buffer, len);
5813             if (ret < 0) {
5814                 av_free(buffer);
5815                 return ret;
5816             }
5817             buffer[len] = '\0';
5818             av_dict_set(&c->fc->metadata, "xmp",
5819                         buffer, AV_DICT_DONT_STRDUP_VAL);
5820         } else {
5821             // skip all uuid atom, which makes it fast for long uuid-xmp file
5822             ret = avio_skip(pb, len);
5823             if (ret < 0)
5824                 return ret;
5825         }
5826     } else if (!memcmp(uuid, uuid_spherical, sizeof(uuid))) {
5827         size_t len = atom.size - sizeof(uuid);
5828         ret = mov_parse_uuid_spherical(sc, pb, len);
5829         if (ret < 0)
5830             return ret;
5831         if (!sc->spherical)
5832             av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");
5833     }
5834
5835     return 0;
5836 }
5837
5838 static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5839 {
5840     int ret;
5841     uint8_t content[16];
5842
5843     if (atom.size < 8)
5844         return 0;
5845
5846     ret = avio_read(pb, content, FFMIN(sizeof(content), atom.size));
5847     if (ret < 0)
5848         return ret;
5849
5850     if (   !c->found_moov
5851         && !c->found_mdat
5852         && !memcmp(content, "Anevia\x1A\x1A", 8)
5853         && c->use_mfra_for == FF_MOV_FLAG_MFRA_AUTO) {
5854         c->use_mfra_for = FF_MOV_FLAG_MFRA_PTS;
5855     }
5856
5857     return 0;
5858 }
5859
5860 static int mov_read_frma(MOVContext *c, AVIOContext *pb, MOVAtom atom)
5861 {
5862     uint32_t format = avio_rl32(pb);
5863     MOVStreamContext *sc;
5864     enum AVCodecID id;
5865     AVStream *st;
5866
5867     if (c->fc->nb_streams < 1)
5868         return 0;
5869     st = c->fc->streams[c->fc->nb_streams - 1];
5870     sc = st->priv_data;
5871
5872     switch (sc->format)
5873     {
5874     case MKTAG('e','n','c','v'):        // encrypted video
5875     case MKTAG('e','n','c','a'):        // encrypted audio
5876         id = mov_codec_id(st, format);
5877         if (st->codecpar->codec_id != AV_CODEC_ID_NONE &&
5878             st->codecpar->codec_id != id) {
5879             av_log(c->fc, AV_LOG_WARNING,
5880                    "ignoring 'frma' atom of '%.4s', stream has codec id %d\n",
5881                    (char*)&format, st->codecpar->codec_id);
5882             break;
5883         }
5884
5885         st->codecpar->codec_id = id;
5886         sc->format = format;
5887         break;
5888
5889     default:
5890         if (format != sc->format) {
5891             av_log(c->fc, AV_LOG_WARNING,
5892                    "ignoring 'frma' atom of '%.4s', stream format is '%.4s'\n",
5893                    (char*)&format, (char*)&sc->format);
5894         }
5895         break;
5896     }
5897
5898     return 0;
5899 }
5900
5901 /**
5902  * Gets the current encryption info and associated current stream context.  If
5903  * we are parsing a track fragment, this will return the specific encryption
5904  * info for this fragment; otherwise this will return the global encryption
5905  * info for the current stream.
5906  */
5907 static int get_current_encryption_info(MOVContext *c, MOVEncryptionIndex **encryption_index, MOVStreamContext **sc)
5908 {
5909     MOVFragmentStreamInfo *frag_stream_info;
5910     AVStream *st;
5911     int i;
5912
5913     frag_stream_info = get_current_frag_stream_info(&c->frag_index);
5914     if (frag_stream_info) {
5915         for (i = 0; i < c->fc->nb_streams; i++) {
5916             if (c->fc->streams[i]->id == frag_stream_info->id) {
5917               st = c->fc->streams[i];
5918               break;
5919             }
5920         }
5921         if (i == c->fc->nb_streams)
5922             return 0;
5923         *sc = st->priv_data;
5924
5925         if (!frag_stream_info->encryption_index) {
5926             // If this stream isn't encrypted, don't create the index.
5927             if (!(*sc)->cenc.default_encrypted_sample)
5928                 return 0;
5929             frag_stream_info->encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5930             if (!frag_stream_info->encryption_index)
5931                 return AVERROR(ENOMEM);
5932         }
5933         *encryption_index = frag_stream_info->encryption_index;
5934         return 1;
5935     } else {
5936         // No current track fragment, using stream level encryption info.
5937
5938         if (c->fc->nb_streams < 1)
5939             return 0;
5940         st = c->fc->streams[c->fc->nb_streams - 1];
5941         *sc = st->priv_data;
5942
5943         if (!(*sc)->cenc.encryption_index) {
5944             // If this stream isn't encrypted, don't create the index.
5945             if (!(*sc)->cenc.default_encrypted_sample)
5946                 return 0;
5947             (*sc)->cenc.encryption_index = av_mallocz(sizeof(*frag_stream_info->encryption_index));
5948             if (!(*sc)->cenc.encryption_index)
5949                 return AVERROR(ENOMEM);
5950         }
5951
5952         *encryption_index = (*sc)->cenc.encryption_index;
5953         return 1;
5954     }
5955 }
5956
5957 static int mov_read_sample_encryption_info(MOVContext *c, AVIOContext *pb, MOVStreamContext *sc, AVEncryptionInfo **sample, int use_subsamples)
5958 {
5959     int i, ret;
5960     unsigned int subsample_count;
5961     AVSubsampleEncryptionInfo *subsamples;
5962
5963     if (!sc->cenc.default_encrypted_sample) {
5964         av_log(c->fc, AV_LOG_ERROR, "Missing schm or tenc\n");
5965         return AVERROR_INVALIDDATA;
5966     }
5967
5968     *sample = av_encryption_info_clone(sc->cenc.default_encrypted_sample);
5969     if (!*sample)
5970         return AVERROR(ENOMEM);
5971
5972     if (sc->cenc.per_sample_iv_size != 0) {
5973         if ((ret = ffio_read_size(pb, (*sample)->iv, sc->cenc.per_sample_iv_size)) < 0) {
5974             av_log(c->fc, AV_LOG_ERROR, "failed to read the initialization vector\n");
5975             av_encryption_info_free(*sample);
5976             *sample = NULL;
5977             return ret;
5978         }
5979     }
5980
5981     if (use_subsamples) {
5982         subsample_count = avio_rb16(pb);
5983         av_free((*sample)->subsamples);
5984         (*sample)->subsamples = av_mallocz_array(subsample_count, sizeof(*subsamples));
5985         if (!(*sample)->subsamples) {
5986             av_encryption_info_free(*sample);
5987             *sample = NULL;
5988             return AVERROR(ENOMEM);
5989         }
5990
5991         for (i = 0; i < subsample_count && !pb->eof_reached; i++) {
5992             (*sample)->subsamples[i].bytes_of_clear_data = avio_rb16(pb);
5993             (*sample)->subsamples[i].bytes_of_protected_data = avio_rb32(pb);
5994         }
5995
5996         if (pb->eof_reached) {
5997             av_log(c->fc, AV_LOG_ERROR, "hit EOF while reading sub-sample encryption info\n");
5998             av_encryption_info_free(*sample);
5999             *sample = NULL;
6000             return AVERROR_INVALIDDATA;
6001         }
6002         (*sample)->subsample_count = subsample_count;
6003     }
6004
6005     return 0;
6006 }
6007
6008 static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6009 {
6010     AVEncryptionInfo **encrypted_samples;
6011     MOVEncryptionIndex *encryption_index;
6012     MOVStreamContext *sc;
6013     int use_subsamples, ret;
6014     unsigned int sample_count, i, alloc_size = 0;
6015
6016     ret = get_current_encryption_info(c, &encryption_index, &sc);
6017     if (ret != 1)
6018         return ret;
6019
6020     if (encryption_index->nb_encrypted_samples) {
6021         // This can happen if we have both saio/saiz and senc atoms.
6022         av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in senc\n");
6023         return 0;
6024     }
6025
6026     avio_r8(pb); /* version */
6027     use_subsamples = avio_rb24(pb) & 0x02; /* flags */
6028
6029     sample_count = avio_rb32(pb);
6030     if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6031         return AVERROR(ENOMEM);
6032
6033     for (i = 0; i < sample_count; i++) {
6034         unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6035         encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6036                                             min_samples * sizeof(*encrypted_samples));
6037         if (encrypted_samples) {
6038             encryption_index->encrypted_samples = encrypted_samples;
6039
6040             ret = mov_read_sample_encryption_info(
6041                 c, pb, sc, &encryption_index->encrypted_samples[i], use_subsamples);
6042         } else {
6043             ret = AVERROR(ENOMEM);
6044         }
6045         if (pb->eof_reached) {
6046             av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading senc\n");
6047             ret = AVERROR_INVALIDDATA;
6048         }
6049
6050         if (ret < 0) {
6051             for (; i > 0; i--)
6052                 av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6053             av_freep(&encryption_index->encrypted_samples);
6054             return ret;
6055         }
6056     }
6057     encryption_index->nb_encrypted_samples = sample_count;
6058
6059     return 0;
6060 }
6061
6062 static int mov_parse_auxiliary_info(MOVContext *c, MOVStreamContext *sc, AVIOContext *pb, MOVEncryptionIndex *encryption_index)
6063 {
6064     AVEncryptionInfo **sample, **encrypted_samples;
6065     int64_t prev_pos;
6066     size_t sample_count, sample_info_size, i;
6067     int ret = 0;
6068     unsigned int alloc_size = 0;
6069
6070     if (encryption_index->nb_encrypted_samples)
6071         return 0;
6072     sample_count = encryption_index->auxiliary_info_sample_count;
6073     if (encryption_index->auxiliary_offsets_count != 1) {
6074         av_log(c->fc, AV_LOG_ERROR, "Multiple auxiliary info chunks are not supported\n");
6075         return AVERROR_PATCHWELCOME;
6076     }
6077     if (sample_count >= INT_MAX / sizeof(*encrypted_samples))
6078         return AVERROR(ENOMEM);
6079
6080     prev_pos = avio_tell(pb);
6081     if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
6082         avio_seek(pb, encryption_index->auxiliary_offsets[0], SEEK_SET) != encryption_index->auxiliary_offsets[0]) {
6083         av_log(c->fc, AV_LOG_INFO, "Failed to seek for auxiliary info, will only parse senc atoms for encryption info\n");
6084         goto finish;
6085     }
6086
6087     for (i = 0; i < sample_count && !pb->eof_reached; i++) {
6088         unsigned int min_samples = FFMIN(FFMAX(i + 1, 1024 * 1024), sample_count);
6089         encrypted_samples = av_fast_realloc(encryption_index->encrypted_samples, &alloc_size,
6090                                             min_samples * sizeof(*encrypted_samples));
6091         if (!encrypted_samples) {
6092             ret = AVERROR(ENOMEM);
6093             goto finish;
6094         }
6095         encryption_index->encrypted_samples = encrypted_samples;
6096
6097         sample = &encryption_index->encrypted_samples[i];
6098         sample_info_size = encryption_index->auxiliary_info_default_size
6099                                ? encryption_index->auxiliary_info_default_size
6100                                : encryption_index->auxiliary_info_sizes[i];
6101
6102         ret = mov_read_sample_encryption_info(c, pb, sc, sample, sample_info_size > sc->cenc.per_sample_iv_size);
6103         if (ret < 0)
6104             goto finish;
6105     }
6106     if (pb->eof_reached) {
6107         av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading auxiliary info\n");
6108         ret = AVERROR_INVALIDDATA;
6109     } else {
6110         encryption_index->nb_encrypted_samples = sample_count;
6111     }
6112
6113 finish:
6114     avio_seek(pb, prev_pos, SEEK_SET);
6115     if (ret < 0) {
6116         for (; i > 0; i--) {
6117             av_encryption_info_free(encryption_index->encrypted_samples[i - 1]);
6118         }
6119         av_freep(&encryption_index->encrypted_samples);
6120     }
6121     return ret;
6122 }
6123
6124 /**
6125  * Tries to read the given number of bytes from the stream and puts it in a
6126  * newly allocated buffer.  This reads in small chunks to avoid allocating large
6127  * memory if the file contains an invalid/malicious size value.
6128  */
6129 static int mov_try_read_block(AVIOContext *pb, size_t size, uint8_t **data)
6130 {
6131     const unsigned int block_size = 1024 * 1024;
6132     uint8_t *buffer = NULL;
6133     unsigned int alloc_size = 0, offset = 0;
6134     while (offset < size) {
6135         unsigned int new_size =
6136             alloc_size >= INT_MAX - block_size ? INT_MAX : alloc_size + block_size;
6137         uint8_t *new_buffer = av_fast_realloc(buffer, &alloc_size, new_size);
6138         unsigned int to_read = FFMIN(size, alloc_size) - offset;
6139         if (!new_buffer) {
6140             av_free(buffer);
6141             return AVERROR(ENOMEM);
6142         }
6143         buffer = new_buffer;
6144
6145         if (avio_read(pb, buffer + offset, to_read) != to_read) {
6146             av_free(buffer);
6147             return AVERROR_INVALIDDATA;
6148         }
6149         offset += to_read;
6150     }
6151
6152     *data = buffer;
6153     return 0;
6154 }
6155
6156 static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6157 {
6158     MOVEncryptionIndex *encryption_index;
6159     MOVStreamContext *sc;
6160     int ret;
6161     unsigned int sample_count, aux_info_type, aux_info_param;
6162
6163     ret = get_current_encryption_info(c, &encryption_index, &sc);
6164     if (ret != 1)
6165         return ret;
6166
6167     if (encryption_index->nb_encrypted_samples) {
6168         // This can happen if we have both saio/saiz and senc atoms.
6169         av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saiz\n");
6170         return 0;
6171     }
6172
6173     if (encryption_index->auxiliary_info_sample_count) {
6174         av_log(c->fc, AV_LOG_ERROR, "Duplicate saiz atom\n");
6175         return AVERROR_INVALIDDATA;
6176     }
6177
6178     avio_r8(pb); /* version */
6179     if (avio_rb24(pb) & 0x01) {  /* flags */
6180         aux_info_type = avio_rb32(pb);
6181         aux_info_param = avio_rb32(pb);
6182         if (sc->cenc.default_encrypted_sample) {
6183             if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6184                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type\n");
6185                 return 0;
6186             }
6187             if (aux_info_param != 0) {
6188                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saiz box with non-zero aux_info_type_parameter\n");
6189                 return 0;
6190             }
6191         } else {
6192             // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6193             if ((aux_info_type == MKBETAG('c','e','n','c') ||
6194                  aux_info_type == MKBETAG('c','e','n','s') ||
6195                  aux_info_type == MKBETAG('c','b','c','1') ||
6196                  aux_info_type == MKBETAG('c','b','c','s')) &&
6197                 aux_info_param == 0) {
6198                 av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saiz without schm/tenc\n");
6199                 return AVERROR_INVALIDDATA;
6200             } else {
6201                 return 0;
6202             }
6203         }
6204     } else if (!sc->cenc.default_encrypted_sample) {
6205         // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6206         return 0;
6207     }
6208
6209     encryption_index->auxiliary_info_default_size = avio_r8(pb);
6210     sample_count = avio_rb32(pb);
6211     encryption_index->auxiliary_info_sample_count = sample_count;
6212
6213     if (encryption_index->auxiliary_info_default_size == 0) {
6214         ret = mov_try_read_block(pb, sample_count, &encryption_index->auxiliary_info_sizes);
6215         if (ret < 0) {
6216             av_log(c->fc, AV_LOG_ERROR, "Failed to read the auxiliary info\n");
6217             return ret;
6218         }
6219     }
6220
6221     if (encryption_index->auxiliary_offsets_count) {
6222         return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6223     }
6224
6225     return 0;
6226 }
6227
6228 static int mov_read_saio(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6229 {
6230     uint64_t *auxiliary_offsets;
6231     MOVEncryptionIndex *encryption_index;
6232     MOVStreamContext *sc;
6233     int i, ret;
6234     unsigned int version, entry_count, aux_info_type, aux_info_param;
6235     unsigned int alloc_size = 0;
6236
6237     ret = get_current_encryption_info(c, &encryption_index, &sc);
6238     if (ret != 1)
6239         return ret;
6240
6241     if (encryption_index->nb_encrypted_samples) {
6242         // This can happen if we have both saio/saiz and senc atoms.
6243         av_log(c->fc, AV_LOG_DEBUG, "Ignoring duplicate encryption info in saio\n");
6244         return 0;
6245     }
6246
6247     if (encryption_index->auxiliary_offsets_count) {
6248         av_log(c->fc, AV_LOG_ERROR, "Duplicate saio atom\n");
6249         return AVERROR_INVALIDDATA;
6250     }
6251
6252     version = avio_r8(pb); /* version */
6253     if (avio_rb24(pb) & 0x01) {  /* flags */
6254         aux_info_type = avio_rb32(pb);
6255         aux_info_param = avio_rb32(pb);
6256         if (sc->cenc.default_encrypted_sample) {
6257             if (aux_info_type != sc->cenc.default_encrypted_sample->scheme) {
6258                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type\n");
6259                 return 0;
6260             }
6261             if (aux_info_param != 0) {
6262                 av_log(c->fc, AV_LOG_DEBUG, "Ignoring saio box with non-zero aux_info_type_parameter\n");
6263                 return 0;
6264             }
6265         } else {
6266             // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6267             if ((aux_info_type == MKBETAG('c','e','n','c') ||
6268                  aux_info_type == MKBETAG('c','e','n','s') ||
6269                  aux_info_type == MKBETAG('c','b','c','1') ||
6270                  aux_info_type == MKBETAG('c','b','c','s')) &&
6271                 aux_info_param == 0) {
6272                 av_log(c->fc, AV_LOG_ERROR, "Saw encrypted saio without schm/tenc\n");
6273                 return AVERROR_INVALIDDATA;
6274             } else {
6275                 return 0;
6276             }
6277         }
6278     } else if (!sc->cenc.default_encrypted_sample) {
6279         // Didn't see 'schm' or 'tenc', so this isn't encrypted.
6280         return 0;
6281     }
6282
6283     entry_count = avio_rb32(pb);
6284     if (entry_count >= INT_MAX / sizeof(*auxiliary_offsets))
6285         return AVERROR(ENOMEM);
6286
6287     for (i = 0; i < entry_count && !pb->eof_reached; i++) {
6288         unsigned int min_offsets = FFMIN(FFMAX(i + 1, 1024), entry_count);
6289         auxiliary_offsets = av_fast_realloc(
6290             encryption_index->auxiliary_offsets, &alloc_size,
6291             min_offsets * sizeof(*auxiliary_offsets));
6292         if (!auxiliary_offsets) {
6293             av_freep(&encryption_index->auxiliary_offsets);
6294             return AVERROR(ENOMEM);
6295         }
6296         encryption_index->auxiliary_offsets = auxiliary_offsets;
6297
6298         if (version == 0) {
6299             encryption_index->auxiliary_offsets[i] = avio_rb32(pb);
6300         } else {
6301             encryption_index->auxiliary_offsets[i] = avio_rb64(pb);
6302         }
6303         if (c->frag_index.current >= 0) {
6304             encryption_index->auxiliary_offsets[i] += c->fragment.base_data_offset;
6305         }
6306     }
6307
6308     if (pb->eof_reached) {
6309         av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading saio\n");
6310         av_freep(&encryption_index->auxiliary_offsets);
6311         return AVERROR_INVALIDDATA;
6312     }
6313
6314     encryption_index->auxiliary_offsets_count = entry_count;
6315
6316     if (encryption_index->auxiliary_info_sample_count) {
6317         return mov_parse_auxiliary_info(c, sc, pb, encryption_index);
6318     }
6319
6320     return 0;
6321 }
6322
6323 static int mov_read_pssh(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6324 {
6325     AVEncryptionInitInfo *info, *old_init_info;
6326     uint8_t **key_ids;
6327     AVStream *st;
6328     uint8_t *side_data, *extra_data, *old_side_data;
6329     size_t side_data_size;
6330     int ret = 0, old_side_data_size;
6331     unsigned int version, kid_count, extra_data_size, alloc_size = 0;
6332
6333     if (c->fc->nb_streams < 1)
6334         return 0;
6335     st = c->fc->streams[c->fc->nb_streams-1];
6336
6337     version = avio_r8(pb); /* version */
6338     avio_rb24(pb);  /* flags */
6339
6340     info = av_encryption_init_info_alloc(/* system_id_size */ 16, /* num_key_ids */ 0,
6341                                          /* key_id_size */ 16, /* data_size */ 0);
6342     if (!info)
6343         return AVERROR(ENOMEM);
6344
6345     if ((ret = ffio_read_size(pb, info->system_id, 16)) < 0) {
6346         av_log(c->fc, AV_LOG_ERROR, "Failed to read the system id\n");
6347         goto finish;
6348     }
6349
6350     if (version > 0) {
6351         kid_count = avio_rb32(pb);
6352         if (kid_count >= INT_MAX / sizeof(*key_ids)) {
6353             ret = AVERROR(ENOMEM);
6354             goto finish;
6355         }
6356
6357         for (unsigned int i = 0; i < kid_count && !pb->eof_reached; i++) {
6358             unsigned int min_kid_count = FFMIN(FFMAX(i + 1, 1024), kid_count);
6359             key_ids = av_fast_realloc(info->key_ids, &alloc_size,
6360                                       min_kid_count * sizeof(*key_ids));
6361             if (!key_ids) {
6362                 ret = AVERROR(ENOMEM);
6363                 goto finish;
6364             }
6365             info->key_ids = key_ids;
6366
6367             info->key_ids[i] = av_mallocz(16);
6368             if (!info->key_ids[i]) {
6369                 ret = AVERROR(ENOMEM);
6370                 goto finish;
6371             }
6372             info->num_key_ids = i + 1;
6373
6374             if ((ret = ffio_read_size(pb, info->key_ids[i], 16)) < 0) {
6375                 av_log(c->fc, AV_LOG_ERROR, "Failed to read the key id\n");
6376                 goto finish;
6377             }
6378         }
6379
6380         if (pb->eof_reached) {
6381             av_log(c->fc, AV_LOG_ERROR, "Hit EOF while reading pssh\n");
6382             ret = AVERROR_INVALIDDATA;
6383             goto finish;
6384         }
6385     }
6386
6387     extra_data_size = avio_rb32(pb);
6388     ret = mov_try_read_block(pb, extra_data_size, &extra_data);
6389     if (ret < 0)
6390         goto finish;
6391
6392     av_freep(&info->data);  // malloc(0) may still allocate something.
6393     info->data = extra_data;
6394     info->data_size = extra_data_size;
6395
6396     // If there is existing initialization data, append to the list.
6397     old_side_data = av_stream_get_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &old_side_data_size);
6398     if (old_side_data) {
6399         old_init_info = av_encryption_init_info_get_side_data(old_side_data, old_side_data_size);
6400         if (old_init_info) {
6401             // Append to the end of the list.
6402             for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
6403                 if (!cur->next) {
6404                     cur->next = info;
6405                     break;
6406                 }
6407             }
6408             info = old_init_info;
6409         } else {
6410             // Assume existing side-data will be valid, so the only error we could get is OOM.
6411             ret = AVERROR(ENOMEM);
6412             goto finish;
6413         }
6414     }
6415
6416     side_data = av_encryption_init_info_add_side_data(info, &side_data_size);
6417     if (!side_data) {
6418         ret = AVERROR(ENOMEM);
6419         goto finish;
6420     }
6421     ret = av_stream_add_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO,
6422                                   side_data, side_data_size);
6423     if (ret < 0)
6424         av_free(side_data);
6425
6426 finish:
6427     av_encryption_init_info_free(info);
6428     return ret;
6429 }
6430
6431 static int mov_read_schm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6432 {
6433     AVStream *st;
6434     MOVStreamContext *sc;
6435
6436     if (c->fc->nb_streams < 1)
6437         return 0;
6438     st = c->fc->streams[c->fc->nb_streams-1];
6439     sc = st->priv_data;
6440
6441     if (sc->pseudo_stream_id != 0) {
6442         av_log(c->fc, AV_LOG_ERROR, "schm boxes are only supported in first sample descriptor\n");
6443         return AVERROR_PATCHWELCOME;
6444     }
6445
6446     if (atom.size < 8)
6447         return AVERROR_INVALIDDATA;
6448
6449     avio_rb32(pb); /* version and flags */
6450
6451     if (!sc->cenc.default_encrypted_sample) {
6452         sc->cenc.default_encrypted_sample = av_encryption_info_alloc(0, 16, 16);
6453         if (!sc->cenc.default_encrypted_sample) {
6454             return AVERROR(ENOMEM);
6455         }
6456     }
6457
6458     sc->cenc.default_encrypted_sample->scheme = avio_rb32(pb);
6459     return 0;
6460 }
6461
6462 static int mov_read_tenc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6463 {
6464     AVStream *st;
6465     MOVStreamContext *sc;
6466     unsigned int version, pattern, is_protected, iv_size;
6467
6468     if (c->fc->nb_streams < 1)
6469         return 0;
6470     st = c->fc->streams[c->fc->nb_streams-1];
6471     sc = st->priv_data;
6472
6473     if (sc->pseudo_stream_id != 0) {
6474         av_log(c->fc, AV_LOG_ERROR, "tenc atom are only supported in first sample descriptor\n");
6475         return AVERROR_PATCHWELCOME;
6476     }
6477
6478     if (!sc->cenc.default_encrypted_sample) {
6479         sc->cenc.default_encrypted_sample = av_encryption_info_alloc(0, 16, 16);
6480         if (!sc->cenc.default_encrypted_sample) {
6481             return AVERROR(ENOMEM);
6482         }
6483     }
6484
6485     if (atom.size < 20)
6486         return AVERROR_INVALIDDATA;
6487
6488     version = avio_r8(pb); /* version */
6489     avio_rb24(pb); /* flags */
6490
6491     avio_r8(pb); /* reserved */
6492     pattern = avio_r8(pb);
6493
6494     if (version > 0) {
6495         sc->cenc.default_encrypted_sample->crypt_byte_block = pattern >> 4;
6496         sc->cenc.default_encrypted_sample->skip_byte_block = pattern & 0xf;
6497     }
6498
6499     is_protected = avio_r8(pb);
6500     if (is_protected && !sc->cenc.encryption_index) {
6501         // The whole stream should be by-default encrypted.
6502         sc->cenc.encryption_index = av_mallocz(sizeof(MOVEncryptionIndex));
6503         if (!sc->cenc.encryption_index)
6504             return AVERROR(ENOMEM);
6505     }
6506     sc->cenc.per_sample_iv_size = avio_r8(pb);
6507     if (sc->cenc.per_sample_iv_size != 0 && sc->cenc.per_sample_iv_size != 8 &&
6508         sc->cenc.per_sample_iv_size != 16) {
6509         av_log(c->fc, AV_LOG_ERROR, "invalid per-sample IV size value\n");
6510         return AVERROR_INVALIDDATA;
6511     }
6512     if (avio_read(pb, sc->cenc.default_encrypted_sample->key_id, 16) != 16) {
6513         av_log(c->fc, AV_LOG_ERROR, "failed to read the default key ID\n");
6514         return AVERROR_INVALIDDATA;
6515     }
6516
6517     if (is_protected && !sc->cenc.per_sample_iv_size) {
6518         iv_size = avio_r8(pb);
6519         if (iv_size != 8 && iv_size != 16) {
6520             av_log(c->fc, AV_LOG_ERROR, "invalid default_constant_IV_size in tenc atom\n");
6521             return AVERROR_INVALIDDATA;
6522         }
6523
6524         if (avio_read(pb, sc->cenc.default_encrypted_sample->iv, iv_size) != iv_size) {
6525             av_log(c->fc, AV_LOG_ERROR, "failed to read the default IV\n");
6526             return AVERROR_INVALIDDATA;
6527         }
6528     }
6529
6530     return 0;
6531 }
6532
6533 static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6534 {
6535     AVStream *st;
6536     int last, type, size, ret;
6537     uint8_t buf[4];
6538
6539     if (c->fc->nb_streams < 1)
6540         return 0;
6541     st = c->fc->streams[c->fc->nb_streams-1];
6542
6543     if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
6544         return AVERROR_INVALIDDATA;
6545
6546     /* Check FlacSpecificBox version. */
6547     if (avio_r8(pb) != 0)
6548         return AVERROR_INVALIDDATA;
6549
6550     avio_rb24(pb); /* Flags */
6551
6552     avio_read(pb, buf, sizeof(buf));
6553     flac_parse_block_header(buf, &last, &type, &size);
6554
6555     if (type != FLAC_METADATA_TYPE_STREAMINFO || size != FLAC_STREAMINFO_SIZE) {
6556         av_log(c->fc, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
6557         return AVERROR_INVALIDDATA;
6558     }
6559
6560     ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
6561     if (ret < 0)
6562         return ret;
6563
6564     if (!last)
6565         av_log(c->fc, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
6566
6567     return 0;
6568 }
6569
6570 static int cenc_decrypt(MOVContext *c, MOVStreamContext *sc, AVEncryptionInfo *sample, uint8_t *input, int size)
6571 {
6572     int i, ret;
6573
6574     if (sample->scheme != MKBETAG('c','e','n','c') || sample->crypt_byte_block != 0 || sample->skip_byte_block != 0) {
6575         av_log(c->fc, AV_LOG_ERROR, "Only the 'cenc' encryption scheme is supported\n");
6576         return AVERROR_PATCHWELCOME;
6577     }
6578
6579     if (!sc->cenc.aes_ctr) {
6580         /* initialize the cipher */
6581         sc->cenc.aes_ctr = av_aes_ctr_alloc();
6582         if (!sc->cenc.aes_ctr) {
6583             return AVERROR(ENOMEM);
6584         }
6585
6586         ret = av_aes_ctr_init(sc->cenc.aes_ctr, c->decryption_key);
6587         if (ret < 0) {
6588             return ret;
6589         }
6590     }
6591
6592     av_aes_ctr_set_full_iv(sc->cenc.aes_ctr, sample->iv);
6593
6594     if (!sample->subsample_count)
6595     {
6596         /* decrypt the whole packet */
6597         av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, size);
6598         return 0;
6599     }
6600
6601     for (i = 0; i < sample->subsample_count; i++)
6602     {
6603         if (sample->subsamples[i].bytes_of_clear_data + sample->subsamples[i].bytes_of_protected_data > size) {
6604             av_log(c->fc, AV_LOG_ERROR, "subsample size exceeds the packet size left\n");
6605             return AVERROR_INVALIDDATA;
6606         }
6607
6608         /* skip the clear bytes */
6609         input += sample->subsamples[i].bytes_of_clear_data;
6610         size -= sample->subsamples[i].bytes_of_clear_data;
6611
6612         /* decrypt the encrypted bytes */
6613         av_aes_ctr_crypt(sc->cenc.aes_ctr, input, input, sample->subsamples[i].bytes_of_protected_data);
6614         input += sample->subsamples[i].bytes_of_protected_data;
6615         size -= sample->subsamples[i].bytes_of_protected_data;
6616     }
6617
6618     if (size > 0) {
6619         av_log(c->fc, AV_LOG_ERROR, "leftover packet bytes after subsample processing\n");
6620         return AVERROR_INVALIDDATA;
6621     }
6622
6623     return 0;
6624 }
6625
6626 static int cenc_filter(MOVContext *mov, AVStream* st, MOVStreamContext *sc, AVPacket *pkt, int current_index)
6627 {
6628     MOVFragmentStreamInfo *frag_stream_info;
6629     MOVEncryptionIndex *encryption_index;
6630     AVEncryptionInfo *encrypted_sample;
6631     int encrypted_index, ret;
6632
6633     frag_stream_info = get_frag_stream_info(&mov->frag_index, mov->frag_index.current, st->id);
6634     encrypted_index = current_index;
6635     encryption_index = NULL;
6636     if (frag_stream_info) {
6637         // Note this only supports encryption info in the first sample descriptor.
6638         if (mov->fragment.stsd_id == 1) {
6639             if (frag_stream_info->encryption_index) {
6640                 encrypted_index = current_index - frag_stream_info->index_entry;
6641                 encryption_index = frag_stream_info->encryption_index;
6642             } else {
6643                 encryption_index = sc->cenc.encryption_index;
6644             }
6645         }
6646     } else {
6647         encryption_index = sc->cenc.encryption_index;
6648     }
6649
6650     if (encryption_index) {
6651         if (encryption_index->auxiliary_info_sample_count &&
6652             !encryption_index->nb_encrypted_samples) {
6653             av_log(mov->fc, AV_LOG_ERROR, "saiz atom found without saio\n");
6654             return AVERROR_INVALIDDATA;
6655         }
6656         if (encryption_index->auxiliary_offsets_count &&
6657             !encryption_index->nb_encrypted_samples) {
6658             av_log(mov->fc, AV_LOG_ERROR, "saio atom found without saiz\n");
6659             return AVERROR_INVALIDDATA;
6660         }
6661
6662         if (!encryption_index->nb_encrypted_samples) {
6663             // Full-sample encryption with default settings.
6664             encrypted_sample = sc->cenc.default_encrypted_sample;
6665         } else if (encrypted_index >= 0 && encrypted_index < encryption_index->nb_encrypted_samples) {
6666             // Per-sample setting override.
6667             encrypted_sample = encryption_index->encrypted_samples[encrypted_index];
6668         } else {
6669             av_log(mov->fc, AV_LOG_ERROR, "Incorrect number of samples in encryption info\n");
6670             return AVERROR_INVALIDDATA;
6671         }
6672
6673         if (mov->decryption_key) {
6674             return cenc_decrypt(mov, sc, encrypted_sample, pkt->data, pkt->size);
6675         } else {
6676             size_t size;
6677             uint8_t *side_data = av_encryption_info_add_side_data(encrypted_sample, &size);
6678             if (!side_data)
6679                 return AVERROR(ENOMEM);
6680             ret = av_packet_add_side_data(pkt, AV_PKT_DATA_ENCRYPTION_INFO, side_data, size);
6681             if (ret < 0)
6682                 av_free(side_data);
6683             return ret;
6684         }
6685     }
6686
6687     return 0;
6688 }
6689
6690 static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6691 {
6692     const int OPUS_SEEK_PREROLL_MS = 80;
6693     int ret;
6694     AVStream *st;
6695     size_t size;
6696     uint16_t pre_skip;
6697
6698     if (c->fc->nb_streams < 1)
6699         return 0;
6700     st = c->fc->streams[c->fc->nb_streams-1];
6701
6702     if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
6703         return AVERROR_INVALIDDATA;
6704
6705     /* Check OpusSpecificBox version. */
6706     if (avio_r8(pb) != 0) {
6707         av_log(c->fc, AV_LOG_ERROR, "unsupported OpusSpecificBox version\n");
6708         return AVERROR_INVALIDDATA;
6709     }
6710
6711     /* OpusSpecificBox size plus magic for Ogg OpusHead header. */
6712     size = atom.size + 8;
6713
6714     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
6715         return ret;
6716
6717     AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
6718     AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
6719     AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
6720     avio_read(pb, st->codecpar->extradata + 9, size - 9);
6721
6722     /* OpusSpecificBox is stored in big-endian, but OpusHead is
6723        little-endian; aside from the preceeding magic and version they're
6724        otherwise currently identical.  Data after output gain at offset 16
6725        doesn't need to be bytewapped. */
6726     pre_skip = AV_RB16(st->codecpar->extradata + 10);
6727     AV_WL16(st->codecpar->extradata + 10, pre_skip);
6728     AV_WL32(st->codecpar->extradata + 12, AV_RB32(st->codecpar->extradata + 12));
6729     AV_WL16(st->codecpar->extradata + 16, AV_RB16(st->codecpar->extradata + 16));
6730
6731     st->codecpar->initial_padding = pre_skip;
6732     st->codecpar->seek_preroll = av_rescale_q(OPUS_SEEK_PREROLL_MS,
6733                                               (AVRational){1, 1000},
6734                                               (AVRational){1, 48000});
6735
6736     return 0;
6737 }
6738
6739 static int mov_read_dmlp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6740 {
6741     AVStream *st;
6742     unsigned format_info;
6743     int channel_assignment, channel_assignment1, channel_assignment2;
6744     int ratebits;
6745
6746     if (c->fc->nb_streams < 1)
6747         return 0;
6748     st = c->fc->streams[c->fc->nb_streams-1];
6749
6750     if (atom.size < 10)
6751         return AVERROR_INVALIDDATA;
6752
6753     format_info = avio_rb32(pb);
6754
6755     ratebits            = (format_info >> 28) & 0xF;
6756     channel_assignment1 = (format_info >> 15) & 0x1F;
6757     channel_assignment2 = format_info & 0x1FFF;
6758     if (channel_assignment2)
6759         channel_assignment = channel_assignment2;
6760     else
6761         channel_assignment = channel_assignment1;
6762
6763     st->codecpar->frame_size = 40 << (ratebits & 0x7);
6764     st->codecpar->sample_rate = mlp_samplerate(ratebits);
6765     st->codecpar->channels = truehd_channels(channel_assignment);
6766     st->codecpar->channel_layout = truehd_layout(channel_assignment);
6767
6768     return 0;
6769 }
6770
6771 static int mov_read_dvcc_dvvc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6772 {
6773     AVStream *st;
6774     uint32_t buf;
6775     AVDOVIDecoderConfigurationRecord *dovi;
6776     size_t dovi_size;
6777     int ret;
6778
6779     if (c->fc->nb_streams < 1)
6780         return 0;
6781     st = c->fc->streams[c->fc->nb_streams-1];
6782
6783     if ((uint64_t)atom.size > (1<<30) || atom.size < 4)
6784         return AVERROR_INVALIDDATA;
6785
6786     dovi = av_dovi_alloc(&dovi_size);
6787     if (!dovi)
6788         return AVERROR(ENOMEM);
6789
6790     dovi->dv_version_major = avio_r8(pb);
6791     dovi->dv_version_minor = avio_r8(pb);
6792
6793     buf = avio_rb16(pb);
6794     dovi->dv_profile        = (buf >> 9) & 0x7f;    // 7 bits
6795     dovi->dv_level          = (buf >> 3) & 0x3f;    // 6 bits
6796     dovi->rpu_present_flag  = (buf >> 2) & 0x01;    // 1 bit
6797     dovi->el_present_flag   = (buf >> 1) & 0x01;    // 1 bit
6798     dovi->bl_present_flag   =  buf       & 0x01;    // 1 bit
6799     if (atom.size >= 24) {  // 4 + 4 + 4 * 4
6800         buf = avio_r8(pb);
6801         dovi->dv_bl_signal_compatibility_id = (buf >> 4) & 0x0f; // 4 bits
6802     } else {
6803         // 0 stands for None
6804         // Dolby Vision V1.2.93 profiles and levels
6805         dovi->dv_bl_signal_compatibility_id = 0;
6806     }
6807
6808     ret = av_stream_add_side_data(st, AV_PKT_DATA_DOVI_CONF,
6809                                   (uint8_t *)dovi, dovi_size);
6810     if (ret < 0) {
6811         av_free(dovi);
6812         return ret;
6813     }
6814
6815     av_log(c, AV_LOG_TRACE, "DOVI in dvcC/dvvC box, version: %d.%d, profile: %d, level: %d, "
6816            "rpu flag: %d, el flag: %d, bl flag: %d, compatibility id: %d\n",
6817            dovi->dv_version_major, dovi->dv_version_minor,
6818            dovi->dv_profile, dovi->dv_level,
6819            dovi->rpu_present_flag,
6820            dovi->el_present_flag,
6821            dovi->bl_present_flag,
6822            dovi->dv_bl_signal_compatibility_id
6823         );
6824
6825     return 0;
6826 }
6827
6828 static const MOVParseTableEntry mov_default_parse_table[] = {
6829 { MKTAG('A','C','L','R'), mov_read_aclr },
6830 { MKTAG('A','P','R','G'), mov_read_avid },
6831 { MKTAG('A','A','L','P'), mov_read_avid },
6832 { MKTAG('A','R','E','S'), mov_read_ares },
6833 { MKTAG('a','v','s','s'), mov_read_avss },
6834 { MKTAG('a','v','1','C'), mov_read_av1c },
6835 { MKTAG('c','h','p','l'), mov_read_chpl },
6836 { MKTAG('c','o','6','4'), mov_read_stco },
6837 { MKTAG('c','o','l','r'), mov_read_colr },
6838 { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
6839 { MKTAG('d','i','n','f'), mov_read_default },
6840 { MKTAG('D','p','x','E'), mov_read_dpxe },
6841 { MKTAG('d','r','e','f'), mov_read_dref },
6842 { MKTAG('e','d','t','s'), mov_read_default },
6843 { MKTAG('e','l','s','t'), mov_read_elst },
6844 { MKTAG('e','n','d','a'), mov_read_enda },
6845 { MKTAG('f','i','e','l'), mov_read_fiel },
6846 { MKTAG('a','d','r','m'), mov_read_adrm },
6847 { MKTAG('f','t','y','p'), mov_read_ftyp },
6848 { MKTAG('g','l','b','l'), mov_read_glbl },
6849 { MKTAG('h','d','l','r'), mov_read_hdlr },
6850 { MKTAG('i','l','s','t'), mov_read_ilst },
6851 { MKTAG('j','p','2','h'), mov_read_jp2h },
6852 { MKTAG('m','d','a','t'), mov_read_mdat },
6853 { MKTAG('m','d','h','d'), mov_read_mdhd },
6854 { MKTAG('m','d','i','a'), mov_read_default },
6855 { MKTAG('m','e','t','a'), mov_read_meta },
6856 { MKTAG('m','i','n','f'), mov_read_default },
6857 { MKTAG('m','o','o','f'), mov_read_moof },
6858 { MKTAG('m','o','o','v'), mov_read_moov },
6859 { MKTAG('m','v','e','x'), mov_read_default },
6860 { MKTAG('m','v','h','d'), mov_read_mvhd },
6861 { MKTAG('S','M','I',' '), mov_read_svq3 },
6862 { MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
6863 { MKTAG('a','v','c','C'), mov_read_glbl },
6864 { MKTAG('p','a','s','p'), mov_read_pasp },
6865 { MKTAG('s','i','d','x'), mov_read_sidx },
6866 { MKTAG('s','t','b','l'), mov_read_default },
6867 { MKTAG('s','t','c','o'), mov_read_stco },
6868 { MKTAG('s','t','p','s'), mov_read_stps },
6869 { MKTAG('s','t','r','f'), mov_read_strf },
6870 { MKTAG('s','t','s','c'), mov_read_stsc },
6871 { MKTAG('s','t','s','d'), mov_read_stsd }, /* sample description */
6872 { MKTAG('s','t','s','s'), mov_read_stss }, /* sync sample */
6873 { MKTAG('s','t','s','z'), mov_read_stsz }, /* sample size */
6874 { MKTAG('s','t','t','s'), mov_read_stts },
6875 { MKTAG('s','t','z','2'), mov_read_stsz }, /* compact sample size */
6876 { MKTAG('s','d','t','p'), mov_read_sdtp }, /* independent and disposable samples */
6877 { MKTAG('t','k','h','d'), mov_read_tkhd }, /* track header */
6878 { MKTAG('t','f','d','t'), mov_read_tfdt },
6879 { MKTAG('t','f','h','d'), mov_read_tfhd }, /* track fragment header */
6880 { MKTAG('t','r','a','k'), mov_read_trak },
6881 { MKTAG('t','r','a','f'), mov_read_default },
6882 { MKTAG('t','r','e','f'), mov_read_default },
6883 { MKTAG('t','m','c','d'), mov_read_tmcd },
6884 { MKTAG('c','h','a','p'), mov_read_chap },
6885 { MKTAG('t','r','e','x'), mov_read_trex },
6886 { MKTAG('t','r','u','n'), mov_read_trun },
6887 { MKTAG('u','d','t','a'), mov_read_default },
6888 { MKTAG('w','a','v','e'), mov_read_wave },
6889 { MKTAG('e','s','d','s'), mov_read_esds },
6890 { MKTAG('d','a','c','3'), mov_read_dac3 }, /* AC-3 info */
6891 { MKTAG('d','e','c','3'), mov_read_dec3 }, /* EAC-3 info */
6892 { MKTAG('d','d','t','s'), mov_read_ddts }, /* DTS audio descriptor */
6893 { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
6894 { MKTAG('w','f','e','x'), mov_read_wfex },
6895 { MKTAG('c','m','o','v'), mov_read_cmov },
6896 { MKTAG('c','h','a','n'), mov_read_chan }, /* channel layout */
6897 { MKTAG('d','v','c','1'), mov_read_dvc1 },
6898 { MKTAG('s','b','g','p'), mov_read_sbgp },
6899 { MKTAG('h','v','c','C'), mov_read_glbl },
6900 { MKTAG('u','u','i','d'), mov_read_uuid },
6901 { MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
6902 { MKTAG('f','r','e','e'), mov_read_free },
6903 { MKTAG('-','-','-','-'), mov_read_custom },
6904 { MKTAG('s','i','n','f'), mov_read_default },
6905 { MKTAG('f','r','m','a'), mov_read_frma },
6906 { MKTAG('s','e','n','c'), mov_read_senc },
6907 { MKTAG('s','a','i','z'), mov_read_saiz },
6908 { MKTAG('s','a','i','o'), mov_read_saio },
6909 { MKTAG('p','s','s','h'), mov_read_pssh },
6910 { MKTAG('s','c','h','m'), mov_read_schm },
6911 { MKTAG('s','c','h','i'), mov_read_default },
6912 { MKTAG('t','e','n','c'), mov_read_tenc },
6913 { MKTAG('d','f','L','a'), mov_read_dfla },
6914 { MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
6915 { MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
6916 { MKTAG('d','O','p','s'), mov_read_dops },
6917 { MKTAG('d','m','l','p'), mov_read_dmlp },
6918 { MKTAG('S','m','D','m'), mov_read_smdm },
6919 { MKTAG('C','o','L','L'), mov_read_coll },
6920 { MKTAG('v','p','c','C'), mov_read_vpcc },
6921 { MKTAG('m','d','c','v'), mov_read_mdcv },
6922 { MKTAG('c','l','l','i'), mov_read_clli },
6923 { MKTAG('d','v','c','C'), mov_read_dvcc_dvvc },
6924 { MKTAG('d','v','v','C'), mov_read_dvcc_dvvc },
6925 { 0, NULL }
6926 };
6927
6928 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
6929 {
6930     int64_t total_size = 0;
6931     MOVAtom a;
6932     int i;
6933
6934     if (c->atom_depth > 10) {
6935         av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
6936         return AVERROR_INVALIDDATA;
6937     }
6938     c->atom_depth ++;
6939
6940     if (atom.size < 0)
6941         atom.size = INT64_MAX;
6942     while (total_size <= atom.size - 8 && !avio_feof(pb)) {
6943         int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
6944         a.size = atom.size;
6945         a.type=0;
6946         if (atom.size >= 8) {
6947             a.size = avio_rb32(pb);
6948             a.type = avio_rl32(pb);
6949             if (((a.type == MKTAG('f','r','e','e') && c->moov_retry) ||
6950                   a.type == MKTAG('h','o','o','v')) &&
6951                 a.size >= 8 &&
6952                 c->fc->strict_std_compliance < FF_COMPLIANCE_STRICT) {
6953                 uint8_t buf[8];
6954                 uint32_t *type = (uint32_t *)buf + 1;
6955                 if (avio_read(pb, buf, 8) != 8)
6956                     return AVERROR_INVALIDDATA;
6957                 avio_seek(pb, -8, SEEK_CUR);
6958                 if (*type == MKTAG('m','v','h','d') ||
6959                     *type == MKTAG('c','m','o','v')) {
6960                     av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free or hoov atom.\n");
6961                     a.type = MKTAG('m','o','o','v');
6962                 }
6963             }
6964             if (atom.type != MKTAG('r','o','o','t') &&
6965                 atom.type != MKTAG('m','o','o','v'))
6966             {
6967                 if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
6968                 {
6969                     av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
6970                     avio_skip(pb, -8);
6971                     c->atom_depth --;
6972                     return 0;
6973                 }
6974             }
6975             total_size += 8;
6976             if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */
6977                 a.size = avio_rb64(pb) - 8;
6978                 total_size += 8;
6979             }
6980         }
6981         av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
6982                av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
6983         if (a.size == 0) {
6984             a.size = atom.size - total_size + 8;
6985         }
6986         a.size -= 8;
6987         if (a.size < 0)
6988             break;
6989         a.size = FFMIN(a.size, atom.size - total_size);
6990
6991         for (i = 0; mov_default_parse_table[i].type; i++)
6992             if (mov_default_parse_table[i].type == a.type) {
6993                 parse = mov_default_parse_table[i].parse;
6994                 break;
6995             }
6996
6997         // container is user data
6998         if (!parse && (atom.type == MKTAG('u','d','t','a') ||
6999                        atom.type == MKTAG('i','l','s','t')))
7000             parse = mov_read_udta_string;
7001
7002         // Supports parsing the QuickTime Metadata Keys.
7003         // https://developer.apple.com/library/mac/documentation/QuickTime/QTFF/Metadata/Metadata.html
7004         if (!parse && c->found_hdlr_mdta &&
7005             atom.type == MKTAG('m','e','t','a') &&
7006             a.type == MKTAG('k','e','y','s') &&
7007             c->meta_keys_count == 0) {
7008             parse = mov_read_keys;
7009         }
7010
7011         if (!parse) { /* skip leaf atoms data */
7012             avio_skip(pb, a.size);
7013         } else {
7014             int64_t start_pos = avio_tell(pb);
7015             int64_t left;
7016             int err = parse(c, pb, a);
7017             if (err < 0) {
7018                 c->atom_depth --;
7019                 return err;
7020             }
7021             if (c->found_moov && c->found_mdat &&
7022                 ((!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete) ||
7023                  start_pos + a.size == avio_size(pb))) {
7024                 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->frag_index.complete)
7025                     c->next_root_atom = start_pos + a.size;
7026                 c->atom_depth --;
7027                 return 0;
7028             }
7029             left = a.size - avio_tell(pb) + start_pos;
7030             if (left > 0) /* skip garbage at atom end */
7031                 avio_skip(pb, left);
7032             else if (left < 0) {
7033                 av_log(c->fc, AV_LOG_WARNING,
7034                        "overread end of atom '%.4s' by %"PRId64" bytes\n",
7035                        (char*)&a.type, -left);
7036                 avio_seek(pb, left, SEEK_CUR);
7037             }
7038         }
7039
7040         total_size += a.size;
7041     }
7042
7043     if (total_size < atom.size && atom.size < 0x7ffff)
7044         avio_skip(pb, atom.size - total_size);
7045
7046     c->atom_depth --;
7047     return 0;
7048 }
7049
7050 static int mov_probe(const AVProbeData *p)
7051 {
7052     int64_t offset;
7053     uint32_t tag;
7054     int score = 0;
7055     int moov_offset = -1;
7056
7057     /* check file header */
7058     offset = 0;
7059     for (;;) {
7060         /* ignore invalid offset */
7061         if ((offset + 8) > (unsigned int)p->buf_size)
7062             break;
7063         tag = AV_RL32(p->buf + offset + 4);
7064         switch(tag) {
7065         /* check for obvious tags */
7066         case MKTAG('m','o','o','v'):
7067             moov_offset = offset + 4;
7068         case MKTAG('m','d','a','t'):
7069         case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
7070         case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
7071         case MKTAG('f','t','y','p'):
7072             if (AV_RB32(p->buf+offset) < 8 &&
7073                 (AV_RB32(p->buf+offset) != 1 ||
7074                  offset + 12 > (unsigned int)p->buf_size ||
7075                  AV_RB64(p->buf+offset + 8) == 0)) {
7076                 score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
7077             } else if (tag == MKTAG('f','t','y','p') &&
7078                        (   AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')
7079                         || AV_RL32(p->buf + offset + 8) == MKTAG('j','p','x',' ')
7080                     )) {
7081                 score = FFMAX(score, 5);
7082             } else {
7083                 score = AVPROBE_SCORE_MAX;
7084             }
7085             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
7086             break;
7087         /* those are more common words, so rate then a bit less */
7088         case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
7089         case MKTAG('w','i','d','e'):
7090         case MKTAG('f','r','e','e'):
7091         case MKTAG('j','u','n','k'):
7092         case MKTAG('p','i','c','t'):
7093             score  = FFMAX(score, AVPROBE_SCORE_MAX - 5);
7094             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
7095             break;
7096         case MKTAG(0x82,0x82,0x7f,0x7d):
7097         case MKTAG('s','k','i','p'):
7098         case MKTAG('u','u','i','d'):
7099         case MKTAG('p','r','f','l'):
7100             /* if we only find those cause probedata is too small at least rate them */
7101             score  = FFMAX(score, AVPROBE_SCORE_EXTENSION);
7102             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
7103             break;
7104         default:
7105             offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
7106         }
7107     }
7108     if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
7109         /* moov atom in the header - we should make sure that this is not a
7110          * MOV-packed MPEG-PS */
7111         offset = moov_offset;
7112
7113         while(offset < (p->buf_size - 16)){ /* Sufficient space */
7114                /* We found an actual hdlr atom */
7115             if(AV_RL32(p->buf + offset     ) == MKTAG('h','d','l','r') &&
7116                AV_RL32(p->buf + offset +  8) == MKTAG('m','h','l','r') &&
7117                AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
7118                 av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
7119                 /* We found a media handler reference atom describing an
7120                  * MPEG-PS-in-MOV, return a
7121                  * low score to force expanding the probe window until
7122                  * mpegps_probe finds what it needs */
7123                 return 5;
7124             }else
7125                 /* Keep looking */
7126                 offset+=2;
7127         }
7128     }
7129
7130     return score;
7131 }
7132
7133 // must be done after parsing all trak because there's no order requirement
7134 static void mov_read_chapters(AVFormatContext *s)
7135 {
7136     MOVContext *mov = s->priv_data;
7137     AVStream *st;
7138     MOVStreamContext *sc;
7139     int64_t cur_pos;
7140     int i, j;
7141     int chapter_track;
7142
7143     for (j = 0; j < mov->nb_chapter_tracks; j++) {
7144         chapter_track = mov->chapter_tracks[j];
7145         st = NULL;
7146         for (i = 0; i < s->nb_streams; i++)
7147             if (s->streams[i]->id == chapter_track) {
7148                 st = s->streams[i];
7149                 break;
7150             }
7151         if (!st) {
7152             av_log(s, AV_LOG_ERROR, "Referenced QT chapter track not found\n");
7153             continue;
7154         }
7155
7156         sc = st->priv_data;
7157         cur_pos = avio_tell(sc->pb);
7158
7159         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
7160             st->disposition |= AV_DISPOSITION_ATTACHED_PIC | AV_DISPOSITION_TIMED_THUMBNAILS;
7161             if (st->nb_index_entries) {
7162                 // Retrieve the first frame, if possible
7163                 AVIndexEntry *sample = &st->index_entries[0];
7164                 if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7165                     av_log(s, AV_LOG_ERROR, "Failed to retrieve first frame\n");
7166                     goto finish;
7167                 }
7168
7169                 if (av_get_packet(sc->pb, &st->attached_pic, sample->size) < 0)
7170                     goto finish;
7171
7172                 st->attached_pic.stream_index = st->index;
7173                 st->attached_pic.flags       |= AV_PKT_FLAG_KEY;
7174             }
7175         } else {
7176             st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
7177             st->codecpar->codec_id = AV_CODEC_ID_BIN_DATA;
7178             st->discard = AVDISCARD_ALL;
7179             for (i = 0; i < st->nb_index_entries; i++) {
7180                 AVIndexEntry *sample = &st->index_entries[i];
7181                 int64_t end = i+1 < st->nb_index_entries ? st->index_entries[i+1].timestamp : st->duration;
7182                 uint8_t *title;
7183                 uint16_t ch;
7184                 int len, title_len;
7185
7186                 if (end < sample->timestamp) {
7187                     av_log(s, AV_LOG_WARNING, "ignoring stream duration which is shorter than chapters\n");
7188                     end = AV_NOPTS_VALUE;
7189                 }
7190
7191                 if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
7192                     av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
7193                     goto finish;
7194                 }
7195
7196                 // the first two bytes are the length of the title
7197                 len = avio_rb16(sc->pb);
7198                 if (len > sample->size-2)
7199                     continue;
7200                 title_len = 2*len + 1;
7201                 if (!(title = av_mallocz(title_len)))
7202                     goto finish;
7203
7204                 // The samples could theoretically be in any encoding if there's an encd
7205                 // atom following, but in practice are only utf-8 or utf-16, distinguished
7206                 // instead by the presence of a BOM
7207                 if (!len) {
7208                     title[0] = 0;
7209                 } else {
7210                     ch = avio_rb16(sc->pb);
7211                     if (ch == 0xfeff)
7212                         avio_get_str16be(sc->pb, len, title, title_len);
7213                     else if (ch == 0xfffe)
7214                         avio_get_str16le(sc->pb, len, title, title_len);
7215                     else {
7216                         AV_WB16(title, ch);
7217                         if (len == 1 || len == 2)
7218                             title[len] = 0;
7219                         else
7220                             avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
7221                     }
7222                 }
7223
7224                 avpriv_new_chapter(s, i, st->time_base, sample->timestamp, end, title);
7225                 av_freep(&title);
7226             }
7227         }
7228 finish:
7229         avio_seek(sc->pb, cur_pos, SEEK_SET);
7230     }
7231 }
7232
7233 static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
7234                                              uint32_t value, int flags)
7235 {
7236     AVTimecode tc;
7237     char buf[AV_TIMECODE_STR_SIZE];
7238     AVRational rate = st->avg_frame_rate;
7239     int ret = av_timecode_init(&tc, rate, flags, 0, s);
7240     if (ret < 0)
7241         return ret;
7242     av_dict_set(&st->metadata, "timecode",
7243                 av_timecode_make_string(&tc, buf, value), 0);
7244     return 0;
7245 }
7246
7247 static int mov_read_rtmd_track(AVFormatContext *s, AVStream *st)
7248 {
7249     MOVStreamContext *sc = st->priv_data;
7250     char buf[AV_TIMECODE_STR_SIZE];
7251     int64_t cur_pos = avio_tell(sc->pb);
7252     int hh, mm, ss, ff, drop;
7253
7254     if (!st->nb_index_entries)
7255         return -1;
7256
7257     avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7258     avio_skip(s->pb, 13);
7259     hh = avio_r8(s->pb);
7260     mm = avio_r8(s->pb);
7261     ss = avio_r8(s->pb);
7262     drop = avio_r8(s->pb);
7263     ff = avio_r8(s->pb);
7264     snprintf(buf, AV_TIMECODE_STR_SIZE, "%02d:%02d:%02d%c%02d",
7265              hh, mm, ss, drop ? ';' : ':', ff);
7266     av_dict_set(&st->metadata, "timecode", buf, 0);
7267
7268     avio_seek(sc->pb, cur_pos, SEEK_SET);
7269     return 0;
7270 }
7271
7272 static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
7273 {
7274     MOVStreamContext *sc = st->priv_data;
7275     int flags = 0;
7276     int64_t cur_pos = avio_tell(sc->pb);
7277     uint32_t value;
7278
7279     if (!st->nb_index_entries)
7280         return -1;
7281
7282     avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
7283     value = avio_rb32(s->pb);
7284
7285     if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
7286     if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
7287     if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
7288
7289     /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
7290      * not the case) and thus assume "frame number format" instead of QT one.
7291      * No sample with tmcd track can be found with a QT timecode at the moment,
7292      * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
7293      * format). */
7294     parse_timecode_in_framenum_format(s, st, value, flags);
7295
7296     avio_seek(sc->pb, cur_pos, SEEK_SET);
7297     return 0;
7298 }
7299
7300 static void mov_free_encryption_index(MOVEncryptionIndex **index) {
7301     int i;
7302     if (!index || !*index) return;
7303     for (i = 0; i < (*index)->nb_encrypted_samples; i++) {
7304         av_encryption_info_free((*index)->encrypted_samples[i]);
7305     }
7306     av_freep(&(*index)->encrypted_samples);
7307     av_freep(&(*index)->auxiliary_info_sizes);
7308     av_freep(&(*index)->auxiliary_offsets);
7309     av_freep(index);
7310 }
7311
7312 static int mov_read_close(AVFormatContext *s)
7313 {
7314     MOVContext *mov = s->priv_data;
7315     int i, j;
7316
7317     for (i = 0; i < s->nb_streams; i++) {
7318         AVStream *st = s->streams[i];
7319         MOVStreamContext *sc = st->priv_data;
7320
7321         if (!sc)
7322             continue;
7323
7324         av_freep(&sc->ctts_data);
7325         for (j = 0; j < sc->drefs_count; j++) {
7326             av_freep(&sc->drefs[j].path);
7327             av_freep(&sc->drefs[j].dir);
7328         }
7329         av_freep(&sc->drefs);
7330
7331         sc->drefs_count = 0;
7332
7333         if (!sc->pb_is_copied)
7334             ff_format_io_close(s, &sc->pb);
7335
7336         sc->pb = NULL;
7337         av_freep(&sc->chunk_offsets);
7338         av_freep(&sc->stsc_data);
7339         av_freep(&sc->sample_sizes);
7340         av_freep(&sc->keyframes);
7341         av_freep(&sc->stts_data);
7342         av_freep(&sc->sdtp_data);
7343         av_freep(&sc->stps_data);
7344         av_freep(&sc->elst_data);
7345         av_freep(&sc->rap_group);
7346         av_freep(&sc->display_matrix);
7347         av_freep(&sc->index_ranges);
7348
7349         if (sc->extradata)
7350             for (j = 0; j < sc->stsd_count; j++)
7351                 av_free(sc->extradata[j]);
7352         av_freep(&sc->extradata);
7353         av_freep(&sc->extradata_size);
7354
7355         mov_free_encryption_index(&sc->cenc.encryption_index);
7356         av_encryption_info_free(sc->cenc.default_encrypted_sample);
7357         av_aes_ctr_free(sc->cenc.aes_ctr);
7358
7359         av_freep(&sc->stereo3d);
7360         av_freep(&sc->spherical);
7361         av_freep(&sc->mastering);
7362         av_freep(&sc->coll);
7363     }
7364
7365     if (mov->dv_demux) {
7366         avformat_free_context(mov->dv_fctx);
7367         mov->dv_fctx = NULL;
7368     }
7369
7370     if (mov->meta_keys) {
7371         for (i = 1; i < mov->meta_keys_count; i++) {
7372             av_freep(&mov->meta_keys[i]);
7373         }
7374         av_freep(&mov->meta_keys);
7375     }
7376
7377     av_freep(&mov->trex_data);
7378     av_freep(&mov->bitrates);
7379
7380     for (i = 0; i < mov->frag_index.nb_items; i++) {
7381         MOVFragmentStreamInfo *frag = mov->frag_index.item[i].stream_info;
7382         for (j = 0; j < mov->frag_index.item[i].nb_stream_info; j++) {
7383             mov_free_encryption_index(&frag[j].encryption_index);
7384         }
7385         av_freep(&mov->frag_index.item[i].stream_info);
7386     }
7387     av_freep(&mov->frag_index.item);
7388
7389     av_freep(&mov->aes_decrypt);
7390     av_freep(&mov->chapter_tracks);
7391
7392     return 0;
7393 }
7394
7395 static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
7396 {
7397     int i;
7398
7399     for (i = 0; i < s->nb_streams; i++) {
7400         AVStream *st = s->streams[i];
7401         MOVStreamContext *sc = st->priv_data;
7402
7403         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
7404             sc->timecode_track == tmcd_id)
7405             return 1;
7406     }
7407     return 0;
7408 }
7409
7410 /* look for a tmcd track not referenced by any video track, and export it globally */
7411 static void export_orphan_timecode(AVFormatContext *s)
7412 {
7413     int i;
7414
7415     for (i = 0; i < s->nb_streams; i++) {
7416         AVStream *st = s->streams[i];
7417
7418         if (st->codecpar->codec_tag  == MKTAG('t','m','c','d') &&
7419             !tmcd_is_referenced(s, i + 1)) {
7420             AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
7421             if (tcr) {
7422                 av_dict_set(&s->metadata, "timecode", tcr->value, 0);
7423                 break;
7424             }
7425         }
7426     }
7427 }
7428
7429 static int read_tfra(MOVContext *mov, AVIOContext *f)
7430 {
7431     int version, fieldlength, i, j;
7432     int64_t pos = avio_tell(f);
7433     uint32_t size = avio_rb32(f);
7434     unsigned track_id, item_count;
7435
7436     if (avio_rb32(f) != MKBETAG('t', 'f', 'r', 'a')) {
7437         return 1;
7438     }
7439     av_log(mov->fc, AV_LOG_VERBOSE, "found tfra\n");
7440
7441     version = avio_r8(f);
7442     avio_rb24(f);
7443     track_id = avio_rb32(f);
7444     fieldlength = avio_rb32(f);
7445     item_count = avio_rb32(f);
7446     for (i = 0; i < item_count; i++) {
7447         int64_t time, offset;
7448         int index;
7449         MOVFragmentStreamInfo * frag_stream_info;
7450
7451         if (avio_feof(f)) {
7452             return AVERROR_INVALIDDATA;
7453         }
7454
7455         if (version == 1) {
7456             time   = avio_rb64(f);
7457             offset = avio_rb64(f);
7458         } else {
7459             time   = avio_rb32(f);
7460             offset = avio_rb32(f);
7461         }
7462
7463         // The first sample of each stream in a fragment is always a random
7464         // access sample.  So it's entry in the tfra can be used as the
7465         // initial PTS of the fragment.
7466         index = update_frag_index(mov, offset);
7467         frag_stream_info = get_frag_stream_info(&mov->frag_index, index, track_id);
7468         if (frag_stream_info &&
7469             frag_stream_info->first_tfra_pts == AV_NOPTS_VALUE)
7470             frag_stream_info->first_tfra_pts = time;
7471
7472         for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
7473             avio_r8(f);
7474         for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
7475             avio_r8(f);
7476         for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
7477             avio_r8(f);
7478     }
7479
7480     avio_seek(f, pos + size, SEEK_SET);
7481     return 0;
7482 }
7483
7484 static int mov_read_mfra(MOVContext *c, AVIOContext *f)
7485 {
7486     int64_t stream_size = avio_size(f);
7487     int64_t original_pos = avio_tell(f);
7488     int64_t seek_ret;
7489     int32_t mfra_size;
7490     int ret = -1;
7491     if ((seek_ret = avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
7492         ret = seek_ret;
7493         goto fail;
7494     }
7495     mfra_size = avio_rb32(f);
7496     if (mfra_size < 0 || mfra_size > stream_size) {
7497         av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
7498         goto fail;
7499     }
7500     if ((seek_ret = avio_seek(f, -mfra_size, SEEK_CUR)) < 0) {
7501         ret = seek_ret;
7502         goto fail;
7503     }
7504     if (avio_rb32(f) != mfra_size) {
7505         av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (size mismatch)\n");
7506         goto fail;
7507     }
7508     if (avio_rb32(f) != MKBETAG('m', 'f', 'r', 'a')) {
7509         av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (tag mismatch)\n");
7510         goto fail;
7511     }
7512     av_log(c->fc, AV_LOG_VERBOSE, "stream has mfra\n");
7513     do {
7514         ret = read_tfra(c, f);
7515         if (ret < 0)
7516             goto fail;
7517     } while (!ret);
7518     ret = 0;
7519 fail:
7520     seek_ret = avio_seek(f, original_pos, SEEK_SET);
7521     if (seek_ret < 0) {
7522         av_log(c->fc, AV_LOG_ERROR,
7523                "failed to seek back after looking for mfra\n");
7524         ret = seek_ret;
7525     }
7526     return ret;
7527 }
7528
7529 static int mov_read_header(AVFormatContext *s)
7530 {
7531     MOVContext *mov = s->priv_data;
7532     AVIOContext *pb = s->pb;
7533     int j, err;
7534     MOVAtom atom = { AV_RL32("root") };
7535     int i;
7536
7537     if (mov->decryption_key_len != 0 && mov->decryption_key_len != AES_CTR_KEY_SIZE) {
7538         av_log(s, AV_LOG_ERROR, "Invalid decryption key len %d expected %d\n",
7539             mov->decryption_key_len, AES_CTR_KEY_SIZE);
7540         return AVERROR(EINVAL);
7541     }
7542
7543     mov->fc = s;
7544     mov->trak_index = -1;
7545     /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
7546     if (pb->seekable & AVIO_SEEKABLE_NORMAL)
7547         atom.size = avio_size(pb);
7548     else
7549         atom.size = INT64_MAX;
7550
7551     /* check MOV header */
7552     do {
7553         if (mov->moov_retry)
7554             avio_seek(pb, 0, SEEK_SET);
7555         if ((err = mov_read_default(mov, pb, atom)) < 0) {
7556             av_log(s, AV_LOG_ERROR, "error reading header\n");
7557             goto fail;
7558         }
7559     } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++);
7560     if (!mov->found_moov) {
7561         av_log(s, AV_LOG_ERROR, "moov atom not found\n");
7562         err = AVERROR_INVALIDDATA;
7563         goto fail;
7564     }
7565     av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
7566
7567     if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
7568         if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)
7569             mov_read_chapters(s);
7570         for (i = 0; i < s->nb_streams; i++)
7571             if (s->streams[i]->codecpar->codec_tag == AV_RL32("tmcd")) {
7572                 mov_read_timecode_track(s, s->streams[i]);
7573             } else if (s->streams[i]->codecpar->codec_tag == AV_RL32("rtmd")) {
7574                 mov_read_rtmd_track(s, s->streams[i]);
7575             }
7576     }
7577
7578     /* copy timecode metadata from tmcd tracks to the related video streams */
7579     for (i = 0; i < s->nb_streams; i++) {
7580         AVStream *st = s->streams[i];
7581         MOVStreamContext *sc = st->priv_data;
7582         if (sc->timecode_track > 0) {
7583             AVDictionaryEntry *tcr;
7584             int tmcd_st_id = -1;
7585
7586             for (j = 0; j < s->nb_streams; j++)
7587                 if (s->streams[j]->id == sc->timecode_track)
7588                     tmcd_st_id = j;
7589
7590             if (tmcd_st_id < 0 || tmcd_st_id == i)
7591                 continue;
7592             tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
7593             if (tcr)
7594                 av_dict_set(&st->metadata, "timecode", tcr->value, 0);
7595         }
7596     }
7597     export_orphan_timecode(s);
7598
7599     for (i = 0; i < s->nb_streams; i++) {
7600         AVStream *st = s->streams[i];
7601         MOVStreamContext *sc = st->priv_data;
7602         fix_timescale(mov, sc);
7603         if(st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->codec_id == AV_CODEC_ID_AAC) {
7604             st->skip_samples = sc->start_pad;
7605         }
7606         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
7607             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
7608                       sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
7609         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
7610             if (st->codecpar->width <= 0 || st->codecpar->height <= 0) {
7611                 st->codecpar->width  = sc->width;
7612                 st->codecpar->height = sc->height;
7613             }
7614             if (st->codecpar->codec_id == AV_CODEC_ID_DVD_SUBTITLE) {
7615                 if ((err = mov_rewrite_dvd_sub_extradata(st)) < 0)
7616                     goto fail;
7617             }
7618         }
7619         if (mov->handbrake_version &&
7620             mov->handbrake_version <= 1000000*0 + 1000*10 + 2 &&  // 0.10.2
7621             st->codecpar->codec_id == AV_CODEC_ID_MP3
7622         ) {
7623             av_log(s, AV_LOG_VERBOSE, "Forcing full parsing for mp3 stream\n");
7624             st->need_parsing = AVSTREAM_PARSE_FULL;
7625         }
7626     }
7627
7628     if (mov->trex_data) {
7629         for (i = 0; i < s->nb_streams; i++) {
7630             AVStream *st = s->streams[i];
7631             MOVStreamContext *sc = st->priv_data;
7632             if (st->duration > 0) {
7633                 if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7634                     av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7635                            sc->data_size, sc->time_scale);
7636                     err = AVERROR_INVALIDDATA;
7637                     goto fail;
7638                 }
7639                 st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
7640             }
7641         }
7642     }
7643
7644     if (mov->use_mfra_for > 0) {
7645         for (i = 0; i < s->nb_streams; i++) {
7646             AVStream *st = s->streams[i];
7647             MOVStreamContext *sc = st->priv_data;
7648             if (sc->duration_for_fps > 0) {
7649                 if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
7650                     av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
7651                            sc->data_size, sc->time_scale);
7652                     err = AVERROR_INVALIDDATA;
7653                     goto fail;
7654                 }
7655                 st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /
7656                     sc->duration_for_fps;
7657             }
7658         }
7659     }
7660
7661     for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
7662         if (mov->bitrates[i]) {
7663             s->streams[i]->codecpar->bit_rate = mov->bitrates[i];
7664         }
7665     }
7666
7667     ff_rfps_calculate(s);
7668
7669     for (i = 0; i < s->nb_streams; i++) {
7670         AVStream *st = s->streams[i];
7671         MOVStreamContext *sc = st->priv_data;
7672
7673         switch (st->codecpar->codec_type) {
7674         case AVMEDIA_TYPE_AUDIO:
7675             err = ff_replaygain_export(st, s->metadata);
7676             if (err < 0) {
7677                 goto fail;
7678             }
7679             break;
7680         case AVMEDIA_TYPE_VIDEO:
7681             if (sc->display_matrix) {
7682                 err = av_stream_add_side_data(st, AV_PKT_DATA_DISPLAYMATRIX, (uint8_t*)sc->display_matrix,
7683                                               sizeof(int32_t) * 9);
7684                 if (err < 0)
7685                     goto fail;
7686
7687                 sc->display_matrix = NULL;
7688             }
7689             if (sc->stereo3d) {
7690                 err = av_stream_add_side_data(st, AV_PKT_DATA_STEREO3D,
7691                                               (uint8_t *)sc->stereo3d,
7692                                               sizeof(*sc->stereo3d));
7693                 if (err < 0)
7694                     goto fail;
7695
7696                 sc->stereo3d = NULL;
7697             }
7698             if (sc->spherical) {
7699                 err = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL,
7700                                               (uint8_t *)sc->spherical,
7701                                               sc->spherical_size);
7702                 if (err < 0)
7703                     goto fail;
7704
7705                 sc->spherical = NULL;
7706             }
7707             if (sc->mastering) {
7708                 err = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
7709                                               (uint8_t *)sc->mastering,
7710                                               sizeof(*sc->mastering));
7711                 if (err < 0)
7712                     goto fail;
7713
7714                 sc->mastering = NULL;
7715             }
7716             if (sc->coll) {
7717                 err = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
7718                                               (uint8_t *)sc->coll,
7719                                               sc->coll_size);
7720                 if (err < 0)
7721                     goto fail;
7722
7723                 sc->coll = NULL;
7724             }
7725             break;
7726         }
7727     }
7728     ff_configure_buffers_for_index(s, AV_TIME_BASE);
7729
7730     for (i = 0; i < mov->frag_index.nb_items; i++)
7731         if (mov->frag_index.item[i].moof_offset <= mov->fragment.moof_offset)
7732             mov->frag_index.item[i].headers_read = 1;
7733
7734     return 0;
7735 fail:
7736     mov_read_close(s);
7737     return err;
7738 }
7739
7740 static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
7741 {
7742     AVIndexEntry *sample = NULL;
7743     int64_t best_dts = INT64_MAX;
7744     int i;
7745     for (i = 0; i < s->nb_streams; i++) {
7746         AVStream *avst = s->streams[i];
7747         MOVStreamContext *msc = avst->priv_data;
7748         if (msc->pb && msc->current_sample < avst->nb_index_entries) {
7749             AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
7750             int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
7751             av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
7752             if (!sample || (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && current_sample->pos < sample->pos) ||
7753                 ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
7754                  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb && dts != AV_NOPTS_VALUE &&
7755                  ((FFABS(best_dts - dts) <= AV_TIME_BASE && current_sample->pos < sample->pos) ||
7756                   (FFABS(best_dts - dts) > AV_TIME_BASE && dts < best_dts)))))) {
7757                 sample = current_sample;
7758                 best_dts = dts;
7759                 *st = avst;
7760             }
7761         }
7762     }
7763     return sample;
7764 }
7765
7766 static int should_retry(AVIOContext *pb, int error_code) {
7767     if (error_code == AVERROR_EOF || avio_feof(pb))
7768         return 0;
7769
7770     return 1;
7771 }
7772
7773 static int mov_switch_root(AVFormatContext *s, int64_t target, int index)
7774 {
7775     int ret;
7776     MOVContext *mov = s->priv_data;
7777
7778     if (index >= 0 && index < mov->frag_index.nb_items)
7779         target = mov->frag_index.item[index].moof_offset;
7780     if (avio_seek(s->pb, target, SEEK_SET) != target) {
7781         av_log(mov->fc, AV_LOG_ERROR, "root atom offset 0x%"PRIx64": partial file\n", target);
7782         return AVERROR_INVALIDDATA;
7783     }
7784
7785     mov->next_root_atom = 0;
7786     if (index < 0 || index >= mov->frag_index.nb_items)
7787         index = search_frag_moof_offset(&mov->frag_index, target);
7788     if (index < mov->frag_index.nb_items &&
7789         mov->frag_index.item[index].moof_offset == target) {
7790         if (index + 1 < mov->frag_index.nb_items)
7791             mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
7792         if (mov->frag_index.item[index].headers_read)
7793             return 0;
7794         mov->frag_index.item[index].headers_read = 1;
7795     }
7796
7797     mov->found_mdat = 0;
7798
7799     ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
7800     if (ret < 0)
7801         return ret;
7802     if (avio_feof(s->pb))
7803         return AVERROR_EOF;
7804     av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
7805
7806     return 1;
7807 }
7808
7809 static int mov_change_extradata(MOVStreamContext *sc, AVPacket *pkt)
7810 {
7811     uint8_t *side, *extradata;
7812     int extradata_size;
7813
7814     /* Save the current index. */
7815     sc->last_stsd_index = sc->stsc_data[sc->stsc_index].id - 1;
7816
7817     /* Notify the decoder that extradata changed. */
7818     extradata_size = sc->extradata_size[sc->last_stsd_index];
7819     extradata = sc->extradata[sc->last_stsd_index];
7820     if (extradata_size > 0 && extradata) {
7821         side = av_packet_new_side_data(pkt,
7822                                        AV_PKT_DATA_NEW_EXTRADATA,
7823                                        extradata_size);
7824         if (!side)
7825             return AVERROR(ENOMEM);
7826         memcpy(side, extradata, extradata_size);
7827     }
7828
7829     return 0;
7830 }
7831
7832 static int get_eia608_packet(AVIOContext *pb, AVPacket *pkt, int size)
7833 {
7834     int new_size, ret;
7835
7836     if (size <= 8)
7837         return AVERROR_INVALIDDATA;
7838     new_size = ((size - 8) / 2) * 3;
7839     ret = av_new_packet(pkt, new_size);
7840     if (ret < 0)
7841         return ret;
7842
7843     avio_skip(pb, 8);
7844     for (int j = 0; j < new_size; j += 3) {
7845         pkt->data[j] = 0xFC;
7846         pkt->data[j+1] = avio_r8(pb);
7847         pkt->data[j+2] = avio_r8(pb);
7848     }
7849
7850     return 0;
7851 }
7852
7853 static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
7854 {
7855     MOVContext *mov = s->priv_data;
7856     MOVStreamContext *sc;
7857     AVIndexEntry *sample;
7858     AVStream *st = NULL;
7859     int64_t current_index;
7860     int ret;
7861     mov->fc = s;
7862  retry:
7863     sample = mov_find_next_sample(s, &st);
7864     if (!sample || (mov->next_root_atom && sample->pos > mov->next_root_atom)) {
7865         if (!mov->next_root_atom)
7866             return AVERROR_EOF;
7867         if ((ret = mov_switch_root(s, mov->next_root_atom, -1)) < 0)
7868             return ret;
7869         goto retry;
7870     }
7871     sc = st->priv_data;
7872     /* must be done just before reading, to avoid infinite loop on sample */
7873     current_index = sc->current_index;
7874     mov_current_sample_inc(sc);
7875
7876     if (mov->next_root_atom) {
7877         sample->pos = FFMIN(sample->pos, mov->next_root_atom);
7878         sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
7879     }
7880
7881     if (st->discard != AVDISCARD_ALL) {
7882         int64_t ret64 = avio_seek(sc->pb, sample->pos, SEEK_SET);
7883         if (ret64 != sample->pos) {
7884             av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
7885                    sc->ffindex, sample->pos);
7886             if (should_retry(sc->pb, ret64)) {
7887                 mov_current_sample_dec(sc);
7888             }
7889             return AVERROR_INVALIDDATA;
7890         }
7891
7892         if( st->discard == AVDISCARD_NONKEY && 0==(sample->flags & AVINDEX_KEYFRAME) ) {
7893             av_log(mov->fc, AV_LOG_DEBUG, "Nonkey frame from stream %d discarded due to AVDISCARD_NONKEY\n", sc->ffindex);
7894             goto retry;
7895         }
7896
7897         if (st->codecpar->codec_id == AV_CODEC_ID_EIA_608 && sample->size > 8)
7898             ret = get_eia608_packet(sc->pb, pkt, sample->size);
7899         else
7900         ret = av_get_packet(sc->pb, pkt, sample->size);
7901         if (ret < 0) {
7902             if (should_retry(sc->pb, ret)) {
7903                 mov_current_sample_dec(sc);
7904             }
7905             return ret;
7906         }
7907         if (sc->has_palette) {
7908             uint8_t *pal;
7909
7910             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
7911             if (!pal) {
7912                 av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");
7913             } else {
7914                 memcpy(pal, sc->palette, AVPALETTE_SIZE);
7915                 sc->has_palette = 0;
7916             }
7917         }
7918 #if CONFIG_DV_DEMUXER
7919         if (mov->dv_demux && sc->dv_audio_container) {
7920             avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
7921             av_freep(&pkt->data);
7922             pkt->size = 0;
7923             ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
7924             if (ret < 0)
7925                 return ret;
7926         }
7927 #endif
7928         if (st->codecpar->codec_id == AV_CODEC_ID_MP3 && !st->need_parsing && pkt->size > 4) {
7929             if (ff_mpa_check_header(AV_RB32(pkt->data)) < 0)
7930                 st->need_parsing = AVSTREAM_PARSE_FULL;
7931         }
7932     }
7933
7934     pkt->stream_index = sc->ffindex;
7935     pkt->dts = sample->timestamp;
7936     if (sample->flags & AVINDEX_DISCARD_FRAME) {
7937         pkt->flags |= AV_PKT_FLAG_DISCARD;
7938     }
7939     if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {
7940         pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;
7941         /* update ctts context */
7942         sc->ctts_sample++;
7943         if (sc->ctts_index < sc->ctts_count &&
7944             sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {
7945             sc->ctts_index++;
7946             sc->ctts_sample = 0;
7947         }
7948     } else {
7949         int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
7950             st->index_entries[sc->current_sample].timestamp : st->duration;
7951
7952         if (next_dts >= pkt->dts)
7953             pkt->duration = next_dts - pkt->dts;
7954         pkt->pts = pkt->dts;
7955     }
7956     if (st->discard == AVDISCARD_ALL)
7957         goto retry;
7958     if (sc->sdtp_data && sc->current_sample <= sc->sdtp_count) {
7959         uint8_t sample_flags = sc->sdtp_data[sc->current_sample - 1];
7960         uint8_t sample_is_depended_on = (sample_flags >> 2) & 0x3;
7961         pkt->flags |= sample_is_depended_on == MOV_SAMPLE_DEPENDENCY_NO ? AV_PKT_FLAG_DISPOSABLE : 0;
7962     }
7963     pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;
7964     pkt->pos = sample->pos;
7965
7966     /* Multiple stsd handling. */
7967     if (sc->stsc_data) {
7968         /* Keep track of the stsc index for the given sample, then check
7969         * if the stsd index is different from the last used one. */
7970         sc->stsc_sample++;
7971         if (mov_stsc_index_valid(sc->stsc_index, sc->stsc_count) &&
7972             mov_get_stsc_samples(sc, sc->stsc_index) == sc->stsc_sample) {
7973             sc->stsc_index++;
7974             sc->stsc_sample = 0;
7975         /* Do not check indexes after a switch. */
7976         } else if (sc->stsc_data[sc->stsc_index].id > 0 &&
7977                    sc->stsc_data[sc->stsc_index].id - 1 < sc->stsd_count &&
7978                    sc->stsc_data[sc->stsc_index].id - 1 != sc->last_stsd_index) {
7979             ret = mov_change_extradata(sc, pkt);
7980             if (ret < 0)
7981                 return ret;
7982         }
7983     }
7984
7985     if (mov->aax_mode)
7986         aax_filter(pkt->data, pkt->size, mov);
7987
7988     ret = cenc_filter(mov, st, sc, pkt, current_index);
7989     if (ret < 0) {
7990         return ret;
7991     }
7992
7993     return 0;
7994 }
7995
7996 static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
7997 {
7998     MOVContext *mov = s->priv_data;
7999     int index;
8000
8001     if (!mov->frag_index.complete)
8002         return 0;
8003
8004     index = search_frag_timestamp(&mov->frag_index, st, timestamp);
8005     if (index < 0)
8006         index = 0;
8007     if (!mov->frag_index.item[index].headers_read)
8008         return mov_switch_root(s, -1, index);
8009     if (index + 1 < mov->frag_index.nb_items)
8010         mov->next_root_atom = mov->frag_index.item[index + 1].moof_offset;
8011
8012     return 0;
8013 }
8014
8015 static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp, int flags)
8016 {
8017     MOVStreamContext *sc = st->priv_data;
8018     int sample, time_sample, ret;
8019     unsigned int i;
8020
8021     // Here we consider timestamp to be PTS, hence try to offset it so that we
8022     // can search over the DTS timeline.
8023     timestamp -= (sc->min_corrected_pts + sc->dts_shift);
8024
8025     ret = mov_seek_fragment(s, st, timestamp);
8026     if (ret < 0)
8027         return ret;
8028
8029     sample = av_index_search_timestamp(st, timestamp, flags);
8030     av_log(s, AV_LOG_TRACE, "stream %d, timestamp %"PRId64", sample %d\n", st->index, timestamp, sample);
8031     if (sample < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
8032         sample = 0;
8033     if (sample < 0) /* not sure what to do */
8034         return AVERROR_INVALIDDATA;
8035     mov_current_sample_set(sc, sample);
8036     av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample);
8037     /* adjust ctts index */
8038     if (sc->ctts_data) {
8039         time_sample = 0;
8040         for (i = 0; i < sc->ctts_count; i++) {
8041             int next = time_sample + sc->ctts_data[i].count;
8042             if (next > sc->current_sample) {
8043                 sc->ctts_index = i;
8044                 sc->ctts_sample = sc->current_sample - time_sample;
8045                 break;
8046             }
8047             time_sample = next;
8048         }
8049     }
8050
8051     /* adjust stsd index */
8052     if (sc->chunk_count) {
8053     time_sample = 0;
8054     for (i = 0; i < sc->stsc_count; i++) {
8055         int64_t next = time_sample + mov_get_stsc_samples(sc, i);
8056         if (next > sc->current_sample) {
8057             sc->stsc_index = i;
8058             sc->stsc_sample = sc->current_sample - time_sample;
8059             break;
8060         }
8061         av_assert0(next == (int)next);
8062         time_sample = next;
8063     }
8064     }
8065
8066     return sample;
8067 }
8068
8069 static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
8070 {
8071     MOVContext *mc = s->priv_data;
8072     AVStream *st;
8073     int sample;
8074     int i;
8075
8076     if (stream_index >= s->nb_streams)
8077         return AVERROR_INVALIDDATA;
8078
8079     st = s->streams[stream_index];
8080     sample = mov_seek_stream(s, st, sample_time, flags);
8081     if (sample < 0)
8082         return sample;
8083
8084     if (mc->seek_individually) {
8085         /* adjust seek timestamp to found sample timestamp */
8086         int64_t seek_timestamp = st->index_entries[sample].timestamp;
8087
8088         for (i = 0; i < s->nb_streams; i++) {
8089             int64_t timestamp;
8090             MOVStreamContext *sc = s->streams[i]->priv_data;
8091             st = s->streams[i];
8092             st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
8093
8094             if (stream_index == i)
8095                 continue;
8096
8097             timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base);
8098             mov_seek_stream(s, st, timestamp, flags);
8099         }
8100     } else {
8101         for (i = 0; i < s->nb_streams; i++) {
8102             MOVStreamContext *sc;
8103             st = s->streams[i];
8104             sc = st->priv_data;
8105             mov_current_sample_set(sc, 0);
8106         }
8107         while (1) {
8108             MOVStreamContext *sc;
8109             AVIndexEntry *entry = mov_find_next_sample(s, &st);
8110             if (!entry)
8111                 return AVERROR_INVALIDDATA;
8112             sc = st->priv_data;
8113             if (sc->ffindex == stream_index && sc->current_sample == sample)
8114                 break;
8115             mov_current_sample_inc(sc);
8116         }
8117     }
8118     return 0;
8119 }
8120
8121 #define OFFSET(x) offsetof(MOVContext, x)
8122 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
8123 static const AVOption mov_options[] = {
8124     {"use_absolute_path",
8125         "allow using absolute path when opening alias, this is a possible security issue",
8126         OFFSET(use_absolute_path), AV_OPT_TYPE_BOOL, {.i64 = 0},
8127         0, 1, FLAGS},
8128     {"seek_streams_individually",
8129         "Seek each stream individually to the closest point",
8130         OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
8131         0, 1, FLAGS},
8132     {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
8133         0, 1, FLAGS},
8134     {"advanced_editlist",
8135         "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
8136         OFFSET(advanced_editlist), AV_OPT_TYPE_BOOL, {.i64 = 1},
8137         0, 1, FLAGS},
8138     {"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 = 0},
8139         0, 1, FLAGS},
8140     {"use_mfra_for",
8141         "use mfra for fragment timestamps",
8142         OFFSET(use_mfra_for), AV_OPT_TYPE_INT, {.i64 = FF_MOV_FLAG_MFRA_AUTO},
8143         -1, FF_MOV_FLAG_MFRA_PTS, FLAGS,
8144         "use_mfra_for"},
8145     {"auto", "auto", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_AUTO}, 0, 0,
8146         FLAGS, "use_mfra_for" },
8147     {"dts", "dts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_DTS}, 0, 0,
8148         FLAGS, "use_mfra_for" },
8149     {"pts", "pts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_PTS}, 0, 0,
8150         FLAGS, "use_mfra_for" },
8151     { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
8152         AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
8153     { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
8154         AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = FLAGS },
8155     { "activation_bytes", "Secret bytes for Audible AAX files", OFFSET(activation_bytes),
8156         AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
8157     { "audible_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
8158         "Fixed key used for handling Audible AAX files", OFFSET(audible_fixed_key),
8159         AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd20a51d67"},
8160         .flags = AV_OPT_FLAG_DECODING_PARAM },
8161     { "decryption_key", "The media decryption key (hex)", OFFSET(decryption_key), AV_OPT_TYPE_BINARY, .flags = AV_OPT_FLAG_DECODING_PARAM },
8162     { "enable_drefs", "Enable external track support.", OFFSET(enable_drefs), AV_OPT_TYPE_BOOL,
8163         {.i64 = 0}, 0, 1, FLAGS },
8164
8165     { NULL },
8166 };
8167
8168 static const AVClass mov_class = {
8169     .class_name = "mov,mp4,m4a,3gp,3g2,mj2",
8170     .item_name  = av_default_item_name,
8171     .option     = mov_options,
8172     .version    = LIBAVUTIL_VERSION_INT,
8173 };
8174
8175 AVInputFormat ff_mov_demuxer = {
8176     .name           = "mov,mp4,m4a,3gp,3g2,mj2",
8177     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime / MOV"),
8178     .priv_class     = &mov_class,
8179     .priv_data_size = sizeof(MOVContext),
8180     .extensions     = "mov,mp4,m4a,3gp,3g2,mj2,psp,m4b,ism,ismv,isma,f4v",
8181     .read_probe     = mov_probe,
8182     .read_header    = mov_read_header,
8183     .read_packet    = mov_read_packet,
8184     .read_close     = mov_read_close,
8185     .read_seek      = mov_read_seek,
8186     .flags          = AVFMT_NO_BYTE_SEEK | AVFMT_SEEK_TO_PTS,
8187 };