Merge commit '04fc8e24a091ed1d77d7a3c0cbcfe60baec19a9f'
authorHendrik Leppkes <h.leppkes@gmail.com>
Sun, 26 Jun 2016 12:34:53 +0000 (14:34 +0200)
committerHendrik Leppkes <h.leppkes@gmail.com>
Sun, 26 Jun 2016 12:34:53 +0000 (14:34 +0200)
* commit '04fc8e24a091ed1d77d7a3c0cbcfe60baec19a9f':
  lavc: deprecate avcodec_get_context_defaults3()

Merged-by: Hendrik Leppkes <h.leppkes@gmail.com>
1  2 
libavcodec/avcodec.h
libavcodec/options.c
libavcodec/version.h

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
   */
  
@@@ -33,7 -33,6 +33,7 @@@
  #include "libavutil/avutil.h"
  #include "libavutil/buffer.h"
  #include "libavutil/cpu.h"
 +#include "libavutil/channel_layout.h"
  #include "libavutil/dict.h"
  #include "libavutil/frame.h"
  #include "libavutil/log.h"
  
  #include "version.h"
  
 -#if FF_API_FAST_MALLOC
 -// to provide fast_*alloc
 -#include "libavutil/mem.h"
 -#endif
 -
  /**
   * @defgroup libavc Encoding/Decoding Library
   * @{
   * - The new API does not handle subtitles yet.
   *
   * Mixing new and old function calls on the same AVCodecContext is not allowed,
 - * and will result in arbitrary behavior.
 + * and will result in undefined behavior.
   *
   * Some codecs might require using the new API; using the old API will return
   * an error when calling it.
   * details.
   *
   * 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.
 + * 1. no value of an existing codec ID changes (that would break ABI),
 + * 2. it is as close as possible to similar codecs
   *
   * After adding new codec IDs, do not forget to add an entry to the codec
   * descriptor list and bump libavcodec minor version.
@@@ -329,7 -333,7 +329,7 @@@ enum AVCodecID 
      AV_CODEC_ID_ANM,
      AV_CODEC_ID_BINKVIDEO,
      AV_CODEC_ID_IFF_ILBM,
 -    AV_CODEC_ID_IFF_BYTERUN1,
 +#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
      AV_CODEC_ID_KGV1,
      AV_CODEC_ID_YOP,
      AV_CODEC_ID_VP8,
      AV_CODEC_ID_WEBP,
      AV_CODEC_ID_HNM4_VIDEO,
      AV_CODEC_ID_HEVC,
 +#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
      AV_CODEC_ID_FIC,
      AV_CODEC_ID_ALIAS_PIX,
      AV_CODEC_ID_BRENDER_PIX,
      AV_CODEC_ID_SCREENPRESSO,
      AV_CODEC_ID_RSCC,
  
 +    AV_CODEC_ID_Y41P = 0x8000,
 +    AV_CODEC_ID_AVRP,
 +    AV_CODEC_ID_012V,
 +    AV_CODEC_ID_AVUI,
 +    AV_CODEC_ID_AYUV,
 +    AV_CODEC_ID_TARGA_Y216,
 +    AV_CODEC_ID_V308,
 +    AV_CODEC_ID_V408,
 +    AV_CODEC_ID_YUV4,
 +    AV_CODEC_ID_AVRN,
 +    AV_CODEC_ID_CPIA,
 +    AV_CODEC_ID_XFACE,
 +    AV_CODEC_ID_SNOW,
 +    AV_CODEC_ID_SMVJPEG,
 +    AV_CODEC_ID_APNG,
 +    AV_CODEC_ID_DAALA,
 +    AV_CODEC_ID_CFHD,
 +    AV_CODEC_ID_TRUEMOTION2RT,
 +    AV_CODEC_ID_M101,
 +    AV_CODEC_ID_MAGICYUV,
 +    AV_CODEC_ID_SHEERVIDEO,
 +    AV_CODEC_ID_YLC,
 +
      /* various PCM "codecs" */
      AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
      AV_CODEC_ID_PCM_S16LE = 0x10000,
      AV_CODEC_ID_PCM_S24LE_PLANAR,
      AV_CODEC_ID_PCM_S32LE_PLANAR,
      AV_CODEC_ID_PCM_S16BE_PLANAR,
 +    /* new PCM "codecs" should be added right below this line starting with
 +     * an explicit value of for example 0x10800
 +     */
  
      /* various ADPCM codecs */
      AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
      AV_CODEC_ID_ADPCM_G722,
      AV_CODEC_ID_ADPCM_IMA_APC,
      AV_CODEC_ID_ADPCM_VIMA,
 +#if FF_API_VIMA_DECODER
 +    AV_CODEC_ID_VIMA = AV_CODEC_ID_ADPCM_VIMA,
 +#endif
 +
 +    AV_CODEC_ID_ADPCM_AFC = 0x11800,
 +    AV_CODEC_ID_ADPCM_IMA_OKI,
 +    AV_CODEC_ID_ADPCM_DTK,
 +    AV_CODEC_ID_ADPCM_IMA_RAD,
 +    AV_CODEC_ID_ADPCM_G726LE,
 +    AV_CODEC_ID_ADPCM_THP_LE,
 +    AV_CODEC_ID_ADPCM_PSX,
 +    AV_CODEC_ID_ADPCM_AICA,
 +    AV_CODEC_ID_ADPCM_IMA_DAT4,
 +    AV_CODEC_ID_ADPCM_MTAF,
  
      /* AMR */
      AV_CODEC_ID_AMR_NB = 0x12000,
      AV_CODEC_ID_XAN_DPCM,
      AV_CODEC_ID_SOL_DPCM,
  
 +    AV_CODEC_ID_SDX2_DPCM = 0x14800,
 +
      /* audio codecs */
      AV_CODEC_ID_MP2 = 0x15000,
      AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
      AV_CODEC_ID_ON2AVC,
      AV_CODEC_ID_DSS_SP,
  
 +    AV_CODEC_ID_FFWAVESYNTH = 0x15800,
 +    AV_CODEC_ID_SONIC,
 +    AV_CODEC_ID_SONIC_LS,
 +    AV_CODEC_ID_EVRC,
 +    AV_CODEC_ID_SMV,
 +    AV_CODEC_ID_DSD_LSBF,
 +    AV_CODEC_ID_DSD_MSBF,
 +    AV_CODEC_ID_DSD_LSBF_PLANAR,
 +    AV_CODEC_ID_DSD_MSBF_PLANAR,
 +    AV_CODEC_ID_4GV,
 +    AV_CODEC_ID_INTERPLAY_ACM,
 +    AV_CODEC_ID_XMA1,
 +    AV_CODEC_ID_XMA2,
 +    AV_CODEC_ID_DST,
 +
      /* subtitle codecs */
      AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
      AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
      AV_CODEC_ID_DVB_TELETEXT,
      AV_CODEC_ID_SRT,
  
 +    AV_CODEC_ID_MICRODVD   = 0x17800,
 +    AV_CODEC_ID_EIA_608,
 +    AV_CODEC_ID_JACOSUB,
 +    AV_CODEC_ID_SAMI,
 +    AV_CODEC_ID_REALTEXT,
 +    AV_CODEC_ID_STL,
 +    AV_CODEC_ID_SUBVIEWER1,
 +    AV_CODEC_ID_SUBVIEWER,
 +    AV_CODEC_ID_SUBRIP,
 +    AV_CODEC_ID_WEBVTT,
 +    AV_CODEC_ID_MPL2,
 +    AV_CODEC_ID_VPLAYER,
 +    AV_CODEC_ID_PJS,
 +    AV_CODEC_ID_ASS,
 +    AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
 +
      /* other specific kind of codecs (generally used for attachments) */
      AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
      AV_CODEC_ID_TTF = 0x18000,
  
 +    AV_CODEC_ID_BINTEXT    = 0x18800,
 +    AV_CODEC_ID_XBIN,
 +    AV_CODEC_ID_IDF,
 +    AV_CODEC_ID_OTF,
 +    AV_CODEC_ID_SMPTE_KLV,
 +    AV_CODEC_ID_DVD_NAV,
 +    AV_CODEC_ID_TIMED_ID3,
 +    AV_CODEC_ID_BIN_DATA,
 +
 +
      AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
  
      AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
