Merge commit '84cfce9f99805a144df684417e166c1ae6f95421'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 7 Mar 2014 22:46:37 +0000 (23:46 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 7 Mar 2014 22:52:44 +0000 (23:52 +0100)
* commit '84cfce9f99805a144df684417e166c1ae6f95421':
  matroskadec: K&R formatting cosmetics

Conflicts:
libavformat/matroskadec.c

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

   * @see specs available on the Matroska project page: http://www.matroska.org/
   */
  
+ #include "config.h"
  #include <stdio.h>
+ #if CONFIG_BZLIB
+ #include <bzlib.h>
+ #endif
+ #if CONFIG_ZLIB
+ #include <zlib.h>
+ #endif
+ #include "libavutil/avstring.h"
++#include "libavutil/base64.h"
+ #include "libavutil/dict.h"
+ #include "libavutil/intfloat.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/lzo.h"
+ #include "libavcodec/bytestream.h"
+ #include "libavcodec/mpeg4audio.h"
  #include "avformat.h"
- #include "internal.h"
  #include "avio_internal.h"
+ #include "internal.h"
+ #include "isom.h"
+ #include "matroska.h"
  /* For ff_codec_get_id(). */
  #include "riff.h"
- #include "isom.h"
  #include "rmsipr.h"
- #include "matroska.h"
- #include "libavcodec/bytestream.h"
- #include "libavcodec/mpeg4audio.h"
- #include "libavutil/base64.h"
- #include "libavutil/intfloat.h"
- #include "libavutil/intreadwrite.h"
- #include "libavutil/avstring.h"
- #include "libavutil/lzo.h"
- #include "libavutil/dict.h"
- #if CONFIG_ZLIB
- #include <zlib.h>
- #endif
- #if CONFIG_BZLIB
- #include <bzlib.h>
- #endif
  
  typedef enum {
      EBML_NONE,
@@@ -314,32 -291,31 +319,32 @@@ static EbmlSyntax ebml_syntax[] = 
  };
  
  static EbmlSyntax matroska_info[] = {
-     { MATROSKA_ID_TIMECODESCALE,      EBML_UINT,  0, offsetof(MatroskaDemuxContext,time_scale), {.u=1000000} },
-     { 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_UTF8, 0, offsetof(MatroskaDemuxContext,muxingapp) },
-     { MATROSKA_ID_DATEUTC,            EBML_BIN,  0, offsetof(MatroskaDemuxContext,date_utc) },
-     { MATROSKA_ID_SEGMENTUID,         EBML_NONE },
+     { MATROSKA_ID_TIMECODESCALE, EBML_UINT,  0, offsetof(MatroskaDemuxContext, time_scale), { .u = 1000000 } },
+     { 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), {.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_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_VIDEOASPECTRATIO,   EBML_NONE },
+     { 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 }
  };
  
@@@ -357,22 -333,11 +362,22 @@@ static EbmlSyntax matroska_track_encodi
      { 0 }
  };
  
-     { MATROSKA_ID_ENCODINGENCALGO,        EBML_UINT, 0, offsetof(MatroskaTrackEncryption,algo), {.u=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 },
+     { 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 }
  };
  
@@@ -381,49 -346,30 +386,49 @@@ static EbmlSyntax matroska_track_encodi
      { 0 }
  };
  
-     { MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n=matroska_track_plane} },
 +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_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n=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_TRACKUID,             EBML_UINT, 0, offsetof(MatroskaTrack,uid) },
-     { 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_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_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_CODECDECODEALL,       EBML_NONE },
-     { MATROSKA_ID_CODECINFOURL,         EBML_NONE },
-     { MATROSKA_ID_CODECDOWNLOADURL,     EBML_NONE },
-     { MATROSKA_ID_TRACKMINCACHE,        EBML_NONE },
-     { MATROSKA_ID_TRACKMAXCACHE,        EBML_NONE },
+     { MATROSKA_ID_TRACKNUMBER,           EBML_UINT,  0, offsetof(MatroskaTrack, num) },
+     { MATROSKA_ID_TRACKNAME,             EBML_UTF8,  0, offsetof(MatroskaTrack, name) },
+     { MATROSKA_ID_TRACKUID,              EBML_UINT,  0, offsetof(MatroskaTrack, uid) },
+     { 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_CODECDECODEALL,        EBML_NONE },
+     { MATROSKA_ID_CODECINFOURL,          EBML_NONE },
+     { MATROSKA_ID_CODECDOWNLOADURL,      EBML_NONE },
+     { MATROSKA_ID_TRACKMINCACHE,         EBML_NONE },
+     { MATROSKA_ID_TRACKMAXCACHE,         EBML_NONE },
 -    { MATROSKA_ID_TRACKMAXBLKADDID,      EBML_NONE },
      { 0 }
  };
  
