Merge commit '302554835e39b79b977ed60c9afe81b44590dfef'
authorJames Almer <jamrial@gmail.com>
Mon, 23 Oct 2017 19:08:42 +0000 (16:08 -0300)
committerJames Almer <jamrial@gmail.com>
Mon, 23 Oct 2017 19:08:42 +0000 (16:08 -0300)
* commit '302554835e39b79b977ed60c9afe81b44590dfef':
  lavc: Drop deprecated unused public members

Merged-by: James Almer <jamrial@gmail.com>
1  2 
libavcodec/avcodec.h
libavcodec/avdct.c
libavcodec/options_table.h
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"
@@@ -43,9 -42,7 +43,9 @@@
  #include "version.h"
  
  /**
 - * @defgroup libavc Encoding/Decoding Library
 + * @defgroup libavc libavcodec
 + * Encoding/Decoding Library
 + *
   * @{
   *
   * @defgroup lavc_decoding Decoding
@@@ -89,7 -86,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
   *
   * 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 (unless it is rejected with EAGAIN - then
 + *   feed an AVPacket to the API twice (unless it is rejected with AVERROR(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():
   * - 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. All codecs support the new API.
   *
 - * A codec is not allowed to return EAGAIN for both sending and receiving. This
 + * A codec is not allowed to return AVERROR(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
 + * do avcodec_send_packet() results in AVERROR(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
   * 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
 + * instead of returning a frame, after it just returned AVERROR(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.
@@@ -351,7 -347,7 +351,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_AV1,
 +    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_CFHD,
 +    AV_CODEC_ID_SPEEDHQ,
 +    AV_CODEC_ID_FMVC,
 +    AV_CODEC_ID_SCPR,
 +    AV_CODEC_ID_CLEARVIDEO,
 +    AV_CODEC_ID_XPM,
 +    AV_CODEC_ID_AV1,
 +    AV_CODEC_ID_BITPACKED,
 +    AV_CODEC_ID_MSCC,
 +    AV_CODEC_ID_SRGC,
 +    AV_CODEC_ID_SVG,
 +    AV_CODEC_ID_GDV,
 +    AV_CODEC_ID_FITS,
  
      /* various PCM "codecs" */
      AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio 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_IMA_APC,
      AV_CODEC_ID_ADPCM_VIMA,
  
 +    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_AMR_WB,
      AV_CODEC_ID_XAN_DPCM,
      AV_CODEC_ID_SOL_DPCM,
  
 +    AV_CODEC_ID_SDX2_DPCM = 0x14800,
 +    AV_CODEC_ID_GREMLIN_DPCM,
 +
      /* 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,
 +    AV_CODEC_ID_DOLBY_E,
 +
      /* 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 -608,6 +709,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.
       */
  
  /**
   * Codec uses only intra compression.
 - * Video codecs only.
 + * Video and audio codecs only.
   */
  #define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
  /**
   * 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
@@@ -802,7 -685,6 +802,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
  
@@@ -816,7 -698,6 +816,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
  };
@@@ -920,7 -801,7 +920,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)
 +
  /**
   * 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_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_PASS1           AV_CODEC_FLAG_PASS1
 +#define CODEC_FLAG_PASS2           AV_CODEC_FLAG_PASS2
 +#define CODEC_FLAG_GRAY            AV_CODEC_FLAG_GRAY
 +#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
  /**
   * Encoder or decoder requires flushing with NULL input at the end in order to
   * give the complete and correct output.
   *       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
 +
  /**
   * Codec can output multiple frames per AVPacket
   * Normally demuxers return one frame at a time, demuxers which do not do
   * 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
  /**
   * 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 */
  
  /**
@@@ -1401,16 -1221,11 +1401,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
      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 contains 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,
 +
 +    /**
 +     * Content light level (based on CTA-861.3). This metadata should be
 +     * associated with a video stream and contains data in the form of the
 +     * AVContentLightMetadata struct.
 +     */
 +    AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
 +
 +    /**
 +     * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
 +     * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
 +     * The number of bytes of CC data is AVPacketSideData.size.
 +     */
 +    AV_PKT_DATA_A53_CC,
 +
 +    /**
 +     * The number of side data elements (in fact a bit more than it).
 +     * This is not part of the public API/ABI in the sense that it may
 +     * change when new side data types are added.
 +     * This must stay the last enum value.
 +     * If its value becomes huge, some code using it
 +     * needs to be updated as it assumes it to be smaller than other limits.
 +     */
 +    AV_PKT_DATA_NB
  };
  
 +#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.
   *