@@@ -672,12 -592,6 +672,12 @@@ typedef struct AVCodecDescriptor 
       */
      int             props;
      /**
 +     * MIME type(s) associated with the codec.
 +     * May be NULL; if not, a NULL-terminated array of MIME types.
 +     * The first item is always non-NULL and is the preferred MIME type.
 +     */
 +    const char *const *mime_types;
 +    /**
       * If non-NULL, an array of profiles recognized for this codec.
       * Terminated with FF_PROFILE_UNKNOWN.
       */
   * equal.
   */
  #define AV_CODEC_PROP_REORDER       (1 << 3)
 +/**
 + * Subtitle codec is bitmap based
 + * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
 + */
 +#define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
 +/**
 + * Subtitle codec is text based.
 + * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
 + */
 +#define AV_CODEC_PROP_TEXT_SUB      (1 << 17)
  
  /**
   * @ingroup lavc_decoding
   * Note: If the first 23 bits of the additional bytes are not 0, then damaged
   * MPEG bitstreams could cause overread and segfault.
   */
 -#define AV_INPUT_BUFFER_PADDING_SIZE 8
 +#define AV_INPUT_BUFFER_PADDING_SIZE 32
  
  /**
   * @ingroup lavc_encoding
  /**
   * @deprecated use AV_INPUT_BUFFER_PADDING_SIZE instead
   */
 -#define FF_INPUT_BUFFER_PADDING_SIZE 8
 +#define FF_INPUT_BUFFER_PADDING_SIZE 32
  
  /**
   * @deprecated use AV_INPUT_BUFFER_MIN_SIZE instead
@@@ -765,7 -669,6 +765,7 @@@ enum Motion_Est_ID 
      ME_HEX,         ///< hexagon based search
      ME_UMH,         ///< uneven multi-hexagon search
      ME_TESA,        ///< transformed exhaustive search algorithm
 +    ME_ITER=50,     ///< iterative search
  };
  #endif
  
@@@ -779,7 -682,6 +779,7 @@@ enum AVDiscard
      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_NONINTRA= 24, ///< discard all non intra frames
      AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes
      AVDISCARD_ALL     = 48, ///< discard all
  };
@@@ -890,7 -792,7 +890,7 @@@ typedef struct RcOverride
   * interlaced motion estimation
   */
  #define AV_CODEC_FLAG_INTERLACED_ME   (1 << 29)
 -#define AV_CODEC_FLAG_CLOSED_GOP      (1 << 31)
 +#define AV_CODEC_FLAG_CLOSED_GOP      (1U << 31)
  
  /**
   * Allow non spec compliant speedup tricks.
   * Place global headers at every keyframe instead of in extradata.
   */
  #define AV_CODEC_FLAG2_LOCAL_HEADER   (1 <<  3)
 +
 +/**
 + * timecode is in drop frame format. DEPRECATED!!!!
 + */
 +#define AV_CODEC_FLAG2_DROP_FRAME_TIMECODE (1 << 13)
 +
  /**
   * Input bitstream might be truncated at a packet boundaries
   * instead of only at frame boundaries.
   */
  #define AV_CODEC_FLAG2_IGNORE_CROP    (1 << 16)
  
 +/**
 + * Show all frames before the first keyframe
 + */
 +#define AV_CODEC_FLAG2_SHOW_ALL       (1 << 22)
 +/**
 + * Export motion vectors through frame side data
 + */
 +#define AV_CODEC_FLAG2_EXPORT_MVS     (1 << 28)
 +/**
 + * Do not skip samples and export skip information as frame side data
 + */
 +#define AV_CODEC_FLAG2_SKIP_MANUAL    (1 << 29)
 +/**
 + * Do not reset ASS ReadOrder field on flush (subtitles decoding)
 + */
 +#define AV_CODEC_FLAG2_RO_FLUSH_NOOP  (1 << 30)
 +
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
   *              Reference Picture Selection
   * This can be used to prevent truncation of the last audio samples.
   */
  #define AV_CODEC_CAP_SMALL_LAST_FRAME    (1 <<  6)
 +
 +#if FF_API_CAP_VDPAU
 +/**
 + * Codec can export data for HW decoding (VDPAU).
 + */
 +#define AV_CODEC_CAP_HWACCEL_VDPAU       (1 <<  7)
 +#endif
 +
  /**
   * Codec can output multiple frames per AVPacket
   * Normally demuxers return one frame at a time, demuxers which do not do
   * Audio encoder supports receiving a different number of samples in each call.
   */
  #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
 +/**
 + * Codec is intra only.
 + */
 +#define AV_CODEC_CAP_INTRA_ONLY       0x40000000
 +/**
 + * Codec is lossless.
 + */
 +#define AV_CODEC_CAP_LOSSLESS         0x80000000
 +
  
  #if FF_API_WITHOUT_PREFIX
  /**
   * Allow decoders to produce frames with data planes that are not aligned
   * to CPU requirements (e.g. due to cropping).
   */
 -#define CODEC_FLAG_UNALIGNED 0x0001
 -#define CODEC_FLAG_QSCALE 0x0002  ///< Use fixed qscale.
 -#define CODEC_FLAG_4MV    0x0004  ///< 4 MV per MB allowed / advanced prediction for H.263.
 -#define CODEC_FLAG_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted
 -#define CODEC_FLAG_QPEL   0x0010  ///< Use qpel MC.
 +#define CODEC_FLAG_UNALIGNED AV_CODEC_FLAG_UNALIGNED
 +#define CODEC_FLAG_QSCALE AV_CODEC_FLAG_QSCALE
 +#define CODEC_FLAG_4MV    AV_CODEC_FLAG_4MV
 +#define CODEC_FLAG_OUTPUT_CORRUPT AV_CODEC_FLAG_OUTPUT_CORRUPT
 +#define CODEC_FLAG_QPEL   AV_CODEC_FLAG_QPEL
  #if FF_API_GMC
  /**
   * @deprecated use the "gmc" private option of the libxvid encoder
   */
  #define CODEC_FLAG_INPUT_PRESERVED 0x0100
  #endif
 -#define CODEC_FLAG_PASS1           0x0200   ///< Use internal 2pass ratecontrol in first pass mode.
 -#define CODEC_FLAG_PASS2           0x0400   ///< Use internal 2pass ratecontrol in second pass mode.
 -#define CODEC_FLAG_GRAY            0x2000   ///< Only decode/encode grayscale.
 +#define CODEC_FLAG_PASS1           AV_CODEC_FLAG_PASS1
 +#define CODEC_FLAG_PASS2           AV_CODEC_FLAG_PASS2
 +#define CODEC_FLAG_GRAY            AV_CODEC_FLAG_GRAY
  #if FF_API_EMU_EDGE
  /**
   * @deprecated edges are not used/required anymore. I.e. this flag is now always
   */
  #define CODEC_FLAG_EMU_EDGE        0x4000
  #endif
 -#define CODEC_FLAG_PSNR            0x8000   ///< error[?] variables will be set during encoding.
 -#define CODEC_FLAG_TRUNCATED       0x00010000 /** Input bitstream might be truncated at a random
 -                                                  location instead of only at frame boundaries. */
 +#define CODEC_FLAG_PSNR            AV_CODEC_FLAG_PSNR
 +#define CODEC_FLAG_TRUNCATED       AV_CODEC_FLAG_TRUNCATED
 +
  #if FF_API_NORMALIZE_AQP
  /**
   * @deprecated use the flag "naq" in the "mpv_flags" private option of the
   */
  #define CODEC_FLAG_NORMALIZE_AQP  0x00020000
  #endif
 -#define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< Use interlaced DCT.
 -#define CODEC_FLAG_LOW_DELAY      0x00080000 ///< Force low delay.
 -#define CODEC_FLAG_GLOBAL_HEADER  0x00400000 ///< Place global headers in extradata instead of every keyframe.
 -#define CODEC_FLAG_BITEXACT       0x00800000 ///< Use only bitexact stuff (except (I)DCT).
 -/* Fx : Flag for H.263+ extra options */
 -#define CODEC_FLAG_AC_PRED        0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
 -#define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter
 -#define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation
 -#define CODEC_FLAG_CLOSED_GOP     0x80000000
 -#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_IGNORE_CROP   0x00010000 ///< Discard cropping information from SPS.
 -
 -#define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
 +#define CODEC_FLAG_INTERLACED_DCT AV_CODEC_FLAG_INTERLACED_DCT
 +#define CODEC_FLAG_LOW_DELAY      AV_CODEC_FLAG_LOW_DELAY
 +#define CODEC_FLAG_GLOBAL_HEADER  AV_CODEC_FLAG_GLOBAL_HEADER
 +#define CODEC_FLAG_BITEXACT       AV_CODEC_FLAG_BITEXACT
 +#define CODEC_FLAG_AC_PRED        AV_CODEC_FLAG_AC_PRED
 +#define CODEC_FLAG_LOOP_FILTER    AV_CODEC_FLAG_LOOP_FILTER
 +#define CODEC_FLAG_INTERLACED_ME  AV_CODEC_FLAG_INTERLACED_ME
 +#define CODEC_FLAG_CLOSED_GOP     AV_CODEC_FLAG_CLOSED_GOP
 +#define CODEC_FLAG2_FAST          AV_CODEC_FLAG2_FAST
 +#define CODEC_FLAG2_NO_OUTPUT     AV_CODEC_FLAG2_NO_OUTPUT
 +#define CODEC_FLAG2_LOCAL_HEADER  AV_CODEC_FLAG2_LOCAL_HEADER
 +#define CODEC_FLAG2_DROP_FRAME_TIMECODE AV_CODEC_FLAG2_DROP_FRAME_TIMECODE
 +#define CODEC_FLAG2_IGNORE_CROP   AV_CODEC_FLAG2_IGNORE_CROP
 +
 +#define CODEC_FLAG2_CHUNKS        AV_CODEC_FLAG2_CHUNKS
 +#define CODEC_FLAG2_SHOW_ALL      AV_CODEC_FLAG2_SHOW_ALL
 +#define CODEC_FLAG2_EXPORT_MVS    AV_CODEC_FLAG2_EXPORT_MVS
 +#define CODEC_FLAG2_SKIP_MANUAL   AV_CODEC_FLAG2_SKIP_MANUAL
  
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
  /* /Fx */
  /* codec capabilities */
  
 -#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< Decoder can use draw_horiz_band callback.
 +#define CODEC_CAP_DRAW_HORIZ_BAND AV_CODEC_CAP_DRAW_HORIZ_BAND ///< Decoder can use draw_horiz_band callback.
  /**
   * Codec uses get_buffer() for allocating buffers and supports custom allocators.
   * If not set, it might not use get_buffer() at all or use operations that
   * assume the buffer was allocated by avcodec_default_get_buffer.
   */
 -#define CODEC_CAP_DR1             0x0002
 -#define CODEC_CAP_TRUNCATED       0x0008
 +#define CODEC_CAP_DR1             AV_CODEC_CAP_DR1
 +#define CODEC_CAP_TRUNCATED       AV_CODEC_CAP_TRUNCATED
  #if FF_API_XVMC
 -/* Codec can export data for HW decoding (XvMC). */
 +/* Codec can export data for HW decoding. This flag indicates that
 + * the codec would call get_format() with list that might contain HW accelerated
 + * pixel formats (XvMC, VDPAU, VAAPI, etc). The application can pick any of them
 + * including raw image format.
 + * The application can use the passed context to determine bitstream version,
 + * chroma format, resolution etc.
 + */
  #define CODEC_CAP_HWACCEL         0x0010
  #endif /* FF_API_XVMC */
  /**
   *       each output packet. If this flag is not set, the pts and duration will
   *       be determined by libavcodec from the input frame.
   */
 -#define CODEC_CAP_DELAY           0x0020
 +#define CODEC_CAP_DELAY           AV_CODEC_CAP_DELAY
  /**
   * Codec can be fed a final frame with a smaller size.
   * This can be used to prevent truncation of the last audio samples.
   */
 -#define CODEC_CAP_SMALL_LAST_FRAME 0x0040
 +#define CODEC_CAP_SMALL_LAST_FRAME AV_CODEC_CAP_SMALL_LAST_FRAME
  #if FF_API_CAP_VDPAU
  /**
   * Codec can export data for HW decoding (VDPAU).
   */
 -#define CODEC_CAP_HWACCEL_VDPAU    0x0080
 +#define CODEC_CAP_HWACCEL_VDPAU    AV_CODEC_CAP_HWACCEL_VDPAU
  #endif
  /**
   * Codec can output multiple frames per AVPacket
   * prohibiting stream copy in many cases thus it should only be considered
   * as a last resort.
   */
 -#define CODEC_CAP_SUBFRAMES        0x0100
 +#define CODEC_CAP_SUBFRAMES        AV_CODEC_CAP_SUBFRAMES
  /**
   * Codec is experimental and is thus avoided in favor of non experimental
   * encoders
   */
 -#define CODEC_CAP_EXPERIMENTAL     0x0200
 +#define CODEC_CAP_EXPERIMENTAL     AV_CODEC_CAP_EXPERIMENTAL
  /**
   * Codec should fill in channel configuration and samplerate instead of container
   */
 -#define CODEC_CAP_CHANNEL_CONF     0x0400
 +#define CODEC_CAP_CHANNEL_CONF     AV_CODEC_CAP_CHANNEL_CONF
  #if FF_API_NEG_LINESIZES
  /**
   * @deprecated no codecs use this capability
  /**
   * Codec supports frame-level multithreading.
   */
 -#define CODEC_CAP_FRAME_THREADS    0x1000
 +#define CODEC_CAP_FRAME_THREADS    AV_CODEC_CAP_FRAME_THREADS
  /**
   * Codec supports slice-based (or partition-based) multithreading.
   */
 -#define CODEC_CAP_SLICE_THREADS    0x2000
 +#define CODEC_CAP_SLICE_THREADS    AV_CODEC_CAP_SLICE_THREADS
  /**
   * Codec supports changed parameters at any point.
   */
 -#define CODEC_CAP_PARAM_CHANGE     0x4000
 +#define CODEC_CAP_PARAM_CHANGE     AV_CODEC_CAP_PARAM_CHANGE
  /**
   * Codec supports avctx->thread_count == 0 (auto).
   */
 -#define CODEC_CAP_AUTO_THREADS     0x8000
 +#define CODEC_CAP_AUTO_THREADS     AV_CODEC_CAP_AUTO_THREADS
  /**
   * Audio encoder supports receiving a different number of samples in each call.
   */
 -#define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
 +#define CODEC_CAP_VARIABLE_FRAME_SIZE AV_CODEC_CAP_VARIABLE_FRAME_SIZE
 +/**
 + * Codec is intra only.
 + */
 +#define CODEC_CAP_INTRA_ONLY       AV_CODEC_CAP_INTRA_ONLY
 +/**
 + * Codec is lossless.
 + */
 +#define CODEC_CAP_LOSSLESS         AV_CODEC_CAP_LOSSLESS
 +
 +/**
 + * HWAccel is experimental and is thus avoided in favor of non experimental
 + * codecs
 + */
 +#define HWACCEL_CODEC_CAP_EXPERIMENTAL     0x0200
  #endif /* FF_API_WITHOUT_PREFIX */
  
  #if FF_API_MB_TYPE
