FFmpeg
opt.c
Go to the documentation of this file.
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 const AVOption *av_opt_next(const void *obj, const AVOption *last)
46 {
47  const AVClass *class;
48  if (!obj)
49  return NULL;
50  class = *(const AVClass**)obj;
51  if (!last && class && class->option && class->option[0].name)
52  return class->option;
53  if (last && last[1].name)
54  return ++last;
55  return NULL;
56 }
57 
58 static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
59 {
60  switch (o->type) {
61  case AV_OPT_TYPE_FLAGS:
62  *intnum = *(unsigned int*)dst;
63  return 0;
65  *intnum = *(enum AVPixelFormat *)dst;
66  return 0;
68  *intnum = *(enum AVSampleFormat *)dst;
69  return 0;
70  case AV_OPT_TYPE_BOOL:
71  case AV_OPT_TYPE_INT:
72  *intnum = *(int *)dst;
73  return 0;
76  case AV_OPT_TYPE_INT64:
77  case AV_OPT_TYPE_UINT64:
78  *intnum = *(int64_t *)dst;
79  return 0;
80  case AV_OPT_TYPE_FLOAT:
81  *num = *(float *)dst;
82  return 0;
83  case AV_OPT_TYPE_DOUBLE:
84  *num = *(double *)dst;
85  return 0;
87  *intnum = ((AVRational *)dst)->num;
88  *den = ((AVRational *)dst)->den;
89  return 0;
90  case AV_OPT_TYPE_CONST:
91  *num = o->default_val.dbl;
92  return 0;
93  }
94  return AVERROR(EINVAL);
95 }
96 
97 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
98 {
99  if (o->type != AV_OPT_TYPE_FLAGS &&
100  (!den || o->max * den < num * intnum || o->min * den > num * intnum)) {
101  num = den ? num * intnum / den : (num && intnum ? INFINITY : NAN);
102  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  return AVERROR(ERANGE);
105  }
106  if (o->type == AV_OPT_TYPE_FLAGS) {
107  double d = num*intnum/den;
108  if (d < -1.5 || d > 0xFFFFFFFF+0.5 || (llrint(d*256) & 255)) {
109  av_log(obj, AV_LOG_ERROR,
110  "Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
111  num*intnum/den, o->name);
112  return AVERROR(ERANGE);
113  }
114  }
115 
116  switch (o->type) {
118  *(enum AVPixelFormat *)dst = llrint(num / den) * intnum;
119  break;
121  *(enum AVSampleFormat *)dst = llrint(num / den) * intnum;
122  break;
123  case AV_OPT_TYPE_BOOL:
124  case AV_OPT_TYPE_FLAGS:
125  case AV_OPT_TYPE_INT:
126  *(int *)dst = llrint(num / den) * intnum;
127  break;
130  case AV_OPT_TYPE_INT64:{
131  double d = num / den;
132  if (intnum == 1 && d == (double)INT64_MAX) {
133  *(int64_t *)dst = INT64_MAX;
134  } else
135  *(int64_t *)dst = llrint(d) * intnum;
136  break;}
137  case AV_OPT_TYPE_UINT64:{
138  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  if (intnum == 1 && d == (double)UINT64_MAX) {
144  *(uint64_t *)dst = UINT64_MAX;
145  } else if (d > INT64_MAX + 1ULL) {
146  *(uint64_t *)dst = (llrint(d - (INT64_MAX + 1ULL)) + (INT64_MAX + 1ULL))*intnum;
147  } else {
148  *(uint64_t *)dst = llrint(d) * intnum;
149  }
150  break;}
151  case AV_OPT_TYPE_FLOAT:
152  *(float *)dst = num * intnum / den;
153  break;
154  case AV_OPT_TYPE_DOUBLE:
155  *(double *)dst = num * intnum / den;
156  break;
159  if ((int) num == num)
160  *(AVRational *)dst = (AVRational) { num *intnum, den };
161  else
162  *(AVRational *)dst = av_d2q(num * intnum / den, 1 << 24);
163  break;
164  default:
165  return AVERROR(EINVAL);
166  }
167  return 0;
168 }
169 
170 static int hexchar2int(char c) {
171  if (c >= '0' && c <= '9')
172  return c - '0';
173  if (c >= 'a' && c <= 'f')
174  return c - 'a' + 10;
175  if (c >= 'A' && c <= 'F')
176  return c - 'A' + 10;
177  return -1;
178 }
179 
180 static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
181 {
182  int *lendst = (int *)(dst + 1);
183  uint8_t *bin, *ptr;
184  int len;
185 
186  av_freep(dst);
187  *lendst = 0;
188 
189  if (!val || !(len = strlen(val)))
190  return 0;
191 
192  if (len & 1)
193  return AVERROR(EINVAL);
194  len /= 2;
195 
196  ptr = bin = av_malloc(len);
197  if (!ptr)
198  return AVERROR(ENOMEM);
199  while (*val) {
200  int a = hexchar2int(*val++);
201  int b = hexchar2int(*val++);
202  if (a < 0 || b < 0) {
203  av_free(bin);
204  return AVERROR(EINVAL);
205  }
206  *ptr++ = (a << 4) | b;
207  }
208  *dst = bin;
209  *lendst = len;
210 
211  return 0;
212 }
213 
214 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
215 {
216  av_freep(dst);
217  *dst = av_strdup(val);
218  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 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
230 {
231  int ret = 0;
232  int num, den;
233  char c;
234 
235  if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
236  if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
237  return ret;
238  ret = 0;
239  }
240 
241  for (;;) {
242  int i = 0;
243  char buf[256];
244  int cmd = 0;
245  double d;
246  int64_t intnum = 1;
247 
248  if (o->type == AV_OPT_TYPE_FLAGS) {
249  if (*val == '+' || *val == '-')
250  cmd = *(val++);
251  for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
252  buf[i] = val[i];
253  buf[i] = 0;
254  }
255 
256  {
257  const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, 0);
258  int res;
259  int ci = 0;
260  double const_values[64];
261  const char * const_names[64];
262  if (o_named && o_named->type == AV_OPT_TYPE_CONST)
263  d = DEFAULT_NUMVAL(o_named);
264  else {
265  if (o->unit) {
266  for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
267  if (o_named->type == AV_OPT_TYPE_CONST &&
268  o_named->unit &&
269  !strcmp(o_named->unit, o->unit)) {
270  if (ci + 6 >= FF_ARRAY_ELEMS(const_values)) {
271  av_log(obj, AV_LOG_ERROR, "const_values array too small for %s\n", o->unit);
272  return AVERROR_PATCHWELCOME;
273  }
274  const_names [ci ] = o_named->name;
275  const_values[ci++] = DEFAULT_NUMVAL(o_named);
276  }
277  }
278  }
279  const_names [ci ] = "default";
280  const_values[ci++] = DEFAULT_NUMVAL(o);
281  const_names [ci ] = "max";
282  const_values[ci++] = o->max;
283  const_names [ci ] = "min";
284  const_values[ci++] = o->min;
285  const_names [ci ] = "none";
286  const_values[ci++] = 0;
287  const_names [ci ] = "all";
288  const_values[ci++] = ~0;
289  const_names [ci] = NULL;
290  const_values[ci] = 0;
291 
292  res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
293  const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
294  if (res < 0) {
295  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
296  return res;
297  }
298  }
299  }
300  if (o->type == AV_OPT_TYPE_FLAGS) {
301  read_number(o, dst, NULL, NULL, &intnum);
302  if (cmd == '+')
303  d = intnum | (int64_t)d;
304  else if (cmd == '-')
305  d = intnum &~(int64_t)d;
306  }
307 
308  if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
309  return ret;
310  val += i;
311  if (!i || !*val)
312  return 0;
313  }
314 }
315 
316 static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
317 {
318  int ret;
319 
320  if (!val || !strcmp(val, "none")) {
321  dst[0] =
322  dst[1] = 0;
323  return 0;
324  }
325  ret = av_parse_video_size(dst, dst + 1, val);
326  if (ret < 0)
327  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
328  return ret;
329 }
330 
331 static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
332 {
333  int ret;
334  if (!val) {
335  ret = AVERROR(EINVAL);
336  } else {
337  ret = av_parse_video_rate(dst, val);
338  }
339  if (ret < 0)
340  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
341  return ret;
342 }
343 
344 static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
345 {
346  int ret;
347 
348  if (!val) {
349  return 0;
350  } else {
351  ret = av_parse_color(dst, val, -1, obj);
352  if (ret < 0)
353  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
354  return ret;
355  }
356  return 0;
357 }
358 
359 static const char *get_bool_name(int val)
360 {
361  if (val < 0)
362  return "auto";
363  return val ? "true" : "false";
364 }
365 
366 static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
367 {
368  int n;
369 
370  if (!val)
371  return 0;
372 
373  if (!strcmp(val, "auto")) {
374  n = -1;
375  } else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
376  n = 1;
377  } else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
378  n = 0;
379  } else {
380  char *end = NULL;
381  n = strtol(val, &end, 10);
382  if (val + strlen(val) != end)
383  goto fail;
384  }
385 
386  if (n < o->min || n > o->max)
387  goto fail;
388 
389  *dst = n;
390  return 0;
391 
392 fail:
393  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as boolean\n", val);
394  return AVERROR(EINVAL);
395 }
396 
397 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  if (!val || !strcmp(val, "none")) {
403  fmt = -1;
404  } else {
405  fmt = get_fmt(val);
406  if (fmt == -1) {
407  char *tail;
408  fmt = strtol(val, &tail, 0);
409  if (*tail || (unsigned)fmt >= fmt_nb) {
410  av_log(obj, AV_LOG_ERROR,
411  "Unable to parse option value \"%s\" as %s\n", val, desc);
412  return AVERROR(EINVAL);
413  }
414  }
415  }
416 
417  min = FFMAX(o->min, -1);
418  max = FFMIN(o->max, fmt_nb-1);
419 
420  // hack for compatibility with old ffmpeg
421  if(min == 0 && max == 0) {
422  min = -1;
423  max = fmt_nb-1;
424  }
425 
426  if (fmt < min || fmt > max) {
427  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  return AVERROR(ERANGE);
431  }
432 
433  *(int *)dst = fmt;
434  return 0;
435 }
436 
437 static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
438 {
439  return set_string_fmt(obj, o, val, dst,
440  AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
441 }
442 
443 static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
444 {
445  return set_string_fmt(obj, o, val, dst,
446  AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
447 }
448 
449 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
450 {
451  int ret = 0;
452  void *dst, *target_obj;
453  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
454  if (!o || !target_obj)
456  if (!val && (o->type != AV_OPT_TYPE_STRING &&
461  return AVERROR(EINVAL);
462 
463  if (o->flags & AV_OPT_FLAG_READONLY)
464  return AVERROR(EINVAL);
465 
466  if (o->flags & AV_OPT_FLAG_DEPRECATED)
467  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
468 
469  dst = ((uint8_t *)target_obj) + o->offset;
470  switch (o->type) {
471  case AV_OPT_TYPE_BOOL:
472  return set_string_bool(obj, o, val, dst);
473  case AV_OPT_TYPE_STRING:
474  return set_string(obj, o, val, dst);
475  case AV_OPT_TYPE_BINARY:
476  return set_string_binary(obj, o, val, dst);
477  case AV_OPT_TYPE_FLAGS:
478  case AV_OPT_TYPE_INT:
479  case AV_OPT_TYPE_INT64:
480  case AV_OPT_TYPE_UINT64:
481  case AV_OPT_TYPE_FLOAT:
482  case AV_OPT_TYPE_DOUBLE:
484  return set_string_number(obj, target_obj, o, val, dst);
486  return set_string_image_size(obj, o, val, dst);
487  case AV_OPT_TYPE_VIDEO_RATE: {
488  AVRational tmp;
489  ret = set_string_video_rate(obj, o, val, &tmp);
490  if (ret < 0)
491  return ret;
492  return write_number(obj, o, dst, 1, tmp.den, tmp.num);
493  }
495  return set_string_pixel_fmt(obj, o, val, dst);
497  return set_string_sample_fmt(obj, o, val, dst);
499  {
500  int64_t usecs = 0;
501  if (val) {
502  if ((ret = av_parse_time(&usecs, val, 1)) < 0) {
503  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
504  return ret;
505  }
506  }
507  if (usecs < o->min || usecs > o->max) {
508  av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
509  usecs / 1000000.0, o->name, o->min / 1000000.0, o->max / 1000000.0);
510  return AVERROR(ERANGE);
511  }
512  *(int64_t *)dst = usecs;
513  return 0;
514  }
515  case AV_OPT_TYPE_COLOR:
516  return set_string_color(obj, o, val, dst);
518  if (!val || !strcmp(val, "none")) {
519  *(int64_t *)dst = 0;
520  } else {
521  int64_t cl = av_get_channel_layout(val);
522  if (!cl) {
523  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
524  ret = AVERROR(EINVAL);
525  }
526  *(int64_t *)dst = cl;
527  return ret;
528  }
529  break;
530  }
531 
532  av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
533  return AVERROR(EINVAL);
534 }
535 
536 #define OPT_EVAL_NUMBER(name, opttype, vartype) \
537 int av_opt_eval_ ## name(void *obj, const AVOption *o, \
538  const char *val, vartype *name ## _out) \
539 { \
540  if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY) \
541  return AVERROR(EINVAL); \
542  return set_string_number(obj, obj, o, val, name ## _out); \
543 }
544 
547 OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
548 OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
549 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
551 
552 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
553  int search_flags)
554 {
555  void *dst, *target_obj;
556  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
557 
558  if (!o || !target_obj)
560 
561  if (o->flags & AV_OPT_FLAG_READONLY)
562  return AVERROR(EINVAL);
563 
564  dst = ((uint8_t *)target_obj) + o->offset;
565  return write_number(obj, o, dst, num, den, intnum);
566 }
567 
568 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
569 {
570  return set_number(obj, name, 1, 1, val, search_flags);
571 }
572 
573 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
574 {
575  return set_number(obj, name, val, 1, 1, search_flags);
576 }
577 
578 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
579 {
580  return set_number(obj, name, val.num, val.den, 1, search_flags);
581 }
582 
583 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
584 {
585  void *target_obj;
586  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
587  uint8_t *ptr;
588  uint8_t **dst;
589  int *lendst;
590 
591  if (!o || !target_obj)
593 
595  return AVERROR(EINVAL);
596 
597  ptr = len ? av_malloc(len) : NULL;
598  if (len && !ptr)
599  return AVERROR(ENOMEM);
600 
601  dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
602  lendst = (int *)(dst + 1);
603 
604  av_free(*dst);
605  *dst = ptr;
606  *lendst = len;
607  if (len)
608  memcpy(ptr, val, len);
609 
610  return 0;
611 }
612 
613 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
614 {
615  void *target_obj;
616  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
617 
618  if (!o || !target_obj)
620  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
621  av_log(obj, AV_LOG_ERROR,
622  "The value set by option '%s' is not an image size.\n", o->name);
623  return AVERROR(EINVAL);
624  }
625  if (w<0 || h<0) {
626  av_log(obj, AV_LOG_ERROR,
627  "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
628  return AVERROR(EINVAL);
629  }
630  *(int *)(((uint8_t *)target_obj) + o->offset) = w;
631  *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
632  return 0;
633 }
634 
635 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
636 {
637  void *target_obj;
638  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
639 
640  if (!o || !target_obj)
642  if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
643  av_log(obj, AV_LOG_ERROR,
644  "The value set by option '%s' is not a video rate.\n", o->name);
645  return AVERROR(EINVAL);
646  }
647  if (val.num <= 0 || val.den <= 0)
648  return AVERROR(EINVAL);
649  return set_number(obj, name, val.num, val.den, 1, search_flags);
650 }
651 
652 static int set_format(void *obj, const char *name, int fmt, int search_flags,
653  enum AVOptionType type, const char *desc, int nb_fmts)
654 {
655  void *target_obj;
656  const AVOption *o = av_opt_find2(obj, name, NULL, 0,
657  search_flags, &target_obj);
658  int min, max;
659 
660  if (!o || !target_obj)
662  if (o->type != type) {
663  av_log(obj, AV_LOG_ERROR,
664  "The value set by option '%s' is not a %s format", name, desc);
665  return AVERROR(EINVAL);
666  }
667 
668  min = FFMAX(o->min, -1);
669  max = FFMIN(o->max, nb_fmts-1);
670 
671  if (fmt < min || fmt > max) {
672  av_log(obj, AV_LOG_ERROR,
673  "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
674  fmt, name, desc, min, max);
675  return AVERROR(ERANGE);
676  }
677  *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
678  return 0;
679 }
680 
681 int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
682 {
683  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
684 }
685 
686 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
687 {
688  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
689 }
690 
691 int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
692 {
693  void *target_obj;
694  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
695 
696  if (!o || !target_obj)
698  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
699  av_log(obj, AV_LOG_ERROR,
700  "The value set by option '%s' is not a channel layout.\n", o->name);
701  return AVERROR(EINVAL);
702  }
703  *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
704  return 0;
705 }
706 
707 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
708  int search_flags)
709 {
710  void *target_obj;
711  AVDictionary **dst;
712  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
713 
714  if (!o || !target_obj)
716  if (o->flags & AV_OPT_FLAG_READONLY)
717  return AVERROR(EINVAL);
718 
719  dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
720  av_dict_free(dst);
721  av_dict_copy(dst, val, 0);
722 
723  return 0;
724 }
725 
726 static void format_duration(char *buf, size_t size, int64_t d)
727 {
728  char *e;
729 
730  av_assert0(size >= 25);
731  if (d < 0 && d != INT64_MIN) {
732  *(buf++) = '-';
733  size--;
734  d = -d;
735  }
736  if (d == INT64_MAX)
737  snprintf(buf, size, "INT64_MAX");
738  else if (d == INT64_MIN)
739  snprintf(buf, size, "INT64_MIN");
740  else if (d > (int64_t)3600*1000000)
741  snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
742  (int)((d / 60000000) % 60),
743  (int)((d / 1000000) % 60),
744  (int)(d % 1000000));
745  else if (d > 60*1000000)
746  snprintf(buf, size, "%d:%02d.%06d",
747  (int)(d / 60000000),
748  (int)((d / 1000000) % 60),
749  (int)(d % 1000000));
750  else
751  snprintf(buf, size, "%d.%06d",
752  (int)(d / 1000000),
753  (int)(d % 1000000));
754  e = buf + strlen(buf);
755  while (e > buf && e[-1] == '0')
756  *(--e) = 0;
757  if (e > buf && e[-1] == '.')
758  *(--e) = 0;
759 }
760 
761 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
762 {
763  void *dst, *target_obj;
764  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
765  uint8_t *bin, buf[128];
766  int len, i, ret;
767  int64_t i64;
768 
769  if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
771 
772  if (o->flags & AV_OPT_FLAG_DEPRECATED)
773  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
774 
775  dst = (uint8_t *)target_obj + o->offset;
776 
777  buf[0] = 0;
778  switch (o->type) {
779  case AV_OPT_TYPE_BOOL:
780  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
781  break;
782  case AV_OPT_TYPE_FLAGS:
783  ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
784  break;
785  case AV_OPT_TYPE_INT:
786  ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
787  break;
788  case AV_OPT_TYPE_INT64:
789  ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
790  break;
791  case AV_OPT_TYPE_UINT64:
792  ret = snprintf(buf, sizeof(buf), "%"PRIu64, *(uint64_t *)dst);
793  break;
794  case AV_OPT_TYPE_FLOAT:
795  ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
796  break;
797  case AV_OPT_TYPE_DOUBLE:
798  ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
799  break;
802  ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
803  break;
804  case AV_OPT_TYPE_CONST:
805  ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
806  break;
807  case AV_OPT_TYPE_STRING:
808  if (*(uint8_t **)dst) {
809  *out_val = av_strdup(*(uint8_t **)dst);
810  } else if (search_flags & AV_OPT_ALLOW_NULL) {
811  *out_val = NULL;
812  return 0;
813  } else {
814  *out_val = av_strdup("");
815  }
816  return *out_val ? 0 : AVERROR(ENOMEM);
817  case AV_OPT_TYPE_BINARY:
818  if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
819  *out_val = NULL;
820  return 0;
821  }
822  len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
823  if ((uint64_t)len * 2 + 1 > INT_MAX)
824  return AVERROR(EINVAL);
825  if (!(*out_val = av_malloc(len * 2 + 1)))
826  return AVERROR(ENOMEM);
827  if (!len) {
828  *out_val[0] = '\0';
829  return 0;
830  }
831  bin = *(uint8_t **)dst;
832  for (i = 0; i < len; i++)
833  snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
834  return 0;
836  ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
837  break;
839  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
840  break;
842  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
843  break;
845  i64 = *(int64_t *)dst;
846  format_duration(buf, sizeof(buf), i64);
847  ret = strlen(buf); // no overflow possible, checked by an assert
848  break;
849  case AV_OPT_TYPE_COLOR:
850  ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
851  (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
852  (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
853  break;
855  i64 = *(int64_t *)dst;
856  ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
857  break;
858  default:
859  return AVERROR(EINVAL);
860  }
861 
862  if (ret >= sizeof(buf))
863  return AVERROR(EINVAL);
864  *out_val = av_strdup(buf);
865  return *out_val ? 0 : AVERROR(ENOMEM);
866 }
867 
868 static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
869  int search_flags)
870 {
871  void *dst, *target_obj;
872  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
873  if (!o || !target_obj)
874  goto error;
875 
876  dst = ((uint8_t *)target_obj) + o->offset;
877 
878  if (o_out) *o_out= o;
879 
880  return read_number(o, dst, num, den, intnum);
881 
882 error:
883  *den =
884  *intnum = 0;
885  return -1;
886 }
887 
888 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
889 {
890  int64_t intnum = 1;
891  double num = 1;
892  int ret, den = 1;
893 
894  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
895  return ret;
896  *out_val = num * intnum / den;
897  return 0;
898 }
899 
900 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
901 {
902  int64_t intnum = 1;
903  double num = 1;
904  int ret, den = 1;
905 
906  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
907  return ret;
908  *out_val = num * intnum / den;
909  return 0;
910 }
911 
912 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
913 {
914  int64_t intnum = 1;
915  double num = 1;
916  int ret, den = 1;
917 
918  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
919  return ret;
920 
921  if (num == 1.0 && (int)intnum == intnum)
922  *out_val = (AVRational){intnum, den};
923  else
924  *out_val = av_d2q(num*intnum/den, 1<<24);
925  return 0;
926 }
927 
928 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
929 {
930  void *dst, *target_obj;
931  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
932  if (!o || !target_obj)
934  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
935  av_log(obj, AV_LOG_ERROR,
936  "The value for option '%s' is not an image size.\n", name);
937  return AVERROR(EINVAL);
938  }
939 
940  dst = ((uint8_t*)target_obj) + o->offset;
941  if (w_out) *w_out = *(int *)dst;
942  if (h_out) *h_out = *((int *)dst+1);
943  return 0;
944 }
945 
946 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
947 {
948  int64_t intnum = 1;
949  double num = 1;
950  int ret, den = 1;
951 
952  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
953  return ret;
954 
955  if (num == 1.0 && (int)intnum == intnum)
956  *out_val = (AVRational) { intnum, den };
957  else
958  *out_val = av_d2q(num * intnum / den, 1 << 24);
959  return 0;
960 }
961 
962 static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
963  enum AVOptionType type, const char *desc)
964 {
965  void *dst, *target_obj;
966  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
967  if (!o || !target_obj)
969  if (o->type != type) {
970  av_log(obj, AV_LOG_ERROR,
971  "The value for option '%s' is not a %s format.\n", desc, name);
972  return AVERROR(EINVAL);
973  }
974 
975  dst = ((uint8_t*)target_obj) + o->offset;
976  *out_fmt = *(int *)dst;
977  return 0;
978 }
979 
980 int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
981 {
982  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
983 }
984 
985 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
986 {
987  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
988 }
989 
990 int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
991 {
992  void *dst, *target_obj;
993  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
994  if (!o || !target_obj)
996  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
997  av_log(obj, AV_LOG_ERROR,
998  "The value for option '%s' is not a channel layout.\n", name);
999  return AVERROR(EINVAL);
1000  }
1001 
1002  dst = ((uint8_t*)target_obj) + o->offset;
1003  *cl = *(int64_t *)dst;
1004  return 0;
1005 }
1006 
1007 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
1008 {
1009  void *target_obj;
1010  AVDictionary *src;
1011  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
1012 
1013  if (!o || !target_obj)
1014  return AVERROR_OPTION_NOT_FOUND;
1015  if (o->type != AV_OPT_TYPE_DICT)
1016  return AVERROR(EINVAL);
1017 
1018  src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
1019  av_dict_copy(out_val, src, 0);
1020 
1021  return 0;
1022 }
1023 
1024 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
1025 {
1026  const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
1027  const AVOption *flag = av_opt_find(obj, flag_name,
1028  field ? field->unit : NULL, 0, 0);
1029  int64_t res;
1030 
1031  if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
1032  av_opt_get_int(obj, field_name, 0, &res) < 0)
1033  return 0;
1034  return res & flag->default_val.i64;
1035 }
1036 
1037 static void log_int_value(void *av_log_obj, int level, int64_t i)
1038 {
1039  if (i == INT_MAX) {
1040  av_log(av_log_obj, level, "INT_MAX");
1041  } else if (i == INT_MIN) {
1042  av_log(av_log_obj, level, "INT_MIN");
1043  } else if (i == UINT32_MAX) {
1044  av_log(av_log_obj, level, "UINT32_MAX");
1045  } else if (i == INT64_MAX) {
1046  av_log(av_log_obj, level, "I64_MAX");
1047  } else if (i == INT64_MIN) {
1048  av_log(av_log_obj, level, "I64_MIN");
1049  } else {
1050  av_log(av_log_obj, level, "%"PRId64, i);
1051  }
1052 }
1053 
1054 static void log_value(void *av_log_obj, int level, double d)
1055 {
1056  if (d == INT_MAX) {
1057  av_log(av_log_obj, level, "INT_MAX");
1058  } else if (d == INT_MIN) {
1059  av_log(av_log_obj, level, "INT_MIN");
1060  } else if (d == UINT32_MAX) {
1061  av_log(av_log_obj, level, "UINT32_MAX");
1062  } else if (d == (double)INT64_MAX) {
1063  av_log(av_log_obj, level, "I64_MAX");
1064  } else if (d == INT64_MIN) {
1065  av_log(av_log_obj, level, "I64_MIN");
1066  } else if (d == FLT_MAX) {
1067  av_log(av_log_obj, level, "FLT_MAX");
1068  } else if (d == FLT_MIN) {
1069  av_log(av_log_obj, level, "FLT_MIN");
1070  } else if (d == -FLT_MAX) {
1071  av_log(av_log_obj, level, "-FLT_MAX");
1072  } else if (d == -FLT_MIN) {
1073  av_log(av_log_obj, level, "-FLT_MIN");
1074  } else if (d == DBL_MAX) {
1075  av_log(av_log_obj, level, "DBL_MAX");
1076  } else if (d == DBL_MIN) {
1077  av_log(av_log_obj, level, "DBL_MIN");
1078  } else if (d == -DBL_MAX) {
1079  av_log(av_log_obj, level, "-DBL_MAX");
1080  } else if (d == -DBL_MIN) {
1081  av_log(av_log_obj, level, "-DBL_MIN");
1082  } else {
1083  av_log(av_log_obj, level, "%g", d);
1084  }
1085 }
1086 
1087 static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
1088 {
1089  const AVOption *opt = NULL;
1090 
1091  if (!unit)
1092  return NULL;
1093  while ((opt = av_opt_next(obj, opt)))
1094  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1095  opt->default_val.i64 == value)
1096  return opt->name;
1097  return NULL;
1098 }
1099 
1100 static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
1101 {
1102  const AVOption *opt = NULL;
1103  char flags[512];
1104 
1105  flags[0] = 0;
1106  if (!unit)
1107  return NULL;
1108  while ((opt = av_opt_next(obj, opt))) {
1109  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1110  opt->default_val.i64 & value) {
1111  if (flags[0])
1112  av_strlcatf(flags, sizeof(flags), "+");
1113  av_strlcatf(flags, sizeof(flags), "%s", opt->name);
1114  }
1115  }
1116  if (flags[0])
1117  return av_strdup(flags);
1118  return NULL;
1119 }
1120 
1121 static void opt_list(void *obj, void *av_log_obj, const char *unit,
1122  int req_flags, int rej_flags, enum AVOptionType parent_type)
1123 {
1124  const AVOption *opt = NULL;
1125  AVOptionRanges *r;
1126  int i;
1127 
1128  while ((opt = av_opt_next(obj, opt))) {
1129  if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
1130  continue;
1131 
1132  /* Don't print CONST's on level one.
1133  * Don't print anything but CONST's on level two.
1134  * Only print items from the requested unit.
1135  */
1136  if (!unit && opt->type == AV_OPT_TYPE_CONST)
1137  continue;
1138  else if (unit && opt->type != AV_OPT_TYPE_CONST)
1139  continue;
1140  else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
1141  continue;
1142  else if (unit && opt->type == AV_OPT_TYPE_CONST)
1143  av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
1144  else
1145  av_log(av_log_obj, AV_LOG_INFO, " %s%-17s ",
1146  (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
1147  opt->name);
1148 
1149  switch (opt->type) {
1150  case AV_OPT_TYPE_FLAGS:
1151  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
1152  break;
1153  case AV_OPT_TYPE_INT:
1154  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
1155  break;
1156  case AV_OPT_TYPE_INT64:
1157  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
1158  break;
1159  case AV_OPT_TYPE_UINT64:
1160  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<uint64>");
1161  break;
1162  case AV_OPT_TYPE_DOUBLE:
1163  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
1164  break;
1165  case AV_OPT_TYPE_FLOAT:
1166  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
1167  break;
1168  case AV_OPT_TYPE_STRING:
1169  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
1170  break;
1171  case AV_OPT_TYPE_RATIONAL:
1172  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
1173  break;
1174  case AV_OPT_TYPE_BINARY:
1175  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
1176  break;
1178  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
1179  break;
1181  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
1182  break;
1183  case AV_OPT_TYPE_PIXEL_FMT:
1184  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
1185  break;
1187  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
1188  break;
1189  case AV_OPT_TYPE_DURATION:
1190  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
1191  break;
1192  case AV_OPT_TYPE_COLOR:
1193  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
1194  break;
1196  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
1197  break;
1198  case AV_OPT_TYPE_BOOL:
1199  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
1200  break;
1201  case AV_OPT_TYPE_CONST:
1202  if (parent_type == AV_OPT_TYPE_INT)
1203  av_log(av_log_obj, AV_LOG_INFO, "%-12"PRId64" ", opt->default_val.i64);
1204  else
1205  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1206  break;
1207  default:
1208  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1209  break;
1210  }
1211  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
1212  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
1213  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
1214  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
1215  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
1216  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
1217  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
1218  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
1219  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_BSF_PARAM) ? 'B' : '.');
1220  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM) ? 'T' : '.');
1221 
1222  if (opt->help)
1223  av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
1224 
1225  if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
1226  switch (opt->type) {
1227  case AV_OPT_TYPE_INT:
1228  case AV_OPT_TYPE_INT64:
1229  case AV_OPT_TYPE_UINT64:
1230  case AV_OPT_TYPE_DOUBLE:
1231  case AV_OPT_TYPE_FLOAT:
1232  case AV_OPT_TYPE_RATIONAL:
1233  for (i = 0; i < r->nb_ranges; i++) {
1234  av_log(av_log_obj, AV_LOG_INFO, " (from ");
1235  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
1236  av_log(av_log_obj, AV_LOG_INFO, " to ");
1237  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
1238  av_log(av_log_obj, AV_LOG_INFO, ")");
1239  }
1240  break;
1241  }
1242  av_opt_freep_ranges(&r);
1243  }
1244 
1245  if (opt->type != AV_OPT_TYPE_CONST &&
1246  opt->type != AV_OPT_TYPE_BINARY &&
1247  !((opt->type == AV_OPT_TYPE_COLOR ||
1248  opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
1249  opt->type == AV_OPT_TYPE_STRING ||
1250  opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
1251  !opt->default_val.str)) {
1252  av_log(av_log_obj, AV_LOG_INFO, " (default ");
1253  switch (opt->type) {
1254  case AV_OPT_TYPE_BOOL:
1255  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
1256  break;
1257  case AV_OPT_TYPE_FLAGS: {
1258  char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
1259  if (def_flags) {
1260  av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
1261  av_freep(&def_flags);
1262  } else {
1263  av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
1264  }
1265  break;
1266  }
1267  case AV_OPT_TYPE_DURATION: {
1268  char buf[25];
1269  format_duration(buf, sizeof(buf), opt->default_val.i64);
1270  av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
1271  break;
1272  }
1273  case AV_OPT_TYPE_INT:
1274  case AV_OPT_TYPE_UINT64:
1275  case AV_OPT_TYPE_INT64: {
1276  const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
1277  if (def_const)
1278  av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
1279  else
1280  log_int_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
1281  break;
1282  }
1283  case AV_OPT_TYPE_DOUBLE:
1284  case AV_OPT_TYPE_FLOAT:
1285  log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
1286  break;
1287  case AV_OPT_TYPE_RATIONAL: {
1288  AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
1289  av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
1290  break;
1291  case AV_OPT_TYPE_PIXEL_FMT:
1292  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
1293  break;
1295  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
1296  break;
1297  case AV_OPT_TYPE_COLOR:
1299  case AV_OPT_TYPE_STRING:
1301  av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
1302  break;
1304  av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
1305  break;
1306  }
1307  av_log(av_log_obj, AV_LOG_INFO, ")");
1308  }
1309 
1310  av_log(av_log_obj, AV_LOG_INFO, "\n");
1311  if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
1312  opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags, opt->type);
1313  }
1314 }
1315 
1316 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
1317 {
1318  if (!obj)
1319  return -1;
1320 
1321  av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
1322 
1323  opt_list(obj, av_log_obj, NULL, req_flags, rej_flags, -1);
1324 
1325  return 0;
1326 }
1327 
1329 {
1330  av_opt_set_defaults2(s, 0, 0);
1331 }
1332 
1333 void av_opt_set_defaults2(void *s, int mask, int flags)
1334 {
1335  const AVOption *opt = NULL;
1336  while ((opt = av_opt_next(s, opt))) {
1337  void *dst = ((uint8_t*)s) + opt->offset;
1338 
1339  if ((opt->flags & mask) != flags)
1340  continue;
1341 
1342  if (opt->flags & AV_OPT_FLAG_READONLY)
1343  continue;
1344 
1345  switch (opt->type) {
1346  case AV_OPT_TYPE_CONST:
1347  /* Nothing to be done here */
1348  break;
1349  case AV_OPT_TYPE_BOOL:
1350  case AV_OPT_TYPE_FLAGS:
1351  case AV_OPT_TYPE_INT:
1352  case AV_OPT_TYPE_INT64:
1353  case AV_OPT_TYPE_UINT64:
1354  case AV_OPT_TYPE_DURATION:
1356  case AV_OPT_TYPE_PIXEL_FMT:
1358  write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1359  break;
1360  case AV_OPT_TYPE_DOUBLE:
1361  case AV_OPT_TYPE_FLOAT: {
1362  double val;
1363  val = opt->default_val.dbl;
1364  write_number(s, opt, dst, val, 1, 1);
1365  }
1366  break;
1367  case AV_OPT_TYPE_RATIONAL: {
1368  AVRational val;
1369  val = av_d2q(opt->default_val.dbl, INT_MAX);
1370  write_number(s, opt, dst, 1, val.den, val.num);
1371  }
1372  break;
1373  case AV_OPT_TYPE_COLOR:
1374  set_string_color(s, opt, opt->default_val.str, dst);
1375  break;
1376  case AV_OPT_TYPE_STRING:
1377  set_string(s, opt, opt->default_val.str, dst);
1378  break;
1380  set_string_image_size(s, opt, opt->default_val.str, dst);
1381  break;
1383  set_string_video_rate(s, opt, opt->default_val.str, dst);
1384  break;
1385  case AV_OPT_TYPE_BINARY:
1386  set_string_binary(s, opt, opt->default_val.str, dst);
1387  break;
1388  case AV_OPT_TYPE_DICT:
1389  /* Cannot set defaults for these types */
1390  break;
1391  default:
1392  av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
1393  opt->type, opt->name);
1394  }
1395  }
1396 }
1397 
1398 /**
1399  * Store the value in the field in ctx that is named like key.
1400  * ctx must be an AVClass context, storing is done using AVOptions.
1401  *
1402  * @param buf the string to parse, buf will be updated to point at the
1403  * separator just after the parsed key/value pair
1404  * @param key_val_sep a 0-terminated list of characters used to
1405  * separate key from value
1406  * @param pairs_sep a 0-terminated list of characters used to separate
1407  * two pairs from each other
1408  * @return 0 if the key/value pair has been successfully parsed and
1409  * set, or a negative value corresponding to an AVERROR code in case
1410  * of error:
1411  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
1412  * the error code issued by av_opt_set() if the key/value pair
1413  * cannot be set
1414  */
1415 static int parse_key_value_pair(void *ctx, const char **buf,
1416  const char *key_val_sep, const char *pairs_sep)
1417 {
1418  char *key = av_get_token(buf, key_val_sep);
1419  char *val;
1420  int ret;
1421 
1422  if (!key)
1423  return AVERROR(ENOMEM);
1424 
1425  if (*key && strspn(*buf, key_val_sep)) {
1426  (*buf)++;
1427  val = av_get_token(buf, pairs_sep);
1428  if (!val) {
1429  av_freep(&key);
1430  return AVERROR(ENOMEM);
1431  }
1432  } else {
1433  av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
1434  av_free(key);
1435  return AVERROR(EINVAL);
1436  }
1437 
1438  av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1439 
1440  ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1441  if (ret == AVERROR_OPTION_NOT_FOUND)
1442  av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
1443 
1444  av_free(key);
1445  av_free(val);
1446  return ret;
1447 }
1448 
1449 int av_set_options_string(void *ctx, const char *opts,
1450  const char *key_val_sep, const char *pairs_sep)
1451 {
1452  int ret, count = 0;
1453 
1454  if (!opts)
1455  return 0;
1456 
1457  while (*opts) {
1458  if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1459  return ret;
1460  count++;
1461 
1462  if (*opts)
1463  opts++;
1464  }
1465 
1466  return count;
1467 }
1468 
1469 #define WHITESPACES " \n\t\r"
1470 
1471 static int is_key_char(char c)
1472 {
1473  return (unsigned)((c | 32) - 'a') < 26 ||
1474  (unsigned)(c - '0') < 10 ||
1475  c == '-' || c == '_' || c == '/' || c == '.';
1476 }
1477 
1478 /**
1479  * Read a key from a string.
1480  *
1481  * The key consists of is_key_char characters and must be terminated by a
1482  * character from the delim string; spaces are ignored.
1483  *
1484  * @return 0 for success (even with ellipsis), <0 for failure
1485  */
1486 static int get_key(const char **ropts, const char *delim, char **rkey)
1487 {
1488  const char *opts = *ropts;
1489  const char *key_start, *key_end;
1490 
1491  key_start = opts += strspn(opts, WHITESPACES);
1492  while (is_key_char(*opts))
1493  opts++;
1494  key_end = opts;
1495  opts += strspn(opts, WHITESPACES);
1496  if (!*opts || !strchr(delim, *opts))
1497  return AVERROR(EINVAL);
1498  opts++;
1499  if (!(*rkey = av_malloc(key_end - key_start + 1)))
1500  return AVERROR(ENOMEM);
1501  memcpy(*rkey, key_start, key_end - key_start);
1502  (*rkey)[key_end - key_start] = 0;
1503  *ropts = opts;
1504  return 0;
1505 }
1506 
1507 int av_opt_get_key_value(const char **ropts,
1508  const char *key_val_sep, const char *pairs_sep,
1509  unsigned flags,
1510  char **rkey, char **rval)
1511 {
1512  int ret;
1513  char *key = NULL, *val;
1514  const char *opts = *ropts;
1515 
1516  if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1517  !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1518  return AVERROR(EINVAL);
1519  if (!(val = av_get_token(&opts, pairs_sep))) {
1520  av_free(key);
1521  return AVERROR(ENOMEM);
1522  }
1523  *ropts = opts;
1524  *rkey = key;
1525  *rval = val;
1526  return 0;
1527 }
1528 
1529 int av_opt_set_from_string(void *ctx, const char *opts,
1530  const char *const *shorthand,
1531  const char *key_val_sep, const char *pairs_sep)
1532 {
1533  int ret, count = 0;
1534  const char *dummy_shorthand = NULL;
1535  char *av_uninit(parsed_key), *av_uninit(value);
1536  const char *key;
1537 
1538  if (!opts)
1539  return 0;
1540  if (!shorthand)
1541  shorthand = &dummy_shorthand;
1542 
1543  while (*opts) {
1544  ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1545  *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1546  &parsed_key, &value);
1547  if (ret < 0) {
1548  if (ret == AVERROR(EINVAL))
1549  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1550  else
1551  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
1552  av_err2str(ret));
1553  return ret;
1554  }
1555  if (*opts)
1556  opts++;
1557  if (parsed_key) {
1558  key = parsed_key;
1559  while (*shorthand) /* discard all remaining shorthand */
1560  shorthand++;
1561  } else {
1562  key = *(shorthand++);
1563  }
1564 
1565  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
1566  if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1567  if (ret == AVERROR_OPTION_NOT_FOUND)
1568  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1569  av_free(value);
1570  av_free(parsed_key);
1571  return ret;
1572  }
1573 
1574  av_free(value);
1575  av_free(parsed_key);
1576  count++;
1577  }
1578  return count;
1579 }
1580 
1581 void av_opt_free(void *obj)
1582 {
1583  const AVOption *o = NULL;
1584  while ((o = av_opt_next(obj, o))) {
1585  switch (o->type) {
1586  case AV_OPT_TYPE_STRING:
1587  case AV_OPT_TYPE_BINARY:
1588  av_freep((uint8_t *)obj + o->offset);
1589  break;
1590 
1591  case AV_OPT_TYPE_DICT:
1592  av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
1593  break;
1594 
1595  default:
1596  break;
1597  }
1598  }
1599 }
1600 
1601 int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
1602 {
1603  AVDictionaryEntry *t = NULL;
1604  AVDictionary *tmp = NULL;
1605  int ret = 0;
1606 
1607  if (!options)
1608  return 0;
1609 
1610  while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1611  ret = av_opt_set(obj, t->key, t->value, search_flags);
1612  if (ret == AVERROR_OPTION_NOT_FOUND)
1613  ret = av_dict_set(&tmp, t->key, t->value, 0);
1614  if (ret < 0) {
1615  av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
1616  av_dict_free(&tmp);
1617  return ret;
1618  }
1619  ret = 0;
1620  }
1621  av_dict_free(options);
1622  *options = tmp;
1623  return ret;
1624 }
1625 
1627 {
1628  return av_opt_set_dict2(obj, options, 0);
1629 }
1630 
1631 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
1632  int opt_flags, int search_flags)
1633 {
1634  return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
1635 }
1636 
1637 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
1638  int opt_flags, int search_flags, void **target_obj)
1639 {
1640  const AVClass *c;
1641  const AVOption *o = NULL;
1642 
1643  if(!obj)
1644  return NULL;
1645 
1646  c= *(AVClass**)obj;
1647 
1648  if (!c)
1649  return NULL;
1650 
1651  if (search_flags & AV_OPT_SEARCH_CHILDREN) {
1652  if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
1653  const AVClass *child = NULL;
1654  while (child = av_opt_child_class_next(c, child))
1655  if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
1656  return o;
1657  } else {
1658  void *child = NULL;
1659  while (child = av_opt_child_next(obj, child))
1660  if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
1661  return o;
1662  }
1663  }
1664 
1665  while (o = av_opt_next(obj, o)) {
1666  if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
1667  ((!unit && o->type != AV_OPT_TYPE_CONST) ||
1668  (unit && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
1669  if (target_obj) {
1670  if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
1671  *target_obj = obj;
1672  else
1673  *target_obj = NULL;
1674  }
1675  return o;
1676  }
1677  }
1678  return NULL;
1679 }
1680 
1681 void *av_opt_child_next(void *obj, void *prev)
1682 {
1683  const AVClass *c = *(AVClass **)obj;
1684  if (c->child_next)
1685  return c->child_next(obj, prev);
1686  return NULL;
1687 }
1688 
1689 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
1690 {
1691  if (parent->child_class_next)
1692  return parent->child_class_next(prev);
1693  return NULL;
1694 }
1695 
1696 void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
1697 {
1698  const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1699  if(!opt)
1700  return NULL;
1701  return (uint8_t*)obj + opt->offset;
1702 }
1703 
1704 static int opt_size(enum AVOptionType type)
1705 {
1706  switch(type) {
1707  case AV_OPT_TYPE_BOOL:
1708  case AV_OPT_TYPE_INT:
1709  case AV_OPT_TYPE_FLAGS:
1710  return sizeof(int);
1711  case AV_OPT_TYPE_DURATION:
1713  case AV_OPT_TYPE_INT64:
1714  case AV_OPT_TYPE_UINT64:
1715  return sizeof(int64_t);
1716  case AV_OPT_TYPE_DOUBLE:
1717  return sizeof(double);
1718  case AV_OPT_TYPE_FLOAT:
1719  return sizeof(float);
1720  case AV_OPT_TYPE_STRING:
1721  return sizeof(uint8_t*);
1723  case AV_OPT_TYPE_RATIONAL:
1724  return sizeof(AVRational);
1725  case AV_OPT_TYPE_BINARY:
1726  return sizeof(uint8_t*) + sizeof(int);
1728  return sizeof(int[2]);
1729  case AV_OPT_TYPE_PIXEL_FMT:
1730  return sizeof(enum AVPixelFormat);
1732  return sizeof(enum AVSampleFormat);
1733  case AV_OPT_TYPE_COLOR:
1734  return 4;
1735  }
1736  return AVERROR(EINVAL);
1737 }
1738 
1739 int av_opt_copy(void *dst, const void *src)
1740 {
1741  const AVOption *o = NULL;
1742  const AVClass *c;
1743  int ret = 0;
1744 
1745  if (!src)
1746  return AVERROR(EINVAL);
1747 
1748  c = *(AVClass **)src;
1749  if (!c || c != *(AVClass **)dst)
1750  return AVERROR(EINVAL);
1751 
1752  while ((o = av_opt_next(src, o))) {
1753  void *field_dst = (uint8_t *)dst + o->offset;
1754  void *field_src = (uint8_t *)src + o->offset;
1755  uint8_t **field_dst8 = (uint8_t **)field_dst;
1756  uint8_t **field_src8 = (uint8_t **)field_src;
1757 
1758  if (o->type == AV_OPT_TYPE_STRING) {
1759  if (*field_dst8 != *field_src8)
1760  av_freep(field_dst8);
1761  *field_dst8 = av_strdup(*field_src8);
1762  if (*field_src8 && !*field_dst8)
1763  ret = AVERROR(ENOMEM);
1764  } else if (o->type == AV_OPT_TYPE_BINARY) {
1765  int len = *(int *)(field_src8 + 1);
1766  if (*field_dst8 != *field_src8)
1767  av_freep(field_dst8);
1768  *field_dst8 = av_memdup(*field_src8, len);
1769  if (len && !*field_dst8) {
1770  ret = AVERROR(ENOMEM);
1771  len = 0;
1772  }
1773  *(int *)(field_dst8 + 1) = len;
1774  } else if (o->type == AV_OPT_TYPE_CONST) {
1775  // do nothing
1776  } else if (o->type == AV_OPT_TYPE_DICT) {
1777  AVDictionary **sdict = (AVDictionary **) field_src;
1778  AVDictionary **ddict = (AVDictionary **) field_dst;
1779  if (*sdict != *ddict)
1780  av_dict_free(ddict);
1781  *ddict = NULL;
1782  av_dict_copy(ddict, *sdict, 0);
1783  if (av_dict_count(*sdict) != av_dict_count(*ddict))
1784  ret = AVERROR(ENOMEM);
1785  } else {
1786  int size = opt_size(o->type);
1787  if (size < 0)
1788  ret = size;
1789  else
1790  memcpy(field_dst, field_src, size);
1791  }
1792  }
1793  return ret;
1794 }
1795 
1796 int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1797 {
1798  int ret;
1799  const AVClass *c = *(AVClass**)obj;
1800  int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
1801 
1802  if (c->version > (52 << 16 | 11 << 8))
1803  callback = c->query_ranges;
1804 
1805  if (!callback)
1807 
1808  ret = callback(ranges_arg, obj, key, flags);
1809  if (ret >= 0) {
1810  if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
1811  ret = 1;
1812  (*ranges_arg)->nb_components = ret;
1813  }
1814  return ret;
1815 }
1816 
1817 int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1818 {
1819  AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
1820  AVOptionRange **range_array = av_mallocz(sizeof(void*));
1821  AVOptionRange *range = av_mallocz(sizeof(*range));
1822  const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1823  int ret;
1824 
1825  *ranges_arg = NULL;
1826 
1827  if (!ranges || !range || !range_array || !field) {
1828  ret = AVERROR(ENOMEM);
1829  goto fail;
1830  }
1831 
1832  ranges->range = range_array;
1833  ranges->range[0] = range;
1834  ranges->nb_ranges = 1;
1835  ranges->nb_components = 1;
1836  range->is_range = 1;
1837  range->value_min = field->min;
1838  range->value_max = field->max;
1839 
1840  switch (field->type) {
1841  case AV_OPT_TYPE_BOOL:
1842  case AV_OPT_TYPE_INT:
1843  case AV_OPT_TYPE_INT64:
1844  case AV_OPT_TYPE_UINT64:
1845  case AV_OPT_TYPE_PIXEL_FMT:
1847  case AV_OPT_TYPE_FLOAT:
1848  case AV_OPT_TYPE_DOUBLE:
1849  case AV_OPT_TYPE_DURATION:
1850  case AV_OPT_TYPE_COLOR:
1852  break;
1853  case AV_OPT_TYPE_STRING:
1854  range->component_min = 0;
1855  range->component_max = 0x10FFFF; // max unicode value
1856  range->value_min = -1;
1857  range->value_max = INT_MAX;
1858  break;
1859  case AV_OPT_TYPE_RATIONAL:
1860  range->component_min = INT_MIN;
1861  range->component_max = INT_MAX;
1862  break;
1864  range->component_min = 0;
1865  range->component_max = INT_MAX/128/8;
1866  range->value_min = 0;
1867  range->value_max = INT_MAX/8;
1868  break;
1870  range->component_min = 1;
1871  range->component_max = INT_MAX;
1872  range->value_min = 1;
1873  range->value_max = INT_MAX;
1874  break;
1875  default:
1876  ret = AVERROR(ENOSYS);
1877  goto fail;
1878  }
1879 
1880  *ranges_arg = ranges;
1881  return 1;
1882 fail:
1883  av_free(ranges);
1884  av_free(range);
1885  av_free(range_array);
1886  return ret;
1887 }
1888 
1890 {
1891  int i;
1892  AVOptionRanges *ranges = *rangesp;
1893 
1894  if (!ranges)
1895  return;
1896 
1897  for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
1898  AVOptionRange *range = ranges->range[i];
1899  if (range) {
1900  av_freep(&range->str);
1901  av_freep(&ranges->range[i]);
1902  }
1903  }
1904  av_freep(&ranges->range);
1905  av_freep(rangesp);
1906 }
1907 
1908 int av_opt_is_set_to_default(void *obj, const AVOption *o)
1909 {
1910  int64_t i64;
1911  double d, d2;
1912  float f;
1913  AVRational q;
1914  int ret, w, h;
1915  char *str;
1916  void *dst;
1917 
1918  if (!o || !obj)
1919  return AVERROR(EINVAL);
1920 
1921  dst = ((uint8_t*)obj) + o->offset;
1922 
1923  switch (o->type) {
1924  case AV_OPT_TYPE_CONST:
1925  return 1;
1926  case AV_OPT_TYPE_BOOL:
1927  case AV_OPT_TYPE_FLAGS:
1928  case AV_OPT_TYPE_PIXEL_FMT:
1930  case AV_OPT_TYPE_INT:
1932  case AV_OPT_TYPE_DURATION:
1933  case AV_OPT_TYPE_INT64:
1934  case AV_OPT_TYPE_UINT64:
1935  read_number(o, dst, NULL, NULL, &i64);
1936  return o->default_val.i64 == i64;
1937  case AV_OPT_TYPE_STRING:
1938  str = *(char **)dst;
1939  if (str == o->default_val.str) //2 NULLs
1940  return 1;
1941  if (!str || !o->default_val.str) //1 NULL
1942  return 0;
1943  return !strcmp(str, o->default_val.str);
1944  case AV_OPT_TYPE_DOUBLE:
1945  read_number(o, dst, &d, NULL, NULL);
1946  return o->default_val.dbl == d;
1947  case AV_OPT_TYPE_FLOAT:
1948  read_number(o, dst, &d, NULL, NULL);
1949  f = o->default_val.dbl;
1950  d2 = f;
1951  return d2 == d;
1952  case AV_OPT_TYPE_RATIONAL:
1953  q = av_d2q(o->default_val.dbl, INT_MAX);
1954  return !av_cmp_q(*(AVRational*)dst, q);
1955  case AV_OPT_TYPE_BINARY: {
1956  struct {
1957  uint8_t *data;
1958  int size;
1959  } tmp = {0};
1960  int opt_size = *(int *)((void **)dst + 1);
1961  void *opt_ptr = *(void **)dst;
1962  if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
1963  return 1;
1964  if (!opt_size || !o->default_val.str || !strlen(o->default_val.str ))
1965  return 0;
1966  if (opt_size != strlen(o->default_val.str) / 2)
1967  return 0;
1968  ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
1969  if (!ret)
1970  ret = !memcmp(opt_ptr, tmp.data, tmp.size);
1971  av_free(tmp.data);
1972  return ret;
1973  }
1974  case AV_OPT_TYPE_DICT:
1975  /* Binary and dict have not default support yet. Any pointer is not default. */
1976  return !!(*(void **)dst);
1978  if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
1979  w = h = 0;
1980  else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
1981  return ret;
1982  return (w == *(int *)dst) && (h == *((int *)dst+1));
1984  q = (AVRational){0, 0};
1985  if (o->default_val.str) {
1986  if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
1987  return ret;
1988  }
1989  return !av_cmp_q(*(AVRational*)dst, q);
1990  case AV_OPT_TYPE_COLOR: {
1991  uint8_t color[4] = {0, 0, 0, 0};
1992  if (o->default_val.str) {
1993  if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
1994  return ret;
1995  }
1996  return !memcmp(color, dst, sizeof(color));
1997  }
1998  default:
1999  av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
2000  break;
2001  }
2002  return AVERROR_PATCHWELCOME;
2003 }
2004 
2005 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
2006 {
2007  const AVOption *o;
2008  void *target;
2009  if (!obj)
2010  return AVERROR(EINVAL);
2011  o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
2012  if (!o)
2013  return AVERROR_OPTION_NOT_FOUND;
2014  return av_opt_is_set_to_default(target, o);
2015 }
2016 
2017 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
2018  const char key_val_sep, const char pairs_sep)
2019 {
2020  const AVOption *o = NULL;
2021  uint8_t *buf;
2022  AVBPrint bprint;
2023  int ret, cnt = 0;
2024  const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
2025 
2026  if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
2027  pairs_sep == '\\' || key_val_sep == '\\') {
2028  av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
2029  return AVERROR(EINVAL);
2030  }
2031 
2032  if (!obj || !buffer)
2033  return AVERROR(EINVAL);
2034 
2035  *buffer = NULL;
2037 
2038  while (o = av_opt_next(obj, o)) {
2039  if (o->type == AV_OPT_TYPE_CONST)
2040  continue;
2041  if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
2042  continue;
2043  else if (((o->flags & opt_flags) != opt_flags))
2044  continue;
2045  if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
2046  continue;
2047  if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
2048  av_bprint_finalize(&bprint, NULL);
2049  return ret;
2050  }
2051  if (buf) {
2052  if (cnt++)
2053  av_bprint_append_data(&bprint, &pairs_sep, 1);
2054  av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2055  av_bprint_append_data(&bprint, &key_val_sep, 1);
2056  av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2057  av_freep(&buf);
2058  }
2059  }
2060  av_bprint_finalize(&bprint, buffer);
2061  return 0;
2062 }
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1007
#define NULL
Definition: coverity.c:32
static const char * get_bool_name(int val)
Definition: opt.c:359
const char const char void * val
Definition: avisynth_c.h:863
A single allowed range of values, or a single allowed value.
Definition: opt.h:307
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:74
static char * get_opt_flags_string(void *obj, const char *unit, int64_t value)
Definition: opt.c:1100
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:578
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:148
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:284
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:280
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information ...
Definition: opt.h:293
const char * fmt
Definition: avisynth_c.h:861
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
Definition: opt.c:316
void * av_opt_child_next(void *obj, void *prev)
Iterate over AVOptions-enabled children of obj.
Definition: opt.c:1681
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
const char * desc
Definition: nvenc.c:68
static int get_key(const char **ropts, const char *delim, char **rkey)
Read a key from a string.
Definition: opt.c:1486
double value_max
Definition: opt.h:314
const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:1689
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1328
static int opt_size(enum AVOptionType type)
Definition: opt.c:1704
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:278
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:1449
static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
Definition: opt.c:443
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
Convenience header that includes libavutil&#39;s core.
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
Definition: opt.c:583
Use backslash escaping.
Definition: avstring.h:320
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:912
int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer, const char key_val_sep, const char pairs_sep)
Serialize object&#39;s options.
Definition: opt.c:2017
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:707
#define src
Definition: vp8dsp.c:254
AVOptionType
Definition: opt.h:221
int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
Check if given option is set to its default value.
Definition: opt.c:2005
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
int av_opt_is_set_to_default(void *obj, const AVOption *o)
Check if given option is set to its default value.
Definition: opt.c:1908
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:946
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1529
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int get_format(void *obj, const char *name, int search_flags, int *out_fmt, enum AVOptionType type, const char *desc)
Definition: opt.c:962
Public dictionary API.
const char * name
Definition: opt.h:247
#define WHITESPACES
Definition: opt.c:1469
uint8_t
AVOptionRange ** range
Array of option ranges.
Definition: opt.h:361
#define av_malloc(s)
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:530
class_name
Definition: libkvazaar.c:289
const char * help
short English help text
Definition: opt.h:253
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
AVS_FilterInfo AVS_Value child
Definition: avisynth_c.h:807
static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
Definition: opt.c:58
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static void opt_list(void *obj, void *av_log_obj, const char *unit, int req_flags, int rej_flags, enum AVOptionType parent_type)
Definition: opt.c:1121
static const char * get_opt_const_name(void *obj, const char *unit, int64_t value)
Definition: opt.c:1087
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
const char * str
Definition: opt.h:268
int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
Definition: opt.c:573
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
double component_max
Definition: opt.h:319
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum, int search_flags)
Definition: opt.c:868
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:635
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:354
static const double const_values[]
Definition: eval.c:28
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
Definition: opt.c:437
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:113
static void log_int_value(void *av_log_obj, int level, int64_t i)
Definition: opt.c:1037
static int hexchar2int(char c)
Definition: opt.c:170
int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
Definition: opt.c:980
int av_expr_parse_and_eval(double *d, const char *s, const char *const *const_names, const double *const_values, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), void *opaque, int log_offset, void *log_ctx)
Parse and evaluate an expression.
Definition: eval.c:748
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
Definition: opt.c:681
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_BPRINT_SIZE_UNLIMITED
void * av_opt_ptr(const AVClass *class, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:1696
static const uint16_t mask[17]
Definition: lzw.c:38
#define AV_OPT_FLAG_FILTERING_PARAM
a generic parameter which can be set by the user for filtering
Definition: opt.h:292
int(* query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags)
Callback to return the supported/allowed ranges.
Definition: log.h:142
double max
maximum valid value for the option
Definition: opt.h:273
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:568
simple assert() macros that are a bit more flexible than ISO C assert().
const AVOption * av_opt_next(const void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:45
int av_match_name(const char *name, const char *names)
Match instances of a name in a comma-separated list of names.
Definition: avstring.c:348
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
GLsizei count
Definition: opengl_enc.c:108
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:283
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:149
union AVOption::@308 default_val
the default value for scalar options
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1631
static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:214
AVDictionary * opts
Definition: movenc.c:50
#define AV_OPT_FLAG_RUNTIME_PARAM
a generic parameter which can be set by the user at runtime
Definition: opt.h:291
int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
Definition: opt.c:985
static void callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time, enum dshowDeviceType devtype)
Definition: dshow.c:161
#define b
Definition: input.c:41
audio channel layout utility functions
const char * str
Definition: opt.h:308
#define NAN
Definition: mathematics.h:64
#define FFMIN(a, b)
Definition: common.h:96
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:557
uint8_t w
Definition: llviddspenc.c:38
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
const char * unit
The logical unit to which the option belongs.
Definition: opt.h:301
static int parse_key_value_pair(void *ctx, const char **buf, const char *key_val_sep, const char *pairs_sep)
Store the value in the field in ctx that is named like key.
Definition: opt.c:1415
double component_min
Value&#39;s component range.
Definition: opt.h:319
int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
Definition: opt.c:691
double min
minimum valid value for the option
Definition: opt.h:272
#define s(width, name)
Definition: cbs_vp9.c:257
static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
Definition: opt.c:229
void av_opt_set_defaults2(void *s, int mask, int flags)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1333
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:290
static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:180
int n
Definition: avisynth_c.h:760
const struct AVClass *(* child_class_next)(const struct AVClass *prev)
Return an AVClass corresponding to the next potential AVOptions-enabled child.
Definition: log.h:123
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1601
static void error(const char *err)
#define FF_ARRAY_ELEMS(a)
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:229
int flags
Definition: opt.h:275
if(ret)
int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
Get a default list of allowed ranges for the given option.
Definition: opt.c:1817
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int is_range
Range flag.
Definition: opt.h:324
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:888
static void log_value(void *av_log_obj, int level, double d)
Definition: opt.c:1054
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static int set_format(void *obj, const char *name, int fmt, int search_flags, enum AVOptionType type, const char *desc, int nb_fmts)
Definition: opt.c:652
void av_opt_freep_ranges(AVOptionRanges **rangesp)
Free an AVOptionRanges struct and set it to NULL.
Definition: opt.c:1889
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
int offset
The offset relative to the context structure where the option value is stored.
Definition: opt.h:259
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1626
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum, int search_flags)
Definition: opt.c:552
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1316
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:279
static void format_duration(char *buf, size_t size, int64_t d)
Definition: opt.c:726
static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
Definition: opt.c:366
#define OPT_EVAL_NUMBER(name, opttype, vartype)
Definition: opt.c:536
void * buf
Definition: avisynth_c.h:766
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
Definition: opt.c:990
#define llrint(x)
Definition: libm.h:394
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Describe the class of an AVClass context structure.
Definition: log.h:67
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
#define AV_OPT_ALLOW_NULL
In av_opt_get, return NULL if the option has a pointer type and is set to NULL, rather than returning...
Definition: opt.h:572
double dbl
Definition: opt.h:267
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:56
offset must point to AVRational
Definition: opt.h:236
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define snprintf
Definition: snprintf.h:34
offset must point to two consecutive integers
Definition: opt.h:233
misc parsing utilities
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t level
Definition: svq3.c:207
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
int version
LIBAVUTIL_VERSION with which this structure was created.
Definition: log.h:93
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
int
static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
Definition: opt.c:331
void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, enum AVEscapeMode mode, int flags)
Escape the content in src and append it to dstbuf.
Definition: bprint.c:265
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1581
const OptionDef options[]
Definition: ffmpeg_opt.c:3372
int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
Get a list of allowed ranges for the given option.
Definition: opt.c:1796
double value_min
Value range.
Definition: opt.h:314
common internal and external API header
#define DEFAULT_NUMVAL(opt)
Definition: opt.c:221
#define class
Definition: math.h:25
#define flag(name)
Definition: cbs_av1.c:553
int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
Definition: opt.c:900
static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst, int fmt_nb, int((*get_fmt)(const char *)), const char *desc)
Definition: opt.c:397
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1739
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poi...
Definition: opt.h:566
static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
Definition: opt.c:97
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
int nb_ranges
Number of ranges per component.
Definition: opt.h:365
List of AVOptionRange structs.
Definition: opt.h:330
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:761
#define av_free(p)
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS
Serialize options that are not set to default values only.
Definition: opt.h:840
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
char * value
Definition: dict.h:87
enum AVOptionType type
Definition: opt.h:260
int len
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
Definition: opt.c:1507
int64_t i64
Definition: opt.h:266
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:289
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
Check whether a particular flag is set in a flags field.
Definition: opt.c:1024
#define av_uninit(x)
Definition: attributes.h:148
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
Definition: pixfmt.h:351
#define av_freep(p)
static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
Definition: opt.c:344
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
#define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT
Serialize options that exactly match opt_flags only.
Definition: opt.h:841
const AVOption * av_opt_find2(void *obj, const char *name, const char *unit, int opt_flags, int search_flags, void **target_obj)
Look for an option in an object.
Definition: opt.c:1637
static const char *const const_names[]
Definition: eval.c:34
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2450
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2438
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define INFINITY
Definition: mathematics.h:67
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:686
#define AV_OPT_MULTI_COMPONENT_RANGE
Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than one component for cert...
Definition: opt.h:579
float min
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
Definition: opt.c:613
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
static int is_key_char(char c)
Definition: opt.c:1471
GLuint buffer
Definition: opengl_enc.c:101
simple arithmetic expression evaluator
const char * name
Definition: opengl_enc.c:102
int nb_components
Number of componentes.
Definition: opt.h:369
int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
Definition: opt.c:928
static uint8_t tmp[11]
Definition: aes_ctr.c:26