Merge commit 'f69befe5eefef12172a6479dd9cef3c01bddec7a'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 7 Mar 2014 23:13:20 +0000 (00:13 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 7 Mar 2014 23:13:20 +0000 (00:13 +0100)
* commit 'f69befe5eefef12172a6479dd9cef3c01bddec7a':
  matroskadec: cosmetics: Fix "attachement" vs. "attachment" typo

Conflicts:
libavformat/matroskadec.c

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

@@@ -1,21 -1,21 +1,21 @@@
  /*
   * Matroska file demuxer
 - * Copyright (c) 2003-2008 The Libav Project
 + * Copyright (c) 2003-2008 The FFmpeg Project
   *
 - * 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
   */
  
@@@ -39,7 -39,6 +39,7 @@@
  #endif
  
  #include "libavutil/avstring.h"
 +#include "libavutil/base64.h"
  #include "libavutil/dict.h"
  #include "libavutil/intfloat.h"
  #include "libavutil/intreadwrite.h"
@@@ -67,7 -66,6 +67,7 @@@ typedef enum 
      EBML_NEST,
      EBML_PASS,
      EBML_STOP,
 +    EBML_SINT,
      EBML_TYPE_COUNT
  } EbmlType;
  
@@@ -109,15 -107,9 +109,15 @@@ typedef struct 
  } MatroskaTrackCompression;
  
  typedef struct {
 +    uint64_t algo;
 +    EbmlBin  key_id;
 +} MatroskaTrackEncryption;
 +
 +typedef struct {
      uint64_t scope;
      uint64_t type;
      MatroskaTrackCompression compression;
 +    MatroskaTrackEncryption encryption;
  } MatroskaTrackEncoding;
  
  typedef struct {
      uint64_t display_height;
      uint64_t pixel_width;
      uint64_t pixel_height;
 -    uint64_t fourcc;
 +    EbmlBin color_space;
 +    uint64_t stereo_mode;
 +    uint64_t alpha_mode;
  } MatroskaTrackVideo;
  
  typedef struct {
  } MatroskaTrackAudio;
  
  typedef struct {
 +    uint64_t uid;
 +    uint64_t type;
 +} MatroskaTrackPlane;
 +
 +typedef struct {
 +    EbmlList combine_planes;
 +} MatroskaTrackOperation;
 +
 +typedef struct {
      uint64_t num;
      uint64_t uid;
      uint64_t type;
      uint64_t default_duration;
      uint64_t flag_default;
      uint64_t flag_forced;
 +    uint64_t codec_delay;
 +    uint64_t seek_preroll;
      MatroskaTrackVideo video;
      MatroskaTrackAudio audio;
 +    MatroskaTrackOperation operation;
      EbmlList encodings;
  
      AVStream *stream;
      int64_t end_timecode;
      int ms_compat;
 +    uint64_t max_block_additional_id;
  } MatroskaTrack;
  
  typedef struct {
      EbmlBin bin;
  
      AVStream *stream;
- } MatroskaAttachement;
+ } MatroskaAttachment;
  
  typedef struct {
      uint64_t start;
@@@ -258,8 -235,6 +258,8 @@@ typedef struct 
      uint64_t time_scale;
      double   duration;
      char    *title;
 +    char    *muxingapp;
 +    EbmlBin date_utc;
      EbmlList tracks;
      EbmlList attachments;
      EbmlList chapters;
@@@ -297,9 -272,6 +297,9 @@@ typedef struct 
      int64_t  reference;
      uint64_t non_simple;
      EbmlBin  bin;
 +    uint64_t additional_id;
 +    EbmlBin  additional;
 +    int64_t discard_padding;
  } MatroskaBlock;
  
  static EbmlSyntax ebml_header[] = {
@@@ -323,27 -295,26 +323,27 @@@ static EbmlSyntax matroska_info[] = 
      { MATROSKA_ID_DURATION,      EBML_FLOAT, 0, offsetof(MatroskaDemuxContext, duration) },
      { MATROSKA_ID_TITLE,         EBML_UTF8,  0, offsetof(MatroskaDemuxContext, title) },
      { MATROSKA_ID_WRITINGAPP,    EBML_NONE },
 -    { MATROSKA_ID_MUXINGAPP,     EBML_NONE },
 -    { MATROSKA_ID_DATEUTC,       EBML_NONE },
 +    { MATROSKA_ID_MUXINGAPP,     EBML_UTF8, 0, offsetof(MatroskaDemuxContext, muxingapp) },
 +    { MATROSKA_ID_DATEUTC,       EBML_BIN,  0, offsetof(MatroskaDemuxContext, date_utc) },
      { MATROSKA_ID_SEGMENTUID,    EBML_NONE },
      { 0 }
  };
  
  static EbmlSyntax matroska_track_video[] = {
      { MATROSKA_ID_VIDEOFRAMERATE,      EBML_FLOAT, 0, offsetof(MatroskaTrackVideo, frame_rate) },
 -    { MATROSKA_ID_VIDEODISPLAYWIDTH,   EBML_UINT,  0, offsetof(MatroskaTrackVideo, display_width) },
 -    { MATROSKA_ID_VIDEODISPLAYHEIGHT,  EBML_UINT,  0, offsetof(MatroskaTrackVideo, display_height) },
 +    { MATROSKA_ID_VIDEODISPLAYWIDTH,   EBML_UINT,  0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
 +    { MATROSKA_ID_VIDEODISPLAYHEIGHT,  EBML_UINT,  0, offsetof(MatroskaTrackVideo, display_height), { .u=-1 } },
      { MATROSKA_ID_VIDEOPIXELWIDTH,     EBML_UINT,  0, offsetof(MatroskaTrackVideo, pixel_width) },
      { MATROSKA_ID_VIDEOPIXELHEIGHT,    EBML_UINT,  0, offsetof(MatroskaTrackVideo, pixel_height) },
 -    { MATROSKA_ID_VIDEOCOLORSPACE,     EBML_UINT,  0, offsetof(MatroskaTrackVideo, fourcc) },
 +    { MATROSKA_ID_VIDEOCOLORSPACE,     EBML_BIN,   0, offsetof(MatroskaTrackVideo, color_space) },
 +    { MATROSKA_ID_VIDEOSTEREOMODE,     EBML_UINT,  0, offsetof(MatroskaTrackVideo, stereo_mode) },
 +    { MATROSKA_ID_VIDEOALPHAMODE,      EBML_UINT,  0, offsetof(MatroskaTrackVideo, alpha_mode) },
      { MATROSKA_ID_VIDEOPIXELCROPB,     EBML_NONE },
      { MATROSKA_ID_VIDEOPIXELCROPT,     EBML_NONE },
      { MATROSKA_ID_VIDEOPIXELCROPL,     EBML_NONE },
      { MATROSKA_ID_VIDEOPIXELCROPR,     EBML_NONE },
      { MATROSKA_ID_VIDEODISPLAYUNIT,    EBML_NONE },
      { MATROSKA_ID_VIDEOFLAGINTERLACED, EBML_NONE },
 -    { MATROSKA_ID_VIDEOSTEREOMODE,     EBML_NONE },
      { MATROSKA_ID_VIDEOASPECTRATIO,    EBML_NONE },
      { 0 }
  };
@@@ -362,21 -333,10 +362,21 @@@ static EbmlSyntax matroska_track_encodi
      { 0 }
  };
  
 +static EbmlSyntax matroska_track_encoding_encryption[] = {
 +    { MATROSKA_ID_ENCODINGENCALGO,        EBML_UINT, 0, offsetof(MatroskaTrackEncryption,algo), {.u = 0} },
 +    { MATROSKA_ID_ENCODINGENCKEYID,       EBML_BIN, 0, offsetof(MatroskaTrackEncryption,key_id) },
 +    { MATROSKA_ID_ENCODINGENCAESSETTINGS, EBML_NONE },
 +    { MATROSKA_ID_ENCODINGSIGALGO,        EBML_NONE },
 +    { MATROSKA_ID_ENCODINGSIGHASHALGO,    EBML_NONE },
 +    { MATROSKA_ID_ENCODINGSIGKEYID,       EBML_NONE },
 +    { MATROSKA_ID_ENCODINGSIGNATURE,      EBML_NONE },
 +    { 0 }
 +};
  static EbmlSyntax matroska_track_encoding[] = {
      { MATROSKA_ID_ENCODINGSCOPE,       EBML_UINT, 0, offsetof(MatroskaTrackEncoding, scope),       { .u = 1 } },
      { MATROSKA_ID_ENCODINGTYPE,        EBML_UINT, 0, offsetof(MatroskaTrackEncoding, type),        { .u = 0 } },
      { MATROSKA_ID_ENCODINGCOMPRESSION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, compression), { .n = matroska_track_encoding_compression } },
 +    { MATROSKA_ID_ENCODINGENCRYPTION,  EBML_NEST, 0, offsetof(MatroskaTrackEncoding, encryption),  { .n = matroska_track_encoding_encryption } },
      { MATROSKA_ID_ENCODINGORDER,       EBML_NONE },
      { 0 }
  };