@@@ -1416,16 -1255,11 +1416,16 @@@ enum AVPacketSideDataType 
      AV_PKT_DATA_AUDIO_SERVICE_TYPE,
  
      /**
 -     * This side data contains an integer value representing the quality
 -     * factor of the compressed frame. Allowed range is between 1 (good)
 -     * and FF_LAMBDA_MAX (bad).
 +     * This side data contains quality related information from the encoder.
 +     * @code
 +     * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
 +     * u8    picture type
 +     * u8    error count
 +     * u16   reserved
 +     * u64le[error count] sum of squared differences between encoder in and output
 +     * @endcode
       */
 -    AV_PKT_DATA_QUALITY_FACTOR,
 +    AV_PKT_DATA_QUALITY_STATS,
  
      /**
       * This side data contains an integer value representing the stream index
       * This side data corresponds to the AVCPBProperties struct.
       */
      AV_PKT_DATA_CPB_PROPERTIES,
 +
 +    /**
 +     * Recommmends skipping the specified number of samples
 +     * @code
 +     * u32le number of samples to skip from start of this packet
 +     * u32le number of samples to skip from end of this packet
 +     * u8    reason for start skip
 +     * u8    reason for end   skip (0=padding silence, 1=convergence)
 +     * @endcode
 +     */
 +    AV_PKT_DATA_SKIP_SAMPLES=70,
 +
 +    /**
 +     * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
 +     * the packet may contain "dual mono" audio specific to Japanese DTV
 +     * and if it is true, recommends only the selected channel to be used.
 +     * @code
 +     * u8    selected channels (0=mail/left, 1=sub/right, 2=both)
 +     * @endcode
 +     */
 +    AV_PKT_DATA_JP_DUALMONO,
 +
 +    /**
 +     * A list of zero terminated key/value strings. There is no end marker for
 +     * the list, so it is required to rely on the side data size to stop.
 +     */
 +    AV_PKT_DATA_STRINGS_METADATA,
 +
 +    /**
 +     * Subtitle event position
 +     * @code
 +     * u32le x1
 +     * u32le y1
 +     * u32le x2
 +     * u32le y2
 +     * @endcode
 +     */
 +    AV_PKT_DATA_SUBTITLE_POSITION,
 +
 +    /**
 +     * Data found in BlockAdditional element of matroska container. There is
 +     * no end marker for the data, so it is required to rely on the side data
 +     * size to recognize the end. 8 byte id (as found in BlockAddId) followed
 +     * by data.
 +     */
 +    AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
 +
 +    /**
 +     * The optional first identifier line of a WebVTT cue.
 +     */
 +    AV_PKT_DATA_WEBVTT_IDENTIFIER,
 +
 +    /**
 +     * The optional settings (rendering instructions) that immediately
 +     * follow the timestamp specifier of a WebVTT cue.
 +     */
 +    AV_PKT_DATA_WEBVTT_SETTINGS,
 +
 +    /**
 +     * A list of zero terminated key/value strings. There is no end marker for
 +     * the list, so it is required to rely on the side data size to stop. This
 +     * side data includes updated metadata which appeared in the stream.
 +     */
 +    AV_PKT_DATA_METADATA_UPDATE,
 +
 +    /**
 +     * MPEGTS stream ID, this is required to pass the stream ID
 +     * information from the demuxer to the corresponding muxer.
 +     */
 +    AV_PKT_DATA_MPEGTS_STREAM_ID,
 +
 +    /**
 +     * Mastering display metadata (based on SMPTE-2086:2014). This metadata
 +     * should be associated with a video stream and containts data in the form
 +     * of the AVMasteringDisplayMetadata struct.
 +     */
 +    AV_PKT_DATA_MASTERING_DISPLAY_METADATA
  };
  
 +#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
 +
  typedef struct AVPacketSideData {
      uint8_t *data;
      int      size;
   * packets, with no compressed data, containing only side data
   * (e.g. to update some stream parameters at the end of encoding).
   *
 - * AVPacket is one of the few structs in Libav, whose size is a part of public
 + * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
   * ABI. Thus it may be allocated on stack and no new fields can be added to it
   * without libavcodec and libavformat major bump.
   *
@@@ -1638,12 -1393,6 +1638,12 @@@ 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.
 + * The name string for AVOptions options matches the associated command line
 + * parameter name and can be found in libavcodec/options_table.h
 + * The AVOption/command line parameter names differ in some cases from the C
 + * structure field names for historic reasons or brevity.
   * sizeof(AVCodecContext) must not be used outside libav*.
   */
  typedef struct AVCodecContext {
      /**
       * the average bitrate
       * - encoding: Set by user; unused for constant quantizer encoding.
 -     * - decoding: Set by libavcodec. 0 or some bitrate if this info is available in the stream.
 +     * - decoding: Set by user, may be overwritten by libavcodec
 +     *             if this info is available in the stream
       */
 -    int bit_rate;
 +    int64_t bit_rate;
  
      /**
       * number of bits the bitstream is allowed to diverge from the reference.
       * of which frame timestamps are represented. For fixed-fps content,
       * timebase should be 1/framerate and timestamp increments should be
       * identically 1.
 +     * This often, but not always is the inverse of the frame rate or field rate
 +     * for video. 1/time_base is not the average frame rate if the frame rate is not
 +     * constant.
 +     *
 +     * Like containers, elementary streams also can store timestamps, 1/time_base
 +     * is the unit in which these timestamps are specified.
 +     * As example of such codec time base see ISO/IEC 14496-2:2001(E)
 +     * vop_time_increment_resolution and fixed_vop_rate
 +     * (fixed_vop_rate == 0 implies that it is different from the framerate)
 +     *
       * - encoding: MUST be set by user.
       * - decoding: the use of this field for decoding is deprecated.
       *             Use framerate instead.
      /**
       * Codec 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
       *   encoded input.
  
      /**
       * Bitstream width / height, may be different from width/height e.g. when
 -     * the decoded frame is cropped before being output.
 +     * the decoded frame is cropped before being output or lowres is enabled.
       *
       * @note Those field may not match the value of the last
       * AVFrame output by avcodec_receive_frame() due frame
  #define FF_CMP_VSAD   8
  #define FF_CMP_VSSE   9
  #define FF_CMP_NSSE   10
 +#define FF_CMP_W53    11
 +#define FF_CMP_W97    12
  #define FF_CMP_DCTMAX 13
  #define FF_CMP_DCT264 14
  #define FF_CMP_CHROMA 256
       * XVideo Motion Acceleration
       * - encoding: forbidden
       * - decoding: set by decoder
 -     * @deprecated XvMC support is slated for removal.
 +     * @deprecated XvMC doesn't need it anymore.
       */
      attribute_deprecated int xvmc_acceleration;
  #endif /* FF_API_XVMC */
      /**
       * precision of the intra DC coefficient - 8
       * - encoding: Set by user.
 -     * - decoding: unused
 +     * - decoding: Set by libavcodec
       */
      int intra_dc_precision;
  
  
      /** Field order
       * - encoding: set by libavcodec
 -     * - decoding: Set by libavcodec
 +     * - decoding: Set by user.
       */
      enum AVFieldOrder field_order;
  
      /**
       * 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;
  
       * avcodec_align_dimensions2() should be used to find the required width and
       * height, as they normally need to be rounded up to the next multiple of 16.
       *
 +     * Some decoders do not support linesizes changing between frames.
 +     *
       * If frame multithreading is used and thread_safe_callbacks is set,
       * this callback may be called from a different thread, but not from more
       * than one at once. Does not need to be reentrant.
      /**
       * maximum bitrate
       * - encoding: Set by user.
 -     * - decoding: unused
 +     * - decoding: Set by user, may be overwritten by libavcodec.
       */
 -    int rc_max_rate;
 +    int64_t rc_max_rate;
  
      /**
       * minimum bitrate
       * - encoding: Set by user.
       * - decoding: unused
       */
 -    int rc_min_rate;
 +    int64_t rc_min_rate;
  
  #if FF_API_MPV_OPT
      /**
      int error_concealment;
  #define FF_EC_GUESS_MVS   1
  #define FF_EC_DEBLOCK     2
 +#define FF_EC_FAVOR_INTER 256
  
      /**
       * debug
  #define FF_DEBUG_MMCO        0x00000800
  #define FF_DEBUG_BUGS        0x00001000
  #if FF_API_DEBUG_MV
 -#define FF_DEBUG_VIS_QP      0x00002000
 -#define FF_DEBUG_VIS_MB_TYPE 0x00004000
 +#define FF_DEBUG_VIS_QP      0x00002000 ///< only access through AVOptions from outside libavcodec
 +#define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec
  #endif
  #define FF_DEBUG_BUFFERS     0x00008000
  #define FF_DEBUG_THREADS     0x00010000
 +#define FF_DEBUG_GREEN_MD    0x00800000
 +#define FF_DEBUG_NOMC        0x01000000
  
  #if FF_API_DEBUG_MV
      /**
 -     * @deprecated this option does not have any effect
 +     * debug
 +     * Code outside libavcodec should access this field using AVOptions
 +     * - encoding: Set by user.
 +     * - decoding: Set by user.
       */
 -    attribute_deprecated
      int debug_mv;
  #define FF_DEBUG_VIS_MV_P_FOR  0x00000001 // visualize forward predicted MVs of P-frames
  #define FF_DEBUG_VIS_MV_B_FOR  0x00000002 // visualize forward predicted MVs of B-frames
   * decoder returning an error.
   */
  #define AV_EF_CRCCHECK  (1<<0)
 -#define AV_EF_BITSTREAM (1<<1)
 -#define AV_EF_BUFFER    (1<<2)
 -#define AV_EF_EXPLODE   (1<<3)
 +#define AV_EF_BITSTREAM (1<<1)          ///< detect bitstream specification deviations
 +#define AV_EF_BUFFER    (1<<2)          ///< detect improper bitstream length
 +#define AV_EF_EXPLODE   (1<<3)          ///< abort decoding on minor error detection
 +
 +#define AV_EF_IGNORE_ERR (1<<15)        ///< ignore errors and continue
 +#define AV_EF_CAREFUL    (1<<16)        ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
 +#define AV_EF_COMPLIANT  (1<<17)        ///< consider all spec non compliances as errors
 +#define AV_EF_AGGRESSIVE (1<<18)        ///< consider things that a sane encoder should not do as an error
 +
  
      /**
       * opaque 64-bit number (generally a PTS) that will be reordered and
       * 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
  #if FF_API_ARCH_ALPHA
  #define FF_IDCT_SIMPLEALPHA   23
  #endif
 +#define FF_IDCT_SIMPLEAUTO    128
  
      /**
       * bits per sample/pixel from the demuxer (needed for huffyuv).
       * low resolution decoding, 1-> 1/2 size, 2->1/4 size
       * - encoding: unused
       * - decoding: Set by user.
 -     *
 -     * @deprecated use decoder private options instead
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_lowres(avctx)
       */
 -    attribute_deprecated int lowres;
 +     int lowres;
  #endif
  
  #if FF_API_CODED_FRAME
  #define FF_PROFILE_HEVC_MAIN                        1
  #define FF_PROFILE_HEVC_MAIN_10                     2
  #define FF_PROFILE_HEVC_MAIN_STILL_PICTURE          3
 +#define FF_PROFILE_HEVC_REXT                        4
  
      /**
       * level
  #define FF_LEVEL_UNKNOWN -99
  
      /**
 +     * Skip loop filtering for selected frames.
       * - encoding: unused
       * - decoding: Set by user.
       */
      enum AVDiscard skip_loop_filter;
  
      /**
 +     * Skip IDCT/dequantization for selected frames.
       * - encoding: unused
       * - decoding: Set by user.
       */
      enum AVDiscard skip_idct;
  
      /**
 +     * Skip decoding for selected frames.
       * - encoding: unused
       * - decoding: Set by user.
       */
       */
      int initial_padding;
  
 -    /*
 +    /**
       * - decoding: For codecs that store a framerate value in the compressed
       *             bitstream, the decoder may export it here. { 0, 1} when
       *             unknown.
      enum AVPixelFormat sw_pix_fmt;
  
      /**
 +     * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_pkt_timebase(avctx)
 +     * - encoding unused.
 +     * - decoding set by user.
 +     */
 +    AVRational pkt_timebase;
 +
 +    /**
 +     * AVCodecDescriptor
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_codec_descriptor(avctx)
 +     * - encoding: unused.
 +     * - decoding: set by libavcodec.
 +     */
 +    const AVCodecDescriptor *codec_descriptor;
 +
 +#if !FF_API_LOWRES
 +    /**
 +     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
 +     * - encoding: unused
 +     * - decoding: Set by user.
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_lowres(avctx)
 +     */
 +     int lowres;
 +#endif
 +
 +    /**
 +     * 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
 +
 +    /**
 +     * Character encoding of the input subtitles file.
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    char *sub_charenc;
 +
 +    /**
 +     * Subtitles character encoding mode. Formats or codecs might be adjusting
 +     * this setting (if they are doing the conversion themselves for instance).
 +     * - decoding: set by libavcodec
 +     * - encoding: unused
 +     */
 +    int sub_charenc_mode;
 +#define FF_SUB_CHARENC_MODE_DO_NOTHING  -1  ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
 +#define FF_SUB_CHARENC_MODE_AUTOMATIC    0  ///< libavcodec will select the mode itself
 +#define FF_SUB_CHARENC_MODE_PRE_DECODER  1  ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
 +
 +    /**
 +     * Skip processing alpha if supported by codec.
 +     * Note that if the format uses pre-multiplied alpha (common with VP6,
 +     * and recommended due to better video quality/compression)
 +     * the image will look as if alpha-blended onto a black background.
 +     * However for formats that do not use pre-multiplied alpha
 +     * there might be serious artefacts (though e.g. libswscale currently
 +     * assumes pre-multiplied alpha anyway).
 +     * Code outside libavcodec should access this field using AVOptions
 +     *
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    int skip_alpha;
 +
 +    /**
 +     * Number of samples to skip after a discontinuity
 +     * - decoding: unused
 +     * - encoding: set by libavcodec
 +     */
 +    int seek_preroll;
 +
 +#if !FF_API_DEBUG_MV
 +    /**
 +     * debug motion vectors
 +     * Code outside libavcodec should access this field using AVOptions
 +     * - encoding: Set by user.
 +     * - decoding: Set by user.
 +     */
 +    int debug_mv;
 +#define FF_DEBUG_VIS_MV_P_FOR  0x00000001 //visualize forward predicted MVs of P frames
 +#define FF_DEBUG_VIS_MV_B_FOR  0x00000002 //visualize forward predicted MVs of B frames
 +#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
 +#endif
 +
 +    /**
 +     * custom intra quantization matrix
 +     * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix()
 +     * - encoding: Set by user, can be NULL.
 +     * - decoding: unused.
 +     */
 +    uint16_t *chroma_intra_matrix;
 +
 +    /**
 +     * dump format separator.
 +     * can be ", " or "\n      " or anything else
 +     * Code outside libavcodec should access this field using AVOptions
 +     * (NO direct access).
 +     * - encoding: Set by user.
 +     * - decoding: Set by user.
 +     */
 +    uint8_t *dump_separator;
 +
 +    /**
 +     * ',' separated list of allowed decoders.
 +     * If NULL then all are allowed
 +     * - encoding: unused
 +     * - decoding: set by user through AVOPtions (NO direct access)
 +     */
 +    char *codec_whitelist;
 +
 +    /*
 +     * Properties of the stream that gets decoded
 +     * To be accessed through av_codec_get_properties() (NO direct access)
 +     * - encoding: unused
 +     * - decoding: set by libavcodec
 +     */
 +    unsigned properties;
 +#define FF_CODEC_PROPERTY_LOSSLESS        0x00000001
 +#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS 0x00000002
 +
 +    /**
       * Additional data associated with the entire coded stream.
       *
       * - decoding: unused
       * afterwards owned and managed by libavcodec.
       */
      AVBufferRef *hw_frames_ctx;
 +
 +    /**
 +     * Control the form of AVSubtitle.rects[N]->ass
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    int sub_text_format;
 +#define FF_SUB_TEXT_FMT_ASS              0
 +#if FF_API_ASS_TIMING
 +#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS 1
 +#endif
 +
  } AVCodecContext;
  
 +AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
 +void       av_codec_set_pkt_timebase         (AVCodecContext *avctx, AVRational val);
 +
 +const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
 +void                     av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
 +
 +unsigned av_codec_get_codec_properties(const AVCodecContext *avctx);
 +
 +int  av_codec_get_lowres(const AVCodecContext *avctx);
 +void av_codec_set_lowres(AVCodecContext *avctx, int val);
 +
 +int  av_codec_get_seek_preroll(const AVCodecContext *avctx);
 +void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
 +
 +uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
 +void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
 +
  /**
   * AVProfile.
   */
@@@ -3564,7 -3119,9 +3564,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
 -#if FF_API_LOWRES
 -    attribute_deprecated uint8_t max_lowres; ///< maximum value for lowres supported by the decoder
 -#endif
 +    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres()
      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}
  
      int caps_internal;
  } AVCodec;
  
 +int av_codec_get_max_lowres(const AVCodec *codec);
 +
 +struct MpegEncContext;
 +
  /**
   * @defgroup lavc_hwaccel AVHWAccel
   * @{
@@@ -3690,7 -3243,7 +3690,7 @@@ typedef struct AVHWAccel 
  
      /**
       * Hardware accelerated codec capabilities.
 -     * see FF_HWACCEL_CODEC_CAP_*
 +     * see HWACCEL_CODEC_CAP_*
       */
      int capabilities;
  
       *
       * Meaningful slice information (codec specific) is guaranteed to
       * be parsed at this point. This function is mandatory.
 +     * The only exception is XvMC, that works on MB level.
       *
       * @param avctx the codec context
       * @param buf the slice data buffer base
      int frame_priv_data_size;
  
      /**
 +     * Called for every Macroblock in a slice.
 +     *
 +     * XvMC uses it to replace the ff_mpv_decode_mb().
 +     * Instead of decoding to raw picture, MB parameters are
 +     * stored in an array provided by the video driver.
 +     *
 +     * @param s the mpeg context
 +     */
 +    void (*decode_mb)(struct MpegEncContext *s);
 +
 +    /**
       * Initialize the hwaccel private data.
       *
       * This will be called from ff_get_format(), after hwaccel and
   * Hardware acceleration should be used for decoding even if the codec level
   * used is unknown or higher than the maximum supported level reported by the
   * hardware driver.
 + *
 + * It's generally a good idea to pass this flag unless you have a specific
 + * reason not to, as hardware tends to under-report supported levels.
   */
  #define AV_HWACCEL_FLAG_IGNORE_LEVEL (1 << 0)
  
   */
  
  /**
 - * four components are given, that's all.
 - * the last component is alpha
 - * @deprecated Use the imgutils functions
 + * Picture data structure.
 + *
 + * Up to four components can be stored into it, the last component is
 + * alpha.
 + * @deprecated use AVFrame or imgutils functions instead
   */
  typedef struct AVPicture {
      attribute_deprecated
 -    uint8_t *data[AV_NUM_DATA_POINTERS];
 +    uint8_t *data[AV_NUM_DATA_POINTERS];    ///< pointers to the image data planes
      attribute_deprecated
      int linesize[AV_NUM_DATA_POINTERS];     ///< number of bytes per line
  } AVPicture;
   */
  #endif
  
 -#define AVPALETTE_SIZE 1024
 -#define AVPALETTE_COUNT 256
 -
  enum AVSubtitleType {
      SUBTITLE_NONE,
  
@@@ -3891,7 -3430,6 +3891,7 @@@ typedef struct AVSubtitleRect 
       * struct.
       */
      char *ass;
 +
      int flags;
  } AVSubtitleRect;
  