@@@ -479,10 -425,8 +484,10 @@@ 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_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 }
  };
@@@ -556,26 -500,13 +561,26 @@@ static EbmlSyntax matroska_segments[] 
      { 0 }
  };
  
-     { MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, {.n=matroska_blockmore} },
 +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) },
-     { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock,discard_padding) },
-     { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock,reference) },
+     { 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} },
+     {                          1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
      { 0 }
  };
  
@@@ -983,16 -892,17 +989,16 @@@ static int ebml_parse_elem(MatroskaDemu
      uint32_t id = syntax->id;
      uint64_t length;
      int res;
 +    void *newelem;
  
-     data = (char *)data + syntax->data_offset;
+     data = (char *) data + syntax->data_offset;
      if (syntax->list_elem_size) {
          EbmlList *list = data;
-         newelem = av_realloc_array(list->elem, list->nb_elem+1, syntax->list_elem_size);
 -        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;
+         data = (char *) list->elem + list->nb_elem * syntax->list_elem_size;
          memset(data, 0, syntax->list_elem_size);
          list->nb_elem++;
      }
      }
  
      switch (syntax->type) {
-     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_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_STR:
-     case EBML_UTF8:  res = ebml_read_ascii (pb, length, data);  break;
-     case EBML_BIN:   res = ebml_read_binary(pb, length, data);  break;
-     case EBML_NEST:  if ((res=ebml_read_master(matroska, length)) < 0)
-                          return res;
-                      if (id == MATROSKA_ID_SEGMENT)
-                          matroska->segment_start = avio_tell(matroska->ctx->pb);
-                      return ebml_parse_nest(matroska, syntax->def.n, data);
-     case EBML_PASS:  return ebml_parse_id(matroska, syntax->def.n, id, data);
-     case EBML_STOP:  return 1;
+     case EBML_UTF8:
+         res = ebml_read_ascii(pb, length, data);
+         break;
+     case EBML_BIN:
+         res = ebml_read_binary(pb, length, data);
+         break;
+     case EBML_NEST:
+         if ((res = ebml_read_master(matroska, length)) < 0)
+             return res;
+         if (id == MATROSKA_ID_SEGMENT)
+             matroska->segment_start = avio_tell(matroska->ctx->pb);
+         return ebml_parse_nest(matroska, syntax->def.n, data);
+     case EBML_PASS:
+         return ebml_parse_id(matroska, syntax->def.n, id, data);
+     case EBML_STOP:
+         return 1;
      default:
-         if(ffio_limit(pb, length) != length)
++        if (ffio_limit(pb, length) != length)
 +            return AVERROR(EIO);
-         return avio_skip(pb,length)<0 ? AVERROR(EIO) : 0;
+         return avio_skip(pb, length) < 0 ? AVERROR(EIO) : 0;
      }
      if (res == AVERROR_INVALIDDATA)
          av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
@@@ -1188,14 -1108,11 +1214,14 @@@ static int matroska_decode_buffer(uint8
                  inflateEnd(&zstream);
                  goto failed;
              }
-             pkt_data = newpktdata;
+             pkt_data          = newpktdata;
              zstream.avail_out = pkt_size - zstream.total_out;
-             zstream.next_out = pkt_data + 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);
+         } while (result == Z_OK && pkt_size < 10000000);
          pkt_size = zstream.total_out;
          inflateEnd(&zstream);
          if (result != Z_STREAM_END) {
                  BZ2_bzDecompressEnd(&bzstream);
                  goto failed;
              }
