Merge commit '14e7e19a90e9b45db7adeb4d40e7f16aa7404f28'
authorClément Bœsch <u@pkh.me>
Thu, 23 Mar 2017 15:03:43 +0000 (16:03 +0100)
committerClément Bœsch <u@pkh.me>
Thu, 23 Mar 2017 15:03:43 +0000 (16:03 +0100)
* commit '14e7e19a90e9b45db7adeb4d40e7f16aa7404f28':
  lavc: bsf: Document input/output codecparam alloc/init process

Merged-by: Clément Bœsch <u@pkh.me>
1  2 
libavcodec/avcodec.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
 + * @defgroup libavc libavcodec
 + * Encoding/Decoding Library
 + *
   * @{
   *
   * @defgroup lavc_decoding Decoding
@@@ -89,7 -91,7 +89,7 @@@
   * - Send valid input:
   *   - For decoding, call avcodec_send_packet() to give the decoder raw
   *     compressed data in an AVPacket.
 - *   - For encoding, call avcodec_send_frame() to give the decoder an AVFrame
 + *   - For encoding, call avcodec_send_frame() to give the encoder an AVFrame
   *     containing uncompressed audio or video.
   *   In both cases, it is recommended that AVPackets and AVFrames are
   *   refcounted, or libavcodec might have to copy the input data. (libavformat
   * are filled. This situation is handled transparently if you follow the steps
   * outlined above.
   *
 + * In theory, sending input can result in EAGAIN - this should happen only if
 + * not all output was received. You can use this to structure alternative decode
 + * or encode loops other than the one suggested above. For example, you could
 + * try sending new input on each iteration, and try to receive output if that
 + * returns EAGAIN.
 + *
   * End of stream situations. These require "flushing" (aka draining) the codec,
   * as the codec might buffer multiple frames or packets internally for
   * performance or out of necessity (consider B-frames).
   *
   * Not all codecs will follow a rigid and predictable dataflow; the only
   * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on
 - * one end implies that a receive/send call on the other end will succeed. In
 - * general, no codec will permit unlimited buffering of input or output.
 + * one end implies that a receive/send call on the other end will succeed, or
 + * at least will not fail with AVERROR(EAGAIN). In general, no codec will
 + * permit unlimited buffering of input or output.
   *
   * This API replaces the following legacy functions:
   * - avcodec_decode_video2() and avcodec_decode_audio4():
   *   Unlike with the old video decoding API, multiple frames might result from
   *   a packet. For audio, splitting the input packet into frames by partially
   *   decoding packets becomes transparent to the API user. You never need to
 - *   feed an AVPacket to the API twice.
 + *   feed an AVPacket to the API twice (unless it is rejected with EAGAIN - then
 + *   no data was read from the packet).
   *   Additionally, sending a flush/draining packet is required only once.
   * - avcodec_encode_video2()/avcodec_encode_audio2():
   *   Use avcodec_send_frame() to feed input to the encoder, then use
   * - 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.
 + * an error when calling it. All codecs support the new API.
 + *
 + * A codec is not allowed to return EAGAIN for both sending and receiving. This
 + * would be an invalid state, which could put the codec user into an endless
 + * loop. The API has no concept of time either: it cannot happen that trying to
 + * do avcodec_send_packet() results in EAGAIN, but a repeated call 1 second
 + * later accepts the packet (with no other receive/flush API calls involved).
 + * The API is a strict state machine, and the passage of time is not supposed
 + * to influence it. Some timing-dependent behavior might still be deemed
 + * acceptable in certain cases. But it must never result in both send/receive
 + * returning EAGAIN at the same time at any point. It must also absolutely be
 + * avoided that the current state is "unstable" and can "flip-flop" between
 + * the send/receive APIs allowing progress. For example, it's not allowed that
 + * the codec randomly decides that it actually wants to consume a packet now
 + * instead of returning a frame, after it just returned EAGAIN on an
 + * avcodec_send_packet() call.
   * @}
   */
  
   * 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.
@@@ -354,7 -333,7 +354,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_DXV,
      AV_CODEC_ID_SCREENPRESSO,
      AV_CODEC_ID_RSCC,
 -    AV_CODEC_ID_MAGICYUV,
 +
 +    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,
 +    AV_CODEC_ID_PSD,
 +    AV_CODEC_ID_PIXLET,
 +    AV_CODEC_ID_SPEEDHQ,
 +    AV_CODEC_ID_FMVC,
 +    AV_CODEC_ID_SCPR,
 +    AV_CODEC_ID_CLEARVIDEO,
 +    AV_CODEC_ID_XPM,
      AV_CODEC_ID_AV1,
  
      /* various PCM "codecs" */
      AV_CODEC_ID_PCM_S32LE_PLANAR,
      AV_CODEC_ID_PCM_S16BE_PLANAR,
  
 +    AV_CODEC_ID_PCM_S64LE = 0x10800,
 +    AV_CODEC_ID_PCM_S64BE,
 +    AV_CODEC_ID_PCM_F16LE,
 +    AV_CODEC_ID_PCM_F24LE,
 +
      /* various ADPCM codecs */
      AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
      AV_CODEC_ID_ADPCM_IMA_WAV,
      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,
 +    AV_CODEC_ID_ATRAC3AL,
 +    AV_CODEC_ID_ATRAC3PAL,
 +
      /* 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_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
 +    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
@@@ -709,12 -594,6 +709,12 @@@ typedef struct AVCodecDescriptor 
       * Codec properties, a combination of AV_CODEC_PROP_* flags.
       */
      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
@@@ -803,7 -672,6 +803,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
  
@@@ -817,7 -685,6 +817,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
  };