@@@ -3948,35 -3486,11 +3948,35 @@@ typedef struct AVCodecParameters 
      /**
       * The average bitrate of the encoded data (in bits per second).
       */
 -    int bit_rate;
 +    int64_t bit_rate;
  
 +    /**
 +     * The number of bits per sample in the codedwords.
 +     *
 +     * This is basically the bitrate per sample. It is mandatory for a bunch of
 +     * formats to actually decode them. It's the number of bits for one sample in
 +     * the actual coded bitstream.
 +     *
 +     * This could be for example 4 for ADPCM
 +     * For PCM formats this matches bits_per_raw_sample
 +     * Can be 0
 +     */
      int bits_per_coded_sample;
  
      /**
 +     * This is the number of valid bits in each output sample. If the
 +     * sample format has more bits, the least significant bits are additional
 +     * padding bits, which are always 0. Use right shifts to reduce the sample
 +     * to its actual size. For example, audio formats with 24 bit samples will
 +     * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
 +     * To get the original sample use "(int32_t)sample >> 8"."
 +     *
 +     * For ADPCM this might be 12 or 16 or similar
 +     * Can be 0
 +     */
 +    int bits_per_raw_sample;
 +
 +    /**
       * Codec-specific bitstream restrictions that the stream conforms to.
       */
      int profile;
      enum AVChromaLocation              chroma_location;
  
      /**
 +     * Video only. Number of delayed frames.
 +     */
 +    int video_delay;
 +
 +    /**
       * Audio only. The channel layout bitmask. May be 0 if the channel layout is
       * unknown or unspecified, otherwise the number of bits set must be equal to
       * the channels field.
       * Corresponds to nBlockAlign in WAVEFORMATEX.
       */
      int      block_align;
 +    /**
 +     * Audio only. Audio frame size, if known. Required by some formats to be static.
 +     */
 +    int      frame_size;
  
      /**
       * Audio only. The amount of padding (in samples) inserted by the encoder at
       * audio without any trailing padding.
       */
      int trailing_padding;
 +    /**
 +     * Audio only. Number of samples to skip after a discontinuity.
 +     */
 +    int seek_preroll;
  } AVCodecParameters;
  
  /**
@@@ -4118,7 -3619,6 +4118,6 @@@ void avcodec_register_all(void)
   *              important mainly for encoders, e.g. libx264).
   *
   * @return An AVCodecContext filled with default values or NULL on failure.
-  * @see avcodec_get_context_defaults
   */
  AVCodecContext *avcodec_alloc_context3(const AVCodec *codec);
  
   */
  void avcodec_free_context(AVCodecContext **avctx);
  