@@@ -1626,19 -1338,6 +1626,19 @@@ 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
 +/**
 + * The packet comes from a trusted source.
 + *
 + * Otherwise-unsafe constructs such as arbitrary pointers to data
 + * outside the packet may be followed.
 + */
 +#define AV_PKT_FLAG_TRUSTED   0x0008
  
  enum AVSideDataParamChangeFlags {
      AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
@@@ -1666,12 -1365,6 +1666,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
      /**
       * precision of the intra DC coefficient - 8
       * - encoding: Set by user.
 -     * - decoding: unused
 +     * - decoding: Set by libavcodec
       */
      int intra_dc_precision;
  
      int chromaoffset;
  #endif
  
- #if FF_API_UNUSED_MEMBERS
-     /**
-      * Multiplied by qscale for each frame and added to scene_change_score.
-      * - encoding: Set by user.
-      * - decoding: unused
-      */
-     attribute_deprecated int scenechange_factor;
- #endif
      /**
       * Note: Value depends upon the compare function used for fullpel ME.
       * - encoding: Set by user.
  
      /** 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.
       * - encoding: unused
       * - decoding: set by the caller before avcodec_open2().
       */
 -    attribute_deprecated int refcounted_frames;
 +    attribute_deprecated
 +    int refcounted_frames;
  
      /* - encoding parameters */
      float qcompress;  ///< amount of qscale change between easy & hard scenes (0.0-1.0)
      /**
       * 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_CODER_TYPE_AC        1
  #define FF_CODER_TYPE_RAW       2
  #define FF_CODER_TYPE_RLE       3
- #if FF_API_UNUSED_MEMBERS
- #define FF_CODER_TYPE_DEFLATE   4
- #endif /* FF_API_UNUSED_MEMBERS */
      /**
       * @deprecated use encoder private options instead
       */
  #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
  #define FF_DEBUG_BITSTREAM   4
  #define FF_DEBUG_MB_TYPE     8
  #define FF_DEBUG_QP          16
 +#if FF_API_DEBUG_MV
 +/**
 + * @deprecated this option does nothing
 + */
 +#define FF_DEBUG_MV          32
 +#endif
  #define FF_DEBUG_DCT_COEFF   0x00000040
  #define FF_DEBUG_SKIP        0x00000080
  #define FF_DEBUG_STARTCODE   0x00000100
- #if FF_API_UNUSED_MEMBERS
- #define FF_DEBUG_PTS         0x00000200
- #endif /* FF_API_UNUSED_MEMBERS */
  #define FF_DEBUG_ER          0x00000400
  #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
 +#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
 +    /**
 +     * debug
 +     * - 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
  
      /**
       * Error recognition; may misdetect some more or less valid parts as errors.
   * 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
  #define FF_IDCT_ARM           7
  #define FF_IDCT_ALTIVEC       8
  #define FF_IDCT_SIMPLEARM     10
- #if FF_API_UNUSED_MEMBERS
- #define FF_IDCT_IPP           13
- #endif /* FF_API_UNUSED_MEMBERS */
  #define FF_IDCT_XVID          14
  #define FF_IDCT_SIMPLEARMV5TE 16
  #define FF_IDCT_SIMPLEARMV6   17
  #define FF_IDCT_FAAN          20
  #define FF_IDCT_SIMPLENEON    22
 +#define FF_IDCT_NONE          24 /* Used by XvMC to extract IDCT coefficients with FF_IDCT_PERM_NONE */
 +#define FF_IDCT_SIMPLEAUTO    128
  
      /**
       * bits per sample/pixel from the demuxer (needed for huffyuv).
       */
      int bits_per_raw_sample;
  
 +#if FF_API_LOWRES
 +    /**
 +     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
 +     * - encoding: unused
 +     * - decoding: Set by user.
 +     */
 +     int lowres;
 +#endif
 +
  #if FF_API_CODED_FRAME
      /**
       * the picture in the bitstream
  #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.
       *
       * - decoding: unused
      AVBufferRef *hw_frames_ctx;
  
      /**
 -     * Video decoding only. Certain video codecs support cropping, meaning that
 -     * only a sub-rectangle of the decoded frame is intended for display.  This
 -     * option controls how cropping is handled by libavcodec.
 -     *
 -     * When set to 1 (the default), libavcodec will apply cropping internally.
 -     * I.e. it will modify the output frame width/height fields and offset the
 -     * data pointers (only by as much as possible while preserving alignment, or
 -     * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that
 -     * the frames output by the decoder refer only to the cropped area. The
 -     * crop_* fields of the output frames will be zero.
 -     *
 -     * When set to 0, the width/height fields of the output frames will be set
 -     * to the coded dimensions and the crop_* fields will describe the cropping
 -     * rectangle. Applying the cropping is left to the caller.
 +     * 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.
       *
 -     * @warning When hardware acceleration with opaque output frames is used,
 -     * libavcodec is unable to apply cropping from the top/left border.
 +     * - decoding: unused
 +     * - encoding: unused
 +     */
 +    int trailing_padding;
 +
 +    /**
 +     * The number of pixels per image to maximally accept.
       *
 -     * @note when this option is set to zero, the width/height fields of the
 -     * AVCodecContext and output AVFrames have different meanings. The codec
 -     * context fields store display dimensions (with the coded dimensions in
 -     * coded_width/height), while the frame fields store the coded dimensions
 -     * (with the display dimensions being determined by the crop_* fields).
 +     * - decoding: set by user
 +     * - encoding: set by user
       */
 -    int apply_cropping;
 +    int64_t max_pixels;
  
      /**
       * A reference to the AVHWDeviceContext describing the device which will
       *             AVCodecContext.get_format callback)
       */
      int hwaccel_flags;
 +
 +    /**
 +     * Video decoding only. Certain video codecs support cropping, meaning that
 +     * only a sub-rectangle of the decoded frame is intended for display.  This
 +     * option controls how cropping is handled by libavcodec.
 +     *
 +     * When set to 1 (the default), libavcodec will apply cropping internally.
 +     * I.e. it will modify the output frame width/height fields and offset the
 +     * data pointers (only by as much as possible while preserving alignment, or
 +     * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that
 +     * the frames output by the decoder refer only to the cropped area. The
 +     * crop_* fields of the output frames will be zero.
 +     *
 +     * When set to 0, the width/height fields of the output frames will be set
 +     * to the coded dimensions and the crop_* fields will describe the cropping
 +     * rectangle. Applying the cropping is left to the caller.
 +     *
 +     * @warning When hardware acceleration with opaque output frames is used,
 +     * libavcodec is unable to apply cropping from the top/left border.
 +     *
 +     * @note when this option is set to zero, the width/height fields of the
 +     * AVCodecContext and output AVFrames have different meanings. The codec
 +     * context fields store display dimensions (with the coded dimensions in
 +     * coded_width/height), while the frame fields store the coded dimensions
 +     * (with the display dimensions being determined by the crop_* fields).
 +     */
 +    int apply_cropping;
  } 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.
   */
@@@ -3636,7 -3072,6 +3618,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
 +    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}
  
      const char *bsfs;
  } AVCodec;
  
 +int av_codec_get_max_lowres(const AVCodec *codec);
 +
 +struct MpegEncContext;
 +
  /**
   * @defgroup lavc_hwaccel AVHWAccel
   * @{
@@@ -3770,7 -3201,7 +3752,7 @@@ typedef struct AVHWAccel 
  
      /**
       * Hardware accelerated codec capabilities.
 -     * see FF_HWACCEL_CODEC_CAP_*
 +     * see AV_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_reconstruct_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
  } AVHWAccel;
  
  /**
 + * HWAccel is experimental and is thus avoided in favor of non experimental
 + * codecs
 + */
 +#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
 +
 +/**
   * 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)
  
  #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
  
  /**
 + * Hardware acceleration should still be attempted for decoding when the
 + * codec profile does not match the reported capabilities of the hardware.
 + *
 + * For example, this can be used to try to decode baseline profile H.264
 + * streams in hardware - it will often succeed, because many streams marked
 + * as baseline profile actually conform to constrained baseline profile.
 + *
 + * @warning If the stream is actually not supported then the behaviour is
 + *          undefined, and may include returning entirely incorrect output
 + *          while indicating success.
 + */
 +#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
 +
 +/**
   * @}
   */
  
   */
  
  /**
 - * 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,
  
@@@ -3996,7 -3393,6 +3978,7 @@@ typedef struct AVSubtitleRect 
       * struct.
       */
      char *ass;
 +
      int flags;
  } AVSubtitleRect;
  
