git.sesse.net Git - ffmpeg/blob - libavformat/mov.c

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