+ #if FF_API_GET_CONTEXT_DEFAULTS
  /**
-  * Set the fields of the given AVCodecContext to default values corresponding
-  * to the given codec (defaults may be codec-dependent).
-  *
-  * Do not call this function if a non-NULL codec has been passed
-  * to avcodec_alloc_context3() that allocated this AVCodecContext.
-  * If codec is non-NULL, it is illegal to call avcodec_open2() with a
-  * different codec on this AVCodecContext.
+  * @deprecated This function should not be used, as closing and opening a codec
+  * context multiple time is not supported. A new codec context should be
+  * allocated for each new use.
   */
  int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec);
+ #endif
  
  /**
   * Get the AVClass for AVCodecContext. It can be used in combination with
@@@ -4149,29 -3647,13 +4146,29 @@@ const AVClass *avcodec_get_class(void)
  
  #if FF_API_COPY_CONTEXT
  /**
 + * 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
   * can use this AVCodecContext to decode/encode video/audio data.
   *
   * @param dest target codec context, should be initialized with
 - *             avcodec_alloc_context3(), but otherwise uninitialized
 + *             avcodec_alloc_context3(NULL), but otherwise uninitialized
   * @param src source codec context
   * @return AVERROR() on error (e.g. memory allocation error), 0 on success
   *
@@@ -4256,9 -3738,8 +4253,8 @@@ int avcodec_parameters_to_context(AVCod
   * @param avctx The context to initialize.
   * @param codec The codec to open this context for. If a non-NULL codec has been
   *              previously passed to avcodec_alloc_context3() or
-  *              avcodec_get_context_defaults3() for this context, then this
-  *              parameter MUST be either NULL or equal to the previously passed
-  *              codec.
+  *              for this context, then this parameter MUST be either NULL or
+  *              equal to the previously passed codec.
   * @param options A dictionary filled with AVCodecContext and codec-private options.
   *                On return this object will be filled with options that were not found.
   *
@@@ -4273,9 -3754,8 +4269,8 @@@ int avcodec_open2(AVCodecContext *avctx
   * (but not the AVCodecContext itself).
   *
   * Calling this function on an AVCodecContext that hasn't been opened will free
-  * the codec-specific data allocated in avcodec_alloc_context3() /
-  * avcodec_get_context_defaults3() with a non-NULL codec. Subsequent calls will
-  * do nothing.
+  * the codec-specific data allocated in avcodec_alloc_context3() with a non-NULL
+  * codec. Subsequent calls will do nothing.
   */
  int avcodec_close(AVCodecContext *avctx);
  
@@@ -4390,20 -3870,6 +4385,20 @@@ int av_packet_from_data(AVPacket *pkt, 
  attribute_deprecated
  int av_dup_packet(AVPacket *pkt);
  /**
 + * Copy packet, including contents
 + *
 + * @return 0 on success, negative AVERROR on fail
 + */
 +int av_copy_packet(AVPacket *dst, const AVPacket *src);
 +
 +/**
 + * Copy packet side data
 + *
 + * @return 0 on success, negative AVERROR on fail
 + */
 +int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
 +
 +/**
   * Free a packet.
   *
   * @deprecated Use av_packet_unref
@@@ -4462,31 -3928,6 +4457,31 @@@ 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);
 +
 +const char *av_packet_side_data_name(enum AVPacketSideDataType type);
 +
 +/**
 + * Pack a dictionary for use in side_data.
 + *
 + * @param dict The dictionary to pack.
 + * @param size pointer to store the size of the returned data
 + * @return pointer to data if successful, NULL otherwise
 + */
 +uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
 +/**
 + * Unpack a dictionary from side_data.
 + *
 + * @param data data from side_data
 + * @param size size of the data
 + * @param dict the metadata storage dictionary
 + * @return 0 on success, < 0 on failure
 + */
 +int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
 +
 +
  /**
   * Convenience function to free all the side data stored.
   * All the other fields stay untouched.
@@@ -4511,7 -3952,7 +4506,7 @@@ void av_packet_free_side_data(AVPacket 
   *
   * @return 0 on success, a negative AVERROR on error.
   */
 -int av_packet_ref(AVPacket *dst, AVPacket *src);
 +int av_packet_ref(AVPacket *dst, const AVPacket *src);
  
  /**
   * Wipe the packet.
@@@ -4626,28 -4067,6 +4621,28 @@@ void avcodec_align_dimensions2(AVCodecC
                                 int linesize_align[AV_NUM_DATA_POINTERS]);
  
  /**
 + * Converts AVChromaLocation to swscale x/y chroma position.
 + *
 + * The positions represent the chroma (0,0) position in a coordinates system
 + * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 + *
 + * @param xpos  horizontal chroma sample position
 + * @param ypos  vertical   chroma sample position
 + */
 +int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
 +
 +/**
 + * Converts swscale x/y chroma position to AVChromaLocation.
 + *
 + * The positions represent the chroma (0,0) position in a coordinates system
 + * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 + *
 + * @param xpos  horizontal chroma sample position
 + * @param ypos  vertical   chroma sample position
 + */
 +enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos);
 +
 +/**
   * Decode the audio frame of size avpkt->size from avpkt->data into frame.
   *
   * Some decoders may support multiple frames in a single AVPacket. Such
   */
  attribute_deprecated
  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.
  attribute_deprecated
  int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
 -                         AVPacket *avpkt);
 +                         const AVPacket *avpkt);
  
  /**
   * Decode a subtitle message.
   * and reusing a get_buffer written for video codecs would probably perform badly
   * due to a potentially very different allocation pattern.
   *
 + * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
 + * and output. This means that for some packets they will not immediately
 + * produce decoded output and need to be flushed at the end of decoding to get
 + * all the decoded data. Flushing is done by calling this function with packets
 + * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
 + * returning subtitles. It is safe to flush even those decoders that are not
 + * marked with CODEC_CAP_DELAY, then no subtitles will be returned.
 + *
   * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
   * before packets may be fed to the decoder.
   *
   * @param avctx the codec context
 - * @param[out] sub The AVSubtitle in which the decoded subtitle will be stored, must be
 -                   freed with avsubtitle_free if *got_sub_ptr is set.
 + * @param[out] sub The Preallocated AVSubtitle in which the decoded subtitle will be stored,
 + *                 must be freed with avsubtitle_free if *got_sub_ptr is set.
   * @param[in,out] got_sub_ptr Zero if no subtitle could be decompressed, otherwise, it is nonzero.
   * @param[in] avpkt The input AVPacket containing the input buffer.
   */
@@@ -4958,7 -4369,6 +4953,7 @@@ typedef struct AVCodecParserContext 
  #define PARSER_FLAG_ONCE                      0x0002
  /// Set if the parser has a valid file offset
  #define PARSER_FLAG_FETCHED_OFFSET            0x0004
 +#define PARSER_FLAG_USE_CODEC_TS              0x1000
  
      int64_t offset;      ///< byte offset from starting packet start
      int64_t cur_frame_end[AV_PARSER_PTS_NB];