@@@ -928,7 -795,7 +928,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)
 +/**
 + * Decoder is not a preferred choice for probing.
 + * This indicates that the decoder is not a good choice for probing.
 + * It could for example be an expensive to spin up hardware decoder,
 + * or it could simply not provide a lot of useful information about
 + * the stream.
 + * A decoder marked with this flag should only be used as last resort
 + * choice for probing.
 + */
 +#define AV_CODEC_CAP_AVOID_PROBING       (1 << 17)
 +/**
 + * 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
@@@ -1477,16 -1271,11 +1477,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,
 +
 +    /**
 +     * This side data should be associated with a video stream and corresponds
 +     * to the AVSphericalMapping structure.
 +     */
 +    AV_PKT_DATA_SPHERICAL,
  };
  
 +#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.
   *
@@@ -1678,12 -1382,6 +1678,12 @@@ typedef struct AVPacket 
  } AVPacket;
  #define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
  #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
 +/**
 + * Flag is used to discard packets which are required to maintain valid
 + * decoder state but are not required for output and should be dropped
 + * after decoding.
 + **/
 +#define AV_PKT_FLAG_DISCARD   0x0004
  
  enum AVSideDataParamChangeFlags {
      AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
@@@ -1711,12 -1409,6 +1711,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.
 + * You can 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
       * - decoding: unused
       */
      int ildct_cmp;
 -#define FF_CMP_SAD    0
 -#define FF_CMP_SSE    1
 -#define FF_CMP_SATD   2
 -#define FF_CMP_DCT    3
 -#define FF_CMP_PSNR   4
 -#define FF_CMP_BIT    5
 -#define FF_CMP_RD     6
 -#define FF_CMP_ZERO   7
 -#define FF_CMP_VSAD   8
 -#define FF_CMP_VSSE   9
 -#define FF_CMP_NSSE   10
 -#define FF_CMP_DCTMAX 13
 -#define FF_CMP_DCT264 14
 -#define FF_CMP_CHROMA 256
 +#define FF_CMP_SAD          0
 +#define FF_CMP_SSE          1
 +#define FF_CMP_SATD         2
 +#define FF_CMP_DCT          3
 +#define FF_CMP_PSNR         4
 +#define FF_CMP_BIT          5
 +#define FF_CMP_RD           6
 +#define FF_CMP_ZERO         7
 +#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_MEDIAN_SAD   15
 +#define FF_CMP_CHROMA       256
  
      /**
       * ME diamond size & shape
       * 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
      /**
  #define FF_BUG_DC_CLIP          4096
  #define FF_BUG_MS               8192 ///< Work around various bugs in Microsoft's broken decoders.
  #define FF_BUG_TRUNCATED       16384
 +#define FF_BUG_IEDGE           32768
  
      /**
       * strictly follow the standard (MPEG-4, ...).
      int error_concealment;
  #define FF_EC_GUESS_MVS   1
  #define FF_EC_DEBLOCK     2
 +#define FF_EC_FAVOR_INTER 256
  
      /**
       * debug
  #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
 +     * - 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
       */
 -    attribute_deprecated int lowres;
 +     int lowres;
  #endif
  
  #if FF_API_CODED_FRAME
  #define FF_PROFILE_MPEG2_AAC_LOW 128
  #define FF_PROFILE_MPEG2_AAC_HE  131
  
 +#define FF_PROFILE_DNXHD         0
 +#define FF_PROFILE_DNXHR_LB      1
 +#define FF_PROFILE_DNXHR_SQ      2
 +#define FF_PROFILE_DNXHR_HQ      3
 +#define FF_PROFILE_DNXHR_HQX     4
 +#define FF_PROFILE_DNXHR_444     5
 +
  #define FF_PROFILE_DTS         20
  #define FF_PROFILE_DTS_ES      30
  #define FF_PROFILE_DTS_96_24   40
  #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.
 +     * - encoding unused.
 +     * - decoding set by user.
 +     */
 +    AVRational pkt_timebase;
 +
 +    /**
 +     * AVCodecDescriptor
 +     * - 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.
 +     */
 +     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).
 +     *
 +     * - 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
 +     * - 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
 +     * - encoding: Set by user, can be NULL.
 +     * - decoding: unused.
 +     */
 +    uint16_t *chroma_intra_matrix;
 +
 +    /**
 +     * dump format separator.
 +     * can be ", " or "\n      " or anything else
 +     * - 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
 +     */
 +    char *codec_whitelist;
 +
 +    /*
 +     * Properties of the stream that gets decoded
 +     * - 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.
       *
      /**
       * A reference to the AVHWFramesContext describing the input (for encoding)
       * or output (decoding) frames. The reference is set by the caller and
 -     * afterwards owned (and freed) by libavcodec.
 +     * afterwards owned (and freed) by libavcodec - it should never be read by
 +     * the caller after being set.
       *
       * - decoding: This field should be set by the caller from the get_format()
       *             callback. The previous reference (if any) will always be
       *             This field should be set before avcodec_open2() is called.
       */
      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
 +
 +    /**
 +     * Audio only. The amount of padding (in samples) appended by the encoder to
 +     * the end of the audio. I.e. this number of decoded samples must be
 +     * discarded by the caller from the end of the stream to get the original
 +     * audio without any trailing padding.
 +     *
 +     * - decoding: unused
 +     * - encoding: unused
 +     */
 +    int trailing_padding;
 +
 +    /**
 +     * The number of pixels per image to maximally accept.
 +     *
 +     * - decoding: set by user
 +     * - encoding: set by user
 +     */
 +    int64_t max_pixels;
 +
 +    /**
 +     * A reference to the AVHWDeviceContext describing the device which will
 +     * be used by a hardware encoder/decoder.  The reference is set by the
 +     * caller and afterwards owned (and freed) by libavcodec.
 +     *
 +     * This should be used if either the codec device does not require
 +     * hardware frames or any that are used are to be allocated internally by
 +     * libavcodec.  If the user wishes to supply any of the frames used as
 +     * encoder input or decoder output then hw_frames_ctx should be used
 +     * instead.  When hw_frames_ctx is set in get_format() for a decoder, this
 +     * field will be ignored while decoding the associated stream segment, but
 +     * may again be used on a following one after another get_format() call.
 +     *
 +     * For both encoders and decoders this field should be set before
 +     * avcodec_open2() is called and must not be written to thereafter.
 +     *
 +     * Note that some decoders may require this field to be set initially in
 +     * order to support hw_frames_ctx at all - in that case, all frames
 +     * contexts used must be created on the same device.
 +     */
 +    AVBufferRef *hw_device_ctx;
 +
 +    /**
 +     * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated
 +     * decoding (if active).
 +     * - encoding: unused
 +     * - decoding: Set by user (either before avcodec_open2(), or in the
 +     *             AVCodecContext.get_format callback)
 +     */
 +    int hwaccel_flags;
  } 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.
   */
