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