@@@ -5144,7 -4554,7 +5139,7 @@@ int av_parser_parse2(AVCodecParserConte
  
  /**
   * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 - * @deprecated use AVBitstreamFilter
 + * @deprecated use AVBitStreamFilter
   */
  int av_parser_change(AVCodecParserContext *s,
                       AVCodecContext *avctx,
@@@ -5191,12 -4601,11 +5186,12 @@@ AVCodec *avcodec_find_encoder_by_name(c
   *                  The user can supply an output buffer by setting
   *                  avpkt->data and avpkt->size prior to calling the
   *                  function, but if the size of the user-provided data is not
 - *                  large enough, encoding will fail. All other AVPacket fields
 - *                  will be reset by the encoder using av_init_packet(). If
 - *                  avpkt->data is NULL, the encoder will allocate it.
 - *                  The encoder will set avpkt->size to the size of the
 - *                  output packet.
 + *                  large enough, encoding will fail. If avpkt->data and
 + *                  avpkt->size are set, avpkt->destruct must also be set. All
 + *                  other AVPacket fields will be reset by the encoder using
 + *                  av_init_packet(). If avpkt->data is NULL, the encoder will
 + *                  allocate it. The encoder will set avpkt->size to the size
 + *                  of the output packet.
   *
   *                  If this function fails or produces no output, avpkt will be
   *                  freed using av_packet_unref().
@@@ -5269,103 -4678,6 +5264,103 @@@ int avcodec_encode_subtitle(AVCodecCont
   * @}
   */
  
 +#if FF_API_AVCODEC_RESAMPLE
 +/**
 + * @defgroup lavc_resample Audio resampling
 + * @ingroup libavc
 + * @deprecated use libswresample instead
 + *
 + * @{
 + */
 +struct ReSampleContext;
 +struct AVResampleContext;
 +
 +typedef struct ReSampleContext ReSampleContext;
 +
 +/**
 + *  Initialize audio resampling context.
 + *
 + * @param output_channels  number of output channels
 + * @param input_channels   number of input channels
 + * @param output_rate      output sample rate
 + * @param input_rate       input sample rate
 + * @param sample_fmt_out   requested output sample format
 + * @param sample_fmt_in    input sample format
 + * @param filter_length    length of each FIR filter in the filterbank relative to the cutoff frequency
 + * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
 + * @param linear           if 1 then the used FIR filter will be linearly interpolated
 +                           between the 2 closest, if 0 the closest will be used
 + * @param cutoff           cutoff frequency, 1.0 corresponds to half the output sampling rate
 + * @return allocated ReSampleContext, NULL if error occurred
 + */
 +attribute_deprecated
 +ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
 +                                        int output_rate, int input_rate,
 +                                        enum AVSampleFormat sample_fmt_out,
 +                                        enum AVSampleFormat sample_fmt_in,
 +                                        int filter_length, int log2_phase_count,
 +                                        int linear, double cutoff);
 +
 +attribute_deprecated
 +int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
 +
 +/**
 + * Free resample context.
 + *
 + * @param s a non-NULL pointer to a resample context previously
 + *          created with av_audio_resample_init()
 + */
 +attribute_deprecated
 +void audio_resample_close(ReSampleContext *s);
 +
 +
 +/**
 + * Initialize an audio resampler.
 + * Note, if either rate is not an integer then simply scale both rates up so they are.
 + * @param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
 + * @param log2_phase_count log2 of the number of entries in the polyphase filterbank
 + * @param linear If 1 then the used FIR filter will be linearly interpolated
 +                 between the 2 closest, if 0 the closest will be used
 + * @param cutoff cutoff frequency, 1.0 corresponds to half the output sampling rate
 + */
 +attribute_deprecated
 +struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff);
 +
 +/**
 + * Resample an array of samples using a previously configured context.
 + * @param src an array of unconsumed samples
 + * @param consumed the number of samples of src which have been consumed are returned here
 + * @param src_size the number of unconsumed samples available
 + * @param dst_size the amount of space in samples available in dst
 + * @param update_ctx If this is 0 then the context will not be modified, that way several channels can be resampled with the same context.
 + * @return the number of samples written in dst or -1 if an error occurred
 + */
 +attribute_deprecated
 +int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx);
 +
 +
 +/**
 + * Compensate samplerate/timestamp drift. The compensation is done by changing
 + * the resampler parameters, so no audible clicks or similar distortions occur
 + * @param compensation_distance distance in output samples over which the compensation should be performed
 + * @param sample_delta number of output samples which should be output less
 + *
 + * example: av_resample_compensate(c, 10, 500)
 + * here instead of 510 samples only 500 samples would be output
 + *
 + * note, due to rounding the actual compensation might be slightly different,
 + * especially if the compensation_distance is large and the in_rate used during init is small
 + */
 +attribute_deprecated
 +void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance);
 +attribute_deprecated
 +void av_resample_close(struct AVResampleContext *c);
 +
 +/**
 + * @}
 + */
 +#endif
 +
  #if FF_API_AVPICTURE
  /**
   * @addtogroup lavc_picture
@@@ -5388,14 -4700,14 +5383,14 @@@ void avpicture_free(AVPicture *picture)
   * @deprecated use av_image_fill_arrays() instead.
   */
  attribute_deprecated
 -int avpicture_fill(AVPicture *picture, uint8_t *ptr,
 +int avpicture_fill(AVPicture *picture, const uint8_t *ptr,
                     enum AVPixelFormat pix_fmt, int width, int height);
  
  /**
   * @deprecated use av_image_copy_to_buffer() instead.
   */
  attribute_deprecated
 -int avpicture_layout(const AVPicturesrc, enum AVPixelFormat pix_fmt,
 +int avpicture_layout(const AVPicture *src, enum AVPixelFormat pix_fmt,
                       int width, int height,
                       unsigned char *dest, int dest_size);
  
@@@ -5448,21 -4760,10 +5443,21 @@@ int av_picture_pad(AVPicture *dst, cons
   */
  
  /**
 - * @deprecated Use av_pix_fmt_get_chroma_sub_sample
 + * Utility function to access log2_chroma_w log2_chroma_h from
 + * the pixel format AVPixFmtDescriptor.
 + *
 + * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample
 + * for one that returns a failure code and continues in case of invalid
 + * pix_fmts.
 + *
 + * @param[in]  pix_fmt the pixel format
 + * @param[out] h_shift store log2_chroma_w
 + * @param[out] v_shift store log2_chroma_h
 + *
 + * @see av_pix_fmt_get_chroma_sub_sample
   */
  
 -void attribute_deprecated avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
 +void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
  
  /**
   * Return a value representing the fourCC code associated to the
   */
  unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt);
  
 -#define FF_LOSS_RESOLUTION  0x0001 /**< loss due to resolution change */
 -#define FF_LOSS_DEPTH       0x0002 /**< loss due to color depth change */
 -#define FF_LOSS_COLORSPACE  0x0004 /**< loss due to color space conversion */
 -#define FF_LOSS_ALPHA       0x0008 /**< loss of alpha bits */
 -#define FF_LOSS_COLORQUANT  0x0010 /**< loss due to color quantization */
 -#define FF_LOSS_CHROMA      0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
 -
 -/**
 - * Compute what kind of losses will occur when converting from one specific
 - * pixel format to another.
 - * 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. These losses can involve loss of chroma, but also loss of
 - * resolution, loss of color depth, loss due to the color space conversion, loss
 - * of the alpha bits or loss due to color quantization.
 - * avcodec_get_fix_fmt_loss() informs you about the various types of losses
 - * which will occur when converting from one pixel format to another.
 - *
 - * @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.
 +/**
 + * @deprecated see av_get_pix_fmt_loss()
   */
  int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
                               int has_alpha);
   * format.  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() searches which of
 + * some formats to other formats. avcodec_find_best_pix_fmt_of_2() searches which of
   * the given pixel formats should be used to suffer the least amount of loss.
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_list parameter.
   * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
   * @return The best pixel format to convert to or -1 if none was found.
   */
 -enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(const enum AVPixelFormat *pix_fmt_list,
 +                                            enum AVPixelFormat src_pix_fmt,
 +                                            int has_alpha, int *loss_ptr);
 +
 +/**
 + * @deprecated see av_find_best_pix_fmt_of_2()
 + */
 +enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
 +attribute_deprecated
 +#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
 +enum AVPixelFormat avcodec_find_best_pix_fmt2(const enum AVPixelFormat *pix_fmt_list,
                                                enum AVPixelFormat src_pix_fmt,
                                                int has_alpha, int *loss_ptr);
 +#else
 +enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
 +                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +#endif
 +
  
  enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  
@@@ -5569,12 -4874,7 +5564,12 @@@ int avcodec_default_execute2(AVCodecCon
  //FIXME func typedef
  
  /**
 - * Fill audio frame data and linesize.
 + * Fill AVFrame audio data and linesize pointers.
 + *
 + * The buffer buf must be a preallocated buffer with a size big enough
 + * to contain the specified samples amount. The filled AVFrame data
 + * pointers will point to this buffer.
 + *
   * AVFrame extended_data channel pointers are allocated if necessary for
   * planar audio.
   *
   * @param buf         buffer to use for frame data
   * @param buf_size    size of buffer
   * @param align       plane size sample alignment (0 = default)
 - * @return            0 on success, negative error code on failure
 + * @return            >=0 on success, negative error code on failure
 + * @todo return the size in bytes required to store the samples in
 + * case of success, at the next libavutil bump
   */
  int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
                               enum AVSampleFormat sample_fmt, const uint8_t *buf,
@@@ -5615,14 -4913,6 +5610,14 @@@ void avcodec_flush_buffers(AVCodecConte
  int av_get_bits_per_sample(enum AVCodecID 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  AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
 + */
 +enum AVCodecID 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.
@@@ -5654,11 -4944,6 +5649,11 @@@ typedef struct AVBitStreamFilterContex
      struct AVBitStreamFilter *filter;
      AVCodecParserContext *parser;
      struct AVBitStreamFilterContext *next;
 +    /**
 +     * Internal default arguments, used if NULL is passed to av_bitstream_filter_filter().
 +     * Not for access by library users.
 +     */
 +    char *args;
  } AVBitStreamFilterContext;
  #endif
  
@@@ -5757,82 -5042,20 +5752,82 @@@ typedef struct AVBitStreamFilter 
  
  #if FF_API_OLD_BSF
  /**
 - * @deprecated the old bitstream filtering API (using AVBitStreamFilterContext)
 - * is deprecated. Use the new bitstream filtering API (using AVBSFContext).
 + * Register a bitstream filter.
 + *
 + * The filter will be accessible to the application code through
 + * av_bitstream_filter_next() or can be directly initialized with
 + * av_bitstream_filter_init().
 + *
 + * @see avcodec_register_all()
   */
  attribute_deprecated
  void av_register_bitstream_filter(AVBitStreamFilter *bsf);
 +
 +/**
 + * Create and initialize a bitstream filter context given a bitstream
 + * filter name.
 + *
 + * The returned context must be freed with av_bitstream_filter_close().
 + *
 + * @param name    the name of the bitstream filter
 + * @return a bitstream filter context if a matching filter was found
 + * and successfully initialized, NULL otherwise
 + */
  attribute_deprecated
  AVBitStreamFilterContext *av_bitstream_filter_init(const char *name);
 +
 +/**
 + * Filter bitstream.
 + *
 + * This function filters the buffer buf with size buf_size, and places the
 + * filtered buffer in the buffer pointed to by poutbuf.
 + *
 + * The output buffer must be freed by the caller.
 + *
 + * @param bsfc            bitstream filter context created by av_bitstream_filter_init()
 + * @param avctx           AVCodecContext accessed by the filter, may be NULL.
 + *                        If specified, this must point to the encoder context of the
 + *                        output stream the packet is sent to.
 + * @param args            arguments which specify the filter configuration, may be NULL
 + * @param poutbuf         pointer which is updated to point to the filtered buffer
 + * @param poutbuf_size    pointer which is updated to the filtered buffer size in bytes
 + * @param buf             buffer containing the data to filter
 + * @param buf_size        size in bytes of buf
 + * @param keyframe        set to non-zero if the buffer to filter corresponds to a key-frame packet data
 + * @return >= 0 in case of success, or a negative error code in case of failure
 + *
 + * If the return value is positive, an output buffer is allocated and
 + * is available in *poutbuf, and is distinct from the input buffer.
 + *
 + * If the return value is 0, the output buffer is not allocated and
 + * should be considered identical to the input buffer, or in case
 + * *poutbuf was set it points to the input buffer (not necessarily to
 + * its starting address). A special case is if *poutbuf was set to NULL and
 + * *poutbuf_size was set to 0, which indicates the packet should be dropped.
 + */
  attribute_deprecated
  int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
                                 AVCodecContext *avctx, const char *args,
                                 uint8_t **poutbuf, int *poutbuf_size,
                                 const uint8_t *buf, int buf_size, int keyframe);
 +
 +/**
 + * Release bitstream filter context.
 + *
 + * @param bsf the bitstream filter context created with
 + * av_bitstream_filter_init(), can be NULL
 + */
  attribute_deprecated
  void av_bitstream_filter_close(AVBitStreamFilterContext *bsf);
 +
 +/**
 + * If f is NULL, return the first registered bitstream filter,
 + * if f is non-NULL, return the next registered bitstream filter
 + * after f, or NULL if f is the last one.
 + *
 + * This function can be used to iterate over all registered bitstream
 + * filters.
 + */
  attribute_deprecated
  AVBitStreamFilter *av_bitstream_filter_next(const AVBitStreamFilter *f);
  #endif
@@@ -5934,21 -5157,14 +5929,21 @@@ const AVClass *av_bsf_get_class(void)
  /* memory */
  
  /**
 - * Allocate a buffer with padding, reusing the given one if large enough.
 - *
   * Same behaviour av_fast_malloc but the buffer has additional
 - * AV_INPUT_PADDING_SIZE at the end which will always memset to 0.
 + * AV_INPUT_BUFFER_PADDING_SIZE at the end which 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);
  
  /**
 + * Same behaviour av_fast_padded_malloc except that buffer will always
 + * be 0-initialized after call.
 + */
 +void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size);
 +
 +/**
   * Encode extradata length to a buffer. Used by xiph codecs.
   *
   * @param s buffer to write to; must be at least (v/255+1) bytes long
@@@ -5960,7 -5176,7 +5955,7 @@@ unsigned int av_xiphlacing(unsigned cha
  #if FF_API_MISSING_SAMPLE
  /**
   * 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
@@@ -5976,7 -5192,7 +5971,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
@@@ -6041,12 -5257,6 +6036,12 @@@ int av_lockmgr_register(int (*cb)(void 
  enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
  
  /**
 + * Get the name of a codec.
 + * @return  a static string identifying the codec; never NULL
 + */
 +const char *avcodec_get_name(enum AVCodecID 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/options.c
@@@ -2,20 -2,20 +2,20 @@@
   * Copyright (c) 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * 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
   */
  
@@@ -70,13 -70,6 +70,13 @@@ static const AVClass *codec_child_class
      return NULL;
  }
  
 +static AVClassCategory get_category(void *ptr)
 +{
 +    AVCodecContext* avctx = ptr;
 +    if(avctx->codec && avctx->codec->decode) return AV_CLASS_CATEGORY_DECODER;
 +    else                                     return AV_CLASS_CATEGORY_ENCODER;
 +}
 +
  static const AVClass av_codec_context_class = {
      .class_name              = "AVCodecContext",
      .item_name               = context_to_name,
      .log_level_offset_offset = offsetof(AVCodecContext, log_level_offset),
      .child_next              = codec_child_next,
      .child_class_next        = codec_child_class_next,
 +    .category                = AV_CLASS_CATEGORY_ENCODER,
 +    .get_category            = get_category,
  };
  
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
static int init_context_defaults(AVCodecContext *s, const AVCodec *codec)
  {
 +    int flags=0;
      memset(s, 0, sizeof(AVCodecContext));
  
      s->av_class = &av_codec_context_class;
  
      s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
 -    s->codec      = codec;
 -    av_opt_set_defaults(s);
 +    if (codec) {
 +        s->codec = codec;
 +        s->codec_id = codec->id;
 +    }
 +
 +    if(s->codec_type == AVMEDIA_TYPE_AUDIO)
 +        flags= AV_OPT_FLAG_AUDIO_PARAM;
 +    else if(s->codec_type == AVMEDIA_TYPE_VIDEO)
 +        flags= AV_OPT_FLAG_VIDEO_PARAM;
 +    else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE)
 +        flags= AV_OPT_FLAG_SUBTITLE_PARAM;
 +    av_opt_set_defaults2(s, flags, flags);
  
      s->time_base           = (AVRational){0,1};
      s->framerate           = (AVRational){ 0, 1 };
 +    s->pkt_timebase        = (AVRational){ 0, 1 };
      s->get_buffer2         = avcodec_default_get_buffer2;
      s->get_format          = avcodec_default_get_format;
      s->execute             = avcodec_default_execute;
      return 0;
  }
  