-             pkt_data = newpktdata;
+             pkt_data           = newpktdata;
              bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
-             bzstream.next_out = pkt_data + 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);
+         } while (result == BZ_OK && pkt_size < 10000000);
          pkt_size = bzstream.total_out_lo32;
          BZ2_bzDecompressEnd(&bzstream);
          if (result != BZ_STREAM_END) {
@@@ -1259,12 -1174,14 +1287,15 @@@ static void matroska_fix_ass_packet(Mat
                                      AVPacket *pkt, uint64_t display_duration)
  {
      AVBufferRef *line;
-     char *layer, *ptr = pkt->data, *end = ptr+pkt->size;
-     for (; *ptr!=',' && ptr<end-1; ptr++);
+     char *layer, *ptr = pkt->data, *end = ptr + pkt->size;
+     for (; *ptr != ',' && ptr < end - 1; ptr++)
+         ;
      if (*ptr == ',')
 -        layer = ++ptr;
 +        ptr++;
 +    layer = ptr;
-     for (; *ptr!=',' && ptr<end-1; ptr++);
+     for (; *ptr != ',' && ptr < end - 1; ptr++)
+         ;
      if (*ptr == ',') {
          int64_t end_pts = pkt->pts + display_duration;
          int sc = matroska->time_scale * pkt->pts / 10000000;
@@@ -1451,16 -1375,26 +1492,17 @@@ static void matroska_execute_seekhead(M
      }
  }
  
- static void matroska_add_index_entries(MatroskaDemuxContext *matroska) {
 -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
-         && index[0].time > 1E14/matroska->time_scale) {
+     index      = index_list->elem;
+     if (index_list->nb_elem &&
+         index[0].time > 1E14 / matroska->time_scale) {
          av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken index.\n");
          index_scale = matroska->time_scale;
      }
      }
  }
  
 +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" };
+     static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
      int profile;
  
-     for (profile=0; profile<FF_ARRAY_ELEMS(aac_profiles); profile++)
+     for (profile = 0; profile < FF_ARRAY_ELEMS(aac_profiles); profile++)
          if (strstr(codec_id, aac_profiles[profile]))
              break;
      return profile + 1;
@@@ -1542,9 -1451,11 +1585,12 @@@ static int matroska_read_header(AVForma
      matroska->ctx = s;
  
      /* First read the EBML header. */
-     if (ebml_parse(matroska, ebml_syntax, &ebml)
-         || ebml.version > EBML_VERSION       || ebml.max_size > sizeof(uint64_t)
-         || ebml.id_length > sizeof(uint32_t) || ebml.doctype_version > 3 || !ebml.doctype) {
+     if (ebml_parse(matroska, ebml_syntax, &ebml) ||
+         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",
      if (!matroska->time_scale)
          matroska->time_scale = 1000000;
      if (matroska->duration)
-         matroska->ctx->duration = matroska->duration * matroska->time_scale
-                                   1000 / AV_TIME_BASE;
+         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++) {
+     for (i = 0; i < matroska->tracks.nb_elem; i++) {
          MatroskaTrack *track = &tracks[i];
          enum AVCodecID codec_id = AV_CODEC_ID_NONE;
          EbmlList *encodings_list = &track->encodings;
  
          if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
              if (!track->default_duration && track->video.frame_rate > 0)
-                 track->default_duration = 1000000000/track->video.frame_rate;
+                 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 &&
+                  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_ZLIB  &&
  #endif
  #if CONFIG_BZLIB
                   encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_BZLIB &&
  #endif
  #if CONFIG_LZO
-                  encodings[0].compression.algo != MATROSKA_TRACK_ENCODING_COMP_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.data != NULL) {
-             track->ms_compat = 1;
-             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, fourcc);
-             extradata_offset = 40;
-         } else if (!strcmp(track->codec_id, "A_MS/ACM")
-                    && track->codec_priv.size >= 14
-                    && track->codec_priv.data != NULL) {
+         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         &&
+                    track->codec_priv.data != NULL) {
              int ret;
-             ffio_init_context(&b, track->codec_priv.data, track->codec_priv.size,
+             ffio_init_context(&b, track->codec_priv.data,
+                               track->codec_priv.size,
                                0, NULL, NULL, NULL, NULL);
              ret = ff_get_wav_header(&b, st->codec, track->codec_priv.size);
              if (ret < 0)
                  return ret;
-             codec_id = st->codec->codec_id;
+             codec_id         = st->codec->codec_id;
              extradata_offset = FFMIN(track->codec_priv.size, 18);
-         } else if (!strcmp(track->codec_id, "V_QUICKTIME")
-                    && (track->codec_priv.size >= 21)
-                    && (track->codec_priv.data != NULL)) {
-             fourcc = AV_RL32(track->codec_priv.data + 4);
 +        } 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);
 +            }
 -                   (track->codec_priv.size >= 86)          &&
+         } else if (!strcmp(track->codec_id, "V_QUICKTIME") &&
 -            track->video.fourcc = AV_RL32(track->codec_priv.data);
 -            codec_id            = ff_codec_get_id(ff_codec_movvideo_tags,
 -                                                  track->video.fourcc);
++                   (track->codec_priv.size >= 21)          &&
+                    (track->codec_priv.data != NULL)) {
-                 fourcc = AV_RL32(track->codec_priv.data);
++            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:  codec_id = AV_CODEC_ID_PCM_U8;     break;
-             case 24:  codec_id = AV_CODEC_ID_PCM_S24BE;  break;
-             case 32:  codec_id = AV_CODEC_ID_PCM_S32BE;  break;
+             case  8:
+                 codec_id = AV_CODEC_ID_PCM_U8;
+                 break;
+             case 24:
+                 codec_id = AV_CODEC_ID_PCM_S24BE;
+                 break;
+             case 32:
+                 codec_id = AV_CODEC_ID_PCM_S32BE;
+                 break;
              }
          } else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
              switch (track->audio.bitdepth) {
                  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. */
+              * Create the "atom size", "tag", and "tag version" fields the
+              * decoder expects manually. */
              extradata_size = 12 + track->codec_priv.size;
-             extradata = av_mallocz(extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
+             extradata      = av_mallocz(extradata_size +
+                                         FF_INPUT_BUFFER_PADDING_SIZE);
              if (extradata == NULL)
                  return AVERROR(ENOMEM);
              AV_WB32(extradata, extradata_size);
              memcpy(&extradata[4], "alac", 4);
              AV_WB32(&extradata[8], 0);
              memcpy(&extradata[12], track->codec_priv.data,
-                                    track->codec_priv.size);
+                    track->codec_priv.size);
          } else if (codec_id == AV_CODEC_ID_TTA) {
              extradata_size = 30;
-             extradata = av_mallocz(extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 -            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, 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 || codec_id == AV_CODEC_ID_RV40) {
 -            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 ||
+                    codec_id == AV_CODEC_ID_RV40) {
              extradata_offset = 26;
          } 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)
