deleted file mode 100644
--- a/media/ffvpx/libavcodec/options_table.h
+++ /dev/null
@@ -1,559 +0,0 @@
-/*
- * Copyright (c) 2001 Fabrice Bellard
- * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_OPTIONS_TABLE_H
-#define AVCODEC_OPTIONS_TABLE_H
-
-#include <float.h>
-#include <limits.h>
-#include <stdint.h>
-
-#include "libavutil/opt.h"
-#include "avcodec.h"
-#include "version.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
-//these names are too long to be readable
-#define V AV_OPT_FLAG_VIDEO_PARAM
-#define A AV_OPT_FLAG_AUDIO_PARAM
-#define S AV_OPT_FLAG_SUBTITLE_PARAM
-#define E AV_OPT_FLAG_ENCODING_PARAM
-#define D AV_OPT_FLAG_DECODING_PARAM
-
-#define AV_CODEC_DEFAULT_BITRATE 200*1000
-
-static const AVOption avcodec_options[] = {
-{"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|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"},
-{"loop", "use loop filter", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V|E, "flags"},
-{"qscale", "use fixed qscale", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_QSCALE }, INT_MIN, INT_MAX, 0, "flags"},
-#if FF_API_GMC
-{"gmc", "use gmc", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GMC }, INT_MIN, INT_MAX, V|E, "flags"},
-#endif
-#if FF_API_MV0
-{"mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_MV0 }, INT_MIN, INT_MAX, V|E, "flags"},
-#endif
-#if FF_API_INPUT_PRESERVED
-{"input_preserved", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INPUT_PRESERVED }, INT_MIN, INT_MAX, 0, "flags"},
-#endif
-{"pass1", "use internal 2-pass ratecontrol in first pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PASS1 }, INT_MIN, INT_MAX, 0, "flags"},
-{"pass2", "use internal 2-pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
-{"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},
-#if FF_API_EMU_EDGE
-{"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", "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
-{"ildct", "use interlaced DCT", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"},
-{"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"},
-{"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},
-{"bitexact", "use only bitexact functions (except (I)DCT)", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A|V|S|D|E, "flags"},
-{"aic", "H.263 advanced intra coding / MPEG-4 AC prediction", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},
-{"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},
-{"cgop", "closed GOP", 0, AV_OPT_TYPE_CONST, {.i64 = AV_CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},
-{"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", 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", 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" },
-{"log", "log motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_LOG }, INT_MIN, INT_MAX, V|E, "me_method" },
-{"phods", "phods motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_PHODS }, 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
-{"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 }, 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},
-{"delay", NULL, OFFSET(delay), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"qcomp", "video quantizer scale compression (VBR). Constant of ratecontrol equation. "
- "Recommended range for default rc_eq: 0.0-1.0",
- 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, 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", "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},
-#endif
-#if FF_API_PRIVATE_OPT
-{"b_strategy", "strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, V|E},
-{"ps", "RTP payload size in bytes", OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-#if FF_API_STAT_BITS
-{"mv_bits", NULL, OFFSET(mv_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"header_bits", NULL, OFFSET(header_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"i_tex_bits", NULL, OFFSET(i_tex_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"p_tex_bits", NULL, OFFSET(p_tex_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"i_count", NULL, OFFSET(i_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"p_count", NULL, OFFSET(p_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"skip_count", NULL, OFFSET(skip_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"misc_bits", NULL, OFFSET(misc_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"frame_bits", NULL, OFFSET(frame_bits), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-#endif
-{"codec_tag", NULL, OFFSET(codec_tag), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"bug", "work around not autodetected encoder bugs", OFFSET(workaround_bugs), AV_OPT_TYPE_FLAGS, {.i64 = FF_BUG_AUTODETECT }, INT_MIN, INT_MAX, V|D, "bug"},
-{"autodetect", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_AUTODETECT }, INT_MIN, INT_MAX, V|D, "bug"},
-#if FF_API_OLD_MSMPEG4
-{"old_msmpeg4", "some old lavc-generated MSMPEG4v3 files (no autodetection)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_OLD_MSMPEG4 }, INT_MIN, INT_MAX, V|D, "bug"},
-#endif
-{"xvid_ilace", "Xvid interlacing bug (autodetected if FOURCC == XVIX)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_XVID_ILACE }, INT_MIN, INT_MAX, V|D, "bug"},
-{"ump4", "(autodetected if FOURCC == UMP4)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_UMP4 }, INT_MIN, INT_MAX, V|D, "bug"},
-{"no_padding", "padding bug (autodetected)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_NO_PADDING }, INT_MIN, INT_MAX, V|D, "bug"},
-{"amv", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_AMV }, INT_MIN, INT_MAX, V|D, "bug"},
-#if FF_API_AC_VLC
-{"ac_vlc", "illegal VLC bug (autodetected per FOURCC)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_AC_VLC }, INT_MIN, INT_MAX, V|D, "bug"},
-#endif
-{"qpel_chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_QPEL_CHROMA }, INT_MIN, INT_MAX, V|D, "bug"},
-{"std_qpel", "old standard qpel (autodetected per FOURCC/version)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_STD_QPEL }, INT_MIN, INT_MAX, V|D, "bug"},
-{"qpel_chroma2", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_QPEL_CHROMA2 }, INT_MIN, INT_MAX, V|D, "bug"},
-{"direct_blocksize", "direct-qpel-blocksize bug (autodetected per FOURCC/version)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_DIRECT_BLOCKSIZE }, INT_MIN, INT_MAX, V|D, "bug"},
-{"edge", "edge padding bug (autodetected per FOURCC/version)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_EDGE }, INT_MIN, INT_MAX, V|D, "bug"},
-{"hpel_chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_HPEL_CHROMA }, INT_MIN, INT_MAX, V|D, "bug"},
-{"dc_clip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_DC_CLIP }, INT_MIN, INT_MAX, V|D, "bug"},
-{"ms", "work around various bugs in Microsoft's broken decoders", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_MS }, INT_MIN, INT_MAX, V|D, "bug"},
-{"trunc", "truncated frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_TRUNCATED}, INT_MIN, INT_MAX, V|D, "bug"},
-{"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, 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, 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
-{"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-#if FF_API_MPV_OPT
-{"qsquish", "deprecated, use encoder private options instead", OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 99, V|E},
-{"rc_qmod_amp", "deprecated, use encoder private options instead", OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},
-{"rc_qmod_freq", "deprecated, use encoder private options instead", OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-{"rc_override_count", NULL, OFFSET(rc_override_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-#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", "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},
-#endif
-{"i_qfactor", "QP factor between P- and I-frames", OFFSET(i_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = -0.8 }, -FLT_MAX, FLT_MAX, V|E},
-{"i_qoffset", "QP offset between P- and I-frames", OFFSET(i_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 0.0 }, -FLT_MAX, FLT_MAX, V|E},
-#if FF_API_MPV_OPT
-{"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", 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"},
-{"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_ALTIVEC }, INT_MIN, INT_MAX, V|E, "dct"},
-{"faan", "floating point AAN DCT", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DCT_FAAN }, INT_MIN, INT_MAX, V|E, "dct"},
-{"lumi_mask", "compresses bright areas stronger than medium ones", OFFSET(lumi_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
-{"tcplx_mask", "temporal complexity masking", OFFSET(temporal_cplx_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
-{"scplx_mask", "spatial complexity masking", OFFSET(spatial_cplx_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
-{"p_mask", "inter masking", OFFSET(p_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
-{"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
-{"idct", "select IDCT implementation", OFFSET(idct_algo), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, V|E|D, "idct"},
-{"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_AUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"int", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"simplemmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"arm", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ALTIVEC }, INT_MIN, INT_MAX, V|E|D, "idct"},
-#if FF_API_ARCH_SH4
-{"sh4", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SH4 }, INT_MIN, INT_MAX, V|E|D, "idct"},
-#endif
-{"simplearm", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"simplearmv5te", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"simplearmv6", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"simpleneon", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},
-#if FF_API_ARCH_ALPHA
-{"simplealpha", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEALPHA }, INT_MIN, INT_MAX, V|E|D, "idct"},
-#endif
-#if FF_API_UNUSED_MEMBERS
-{"ipp", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},
-#endif /* FF_API_UNUSED_MEMBERS */
-{"xvid", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"xvidmmx", "deprecated, for compatibility only", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVID }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"faani", "floating point AAN IDCT", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},
-{"simpleauto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEAUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
-{"slice_count", NULL, OFFSET(slice_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"ec", "set error concealment strategy", OFFSET(error_concealment), AV_OPT_TYPE_FLAGS, {.i64 = 3 }, INT_MIN, INT_MAX, V|D, "ec"},
-{"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},
-{"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},
-{"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"},
-{"left", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},
-{"plane", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_PLANE }, INT_MIN, INT_MAX, V|E, "pred"},
-{"median", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_MEDIAN }, INT_MIN, INT_MAX, V|E, "pred"},
-#endif
-{"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},
-{"sar", "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},
-{"debug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, INT_MAX, V|A|S|E|D, "debug"},
-{"pict", "picture info", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PICT_INFO }, INT_MIN, INT_MAX, V|D, "debug"},
-{"rc", "rate control", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_RC }, INT_MIN, INT_MAX, V|E, "debug"},
-{"bitstream", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BITSTREAM }, INT_MIN, INT_MAX, V|D, "debug"},
-{"mb_type", "macroblock (MB) type", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
-{"qp", "per-block quantization parameter (QP)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_QP }, INT_MIN, INT_MAX, V|D, "debug"},
-#if FF_API_DEBUG_MV
-{"mv", "motion vector", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MV }, INT_MIN, INT_MAX, V|D, "debug"},
-#endif
-{"dct_coeff", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_DCT_COEFF }, INT_MIN, INT_MAX, V|D, "debug"},
-{"green_metadata", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_GREEN_MD }, INT_MIN, INT_MAX, V|D, "debug"},
-{"skip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_SKIP }, INT_MIN, INT_MAX, V|D, "debug"},
-{"startcode", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_STARTCODE }, INT_MIN, INT_MAX, V|D, "debug"},
-#if FF_API_UNUSED_MEMBERS
-{"pts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PTS }, INT_MIN, INT_MAX, V|D, "debug"},
-#endif /* FF_API_UNUSED_MEMBERS */
-{"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},
-{"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},
-{"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},
-{"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"},
-{"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|A|D, "debug"},
-{"nomc", "skip motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_NOMC }, INT_MIN, INT_MAX, V|A|D, "debug"},
-#if FF_API_VISMV
-{"vismv", "visualize motion vectors (MVs) (deprecated)", OFFSET(debug_mv), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, INT_MAX, V|D, "debug_mv"},
-{"pf", "forward predicted MVs of P-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_P_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
-{"bf", "forward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
-{"bb", "backward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_BACK }, INT_MIN, INT_MAX, V|D, "debug_mv"},
-#endif
-{"cmp", "full-pel ME compare function", OFFSET(me_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"subcmp", "sub-pel ME compare function", OFFSET(me_sub_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"mbcmp", "macroblock compare function", OFFSET(mb_cmp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"ildctcmp", "interlaced DCT compare function", OFFSET(ildct_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_VSAD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"dia_size", "diamond type & size for motion estimation", OFFSET(dia_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-{"last_pred", "amount of motion predictors from the previous frame", OFFSET(last_predictor_count), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#if FF_API_PRIVATE_OPT
-{"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", 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"},
-{"psnr", "sum of squared quantization errors (avoid, low quality)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_PSNR }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"bit", "number of bits needed for the block", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_BIT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"rd", "rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_RD }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-{"zero", "0", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_ZERO }, 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"},
-{"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
-{"dtg_active_format", NULL, OFFSET(dtg_active_format), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-#endif
-{"me_range", "limit motion vectors range (1023 for DivX player)", OFFSET(me_range), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#if FF_API_QUANT_BIAS
-{"ibias", "intra quant bias", OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
-{"pbias", "inter quant bias", OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, V|E},
-#endif
-{"global_quality", NULL, OFFSET(global_quality), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
-#if FF_API_CODER_TYPE
-{"coder", NULL, OFFSET(coder_type), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "coder"},
-{"vlc", "variable length coder / Huffman coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_VLC }, INT_MIN, INT_MAX, V|E, "coder"},
-{"ac", "arithmetic coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_AC }, INT_MIN, INT_MAX, V|E, "coder"},
-{"raw", "raw (no encoding)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_RAW }, INT_MIN, INT_MAX, V|E, "coder"},
-{"rle", "run-length coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_RLE }, INT_MIN, INT_MAX, V|E, "coder"},
-#if FF_API_UNUSED_MEMBERS
-{"deflate", "deflate-based coder", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CODER_TYPE_DEFLATE }, INT_MIN, INT_MAX, V|E, "coder"},
-#endif /* FF_API_UNUSED_MEMBERS */
-#endif /* FF_API_CODER_TYPE */
-#if FF_API_PRIVATE_OPT
-{"context", "context model", OFFSET(context_model), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-{"slice_flags", NULL, OFFSET(slice_flags), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-#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 }, 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
-{"stream_codec_tag", NULL, OFFSET(stream_codec_tag), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-#endif
-#if FF_API_PRIVATE_OPT
-{"sc_threshold", "scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-#if FF_API_MPV_OPT
-{"lmin", "deprecated, use encoder private options instead", OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|E},
-{"lmax", "deprecated, use encoder private options instead", OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|E},
-#endif
-#if FF_API_PRIVATE_OPT
-{"nr", "noise reduction", OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-{"rc_init_occupancy", "number of bits which should be loaded into the rc buffer before decoding starts", OFFSET(rc_initial_buffer_occupancy), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-{"flags2", NULL, OFFSET(flags2), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT}, 0, UINT_MAX, V|A|E|D, "flags2"},
-#if FF_API_ERROR_RATE
-{"error", NULL, OFFSET(error_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-{"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 }, -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},
-{"profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, {.i64 = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
-{"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
-{"aac_main", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_MAIN }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_low", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LOW }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_ssr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_SSR }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_ltp", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LTP }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_he", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_HE }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_he_v2", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_HE_V2 }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_ld", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LD }, INT_MIN, INT_MAX, A|E, "profile"},
-{"aac_eld", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_ELD }, INT_MIN, INT_MAX, A|E, "profile"},
-{"mpeg2_aac_low", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG2_AAC_LOW }, INT_MIN, INT_MAX, A|E, "profile"},
-{"mpeg2_aac_he", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG2_AAC_HE }, INT_MIN, INT_MAX, A|E, "profile"},
-{"dts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS }, INT_MIN, INT_MAX, A|E, "profile"},
-{"dts_es", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_ES }, INT_MIN, INT_MAX, A|E, "profile"},
-{"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},
-{"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-{"skipcmp", "frame skip compare function", OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, V|E, "cmp_func"},
-#endif
-#if FF_API_MPV_OPT
-{"border_mask", "deprecated, use encoder private options instead", OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},
-#endif
-{"mblmin", "minimum macroblock Lagrange factor (VBR)", OFFSET(mb_lmin), AV_OPT_TYPE_INT, {.i64 = FF_QP2LAMBDA * 2 }, 1, FF_LAMBDA_MAX, V|E},
-{"mblmax", "maximum macroblock Lagrange factor (VBR)", OFFSET(mb_lmax), AV_OPT_TYPE_INT, {.i64 = FF_QP2LAMBDA * 31 }, 1, FF_LAMBDA_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", "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", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.i64 = 25 }, INT_MIN, INT_MAX, V|E},
-{"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.i64 = 1 }, INT_MIN, INT_MAX, V|E},
-#if FF_API_PRIVATE_OPT
-{"chromaoffset", "chroma QP offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
-#endif
-{"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
-#if FF_API_UNUSED_MEMBERS
-{"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor), AV_OPT_TYPE_INT, {.i64 = 6 }, 0, INT_MAX, V|E},
-#endif /* FF_API_UNUSED_MEMBERS */
-{"mv0_threshold", NULL, OFFSET(mv0_threshold), AV_OPT_TYPE_INT, {.i64 = 256 }, 0, INT_MAX, V|E},
-#if FF_API_PRIVATE_OPT
-{"b_sensitivity", "adjust sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, V|E},
-#endif
-{"compression_level", NULL, OFFSET(compression_level), AV_OPT_TYPE_INT, {.i64 = FF_COMPRESSION_DEFAULT }, INT_MIN, INT_MAX, V|A|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 = -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 = 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"},
-{"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"},
-{"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"},
-{"gamma22", "BT.470 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"gamma28", "BT.470 BG", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"smpte170m", "SMPTE 170 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"smpte240m", "SMPTE 240 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"linear", "Linear", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"log", "Log", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"log_sqrt", "Log square root", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"iec61966_2_4", "IEC 61966-2-4", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"bt1361", "BT.1361", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG }, 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"},
-{"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"},
-{"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"},
-{"bt709", "BT.709", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT709 }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"fcc", "FCC", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_FCC }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"bt470bg", "BT.470 BG", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT470BG }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"smpte170m", "SMPTE 170 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE170M }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"smpte240m", "SMPTE 240 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE240M }, 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"},
-{"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"},
-{"jpeg", "JPEG (2^n-1)", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG }, INT_MIN, INT_MAX, V|E|D, "color_range_type"},
-{"chroma_sample_location", "chroma sample location", OFFSET(chroma_sample_location), AV_OPT_TYPE_INT, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, AVCHROMA_LOC_NB-1, V|E|D, "chroma_sample_location_type"},
-{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
-{"left", "Left", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_LEFT }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
-{"center", "Center", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_CENTER }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
-{"topleft", "Top-left", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_TOPLEFT }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
-{"top", "Top", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_TOP }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_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", "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"},
-{"ma", "Main Audio Service", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_MAIN }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"ef", "Effects", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_EFFECTS }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"vi", "Visually Impaired", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"hi", "Hearing Impaired", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"di", "Dialogue", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_DIALOGUE }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"co", "Commentary", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_COMMENTARY }, INT_MIN, INT_MAX, 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", "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_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},
-};
-
-#undef A
-#undef V
-#undef S
-#undef E
-#undef D
-#undef DEFAULT
-#undef OFFSET
-
-#endif /* AVCODEC_OPTIONS_TABLE_H */
deleted file mode 100644
--- a/media/ffvpx/libavutil/opt.c
+++ /dev/null
@@ -1,1994 +0,0 @@
-/*
- * AVOptions
- * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * AVOptions
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#include "avutil.h"
-#include "avassert.h"
-#include "avstring.h"
-#include "channel_layout.h"
-#include "common.h"
-#include "dict.h"
-#include "eval.h"
-#include "log.h"
-#include "parseutils.h"
-#include "pixdesc.h"
-#include "mathematics.h"
-#include "opt.h"
-#include "samplefmt.h"
-#include "bprint.h"
-
-#include <float.h>
-
-const AVOption *av_opt_next(const void *obj, const AVOption *last)
-{
- const AVClass *class;
- if (!obj)
- return NULL;
- class = *(const AVClass**)obj;
- if (!last && class && class->option && class->option[0].name)
- return class->option;
- if (last && last[1].name)
- return ++last;
- return NULL;
-}
-
-static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
-{
- switch (o->type) {
- case AV_OPT_TYPE_FLAGS:
- *intnum = *(unsigned int*)dst;
- return 0;
- case AV_OPT_TYPE_PIXEL_FMT:
- *intnum = *(enum AVPixelFormat *)dst;
- return 0;
- case AV_OPT_TYPE_SAMPLE_FMT:
- *intnum = *(enum AVSampleFormat *)dst;
- return 0;
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_INT:
- *intnum = *(int *)dst;
- return 0;
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_INT64:
- *intnum = *(int64_t *)dst;
- return 0;
- case AV_OPT_TYPE_FLOAT:
- *num = *(float *)dst;
- return 0;
- case AV_OPT_TYPE_DOUBLE:
- *num = *(double *)dst;
- return 0;
- case AV_OPT_TYPE_RATIONAL:
- *intnum = ((AVRational *)dst)->num;
- *den = ((AVRational *)dst)->den;
- return 0;
- case AV_OPT_TYPE_CONST:
- *num = o->default_val.dbl;
- return 0;
- }
- return AVERROR(EINVAL);
-}
-
-static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
-{
- if (o->type != AV_OPT_TYPE_FLAGS &&
- (o->max * den < num * intnum || o->min * den > num * intnum)) {
- num = den ? num * intnum / den : (num * intnum ? INFINITY : NAN);
- av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
- num, o->name, o->min, o->max);
- return AVERROR(ERANGE);
- }
- if (o->type == AV_OPT_TYPE_FLAGS) {
- double d = num*intnum/den;
- if (d < -1.5 || d > 0xFFFFFFFF+0.5 || (llrint(d*256) & 255)) {
- av_log(obj, AV_LOG_ERROR,
- "Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
- num*intnum/den, o->name);
- return AVERROR(ERANGE);
- }
- }
-
- switch (o->type) {
- case AV_OPT_TYPE_PIXEL_FMT:
- *(enum AVPixelFormat *)dst = llrint(num / den) * intnum;
- break;
- case AV_OPT_TYPE_SAMPLE_FMT:
- *(enum AVSampleFormat *)dst = llrint(num / den) * intnum;
- break;
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_FLAGS:
- case AV_OPT_TYPE_INT:
- *(int *)dst = llrint(num / den) * intnum;
- break;
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- case AV_OPT_TYPE_INT64:
- *(int64_t *)dst = llrint(num / den) * intnum;
- break;
- case AV_OPT_TYPE_FLOAT:
- *(float *)dst = num * intnum / den;
- break;
- case AV_OPT_TYPE_DOUBLE:
- *(double *)dst = num * intnum / den;
- break;
- case AV_OPT_TYPE_RATIONAL:
- case AV_OPT_TYPE_VIDEO_RATE:
- if ((int) num == num)
- *(AVRational *)dst = (AVRational) { num *intnum, den };
- else
- *(AVRational *)dst = av_d2q(num * intnum / den, 1 << 24);
- break;
- default:
- return AVERROR(EINVAL);
- }
- return 0;
-}
-
-static int hexchar2int(char c) {
- if (c >= '0' && c <= '9')
- return c - '0';
- if (c >= 'a' && c <= 'f')
- return c - 'a' + 10;
- if (c >= 'A' && c <= 'F')
- return c - 'A' + 10;
- return -1;
-}
-
-static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
-{
- int *lendst = (int *)(dst + 1);
- uint8_t *bin, *ptr;
- int len;
-
- av_freep(dst);
- *lendst = 0;
-
- if (!val || !(len = strlen(val)))
- return 0;
-
- if (len & 1)
- return AVERROR(EINVAL);
- len /= 2;
-
- ptr = bin = av_malloc(len);
- if (!ptr)
- return AVERROR(ENOMEM);
- while (*val) {
- int a = hexchar2int(*val++);
- int b = hexchar2int(*val++);
- if (a < 0 || b < 0) {
- av_free(bin);
- return AVERROR(EINVAL);
- }
- *ptr++ = (a << 4) | b;
- }
- *dst = bin;
- *lendst = len;
-
- return 0;
-}
-
-static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
-{
- av_freep(dst);
- *dst = av_strdup(val);
- return *dst ? 0 : AVERROR(ENOMEM);
-}
-
-#define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
- opt->type == AV_OPT_TYPE_CONST || \
- opt->type == AV_OPT_TYPE_FLAGS || \
- opt->type == AV_OPT_TYPE_INT) \
- ? opt->default_val.i64 \
- : opt->default_val.dbl)
-
-static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
-{
- int ret = 0;
- int num, den;
- char c;
-
- if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
- if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
- return ret;
- ret = 0;
- }
-
- for (;;) {
- int i = 0;
- char buf[256];
- int cmd = 0;
- double d;
- int64_t intnum = 1;
-
- if (o->type == AV_OPT_TYPE_FLAGS) {
- if (*val == '+' || *val == '-')
- cmd = *(val++);
- for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
- buf[i] = val[i];
- buf[i] = 0;
- }
-
- {
- const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, 0);
- int res;
- int ci = 0;
- double const_values[64];
- const char * const_names[64];
- if (o_named && o_named->type == AV_OPT_TYPE_CONST)
- d = DEFAULT_NUMVAL(o_named);
- else {
- if (o->unit) {
- for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
- if (o_named->type == AV_OPT_TYPE_CONST &&
- o_named->unit &&
- !strcmp(o_named->unit, o->unit)) {
- if (ci + 6 >= FF_ARRAY_ELEMS(const_values)) {
- av_log(obj, AV_LOG_ERROR, "const_values array too small for %s\n", o->unit);
- return AVERROR_PATCHWELCOME;
- }
- const_names [ci ] = o_named->name;
- const_values[ci++] = DEFAULT_NUMVAL(o_named);
- }
- }
- }
- const_names [ci ] = "default";
- const_values[ci++] = DEFAULT_NUMVAL(o);
- const_names [ci ] = "max";
- const_values[ci++] = o->max;
- const_names [ci ] = "min";
- const_values[ci++] = o->min;
- const_names [ci ] = "none";
- const_values[ci++] = 0;
- const_names [ci ] = "all";
- const_values[ci++] = ~0;
- const_names [ci] = NULL;
- const_values[ci] = 0;
-
- res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
- const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
- if (res < 0) {
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
- return res;
- }
- }
- }
- if (o->type == AV_OPT_TYPE_FLAGS) {
- read_number(o, dst, NULL, NULL, &intnum);
- if (cmd == '+')
- d = intnum | (int64_t)d;
- else if (cmd == '-')
- d = intnum &~(int64_t)d;
- }
-
- if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
- return ret;
- val += i;
- if (!i || !*val)
- return 0;
- }
-
- return 0;
-}
-
-static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
-{
- int ret;
-
- if (!val || !strcmp(val, "none")) {
- dst[0] =
- dst[1] = 0;
- return 0;
- }
- ret = av_parse_video_size(dst, dst + 1, val);
- if (ret < 0)
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
- return ret;
-}
-
-static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
-{
- int ret;
- if (!val) {
- ret = AVERROR(EINVAL);
- } else {
- ret = av_parse_video_rate(dst, val);
- }
- if (ret < 0)
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
- return ret;
-}
-
-static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
-{
- int ret;
-
- if (!val) {
- return 0;
- } else {
- ret = av_parse_color(dst, val, -1, obj);
- if (ret < 0)
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
- return ret;
- }
- return 0;
-}
-
-static const char *get_bool_name(int val)
-{
- if (val < 0)
- return "auto";
- return val ? "true" : "false";
-}
-
-static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
-{
- int n;
-
- if (!val)
- return 0;
-
- if (!strcmp(val, "auto")) {
- n = -1;
- } else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
- n = 1;
- } else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
- n = 0;
- } else {
- char *end = NULL;
- n = strtol(val, &end, 10);
- if (val + strlen(val) != end)
- goto fail;
- }
-
- if (n < o->min || n > o->max)
- goto fail;
-
- *dst = n;
- return 0;
-
-fail:
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as boolean\n", val);
- return AVERROR(EINVAL);
-}
-
-static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst,
- int fmt_nb, int ((*get_fmt)(const char *)), const char *desc)
-{
- int fmt, min, max;
-
- if (!val || !strcmp(val, "none")) {
- fmt = -1;
- } else {
- fmt = get_fmt(val);
- if (fmt == -1) {
- char *tail;
- fmt = strtol(val, &tail, 0);
- if (*tail || (unsigned)fmt >= fmt_nb) {
- av_log(obj, AV_LOG_ERROR,
- "Unable to parse option value \"%s\" as %s\n", val, desc);
- return AVERROR(EINVAL);
- }
- }
- }
-
- min = FFMAX(o->min, -1);
- max = FFMIN(o->max, fmt_nb-1);
-
- // hack for compatibility with old ffmpeg
- if(min == 0 && max == 0) {
- min = -1;
- max = fmt_nb-1;
- }
-
- if (fmt < min || fmt > max) {
- av_log(obj, AV_LOG_ERROR,
- "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
- fmt, o->name, desc, min, max);
- return AVERROR(ERANGE);
- }
-
- *(int *)dst = fmt;
- return 0;
-}
-
-static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
-{
- return set_string_fmt(obj, o, val, dst,
- AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
-}
-
-static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
-{
- return set_string_fmt(obj, o, val, dst,
- AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
-}
-
-int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
-{
- int ret = 0;
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (!val && (o->type != AV_OPT_TYPE_STRING &&
- o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
- o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
- o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
- o->type != AV_OPT_TYPE_CHANNEL_LAYOUT && o->type != AV_OPT_TYPE_BOOL))
- return AVERROR(EINVAL);
-
- if (o->flags & AV_OPT_FLAG_READONLY)
- return AVERROR(EINVAL);
-
- dst = ((uint8_t *)target_obj) + o->offset;
- switch (o->type) {
- case AV_OPT_TYPE_BOOL:
- return set_string_bool(obj, o, val, dst);
- case AV_OPT_TYPE_STRING:
- return set_string(obj, o, val, dst);
- case AV_OPT_TYPE_BINARY:
- return set_string_binary(obj, o, val, dst);
- case AV_OPT_TYPE_FLAGS:
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_INT64:
- case AV_OPT_TYPE_FLOAT:
- case AV_OPT_TYPE_DOUBLE:
- case AV_OPT_TYPE_RATIONAL:
- return set_string_number(obj, target_obj, o, val, dst);
- case AV_OPT_TYPE_IMAGE_SIZE:
- return set_string_image_size(obj, o, val, dst);
- case AV_OPT_TYPE_VIDEO_RATE: {
- AVRational tmp;
- ret = set_string_video_rate(obj, o, val, &tmp);
- if (ret < 0)
- return ret;
- return write_number(obj, o, dst, 1, tmp.den, tmp.num);
- }
- case AV_OPT_TYPE_PIXEL_FMT:
- return set_string_pixel_fmt(obj, o, val, dst);
- case AV_OPT_TYPE_SAMPLE_FMT:
- return set_string_sample_fmt(obj, o, val, dst);
- case AV_OPT_TYPE_DURATION:
- if (!val) {
- *(int64_t *)dst = 0;
- return 0;
- } else {
- if ((ret = av_parse_time(dst, val, 1)) < 0)
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
- return ret;
- }
- break;
- case AV_OPT_TYPE_COLOR:
- return set_string_color(obj, o, val, dst);
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- if (!val || !strcmp(val, "none")) {
- *(int64_t *)dst = 0;
- } else {
- int64_t cl = av_get_channel_layout(val);
- if (!cl) {
- av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
- ret = AVERROR(EINVAL);
- }
- *(int64_t *)dst = cl;
- return ret;
- }
- break;
- }
-
- av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
- return AVERROR(EINVAL);
-}
-
-#define OPT_EVAL_NUMBER(name, opttype, vartype) \
-int av_opt_eval_ ## name(void *obj, const AVOption *o, \
- const char *val, vartype *name ## _out) \
-{ \
- if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY) \
- return AVERROR(EINVAL); \
- return set_string_number(obj, obj, o, val, name ## _out); \
-}
-
-OPT_EVAL_NUMBER(flags, AV_OPT_TYPE_FLAGS, int)
-OPT_EVAL_NUMBER(int, AV_OPT_TYPE_INT, int)
-OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
-OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
-OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
-OPT_EVAL_NUMBER(q, AV_OPT_TYPE_RATIONAL, AVRational)
-
-static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
- int search_flags)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
-
- if (o->flags & AV_OPT_FLAG_READONLY)
- return AVERROR(EINVAL);
-
- dst = ((uint8_t *)target_obj) + o->offset;
- return write_number(obj, o, dst, num, den, intnum);
-}
-
-int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
-{
- return set_number(obj, name, 1, 1, val, search_flags);
-}
-
-int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
-{
- return set_number(obj, name, val, 1, 1, search_flags);
-}
-
-int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
-{
- return set_number(obj, name, val.num, val.den, 1, search_flags);
-}
-
-int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
-{
- void *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- uint8_t *ptr;
- uint8_t **dst;
- int *lendst;
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
-
- if (o->type != AV_OPT_TYPE_BINARY || o->flags & AV_OPT_FLAG_READONLY)
- return AVERROR(EINVAL);
-
- ptr = len ? av_malloc(len) : NULL;
- if (len && !ptr)
- return AVERROR(ENOMEM);
-
- dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
- lendst = (int *)(dst + 1);
-
- av_free(*dst);
- *dst = ptr;
- *lendst = len;
- if (len)
- memcpy(ptr, val, len);
-
- return 0;
-}
-
-int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
-{
- void *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
- av_log(obj, AV_LOG_ERROR,
- "The value set by option '%s' is not an image size.\n", o->name);
- return AVERROR(EINVAL);
- }
- if (w<0 || h<0) {
- av_log(obj, AV_LOG_ERROR,
- "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
- return AVERROR(EINVAL);
- }
- *(int *)(((uint8_t *)target_obj) + o->offset) = w;
- *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
- return 0;
-}
-
-int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
-{
- void *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
- av_log(obj, AV_LOG_ERROR,
- "The value set by option '%s' is not a video rate.\n", o->name);
- return AVERROR(EINVAL);
- }
- if (val.num <= 0 || val.den <= 0)
- return AVERROR(EINVAL);
- return set_number(obj, name, val.num, val.den, 1, search_flags);
-}
-
-static int set_format(void *obj, const char *name, int fmt, int search_flags,
- enum AVOptionType type, const char *desc, int nb_fmts)
-{
- void *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0,
- search_flags, &target_obj);
- int min, max;
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != type) {
- av_log(obj, AV_LOG_ERROR,
- "The value set by option '%s' is not a %s format", name, desc);
- return AVERROR(EINVAL);
- }
-
- min = FFMAX(o->min, -1);
- max = FFMIN(o->max, nb_fmts-1);
-
- if (fmt < min || fmt > max) {
- av_log(obj, AV_LOG_ERROR,
- "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
- fmt, name, desc, min, max);
- return AVERROR(ERANGE);
- }
- *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
- return 0;
-}
-
-int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
-{
- return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
-}
-
-int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
-{
- return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
-}
-
-int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
-{
- void *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
- av_log(obj, AV_LOG_ERROR,
- "The value set by option '%s' is not a channel layout.\n", o->name);
- return AVERROR(EINVAL);
- }
- *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
- return 0;
-}
-
-int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
- int search_flags)
-{
- void *target_obj;
- AVDictionary **dst;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->flags & AV_OPT_FLAG_READONLY)
- return AVERROR(EINVAL);
-
- dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
- av_dict_free(dst);
- av_dict_copy(dst, val, 0);
-
- return 0;
-}
-
-static void format_duration(char *buf, size_t size, int64_t d)
-{
- char *e;
-
- av_assert0(size >= 25);
- if (d < 0 && d != INT64_MIN) {
- *(buf++) = '-';
- size--;
- d = -d;
- }
- if (d == INT64_MAX)
- snprintf(buf, size, "INT64_MAX");
- else if (d == INT64_MIN)
- snprintf(buf, size, "INT64_MIN");
- else if (d > (int64_t)3600*1000000)
- snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
- (int)((d / 60000000) % 60),
- (int)((d / 1000000) % 60),
- (int)(d % 1000000));
- else if (d > 60*1000000)
- snprintf(buf, size, "%d:%02d.%06d",
- (int)(d / 60000000),
- (int)((d / 1000000) % 60),
- (int)(d % 1000000));
- else
- snprintf(buf, size, "%d.%06d",
- (int)(d / 1000000),
- (int)(d % 1000000));
- e = buf + strlen(buf);
- while (e > buf && e[-1] == '0')
- *(--e) = 0;
- if (e > buf && e[-1] == '.')
- *(--e) = 0;
-}
-
-int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- uint8_t *bin, buf[128];
- int len, i, ret;
- int64_t i64;
-
- if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
- return AVERROR_OPTION_NOT_FOUND;
-
- dst = (uint8_t *)target_obj + o->offset;
-
- buf[0] = 0;
- switch (o->type) {
- case AV_OPT_TYPE_BOOL:
- ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
- break;
- case AV_OPT_TYPE_FLAGS:
- ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
- break;
- case AV_OPT_TYPE_INT:
- ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
- break;
- case AV_OPT_TYPE_INT64:
- ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
- break;
- case AV_OPT_TYPE_FLOAT:
- ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
- break;
- case AV_OPT_TYPE_DOUBLE:
- ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
- break;
- case AV_OPT_TYPE_VIDEO_RATE:
- case AV_OPT_TYPE_RATIONAL:
- ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
- break;
- case AV_OPT_TYPE_CONST:
- ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
- break;
- case AV_OPT_TYPE_STRING:
- if (*(uint8_t **)dst) {
- *out_val = av_strdup(*(uint8_t **)dst);
- } else if (search_flags & AV_OPT_ALLOW_NULL) {
- *out_val = NULL;
- return 0;
- } else {
- *out_val = av_strdup("");
- }
- return *out_val ? 0 : AVERROR(ENOMEM);
- case AV_OPT_TYPE_BINARY:
- if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
- *out_val = NULL;
- return 0;
- }
- len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
- if ((uint64_t)len * 2 + 1 > INT_MAX)
- return AVERROR(EINVAL);
- if (!(*out_val = av_malloc(len * 2 + 1)))
- return AVERROR(ENOMEM);
- if (!len) {
- *out_val[0] = '\0';
- return 0;
- }
- bin = *(uint8_t **)dst;
- for (i = 0; i < len; i++)
- snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
- return 0;
- case AV_OPT_TYPE_IMAGE_SIZE:
- ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
- break;
- case AV_OPT_TYPE_PIXEL_FMT:
- ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
- break;
- case AV_OPT_TYPE_SAMPLE_FMT:
- ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
- break;
- case AV_OPT_TYPE_DURATION:
- i64 = *(int64_t *)dst;
- format_duration(buf, sizeof(buf), i64);
- ret = strlen(buf); // no overflow possible, checked by an assert
- break;
- case AV_OPT_TYPE_COLOR:
- ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
- (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
- (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
- break;
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- i64 = *(int64_t *)dst;
- ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
- break;
- default:
- return AVERROR(EINVAL);
- }
-
- if (ret >= sizeof(buf))
- return AVERROR(EINVAL);
- *out_val = av_strdup(buf);
- return *out_val ? 0 : AVERROR(ENOMEM);
-}
-
-static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
- int search_flags)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- if (!o || !target_obj)
- goto error;
-
- dst = ((uint8_t *)target_obj) + o->offset;
-
- if (o_out) *o_out= o;
-
- return read_number(o, dst, num, den, intnum);
-
-error:
- *den =
- *intnum = 0;
- return -1;
-}
-
-int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
-{
- int64_t intnum = 1;
- double num = 1;
- int ret, den = 1;
-
- if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
- return ret;
- *out_val = num * intnum / den;
- return 0;
-}
-
-int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
-{
- int64_t intnum = 1;
- double num = 1;
- int ret, den = 1;
-
- if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
- return ret;
- *out_val = num * intnum / den;
- return 0;
-}
-
-int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
-{
- int64_t intnum = 1;
- double num = 1;
- int ret, den = 1;
-
- if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
- return ret;
-
- if (num == 1.0 && (int)intnum == intnum)
- *out_val = (AVRational){intnum, den};
- else
- *out_val = av_d2q(num*intnum/den, 1<<24);
- return 0;
-}
-
-int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
- av_log(obj, AV_LOG_ERROR,
- "The value for option '%s' is not an image size.\n", name);
- return AVERROR(EINVAL);
- }
-
- dst = ((uint8_t*)target_obj) + o->offset;
- if (w_out) *w_out = *(int *)dst;
- if (h_out) *h_out = *((int *)dst+1);
- return 0;
-}
-
-int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
-{
- int64_t intnum = 1;
- double num = 1;
- int ret, den = 1;
-
- if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
- return ret;
-
- if (num == 1.0 && (int)intnum == intnum)
- *out_val = (AVRational) { intnum, den };
- else
- *out_val = av_d2q(num * intnum / den, 1 << 24);
- return 0;
-}
-
-static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
- enum AVOptionType type, const char *desc)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != type) {
- av_log(obj, AV_LOG_ERROR,
- "The value for option '%s' is not a %s format.\n", desc, name);
- return AVERROR(EINVAL);
- }
-
- dst = ((uint8_t*)target_obj) + o->offset;
- *out_fmt = *(int *)dst;
- return 0;
-}
-
-int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
-{
- return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
-}
-
-int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
-{
- return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
-}
-
-int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
-{
- void *dst, *target_obj;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
- av_log(obj, AV_LOG_ERROR,
- "The value for option '%s' is not a channel layout.\n", name);
- return AVERROR(EINVAL);
- }
-
- dst = ((uint8_t*)target_obj) + o->offset;
- *cl = *(int64_t *)dst;
- return 0;
-}
-
-int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
-{
- void *target_obj;
- AVDictionary *src;
- const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
-
- if (!o || !target_obj)
- return AVERROR_OPTION_NOT_FOUND;
- if (o->type != AV_OPT_TYPE_DICT)
- return AVERROR(EINVAL);
-
- src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
- av_dict_copy(out_val, src, 0);
-
- return 0;
-}
-
-int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
-{
- const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
- const AVOption *flag = av_opt_find(obj, flag_name,
- field ? field->unit : NULL, 0, 0);
- int64_t res;
-
- if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
- av_opt_get_int(obj, field_name, 0, &res) < 0)
- return 0;
- return res & flag->default_val.i64;
-}
-
-static void log_value(void *av_log_obj, int level, double d)
-{
- if (d == INT_MAX) {
- av_log(av_log_obj, level, "INT_MAX");
- } else if (d == INT_MIN) {
- av_log(av_log_obj, level, "INT_MIN");
- } else if (d == UINT32_MAX) {
- av_log(av_log_obj, level, "UINT32_MAX");
- } else if (d == (double)INT64_MAX) {
- av_log(av_log_obj, level, "I64_MAX");
- } else if (d == INT64_MIN) {
- av_log(av_log_obj, level, "I64_MIN");
- } else if (d == FLT_MAX) {
- av_log(av_log_obj, level, "FLT_MAX");
- } else if (d == FLT_MIN) {
- av_log(av_log_obj, level, "FLT_MIN");
- } else if (d == -FLT_MAX) {
- av_log(av_log_obj, level, "-FLT_MAX");
- } else if (d == -FLT_MIN) {
- av_log(av_log_obj, level, "-FLT_MIN");
- } else if (d == DBL_MAX) {
- av_log(av_log_obj, level, "DBL_MAX");
- } else if (d == DBL_MIN) {
- av_log(av_log_obj, level, "DBL_MIN");
- } else if (d == -DBL_MAX) {
- av_log(av_log_obj, level, "-DBL_MAX");
- } else if (d == -DBL_MIN) {
- av_log(av_log_obj, level, "-DBL_MIN");
- } else {
- av_log(av_log_obj, level, "%g", d);
- }
-}
-
-static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
-{
- const AVOption *opt = NULL;
-
- if (!unit)
- return NULL;
- while ((opt = av_opt_next(obj, opt)))
- if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
- opt->default_val.i64 == value)
- return opt->name;
- return NULL;
-}
-
-static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
-{
- const AVOption *opt = NULL;
- char flags[512];
-
- flags[0] = 0;
- if (!unit)
- return NULL;
- while ((opt = av_opt_next(obj, opt))) {
- if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
- opt->default_val.i64 & value) {
- if (flags[0])
- av_strlcatf(flags, sizeof(flags), "+");
- av_strlcatf(flags, sizeof(flags), "%s", opt->name);
- }
- }
- if (flags[0])
- return av_strdup(flags);
- return NULL;
-}
-
-static void opt_list(void *obj, void *av_log_obj, const char *unit,
- int req_flags, int rej_flags)
-{
- const AVOption *opt = NULL;
- AVOptionRanges *r;
- int i;
-
- while ((opt = av_opt_next(obj, opt))) {
- if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
- continue;
-
- /* Don't print CONST's on level one.
- * Don't print anything but CONST's on level two.
- * Only print items from the requested unit.
- */
- if (!unit && opt->type == AV_OPT_TYPE_CONST)
- continue;
- else if (unit && opt->type != AV_OPT_TYPE_CONST)
- continue;
- else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
- continue;
- else if (unit && opt->type == AV_OPT_TYPE_CONST)
- av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
- else
- av_log(av_log_obj, AV_LOG_INFO, " %s%-17s ",
- (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
- opt->name);
-
- switch (opt->type) {
- case AV_OPT_TYPE_FLAGS:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
- break;
- case AV_OPT_TYPE_INT:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
- break;
- case AV_OPT_TYPE_INT64:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
- break;
- case AV_OPT_TYPE_DOUBLE:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
- break;
- case AV_OPT_TYPE_FLOAT:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
- break;
- case AV_OPT_TYPE_STRING:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
- break;
- case AV_OPT_TYPE_RATIONAL:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
- break;
- case AV_OPT_TYPE_BINARY:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
- break;
- case AV_OPT_TYPE_IMAGE_SIZE:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
- break;
- case AV_OPT_TYPE_VIDEO_RATE:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
- break;
- case AV_OPT_TYPE_PIXEL_FMT:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
- break;
- case AV_OPT_TYPE_SAMPLE_FMT:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
- break;
- case AV_OPT_TYPE_DURATION:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
- break;
- case AV_OPT_TYPE_COLOR:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
- break;
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
- break;
- case AV_OPT_TYPE_BOOL:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
- break;
- case AV_OPT_TYPE_CONST:
- default:
- av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
- break;
- }
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
- av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
-
- if (opt->help)
- av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
-
- if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
- switch (opt->type) {
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_INT64:
- case AV_OPT_TYPE_DOUBLE:
- case AV_OPT_TYPE_FLOAT:
- case AV_OPT_TYPE_RATIONAL:
- for (i = 0; i < r->nb_ranges; i++) {
- av_log(av_log_obj, AV_LOG_INFO, " (from ");
- log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
- av_log(av_log_obj, AV_LOG_INFO, " to ");
- log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
- av_log(av_log_obj, AV_LOG_INFO, ")");
- }
- break;
- }
- av_opt_freep_ranges(&r);
- }
-
- if (opt->type != AV_OPT_TYPE_CONST &&
- opt->type != AV_OPT_TYPE_BINARY &&
- !((opt->type == AV_OPT_TYPE_COLOR ||
- opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
- opt->type == AV_OPT_TYPE_STRING ||
- opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
- !opt->default_val.str)) {
- av_log(av_log_obj, AV_LOG_INFO, " (default ");
- switch (opt->type) {
- case AV_OPT_TYPE_BOOL:
- av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
- break;
- case AV_OPT_TYPE_FLAGS: {
- char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
- if (def_flags) {
- av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
- av_freep(&def_flags);
- } else {
- av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
- }
- break;
- }
- case AV_OPT_TYPE_DURATION: {
- char buf[25];
- format_duration(buf, sizeof(buf), opt->default_val.i64);
- av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
- break;
- }
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_INT64: {
- const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
- if (def_const)
- av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
- else
- log_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
- break;
- }
- case AV_OPT_TYPE_DOUBLE:
- case AV_OPT_TYPE_FLOAT:
- log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
- break;
- case AV_OPT_TYPE_RATIONAL: {
- AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
- av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
- break;
- case AV_OPT_TYPE_PIXEL_FMT:
- av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
- break;
- case AV_OPT_TYPE_SAMPLE_FMT:
- av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
- break;
- case AV_OPT_TYPE_COLOR:
- case AV_OPT_TYPE_IMAGE_SIZE:
- case AV_OPT_TYPE_STRING:
- case AV_OPT_TYPE_VIDEO_RATE:
- av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
- break;
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
- break;
- }
- av_log(av_log_obj, AV_LOG_INFO, ")");
- }
-
- av_log(av_log_obj, AV_LOG_INFO, "\n");
- if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
- opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
- }
-}
-
-int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
-{
- if (!obj)
- return -1;
-
- av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
-
- opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
-
- return 0;
-}
-
-void av_opt_set_defaults(void *s)
-{
- av_opt_set_defaults2(s, 0, 0);
-}
-
-void av_opt_set_defaults2(void *s, int mask, int flags)
-{
- const AVOption *opt = NULL;
- while ((opt = av_opt_next(s, opt))) {
- void *dst = ((uint8_t*)s) + opt->offset;
-
- if ((opt->flags & mask) != flags)
- continue;
-
- if (opt->flags & AV_OPT_FLAG_READONLY)
- continue;
-
- switch (opt->type) {
- case AV_OPT_TYPE_CONST:
- /* Nothing to be done here */
- break;
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_FLAGS:
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_INT64:
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- case AV_OPT_TYPE_PIXEL_FMT:
- case AV_OPT_TYPE_SAMPLE_FMT:
- write_number(s, opt, dst, 1, 1, opt->default_val.i64);
- break;
- case AV_OPT_TYPE_DOUBLE:
- case AV_OPT_TYPE_FLOAT: {
- double val;
- val = opt->default_val.dbl;
- write_number(s, opt, dst, val, 1, 1);
- }
- break;
- case AV_OPT_TYPE_RATIONAL: {
- AVRational val;
- val = av_d2q(opt->default_val.dbl, INT_MAX);
- write_number(s, opt, dst, 1, val.den, val.num);
- }
- break;
- case AV_OPT_TYPE_COLOR:
- set_string_color(s, opt, opt->default_val.str, dst);
- break;
- case AV_OPT_TYPE_STRING:
- set_string(s, opt, opt->default_val.str, dst);
- break;
- case AV_OPT_TYPE_IMAGE_SIZE:
- set_string_image_size(s, opt, opt->default_val.str, dst);
- break;
- case AV_OPT_TYPE_VIDEO_RATE:
- set_string_video_rate(s, opt, opt->default_val.str, dst);
- break;
- case AV_OPT_TYPE_BINARY:
- set_string_binary(s, opt, opt->default_val.str, dst);
- break;
- case AV_OPT_TYPE_DICT:
- /* Cannot set defaults for these types */
- break;
- default:
- av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
- opt->type, opt->name);
- }
- }
-}
-
-/**
- * Store the value in the field in ctx that is named like key.
- * ctx must be an AVClass context, storing is done using AVOptions.
- *
- * @param buf the string to parse, buf will be updated to point at the
- * separator just after the parsed key/value pair
- * @param key_val_sep a 0-terminated list of characters used to
- * separate key from value
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other
- * @return 0 if the key/value pair has been successfully parsed and
- * set, or a negative value corresponding to an AVERROR code in case
- * of error:
- * AVERROR(EINVAL) if the key/value pair cannot be parsed,
- * the error code issued by av_opt_set() if the key/value pair
- * cannot be set
- */
-static int parse_key_value_pair(void *ctx, const char **buf,
- const char *key_val_sep, const char *pairs_sep)
-{
- char *key = av_get_token(buf, key_val_sep);
- char *val;
- int ret;
-
- if (!key)
- return AVERROR(ENOMEM);
-
- if (*key && strspn(*buf, key_val_sep)) {
- (*buf)++;
- val = av_get_token(buf, pairs_sep);
- if (!val) {
- av_freep(&key);
- return AVERROR(ENOMEM);
- }
- } else {
- av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
- av_free(key);
- return AVERROR(EINVAL);
- }
-
- av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
-
- ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
- if (ret == AVERROR_OPTION_NOT_FOUND)
- av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
-
- av_free(key);
- av_free(val);
- return ret;
-}
-
-int av_set_options_string(void *ctx, const char *opts,
- const char *key_val_sep, const char *pairs_sep)
-{
- int ret, count = 0;
-
- if (!opts)
- return 0;
-
- while (*opts) {
- if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
- return ret;
- count++;
-
- if (*opts)
- opts++;
- }
-
- return count;
-}
-
-#define WHITESPACES " \n\t\r"
-
-static int is_key_char(char c)
-{
- return (unsigned)((c | 32) - 'a') < 26 ||
- (unsigned)(c - '0') < 10 ||
- c == '-' || c == '_' || c == '/' || c == '.';
-}
-
-/**
- * Read a key from a string.
- *
- * The key consists of is_key_char characters and must be terminated by a
- * character from the delim string; spaces are ignored.
- *
- * @return 0 for success (even with ellipsis), <0 for failure
- */
-static int get_key(const char **ropts, const char *delim, char **rkey)
-{
- const char *opts = *ropts;
- const char *key_start, *key_end;
-
- key_start = opts += strspn(opts, WHITESPACES);
- while (is_key_char(*opts))
- opts++;
- key_end = opts;
- opts += strspn(opts, WHITESPACES);
- if (!*opts || !strchr(delim, *opts))
- return AVERROR(EINVAL);
- opts++;
- if (!(*rkey = av_malloc(key_end - key_start + 1)))
- return AVERROR(ENOMEM);
- memcpy(*rkey, key_start, key_end - key_start);
- (*rkey)[key_end - key_start] = 0;
- *ropts = opts;
- return 0;
-}
-
-int av_opt_get_key_value(const char **ropts,
- const char *key_val_sep, const char *pairs_sep,
- unsigned flags,
- char **rkey, char **rval)
-{
- int ret;
- char *key = NULL, *val;
- const char *opts = *ropts;
-
- if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
- !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
- return AVERROR(EINVAL);
- if (!(val = av_get_token(&opts, pairs_sep))) {
- av_free(key);
- return AVERROR(ENOMEM);
- }
- *ropts = opts;
- *rkey = key;
- *rval = val;
- return 0;
-}
-
-int av_opt_set_from_string(void *ctx, const char *opts,
- const char *const *shorthand,
- const char *key_val_sep, const char *pairs_sep)
-{
- int ret, count = 0;
- const char *dummy_shorthand = NULL;
- char *av_uninit(parsed_key), *av_uninit(value);
- const char *key;
-
- if (!opts)
- return 0;
- if (!shorthand)
- shorthand = &dummy_shorthand;
-
- while (*opts) {
- ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
- *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
- &parsed_key, &value);
- if (ret < 0) {
- if (ret == AVERROR(EINVAL))
- av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
- else
- av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
- av_err2str(ret));
- return ret;
- }
- if (*opts)
- opts++;
- if (parsed_key) {
- key = parsed_key;
- while (*shorthand) /* discard all remaining shorthand */
- shorthand++;
- } else {
- key = *(shorthand++);
- }
-
- av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
- if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
- if (ret == AVERROR_OPTION_NOT_FOUND)
- av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
- av_free(value);
- av_free(parsed_key);
- return ret;
- }
-
- av_free(value);
- av_free(parsed_key);
- count++;
- }
- return count;
-}
-
-void av_opt_free(void *obj)
-{
- const AVOption *o = NULL;
- while ((o = av_opt_next(obj, o))) {
- switch (o->type) {
- case AV_OPT_TYPE_STRING:
- case AV_OPT_TYPE_BINARY:
- av_freep((uint8_t *)obj + o->offset);
- break;
-
- case AV_OPT_TYPE_DICT:
- av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
- break;
-
- default:
- break;
- }
- }
-}
-
-int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
-{
- AVDictionaryEntry *t = NULL;
- AVDictionary *tmp = NULL;
- int ret = 0;
-
- if (!options)
- return 0;
-
- while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
- ret = av_opt_set(obj, t->key, t->value, search_flags);
- if (ret == AVERROR_OPTION_NOT_FOUND)
- ret = av_dict_set(&tmp, t->key, t->value, 0);
- if (ret < 0) {
- av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
- av_dict_free(&tmp);
- return ret;
- }
- ret = 0;
- }
- av_dict_free(options);
- *options = tmp;
- return ret;
-}
-
-int av_opt_set_dict(void *obj, AVDictionary **options)
-{
- return av_opt_set_dict2(obj, options, 0);
-}
-
-const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
- int opt_flags, int search_flags)
-{
- return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
-}
-
-const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
- int opt_flags, int search_flags, void **target_obj)
-{
- const AVClass *c;
- const AVOption *o = NULL;
-
- if(!obj)
- return NULL;
-
- c= *(AVClass**)obj;
-
- if (!c)
- return NULL;
-
- if (search_flags & AV_OPT_SEARCH_CHILDREN) {
- if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
- const AVClass *child = NULL;
- while (child = av_opt_child_class_next(c, child))
- if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
- return o;
- } else {
- void *child = NULL;
- while (child = av_opt_child_next(obj, child))
- if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
- return o;
- }
- }
-
- while (o = av_opt_next(obj, o)) {
- if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
- ((!unit && o->type != AV_OPT_TYPE_CONST) ||
- (unit && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
- if (target_obj) {
- if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
- *target_obj = obj;
- else
- *target_obj = NULL;
- }
- return o;
- }
- }
- return NULL;
-}
-
-void *av_opt_child_next(void *obj, void *prev)
-{
- const AVClass *c = *(AVClass **)obj;
- if (c->child_next)
- return c->child_next(obj, prev);
- return NULL;
-}
-
-const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
-{
- if (parent->child_class_next)
- return parent->child_class_next(prev);
- return NULL;
-}
-
-void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
-{
- const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
- if(!opt)
- return NULL;
- return (uint8_t*)obj + opt->offset;
-}
-
-static int opt_size(enum AVOptionType type)
-{
- switch(type) {
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_FLAGS:
- return sizeof(int);
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- case AV_OPT_TYPE_INT64:
- return sizeof(int64_t);
- case AV_OPT_TYPE_DOUBLE:
- return sizeof(double);
- case AV_OPT_TYPE_FLOAT:
- return sizeof(float);
- case AV_OPT_TYPE_STRING:
- return sizeof(uint8_t*);
- case AV_OPT_TYPE_VIDEO_RATE:
- case AV_OPT_TYPE_RATIONAL:
- return sizeof(AVRational);
- case AV_OPT_TYPE_BINARY:
- return sizeof(uint8_t*) + sizeof(int);
- case AV_OPT_TYPE_IMAGE_SIZE:
- return sizeof(int[2]);
- case AV_OPT_TYPE_PIXEL_FMT:
- return sizeof(enum AVPixelFormat);
- case AV_OPT_TYPE_SAMPLE_FMT:
- return sizeof(enum AVSampleFormat);
- case AV_OPT_TYPE_COLOR:
- return 4;
- }
- return AVERROR(EINVAL);
-}
-
-int av_opt_copy(void *dst, const void *src)
-{
- const AVOption *o = NULL;
- const AVClass *c;
- int ret = 0;
-
- if (!src)
- return AVERROR(EINVAL);
-
- c = *(AVClass **)src;
- if (!c || c != *(AVClass **)dst)
- return AVERROR(EINVAL);
-
- while ((o = av_opt_next(src, o))) {
- void *field_dst = (uint8_t *)dst + o->offset;
- void *field_src = (uint8_t *)src + o->offset;
- uint8_t **field_dst8 = (uint8_t **)field_dst;
- uint8_t **field_src8 = (uint8_t **)field_src;
-
- if (o->type == AV_OPT_TYPE_STRING) {
- if (*field_dst8 != *field_src8)
- av_freep(field_dst8);
- *field_dst8 = av_strdup(*field_src8);
- if (*field_src8 && !*field_dst8)
- ret = AVERROR(ENOMEM);
- } else if (o->type == AV_OPT_TYPE_BINARY) {
- int len = *(int *)(field_src8 + 1);
- if (*field_dst8 != *field_src8)
- av_freep(field_dst8);
- *field_dst8 = av_memdup(*field_src8, len);
- if (len && !*field_dst8) {
- ret = AVERROR(ENOMEM);
- len = 0;
- }
- *(int *)(field_dst8 + 1) = len;
- } else if (o->type == AV_OPT_TYPE_CONST) {
- // do nothing
- } else if (o->type == AV_OPT_TYPE_DICT) {
- AVDictionary **sdict = (AVDictionary **) field_src;
- AVDictionary **ddict = (AVDictionary **) field_dst;
- if (*sdict != *ddict)
- av_dict_free(ddict);
- *ddict = NULL;
- av_dict_copy(ddict, *sdict, 0);
- if (av_dict_count(*sdict) != av_dict_count(*ddict))
- ret = AVERROR(ENOMEM);
- } else {
- int size = opt_size(o->type);
- if (size < 0)
- ret = size;
- else
- memcpy(field_dst, field_src, size);
- }
- }
- return ret;
-}
-
-int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
-{
- int ret;
- const AVClass *c = *(AVClass**)obj;
- int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
-
- if (c->version > (52 << 16 | 11 << 8))
- callback = c->query_ranges;
-
- if (!callback)
- callback = av_opt_query_ranges_default;
-
- ret = callback(ranges_arg, obj, key, flags);
- if (ret >= 0) {
- if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
- ret = 1;
- (*ranges_arg)->nb_components = ret;
- }
- return ret;
-}
-
-int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
-{
- AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
- AVOptionRange **range_array = av_mallocz(sizeof(void*));
- AVOptionRange *range = av_mallocz(sizeof(*range));
- const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
- int ret;
-
- *ranges_arg = NULL;
-
- if (!ranges || !range || !range_array || !field) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
-
- ranges->range = range_array;
- ranges->range[0] = range;
- ranges->nb_ranges = 1;
- ranges->nb_components = 1;
- range->is_range = 1;
- range->value_min = field->min;
- range->value_max = field->max;
-
- switch (field->type) {
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_INT64:
- case AV_OPT_TYPE_PIXEL_FMT:
- case AV_OPT_TYPE_SAMPLE_FMT:
- case AV_OPT_TYPE_FLOAT:
- case AV_OPT_TYPE_DOUBLE:
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_COLOR:
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- break;
- case AV_OPT_TYPE_STRING:
- range->component_min = 0;
- range->component_max = 0x10FFFF; // max unicode value
- range->value_min = -1;
- range->value_max = INT_MAX;
- break;
- case AV_OPT_TYPE_RATIONAL:
- range->component_min = INT_MIN;
- range->component_max = INT_MAX;
- break;
- case AV_OPT_TYPE_IMAGE_SIZE:
- range->component_min = 0;
- range->component_max = INT_MAX/128/8;
- range->value_min = 0;
- range->value_max = INT_MAX/8;
- break;
- case AV_OPT_TYPE_VIDEO_RATE:
- range->component_min = 1;
- range->component_max = INT_MAX;
- range->value_min = 1;
- range->value_max = INT_MAX;
- break;
- default:
- ret = AVERROR(ENOSYS);
- goto fail;
- }
-
- *ranges_arg = ranges;
- return 1;
-fail:
- av_free(ranges);
- av_free(range);
- av_free(range_array);
- return ret;
-}
-
-void av_opt_freep_ranges(AVOptionRanges **rangesp)
-{
- int i;
- AVOptionRanges *ranges = *rangesp;
-
- if (!ranges)
- return;
-
- for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
- AVOptionRange *range = ranges->range[i];
- if (range) {
- av_freep(&range->str);
- av_freep(&ranges->range[i]);
- }
- }
- av_freep(&ranges->range);
- av_freep(rangesp);
-}
-
-int av_opt_is_set_to_default(void *obj, const AVOption *o)
-{
- int64_t i64;
- double d, d2;
- float f;
- AVRational q;
- int ret, w, h;
- char *str;
- void *dst;
-
- if (!o || !obj)
- return AVERROR(EINVAL);
-
- dst = ((uint8_t*)obj) + o->offset;
-
- switch (o->type) {
- case AV_OPT_TYPE_CONST:
- return 1;
- case AV_OPT_TYPE_BOOL:
- case AV_OPT_TYPE_FLAGS:
- case AV_OPT_TYPE_PIXEL_FMT:
- case AV_OPT_TYPE_SAMPLE_FMT:
- case AV_OPT_TYPE_INT:
- case AV_OPT_TYPE_CHANNEL_LAYOUT:
- case AV_OPT_TYPE_DURATION:
- case AV_OPT_TYPE_INT64:
- read_number(o, dst, NULL, NULL, &i64);
- return o->default_val.i64 == i64;
- case AV_OPT_TYPE_STRING:
- str = *(char **)dst;
- if (str == o->default_val.str) //2 NULLs
- return 1;
- if (!str || !o->default_val.str) //1 NULL
- return 0;
- return !strcmp(str, o->default_val.str);
- case AV_OPT_TYPE_DOUBLE:
- read_number(o, dst, &d, NULL, NULL);
- return o->default_val.dbl == d;
- case AV_OPT_TYPE_FLOAT:
- read_number(o, dst, &d, NULL, NULL);
- f = o->default_val.dbl;
- d2 = f;
- return d2 == d;
- case AV_OPT_TYPE_RATIONAL:
- q = av_d2q(o->default_val.dbl, INT_MAX);
- return !av_cmp_q(*(AVRational*)dst, q);
- case AV_OPT_TYPE_BINARY: {
- struct {
- uint8_t *data;
- int size;
- } tmp = {0};
- int opt_size = *(int *)((void **)dst + 1);
- void *opt_ptr = *(void **)dst;
- if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
- return 1;
- if (!opt_size || !o->default_val.str || !strlen(o->default_val.str ))
- return 0;
- if (opt_size != strlen(o->default_val.str) / 2)
- return 0;
- ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
- if (!ret)
- ret = !memcmp(opt_ptr, tmp.data, tmp.size);
- av_free(tmp.data);
- return ret;
- }
- case AV_OPT_TYPE_DICT:
- /* Binary and dict have not default support yet. Any pointer is not default. */
- return !!(*(void **)dst);
- case AV_OPT_TYPE_IMAGE_SIZE:
- if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
- w = h = 0;
- else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
- return ret;
- return (w == *(int *)dst) && (h == *((int *)dst+1));
- case AV_OPT_TYPE_VIDEO_RATE:
- q = (AVRational){0, 0};
- if (o->default_val.str) {
- if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
- return ret;
- }
- return !av_cmp_q(*(AVRational*)dst, q);
- case AV_OPT_TYPE_COLOR: {
- uint8_t color[4] = {0, 0, 0, 0};
- if (o->default_val.str) {
- if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
- return ret;
- }
- return !memcmp(color, dst, sizeof(color));
- }
- default:
- av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
- break;
- }
- return AVERROR_PATCHWELCOME;
-}
-
-int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
-{
- const AVOption *o;
- void *target;
- if (!obj)
- return AVERROR(EINVAL);
- o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
- if (!o)
- return AVERROR_OPTION_NOT_FOUND;
- return av_opt_is_set_to_default(target, o);
-}
-
-int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
- const char key_val_sep, const char pairs_sep)
-{
- const AVOption *o = NULL;
- uint8_t *buf;
- AVBPrint bprint;
- int ret, cnt = 0;
- const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
-
- if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
- pairs_sep == '\\' || key_val_sep == '\\') {
- av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
- return AVERROR(EINVAL);
- }
-
- if (!obj || !buffer)
- return AVERROR(EINVAL);
-
- *buffer = NULL;
- av_bprint_init(&bprint, 64, AV_BPRINT_SIZE_UNLIMITED);
-
- while (o = av_opt_next(obj, o)) {
- if (o->type == AV_OPT_TYPE_CONST)
- continue;
- if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
- continue;
- else if (((o->flags & opt_flags) != opt_flags))
- continue;
- if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
- continue;
- if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
- av_bprint_finalize(&bprint, NULL);
- return ret;
- }
- if (buf) {
- if (cnt++)
- av_bprint_append_data(&bprint, &pairs_sep, 1);
- av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
- av_bprint_append_data(&bprint, &key_val_sep, 1);
- av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
- av_freep(&buf);
- }
- }
- av_bprint_finalize(&bprint, buffer);
- return 0;
-}