@@@ -386,22 -346,6 +386,22 @@@ static EbmlSyntax matroska_track_encodi
      { 0 }
  };
  
 +static EbmlSyntax matroska_track_plane[] = {
 +    { MATROSKA_ID_TRACKPLANEUID,  EBML_UINT, 0, offsetof(MatroskaTrackPlane,uid) },
 +    { MATROSKA_ID_TRACKPLANETYPE, EBML_UINT, 0, offsetof(MatroskaTrackPlane,type) },
 +    { 0 }
 +};
 +
 +static EbmlSyntax matroska_track_combine_planes[] = {
 +    { MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
 +    { 0 }
 +};
 +
 +static EbmlSyntax matroska_track_operation[] = {
 +    { MATROSKA_ID_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n = matroska_track_combine_planes} },
 +    { 0 }
 +};
 +
  static EbmlSyntax matroska_track[] = {
      { MATROSKA_ID_TRACKNUMBER,           EBML_UINT,  0, offsetof(MatroskaTrack, num) },
      { MATROSKA_ID_TRACKNAME,             EBML_UTF8,  0, offsetof(MatroskaTrack, name) },
      { MATROSKA_ID_TRACKTYPE,             EBML_UINT,  0, offsetof(MatroskaTrack, type) },
      { MATROSKA_ID_CODECID,               EBML_STR,   0, offsetof(MatroskaTrack, codec_id) },
      { MATROSKA_ID_CODECPRIVATE,          EBML_BIN,   0, offsetof(MatroskaTrack, codec_priv) },
 -    { MATROSKA_ID_TRACKLANGUAGE,         EBML_UTF8,  0, offsetof(MatroskaTrack, language),     { .s = "eng"  } },
 +    { MATROSKA_ID_TRACKLANGUAGE,         EBML_UTF8,  0, offsetof(MatroskaTrack, language),     { .s = "eng" } },
      { MATROSKA_ID_TRACKDEFAULTDURATION,  EBML_UINT,  0, offsetof(MatroskaTrack, default_duration) },
 -    { MATROSKA_ID_TRACKTIMECODESCALE,    EBML_FLOAT, 0, offsetof(MatroskaTrack, time_scale),   { .f = 1.0  } },
 -    { MATROSKA_ID_TRACKFLAGDEFAULT,      EBML_UINT,  0, offsetof(MatroskaTrack, flag_default), { .u = 1  } },
 -    { MATROSKA_ID_TRACKFLAGFORCED,       EBML_UINT,  0, offsetof(MatroskaTrack, flag_forced),  { .u = 0   } },
 +    { MATROSKA_ID_TRACKTIMECODESCALE,    EBML_FLOAT, 0, offsetof(MatroskaTrack, time_scale),   { .f = 1.0 } },
 +    { MATROSKA_ID_TRACKFLAGDEFAULT,      EBML_UINT,  0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
 +    { MATROSKA_ID_TRACKFLAGFORCED,       EBML_UINT,  0, offsetof(MatroskaTrack, flag_forced),  { .u = 0 } },
      { MATROSKA_ID_TRACKVIDEO,            EBML_NEST,  0, offsetof(MatroskaTrack, video),        { .n = matroska_track_video } },
      { MATROSKA_ID_TRACKAUDIO,            EBML_NEST,  0, offsetof(MatroskaTrack, audio),        { .n = matroska_track_audio } },
 +    { MATROSKA_ID_TRACKOPERATION,        EBML_NEST,  0, offsetof(MatroskaTrack, operation),    { .n = matroska_track_operation } },
      { MATROSKA_ID_TRACKCONTENTENCODINGS, EBML_NEST,  0, 0,                                     { .n = matroska_track_encodings } },
 +    { MATROSKA_ID_TRACKMAXBLKADDID,      EBML_UINT,  0, offsetof(MatroskaTrack, max_block_additional_id) },
 +    { MATROSKA_ID_CODECDELAY,            EBML_UINT,  0, offsetof(MatroskaTrack, codec_delay) },
 +    { MATROSKA_ID_SEEKPREROLL,           EBML_UINT,  0, offsetof(MatroskaTrack, seek_preroll) },
      { MATROSKA_ID_TRACKFLAGENABLED,      EBML_NONE },
      { MATROSKA_ID_TRACKFLAGLACING,       EBML_NONE },
      { MATROSKA_ID_CODECNAME,             EBML_NONE },
      { MATROSKA_ID_CODECDOWNLOADURL,      EBML_NONE },
      { MATROSKA_ID_TRACKMINCACHE,         EBML_NONE },
      { MATROSKA_ID_TRACKMAXCACHE,         EBML_NONE },
 -    { MATROSKA_ID_TRACKMAXBLKADDID,      EBML_NONE },
      { 0 }
  };
  
@@@ -438,16 -379,16 +438,16 @@@ static EbmlSyntax matroska_tracks[] = 
  };
  
  static EbmlSyntax matroska_attachment[] = {
-     { MATROSKA_ID_FILEUID,      EBML_UINT, 0, offsetof(MatroskaAttachement, uid) },
-     { MATROSKA_ID_FILENAME,     EBML_UTF8, 0, offsetof(MatroskaAttachement, filename) },
-     { MATROSKA_ID_FILEMIMETYPE, EBML_STR,  0, offsetof(MatroskaAttachement, mime) },
-     { MATROSKA_ID_FILEDATA,     EBML_BIN,  0, offsetof(MatroskaAttachement, bin) },
+     { MATROSKA_ID_FILEUID,      EBML_UINT, 0, offsetof(MatroskaAttachment, uid) },
+     { MATROSKA_ID_FILENAME,     EBML_UTF8, 0, offsetof(MatroskaAttachment, filename) },
+     { MATROSKA_ID_FILEMIMETYPE, EBML_STR,  0, offsetof(MatroskaAttachment, mime) },
+     { MATROSKA_ID_FILEDATA,     EBML_BIN,  0, offsetof(MatroskaAttachment, bin) },
      { MATROSKA_ID_FILEDESC,     EBML_NONE },
      { 0 }
  };
  
  static EbmlSyntax matroska_attachments[] = {
-     { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachement), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
+     { MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
      { 0 }
  };
  
@@@ -486,8 -427,6 +486,8 @@@ static EbmlSyntax matroska_chapters[] 
  static EbmlSyntax matroska_index_pos[] = {
      { MATROSKA_ID_CUETRACK,           EBML_UINT, 0, offsetof(MatroskaIndexPos, track) },
      { MATROSKA_ID_CUECLUSTERPOSITION, EBML_UINT, 0, offsetof(MatroskaIndexPos, pos) },
 +    { MATROSKA_ID_CUERELATIVEPOSITION,EBML_NONE },
 +    { MATROSKA_ID_CUEDURATION,        EBML_NONE },
      { MATROSKA_ID_CUEBLOCKNUMBER,     EBML_NONE },
      { 0 }
  };
@@@ -561,24 -500,11 +561,24 @@@ static EbmlSyntax matroska_segments[] 
      { 0 }
  };
  
 +static EbmlSyntax matroska_blockmore[] = {
 +    { MATROSKA_ID_BLOCKADDID,      EBML_UINT, 0, offsetof(MatroskaBlock,additional_id) },
 +    { MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN,  0, offsetof(MatroskaBlock,additional) },
 +    { 0 }
 +};
 +
 +static EbmlSyntax matroska_blockadditions[] = {
 +    { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, {.n = matroska_blockmore} },
 +    { 0 }
 +};
 +
  static EbmlSyntax matroska_blockgroup[] = {
      { MATROSKA_ID_BLOCK,          EBML_BIN,  0, offsetof(MatroskaBlock, bin) },
 +    { MATROSKA_ID_BLOCKADDITIONS, EBML_NEST, 0, 0, { .n = matroska_blockadditions} },
      { MATROSKA_ID_SIMPLEBLOCK,    EBML_BIN,  0, offsetof(MatroskaBlock, bin) },
 -    { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock, duration), { .u = AV_NOPTS_VALUE } },
 -    { MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock, reference) },
 +    { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock, duration) },
 +    { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock, discard_padding) },
 +    { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference) },
      { MATROSKA_ID_CODECSTATE,     EBML_NONE },
      {                          1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
      { 0 }
@@@ -650,7 -576,7 +650,7 @@@ static int matroska_resync(MatroskaDemu
      id = avio_rb32(pb);
  
      // try to find a toplevel element
 -    while (!pb->eof_reached) {
 +    while (!url_feof(pb)) {
          if (id == MATROSKA_ID_INFO     || id == MATROSKA_ID_TRACKS      ||
              id == MATROSKA_ID_CUES     || id == MATROSKA_ID_TAGS        ||
              id == MATROSKA_ID_SEEKHEAD || id == MATROSKA_ID_ATTACHMENTS ||
@@@ -703,7 -629,7 +703,7 @@@ static int ebml_read_num(MatroskaDemuxC
       * use it safely here to catch EOS. */
      if (!(total = avio_r8(pb))) {
          /* we might encounter EOS here */
 -        if (!pb->eof_reached) {
 +        if (!url_feof(pb)) {
              int64_t pos = avio_tell(pb);
              av_log(matroska->ctx, AV_LOG_ERROR,
                     "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
@@@ -767,30 -693,6 +767,30 @@@ static int ebml_read_uint(AVIOContext *
  }
  
  /*
 + * Read the next element as a signed int.
 + * 0 is success, < 0 is failure.
 + */
 +static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
 +{
 +    int n = 1;
 +
 +    if (size > 8)
 +        return AVERROR_INVALIDDATA;
 +
 +    if (size == 0) {
 +        *num = 0;
 +    } else {
 +        *num = sign_extend(avio_r8(pb), 8);
 +
 +        /* big-endian ordering; build up number */
 +        while (n++ < size)
 +            *num = (*num << 8) | avio_r8(pb);
 +    }
 +
 +    return 0;
 +}
 +
 +/*
   * Read the next element as a float.
   * 0 is success, < 0 is failure.
   */
@@@ -837,15 -739,16 +837,15 @@@ static int ebml_read_ascii(AVIOContext 
   */
  static int ebml_read_binary(AVIOContext *pb, int length, EbmlBin *bin)
  {
 -    av_free(bin->data);
 -    if (!(bin->data = av_malloc(length + FF_INPUT_BUFFER_PADDING_SIZE)))
 +    av_fast_padded_malloc(&bin->data, &bin->size, length);
 +    if (!bin->data)
          return AVERROR(ENOMEM);
  
 -    memset(bin->data + length, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 -
      bin->size = length;
      bin->pos  = avio_tell(pb);
      if (avio_read(pb, bin->data, length) != length) {
          av_freep(&bin->data);
 +        bin->size = 0;
          return AVERROR(EIO);
      }
  
@@@ -989,15 -892,16 +989,15 @@@ static int ebml_parse_elem(MatroskaDemu
      uint32_t id = syntax->id;
      uint64_t length;
      int res;
 +    void *newelem;
  
      data = (char *) data + syntax->data_offset;
      if (syntax->list_elem_size) {
          EbmlList *list = data;
 -        if ((res = av_reallocp_array(&list->elem,
 -                                     list->nb_elem + 1,
 -                                     syntax->list_elem_size)) < 0) {
 -            list->nb_elem = 0;
 -            return res;
 -        }
 +        newelem = av_realloc_array(list->elem, list->nb_elem + 1, syntax->list_elem_size);
 +        if (!newelem)
 +            return AVERROR(ENOMEM);
 +        list->elem = newelem;
          data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
          memset(data, 0, syntax->list_elem_size);
          list->nb_elem++;
      case EBML_UINT:
          res = ebml_read_uint(pb, length, data);
          break;
 +    case EBML_SINT:
 +        res = ebml_read_sint(pb, length, data);
 +        break;
      case EBML_FLOAT:
          res = ebml_read_float(pb, length, data);
          break;
      case EBML_STOP:
          return 1;
      default:
 +        if (ffio_limit(pb, length) != length)
 +            return AVERROR(EIO);
          return avio_skip(pb, length) < 0 ? AVERROR(EIO) : 0;
      }
      if (res == AVERROR_INVALIDDATA)
@@@ -1154,7 -1053,7 +1154,7 @@@ static int matroska_decode_buffer(uint8
      int result = 0;
      int olen;
  
 -    if (pkt_size >= 10000000)
 +    if (pkt_size >= 10000000U)
          return AVERROR_INVALIDDATA;
  
      switch (encodings[0].compression.algo) {
          int header_size = encodings[0].compression.settings.size;
          uint8_t *header = encodings[0].compression.settings.data;
  
 +        if (header_size && !header) {
 +            av_log(NULL, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
 +            return -1;
 +        }
 +
          if (!header_size)
              return 0;
  
              pkt_data          = newpktdata;
              zstream.avail_out = pkt_size - zstream.total_out;
              zstream.next_out  = pkt_data + zstream.total_out;
 -            result            = inflate(&zstream, Z_NO_FLUSH);
 +            if (pkt_data) {
 +                result = inflate(&zstream, Z_NO_FLUSH);
 +            } else
 +                result = Z_MEM_ERROR;
          } while (result == Z_OK && pkt_size < 10000000);
          pkt_size = zstream.total_out;
          inflateEnd(&zstream);
              pkt_data           = newpktdata;
              bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
              bzstream.next_out  = pkt_data + bzstream.total_out_lo32;
 -            result             = BZ2_bzDecompress(&bzstream);
 +            if (pkt_data) {
 +                result = BZ2_bzDecompress(&bzstream);
 +            } else
 +                result = BZ_MEM_ERROR;
          } while (result == BZ_OK && pkt_size < 10000000);
          pkt_size = bzstream.total_out_lo32;
          BZ2_bzDecompressEnd(&bzstream);
@@@ -1282,7 -1170,6 +1282,7 @@@ failed
      return result;
  }
  
 +#if FF_API_ASS_SSA
  static void matroska_fix_ass_packet(MatroskaDemuxContext *matroska,
                                      AVPacket *pkt, uint64_t display_duration)
  {
      for (; *ptr != ',' && ptr < end - 1; ptr++)
          ;
      if (*ptr == ',')
 -        layer = ++ptr;
 +        ptr++;
 +    layer = ptr;
      for (; *ptr != ',' && ptr < end - 1; ptr++)
          ;
      if (*ptr == ',') {
  
  static int matroska_merge_packets(AVPacket *out, AVPacket *in)
  {
 -    int old_size = out->size;
      int ret = av_grow_packet(out, in->size);
      if (ret < 0)
          return ret;
  
 -    memcpy(out->data + old_size, in->data, in->size);
 +    memcpy(out->data + out->size - in->size, in->data, in->size);
  
      av_free_packet(in);
      av_free(in);
      return 0;
  }
 +#endif
  
  static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
                                   AVDictionary **metadata, char *prefix)
@@@ -1384,7 -1270,7 +1384,7 @@@ static void matroska_convert_tags(AVFor
  
      for (i = 0; i < matroska->tags.nb_elem; i++) {
          if (tags[i].target.attachuid) {
-             MatroskaAttachement *attachment = matroska->attachments.elem;
+             MatroskaAttachment *attachment = matroska->attachments.elem;
              for (j = 0; j < matroska->attachments.nb_elem; j++)
                  if (attachment[j].uid == tags[i].target.attachuid &&
                      attachment[j].stream)
@@@ -1484,21 -1370,27 +1484,21 @@@ static void matroska_execute_seekhead(M
              continue;
          }
  
 -        if (matroska_parse_seekhead_entry(matroska, i) < 0)
 +        if (matroska_parse_seekhead_entry(matroska, i) < 0) {
 +            // mark index as broken
 +            matroska->cues_parsing_deferred = -1;
              break;
 +        }
      }
  }
  
 -static void matroska_parse_cues(MatroskaDemuxContext *matroska)
 +static void matroska_add_index_entries(MatroskaDemuxContext *matroska)
  {
 -    EbmlList *seekhead_list = &matroska->seekhead;
 -    MatroskaSeekhead *seekhead = seekhead_list->elem;
      EbmlList *index_list;
      MatroskaIndex *index;
      int index_scale = 1;
      int i, j;
  
 -    for (i = 0; i < seekhead_list->nb_elem; i++)
 -        if (seekhead[i].id == MATROSKA_ID_CUES)
 -            break;
 -    assert(i <= seekhead_list->nb_elem);
 -
 -    matroska_parse_seekhead_entry(matroska, i);
 -
      index_list = &matroska->index;
      index      = index_list->elem;
      if (index_list->nb_elem &&
      }
  }
  
 +static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
 +    EbmlList *seekhead_list = &matroska->seekhead;
 +    MatroskaSeekhead *seekhead = seekhead_list->elem;
 +    int i;
 +
 +    for (i = 0; i < seekhead_list->nb_elem; i++)
 +        if (seekhead[i].id == MATROSKA_ID_CUES)
 +            break;
 +    av_assert1(i <= seekhead_list->nb_elem);
 +
 +    if (matroska_parse_seekhead_entry(matroska, i) < 0)
 +       matroska->cues_parsing_deferred = -1;
 +    matroska_add_index_entries(matroska);
 +}
 +
  static int matroska_aac_profile(char *codec_id)
  {
      static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
@@@ -1557,30 -1434,19 +1557,30 @@@ static int matroska_aac_sri(int sampler
      return sri;
  }
  
 +static void matroska_metadata_creation_time(AVDictionary **metadata, int64_t date_utc)
 +{
 +    char buffer[32];
 +    /* Convert to seconds and adjust by number of seconds between 2001-01-01 and Epoch */
 +    time_t creation_time = date_utc / 1000000000 + 978307200;
 +    struct tm *ptm = gmtime(&creation_time);
 +    if (!ptm) return;
 +    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
 +    av_dict_set(metadata, "creation_time", buffer, 0);
 +}
 +
  static int matroska_read_header(AVFormatContext *s)
  {
      MatroskaDemuxContext *matroska = s->priv_data;
-     EbmlList *attachements_list = &matroska->attachments;
-     EbmlList *chapters_list     = &matroska->chapters;
-     MatroskaAttachement *attachements;
+     EbmlList *attachments_list = &matroska->attachments;
+     EbmlList *chapters_list    = &matroska->chapters;
+     MatroskaAttachment *attachments;
      MatroskaChapter *chapters;
      MatroskaTrack *tracks;
      uint64_t max_start = 0;
      int64_t pos;
      Ebml ebml = { 0 };
      AVStream *st;
 -    int i, j, res;
 +    int i, j, k, res;
  
      matroska->ctx = s;
  
          ebml.version         > EBML_VERSION      ||
          ebml.max_size        > sizeof(uint64_t)  ||
          ebml.id_length       > sizeof(uint32_t)  ||
 -        ebml.doctype_version > 2) {
 +        ebml.doctype_version > 3                 ||
 +        !ebml.doctype) {
          av_log(matroska->ctx, AV_LOG_ERROR,
                 "EBML header using unsupported features\n"
                 "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
                 ebml.version, ebml.doctype, ebml.doctype_version);
          ebml_free(ebml_syntax, &ebml);
          return AVERROR_PATCHWELCOME;
 +    } else if (ebml.doctype_version == 3) {
 +        av_log(matroska->ctx, AV_LOG_WARNING,
 +               "EBML header using unsupported features\n"
 +               "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
 +               ebml.version, ebml.doctype, ebml.doctype_version);
      }
      for (i = 0; i < FF_ARRAY_ELEMS(matroska_doctypes); i++)
          if (!strcmp(ebml.doctype, matroska_doctypes[i]))
          matroska->ctx->duration = matroska->duration * matroska->time_scale *
                                    1000 / AV_TIME_BASE;
      av_dict_set(&s->metadata, "title", matroska->title, 0);
 +    av_dict_set(&s->metadata, "encoder", matroska->muxingapp, 0);
 +
 +    if (matroska->date_utc.size == 8)
 +        matroska_metadata_creation_time(&s->metadata, AV_RB64(matroska->date_utc.data));
  
      tracks = matroska->tracks.elem;
      for (i = 0; i < matroska->tracks.nb_elem; i++) {
          uint8_t *extradata = NULL;
          int extradata_size = 0;
          int extradata_offset = 0;
 +        uint32_t fourcc = 0;
          AVIOContext b;
 +        char* key_id_base64 = NULL;
 +        int bit_depth = -1;
  
          /* Apply some sanity checks. */
          if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
              track->type != MATROSKA_TRACK_TYPE_AUDIO &&
 -            track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
 +            track->type != MATROSKA_TRACK_TYPE_SUBTITLE &&
 +            track->type != MATROSKA_TRACK_TYPE_METADATA) {
              av_log(matroska->ctx, AV_LOG_INFO,
                     "Unknown or unsupported track type %"PRIu64"\n",
                     track->type);
          if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
              if (!track->default_duration && track->video.frame_rate > 0)
                  track->default_duration = 1000000000 / track->video.frame_rate;
 -            if (!track->video.display_width)
 +            if (track->video.display_width == -1)
                  track->video.display_width = track->video.pixel_width;
 -            if (!track->video.display_height)
 +            if (track->video.display_height == -1)
                  track->video.display_height = track->video.pixel_height;
 +            if (track->video.color_space.size == 4)
 +                fourcc = AV_RL32(track->video.color_space.data);
          } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
              if (!track->audio.out_samplerate)
                  track->audio.out_samplerate = track->audio.samplerate;
              av_log(matroska->ctx, AV_LOG_ERROR,
                     "Multiple combined encodings not supported");
          } else if (encodings_list->nb_elem == 1) {
 -            if (encodings[0].type ||
 -                (
 +            if (encodings[0].type) {
 +                if (encodings[0].encryption.key_id.size > 0) {
 +                    /* Save the encryption key id to be stored later as a
 +                       metadata tag. */
 +                    const int b64_size = AV_BASE64_SIZE(encodings[0].encryption.key_id.size);
 +                    key_id_base64 = av_malloc(b64_size);
 +                    if (key_id_base64 == NULL)
 +                        return AVERROR(ENOMEM);
 +
 +                    av_base64_encode(key_id_base64, b64_size,
 +                                     encodings[0].encryption.key_id.data,
 +                                     encodings[0].encryption.key_id.size);
 +                } else {
 +                    encodings[0].scope = 0;
 +                    av_log(matroska->ctx, AV_LOG_ERROR,
 +                           "Unsupported encoding type");
 +                }
 +            } else if (
  #if CONFIG_ZLIB
                   encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB  &&
  #endif
  #if CONFIG_LZO
                   encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_LZO   &&
  #endif
 -                 encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP)) {
 +                 encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP) {
                  encodings[0].scope = 0;
                  av_log(matroska->ctx, AV_LOG_ERROR,
                         "Unsupported encoding type");
          }
  
          st = track->stream = avformat_new_stream(s, NULL);
 -        if (st == NULL)
 +        if (st == NULL) {
 +            av_free(key_id_base64);
              return AVERROR(ENOMEM);
 +        }
 +
 +        if (key_id_base64) {
 +            /* export encryption key id as base64 metadata tag */
 +            av_dict_set(&st->metadata, "enc_key_id", key_id_base64, 0);
 +            av_freep(&key_id_base64);
 +        }
  
          if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC") &&
 -            track->codec_priv.size >= 40                &&
 +             track->codec_priv.size >= 40               &&
              track->codec_priv.data != NULL) {
              track->ms_compat    = 1;
 -            track->video.fourcc = AV_RL32(track->codec_priv.data + 16);
 +            bit_depth           = AV_RL16(track->codec_priv.data + 14);
 +            fourcc              = AV_RL32(track->codec_priv.data + 16);
              codec_id            = ff_codec_get_id(ff_codec_bmp_tags,
 -                                                  track->video.fourcc);
 +                                                  fourcc);
              extradata_offset    = 40;
          } else if (!strcmp(track->codec_id, "A_MS/ACM") &&
                     track->codec_priv.size >= 14         &&
                  return ret;
              codec_id         = st->codec->codec_id;
              extradata_offset = FFMIN(track->codec_priv.size, 18);
 +        } else if (!strcmp(track->codec_id, "A_QUICKTIME")
 +                   && (track->codec_priv.size >= 86)
 +                   && (track->codec_priv.data != NULL)) {
 +            fourcc = AV_RL32(track->codec_priv.data + 4);
 +            codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
 +            if (ff_codec_get_id(ff_codec_movaudio_tags, AV_RL32(track->codec_priv.data))) {
 +                fourcc = AV_RL32(track->codec_priv.data);
 +                codec_id = ff_codec_get_id(ff_codec_movaudio_tags, fourcc);
 +            }
          } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
 -                   (track->codec_priv.size >= 86)          &&
 +                   (track->codec_priv.size >= 21)          &&
                     (track->codec_priv.data != NULL)) {
 -            track->video.fourcc = AV_RL32(track->codec_priv.data);
 -            codec_id            = ff_codec_get_id(ff_codec_movvideo_tags,
 -                                                  track->video.fourcc);
 +            fourcc   = AV_RL32(track->codec_priv.data + 4);
 +            codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
 +            if (ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(track->codec_priv.data))) {
 +                fourcc   = AV_RL32(track->codec_priv.data);
 +                codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
 +            }
 +            if (codec_id == AV_CODEC_ID_NONE && AV_RL32(track->codec_priv.data+4) == AV_RL32("SMI "))
 +                codec_id = AV_CODEC_ID_SVQ3;
          } else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
              switch (track->audio.bitdepth) {
              case  8:
                  extradata_size = 5;
              } else
                  extradata_size = 2;
 -        } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size) {
 +        } else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size && track->codec_priv.size < INT_MAX - 12 - FF_INPUT_BUFFER_PADDING_SIZE) {
              /* Only ALAC's magic cookie is stored in Matroska's track headers.
               * Create the "atom size", "tag", and "tag version" fields the
               * decoder expects manually. */
                     track->codec_priv.size);
          } else if (codec_id == AV_CODEC_ID_TTA) {
              extradata_size = 30;
 -            extradata      = av_mallocz(extradata_size);
 +            extradata      = av_mallocz(extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
              if (extradata == NULL)
                  return AVERROR(ENOMEM);
              ffio_init_context(&b, extradata, extradata_size, 1,
              avio_wl16(&b, 1);
              avio_wl16(&b, track->audio.channels);
              avio_wl16(&b, track->audio.bitdepth);
 +            if (track->audio.out_samplerate < 0 || track->audio.out_samplerate > INT_MAX)
 +                return AVERROR_INVALIDDATA;
              avio_wl32(&b, track->audio.out_samplerate);
 -            avio_wl32(&b, matroska->ctx->duration *
 -                      track->audio.out_samplerate);
 +            avio_wl32(&b, av_rescale((matroska->duration * matroska->time_scale),
 +                                     track->audio.out_samplerate,
 +                                     AV_TIME_BASE * 1000));
          } else if (codec_id == AV_CODEC_ID_RV10 ||
                     codec_id == AV_CODEC_ID_RV20 ||
                     codec_id == AV_CODEC_ID_RV30 ||
          } else if (codec_id == AV_CODEC_ID_RA_144) {
              track->audio.out_samplerate = 8000;
              track->audio.channels       = 1;
 -        } else if (codec_id == AV_CODEC_ID_RA_288 ||
 -                   codec_id == AV_CODEC_ID_COOK   ||
 -                   codec_id == AV_CODEC_ID_ATRAC3 ||
 -                   codec_id == AV_CODEC_ID_SIPR) {
 +        } else if ((codec_id == AV_CODEC_ID_RA_288 ||
 +                    codec_id == AV_CODEC_ID_COOK   ||
 +                    codec_id == AV_CODEC_ID_ATRAC3 ||
 +                    codec_id == AV_CODEC_ID_SIPR)
 +                      && track->codec_priv.data) {
              int flavor;
 +
              ffio_init_context(&b, track->codec_priv.data,
                                track->codec_priv.size,
                                0, NULL, NULL, NULL, NULL);
              track->audio.sub_packet_h    = avio_rb16(&b);
              track->audio.frame_size      = avio_rb16(&b);
              track->audio.sub_packet_size = avio_rb16(&b);
 -            if (flavor                       <= 0 ||
 +            if (flavor                        < 0 ||
                  track->audio.coded_framesize <= 0 ||
                  track->audio.sub_packet_h    <= 0 ||
                  track->audio.frame_size      <= 0 ||
                  track->audio.sub_packet_size <= 0)
                  return AVERROR_INVALIDDATA;
 -            track->audio.buf = av_malloc(track->audio.frame_size *
 -                                         track->audio.sub_packet_h);
 +            track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
 +                                               track->audio.frame_size);
 +            if (!track->audio.buf)
 +                return AVERROR(ENOMEM);
              if (codec_id == AV_CODEC_ID_RA_288) {
                  st->codec->block_align = track->audio.coded_framesize;
                  track->codec_priv.size = 0;
              } else {
                  if (codec_id == AV_CODEC_ID_SIPR && flavor < 4) {
 -                    const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
 +                    static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
                      track->audio.sub_packet_size = ff_sipr_subpk_size[flavor];
                      st->codec->bit_rate          = sipr_bit_rate[flavor];
                  }
                              1000 * 1000 * 1000);    /* 64 bit pts in ns */
  
          st->codec->codec_id = codec_id;
 -        st->start_time      = 0;
 +
          if (strcmp(track->language, "und"))
              av_dict_set(&st->metadata, "language", track->language, 0);
          av_dict_set(&st->metadata, "title", track->name, 0);
                  st->codec->extradata      = extradata;
                  st->codec->extradata_size = extradata_size;
              } else if (track->codec_priv.data && track->codec_priv.size > 0) {
 -                st->codec->extradata = av_mallocz(track->codec_priv.size +
 -                                                  FF_INPUT_BUFFER_PADDING_SIZE);
 -                if (st->codec->extradata == NULL)
 +                if (ff_alloc_extradata(st->codec, track->codec_priv.size))
                      return AVERROR(ENOMEM);
 -                st->codec->extradata_size = track->codec_priv.size;
                  memcpy(st->codec->extradata,
                         track->codec_priv.data + extradata_offset,
                         track->codec_priv.size);
          }
  
          if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
 +            MatroskaTrackPlane *planes = track->operation.combine_planes.elem;
 +
              st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
 -            st->codec->codec_tag  = track->video.fourcc;
 +            st->codec->codec_tag  = fourcc;
 +            if (bit_depth >= 0)
 +                st->codec->bits_per_coded_sample = bit_depth;
              st->codec->width      = track->video.pixel_width;
              st->codec->height     = track->video.pixel_height;
              av_reduce(&st->sample_aspect_ratio.num,
                        st->codec->height * track->video.display_width,
                        st->codec->width  * track->video.display_height,
                        255);
 -            if (st->codec->codec_id != AV_CODEC_ID_H264 &&
 -                st->codec->codec_id != AV_CODEC_ID_HEVC)
 +            if (st->codec->codec_id != AV_CODEC_ID_HEVC)
                  st->need_parsing = AVSTREAM_PARSE_HEADERS;
 +
              if (track->default_duration) {
                  av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
                            1000000000, track->default_duration, 30000);
 +#if FF_API_R_FRAME_RATE
 +                if (st->avg_frame_rate.num < st->avg_frame_rate.den * 1000L)
 +                    st->r_frame_rate = st->avg_frame_rate;
 +#endif
 +            }
 +
 +            /* export stereo mode flag as metadata tag */
 +            if (track->video.stereo_mode && track->video.stereo_mode < MATROSKA_VIDEO_STEREO_MODE_COUNT)
 +                av_dict_set(&st->metadata, "stereo_mode", ff_matroska_video_stereo_mode[track->video.stereo_mode], 0);
 +
 +            /* export alpha mode flag as metadata tag  */
 +            if (track->video.alpha_mode)
 +                av_dict_set(&st->metadata, "alpha_mode", "1", 0);
 +
 +            /* if we have virtual track, mark the real tracks */
 +            for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
 +                char buf[32];
 +                if (planes[j].type >= MATROSKA_VIDEO_STEREO_PLANE_COUNT)
 +                    continue;
 +                snprintf(buf, sizeof(buf), "%s_%d",
 +                         ff_matroska_video_stereo_plane[planes[j].type], i);
 +                for (k=0; k < matroska->tracks.nb_elem; k++)
 +                    if (planes[j].uid == tracks[k].uid) {
 +                        av_dict_set(&s->streams[k]->metadata,
 +                                    "stereo_mode", buf, 0);
 +                        break;
 +                    }
              }
          } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
              st->codec->codec_type  = AVMEDIA_TYPE_AUDIO;
              st->codec->sample_rate = track->audio.out_samplerate;
              st->codec->channels    = track->audio.channels;
 +            if (!st->codec->bits_per_coded_sample)
 +                st->codec->bits_per_coded_sample = track->audio.bitdepth;
              if (st->codec->codec_id != AV_CODEC_ID_AAC)
                  st->need_parsing = AVSTREAM_PARSE_HEADERS;
 +            if (track->codec_delay > 0) {
 +                st->codec->delay = av_rescale_q(track->codec_delay,
 +                                                (AVRational){1, 1000000000},
 +                                                (AVRational){1, st->codec->sample_rate});
 +            }
 +            if (track->seek_preroll > 0) {
 +                av_codec_set_seek_preroll(st->codec,
 +                                          av_rescale_q(track->seek_preroll,
 +                                                       (AVRational){1, 1000000000},
 +                                                       (AVRational){1, st->codec->sample_rate}));
 +            }
 +        } else if (codec_id == AV_CODEC_ID_WEBVTT) {
 +            st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
 +
 +            if (!strcmp(track->codec_id, "D_WEBVTT/CAPTIONS")) {
 +                st->disposition |= AV_DISPOSITION_CAPTIONS;
 +            } else if (!strcmp(track->codec_id, "D_WEBVTT/DESCRIPTIONS")) {
 +                st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
 +            } else if (!strcmp(track->codec_id, "D_WEBVTT/METADATA")) {
 +                st->disposition |= AV_DISPOSITION_METADATA;
 +            }
          } else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
              st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
 -            if (st->codec->codec_id == AV_CODEC_ID_SSA)
 +#if FF_API_ASS_SSA
 +            if (st->codec->codec_id == AV_CODEC_ID_SSA ||
 +                st->codec->codec_id == AV_CODEC_ID_ASS)
 +#else
 +            if (st->codec->codec_id == AV_CODEC_ID_ASS)
 +#endif
                  matroska->contains_ssa = 1;
          }
      }
  
-     attachements = attachements_list->elem;
-     for (j = 0; j < attachements_list->nb_elem; j++) {
-         if (!(attachements[j].filename && attachements[j].mime &&
-               attachements[j].bin.data && attachements[j].bin.size > 0)) {
+     attachments = attachments_list->elem;
+     for (j = 0; j < attachments_list->nb_elem; j++) {
+         if (!(attachments[j].filename && attachments[j].mime &&
+               attachments[j].bin.data && attachments[j].bin.size > 0)) {
              av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
          } else {
              AVStream *st = avformat_new_stream(s, NULL);
              if (st == NULL)
                  break;
-             av_dict_set(&st->metadata, "filename", attachements[j].filename, 0);
-             av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
+             av_dict_set(&st->metadata, "filename", attachments[j].filename, 0);
+             av_dict_set(&st->metadata, "mimetype", attachments[j].mime, 0);
              st->codec->codec_id   = AV_CODEC_ID_NONE;
              st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
-             if (ff_alloc_extradata(st->codec, attachements[j].bin.size))
 -            st->codec->extradata  = av_malloc(attachments[j].bin.size);
 -            if (st->codec->extradata == NULL)
++            if (ff_alloc_extradata(st->codec, attachments[j].bin.size))
                  break;
-             memcpy(st->codec->extradata, attachements[j].bin.data,
-                    attachements[j].bin.size);
 -            st->codec->extradata_size = attachments[j].bin.size;
+             memcpy(st->codec->extradata, attachments[j].bin.data,
+                    attachments[j].bin.size);
  
              for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
-                 if (!strncmp(ff_mkv_mime_tags[i].str, attachements[j].mime,
+                 if (!strncmp(ff_mkv_mime_tags[i].str, attachments[j].mime,
                               strlen(ff_mkv_mime_tags[i].str))) {
                      st->codec->codec_id = ff_mkv_mime_tags[i].id;
                      break;
                  }
              }
-             attachements[j].stream = st;
+             attachments[j].stream = st;
          }
      }
  
              max_start = chapters[i].start;
          }
  
 +    matroska_add_index_entries(matroska);
 +
      matroska_convert_tags(s);
  
      return 0;
@@@ -2153,7 -1901,7 +2153,7 @@@ static int matroska_parse_laces(Matrosk
          return 0;
      }
  
 -    assert(size > 0);
 +    av_assert0(size > 0);
      *laces    = *data + 1;
      data     += 1;
      size     -= 1;
          uint32_t total = 0;
          for (n = 0; res == 0 && n < *laces - 1; n++) {
              while (1) {
 -                if (size == 0) {
 -                    res = AVERROR_EOF;
 +                if (size <= total) {
 +                    res = AVERROR_INVALIDDATA;
                      break;
                  }
                  temp          = *data;
 +                total        += temp;
                  lace_size[n] += temp;
                  data         += 1;
                  size         -= 1;
                  if (temp != 0xff)
                      break;
              }
 -            total += lace_size[n];
          }
          if (size <= total) {
              res = AVERROR_INVALIDDATA;
          uint64_t num;
          uint64_t total;
          n = matroska_ebmlnum_uint(matroska, data, size, &num);
 -        if (n < 0) {
 +        if (n < 0 || num > INT_MAX) {
              av_log(matroska->ctx, AV_LOG_INFO,
                     "EBML block data error\n");
 -            res = n;
 +            res = n<0 ? n : AVERROR_INVALIDDATA;
              break;
          }
          data += n;
              int64_t snum;
              int r;
              r = matroska_ebmlnum_sint(matroska, data, size, &snum);
 -            if (r < 0) {
 +            if (r < 0 || lace_size[n - 1] + snum > (uint64_t)INT_MAX) {
                  av_log(matroska->ctx, AV_LOG_INFO,
                         "EBML block data error\n");
 -                res = r;
 +                res = r<0 ? r : AVERROR_INVALIDDATA;
                  break;
              }
              data        += r;
  static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
                                     MatroskaTrack *track, AVStream *st,
                                     uint8_t *data, int size, uint64_t timecode,
 -                                   uint64_t duration, int64_t pos)
 +                                   int64_t pos)
  {
      int a = st->codec->block_align;
      int sps = track->audio.sub_packet_size;
              }
              memcpy(track->audio.buf + y * w, data, w);
          } else {
 -            if (size < sps * w / sps) {
 +            if (size < sps * w / sps || h<=0 || w%sps) {
                  av_log(matroska->ctx, AV_LOG_ERROR,
                         "Corrupt generic RM-style audio packet size\n");
                  return AVERROR_INVALIDDATA;
      }
  
      while (track->audio.pkt_cnt) {
 -        AVPacket *pkt = av_mallocz(sizeof(AVPacket));
 -        av_new_packet(pkt, a);
 +        AVPacket *pkt = NULL;
 +        if (!(pkt = av_mallocz(sizeof(AVPacket))) || av_new_packet(pkt, a) < 0) {
 +            av_free(pkt);
 +            return AVERROR(ENOMEM);
 +        }
          memcpy(pkt->data,
                 track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
                 a);
      return ret;
  }
  
 +static int matroska_parse_webvtt(MatroskaDemuxContext *matroska,
 +                                 MatroskaTrack *track,
 +                                 AVStream *st,
 +                                 uint8_t *data, int data_len,
 +                                 uint64_t timecode,
 +                                 uint64_t duration,
 +                                 int64_t pos)
 +{
 +    AVPacket *pkt;
 +    uint8_t *id, *settings, *text, *buf;
 +    int id_len, settings_len, text_len;
 +    uint8_t *p, *q;
 +    int err;
 +
 +    if (data_len <= 0)
 +        return AVERROR_INVALIDDATA;
 +
 +    p = data;
 +    q = data + data_len;
 +
 +    id = p;
 +    id_len = -1;
 +    while (p < q) {
 +        if (*p == '\r' || *p == '\n') {
 +            id_len = p - id;
 +            if (*p == '\r')
 +                p++;
 +            break;
 +        }
 +        p++;
 +    }
 +
 +    if (p >= q || *p != '\n')
 +        return AVERROR_INVALIDDATA;
 +    p++;
 +
 +    settings = p;
 +    settings_len = -1;
 +    while (p < q) {
 +        if (*p == '\r' || *p == '\n') {
 +            settings_len = p - settings;
 +            if (*p == '\r')
 +                p++;
 +            break;
 +        }
 +        p++;
 +    }
 +
 +    if (p >= q || *p != '\n')
 +        return AVERROR_INVALIDDATA;
 +    p++;
 +
 +    text = p;
 +    text_len = q - p;
 +    while (text_len > 0) {
 +        const int len = text_len - 1;
 +        const uint8_t c = p[len];
 +        if (c != '\r' && c != '\n')
 +            break;
 +        text_len = len;
 +    }
 +
 +    if (text_len <= 0)
 +        return AVERROR_INVALIDDATA;
 +
 +    pkt = av_mallocz(sizeof(*pkt));
 +    err = av_new_packet(pkt, text_len);
 +    if (err < 0) {
 +        av_free(pkt);
 +        return AVERROR(err);
 +    }
 +
 +    memcpy(pkt->data, text, text_len);
 +
 +    if (id_len > 0) {
 +        buf = av_packet_new_side_data(pkt,
 +                                      AV_PKT_DATA_WEBVTT_IDENTIFIER,
 +                                      id_len);
 +        if (buf == NULL) {
 +            av_free(pkt);
 +            return AVERROR(ENOMEM);
 +        }
 +        memcpy(buf, id, id_len);
 +    }
 +
 +    if (settings_len > 0) {
 +        buf = av_packet_new_side_data(pkt,
 +                                      AV_PKT_DATA_WEBVTT_SETTINGS,
 +                                      settings_len);
 +        if (buf == NULL) {
 +            av_free(pkt);
 +            return AVERROR(ENOMEM);
 +        }
 +        memcpy(buf, settings, settings_len);
 +    }
 +
 +    // Do we need this for subtitles?
 +    // pkt->flags = AV_PKT_FLAG_KEY;
 +
 +    pkt->stream_index = st->index;
 +    pkt->pts = timecode;
 +
 +    // Do we need this for subtitles?
 +    // pkt->dts = timecode;
 +
 +    pkt->duration = duration;
 +    pkt->pos = pos;
 +
 +    dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
 +    matroska->prev_pkt = pkt;
 +
 +    return 0;
 +}
 +
  static int matroska_parse_frame(MatroskaDemuxContext *matroska,
                                  MatroskaTrack *track, AVStream *st,
                                  uint8_t *data, int pkt_size,
 -                                uint64_t timecode, uint64_t duration,
 -                                int64_t pos, int is_keyframe)
 +                                uint64_t timecode, uint64_t lace_duration,
 +                                int64_t pos, int is_keyframe,
 +                                uint8_t *additional, uint64_t additional_id, int additional_size,
 +                                int64_t discard_padding)
  {
      MatroskaTrackEncoding *encodings = track->encodings.elem;
      uint8_t *pkt_data = data;
      int offset = 0, res;
      AVPacket *pkt;
  
 -    if (encodings && encodings->scope & 1) {
 +    if (encodings && !encodings->type && encodings->scope & 1) {
          res = matroska_decode_buffer(&pkt_data, &pkt_size, track);
          if (res < 0)
              return res;
      /* XXX: prevent data copy... */
      if (av_new_packet(pkt, pkt_size + offset) < 0) {
          av_free(pkt);
 -        return AVERROR(ENOMEM);
 +        res = AVERROR(ENOMEM);
 +        goto fail;
      }
  
      if (st->codec->codec_id == AV_CODEC_ID_PRORES) {
      memcpy(pkt->data + offset, pkt_data, pkt_size);
  
      if (pkt_data != data)
 -        av_free(pkt_data);
 +        av_freep(&pkt_data);
  
      pkt->flags        = is_keyframe;
      pkt->stream_index = st->index;
  
 +    if (additional_size > 0) {
 +        uint8_t *side_data = av_packet_new_side_data(pkt,
 +                                                     AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
 +                                                     additional_size + 8);
 +        if (side_data == NULL) {
 +            av_free_packet(pkt);
 +            av_free(pkt);
 +            return AVERROR(ENOMEM);
 +        }
 +        AV_WB64(side_data, additional_id);
 +        memcpy(side_data + 8, additional, additional_size);
 +    }
 +
 +    if (discard_padding) {
 +        uint8_t *side_data = av_packet_new_side_data(pkt,
 +                                                     AV_PKT_DATA_SKIP_SAMPLES,
 +                                                     10);
 +        if (side_data == NULL) {
 +            av_free_packet(pkt);
 +            av_free(pkt);
 +            return AVERROR(ENOMEM);
 +        }
 +        AV_WL32(side_data, 0);
 +        AV_WL32(side_data + 4, av_rescale_q(discard_padding,
 +                                            (AVRational){1, 1000000000},
 +                                            (AVRational){1, st->codec->sample_rate}));
 +    }
 +
      if (track->ms_compat)
          pkt->dts = timecode;
      else
          pkt->pts = timecode;
      pkt->pos = pos;
 -    if (st->codec->codec_id == AV_CODEC_ID_TEXT)
 -        pkt->convergence_duration = duration;
 -    else if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE)
 -        pkt->duration = duration;
 +    if (st->codec->codec_id == AV_CODEC_ID_SUBRIP) {
 +        /*
 +         * For backward compatibility.
 +         * Historically, we have put subtitle duration
 +         * in convergence_duration, on the off chance
 +         * that the time_scale is less than 1us, which
 +         * could result in a 32bit overflow on the
 +         * normal duration field.
 +         */
 +        pkt->convergence_duration = lace_duration;
 +    }
  
 +    if (track->type != MATROSKA_TRACK_TYPE_SUBTITLE ||
 +        lace_duration <= INT_MAX) {
 +        /*
 +         * For non subtitle tracks, just store the duration
 +         * as normal.
 +         *
 +         * If it's a subtitle track and duration value does
 +         * not overflow a uint32, then also store it normally.
 +         */
 +        pkt->duration = lace_duration;
 +    }
 +
 +#if FF_API_ASS_SSA
      if (st->codec->codec_id == AV_CODEC_ID_SSA)
 -        matroska_fix_ass_packet(matroska, pkt, duration);
 +        matroska_fix_ass_packet(matroska, pkt, lace_duration);
  
      if (matroska->prev_pkt                                 &&
          timecode                         != AV_NOPTS_VALUE &&
          dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
          matroska->prev_pkt = pkt;
      }
 +#else
 +    dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
 +    matroska->prev_pkt = pkt;
 +#endif
  
      return 0;
  
@@@ -2654,8 -2230,7 +2654,8 @@@ fail
  static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
                                  int size, int64_t pos, uint64_t cluster_time,
                                  uint64_t block_duration, int is_keyframe,
 -                                int64_t cluster_pos)
 +                                uint8_t *additional, uint64_t additional_id, int additional_size,
 +                                int64_t cluster_pos, int64_t discard_padding)
  {
      uint64_t timecode = AV_NOPTS_VALUE;
      MatroskaTrack *track;
      int16_t block_time;
      uint32_t *lace_size = NULL;
      int n, flags, laces = 0;
 -    uint64_t num, duration;
 +    uint64_t num;
 +    int trust_default_duration = 1;
  
      if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
          av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
      st = track->stream;
      if (st->discard >= AVDISCARD_ALL)
          return res;
 +    av_assert1(block_duration != AV_NOPTS_VALUE);
  
 -    block_time = AV_RB16(data);
 +    block_time = sign_extend(AV_RB16(data), 16);
      data      += 2;
      flags      = *data++;
      size      -= 3;
  
      if (matroska->skip_to_keyframe &&
          track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
 -        if (!is_keyframe || timecode < matroska->skip_to_timecode)
 +        if (timecode < matroska->skip_to_timecode)
              return res;
 -        matroska->skip_to_keyframe = 0;
 +        if (is_keyframe)
 +            matroska->skip_to_keyframe = 0;
 +        else if (!st->skip_to_keyframe) {
 +            av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
 +            matroska->skip_to_keyframe = 0;
 +        }
      }
  
      res = matroska_parse_laces(matroska, &data, &size, (flags & 0x06) >> 1,
      if (res)
          goto end;
  
 -    if (block_duration != AV_NOPTS_VALUE) {
 -        duration = block_duration / laces;
 -        if (block_duration != duration * laces) {
 -            av_log(matroska->ctx, AV_LOG_WARNING,
 -                   "Incorrect block_duration, possibly corrupted container");
 +    if (track->audio.samplerate == 8000) {
 +        // If this is needed for more codecs, then add them here
 +        if (st->codec->codec_id == AV_CODEC_ID_AC3) {
 +            if (track->audio.samplerate != st->codec->sample_rate || !st->codec->frame_size)
 +                trust_default_duration = 0;
          }
 -    } else {
 -        duration       = track->default_duration / matroska->time_scale;
 -        block_duration = duration * laces;
      }
  
 -    if (timecode != AV_NOPTS_VALUE)
 +    if (!block_duration && trust_default_duration)
 +        block_duration = track->default_duration * laces / matroska->time_scale;
 +
 +    if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
          track->end_timecode =
              FFMAX(track->end_timecode, timecode + block_duration);
  
      for (n = 0; n < laces; n++) {
 +        int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
 +
 +        if (lace_size[n] > size) {
 +            av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
 +            break;
 +        }
 +
          if ((st->codec->codec_id == AV_CODEC_ID_RA_288 ||
               st->codec->codec_id == AV_CODEC_ID_COOK   ||
               st->codec->codec_id == AV_CODEC_ID_SIPR   ||
              st->codec->block_align && track->audio.sub_packet_size) {
              res = matroska_parse_rm_audio(matroska, track, st, data,
                                            lace_size[n],
 -                                          timecode, duration, pos);
 +                                          timecode, pos);
 +            if (res)
 +                goto end;
 +
 +        } else if (st->codec->codec_id == AV_CODEC_ID_WEBVTT) {
 +            res = matroska_parse_webvtt(matroska, track, st,
 +                                        data, lace_size[n],
 +                                        timecode, lace_duration,
 +                                        pos);
              if (res)
                  goto end;
          } else {
              res = matroska_parse_frame(matroska, track, st, data, lace_size[n],
 -                                       timecode, duration, pos,
 -                                       !n ? is_keyframe : 0);
 +                                       timecode, lace_duration, pos,
 +                                       !n ? is_keyframe : 0,
 +                                       additional, additional_id, additional_size,
 +                                       discard_padding);
              if (res)
                  goto end;
          }
  
          if (timecode != AV_NOPTS_VALUE)
 -            timecode = duration ? timecode + duration : AV_NOPTS_VALUE;
 +            timecode = lace_duration ? timecode + lace_duration : AV_NOPTS_VALUE;
          data += lace_size[n];
 +        size -= lace_size[n];
      }
  
  end:
@@@ -2824,21 -2374,18 +2824,21 @@@ static int matroska_parse_cluster_incre
          i                                    = blocks_list->nb_elem - 1;
          if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
              int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
 +            uint8_t* additional = blocks[i].additional.size > 0 ?
 +                                    blocks[i].additional.data : NULL;
              if (!blocks[i].non_simple)
 -                blocks[i].duration = AV_NOPTS_VALUE;
 +                blocks[i].duration = 0;
              res = matroska_parse_block(matroska, blocks[i].bin.data,
                                         blocks[i].bin.size, blocks[i].bin.pos,
                                         matroska->current_cluster.timecode,
                                         blocks[i].duration, is_keyframe,
 -                                       matroska->current_cluster_pos);
 +                                       additional, blocks[i].additional_id,
 +                                       blocks[i].additional.size,
 +                                       matroska->current_cluster_pos,
 +                                       blocks[i].discard_padding);
          }
      }
  
 -    if (res < 0)
 -        matroska->done = 1;
      return res;
  }
  
@@@ -2859,14 -2406,15 +2859,14 @@@ static int matroska_parse_cluster(Matro
      res         = ebml_parse(matroska, matroska_clusters, &cluster);
      blocks_list = &cluster.blocks;
      blocks      = blocks_list->elem;
 -    for (i = 0; i < blocks_list->nb_elem && !res; i++)
 +    for (i = 0; i < blocks_list->nb_elem; i++)
          if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
              int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
 -            if (!blocks[i].non_simple)
 -                blocks[i].duration = AV_NOPTS_VALUE;
              res = matroska_parse_block(matroska, blocks[i].bin.data,
                                         blocks[i].bin.size, blocks[i].bin.pos,
                                         cluster.timecode, blocks[i].duration,
 -                                       is_keyframe, pos);
 +                                       is_keyframe, NULL, 0, 0, pos,
 +                                       blocks[i].discard_padding);
          }
      ebml_free(matroska_cluster, &cluster);
      return res;
  static int matroska_read_packet(AVFormatContext *s, AVPacket *pkt)
  {
      MatroskaDemuxContext *matroska = s->priv_data;
 -    int ret = 0;
  
 -    while (!ret && matroska_deliver_packet(matroska, pkt)) {
 +    while (matroska_deliver_packet(matroska, pkt)) {
          int64_t pos = avio_tell(matroska->ctx->pb);
          if (matroska->done)
              return AVERROR_EOF;
          if (matroska_parse_cluster(matroska) < 0)
 -            ret = matroska_resync(matroska, pos);
 -    }
 -
 -    if (ret == AVERROR_INVALIDDATA && pkt->data) {
 -        pkt->flags |= AV_PKT_FLAG_CORRUPT;
 -        return 0;
 +            matroska_resync(matroska, pos);
      }
  
 -    return ret;
 +    return 0;
  }
  
  static int matroska_read_seek(AVFormatContext *s, int stream_index,
      int i, index, index_sub, index_min;
  
      /* Parse the CUES now since we need the index data to seek. */
 -    if (matroska->cues_parsing_deferred) {
 -        matroska_parse_cues(matroska);
 +    if (matroska->cues_parsing_deferred > 0) {
          matroska->cues_parsing_deferred = 0;
 +        matroska_parse_cues(matroska);
      }
  
      if (!st->nb_index_entries)
 -        return 0;
 +        goto err;
      timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
  
      if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
      }
  
      matroska_clear_queue(matroska);
 -    if (index < 0)
 -        return 0;
 +    if (index < 0 || (matroska->cues_parsing_deferred < 0 && index == st->nb_index_entries - 1))
 +        goto err;
  
      index_min = index;
      for (i = 0; i < matroska->tracks.nb_elem; i++) {
          tracks[i].audio.buf_timecode   = AV_NOPTS_VALUE;
          tracks[i].end_timecode         = 0;
          if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE &&
 -            !tracks[i].stream->discard != AVDISCARD_ALL) {
 +            tracks[i].stream->discard != AVDISCARD_ALL) {
              index_sub = av_index_search_timestamp(
                  tracks[i].stream, st->index_entries[index].timestamp,
                  AVSEEK_FLAG_BACKWARD);
 -            if (index_sub >= 0 &&
 -                st->index_entries[index_sub].pos < st->index_entries[index_min].pos &&
 -                st->index_entries[index].timestamp -
 -                st->index_entries[index_sub].timestamp < 30000000000 / matroska->time_scale)
 -                index_min = index_sub;
 +            while (index_sub >= 0 &&
 +                  index_min >= 0 &&
 +                  tracks[i].stream->index_entries[index_sub].pos < st->index_entries[index_min].pos &&
 +                  st->index_entries[index].timestamp - tracks[i].stream->index_entries[index_sub].timestamp < 30000000000 / matroska->time_scale)
 +                index_min--;
          }
      }
  
      avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
      matroska->current_id       = 0;
 -    matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
 -    matroska->skip_to_timecode = st->index_entries[index].timestamp;
 +    if (flags & AVSEEK_FLAG_ANY) {
 +        st->skip_to_keyframe = 0;
 +        matroska->skip_to_timecode = timestamp;
 +    } else {
 +        st->skip_to_keyframe = 1;
 +        matroska->skip_to_timecode = st->index_entries[index].timestamp;
 +    }
 +    matroska->skip_to_keyframe = 1;
      matroska->done             = 0;
 +    matroska->num_levels       = 0;
      ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
      return 0;
 +err:
 +    // slightly hackish but allows proper fallback to
 +    // the generic seeking code.
 +    matroska_clear_queue(matroska);
 +    matroska->current_id = 0;
 +    st->skip_to_keyframe =
 +    matroska->skip_to_keyframe = 0;
 +    matroska->done = 0;
 +    matroska->num_levels = 0;
 +    return -1;
  }
  
  static int matroska_read_close(AVFormatContext *s)