@@@ -3693,7 -3148,9 +3693,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
      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
   * @{
@@@ -3819,7 -3272,7 +3819,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.
       *
       * AVCodecInternal.hwaccel_priv_data.
       */
      int priv_data_size;
 +
 +    /**
 +     * Internal hwaccel capabilities.
 +     */
 +    int caps_internal;
  } AVHWAccel;
  
  /**
   * 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,
  
@@@ -4025,7 -3459,6 +4025,7 @@@ typedef struct AVSubtitleRect 
       * struct.
       */
      char *ass;
 +
      int flags;
  } AVSubtitleRect;
  
@@@ -4082,34 -3515,10 +4082,34 @@@ 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.
       */
      enum AVColorSpace                  color_space;
      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
       * 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;
  
  /**
@@@ -4279,22 -3675,6 +4279,22 @@@ int avcodec_get_context_defaults3(AVCod
  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
   * 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
   *
@@@ -4523,20 -3903,6 +4523,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.
   *
@@@ -4593,38 -3959,9 +4593,38 @@@ int av_packet_shrink_side_data(AVPacke
   * @param size pointer for side information size to store (optional)
   * @return pointer to data if present or NULL otherwise
   */
 -uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
 +uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
                                   int *size);
  
 +#if FF_API_MERGE_SD_API
 +attribute_deprecated
 +int av_packet_merge_side_data(AVPacket *pkt);
 +
 +attribute_deprecated
 +int av_packet_split_side_data(AVPacket *pkt);
 +#endif
 +
 +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.
