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