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

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