@@@ -4649,7 -3986,7 +4649,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.
@@@ -4763,28 -4100,6 +4763,28 @@@ void avcodec_align_dimensions(AVCodecCo
  void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
                                 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.
   *
   */
  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.
   */
@@@ -4962,10 -4269,8 +4962,10 @@@ int avcodec_decode_subtitle2(AVCodecCon
   *                  a flush packet.
   *
   * @return 0 on success, otherwise negative error code:
 - *      AVERROR(EAGAIN):   input is not accepted right now - the packet must be
 - *                         resent after trying to read output
 + *      AVERROR(EAGAIN):   input is not accepted in the current state - user
 + *                         must read output with avcodec_receive_frame() (once
 + *                         all output is read, the packet should be resent, and
 + *                         the call will not fail with EAGAIN).
   *      AVERROR_EOF:       the decoder has been flushed, and no new packets can
   *                         be sent to it (also returned if more than 1 flush
   *                         packet is sent)
@@@ -4986,7 -4291,7 +4986,7 @@@ int avcodec_send_packet(AVCodecContext 
   *
   * @return
   *      0:                 success, a frame was returned
 - *      AVERROR(EAGAIN):   output is not available right now - user must try
 + *      AVERROR(EAGAIN):   output is not available in this state - user must try
   *                         to send new input
   *      AVERROR_EOF:       the decoder has been fully flushed, and there will be
   *                         no more output frames
@@@ -5019,10 -4324,8 +5019,10 @@@ int avcodec_receive_frame(AVCodecContex
   *                  avctx->frame_size for all frames except the last.
   *                  The final frame may be smaller than avctx->frame_size.
   * @return 0 on success, otherwise negative error code:
 - *      AVERROR(EAGAIN):   input is not accepted right now - the frame must be
 - *                         resent after trying to read output packets
 + *      AVERROR(EAGAIN):   input is not accepted in the current state - user
 + *                         must read output with avcodec_receive_packet() (once
 + *                         all output is read, the packet should be resent, and
 + *                         the call will not fail with EAGAIN).
   *      AVERROR_EOF:       the encoder has been flushed, and no new frames can
   *                         be sent to it
   *      AVERROR(EINVAL):   codec not opened, refcounted_frames not set, it is a
@@@ -5040,8 -4343,8 +5040,8 @@@ int avcodec_send_frame(AVCodecContext *
   *              encoder. Note that the function will always call
   *              av_frame_unref(frame) before doing anything else.
   * @return 0 on success, otherwise negative error code:
 - *      AVERROR(EAGAIN):   output is not available right now - user must try
 - *                         to send input
 + *      AVERROR(EAGAIN):   output is not available in the current state - user
 + *                         must try to send input
   *      AVERROR_EOF:       the encoder has been fully flushed, and there will be
   *                         no more output packets
   *      AVERROR(EINVAL):   codec not opened, or it is an encoder
@@@ -5100,7 -4403,6 +5100,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];
@@@ -5257,10 -4559,7 +5257,10 @@@ AVCodecParserContext *av_parser_init(in
   * @param poutbuf       set to pointer to parsed buffer or NULL if not yet finished.
   * @param poutbuf_size  set to size of parsed buffer or zero if not yet finished.
   * @param buf           input buffer.
 - * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output).
 + * @param buf_size      buffer size in bytes without the padding. I.e. the full buffer
 +                        size is assumed to be buf_size + AV_INPUT_BUFFER_PADDING_SIZE.
 +                        To signal EOF, this should be 0 (so that the last frame
 +                        can be output).
   * @param pts           input presentation timestamp.
   * @param dts           input decoding timestamp.
   * @param pos           input byte position in stream.
@@@ -5289,7 -4588,7 +5289,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,
@@@ -5336,12 -4635,11 +5336,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().
@@@ -5414,103 -4712,6 +5414,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
@@@ -5533,14 -4734,14 +5533,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);
  
@@@ -5593,21 -4794,10 +5593,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 src_pix_fmt,
 -                                              int has_alpha, int *loss_ptr);
 +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
 +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);
  
  enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  
@@@ -5707,12 -4908,7 +5707,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,
@@@ -5752,14 -4946,6 +5752,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
@@@ -5789,14 -4975,9 +5789,14 @@@ int av_get_audio_frame_duration2(AVCode
  #if FF_API_OLD_BSF
  typedef struct AVBitStreamFilterContext {
      void *priv_data;
 -    struct AVBitStreamFilter *filter;
 +    const 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
  
@@@ -5836,12 -5017,15 +5836,15 @@@ typedef struct AVBSFContext 
      void *priv_data;
  
      /**
-      * Parameters of the input stream. Set by the caller before av_bsf_init().
+      * Parameters of the input stream. This field is allocated in
+      * av_bsf_alloc(), it needs to be filled by the caller before
+      * av_bsf_init().
       */
      AVCodecParameters *par_in;
  
      /**
-      * Parameters of the output stream. Set by the filter in av_bsf_init().
+      * Parameters of the output stream. This field is allocated in
+      * av_bsf_alloc(), it is set by the filter in av_bsf_init().
       */
      AVCodecParameters *par_out;
  
@@@ -5895,82 -5079,20 +5898,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
@@@ -6019,8 -5141,7 +6022,8 @@@ int av_bsf_init(AVBSFContext *ctx)
   * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
   * AVERROR_EOF.
   *
 - * @param pkt the packet to filter. The bitstream filter will take ownership of
 + * @param pkt the packet to filter. pkt must contain some payload (i.e data or
 + * side data must be present in pkt). The bitstream filter will take ownership of
   * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
   * This parameter may be NULL, which signals the end of the stream (i.e. no more
   * packets will be sent). That will cause the filter to output any packets it
@@@ -6070,108 -5191,16 +6073,108 @@@ void av_bsf_free(AVBSFContext **ctx)
   */
  const AVClass *av_bsf_get_class(void);
  
 -/* memory */
 +/**
 + * Structure for chain/list of bitstream filters.
 + * Empty list can be allocated by av_bsf_list_alloc().
 + */
 +typedef struct AVBSFList AVBSFList;
 +
 +/**
 + * Allocate empty list of bitstream filters.
 + * The list must be later freed by av_bsf_list_free()
 + * or finalized by av_bsf_list_finalize().
 + *
 + * @return Pointer to @ref AVBSFList on success, NULL in case of failure
 + */
 +AVBSFList *av_bsf_list_alloc(void);
 +
 +/**
 + * Free list of bitstream filters.
 + *
 + * @param lst Pointer to pointer returned by av_bsf_list_alloc()
 + */
 +void av_bsf_list_free(AVBSFList **lst);
 +
 +/**
 + * Append bitstream filter to the list of bitstream filters.
 + *
 + * @param lst List to append to
 + * @param bsf Filter context to be appended
 + *
 + * @return >=0 on success, negative AVERROR in case of failure
 + */
 +int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
 +
 +/**
 + * Construct new bitstream filter context given it's name and options
 + * and append it to the list of bitstream filters.
 + *
 + * @param lst      List to append to
 + * @param bsf_name Name of the bitstream filter
 + * @param options  Options for the bitstream filter, can be set to NULL
 + *
 + * @return >=0 on success, negative AVERROR in case of failure
 + */
 +int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
 +/**
 + * Finalize list of bitstream filters.
 + *
 + * This function will transform @ref AVBSFList to single @ref AVBSFContext,
 + * so the whole chain of bitstream filters can be treated as single filter
 + * freshly allocated by av_bsf_alloc().
 + * If the call is successful, @ref AVBSFList structure is freed and lst
 + * will be set to NULL. In case of failure, caller is responsible for
 + * freeing the structure by av_bsf_list_free()
 + *
 + * @param      lst Filter list structure to be transformed
 + * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 + *                 representing the chain of bitstream filters
 + *
 + * @return >=0 on success, negative AVERROR in case of failure
 + */
 +int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
  
  /**
 - * Allocate a buffer with padding, reusing the given one if large enough.
 + * Parse string describing list of bitstream filters and create single
 + * @ref AVBSFContext describing the whole chain of bitstream filters.
 + * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
 + * allocated by av_bsf_alloc().
 + *
 + * @param      str String describing chain of bitstream filters in format
 + *                 `bsf1[=opt1=val1:opt2=val2][,bsf2]`
 + * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 + *                 representing the chain of bitstream filters
 + *
 + * @return >=0 on success, negative AVERROR in case of failure
 + */
 +int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
 +
 +/**
 + * Get null/pass-through bitstream filter.
 + *
 + * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter
   *
 + * @return
 + */
 +int av_bsf_get_null_filter(AVBSFContext **bsf);
 +
 +/* memory */
 +
 +/**
   * 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.
   *
@@@ -6184,7 -5213,7 +6187,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
@@@ -6200,7 -5229,7 +6203,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
@@@ -6264,12 -5293,6 +6267,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.