FFmpeg: libavutil/opt.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /