Merge commit 'a8164323374e86ce5f93759230868c98356833a2'
authorJames Almer <jamrial@gmail.com>
Wed, 28 Sep 2016 16:12:18 +0000 (13:12 -0300)
committerJames Almer <jamrial@gmail.com>
Wed, 28 Sep 2016 16:12:18 +0000 (13:12 -0300)
* commit 'a8164323374e86ce5f93759230868c98356833a2':
  pixdesc: Add new SMPTE 431, 432, and 2085 color properties

Conflicts:
    libavcodec/options_table.h
    libavcodec/version.h
    libavutil/pixdesc.c
    libavutil/pixfmt.h
    libavutil/version.h

Merged-by: James Almer <jamrial@gmail.com>
1  2 
libavcodec/options_table.h
libavcodec/version.h
libavutil/pixdesc.c
libavutil/pixfmt.h
libavutil/version.h

@@@ -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
   */
  
@@@ -29,6 -26,7 +29,6 @@@
  #include "libavutil/opt.h"
  #include "avcodec.h"
  #include "version.h"
 -#include "config.h"
  
  #define OFFSET(x) offsetof(AVCodecContext,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
  #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"},
@@@ -70,7 -67,7 +70,7 @@@
  {"emu_edge", "do not draw edges", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_EMU_EDGE }, INT_MIN, INT_MAX, 0, "flags"},
  #endif
  {"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},
  {"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_number", NULL, OFFSET(frame_number), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
            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},
  {"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"},
  {"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"},
 +{"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 }, INT_MIN, INT_MAX},
  {"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
  #if FF_API_PRIVATE_OPT
  #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"},
  {"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"},
 -#if FF_API_IDCT_XVIDMMX
 -{"xvidmmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
 -#endif /* FF_API_IDCT_XVIDMMX */
 +{"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"},
 +{"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 }, INT_MIN, 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"},
  {"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"},
  {"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
  {"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"},
 -#if FF_API_DEBUG_MV
 -{"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, V|D, "debug_mv"},
 +{"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"},
  {"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
  #if FF_API_XVMC
  {"xvmc_acceleration", NULL, OFFSET(xvmc_acceleration), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
  #endif /* FF_API_XVMC */
 -{"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
  #if FF_API_ERROR_RATE
  {"error", NULL, OFFSET(error_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
 -{"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"},
 +{"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"},
  {"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},
  #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},
 +{"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, AVCOL_PRI_NB-1, 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"},
 -{"unspecified", "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"},
 -{"smptest428_1", "SMPTE ST 428-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTEST428_1 }, 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"},
 +{"bt709",       "BT.709",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT709 },        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"},
 +{"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_1",  "SMPTE ST 428-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTEST428_1 }, 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"},
  {"color_trc", "color transfer characteristics", OFFSET(color_trc), AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, 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"},
  {"unspecified",  "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 ST 2084",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 -{"smptest428_1", "SMPTE ST 428-1",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 +{"smpte2084",    "SMPTE ST 2084",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 +{"smpte428_1",   "SMPTE ST 428-1",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"arib-std-b67", "ARIB STD-B67",     0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_ARIB_STD_B67 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
  {"colorspace", "color space", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = AVCOL_SPC_UNSPECIFIED }, 0, AVCOL_SPC_NB-1, 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"},
  {"ycocg",       "YCOCG",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_YCOCG },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
  {"bt2020_ncl",  "BT.2020 NCL", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_NCL },  INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
  {"bt2020_cl",   "BT.2020 CL",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_CL },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+ {"smpte2085",   "SMPTE 2085",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE2085 },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
  {"color_range", "color range", OFFSET(color_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, AVCOL_RANGE_NB-1, V|E|D, "color_range_type"},
  {"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "color_range_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"},
  {"bottomleft",  "Bottom-left", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_BOTTOMLEFT },  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"},
  {"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, AV_SAMPLE_FMT_NB-1, 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 },
 -#endif
 +{"side_data_only_packets", NULL, OFFSET(side_data_only_packets), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, A|V|E },
 +#endif
 +{"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 },
  {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 57
 -#define LIBAVCODEC_VERSION_MINOR 22
 -#define LIBAVCODEC_VERSION_MICRO  2
 +#define LIBAVCODEC_VERSION_MAJOR  57
 +#define LIBAVCODEC_VERSION_MINOR  58
- #define LIBAVCODEC_VERSION_MICRO 103
++#define LIBAVCODEC_VERSION_MICRO 104
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
   * FF_API_* defines may be placed below to indicate public API that will be
   * dropped at a future version bump. The defines themselves are not part of
   * the public API and may change, break or disappear at any time.
 + *
 + * @note, when bumping the major version it is recommended to manually
 + * disable each FF_API_* in its own commit instead of disabling them all
 + * at once through the bump. This improves the git bisect-ability of the change.
   */
  
 +#ifndef FF_API_VIMA_DECODER
 +#define FF_API_VIMA_DECODER     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
 +#ifndef FF_API_AUDIO_CONVERT
 +#define FF_API_AUDIO_CONVERT     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
 +#ifndef FF_API_AVCODEC_RESAMPLE
 +#define FF_API_AVCODEC_RESAMPLE  FF_API_AUDIO_CONVERT
 +#endif
  #ifndef FF_API_GETCHROMA
  #define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_MAX_BFRAMES
  #define FF_API_MAX_BFRAMES       (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 -#ifndef FF_API_FAST_MALLOC
 -#define FF_API_FAST_MALLOC       (LIBAVCODEC_VERSION_MAJOR < 58)
 -#endif
  #ifndef FF_API_NEG_LINESIZES
  #define FF_API_NEG_LINESIZES     (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
  #ifndef FF_API_AFD
  #define FF_API_AFD               (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_VISMV
 +/* XXX: don't forget to drop the -vismv documentation */
 +#define FF_API_VISMV             (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_AUDIOENC_DELAY
  #define FF_API_AUDIOENC_DELAY    (LIBAVCODEC_VERSION_MAJOR < 58)
  #endif
 +#ifndef FF_API_VAAPI_CONTEXT
 +#define FF_API_VAAPI_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 58)
 +#endif
  #ifndef FF_API_AVCTX_TIMEBASE
  #define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_STAT_BITS
  #define FF_API_STAT_BITS         (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 -#ifndef FF_API_NVENC_OLD_NAME
 -#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 -#endif
  #ifndef FF_API_PRIVATE_OPT
  #define FF_API_PRIVATE_OPT      (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 +#ifndef FF_API_ASS_TIMING
 +#define FF_API_ASS_TIMING       (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
  #ifndef FF_API_OLD_BSF
  #define FF_API_OLD_BSF          (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
  #ifndef FF_API_GET_CONTEXT_DEFAULTS
  #define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
  #endif
 +#ifndef FF_API_NVENC_OLD_NAME
 +#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 +#endif
  
  #endif /* AVCODEC_VERSION_H */
diff --combined libavutil/pixdesc.c
@@@ -2,27 -2,26 +2,27 @@@
   * pixel format descriptor
   * Copyright (c) 2009 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include <stdio.h>
  #include <string.h>
  
 +#include "avassert.h"
  #include "avstring.h"
  #include "common.h"
  #include "pixfmt.h"
@@@ -237,18 -236,6 +237,18 @@@ static const AVPixFmtDescriptor av_pix_
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR,
      },
 +    [AV_PIX_FMT_YUVJ411P] = {
 +        .name = "yuvj411p",
 +        .nb_components = 3,
 +        .log2_chroma_w = 2,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 1, 0, 0, 8, 0, 7, 1 },        /* Y */
 +            { 1, 1, 0, 0, 8, 0, 7, 1 },        /* U */
 +            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_GRAY8] = {
          .name = "gray",
          .nb_components = 1,
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
  #endif /* FF_API_XVMC */
 +#if !FF_API_XVMC
 +    [AV_PIX_FMT_XVMC] = {
 +        .name = "xvmc",
 +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
 +    },
 +#endif /* !FF_API_XVMC */
      [AV_PIX_FMT_UYVY422] = {
          .name = "uyvy422",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
 +    [AV_PIX_FMT_0RGB] = {
 +        .name = "0rgb",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
 +            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* R */
 +            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
 +            { 0, 4, 3, 0, 8, 3, 7, 4 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_RGB0] = {
 +        .name = "rgb0",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
 +            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* R */
 +            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
 +            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_0BGR] = {
 +        .name = "0bgr",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
 +            { 0, 4, 3, 0, 8, 3, 7, 4 },        /* R */
 +            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
 +            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BGR0] = {
 +        .name = "bgr0",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
 +            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* R */
 +            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
 +            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
      [AV_PIX_FMT_GRAY16BE] = {
          .name = "gray16be",
          .nb_components = 1,
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR,
      },
 +    [AV_PIX_FMT_YUV440P10LE] = {
 +        .name = "yuv440p10le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 10, 1, 9, 1 },        /* Y */
 +            { 1, 2, 0, 0, 10, 1, 9, 1 },        /* U */
 +            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P10BE] = {
 +        .name = "yuv440p10be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 10, 1, 9, 1 },        /* Y */
 +            { 1, 2, 0, 0, 10, 1, 9, 1 },        /* U */
 +            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P12LE] = {
 +        .name = "yuv440p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P12BE] = {
 +        .name = "yuv440p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUVA420P] = {
          .name = "yuva420p",
          .nb_components = 4,
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_ALPHA,
      },
 -        [AV_PIX_FMT_YUVA422P] = {
 +    [AV_PIX_FMT_YUVA422P] = {
          .name = "yuva422p",
          .nb_components = 4,
          .log2_chroma_w = 1,
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
  #endif
 -    [AV_PIX_FMT_VDA_VLD] = {
 -        .name = "vda_vld",
 -        .log2_chroma_w = 1,
 -        .log2_chroma_h = 1,
 -        .flags = AV_PIX_FMT_FLAG_HWACCEL,
 -    },
      [AV_PIX_FMT_YUV420P9LE] = {
          .name = "yuv420p9le",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
 +    [AV_PIX_FMT_YUV420P12LE] = {
 +        .name = "yuv420p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P12BE] = {
 +        .name = "yuv420p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P14LE] = {
 +        .name = "yuv420p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P14BE] = {
 +        .name = "yuv420p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUV420P16LE] = {
          .name = "yuv420p16le",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
 +    [AV_PIX_FMT_YUV422P12LE] = {
 +        .name = "yuv422p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P12BE] = {
 +        .name = "yuv422p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P14LE] = {
 +        .name = "yuv422p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P14BE] = {
 +        .name = "yuv422p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUV422P16LE] = {
          .name = "yuv422p16le",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
 +    [AV_PIX_FMT_YUV444P12LE] = {
 +        .name = "yuv444p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P12BE] = {
 +        .name = "yuv444p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P14LE] = {
 +        .name = "yuv444p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P14BE] = {
 +        .name = "yuv444p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_D3D11VA_VLD] = {
          .name = "d3d11va_vld",
          .log2_chroma_w = 1,
          .log2_chroma_h = 1,
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
 +    [AV_PIX_FMT_VDA_VLD] = {
 +        .name = "vda_vld",
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
 +    },
      [AV_PIX_FMT_YA8] = {
          .name = "ya8",
          .nb_components = 2,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_ALPHA,
      },
 +    [AV_PIX_FMT_VIDEOTOOLBOX] = {
 +        .name = "videotoolbox_vld",
 +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
 +    },
      [AV_PIX_FMT_GBRP] = {
          .name = "gbrp",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
 +    [AV_PIX_FMT_GBRP12LE] = {
 +        .name = "gbrp12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* R */
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* G */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP12BE] = {
 +        .name = "gbrp12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* R */
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* G */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP14LE] = {
 +        .name = "gbrp14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* R */
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* G */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP14BE] = {
 +        .name = "gbrp14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* R */
 +            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* G */
 +            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
      [AV_PIX_FMT_GBRP16LE] = {
          .name = "gbrp16le",
          .nb_components = 3,
         },
          .flags = AV_PIX_FMT_FLAG_BE,
      },
 +
 +#define BAYER8_DESC_COMMON \
 +        .nb_components= 3, \
 +        .log2_chroma_w= 0, \
 +        .log2_chroma_h= 0, \
 +        .comp = {          \
 +            {0,1,0,0,2,0,1,1},\
 +            {0,1,0,0,4,0,3,1},\
 +            {0,1,0,0,2,0,1,1},\
 +        },                 \
 +
 +#define BAYER16_DESC_COMMON \
 +        .nb_components= 3, \
 +        .log2_chroma_w= 0, \
 +        .log2_chroma_h= 0, \
 +        .comp = {          \
 +            {0,2,0,0,4,1,3,1},\
 +            {0,2,0,0,8,1,7,1},\
 +            {0,2,0,0,4,1,3,1},\
 +        },                 \
 +
 +    [AV_PIX_FMT_BAYER_BGGR8] = {
 +        .name = "bayer_bggr8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_BGGR16LE] = {
 +        .name = "bayer_bggr16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_BGGR16BE] = {
 +        .name = "bayer_bggr16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB8] = {
 +        .name = "bayer_rggb8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB16LE] = {
 +        .name = "bayer_rggb16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB16BE] = {
 +        .name = "bayer_rggb16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG8] = {
 +        .name = "bayer_gbrg8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG16LE] = {
 +        .name = "bayer_gbrg16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG16BE] = {
 +        .name = "bayer_gbrg16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG8] = {
 +        .name = "bayer_grbg8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG16LE] = {
 +        .name = "bayer_grbg16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG16BE] = {
 +        .name = "bayer_grbg16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
      [AV_PIX_FMT_NV16] = {
          .name = "nv16",
          .nb_components = 3,
          .name = "qsv",
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
 +    [AV_PIX_FMT_MEDIACODEC] = {
 +        .name = "mediacodec",
 +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
 +    },
      [AV_PIX_FMT_MMAL] = {
          .name = "mmal",
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
          .name = "cuda",
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
 +    [AV_PIX_FMT_AYUV64LE] = {
 +        .name = "ayuv64le",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 8, 2, 0, 16, 7, 15, 3 },        /* Y */
 +            { 0, 8, 4, 0, 16, 7, 15, 5 },        /* U */
 +            { 0, 8, 6, 0, 16, 7, 15, 7 },        /* V */
 +            { 0, 8, 0, 0, 16, 7, 15, 1 },        /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_AYUV64BE] = {
 +        .name = "ayuv64be",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 0, 8, 2, 0, 16, 7, 15, 3 },        /* Y */
 +            { 0, 8, 4, 0, 16, 7, 15, 5 },        /* U */
 +            { 0, 8, 6, 0, 16, 7, 15, 7 },        /* V */
 +            { 0, 8, 0, 0, 16, 7, 15, 1 },        /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_P010LE] = {
 +        .name = "p010le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 6, 10, 1, 9, 1 },        /* Y */
 +            { 1, 4, 0, 6, 10, 3, 9, 1 },        /* U */
 +            { 1, 4, 2, 6, 10, 3, 9, 3 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_P010BE] = {
 +        .name = "p010be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
 +            { 0, 2, 0, 6, 10, 1, 9, 1 },        /* Y */
 +            { 1, 4, 0, 6, 10, 3, 9, 1 },        /* U */
 +            { 1, 4, 2, 6, 10, 3, 9, 3 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_BE,
 +    },
 +    [AV_PIX_FMT_GBRAP12LE] = {
 +        .name = "gbrap12le",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },       /* R */
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },       /* G */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },       /* B */
 +            { 3, 2, 0, 0, 12, 1, 11, 1 },       /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB |
 +                 AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_GBRAP12BE] = {
 +        .name = "gbrap12be",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 12, 1, 11, 1 },       /* R */
 +            { 0, 2, 0, 0, 12, 1, 11, 1 },       /* G */
 +            { 1, 2, 0, 0, 12, 1, 11, 1 },       /* B */
 +            { 3, 2, 0, 0, 12, 1, 11, 1 },       /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
 +                 AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_GBRAP10LE] = {
 +        .name = "gbrap10le",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 10, 1, 9, 1 },       /* R */
 +            { 0, 2, 0, 0, 10, 1, 9, 1 },       /* G */
 +            { 1, 2, 0, 0, 10, 1, 9, 1 },       /* B */
 +            { 3, 2, 0, 0, 10, 1, 9, 1 },       /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB |
 +                 AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_GBRAP10BE] = {
 +        .name = "gbrap10be",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
 +            { 2, 2, 0, 0, 10, 1, 9, 1 },       /* R */
 +            { 0, 2, 0, 0, 10, 1, 9, 1 },       /* G */
 +            { 1, 2, 0, 0, 10, 1, 9, 1 },       /* B */
 +            { 3, 2, 0, 0, 10, 1, 9, 1 },       /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
 +                 AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
 +    },
  };
  #if FF_API_PLUS1_MINUS1
  FF_ENABLE_DEPRECATION_WARNINGS
@@@ -2103,7 -1601,7 +2103,7 @@@ static const char *color_range_names[] 
      [AVCOL_RANGE_JPEG] = "pc",
  };
  
 -static const char *color_primaries_names[] = {
 +static const char *color_primaries_names[AVCOL_PRI_NB] = {
      [AVCOL_PRI_RESERVED0] = "reserved",
      [AVCOL_PRI_BT709] = "bt709",
      [AVCOL_PRI_UNSPECIFIED] = "unknown",
      [AVCOL_PRI_SMPTE240M] = "smpte240m",
      [AVCOL_PRI_FILM] = "film",
      [AVCOL_PRI_BT2020] = "bt2020",
 -    [AVCOL_PRI_SMPTEST428_1] = "smptest428-1",
 +    [AVCOL_PRI_SMPTEST428_1] = "smpte428-1",
+     [AVCOL_PRI_SMPTE431] = "smpte431",
+     [AVCOL_PRI_SMPTE432] = "smpte432",
  };
  
  static const char *color_transfer_names[] = {
      [AVCOL_TRC_IEC61966_2_1] = "iec61966-2-1",
      [AVCOL_TRC_BT2020_10] = "bt2020-10",
      [AVCOL_TRC_BT2020_12] = "bt2020-20",
 -    [AVCOL_TRC_SMPTEST2084] = "smptest2084",
 -    [AVCOL_TRC_SMPTEST428_1] = "smptest428-1",
 +    [AVCOL_TRC_SMPTEST2084] = "smpte2084",
 +    [AVCOL_TRC_SMPTEST428_1] = "smpte428-1",
      [AVCOL_TRC_ARIB_STD_B67] = "arib-std-b67",
  };
  
@@@ -2151,6 -1651,7 +2153,7 @@@ static const char *color_space_names[] 
      [AVCOL_SPC_YCOCG] = "ycgco",
      [AVCOL_SPC_BT2020_NCL] = "bt2020nc",
      [AVCOL_SPC_BT2020_CL] = "bt2020c",
+     [AVCOL_SPC_SMPTE2085] = "smpte2085",
  };
  
  static const char *chroma_location_names[] = {
@@@ -2225,26 -1726,6 +2228,26 @@@ int av_get_bits_per_pixel(const AVPixFm
      return bits >> log2_pixels;
  }
  
 +int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
 +{
 +    int c, bits = 0;
 +    int log2_pixels = pixdesc->log2_chroma_w + pixdesc->log2_chroma_h;
 +    int steps[4] = {0};
 +
 +    for (c = 0; c < pixdesc->nb_components; c++) {
 +        const AVComponentDescriptor *comp = &pixdesc->comp[c];
 +        int s = c == 1 || c == 2 ? 0 : log2_pixels;
 +        steps[comp->plane] = comp->step << s;
 +    }
 +    for (c = 0; c < 4; c++)
 +        bits += steps[c];
 +
 +    if(!(pixdesc->flags & AV_PIX_FMT_FLAG_BITSTREAM))
 +        bits *= 8;
 +
 +    return bits >> log2_pixels;
 +}
 +
  char *av_get_pix_fmt_string(char *buf, int buf_size,
                              enum AVPixelFormat pix_fmt)
  {
@@@ -2271,11 -1752,8 +2274,11 @@@ const AVPixFmtDescriptor *av_pix_fmt_de
  {
      if (!prev)
          return &av_pix_fmt_descriptors[0];
 -    if (prev - av_pix_fmt_descriptors < FF_ARRAY_ELEMS(av_pix_fmt_descriptors) - 1)
 -        return prev + 1;
 +    while (prev - av_pix_fmt_descriptors < FF_ARRAY_ELEMS(av_pix_fmt_descriptors) - 1) {
 +        prev++;
 +        if (prev->name)
 +            return prev;
 +    }
      return NULL;
  }
  
@@@ -2315,262 -1793,56 +2318,262 @@@ int av_pix_fmt_count_planes(enum AVPixe
      return ret;
  }
  
 +void ff_check_pixfmt_descriptors(void){
 +    int i, j;
 +
 +    for (i=0; i<FF_ARRAY_ELEMS(av_pix_fmt_descriptors); i++) {
 +        const AVPixFmtDescriptor *d = &av_pix_fmt_descriptors[i];
 +        uint8_t fill[4][8+6+3] = {{0}};
 +        uint8_t *data[4] = {fill[0], fill[1], fill[2], fill[3]};
 +        int linesize[4] = {0,0,0,0};
 +        uint16_t tmp[2];
 +
 +        if (!d->name && !d->nb_components && !d->log2_chroma_w && !d->log2_chroma_h && !d->flags)
 +            continue;
 +//         av_log(NULL, AV_LOG_DEBUG, "Checking: %s\n", d->name);
 +        av_assert0(d->log2_chroma_w <= 3);
 +        av_assert0(d->log2_chroma_h <= 3);
 +        av_assert0(d->nb_components <= 4);
 +        av_assert0(d->name && d->name[0]);
 +        av_assert0((d->nb_components==4 || d->nb_components==2) == !!(d->flags & AV_PIX_FMT_FLAG_ALPHA));
 +        av_assert2(av_get_pix_fmt(d->name) == i);
 +
 +        for (j=0; j<FF_ARRAY_ELEMS(d->comp); j++) {
 +            const AVComponentDescriptor *c = &d->comp[j];
 +            if(j>=d->nb_components) {
 +                av_assert0(!c->plane && !c->step && !c->offset && !c->shift && !c->depth);
 +                continue;
 +            }
 +            if (d->flags & AV_PIX_FMT_FLAG_BITSTREAM) {
 +                av_assert0(c->step >= c->depth);
 +            } else {
 +                av_assert0(8*c->step >= c->depth);
 +            }
 +            if (!strncmp(d->name, "bayer_", 6))
 +                continue;
 +            av_read_image_line(tmp, (void*)data, linesize, d, 0, 0, j, 2, 0);
 +            av_assert0(tmp[0] == 0 && tmp[1] == 0);
 +            tmp[0] = tmp[1] = (1<<c->depth) - 1;
 +            av_write_image_line(tmp, data, linesize, d, 0, 0, j, 2);
 +        }
 +    }
 +}
 +
  
  enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
  {
 -#define PIX_FMT_SWAP_ENDIANNESS(fmt)                                           \
 -    case AV_PIX_FMT_ ## fmt ## BE: return AV_PIX_FMT_ ## fmt ## LE;            \
 -    case AV_PIX_FMT_ ## fmt ## LE: return AV_PIX_FMT_ ## fmt ## BE
 -
 -    switch (pix_fmt) {
 -    PIX_FMT_SWAP_ENDIANNESS(GRAY16);
 -    PIX_FMT_SWAP_ENDIANNESS(YA16);
 -    PIX_FMT_SWAP_ENDIANNESS(RGB48);
 -    PIX_FMT_SWAP_ENDIANNESS(RGB565);
 -    PIX_FMT_SWAP_ENDIANNESS(RGB555);
 -    PIX_FMT_SWAP_ENDIANNESS(RGB444);
 -    PIX_FMT_SWAP_ENDIANNESS(BGR48);
 -    PIX_FMT_SWAP_ENDIANNESS(BGR565);
 -    PIX_FMT_SWAP_ENDIANNESS(BGR555);
 -    PIX_FMT_SWAP_ENDIANNESS(BGR444);
 -
 -    PIX_FMT_SWAP_ENDIANNESS(YUV420P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV422P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV444P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV420P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV422P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV444P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV420P16);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV422P16);
 -    PIX_FMT_SWAP_ENDIANNESS(YUV444P16);
 -
 -    PIX_FMT_SWAP_ENDIANNESS(GBRP9);
 -    PIX_FMT_SWAP_ENDIANNESS(GBRP10);
 -    PIX_FMT_SWAP_ENDIANNESS(GBRP16);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA420P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA422P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA444P9);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA420P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA422P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA444P10);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA420P16);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA422P16);
 -    PIX_FMT_SWAP_ENDIANNESS(YUVA444P16);
 -
 -    PIX_FMT_SWAP_ENDIANNESS(XYZ12);
 -    PIX_FMT_SWAP_ENDIANNESS(NV20);
 -    PIX_FMT_SWAP_ENDIANNESS(RGBA64);
 -    PIX_FMT_SWAP_ENDIANNESS(BGRA64);
 -    default:
 +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 +    char name[16];
 +    int i;
 +
 +    if (!desc || strlen(desc->name) < 2)
 +        return AV_PIX_FMT_NONE;
 +    av_strlcpy(name, desc->name, sizeof(name));
 +    i = strlen(name) - 2;
 +    if (strcmp(name + i, "be") && strcmp(name + i, "le"))
          return AV_PIX_FMT_NONE;
 +
 +    name[i] ^= 'b' ^ 'l';
 +
 +    return get_pix_fmt_internal(name);
 +}
 +
 +#define FF_COLOR_NA      -1
 +#define FF_COLOR_RGB      0 /**< RGB color space */
 +#define FF_COLOR_GRAY     1 /**< gray color space */
 +#define FF_COLOR_YUV      2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
 +#define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
 +#define FF_COLOR_XYZ      4
 +
 +#define pixdesc_has_alpha(pixdesc) \
 +    ((pixdesc)->nb_components == 2 || (pixdesc)->nb_components == 4 || (pixdesc)->flags & AV_PIX_FMT_FLAG_PAL)
 +
 +
 +static int get_color_type(const AVPixFmtDescriptor *desc) {
 +    if (desc->flags & AV_PIX_FMT_FLAG_PAL)
 +        return FF_COLOR_RGB;
 +
 +    if(desc->nb_components == 1 || desc->nb_components == 2)
 +        return FF_COLOR_GRAY;
 +
 +    if(desc->name && !strncmp(desc->name, "yuvj", 4))
 +        return FF_COLOR_YUV_JPEG;
 +
 +    if(desc->name && !strncmp(desc->name, "xyz", 3))
 +        return FF_COLOR_XYZ;
 +
 +    if(desc->flags & AV_PIX_FMT_FLAG_RGB)
 +        return  FF_COLOR_RGB;
 +
 +    if(desc->nb_components == 0)
 +        return FF_COLOR_NA;
 +
 +    return FF_COLOR_YUV;
 +}
 +
 +static int get_pix_fmt_depth(int *min, int *max, enum AVPixelFormat pix_fmt)
 +{
 +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 +    int i;
 +
 +    if (!desc || !desc->nb_components) {
 +        *min = *max = 0;
 +        return AVERROR(EINVAL);
 +    }
 +
 +    *min = INT_MAX, *max = -INT_MAX;
 +    for (i = 0; i < desc->nb_components; i++) {
 +        *min = FFMIN(desc->comp[i].depth, *min);
 +        *max = FFMAX(desc->comp[i].depth, *max);
      }
 -#undef PIX_FMT_SWAP_ENDIANNESS
 +    return 0;
 +}
 +
 +static int get_pix_fmt_score(enum AVPixelFormat dst_pix_fmt,
 +                              enum AVPixelFormat src_pix_fmt,
 +                              unsigned *lossp, unsigned consider)
 +{
 +    const AVPixFmtDescriptor *src_desc = av_pix_fmt_desc_get(src_pix_fmt);
 +    const AVPixFmtDescriptor *dst_desc = av_pix_fmt_desc_get(dst_pix_fmt);
 +    int src_color, dst_color;
 +    int src_min_depth, src_max_depth, dst_min_depth, dst_max_depth;
 +    int ret, loss, i, nb_components;
 +    int score = INT_MAX - 1;
 +
 +    if (dst_pix_fmt >= AV_PIX_FMT_NB || dst_pix_fmt <= AV_PIX_FMT_NONE)
 +        return ~0;
 +
 +    /* compute loss */
 +    *lossp = loss = 0;
 +
 +    if (dst_pix_fmt == src_pix_fmt)
 +        return INT_MAX;
 +
 +    if ((ret = get_pix_fmt_depth(&src_min_depth, &src_max_depth, src_pix_fmt)) < 0)
 +        return ret;
 +    if ((ret = get_pix_fmt_depth(&dst_min_depth, &dst_max_depth, dst_pix_fmt)) < 0)
 +        return ret;
 +
 +    src_color = get_color_type(src_desc);
 +    dst_color = get_color_type(dst_desc);
 +    if (dst_pix_fmt == AV_PIX_FMT_PAL8)
 +        nb_components = FFMIN(src_desc->nb_components, 4);
 +    else
 +        nb_components = FFMIN(src_desc->nb_components, dst_desc->nb_components);
 +
 +    for (i = 0; i < nb_components; i++) {
 +        int depth_minus1 = (dst_pix_fmt == AV_PIX_FMT_PAL8) ? 7/nb_components : (dst_desc->comp[i].depth - 1);
 +        if (src_desc->comp[i].depth - 1 > depth_minus1 && (consider & FF_LOSS_DEPTH)) {
 +            loss |= FF_LOSS_DEPTH;
 +            score -= 65536 >> depth_minus1;
 +        }
 +    }
 +
 +    if (consider & FF_LOSS_RESOLUTION) {
 +        if (dst_desc->log2_chroma_w > src_desc->log2_chroma_w) {
 +            loss |= FF_LOSS_RESOLUTION;
 +            score -= 256 << dst_desc->log2_chroma_w;
 +        }
 +        if (dst_desc->log2_chroma_h > src_desc->log2_chroma_h) {
 +            loss |= FF_LOSS_RESOLUTION;
 +            score -= 256 << dst_desc->log2_chroma_h;
 +        }
 +        // don't favor 422 over 420 if downsampling is needed, because 420 has much better support on the decoder side
 +        if (dst_desc->log2_chroma_w == 1 && src_desc->log2_chroma_w == 0 &&
 +            dst_desc->log2_chroma_h == 1 && src_desc->log2_chroma_h == 0 ) {
 +            score += 512;
 +        }
 +    }
 +
 +    if(consider & FF_LOSS_COLORSPACE)
 +    switch(dst_color) {
 +    case FF_COLOR_RGB:
 +        if (src_color != FF_COLOR_RGB &&
 +            src_color != FF_COLOR_GRAY)
 +            loss |= FF_LOSS_COLORSPACE;
 +        break;
 +    case FF_COLOR_GRAY:
 +        if (src_color != FF_COLOR_GRAY)
 +            loss |= FF_LOSS_COLORSPACE;
 +        break;
 +    case FF_COLOR_YUV:
 +        if (src_color != FF_COLOR_YUV)
 +            loss |= FF_LOSS_COLORSPACE;
 +        break;
 +    case FF_COLOR_YUV_JPEG:
 +        if (src_color != FF_COLOR_YUV_JPEG &&
 +            src_color != FF_COLOR_YUV &&
 +            src_color != FF_COLOR_GRAY)
 +            loss |= FF_LOSS_COLORSPACE;
 +        break;
 +    default:
 +        /* fail safe test */
 +        if (src_color != dst_color)
 +            loss |= FF_LOSS_COLORSPACE;
 +        break;
 +    }
 +    if(loss & FF_LOSS_COLORSPACE)
 +        score -= (nb_components * 65536) >> FFMIN(dst_desc->comp[0].depth - 1, src_desc->comp[0].depth - 1);
 +
 +    if (dst_color == FF_COLOR_GRAY &&
 +        src_color != FF_COLOR_GRAY && (consider & FF_LOSS_CHROMA)) {
 +        loss |= FF_LOSS_CHROMA;
 +        score -= 2 * 65536;
 +    }
 +    if (!pixdesc_has_alpha(dst_desc) && (pixdesc_has_alpha(src_desc) && (consider & FF_LOSS_ALPHA))) {
 +        loss |= FF_LOSS_ALPHA;
 +        score -= 65536;
 +    }
 +    if (dst_pix_fmt == AV_PIX_FMT_PAL8 && (consider & FF_LOSS_COLORQUANT) &&
 +        (src_pix_fmt != AV_PIX_FMT_PAL8 && (src_color != FF_COLOR_GRAY || (pixdesc_has_alpha(src_desc) && (consider & FF_LOSS_ALPHA))))) {
 +        loss |= FF_LOSS_COLORQUANT;
 +        score -= 65536;
 +    }
 +
 +    *lossp = loss;
 +    return score;
 +}
 +
 +int av_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt,
 +                            enum AVPixelFormat src_pix_fmt,
 +                            int has_alpha)
 +{
 +    int loss;
 +    int ret = get_pix_fmt_score(dst_pix_fmt, src_pix_fmt, &loss, has_alpha ? ~0 : ~FF_LOSS_ALPHA);
 +    if (ret < 0)
 +        return ret;
 +    return loss;
 +}
 +
 +enum AVPixelFormat av_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)
 +{
 +    enum AVPixelFormat dst_pix_fmt;
 +    int loss1, loss2, loss_mask;
 +    const AVPixFmtDescriptor *desc1 = av_pix_fmt_desc_get(dst_pix_fmt1);
 +    const AVPixFmtDescriptor *desc2 = av_pix_fmt_desc_get(dst_pix_fmt2);
 +    int score1, score2;
 +
 +    loss_mask= loss_ptr?~*loss_ptr:~0; /* use loss mask if provided */
 +    if(!has_alpha)
 +        loss_mask &= ~FF_LOSS_ALPHA;
 +
 +    score1 = get_pix_fmt_score(dst_pix_fmt1, src_pix_fmt, &loss1, loss_mask);
 +    score2 = get_pix_fmt_score(dst_pix_fmt2, src_pix_fmt, &loss2, loss_mask);
 +
 +    if (score1 == score2) {
 +        if(av_get_padded_bits_per_pixel(desc2) != av_get_padded_bits_per_pixel(desc1)) {
 +            dst_pix_fmt = av_get_padded_bits_per_pixel(desc2) < av_get_padded_bits_per_pixel(desc1) ? dst_pix_fmt2 : dst_pix_fmt1;
 +        } else {
 +            dst_pix_fmt = desc2->nb_components < desc1->nb_components ? dst_pix_fmt2 : dst_pix_fmt1;
 +        }
 +    } else {
 +        dst_pix_fmt = score1 < score2 ? dst_pix_fmt2 : dst_pix_fmt1;
 +    }
 +
 +    if (loss_ptr)
 +        *loss_ptr = av_get_pix_fmt_loss(dst_pix_fmt, src_pix_fmt, has_alpha);
 +    return dst_pix_fmt;
  }
  
  const char *av_color_range_name(enum AVColorRange range)
@@@ -2602,3 -1874,4 +2605,3 @@@ const char *av_chroma_location_name(enu
      return (unsigned) location < AVCHROMA_LOC_NB ?
          chroma_location_names[location] : NULL;
  }
 -
diff --combined libavutil/pixfmt.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -29,9 -29,6 +29,9 @@@
  #include "libavutil/avconfig.h"
  #include "version.h"
  
 +#define AVPALETTE_SIZE 1024
 +#define AVPALETTE_COUNT 256
 +
  /**
   * Pixel format.
   *
   * big-endian CPUs.
   *
   * @par
 - * When the pixel format is palettized RGB (AV_PIX_FMT_PAL8), the palettized
 + * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
   * image data is stored in AVFrame.data[0]. The palette is transported in
   * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
   * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
 - * also endian-specific). Note also that the individual RGB palette
 + * also endian-specific). Note also that the individual RGB32 palette
   * components stored in AVFrame.data[1] should be in the range 0..255.
   * This is important as many custom PAL8 video codecs that were designed
   * to run on the IBM VGA graphics adapter use 6-bit palette components.
@@@ -77,7 -74,6 +77,7 @@@ enum AVPixelFormat 
  #if FF_API_XVMC
      AV_PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
      AV_PIX_FMT_XVMC_MPEG2_IDCT,
 +#define AV_PIX_FMT_XVMC AV_PIX_FMT_XVMC_MPEG2_IDCT
  #endif /* FF_API_XVMC */
      AV_PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
      AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
  
      AV_PIX_FMT_RGB565BE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
      AV_PIX_FMT_RGB565LE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
 -    AV_PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0
 -    AV_PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0
 +    AV_PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian   , X=unused/undefined
 +    AV_PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
  
      AV_PIX_FMT_BGR565BE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
      AV_PIX_FMT_BGR565LE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
 -    AV_PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1
 -    AV_PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1
 +    AV_PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian   , X=unused/undefined
 +    AV_PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
  
  #if FF_API_VAAPI
 +    /** @name Deprecated pixel formats */
 +    /**@{*/
      AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
      AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
      AV_PIX_FMT_VAAPI_VLD,  ///< HW decoding through VA API, Picture.data[3] contains a VASurfaceID
 +    /**@}*/
      AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD,
  #else
 -    AV_PIX_FMT_VAAPI,      ///< HW decoding through VA API, Picture.data[3] contains a VASurfaceID
 +    /**
 +     *  Hardware acceleration through VA-API, data[3] contains a
 +     *  VASurfaceID.
 +     */
 +    AV_PIX_FMT_VAAPI,
  #endif
  
      AV_PIX_FMT_YUV420P16LE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
  #endif
      AV_PIX_FMT_DXVA2_VLD,    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
  
 -    AV_PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0
 -    AV_PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0
 -    AV_PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1
 -    AV_PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1
 +    AV_PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
 +    AV_PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian,    X=unused/undefined
 +    AV_PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
 +    AV_PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian,    X=unused/undefined
      AV_PIX_FMT_YA8,       ///< 8 bits gray, 8 bits alpha
  
      AV_PIX_FMT_Y400A = AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
 +    AV_PIX_FMT_GRAY8A= AV_PIX_FMT_YA8, ///< alias for AV_PIX_FMT_YA8
  
      AV_PIX_FMT_BGR48BE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
      AV_PIX_FMT_BGR48LE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
 +
 +    /**
 +     * The following 12 formats have the disadvantage of needing 1 format for each bit depth.
 +     * Notice that each 9/10 bits sample is stored in 16 bits with extra padding.
 +     * If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better.
 +     */
      AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
      AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
      AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
      AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
      AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
      AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
 +
      AV_PIX_FMT_VDPAU,     ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
 +
      AV_PIX_FMT_XYZ12LE,      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
      AV_PIX_FMT_XYZ12BE,      ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
      AV_PIX_FMT_NV16,         ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
       */
      AV_PIX_FMT_CUDA,
  
 +    AV_PIX_FMT_0RGB=0x123+4,///< packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
 +    AV_PIX_FMT_RGB0,        ///< packed RGB 8:8:8, 32bpp, RGBXRGBX...   X=unused/undefined
 +    AV_PIX_FMT_0BGR,        ///< packed BGR 8:8:8, 32bpp, XBGRXBGR...   X=unused/undefined
 +    AV_PIX_FMT_BGR0,        ///< packed BGR 8:8:8, 32bpp, BGRXBGRX...   X=unused/undefined
 +
 +    AV_PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
 +    AV_PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
 +    AV_PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
 +    AV_PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
 +    AV_PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
 +    AV_PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
 +    AV_PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
 +    AV_PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
 +    AV_PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
 +    AV_PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
 +    AV_PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
 +    AV_PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
 +    AV_PIX_FMT_GBRP12BE,    ///< planar GBR 4:4:4 36bpp, big-endian
 +    AV_PIX_FMT_GBRP12LE,    ///< planar GBR 4:4:4 36bpp, little-endian
 +    AV_PIX_FMT_GBRP14BE,    ///< planar GBR 4:4:4 42bpp, big-endian
 +    AV_PIX_FMT_GBRP14LE,    ///< planar GBR 4:4:4 42bpp, little-endian
 +    AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
 +
 +    AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
 +    AV_PIX_FMT_BAYER_RGGB8,    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */
 +    AV_PIX_FMT_BAYER_GBRG8,    ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */
 +    AV_PIX_FMT_BAYER_GRBG8,    ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */
 +    AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */
 +    AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */
 +    AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */
 +    AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */
 +    AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
 +    AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */
 +    AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
 +    AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
 +#if !FF_API_XVMC
 +    AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
 +#endif /* !FF_API_XVMC */
 +    AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
 +    AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
 +    AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
 +    AV_PIX_FMT_YUV440P12BE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
 +    AV_PIX_FMT_AYUV64LE,    ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
 +    AV_PIX_FMT_AYUV64BE,    ///< packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
 +
 +    AV_PIX_FMT_VIDEOTOOLBOX, ///< hardware decoding through Videotoolbox
 +
 +    AV_PIX_FMT_P010LE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
 +    AV_PIX_FMT_P010BE, ///< like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
 +
 +    AV_PIX_FMT_GBRAP12BE,  ///< planar GBR 4:4:4:4 48bpp, big-endian
 +    AV_PIX_FMT_GBRAP12LE,  ///< planar GBR 4:4:4:4 48bpp, little-endian
 +
 +    AV_PIX_FMT_GBRAP10BE,  ///< planar GBR 4:4:4:4 40bpp, big-endian
 +    AV_PIX_FMT_GBRAP10LE,  ///< planar GBR 4:4:4:4 40bpp, little-endian
 +
 +    AV_PIX_FMT_MEDIACODEC, ///< hardware decoding through MediaCodec
 +
      AV_PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
  };
  
 +#define AV_PIX_FMT_Y400A AV_PIX_FMT_GRAY8A
 +#define AV_PIX_FMT_GBR24P AV_PIX_FMT_GBRP
 +
  #if AV_HAVE_BIGENDIAN
  #   define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##be
  #else
  #define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR)
  #define AV_PIX_FMT_BGR32   AV_PIX_FMT_NE(ABGR, RGBA)
  #define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB)
 +#define AV_PIX_FMT_0RGB32  AV_PIX_FMT_NE(0RGB, BGR0)
 +#define AV_PIX_FMT_0BGR32  AV_PIX_FMT_NE(0BGR, RGB0)
  
  #define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
  #define AV_PIX_FMT_YA16   AV_PIX_FMT_NE(YA16BE,   YA16LE)
  #define AV_PIX_FMT_YUV444P9  AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE)
  #define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE)
  #define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE)
 +#define AV_PIX_FMT_YUV440P10 AV_PIX_FMT_NE(YUV440P10BE, YUV440P10LE)
  #define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE)
 +#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE)
 +#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE)
 +#define AV_PIX_FMT_YUV440P12 AV_PIX_FMT_NE(YUV440P12BE, YUV440P12LE)
 +#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE)
 +#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE)
 +#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE)
 +#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE)
  #define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE)
  #define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE)
  #define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE)
  
  #define AV_PIX_FMT_GBRP9     AV_PIX_FMT_NE(GBRP9BE ,    GBRP9LE)
  #define AV_PIX_FMT_GBRP10    AV_PIX_FMT_NE(GBRP10BE,    GBRP10LE)
 +#define AV_PIX_FMT_GBRP12    AV_PIX_FMT_NE(GBRP12BE,    GBRP12LE)
 +#define AV_PIX_FMT_GBRP14    AV_PIX_FMT_NE(GBRP14BE,    GBRP14LE)
  #define AV_PIX_FMT_GBRP16    AV_PIX_FMT_NE(GBRP16BE,    GBRP16LE)
 -
 +#define AV_PIX_FMT_GBRAP10   AV_PIX_FMT_NE(GBRAP10BE,   GBRAP10LE)
 +#define AV_PIX_FMT_GBRAP12   AV_PIX_FMT_NE(GBRAP12BE,   GBRAP12LE)
  #define AV_PIX_FMT_GBRAP16   AV_PIX_FMT_NE(GBRAP16BE,   GBRAP16LE)
  
 +#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE,    BAYER_BGGR16LE)
 +#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE,    BAYER_RGGB16LE)
 +#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE,    BAYER_GBRG16LE)
 +#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE,    BAYER_GRBG16LE)
 +
 +
  #define AV_PIX_FMT_YUVA420P9  AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
  #define AV_PIX_FMT_YUVA422P9  AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
  #define AV_PIX_FMT_YUVA444P9  AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
  
  #define AV_PIX_FMT_XYZ12      AV_PIX_FMT_NE(XYZ12BE, XYZ12LE)
  #define AV_PIX_FMT_NV20       AV_PIX_FMT_NE(NV20BE,  NV20LE)
 +#define AV_PIX_FMT_AYUV64     AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
 +#define AV_PIX_FMT_P010       AV_PIX_FMT_NE(P010BE,  P010LE)
  
  /**
    * Chromaticity coordinates of the source primaries.
    */
  enum AVColorPrimaries {
      AVCOL_PRI_RESERVED0   = 0,
 -    AVCOL_PRI_BT709       = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
 +    AVCOL_PRI_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
      AVCOL_PRI_UNSPECIFIED = 2,
      AVCOL_PRI_RESERVED    = 3,
 -    AVCOL_PRI_BT470M      = 4, ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
 +    AVCOL_PRI_BT470M      = 4,  ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
  
 -    AVCOL_PRI_BT470BG     = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
 -    AVCOL_PRI_SMPTE170M   = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
 -    AVCOL_PRI_SMPTE240M   = 7, ///< functionally identical to above
 -    AVCOL_PRI_FILM        = 8, ///< colour filters using Illuminant C
 -    AVCOL_PRI_BT2020      = 9, ///< ITU-R BT2020
 +    AVCOL_PRI_BT470BG     = 5,  ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
 +    AVCOL_PRI_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
 +    AVCOL_PRI_SMPTE240M   = 7,  ///< functionally identical to above
 +    AVCOL_PRI_FILM        = 8,  ///< colour filters using Illuminant C
 +    AVCOL_PRI_BT2020      = 9,  ///< ITU-R BT2020
-     AVCOL_PRI_SMPTEST428_1= 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
+     AVCOL_PRI_SMPTEST428_1 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
+     AVCOL_PRI_SMPTE431    = 11, ///< SMPTE ST 431-2 (2011)
+     AVCOL_PRI_SMPTE432    = 12, ///< SMPTE ST 432-1 D65 (2010)
 -    AVCOL_PRI_NB,              ///< Not part of ABI
 +    AVCOL_PRI_NB,               ///< Not part of ABI
  };
  
  /**
@@@ -445,10 -345,9 +447,11 @@@ enum AVColorSpace 
      AVCOL_SPC_YCOCG       = 8,  ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
      AVCOL_SPC_BT2020_NCL  = 9,  ///< ITU-R BT2020 non-constant luminance system
      AVCOL_SPC_BT2020_CL   = 10, ///< ITU-R BT2020 constant luminance system
+     AVCOL_SPC_SMPTE2085   = 11, ///< SMPTE 2085, Y'D'zD'x
      AVCOL_SPC_NB,               ///< Not part of ABI
  };
 +#define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
 +
  
  /**
   * MPEG vs JPEG YUV range.
@@@ -463,23 -362,15 +466,23 @@@ enum AVColorRange 
  /**
   * Location of chroma samples.
   *
 - *  X   X      3 4 X      X are luma samples,
 - *             1 2        1-6 are possible chroma positions
 - *  X   X      5 6 X      0 is undefined/unknown position
 + * Illustration showing the location of the first (top left) chroma sample of the
 + * image, the left shows only luma, the right
 + * shows the location of the chroma sample, the 2 could be imagined to overlay
 + * each other but are drawn separately due to limitations of ASCII
 + *
 + *                1st 2nd       1st 2nd horizontal luma sample positions
 + *                 v   v         v   v
 + *                 ______        ______
 + *1st luma line > |X   X ...    |3 4 X ...     X are luma samples,
 + *                |             |1 2           1-6 are possible chroma positions
 + *2nd luma line > |X   X ...    |5 6 X ...     0 is undefined/unknown position
   */
  enum AVChromaLocation {
      AVCHROMA_LOC_UNSPECIFIED = 0,
 -    AVCHROMA_LOC_LEFT        = 1, ///< MPEG-2/4, H.264 default
 -    AVCHROMA_LOC_CENTER      = 2, ///< MPEG-1, JPEG, H.263
 -    AVCHROMA_LOC_TOPLEFT     = 3, ///< DV
 +    AVCHROMA_LOC_LEFT        = 1, ///< MPEG-2/4 4:2:0, H.264 default for 4:2:0
 +    AVCHROMA_LOC_CENTER      = 2, ///< MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0
 +    AVCHROMA_LOC_TOPLEFT     = 3, ///< ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2
      AVCHROMA_LOC_TOP         = 4,
      AVCHROMA_LOC_BOTTOMLEFT  = 5,
      AVCHROMA_LOC_BOTTOM      = 6,
diff --combined libavutil/version.h
@@@ -1,72 -1,47 +1,72 @@@
  /*
 - * This file is part of Libav.
 + * copyright (c) 2003 Fabrice Bellard
   *
 - * 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
   */
  
 +/**
 + * @file
 + * @ingroup lavu
 + * Libavutil version macros
 + */
 +
  #ifndef AVUTIL_VERSION_H
  #define AVUTIL_VERSION_H
  
  #include "macros.h"
  
  /**
 - * @defgroup version_utils Library Version Macros
 + * @addtogroup version_utils
   *
   * Useful to check and match library version in order to maintain
   * backward compatibility.
   *
 + * The FFmpeg libraries follow a versioning sheme very similar to
 + * Semantic Versioning (http://semver.org/)
 + * The difference is that the component called PATCH is called MICRO in FFmpeg
 + * and its value is reset to 100 instead of 0 to keep it above or equal to 100.
 + * Also we do not increase MICRO for every bugfix or change in git master.
 + *
 + * Prior to FFmpeg 3.2 point releases did not change any lib version number to
 + * avoid aliassing different git master checkouts.
 + * Starting with FFmpeg 3.2, the released library versions will occupy
 + * a separate MAJOR.MINOR that is not used on the master development branch.
 + * That is if we branch a release of master 55.10.123 we will bump to 55.11.100
 + * for the release and master will continue at 55.12.100 after it. Each new
 + * point release will then bump the MICRO improving the usefulness of the lib
 + * versions.
 + *
   * @{
   */
  
 -#define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
 +#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
  #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
  #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
  
  /**
 - * @}
 + * Extract version components from the full ::AV_VERSION_INT int as returned
 + * by functions like ::avformat_version() and ::avcodec_version()
   */
 +#define AV_VERSION_MAJOR(a) ((a) >> 16)
 +#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8)
 +#define AV_VERSION_MICRO(a) ((a) & 0xFF)
  
  /**
 - * @file
 - * @ingroup lavu
 - * Libavutil version macros
 + * @}
   */
  
  /**
@@@ -78,9 -53,9 +78,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 55
 -#define LIBAVUTIL_VERSION_MINOR 15
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  55
- #define LIBAVUTIL_VERSION_MINOR  30
++#define LIBAVUTIL_VERSION_MINOR  31
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \
  #define LIBAVUTIL_IDENT         "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
  
  /**
 - * @}
 - *
 - * @defgroup depr_guards Deprecation guards
 + * @defgroup lavu_depr_guards Deprecation Guards
   * 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_DLOG
  #define FF_API_DLOG                     (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
 -#ifndef FF_API_CRYPTO_CONTEXT
 -#define FF_API_CRYPTO_CONTEXT           (LIBAVUTIL_VERSION_MAJOR < 56)
 +#ifndef FF_API_VAAPI
 +#define FF_API_VAAPI                    (LIBAVUTIL_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_FRAME_QP
 +#define FF_API_FRAME_QP                 (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
  #ifndef FF_API_PLUS1_MINUS1
  #define FF_API_PLUS1_MINUS1             (LIBAVUTIL_VERSION_MAJOR < 56)
  #ifndef FF_API_ERROR_FRAME
  #define FF_API_ERROR_FRAME              (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
 -#ifndef FF_API_VAAPI
 -#define FF_API_VAAPI                    (LIBAVUTIL_VERSION_MAJOR < 56)
 +#ifndef FF_API_CRC_BIG_TABLE
 +#define FF_API_CRC_BIG_TABLE            (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
  
  
  /**
   * @}
 + * @}
   */
  
  #endif /* AVUTIL_VERSION_H */