-                     && track->codec_priv.data) {
+             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);
 +
+             ffio_init_context(&b, track->codec_priv.data,
+                               track->codec_priv.size,
+                               0, NULL, NULL, NULL, NULL);
              avio_skip(&b, 22);
              flavor                       = avio_rb16(&b);
              track->audio.coded_framesize = avio_rb32(&b);
              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 || track->audio.coded_framesize <= 0 ||
-                 track->audio.sub_packet_h <= 0 || track->audio.frame_size <= 0 ||
 -            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_array(track->audio.sub_packet_h, track->audio.frame_size);
 -            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];
+                     st->codec->bit_rate          = sipr_bit_rate[flavor];
                  }
                  st->codec->block_align = track->audio.sub_packet_size;
-                 extradata_offset = 78;
+                 extradata_offset       = 78;
              }
          }
          track->codec_priv.size -= extradata_offset;
  
          if (track->time_scale < 0.01)
              track->time_scale = 1.0;
-         avpriv_set_pts_info(st, 64, matroska->time_scale*track->time_scale, 1000*1000*1000); /* 64 bit pts in ns */
+         avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
+                             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->disposition |= AV_DISPOSITION_FORCED;
  
          if (!st->codec->extradata) {
-             if(extradata){
-                 st->codec->extradata = extradata;
+             if (extradata) {
+                 st->codec->extradata      = extradata;
                  st->codec->extradata_size = extradata_size;
-             } else if(track->codec_priv.data && track->codec_priv.size > 0){
+             } 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;
+             st->codec->width      = track->video.pixel_width;
+             st->codec->height     = track->video.pixel_height;
              av_reduce(&st->sample_aspect_ratio.num,
                        &st->sample_aspect_ratio.den,
                        st->codec->height * track->video.display_width,
-                       st->codec-> width * track->video.display_height,
+                       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->codec_type  = AVMEDIA_TYPE_AUDIO;
              st->codec->sample_rate = track->audio.out_samplerate;
-             st->codec->channels = track->audio.channels;
+             st->codec->channels    = track->audio.channels;
 +            if (!st->codec->bits_per_coded_sample)
-             st->codec->bits_per_coded_sample = track->audio.bitdepth;
++                st->codec->bits_per_coded_sample = track->audio.bitdepth;
              if (st->codec->codec_id != AV_CODEC_ID_AAC)
-             st->need_parsing = AVSTREAM_PARSE_HEADERS;
+                 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;
          }
      }
              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, "filename", attachements[j].filename, 0);
              av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
