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