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

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