+ #if FF_API_GET_CONTEXT_DEFAULTS
+ int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
+ {
+     return init_context_defaults(s, codec);
+ }
+ #endif
  AVCodecContext *avcodec_alloc_context3(const AVCodec *codec)
  {
      AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
      if (!avctx)
          return NULL;
  
-     if(avcodec_get_context_defaults3(avctx, codec) < 0){
+     if (init_context_defaults(avctx, codec) < 0) {
          av_free(avctx);
          return NULL;
      }
@@@ -172,9 -158,6 +179,9 @@@ void avcodec_free_context(AVCodecContex
  
      av_freep(&avctx->extradata);
      av_freep(&avctx->subtitle_header);
 +    av_freep(&avctx->intra_matrix);
 +    av_freep(&avctx->inter_matrix);
 +    av_freep(&avctx->rc_override);
  
      av_freep(pavctx);
  }
@@@ -191,34 -174,15 +198,34 @@@ int avcodec_copy_context(AVCodecContex
                 src, dest);
          return AVERROR(EINVAL);
      }
 +
 +    av_opt_free(dest);
 +    av_freep(&dest->rc_override);
 +    av_freep(&dest->intra_matrix);
 +    av_freep(&dest->inter_matrix);
 +    av_freep(&dest->extradata);
 +    av_freep(&dest->subtitle_header);
 +
      memcpy(dest, src, sizeof(*dest));
 +    av_opt_copy(dest, src);
  
      dest->priv_data       = orig_priv_data;
      dest->codec           = orig_codec;
  
 +    if (orig_priv_data && src->codec && src->codec->priv_class &&
 +        dest->codec && dest->codec->priv_class)
 +        av_opt_copy(orig_priv_data, src->priv_data);
 +
 +
      /* set values specific to opened codecs back to their default state */
      dest->slice_offset    = NULL;
      dest->hwaccel         = NULL;
      dest->internal        = NULL;
 +#if FF_API_CODED_FRAME
 +FF_DISABLE_DEPRECATION_WARNINGS
 +    dest->coded_frame     = NULL;
 +FF_ENABLE_DEPRECATION_WARNINGS
 +#endif
  
      /* reallocate values that should be allocated separately */
      dest->extradata       = NULL;
      dest->inter_matrix    = NULL;
      dest->rc_override     = NULL;
      dest->subtitle_header = NULL;
 -#if FF_API_MPV_OPT
 -    FF_DISABLE_DEPRECATION_WARNINGS
 -    dest->rc_eq           = NULL;
 -    if (src->rc_eq) {
 -        dest->rc_eq = av_strdup(src->rc_eq);
 -        if (!dest->rc_eq)
 -            return AVERROR(ENOMEM);
 -    }
 -    FF_ENABLE_DEPRECATION_WARNINGS
 -#endif
  
  #define alloc_and_copy_or_fail(obj, size, pad) \
      if (src->obj && size > 0) { \
      }
      alloc_and_copy_or_fail(extradata,    src->extradata_size,
                             AV_INPUT_BUFFER_PADDING_SIZE);
 +    dest->extradata_size  = src->extradata_size;
      alloc_and_copy_or_fail(intra_matrix, 64 * sizeof(int16_t), 0);
      alloc_and_copy_or_fail(inter_matrix, 64 * sizeof(int16_t), 0);
      alloc_and_copy_or_fail(rc_override,  src->rc_override_count * sizeof(*src->rc_override), 0);
 -    alloc_and_copy_or_fail(subtitle_header, src->subtitle_header_size, 0);
 -    dest->subtitle_header_size = src->subtitle_header_size;
 +    alloc_and_copy_or_fail(subtitle_header, src->subtitle_header_size, 1);
 +    av_assert0(dest->subtitle_header_size == src->subtitle_header_size);
  #undef alloc_and_copy_or_fail
  
      return 0;
@@@ -253,10 -226,11 +260,10 @@@ fail
      av_freep(&dest->intra_matrix);
      av_freep(&dest->inter_matrix);
      av_freep(&dest->extradata);
 -#if FF_API_MPV_OPT
 -    FF_DISABLE_DEPRECATION_WARNINGS
 -    av_freep(&dest->rc_eq);
 -    FF_ENABLE_DEPRECATION_WARNINGS
 -#endif
 +    av_freep(&dest->subtitle_header);
 +    dest->subtitle_header_size = 0;
 +    dest->extradata_size = 0;
 +    av_opt_free(dest);
      return AVERROR(ENOMEM);
  }
  #endif
