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

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