Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 30 Apr 2012 20:05:03 +0000 (22:05 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 30 Apr 2012 20:18:43 +0000 (22:18 +0200)
* qatar/master:
  mkv: mark corrupted packets and return them
  mkv: forward EMBL block data error
  avcodec: introduce YCoCg colorspace
  avcodec: cosmetic cleanup on header
  aac sbr: align struct member by 32 byte.

Conflicts:
libavcodec/avcodec.h
libavformat/matroskadec.c

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

diff --combined libavcodec/avcodec.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2001 Fabrice Bellard
   *
 - * 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
   */
  
@@@ -34,7 -34,6 +34,7 @@@
  #include "libavutil/log.h"
  #include "libavutil/pixfmt.h"
  #include "libavutil/rational.h"
 +#include "libavutil/audioconvert.h"
  
  #include "libavcodec/version.h"
  /**
@@@ -87,8 -86,7 +87,8 @@@
   *
   * If you add a codec ID to this list, add it so that
   * 1. no value of a existing codec ID changes (that would break ABI),
 - * 2. it is as close as possible to similar codecs.
 + * 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec.
 + *    This ensures that 2 forks can independently add CodecIDs without producing conflicts.
   */
  enum CodecID {
      CODEC_ID_NONE,
      CODEC_ID_CDXL,
      CODEC_ID_XBM,
      CODEC_ID_ZEROCODEC,
 +    CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
 +    CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
 +    CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
 +    CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),
 +
 +    CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
 +    CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
 +    CODEC_ID_V308       = MKBETAG('V','3','0','8'),
 +    CODEC_ID_V408       = MKBETAG('V','4','0','8'),
 +    CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
  
      /* various PCM "codecs" */
      CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
      CODEC_ID_8SVX_FIB,
      CODEC_ID_BMV_AUDIO,
      CODEC_ID_RALF,
 +    CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
 +    CODEC_ID_8SVX_RAW    = MKBETAG('8','S','V','X'),
 +    CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
 +    CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
  
      /* subtitle codecs */
      CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
      CODEC_ID_HDMV_PGS_SUBTITLE,
      CODEC_ID_DVB_TELETEXT,
      CODEC_ID_SRT,
 +    CODEC_ID_MICRODVD   = MKBETAG('m','D','V','D'),
 +    CODEC_ID_EIA_608    = MKBETAG('c','6','0','8'),
  
      /* other specific kind of codecs (generally used for attachments) */
      CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
      CODEC_ID_TTF = 0x18000,
 +    CODEC_ID_BINTEXT    = MKBETAG('B','T','X','T'),
 +    CODEC_ID_XBIN       = MKBETAG('X','B','I','N'),
 +    CODEC_ID_IDF        = MKBETAG( 0 ,'I','D','F'),
  
      CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it
  
   * Note: If the first 23 bits of the additional bytes are not 0, then damaged
   * MPEG bitstreams could cause overread and segfault.
   */
 -#define FF_INPUT_BUFFER_PADDING_SIZE 8
 +#define FF_INPUT_BUFFER_PADDING_SIZE 16
  
  /**
   * @ingroup lavc_encoding
@@@ -486,51 -465,50 +486,52 @@@ enum Motion_Est_ID 
  enum AVDiscard{
      /* We leave some space between them for extensions (drop some
       * keyframes for intra-only or drop just some bidir frames). */
-     AVDISCARD_NONE   =-16, ///< discard nothing
-     AVDISCARD_DEFAULT=  0, ///< discard useless packets like 0 size packets in avi
-     AVDISCARD_NONREF =  8, ///< discard all non reference
-     AVDISCARD_BIDIR  = 16, ///< discard all bidirectional frames
-     AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes
-     AVDISCARD_ALL    = 48, ///< discard all
+     AVDISCARD_NONE    =-16, ///< discard nothing
+     AVDISCARD_DEFAULT =  0, ///< discard useless packets like 0 size packets in avi
+     AVDISCARD_NONREF  =  8, ///< discard all non reference
+     AVDISCARD_BIDIR   = 16, ///< discard all bidirectional frames
+     AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes
+     AVDISCARD_ALL     = 48, ///< discard all
  };
  
  enum AVColorPrimaries{
-     AVCOL_PRI_BT709      =1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
-     AVCOL_PRI_UNSPECIFIED=2,
-     AVCOL_PRI_BT470M     =4,
-     AVCOL_PRI_BT470BG    =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
-     AVCOL_PRI_SMPTE170M  =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
-     AVCOL_PRI_SMPTE240M  =7, ///< functionally identical to above
-     AVCOL_PRI_FILM       =8,
-     AVCOL_PRI_NB           , ///< Not part of ABI
+     AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
+     AVCOL_PRI_UNSPECIFIED = 2,
+     AVCOL_PRI_BT470M      = 4,
+     AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
+     AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
+     AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
+     AVCOL_PRI_FILM        = 8,
+     AVCOL_PRI_NB             , ///< Not part of ABI
  };
  
  enum AVColorTransferCharacteristic{
-     AVCOL_TRC_BT709      =1, ///< also ITU-R BT1361
-     AVCOL_TRC_UNSPECIFIED=2,
-     AVCOL_TRC_GAMMA22    =4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
-     AVCOL_TRC_GAMMA28    =5, ///< also ITU-R BT470BG
-     AVCOL_TRC_SMPTE240M  =7,
-     AVCOL_TRC_NB           , ///< Not part of ABI
+     AVCOL_TRC_BT709       = 1, ///< also ITU-R BT1361
+     AVCOL_TRC_UNSPECIFIED = 2,
+     AVCOL_TRC_GAMMA22     = 4, ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
+     AVCOL_TRC_GAMMA28     = 5, ///< also ITU-R BT470BG
++    AVCOL_TRC_SMPTE240M   = 7,
+     AVCOL_TRC_NB             , ///< Not part of ABI
  };
  
  enum AVColorSpace{
-     AVCOL_SPC_RGB        =0,
-     AVCOL_SPC_BT709      =1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
-     AVCOL_SPC_UNSPECIFIED=2,
-     AVCOL_SPC_FCC        =4,
-     AVCOL_SPC_BT470BG    =5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
-     AVCOL_SPC_SMPTE170M  =6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
-     AVCOL_SPC_SMPTE240M  =7,
-     AVCOL_SPC_YCGCO      =8,
-     AVCOL_SPC_NB           , ///< Not part of ABI
+     AVCOL_SPC_RGB         = 0,
+     AVCOL_SPC_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
+     AVCOL_SPC_UNSPECIFIED = 2,
+     AVCOL_SPC_FCC         = 4,
+     AVCOL_SPC_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
+     AVCOL_SPC_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+     AVCOL_SPC_SMPTE240M   = 7,
+     AVCOL_SPC_YCOCG       = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+     AVCOL_SPC_NB             , ///< Not part of ABI
  };