@@@ -4053,35 -3449,11 +4035,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;
  
  /**
@@@ -4251,29 -3610,13 +4233,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
   *
@@@ -4495,26 -3838,6 +4477,26 @@@ 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
 + *
 + * @deprecated Use av_packet_ref
 + */
 +attribute_deprecated
 +int av_copy_packet(AVPacket *dst, const AVPacket *src);
 +
 +/**
 + * Copy packet side data
 + *
 + * @return 0 on success, negative AVERROR on fail
 + *
 + * @deprecated Use av_packet_copy_props
 + */
 +attribute_deprecated
 +int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
 +
 +/**
   * Free a packet.
   *
   * @deprecated Use av_packet_unref
@@@ -4570,38 -3893,9 +4552,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.
@@@ -4726,28 -4020,6 +4708,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 AV_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 AV_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.
   */
@@@ -5062,7 -4326,6 +5044,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];
@@@ -5219,10 -4482,7 +5201,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.
@@@ -5251,7 -4511,7 +5233,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,
@@@ -5298,12 -4558,11 +5280,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().
@@@ -5398,14 -4657,14 +5380,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);
  
@@@ -5457,15 -4716,6 +5439,15 @@@ int av_picture_pad(AVPicture *dst, cons
   * @{
   */
  
 +#if FF_API_GETCHROMA
 +/**
 + * @deprecated Use av_pix_fmt_get_chroma_sub_sample
 + */
 +
 +attribute_deprecated
 +void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
 +#endif
 +
  /**
   * Return a value representing the fourCC code associated to the
   * pixel format pix_fmt, or 0 if no associated fourCC code can be
   */
  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);
  
   * @}
   */
  
 +#if FF_API_TAG_STRING
  /**
   * Put a string representing the codec tag codec_tag in buf.
   *
   * @param codec_tag codec tag to assign
   * @return the length of the string that would have been generated if
   * enough space had been available, excluding the trailing null
 + *
 + * @deprecated see av_fourcc_make_string() and av_fourcc2str().
   */
 +attribute_deprecated
  size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
 +#endif
  
  void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
  
@@@ -5561,12 -4817,7 +5543,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,
@@@ -5607,14 -4856,6 +5589,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.
@@@ -5643,14 -4884,9 +5625,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
  
