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

Generated by: LCOV version 1.13