++#define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
  
  enum AVColorRange{
-     AVCOL_RANGE_UNSPECIFIED=0,
-     AVCOL_RANGE_MPEG       =1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
-     AVCOL_RANGE_JPEG       =2, ///< the normal     2^n-1   "JPEG" YUV ranges
-     AVCOL_RANGE_NB           , ///< Not part of ABI
+     AVCOL_RANGE_UNSPECIFIED = 0,
+     AVCOL_RANGE_MPEG        = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
+     AVCOL_RANGE_JPEG        = 2, ///< the normal     2^n-1   "JPEG" YUV ranges
+     AVCOL_RANGE_NB             , ///< Not part of ABI
  };
  
  /**
   *  X   X      5 6 X      0 is undefined/unknown position
   */
  enum AVChromaLocation{
-     AVCHROMA_LOC_UNSPECIFIED=0,
-     AVCHROMA_LOC_LEFT       =1, ///< mpeg2/4, h264 default
-     AVCHROMA_LOC_CENTER     =2, ///< mpeg1, jpeg, h263
-     AVCHROMA_LOC_TOPLEFT    =3, ///< DV
-     AVCHROMA_LOC_TOP        =4,
-     AVCHROMA_LOC_BOTTOMLEFT =5,
-     AVCHROMA_LOC_BOTTOM     =6,
-     AVCHROMA_LOC_NB           , ///< Not part of ABI
+     AVCHROMA_LOC_UNSPECIFIED = 0,
+     AVCHROMA_LOC_LEFT        = 1, ///< mpeg2/4, h264 default
+     AVCHROMA_LOC_CENTER      = 2, ///< mpeg1, jpeg, h263
+     AVCHROMA_LOC_TOPLEFT     = 3, ///< DV
+     AVCHROMA_LOC_TOP         = 4,
+     AVCHROMA_LOC_BOTTOMLEFT  = 5,
+     AVCHROMA_LOC_BOTTOM      = 6,
+     AVCHROMA_LOC_NB             , ///< Not part of ABI
  };
  
  enum AVAudioServiceType {
@@@ -610,7 -588,6 +611,7 @@@ typedef struct RcOverride
  #define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.
  #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
  #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
 +#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
  #if FF_API_MPV_GLOBAL_OPTS
  #define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.
  #define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.
  #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping
  #endif
  #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
 +#define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
  
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
   * Codec should fill in channel configuration and samplerate instead of container
   */
  #define CODEC_CAP_CHANNEL_CONF     0x0400
 +
  /**
   * Codec is able to deal with negative linesizes
   */
  #define CODEC_CAP_NEG_LINESIZES    0x0800
 +
  /**
   * Codec supports frame-level multithreading.
   */
   * Audio encoder supports receiving a different number of samples in each call.
   */
  #define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
 +/**
 + * Codec is lossless.
 + */
 +#define CODEC_CAP_LOSSLESS         0x80000000
  
  //The following defines may change, don't expect compatibility if you use them.
  #define MB_TYPE_INTRA4x4   0x0001
@@@ -918,12 -888,9 +919,12 @@@ enum AVSideDataParamChangeFlags 
  /**
   * Audio Video Frame.
   * New fields can be added to the end of AVFRAME with minor version
 - * bumps. Removal, reordering and changes to existing fields require
 + * bumps. Similarly fields that are marked as to be only accessed by
 + * av_opt_ptr() can be reordered. This allows 2 forks to add fields
 + * without breaking compatibility with each other.
 + * Removal, reordering and changes in the remaining cases require
   * a major version bump.
 - * sizeof(AVFrame) must not be used outside libav*.
 + * sizeof(AVFrame) must not be used outside libavcodec.
   */
  typedef struct AVFrame {
  #define AV_NUM_DATA_POINTERS 8
      int64_t reordered_opaque;
  
      /**
 -     * hardware accelerator private data (Libav-allocated)
 +     * hardware accelerator private data (FFmpeg-allocated)
       * - encoding: unused
       * - decoding: Set by libavcodec
       */
       * - decoding: Set by libavcodec.
       */
      uint8_t motion_subsample_log2;
 +
 +    /**
 +     * frame timestamp estimated using various heuristics, in stream time base
 +     * Code outside libavcodec should access this field using:
 +     *  av_opt_ptr(avcodec_get_frame_class(), frame, "best_effort_timestamp");
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int64_t best_effort_timestamp;
 +
 +    /**
 +     * reordered pos from the last AVPacket that has been input into the decoder
 +     * Code outside libavcodec should access this field using:
 +     *  av_opt_ptr(avcodec_get_frame_class(), frame, "pkt_pos");
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_pos;
 +
 +    /**
 +     * channel layout of the audio frame
 +     * - encoding: unused
 +     * - decoding: read by user.
 +     * Code outside libavcodec should access this field using:
 +     * av_opt_ptr(avcodec_get_frame_class(), frame, "channel_layout")
 +     */
 +    int64_t channel_layout;
 +
 +    /**
 +     * sample rate of the audio frame
 +     * - encoding: unused
 +     * - decoding: read by user.
 +     * Code outside libavcodec should access this field using:
 +     * av_opt_ptr(avcodec_get_frame_class(), frame, "sample_rate")
 +     */
 +    int sample_rate;
 +
  } AVFrame;
  
  struct AVCodecInternal;
@@@ -1294,8 -1224,6 +1295,8 @@@ enum AVFieldOrder 
   * New fields can be added to the end with minor version bumps.
   * Removal, reordering and changes to existing fields require a major
   * version bump.
 + * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
 + * applications.
   * sizeof(AVCodecContext) must not be used outside libav*.
   */
  typedef struct AVCodecContext {
      int ticks_per_frame;
  
      /**
 -     * Encoder delay.
 +     * Encoding: Number of frames delay there will be from the encoder input to
 +     *           the decoder output. (we assume the decoder matches the spec)
 +     * Decoding: Number of frames delay in addition to what a standard decoder
 +     *           as specified in the spec would produce.
       *
       * Video:
       *   Number of frames the decoded output will be delayed relative to the
       *   time, including any delay.
       *
       * - encoding: Set by libavcodec.
 -     * - decoding: unused
 +     * - decoding: Set by libavcodec.
       */
      int delay;
  
      int width, height;
  
      /**
 -     * Bitstream width / height, may be different from width/height.
 +     * Bitstream width / height, may be different from width/height if lowres enabled.
       * - encoding: unused
       * - decoding: Set by user before init if known. Codec should override / dynamically change if needed.
       */
      /**
       * Audio channel layout.
       * - encoding: set by user.
 -     * - decoding: set by libavcodec.
 +     * - decoding: set by user, may be overwritten by libavcodec.
       */
      uint64_t channel_layout;
  
      enum AVAudioServiceType audio_service_type;
  
      /**
 -     * Used to request a sample format from the decoder.
 -     * - encoding: unused.
 +     * desired sample format
 +     * - encoding: Not used.
       * - decoding: Set by user.
 +     * Decoder will decode to this format if it can.
       */
      enum AVSampleFormat request_sample_fmt;
  
      int max_prediction_order;
  
      /**
 -     * GOP timecode frame start number, in non drop frame format
 -     * - encoding: Set by user.
 -     * - decoding: unused
 +     * GOP timecode frame start number
 +     * - encoding: Set by user, in non drop frame format
 +     * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
       */
      int64_t timecode_frame_start;
  
  #define AV_EF_BUFFER    (1<<2)
  #define AV_EF_EXPLODE   (1<<3)
  
 +#define AV_EF_CAREFUL    (1<<16)
 +#define AV_EF_COMPLIANT  (1<<17)
 +#define AV_EF_AGGRESSIVE (1<<18)
 +
 +
      /**
       * opaque 64bit number (generally a PTS) that will be reordered and
       * output in AVFrame.reordered_opaque
       * Hardware accelerator context.
       * For some hardware accelerators, a global context needs to be
       * provided by the user. In that case, this holds display-dependent
 -     * data Libav cannot instantiate itself. Please refer to the
 -     * Libav HW accelerator documentation to know how to fill this
 +     * data FFmpeg cannot instantiate itself. Please refer to the
 +     * FFmpeg HW accelerator documentation to know how to fill this
       * is. e.g. for VA API, this is a struct vaapi_context.
       * - encoding: unused
       * - decoding: Set by user
       * - encoding: unused
       * - decoding: Set by user.
       */
 -    attribute_deprecated int lowres;
 +     int lowres;
  
      /**
       * the picture in the bitstream
       * - decoding: unused.
       */
      uint64_t vbv_delay;
 +
 +    /**
 +     * Current statistics for PTS correction.
 +     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
 +     * - encoding: unused
 +     */
 +    int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
 +    int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
 +    int64_t pts_correction_last_pts;       /// PTS of the last frame
 +    int64_t pts_correction_last_dts;       /// DTS of the last frame
  } AVCodecContext;
  
  /**
@@@ -2939,7 -2848,7 +2940,7 @@@ typedef struct AVCodec 
      const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
      const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
      const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
 -    attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
 +    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
      const AVClass *priv_class;              ///< AVClass for the private context
      const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
  
@@@ -3158,12 -3067,6 +3159,12 @@@ typedef struct AVSubtitleRect 
       * struct.
       */
      char *ass;
 +
 +    /**
 +     * 1 indicates this subtitle is a forced subtitle.
 +     * A forced subtitle should be displayed even when subtitles are hidden.
 +     */
 +    int forced;
  } AVSubtitleRect;
  
  typedef struct AVSubtitle {
@@@ -3219,40 -3122,6 +3220,40 @@@ void avcodec_register(AVCodec *codec)
   */
  void avcodec_register_all(void);
  
 +
 +#if FF_API_ALLOC_CONTEXT
 +/**
 + * Allocate an AVCodecContext and set its fields to default values.  The
 + * resulting struct can be deallocated by simply calling av_free().
 + *
 + * @return An AVCodecContext filled with default values or NULL on failure.
 + * @see avcodec_get_context_defaults
 + *
 + * @deprecated use avcodec_alloc_context3()
 + */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context(void);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +AVCodecContext *avcodec_alloc_context2(enum AVMediaType);
 +
 +/**
 + * Set the fields of the given AVCodecContext to default values.
 + *
 + * @param s The AVCodecContext of which the fields should be set to default values.
 + * @deprecated use avcodec_get_context_defaults3
 + */
 +attribute_deprecated
 +void avcodec_get_context_defaults(AVCodecContext *s);
 +
 +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API!
 + *  we WILL change its arguments and name a few times! */
 +attribute_deprecated
 +void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType);
 +#endif
 +
  /**
   * Allocate an AVCodecContext and set its fields to default values.  The
   * resulting struct can be deallocated by calling avcodec_close() on it followed
@@@ -3290,22 -3159,6 +3291,22 @@@ int avcodec_get_context_defaults3(AVCod
  const AVClass *avcodec_get_class(void);
  
  /**
 + * Get the AVClass for AVFrame. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_frame_class(void);
 +
 +/**
 + * Get the AVClass for AVSubtitleRect. It can be used in combination with
 + * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 + *
 + * @see av_opt_find().
 + */
 +const AVClass *avcodec_get_subtitle_rect_class(void);
 +
 +/**
   * Copy the settings of the source AVCodecContext into the destination
   * AVCodecContext. The resulting destination codec context will be
   * unopened, i.e. you are required to call avcodec_open2() before you
@@@ -3334,40 -3187,6 +3335,40 @@@ AVFrame *avcodec_alloc_frame(void)
   */
  void avcodec_get_frame_defaults(AVFrame *pic);
  
 +#if FF_API_AVCODEC_OPEN
 +/**
 + * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
 + * function the context has to be allocated.
 + *
 + * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(),
 + * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for
 + * retrieving a codec.
 + *
 + * @warning This function is not thread safe!
 + *
 + * @code
 + * avcodec_register_all();
 + * codec = avcodec_find_decoder(CODEC_ID_H264);
 + * if (!codec)
 + *     exit(1);
 + *
 + * context = avcodec_alloc_context3(codec);
 + *
 + * if (avcodec_open(context, codec) < 0)
 + *     exit(1);
 + * @endcode
 + *
 + * @param avctx The context which will be set up to use the given codec.
 + * @param codec The codec to use within the context.
 + * @return zero on success, a negative value on error
 + * @see avcodec_alloc_context3, avcodec_find_decoder, avcodec_find_encoder, avcodec_close
 + *
 + * @deprecated use avcodec_open2
 + */
 +attribute_deprecated
 +int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
 +#endif
 +
  /**
   * Initialize the AVCodecContext to use the given AVCodec. Prior to using this
   * function the context has to be allocated with avcodec_alloc_context3().
@@@ -3522,11 -3341,6 +3523,11 @@@ int av_packet_shrink_side_data(AVPacke
  uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                   int *size);
  
 +int av_packet_merge_side_data(AVPacket *pkt);
 +
 +int av_packet_split_side_data(AVPacket *pkt);
 +
 +
  /**
   * @}
   */