@@@ -5752,82 -4988,20 +5734,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
@@@ -5926,109 -5100,17 +5908,109 @@@ 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 a buffer with padding, reusing the given one if large enough.
 + * 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);
 +
 +/**
 + * 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.
   *
   * @param s buffer to write to; must be at least (v/255+1) bytes long
@@@ -6091,12 -5173,6 +6073,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/avdct.c
index a9a43cc,0000000..860f865
mode 100644,000000..100644
--- /dev/null
@@@ -1,133 -1,0 +1,130 @@@
- #if FF_API_UNUSED_MEMBERS
- {"ipp", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},
- #endif
 +/*
 + * Copyright (c) 2014 Michael Niedermayer <michaelni@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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 FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "avcodec.h"
 +#include "idctdsp.h"
 +#include "fdctdsp.h"
 +#include "pixblockdsp.h"
 +#include "avdct.h"
 +
 +#define OFFSET(x) offsetof(AVDCT,x)
 +#define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
 +//these names are too long to be readable
 +#define V AV_OPT_FLAG_VIDEO_PARAM
 +#define A AV_OPT_FLAG_AUDIO_PARAM
 +#define E AV_OPT_FLAG_ENCODING_PARAM
 +#define D AV_OPT_FLAG_DECODING_PARAM
 +
 +static const AVOption avdct_options[] = {
 +{"dct", "DCT algorithm", OFFSET(dct_algo), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, V|E, "dct"},
 +{"auto", "autoselect a good one", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_AUTO }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"fastint", "fast integer (experimental / for debugging)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_FASTINT }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"int", "accurate integer", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_INT }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"mmx", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_MMX }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"altivec", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_ALTIVEC }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"faan", "floating point AAN DCT (experimental / for debugging)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_FAAN }, INT_MIN, INT_MAX, V|E, "dct"},
 +
 +{"idct", "select IDCT implementation", OFFSET(idct_algo), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, V|E|D, "idct"},
 +{"auto", "autoselect a good one", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_AUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"int", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simple", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simplemmx", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"arm", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"altivec", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ALTIVEC }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simplearm", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simplearmv5te", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simplearmv6", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"simpleneon", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"xvid", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"xvidmmx", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"faani", "floating point AAN IDCT (experimental / for debugging)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},
 +{"simpleauto", "experimental / for debugging", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEAUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +
 +{"bits_per_sample", "", OFFSET(bits_per_sample), AV_OPT_TYPE_INT, {.i64 = 8 }, 0, 14, 0,},
 +{NULL},
 +};
 +
 +static const AVClass avdct_class = {
 +    .class_name              = "AVDCT",
 +    .option                  = avdct_options,
 +    .version                 = LIBAVUTIL_VERSION_INT,
 +};
 +
 +const AVClass *avcodec_dct_get_class(void)
 +{
 +    return &avdct_class;
 +}
 +
 +AVDCT *avcodec_dct_alloc(void)
 +{
 +    AVDCT *dsp = av_mallocz(sizeof(AVDCT));
 +
 +    if (!dsp)
 +        return NULL;
 +
 +    dsp->av_class = &avdct_class;
 +    av_opt_set_defaults(dsp);
 +
 +    return dsp;
 +}
 +
 +int avcodec_dct_init(AVDCT *dsp)
 +{
 +    AVCodecContext *avctx = avcodec_alloc_context3(NULL);
 +
 +    if (!avctx)
 +        return AVERROR(ENOMEM);
 +
 +    avctx->idct_algo = dsp->idct_algo;
 +    avctx->dct_algo  = dsp->dct_algo;
 +    avctx->bits_per_raw_sample = dsp->bits_per_sample;
 +
 +#define COPY(src, name) memcpy(&dsp->name, &src.name, sizeof(dsp->name))
 +
 +#if CONFIG_IDCTDSP
 +    {
 +        IDCTDSPContext idsp;
 +        ff_idctdsp_init(&idsp, avctx);
 +        COPY(idsp, idct);
 +        COPY(idsp, idct_permutation);
 +    }
 +#endif
 +
 +#if CONFIG_FDCTDSP
 +    {
 +        FDCTDSPContext fdsp;
 +        ff_fdctdsp_init(&fdsp, avctx);
 +        COPY(fdsp, fdct);
 +    }
 +#endif
 +
 +#if CONFIG_PIXBLOCKDSP
 +    {
 +        PixblockDSPContext pdsp;
 +        ff_pixblockdsp_init(&pdsp, avctx);
 +        COPY(pdsp, get_pixels);
 +    }
 +#endif
 +
 +    avcodec_close(avctx);
 +    av_free(avctx);
 +
 +    return 0;
 +}
@@@ -1,21 -1,18 +1,21 @@@
  /*
 - * This file is part of Libav.
 + * Copyright (c) 2001 Fabrice Bellard
 + * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * Libav is free software; you can redistribute it and/or
 + * This file is part of FFmpeg.
 + *
 + * 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
   */
  
  #define AV_CODEC_DEFAULT_BITRATE 200*1000
  
  static const AVOption avcodec_options[] = {
 -{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, V|A|E},
 +{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT64, {.i64 = AV_CODEC_DEFAULT_BITRATE }, 0, INT64_MAX, A|V|E},
 +{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT64, {.i64 = 128*1000 }, 0, INT_MAX, A|E},
  {"bt", "Set video bitrate tolerance (in bits/s). In 1-pass mode, bitrate tolerance specifies how far "
         "ratecontrol is willing to deviate from the target average bitrate value. This is not related "
         "to minimum/maximum bitrate. Lowering tolerance too much has an adverse effect on quality.",
         OFFSET(bit_rate_tolerance), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE*20 }, 1, INT_MAX, V|E},
 -{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, V|A|E|D, "flags"},
 +{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, V|A|S|E|D, "flags"},
  {"unaligned", "allow decoders to produce unaligned output", 0, AV_OPT_TYPE_CONST, { .i64 = AV_CODEC_FLAG_UNALIGNED }, INT_MIN, INT_MAX, V | D, "flags" },
  {"mv4", "use four motion vectors per macroblock (MPEG-4)", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V|E, "flags"},
  {"qpel", "use 1/4-pel motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V|E, "flags"},
@@@ -67,7 -63,7 +67,7 @@@
  {"pass2", "use internal 2-pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
  {"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},
  {"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"},
 -{"truncated", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, 0, "flags"},
 +{"truncated", "Input bitstream might be randomly truncated", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, V|D, "flags"},
  #if FF_API_NORMALIZE_AQP
  {"naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_NORMALIZE_AQP }, INT_MIN, INT_MAX, V|E, "flags"},
  #endif
  {"output_corrupt", "Output even potentially corrupted frames", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_OUTPUT_CORRUPT }, INT_MIN, INT_MAX, V|D, "flags"},
  {"fast", "allow non-spec-compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},
  {"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
 -{"ignorecrop", "ignore cropping information from sps", 1, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_IGNORE_CROP }, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"ignorecrop", "ignore cropping information from sps", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_IGNORE_CROP }, INT_MIN, INT_MAX, V|D, "flags2"},
  {"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
 +{"chunks", "Frame data might be split into multiple chunks", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_CHUNKS }, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"export_mvs", "export motion vectors through frame side data", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_EXPORT_MVS}, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"skip_manual", "do not skip samples and export skip information as frame side data", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_SKIP_MANUAL}, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"ass_ro_flush_noop", "do not reset ASS ReadOrder field on flush", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG2_RO_FLUSH_NOOP}, INT_MIN, INT_MAX, S|D, "flags2"},
  #if FF_API_MOTION_EST
  {"me_method", "set motion estimation method", OFFSET(me_method), AV_OPT_TYPE_INT, {.i64 = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method"},
  {"zero", "zero motion estimation (fastest)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_ZERO }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"full", "full motion estimation (slowest)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_FULL }, INT_MIN, INT_MAX, V|E, "me_method" },
 -{"epzs", "EPZS motion estimation (default)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method" },
 +{"epzs", "EPZS motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"esa", "esa motion estimation (alias for full)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_FULL }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"tesa", "tesa motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_TESA }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"dia", "diamond motion estimation (alias for EPZS)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"x1", "X1 motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_X1 }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"hex", "hex motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_HEX }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"umh", "umh motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_UMH }, INT_MIN, INT_MAX, V|E, "me_method" },
 +{"iter", "iter motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_ITER }, INT_MIN, INT_MAX, V|E, "me_method" },
  #endif
 -{"extradata_size", NULL, OFFSET(extradata_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 -{"time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, INT_MIN, INT_MAX},
 +{"time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, INT_MAX},
  {"g", "set the group of picture (GOP) size", OFFSET(gop_size), AV_OPT_TYPE_INT, {.i64 = 12 }, INT_MIN, INT_MAX, V|E},
 -{"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|D|E},
 -{"ac", "set number of audio channels", OFFSET(channels), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|D|E},
 +{"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|D|E},
 +{"ac", "set number of audio channels", OFFSET(channels), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|D|E},
  {"cutoff", "set cutoff bandwidth", OFFSET(cutoff), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|E},
 -{"frame_size", NULL, OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|E},
 +{"frame_size", NULL, OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|E},
  {"frame_number", NULL, OFFSET(frame_number), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
  {"delay", NULL, OFFSET(delay), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
  {"qcomp", "video quantizer scale compression (VBR). Constant of ratecontrol equation. "
            OFFSET(qcompress), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -FLT_MAX, FLT_MAX, V|E},
  {"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -1, FLT_MAX, V|E},
  {"qmin", "minimum video quantizer scale (VBR)", OFFSET(qmin), AV_OPT_TYPE_INT, {.i64 = 2 }, -1, 69, V|E},
 -{"qmax", "maximum video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.i64 = 31 }, -1, 69, V|E},
 +{"qmax", "maximum video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.i64 = 31 }, -1, 1024, V|E},
  {"qdiff", "maximum difference between the quantizer scales (VBR)", OFFSET(max_qdiff), AV_OPT_TYPE_INT, {.i64 = 3 }, INT_MIN, INT_MAX, V|E},
 -{"bf", "use 'frames' B-frames", OFFSET(max_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, -1, INT_MAX, V|E},
 +{"bf", "set maximum number of B-frames between non-B-frames", OFFSET(max_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, -1, INT_MAX, V|E},
  {"b_qfactor", "QP factor between P- and B-frames", OFFSET(b_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
  #if FF_API_RC_STRATEGY
  {"rc_strategy", "ratecontrol method", OFFSET(rc_strategy), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"dc_clip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_DC_CLIP }, INT_MIN, INT_MAX, V|D, "bug"},
  {"ms", "work around various bugs in Microsoft's broken decoders", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_MS }, INT_MIN, INT_MAX, V|D, "bug"},
  {"trunc", "truncated frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_TRUNCATED}, INT_MIN, INT_MAX, V|D, "bug"},
 +{"iedge", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_IEDGE }, INT_MIN, INT_MAX, V|D, "bug"},
  {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 -{"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
 -{"strict", "strictly conform to all the things in the spec no matter what the consequences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
 -{"normal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_NORMAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
 -{"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
 -{"experimental", "allow non-standardized experimental things", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
 +{"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 +{"strict", "strictly conform to all the things in the spec no matter what the consequences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 +{"normal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_NORMAL }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 +{"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 +{"experimental", "allow non-standardized experimental things", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
  {"b_qoffset", "QP offset between P- and B-frames", OFFSET(b_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
 -{"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 -{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 -{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 +{"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"ignore_err", "ignore errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_IGNORE_ERR }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"careful",    "consider things that violate the spec, are fast to check and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"aggressive", "consider things that a sane encoder should not do as an error", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
 +{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
  #if FF_API_PRIVATE_OPT
  {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
  #if FF_API_MPV_OPT
  {"rc_eq", "deprecated, use encoder private options instead", OFFSET(rc_eq), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, V|E},
  #endif
 -{"maxrate", "Set maximum bitrate tolerance (in bits/s). Requires bufsize to be set.", OFFSET(rc_max_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
 -{"minrate", "Set minimum bitrate tolerance (in bits/s). Most useful in setting up a CBR encode. It is of little use otherwise.",
 -            OFFSET(rc_min_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
 +{"maxrate", "maximum bitrate (in bits/s). Used for VBV together with bufsize.", OFFSET(rc_max_rate), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT_MAX, V|A|E},
 +{"minrate", "minimum bitrate (in bits/s). Most useful in setting up a CBR encode. It is of little use otherwise.",
 +            OFFSET(rc_min_rate), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
  {"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|V|E},
  #if FF_API_MPV_OPT
  {"rc_buf_aggressivity", "deprecated, use encoder private options instead", OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, V|E},
  {"rc_init_cplx", "deprecated, use encoder private options instead", OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},
  #endif
  {"dct", "DCT algorithm", OFFSET(dct_algo), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, V|E, "dct"},
 -{"auto", "autoselect a good one (default)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_AUTO }, INT_MIN, INT_MAX, V|E, "dct"},
 +{"auto", "autoselect a good one", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_AUTO }, INT_MIN, INT_MAX, V|E, "dct"},
  {"fastint", "fast integer", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_FASTINT }, INT_MIN, INT_MAX, V|E, "dct"},
  {"int", "accurate integer", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_INT }, INT_MIN, INT_MAX, V|E, "dct"},
  {"mmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_MMX }, INT_MIN, INT_MAX, V|E, "dct"},
  {"simplearmv5te", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},
  {"simplearmv6", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},
  {"simpleneon", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},
- #if FF_API_UNUSED_MEMBERS
- {"ipp", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},
- #endif /* FF_API_UNUSED_MEMBERS */
  {"xvid", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
 +{"xvidmmx", "deprecated, for compatibility only", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
  {"faani", "floating point AAN IDCT", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},
 +{"simpleauto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEAUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
  {"slice_count", NULL, OFFSET(slice_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
  {"ec", "set error concealment strategy", OFFSET(error_concealment), AV_OPT_TYPE_FLAGS, {.i64 = 3 }, INT_MIN, INT_MAX, V|D, "ec"},
  {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},
  {"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},
 -{"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 +{"favor_inter", "favor predicting from the previous frame", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_FAVOR_INTER }, INT_MIN, INT_MAX, V|D, "ec"},
 +{"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
  #if FF_API_PRIVATE_OPT
  {"pred", "prediction method", OFFSET(prediction_method), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "pred"},
  {"left", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},
  {"median", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_MEDIAN }, INT_MIN, INT_MAX, V|E, "pred"},
  #endif
  {"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},
 +{"sar",    "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},
  {"debug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, INT_MAX, V|A|S|E|D, "debug"},
  {"pict", "picture info", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PICT_INFO }, INT_MIN, INT_MAX, V|D, "debug"},
  {"rc", "rate control", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_RC }, INT_MIN, INT_MAX, V|E, "debug"},
  {"bitstream", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BITSTREAM }, INT_MIN, INT_MAX, V|D, "debug"},
  {"mb_type", "macroblock (MB) type", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
  {"qp", "per-block quantization parameter (QP)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_QP }, INT_MIN, INT_MAX, V|D, "debug"},
 +#if FF_API_DEBUG_MV
 +{"mv", "motion vector", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MV }, INT_MIN, INT_MAX, V|D, "debug"},
 +#endif
  {"dct_coeff", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_DCT_COEFF }, INT_MIN, INT_MAX, V|D, "debug"},
 +{"green_metadata", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_GREEN_MD }, INT_MIN, INT_MAX, V|D, "debug"},
  {"skip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_SKIP }, INT_MIN, INT_MAX, V|D, "debug"},
  {"startcode", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_STARTCODE }, INT_MIN, INT_MAX, V|D, "debug"},
- #if FF_API_UNUSED_MEMBERS
- {"pts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PTS }, INT_MIN, INT_MAX, V|D, "debug"},
- #endif /* FF_API_UNUSED_MEMBERS */
  {"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},
  {"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},
  {"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},
 +#if FF_API_DEBUG_MV
 +{"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_QP }, INT_MIN, INT_MAX, V|D, "debug"},
 +{"vis_mb_type", "visualize block types", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
 +#endif
  {"buffers", "picture buffer allocations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUFFERS }, INT_MIN, INT_MAX, V|D, "debug"},
 -{"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|D, "debug"},
 +{"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|A|D, "debug"},
 +{"nomc", "skip motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_NOMC }, INT_MIN, INT_MAX, V|A|D, "debug"},
 +#if FF_API_VISMV
 +{"vismv", "visualize motion vectors (MVs) (deprecated)", OFFSET(debug_mv), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, INT_MAX, V|D, "debug_mv"},
 +{"pf", "forward predicted MVs of P-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_P_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
 +{"bf", "forward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
 +{"bb", "backward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_BACK }, INT_MIN, INT_MAX, V|D, "debug_mv"},
 +#endif
  {"cmp", "full-pel ME compare function", OFFSET(me_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"subcmp", "sub-pel ME compare function", OFFSET(me_sub_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"mbcmp", "macroblock compare function", OFFSET(mb_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"preme", "pre motion estimation", OFFSET(pre_me), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
  {"precmp", "pre motion estimation compare function", OFFSET(me_pre_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 -{"sad", "sum of absolute differences, fast (default)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 +{"sad", "sum of absolute differences, fast", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"sse", "sum of squared errors", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"satd", "sum of absolute Hadamard transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SATD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"dct", "sum of absolute DCT transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"vsad", "sum of absolute vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"vsse", "sum of squared vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"nsse", "noise preserving sum of squared differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_NSSE }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 +#if CONFIG_SNOW_ENCODER
 +{"w53", "5/3 wavelet, only used in snow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_W53 }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 +{"w97", "9/7 wavelet, only used in snow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_W97 }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 +#endif
  {"dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_CHROMA }, INT_MIN, INT_MAX, V|E, "cmp_func"},
 +{"msad", "sum of absolute differences, median predicted", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_MEDIAN_SAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"pre_dia_size", "diamond type & size for motion estimation pre-pass", OFFSET(pre_dia_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"subq", "sub-pel motion estimation quality", OFFSET(me_subpel_quality), AV_OPT_TYPE_INT, {.i64 = 8 }, INT_MIN, INT_MAX, V|E},
  #if FF_API_AFD
  {"ac", "arithmetic coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_AC }, INT_MIN, INT_MAX, V|E, "coder"},
  {"raw", "raw (no encoding)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_RAW }, INT_MIN, INT_MAX, V|E, "coder"},
  {"rle", "run-length coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_RLE }, INT_MIN, INT_MAX, V|E, "coder"},
- #if FF_API_UNUSED_MEMBERS
- {"deflate", "deflate-based coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_DEFLATE }, INT_MIN, INT_MAX, V|E, "coder"},
- #endif /* FF_API_UNUSED_MEMBERS */
  #endif /* FF_API_CODER_TYPE */
  #if FF_API_PRIVATE_OPT
  {"context", "context model", OFFSET(context_model), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
  {"slice_flags", NULL, OFFSET(slice_flags), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 -{"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "mbd"},
 -{"simple", "use mbcmp (default)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MB_DECISION_SIMPLE }, INT_MIN, INT_MAX, V|E, "mbd"},
 +{"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, 2, V|E, "mbd"},
 +{"simple", "use mbcmp", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MB_DECISION_SIMPLE }, INT_MIN, INT_MAX, V|E, "mbd"},
  {"bits", "use fewest bits", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MB_DECISION_BITS }, INT_MIN, INT_MAX, V|E, "mbd"},
  {"rd", "use best rate distortion", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MB_DECISION_RD }, INT_MIN, INT_MAX, V|E, "mbd"},
  #if FF_API_STREAM_CODEC_TAG
  #endif
  {"rc_init_occupancy", "number of bits which should be loaded into the rc buffer before decoding starts", OFFSET(rc_initial_buffer_occupancy), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"flags2", NULL, OFFSET(flags2), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT}, 0, UINT_MAX, V|A|E|D, "flags2"},
 -{"threads", NULL, OFFSET(thread_count), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, INT_MAX, V|E|D, "threads"},
 +{"threads", "set the number of threads", OFFSET(thread_count), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, INT_MAX, V|A|E|D, "threads"},
  {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, V|E|D, "threads"},
  #if FF_API_MPV_OPT
  {"me_threshold", "motion estimation threshold", OFFSET(me_threshold), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"mb_threshold", "macroblock threshold", OFFSET(mb_threshold), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
 -{"dc", "intra_dc_precision", OFFSET(intra_dc_precision), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, V|E},
 +{"dc", "intra_dc_precision", OFFSET(intra_dc_precision), AV_OPT_TYPE_INT, {.i64 = 0 }, -8, 16, V|E},
  {"nssew", "nsse weight", OFFSET(nsse_weight), AV_OPT_TYPE_INT, {.i64 = 8 }, INT_MIN, INT_MAX, V|E},
  {"skip_top", "number of macroblock rows at the top which are skipped", OFFSET(skip_top), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|D},
  {"skip_bottom", "number of macroblock rows at the bottom which are skipped", OFFSET(skip_bottom), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|D},
  {"dts_96_24", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_96_24 }, INT_MIN, INT_MAX, A|E, "profile"},
  {"dts_hd_hra", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_HD_HRA }, INT_MIN, INT_MAX, A|E, "profile"},
  {"dts_hd_ma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_HD_MA }, INT_MIN, INT_MAX, A|E, "profile"},
 -{"main10", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, A|E, "profile"},
 +{"mpeg4_sp",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_SIMPLE }, INT_MIN, INT_MAX, V|E, "profile"},
 +{"mpeg4_core", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_CORE }, INT_MIN, INT_MAX, V|E, "profile"},
 +{"mpeg4_main", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_MAIN }, INT_MIN, INT_MAX, V|E, "profile"},
 +{"mpeg4_asp",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_ADVANCED_SIMPLE }, INT_MIN, INT_MAX, V|E, "profile"},
 +{"main10",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, V|E, "profile"},
  {"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
 +{"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|A|D},
  #if FF_API_PRIVATE_OPT
  {"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"skip_factor", "frame skip factor", OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #if FF_API_PRIVATE_OPT
  {"mepc", "motion estimation bitrate penalty compensation (1.0 = 256)", OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, V|E},
  #endif
 -{"skip_loop_filter", NULL, OFFSET(skip_loop_filter), AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"skip_idct"       , NULL, OFFSET(skip_idct)       , AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"skip_frame"      , NULL, OFFSET(skip_frame)      , AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"none"            , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE    }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"default"         , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"noref"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"bidir"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR   }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"nokey"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 -{"all"             , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"skip_loop_filter", "skip loop filtering process for the selected frames", OFFSET(skip_loop_filter), AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"skip_idct"       , "skip IDCT/dequantization for the selected frames",    OFFSET(skip_idct),        AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"skip_frame"      , "skip decoding for the selected frames",               OFFSET(skip_frame),       AV_OPT_TYPE_INT, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"none"            , "discard no frame",                    0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE    }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"default"         , "discard useless frames",              0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"noref"           , "discard all non-reference frames",    0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"bidir"           , "discard all bidirectional frames",    0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR   }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"nokey"           , "discard all frames except keyframes", 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"nointra"         , "discard all frames except I frames",  0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONINTRA}, INT_MIN, INT_MAX, V|D, "avdiscard"},
 +{"all"             , "discard all frames",                  0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 4, V|E},
  #if FF_API_PRIVATE_OPT
  {"brd_scale", "downscale frames for dynamic B-frame decision", OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, 10, V|E},
  #endif
 -{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.i64 = 25 }, INT_MIN, INT_MAX, V|E},
 +{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.i64 = 25 }, INT_MIN, INT_MAX, V|E},
  {"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.i64 = 1 }, INT_MIN, INT_MAX, V|E},
  #if FF_API_PRIVATE_OPT
  {"chromaoffset", "chroma QP offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
  {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
- #if FF_API_UNUSED_MEMBERS
- {"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor), AV_OPT_TYPE_INT, {.i64 = 6 }, 0, INT_MAX, V|E},
- #endif /* FF_API_UNUSED_MEMBERS */
  {"mv0_threshold", NULL, OFFSET(mv0_threshold), AV_OPT_TYPE_INT, {.i64 = 256 }, 0, INT_MAX, V|E},
  #if FF_API_PRIVATE_OPT
  {"b_sensitivity", "adjust sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, V|E},
  #if FF_API_PRIVATE_OPT
  {"min_prediction_order", NULL, OFFSET(min_prediction_order), AV_OPT_TYPE_INT, {.i64 = -1 }, INT_MIN, INT_MAX, A|E},
  {"max_prediction_order", NULL, OFFSET(max_prediction_order), AV_OPT_TYPE_INT, {.i64 = -1 }, INT_MIN, INT_MAX, A|E},
 -{"timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, V|E},
 +{"timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, V|E},
  #endif
 -{"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 -{"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|E|D, "channel_layout"},
 -{"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|D, "request_channel_layout"},
 -{"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 1.0/3 }, 0.0, FLT_MAX, V|E},
 +{"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
 +{"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_UINT64, {.i64 = DEFAULT }, 0, UINT64_MAX, A|E|D, "channel_layout"},
 +{"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_UINT64, {.i64 = DEFAULT }, 0, UINT64_MAX, A|D, "request_channel_layout"},
 +{"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0.0, FLT_MAX, V|E},
  {"rc_min_vbv_use", NULL, OFFSET(rc_min_vbv_overflow_use),  AV_OPT_TYPE_FLOAT, {.dbl = 3 },     0.0, FLT_MAX, V|E},
  {"ticks_per_frame", NULL, OFFSET(ticks_per_frame), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, INT_MAX, A|V|E|D},
  {"color_primaries", "color primaries", OFFSET(color_primaries), AV_OPT_TYPE_INT, {.i64 = AVCOL_PRI_UNSPECIFIED }, 1, INT_MAX, V|E|D, "color_primaries_type"},
 -{"bt709",       "BT.709",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT709 },       INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"unknown",     "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"bt470m",      "BT.470 M",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470M },      INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"bt470bg",     "BT.470 BG",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470BG },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smpte170m",   "SMPTE 170 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE170M },   INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smpte240m",   "SMPTE 240 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE240M },   INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"film",        "Film",        0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_FILM },        INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"bt2020",      "BT.2020",     0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT2020 },      INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smpte428",    "SMPTE 428-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },   INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smpte431",    "SMPTE 431-2", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE431 },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smpte432",    "SMPTE 422-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE432 },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"jedec-p22",    "JEDEC P22",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_JEDEC_P22 },   INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 -{"smptest428_1", "SMPTE 428-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },   INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"bt709",       "BT.709",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT709 },        INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"unknown",     "Unspecified",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"bt470m",      "BT.470 M",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470M },       INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"bt470bg",     "BT.470 BG",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470BG },      INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte170m",   "SMPTE 170 M",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE170M },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte240m",   "SMPTE 240 M",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE240M },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"film",        "Film",           0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_FILM },         INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"bt2020",      "BT.2020",        0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT2020 },       INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte428",    "SMPTE 428-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte428_1",  "SMPTE 428-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte431",    "SMPTE 431-2",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE431 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"smpte432",    "SMPTE 422-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE432 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"jedec-p22",   "JEDEC P22",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_JEDEC_P22 },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 +{"unspecified", "Unspecified",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
  {"color_trc", "color transfer characteristics", OFFSET(color_trc), AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, INT_MAX, V|E|D, "color_trc_type"},
  {"bt709",        "BT.709",           0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 },        INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"unknown",      "Unspecified",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"iec61966_2_1", "IEC 61966-2-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"bt2020_10bit", "BT.2020 - 10 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"bt2020_12bit", "BT.2020 - 12 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 -{"smptest2084",  "SMPTE 2084",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE2084 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 -{"smptest428_1", "SMPTE 428-1",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 +{"smpte428_1",   "SMPTE 428-1",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"colorspace", "color space", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = AVCOL_SPC_UNSPECIFIED }, 0, INT_MAX, V|E|D, "colorspace_type"},
  {"rgb",         "RGB",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_RGB },         INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
  {"bt709",       "BT.709",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT709 },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
  {"mpeg", "MPEG (219*2^(n-8))", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
  {"jpeg", "JPEG (2^n-1)",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
  {"chroma_sample_location", "chroma sample location", OFFSET(chroma_sample_location), AV_OPT_TYPE_INT, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, INT_MAX, V|E|D, "chroma_sample_location_type"},
 -{"unknown", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 +{"unknown",     "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"left",        "Left",        0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_LEFT },        INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"center",      "Center",      0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_CENTER },      INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"topleft",     "Top-left",    0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_TOPLEFT },     INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"bottom",      "Bottom",      0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_BOTTOM },      INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
  {"log_level_offset", "set the log level offset", OFFSET(log_level_offset), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX },
 -{"slices", "number of slices, used in parallelized encoding", OFFSET(slices), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|E},
 -{"thread_type", "select multithreading type", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, {.i64 = FF_THREAD_SLICE|FF_THREAD_FRAME }, 0, INT_MAX, V|E|D, "thread_type"},
 +{"slices", "set the number of slices, used in parallelized encoding", OFFSET(slices), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|E},
 +{"thread_type", "select multithreading type", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, {.i64 = FF_THREAD_SLICE|FF_THREAD_FRAME }, 0, INT_MAX, V|A|E|D, "thread_type"},
  {"slice", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_THREAD_SLICE }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
  {"frame", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_THREAD_FRAME }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
  {"audio_service_type", "audio service type", OFFSET(audio_service_type), AV_OPT_TYPE_INT, {.i64 = AV_AUDIO_SERVICE_TYPE_MAIN }, 0, AV_AUDIO_SERVICE_TYPE_NB-1, A|E, "audio_service_type"},
  {"em", "Emergency",          0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_EMERGENCY },         INT_MIN, INT_MAX, A|E, "audio_service_type"},
  {"vo", "Voice Over",         0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_VOICE_OVER },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
  {"ka", "Karaoke",            0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_KARAOKE },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
 -{"request_sample_fmt", NULL, OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.i64 = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, INT_MAX, A|D, "request_sample_fmt"},
 -{"u8" , "8-bit unsigned integer", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_U8  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"s16", "16-bit signed integer",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S16 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"s32", "32-bit signed integer",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"flt", "32-bit float",           0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_FLT }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"dbl", "64-bit double",          0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_DBL }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"u8p" , "8-bit unsigned integer planar", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_U8P  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"s16p", "16-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S16P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"s32p", "32-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"fltp", "32-bit float planar",           0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_FLTP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"dblp", "64-bit double planar",          0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_DBLP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 -{"refcounted_frames", NULL, OFFSET(refcounted_frames), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, A|V|D },
 +{"request_sample_fmt", "sample format audio decoders should prefer", OFFSET(request_sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, {.i64=AV_SAMPLE_FMT_NONE}, -1, INT_MAX, A|D, "request_sample_fmt"},
 +{"pkt_timebase", NULL, OFFSET(pkt_timebase), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
 +{"sub_charenc", "set input text subtitles character encoding", OFFSET(sub_charenc), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, S|D},
 +{"sub_charenc_mode", "set input text subtitles character encoding mode", OFFSET(sub_charenc_mode), AV_OPT_TYPE_FLAGS, {.i64 = FF_SUB_CHARENC_MODE_AUTOMATIC}, -1, INT_MAX, S|D, "sub_charenc_mode"},
 +{"do_nothing",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_SUB_CHARENC_MODE_DO_NOTHING},  INT_MIN, INT_MAX, S|D, "sub_charenc_mode"},
 +{"auto",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_SUB_CHARENC_MODE_AUTOMATIC},   INT_MIN, INT_MAX, S|D, "sub_charenc_mode"},
 +{"pre_decoder", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_SUB_CHARENC_MODE_PRE_DECODER}, INT_MIN, INT_MAX, S|D, "sub_charenc_mode"},
 +#if FF_API_ASS_TIMING
 +{"sub_text_format", "set decoded text subtitle format", OFFSET(sub_text_format), AV_OPT_TYPE_INT, {.i64 = FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS}, 0, 1, S|D, "sub_text_format"},
 +#else
 +{"sub_text_format", "set decoded text subtitle format", OFFSET(sub_text_format), AV_OPT_TYPE_INT, {.i64 = FF_SUB_TEXT_FMT_ASS}, 0, 1, S|D, "sub_text_format"},
 +#endif
 +{"ass",              NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_SUB_TEXT_FMT_ASS},              INT_MIN, INT_MAX, S|D, "sub_text_format"},
 +#if FF_API_ASS_TIMING
 +{"ass_with_timings", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS}, INT_MIN, INT_MAX, S|D, "sub_text_format"},
 +#endif
 +{"refcounted_frames", NULL, OFFSET(refcounted_frames), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|V|D },
  #if FF_API_SIDEDATA_ONLY_PKT
 -{"side_data_only_packets", NULL, OFFSET(side_data_only_packets), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, A|V|E },
 +{"side_data_only_packets", NULL, OFFSET(side_data_only_packets), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, A|V|E },
  #endif
 -{"apply_cropping", NULL, OFFSET(apply_cropping), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, V | D },
 +{"apply_cropping", NULL, OFFSET(apply_cropping), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, V | D },
 +{"skip_alpha", "Skip processing alpha", OFFSET(skip_alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, V|D },
 +{"field_order", "Field order", OFFSET(field_order), AV_OPT_TYPE_INT, {.i64 = AV_FIELD_UNKNOWN }, 0, 5, V|D|E, "field_order" },
 +{"progressive", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_PROGRESSIVE }, 0, 0, V|D|E, "field_order" },
 +{"tt", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_TT }, 0, 0, V|D|E, "field_order" },
 +{"bb", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_BB }, 0, 0, V|D|E, "field_order" },
 +{"tb", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_TB }, 0, 0, V|D|E, "field_order" },
 +{"bt", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_BT }, 0, 0, V|D|E, "field_order" },
 +{"dump_separator", "set information dump field separator", OFFSET(dump_separator), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, A|V|S|D|E},
 +{"codec_whitelist", "List of decoders that are allowed to be used", OFFSET(codec_whitelist), AV_OPT_TYPE_STRING, { .str = NULL },  CHAR_MIN, CHAR_MAX, A|V|S|D },
 +{"pixel_format", "set pixel format", OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, {.i64=AV_PIX_FMT_NONE}, -1, INT_MAX, 0 },
 +{"video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str=NULL}, 0, INT_MAX, 0 },
 +{"max_pixels", "Maximum number of pixels", OFFSET(max_pixels), AV_OPT_TYPE_INT64, {.i64 = INT_MAX }, 0, INT_MAX, A|V|S|D|E },
 +{"hwaccel_flags", NULL, OFFSET(hwaccel_flags), AV_OPT_TYPE_FLAGS, {.i64 = AV_HWACCEL_FLAG_IGNORE_LEVEL }, 0, UINT_MAX, V|D, "hwaccel_flags"},
 +{"ignore_level", "ignore level even if the codec level used is unknown or higher than the maximum supported level reported by the hardware driver", 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWACCEL_FLAG_IGNORE_LEVEL }, INT_MIN, INT_MAX, V | D, "hwaccel_flags" },
 +{"allow_high_depth", "allow to output YUV pixel formats with a different chroma sampling than 4:2:0 and/or other than 8 bits per component", 0, AV_OPT_TYPE_CONST, {.i64 = AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH }, INT_MIN, INT_MAX, V | D, "hwaccel_flags"},
 +{"allow_profile_mismatch", "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream", 0, AV_OPT_TYPE_CONST, {.i64 = AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH }, INT_MIN, INT_MAX, V | D, "hwaccel_flags"},
  {NULL},
  };
  
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 58
 -#define LIBAVCODEC_VERSION_MINOR  0
 -#define LIBAVCODEC_VERSION_MICRO  0
 +#define LIBAVCODEC_VERSION_MAJOR  58
 +#define LIBAVCODEC_VERSION_MINOR   0
 +#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_UNUSED_MEMBERS
- #define FF_API_UNUSED_MEMBERS    (LIBAVCODEC_VERSION_MAJOR < 58)
- #endif
 +#ifndef FF_API_LOWRES
 +#define FF_API_LOWRES            (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
 +#ifndef FF_API_DEBUG_MV
 +#define FF_API_DEBUG_MV          (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_INPUT_PRESERVED
  #define FF_API_INPUT_PRESERVED   (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 < 58)
 +#define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_MPV_OPT
  #define FF_API_MPV_OPT           (LIBAVCODEC_VERSION_MAJOR < 58)
  #define FF_API_RC_STRATEGY       (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_CODED_FRAME
 -#define FF_API_CODED_FRAME       (LIBAVCODEC_VERSION_MAJOR < 58)
 +#define FF_API_CODED_FRAME       (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_MOTION_EST
  #define FF_API_MOTION_EST        (LIBAVCODEC_VERSION_MAJOR < 58)
  #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_GET_CONTEXT_DEFAULTS
  #define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 -#ifndef FF_API_VAAPI_CONTEXT
 -#define FF_API_VAAPI_CONTEXT    (LIBAVCODEC_VERSION_MAJOR < 59)
 +#ifndef FF_API_NVENC_OLD_NAME
 +#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
 +#ifndef FF_API_STRUCT_VAAPI_CONTEXT
 +#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 +#ifndef FF_API_MERGE_SD_API
 +#define FF_API_MERGE_SD_API      (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
 +#ifndef FF_API_TAG_STRING
 +#define FF_API_TAG_STRING        (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
 +#ifndef FF_API_GETCHROMA
 +#define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
 +
  
  #endif /* AVCODEC_VERSION_H */