@@@ -265,224 -239,3 +272,224 @@@ const AVClass *avcodec_get_class(void
  {
      return &av_codec_context_class;
  }
 +
 +#define FOFFSET(x) offsetof(AVFrame,x)
 +
 +static const AVOption frame_options[]={
 +{"best_effort_timestamp", "", FOFFSET(best_effort_timestamp), AV_OPT_TYPE_INT64, {.i64 = AV_NOPTS_VALUE }, INT64_MIN, INT64_MAX, 0},
 +{"pkt_pos", "", FOFFSET(pkt_pos), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
 +{"pkt_size", "", FOFFSET(pkt_size), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
 +{"sample_aspect_ratio", "", FOFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
 +{"width", "", FOFFSET(width), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"height", "", FOFFSET(height), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"format", "", FOFFSET(format), AV_OPT_TYPE_INT, {.i64 = -1 }, 0, INT_MAX, 0},
 +{"channel_layout", "", FOFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, 0},
 +{"sample_rate", "", FOFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{NULL},
 +};
 +
 +static const AVClass av_frame_class = {
 +    .class_name              = "AVFrame",
 +    .item_name               = NULL,
 +    .option                  = frame_options,
 +    .version                 = LIBAVUTIL_VERSION_INT,
 +};
 +
 +const AVClass *avcodec_get_frame_class(void)
 +{
 +    return &av_frame_class;
 +}
 +
 +#define SROFFSET(x) offsetof(AVSubtitleRect,x)
 +
 +static const AVOption subtitle_rect_options[]={
 +{"x", "", SROFFSET(x), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"y", "", SROFFSET(y), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"w", "", SROFFSET(w), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"h", "", SROFFSET(h), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"type", "", SROFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
 +{"flags", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0, "flags"},
 +{"forced", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0},
 +{NULL},
 +};
 +
 +static const AVClass av_subtitle_rect_class = {
 +    .class_name             = "AVSubtitleRect",
 +    .item_name              = NULL,
 +    .option                 = subtitle_rect_options,
 +    .version                = LIBAVUTIL_VERSION_INT,
 +};
 +
 +const AVClass *avcodec_get_subtitle_rect_class(void)
 +{
 +    return &av_subtitle_rect_class;
 +}
 +
 +#ifdef TEST
 +static int dummy_init(AVCodecContext *ctx)
 +{
 +    //TODO: this code should set every possible pointer that could be set by codec and is not an option;
 +    ctx->extradata_size = 8;
 +    ctx->extradata = av_malloc(ctx->extradata_size);
 +    return 0;
 +}
 +
 +static int dummy_close(AVCodecContext *ctx)
 +{
 +    av_freep(&ctx->extradata);
 +    ctx->extradata_size = 0;
 +    return 0;
 +}
 +
 +static int dummy_encode(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
 +{
 +    return AVERROR(ENOSYS);
 +}
 +
 +typedef struct Dummy12Context {
 +    AVClass  *av_class;
 +    int      num;
 +    char*    str;
 +} Dummy12Context;
 +
 +typedef struct Dummy3Context {
 +    void     *fake_av_class;
 +    int      num;
 +    char*    str;
 +} Dummy3Context;
 +
 +#define OFFSET(x) offsetof(Dummy12Context, x)
 +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption dummy_options[] = {
 +    { "str", "set str", OFFSET(str), AV_OPT_TYPE_STRING, { .str = "i'm src default value" }, 0, 0, VE},
 +    { "num", "set num", OFFSET(num), AV_OPT_TYPE_INT,    { .i64 = 1500100900 },    0, INT_MAX, VE},
 +    { NULL },
 +};
 +
 +static const AVClass dummy_v1_class = {
 +    .class_name = "dummy_v1_class",
 +    .item_name  = av_default_item_name,
 +    .option     = dummy_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +static const AVClass dummy_v2_class = {
 +    .class_name = "dummy_v2_class",
 +    .item_name  = av_default_item_name,
 +    .option     = dummy_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +/* codec with options */
 +static AVCodec dummy_v1_encoder = {
 +    .name             = "dummy_v1_codec",
 +    .type             = AVMEDIA_TYPE_VIDEO,
 +    .id               = AV_CODEC_ID_NONE - 1,
 +    .encode2          = dummy_encode,
 +    .init             = dummy_init,
 +    .close            = dummy_close,
 +    .priv_class       = &dummy_v1_class,
 +    .priv_data_size   = sizeof(Dummy12Context),
 +};
 +
 +/* codec with options, different class */
 +static AVCodec dummy_v2_encoder = {
 +    .name             = "dummy_v2_codec",
 +    .type             = AVMEDIA_TYPE_VIDEO,
 +    .id               = AV_CODEC_ID_NONE - 2,
 +    .encode2          = dummy_encode,
 +    .init             = dummy_init,
 +    .close            = dummy_close,
 +    .priv_class       = &dummy_v2_class,
 +    .priv_data_size   = sizeof(Dummy12Context),
 +};
 +
 +/* codec with priv data, but no class */
 +static AVCodec dummy_v3_encoder = {
 +    .name             = "dummy_v3_codec",
 +    .type             = AVMEDIA_TYPE_VIDEO,
 +    .id               = AV_CODEC_ID_NONE - 3,
 +    .encode2          = dummy_encode,
 +    .init             = dummy_init,
 +    .close            = dummy_close,
 +    .priv_data_size   = sizeof(Dummy3Context),
 +};
 +
 +/* codec without priv data */
 +static AVCodec dummy_v4_encoder = {
 +    .name             = "dummy_v4_codec",
 +    .type             = AVMEDIA_TYPE_VIDEO,
 +    .id               = AV_CODEC_ID_NONE - 4,
 +    .encode2          = dummy_encode,
 +    .init             = dummy_init,
 +    .close            = dummy_close,
 +};
 +
 +static void test_copy_print_codec(const AVCodecContext *ctx)
 +{
 +    printf("%-14s: %dx%d prv: %s",
 +           ctx->codec ? ctx->codec->name : "NULL",
 +           ctx->width, ctx->height,
 +           ctx->priv_data ? "set" : "null");
 +    if (ctx->codec && ctx->codec->priv_class && ctx->codec->priv_data_size) {
 +        int64_t i64;
 +        char *str = NULL;
 +        av_opt_get_int(ctx->priv_data, "num", 0, &i64);
 +        av_opt_get(ctx->priv_data, "str", 0, (uint8_t**)&str);
 +        printf(" opts: %"PRId64" %s", i64, str);
 +        av_free(str);
 +    }
 +    printf("\n");
 +}
 +
 +static void test_copy(const AVCodec *c1, const AVCodec *c2)
 +{
 +    AVCodecContext *ctx1, *ctx2;
 +    printf("%s -> %s\nclosed:\n", c1 ? c1->name : "NULL", c2 ? c2->name : "NULL");
 +    ctx1 = avcodec_alloc_context3(c1);
 +    ctx2 = avcodec_alloc_context3(c2);
 +    ctx1->width = ctx1->height = 128;
 +    if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
 +        av_opt_set(ctx2->priv_data, "num", "667", 0);
 +        av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
 +    }
 +    avcodec_copy_context(ctx2, ctx1);
 +    test_copy_print_codec(ctx1);
 +    test_copy_print_codec(ctx2);
 +    if (ctx1->codec) {
 +        printf("opened:\n");
 +        avcodec_open2(ctx1, ctx1->codec, NULL);
 +        if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
 +            av_opt_set(ctx2->priv_data, "num", "667", 0);
 +            av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
 +        }
 +        avcodec_copy_context(ctx2, ctx1);
 +        test_copy_print_codec(ctx1);
 +        test_copy_print_codec(ctx2);
 +        avcodec_close(ctx1);
 +    }
 +    avcodec_free_context(&ctx1);
 +    avcodec_free_context(&ctx2);
 +}
 +
 +int main(void)
 +{
 +    AVCodec *dummy_codec[] = {
 +        &dummy_v1_encoder,
 +        &dummy_v2_encoder,
 +        &dummy_v3_encoder,
 +        &dummy_v4_encoder,
 +        NULL,
 +    };
 +    int i, j;
 +
 +    for (i = 0; dummy_codec[i]; i++)
 +        avcodec_register(dummy_codec[i]);
 +
 +    printf("testing avcodec_copy_context()\n");
 +    for (i = 0; i < FF_ARRAY_ELEMS(dummy_codec); i++)
 +        for (j = 0; j < FF_ARRAY_ELEMS(dummy_codec); j++)
 +            test_copy(dummy_codec[i], dummy_codec[j]);
 +    return 0;
 +}
 +#endif
diff --combined libavcodec/version.h
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * 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
   */
  
@@@ -27,9 -27,9 +27,9 @@@
  
  #include "libavutil/version.h"
  
 -#define LIBAVCODEC_VERSION_MAJOR 57
 -#define LIBAVCODEC_VERSION_MINOR 19
 -#define LIBAVCODEC_VERSION_MICRO  0
 +#define LIBAVCODEC_VERSION_MAJOR  57
 +#define LIBAVCODEC_VERSION_MINOR  48
 +#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
   * FF_API_* defines may be placed below to indicate public API that will be
   * dropped at a future version bump. The defines themselves are not part of
   * the public API and may change, break or disappear at any time.
 + *
 + * @note, when bumping the major version it is recommended to manually
 + * disable each FF_API_* in its own commit instead of disabling them all
 + * at once through the bump. This improves the git bisect-ability of the change.
   */
  
 +#ifndef FF_API_VIMA_DECODER
 +#define FF_API_VIMA_DECODER     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
 +#ifndef FF_API_AUDIO_CONVERT
 +#define FF_API_AUDIO_CONVERT     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
 +#ifndef FF_API_AVCODEC_RESAMPLE
 +#define FF_API_AVCODEC_RESAMPLE  FF_API_AUDIO_CONVERT
 +#endif
  #ifndef FF_API_GETCHROMA
  #define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_MAX_BFRAMES
  #define FF_API_MAX_BFRAMES       (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 -#ifndef FF_API_FAST_MALLOC
 -#define FF_API_FAST_MALLOC       (LIBAVCODEC_VERSION_MAJOR < 58)
 -#endif
  #ifndef FF_API_NEG_LINESIZES
  #define FF_API_NEG_LINESIZES     (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_AFD
  #define FF_API_AFD               (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_VISMV
 +/* XXX: don't forget to drop the -vismv documentation */
 +#define FF_API_VISMV             (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_AUDIOENC_DELAY
  #define FF_API_AUDIOENC_DELAY    (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_VAAPI_CONTEXT
 +#define FF_API_VAAPI_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_AVCTX_TIMEBASE
  #define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_STAT_BITS
  #define FF_API_STAT_BITS         (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 -#ifndef FF_API_NVENC_OLD_NAME
 -#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 -#endif
  #ifndef FF_API_PRIVATE_OPT
  #define FF_API_PRIVATE_OPT      (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 +#ifndef FF_API_ASS_TIMING
 +#define FF_API_ASS_TIMING       (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
  #ifndef FF_API_OLD_BSF
  #define FF_API_OLD_BSF          (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_COPY_CONTEXT
  #define FF_API_COPY_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
+ #ifndef FF_API_GET_CONTEXT_DEFAULTS
+ #define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
+ #endif
 +#ifndef FF_API_NVENC_OLD_NAME
 +#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
  
  #endif /* AVCODEC_VERSION_H */