-             st->codec->codec_id = AV_CODEC_ID_NONE;
+             st->codec->codec_id   = AV_CODEC_ID_NONE;
              st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
 -            st->codec->extradata  = av_malloc(attachements[j].bin.size);
 -            if (st->codec->extradata == NULL)
 +            if (ff_alloc_extradata(st->codec, attachements[j].bin.size))
                  break;
-             memcpy(st->codec->extradata, attachements[j].bin.data, attachements[j].bin.size);
 -            st->codec->extradata_size = attachements[j].bin.size;
+             memcpy(st->codec->extradata, attachements[j].bin.data,
+                    attachements[j].bin.size);
  
-             for (i=0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
+             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,
                               strlen(ff_mkv_mime_tags[i].str))) {
                      st->codec->codec_id = ff_mkv_mime_tags[i].id;
@@@ -2077,10 -1901,10 +2153,10 @@@ static int matroska_parse_laces(Matrosk
          return 0;
      }
  
 -    assert(size > 0);
 +    av_assert0(size > 0);
-     *laces = *data + 1;
-     data += 1;
-     size -= 1;
+     *laces    = *data + 1;
+     data     += 1;
+     size     -= 1;
      lace_size = av_mallocz(*laces * sizeof(int));
      if (!lace_size)
          return AVERROR(ENOMEM);
          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;
+                 temp          = *data;
++                total        += temp;
                  lace_size[n] += temp;
-                 data += 1;
-                 size -= 1;
+                 data         += 1;
+                 size         -= 1;
                  if (temp != 0xff)
                      break;
              }
              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;
-             size -= r;
+             data        += r;
+             size        -= r;
              lace_size[n] = lace_size[n - 1] + snum;
-             total += lace_size[n];
+             total       += lace_size[n];
          }
          if (size <= total) {
              res = AVERROR_INVALIDDATA;
  }
  
  static int matroska_parse_rm_audio(MatroskaDemuxContext *matroska,
-                                    MatroskaTrack *track,
-                                    AVStream *st,
-                                    uint8_t *data, int size,
-                                    uint64_t timecode,
+                                    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;
                         "Corrupt sipr RM-style audio packet size\n");
                  return AVERROR_INVALIDDATA;
              }
-             memcpy(track->audio.buf + y*w, data, w);
+             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){
++        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);
-         pkt->pts = track->audio.buf_timecode;
+         memcpy(pkt->data,
+                track->audio.buf + a * (h * w / a - track->audio.pkt_cnt--),
+                a);
+         pkt->pts                  = track->audio.buf_timecode;
          track->audio.buf_timecode = AV_NOPTS_VALUE;
-         pkt->pos = pos;
-         pkt->stream_index = st->index;
-         dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
+         pkt->pos                  = pos;
+         pkt->stream_index         = st->index;
+         dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
      }
  
      return 0;
      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,
+                                 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;
      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->flags        = is_keyframe;
      pkt->stream_index = st->index;
  
