Merge commit '32125781487411ed3b1b28b32063d6cd4024d4fc'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Jan 2015 17:32:19 +0000 (18:32 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 27 Jan 2015 17:32:23 +0000 (18:32 +0100)
* commit '32125781487411ed3b1b28b32063d6cd4024d4fc':
  mov: export audio service type as side data

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/mov.c

diff --combined libavformat/mov.c
@@@ -6,20 -6,20 +6,20 @@@
   * first version by Francois Revol <revol@free.fr>
   * seek function by Gael Chardon <gael.dev@4now.net>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -35,9 -35,7 +35,9 @@@
  #include "libavutil/time_internal.h"
  #include "libavutil/avstring.h"
  #include "libavutil/dict.h"
 +#include "libavutil/display.h"
  #include "libavutil/opt.h"
 +#include "libavutil/timecode.h"
  #include "libavcodec/ac3tab.h"
  #include "avformat.h"
  #include "internal.h"
@@@ -67,7 -65,6 +67,7 @@@ typedef struct MOVParseTableEntry 
  } MOVParseTableEntry;
  
  static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
 +static int mov_read_mfra(MOVContext *c, AVIOContext *f);
  
  static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
                                               unsigned len, const char *key)
  static int mov_metadata_int8_bypass_padding(MOVContext *c, AVIOContext *pb,
                                              unsigned len, const char *key)
  {
 -    char buf[16];
 -
      /* bypass padding bytes */
      avio_r8(pb);
      avio_r8(pb);
      avio_r8(pb);
  
 -    snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
      c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 -    av_dict_set(&c->fc->metadata, key, buf, 0);
 +    av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
  
      return 0;
  }
  static int mov_metadata_int8_no_padding(MOVContext *c, AVIOContext *pb,
                                          unsigned len, const char *key)
  {
 -    char buf[16];
 -
 -    snprintf(buf, sizeof(buf), "%d", avio_r8(pb));
      c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 -    av_dict_set(&c->fc->metadata, key, buf, 0);
 +    av_dict_set_int(&c->fc->metadata, key, avio_r8(pb), 0);
  
      return 0;
  }
@@@ -116,14 -119,16 +116,14 @@@ static int mov_metadata_gnre(MOVContex
                               unsigned len, const char *key)
  {
      short genre;
 -    char buf[20];
  
      avio_r8(pb); // unknown
  
      genre = avio_r8(pb);
      if (genre < 1 || genre > ID3v1_GENRE_MAX)
          return 0;
 -    snprintf(buf, sizeof(buf), "%s", ff_id3v1_genre_str[genre-1]);
      c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
 -    av_dict_set(&c->fc->metadata, key, buf, 0);
 +    av_dict_set(&c->fc->metadata, key, ff_id3v1_genre_str[genre-1], 0);
  
      return 0;
  }
@@@ -158,7 -163,7 +158,7 @@@ static int mov_read_mac_string(MOVConte
          uint8_t t, c = avio_r8(pb);
          if (c < 0x80 && p < end)
              *p++ = c;
 -        else
 +        else if (p < end)
              PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
      }
      *p = 0;
@@@ -248,8 -253,7 +248,8 @@@ static int mov_metadata_loci(MOVContex
  static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      char tmp_key[5];
 -    char *str, key2[32], language[4] = {0};
 +    char key2[32], language[4] = {0};
 +    char *str = NULL;
      const char *key = NULL;
      uint16_t langcode = 0;
      uint32_t data_type = 0, str_size, str_size_alloc;
                  int ret = mov_read_covr(c, pb, data_type, str_size);
                  if (ret < 0) {
                      av_log(c->fc, AV_LOG_ERROR, "Error parsing cover art.\n");
 -                    return ret;
                  }
 +                return ret;
              }
          } else return 0;
      } else if (atom.size > 4 && key && !c->itunes_metadata && !raw) {
  
      if (!key)
          return 0;
 -    if (atom.size < 0)
 +    if (atom.size < 0 || str_size >= INT_MAX/2)
          return AVERROR_INVALIDDATA;
  
 -    // allocate twice as much as worst-case
 +    // worst-case requirement for output string in case of utf8 coded input
      str_size_alloc = (raw ? str_size : str_size * 2) + 1;
 -    str = av_malloc(str_size_alloc);
 +    str = av_mallocz(str_size_alloc);
      if (!str)
          return AVERROR(ENOMEM);
  
          if (!raw && (data_type == 3 || (data_type == 0 && (langcode < 0x400 || langcode == 0x7fff)))) { // MAC Encoded
              mov_read_mac_string(c, pb, str_size, str, str_size_alloc);
          } else {
 -            avio_read(pb, str, str_size);
 +            int ret = avio_read(pb, str, str_size);
 +            if (ret != str_size) {
 +                av_freep(&str);
 +                return ret < 0 ? ret : AVERROR_INVALIDDATA;
 +            }
              str[str_size] = 0;
          }
          c->fc->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
@@@ -462,7 -462,6 +462,7 @@@ static int mov_read_dref(MOVContext *c
          entries >= UINT_MAX / sizeof(*sc->drefs))
          return AVERROR_INVALIDDATA;
      av_free(sc->drefs);
 +    sc->drefs_count = 0;
      sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
      if (!sc->drefs)
          return AVERROR(ENOMEM);
              avio_skip(pb, 16);
  
              for (type = 0; type != -1 && avio_tell(pb) < next; ) {
 -                if (pb->eof_reached)
 +                if(avio_feof(pb))
                      return AVERROR_EOF;
                  type = avio_rb16(pb);
                  len = avio_rb16(pb);
                      dref->dir = av_malloc(len+1);
                      if (!dref->dir)
                          return AVERROR(ENOMEM);
 -                    avio_read(pb, dref->dir, len);
 +                    if (avio_read(pb, dref->dir, len) != len)
 +                        return AVERROR_INVALIDDATA;
                      dref->dir[len] = 0;
                      for (j = 0; j < len; j++)
                          if (dref->dir[j] == ':')
@@@ -560,8 -558,6 +560,8 @@@ static int mov_read_hdlr(MOVContext *c
      AVStream *st;
      uint32_t type;
      uint32_t av_unused ctype;
 +    int title_size;
 +    char *title_str;
  
      if (c->fc->nb_streams < 1) // meta before first trak
          return 0;
      avio_rb32(pb); /* component flags */
      avio_rb32(pb); /* component flags mask */
  
 +    title_size = atom.size - 24;
 +    if (title_size > 0) {
 +        title_str = av_malloc(title_size + 1); /* Add null terminator */
 +        if (!title_str)
 +            return AVERROR(ENOMEM);
 +        avio_read(pb, title_str, title_size);
 +        title_str[title_size] = 0;
 +        if (title_str[0])
 +            av_dict_set(&st->metadata, "handler_name", title_str +
 +                        (!c->isom && title_str[0] == title_size - 1), 0);
 +        av_freep(&title_str);
 +    }
 +
      return 0;
  }
  
@@@ -637,12 -620,18 +637,18 @@@ static int mov_read_esds(MOVContext *c
  static int mov_read_dac3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
+     enum AVAudioServiceType *ast;
      int ac3info, acmod, lfeon, bsmod;
  
      if (c->fc->nb_streams < 1)
          return 0;
      st = c->fc->streams[c->fc->nb_streams-1];
  
+     ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+                                                             sizeof(*ast));
+     if (!ast)
+         return AVERROR(ENOMEM);
      ac3info = avio_rb24(pb);
      bsmod = (ac3info >> 14) & 0x7;
      acmod = (ac3info >> 11) & 0x7;
      st->codec->channel_layout = avpriv_ac3_channel_layout_tab[acmod];
      if (lfeon)
          st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
-     st->codec->audio_service_type = bsmod;
+     *ast = bsmod;
      if (st->codec->channels > 1 && bsmod == 0x7)
-         st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+         *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+     st->codec->audio_service_type = *ast;
  
      return 0;
  }
  static int mov_read_dec3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
+     enum AVAudioServiceType *ast;
      int eac3info, acmod, lfeon, bsmod;
  
      if (c->fc->nb_streams < 1)
          return 0;
      st = c->fc->streams[c->fc->nb_streams-1];
  
+     ast = (enum AVAudioServiceType*)ff_stream_new_side_data(st, AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+                                                             sizeof(*ast));
+     if (!ast)
+         return AVERROR(ENOMEM);
      /* No need to parse fields for additional independent substreams and its
       * associated dependent substreams since libavcodec's E-AC-3 decoder
       * does not support them yet. */
      if (lfeon)
          st->codec->channel_layout |= AV_CH_LOW_FREQUENCY;
      st->codec->channels = av_get_channel_layout_nb_channels(st->codec->channel_layout);
-     st->codec->audio_service_type = bsmod;
+     *ast = bsmod;
      if (st->codec->channels > 1 && bsmod == 0x7)
-         st->codec->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+         *ast = AV_AUDIO_SERVICE_TYPE_KARAOKE;
+     st->codec->audio_service_type = *ast;
  
      return 0;
  }