@@@ -3682,7 -3496,7 +3683,7 @@@ attribute_deprecated int avcodec_decode
   *         AVPacket is returned.
   */
  int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame,
 -                          int *got_frame_ptr, AVPacket *avpkt);
 +                          int *got_frame_ptr, const AVPacket *avpkt);
  
  /**
   * Decode the video frame of size avpkt->size from avpkt->data into picture.
   */
  int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
 -                         AVPacket *avpkt);
 +                         const AVPacket *avpkt);
  
  /**
   * Decode a subtitle message.
@@@ -4357,8 -4171,7 +4358,8 @@@ unsigned int avcodec_pix_fmt_to_codec_t
   * @param[in] dst_pix_fmt destination pixel format
   * @param[in] src_pix_fmt source pixel format
   * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 - * @return Combination of flags informing you what kind of losses will occur.
 + * @return Combination of flags informing you what kind of losses will occur
 + * (maximum loss for an invalid dst_pix_fmt).
   */
  int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt,
                               int has_alpha);
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_mask parameter.
   *
 + * Note, only the first 64 pixel formats will fit in pix_fmt_mask.
 + *
   * @code
   * src_pix_fmt = PIX_FMT_YUV420P;
 - * pix_fmt_mask = (1 << PIX_FMT_YUV422P) || (1 << PIX_FMT_RGB24);
 + * pix_fmt_mask = (1 << PIX_FMT_YUV422P) | (1 << PIX_FMT_RGB24);
   * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss);
   * @endcode
   *
  enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt,
                                int has_alpha, int *loss_ptr);
  
 +/**
 + * Find the best pixel format to convert to given a certain source pixel
 + * format and a selection of two destination pixel formats. When converting from
 + * one pixel format to another, information loss may occur.  For example, when converting
 + * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
 + * converting from some formats to other formats. avcodec_find_best_pix_fmt2() selects which of
 + * the given pixel formats should be used to suffer the least amount of loss.
 + *
 + * If one of the destination formats is PIX_FMT_NONE the other pixel format (if valid) will be
 + * returned.
 + *
 + * @code
 + * src_pix_fmt = PIX_FMT_YUV420P;
 + * dst_pix_fmt1= PIX_FMT_RGB24;
 + * dst_pix_fmt2= PIX_FMT_GRAY8;
 + * dst_pix_fmt3= PIX_FMT_RGB8;
 + * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
 + * @endcode
 + *
 + * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
 + * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
 + * @param[in] src_pix_fmt Source pixel format
 + * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 + * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
 + *                               NULL or value of zero means we care about all losses. Out: the loss
 + *                               that occurs when converting from src to selected dst pixel format.
 + * @return The best pixel format to convert to or -1 if none was found.
 + */
 +enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,
 +                                            enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
  enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt);
  
  /**
@@@ -4491,14 -4269,6 +4492,14 @@@ void avcodec_default_free_buffers(AVCod
  int av_get_bits_per_sample(enum CodecID codec_id);
  
  /**
 + * Return the PCM codec associated with a sample format.
 + * @param be  endianness, 0 for little, 1 for big,
 + *            -1 (or anything else) for native
 + * @return  CODEC_ID_PCM_* or CODEC_ID_NONE
 + */
 +enum CodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
 +
 +/**
   * Return codec bits per sample.
   * Only return non-zero if the bits per sample is exactly correct, not an
   * approximation.
@@@ -4572,11 -4342,11 +4573,11 @@@ void *av_fast_realloc(void *ptr, unsign
  void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
  
  /**
 - * Allocate a buffer with padding, reusing the given one if large enough.
 - *
   * Same behaviour av_fast_malloc but the buffer has additional
 - * FF_INPUT_PADDING_SIZE at the end which will always memset to 0.
 + * FF_INPUT_PADDING_SIZE at the end which will will always be 0.
   *
 + * In addition the whole buffer will initially and after resizes
 + * be 0-initialized so that no uninitialized data will ever appear.
   */
  void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size);
  
