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 
234  int num, den;
235  char c;
236  if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
237  if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
238  return ret;
239  ret = 0;
240  }
241  }
242 
243  for (;;) {
244  int i = 0;
245  char buf[256];
246  int cmd = 0;
247  double d;
248  int64_t intnum = 1;
249 
250  if (o->type == AV_OPT_TYPE_FLAGS) {
251  if (*val == '+' || *val == '-')
252  cmd = *(val++);
253  for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
254  buf[i] = val[i];
255  buf[i] = 0;
256  }
257 
258  {
259  int res;
260  int ci = 0;
261  double const_values[64];
262  const char * const_names[64];
263  int search_flags = (o->flags & AV_OPT_FLAG_CHILD_CONSTS) ? AV_OPT_SEARCH_CHILDREN : 0;
264  const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, search_flags);
265  if (o_named && o_named->type == AV_OPT_TYPE_CONST)
266  d = DEFAULT_NUMVAL(o_named);
267  else {
268  if (o->unit) {
269  for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
270  if (o_named->type == AV_OPT_TYPE_CONST &&
271  o_named->unit &&
272  !strcmp(o_named->unit, o->unit)) {
273  if (ci + 6 >= FF_ARRAY_ELEMS(const_values)) {
274  av_log(obj, AV_LOG_ERROR, "const_values array too small for %s\n", o->unit);
275  return AVERROR_PATCHWELCOME;
276  }
277  const_names [ci ] = o_named->name;
278  const_values[ci++] = DEFAULT_NUMVAL(o_named);
279  }
280  }
281  }
282  const_names [ci ] = "default";
283  const_values[ci++] = DEFAULT_NUMVAL(o);
284  const_names [ci ] = "max";
285  const_values[ci++] = o->max;
286  const_names [ci ] = "min";
287  const_values[ci++] = o->min;
288  const_names [ci ] = "none";
289  const_values[ci++] = 0;
290  const_names [ci ] = "all";
291  const_values[ci++] = ~0;
292  const_names [ci] = NULL;
293  const_values[ci] = 0;
294 
295  res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
296  const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
297  if (res < 0) {
298  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
299  return res;
300  }
301  }
302  }
303  if (o->type == AV_OPT_TYPE_FLAGS) {
304  read_number(o, dst, NULL, NULL, &intnum);
305  if (cmd == '+')
306  d = intnum | (int64_t)d;
307  else if (cmd == '-')
308  d = intnum &~(int64_t)d;
309  }
310 
311  if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
312  return ret;
313  val += i;
314  if (!i || !*val)
315  return 0;
316  }
317 }
318 
319 static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
320 {
321  int ret;
322 
323  if (!val || !strcmp(val, "none")) {
324  dst[0] =
325  dst[1] = 0;
326  return 0;
327  }
328  ret = av_parse_video_size(dst, dst + 1, val);
329  if (ret < 0)
330  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
331  return ret;
332 }
333 
334 static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
335 {
336  int ret = av_parse_video_rate(dst, val);
337  if (ret < 0)
338  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
339  return ret;
340 }
341 
342 static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
343 {
344  int ret;
345 
346  if (!val) {
347  return 0;
348  } else {
349  ret = av_parse_color(dst, val, -1, obj);
350  if (ret < 0)
351  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
352  return ret;
353  }
354  return 0;
355 }
356 
357 static const char *get_bool_name(int val)
358 {
359  if (val < 0)
360  return "auto";
361  return val ? "true" : "false";
362 }
363 
364 static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
365 {
366  int n;
367 
368  if (!val)
369  return 0;
370 
371  if (!strcmp(val, "auto")) {
372  n = -1;
373  } else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
374  n = 1;
375  } else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
376  n = 0;
377  } else {
378  char *end = NULL;
379  n = strtol(val, &end, 10);
380  if (val + strlen(val) != end)
381  goto fail;
382  }
383 
384  if (n < o->min || n > o->max)
385  goto fail;
386 
387  *dst = n;
388  return 0;
389 
390 fail:
391  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as boolean\n", val);
392  return AVERROR(EINVAL);
393 }
394 
395 static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst,
396  int fmt_nb, int ((*get_fmt)(const char *)), const char *desc)
397 {
398  int fmt, min, max;
399 
400  if (!val || !strcmp(val, "none")) {
401  fmt = -1;
402  } else {
403  fmt = get_fmt(val);
404  if (fmt == -1) {
405  char *tail;
406  fmt = strtol(val, &tail, 0);
407  if (*tail || (unsigned)fmt >= fmt_nb) {
408  av_log(obj, AV_LOG_ERROR,
409  "Unable to parse option value \"%s\" as %s\n", val, desc);
410  return AVERROR(EINVAL);
411  }
412  }
413  }
414 
415  min = FFMAX(o->min, -1);
416  max = FFMIN(o->max, fmt_nb-1);
417 
418  // hack for compatibility with old ffmpeg
419  if(min == 0 && max == 0) {
420  min = -1;
421  max = fmt_nb-1;
422  }
423 
424  if (fmt < min || fmt > max) {
425  av_log(obj, AV_LOG_ERROR,
426  "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
427  fmt, o->name, desc, min, max);
428  return AVERROR(ERANGE);
429  }
430 
431  *(int *)dst = fmt;
432  return 0;
433 }
434 
435 static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
436 {
437  return set_string_fmt(obj, o, val, dst,
438  AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
439 }
440 
441 static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
442 {
443  return set_string_fmt(obj, o, val, dst,
444  AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
445 }
446 
447 static int set_string_dict(void *obj, const AVOption *o, const char *val, uint8_t **dst)
448 {
450 
451  if (val) {
452  int ret = av_dict_parse_string(&options, val, "=", ":", 0);
453  if (ret < 0) {
454  av_dict_free(&options);
455  return ret;
456  }
457  }
458 
459  av_dict_free((AVDictionary **)dst);
460  *dst = (uint8_t *)options;
461 
462  return 0;
463 }
464 
465 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
466 {
467  int ret = 0;
468  void *dst, *target_obj;
469  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
470  if (!o || !target_obj)
472  if (!val && (o->type != AV_OPT_TYPE_STRING &&
477  return AVERROR(EINVAL);
478 
479  if (o->flags & AV_OPT_FLAG_READONLY)
480  return AVERROR(EINVAL);
481 
482  if (o->flags & AV_OPT_FLAG_DEPRECATED)
483  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
484 
485  dst = ((uint8_t *)target_obj) + o->offset;
486  switch (o->type) {
487  case AV_OPT_TYPE_BOOL:
488  return set_string_bool(obj, o, val, dst);
489  case AV_OPT_TYPE_STRING:
490  return set_string(obj, o, val, dst);
491  case AV_OPT_TYPE_BINARY:
492  return set_string_binary(obj, o, val, dst);
493  case AV_OPT_TYPE_FLAGS:
494  case AV_OPT_TYPE_INT:
495  case AV_OPT_TYPE_INT64:
496  case AV_OPT_TYPE_UINT64:
497  case AV_OPT_TYPE_FLOAT:
498  case AV_OPT_TYPE_DOUBLE:
500  return set_string_number(obj, target_obj, o, val, dst);
502  return set_string_image_size(obj, o, val, dst);
503  case AV_OPT_TYPE_VIDEO_RATE: {
504  AVRational tmp;
505  ret = set_string_video_rate(obj, o, val, &tmp);
506  if (ret < 0)
507  return ret;
508  return write_number(obj, o, dst, 1, tmp.den, tmp.num);
509  }
511  return set_string_pixel_fmt(obj, o, val, dst);
513  return set_string_sample_fmt(obj, o, val, dst);
515  {
516  int64_t usecs = 0;
517  if (val) {
518  if ((ret = av_parse_time(&usecs, val, 1)) < 0) {
519  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
520  return ret;
521  }
522  }
523  if (usecs < o->min || usecs > o->max) {
524  av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
525  usecs / 1000000.0, o->name, o->min / 1000000.0, o->max / 1000000.0);
526  return AVERROR(ERANGE);
527  }
528  *(int64_t *)dst = usecs;
529  return 0;
530  }
531  case AV_OPT_TYPE_COLOR:
532  return set_string_color(obj, o, val, dst);
534  if (!val || !strcmp(val, "none")) {
535  *(int64_t *)dst = 0;
536  } else {
537  int64_t cl = av_get_channel_layout(val);
538  if (!cl) {
539  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
540  ret = AVERROR(EINVAL);
541  }
542  *(int64_t *)dst = cl;
543  return ret;
544  }
545  break;
546  case AV_OPT_TYPE_DICT:
547  return set_string_dict(obj, o, val, dst);
548  }
549 
550  av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
551  return AVERROR(EINVAL);
552 }
553 
554 #define OPT_EVAL_NUMBER(name, opttype, vartype) \
555 int av_opt_eval_ ## name(void *obj, const AVOption *o, \
556  const char *val, vartype *name ## _out) \
557 { \
558  if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY) \
559  return AVERROR(EINVAL); \
560  return set_string_number(obj, obj, o, val, name ## _out); \
561 }
562 
565 OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
566 OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
567 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
569 
570 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
571  int search_flags)
572 {
573  void *dst, *target_obj;
574  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
575 
576  if (!o || !target_obj)
578 
579  if (o->flags & AV_OPT_FLAG_READONLY)
580  return AVERROR(EINVAL);
581 
582  dst = ((uint8_t *)target_obj) + o->offset;
583  return write_number(obj, o, dst, num, den, intnum);
584 }
585 
586 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
587 {
588  return set_number(obj, name, 1, 1, val, search_flags);
589 }
590 
591 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
592 {
593  return set_number(obj, name, val, 1, 1, search_flags);
594 }
595 
596 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
597 {
598  return set_number(obj, name, val.num, val.den, 1, search_flags);
599 }
600 
601 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
602 {
603  void *target_obj;
604  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
605  uint8_t *ptr;
606  uint8_t **dst;
607  int *lendst;
608 
609  if (!o || !target_obj)
611 
613  return AVERROR(EINVAL);
614 
615  ptr = len ? av_malloc(len) : NULL;
616  if (len && !ptr)
617  return AVERROR(ENOMEM);
618 
619  dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
620  lendst = (int *)(dst + 1);
621 
622  av_free(*dst);
623  *dst = ptr;
624  *lendst = len;
625  if (len)
626  memcpy(ptr, val, len);
627 
628  return 0;
629 }
630 
631 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
632 {
633  void *target_obj;
634  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
635 
636  if (!o || !target_obj)
638  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
639  av_log(obj, AV_LOG_ERROR,
640  "The value set by option '%s' is not an image size.\n", o->name);
641  return AVERROR(EINVAL);
642  }
643  if (w<0 || h<0) {
644  av_log(obj, AV_LOG_ERROR,
645  "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
646  return AVERROR(EINVAL);
647  }
648  *(int *)(((uint8_t *)target_obj) + o->offset) = w;
649  *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
650  return 0;
651 }
652 
653 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
654 {
655  void *target_obj;
656  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
657 
658  if (!o || !target_obj)
660  if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
661  av_log(obj, AV_LOG_ERROR,
662  "The value set by option '%s' is not a video rate.\n", o->name);
663  return AVERROR(EINVAL);
664  }
665  if (val.num <= 0 || val.den <= 0)
666  return AVERROR(EINVAL);
667  return set_number(obj, name, val.num, val.den, 1, search_flags);
668 }
669 
670 static int set_format(void *obj, const char *name, int fmt, int search_flags,
671  enum AVOptionType type, const char *desc, int nb_fmts)
672 {
673  void *target_obj;
674  const AVOption *o = av_opt_find2(obj, name, NULL, 0,
675  search_flags, &target_obj);
676  int min, max;
677 
678  if (!o || !target_obj)
680  if (o->type != type) {
681  av_log(obj, AV_LOG_ERROR,
682  "The value set by option '%s' is not a %s format", name, desc);
683  return AVERROR(EINVAL);
684  }
685 
686  min = FFMAX(o->min, -1);
687  max = FFMIN(o->max, nb_fmts-1);
688 
689  if (fmt < min || fmt > max) {
690  av_log(obj, AV_LOG_ERROR,
691  "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
692  fmt, name, desc, min, max);
693  return AVERROR(ERANGE);
694  }
695  *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
696  return 0;
697 }
698 
699 int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
700 {
701  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
702 }
703 
704 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
705 {
706  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
707 }
708 
709 int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
710 {
711  void *target_obj;
712  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
713 
714  if (!o || !target_obj)
716  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
717  av_log(obj, AV_LOG_ERROR,
718  "The value set by option '%s' is not a channel layout.\n", o->name);
719  return AVERROR(EINVAL);
720  }
721  *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
722  return 0;
723 }
724 
725 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
726  int search_flags)
727 {
728  void *target_obj;
729  AVDictionary **dst;
730  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
731 
732  if (!o || !target_obj)
734  if (o->flags & AV_OPT_FLAG_READONLY)
735  return AVERROR(EINVAL);
736 
737  dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
738  av_dict_free(dst);
739  av_dict_copy(dst, val, 0);
740 
741  return 0;
742 }
743 
744 static void format_duration(char *buf, size_t size, int64_t d)
745 {
746  char *e;
747 
748  av_assert0(size >= 25);
749  if (d < 0 && d != INT64_MIN) {
750  *(buf++) = '-';
751  size--;
752  d = -d;
753  }
754  if (d == INT64_MAX)
755  snprintf(buf, size, "INT64_MAX");
756  else if (d == INT64_MIN)
757  snprintf(buf, size, "INT64_MIN");
758  else if (d > (int64_t)3600*1000000)
759  snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
760  (int)((d / 60000000) % 60),
761  (int)((d / 1000000) % 60),
762  (int)(d % 1000000));
763  else if (d > 60*1000000)
764  snprintf(buf, size, "%d:%02d.%06d",
765  (int)(d / 60000000),
766  (int)((d / 1000000) % 60),
767  (int)(d % 1000000));
768  else
769  snprintf(buf, size, "%d.%06d",
770  (int)(d / 1000000),
771  (int)(d % 1000000));
772  e = buf + strlen(buf);
773  while (e > buf && e[-1] == '0')
774  *(--e) = 0;
775  if (e > buf && e[-1] == '.')
776  *(--e) = 0;
777 }
778 
779 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
780 {
781  void *dst, *target_obj;
782  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
783  uint8_t *bin, buf[128];
784  int len, i, ret;
785  int64_t i64;
786 
787  if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
789 
790  if (o->flags & AV_OPT_FLAG_DEPRECATED)
791  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
792 
793  dst = (uint8_t *)target_obj + o->offset;
794 
795  buf[0] = 0;
796  switch (o->type) {
797  case AV_OPT_TYPE_BOOL:
798  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
799  break;
800  case AV_OPT_TYPE_FLAGS:
801  ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
802  break;
803  case AV_OPT_TYPE_INT:
804  ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
805  break;
806  case AV_OPT_TYPE_INT64:
807  ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
808  break;
809  case AV_OPT_TYPE_UINT64:
810  ret = snprintf(buf, sizeof(buf), "%"PRIu64, *(uint64_t *)dst);
811  break;
812  case AV_OPT_TYPE_FLOAT:
813  ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
814  break;
815  case AV_OPT_TYPE_DOUBLE:
816  ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
817  break;
820  ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
821  break;
822  case AV_OPT_TYPE_CONST:
823  ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
824  break;
825  case AV_OPT_TYPE_STRING:
826  if (*(uint8_t **)dst) {
827  *out_val = av_strdup(*(uint8_t **)dst);
828  } else if (search_flags & AV_OPT_ALLOW_NULL) {
829  *out_val = NULL;
830  return 0;
831  } else {
832  *out_val = av_strdup("");
833  }
834  return *out_val ? 0 : AVERROR(ENOMEM);
835  case AV_OPT_TYPE_BINARY:
836  if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
837  *out_val = NULL;
838  return 0;
839  }
840  len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
841  if ((uint64_t)len * 2 + 1 > INT_MAX)
842  return AVERROR(EINVAL);
843  if (!(*out_val = av_malloc(len * 2 + 1)))
844  return AVERROR(ENOMEM);
845  if (!len) {
846  *out_val[0] = '\0';
847  return 0;
848  }
849  bin = *(uint8_t **)dst;
850  for (i = 0; i < len; i++)
851  snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
852  return 0;
854  ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
855  break;
857  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
858  break;
860  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
861  break;
863  i64 = *(int64_t *)dst;
864  format_duration(buf, sizeof(buf), i64);
865  ret = strlen(buf); // no overflow possible, checked by an assert
866  break;
867  case AV_OPT_TYPE_COLOR:
868  ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
869  (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
870  (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
871  break;
873  i64 = *(int64_t *)dst;
874  ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
875  break;
876  case AV_OPT_TYPE_DICT:
877  if (!*(AVDictionary **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
878  *out_val = NULL;
879  return 0;
880  }
881  return av_dict_get_string(*(AVDictionary **)dst, (char **)out_val, '=', ':');
882  default:
883  return AVERROR(EINVAL);
884  }
885 
886  if (ret >= sizeof(buf))
887  return AVERROR(EINVAL);
888  *out_val = av_strdup(buf);
889  return *out_val ? 0 : AVERROR(ENOMEM);
890 }
891 
892 static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
893  int search_flags)
894 {
895  void *dst, *target_obj;
896  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
897  if (!o || !target_obj)
898  goto error;
899 
900  dst = ((uint8_t *)target_obj) + o->offset;
901 
902  if (o_out) *o_out= o;
903 
904  return read_number(o, dst, num, den, intnum);
905 
906 error:
907  *den =
908  *intnum = 0;
909  return -1;
910 }
911 
912 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *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  *out_val = num * intnum / den;
921  return 0;
922 }
923 
924 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
925 {
926  int64_t intnum = 1;
927  double num = 1;
928  int ret, den = 1;
929 
930  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
931  return ret;
932  *out_val = num * intnum / den;
933  return 0;
934 }
935 
936 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
937 {
938  int64_t intnum = 1;
939  double num = 1;
940  int ret, den = 1;
941 
942  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
943  return ret;
944 
945  if (num == 1.0 && (int)intnum == intnum)
946  *out_val = (AVRational){intnum, den};
947  else
948  *out_val = av_d2q(num*intnum/den, 1<<24);
949  return 0;
950 }
951 
952 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
953 {
954  void *dst, *target_obj;
955  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
956  if (!o || !target_obj)
958  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
959  av_log(obj, AV_LOG_ERROR,
960  "The value for option '%s' is not an image size.\n", name);
961  return AVERROR(EINVAL);
962  }
963 
964  dst = ((uint8_t*)target_obj) + o->offset;
965  if (w_out) *w_out = *(int *)dst;
966  if (h_out) *h_out = *((int *)dst+1);
967  return 0;
968 }
969 
970 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
971 {
972  int64_t intnum = 1;
973  double num = 1;
974  int ret, den = 1;
975 
976  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
977  return ret;
978 
979  if (num == 1.0 && (int)intnum == intnum)
980  *out_val = (AVRational) { intnum, den };
981  else
982  *out_val = av_d2q(num * intnum / den, 1 << 24);
983  return 0;
984 }
985 
986 static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
987  enum AVOptionType type, const char *desc)
988 {
989  void *dst, *target_obj;
990  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
991  if (!o || !target_obj)
993  if (o->type != type) {
994  av_log(obj, AV_LOG_ERROR,
995  "The value for option '%s' is not a %s format.\n", desc, name);
996  return AVERROR(EINVAL);
997  }
998 
999  dst = ((uint8_t*)target_obj) + o->offset;
1000  *out_fmt = *(int *)dst;
1001  return 0;
1002 }
1003 
1004 int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
1005 {
1006  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
1007 }
1008 
1009 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
1010 {
1011  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
1012 }
1013 
1014 int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
1015 {
1016  void *dst, *target_obj;
1017  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
1018  if (!o || !target_obj)
1019  return AVERROR_OPTION_NOT_FOUND;
1020  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
1021  av_log(obj, AV_LOG_ERROR,
1022  "The value for option '%s' is not a channel layout.\n", name);
1023  return AVERROR(EINVAL);
1024  }
1025 
1026  dst = ((uint8_t*)target_obj) + o->offset;
1027  *cl = *(int64_t *)dst;
1028  return 0;
1029 }
1030 
1031 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
1032 {
1033  void *target_obj;
1034  AVDictionary *src;
1035  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
1036 
1037  if (!o || !target_obj)
1038  return AVERROR_OPTION_NOT_FOUND;
1039  if (o->type != AV_OPT_TYPE_DICT)
1040  return AVERROR(EINVAL);
1041 
1042  src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
1043  av_dict_copy(out_val, src, 0);
1044 
1045  return 0;
1046 }
1047 
1048 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
1049 {
1050  const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
1051  const AVOption *flag = av_opt_find(obj, flag_name,
1052  field ? field->unit : NULL, 0, 0);
1053  int64_t res;
1054 
1055  if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
1056  av_opt_get_int(obj, field_name, 0, &res) < 0)
1057  return 0;
1058  return res & flag->default_val.i64;
1059 }
1060 
1061 static void log_int_value(void *av_log_obj, int level, int64_t i)
1062 {
1063  if (i == INT_MAX) {
1064  av_log(av_log_obj, level, "INT_MAX");
1065  } else if (i == INT_MIN) {
1066  av_log(av_log_obj, level, "INT_MIN");
1067  } else if (i == UINT32_MAX) {
1068  av_log(av_log_obj, level, "UINT32_MAX");
1069  } else if (i == INT64_MAX) {
1070  av_log(av_log_obj, level, "I64_MAX");
1071  } else if (i == INT64_MIN) {
1072  av_log(av_log_obj, level, "I64_MIN");
1073  } else {
1074  av_log(av_log_obj, level, "%"PRId64, i);
1075  }
1076 }
1077 
1078 static void log_value(void *av_log_obj, int level, double d)
1079 {
1080  if (d == INT_MAX) {
1081  av_log(av_log_obj, level, "INT_MAX");
1082  } else if (d == INT_MIN) {
1083  av_log(av_log_obj, level, "INT_MIN");
1084  } else if (d == UINT32_MAX) {
1085  av_log(av_log_obj, level, "UINT32_MAX");
1086  } else if (d == (double)INT64_MAX) {
1087  av_log(av_log_obj, level, "I64_MAX");
1088  } else if (d == INT64_MIN) {
1089  av_log(av_log_obj, level, "I64_MIN");
1090  } else if (d == FLT_MAX) {
1091  av_log(av_log_obj, level, "FLT_MAX");
1092  } else if (d == FLT_MIN) {
1093  av_log(av_log_obj, level, "FLT_MIN");
1094  } else if (d == -FLT_MAX) {
1095  av_log(av_log_obj, level, "-FLT_MAX");
1096  } else if (d == -FLT_MIN) {
1097  av_log(av_log_obj, level, "-FLT_MIN");
1098  } else if (d == DBL_MAX) {
1099  av_log(av_log_obj, level, "DBL_MAX");
1100  } else if (d == DBL_MIN) {
1101  av_log(av_log_obj, level, "DBL_MIN");
1102  } else if (d == -DBL_MAX) {
1103  av_log(av_log_obj, level, "-DBL_MAX");
1104  } else if (d == -DBL_MIN) {
1105  av_log(av_log_obj, level, "-DBL_MIN");
1106  } else {
1107  av_log(av_log_obj, level, "%g", d);
1108  }
1109 }
1110 
1111 static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
1112 {
1113  const AVOption *opt = NULL;
1114 
1115  if (!unit)
1116  return NULL;
1117  while ((opt = av_opt_next(obj, opt)))
1118  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1119  opt->default_val.i64 == value)
1120  return opt->name;
1121  return NULL;
1122 }
1123 
1124 static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
1125 {
1126  const AVOption *opt = NULL;
1127  char flags[512];
1128 
1129  flags[0] = 0;
1130  if (!unit)
1131  return NULL;
1132  while ((opt = av_opt_next(obj, opt))) {
1133  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1134  opt->default_val.i64 & value) {
1135  if (flags[0])
1136  av_strlcatf(flags, sizeof(flags), "+");
1137  av_strlcatf(flags, sizeof(flags), "%s", opt->name);
1138  }
1139  }
1140  if (flags[0])
1141  return av_strdup(flags);
1142  return NULL;
1143 }
1144 
1145 static void opt_list(void *obj, void *av_log_obj, const char *unit,
1146  int req_flags, int rej_flags, enum AVOptionType parent_type)
1147 {
1148  const AVOption *opt = NULL;
1149  AVOptionRanges *r;
1150  int i;
1151 
1152  while ((opt = av_opt_next(obj, opt))) {
1153  if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
1154  continue;
1155 
1156  /* Don't print CONST's on level one.
1157  * Don't print anything but CONST's on level two.
1158  * Only print items from the requested unit.
1159  */
1160  if (!unit && opt->type == AV_OPT_TYPE_CONST)
1161  continue;
1162  else if (unit && opt->type != AV_OPT_TYPE_CONST)
1163  continue;
1164  else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
1165  continue;
1166  else if (unit && opt->type == AV_OPT_TYPE_CONST)
1167  av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
1168  else
1169  av_log(av_log_obj, AV_LOG_INFO, " %s%-17s ",
1170  (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
1171  opt->name);
1172 
1173  switch (opt->type) {
1174  case AV_OPT_TYPE_FLAGS:
1175  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
1176  break;
1177  case AV_OPT_TYPE_INT:
1178  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
1179  break;
1180  case AV_OPT_TYPE_INT64:
1181  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
1182  break;
1183  case AV_OPT_TYPE_UINT64:
1184  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<uint64>");
1185  break;
1186  case AV_OPT_TYPE_DOUBLE:
1187  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
1188  break;
1189  case AV_OPT_TYPE_FLOAT:
1190  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
1191  break;
1192  case AV_OPT_TYPE_STRING:
1193  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
1194  break;
1195  case AV_OPT_TYPE_RATIONAL:
1196  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
1197  break;
1198  case AV_OPT_TYPE_BINARY:
1199  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
1200  break;
1201  case AV_OPT_TYPE_DICT:
1202  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<dictionary>");
1203  break;
1205  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
1206  break;
1208  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
1209  break;
1210  case AV_OPT_TYPE_PIXEL_FMT:
1211  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
1212  break;
1214  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
1215  break;
1216  case AV_OPT_TYPE_DURATION:
1217  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
1218  break;
1219  case AV_OPT_TYPE_COLOR:
1220  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
1221  break;
1223  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
1224  break;
1225  case AV_OPT_TYPE_BOOL:
1226  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
1227  break;
1228  case AV_OPT_TYPE_CONST:
1229  if (parent_type == AV_OPT_TYPE_INT)
1230  av_log(av_log_obj, AV_LOG_INFO, "%-12"PRId64" ", opt->default_val.i64);
1231  else
1232  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1233  break;
1234  default:
1235  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1236  break;
1237  }
1238  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
1239  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
1240  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
1241  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
1242  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
1243  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
1244  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
1245  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
1246  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_BSF_PARAM) ? 'B' : '.');
1247  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM) ? 'T' : '.');
1248  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DEPRECATED) ? 'P' : '.');
1249 
1250  if (opt->help)
1251  av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
1252 
1253  if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
1254  switch (opt->type) {
1255  case AV_OPT_TYPE_INT:
1256  case AV_OPT_TYPE_INT64:
1257  case AV_OPT_TYPE_UINT64:
1258  case AV_OPT_TYPE_DOUBLE:
1259  case AV_OPT_TYPE_FLOAT:
1260  case AV_OPT_TYPE_RATIONAL:
1261  for (i = 0; i < r->nb_ranges; i++) {
1262  av_log(av_log_obj, AV_LOG_INFO, " (from ");
1263  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
1264  av_log(av_log_obj, AV_LOG_INFO, " to ");
1265  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
1266  av_log(av_log_obj, AV_LOG_INFO, ")");
1267  }
1268  break;
1269  }
1270  av_opt_freep_ranges(&r);
1271  }
1272 
1273  if (opt->type != AV_OPT_TYPE_CONST &&
1274  opt->type != AV_OPT_TYPE_BINARY &&
1275  !((opt->type == AV_OPT_TYPE_COLOR ||
1276  opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
1277  opt->type == AV_OPT_TYPE_STRING ||
1278  opt->type == AV_OPT_TYPE_DICT ||
1279  opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
1280  !opt->default_val.str)) {
1281  av_log(av_log_obj, AV_LOG_INFO, " (default ");
1282  switch (opt->type) {
1283  case AV_OPT_TYPE_BOOL:
1284  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
1285  break;
1286  case AV_OPT_TYPE_FLAGS: {
1287  char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
1288  if (def_flags) {
1289  av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
1290  av_freep(&def_flags);
1291  } else {
1292  av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
1293  }
1294  break;
1295  }
1296  case AV_OPT_TYPE_DURATION: {
1297  char buf[25];
1298  format_duration(buf, sizeof(buf), opt->default_val.i64);
1299  av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
1300  break;
1301  }
1302  case AV_OPT_TYPE_INT:
1303  case AV_OPT_TYPE_UINT64:
1304  case AV_OPT_TYPE_INT64: {
1305  const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
1306  if (def_const)
1307  av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
1308  else
1309  log_int_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
1310  break;
1311  }
1312  case AV_OPT_TYPE_DOUBLE:
1313  case AV_OPT_TYPE_FLOAT:
1314  log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
1315  break;
1316  case AV_OPT_TYPE_RATIONAL: {
1317  AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
1318  av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
1319  break;
1320  case AV_OPT_TYPE_PIXEL_FMT:
1321  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
1322  break;
1324  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
1325  break;
1326  case AV_OPT_TYPE_COLOR:
1328  case AV_OPT_TYPE_STRING:
1329  case AV_OPT_TYPE_DICT:
1331  av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
1332  break;
1334  av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
1335  break;
1336  }
1337  av_log(av_log_obj, AV_LOG_INFO, ")");
1338  }
1339 
1340  av_log(av_log_obj, AV_LOG_INFO, "\n");
1341  if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
1342  opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags, opt->type);
1343  }
1344 }
1345 
1346 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
1347 {
1348  if (!obj)
1349  return -1;
1350 
1351  av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
1352 
1353  opt_list(obj, av_log_obj, NULL, req_flags, rej_flags, -1);
1354 
1355  return 0;
1356 }
1357 
1359 {
1360  av_opt_set_defaults2(s, 0, 0);
1361 }
1362 
1363 void av_opt_set_defaults2(void *s, int mask, int flags)
1364 {
1365  const AVOption *opt = NULL;
1366  while ((opt = av_opt_next(s, opt))) {
1367  void *dst = ((uint8_t*)s) + opt->offset;
1368 
1369  if ((opt->flags & mask) != flags)
1370  continue;
1371 
1372  if (opt->flags & AV_OPT_FLAG_READONLY)
1373  continue;
1374 
1375  switch (opt->type) {
1376  case AV_OPT_TYPE_CONST:
1377  /* Nothing to be done here */
1378  break;
1379  case AV_OPT_TYPE_BOOL:
1380  case AV_OPT_TYPE_FLAGS:
1381  case AV_OPT_TYPE_INT:
1382  case AV_OPT_TYPE_INT64:
1383  case AV_OPT_TYPE_UINT64:
1384  case AV_OPT_TYPE_DURATION:
1386  case AV_OPT_TYPE_PIXEL_FMT:
1388  write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1389  break;
1390  case AV_OPT_TYPE_DOUBLE:
1391  case AV_OPT_TYPE_FLOAT: {
1392  double val;
1393  val = opt->default_val.dbl;
1394  write_number(s, opt, dst, val, 1, 1);
1395  }
1396  break;
1397  case AV_OPT_TYPE_RATIONAL: {
1398  AVRational val;
1399  val = av_d2q(opt->default_val.dbl, INT_MAX);
1400  write_number(s, opt, dst, 1, val.den, val.num);
1401  }
1402  break;
1403  case AV_OPT_TYPE_COLOR:
1404  set_string_color(s, opt, opt->default_val.str, dst);
1405  break;
1406  case AV_OPT_TYPE_STRING:
1407  set_string(s, opt, opt->default_val.str, dst);
1408  break;
1410  set_string_image_size(s, opt, opt->default_val.str, dst);
1411  break;
1413  set_string_video_rate(s, opt, opt->default_val.str, dst);
1414  break;
1415  case AV_OPT_TYPE_BINARY:
1416  set_string_binary(s, opt, opt->default_val.str, dst);
1417  break;
1418  case AV_OPT_TYPE_DICT:
1419  set_string_dict(s, opt, opt->default_val.str, dst);
1420  break;
1421  default:
1422  av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
1423  opt->type, opt->name);
1424  }
1425  }
1426 }
1427 
1428 /**
1429  * Store the value in the field in ctx that is named like key.
1430  * ctx must be an AVClass context, storing is done using AVOptions.
1431  *
1432  * @param buf the string to parse, buf will be updated to point at the
1433  * separator just after the parsed key/value pair
1434  * @param key_val_sep a 0-terminated list of characters used to
1435  * separate key from value
1436  * @param pairs_sep a 0-terminated list of characters used to separate
1437  * two pairs from each other
1438  * @return 0 if the key/value pair has been successfully parsed and
1439  * set, or a negative value corresponding to an AVERROR code in case
1440  * of error:
1441  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
1442  * the error code issued by av_opt_set() if the key/value pair
1443  * cannot be set
1444  */
1445 static int parse_key_value_pair(void *ctx, const char **buf,
1446  const char *key_val_sep, const char *pairs_sep)
1447 {
1448  char *key = av_get_token(buf, key_val_sep);
1449  char *val;
1450  int ret;
1451 
1452  if (!key)
1453  return AVERROR(ENOMEM);
1454 
1455  if (*key && strspn(*buf, key_val_sep)) {
1456  (*buf)++;
1457  val = av_get_token(buf, pairs_sep);
1458  if (!val) {
1459  av_freep(&key);
1460  return AVERROR(ENOMEM);
1461  }
1462  } else {
1463  av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
1464  av_free(key);
1465  return AVERROR(EINVAL);
1466  }
1467 
1468  av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1469 
1470  ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1471  if (ret == AVERROR_OPTION_NOT_FOUND)
1472  av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
1473 
1474  av_free(key);
1475  av_free(val);
1476  return ret;
1477 }
1478 
1479 int av_set_options_string(void *ctx, const char *opts,
1480  const char *key_val_sep, const char *pairs_sep)
1481 {
1482  int ret, count = 0;
1483 
1484  if (!opts)
1485  return 0;
1486 
1487  while (*opts) {
1488  if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1489  return ret;
1490  count++;
1491 
1492  if (*opts)
1493  opts++;
1494  }
1495 
1496  return count;
1497 }
1498 
1499 #define WHITESPACES " \n\t\r"
1500 
1501 static int is_key_char(char c)
1502 {
1503  return (unsigned)((c | 32) - 'a') < 26 ||
1504  (unsigned)(c - '0') < 10 ||
1505  c == '-' || c == '_' || c == '/' || c == '.';
1506 }
1507 
1508 /**
1509  * Read a key from a string.
1510  *
1511  * The key consists of is_key_char characters and must be terminated by a
1512  * character from the delim string; spaces are ignored.
1513  *
1514  * @return 0 for success (even with ellipsis), <0 for failure
1515  */
1516 static int get_key(const char **ropts, const char *delim, char **rkey)
1517 {
1518  const char *opts = *ropts;
1519  const char *key_start, *key_end;
1520 
1521  key_start = opts += strspn(opts, WHITESPACES);
1522  while (is_key_char(*opts))
1523  opts++;
1524  key_end = opts;
1525  opts += strspn(opts, WHITESPACES);
1526  if (!*opts || !strchr(delim, *opts))
1527  return AVERROR(EINVAL);
1528  opts++;
1529  if (!(*rkey = av_malloc(key_end - key_start + 1)))
1530  return AVERROR(ENOMEM);
1531  memcpy(*rkey, key_start, key_end - key_start);
1532  (*rkey)[key_end - key_start] = 0;
1533  *ropts = opts;
1534  return 0;
1535 }
1536 
1537 int av_opt_get_key_value(const char **ropts,
1538  const char *key_val_sep, const char *pairs_sep,
1539  unsigned flags,
1540  char **rkey, char **rval)
1541 {
1542  int ret;
1543  char *key = NULL, *val;
1544  const char *opts = *ropts;
1545 
1546  if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1547  !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1548  return AVERROR(EINVAL);
1549  if (!(val = av_get_token(&opts, pairs_sep))) {
1550  av_free(key);
1551  return AVERROR(ENOMEM);
1552  }
1553  *ropts = opts;
1554  *rkey = key;
1555  *rval = val;
1556  return 0;
1557 }
1558 
1559 int av_opt_set_from_string(void *ctx, const char *opts,
1560  const char *const *shorthand,
1561  const char *key_val_sep, const char *pairs_sep)
1562 {
1563  int ret, count = 0;
1564  const char *dummy_shorthand = NULL;
1565  char *av_uninit(parsed_key), *av_uninit(value);
1566  const char *key;
1567 
1568  if (!opts)
1569  return 0;
1570  if (!shorthand)
1571  shorthand = &dummy_shorthand;
1572 
1573  while (*opts) {
1574  ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1575  *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1576  &parsed_key, &value);
1577  if (ret < 0) {
1578  if (ret == AVERROR(EINVAL))
1579  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1580  else
1581  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
1582  av_err2str(ret));
1583  return ret;
1584  }
1585  if (*opts)
1586  opts++;
1587  if (parsed_key) {
1588  key = parsed_key;
1589  while (*shorthand) /* discard all remaining shorthand */
1590  shorthand++;
1591  } else {
1592  key = *(shorthand++);
1593  }
1594 
1595  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
1596  if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1597  if (ret == AVERROR_OPTION_NOT_FOUND)
1598  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1599  av_free(value);
1600  av_free(parsed_key);
1601  return ret;
1602  }
1603 
1604  av_free(value);
1605  av_free(parsed_key);
1606  count++;
1607  }
1608  return count;
1609 }
1610 
1611 void av_opt_free(void *obj)
1612 {
1613  const AVOption *o = NULL;
1614  while ((o = av_opt_next(obj, o))) {
1615  switch (o->type) {
1616  case AV_OPT_TYPE_STRING:
1617  case AV_OPT_TYPE_BINARY:
1618  av_freep((uint8_t *)obj + o->offset);
1619  break;
1620 
1621  case AV_OPT_TYPE_DICT:
1622  av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
1623  break;
1624 
1625  default:
1626  break;
1627  }
1628  }
1629 }
1630 
1631 int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
1632 {
1633  AVDictionaryEntry *t = NULL;
1634  AVDictionary *tmp = NULL;
1635  int ret = 0;
1636 
1637  if (!options)
1638  return 0;
1639 
1640  while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1641  ret = av_opt_set(obj, t->key, t->value, search_flags);
1642  if (ret == AVERROR_OPTION_NOT_FOUND)
1643  ret = av_dict_set(&tmp, t->key, t->value, 0);
1644  if (ret < 0) {
1645  av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
1646  av_dict_free(&tmp);
1647  return ret;
1648  }
1649  ret = 0;
1650  }
1651  av_dict_free(options);
1652  *options = tmp;
1653  return ret;
1654 }
1655 
1657 {
1658  return av_opt_set_dict2(obj, options, 0);
1659 }
1660 
1661 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
1662  int opt_flags, int search_flags)
1663 {
1664  return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
1665 }
1666 
1667 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
1668  int opt_flags, int search_flags, void **target_obj)
1669 {
1670  const AVClass *c;
1671  const AVOption *o = NULL;
1672 
1673  if(!obj)
1674  return NULL;
1675 
1676  c= *(AVClass**)obj;
1677 
1678  if (!c)
1679  return NULL;
1680 
1681  if (search_flags & AV_OPT_SEARCH_CHILDREN) {
1682  if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
1683  void *iter = NULL;
1684  const AVClass *child;
1685  while (child = av_opt_child_class_iterate(c, &iter))
1686  if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
1687  return o;
1688  } else {
1689  void *child = NULL;
1690  while (child = av_opt_child_next(obj, child))
1691  if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
1692  return o;
1693  }
1694  }
1695 
1696  while (o = av_opt_next(obj, o)) {
1697  if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
1698  ((!unit && o->type != AV_OPT_TYPE_CONST) ||
1699  (unit && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
1700  if (target_obj) {
1701  if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
1702  *target_obj = obj;
1703  else
1704  *target_obj = NULL;
1705  }
1706  return o;
1707  }
1708  }
1709  return NULL;
1710 }
1711 
1712 void *av_opt_child_next(void *obj, void *prev)
1713 {
1714  const AVClass *c = *(AVClass **)obj;
1715  if (c->child_next)
1716  return c->child_next(obj, prev);
1717  return NULL;
1718 }
1719 
1720 #if FF_API_CHILD_CLASS_NEXT
1722 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
1723 {
1724  if (parent->child_class_next)
1725  return parent->child_class_next(prev);
1726  return NULL;
1727 }
1729 #endif
1730 
1731 const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter)
1732 {
1733  if (parent->child_class_iterate)
1734  return parent->child_class_iterate(iter);
1735 #if FF_API_CHILD_CLASS_NEXT
1737  if (parent->child_class_next) {
1738  *iter = parent->child_class_next(*iter);
1739  return *iter;
1740  }
1742 #endif
1743  return NULL;
1744 }
1745 
1746 void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
1747 {
1748  const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1749  if(!opt)
1750  return NULL;
1751  return (uint8_t*)obj + opt->offset;
1752 }
1753 
1754 static int opt_size(enum AVOptionType type)
1755 {
1756  switch(type) {
1757  case AV_OPT_TYPE_BOOL:
1758  case AV_OPT_TYPE_INT:
1759  case AV_OPT_TYPE_FLAGS:
1760  return sizeof(int);
1761  case AV_OPT_TYPE_DURATION:
1763  case AV_OPT_TYPE_INT64:
1764  case AV_OPT_TYPE_UINT64:
1765  return sizeof(int64_t);
1766  case AV_OPT_TYPE_DOUBLE:
1767  return sizeof(double);
1768  case AV_OPT_TYPE_FLOAT:
1769  return sizeof(float);
1770  case AV_OPT_TYPE_STRING:
1771  return sizeof(uint8_t*);
1773  case AV_OPT_TYPE_RATIONAL:
1774  return sizeof(AVRational);
1775  case AV_OPT_TYPE_BINARY:
1776  return sizeof(uint8_t*) + sizeof(int);
1778  return sizeof(int[2]);
1779  case AV_OPT_TYPE_PIXEL_FMT:
1780  return sizeof(enum AVPixelFormat);
1782  return sizeof(enum AVSampleFormat);
1783  case AV_OPT_TYPE_COLOR:
1784  return 4;
1785  }
1786  return AVERROR(EINVAL);
1787 }
1788 
1789 int av_opt_copy(void *dst, const void *src)
1790 {
1791  const AVOption *o = NULL;
1792  const AVClass *c;
1793  int ret = 0;
1794 
1795  if (!src)
1796  return AVERROR(EINVAL);
1797 
1798  c = *(AVClass **)src;
1799  if (!c || c != *(AVClass **)dst)
1800  return AVERROR(EINVAL);
1801 
1802  while ((o = av_opt_next(src, o))) {
1803  void *field_dst = (uint8_t *)dst + o->offset;
1804  void *field_src = (uint8_t *)src + o->offset;
1805  uint8_t **field_dst8 = (uint8_t **)field_dst;
1806  uint8_t **field_src8 = (uint8_t **)field_src;
1807 
1808  if (o->type == AV_OPT_TYPE_STRING) {
1809  if (*field_dst8 != *field_src8)
1810  av_freep(field_dst8);
1811  *field_dst8 = av_strdup(*field_src8);
1812  if (*field_src8 && !*field_dst8)
1813  ret = AVERROR(ENOMEM);
1814  } else if (o->type == AV_OPT_TYPE_BINARY) {
1815  int len = *(int *)(field_src8 + 1);
1816  if (*field_dst8 != *field_src8)
1817  av_freep(field_dst8);
1818  *field_dst8 = av_memdup(*field_src8, len);
1819  if (len && !*field_dst8) {
1820  ret = AVERROR(ENOMEM);
1821  len = 0;
1822  }
1823  *(int *)(field_dst8 + 1) = len;
1824  } else if (o->type == AV_OPT_TYPE_CONST) {
1825  // do nothing
1826  } else if (o->type == AV_OPT_TYPE_DICT) {
1827  AVDictionary **sdict = (AVDictionary **) field_src;
1828  AVDictionary **ddict = (AVDictionary **) field_dst;
1829  if (*sdict != *ddict)
1830  av_dict_free(ddict);
1831  *ddict = NULL;
1832  av_dict_copy(ddict, *sdict, 0);
1833  if (av_dict_count(*sdict) != av_dict_count(*ddict))
1834  ret = AVERROR(ENOMEM);
1835  } else {
1836  int size = opt_size(o->type);
1837  if (size < 0)
1838  ret = size;
1839  else
1840  memcpy(field_dst, field_src, size);
1841  }
1842  }
1843  return ret;
1844 }
1845 
1846 int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1847 {
1848  int ret;
1849  const AVClass *c = *(AVClass**)obj;
1850  int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
1851 
1852  if (c->version > (52 << 16 | 11 << 8))
1853  callback = c->query_ranges;
1854 
1855  if (!callback)
1857 
1858  ret = callback(ranges_arg, obj, key, flags);
1859  if (ret >= 0) {
1860  if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
1861  ret = 1;
1862  (*ranges_arg)->nb_components = ret;
1863  }
1864  return ret;
1865 }
1866 
1867 int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1868 {
1869  AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
1870  AVOptionRange **range_array = av_mallocz(sizeof(void*));
1871  AVOptionRange *range = av_mallocz(sizeof(*range));
1872  const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1873  int ret;
1874 
1875  *ranges_arg = NULL;
1876 
1877  if (!ranges || !range || !range_array || !field) {
1878  ret = AVERROR(ENOMEM);
1879  goto fail;
1880  }
1881 
1882  ranges->range = range_array;
1883  ranges->range[0] = range;
1884  ranges->nb_ranges = 1;
1885  ranges->nb_components = 1;
1886  range->is_range = 1;
1887  range->value_min = field->min;
1888  range->value_max = field->max;
1889 
1890  switch (field->type) {
1891  case AV_OPT_TYPE_BOOL:
1892  case AV_OPT_TYPE_INT:
1893  case AV_OPT_TYPE_INT64:
1894  case AV_OPT_TYPE_UINT64:
1895  case AV_OPT_TYPE_PIXEL_FMT:
1897  case AV_OPT_TYPE_FLOAT:
1898  case AV_OPT_TYPE_DOUBLE:
1899  case AV_OPT_TYPE_DURATION:
1900  case AV_OPT_TYPE_COLOR:
1902  break;
1903  case AV_OPT_TYPE_STRING:
1904  range->component_min = 0;
1905  range->component_max = 0x10FFFF; // max unicode value
1906  range->value_min = -1;
1907  range->value_max = INT_MAX;
1908  break;
1909  case AV_OPT_TYPE_RATIONAL:
1910  range->component_min = INT_MIN;
1911  range->component_max = INT_MAX;
1912  break;
1914  range->component_min = 0;
1915  range->component_max = INT_MAX/128/8;
1916  range->value_min = 0;
1917  range->value_max = INT_MAX/8;
1918  break;
1920  range->component_min = 1;
1921  range->component_max = INT_MAX;
1922  range->value_min = 1;
1923  range->value_max = INT_MAX;
1924  break;
1925  default:
1926  ret = AVERROR(ENOSYS);
1927  goto fail;
1928  }
1929 
1930  *ranges_arg = ranges;
1931  return 1;
1932 fail:
1933  av_free(ranges);
1934  av_free(range);
1935  av_free(range_array);
1936  return ret;
1937 }
1938 
1940 {
1941  int i;
1942  AVOptionRanges *ranges = *rangesp;
1943 
1944  if (!ranges)
1945  return;
1946 
1947  for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
1948  AVOptionRange *range = ranges->range[i];
1949  if (range) {
1950  av_freep(&range->str);
1951  av_freep(&ranges->range[i]);
1952  }
1953  }
1954  av_freep(&ranges->range);
1955  av_freep(rangesp);
1956 }
1957 
1958 int av_opt_is_set_to_default(void *obj, const AVOption *o)
1959 {
1960  int64_t i64;
1961  double d, d2;
1962  float f;
1963  AVRational q;
1964  int ret, w, h;
1965  char *str;
1966  void *dst;
1967 
1968  if (!o || !obj)
1969  return AVERROR(EINVAL);
1970 
1971  dst = ((uint8_t*)obj) + o->offset;
1972 
1973  switch (o->type) {
1974  case AV_OPT_TYPE_CONST:
1975  return 1;
1976  case AV_OPT_TYPE_BOOL:
1977  case AV_OPT_TYPE_FLAGS:
1978  case AV_OPT_TYPE_PIXEL_FMT:
1980  case AV_OPT_TYPE_INT:
1982  case AV_OPT_TYPE_DURATION:
1983  case AV_OPT_TYPE_INT64:
1984  case AV_OPT_TYPE_UINT64:
1985  read_number(o, dst, NULL, NULL, &i64);
1986  return o->default_val.i64 == i64;
1987  case AV_OPT_TYPE_STRING:
1988  str = *(char **)dst;
1989  if (str == o->default_val.str) //2 NULLs
1990  return 1;
1991  if (!str || !o->default_val.str) //1 NULL
1992  return 0;
1993  return !strcmp(str, o->default_val.str);
1994  case AV_OPT_TYPE_DOUBLE:
1995  read_number(o, dst, &d, NULL, NULL);
1996  return o->default_val.dbl == d;
1997  case AV_OPT_TYPE_FLOAT:
1998  read_number(o, dst, &d, NULL, NULL);
1999  f = o->default_val.dbl;
2000  d2 = f;
2001  return d2 == d;
2002  case AV_OPT_TYPE_RATIONAL:
2003  q = av_d2q(o->default_val.dbl, INT_MAX);
2004  return !av_cmp_q(*(AVRational*)dst, q);
2005  case AV_OPT_TYPE_BINARY: {
2006  struct {
2007  uint8_t *data;
2008  int size;
2009  } tmp = {0};
2010  int opt_size = *(int *)((void **)dst + 1);
2011  void *opt_ptr = *(void **)dst;
2012  if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
2013  return 1;
2014  if (!opt_size || !o->default_val.str || !strlen(o->default_val.str ))
2015  return 0;
2016  if (opt_size != strlen(o->default_val.str) / 2)
2017  return 0;
2018  ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
2019  if (!ret)
2020  ret = !memcmp(opt_ptr, tmp.data, tmp.size);
2021  av_free(tmp.data);
2022  return ret;
2023  }
2024  case AV_OPT_TYPE_DICT: {
2025  AVDictionary *dict1 = NULL;
2026  AVDictionary *dict2 = *(AVDictionary **)dst;
2027  AVDictionaryEntry *en1 = NULL;
2028  AVDictionaryEntry *en2 = NULL;
2029  ret = av_dict_parse_string(&dict1, o->default_val.str, "=", ":", 0);
2030  if (ret < 0) {
2031  av_dict_free(&dict1);
2032  return ret;
2033  }
2034  do {
2035  en1 = av_dict_get(dict1, "", en1, AV_DICT_IGNORE_SUFFIX);
2036  en2 = av_dict_get(dict2, "", en2, AV_DICT_IGNORE_SUFFIX);
2037  } while (en1 && en2 && !strcmp(en1->key, en2->key) && !strcmp(en1->value, en2->value));
2038  av_dict_free(&dict1);
2039  return (!en1 && !en2);
2040  }
2042  if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
2043  w = h = 0;
2044  else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
2045  return ret;
2046  return (w == *(int *)dst) && (h == *((int *)dst+1));
2048  q = (AVRational){0, 0};
2049  if (o->default_val.str) {
2050  if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
2051  return ret;
2052  }
2053  return !av_cmp_q(*(AVRational*)dst, q);
2054  case AV_OPT_TYPE_COLOR: {
2055  uint8_t color[4] = {0, 0, 0, 0};
2056  if (o->default_val.str) {
2057  if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
2058  return ret;
2059  }
2060  return !memcmp(color, dst, sizeof(color));
2061  }
2062  default:
2063  av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
2064  break;
2065  }
2066  return AVERROR_PATCHWELCOME;
2067 }
2068 
2069 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
2070 {
2071  const AVOption *o;
2072  void *target;
2073  if (!obj)
2074  return AVERROR(EINVAL);
2075  o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
2076  if (!o)
2077  return AVERROR_OPTION_NOT_FOUND;
2078  return av_opt_is_set_to_default(target, o);
2079 }
2080 
2081 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
2082  const char key_val_sep, const char pairs_sep)
2083 {
2084  const AVOption *o = NULL;
2085  uint8_t *buf;
2086  AVBPrint bprint;
2087  int ret, cnt = 0;
2088  const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
2089 
2090  if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
2091  pairs_sep == '\\' || key_val_sep == '\\') {
2092  av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
2093  return AVERROR(EINVAL);
2094  }
2095 
2096  if (!obj || !buffer)
2097  return AVERROR(EINVAL);
2098 
2099  *buffer = NULL;
2101 
2102  while (o = av_opt_next(obj, o)) {
2103  if (o->type == AV_OPT_TYPE_CONST)
2104  continue;
2105  if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
2106  continue;
2107  else if (((o->flags & opt_flags) != opt_flags))
2108  continue;
2109  if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
2110  continue;
2111  if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
2112  av_bprint_finalize(&bprint, NULL);
2113  return ret;
2114  }
2115  if (buf) {
2116  if (cnt++)
2117  av_bprint_append_data(&bprint, &pairs_sep, 1);
2118  av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2119  av_bprint_append_data(&bprint, &key_val_sep, 1);
2120  av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2121  av_freep(&buf);
2122  }
2123  }
2124  ret = av_bprint_finalize(&bprint, buffer);
2125  if (ret < 0)
2126  return ret;
2127  return 0;
2128 }
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1031
#define NULL
Definition: coverity.c:32
static const char * get_bool_name(int val)
Definition: opt.c:357
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:533
A single allowed range of values, or a single allowed value.
Definition: opt.h:310
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:1124
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:248
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:596
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:286
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:282
#define AV_OPT_FLAG_DEPRECATED
set if option is deprecated, users should refer to AVOption.help text for more information ...
Definition: opt.h:295
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
Definition: opt.c:319
void * av_opt_child_next(void *obj, void *prev)
Iterate over AVOptions-enabled children of obj.
Definition: opt.c:1712
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
static int get_key(const char **ropts, const char *delim, char **rkey)
Read a key from a string.
Definition: opt.c:1516
double value_max
Definition: opt.h:317
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
static int opt_size(enum AVOptionType type)
Definition: opt.c:1754
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
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:1479
int av_dict_get_string(const AVDictionary *m, char **buffer, const char key_val_sep, const char pairs_sep)
Get dictionary entries as a string.
Definition: dict.c:230
static int set_string_dict(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:447
static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
Definition: opt.c:441
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:601
Use backslash escaping.
Definition: avstring.h:325
#define FF_ARRAY_ELEMS(a)
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:237
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:936
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:2081
static void error(const char *err)
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:725
AVOptionType
Definition: opt.h:223
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:2069
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:1958
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:970
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:1559
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:986
Public dictionary API.
const char * name
Definition: opt.h:249
#define WHITESPACES
Definition: opt.c:1499
uint8_t
AVOptionRange ** range
Array of option ranges.
Definition: opt.h:364
#define av_malloc(s)
class_name
Definition: libkvazaar.c:317
const char * help
short English help text
Definition: opt.h:255
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
Definition: opt.c:58
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:1145
static const char * get_opt_const_name(void *obj, const char *unit, int64_t value)
Definition: opt.c:1111
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
const char * str
Definition: opt.h:270
int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
Definition: opt.c:591
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:322
FF_DISABLE_DEPRECATION_WARNINGS const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:1722
#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:892
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:653
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:278
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:435
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:113
#define src
Definition: vp8dsp.c:255
static void log_int_value(void *av_log_obj, int level, int64_t i)
Definition: opt.c:1061
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:1004
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:776
int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
Definition: opt.c:699
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#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:1746
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:294
int(* query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags)
Callback to return the supported/allowed ranges.
Definition: log.h:145
double max
maximum valid value for the option
Definition: opt.h:275
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:116
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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:586
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:352
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:285
#define FFMAX(a, b)
Definition: common.h:103
#define fail()
Definition: checkasm.h:133
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:151
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:1661
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:293
int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
Definition: opt.c:1009
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:311
#define NAN
Definition: mathematics.h:64
#define FFMIN(a, b)
Definition: common.h:105
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
uint8_t w
Definition: llviddspenc.c:39
#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:304
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:1445
double component_min
Value&#39;s component range.
Definition: opt.h:322
int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
Definition: opt.c:709
double min
minimum valid value for the option
Definition: opt.h:274
#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:1363
#define AV_OPT_FLAG_BSF_PARAM
a generic parameter which can be set by the user for bit stream filtering
Definition: opt.h:292
static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:180
union AVOption::@312 default_val
the default value for scalar options
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:1631
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:231
int flags
Definition: opt.h:277
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:1867
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int is_range
Range flag.
Definition: opt.h:327
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:912
static void log_value(void *av_log_obj, int level, double d)
Definition: opt.c:1078
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
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:670
void av_opt_freep_ranges(AVOptionRanges **rangesp)
Free an AVOptionRanges struct and set it to NULL.
Definition: opt.c:1939
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
int offset
The offset relative to the context structure where the option value is stored.
Definition: opt.h:261
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:1656
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum, int search_flags)
Definition: opt.c:570
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1346
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:281
static void format_duration(char *buf, size_t size, int64_t d)
Definition: opt.c:744
static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
Definition: opt.c:364
#define OPT_EVAL_NUMBER(name, opttype, vartype)
Definition: opt.c:554
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
Definition: opt.c:1014
#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
attribute_deprecated const struct AVClass *(* child_class_next)(const struct AVClass *prev)
Return an AVClass corresponding to the next potential AVOptions-enabled child.
Definition: log.h:125
Rational number (pair of numerator and denominator).
Definition: rational.h:58
FF_ENABLE_DEPRECATION_WARNINGS const AVClass * av_opt_child_class_iterate(const AVClass *parent, void **iter)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:1731
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
#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:575
double dbl
Definition: opt.h:269
#define AV_OPT_FLAG_CHILD_CONSTS
set if option constants can also reside in child objects
Definition: opt.h:296
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:238
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:235
misc parsing utilities
#define flags(name, subs,...)
Definition: cbs_av1.c:561
uint8_t level
Definition: svq3.c:206
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:334
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:1611
const OptionDef options[]
Definition: ffmpeg_opt.c:3424
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
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:1846
double value_min
Value range.
Definition: opt.h:317
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:924
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:395
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1789
#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:569
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:368
List of AVOptionRange structs.
Definition: opt.h:333
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:779
#define av_free(p)
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS
Serialize options that are not set to default values only.
Definition: opt.h:860
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:61
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
enum AVOptionType type
Definition: opt.h:262
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:1537
int64_t i64
Definition: opt.h:268
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:291
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:1048
#define av_uninit(x)
Definition: attributes.h:154
number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of...
Definition: pixfmt.h:363
#define av_freep(p)
static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
Definition: opt.c:342
#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:861
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:1667
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:2501
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:2489
const struct AVClass *(* child_class_iterate)(void **iter)
Iterate over the AVClasses corresponding to potential AVOptions-enabled children. ...
Definition: log.h:160
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:704
#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:582
float min
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
Definition: opt.c:631
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
static int is_key_char(char c)
Definition: opt.c:1501
int i
Definition: input.c:407
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:372
int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
Definition: opt.c:952
static uint8_t tmp[11]
Definition: aes_ctr.c:27