LCOV - code coverage report
Current view: top level - libavutil - opt.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 972 1293 75.2 %
Date: 2018-05-20 11:54:08 Functions: 56 77 72.7 %

          Line data    Source code
       1             : /*
       2             :  * AVOptions
       3             :  * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * AVOptions
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #include "avutil.h"
      29             : #include "avassert.h"
      30             : #include "avstring.h"
      31             : #include "channel_layout.h"
      32             : #include "common.h"
      33             : #include "dict.h"
      34             : #include "eval.h"
      35             : #include "log.h"
      36             : #include "parseutils.h"
      37             : #include "pixdesc.h"
      38             : #include "mathematics.h"
      39             : #include "opt.h"
      40             : #include "samplefmt.h"
      41             : #include "bprint.h"
      42             : 
      43             : #include <float.h>
      44             : 
      45   366862387 : const AVOption *av_opt_next(const void *obj, const AVOption *last)
      46             : {
      47             :     const AVClass *class;
      48   366862387 :     if (!obj)
      49           0 :         return NULL;
      50   366862387 :     class = *(const AVClass**)obj;
      51   366862387 :     if (!last && class && class->option && class->option[0].name)
      52    20941431 :         return class->option;
      53   345920956 :     if (last && last[1].name)
      54   324980691 :         return ++last;
      55    20940265 :     return NULL;
      56             : }
      57             : 
      58       89431 : static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
      59             : {
      60       89431 :     switch (o->type) {
      61       75700 :     case AV_OPT_TYPE_FLAGS:
      62       75700 :         *intnum = *(unsigned int*)dst;
      63       75700 :         return 0;
      64           2 :     case AV_OPT_TYPE_PIXEL_FMT:
      65           2 :         *intnum = *(enum AVPixelFormat *)dst;
      66           2 :         return 0;
      67           2 :     case AV_OPT_TYPE_SAMPLE_FMT:
      68           2 :         *intnum = *(enum AVSampleFormat *)dst;
      69           2 :         return 0;
      70       11389 :     case AV_OPT_TYPE_BOOL:
      71             :     case AV_OPT_TYPE_INT:
      72       11389 :         *intnum = *(int *)dst;
      73       11389 :         return 0;
      74        2334 :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
      75             :     case AV_OPT_TYPE_DURATION:
      76             :     case AV_OPT_TYPE_INT64:
      77             :     case AV_OPT_TYPE_UINT64:
      78        2334 :         *intnum = *(int64_t *)dst;
      79        2334 :         return 0;
      80           2 :     case AV_OPT_TYPE_FLOAT:
      81           2 :         *num = *(float *)dst;
      82           2 :         return 0;
      83           2 :     case AV_OPT_TYPE_DOUBLE:
      84           2 :         *num = *(double *)dst;
      85           2 :         return 0;
      86           0 :     case AV_OPT_TYPE_RATIONAL:
      87           0 :         *intnum = ((AVRational *)dst)->num;
      88           0 :         *den    = ((AVRational *)dst)->den;
      89           0 :         return 0;
      90           0 :     case AV_OPT_TYPE_CONST:
      91           0 :         *num = o->default_val.dbl;
      92           0 :         return 0;
      93             :     }
      94           0 :     return AVERROR(EINVAL);
      95             : }
      96             : 
      97     7347567 : static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
      98             : {
      99     7347567 :     if (o->type != AV_OPT_TYPE_FLAGS &&
     100     6747385 :         (!den || o->max * den < num * intnum || o->min * den > num * intnum)) {
     101          11 :         num = den ? num * intnum / den : (num && intnum ? INFINITY : NAN);
     102          11 :         av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
     103             :                num, o->name, o->min, o->max);
     104          11 :         return AVERROR(ERANGE);
     105             :     }
     106     7347556 :     if (o->type == AV_OPT_TYPE_FLAGS) {
     107      600181 :         double d = num*intnum/den;
     108      600181 :         if (d < -1.5 || d > 0xFFFFFFFF+0.5 || (llrint(d*256) & 255)) {
     109           0 :             av_log(obj, AV_LOG_ERROR,
     110             :                    "Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
     111           0 :                    num*intnum/den, o->name);
     112           0 :             return AVERROR(ERANGE);
     113             :         }
     114             :     }
     115             : 
     116     7347556 :     switch (o->type) {
     117       66053 :     case AV_OPT_TYPE_PIXEL_FMT:
     118       66053 :         *(enum AVPixelFormat *)dst = llrint(num / den) * intnum;
     119       66053 :         break;
     120       49799 :     case AV_OPT_TYPE_SAMPLE_FMT:
     121       49799 :         *(enum AVSampleFormat *)dst = llrint(num / den) * intnum;
     122       49799 :         break;
     123     5927545 :     case AV_OPT_TYPE_BOOL:
     124             :     case AV_OPT_TYPE_FLAGS:
     125             :     case AV_OPT_TYPE_INT:
     126     5927545 :         *(int *)dst = llrint(num / den) * intnum;
     127     5927545 :         break;
     128      363225 :     case AV_OPT_TYPE_DURATION:
     129             :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     130             :     case AV_OPT_TYPE_INT64:{
     131      363225 :         double d = num / den;
     132      363225 :         if (intnum == 1 && d == (double)INT64_MAX) {
     133           0 :             *(int64_t *)dst = INT64_MAX;
     134             :         } else
     135      363225 :             *(int64_t *)dst = llrint(d) * intnum;
     136      363225 :         break;}
     137       78033 :     case AV_OPT_TYPE_UINT64:{
     138       78033 :         double d = num / den;
     139             :         // We must special case uint64_t here as llrint() does not support values
     140             :         // outside the int64_t range and there is no portable function which does
     141             :         // "INT64_MAX + 1ULL" is used as it is representable exactly as IEEE double
     142             :         // while INT64_MAX is not
     143       78033 :         if (intnum == 1 && d == (double)UINT64_MAX) {
     144           0 :             *(uint64_t *)dst = UINT64_MAX;
     145       78033 :         } else if (d > INT64_MAX + 1ULL) {
     146           0 :             *(uint64_t *)dst = (llrint(d - (INT64_MAX + 1ULL)) + (INT64_MAX + 1ULL))*intnum;
     147             :         } else {
     148       78033 :             *(uint64_t *)dst = llrint(d) * intnum;
     149             :         }
     150       78033 :         break;}
     151      613597 :     case AV_OPT_TYPE_FLOAT:
     152      613597 :         *(float *)dst = num * intnum / den;
     153      613597 :         break;
     154       36763 :     case AV_OPT_TYPE_DOUBLE:
     155       36763 :         *(double    *)dst = num * intnum / den;
     156       36763 :         break;
     157      212541 :     case AV_OPT_TYPE_RATIONAL:
     158             :     case AV_OPT_TYPE_VIDEO_RATE:
     159      212541 :         if ((int) num == num)
     160      212541 :             *(AVRational *)dst = (AVRational) { num *intnum, den };
     161             :         else
     162           0 :             *(AVRational *)dst = av_d2q(num * intnum / den, 1 << 24);
     163      212541 :         break;
     164           0 :     default:
     165           0 :         return AVERROR(EINVAL);
     166             :     }
     167     7347556 :     return 0;
     168             : }
     169             : 
     170       12110 : static int hexchar2int(char c) {
     171       12110 :     if (c >= '0' && c <= '9')
     172        8742 :         return c - '0';
     173        3368 :     if (c >= 'a' && c <= 'f')
     174        3366 :         return c - 'a' + 10;
     175           2 :     if (c >= 'A' && c <= 'F')
     176           1 :         return c - 'A' + 10;
     177           1 :     return -1;
     178             : }
     179             : 
     180       21804 : static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
     181             : {
     182       21804 :     int *lendst = (int *)(dst + 1);
     183             :     uint8_t *bin, *ptr;
     184             :     int len;
     185             : 
     186       21804 :     av_freep(dst);
     187       21804 :     *lendst = 0;
     188             : 
     189       21804 :     if (!val || !(len = strlen(val)))
     190       21418 :         return 0;
     191             : 
     192         386 :     if (len & 1)
     193           1 :         return AVERROR(EINVAL);
     194         385 :     len /= 2;
     195             : 
     196         385 :     ptr = bin = av_malloc(len);
     197         385 :     if (!ptr)
     198           0 :         return AVERROR(ENOMEM);
     199        6824 :     while (*val) {
     200        6055 :         int a = hexchar2int(*val++);
     201        6055 :         int b = hexchar2int(*val++);
     202        6055 :         if (a < 0 || b < 0) {
     203           1 :             av_free(bin);
     204           1 :             return AVERROR(EINVAL);
     205             :         }
     206        6054 :         *ptr++ = (a << 4) | b;
     207             :     }
     208         384 :     *dst    = bin;
     209         384 :     *lendst = len;
     210             : 
     211         384 :     return 0;
     212             : }
     213             : 
     214      341351 : static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
     215             : {
     216      341351 :     av_freep(dst);
     217      341351 :     *dst = av_strdup(val);
     218      341351 :     return *dst ? 0 : AVERROR(ENOMEM);
     219             : }
     220             : 
     221             : #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
     222             :                               opt->type == AV_OPT_TYPE_UINT64 || \
     223             :                               opt->type == AV_OPT_TYPE_CONST || \
     224             :                               opt->type == AV_OPT_TYPE_FLAGS || \
     225             :                               opt->type == AV_OPT_TYPE_INT)     \
     226             :                              ? opt->default_val.i64             \
     227             :                              : opt->default_val.dbl)
     228             : 
     229      131758 : static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
     230             : {
     231      131758 :     int ret = 0;
     232             :     int num, den;
     233             :     char c;
     234             : 
     235      131758 :     if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
     236       28684 :         if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
     237       28682 :             return ret;
     238           2 :         ret = 0;
     239             :     }
     240             : 
     241       20523 :     for (;;) {
     242      123599 :         int i = 0;
     243             :         char buf[256];
     244      123599 :         int cmd = 0;
     245             :         double d;
     246      123599 :         int64_t intnum = 1;
     247             : 
     248      123599 :         if (o->type == AV_OPT_TYPE_FLAGS) {
     249       75698 :             if (*val == '+' || *val == '-')
     250       55275 :                 cmd = *(val++);
     251      627383 :             for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
     252      551685 :                 buf[i] = val[i];
     253       75698 :             buf[i] = 0;
     254             :         }
     255             : 
     256             :         {
     257      123599 :             const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, 0);
     258             :             int res;
     259      123599 :             int ci = 0;
     260             :             double const_values[64];
     261             :             const char * const_names[64];
     262      123599 :             if (o_named && o_named->type == AV_OPT_TYPE_CONST)
     263       92725 :                 d = DEFAULT_NUMVAL(o_named);
     264             :             else {
     265       30874 :                 if (o->unit) {
     266     6102085 :                     for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
     267     9975940 :                         if (o_named->type == AV_OPT_TYPE_CONST &&
     268     7832290 :                             o_named->unit &&
     269     3916145 :                             !strcmp(o_named->unit, o->unit)) {
     270      208464 :                             if (ci + 6 >= FF_ARRAY_ELEMS(const_values)) {
     271           0 :                                 av_log(obj, AV_LOG_ERROR, "const_values array too small for %s\n", o->unit);
     272           6 :                                 return AVERROR_PATCHWELCOME;
     273             :                             }
     274      208464 :                             const_names [ci  ] = o_named->name;
     275      208464 :                             const_values[ci++] = DEFAULT_NUMVAL(o_named);
     276             :                         }
     277             :                     }
     278             :                 }
     279       30874 :                 const_names [ci  ] = "default";
     280       30874 :                 const_values[ci++] = DEFAULT_NUMVAL(o);
     281       30874 :                 const_names [ci  ] = "max";
     282       30874 :                 const_values[ci++] = o->max;
     283       30874 :                 const_names [ci  ] = "min";
     284       30874 :                 const_values[ci++] = o->min;
     285       30874 :                 const_names [ci  ] = "none";
     286       30874 :                 const_values[ci++] = 0;
     287       30874 :                 const_names [ci  ] = "all";
     288       30874 :                 const_values[ci++] = ~0;
     289       30874 :                 const_names [ci] = NULL;
     290       30874 :                 const_values[ci] = 0;
     291             : 
     292       30874 :                 res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
     293             :                                             const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
     294       30874 :                 if (res < 0) {
     295           6 :                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
     296           6 :                     return res;
     297             :                 }
     298             :             }
     299             :         }
     300      123593 :         if (o->type == AV_OPT_TYPE_FLAGS) {
     301       75698 :             read_number(o, dst, NULL, NULL, &intnum);
     302       75698 :             if (cmd == '+')
     303       55261 :                 d = intnum | (int64_t)d;
     304       20437 :             else if (cmd == '-')
     305          14 :                 d = intnum &~(int64_t)d;
     306             :         }
     307             : 
     308      123593 :         if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
     309           9 :             return ret;
     310      123584 :         val += i;
     311      123584 :         if (!i || !*val)
     312      103061 :             return 0;
     313             :     }
     314             : }
     315             : 
     316       53426 : static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
     317             : {
     318             :     int ret;
     319             : 
     320       53426 :     if (!val || !strcmp(val, "none")) {
     321       43862 :         dst[0] =
     322       43862 :         dst[1] = 0;
     323       43862 :         return 0;
     324             :     }
     325        9564 :     ret = av_parse_video_size(dst, dst + 1, val);
     326        9564 :     if (ret < 0)
     327           1 :         av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
     328        9564 :     return ret;
     329             : }
     330             : 
     331        3904 : static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
     332             : {
     333             :     int ret;
     334        3904 :     if (!val) {
     335           0 :         ret = AVERROR(EINVAL);
     336             :     } else {
     337        3904 :         ret = av_parse_video_rate(dst, val);
     338             :     }
     339        3904 :     if (ret < 0)
     340           1 :         av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
     341        3904 :     return ret;
     342             : }
     343             : 
     344         163 : static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
     345             : {
     346             :     int ret;
     347             : 
     348         163 :     if (!val) {
     349           0 :         return 0;
     350             :     } else {
     351         163 :         ret = av_parse_color(dst, val, -1, obj);
     352         163 :         if (ret < 0)
     353           0 :             av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
     354         163 :         return ret;
     355             :     }
     356             :     return 0;
     357             : }
     358             : 
     359          49 : static const char *get_bool_name(int val)
     360             : {
     361          49 :     if (val < 0)
     362           3 :         return "auto";
     363          46 :     return val ? "true" : "false";
     364             : }
     365             : 
     366        1630 : static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
     367             : {
     368             :     int n;
     369             : 
     370        1630 :     if (!val)
     371           0 :         return 0;
     372             : 
     373        1630 :     if (!strcmp(val, "auto")) {
     374           2 :         n = -1;
     375        1628 :     } else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
     376         640 :         n = 1;
     377         988 :     } else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
     378           5 :         n = 0;
     379             :     } else {
     380         983 :         char *end = NULL;
     381         983 :         n = strtol(val, &end, 10);
     382         983 :         if (val + strlen(val) != end)
     383           0 :             goto fail;
     384             :     }
     385             : 
     386        1630 :     if (n < o->min || n > o->max)
     387             :         goto fail;
     388             : 
     389        1630 :     *dst = n;
     390        1630 :     return 0;
     391             : 
     392           0 : fail:
     393           0 :     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as boolean\n", val);
     394           0 :     return AVERROR(EINVAL);
     395             : }
     396             : 
     397       11632 : static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst,
     398             :                           int fmt_nb, int ((*get_fmt)(const char *)), const char *desc)
     399             : {
     400             :     int fmt, min, max;
     401             : 
     402       11632 :     if (!val || !strcmp(val, "none")) {
     403           0 :         fmt = -1;
     404             :     } else {
     405       11632 :         fmt = get_fmt(val);
     406       11632 :         if (fmt == -1) {
     407             :             char *tail;
     408        8850 :             fmt = strtol(val, &tail, 0);
     409        8850 :             if (*tail || (unsigned)fmt >= fmt_nb) {
     410           2 :                 av_log(obj, AV_LOG_ERROR,
     411             :                        "Unable to parse option value \"%s\" as %s\n", val, desc);
     412           2 :                 return AVERROR(EINVAL);
     413             :             }
     414             :         }
     415             :     }
     416             : 
     417       11630 :     min = FFMAX(o->min, -1);
     418       11630 :     max = FFMIN(o->max, fmt_nb-1);
     419             : 
     420             :     // hack for compatibility with old ffmpeg
     421       11630 :     if(min == 0 && max == 0) {
     422           0 :         min = -1;
     423           0 :         max = fmt_nb-1;
     424             :     }
     425             : 
     426       11630 :     if (fmt < min || fmt > max) {
     427           0 :         av_log(obj, AV_LOG_ERROR,
     428             :                "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
     429             :                fmt, o->name, desc, min, max);
     430           0 :         return AVERROR(ERANGE);
     431             :     }
     432             : 
     433       11630 :     *(int *)dst = fmt;
     434       11630 :     return 0;
     435             : }
     436             : 
     437        8854 : static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
     438             : {
     439        8854 :     return set_string_fmt(obj, o, val, dst,
     440             :                           AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
     441             : }
     442             : 
     443        2778 : static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
     444             : {
     445        2778 :     return set_string_fmt(obj, o, val, dst,
     446             :                           AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
     447             : }
     448             : 
     449      316386 : int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
     450             : {
     451      316386 :     int ret = 0;
     452             :     void *dst, *target_obj;
     453      316386 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     454      316386 :     if (!o || !target_obj)
     455      120254 :         return AVERROR_OPTION_NOT_FOUND;
     456      196132 :     if (!val && (o->type != AV_OPT_TYPE_STRING &&
     457           0 :                  o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
     458           0 :                  o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
     459           0 :                  o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
     460           0 :                  o->type != AV_OPT_TYPE_CHANNEL_LAYOUT && o->type != AV_OPT_TYPE_BOOL))
     461           0 :         return AVERROR(EINVAL);
     462             : 
     463      196132 :     if (o->flags & AV_OPT_FLAG_READONLY)
     464           0 :         return AVERROR(EINVAL);
     465             : 
     466      196132 :     if (o->flags & AV_OPT_FLAG_DEPRECATED)
     467           0 :         av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
     468             : 
     469      196132 :     dst = ((uint8_t *)target_obj) + o->offset;
     470      196132 :     switch (o->type) {
     471        1630 :     case AV_OPT_TYPE_BOOL:
     472        1630 :         return set_string_bool(obj, o, val, dst);
     473       59687 :     case AV_OPT_TYPE_STRING:
     474       59687 :         return set_string(obj, o, val, dst);
     475          11 :     case AV_OPT_TYPE_BINARY:
     476          11 :         return set_string_binary(obj, o, val, dst);
     477      113282 :     case AV_OPT_TYPE_FLAGS:
     478             :     case AV_OPT_TYPE_INT:
     479             :     case AV_OPT_TYPE_INT64:
     480             :     case AV_OPT_TYPE_UINT64:
     481             :     case AV_OPT_TYPE_FLOAT:
     482             :     case AV_OPT_TYPE_DOUBLE:
     483             :     case AV_OPT_TYPE_RATIONAL:
     484      113282 :         return set_string_number(obj, target_obj, o, val, dst);
     485        9375 :     case AV_OPT_TYPE_IMAGE_SIZE:
     486        9375 :         return set_string_image_size(obj, o, val, dst);
     487         245 :     case AV_OPT_TYPE_VIDEO_RATE: {
     488             :         AVRational tmp;
     489         245 :         ret = set_string_video_rate(obj, o, val, &tmp);
     490         245 :         if (ret < 0)
     491           1 :             return ret;
     492         244 :         return write_number(obj, o, dst, 1, tmp.den, tmp.num);
     493             :     }
     494        8854 :     case AV_OPT_TYPE_PIXEL_FMT:
     495        8854 :         return set_string_pixel_fmt(obj, o, val, dst);
     496        2778 :     case AV_OPT_TYPE_SAMPLE_FMT:
     497        2778 :         return set_string_sample_fmt(obj, o, val, dst);
     498         235 :     case AV_OPT_TYPE_DURATION:
     499         235 :         if (!val) {
     500           0 :             *(int64_t *)dst = 0;
     501           0 :             return 0;
     502             :         } else {
     503         235 :             if ((ret = av_parse_time(dst, val, 1)) < 0)
     504           1 :                 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
     505         235 :             return ret;
     506             :         }
     507             :         break;
     508          32 :     case AV_OPT_TYPE_COLOR:
     509          32 :         return set_string_color(obj, o, val, dst);
     510           3 :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     511           3 :         if (!val || !strcmp(val, "none")) {
     512           0 :             *(int64_t *)dst = 0;
     513             :         } else {
     514           3 :             int64_t cl = av_get_channel_layout(val);
     515           3 :             if (!cl) {
     516           1 :                 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
     517           1 :                 ret = AVERROR(EINVAL);
     518             :             }
     519           3 :             *(int64_t *)dst = cl;
     520           3 :             return ret;
     521             :         }
     522           0 :         break;
     523             :     }
     524             : 
     525           0 :     av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
     526           0 :     return AVERROR(EINVAL);
     527             : }
     528             : 
     529             : #define OPT_EVAL_NUMBER(name, opttype, vartype)                         \
     530             : int av_opt_eval_ ## name(void *obj, const AVOption *o,                  \
     531             :                          const char *val, vartype *name ## _out)        \
     532             : {                                                                       \
     533             :     if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)    \
     534             :         return AVERROR(EINVAL);                                         \
     535             :     return set_string_number(obj, obj, o, val, name ## _out);           \
     536             : }
     537             : 
     538       18476 : OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
     539           0 : OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
     540           0 : OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
     541           0 : OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
     542           0 : OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
     543           0 : OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
     544             : 
     545       57023 : static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
     546             :                       int search_flags)
     547             : {
     548             :     void *dst, *target_obj;
     549       57023 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     550             : 
     551       57023 :     if (!o || !target_obj)
     552           0 :         return AVERROR_OPTION_NOT_FOUND;
     553             : 
     554       57023 :     if (o->flags & AV_OPT_FLAG_READONLY)
     555           0 :         return AVERROR(EINVAL);
     556             : 
     557       57023 :     dst = ((uint8_t *)target_obj) + o->offset;
     558       57023 :     return write_number(obj, o, dst, num, den, intnum);
     559             : }
     560             : 
     561       57023 : int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
     562             : {
     563       57023 :     return set_number(obj, name, 1, 1, val, search_flags);
     564             : }
     565             : 
     566           0 : int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
     567             : {
     568           0 :     return set_number(obj, name, val, 1, 1, search_flags);
     569             : }
     570             : 
     571           0 : int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
     572             : {
     573           0 :     return set_number(obj, name, val.num, val.den, 1, search_flags);
     574             : }
     575             : 
     576          21 : int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
     577             : {
     578             :     void *target_obj;
     579          21 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     580             :     uint8_t *ptr;
     581             :     uint8_t **dst;
     582             :     int *lendst;
     583             : 
     584          21 :     if (!o || !target_obj)
     585           0 :         return AVERROR_OPTION_NOT_FOUND;
     586             : 
     587          21 :     if (o->type != AV_OPT_TYPE_BINARY || o->flags & AV_OPT_FLAG_READONLY)
     588           0 :         return AVERROR(EINVAL);
     589             : 
     590          21 :     ptr = len ? av_malloc(len) : NULL;
     591          21 :     if (len && !ptr)
     592           0 :         return AVERROR(ENOMEM);
     593             : 
     594          21 :     dst    = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
     595          21 :     lendst = (int *)(dst + 1);
     596             : 
     597          21 :     av_free(*dst);
     598          21 :     *dst    = ptr;
     599          21 :     *lendst = len;
     600          21 :     if (len)
     601          21 :         memcpy(ptr, val, len);
     602             : 
     603          21 :     return 0;
     604             : }
     605             : 
     606           0 : int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
     607             : {
     608             :     void *target_obj;
     609           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     610             : 
     611           0 :     if (!o || !target_obj)
     612           0 :         return AVERROR_OPTION_NOT_FOUND;
     613           0 :     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
     614           0 :         av_log(obj, AV_LOG_ERROR,
     615             :                "The value set by option '%s' is not an image size.\n", o->name);
     616           0 :         return AVERROR(EINVAL);
     617             :     }
     618           0 :     if (w<0 || h<0) {
     619           0 :         av_log(obj, AV_LOG_ERROR,
     620             :                "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
     621           0 :         return AVERROR(EINVAL);
     622             :     }
     623           0 :     *(int *)(((uint8_t *)target_obj)             + o->offset) = w;
     624           0 :     *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
     625           0 :     return 0;
     626             : }
     627             : 
     628           0 : int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
     629             : {
     630             :     void *target_obj;
     631           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     632             : 
     633           0 :     if (!o || !target_obj)
     634           0 :         return AVERROR_OPTION_NOT_FOUND;
     635           0 :     if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
     636           0 :         av_log(obj, AV_LOG_ERROR,
     637             :                "The value set by option '%s' is not a video rate.\n", o->name);
     638           0 :         return AVERROR(EINVAL);
     639             :     }
     640           0 :     if (val.num <= 0 || val.den <= 0)
     641           0 :         return AVERROR(EINVAL);
     642           0 :     return set_number(obj, name, val.num, val.den, 1, search_flags);
     643             : }
     644             : 
     645           0 : static int set_format(void *obj, const char *name, int fmt, int search_flags,
     646             :                       enum AVOptionType type, const char *desc, int nb_fmts)
     647             : {
     648             :     void *target_obj;
     649           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0,
     650             :                                      search_flags, &target_obj);
     651             :     int min, max;
     652             : 
     653           0 :     if (!o || !target_obj)
     654           0 :         return AVERROR_OPTION_NOT_FOUND;
     655           0 :     if (o->type != type) {
     656           0 :         av_log(obj, AV_LOG_ERROR,
     657             :                "The value set by option '%s' is not a %s format", name, desc);
     658           0 :         return AVERROR(EINVAL);
     659             :     }
     660             : 
     661           0 :     min = FFMAX(o->min, -1);
     662           0 :     max = FFMIN(o->max, nb_fmts-1);
     663             : 
     664           0 :     if (fmt < min || fmt > max) {
     665           0 :         av_log(obj, AV_LOG_ERROR,
     666             :                "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
     667             :                fmt, name, desc, min, max);
     668           0 :         return AVERROR(ERANGE);
     669             :     }
     670           0 :     *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
     671           0 :     return 0;
     672             : }
     673             : 
     674           0 : int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
     675             : {
     676           0 :     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
     677             : }
     678             : 
     679           0 : int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
     680             : {
     681           0 :     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
     682             : }
     683             : 
     684           0 : int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
     685             : {
     686             :     void *target_obj;
     687           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     688             : 
     689           0 :     if (!o || !target_obj)
     690           0 :         return AVERROR_OPTION_NOT_FOUND;
     691           0 :     if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
     692           0 :         av_log(obj, AV_LOG_ERROR,
     693             :                "The value set by option '%s' is not a channel layout.\n", o->name);
     694           0 :         return AVERROR(EINVAL);
     695             :     }
     696           0 :     *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
     697           0 :     return 0;
     698             : }
     699             : 
     700           0 : int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
     701             :                         int search_flags)
     702             : {
     703             :     void *target_obj;
     704             :     AVDictionary **dst;
     705           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     706             : 
     707           0 :     if (!o || !target_obj)
     708           0 :         return AVERROR_OPTION_NOT_FOUND;
     709           0 :     if (o->flags & AV_OPT_FLAG_READONLY)
     710           0 :         return AVERROR(EINVAL);
     711             : 
     712           0 :     dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
     713           0 :     av_dict_free(dst);
     714           0 :     av_dict_copy(dst, val, 0);
     715             : 
     716           0 :     return 0;
     717             : }
     718             : 
     719           3 : static void format_duration(char *buf, size_t size, int64_t d)
     720             : {
     721             :     char *e;
     722             : 
     723           3 :     av_assert0(size >= 25);
     724           3 :     if (d < 0 && d != INT64_MIN) {
     725           0 :         *(buf++) = '-';
     726           0 :         size--;
     727           0 :         d = -d;
     728             :     }
     729           3 :     if (d == INT64_MAX)
     730           0 :         snprintf(buf, size, "INT64_MAX");
     731           3 :     else if (d == INT64_MIN)
     732           0 :         snprintf(buf, size, "INT64_MIN");
     733           3 :     else if (d > (int64_t)3600*1000000)
     734           0 :         snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
     735           0 :                  (int)((d / 60000000) % 60),
     736           0 :                  (int)((d / 1000000) % 60),
     737           0 :                  (int)(d % 1000000));
     738           3 :     else if (d > 60*1000000)
     739           0 :         snprintf(buf, size, "%d:%02d.%06d",
     740           0 :                  (int)(d / 60000000),
     741           0 :                  (int)((d / 1000000) % 60),
     742           0 :                  (int)(d % 1000000));
     743             :     else
     744           6 :         snprintf(buf, size, "%d.%06d",
     745           3 :                  (int)(d / 1000000),
     746           3 :                  (int)(d % 1000000));
     747           3 :     e = buf + strlen(buf);
     748          15 :     while (e > buf && e[-1] == '0')
     749           9 :         *(--e) = 0;
     750           3 :     if (e > buf && e[-1] == '.')
     751           0 :         *(--e) = 0;
     752           3 : }
     753             : 
     754        4575 : int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
     755             : {
     756             :     void *dst, *target_obj;
     757        4575 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     758             :     uint8_t *bin, buf[128];
     759             :     int len, i, ret;
     760             :     int64_t i64;
     761             : 
     762        4575 :     if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
     763        3329 :         return AVERROR_OPTION_NOT_FOUND;
     764             : 
     765        1246 :     if (o->flags & AV_OPT_FLAG_DEPRECATED)
     766           0 :         av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
     767             : 
     768        1246 :     dst = (uint8_t *)target_obj + o->offset;
     769             : 
     770        1246 :     buf[0] = 0;
     771        1246 :     switch (o->type) {
     772          46 :     case AV_OPT_TYPE_BOOL:
     773          46 :         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
     774          46 :         break;
     775          76 :     case AV_OPT_TYPE_FLAGS:
     776          76 :         ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
     777          76 :         break;
     778         778 :     case AV_OPT_TYPE_INT:
     779         778 :         ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
     780         778 :         break;
     781          54 :     case AV_OPT_TYPE_INT64:
     782          54 :         ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
     783          54 :         break;
     784          16 :     case AV_OPT_TYPE_UINT64:
     785          16 :         ret = snprintf(buf, sizeof(buf), "%"PRIu64, *(uint64_t *)dst);
     786          16 :         break;
     787         130 :     case AV_OPT_TYPE_FLOAT:
     788         130 :         ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
     789         130 :         break;
     790           2 :     case AV_OPT_TYPE_DOUBLE:
     791           2 :         ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
     792           2 :         break;
     793          36 :     case AV_OPT_TYPE_VIDEO_RATE:
     794             :     case AV_OPT_TYPE_RATIONAL:
     795          36 :         ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
     796          36 :         break;
     797           0 :     case AV_OPT_TYPE_CONST:
     798           0 :         ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
     799           0 :         break;
     800          66 :     case AV_OPT_TYPE_STRING:
     801          66 :         if (*(uint8_t **)dst) {
     802          42 :             *out_val = av_strdup(*(uint8_t **)dst);
     803          24 :         } else if (search_flags & AV_OPT_ALLOW_NULL) {
     804           0 :             *out_val = NULL;
     805           0 :             return 0;
     806             :         } else {
     807          24 :             *out_val = av_strdup("");
     808             :         }
     809          66 :         return *out_val ? 0 : AVERROR(ENOMEM);
     810           6 :     case AV_OPT_TYPE_BINARY:
     811           6 :         if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
     812           0 :             *out_val = NULL;
     813           0 :             return 0;
     814             :         }
     815           6 :         len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
     816           6 :         if ((uint64_t)len * 2 + 1 > INT_MAX)
     817           0 :             return AVERROR(EINVAL);
     818           6 :         if (!(*out_val = av_malloc(len * 2 + 1)))
     819           0 :             return AVERROR(ENOMEM);
     820           6 :         if (!len) {
     821           4 :             *out_val[0] = '\0';
     822           4 :             return 0;
     823             :         }
     824           2 :         bin = *(uint8_t **)dst;
     825          10 :         for (i = 0; i < len; i++)
     826           8 :             snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
     827           2 :         return 0;
     828          10 :     case AV_OPT_TYPE_IMAGE_SIZE:
     829          10 :         ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
     830          10 :         break;
     831          10 :     case AV_OPT_TYPE_PIXEL_FMT:
     832          10 :         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
     833          10 :         break;
     834          10 :     case AV_OPT_TYPE_SAMPLE_FMT:
     835          10 :         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
     836          10 :         break;
     837           2 :     case AV_OPT_TYPE_DURATION:
     838           2 :         i64 = *(int64_t *)dst;
     839           2 :         format_duration(buf, sizeof(buf), i64);
     840           2 :         ret = strlen(buf); // no overflow possible, checked by an assert
     841           2 :         break;
     842           2 :     case AV_OPT_TYPE_COLOR:
     843           8 :         ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
     844           4 :                        (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
     845           4 :                        (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
     846           2 :         break;
     847           2 :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     848           2 :         i64 = *(int64_t *)dst;
     849           2 :         ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
     850           2 :         break;
     851           0 :     default:
     852           0 :         return AVERROR(EINVAL);
     853             :     }
     854             : 
     855        1174 :     if (ret >= sizeof(buf))
     856           0 :         return AVERROR(EINVAL);
     857        1174 :     *out_val = av_strdup(buf);
     858        1174 :     return *out_val ? 0 : AVERROR(ENOMEM);
     859             : }
     860             : 
     861       13709 : static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
     862             :                       int search_flags)
     863             : {
     864             :     void *dst, *target_obj;
     865       13709 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     866       13709 :     if (!o || !target_obj)
     867             :         goto error;
     868             : 
     869       13707 :     dst = ((uint8_t *)target_obj) + o->offset;
     870             : 
     871       13707 :     if (o_out) *o_out= o;
     872             : 
     873       13707 :     return read_number(o, dst, num, den, intnum);
     874             : 
     875           2 : error:
     876           2 :     *den    =
     877           2 :     *intnum = 0;
     878           2 :     return -1;
     879             : }
     880             : 
     881       13709 : int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
     882             : {
     883       13709 :     int64_t intnum = 1;
     884       13709 :     double num = 1;
     885       13709 :     int ret, den = 1;
     886             : 
     887       13709 :     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
     888           2 :         return ret;
     889       13707 :     *out_val = num * intnum / den;
     890       13707 :     return 0;
     891             : }
     892             : 
     893           0 : int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
     894             : {
     895           0 :     int64_t intnum = 1;
     896           0 :     double num = 1;
     897           0 :     int ret, den = 1;
     898             : 
     899           0 :     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
     900           0 :         return ret;
     901           0 :     *out_val = num * intnum / den;
     902           0 :     return 0;
     903             : }
     904             : 
     905           0 : int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
     906             : {
     907           0 :     int64_t intnum = 1;
     908           0 :     double num = 1;
     909           0 :     int ret, den = 1;
     910             : 
     911           0 :     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
     912           0 :         return ret;
     913             : 
     914           0 :     if (num == 1.0 && (int)intnum == intnum)
     915           0 :         *out_val = (AVRational){intnum, den};
     916             :     else
     917           0 :         *out_val = av_d2q(num*intnum/den, 1<<24);
     918           0 :     return 0;
     919             : }
     920             : 
     921           0 : int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
     922             : {
     923             :     void *dst, *target_obj;
     924           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     925           0 :     if (!o || !target_obj)
     926           0 :         return AVERROR_OPTION_NOT_FOUND;
     927           0 :     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
     928           0 :         av_log(obj, AV_LOG_ERROR,
     929             :                "The value for option '%s' is not an image size.\n", name);
     930           0 :         return AVERROR(EINVAL);
     931             :     }
     932             : 
     933           0 :     dst = ((uint8_t*)target_obj) + o->offset;
     934           0 :     if (w_out) *w_out = *(int *)dst;
     935           0 :     if (h_out) *h_out = *((int *)dst+1);
     936           0 :     return 0;
     937             : }
     938             : 
     939           0 : int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
     940             : {
     941           0 :     int64_t intnum = 1;
     942           0 :     double     num = 1;
     943           0 :     int   ret, den = 1;
     944             : 
     945           0 :     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
     946           0 :         return ret;
     947             : 
     948           0 :     if (num == 1.0 && (int)intnum == intnum)
     949           0 :         *out_val = (AVRational) { intnum, den };
     950             :     else
     951           0 :         *out_val = av_d2q(num * intnum / den, 1 << 24);
     952           0 :     return 0;
     953             : }
     954             : 
     955        2328 : static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
     956             :                       enum AVOptionType type, const char *desc)
     957             : {
     958             :     void *dst, *target_obj;
     959        2328 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     960        2328 :     if (!o || !target_obj)
     961           0 :         return AVERROR_OPTION_NOT_FOUND;
     962        2328 :     if (o->type != type) {
     963           0 :         av_log(obj, AV_LOG_ERROR,
     964             :                "The value for option '%s' is not a %s format.\n", desc, name);
     965           0 :         return AVERROR(EINVAL);
     966             :     }
     967             : 
     968        2328 :     dst = ((uint8_t*)target_obj) + o->offset;
     969        2328 :     *out_fmt = *(int *)dst;
     970        2328 :     return 0;
     971             : }
     972             : 
     973           0 : int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
     974             : {
     975           0 :     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
     976             : }
     977             : 
     978        2328 : int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
     979             : {
     980        2328 :     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
     981             : }
     982             : 
     983           0 : int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
     984             : {
     985             :     void *dst, *target_obj;
     986           0 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
     987           0 :     if (!o || !target_obj)
     988           0 :         return AVERROR_OPTION_NOT_FOUND;
     989           0 :     if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
     990           0 :         av_log(obj, AV_LOG_ERROR,
     991             :                "The value for option '%s' is not a channel layout.\n", name);
     992           0 :         return AVERROR(EINVAL);
     993             :     }
     994             : 
     995           0 :     dst = ((uint8_t*)target_obj) + o->offset;
     996           0 :     *cl = *(int64_t *)dst;
     997           0 :     return 0;
     998             : }
     999             : 
    1000      506190 : int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
    1001             : {
    1002             :     void *target_obj;
    1003             :     AVDictionary *src;
    1004      506190 :     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    1005             : 
    1006      506190 :     if (!o || !target_obj)
    1007      506190 :         return AVERROR_OPTION_NOT_FOUND;
    1008           0 :     if (o->type != AV_OPT_TYPE_DICT)
    1009           0 :         return AVERROR(EINVAL);
    1010             : 
    1011           0 :     src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
    1012           0 :     av_dict_copy(out_val, src, 0);
    1013             : 
    1014           0 :     return 0;
    1015             : }
    1016             : 
    1017           0 : int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
    1018             : {
    1019           0 :     const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
    1020           0 :     const AVOption *flag  = av_opt_find(obj, flag_name,
    1021             :                                         field ? field->unit : NULL, 0, 0);
    1022             :     int64_t res;
    1023             : 
    1024           0 :     if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
    1025           0 :         av_opt_get_int(obj, field_name, 0, &res) < 0)
    1026           0 :         return 0;
    1027           0 :     return res & flag->default_val.i64;
    1028             : }
    1029             : 
    1030          17 : static void log_value(void *av_log_obj, int level, double d)
    1031             : {
    1032          17 :     if      (d == INT_MAX) {
    1033           0 :         av_log(av_log_obj, level, "INT_MAX");
    1034          17 :     } else if (d == INT_MIN) {
    1035           0 :         av_log(av_log_obj, level, "INT_MIN");
    1036          17 :     } else if (d == UINT32_MAX) {
    1037           0 :         av_log(av_log_obj, level, "UINT32_MAX");
    1038          17 :     } else if (d == (double)INT64_MAX) {
    1039           0 :         av_log(av_log_obj, level, "I64_MAX");
    1040          17 :     } else if (d == INT64_MIN) {
    1041           0 :         av_log(av_log_obj, level, "I64_MIN");
    1042          17 :     } else if (d == FLT_MAX) {
    1043           0 :         av_log(av_log_obj, level, "FLT_MAX");
    1044          17 :     } else if (d == FLT_MIN) {
    1045           0 :         av_log(av_log_obj, level, "FLT_MIN");
    1046          17 :     } else if (d == -FLT_MAX) {
    1047           0 :         av_log(av_log_obj, level, "-FLT_MAX");
    1048          17 :     } else if (d == -FLT_MIN) {
    1049           0 :         av_log(av_log_obj, level, "-FLT_MIN");
    1050          17 :     } else if (d == DBL_MAX) {
    1051           0 :         av_log(av_log_obj, level, "DBL_MAX");
    1052          17 :     } else if (d == DBL_MIN) {
    1053           0 :         av_log(av_log_obj, level, "DBL_MIN");
    1054          17 :     } else if (d == -DBL_MAX) {
    1055           0 :         av_log(av_log_obj, level, "-DBL_MAX");
    1056          17 :     } else if (d == -DBL_MIN) {
    1057           0 :         av_log(av_log_obj, level, "-DBL_MIN");
    1058             :     } else {
    1059          17 :         av_log(av_log_obj, level, "%g", d);
    1060             :     }
    1061          17 : }
    1062             : 
    1063           3 : static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
    1064             : {
    1065           3 :     const AVOption *opt = NULL;
    1066             : 
    1067           3 :     if (!unit)
    1068           3 :         return NULL;
    1069           0 :     while ((opt = av_opt_next(obj, opt)))
    1070           0 :         if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
    1071           0 :             opt->default_val.i64 == value)
    1072           0 :             return opt->name;
    1073           0 :     return NULL;
    1074             : }
    1075             : 
    1076           1 : static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
    1077             : {
    1078           1 :     const AVOption *opt = NULL;
    1079             :     char flags[512];
    1080             : 
    1081           1 :     flags[0] = 0;
    1082           1 :     if (!unit)
    1083           0 :         return NULL;
    1084          27 :     while ((opt = av_opt_next(obj, opt))) {
    1085          28 :         if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
    1086           3 :             opt->default_val.i64 & value) {
    1087           1 :             if (flags[0])
    1088           0 :                 av_strlcatf(flags, sizeof(flags), "+");
    1089           1 :             av_strlcatf(flags, sizeof(flags), "%s", opt->name);
    1090             :         }
    1091             :     }
    1092           1 :     if (flags[0])
    1093           1 :         return av_strdup(flags);
    1094           0 :     return NULL;
    1095             : }
    1096             : 
    1097           2 : static void opt_list(void *obj, void *av_log_obj, const char *unit,
    1098             :                      int req_flags, int rej_flags)
    1099             : {
    1100           2 :     const AVOption *opt = NULL;
    1101             :     AVOptionRanges *r;
    1102             :     int i;
    1103             : 
    1104          54 :     while ((opt = av_opt_next(obj, opt))) {
    1105          50 :         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
    1106           0 :             continue;
    1107             : 
    1108             :         /* Don't print CONST's on level one.
    1109             :          * Don't print anything but CONST's on level two.
    1110             :          * Only print items from the requested unit.
    1111             :          */
    1112          50 :         if (!unit && opt->type == AV_OPT_TYPE_CONST)
    1113           3 :             continue;
    1114          47 :         else if (unit && opt->type != AV_OPT_TYPE_CONST)
    1115          22 :             continue;
    1116          25 :         else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
    1117           0 :             continue;
    1118          25 :         else if (unit && opt->type == AV_OPT_TYPE_CONST)
    1119           3 :             av_log(av_log_obj, AV_LOG_INFO, "     %-15s ", opt->name);
    1120             :         else
    1121          44 :             av_log(av_log_obj, AV_LOG_INFO, "  %s%-17s ",
    1122          22 :                    (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
    1123             :                    opt->name);
    1124             : 
    1125          25 :         switch (opt->type) {
    1126           1 :             case AV_OPT_TYPE_FLAGS:
    1127           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
    1128           1 :                 break;
    1129           2 :             case AV_OPT_TYPE_INT:
    1130           2 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
    1131           2 :                 break;
    1132           1 :             case AV_OPT_TYPE_INT64:
    1133           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
    1134           1 :                 break;
    1135           0 :             case AV_OPT_TYPE_UINT64:
    1136           0 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<uint64>");
    1137           0 :                 break;
    1138           1 :             case AV_OPT_TYPE_DOUBLE:
    1139           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
    1140           1 :                 break;
    1141           1 :             case AV_OPT_TYPE_FLOAT:
    1142           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
    1143           1 :                 break;
    1144           2 :             case AV_OPT_TYPE_STRING:
    1145           2 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
    1146           2 :                 break;
    1147           1 :             case AV_OPT_TYPE_RATIONAL:
    1148           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
    1149           1 :                 break;
    1150           3 :             case AV_OPT_TYPE_BINARY:
    1151           3 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
    1152           3 :                 break;
    1153           1 :             case AV_OPT_TYPE_IMAGE_SIZE:
    1154           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
    1155           1 :                 break;
    1156           1 :             case AV_OPT_TYPE_VIDEO_RATE:
    1157           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
    1158           1 :                 break;
    1159           1 :             case AV_OPT_TYPE_PIXEL_FMT:
    1160           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
    1161           1 :                 break;
    1162           1 :             case AV_OPT_TYPE_SAMPLE_FMT:
    1163           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
    1164           1 :                 break;
    1165           1 :             case AV_OPT_TYPE_DURATION:
    1166           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
    1167           1 :                 break;
    1168           1 :             case AV_OPT_TYPE_COLOR:
    1169           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
    1170           1 :                 break;
    1171           1 :             case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1172           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
    1173           1 :                 break;
    1174           3 :             case AV_OPT_TYPE_BOOL:
    1175           3 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
    1176           3 :                 break;
    1177           3 :             case AV_OPT_TYPE_CONST:
    1178             :             default:
    1179           3 :                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
    1180           3 :                 break;
    1181             :         }
    1182          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
    1183          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
    1184          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
    1185          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
    1186          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
    1187          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
    1188          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT)         ? 'X' : '.');
    1189          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY)       ? 'R' : '.');
    1190          25 :         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_BSF_PARAM)      ? 'B' : '.');
    1191             : 
    1192          25 :         if (opt->help)
    1193          25 :             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
    1194             : 
    1195          25 :         if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
    1196          18 :             switch (opt->type) {
    1197           6 :             case AV_OPT_TYPE_INT:
    1198             :             case AV_OPT_TYPE_INT64:
    1199             :             case AV_OPT_TYPE_UINT64:
    1200             :             case AV_OPT_TYPE_DOUBLE:
    1201             :             case AV_OPT_TYPE_FLOAT:
    1202             :             case AV_OPT_TYPE_RATIONAL:
    1203          12 :                 for (i = 0; i < r->nb_ranges; i++) {
    1204           6 :                     av_log(av_log_obj, AV_LOG_INFO, " (from ");
    1205           6 :                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
    1206           6 :                     av_log(av_log_obj, AV_LOG_INFO, " to ");
    1207           6 :                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
    1208           6 :                     av_log(av_log_obj, AV_LOG_INFO, ")");
    1209             :                 }
    1210           6 :                 break;
    1211             :             }
    1212          18 :             av_opt_freep_ranges(&r);
    1213             :         }
    1214             : 
    1215          47 :         if (opt->type != AV_OPT_TYPE_CONST  &&
    1216          41 :             opt->type != AV_OPT_TYPE_BINARY &&
    1217          42 :                 !((opt->type == AV_OPT_TYPE_COLOR      ||
    1218          35 :                    opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
    1219          32 :                    opt->type == AV_OPT_TYPE_STRING     ||
    1220          15 :                    opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
    1221           5 :                   !opt->default_val.str)) {
    1222          19 :             av_log(av_log_obj, AV_LOG_INFO, " (default ");
    1223          19 :             switch (opt->type) {
    1224           3 :             case AV_OPT_TYPE_BOOL:
    1225           3 :                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
    1226           3 :                 break;
    1227           1 :             case AV_OPT_TYPE_FLAGS: {
    1228           1 :                 char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
    1229           1 :                 if (def_flags) {
    1230           1 :                     av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
    1231           1 :                     av_freep(&def_flags);
    1232             :                 } else {
    1233           0 :                     av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
    1234             :                 }
    1235           1 :                 break;
    1236             :             }
    1237           1 :             case AV_OPT_TYPE_DURATION: {
    1238             :                 char buf[25];
    1239           1 :                 format_duration(buf, sizeof(buf), opt->default_val.i64);
    1240           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
    1241           1 :                 break;
    1242             :             }
    1243           3 :             case AV_OPT_TYPE_INT:
    1244             :             case AV_OPT_TYPE_UINT64:
    1245             :             case AV_OPT_TYPE_INT64: {
    1246           3 :                 const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
    1247           3 :                 if (def_const)
    1248           0 :                     av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
    1249             :                 else
    1250           3 :                     log_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
    1251           3 :                 break;
    1252             :             }
    1253           2 :             case AV_OPT_TYPE_DOUBLE:
    1254             :             case AV_OPT_TYPE_FLOAT:
    1255           2 :                 log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
    1256           2 :                 break;
    1257           1 :             case AV_OPT_TYPE_RATIONAL: {
    1258           1 :                 AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
    1259           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
    1260           1 :                 break;
    1261           1 :             case AV_OPT_TYPE_PIXEL_FMT:
    1262           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
    1263           1 :                 break;
    1264           1 :             case AV_OPT_TYPE_SAMPLE_FMT:
    1265           1 :                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
    1266           1 :                 break;
    1267           5 :             case AV_OPT_TYPE_COLOR:
    1268             :             case AV_OPT_TYPE_IMAGE_SIZE:
    1269             :             case AV_OPT_TYPE_STRING:
    1270             :             case AV_OPT_TYPE_VIDEO_RATE:
    1271           5 :                 av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
    1272           5 :                 break;
    1273           1 :             case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1274           1 :                 av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
    1275           1 :                 break;
    1276             :             }
    1277          19 :             av_log(av_log_obj, AV_LOG_INFO, ")");
    1278             :         }
    1279             : 
    1280          25 :         av_log(av_log_obj, AV_LOG_INFO, "\n");
    1281          25 :         if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
    1282           1 :             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
    1283             :     }
    1284           2 : }
    1285             : 
    1286           1 : int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
    1287             : {
    1288           1 :     if (!obj)
    1289           0 :         return -1;
    1290             : 
    1291           1 :     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
    1292             : 
    1293           1 :     opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
    1294             : 
    1295           1 :     return 0;
    1296             : }
    1297             : 
    1298      221462 : void av_opt_set_defaults(void *s)
    1299             : {
    1300      221462 :     av_opt_set_defaults2(s, 0, 0);
    1301      221462 : }
    1302             : 
    1303      269736 : void av_opt_set_defaults2(void *s, int mask, int flags)
    1304             : {
    1305      269736 :     const AVOption *opt = NULL;
    1306    21209594 :     while ((opt = av_opt_next(s, opt))) {
    1307    20670122 :         void *dst = ((uint8_t*)s) + opt->offset;
    1308             : 
    1309    20670122 :         if ((opt->flags & mask) != flags)
    1310     1448425 :             continue;
    1311             : 
    1312    19221697 :         if (opt->flags & AV_OPT_FLAG_READONLY)
    1313          61 :             continue;
    1314             : 
    1315    19221636 :         switch (opt->type) {
    1316    11732316 :             case AV_OPT_TYPE_CONST:
    1317             :                 /* Nothing to be done here */
    1318    11732316 :                 break;
    1319     6310287 :             case AV_OPT_TYPE_BOOL:
    1320             :             case AV_OPT_TYPE_FLAGS:
    1321             :             case AV_OPT_TYPE_INT:
    1322             :             case AV_OPT_TYPE_INT64:
    1323             :             case AV_OPT_TYPE_UINT64:
    1324             :             case AV_OPT_TYPE_DURATION:
    1325             :             case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1326             :             case AV_OPT_TYPE_PIXEL_FMT:
    1327             :             case AV_OPT_TYPE_SAMPLE_FMT:
    1328     6310287 :                 write_number(s, opt, dst, 1, 1, opt->default_val.i64);
    1329     6310287 :                 break;
    1330      644123 :             case AV_OPT_TYPE_DOUBLE:
    1331             :             case AV_OPT_TYPE_FLOAT: {
    1332             :                 double val;
    1333      644123 :                 val = opt->default_val.dbl;
    1334      644123 :                 write_number(s, opt, dst, val, 1, 1);
    1335             :             }
    1336      644123 :             break;
    1337      183613 :             case AV_OPT_TYPE_RATIONAL: {
    1338             :                 AVRational val;
    1339      183613 :                 val = av_d2q(opt->default_val.dbl, INT_MAX);
    1340      183613 :                 write_number(s, opt, dst, 1, val.den, val.num);
    1341             :             }
    1342      183613 :             break;
    1343         131 :             case AV_OPT_TYPE_COLOR:
    1344         131 :                 set_string_color(s, opt, opt->default_val.str, dst);
    1345         131 :                 break;
    1346      281664 :             case AV_OPT_TYPE_STRING:
    1347      281664 :                 set_string(s, opt, opt->default_val.str, dst);
    1348      281664 :                 break;
    1349       44051 :             case AV_OPT_TYPE_IMAGE_SIZE:
    1350       44051 :                 set_string_image_size(s, opt, opt->default_val.str, dst);
    1351       44051 :                 break;
    1352        3659 :             case AV_OPT_TYPE_VIDEO_RATE:
    1353        3659 :                 set_string_video_rate(s, opt, opt->default_val.str, dst);
    1354        3659 :                 break;
    1355       21792 :             case AV_OPT_TYPE_BINARY:
    1356       21792 :                 set_string_binary(s, opt, opt->default_val.str, dst);
    1357       21792 :                 break;
    1358           0 :             case AV_OPT_TYPE_DICT:
    1359             :                 /* Cannot set defaults for these types */
    1360           0 :             break;
    1361           0 :         default:
    1362           0 :             av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
    1363           0 :                    opt->type, opt->name);
    1364             :         }
    1365             :     }
    1366      269736 : }
    1367             : 
    1368             : /**
    1369             :  * Store the value in the field in ctx that is named like key.
    1370             :  * ctx must be an AVClass context, storing is done using AVOptions.
    1371             :  *
    1372             :  * @param buf the string to parse, buf will be updated to point at the
    1373             :  * separator just after the parsed key/value pair
    1374             :  * @param key_val_sep a 0-terminated list of characters used to
    1375             :  * separate key from value
    1376             :  * @param pairs_sep a 0-terminated list of characters used to separate
    1377             :  * two pairs from each other
    1378             :  * @return 0 if the key/value pair has been successfully parsed and
    1379             :  * set, or a negative value corresponding to an AVERROR code in case
    1380             :  * of error:
    1381             :  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
    1382             :  * the error code issued by av_opt_set() if the key/value pair
    1383             :  * cannot be set
    1384             :  */
    1385          88 : static int parse_key_value_pair(void *ctx, const char **buf,
    1386             :                                 const char *key_val_sep, const char *pairs_sep)
    1387             : {
    1388          88 :     char *key = av_get_token(buf, key_val_sep);
    1389             :     char *val;
    1390             :     int ret;
    1391             : 
    1392          88 :     if (!key)
    1393           0 :         return AVERROR(ENOMEM);
    1394             : 
    1395          88 :     if (*key && strspn(*buf, key_val_sep)) {
    1396          83 :         (*buf)++;
    1397          83 :         val = av_get_token(buf, pairs_sep);
    1398         166 :         if (!val) {
    1399           0 :             av_freep(&key);
    1400           0 :             return AVERROR(ENOMEM);
    1401             :         }
    1402             :     } else {
    1403           5 :         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
    1404           5 :         av_free(key);
    1405           5 :         return AVERROR(EINVAL);
    1406             :     }
    1407             : 
    1408          83 :     av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
    1409             : 
    1410          83 :     ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
    1411          83 :     if (ret == AVERROR_OPTION_NOT_FOUND)
    1412           5 :         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
    1413             : 
    1414          83 :     av_free(key);
    1415          83 :     av_free(val);
    1416          83 :     return ret;
    1417             : }
    1418             : 
    1419          62 : int av_set_options_string(void *ctx, const char *opts,
    1420             :                           const char *key_val_sep, const char *pairs_sep)
    1421             : {
    1422          62 :     int ret, count = 0;
    1423             : 
    1424          62 :     if (!opts)
    1425           0 :         return 0;
    1426             : 
    1427         180 :     while (*opts) {
    1428          88 :         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
    1429          32 :             return ret;
    1430          56 :         count++;
    1431             : 
    1432          56 :         if (*opts)
    1433          28 :             opts++;
    1434             :     }
    1435             : 
    1436          30 :     return count;
    1437             : }
    1438             : 
    1439             : #define WHITESPACES " \n\t\r"
    1440             : 
    1441      506855 : static int is_key_char(char c)
    1442             : {
    1443      624403 :     return (unsigned)((c | 32) - 'a') < 26 ||
    1444      207927 :            (unsigned)(c - '0') < 10 ||
    1445      597189 :            c == '-' || c == '_' || c == '/' || c == '.';
    1446             : }
    1447             : 
    1448             : /**
    1449             :  * Read a key from a string.
    1450             :  *
    1451             :  * The key consists of is_key_char characters and must be terminated by a
    1452             :  * character from the delim string; spaces are ignored.
    1453             :  *
    1454             :  * @return  0 for success (even with ellipsis), <0 for failure
    1455             :  */
    1456       51602 : static int get_key(const char **ropts, const char *delim, char **rkey)
    1457             : {
    1458       51602 :     const char *opts = *ropts;
    1459             :     const char *key_start, *key_end;
    1460             : 
    1461       51602 :     key_start = opts += strspn(opts, WHITESPACES);
    1462      558457 :     while (is_key_char(*opts))
    1463      455253 :         opts++;
    1464       51602 :     key_end = opts;
    1465       51602 :     opts += strspn(opts, WHITESPACES);
    1466       51602 :     if (!*opts || !strchr(delim, *opts))
    1467        9886 :         return AVERROR(EINVAL);
    1468       41716 :     opts++;
    1469       41716 :     if (!(*rkey = av_malloc(key_end - key_start + 1)))
    1470           0 :         return AVERROR(ENOMEM);
    1471       41716 :     memcpy(*rkey, key_start, key_end - key_start);
    1472       41716 :     (*rkey)[key_end - key_start] = 0;
    1473       41716 :     *ropts = opts;
    1474       41716 :     return 0;
    1475             : }
    1476             : 
    1477       51602 : int av_opt_get_key_value(const char **ropts,
    1478             :                          const char *key_val_sep, const char *pairs_sep,
    1479             :                          unsigned flags,
    1480             :                          char **rkey, char **rval)
    1481             : {
    1482             :     int ret;
    1483       51602 :     char *key = NULL, *val;
    1484       51602 :     const char *opts = *ropts;
    1485             : 
    1486       61488 :     if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
    1487        9886 :         !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
    1488           1 :         return AVERROR(EINVAL);
    1489       51601 :     if (!(val = av_get_token(&opts, pairs_sep))) {
    1490           0 :         av_free(key);
    1491           0 :         return AVERROR(ENOMEM);
    1492             :     }
    1493       51601 :     *ropts = opts;
    1494       51601 :     *rkey  = key;
    1495       51601 :     *rval  = val;
    1496       51601 :     return 0;
    1497             : }
    1498             : 
    1499          18 : int av_opt_set_from_string(void *ctx, const char *opts,
    1500             :                            const char *const *shorthand,
    1501             :                            const char *key_val_sep, const char *pairs_sep)
    1502             : {
    1503          18 :     int ret, count = 0;
    1504          18 :     const char *dummy_shorthand = NULL;
    1505          18 :     char *av_uninit(parsed_key), *av_uninit(value);
    1506             :     const char *key;
    1507             : 
    1508          18 :     if (!opts)
    1509           0 :         return 0;
    1510          18 :     if (!shorthand)
    1511           0 :         shorthand = &dummy_shorthand;
    1512             : 
    1513          56 :     while (*opts) {
    1514          24 :         ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
    1515          24 :                                    *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
    1516             :                                    &parsed_key, &value);
    1517          24 :         if (ret < 0) {
    1518           1 :             if (ret == AVERROR(EINVAL))
    1519           1 :                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
    1520             :             else
    1521           0 :                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
    1522           0 :                        av_err2str(ret));
    1523           1 :             return ret;
    1524             :         }
    1525          23 :         if (*opts)
    1526           8 :             opts++;
    1527          23 :         if (parsed_key) {
    1528          11 :             key = parsed_key;
    1529          33 :             while (*shorthand) /* discard all remaining shorthand */
    1530          11 :                 shorthand++;
    1531             :         } else {
    1532          12 :             key = *(shorthand++);
    1533             :         }
    1534             : 
    1535          23 :         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
    1536          23 :         if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
    1537           3 :             if (ret == AVERROR_OPTION_NOT_FOUND)
    1538           2 :                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
    1539           3 :             av_free(value);
    1540           3 :             av_free(parsed_key);
    1541           3 :             return ret;
    1542             :         }
    1543             : 
    1544          20 :         av_free(value);
    1545          20 :         av_free(parsed_key);
    1546          20 :         count++;
    1547             :     }
    1548          14 :     return count;
    1549             : }
    1550             : 
    1551      471573 : void av_opt_free(void *obj)
    1552             : {
    1553      471573 :     const AVOption *o = NULL;
    1554    28219136 :     while ((o = av_opt_next(obj, o))) {
    1555    27275990 :         switch (o->type) {
    1556      676002 :         case AV_OPT_TYPE_STRING:
    1557             :         case AV_OPT_TYPE_BINARY:
    1558      676002 :             av_freep((uint8_t *)obj + o->offset);
    1559      676002 :             break;
    1560             : 
    1561           0 :         case AV_OPT_TYPE_DICT:
    1562           0 :             av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
    1563           0 :             break;
    1564             : 
    1565    26599988 :         default:
    1566    26599988 :             break;
    1567             :         }
    1568             :     }
    1569      471573 : }
    1570             : 
    1571      193011 : int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
    1572             : {
    1573      193011 :     AVDictionaryEntry *t = NULL;
    1574      193011 :     AVDictionary    *tmp = NULL;
    1575      193011 :     int ret = 0;
    1576             : 
    1577      193011 :     if (!options)
    1578           0 :         return 0;
    1579             : 
    1580      601854 :     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
    1581      215832 :         ret = av_opt_set(obj, t->key, t->value, search_flags);
    1582      215832 :         if (ret == AVERROR_OPTION_NOT_FOUND)
    1583      103425 :             ret = av_dict_set(&tmp, t->key, t->value, 0);
    1584      215832 :         if (ret < 0) {
    1585           0 :             av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
    1586           0 :             av_dict_free(&tmp);
    1587           0 :             return ret;
    1588             :         }
    1589      215832 :         ret = 0;
    1590             :     }
    1591      193011 :     av_dict_free(options);
    1592      193011 :     *options = tmp;
    1593      193011 :     return ret;
    1594             : }
    1595             : 
    1596      164934 : int av_opt_set_dict(void *obj, AVDictionary **options)
    1597             : {
    1598      164934 :     return av_opt_set_dict2(obj, options, 0);
    1599             : }
    1600             : 
    1601      459810 : const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
    1602             :                             int opt_flags, int search_flags)
    1603             : {
    1604      459810 :     return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
    1605             : }
    1606             : 
    1607    20619187 : const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
    1608             :                              int opt_flags, int search_flags, void **target_obj)
    1609             : {
    1610             :     const AVClass  *c;
    1611    20619187 :     const AVOption *o = NULL;
    1612             : 
    1613    20619187 :     if(!obj)
    1614           0 :         return NULL;
    1615             : 
    1616    20619187 :     c= *(AVClass**)obj;
    1617             : 
    1618    20619187 :     if (!c)
    1619         928 :         return NULL;
    1620             : 
    1621    20618259 :     if (search_flags & AV_OPT_SEARCH_CHILDREN) {
    1622    20088338 :         if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
    1623    17797799 :             const AVClass *child = NULL;
    1624    53179149 :             while (child = av_opt_child_class_next(c, child))
    1625    17588854 :                 if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
    1626        5303 :                     return o;
    1627             :         } else {
    1628     2290539 :             void *child = NULL;
    1629     6244001 :             while (child = av_opt_child_next(obj, child))
    1630     1664324 :                 if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
    1631        1401 :                     return o;
    1632             :         }
    1633             :     }
    1634             : 
    1635   329962412 :     while (o = av_opt_next(obj, o)) {
    1636   289222676 :         if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
    1637      439016 :             ((!unit && o->type != AV_OPT_TYPE_CONST) ||
    1638       98588 :              (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
    1639      483374 :             if (target_obj) {
    1640      270501 :                 if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
    1641      270501 :                     *target_obj = obj;
    1642             :                 else
    1643           0 :                     *target_obj = NULL;
    1644             :             }
    1645      483374 :             return o;
    1646             :         }
    1647             :     }
    1648    20128181 :     return NULL;
    1649             : }
    1650             : 
    1651     3953462 : void *av_opt_child_next(void *obj, void *prev)
    1652             : {
    1653     3953462 :     const AVClass *c = *(AVClass **)obj;
    1654     3953462 :     if (c->child_next)
    1655     3063868 :         return c->child_next(obj, prev);
    1656      889594 :     return NULL;
    1657             : }
    1658             : 
    1659    35381350 : const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
    1660             : {
    1661    35381350 :     if (parent->child_class_next)
    1662    17822515 :         return parent->child_class_next(prev);
    1663    17558835 :     return NULL;
    1664             : }
    1665             : 
    1666        5917 : void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
    1667             : {
    1668        5917 :     const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
    1669        5917 :     if(!opt)
    1670        5889 :         return NULL;
    1671          28 :     return (uint8_t*)obj + opt->offset;
    1672             : }
    1673             : 
    1674      778732 : static int opt_size(enum AVOptionType type)
    1675             : {
    1676      778732 :     switch(type) {
    1677      619607 :     case AV_OPT_TYPE_BOOL:
    1678             :     case AV_OPT_TYPE_INT:
    1679             :     case AV_OPT_TYPE_FLAGS:
    1680      619607 :         return sizeof(int);
    1681       45465 :     case AV_OPT_TYPE_DURATION:
    1682             :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1683             :     case AV_OPT_TYPE_INT64:
    1684             :     case AV_OPT_TYPE_UINT64:
    1685       45465 :         return sizeof(int64_t);
    1686           0 :     case AV_OPT_TYPE_DOUBLE:
    1687           0 :         return sizeof(double);
    1688       73879 :     case AV_OPT_TYPE_FLOAT:
    1689       73879 :         return sizeof(float);
    1690           0 :     case AV_OPT_TYPE_STRING:
    1691           0 :         return sizeof(uint8_t*);
    1692       22732 :     case AV_OPT_TYPE_VIDEO_RATE:
    1693             :     case AV_OPT_TYPE_RATIONAL:
    1694       22732 :         return sizeof(AVRational);
    1695           0 :     case AV_OPT_TYPE_BINARY:
    1696           0 :         return sizeof(uint8_t*) + sizeof(int);
    1697        5683 :     case AV_OPT_TYPE_IMAGE_SIZE:
    1698        5683 :         return sizeof(int[2]);
    1699        5683 :     case AV_OPT_TYPE_PIXEL_FMT:
    1700        5683 :         return sizeof(enum AVPixelFormat);
    1701        5683 :     case AV_OPT_TYPE_SAMPLE_FMT:
    1702        5683 :         return sizeof(enum AVSampleFormat);
    1703           0 :     case AV_OPT_TYPE_COLOR:
    1704           0 :         return 4;
    1705             :     }
    1706           0 :     return AVERROR(EINVAL);
    1707             : }
    1708             : 
    1709        5824 : int av_opt_copy(void *dst, const void *src)
    1710             : {
    1711        5824 :     const AVOption *o = NULL;
    1712             :     const AVClass *c;
    1713        5824 :     int ret = 0;
    1714             : 
    1715        5824 :     if (!src)
    1716           0 :         return AVERROR(EINVAL);
    1717             : 
    1718        5824 :     c = *(AVClass **)src;
    1719        5824 :     if (!c || c != *(AVClass **)dst)
    1720           4 :         return AVERROR(EINVAL);
    1721             : 
    1722     2194631 :     while ((o = av_opt_next(src, o))) {
    1723     2182991 :         void *field_dst = (uint8_t *)dst + o->offset;
    1724     2182991 :         void *field_src = (uint8_t *)src + o->offset;
    1725     2182991 :         uint8_t **field_dst8 = (uint8_t **)field_dst;
    1726     2182991 :         uint8_t **field_src8 = (uint8_t **)field_src;
    1727             : 
    1728     2182991 :         if (o->type == AV_OPT_TYPE_STRING) {
    1729       17055 :             if (*field_dst8 != *field_src8)
    1730           4 :                 av_freep(field_dst8);
    1731       17055 :             *field_dst8 = av_strdup(*field_src8);
    1732       17055 :             if (*field_src8 && !*field_dst8)
    1733           0 :                 ret = AVERROR(ENOMEM);
    1734     2165936 :         } else if (o->type == AV_OPT_TYPE_BINARY) {
    1735           0 :             int len = *(int *)(field_src8 + 1);
    1736           0 :             if (*field_dst8 != *field_src8)
    1737           0 :                 av_freep(field_dst8);
    1738           0 :             *field_dst8 = av_memdup(*field_src8, len);
    1739           0 :             if (len && !*field_dst8) {
    1740           0 :                 ret = AVERROR(ENOMEM);
    1741           0 :                 len = 0;
    1742             :             }
    1743           0 :             *(int *)(field_dst8 + 1) = len;
    1744     2165936 :         } else if (o->type == AV_OPT_TYPE_CONST) {
    1745             :             // do nothing
    1746      778732 :         } else if (o->type == AV_OPT_TYPE_DICT) {
    1747           0 :             AVDictionary **sdict = (AVDictionary **) field_src;
    1748           0 :             AVDictionary **ddict = (AVDictionary **) field_dst;
    1749           0 :             if (*sdict != *ddict)
    1750           0 :                 av_dict_free(ddict);
    1751           0 :             *ddict = NULL;
    1752           0 :             av_dict_copy(ddict, *sdict, 0);
    1753           0 :             if (av_dict_count(*sdict) != av_dict_count(*ddict))
    1754           0 :                 ret = AVERROR(ENOMEM);
    1755             :         } else {
    1756      778732 :             int size = opt_size(o->type);
    1757      778732 :             if (size < 0)
    1758           0 :                 ret = size;
    1759             :             else
    1760      778732 :                 memcpy(field_dst, field_src, size);
    1761             :         }
    1762             :     }
    1763        5820 :     return ret;
    1764             : }
    1765             : 
    1766          25 : int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
    1767             : {
    1768             :     int ret;
    1769          25 :     const AVClass *c = *(AVClass**)obj;
    1770          25 :     int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
    1771             : 
    1772          25 :     if (c->version > (52 << 16 | 11 << 8))
    1773           0 :         callback = c->query_ranges;
    1774             : 
    1775          25 :     if (!callback)
    1776          25 :         callback = av_opt_query_ranges_default;
    1777             : 
    1778          25 :     ret = callback(ranges_arg, obj, key, flags);
    1779          25 :     if (ret >= 0) {
    1780          18 :         if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
    1781          18 :             ret = 1;
    1782          18 :         (*ranges_arg)->nb_components = ret;
    1783             :     }
    1784          25 :     return ret;
    1785             : }
    1786             : 
    1787          25 : int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
    1788             : {
    1789          25 :     AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
    1790          25 :     AVOptionRange **range_array = av_mallocz(sizeof(void*));
    1791          25 :     AVOptionRange *range = av_mallocz(sizeof(*range));
    1792          25 :     const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
    1793             :     int ret;
    1794             : 
    1795          25 :     *ranges_arg = NULL;
    1796             : 
    1797          25 :     if (!ranges || !range || !range_array || !field) {
    1798           3 :         ret = AVERROR(ENOMEM);
    1799           3 :         goto fail;
    1800             :     }
    1801             : 
    1802          22 :     ranges->range = range_array;
    1803          22 :     ranges->range[0] = range;
    1804          22 :     ranges->nb_ranges = 1;
    1805          22 :     ranges->nb_components = 1;
    1806          22 :     range->is_range = 1;
    1807          22 :     range->value_min = field->min;
    1808          22 :     range->value_max = field->max;
    1809             : 
    1810          22 :     switch (field->type) {
    1811          13 :     case AV_OPT_TYPE_BOOL:
    1812             :     case AV_OPT_TYPE_INT:
    1813             :     case AV_OPT_TYPE_INT64:
    1814             :     case AV_OPT_TYPE_UINT64:
    1815             :     case AV_OPT_TYPE_PIXEL_FMT:
    1816             :     case AV_OPT_TYPE_SAMPLE_FMT:
    1817             :     case AV_OPT_TYPE_FLOAT:
    1818             :     case AV_OPT_TYPE_DOUBLE:
    1819             :     case AV_OPT_TYPE_DURATION:
    1820             :     case AV_OPT_TYPE_COLOR:
    1821             :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1822          13 :         break;
    1823           2 :     case AV_OPT_TYPE_STRING:
    1824           2 :         range->component_min = 0;
    1825           2 :         range->component_max = 0x10FFFF; // max unicode value
    1826           2 :         range->value_min = -1;
    1827           2 :         range->value_max = INT_MAX;
    1828           2 :         break;
    1829           1 :     case AV_OPT_TYPE_RATIONAL:
    1830           1 :         range->component_min = INT_MIN;
    1831           1 :         range->component_max = INT_MAX;
    1832           1 :         break;
    1833           1 :     case AV_OPT_TYPE_IMAGE_SIZE:
    1834           1 :         range->component_min = 0;
    1835           1 :         range->component_max = INT_MAX/128/8;
    1836           1 :         range->value_min = 0;
    1837           1 :         range->value_max = INT_MAX/8;
    1838           1 :         break;
    1839           1 :     case AV_OPT_TYPE_VIDEO_RATE:
    1840           1 :         range->component_min = 1;
    1841           1 :         range->component_max = INT_MAX;
    1842           1 :         range->value_min = 1;
    1843           1 :         range->value_max = INT_MAX;
    1844           1 :         break;
    1845           4 :     default:
    1846           4 :         ret = AVERROR(ENOSYS);
    1847           4 :         goto fail;
    1848             :     }
    1849             : 
    1850          18 :     *ranges_arg = ranges;
    1851          18 :     return 1;
    1852           7 : fail:
    1853           7 :     av_free(ranges);
    1854           7 :     av_free(range);
    1855           7 :     av_free(range_array);
    1856           7 :     return ret;
    1857             : }
    1858             : 
    1859          18 : void av_opt_freep_ranges(AVOptionRanges **rangesp)
    1860             : {
    1861             :     int i;
    1862          18 :     AVOptionRanges *ranges = *rangesp;
    1863             : 
    1864          18 :     if (!ranges)
    1865           0 :         return;
    1866             : 
    1867          36 :     for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
    1868          18 :         AVOptionRange *range = ranges->range[i];
    1869          18 :         if (range) {
    1870          18 :             av_freep(&range->str);
    1871          18 :             av_freep(&ranges->range[i]);
    1872             :         }
    1873             :     }
    1874          18 :     av_freep(&ranges->range);
    1875          18 :     av_freep(rangesp);
    1876             : }
    1877             : 
    1878          44 : int av_opt_is_set_to_default(void *obj, const AVOption *o)
    1879             : {
    1880             :     int64_t i64;
    1881             :     double d, d2;
    1882             :     float f;
    1883             :     AVRational q;
    1884             :     int ret, w, h;
    1885             :     char *str;
    1886             :     void *dst;
    1887             : 
    1888          44 :     if (!o || !obj)
    1889           0 :         return AVERROR(EINVAL);
    1890             : 
    1891          44 :     dst = ((uint8_t*)obj) + o->offset;
    1892             : 
    1893          44 :     switch (o->type) {
    1894           0 :     case AV_OPT_TYPE_CONST:
    1895           0 :         return 1;
    1896          22 :     case AV_OPT_TYPE_BOOL:
    1897             :     case AV_OPT_TYPE_FLAGS:
    1898             :     case AV_OPT_TYPE_PIXEL_FMT:
    1899             :     case AV_OPT_TYPE_SAMPLE_FMT:
    1900             :     case AV_OPT_TYPE_INT:
    1901             :     case AV_OPT_TYPE_CHANNEL_LAYOUT:
    1902             :     case AV_OPT_TYPE_DURATION:
    1903             :     case AV_OPT_TYPE_INT64:
    1904             :     case AV_OPT_TYPE_UINT64:
    1905          22 :         read_number(o, dst, NULL, NULL, &i64);
    1906          22 :         return o->default_val.i64 == i64;
    1907           4 :     case AV_OPT_TYPE_STRING:
    1908           4 :         str = *(char **)dst;
    1909           4 :         if (str == o->default_val.str) //2 NULLs
    1910           0 :             return 1;
    1911           4 :         if (!str || !o->default_val.str) //1 NULL
    1912           2 :             return 0;
    1913           2 :         return !strcmp(str, o->default_val.str);
    1914           2 :     case AV_OPT_TYPE_DOUBLE:
    1915           2 :         read_number(o, dst, &d, NULL, NULL);
    1916           2 :         return o->default_val.dbl == d;
    1917           2 :     case AV_OPT_TYPE_FLOAT:
    1918           2 :         read_number(o, dst, &d, NULL, NULL);
    1919           2 :         f = o->default_val.dbl;
    1920           2 :         d2 = f;
    1921           2 :         return d2 == d;
    1922           2 :     case AV_OPT_TYPE_RATIONAL:
    1923           2 :         q = av_d2q(o->default_val.dbl, INT_MAX);
    1924           2 :         return !av_cmp_q(*(AVRational*)dst, q);
    1925           6 :     case AV_OPT_TYPE_BINARY: {
    1926             :         struct {
    1927             :             uint8_t *data;
    1928             :             int size;
    1929           6 :         } tmp = {0};
    1930           6 :         int opt_size = *(int *)((void **)dst + 1);
    1931           6 :         void *opt_ptr = *(void **)dst;
    1932           6 :         if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
    1933           4 :             return 1;
    1934           2 :         if (!opt_size ||  !o->default_val.str || !strlen(o->default_val.str ))
    1935           1 :             return 0;
    1936           1 :         if (opt_size != strlen(o->default_val.str) / 2)
    1937           0 :             return 0;
    1938           1 :         ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
    1939           1 :         if (!ret)
    1940           1 :             ret = !memcmp(opt_ptr, tmp.data, tmp.size);
    1941           1 :         av_free(tmp.data);
    1942           1 :         return ret;
    1943             :     }
    1944           0 :     case AV_OPT_TYPE_DICT:
    1945             :         /* Binary and dict have not default support yet. Any pointer is not default. */
    1946           0 :         return !!(*(void **)dst);
    1947           2 :     case AV_OPT_TYPE_IMAGE_SIZE:
    1948           2 :         if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
    1949           0 :             w = h = 0;
    1950           2 :         else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
    1951           0 :             return ret;
    1952           2 :         return (w == *(int *)dst) && (h == *((int *)dst+1));
    1953           2 :     case AV_OPT_TYPE_VIDEO_RATE:
    1954           2 :         q = (AVRational){0, 0};
    1955           2 :         if (o->default_val.str) {
    1956           2 :             if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
    1957           0 :                 return ret;
    1958             :         }
    1959           2 :         return !av_cmp_q(*(AVRational*)dst, q);
    1960           2 :     case AV_OPT_TYPE_COLOR: {
    1961           2 :         uint8_t color[4] = {0, 0, 0, 0};
    1962           2 :         if (o->default_val.str) {
    1963           2 :             if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
    1964           0 :                 return ret;
    1965             :         }
    1966           2 :         return !memcmp(color, dst, sizeof(color));
    1967             :     }
    1968           0 :     default:
    1969           0 :         av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
    1970           0 :         break;
    1971             :     }
    1972           0 :     return AVERROR_PATCHWELCOME;
    1973             : }
    1974             : 
    1975          50 : int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
    1976             : {
    1977             :     const AVOption *o;
    1978             :     void *target;
    1979          50 :     if (!obj)
    1980           0 :         return AVERROR(EINVAL);
    1981          50 :     o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
    1982          50 :     if (!o)
    1983           6 :         return AVERROR_OPTION_NOT_FOUND;
    1984          44 :     return av_opt_is_set_to_default(target, o);
    1985             : }
    1986             : 
    1987           2 : int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
    1988             :                      const char key_val_sep, const char pairs_sep)
    1989             : {
    1990           2 :     const AVOption *o = NULL;
    1991             :     uint8_t *buf;
    1992             :     AVBPrint bprint;
    1993           2 :     int ret, cnt = 0;
    1994           2 :     const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
    1995             : 
    1996           4 :     if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
    1997           4 :         pairs_sep == '\\' || key_val_sep == '\\') {
    1998           0 :         av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
    1999           0 :         return AVERROR(EINVAL);
    2000             :     }
    2001             : 
    2002           2 :     if (!obj || !buffer)
    2003           0 :         return AVERROR(EINVAL);
    2004             : 
    2005           2 :     *buffer = NULL;
    2006           2 :     av_bprint_init(&bprint, 64, AV_BPRINT_SIZE_UNLIMITED);
    2007             : 
    2008          54 :     while (o = av_opt_next(obj, o)) {
    2009          50 :         if (o->type == AV_OPT_TYPE_CONST)
    2010           6 :             continue;
    2011          44 :         if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
    2012           0 :             continue;
    2013          44 :         else if (((o->flags & opt_flags) != opt_flags))
    2014           0 :             continue;
    2015          44 :         if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
    2016           0 :             continue;
    2017          44 :         if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
    2018           0 :             av_bprint_finalize(&bprint, NULL);
    2019           0 :             return ret;
    2020             :         }
    2021          44 :         if (buf) {
    2022          44 :             if (cnt++)
    2023          42 :                 av_bprint_append_data(&bprint, &pairs_sep, 1);
    2024          44 :             av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
    2025          44 :             av_bprint_append_data(&bprint, &key_val_sep, 1);
    2026          44 :             av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
    2027          44 :             av_freep(&buf);
    2028             :         }
    2029             :     }
    2030           2 :     av_bprint_finalize(&bprint, buffer);
    2031           2 :     return 0;
    2032             : }

Generated by: LCOV version 1.13