@@@ -4591,7 -4361,7 +4592,7 @@@ unsigned int av_xiphlacing(unsigned cha
  
  /**
   * Log a generic warning message about a missing feature. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4605,7 -4375,7 +4606,7 @@@ void av_log_missing_feature(void *avc, 
  
  /**
   * Log a generic warning message asking for a sample. This function is
 - * intended to be used internally by Libav (libavcodec, libavformat, etc.)
 + * intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)
   * only, and would normally not be used by applications.
   * @param[in] avc a pointer to an arbitrary struct of which the first field is
   * a pointer to an AVClass struct
@@@ -4642,7 -4412,7 +4643,7 @@@ enum AVLockOp 
   * lockmgr should store/get a pointer to a user allocated mutex. It's
   * NULL upon AV_LOCK_CREATE and != NULL for all other ops.
   *
 - * @param cb User defined callback. Note: Libav may invoke calls to this
 + * @param cb User defined callback. Note: FFmpeg may invoke calls to this
   *           callback during the call to av_lockmgr_register().
   *           Thus, the application must be prepared to handle that.
   *           If cb is set to NULL the lockmgr will be unregistered.
@@@ -4657,12 -4427,6 +4658,12 @@@ int av_lockmgr_register(int (*cb)(void 
  enum AVMediaType avcodec_get_type(enum CodecID codec_id);
  
  /**
 + * Get the name of a codec.
 + * @return  a static string identifying the codec; never NULL
 + */
 +const char *avcodec_get_name(enum CodecID id);
 +
 +/**
   * @return a positive value if s is open (i.e. avcodec_open2() was called on it
   * with no corresponding avcodec_close()), 0 otherwise.
   */
diff --combined libavcodec/sbr.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
   * Copyright (c) 2010      Alex Converse <alex.converse@gmail.com>
   *
 - * 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
   */
  
@@@ -180,7 -180,7 +180,7 @@@ typedef struct 
      ///Sinusoidal levels
      float              s_m[7][48];
      float              gain[7][48];
-     DECLARE_ALIGNED(16, float, qmf_filter_scratch)[5][64];
+     DECLARE_ALIGNED(32, float, qmf_filter_scratch)[5][64];
      FFTContext         mdct_ana;
      FFTContext         mdct;
      SBRDSPContext      dsp;
@@@ -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
   */
  
@@@ -112,8 -112,7 +112,8 @@@ typedef struct 
      uint64_t display_height;
      uint64_t pixel_width;
      uint64_t pixel_height;
 -    uint64_t fourcc;
 +    EbmlBin color_space;
 +    uint64_t stereo_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 flag_forced;
      MatroskaTrackVideo video;
      MatroskaTrackAudio audio;
 +    MatroskaTrackOperation operation;
      EbmlList encodings;
  
      AVStream *stream;
@@@ -240,7 -229,6 +240,7 @@@ typedef struct 
      uint64_t time_scale;
      double   duration;
      char    *title;
 +    EbmlBin date_utc;
      EbmlList tracks;
      EbmlList attachments;
      EbmlList chapters;
@@@ -302,7 -290,7 +302,7 @@@ static EbmlSyntax matroska_info[] = 
      { 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_DATEUTC,            EBML_BIN,  0, offsetof(MatroskaDemuxContext,date_utc) },
      { MATROSKA_ID_SEGMENTUID,         EBML_NONE },
      { 0 }
  };