-         if(side_data == NULL) {
 +    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) {
++        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 &&
-         matroska->prev_pkt->pts == timecode &&
-         matroska->prev_pkt->stream_index == st->index &&
+     if (matroska->prev_pkt                                 &&
+         timecode                         != AV_NOPTS_VALUE &&
+         matroska->prev_pkt->pts          == timecode       &&
+         matroska->prev_pkt->stream_index == st->index      &&
          st->codec->codec_id == AV_CODEC_ID_SSA)
          matroska_merge_packets(matroska->prev_pkt, pkt);
      else {
-         dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
+         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;
  fail:
      if (pkt_data != data)
          av_freep(&pkt_data);
@@@ -2604,34 -2258,30 +2684,36 @@@ static int matroska_parse_block(Matrosk
      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;
+     data      += 2;
+     flags      = *data++;
+     size      -= 3;
      if (is_keyframe == -1)
          is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
  
-     if (cluster_time != (uint64_t)-1
-         && (block_time >= 0 || cluster_time >= -block_time)) {
+     if (cluster_time != (uint64_t) -1 &&
+         (block_time >= 0 || cluster_time >= -block_time)) {
          timecode = cluster_time + block_time;
-         if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE
-             && timecode < track->end_timecode)
+         if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
+             timecode < track->end_timecode)
              is_keyframe = 0;  /* overlapping subtitles are not key frame */
          if (is_keyframe)
-             av_add_index_entry(st, cluster_pos, timecode, 0,0,AVINDEX_KEYFRAME);
+             av_add_index_entry(st, cluster_pos, timecode, 0, 0,
+                                AVINDEX_KEYFRAME);
      }
  
-     if (matroska->skip_to_keyframe && track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
+     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)
++            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->codec_id == AV_CODEC_ID_COOK   ||
+              st->codec->codec_id == AV_CODEC_ID_SIPR   ||
               st->codec->codec_id == AV_CODEC_ID_ATRAC3) &&
-              st->codec->block_align && track->audio.sub_packet_size) {
+             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, lace_duration,
-                                       pos, !n? is_keyframe : 0,
-                                       additional, additional_id, additional_size,
-                                       discard_padding);
 -                                       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;
          }
@@@ -2736,27 -2366,21 +2816,26 @@@ static int matroska_parse_cluster_incre
  
      if (!res &&
          matroska->current_cluster_num_blocks <
-             matroska->current_cluster.blocks.nb_elem) {
+         matroska->current_cluster.blocks.nb_elem) {
          blocks_list = &matroska->current_cluster.blocks;
-         blocks = blocks_list->elem;
+         blocks      = blocks_list->elem;
  
          matroska->current_cluster_num_blocks = blocks_list->nb_elem;
-         i = blocks_list->nb_elem - 1;
+         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,
+             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);
          }
      }
  
@@@ -2776,17 -2403,18 +2856,17 @@@ static int matroska_parse_cluster(Matro
      matroska->prev_pkt = NULL;
      if (matroska->current_id)
          pos -= 4;  /* sizeof the ID which was already read */
-     res = ebml_parse(matroska, matroska_clusters, &cluster);
+     res         = ebml_parse(matroska, matroska_clusters, &cluster);
      blocks_list = &cluster.blocks;
-     blocks = blocks_list->elem;
-     for (i=0; i<blocks_list->nb_elem; i++)
+     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;
-             res=matroska_parse_block(matroska,
-                                      blocks[i].bin.data, blocks[i].bin.size,
-                                      blocks[i].bin.pos,  cluster.timecode,
-                                      blocks[i].duration, is_keyframe, NULL, 0, 0,
-                                      pos, blocks[i].discard_padding);
 -            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;
@@@ -2836,50 -2471,35 +2917,52 @@@ static int matroska_read_seek(AVFormatC
      }
  
      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.pkt_cnt = 0;
+     for (i = 0; i < matroska->tracks.nb_elem; i++) {
+         tracks[i].audio.pkt_cnt        = 0;
          tracks[i].audio.sub_packet_cnt = 0;
-         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) {
-             index_sub = av_index_search_timestamp(tracks[i].stream, st->index_entries[index].timestamp, AVSEEK_FLAG_BACKWARD);
-             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)
+         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->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;
+     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)