@@@ -708,16 -707,12 +724,16 @@@ static int mov_read_chan(MOVContext *c
  static int mov_read_wfex(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
 +    int ret;
  
      if (c->fc->nb_streams < 1)
          return 0;
      st = c->fc->streams[c->fc->nb_streams-1];
  
 -    return ff_get_wav_header(pb, st->codec, atom.size);
 +    if ((ret = ff_get_wav_header(pb, st->codec, atom.size, 0)) < 0)
 +        av_log(c->fc, AV_LOG_WARNING, "get_wav_header failed\n");
 +
 +    return ret;
  }
  
  static int mov_read_pasp(MOVContext *c, AVIOContext *pb, MOVAtom atom)
@@@ -757,6 -752,7 +773,6 @@@ static int mov_read_ftyp(MOVContext *c
  {
      uint32_t minor_ver;
      int comp_brand_size;
 -    char minor_ver_str[11]; /* 32 bit integer -> 10 digits + null */
      char* comp_brands_str;
      uint8_t type[5] = {0};
  
      av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
      av_dict_set(&c->fc->metadata, "major_brand", type, 0);
      minor_ver = avio_rb32(pb); /* minor version */
 -    snprintf(minor_ver_str, sizeof(minor_ver_str), "%"PRIu32"", minor_ver);
 -    av_dict_set(&c->fc->metadata, "minor_version", minor_ver_str, 0);
 +    av_dict_set_int(&c->fc->metadata, "minor_version", minor_ver, 0);
  
      comp_brand_size = atom.size - 8;
      if (comp_brand_size < 0)
@@@ -787,12 -784,6 +803,12 @@@ static int mov_read_moov(MOVContext *c
  {
      int ret;
  
 +    if (c->found_moov) {
 +        av_log(c->fc, AV_LOG_WARNING, "Found duplicated MOOV Atom. Skipped it\n");
 +        avio_skip(pb, atom.size);
 +        return 0;
 +    }
 +
      if ((ret = mov_read_default(c, pb, atom)) < 0)
          return ret;
      /* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
  
  static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
 +    if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
 +        c->has_looked_for_mfra = 1;
 +        if (pb->seekable) {
 +            int ret;
 +            av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
 +                    "for a mfra\n");
 +            if ((ret = mov_read_mfra(c, pb)) < 0) {
 +                av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but failed to "
 +                        "read the mfra (may be a live ismv)\n");
 +            }
 +        } else {
 +            av_log(c->fc, AV_LOG_VERBOSE, "found a moof box but stream is not "
 +                    "seekable, can not look for mfra\n");
 +        }
 +    }
      c->fragment.moof_offset = c->fragment.implicit_offset = avio_tell(pb) - 8;
      av_dlog(c->fc, "moof offset %"PRIx64"\n", c->fragment.moof_offset);
      return mov_read_default(c, pb, atom);
  }
  
 -static void mov_metadata_creation_time(AVDictionary **metadata, time_t time)
 +static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
  {
      char buffer[32];
      if (time) {
          struct tm *ptm, tmbuf;
 -        time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
 -        ptm = gmtime_r(&time, &tmbuf);
 +        time_t timet;
 +        if(time >= 2082844800)
 +            time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
 +        timet = time;
 +        ptm = gmtime_r(&timet, &tmbuf);
          if (!ptm) return;
          if (strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm))
              av_dict_set(metadata, "creation_time", buffer, 0);
@@@ -846,7 -819,7 +862,7 @@@ static int mov_read_mdhd(MOVContext *c
      int version;
      char language[4] = {0};
      unsigned lang;
 -    time_t creation_time;
 +    int64_t creation_time;
  
      if (c->fc->nb_streams < 1)
          return 0;
  
  static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
 -    time_t creation_time;
 +    int64_t creation_time;
      int version = avio_r8(pb); /* version */
      avio_rb24(pb); /* flags */
  
      av_dlog(c->fc, "time scale = %i\n", c->time_scale);
  
      c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
 +    // set the AVCodecContext duration because the duration of individual tracks
 +    // may be inaccurate
 +    if (c->time_scale > 0 && !c->trex_data)
 +        c->fc->duration = av_rescale(c->duration, AV_TIME_BASE, c->time_scale);
      avio_rb32(pb); /* preferred scale */
  
      avio_rb16(pb); /* preferred volume */
      avio_rb32(pb); /* selection duration */
      avio_rb32(pb); /* current time */
      avio_rb32(pb); /* next track ID */
 -
 -    return 0;
 -}
 -
 -static int mov_read_smi(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 -{
 -    AVStream *st;
 -
 -    if (c->fc->nb_streams < 1)
 -        return 0;
 -    st = c->fc->streams[c->fc->nb_streams-1];
 -
 -    if ((uint64_t)atom.size > (1<<30))
 -        return AVERROR_INVALIDDATA;
 -
 -    // currently SVQ3 decoder expect full STSD header - so let's fake it
 -    // this should be fixed and just SMI header should be passed
 -    av_free(st->codec->extradata);
 -    st->codec->extradata = av_mallocz(atom.size + 0x5a + FF_INPUT_BUFFER_PADDING_SIZE);
 -    if (!st->codec->extradata)
 -        return AVERROR(ENOMEM);
 -    st->codec->extradata_size = 0x5a + atom.size;
 -    memcpy(st->codec->extradata, "SVQ3", 4); // fake
 -    avio_read(pb, st->codec->extradata + 0x5a, atom.size);
 -    av_dlog(c->fc, "Reading SMI %"PRId64"  %s\n", atom.size, st->codec->extradata + 0x5a);
      return 0;
  }
  
@@@ -934,7 -928,7 +950,7 @@@ static int mov_read_enda(MOVContext *c
          return 0;
      st = c->fc->streams[c->fc->nb_streams-1];
  
 -    little_endian = avio_rb16(pb);
 +    little_endian = avio_rb16(pb) & 0xFF;
      av_dlog(c->fc, "enda %d\n", little_endian);
      if (little_endian == 1) {
          switch (st->codec->codec_id) {
@@@ -979,12 -973,12 +995,12 @@@ static int mov_read_colr(MOVContext *c
      color_trc = avio_rb16(pb);
      color_matrix = avio_rb16(pb);
  
 -    av_dlog(c->fc, "%s: pri %"PRIu16" trc %"PRIu16" matrix %"PRIu16"",
 +    av_dlog(c->fc, "%s: pri %d trc %d matrix %d",
              color_parameter_type, color_primaries, color_trc, color_matrix);
  
      if (c->isom) {
          uint8_t color_range = avio_r8(pb) >> 7;
 -        av_dlog(c->fc, " full %"PRIu8"", color_range)
 +        av_dlog(c->fc, " full %"PRIu8"", color_range);
          if (color_range)
              st->codec->color_range = AVCOL_RANGE_JPEG;
          else
          case 7: st->codec->colorspace = AVCOL_SPC_SMPTE240M; break;
          }
      }
 -    av_dlog(c->fc, "\n")
 +    av_dlog(c->fc, "\n");
  
      return 0;
  }
@@@ -1061,8 -1055,7 +1077,8 @@@ static int mov_read_fiel(MOVContext *c
  }
  
  /* FIXME modify qdm2/svq3/h264 decoders to take full atom as extradata */
 -static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
 +                              enum AVCodecID codec_id)
  {
      AVStream *st;
      uint64_t size;
      if (c->fc->nb_streams < 1) // will happen with jp2 files
          return 0;
      st= c->fc->streams[c->fc->nb_streams-1];
 +
 +    if (st->codec->codec_id != codec_id)
 +        return 0; /* unexpected codec_id - don't mess with extradata */
 +
      size= (uint64_t)st->codec->extradata_size + atom.size + 8 + FF_INPUT_BUFFER_PADDING_SIZE;
      if (size > INT_MAX || (uint64_t)atom.size > INT_MAX)
          return AVERROR_INVALIDDATA;
      st->codec->extradata_size= size - FF_INPUT_BUFFER_PADDING_SIZE;
      AV_WB32(       buf    , atom.size + 8);
      AV_WL32(       buf + 4, atom.type);
 -    avio_read(pb, buf + 8, atom.size);
 +    err = avio_read(pb, buf + 8, atom.size);
 +    if (err < 0) {
 +        return err;
 +    } else if (err < atom.size) {
 +        av_log(c->fc, AV_LOG_WARNING, "truncated extradata\n");
 +        st->codec->extradata_size -= atom.size - err;
 +    }
 +    memset(buf + 8 + err, 0, FF_INPUT_BUFFER_PADDING_SIZE);
      return 0;
  }
  
 +/* wrapper functions for reading ALAC/AVS/MJPEG/MJPEG2000 extradata atoms only for those codecs */
 +static int mov_read_alac(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    return mov_read_extradata(c, pb, atom, AV_CODEC_ID_ALAC);
 +}
 +
 +static int mov_read_avss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    return mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVS);
 +}
 +
 +static int mov_read_jp2h(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    return mov_read_extradata(c, pb, atom, AV_CODEC_ID_JPEG2000);
 +}
 +
 +static int mov_read_dpxe(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    return mov_read_extradata(c, pb, atom, AV_CODEC_ID_R10K);
 +}
 +
 +static int mov_read_avid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_AVUI);
 +    if(ret == 0)
 +        ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_DNXHD);
 +    return ret;
 +}
 +
 +static int mov_read_targa_y216(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    int ret = mov_read_extradata(c, pb, atom, AV_CODEC_ID_TARGA_Y216);
 +
 +    if (!ret && c->fc->nb_streams >= 1) {
 +        AVCodecContext *avctx = c->fc->streams[c->fc->nb_streams-1]->codec;
 +        if (avctx->extradata_size >= 40) {
 +            avctx->height = AV_RB16(&avctx->extradata[36]);
 +            avctx->width  = AV_RB16(&avctx->extradata[38]);
 +        }
 +    }
 +    return ret;
 +}
 +
 +static int mov_read_ares(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    if (c->fc->nb_streams >= 1) {
 +        AVCodecContext *codec = c->fc->streams[c->fc->nb_streams-1]->codec;
 +        if (codec->codec_tag == MKTAG('A', 'V', 'i', 'n') &&
 +            codec->codec_id == AV_CODEC_ID_H264 &&
 +            atom.size > 11) {
 +            avio_skip(pb, 10);
 +            /* For AVID AVCI50, force width of 1440 to be able to select the correct SPS and PPS */
 +            if (avio_rb16(pb) == 0xd4d)
 +                codec->width = 1440;
 +            return 0;
 +        }
 +    }
 +
 +    return mov_read_avid(c, pb, atom);
 +}
 +
 +static int mov_read_svq3(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    return mov_read_extradata(c, pb, atom, AV_CODEC_ID_SVQ3);
 +}
 +
  static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
      if ((uint64_t)atom.size > (1<<30))
          return AVERROR_INVALIDDATA;
  
 -    if (st->codec->codec_id == AV_CODEC_ID_QDM2 || st->codec->codec_id == AV_CODEC_ID_QDMC) {
 +    if (st->codec->codec_id == AV_CODEC_ID_QDM2 ||
 +        st->codec->codec_id == AV_CODEC_ID_QDMC ||
 +        st->codec->codec_id == AV_CODEC_ID_SPEEX) {
          // pass all frma atom to codec, needed at least for QDMC and QDM2
 -        av_free(st->codec->extradata);
 -        st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
 -        if (!st->codec->extradata)
 +        av_freep(&st->codec->extradata);
 +        if (ff_get_extradata(st->codec, pb, atom.size) < 0)
              return AVERROR(ENOMEM);
 -        st->codec->extradata_size = atom.size;
 -        avio_read(pb, st->codec->extradata, atom.size);
      } else if (atom.size > 8) { /* to read frma, esds atoms */
          int ret;
          if ((ret = mov_read_default(c, pb, atom)) < 0)
@@@ -1215,14 -1132,12 +1231,14 @@@ static int mov_read_glbl(MOVContext *c
          if (type == MKTAG('f','i','e','l') && size == atom.size)
              return mov_read_default(c, pb, atom);
      }
 -    av_free(st->codec->extradata);
 -    st->codec->extradata = av_mallocz(atom.size + FF_INPUT_BUFFER_PADDING_SIZE);
 -    if (!st->codec->extradata)
 +    if (st->codec->extradata_size > 1 && st->codec->extradata) {
 +        av_log(c, AV_LOG_WARNING, "ignoring multiple glbl\n");
 +        return 0;
 +    }
 +    av_freep(&st->codec->extradata);
 +    if (ff_get_extradata(st->codec, pb, atom.size) < 0)
          return AVERROR(ENOMEM);
 -    st->codec->extradata_size = atom.size;
 -    avio_read(pb, st->codec->extradata, atom.size);
 +
      return 0;
  }
  
@@@ -1230,7 -1145,6 +1246,7 @@@ static int mov_read_dvc1(MOVContext *c
  {
      AVStream *st;
      uint8_t profile_level;
 +    int ret;
  
      if (c->fc->nb_streams < 1)
          return 0;
      if ((profile_level & 0xf0) != 0xc0)
          return 0;
  
 -    av_free(st->codec->extradata);
 -    st->codec->extradata = av_mallocz(atom.size - 7 + FF_INPUT_BUFFER_PADDING_SIZE);
 -    if (!st->codec->extradata)
 -        return AVERROR(ENOMEM);
 -    st->codec->extradata_size = atom.size - 7;
      avio_seek(pb, 6, SEEK_CUR);
 -    avio_read(pb, st->codec->extradata, st->codec->extradata_size);
 +    av_freep(&st->codec->extradata);
 +    if ((ret = ff_get_extradata(st->codec, pb, atom.size - 7)) < 0)
 +        return ret;
 +
      return 0;
  }
  
@@@ -1269,10 -1185,13 +1285,10 @@@ static int mov_read_strf(MOVContext *c
      if ((uint64_t)atom.size > (1<<30))
          return AVERROR_INVALIDDATA;
  
 -    av_free(st->codec->extradata);
 -    st->codec->extradata = av_mallocz(atom.size - 40 + FF_INPUT_BUFFER_PADDING_SIZE);
 -    if (!st->codec->extradata)
 -        return AVERROR(ENOMEM);
 -    st->codec->extradata_size = atom.size - 40;
      avio_skip(pb, 40);
 -    avio_read(pb, st->codec->extradata, atom.size - 40);
 +    av_freep(&st->codec->extradata);
 +    if (ff_get_extradata(st->codec, pb, atom.size - 40) < 0)
 +        return AVERROR(ENOMEM);
      return 0;
  }
  
@@@ -1294,12 -1213,10 +1310,12 @@@ static int mov_read_stco(MOVContext *c
  
      if (!entries)
          return 0;
 -    if (entries >= UINT_MAX/sizeof(int64_t))
 -        return AVERROR_INVALIDDATA;
  
 -    sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
 +    if (sc->chunk_offsets)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STCO atom\n");
 +    av_free(sc->chunk_offsets);
 +    sc->chunk_count = 0;
 +    sc->chunk_offsets = av_malloc_array(entries, sizeof(*sc->chunk_offsets));
      if (!sc->chunk_offsets)
          return AVERROR(ENOMEM);
      sc->chunk_count = entries;
@@@ -1354,9 -1271,7 +1370,9 @@@ static int mov_codec_id(AVStream *st, u
              id = ff_codec_get_id(ff_codec_bmp_tags, format);
          if (id > 0)
              st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
 -        else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
 +        else if (st->codec->codec_type == AVMEDIA_TYPE_DATA ||
 +                    (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE &&
 +                    st->codec->codec_id == AV_CODEC_ID_NONE)) {
              id = ff_codec_get_id(ff_codec_movsubtitle_tags, format);
              if (id > 0)
                  st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
@@@ -1401,11 -1316,8 +1417,11 @@@ static void mov_parse_stsd_video(MOVCon
          av_dict_set(&st->metadata, "encoder", codec_name, 0);
  
      /* codec_tag YV12 triggers an UV swap in rawdec.c */
 -    if (!memcmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25))
 +    if (!memcmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
          st->codec->codec_tag = MKTAG('I', '4', '2', '0');
 +        st->codec->width &= ~1;
 +        st->codec->height &= ~1;
 +    }
      /* Flash Media Server uses tag H263 with Sorenson Spark */
      if (st->codec->codec_tag == MKTAG('H','2','6','3') &&
          !memcmp(codec_name, "Sorenson H263", 13))
      /* figure out the palette situation */
      color_depth     = st->codec->bits_per_coded_sample & 0x1F;
      color_greyscale = st->codec->bits_per_coded_sample & 0x20;
 +    /* Do not create a greyscale palette for cinepak */
 +    if (color_greyscale && st->codec->codec_id == AV_CODEC_ID_CINEPAK)
 +        return;
  
      /* if the depth is 2, 4, or 8 bpp, file is palettized */
      if ((color_depth == 2) || (color_depth == 4) || (color_depth == 8)) {
          /* for palette traversal */
          unsigned int color_start, color_count, color_end;
 -        unsigned char r, g, b;
 +        unsigned char a, r, g, b;
  
          if (color_greyscale) {
              int color_index, color_dec;
              color_dec   = 256 / (color_count - 1);
              for (j = 0; j < color_count; j++) {
                  r = g = b = color_index;
 -                sc->palette[j] = (r << 16) | (g << 8) | (b);
 +                sc->palette[j] = (0xFFU << 24) | (r << 16) | (g << 8) | (b);
                  color_index -= color_dec;
                  if (color_index < 0)
                      color_index = 0;
                  r = color_table[j * 3 + 0];
                  g = color_table[j * 3 + 1];
                  b = color_table[j * 3 + 2];
 -                sc->palette[j] = (r << 16) | (g << 8) | (b);
 +                sc->palette[j] = (0xFFU << 24) | (r << 16) | (g << 8) | (b);
              }
          } else {
              /* load the palette from the file */
              color_end   = avio_rb16(pb);
              if ((color_start <= 255) && (color_end <= 255)) {
                  for (j = color_start; j <= color_end; j++) {
 -                    /* each R, G, or B component is 16 bits;
 -                     * only use the top 8 bits; skip alpha bytes
 -                     * up front */
 -                    avio_r8(pb);
 +                    /* each A, R, G, or B component is 16 bits;
 +                        * only use the top 8 bits */
 +                    a = avio_r8(pb);
                      avio_r8(pb);
                      r = avio_r8(pb);
                      avio_r8(pb);
                      avio_r8(pb);
                      b = avio_r8(pb);
                      avio_r8(pb);
 -                    sc->palette[j] = (r << 16) | (g << 8) | (b);
 +                    sc->palette[j] = (a << 24 ) | (r << 16) | (g << 8) | (b);
                  }
              }
          }
@@@ -1489,7 -1399,6 +1505,7 @@@ static void mov_parse_stsd_audio(MOVCon
  {
      int bits_per_sample, flags;
      uint16_t version = avio_rb16(pb);
 +    AVDictionaryEntry *compatible_brands = av_dict_get(c->fc->metadata, "compatible_brands", NULL, AV_DICT_MATCH_CASE);
  
      avio_rb16(pb); /* revision level */
      avio_rb32(pb); /* vendor */
  
      // Read QT version 1 fields. In version 0 these do not exist.
      av_dlog(c->fc, "version =%d, isom =%d\n", version, c->isom);
 -    if (!c->isom) {
 +    if (!c->isom ||
 +        (compatible_brands && strstr(compatible_brands->value, "qt  "))) {
 +
          if (version == 1) {
              sc->samples_per_frame = avio_rb32(pb);
              avio_rb32(pb); /* bytes per packet */
              st->codec->codec_id =
                  st->codec->codec_id == AV_CODEC_ID_PCM_S16BE ?
                  AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
 +        else if (st->codec->bits_per_coded_sample == 32)
 +             st->codec->codec_id =
 +                st->codec->codec_id == AV_CODEC_ID_PCM_S16BE ?
 +                AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
          break;
      /* set values for old format before stsd version 1 appeared */
      case AV_CODEC_ID_MACE3:
  
  static void mov_parse_stsd_subtitle(MOVContext *c, AVIOContext *pb,
                                      AVStream *st, MOVStreamContext *sc,
 -                                    int size)
 +                                    int64_t size)
  {
      // ttxt stsd contains display flags, justification, background
      // color, fonts, and default styles, so fake an atom to read it
@@@ -1644,48 -1547,14 +1660,48 @@@ static int mov_rewrite_dvd_sub_extradat
  
  static int mov_parse_stsd_data(MOVContext *c, AVIOContext *pb,
                                  AVStream *st, MOVStreamContext *sc,
 -                                int size)
 +                                int64_t size)
  {
      if (st->codec->codec_tag == MKTAG('t','m','c','d')) {
 -        st->codec->extradata_size = size;
 -        st->codec->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 -        if (!st->codec->extradata)
 +        if ((int)size != size || ff_get_extradata(st->codec, pb, size) < 0)
              return AVERROR(ENOMEM);
 -        avio_read(pb, st->codec->extradata, size);
 +        if (size > 16) {
 +            MOVStreamContext *tmcd_ctx = st->priv_data;
 +            int val;
 +            val = AV_RB32(st->codec->extradata + 4);
 +            tmcd_ctx->tmcd_flags = val;
 +            if (val & 1)
 +                st->codec->flags2 |= CODEC_FLAG2_DROP_FRAME_TIMECODE;
 +            st->codec->time_base.den = st->codec->extradata[16]; /* number of frame */
 +            st->codec->time_base.num = 1;
 +            /* adjust for per frame dur in counter mode */
 +            if (tmcd_ctx->tmcd_flags & 0x0008) {
 +                int timescale = AV_RB32(st->codec->extradata + 8);
 +                int framedur = AV_RB32(st->codec->extradata + 12);
 +                st->codec->time_base.den *= timescale;
 +                st->codec->time_base.num *= framedur;
 +            }
 +            if (size > 30) {
 +                uint32_t len = AV_RB32(st->codec->extradata + 18); /* name atom length */
 +                uint32_t format = AV_RB32(st->codec->extradata + 22);
 +                if (format == AV_RB32("name") && (int64_t)size >= (int64_t)len + 18) {
 +                    uint16_t str_size = AV_RB16(st->codec->extradata + 26); /* string length */
 +                    if (str_size > 0 && size >= (int)str_size + 26) {
 +                        char *reel_name = av_malloc(str_size + 1);
 +                        if (!reel_name)
 +                            return AVERROR(ENOMEM);
 +                        memcpy(reel_name, st->codec->extradata + 30, str_size);
 +                        reel_name[str_size] = 0; /* Add null terminator */
 +                        /* don't add reel_name if emtpy string */
 +                        if (*reel_name == 0) {
 +                            av_free(reel_name);
 +                        } else {
 +                            av_dict_set(&st->metadata, "reel_name", reel_name,  AV_DICT_DONT_STRDUP_VAL);
 +                        }
 +                    }
 +                }
 +            }
 +        }
      } else {
          /* other codec type, just skip (rtp, mp4s ...) */
          avio_skip(pb, size);
@@@ -1720,10 -1589,6 +1736,10 @@@ static int mov_finalize_stsd_codec(MOVC
          // force sample rate for qcelp when not stored in mov
          if (st->codec->codec_tag != MKTAG('Q','c','l','p'))
              st->codec->sample_rate = 8000;
 +        // FIXME: Why is the following needed for some files?
 +        sc->samples_per_frame = 160;
 +        if (!sc->bytes_per_frame)
 +            sc->bytes_per_frame = 35;
          break;
      case AV_CODEC_ID_AMR_NB:
          st->codec->channels    = 1;
      case AV_CODEC_ID_ADPCM_MS:
      case AV_CODEC_ID_ADPCM_IMA_WAV:
      case AV_CODEC_ID_ILBC:
 +    case AV_CODEC_ID_MACE3:
 +    case AV_CODEC_ID_MACE6:
 +    case AV_CODEC_ID_QDM2:
          st->codec->block_align = sc->bytes_per_frame;
          break;
      case AV_CODEC_ID_ALAC:
              st->codec->sample_rate = AV_RB32(st->codec->extradata + 32);
          }
          break;
 +    case AV_CODEC_ID_AC3:
 +    case AV_CODEC_ID_EAC3:
 +    case AV_CODEC_ID_MPEG1VIDEO:
      case AV_CODEC_ID_VC1:
          st->need_parsing = AVSTREAM_PARSE_FULL;
          break;
  
  static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
                                    int codec_tag, int format,
 -                                  int size)
 +                                  int64_t size)
  {
      int video_codec_id = ff_codec_get_id(ff_codec_movvideo_tags, format);
  
      if (codec_tag &&
 -        (codec_tag == AV_RL32("avc1") ||
 -         codec_tag == AV_RL32("hvc1") ||
 -         codec_tag == AV_RL32("hev1") ||
           (codec_tag != format &&
            (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
 -                                 : codec_tag != MKTAG('j','p','e','g'))))) {
 +                                 : codec_tag != MKTAG('j','p','e','g')))) {
          /* Multiple fourcc, we skip JPEG. This is not correct, we should
           * export it as a separate AVStream but this needs a few changes
           * in the MOV demuxer, patch welcome. */
          avio_skip(pb, size);
          return 1;
      }
 +    if ( codec_tag == AV_RL32("avc1") ||
 +         codec_tag == AV_RL32("hvc1") ||
 +         codec_tag == AV_RL32("hev1")
 +    )
 +        av_log(c->fc, AV_LOG_WARNING, "Concatenated H.264 or H.265 might not play correctly.\n");
  
      return 0;
  }
@@@ -1813,15 -1670,15 +1829,15 @@@ int ff_mov_read_stsd_entries(MOVContex
          int ret, dref_id = 1;
          MOVAtom a = { AV_RL32("stsd") };
          int64_t start_pos = avio_tell(pb);
 -        uint32_t size = avio_rb32(pb); /* size */
 +        int64_t size = avio_rb32(pb); /* size */
          uint32_t format = avio_rl32(pb); /* data format */
  
          if (size >= 16) {
              avio_rb32(pb); /* reserved */
              avio_rb16(pb); /* reserved */
              dref_id = avio_rb16(pb);
 -        } else {
 -            av_log(c->fc, AV_LOG_ERROR, "invalid size %"PRIu32" in stsd\n", size);
 +        }else if (size <= 7){
 +            av_log(c->fc, AV_LOG_ERROR, "invalid size %"PRId64" in stsd\n", size);
              return AVERROR_INVALIDDATA;
          }
  
  
          id = mov_codec_id(st, format);
  
 -        av_dlog(c->fc, "size=%"PRIu32" 4CC= %"PRIu8"%"PRIu8"%"PRIu8"%"PRIu8" codec_type=%d\n", size,
 +        av_dlog(c->fc, "size=%"PRId64" 4CC= %c%c%c%c codec_type=%d\n", size,
                  (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
                  (format >> 24) & 0xff, st->codec->codec_type);
  
@@@ -1900,11 -1757,9 +1916,11 @@@ static int mov_read_stsc(MOVContext *c
  
      if (!entries)
          return 0;
 -    if (entries >= UINT_MAX / sizeof(*sc->stsc_data))
 -        return AVERROR_INVALIDDATA;
 -    sc->stsc_data = av_malloc(entries * sizeof(*sc->stsc_data));
 +    if (sc->stsc_data)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STSC atom\n");
 +    av_free(sc->stsc_data);
 +    sc->stsc_count = 0;
 +    sc->stsc_data = av_malloc_array(entries, sizeof(*sc->stsc_data));
      if (!sc->stsc_data)
          return AVERROR(ENOMEM);
  
@@@ -1936,11 -1791,9 +1952,11 @@@ static int mov_read_stps(MOVContext *c
      avio_rb32(pb); // version + flags
  
      entries = avio_rb32(pb);
 -    if (entries >= UINT_MAX / sizeof(*sc->stps_data))
 -        return AVERROR_INVALIDDATA;
 -    sc->stps_data = av_malloc(entries * sizeof(*sc->stps_data));
 +    if (sc->stps_data)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STPS atom\n");
 +    av_free(sc->stps_data);
 +    sc->stps_count = 0;
 +    sc->stps_data = av_malloc_array(entries, sizeof(*sc->stps_data));
      if (!sc->stps_data)
          return AVERROR(ENOMEM);
  
@@@ -1978,17 -1831,12 +1994,17 @@@ static int mov_read_stss(MOVContext *c
      if (!entries)
      {
          sc->keyframe_absent = 1;
 +        if (!st->need_parsing && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 +            st->need_parsing = AVSTREAM_PARSE_HEADERS;
          return 0;
      }
 +    if (sc->keyframes)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STSS atom\n");
      if (entries >= UINT_MAX / sizeof(int))
          return AVERROR_INVALIDDATA;
      av_freep(&sc->keyframes);
 -    sc->keyframes = av_malloc(entries * sizeof(int));
 +    sc->keyframe_count = 0;
 +    sc->keyframes = av_malloc_array(entries, sizeof(*sc->keyframes));
      if (!sc->keyframes)
          return AVERROR(ENOMEM);
  
@@@ -2025,7 -1873,6 +2041,7 @@@ static int mov_read_stsz(MOVContext *c
          sample_size = avio_rb32(pb);
          if (!sc->sample_size) /* do not overwrite value computed in stsd */
              sc->sample_size = sample_size;
 +        sc->stsz_sample_size = sample_size;
          field_size = 32;
      } else {
          sample_size = 0;
  
      if (!entries)
          return 0;
 -    if (entries >= UINT_MAX / sizeof(int) || entries >= (UINT_MAX - 4) / field_size)
 +    if (entries >= (UINT_MAX - 4) / field_size)
          return AVERROR_INVALIDDATA;
 -    sc->sample_sizes = av_malloc(entries * sizeof(int));
 +    if (sc->sample_sizes)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STSZ atom\n");
 +    av_free(sc->sample_sizes);
 +    sc->sample_count = 0;
 +    sc->sample_sizes = av_malloc_array(entries, sizeof(*sc->sample_sizes));
      if (!sc->sample_sizes)
          return AVERROR(ENOMEM);
  
@@@ -2107,11 -1950,13 +2123,11 @@@ static int mov_read_stts(MOVContext *c
      av_dlog(c->fc, "track[%i].stts.entries = %i\n",
              c->fc->nb_streams-1, entries);
  
 -    if (!entries)
 -        return 0;
 -    if (entries >= UINT_MAX / sizeof(*sc->stts_data))
 -        return AVERROR(EINVAL);
 -
 +    if (sc->stts_data)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated STTS atom\n");
      av_free(sc->stts_data);
 -    sc->stts_data = av_malloc(entries * sizeof(*sc->stts_data));
 +    sc->stts_count = 0;
 +    sc->stts_data = av_malloc_array(entries, sizeof(*sc->stts_data));
      if (!sc->stts_data)
          return AVERROR(ENOMEM);
  
  
          sample_count=avio_rb32(pb);
          sample_duration = avio_rb32(pb);
 +
 +        /* sample_duration < 0 is invalid based on the spec */
 +        if (sample_duration < 0) {
 +            av_log(c->fc, AV_LOG_ERROR, "Invalid SampleDelta %d in STTS, at %d st:%d\n",
 +                   sample_duration, i, c->fc->nb_streams-1);
 +            sample_duration = 1;
 +        }
          if (sample_count < 0) {
              av_log(c->fc, AV_LOG_ERROR, "Invalid sample_count=%d\n", sample_count);
              return AVERROR_INVALIDDATA;
          av_dlog(c->fc, "sample_count=%d, sample_duration=%d\n",
                  sample_count, sample_duration);
  
 +        if (   i+1 == entries
 +            && i
 +            && sample_count == 1
 +            && total_sample_count > 100
 +            && sample_duration/10 > duration / total_sample_count)
 +            sample_duration = duration / total_sample_count;
          duration+=(int64_t)sample_duration*sample_count;
          total_sample_count+=sample_count;
      }
  
      sc->stts_count = i;
  
 +    sc->duration_for_fps  += duration;
 +    sc->nb_frames_for_fps += total_sample_count;
 +
      if (pb->eof_reached)
          return AVERROR_EOF;
  
      return 0;
  }
  
 +static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
 +{
 +    if (duration < 0) {
 +        sc->dts_shift = FFMAX(sc->dts_shift, -duration);
 +    }
 +}
 +
  static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
  
          sc->ctts_data[i].count   = count;
          sc->ctts_data[i].duration= duration;
 -        if (duration < 0)
 -            sc->dts_shift = FFMAX(sc->dts_shift, -duration);
 +
 +        av_dlog(c->fc, "count=%d, duration=%d\n",
 +                count, duration);
 +
 +        if (FFABS(duration) > (1<<28) && i+2<entries) {
 +            av_log(c->fc, AV_LOG_WARNING, "CTTS invalid\n");
 +            av_freep(&sc->ctts_data);
 +            sc->ctts_count = 0;
 +            return 0;
 +        }
 +
 +        if (i+2<entries)
 +            mov_update_dts_shift(sc, duration);
      }
  
      sc->ctts_count = i;
@@@ -2250,11 -2061,9 +2266,11 @@@ static int mov_read_sbgp(MOVContext *c
      entries = avio_rb32(pb);
      if (!entries)
          return 0;
 -    if (entries >= UINT_MAX / sizeof(*sc->rap_group))
 -        return AVERROR_INVALIDDATA;
 -    sc->rap_group = av_malloc(entries * sizeof(*sc->rap_group));
 +    if (sc->rap_group)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated SBGP atom\n");
 +    av_free(sc->rap_group);
 +    sc->rap_group_count = 0;
 +    sc->rap_group = av_malloc_array(entries, sizeof(*sc->rap_group));
      if (!sc->rap_group)
          return AVERROR(ENOMEM);
  
@@@ -2280,40 -2089,17 +2296,40 @@@ static void mov_build_index(MOVContext 
      unsigned int i, j;
      uint64_t stream_size = 0;
  
 -    /* adjust first dts according to edit list */
 -    if (sc->time_offset && mov->time_scale > 0) {
 -        if (sc->time_offset < 0)
 -            sc->time_offset = av_rescale(sc->time_offset, sc->time_scale, mov->time_scale);
 -        current_dts = -sc->time_offset;
 -        if (sc->ctts_data && sc->stts_data && sc->stts_data[0].duration &&
 -            sc->ctts_data[0].duration / sc->stts_data[0].duration > 16) {
 -            /* more than 16 frames delay, dts are likely wrong
 -               this happens with files created by iMovie */
 -            sc->wrong_dts = 1;
 -            st->codec->has_b_frames = 1;
 +    if (sc->elst_count) {
 +        int i, edit_start_index = 0, unsupported = 0;
 +        int64_t empty_duration = 0; // empty duration of the first edit list entry
 +        int64_t start_time = 0; // start time of the media
 +
 +        for (i = 0; i < sc->elst_count; i++) {
 +            const MOVElst *e = &sc->elst_data[i];
 +            if (i == 0 && e->time == -1) {
 +                /* if empty, the first entry is the start time of the stream
 +                 * relative to the presentation itself */
 +                empty_duration = e->duration;
 +                edit_start_index = 1;
 +            } else if (i == edit_start_index && e->time >= 0) {
 +                start_time = e->time;
 +            } else
 +                unsupported = 1;
 +        }
 +        if (unsupported)
 +            av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
 +                   "a/v desync might occur, patch welcome\n");
 +
 +        /* adjust first dts according to edit list */
 +        if ((empty_duration || start_time) && mov->time_scale > 0) {
 +            if (empty_duration)
 +                empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
 +            sc->time_offset = start_time - empty_duration;
 +            current_dts = -sc->time_offset;
 +            if (sc->ctts_count>0 && sc->stts_count>0 &&
 +                sc->ctts_data[0].duration / FFMAX(sc->stts_data[0].duration, 1) > 16) {
 +                /* more than 16 frames delay, dts are likely wrong
 +                   this happens with files created by iMovie */
 +                sc->wrong_dts = 1;
 +                st->codec->has_b_frames = 1;
 +            }
          }
      }
  
          unsigned int rap_group_index = 0;
          unsigned int rap_group_sample = 0;
          int rap_group_present = sc->rap_group_count && sc->rap_group;
 -        int key_off = (sc->keyframes && sc->keyframes[0] > 0) || (sc->stps_data && sc->stps_data[0] > 0);
 +        int key_off = (sc->keyframe_count && sc->keyframes[0] > 0) || (sc->stps_count && sc->stps_data[0] > 0);
  
          current_dts -= sc->dts_shift;
  
 -        if (!sc->sample_count)
 +        if (!sc->sample_count || st->nb_index_entries)
              return;
          if (sc->sample_count >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
              return;
          st->index_entries_allocated_size = (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries);
  
          for (i = 0; i < sc->chunk_count; i++) {
 +            int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
              current_offset = sc->chunk_offsets[i];
              while (stsc_index + 1 < sc->stsc_count &&
                  i + 1 == sc->stsc_data[stsc_index + 1].first)
                  stsc_index++;
 +
 +            if (next_offset > current_offset && sc->sample_size>0 && sc->sample_size < sc->stsz_sample_size &&
 +                sc->stsc_data[stsc_index].count * (int64_t)sc->stsz_sample_size > next_offset - current_offset) {
 +                av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too large), ignoring\n", sc->stsz_sample_size);
 +                sc->stsz_sample_size = sc->sample_size;
 +            }
 +            if (sc->stsz_sample_size>0 && sc->stsz_sample_size < sc->sample_size) {
 +                av_log(mov->fc, AV_LOG_WARNING, "STSZ sample size %d invalid (too small), ignoring\n", sc->stsz_sample_size);
 +                sc->stsz_sample_size = sc->sample_size;
 +            }
 +
              for (j = 0; j < sc->stsc_data[stsc_index].count; j++) {
                  int keyframe = 0;
                  if (current_sample >= sc->sample_count) {
                          rap_group_index++;
                      }
                  }
 +                if (sc->keyframe_absent
 +                    && !sc->stps_count
 +                    && !rap_group_present
 +                    && (st->codec->codec_type == AVMEDIA_TYPE_AUDIO || (i==0 && j==0)))
 +                     keyframe = 1;
                  if (keyframe)
                      distance = 0;
 -                sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
 +                sample_size = sc->stsz_sample_size > 0 ? sc->stsz_sample_size : sc->sample_sizes[current_sample];
                  if (sc->pseudo_stream_id == -1 ||
                     sc->stsc_data[stsc_index].id - 1 == sc->pseudo_stream_id) {
                      AVIndexEntry *e = &st->index_entries[st->nb_index_entries++];
                      av_dlog(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
                              "size %d, distance %d, keyframe %d\n", st->index, current_sample,
                              current_offset, current_dts, sample_size, distance, keyframe);
 +                    if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
 +                        ff_rfps_add_frame(mov->fc, st, current_dts);
                  }
  
                  current_offset += sample_size;
      }
  }
  
 -static int mov_open_dref(AVIOContext **pb, char *src, MOVDref *ref,
 -                         AVIOInterruptCB *int_cb)
 +static int mov_open_dref(AVIOContext **pb, const char *src, MOVDref *ref,
 +                         AVIOInterruptCB *int_cb, int use_absolute_path, AVFormatContext *fc)
  {
      /* try relative path, we do not try the absolute because it can leak information about our
         system to an attacker */
      if (ref->nlvl_to > 0 && ref->nlvl_from > 0) {
          char filename[1024];
 -        char *src_path;
 +        const char *src_path;
          int i, l;
  
          /* find a source dir */
              if (!avio_open2(pb, filename, AVIO_FLAG_READ, int_cb, NULL))
                  return 0;
          }
 +    } else if (use_absolute_path) {
 +        av_log(fc, AV_LOG_WARNING, "Using absolute path on user request, "
 +               "this is a possible security issue\n");
 +        if (!avio_open2(pb, ref->path, AVIO_FLAG_READ, int_cb, NULL))
 +            return 0;
      }
  
      return AVERROR(ENOENT);
  }
  
 +static void fix_timescale(MOVContext *c, MOVStreamContext *sc)
 +{
 +    if (sc->time_scale <= 0) {
 +        av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", sc->ffindex);
 +        sc->time_scale = c->time_scale;
 +        if (sc->time_scale <= 0)
 +            sc->time_scale = 1;
 +    }
 +}
 +
  static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
  {
      AVStream *st;
          return 0;
      }
  
 -    if (sc->time_scale <= 0) {
 -        av_log(c->fc, AV_LOG_WARNING, "stream %d, timescale not set\n", st->index);
 -        sc->time_scale = c->time_scale;
 -        if (sc->time_scale <= 0)
 -            sc->time_scale = 1;
 -    }
 +    fix_timescale(c, sc);
  
      avpriv_set_pts_info(st, 64, 1, sc->time_scale);
  
  
      if (sc->dref_id-1 < sc->drefs_count && sc->drefs[sc->dref_id-1].path) {
          MOVDref *dref = &sc->drefs[sc->dref_id - 1];
 -        if (mov_open_dref(&sc->pb, c->fc->filename, dref, &c->fc->interrupt_callback) < 0)
 +        if (mov_open_dref(&sc->pb, c->fc->filename, dref, &c->fc->interrupt_callback,
 +            c->use_absolute_path, c->fc) < 0)
              av_log(c->fc, AV_LOG_ERROR,
                     "stream %d, error opening alias: path='%s', dir='%s', "
                     "filename='%s', volume='%s', nlvl_from=%d, nlvl_to=%d\n",
                     st->index, dref->path, dref->dir, dref->filename,
                     dref->volume, dref->nlvl_from, dref->nlvl_to);
 -    } else
 +    } else {
          sc->pb = c->fc->pb;
 +        sc->pb_is_copied = 1;
 +    }
  
      if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
          if (!st->sample_aspect_ratio.num &&
              st->sample_aspect_ratio = av_d2q(((double)st->codec->height * sc->width) /
                                               ((double)st->codec->width * sc->height), INT_MAX);
          }
 +
 +#if FF_API_R_FRAME_RATE
 +        if (sc->stts_count == 1 || (sc->stts_count == 2 && sc->stts_data[1].count == 1))
 +            av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
 +                      sc->time_scale, sc->stts_data[0].duration, INT_MAX);
 +#endif
      }
  
      // done for ai5q, ai52, ai55, ai1q, ai12 and ai15.
      av_freep(&sc->keyframes);
      av_freep(&sc->stts_data);
      av_freep(&sc->stps_data);
 +    av_freep(&sc->elst_data);
      av_freep(&sc->rap_group);
  
      return 0;
@@@ -2675,18 -2422,11 +2691,18 @@@ static int mov_read_ilst(MOVContext *c
      return ret;
  }
  
 -static int mov_read_replaygain(MOVContext *c, AVIOContext *pb, int size)
 +static int mov_read_custom_2plus(MOVContext *c, AVIOContext *pb, int size)
  {
      int64_t end = avio_tell(pb) + size;
      uint8_t *key = NULL, *val = NULL;
      int i;
 +    AVStream *st;
 +    MOVStreamContext *sc;
 +
 +    if (c->fc->nb_streams < 1)
 +        return 0;
 +    st = c->fc->streams[c->fc->nb_streams-1];
 +    sc = st->priv_data;
  
      for (i = 0; i < 2; i++) {
          uint8_t **p;
      }
  
      if (key && val) {
 -        av_dict_set(&c->fc->metadata, key, val,
 -                    AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
 -        key = val = NULL;
 +        if (strcmp(key, "iTunSMPB") == 0) {
 +            int priming, remainder, samples;
 +            if(sscanf(val, "%*X %X %X %X", &priming, &remainder, &samples) == 3){
 +                if(priming>0 && priming<16384)
 +                    sc->start_pad = priming;
 +            }
 +        }
 +        if (strcmp(key, "cdec") != 0) {
 +            av_dict_set(&c->fc->metadata, key, val,
 +                        AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
 +            key = val = NULL;
 +        }
      }
  
      avio_seek(pb, end, SEEK_SET);
@@@ -2763,7 -2494,8 +2779,7 @@@ static int mov_read_custom(MOVContext *
  
          domain_len = avio_get_str(pb, len, domain, sizeof(domain));
          avio_skip(pb, len - domain_len);
 -        if (!strcmp(domain, "org.hydrogenaudio.replaygain"))
 -            return mov_read_replaygain(c, pb, end - avio_tell(pb));
 +        return mov_read_custom_2plus(c, pb, end - avio_tell(pb));
      }
  
  fail:
@@@ -2791,6 -2523,7 +2807,6 @@@ static int mov_read_tkhd(MOVContext *c
      int i;
      int width;
      int height;
 -    int64_t disp_transform[2];
      int display_matrix[3][3];
      AVStream *st;
      MOVStreamContext *sc;
      sc->width = width >> 16;
      sc->height = height >> 16;
  
 -    // save the matrix when it is not the default identity
 +    // save the matrix and add rotate metadata when it is not the default
 +    // identity
      if (display_matrix[0][0] != (1 << 16) ||
          display_matrix[1][1] != (1 << 16) ||
          display_matrix[2][2] != (1 << 30) ||
          display_matrix[1][0] || display_matrix[1][2] ||
          display_matrix[2][0] || display_matrix[2][1]) {
          int i, j;
 +        double rotate;
  
          av_freep(&sc->display_matrix);
          sc->display_matrix = av_malloc(sizeof(int32_t) * 9);
          for (i = 0; i < 3; i++)
              for (j = 0; j < 3; j++)
                  sc->display_matrix[i * 3 + j] = display_matrix[j][i];
 +
 +        rotate = av_display_rotation_get(sc->display_matrix);
 +        if (!isnan(rotate)) {
 +            char rotate_buf[64];
 +            rotate = -rotate;
 +            if (rotate < 0) // for backward compatibility
 +                rotate += 360;
 +            snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
 +            av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
 +        }
      }
  
      // transform the display width/height according to the matrix
 -    // skip this when the display matrix is the identity one
      // to keep the same scale, use [width height 1<<16]
      if (width && height && sc->display_matrix) {
 +        double disp_transform[2];
 +
 +#define SQR(a) ((a)*(double)(a))
          for (i = 0; i < 2; i++)
 -            disp_transform[i] =
 -                (int64_t)  width  * display_matrix[0][i] +
 -                (int64_t)  height * display_matrix[1][i] +
 -                ((int64_t) display_matrix[2][i] << 16);
 +            disp_transform[i] = sqrt(SQR(display_matrix[i][0]) + SQR(display_matrix[i][1]));
  
 -        //sample aspect ratio is new width/height divided by old width/height
 -        if (disp_transform[0] > 0 && disp_transform[1] > 0)
 +        if (disp_transform[0] > 0       && disp_transform[1] > 0 &&
 +            disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
 +            fabs((disp_transform[0] / disp_transform[1]) - 1.0) > 0.01)
              st->sample_aspect_ratio = av_d2q(
 -                ((double) disp_transform[0] * height) /
 -                ((double) disp_transform[1] * width), INT_MAX);
 +                disp_transform[0] / disp_transform[1],
 +                INT_MAX);
      }
      return 0;
  }
@@@ -2895,7 -2616,6 +2911,7 @@@ static int mov_read_tfhd(MOVContext *c
  {
      MOVFragment *frag = &c->fragment;
      MOVTrackExt *trex = NULL;
 +    MOVFragmentIndex* index = NULL;
      int flags, track_id, i;
  
      avio_r8(pb); /* version */
          av_log(c->fc, AV_LOG_ERROR, "could not find corresponding trex\n");
          return AVERROR_INVALIDDATA;
      }
 +    for (i = 0; i < c->fragment_index_count; i++) {
 +        MOVFragmentIndex* candidate = c->fragment_index_data[i];
 +        if (candidate->track_id == frag->track_id) {
 +            av_log(c->fc, AV_LOG_DEBUG,
 +                   "found fragment index for track %u\n", frag->track_id);
 +            index = candidate;
 +            break;
 +        }
 +    }
  
      frag->base_data_offset = flags & MOV_TFHD_BASE_DATA_OFFSET ?
                               avio_rb64(pb) : flags & MOV_TFHD_DEFAULT_BASE_IS_MOOF ?
                       avio_rb32(pb) : trex->size;
      frag->flags    = flags & MOV_TFHD_DEFAULT_FLAGS ?
                       avio_rb32(pb) : trex->flags;
 +    frag->time     = AV_NOPTS_VALUE;
 +    if (index) {
 +        int i, found = 0;
 +        for (i = index->current_item; i < index->item_count; i++) {
 +            if (frag->implicit_offset == index->items[i].moof_offset) {
 +                av_log(c->fc, AV_LOG_DEBUG, "found fragment index entry "
 +                        "for track %u and moof_offset %"PRId64"\n",
 +                        frag->track_id, index->items[i].moof_offset);
 +                frag->time = index->items[i].time;
 +                index->current_item = i + 1;
 +                found = 1;
 +            }
 +        }
 +        if (!found) {
 +            av_log(c->fc, AV_LOG_WARNING, "track %u has a fragment index "
 +                   "but it doesn't have an (in-order) entry for moof_offset "
 +                   "%"PRId64"\n", frag->track_id, frag->implicit_offset);
 +        }
 +    }
      av_dlog(c->fc, "frag flags 0x%x\n", frag->flags);
      return 0;
  }
@@@ -2976,9 -2668,6 +2992,9 @@@ static int mov_read_trex(MOVContext *c
          c->trex_count = 0;
          return err;
      }
 +
 +    c->fc->duration = AV_NOPTS_VALUE; // the duration from mvhd is not representing the whole file when fragments are used.
 +
      trex = &c->trex_data[c->trex_count++];
      avio_r8(pb); /* version */
      avio_rb24(pb); /* flags */
@@@ -3043,7 -2732,7 +3059,7 @@@ static int mov_read_trun(MOVContext *c
          return AVERROR_INVALIDDATA;
      }
      sc = st->priv_data;
 -    if (sc->pseudo_stream_id+1 != frag->stsd_id)
 +    if (sc->pseudo_stream_id+1 != frag->stsd_id && sc->pseudo_stream_id != -1)
          return 0;
      avio_r8(pb); /* version */
      flags = avio_rb24(pb);
          sc->ctts_data[sc->ctts_count].count = 1;
          sc->ctts_data[sc->ctts_count].duration = (flags & MOV_TRUN_SAMPLE_CTS) ?
                                                    avio_rb32(pb) : 0;
 +        mov_update_dts_shift(sc, sc->ctts_data[sc->ctts_count].duration);
 +        if (frag->time != AV_NOPTS_VALUE) {
 +            if (c->use_mfra_for == FF_MOV_FLAG_MFRA_PTS) {
 +                int64_t pts = frag->time;
 +                av_log(c->fc, AV_LOG_DEBUG, "found frag time %"PRId64
 +                        " sc->dts_shift %d ctts.duration %d"
 +                        " sc->time_offset %"PRId64" flags & MOV_TRUN_SAMPLE_CTS %d\n", pts,
 +                        sc->dts_shift, sc->ctts_data[sc->ctts_count].duration,
 +                        sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
 +                dts = pts - sc->dts_shift;
 +                if (flags & MOV_TRUN_SAMPLE_CTS) {
 +                    dts -= sc->ctts_data[sc->ctts_count].duration;
 +                } else {
 +                    dts -= sc->time_offset;
 +                }
 +                av_log(c->fc, AV_LOG_DEBUG, "calculated into dts %"PRId64"\n", dts);
 +            } else {
 +                dts = frag->time;
 +                av_log(c->fc, AV_LOG_DEBUG, "found frag time %"PRId64
 +                        ", using it for dts\n", dts);
 +            }
 +            frag->time = AV_NOPTS_VALUE;
 +        }
          sc->ctts_count++;
          if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
              keyframe = 1;
          dts += sample_duration;
          offset += sample_size;
          sc->data_size += sample_size;
 +        sc->duration_for_fps += sample_duration;
 +        sc->nb_frames_for_fps ++;
      }
  
      if (pb->eof_reached)
@@@ -3180,7 -2844,7 +3196,7 @@@ static int mov_read_cmov(MOVContext *c
      if (avio_rl32(pb) != MKTAG('d','c','o','m'))
          return AVERROR_INVALIDDATA;
      if (avio_rl32(pb) != MKTAG('z','l','i','b')) {
 -        av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !");
 +        av_log(c->fc, AV_LOG_ERROR, "unknown compression for cmov atom !\n");
          return AVERROR_INVALIDDATA;
      }
      avio_rb32(pb); /* cmvd atom */
@@@ -3221,7 -2885,7 +3237,7 @@@ static int mov_read_elst(MOVContext *c
      MOVStreamContext *sc;
      int i, edit_count, version;
  
 -    if (c->fc->nb_streams < 1)
 +    if (c->fc->nb_streams < 1 || c->ignore_editlist)
          return 0;
      sc = c->fc->streams[c->fc->nb_streams-1]->priv_data;
  
      avio_rb24(pb); /* flags */
      edit_count = avio_rb32(pb); /* entries */
  
 -    if ((uint64_t)edit_count*12+8 > atom.size)
 -        return AVERROR_INVALIDDATA;
 +    if (!edit_count)
 +        return 0;
 +    if (sc->elst_data)
 +        av_log(c->fc, AV_LOG_WARNING, "Duplicated ELST atom\n");
 +    av_free(sc->elst_data);
 +    sc->elst_count = 0;
 +    sc->elst_data = av_malloc_array(edit_count, sizeof(*sc->elst_data));
 +    if (!sc->elst_data)
 +        return AVERROR(ENOMEM);
 +
 +    av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
 +    for (i = 0; i < edit_count && !pb->eof_reached; i++) {
 +        MOVElst *e = &sc->elst_data[i];
  
 -    for (i=0; i<edit_count; i++){
 -        int64_t time;
 -        int64_t duration;
          if (version == 1) {
 -            duration = avio_rb64(pb);
 -            time     = avio_rb64(pb);
 +            e->duration = avio_rb64(pb);
 +            e->time     = avio_rb64(pb);
          } else {
 -            duration = avio_rb32(pb); /* segment duration */
 -            time     = (int32_t)avio_rb32(pb); /* media time */
 +            e->duration = avio_rb32(pb); /* segment duration */
 +            e->time     = (int32_t)avio_rb32(pb); /* media time */
 +        }
 +        e->rate = avio_rb32(pb) / 65536.0;
 +        av_dlog(c->fc, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
 +                e->duration, e->time, e->rate);
 +    }
 +    sc->elst_count = i;
 +
 +    return 0;
 +}
 +
 +static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    MOVStreamContext *sc;
 +
 +    if (c->fc->nb_streams < 1)
 +        return AVERROR_INVALIDDATA;
 +    sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
 +    sc->timecode_track = avio_rb32(pb);
 +    return 0;
 +}
 +
 +static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    int ret;
 +    uint8_t uuid[16];
 +    static const uint8_t uuid_isml_manifest[] = {
 +        0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
 +        0xba, 0x2f, 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66
 +    };
 +
 +    if (atom.size < sizeof(uuid) || atom.size == INT64_MAX)
 +        return AVERROR_INVALIDDATA;
 +
 +    ret = avio_read(pb, uuid, sizeof(uuid));
 +    if (ret < 0) {
 +        return ret;
 +    } else if (ret != sizeof(uuid)) {
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (!memcmp(uuid, uuid_isml_manifest, sizeof(uuid))) {
 +        uint8_t *buffer, *ptr;
 +        char *endptr;
 +        size_t len = atom.size - sizeof(uuid);
 +
 +        if (len < 4) {
 +            return AVERROR_INVALIDDATA;
          }
 -        avio_rb32(pb); /* Media rate */
 -        if (i == 0 && time >= -1) {
 -            sc->time_offset = time != -1 ? time : -duration;
 +        ret = avio_skip(pb, 4); // zeroes
 +        len -= 4;
 +
 +        buffer = av_mallocz(len + 1);
 +        if (!buffer) {
 +            return AVERROR(ENOMEM);
 +        }
 +        ret = avio_read(pb, buffer, len);
 +        if (ret < 0) {
 +            av_free(buffer);
 +            return ret;
 +        } else if (ret != len) {
 +            av_free(buffer);
 +            return AVERROR_INVALIDDATA;
          }
 +
 +        ptr = buffer;
 +        while ((ptr = av_stristr(ptr, "systemBitrate=\""))) {
 +            ptr += sizeof("systemBitrate=\"") - 1;
 +            c->bitrates_count++;
 +            c->bitrates = av_realloc_f(c->bitrates, c->bitrates_count, sizeof(*c->bitrates));
 +            if (!c->bitrates) {
 +                c->bitrates_count = 0;
 +                av_free(buffer);
 +                return AVERROR(ENOMEM);
 +            }
 +            errno = 0;
 +            ret = strtol(ptr, &endptr, 10);
 +            if (ret < 0 || errno || *endptr != '"') {
 +                c->bitrates[c->bitrates_count - 1] = 0;
 +            } else {
 +                c->bitrates[c->bitrates_count - 1] = ret;
 +            }
 +        }
 +
 +        av_free(buffer);
      }
 +    return 0;
 +}
  
 -    if (edit_count > 1)
 -        av_log(c->fc, AV_LOG_WARNING, "multiple edit list entries, "
 -               "a/v desync might occur, patch welcome\n");
 +static int mov_read_free(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 +{
 +    int ret;
 +    uint8_t content[16];
 +
 +    if (atom.size < 8)
 +        return 0;
 +
 +    ret = avio_read(pb, content, FFMIN(sizeof(content), atom.size));
 +    if (ret < 0)
 +        return ret;
 +
 +    if (   !c->found_moov
 +        && !c->found_mdat
 +        && !memcmp(content, "Anevia\x1A\x1A", 8)
 +        && c->use_mfra_for == FF_MOV_FLAG_MFRA_AUTO) {
 +        c->use_mfra_for = FF_MOV_FLAG_MFRA_PTS;
 +    }
  
 -    av_dlog(c->fc, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
      return 0;
  }
  
  static const MOVParseTableEntry mov_default_parse_table[] = {
 -{ MKTAG('a','v','s','s'), mov_read_extradata },
 +{ MKTAG('A','C','L','R'), mov_read_avid },
 +{ MKTAG('A','P','R','G'), mov_read_avid },
 +{ MKTAG('A','A','L','P'), mov_read_avid },
 +{ MKTAG('A','R','E','S'), mov_read_ares },
 +{ MKTAG('a','v','s','s'), mov_read_avss },
  { MKTAG('c','h','p','l'), mov_read_chpl },
  { MKTAG('c','o','6','4'), mov_read_stco },
  { MKTAG('c','o','l','r'), mov_read_colr },
  { MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
  { MKTAG('d','i','n','f'), mov_read_default },
 +{ MKTAG('D','p','x','E'), mov_read_dpxe },
  { MKTAG('d','r','e','f'), mov_read_dref },
  { MKTAG('e','d','t','s'), mov_read_default },
  { MKTAG('e','l','s','t'), mov_read_elst },
  { MKTAG('g','l','b','l'), mov_read_glbl },
  { MKTAG('h','d','l','r'), mov_read_hdlr },
  { MKTAG('i','l','s','t'), mov_read_ilst },
 -{ MKTAG('j','p','2','h'), mov_read_extradata },
 +{ MKTAG('j','p','2','h'), mov_read_jp2h },
  { MKTAG('m','d','a','t'), mov_read_mdat },
  { MKTAG('m','d','h','d'), mov_read_mdhd },
  { MKTAG('m','d','i','a'), mov_read_default },
  { MKTAG('m','o','o','v'), mov_read_moov },
  { MKTAG('m','v','e','x'), mov_read_default },
  { MKTAG('m','v','h','d'), mov_read_mvhd },
 -{ MKTAG('S','M','I',' '), mov_read_smi }, /* Sorenson extension ??? */
 -{ MKTAG('a','l','a','c'), mov_read_extradata }, /* alac specific atom */
 +{ MKTAG('S','M','I',' '), mov_read_svq3 },
 +{ MKTAG('a','l','a','c'), mov_read_alac }, /* alac specific atom */
  { MKTAG('a','v','c','C'), mov_read_glbl },
  { MKTAG('p','a','s','p'), mov_read_pasp },
  { MKTAG('s','t','b','l'), mov_read_default },
  { MKTAG('t','r','a','k'), mov_read_trak },
  { MKTAG('t','r','a','f'), mov_read_default },
  { MKTAG('t','r','e','f'), mov_read_default },
 +{ MKTAG('t','m','c','d'), mov_read_tmcd },
  { MKTAG('c','h','a','p'), mov_read_chap },
  { MKTAG('t','r','e','x'), mov_read_trex },
  { MKTAG('t','r','u','n'), mov_read_trun },
  { MKTAG('d','v','c','1'), mov_read_dvc1 },
  { MKTAG('s','b','g','p'), mov_read_sbgp },
  { MKTAG('h','v','c','C'), mov_read_glbl },
 +{ MKTAG('u','u','i','d'), mov_read_uuid },
 +{ MKTAG('C','i','n', 0x8e), mov_read_targa_y216 },
 +{ MKTAG('f','r','e','e'), mov_read_free },
  { MKTAG('-','-','-','-'), mov_read_custom },
  { 0, NULL }
  };
@@@ -3438,55 -2991,27 +3454,55 @@@ static int mov_read_default(MOVContext 
      MOVAtom a;
      int i;
  
 +    if (c->atom_depth > 10) {
 +        av_log(c->fc, AV_LOG_ERROR, "Atoms too deeply nested\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    c->atom_depth ++;
 +
      if (atom.size < 0)
          atom.size = INT64_MAX;
 -    while (total_size + 8 < atom.size && !pb->eof_reached) {
 +    while (total_size + 8 <= atom.size && !avio_feof(pb)) {
          int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
          a.size = atom.size;
          a.type=0;
          if (atom.size >= 8) {
              a.size = avio_rb32(pb);
              a.type = avio_rl32(pb);
 +            if (a.type == MKTAG('f','r','e','e') &&
 +                a.size >= 8 &&
 +                c->moov_retry) {
 +                uint8_t buf[8];
 +                uint32_t *type = (uint32_t *)buf + 1;
 +                avio_read(pb, buf, 8);
 +                avio_seek(pb, -8, SEEK_CUR);
 +                if (*type == MKTAG('m','v','h','d') ||
 +                    *type == MKTAG('c','m','o','v')) {
 +                    av_log(c->fc, AV_LOG_ERROR, "Detected moov in a free atom.\n");
 +                    a.type = MKTAG('m','o','o','v');
 +                }
 +            }
 +            if (atom.type != MKTAG('r','o','o','t') &&
 +                atom.type != MKTAG('m','o','o','v'))
 +            {
 +                if (a.type == MKTAG('t','r','a','k') || a.type == MKTAG('m','d','a','t'))
 +                {
 +                    av_log(c->fc, AV_LOG_ERROR, "Broken file, trak/mdat not at top-level\n");
 +                    avio_skip(pb, -8);
 +                    c->atom_depth --;
 +                    return 0;
 +                }
 +            }
 +            total_size += 8;
 +            if (a.size == 1 && total_size + 8 <= atom.size) { /* 64 bit extended size */
 +                a.size = avio_rb64(pb) - 8;
 +                total_size += 8;
 +            }
          }
          av_dlog(c->fc, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
                  a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
 -        total_size += 8;
 -        if (a.size == 1) { /* 64 bit extended size */
 -            a.size = avio_rb64(pb) - 8;
 -            total_size += 8;
 -        }
          if (a.size == 0) {
 -            a.size = atom.size - total_size;
 -            if (a.size <= 8)
 -                break;
 +            a.size = atom.size - total_size + 8;
          }
          a.size -= 8;
          if (a.size < 0)
              int64_t start_pos = avio_tell(pb);
              int64_t left;
              int err = parse(c, pb, a);
 -            if (err < 0)
 +            if (err < 0) {
 +                c->atom_depth --;
                  return err;
 +            }
              if (c->found_moov && c->found_mdat &&
                  ((!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX) ||
                   start_pos + a.size == avio_size(pb))) {
                  if (!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX)
                      c->next_root_atom = start_pos + a.size;
 +                c->atom_depth --;
                  return 0;
              }
              left = a.size - avio_tell(pb) + start_pos;
      if (total_size < atom.size && atom.size < 0x7ffff)
          avio_skip(pb, atom.size - total_size);
  
 +    c->atom_depth --;
      return 0;
  }
  
  static int mov_probe(AVProbeData *p)
  {
 -    unsigned int offset;
 +    int64_t offset;
      uint32_t tag;
      int score = 0;
 +    int moov_offset = -1;
  
      /* check file header */
      offset = 0;
      for (;;) {
          /* ignore invalid offset */
          if ((offset + 8) > (unsigned int)p->buf_size)
 -            return score;
 +            break;
          tag = AV_RL32(p->buf + offset + 4);
          switch(tag) {
          /* check for obvious tags */
 -        case MKTAG('j','P',' ',' '): /* jpeg 2000 signature */
          case MKTAG('m','o','o','v'):
 +            moov_offset = offset + 4;
          case MKTAG('m','d','a','t'):
          case MKTAG('p','n','o','t'): /* detect movs with preview pics like ew.mov and april.mov */
          case MKTAG('u','d','t','a'): /* Packet Video PVAuthor adds this and a lot of more junk */
          case MKTAG('f','t','y','p'):
 -            return AVPROBE_SCORE_MAX;
 +            if (AV_RB32(p->buf+offset) < 8 &&
 +                (AV_RB32(p->buf+offset) != 1 ||
 +                 offset + 12 > (unsigned int)p->buf_size ||
 +                 AV_RB64(p->buf+offset + 8) == 0)) {
 +                score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
 +            } else if (tag == MKTAG('f','t','y','p') &&
 +                       AV_RL32(p->buf + offset + 8) == MKTAG('j','p','2',' ')) {
 +                score = FFMAX(score, 5);
 +            } else {
 +                score = AVPROBE_SCORE_MAX;
 +            }
 +            offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
 +            break;
          /* those are more common words, so rate then a bit less */
          case MKTAG('e','d','i','w'): /* xdcam files have reverted first tags */
          case MKTAG('w','i','d','e'):
          case MKTAG('f','r','e','e'):
          case MKTAG('j','u','n','k'):
          case MKTAG('p','i','c','t'):
 -            return AVPROBE_SCORE_MAX - 5;
 +            score  = FFMAX(score, AVPROBE_SCORE_MAX - 5);
 +            offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
 +            break;
          case MKTAG(0x82,0x82,0x7f,0x7d):
          case MKTAG('s','k','i','p'):
          case MKTAG('u','u','i','d'):
          case MKTAG('p','r','f','l'):
 -            offset = AV_RB32(p->buf+offset) + offset;
              /* if we only find those cause probedata is too small at least rate them */
 -            score = AVPROBE_SCORE_EXTENSION;
 +            score  = FFMAX(score, AVPROBE_SCORE_EXTENSION);
 +            offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
              break;
          default:
 -            /* unrecognized tag */
 -            return score;
 +            offset = FFMAX(4, AV_RB32(p->buf+offset)) + offset;
          }
      }
 +    if(score > AVPROBE_SCORE_MAX - 50 && moov_offset != -1) {
 +        /* moov atom in the header - we should make sure that this is not a
 +         * MOV-packed MPEG-PS */
 +        offset = moov_offset;
 +
 +        while(offset < (p->buf_size - 16)){ /* Sufficient space */
 +               /* We found an actual hdlr atom */
 +            if(AV_RL32(p->buf + offset     ) == MKTAG('h','d','l','r') &&
 +               AV_RL32(p->buf + offset +  8) == MKTAG('m','h','l','r') &&
 +               AV_RL32(p->buf + offset + 12) == MKTAG('M','P','E','G')){
 +                av_log(NULL, AV_LOG_WARNING, "Found media data tag MPEG indicating this is a MOV-packed MPEG-PS.\n");
 +                /* We found a media handler reference atom describing an
 +                 * MPEG-PS-in-MOV, return a
 +                 * low score to force expanding the probe window until
 +                 * mpegps_probe finds what it needs */
 +                return 5;
 +            }else
 +                /* Keep looking */
 +                offset+=2;
 +        }
 +    }
 +
 +    return score;
  }
  
  // must be done after parsing all trak because there's no order requirement
@@@ -3654,11 -3138,6 +3670,11 @@@ static void mov_read_chapters(AVFormatC
          uint16_t ch;
          int len, title_len;
  
 +        if (end < sample->timestamp) {
 +            av_log(s, AV_LOG_WARNING, "ignoring stream duration which is shorter than chapters\n");
 +            end = AV_NOPTS_VALUE;
 +        }
 +
          if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
              av_log(s, AV_LOG_ERROR, "Chapter %d not found in file\n", i);
              goto finish;
                  if (len == 1 || len == 2)
                      title[len] = 0;
                  else
 -                    avio_get_str(sc->pb, len - 2, title + 2, title_len - 2);
 +                    avio_get_str(sc->pb, INT_MAX, title + 2, len - 1);
              }
          }
  
@@@ -3699,49 -3178,6 +3715,49 @@@ finish
      avio_seek(sc->pb, cur_pos, SEEK_SET);
  }
  
 +static int parse_timecode_in_framenum_format(AVFormatContext *s, AVStream *st,
 +                                             uint32_t value, int flags)
 +{
 +    AVTimecode tc;
 +    char buf[AV_TIMECODE_STR_SIZE];
 +    AVRational rate = {st->codec->time_base.den,
 +                       st->codec->time_base.num};
 +    int ret = av_timecode_init(&tc, rate, flags, 0, s);
 +    if (ret < 0)
 +        return ret;
 +    av_dict_set(&st->metadata, "timecode",
 +                av_timecode_make_string(&tc, buf, value), 0);
 +    return 0;
 +}
 +
 +static int mov_read_timecode_track(AVFormatContext *s, AVStream *st)
 +{
 +    MOVStreamContext *sc = st->priv_data;
 +    int flags = 0;
 +    int64_t cur_pos = avio_tell(sc->pb);
 +    uint32_t value;
 +
 +    if (!st->nb_index_entries)
 +        return -1;
 +
 +    avio_seek(sc->pb, st->index_entries->pos, SEEK_SET);
 +    value = avio_rb32(s->pb);
 +
 +    if (sc->tmcd_flags & 0x0001) flags |= AV_TIMECODE_FLAG_DROPFRAME;
 +    if (sc->tmcd_flags & 0x0002) flags |= AV_TIMECODE_FLAG_24HOURSMAX;
 +    if (sc->tmcd_flags & 0x0004) flags |= AV_TIMECODE_FLAG_ALLOWNEGATIVE;
 +
 +    /* Assume Counter flag is set to 1 in tmcd track (even though it is likely
 +     * not the case) and thus assume "frame number format" instead of QT one.
 +     * No sample with tmcd track can be found with a QT timecode at the moment,
 +     * despite what the tmcd track "suggests" (Counter flag set to 0 means QT
 +     * format). */
 +    parse_timecode_in_framenum_format(s, st, value, flags);
 +
 +    avio_seek(sc->pb, cur_pos, SEEK_SET);
 +    return 0;
 +}
 +
  static int mov_read_close(AVFormatContext *s)
  {
      MOVContext *mov = s->priv_data;
              av_freep(&sc->drefs[j].dir);
          }
          av_freep(&sc->drefs);
 -        if (sc->pb && sc->pb != s->pb)
 -            avio_close(sc->pb);
  
 +        sc->drefs_count = 0;
 +
 +        if (!sc->pb_is_copied)
 +            avio_closep(&sc->pb);
 +
 +        sc->pb = NULL;
          av_freep(&sc->chunk_offsets);
          av_freep(&sc->stsc_data);
          av_freep(&sc->sample_sizes);
          av_freep(&sc->keyframes);
          av_freep(&sc->stts_data);
          av_freep(&sc->stps_data);
 +        av_freep(&sc->elst_data);
          av_freep(&sc->rap_group);
          av_freep(&sc->display_matrix);
      }
      }
  
      av_freep(&mov->trex_data);
 +    av_freep(&mov->bitrates);
 +
 +    for (i = 0; i < mov->fragment_index_count; i++) {
 +        MOVFragmentIndex* index = mov->fragment_index_data[i];
 +        av_freep(&index->items);
 +        av_freep(&mov->fragment_index_data[i]);
 +    }
 +    av_freep(&mov->fragment_index_data);
 +
 +    return 0;
 +}
 +
 +static int tmcd_is_referenced(AVFormatContext *s, int tmcd_id)
 +{
 +    int i;
 +
 +    for (i = 0; i < s->nb_streams; i++) {
 +        AVStream *st = s->streams[i];
 +        MOVStreamContext *sc = st->priv_data;
 +
 +        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
 +            sc->timecode_track == tmcd_id)
 +            return 1;
 +    }
 +    return 0;
 +}
 +
 +/* look for a tmcd track not referenced by any video track, and export it globally */
 +static void export_orphan_timecode(AVFormatContext *s)
 +{
 +    int i;
 +
 +    for (i = 0; i < s->nb_streams; i++) {
 +        AVStream *st = s->streams[i];
 +
 +        if (st->codec->codec_tag  == MKTAG('t','m','c','d') &&
 +            !tmcd_is_referenced(s, i + 1)) {
 +            AVDictionaryEntry *tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
 +            if (tcr) {
 +                av_dict_set(&s->metadata, "timecode", tcr->value, 0);
 +                break;
 +            }
 +        }
 +    }
 +}
 +
 +static int read_tfra(MOVContext *mov, AVIOContext *f)
 +{
 +    MOVFragmentIndex* index = NULL;
 +    int version, fieldlength, i, j;
 +    int64_t pos = avio_tell(f);
 +    uint32_t size = avio_rb32(f);
 +    void *tmp;
 +
 +    if (avio_rb32(f) != MKBETAG('t', 'f', 'r', 'a')) {
 +        return 1;
 +    }
 +    av_log(mov->fc, AV_LOG_VERBOSE, "found tfra\n");
 +    index = av_mallocz(sizeof(MOVFragmentIndex));
 +    if (!index) {
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    tmp = av_realloc_array(mov->fragment_index_data,
 +                           mov->fragment_index_count + 1,
 +                           sizeof(MOVFragmentIndex*));
 +    if (!tmp) {
 +        av_freep(&index);
 +        return AVERROR(ENOMEM);
 +    }
 +    mov->fragment_index_data = tmp;
 +    mov->fragment_index_data[mov->fragment_index_count++] = index;
 +
 +    version = avio_r8(f);
 +    avio_rb24(f);
 +    index->track_id = avio_rb32(f);
 +    fieldlength = avio_rb32(f);
 +    index->item_count = avio_rb32(f);
 +    index->items = av_mallocz_array(
 +            index->item_count, sizeof(MOVFragmentIndexItem));
 +    if (!index->items) {
 +        index->item_count = 0;
 +        return AVERROR(ENOMEM);
 +    }
 +    for (i = 0; i < index->item_count; i++) {
 +        int64_t time, offset;
 +        if (version == 1) {
 +            time   = avio_rb64(f);
 +            offset = avio_rb64(f);
 +        } else {
 +            time   = avio_rb32(f);
 +            offset = avio_rb32(f);
 +        }
 +        index->items[i].time = time;
 +        index->items[i].moof_offset = offset;
 +        for (j = 0; j < ((fieldlength >> 4) & 3) + 1; j++)
 +            avio_r8(f);
 +        for (j = 0; j < ((fieldlength >> 2) & 3) + 1; j++)
 +            avio_r8(f);
 +        for (j = 0; j < ((fieldlength >> 0) & 3) + 1; j++)
 +            avio_r8(f);
 +    }
  
 +    avio_seek(f, pos + size, SEEK_SET);
      return 0;
  }
  
 +static int mov_read_mfra(MOVContext *c, AVIOContext *f)
 +{
 +    int64_t stream_size = avio_size(f);
 +    int64_t original_pos = avio_tell(f);
 +    int64_t seek_ret;
 +    int32_t mfra_size;
 +    int ret = -1;
 +    if ((seek_ret = avio_seek(f, stream_size - 4, SEEK_SET)) < 0) {
 +        ret = seek_ret;
 +        goto fail;
 +    }
 +    mfra_size = avio_rb32(f);
 +    if (mfra_size < 0 || mfra_size > stream_size) {
 +        av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (unreasonable size)\n");
 +        goto fail;
 +    }
 +    if ((seek_ret = avio_seek(f, -mfra_size, SEEK_CUR)) < 0) {
 +        ret = seek_ret;
 +        goto fail;
 +    }
 +    if (avio_rb32(f) != mfra_size) {
 +        av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (size mismatch)\n");
 +        goto fail;
 +    }
 +    if (avio_rb32(f) != MKBETAG('m', 'f', 'r', 'a')) {
 +        av_log(c->fc, AV_LOG_DEBUG, "doesn't look like mfra (tag mismatch)\n");
 +        goto fail;
 +    }
 +    av_log(c->fc, AV_LOG_VERBOSE, "stream has mfra\n");
 +    do {
 +        ret = read_tfra(c, f);
 +        if (ret < 0)
 +            goto fail;
 +    } while (!ret);
 +    ret = 0;
 +fail:
 +    seek_ret = avio_seek(f, original_pos, SEEK_SET);
 +    if (seek_ret < 0) {
 +        av_log(c->fc, AV_LOG_ERROR,
 +               "failed to seek back after looking for mfra\n");
 +        ret = seek_ret;
 +    }
 +    return ret;
 +}
 +
  static int mov_read_header(AVFormatContext *s)
  {
      MOVContext *mov = s->priv_data;
      AVIOContext *pb = s->pb;
 -    int err;
 +    int j, err;
      MOVAtom atom = { AV_RL32("root") };
      int i;
  
          atom.size = INT64_MAX;
  
      /* check MOV header */
 +    do {
 +    if (mov->moov_retry)
 +        avio_seek(pb, 0, SEEK_SET);
      if ((err = mov_read_default(mov, pb, atom)) < 0) {
 -        av_log(s, AV_LOG_ERROR, "error reading header: %d\n", err);
 +        av_log(s, AV_LOG_ERROR, "error reading header\n");
          mov_read_close(s);
          return err;
      }
 +    } while (pb->seekable && !mov->found_moov && !mov->moov_retry++);
      if (!mov->found_moov) {
          av_log(s, AV_LOG_ERROR, "moov atom not found\n");
          mov_read_close(s);
      }
      av_dlog(mov->fc, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
  
 -    if (pb->seekable && mov->chapter_track > 0)
 -        mov_read_chapters(s);
 +    if (pb->seekable) {
 +        if (mov->chapter_track > 0)
 +            mov_read_chapters(s);
 +        for (i = 0; i < s->nb_streams; i++)
 +            if (s->streams[i]->codec->codec_tag == AV_RL32("tmcd"))
 +                mov_read_timecode_track(s, s->streams[i]);
 +    }
  
 +    /* copy timecode metadata from tmcd tracks to the related video streams */
      for (i = 0; i < s->nb_streams; i++) {
          AVStream *st = s->streams[i];
          MOVStreamContext *sc = st->priv_data;
 +        if (sc->timecode_track > 0) {
 +            AVDictionaryEntry *tcr;
 +            int tmcd_st_id = -1;
 +
 +            for (j = 0; j < s->nb_streams; j++)
 +                if (s->streams[j]->id == sc->timecode_track)
 +                    tmcd_st_id = j;
 +
 +            if (tmcd_st_id < 0 || tmcd_st_id == i)
 +                continue;
 +            tcr = av_dict_get(s->streams[tmcd_st_id]->metadata, "timecode", NULL, 0);
 +            if (tcr)
 +                av_dict_set(&st->metadata, "timecode", tcr->value, 0);
 +        }
 +    }
 +    export_orphan_timecode(s);
  
 +    for (i = 0; i < s->nb_streams; i++) {
 +        AVStream *st = s->streams[i];
 +        MOVStreamContext *sc = st->priv_data;
 +        fix_timescale(mov, sc);
 +        if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->codec->codec_id == AV_CODEC_ID_AAC) {
 +            st->skip_samples = sc->start_pad;
 +        }
 +        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && sc->nb_frames_for_fps > 0 && sc->duration_for_fps > 0)
 +            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
 +                      sc->time_scale*(int64_t)sc->nb_frames_for_fps, sc->duration_for_fps, INT_MAX);
          if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
              if (st->codec->width <= 0 || st->codec->height <= 0) {
                  st->codec->width  = sc->width;
          }
      }
  
 +    if (mov->use_mfra_for > 0) {
 +        for (i = 0; i < s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            MOVStreamContext *sc = st->priv_data;
 +            if (sc->duration_for_fps > 0) {
 +                st->codec->bit_rate = sc->data_size * 8 * sc->time_scale /
 +                    sc->duration_for_fps;
 +            }
 +        }
 +    }
 +
 +    for (i = 0; i < mov->bitrates_count && i < s->nb_streams; i++) {
 +        if (mov->bitrates[i]) {
 +            s->streams[i]->codec->bit_rate = mov->bitrates[i];
 +        }
 +    }
 +
 +    ff_rfps_calculate(s);
 +
      for (i = 0; i < s->nb_streams; i++) {
          AVStream *st = s->streams[i];
          MOVStreamContext *sc = st->priv_data;
@@@ -4114,7 -3342,6 +4130,7 @@@ static int mov_read_packet(AVFormatCont
      AVIndexEntry *sample;
      AVStream *st = NULL;
      int ret;
 +    mov->fc = s;
   retry:
      sample = mov_find_next_sample(s, &st);
      if (!sample) {
          avio_seek(s->pb, mov->next_root_atom, SEEK_SET);
          mov->next_root_atom = 0;
          if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
 -            s->pb->eof_reached)
 +            avio_feof(s->pb))
              return AVERROR_EOF;
          av_dlog(s, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
          goto retry;
      /* must be done just before reading, to avoid infinite loop on sample */
      sc->current_sample++;
  
 +    if (mov->next_root_atom) {
 +        sample->pos = FFMIN(sample->pos, mov->next_root_atom);
 +        sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));
 +    }
 +
      if (st->discard != AVDISCARD_ALL) {
          if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {
              av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
          }
  #if CONFIG_DV_DEMUXER
          if (mov->dv_demux && sc->dv_audio_container) {
 -            avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size);
 -            av_free(pkt->data);
 +            avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);
 +            av_freep(&pkt->data);
              pkt->size = 0;
              ret = avpriv_dv_get_packet(mov->dv_demux, pkt);
              if (ret < 0)
@@@ -4237,6 -3459,8 +4253,6 @@@ static int mov_read_seek(AVFormatContex
  
      if (stream_index >= s->nb_streams)
          return AVERROR_INVALIDDATA;
 -    if (sample_time < 0)
 -        sample_time = 0;
  
      st = s->streams[stream_index];
      sample = mov_seek_stream(s, st, sample_time, flags);
      seek_timestamp = st->index_entries[sample].timestamp;
  
      for (i = 0; i < s->nb_streams; i++) {
 +        MOVStreamContext *sc = s->streams[i]->priv_data;
          st = s->streams[i];
 +        st->skip_samples = (sample_time <= 0) ? sc->start_pad : 0;
 +
          if (stream_index == i)
              continue;
  
  #define OFFSET(x) offsetof(MOVContext, x)
  #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
  static const AVOption mov_options[] = {
 +    {"use_absolute_path",
 +        "allow using absolute path when opening alias, this is a possible security issue",
 +        OFFSET(use_absolute_path), FF_OPT_TYPE_INT, {.i64 = 0},
 +        0, 1, FLAGS},
 +    {"ignore_editlist", "", OFFSET(ignore_editlist), FF_OPT_TYPE_INT, {.i64 = 0},
 +        0, 1, FLAGS},
 +    {"use_mfra_for",
 +        "use mfra for fragment timestamps",
 +        OFFSET(use_mfra_for), FF_OPT_TYPE_INT, {.i64 = FF_MOV_FLAG_MFRA_AUTO},
 +        -1, FF_MOV_FLAG_MFRA_PTS, FLAGS,
 +        "use_mfra_for"},
 +    {"auto", "auto", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_AUTO}, 0, 0,
 +        FLAGS, "use_mfra_for" },
 +    {"dts", "dts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_DTS}, 0, 0,
 +        FLAGS, "use_mfra_for" },
 +    {"pts", "pts", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_MFRA_PTS}, 0, 0,
 +        FLAGS, "use_mfra_for" },
      { "export_all", "Export unrecognized metadata entries", OFFSET(export_all),
          AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = FLAGS },
      { "export_xmp", "Export full XMP metadata", OFFSET(export_xmp),
@@@ -4305,5 -3509,4 +4321,5 @@@ AVInputFormat ff_mov_demuxer = 
      .read_packet    = mov_read_packet,
      .read_close     = mov_read_close,
      .read_seek      = mov_read_seek,
 +    .flags          = AVFMT_NO_BYTE_SEEK,
  };