@@@ -313,14 -301,14 +313,14 @@@ static EbmlSyntax matroska_track_video[
      { MATROSKA_ID_VIDEODISPLAYHEIGHT, EBML_UINT, 0, offsetof(MatroskaTrackVideo,display_height) },
      { 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_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 }
  };
@@@ -352,22 -340,6 +352,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_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_TRACKFLAGENABLED,     EBML_NONE },
      { MATROSKA_ID_TRACKFLAGLACING,      EBML_NONE },
@@@ -526,7 -497,7 +526,7 @@@ static EbmlSyntax matroska_segments[] 
  static EbmlSyntax matroska_blockgroup[] = {
      { MATROSKA_ID_BLOCK,          EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
      { MATROSKA_ID_SIMPLEBLOCK,    EBML_BIN,  0, offsetof(MatroskaBlock,bin) },
 -    { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock,duration), {.u=AV_NOPTS_VALUE} },
 +    { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock,duration) },
      { MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock,reference) },
      { 1,                          EBML_UINT, 0, offsetof(MatroskaBlock,non_simple), {.u=1} },
      { 0 }
@@@ -584,36 -555,6 +584,36 @@@ static EbmlSyntax matroska_clusters_inc
  
  static const char *const matroska_doctypes[] = { "matroska", "webm" };
  
 +static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
 +{
 +    AVIOContext *pb = matroska->ctx->pb;
 +    uint32_t id;
 +    matroska->current_id = 0;
 +    matroska->num_levels = 0;
 +
 +    // seek to next position to resync from
 +    if (avio_seek(pb, last_pos + 1, SEEK_SET) < 0 || avio_tell(pb) <= last_pos)
 +        goto eof;
 +
 +    id = avio_rb32(pb);
 +
 +    // try to find a toplevel element
 +    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 ||
 +            id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS)
 +        {
 +            matroska->current_id = id;
 +            return 0;
 +        }
 +        id = (id << 8) | avio_r8(pb);
 +    }
 +eof:
 +    matroska->done = 1;
 +    return AVERROR_EOF;
 +}
 +
  /*
   * Return: Whether we reached the end of a level in the hierarchy or not.
   */
