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 static int set_string_dict(void *obj, const AVOption *o, const char *val, uint8_t **dst)
450 {
452 
453  if (val) {
454  int ret = av_dict_parse_string(&options, val, "=", ":", 0);
455  if (ret < 0) {
456  av_dict_free(&options);
457  return ret;
458  }
459  }
460 
461  av_dict_free((AVDictionary **)dst);
462  *dst = (uint8_t *)options;
463 
464  return 0;
465 }
466 
467 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
468 {
469  int ret = 0;
470  void *dst, *target_obj;
471  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
472  if (!o || !target_obj)
474  if (!val && (o->type != AV_OPT_TYPE_STRING &&
479  return AVERROR(EINVAL);
480 
481  if (o->flags & AV_OPT_FLAG_READONLY)
482  return AVERROR(EINVAL);
483 
484  if (o->flags & AV_OPT_FLAG_DEPRECATED)
485  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
486 
487  dst = ((uint8_t *)target_obj) + o->offset;
488  switch (o->type) {
489  case AV_OPT_TYPE_BOOL:
490  return set_string_bool(obj, o, val, dst);
491  case AV_OPT_TYPE_STRING:
492  return set_string(obj, o, val, dst);
493  case AV_OPT_TYPE_BINARY:
494  return set_string_binary(obj, o, val, dst);
495  case AV_OPT_TYPE_FLAGS:
496  case AV_OPT_TYPE_INT:
497  case AV_OPT_TYPE_INT64:
498  case AV_OPT_TYPE_UINT64:
499  case AV_OPT_TYPE_FLOAT:
500  case AV_OPT_TYPE_DOUBLE:
502  return set_string_number(obj, target_obj, o, val, dst);
504  return set_string_image_size(obj, o, val, dst);
505  case AV_OPT_TYPE_VIDEO_RATE: {
506  AVRational tmp;
507  ret = set_string_video_rate(obj, o, val, &tmp);
508  if (ret < 0)
509  return ret;
510  return write_number(obj, o, dst, 1, tmp.den, tmp.num);
511  }
513  return set_string_pixel_fmt(obj, o, val, dst);
515  return set_string_sample_fmt(obj, o, val, dst);
517  {
518  int64_t usecs = 0;
519  if (val) {
520  if ((ret = av_parse_time(&usecs, val, 1)) < 0) {
521  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
522  return ret;
523  }
524  }
525  if (usecs < o->min || usecs > o->max) {
526  av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
527  usecs / 1000000.0, o->name, o->min / 1000000.0, o->max / 1000000.0);
528  return AVERROR(ERANGE);
529  }
530  *(int64_t *)dst = usecs;
531  return 0;
532  }
533  case AV_OPT_TYPE_COLOR:
534  return set_string_color(obj, o, val, dst);
536  if (!val || !strcmp(val, "none")) {
537  *(int64_t *)dst = 0;
538  } else {
539  int64_t cl = av_get_channel_layout(val);
540  if (!cl) {
541  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
542  ret = AVERROR(EINVAL);
543  }
544  *(int64_t *)dst = cl;
545  return ret;
546  }
547  break;
548  case AV_OPT_TYPE_DICT:
549  return set_string_dict(obj, o, val, dst);
550  }
551 
552  av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
553  return AVERROR(EINVAL);
554 }
555 
556 #define OPT_EVAL_NUMBER(name, opttype, vartype) \
557 int av_opt_eval_ ## name(void *obj, const AVOption *o, \
558  const char *val, vartype *name ## _out) \
559 { \
560  if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY) \
561  return AVERROR(EINVAL); \
562  return set_string_number(obj, obj, o, val, name ## _out); \
563 }
564 
567 OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
568 OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
569 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
571 
572 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
573  int search_flags)
574 {
575  void *dst, *target_obj;
576  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
577 
578  if (!o || !target_obj)
580 
581  if (o->flags & AV_OPT_FLAG_READONLY)
582  return AVERROR(EINVAL);
583 
584  dst = ((uint8_t *)target_obj) + o->offset;
585  return write_number(obj, o, dst, num, den, intnum);
586 }
587 
588 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
589 {
590  return set_number(obj, name, 1, 1, val, search_flags);
591 }
592 
593 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
594 {
595  return set_number(obj, name, val, 1, 1, search_flags);
596 }
597 
598 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
599 {
600  return set_number(obj, name, val.num, val.den, 1, search_flags);
601 }
602 
603 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
604 {
605  void *target_obj;
606  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
607  uint8_t *ptr;
608  uint8_t **dst;
609  int *lendst;
610 
611  if (!o || !target_obj)
613 
615  return AVERROR(EINVAL);
616 
617  ptr = len ? av_malloc(len) : NULL;
618  if (len && !ptr)
619  return AVERROR(ENOMEM);
620 
621  dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
622  lendst = (int *)(dst + 1);
623 
624  av_free(*dst);
625  *dst = ptr;
626  *lendst = len;
627  if (len)
628  memcpy(ptr, val, len);
629 
630  return 0;
631 }
632 
633 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
634 {
635  void *target_obj;
636  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
637 
638  if (!o || !target_obj)
640  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
641  av_log(obj, AV_LOG_ERROR,
642  "The value set by option '%s' is not an image size.\n", o->name);
643  return AVERROR(EINVAL);
644  }
645  if (w<0 || h<0) {
646  av_log(obj, AV_LOG_ERROR,
647  "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
648  return AVERROR(EINVAL);
649  }
650  *(int *)(((uint8_t *)target_obj) + o->offset) = w;
651  *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
652  return 0;
653 }
654 
655 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
656 {
657  void *target_obj;
658  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
659 
660  if (!o || !target_obj)
662  if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
663  av_log(obj, AV_LOG_ERROR,
664  "The value set by option '%s' is not a video rate.\n", o->name);
665  return AVERROR(EINVAL);
666  }
667  if (val.num <= 0 || val.den <= 0)
668  return AVERROR(EINVAL);
669  return set_number(obj, name, val.num, val.den, 1, search_flags);
670 }
671 
672 static int set_format(void *obj, const char *name, int fmt, int search_flags,
673  enum AVOptionType type, const char *desc, int nb_fmts)
674 {
675  void *target_obj;
676  const AVOption *o = av_opt_find2(obj, name, NULL, 0,
677  search_flags, &target_obj);
678  int min, max;
679 
680  if (!o || !target_obj)
682  if (o->type != type) {
683  av_log(obj, AV_LOG_ERROR,
684  "The value set by option '%s' is not a %s format", name, desc);
685  return AVERROR(EINVAL);
686  }
687 
688  min = FFMAX(o->min, -1);
689  max = FFMIN(o->max, nb_fmts-1);
690 
691  if (fmt < min || fmt > max) {
692  av_log(obj, AV_LOG_ERROR,
693  "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
694  fmt, name, desc, min, max);
695  return AVERROR(ERANGE);
696  }
697  *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
698  return 0;
699 }
700 
701 int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
702 {
703  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
704 }
705 
706 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
707 {
708  return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
709 }
710 
711 int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
712 {
713  void *target_obj;
714  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
715 
716  if (!o || !target_obj)
718  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
719  av_log(obj, AV_LOG_ERROR,
720  "The value set by option '%s' is not a channel layout.\n", o->name);
721  return AVERROR(EINVAL);
722  }
723  *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
724  return 0;
725 }
726 
727 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
728  int search_flags)
729 {
730  void *target_obj;
731  AVDictionary **dst;
732  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
733 
734  if (!o || !target_obj)
736  if (o->flags & AV_OPT_FLAG_READONLY)
737  return AVERROR(EINVAL);
738 
739  dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
740  av_dict_free(dst);
741  av_dict_copy(dst, val, 0);
742 
743  return 0;
744 }
745 
746 static void format_duration(char *buf, size_t size, int64_t d)
747 {
748  char *e;
749 
750  av_assert0(size >= 25);
751  if (d < 0 && d != INT64_MIN) {
752  *(buf++) = '-';
753  size--;
754  d = -d;
755  }
756  if (d == INT64_MAX)
757  snprintf(buf, size, "INT64_MAX");
758  else if (d == INT64_MIN)
759  snprintf(buf, size, "INT64_MIN");
760  else if (d > (int64_t)3600*1000000)
761  snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
762  (int)((d / 60000000) % 60),
763  (int)((d / 1000000) % 60),
764  (int)(d % 1000000));
765  else if (d > 60*1000000)
766  snprintf(buf, size, "%d:%02d.%06d",
767  (int)(d / 60000000),
768  (int)((d / 1000000) % 60),
769  (int)(d % 1000000));
770  else
771  snprintf(buf, size, "%d.%06d",
772  (int)(d / 1000000),
773  (int)(d % 1000000));
774  e = buf + strlen(buf);
775  while (e > buf && e[-1] == '0')
776  *(--e) = 0;
777  if (e > buf && e[-1] == '.')
778  *(--e) = 0;
779 }
780 
781 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
782 {
783  void *dst, *target_obj;
784  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
785  uint8_t *bin, buf[128];
786  int len, i, ret;
787  int64_t i64;
788 
789  if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
791 
792  if (o->flags & AV_OPT_FLAG_DEPRECATED)
793  av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
794 
795  dst = (uint8_t *)target_obj + o->offset;
796 
797  buf[0] = 0;
798  switch (o->type) {
799  case AV_OPT_TYPE_BOOL:
800  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
801  break;
802  case AV_OPT_TYPE_FLAGS:
803  ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
804  break;
805  case AV_OPT_TYPE_INT:
806  ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
807  break;
808  case AV_OPT_TYPE_INT64:
809  ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
810  break;
811  case AV_OPT_TYPE_UINT64:
812  ret = snprintf(buf, sizeof(buf), "%"PRIu64, *(uint64_t *)dst);
813  break;
814  case AV_OPT_TYPE_FLOAT:
815  ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
816  break;
817  case AV_OPT_TYPE_DOUBLE:
818  ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
819  break;
822  ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
823  break;
824  case AV_OPT_TYPE_CONST:
825  ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
826  break;
827  case AV_OPT_TYPE_STRING:
828  if (*(uint8_t **)dst) {
829  *out_val = av_strdup(*(uint8_t **)dst);
830  } else if (search_flags & AV_OPT_ALLOW_NULL) {
831  *out_val = NULL;
832  return 0;
833  } else {
834  *out_val = av_strdup("");
835  }
836  return *out_val ? 0 : AVERROR(ENOMEM);
837  case AV_OPT_TYPE_BINARY:
838  if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
839  *out_val = NULL;
840  return 0;
841  }
842  len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
843  if ((uint64_t)len * 2 + 1 > INT_MAX)
844  return AVERROR(EINVAL);
845  if (!(*out_val = av_malloc(len * 2 + 1)))
846  return AVERROR(ENOMEM);
847  if (!len) {
848  *out_val[0] = '\0';
849  return 0;
850  }
851  bin = *(uint8_t **)dst;
852  for (i = 0; i < len; i++)
853  snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
854  return 0;
856  ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
857  break;
859  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
860  break;
862  ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
863  break;
865  i64 = *(int64_t *)dst;
866  format_duration(buf, sizeof(buf), i64);
867  ret = strlen(buf); // no overflow possible, checked by an assert
868  break;
869  case AV_OPT_TYPE_COLOR:
870  ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
871  (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
872  (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
873  break;
875  i64 = *(int64_t *)dst;
876  ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
877  break;
878  case AV_OPT_TYPE_DICT:
879  if (!*(AVDictionary **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
880  *out_val = NULL;
881  return 0;
882  }
883  return av_dict_get_string(*(AVDictionary **)dst, (char **)out_val, '=', ':');
884  default:
885  return AVERROR(EINVAL);
886  }
887 
888  if (ret >= sizeof(buf))
889  return AVERROR(EINVAL);
890  *out_val = av_strdup(buf);
891  return *out_val ? 0 : AVERROR(ENOMEM);
892 }
893 
894 static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
895  int search_flags)
896 {
897  void *dst, *target_obj;
898  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
899  if (!o || !target_obj)
900  goto error;
901 
902  dst = ((uint8_t *)target_obj) + o->offset;
903 
904  if (o_out) *o_out= o;
905 
906  return read_number(o, dst, num, den, intnum);
907 
908 error:
909  *den =
910  *intnum = 0;
911  return -1;
912 }
913 
914 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
915 {
916  int64_t intnum = 1;
917  double num = 1;
918  int ret, den = 1;
919 
920  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
921  return ret;
922  *out_val = num * intnum / den;
923  return 0;
924 }
925 
926 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
927 {
928  int64_t intnum = 1;
929  double num = 1;
930  int ret, den = 1;
931 
932  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
933  return ret;
934  *out_val = num * intnum / den;
935  return 0;
936 }
937 
938 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
939 {
940  int64_t intnum = 1;
941  double num = 1;
942  int ret, den = 1;
943 
944  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
945  return ret;
946 
947  if (num == 1.0 && (int)intnum == intnum)
948  *out_val = (AVRational){intnum, den};
949  else
950  *out_val = av_d2q(num*intnum/den, 1<<24);
951  return 0;
952 }
953 
954 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
955 {
956  void *dst, *target_obj;
957  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
958  if (!o || !target_obj)
960  if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
961  av_log(obj, AV_LOG_ERROR,
962  "The value for option '%s' is not an image size.\n", name);
963  return AVERROR(EINVAL);
964  }
965 
966  dst = ((uint8_t*)target_obj) + o->offset;
967  if (w_out) *w_out = *(int *)dst;
968  if (h_out) *h_out = *((int *)dst+1);
969  return 0;
970 }
971 
972 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
973 {
974  int64_t intnum = 1;
975  double num = 1;
976  int ret, den = 1;
977 
978  if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
979  return ret;
980 
981  if (num == 1.0 && (int)intnum == intnum)
982  *out_val = (AVRational) { intnum, den };
983  else
984  *out_val = av_d2q(num * intnum / den, 1 << 24);
985  return 0;
986 }
987 
988 static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
989  enum AVOptionType type, const char *desc)
990 {
991  void *dst, *target_obj;
992  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
993  if (!o || !target_obj)
995  if (o->type != type) {
996  av_log(obj, AV_LOG_ERROR,
997  "The value for option '%s' is not a %s format.\n", desc, name);
998  return AVERROR(EINVAL);
999  }
1000 
1001  dst = ((uint8_t*)target_obj) + o->offset;
1002  *out_fmt = *(int *)dst;
1003  return 0;
1004 }
1005 
1006 int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
1007 {
1008  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
1009 }
1010 
1011 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
1012 {
1013  return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
1014 }
1015 
1016 int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
1017 {
1018  void *dst, *target_obj;
1019  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
1020  if (!o || !target_obj)
1021  return AVERROR_OPTION_NOT_FOUND;
1022  if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
1023  av_log(obj, AV_LOG_ERROR,
1024  "The value for option '%s' is not a channel layout.\n", name);
1025  return AVERROR(EINVAL);
1026  }
1027 
1028  dst = ((uint8_t*)target_obj) + o->offset;
1029  *cl = *(int64_t *)dst;
1030  return 0;
1031 }
1032 
1033 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
1034 {
1035  void *target_obj;
1036  AVDictionary *src;
1037  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
1038 
1039  if (!o || !target_obj)
1040  return AVERROR_OPTION_NOT_FOUND;
1041  if (o->type != AV_OPT_TYPE_DICT)
1042  return AVERROR(EINVAL);
1043 
1044  src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
1045  av_dict_copy(out_val, src, 0);
1046 
1047  return 0;
1048 }
1049 
1050 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
1051 {
1052  const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
1053  const AVOption *flag = av_opt_find(obj, flag_name,
1054  field ? field->unit : NULL, 0, 0);
1055  int64_t res;
1056 
1057  if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
1058  av_opt_get_int(obj, field_name, 0, &res) < 0)
1059  return 0;
1060  return res & flag->default_val.i64;
1061 }
1062 
1063 static void log_int_value(void *av_log_obj, int level, int64_t i)
1064 {
1065  if (i == INT_MAX) {
1066  av_log(av_log_obj, level, "INT_MAX");
1067  } else if (i == INT_MIN) {
1068  av_log(av_log_obj, level, "INT_MIN");
1069  } else if (i == UINT32_MAX) {
1070  av_log(av_log_obj, level, "UINT32_MAX");
1071  } else if (i == INT64_MAX) {
1072  av_log(av_log_obj, level, "I64_MAX");
1073  } else if (i == INT64_MIN) {
1074  av_log(av_log_obj, level, "I64_MIN");
1075  } else {
1076  av_log(av_log_obj, level, "%"PRId64, i);
1077  }
1078 }
1079 
1080 static void log_value(void *av_log_obj, int level, double d)
1081 {
1082  if (d == INT_MAX) {
1083  av_log(av_log_obj, level, "INT_MAX");
1084  } else if (d == INT_MIN) {
1085  av_log(av_log_obj, level, "INT_MIN");
1086  } else if (d == UINT32_MAX) {
1087  av_log(av_log_obj, level, "UINT32_MAX");
1088  } else if (d == (double)INT64_MAX) {
1089  av_log(av_log_obj, level, "I64_MAX");
1090  } else if (d == INT64_MIN) {
1091  av_log(av_log_obj, level, "I64_MIN");
1092  } else if (d == FLT_MAX) {
1093  av_log(av_log_obj, level, "FLT_MAX");
1094  } else if (d == FLT_MIN) {
1095  av_log(av_log_obj, level, "FLT_MIN");
1096  } else if (d == -FLT_MAX) {
1097  av_log(av_log_obj, level, "-FLT_MAX");
1098  } else if (d == -FLT_MIN) {
1099  av_log(av_log_obj, level, "-FLT_MIN");
1100  } else if (d == DBL_MAX) {
1101  av_log(av_log_obj, level, "DBL_MAX");
1102  } else if (d == DBL_MIN) {
1103  av_log(av_log_obj, level, "DBL_MIN");
1104  } else if (d == -DBL_MAX) {
1105  av_log(av_log_obj, level, "-DBL_MAX");
1106  } else if (d == -DBL_MIN) {
1107  av_log(av_log_obj, level, "-DBL_MIN");
1108  } else {
1109  av_log(av_log_obj, level, "%g", d);
1110  }
1111 }
1112 
1113 static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
1114 {
1115  const AVOption *opt = NULL;
1116 
1117  if (!unit)
1118  return NULL;
1119  while ((opt = av_opt_next(obj, opt)))
1120  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1121  opt->default_val.i64 == value)
1122  return opt->name;
1123  return NULL;
1124 }
1125 
1126 static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
1127 {
1128  const AVOption *opt = NULL;
1129  char flags[512];
1130 
1131  flags[0] = 0;
1132  if (!unit)
1133  return NULL;
1134  while ((opt = av_opt_next(obj, opt))) {
1135  if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1136  opt->default_val.i64 & value) {
1137  if (flags[0])
1138  av_strlcatf(flags, sizeof(flags), "+");
1139  av_strlcatf(flags, sizeof(flags), "%s", opt->name);
1140  }
1141  }
1142  if (flags[0])
1143  return av_strdup(flags);
1144  return NULL;
1145 }
1146 
1147 static void opt_list(void *obj, void *av_log_obj, const char *unit,
1148  int req_flags, int rej_flags, enum AVOptionType parent_type)
1149 {
1150  const AVOption *opt = NULL;
1151  AVOptionRanges *r;
1152  int i;
1153 
1154  while ((opt = av_opt_next(obj, opt))) {
1155  if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
1156  continue;
1157 
1158  /* Don't print CONST's on level one.
1159  * Don't print anything but CONST's on level two.
1160  * Only print items from the requested unit.
1161  */
1162  if (!unit && opt->type == AV_OPT_TYPE_CONST)
1163  continue;
1164  else if (unit && opt->type != AV_OPT_TYPE_CONST)
1165  continue;
1166  else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
1167  continue;
1168  else if (unit && opt->type == AV_OPT_TYPE_CONST)
1169  av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
1170  else
1171  av_log(av_log_obj, AV_LOG_INFO, " %s%-17s ",
1172  (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
1173  opt->name);
1174 
1175  switch (opt->type) {
1176  case AV_OPT_TYPE_FLAGS:
1177  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
1178  break;
1179  case AV_OPT_TYPE_INT:
1180  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
1181  break;
1182  case AV_OPT_TYPE_INT64:
1183  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
1184  break;
1185  case AV_OPT_TYPE_UINT64:
1186  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<uint64>");
1187  break;
1188  case AV_OPT_TYPE_DOUBLE:
1189  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
1190  break;
1191  case AV_OPT_TYPE_FLOAT:
1192  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
1193  break;
1194  case AV_OPT_TYPE_STRING:
1195  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
1196  break;
1197  case AV_OPT_TYPE_RATIONAL:
1198  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
1199  break;
1200  case AV_OPT_TYPE_BINARY:
1201  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
1202  break;
1203  case AV_OPT_TYPE_DICT:
1204  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<dictionary>");
1205  break;
1207  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
1208  break;
1210  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
1211  break;
1212  case AV_OPT_TYPE_PIXEL_FMT:
1213  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
1214  break;
1216  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
1217  break;
1218  case AV_OPT_TYPE_DURATION:
1219  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
1220  break;
1221  case AV_OPT_TYPE_COLOR:
1222  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
1223  break;
1225  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
1226  break;
1227  case AV_OPT_TYPE_BOOL:
1228  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
1229  break;
1230  case AV_OPT_TYPE_CONST:
1231  if (parent_type == AV_OPT_TYPE_INT)
1232  av_log(av_log_obj, AV_LOG_INFO, "%-12"PRId64" ", opt->default_val.i64);
1233  else
1234  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1235  break;
1236  default:
1237  av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1238  break;
1239  }
1240  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
1241  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
1242  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
1243  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
1244  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
1245  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
1246  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
1247  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
1248  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_BSF_PARAM) ? 'B' : '.');
1249  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM) ? 'T' : '.');
1250 
1251  if (opt->help)
1252  av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
1253 
1254  if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
1255  switch (opt->type) {
1256  case AV_OPT_TYPE_INT:
1257  case AV_OPT_TYPE_INT64:
1258  case AV_OPT_TYPE_UINT64:
1259  case AV_OPT_TYPE_DOUBLE:
1260  case AV_OPT_TYPE_FLOAT:
1261  case AV_OPT_TYPE_RATIONAL:
1262  for (i = 0; i < r->nb_ranges; i++) {
1263  av_log(av_log_obj, AV_LOG_INFO, " (from ");
1264  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
1265  av_log(av_log_obj, AV_LOG_INFO, " to ");
1266  log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
1267  av_log(av_log_obj, AV_LOG_INFO, ")");
1268  }
1269  break;
1270  }
1271  av_opt_freep_ranges(&r);
1272  }
1273 
1274  if (opt->type != AV_OPT_TYPE_CONST &&
1275  opt->type != AV_OPT_TYPE_BINARY &&
1276  !((opt->type == AV_OPT_TYPE_COLOR ||
1277  opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
1278  opt->type == AV_OPT_TYPE_STRING ||
1279  opt->type == AV_OPT_TYPE_DICT ||
1280  opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
1281  !opt->default_val.str)) {
1282  av_log(av_log_obj, AV_LOG_INFO, " (default ");
1283  switch (opt->type) {
1284  case AV_OPT_TYPE_BOOL:
1285  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
1286  break;
1287  case AV_OPT_TYPE_FLAGS: {
1288  char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
1289  if (def_flags) {
1290  av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
1291  av_freep(&def_flags);
1292  } else {
1293  av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
1294  }
1295  break;
1296  }
1297  case AV_OPT_TYPE_DURATION: {
1298  char buf[25];
1299  format_duration(buf, sizeof(buf), opt->default_val.i64);
1300  av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
1301  break;
1302  }
1303  case AV_OPT_TYPE_INT:
1304  case AV_OPT_TYPE_UINT64:
1305  case AV_OPT_TYPE_INT64: {
1306  const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
1307  if (def_const)
1308  av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
1309  else
1310  log_int_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
1311  break;
1312  }
1313  case AV_OPT_TYPE_DOUBLE:
1314  case AV_OPT_TYPE_FLOAT:
1315  log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
1316  break;
1317  case AV_OPT_TYPE_RATIONAL: {
1318  AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
1319  av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
1320  break;
1321  case AV_OPT_TYPE_PIXEL_FMT:
1322  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
1323  break;
1325  av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
1326  break;
1327  case AV_OPT_TYPE_COLOR:
1329  case AV_OPT_TYPE_STRING:
1330  case AV_OPT_TYPE_DICT:
1332  av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
1333  break;
1335  av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
1336  break;
1337  }
1338  av_log(av_log_obj, AV_LOG_INFO, ")");
1339  }
1340 
1341  av_log(av_log_obj, AV_LOG_INFO, "\n");
1342  if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
1343  opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags, opt->type);
1344  }
1345 }
1346 
1347 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
1348 {
1349  if (!obj)
1350  return -1;
1351 
1352  av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
1353 
1354  opt_list(obj, av_log_obj, NULL, req_flags, rej_flags, -1);
1355 
1356  return 0;
1357 }
1358 
1360 {
1361  av_opt_set_defaults2(s, 0, 0);
1362 }
1363 
1364 void av_opt_set_defaults2(void *s, int mask, int flags)
1365 {
1366  const AVOption *opt = NULL;
1367  while ((opt = av_opt_next(s, opt))) {
1368  void *dst = ((uint8_t*)s) + opt->offset;
1369 
1370  if ((opt->flags & mask) != flags)
1371  continue;
1372 
1373  if (opt->flags & AV_OPT_FLAG_READONLY)
1374  continue;
1375 
1376  switch (opt->type) {
1377  case AV_OPT_TYPE_CONST:
1378  /* Nothing to be done here */
1379  break;
1380  case AV_OPT_TYPE_BOOL:
1381  case AV_OPT_TYPE_FLAGS:
1382  case AV_OPT_TYPE_INT:
1383  case AV_OPT_TYPE_INT64:
1384  case AV_OPT_TYPE_UINT64:
1385  case AV_OPT_TYPE_DURATION:
1387  case AV_OPT_TYPE_PIXEL_FMT:
1389  write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1390  break;
1391  case AV_OPT_TYPE_DOUBLE:
1392  case AV_OPT_TYPE_FLOAT: {
1393  double val;
1394  val = opt->default_val.dbl;
1395  write_number(s, opt, dst, val, 1, 1);
1396  }
1397  break;
1398  case AV_OPT_TYPE_RATIONAL: {
1399  AVRational val;
1400  val = av_d2q(opt->default_val.dbl, INT_MAX);
1401  write_number(s, opt, dst, 1, val.den, val.num);
1402  }
1403  break;
1404  case AV_OPT_TYPE_COLOR:
1405  set_string_color(s, opt, opt->default_val.str, dst);
1406  break;
1407  case AV_OPT_TYPE_STRING:
1408  set_string(s, opt, opt->default_val.str, dst);
1409  break;
1411  set_string_image_size(s, opt, opt->default_val.str, dst);
1412  break;
1414  set_string_video_rate(s, opt, opt->default_val.str, dst);
1415  break;
1416  case AV_OPT_TYPE_BINARY:
1417  set_string_binary(s, opt, opt->default_val.str, dst);
1418  break;
1419  case AV_OPT_TYPE_DICT:
1420  set_string_dict(s, opt, opt->default_val.str, dst);
1421  break;
1422  default:
1423  av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
1424  opt->type, opt->name);
1425  }
1426  }
1427 }
1428 
1429 /**
1430  * Store the value in the field in ctx that is named like key.
1431  * ctx must be an AVClass context, storing is done using AVOptions.
1432  *
1433  * @param buf the string to parse, buf will be updated to point at the
1434  * separator just after the parsed key/value pair
1435  * @param key_val_sep a 0-terminated list of characters used to
1436  * separate key from value
1437  * @param pairs_sep a 0-terminated list of characters used to separate
1438  * two pairs from each other
1439  * @return 0 if the key/value pair has been successfully parsed and
1440  * set, or a negative value corresponding to an AVERROR code in case
1441  * of error:
1442  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
1443  * the error code issued by av_opt_set() if the key/value pair
1444  * cannot be set
1445  */
1446 static int parse_key_value_pair(void *ctx, const char **buf,
1447  const char *key_val_sep, const char *pairs_sep)
1448 {
1449  char *key = av_get_token(buf, key_val_sep);
1450  char *val;
1451  int ret;
1452 
1453  if (!key)
1454  return AVERROR(ENOMEM);
1455 
1456  if (*key && strspn(*buf, key_val_sep)) {
1457  (*buf)++;
1458  val = av_get_token(buf, pairs_sep);
1459  if (!val) {
1460  av_freep(&key);
1461  return AVERROR(ENOMEM);
1462  }
1463  } else {
1464  av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
1465  av_free(key);
1466  return AVERROR(EINVAL);
1467  }
1468 
1469  av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1470 
1471  ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1472  if (ret == AVERROR_OPTION_NOT_FOUND)
1473  av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
1474 
1475  av_free(key);
1476  av_free(val);
1477  return ret;
1478 }
1479 
1480 int av_set_options_string(void *ctx, const char *opts,
1481  const char *key_val_sep, const char *pairs_sep)
1482 {
1483  int ret, count = 0;
1484 
1485  if (!opts)
1486  return 0;
1487 
1488  while (*opts) {
1489  if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1490  return ret;
1491  count++;
1492 
1493  if (*opts)
1494  opts++;
1495  }
1496 
1497  return count;
1498 }
1499 
1500 #define WHITESPACES " \n\t\r"
1501 
1502 static int is_key_char(char c)
1503 {
1504  return (unsigned)((c | 32) - 'a') < 26 ||
1505  (unsigned)(c - '0') < 10 ||
1506  c == '-' || c == '_' || c == '/' || c == '.';
1507 }
1508 
1509 /**
1510  * Read a key from a string.
1511  *
1512  * The key consists of is_key_char characters and must be terminated by a
1513  * character from the delim string; spaces are ignored.
1514  *
1515  * @return 0 for success (even with ellipsis), <0 for failure
1516  */
1517 static int get_key(const char **ropts, const char *delim, char **rkey)
1518 {
1519  const char *opts = *ropts;
1520  const char *key_start, *key_end;
1521 
1522  key_start = opts += strspn(opts, WHITESPACES);
1523  while (is_key_char(*opts))
1524  opts++;
1525  key_end = opts;
1526  opts += strspn(opts, WHITESPACES);
1527  if (!*opts || !strchr(delim, *opts))
1528  return AVERROR(EINVAL);
1529  opts++;
1530  if (!(*rkey = av_malloc(key_end - key_start + 1)))
1531  return AVERROR(ENOMEM);
1532  memcpy(*rkey, key_start, key_end - key_start);
1533  (*rkey)[key_end - key_start] = 0;
1534  *ropts = opts;
1535  return 0;
1536 }
1537 
1538 int av_opt_get_key_value(const char **ropts,
1539  const char *key_val_sep, const char *pairs_sep,
1540  unsigned flags,
1541  char **rkey, char **rval)
1542 {
1543  int ret;
1544  char *key = NULL, *val;
1545  const char *opts = *ropts;
1546 
1547  if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1548  !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1549  return AVERROR(EINVAL);
1550  if (!(val = av_get_token(&opts, pairs_sep))) {
1551  av_free(key);
1552  return AVERROR(ENOMEM);
1553  }
1554  *ropts = opts;
1555  *rkey = key;
1556  *rval = val;
1557  return 0;
1558 }
1559 
1560 int av_opt_set_from_string(void *ctx, const char *opts,
1561  const char *const *shorthand,
1562  const char *key_val_sep, const char *pairs_sep)
1563 {
1564  int ret, count = 0;
1565  const char *dummy_shorthand = NULL;
1566  char *av_uninit(parsed_key), *av_uninit(value);
1567  const char *key;
1568 
1569  if (!opts)
1570  return 0;
1571  if (!shorthand)
1572  shorthand = &dummy_shorthand;
1573 
1574  while (*opts) {
1575  ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1576  *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1577  &parsed_key, &value);
1578  if (ret < 0) {
1579  if (ret == AVERROR(EINVAL))
1580  av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1581  else
1582  av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
1583  av_err2str(ret));
1584  return ret;
1585  }
1586  if (*opts)
1587  opts++;
1588  if (parsed_key) {
1589  key = parsed_key;
1590  while (*shorthand) /* discard all remaining shorthand */
1591  shorthand++;
1592  } else {
1593  key = *(shorthand++);
1594  }
1595 
1596  av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
1597  if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1598  if (ret == AVERROR_OPTION_NOT_FOUND)
1599  av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1600  av_free(value);
1601  av_free(parsed_key);
1602  return ret;
1603  }
1604 
1605  av_free(value);
1606  av_free(parsed_key);
1607  count++;
1608  }
1609  return count;
1610 }
1611 
1612 void av_opt_free(void *obj)
1613 {
1614  const AVOption *o = NULL;
1615  while ((o = av_opt_next(obj, o))) {
1616  switch (o->type) {
1617  case AV_OPT_TYPE_STRING:
1618  case AV_OPT_TYPE_BINARY:
1619  av_freep((uint8_t *)obj + o->offset);
1620  break;
1621 
1622  case AV_OPT_TYPE_DICT:
1623  av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
1624  break;
1625 
1626  default:
1627  break;
1628  }
1629  }
1630 }
1631 
1632 int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
1633 {
1634  AVDictionaryEntry *t = NULL;
1635  AVDictionary *tmp = NULL;
1636  int ret = 0;
1637 
1638  if (!options)
1639  return 0;
1640 
1641  while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1642  ret = av_opt_set(obj, t->key, t->value, search_flags);
1643  if (ret == AVERROR_OPTION_NOT_FOUND)
1644  ret = av_dict_set(&tmp, t->key, t->value, 0);
1645  if (ret < 0) {
1646  av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
1647  av_dict_free(&tmp);
1648  return ret;
1649  }
1650  ret = 0;
1651  }
1652  av_dict_free(options);
1653  *options = tmp;
1654  return ret;
1655 }
1656 
1658 {
1659  return av_opt_set_dict2(obj, options, 0);
1660 }
1661 
1662 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
1663  int opt_flags, int search_flags)
1664 {
1665  return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
1666 }
1667 
1668 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
1669  int opt_flags, int search_flags, void **target_obj)
1670 {
1671  const AVClass *c;
1672  const AVOption *o = NULL;
1673 
1674  if(!obj)
1675  return NULL;
1676 
1677  c= *(AVClass**)obj;
1678 
1679  if (!c)
1680  return NULL;
1681 
1682  if (search_flags & AV_OPT_SEARCH_CHILDREN) {
1683  if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
1684  const AVClass *child = NULL;
1685  while (child = av_opt_child_class_next(c, child))
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 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
1721 {
1722  if (parent->child_class_next)
1723  return parent->child_class_next(prev);
1724  return NULL;
1725 }
1726 
1727 void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
1728 {
1729  const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1730  if(!opt)
1731  return NULL;
1732  return (uint8_t*)obj + opt->offset;
1733 }
1734 
1735 static int opt_size(enum AVOptionType type)
1736 {
1737  switch(type) {
1738  case AV_OPT_TYPE_BOOL:
1739  case AV_OPT_TYPE_INT:
1740  case AV_OPT_TYPE_FLAGS:
1741  return sizeof(int);
1742  case AV_OPT_TYPE_DURATION:
1744  case AV_OPT_TYPE_INT64:
1745  case AV_OPT_TYPE_UINT64:
1746  return sizeof(int64_t);
1747  case AV_OPT_TYPE_DOUBLE:
1748  return sizeof(double);
1749  case AV_OPT_TYPE_FLOAT:
1750  return sizeof(float);
1751  case AV_OPT_TYPE_STRING:
1752  return sizeof(uint8_t*);
1754  case AV_OPT_TYPE_RATIONAL:
1755  return sizeof(AVRational);
1756  case AV_OPT_TYPE_BINARY:
1757  return sizeof(uint8_t*) + sizeof(int);
1759  return sizeof(int[2]);
1760  case AV_OPT_TYPE_PIXEL_FMT:
1761  return sizeof(enum AVPixelFormat);
1763  return sizeof(enum AVSampleFormat);
1764  case AV_OPT_TYPE_COLOR:
1765  return 4;
1766  }
1767  return AVERROR(EINVAL);
1768 }
1769 
1770 int av_opt_copy(void *dst, const void *src)
1771 {
1772  const AVOption *o = NULL;
1773  const AVClass *c;
1774  int ret = 0;
1775 
1776  if (!src)
1777  return AVERROR(EINVAL);
1778 
1779  c = *(AVClass **)src;
1780  if (!c || c != *(AVClass **)dst)
1781  return AVERROR(EINVAL);
1782 
1783  while ((o = av_opt_next(src, o))) {
1784  void *field_dst = (uint8_t *)dst + o->offset;
1785  void *field_src = (uint8_t *)src + o->offset;
1786  uint8_t **field_dst8 = (uint8_t **)field_dst;
1787  uint8_t **field_src8 = (uint8_t **)field_src;
1788 
1789  if (o->type == AV_OPT_TYPE_STRING) {
1790  if (*field_dst8 != *field_src8)
1791  av_freep(field_dst8);
1792  *field_dst8 = av_strdup(*field_src8);
1793  if (*field_src8 && !*field_dst8)
1794  ret = AVERROR(ENOMEM);
1795  } else if (o->type == AV_OPT_TYPE_BINARY) {
1796  int len = *(int *)(field_src8 + 1);
1797  if (*field_dst8 != *field_src8)
1798  av_freep(field_dst8);
1799  *field_dst8 = av_memdup(*field_src8, len);
1800  if (len && !*field_dst8) {
1801  ret = AVERROR(ENOMEM);
1802  len = 0;
1803  }
1804  *(int *)(field_dst8 + 1) = len;
1805  } else if (o->type == AV_OPT_TYPE_CONST) {
1806  // do nothing
1807  } else if (o->type == AV_OPT_TYPE_DICT) {
1808  AVDictionary **sdict = (AVDictionary **) field_src;
1809  AVDictionary **ddict = (AVDictionary **) field_dst;
1810  if (*sdict != *ddict)
1811  av_dict_free(ddict);
1812  *ddict = NULL;
1813  av_dict_copy(ddict, *sdict, 0);
1814  if (av_dict_count(*sdict) != av_dict_count(*ddict))
1815  ret = AVERROR(ENOMEM);
1816  } else {
1817  int size = opt_size(o->type);
1818  if (size < 0)
1819  ret = size;
1820  else
1821  memcpy(field_dst, field_src, size);
1822  }
1823  }
1824  return ret;
1825 }
1826 
1827 int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1828 {
1829  int ret;
1830  const AVClass *c = *(AVClass**)obj;
1831  int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
1832 
1833  if (c->version > (52 << 16 | 11 << 8))
1834  callback = c->query_ranges;
1835 
1836  if (!callback)
1838 
1839  ret = callback(ranges_arg, obj, key, flags);
1840  if (ret >= 0) {
1841  if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
1842  ret = 1;
1843  (*ranges_arg)->nb_components = ret;
1844  }
1845  return ret;
1846 }
1847 
1848 int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1849 {
1850  AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
1851  AVOptionRange **range_array = av_mallocz(sizeof(void*));
1852  AVOptionRange *range = av_mallocz(sizeof(*range));
1853  const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1854  int ret;
1855 
1856  *ranges_arg = NULL;
1857 
1858  if (!ranges || !range || !range_array || !field) {
1859  ret = AVERROR(ENOMEM);
1860  goto fail;
1861  }
1862 
1863  ranges->range = range_array;
1864  ranges->range[0] = range;
1865  ranges->nb_ranges = 1;
1866  ranges->nb_components = 1;
1867  range->is_range = 1;
1868  range->value_min = field->min;
1869  range->value_max = field->max;
1870 
1871  switch (field->type) {
1872  case AV_OPT_TYPE_BOOL:
1873  case AV_OPT_TYPE_INT:
1874  case AV_OPT_TYPE_INT64:
1875  case AV_OPT_TYPE_UINT64:
1876  case AV_OPT_TYPE_PIXEL_FMT:
1878  case AV_OPT_TYPE_FLOAT:
1879  case AV_OPT_TYPE_DOUBLE:
1880  case AV_OPT_TYPE_DURATION:
1881  case AV_OPT_TYPE_COLOR:
1883  break;
1884  case AV_OPT_TYPE_STRING:
1885  range->component_min = 0;
1886  range->component_max = 0x10FFFF; // max unicode value
1887  range->value_min = -1;
1888  range->value_max = INT_MAX;
1889  break;
1890  case AV_OPT_TYPE_RATIONAL:
1891  range->component_min = INT_MIN;
1892  range->component_max = INT_MAX;
1893  break;
1895  range->component_min = 0;
1896  range->component_max = INT_MAX/128/8;
1897  range->value_min = 0;
1898  range->value_max = INT_MAX/8;
1899  break;
1901  range->component_min = 1;
1902  range->component_max = INT_MAX;
1903  range->value_min = 1;
1904  range->value_max = INT_MAX;
1905  break;
1906  default:
1907  ret = AVERROR(ENOSYS);
1908  goto fail;
1909  }
1910 
1911  *ranges_arg = ranges;
1912  return 1;
1913 fail:
1914  av_free(ranges);
1915  av_free(range);
1916  av_free(range_array);
1917  return ret;
1918 }
1919 
1921 {
1922  int i;
1923  AVOptionRanges *ranges = *rangesp;
1924 
1925  if (!ranges)
1926  return;
1927 
1928  for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
1929  AVOptionRange *range = ranges->range[i];
1930  if (range) {
1931  av_freep(&range->str);
1932  av_freep(&ranges->range[i]);
1933  }
1934  }
1935  av_freep(&ranges->range);
1936  av_freep(rangesp);
1937 }
1938 
1939 int av_opt_is_set_to_default(void *obj, const AVOption *o)
1940 {
1941  int64_t i64;
1942  double d, d2;
1943  float f;
1944  AVRational q;
1945  int ret, w, h;
1946  char *str;
1947  void *dst;
1948 
1949  if (!o || !obj)
1950  return AVERROR(EINVAL);
1951 
1952  dst = ((uint8_t*)obj) + o->offset;
1953 
1954  switch (o->type) {
1955  case AV_OPT_TYPE_CONST:
1956  return 1;
1957  case AV_OPT_TYPE_BOOL:
1958  case AV_OPT_TYPE_FLAGS:
1959  case AV_OPT_TYPE_PIXEL_FMT:
1961  case AV_OPT_TYPE_INT:
1963  case AV_OPT_TYPE_DURATION:
1964  case AV_OPT_TYPE_INT64:
1965  case AV_OPT_TYPE_UINT64:
1966  read_number(o, dst, NULL, NULL, &i64);
1967  return o->default_val.i64 == i64;
1968  case AV_OPT_TYPE_STRING:
1969  str = *(char **)dst;
1970  if (str == o->default_val.str) //2 NULLs
1971  return 1;
1972  if (!str || !o->default_val.str) //1 NULL
1973  return 0;
1974  return !strcmp(str, o->default_val.str);
1975  case AV_OPT_TYPE_DOUBLE:
1976  read_number(o, dst, &d, NULL, NULL);
1977  return o->default_val.dbl == d;
1978  case AV_OPT_TYPE_FLOAT:
1979  read_number(o, dst, &d, NULL, NULL);
1980  f = o->default_val.dbl;
1981  d2 = f;
1982  return d2 == d;
1983  case AV_OPT_TYPE_RATIONAL:
1984  q = av_d2q(o->default_val.dbl, INT_MAX);
1985  return !av_cmp_q(*(AVRational*)dst, q);
1986  case AV_OPT_TYPE_BINARY: {
1987  struct {
1988  uint8_t *data;
1989  int size;
1990  } tmp = {0};
1991  int opt_size = *(int *)((void **)dst + 1);
1992  void *opt_ptr = *(void **)dst;
1993  if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
1994  return 1;
1995  if (!opt_size || !o->default_val.str || !strlen(o->default_val.str ))
1996  return 0;
1997  if (opt_size != strlen(o->default_val.str) / 2)
1998  return 0;
1999  ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
2000  if (!ret)
2001  ret = !memcmp(opt_ptr, tmp.data, tmp.size);
2002  av_free(tmp.data);
2003  return ret;
2004  }
2005  case AV_OPT_TYPE_DICT: {
2006  AVDictionary *dict1 = NULL;
2007  AVDictionary *dict2 = *(AVDictionary **)dst;
2008  AVDictionaryEntry *en1 = NULL;
2009  AVDictionaryEntry *en2 = NULL;
2010  ret = av_dict_parse_string(&dict1, o->default_val.str, "=", ":", 0);
2011  if (ret < 0) {
2012  av_dict_free(&dict1);
2013  return ret;
2014  }
2015  do {
2016  en1 = av_dict_get(dict1, "", en1, AV_DICT_IGNORE_SUFFIX);
2017  en2 = av_dict_get(dict2, "", en2, AV_DICT_IGNORE_SUFFIX);
2018  } while (en1 && en2 && !strcmp(en1->key, en2->key) && !strcmp(en1->value, en2->value));
2019  av_dict_free(&dict1);
2020  return (!en1 && !en2);
2021  }
2023  if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
2024  w = h = 0;
2025  else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
2026  return ret;
2027  return (w == *(int *)dst) && (h == *((int *)dst+1));
2029  q = (AVRational){0, 0};
2030  if (o->default_val.str) {
2031  if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
2032  return ret;
2033  }
2034  return !av_cmp_q(*(AVRational*)dst, q);
2035  case AV_OPT_TYPE_COLOR: {
2036  uint8_t color[4] = {0, 0, 0, 0};
2037  if (o->default_val.str) {
2038  if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
2039  return ret;
2040  }
2041  return !memcmp(color, dst, sizeof(color));
2042  }
2043  default:
2044  av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
2045  break;
2046  }
2047  return AVERROR_PATCHWELCOME;
2048 }
2049 
2050 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
2051 {
2052  const AVOption *o;
2053  void *target;
2054  if (!obj)
2055  return AVERROR(EINVAL);
2056  o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
2057  if (!o)
2058  return AVERROR_OPTION_NOT_FOUND;
2059  return av_opt_is_set_to_default(target, o);
2060 }
2061 
2062 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
2063  const char key_val_sep, const char pairs_sep)
2064 {
2065  const AVOption *o = NULL;
2066  uint8_t *buf;
2067  AVBPrint bprint;
2068  int ret, cnt = 0;
2069  const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
2070 
2071  if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
2072  pairs_sep == '\\' || key_val_sep == '\\') {
2073  av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
2074  return AVERROR(EINVAL);
2075  }
2076 
2077  if (!obj || !buffer)
2078  return AVERROR(EINVAL);
2079 
2080  *buffer = NULL;
2082 
2083  while (o = av_opt_next(obj, o)) {
2084  if (o->type == AV_OPT_TYPE_CONST)
2085  continue;
2086  if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
2087  continue;
2088  else if (((o->flags & opt_flags) != opt_flags))
2089  continue;
2090  if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
2091  continue;
2092  if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
2093  av_bprint_finalize(&bprint, NULL);
2094  return ret;
2095  }
2096  if (buf) {
2097  if (cnt++)
2098  av_bprint_append_data(&bprint, &pairs_sep, 1);
2099  av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2100  av_bprint_append_data(&bprint, &key_val_sep, 1);
2101  av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2102  av_freep(&buf);
2103  }
2104  }
2105  av_bprint_finalize(&bprint, buffer);
2106  return 0;
2107 }
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1033
#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:1126
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:598
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: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
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:1517
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:1720
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1359
static int opt_size(enum AVOptionType type)
Definition: opt.c:1735
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:1480
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:449
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:603
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:938
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:2062
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:727
#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:2050
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:1939
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:972
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:1560
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:988
Public dictionary API.
const char * name
Definition: opt.h:247
#define WHITESPACES
Definition: opt.c:1500
uint8_t
AVOptionRange ** range
Array of option ranges.
Definition: opt.h:361
#define av_malloc(s)
class_name
Definition: libkvazaar.c:289
const char * help
short English help text
Definition: opt.h:253
AVOptions.
union AVOption::@313 default_val
the default value for scalar options
#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:1147
static const char * get_opt_const_name(void *obj, const char *unit, int64_t value)
Definition: opt.c:1113
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:593
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:894
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:655
#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:1063
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:1006
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
#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:701
#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:1727
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:588
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:350
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
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:1662
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:1011
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:1446
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:711
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:1364
#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:1632
#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:1848
#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_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:914
static void log_value(void *av_log_obj, int level, double d)
Definition: opt.c:1080
#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:672
void av_opt_freep_ranges(AVOptionRanges **rangesp)
Free an AVOptionRanges struct and set it to NULL.
Definition: opt.c:1920
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:1657
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum, int search_flags)
Definition: opt.c:572
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1347
#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:746
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:556
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:1016
#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
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:530
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:1612
const OptionDef options[]
Definition: ffmpeg_opt.c:3374
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:1827
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:926
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:1770
#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:781
#define av_free(p)
#define AV_OPT_SERIALIZE_SKIP_DEFAULTS
Serialize options that are not set to default values only.
Definition: opt.h:844
#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:1538
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:1050
#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:845
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:1668
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:706
#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:633
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:467
static int is_key_char(char c)
Definition: opt.c:1502
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:954
static uint8_t tmp[11]
Definition: aes_ctr.c:26