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