@@@ -651,7 -592,7 +651,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",
@@@ -1050,10 -991,6 +1050,10 @@@ static int matroska_decode_buffer(uint8
  
      switch (encodings[0].compression.algo) {
      case MATROSKA_TRACK_ENCODING_COMP_HEADERSTRIP:
 +        if (encodings[0].compression.settings.size && !encodings[0].compression.settings.data) {
 +            av_log(0, AV_LOG_ERROR, "Compression size but no data in headerstrip\n");
 +            return -1;
 +        }
          return encodings[0].compression.settings.size;
      case MATROSKA_TRACK_ENCODING_COMP_LZO:
          do {
              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);
@@@ -1141,8 -1072,7 +1141,8 @@@ static void matroska_fix_ass_packet(Mat
      char *line, *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++);
      if (*ptr == ',') {
          int64_t end_pts = pkt->pts + display_duration;
  
  static int matroska_merge_packets(AVPacket *out, AVPacket *in)
  {
 -    void *newdata = av_realloc(out->data, out->size+in->size);
 -    if (!newdata)
 -        return AVERROR(ENOMEM);
 -    out->data = newdata;
 -    memcpy(out->data+out->size, in->data, in->size);
 -    out->size += in->size;
 +    int ret = av_grow_packet(out, in->size);
 +    if (ret < 0)
 +        return ret;
 +    memcpy(out->data + out->size - in->size, in->data, in->size);
      av_destruct_packet(in);
      av_free(in);
      return 0;
@@@ -1186,7 -1118,7 +1186,7 @@@ static void matroska_convert_tag(AVForm
      int i;
  
      for (i=0; i < list->nb_elem; i++) {
 -        const char *lang = strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
 +        const char *lang= (tags[i].lang && strcmp(tags[i].lang, "und")) ? tags[i].lang : NULL;
  
          if (!tags[i].name) {
              av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no TagName.\n");
@@@ -1317,20 -1249,26 +1317,20 @@@ 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) {
 -    EbmlList *seekhead_list = &matroska->seekhead;
 -    MatroskaSeekhead *seekhead = seekhead_list->elem;
 +static void matroska_add_index_entries(MatroskaDemuxContext *matroska) {
      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;
 +    assert(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" };
@@@ -1388,17 -1311,6 +1388,17 @@@ 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;
      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;
  
      /* 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 > 2) {
 +        || ebml.id_length > sizeof(uint32_t) || 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]))
      ebml_free(ebml_syntax, &ebml);
  
      /* The next thing is a segment. */
 -    if ((res = ebml_parse(matroska, matroska_segments, matroska)) < 0)
 -        return res;
 +    pos = avio_tell(matroska->ctx->pb);
 +    res = ebml_parse(matroska, matroska_segments, matroska);
 +    // try resyncing until we find a EBML_STOP type element.
 +    while (res != 1) {
 +        res = matroska_resync(matroska, pos);
 +        if (res < 0)
 +            return res;
 +        pos = avio_tell(matroska->ctx->pb);
 +        res = ebml_parse(matroska, matroska_segment, matroska);
 +    }
      matroska_execute_seekhead(matroska);
  
      if (!matroska->time_scale)
                                    * 1000 / AV_TIME_BASE;
      av_dict_set(&s->metadata, "title", matroska->title, 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++) {
          MatroskaTrack *track = &tracks[i];
          enum CodecID codec_id = CODEC_ID_NONE;
 -        EbmlList *encodings_list = &tracks->encodings;
 +        EbmlList *encodings_list = &track->encodings;
          MatroskaTrackEncoding *encodings = encodings_list->elem;
          uint8_t *extradata = NULL;
          int extradata_size = 0;
          int extradata_offset = 0;
 +        uint32_t fourcc = 0;
          AVIOContext b;
  
          /* Apply some sanity checks. */
                  track->video.display_width = track->video.pixel_width;
              if (!track->video.display_height)
                  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;
              && track->codec_priv.size >= 40
              && track->codec_priv.data != NULL) {
              track->ms_compat = 1;
 -            track->video.fourcc = AV_RL32(track->codec_priv.data + 16);
 -            codec_id = ff_codec_get_id(ff_codec_bmp_tags, track->video.fourcc);
 +            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
          } else if (!strcmp(track->codec_id, "V_QUICKTIME")
                     && (track->codec_priv.size >= 86)
                     && (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);
 +            codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
          } else if (codec_id == CODEC_ID_PCM_S16BE) {
              switch (track->audio.bitdepth) {
              case  8:  codec_id = CODEC_ID_PCM_U8;     break;
                  extradata_size = 2;
          } else if (codec_id == 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,
          } else if (codec_id == CODEC_ID_RA_144) {
              track->audio.out_samplerate = 8000;
              track->audio.channels = 1;
 -        } else if (codec_id == CODEC_ID_RA_288 || codec_id == CODEC_ID_COOK ||
 -                   codec_id == CODEC_ID_ATRAC3 || codec_id == CODEC_ID_SIPR) {
 +        } else if ((codec_id == CODEC_ID_RA_288 || codec_id == CODEC_ID_COOK ||
 +                    codec_id == CODEC_ID_ATRAC3 || codec_id == 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);
              avio_skip(&b, 22);
          }
  
          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;
              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 != CODEC_ID_H264)
              st->need_parsing = AVSTREAM_PARSE_HEADERS;
              if (track->default_duration) {
                  av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
                            1000000000, track->default_duration, 30000);
                  st->avg_frame_rate = st->r_frame_rate;
              }
 +
 +            /* 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", matroska_video_stereo_mode[track->video.stereo_mode], 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",
 +                         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;
              av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
              st->codec->codec_id = CODEC_ID_NONE;
              st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
 -            st->codec->extradata  = av_malloc(attachements[j].bin.size);
 +            st->codec->extradata  = av_malloc(attachements[j].bin.size + FF_INPUT_BUFFER_PADDING_SIZE);
              if(st->codec->extradata == NULL)
                  break;
              st->codec->extradata_size = attachements[j].bin.size;
              max_start = chapters[i].start;
          }
  
 +    matroska_add_index_entries(matroska);
 +
      matroska_convert_tags(s);
  
      return 0;
@@@ -1849,7 -1717,7 +1849,7 @@@ static int matroska_parse_block(Matrosk
  
      if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
          av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
-         return AVERROR_INVALIDDATA;
+         return n;
      }
      data += n;
      size -= n;
      st = track->stream;
      if (st->discard >= AVDISCARD_ALL)
          return res;
 -    if (duration == AV_NOPTS_VALUE)
 +    av_assert1(duration != AV_NOPTS_VALUE);
 +    if (!duration)
          duration = track->default_duration / matroska->time_scale;
  
      block_time = AV_RB16(data);
      }
  
      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 (!st->skip_to_keyframe) {
 +            av_log(matroska->ctx, AV_LOG_ERROR, "File is broken, keyframes not correctly marked!\n");
 +            matroska->skip_to_keyframe = 0;
 +        }
 +        if (is_keyframe)
 +            matroska->skip_to_keyframe = 0;
      }
  
      switch ((flags & 0x06) >> 1) {
@@@ -2150,7 -2012,7 +2150,7 @@@ static int matroska_parse_cluster_incre
          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;
 +                blocks[i].duration = 0;
              res = matroska_parse_block(matroska,
                                         blocks[i].bin.data, blocks[i].bin.size,
                                         blocks[i].bin.pos,
@@@ -2180,9 -2042,11 +2180,9 @@@ 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,
                                       pos);
          }
      ebml_free(matroska_cluster, &cluster);
 -    if (res < 0)  matroska->done = 1;
      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;
 -        ret = matroska_parse_cluster(matroska);
 -    }
 -
 -    if (ret == AVERROR_INVALIDDATA) {
 -        pkt->flags |= AV_PKT_FLAG_CORRUPT;
 -        return 0;
 +        if (matroska_parse_cluster(matroska) < 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++) {
  
      avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
      matroska->current_id = 0;
 +    st->skip_to_keyframe =
      matroska->skip_to_keyframe = !(flags & AVSEEK_FLAG_ANY);
      matroska->skip_to_timecode = st->index_entries[index].timestamp;
      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)