Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "avutil.h"
29 #include "avstring.h"
30 #include "common.h"
31 #include "opt.h"
32 #include "eval.h"
33 #include "dict.h"
34 #include "log.h"
35 #include "mathematics.h"
36 
37 const AVOption *av_opt_next(void *obj, const AVOption *last)
38 {
39  AVClass *class = *(AVClass**)obj;
40  if (!last && class->option && class->option[0].name)
41  return class->option;
42  if (last && last[1].name)
43  return ++last;
44  return NULL;
45 }
46 
47 static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
48 {
49  switch (o->type) {
50  case AV_OPT_TYPE_FLAGS: *intnum = *(unsigned int*)dst;return 0;
51  case AV_OPT_TYPE_INT: *intnum = *(int *)dst;return 0;
52  case AV_OPT_TYPE_INT64: *intnum = *(int64_t *)dst;return 0;
53  case AV_OPT_TYPE_FLOAT: *num = *(float *)dst;return 0;
54  case AV_OPT_TYPE_DOUBLE: *num = *(double *)dst;return 0;
55  case AV_OPT_TYPE_RATIONAL: *intnum = ((AVRational*)dst)->num;
56  *den = ((AVRational*)dst)->den;
57  return 0;
58  }
59  return AVERROR(EINVAL);
60 }
61 
62 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
63 {
64  if (o->type != AV_OPT_TYPE_FLAGS &&
65  (o->max * den < num * intnum || o->min * den > num * intnum)) {
66  av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range\n",
67  num*intnum/den, o->name);
68  return AVERROR(ERANGE);
69  }
70 
71  switch (o->type) {
72  case AV_OPT_TYPE_FLAGS:
73  case AV_OPT_TYPE_INT: *(int *)dst= llrint(num/den)*intnum; break;
74  case AV_OPT_TYPE_INT64: *(int64_t *)dst= llrint(num/den)*intnum; break;
75  case AV_OPT_TYPE_FLOAT: *(float *)dst= num*intnum/den; break;
76  case AV_OPT_TYPE_DOUBLE:*(double *)dst= num*intnum/den; break;
78  if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
79  else *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
80  break;
81  default:
82  return AVERROR(EINVAL);
83  }
84  return 0;
85 }
86 
87 static const double const_values[] = {
88  M_PI,
89  M_E,
91  0
92 };
93 
94 static const char * const const_names[] = {
95  "PI",
96  "E",
97  "QP2LAMBDA",
98  0
99 };
100 
101 static int hexchar2int(char c) {
102  if (c >= '0' && c <= '9') return c - '0';
103  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
104  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
105  return -1;
106 }
107 
108 static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
109 {
110  int *lendst = (int *)(dst + 1);
111  uint8_t *bin, *ptr;
112  int len = strlen(val);
113 
114  av_freep(dst);
115  *lendst = 0;
116 
117  if (len & 1)
118  return AVERROR(EINVAL);
119  len /= 2;
120 
121  ptr = bin = av_malloc(len);
122  while (*val) {
123  int a = hexchar2int(*val++);
124  int b = hexchar2int(*val++);
125  if (a < 0 || b < 0) {
126  av_free(bin);
127  return AVERROR(EINVAL);
128  }
129  *ptr++ = (a << 4) | b;
130  }
131  *dst = bin;
132  *lendst = len;
133 
134  return 0;
135 }
136 
137 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
138 {
139  av_freep(dst);
140  *dst = av_strdup(val);
141  return 0;
142 }
143 
144 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
145  opt->type == AV_OPT_TYPE_CONST || \
146  opt->type == AV_OPT_TYPE_FLAGS || \
147  opt->type == AV_OPT_TYPE_INT) ? \
148  opt->default_val.i64 : opt->default_val.dbl)
149 
150 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
151 {
152  int ret = 0, notfirst = 0;
153  for (;;) {
154  int i, den = 1;
155  char buf[256];
156  int cmd = 0;
157  double d, num = 1;
158  int64_t intnum = 1;
159 
160  i = 0;
161  if (*val == '+' || *val == '-') {
162  if (o->type == AV_OPT_TYPE_FLAGS)
163  cmd = *(val++);
164  else if (!notfirst)
165  buf[i++] = *val;
166  }
167 
168  for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
169  buf[i] = val[i];
170  buf[i] = 0;
171 
172  {
173  const AVOption *o_named = av_opt_find(target_obj, buf, o->unit, 0, 0);
174  if (o_named && o_named->type == AV_OPT_TYPE_CONST)
175  d = DEFAULT_NUMVAL(o_named);
176  else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
177  else if (!strcmp(buf, "max" )) d = o->max;
178  else if (!strcmp(buf, "min" )) d = o->min;
179  else if (!strcmp(buf, "none" )) d = 0;
180  else if (!strcmp(buf, "all" )) d = ~0;
181  else {
182  int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
183  if (res < 0) {
184  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
185  return res;
186  }
187  }
188  }
189  if (o->type == AV_OPT_TYPE_FLAGS) {
190  read_number(o, dst, NULL, NULL, &intnum);
191  if (cmd == '+') d = intnum | (int64_t)d;
192  else if (cmd == '-') d = intnum &~(int64_t)d;
193  } else {
194  read_number(o, dst, &num, &den, &intnum);
195  if (cmd == '+') d = notfirst*num*intnum/den + d;
196  else if (cmd == '-') d = notfirst*num*intnum/den - d;
197  }
198 
199  if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
200  return ret;
201  val += i;
202  if (!*val)
203  return 0;
204  notfirst = 1;
205  }
206 
207  return 0;
208 }
209 
210 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
211 {
212  void *dst, *target_obj;
213  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
214  if (!o || !target_obj)
216  if (!val || o->flags & AV_OPT_FLAG_READONLY)
217  return AVERROR(EINVAL);
218 
219  dst = ((uint8_t*)target_obj) + o->offset;
220  switch (o->type) {
221  case AV_OPT_TYPE_STRING: return set_string(obj, o, val, dst);
222  case AV_OPT_TYPE_BINARY: return set_string_binary(obj, o, val, dst);
223  case AV_OPT_TYPE_FLAGS:
224  case AV_OPT_TYPE_INT:
225  case AV_OPT_TYPE_INT64:
226  case AV_OPT_TYPE_FLOAT:
227  case AV_OPT_TYPE_DOUBLE:
228  case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, target_obj, o, val, dst);
229  }
230 
231  av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
232  return AVERROR(EINVAL);
233 }
234 
235 #define OPT_EVAL_NUMBER(name, opttype, vartype)\
236  int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
237  {\
238  if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)\
239  return AVERROR(EINVAL);\
240  return set_string_number(obj, obj, o, val, name ## _out);\
241  }
242 
245 OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
246 OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
247 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
249 
250 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
251  int search_flags)
252 {
253  void *dst, *target_obj;
254  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
255 
256  if (!o || !target_obj)
258 
259  if (o->flags & AV_OPT_FLAG_READONLY)
260  return AVERROR(EINVAL);
261 
262  dst = ((uint8_t*)target_obj) + o->offset;
263  return write_number(obj, o, dst, num, den, intnum);
264 }
265 
266 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
267 {
268  return set_number(obj, name, 1, 1, val, search_flags);
269 }
270 
271 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
272 {
273  return set_number(obj, name, val, 1, 1, search_flags);
274 }
275 
276 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
277 {
278  return set_number(obj, name, val.num, val.den, 1, search_flags);
279 }
280 
281 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
282 {
283  void *target_obj;
284  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
285  uint8_t *ptr;
286  uint8_t **dst;
287  int *lendst;
288 
289  if (!o || !target_obj)
291 
293  return AVERROR(EINVAL);
294 
295  ptr = av_malloc(len);
296  if (!ptr)
297  return AVERROR(ENOMEM);
298 
299  dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
300  lendst = (int *)(dst + 1);
301 
302  av_free(*dst);
303  *dst = ptr;
304  *lendst = len;
305  memcpy(ptr, val, len);
306 
307  return 0;
308 }
309 
310 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
311 {
312  void *target_obj;
313  AVDictionary **dst;
314  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
315 
316  if (!o || !target_obj)
318  if (o->flags & AV_OPT_FLAG_READONLY)
319  return AVERROR(EINVAL);
320 
321  dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
322  av_dict_free(dst);
323  av_dict_copy(dst, val, 0);
324 
325  return 0;
326 }
327 
328 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
329 {
330  void *dst, *target_obj;
331  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
332  uint8_t *bin, buf[128];
333  int len, i, ret;
334 
335  if (!o || !target_obj)
337 
338  dst = (uint8_t*)target_obj + o->offset;
339 
340  buf[0] = 0;
341  switch (o->type) {
342  case AV_OPT_TYPE_FLAGS: ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);break;
343  case AV_OPT_TYPE_INT: ret = snprintf(buf, sizeof(buf), "%d" , *(int *)dst);break;
344  case AV_OPT_TYPE_INT64: ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
345  case AV_OPT_TYPE_FLOAT: ret = snprintf(buf, sizeof(buf), "%f" , *(float *)dst);break;
346  case AV_OPT_TYPE_DOUBLE: ret = snprintf(buf, sizeof(buf), "%f" , *(double *)dst);break;
347  case AV_OPT_TYPE_RATIONAL: ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
348  case AV_OPT_TYPE_STRING:
349  if (*(uint8_t**)dst)
350  *out_val = av_strdup(*(uint8_t**)dst);
351  else
352  *out_val = av_strdup("");
353  return 0;
354  case AV_OPT_TYPE_BINARY:
355  len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
356  if ((uint64_t)len*2 + 1 > INT_MAX)
357  return AVERROR(EINVAL);
358  if (!(*out_val = av_malloc(len*2 + 1)))
359  return AVERROR(ENOMEM);
360  bin = *(uint8_t**)dst;
361  for (i = 0; i < len; i++)
362  snprintf(*out_val + i*2, 3, "%02X", bin[i]);
363  return 0;
364  default:
365  return AVERROR(EINVAL);
366  }
367 
368  if (ret >= sizeof(buf))
369  return AVERROR(EINVAL);
370  *out_val = av_strdup(buf);
371  return 0;
372 }
373 
374 static int get_number(void *obj, const char *name, double *num, int *den, int64_t *intnum,
375  int search_flags)
376 {
377  void *dst, *target_obj;
378  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
379  if (!o || !target_obj)
380  goto error;
381 
382  dst = ((uint8_t*)target_obj) + o->offset;
383 
384  return read_number(o, dst, num, den, intnum);
385 
386 error:
387  *den=*intnum=0;
388  return -1;
389 }
390 
391 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
392 {
393  int64_t intnum = 1;
394  double num = 1;
395  int ret, den = 1;
396 
397  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
398  return ret;
399  *out_val = num*intnum/den;
400  return 0;
401 }
402 
403 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
404 {
405  int64_t intnum = 1;
406  double num = 1;
407  int ret, den = 1;
408 
409  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
410  return ret;
411  *out_val = num*intnum/den;
412  return 0;
413 }
414 
415 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
416 {
417  int64_t intnum = 1;
418  double num = 1;
419  int ret, den = 1;
420 
421  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
422  return ret;
423 
424  if (num == 1.0 && (int)intnum == intnum)
425  *out_val = (AVRational){intnum, den};
426  else
427  *out_val = av_d2q(num*intnum/den, 1<<24);
428  return 0;
429 }
430 
431 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
432 {
433  void *target_obj;
434  AVDictionary *src;
435  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
436 
437  if (!o || !target_obj)
439  if (o->type != AV_OPT_TYPE_DICT)
440  return AVERROR(EINVAL);
441 
442  src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
443  av_dict_copy(out_val, src, 0);
444 
445  return 0;
446 }
447 
448 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
449 {
450  const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
451  const AVOption *flag = av_opt_find(obj, flag_name,
452  field ? field->unit : NULL, 0, 0);
453  int64_t res;
454 
455  if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
456  av_opt_get_int(obj, field_name, 0, &res) < 0)
457  return 0;
458  return res & flag->default_val.i64;
459 }
460 
461 static void opt_list(void *obj, void *av_log_obj, const char *unit,
462  int req_flags, int rej_flags)
463 {
464  const AVOption *opt=NULL;
465 
466  while ((opt = av_opt_next(obj, opt))) {
467  if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
468  continue;
469 
470  /* Don't print CONST's on level one.
471  * Don't print anything but CONST's on level two.
472  * Only print items from the requested unit.
473  */
474  if (!unit && opt->type==AV_OPT_TYPE_CONST)
475  continue;
476  else if (unit && opt->type!=AV_OPT_TYPE_CONST)
477  continue;
478  else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
479  continue;
480  else if (unit && opt->type == AV_OPT_TYPE_CONST)
481  av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
482  else
483  av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
484 
485  switch (opt->type) {
486  case AV_OPT_TYPE_FLAGS:
487  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
488  break;
489  case AV_OPT_TYPE_INT:
490  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
491  break;
492  case AV_OPT_TYPE_INT64:
493  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
494  break;
495  case AV_OPT_TYPE_DOUBLE:
496  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
497  break;
498  case AV_OPT_TYPE_FLOAT:
499  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
500  break;
501  case AV_OPT_TYPE_STRING:
502  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
503  break;
505  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
506  break;
507  case AV_OPT_TYPE_BINARY:
508  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
509  break;
510  case AV_OPT_TYPE_CONST:
511  default:
512  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
513  break;
514  }
515  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
516  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
517  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
518  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
519  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
520  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
521  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
522 
523  if (opt->help)
524  av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
525  av_log(av_log_obj, AV_LOG_INFO, "\n");
526  if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
527  opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
528  }
529  }
530 }
531 
532 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
533 {
534  if (!obj)
535  return -1;
536 
537  av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
538 
539  opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
540 
541  return 0;
542 }
543 
544 void av_opt_set_defaults(void *s)
545 {
546  const AVOption *opt = NULL;
547  while ((opt = av_opt_next(s, opt))) {
548  if (opt->flags & AV_OPT_FLAG_READONLY)
549  continue;
550 
551  switch (opt->type) {
552  case AV_OPT_TYPE_CONST:
553  /* Nothing to be done here */
554  break;
555  case AV_OPT_TYPE_FLAGS:
556  case AV_OPT_TYPE_INT:
557  case AV_OPT_TYPE_INT64:
558  av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
559  break;
560  case AV_OPT_TYPE_DOUBLE:
561  case AV_OPT_TYPE_FLOAT: {
562  double val;
563  val = opt->default_val.dbl;
564  av_opt_set_double(s, opt->name, val, 0);
565  }
566  break;
567  case AV_OPT_TYPE_RATIONAL: {
568  AVRational val;
569  val = av_d2q(opt->default_val.dbl, INT_MAX);
570  av_opt_set_q(s, opt->name, val, 0);
571  }
572  break;
573  case AV_OPT_TYPE_STRING:
574  av_opt_set(s, opt->name, opt->default_val.str, 0);
575  break;
576  case AV_OPT_TYPE_BINARY:
577  case AV_OPT_TYPE_DICT:
578  /* Cannot set defaults for these types */
579  break;
580  default:
581  av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
582  }
583  }
584 }
585 
603 static int parse_key_value_pair(void *ctx, const char **buf,
604  const char *key_val_sep, const char *pairs_sep)
605 {
606  char *key = av_get_token(buf, key_val_sep);
607  char *val;
608  int ret;
609 
610  if (!key)
611  return AVERROR(ENOMEM);
612 
613  if (*key && strspn(*buf, key_val_sep)) {
614  (*buf)++;
615  val = av_get_token(buf, pairs_sep);
616  if (!val) {
617  av_freep(&key);
618  return AVERROR(ENOMEM);
619  }
620  } else {
621  av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
622  av_free(key);
623  return AVERROR(EINVAL);
624  }
625 
626  av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
627 
628  ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
629  if (ret == AVERROR_OPTION_NOT_FOUND)
630  av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
631 
632  av_free(key);
633  av_free(val);
634  return ret;
635 }
636 
637 int av_set_options_string(void *ctx, const char *opts,
638  const char *key_val_sep, const char *pairs_sep)
639 {
640  int ret, count = 0;
641 
642  if (!opts)
643  return 0;
644 
645  while (*opts) {
646  if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
647  return ret;
648  count++;
649 
650  if (*opts)
651  opts++;
652  }
653 
654  return count;
655 }
656 
657 void av_opt_free(void *obj)
658 {
659  const AVOption *o = NULL;
660  while ((o = av_opt_next(obj, o))) {
661  switch (o->type) {
662  case AV_OPT_TYPE_STRING:
663  case AV_OPT_TYPE_BINARY:
664  av_freep((uint8_t *)obj + o->offset);
665  break;
666 
667  case AV_OPT_TYPE_DICT:
668  av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
669  break;
670 
671  default:
672  break;
673  }
674  }
675 }
676 
678 {
679  AVDictionaryEntry *t = NULL;
680  AVDictionary *tmp = NULL;
681  int ret = 0;
682 
683  while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
684  ret = av_opt_set(obj, t->key, t->value, 0);
685  if (ret == AVERROR_OPTION_NOT_FOUND)
686  av_dict_set(&tmp, t->key, t->value, 0);
687  else if (ret < 0) {
688  av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
689  break;
690  }
691  ret = 0;
692  }
693  av_dict_free(options);
694  *options = tmp;
695  return ret;
696 }
697 
698 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
699  int opt_flags, int search_flags)
700 {
701  return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
702 }
703 
704 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
705  int opt_flags, int search_flags, void **target_obj)
706 {
707  const AVClass *c = *(AVClass**)obj;
708  const AVOption *o = NULL;
709 
710  if (!c)
711  return NULL;
712 
713  if (search_flags & AV_OPT_SEARCH_CHILDREN) {
714  if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
715  const AVClass *child = NULL;
716  while (child = av_opt_child_class_next(c, child))
717  if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
718  return o;
719  } else {
720  void *child = NULL;
721  while (child = av_opt_child_next(obj, child))
722  if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
723  return o;
724  }
725  }
726 
727  while (o = av_opt_next(obj, o)) {
728  if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
729  ((!unit && o->type != AV_OPT_TYPE_CONST) ||
730  (unit && o->unit && !strcmp(o->unit, unit)))) {
731  if (target_obj) {
732  if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
733  *target_obj = obj;
734  else
735  *target_obj = NULL;
736  }
737  return o;
738  }
739  }
740  return NULL;
741 }
742 
743 void *av_opt_child_next(void *obj, void *prev)
744 {
745  const AVClass *c = *(AVClass**)obj;
746  if (c->child_next)
747  return c->child_next(obj, prev);
748  return NULL;
749 }
750 
751 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
752 {
753  if (parent->child_class_next)
754  return parent->child_class_next(prev);
755  return NULL;
756 }
757 
758 #ifdef TEST
759 
760 typedef struct TestContext
761 {
762  const AVClass *class;
763  int num;
764  int toggle;
765  char *string;
766  int flags;
767  AVRational rational;
768 } TestContext;
769 
770 #define OFFSET(x) offsetof(TestContext, x)
771 
772 #define TEST_FLAG_COOL 01
773 #define TEST_FLAG_LAME 02
774 #define TEST_FLAG_MU 04
775 
776 static const AVOption test_options[]= {
777 {"num", "set num", OFFSET(num), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 100 },
778 {"toggle", "set toggle", OFFSET(toggle), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1 },
779 {"rational", "set rational", OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10 },
780 {"string", "set string", OFFSET(string), AV_OPT_TYPE_STRING, {0}, CHAR_MIN, CHAR_MAX },
781 {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, 0, "flags" },
782 {"cool", "set cool flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_COOL}, INT_MIN, INT_MAX, 0, "flags" },
783 {"lame", "set lame flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_LAME}, INT_MIN, INT_MAX, 0, "flags" },
784 {"mu", "set mu flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_MU}, INT_MIN, INT_MAX, 0, "flags" },
785 {NULL},
786 };
787 
788 static const char *test_get_name(void *ctx)
789 {
790  return "test";
791 }
792 
793 static const AVClass test_class = {
794  "TestContext",
795  test_get_name,
796  test_options
797 };
798 
799 int main(void)
800 {
801  int i;
802 
803  printf("\nTesting av_set_options_string()\n");
804  {
805  TestContext test_ctx;
806  const char *options[] = {
807  "",
808  ":",
809  "=",
810  "foo=:",
811  ":=foo",
812  "=foo",
813  "foo=",
814  "foo",
815  "foo=val",
816  "foo==val",
817  "toggle=:",
818  "string=:",
819  "toggle=1 : foo",
820  "toggle=100",
821  "toggle==1",
822  "flags=+mu-lame : num=42: toggle=0",
823  "num=42 : string=blahblah",
824  "rational=0 : rational=1/2 : rational=1/-1",
825  "rational=-1/0",
826  };
827 
828  test_ctx.class = &test_class;
829  av_opt_set_defaults(&test_ctx);
830  test_ctx.string = av_strdup("default");
831 
833 
834  for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
835  av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
836  if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
837  av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
838  printf("\n");
839  }
840  }
841 
842  return 0;
843 }
844 
845 #endif
static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
Definition: opt.c:47
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:431
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
class_name
Definition: ffv1enc.c:1077
AVOption.
Definition: opt.h:234
int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:276
#define AV_OPT_FLAG_EXPORT
The option is inteded for exporting values to the caller.
Definition: opt.h:275
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:271
void * av_opt_child_next(void *obj, void *prev)
Iterate over AVOptions-enabled children of obj.
Definition: opt.c:743
void av_log_set_level(int level)
Set the log level.
Definition: log.c:190
const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:751
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:544
int num
numerator
Definition: rational.h:44
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:269
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:637
external API header
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
Definition: opt.c:281
#define FF_ARRAY_ELEMS(a)
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:415
static void opt_list(void *obj, void *av_log_obj, const char *unit, int req_flags, int rej_flags)
Definition: opt.c:461
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:310
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
Public dictionary API.
const char * name
Definition: opt.h:235
uint8_t
const char * help
short English help text
Definition: opt.h:241
AVOptions.
#define b
Definition: input.c:52
const struct AVOption * option
a pointer to the first option specified in the class if any or NULL
Definition: log.h:51
const char * str
Definition: opt.h:256
const char * name
int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
Definition: opt.c:271
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:38
static const double const_values[]
Definition: opt.c:87
static int flags
Definition: log.c:44
void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:184
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:264
const OptionDef options[]
Definition: avconv_opt.c:2183
static int hexchar2int(char c)
Definition: opt.c:101
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:551
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
double max
maximum valid value for the option
Definition: opt.h:261
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:170
const AVOption * av_opt_next(void *obj, const AVOption *last)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:37
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:266
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:168
int main(int argc, char **argv)
Definition: avconv.c:2608
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:121
static const char *const const_names[]
Definition: opt.c:94
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:698
static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:137
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:105
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:383
#define M_E
Definition: ratecontrol.c:39
const char * unit
The logical unit to which the option belongs.
Definition: opt.h:288
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:603
double min
minimum valid value for the option
Definition: opt.h:260
static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
Definition: opt.c:150
static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:108
const struct AVClass *(* child_class_next)(const struct AVClass *prev)
Return an AVClass corresponding to the next potential AVOptions-enabled child.
Definition: log.h:89
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:226
int flags
Definition: opt.h:263
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:391
NULL
Definition: eval.c:55
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
int offset
The offset relative to the context structure where the option value is stored.
Definition: opt.h:247
int av_opt_set_dict(void *obj, AVDictionary **options)
Definition: opt.c:677
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:213
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum, int search_flags)
Definition: opt.c:250
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:532
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:270
#define OPT_EVAL_NUMBER(name, opttype, vartype)
Definition: opt.c:235
#define llrint(x)
Definition: libm.h:101
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:68
Describe the class of an AVClass context structure.
Definition: log.h:33
rational number numerator/denominator
Definition: rational.h:43
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:265
double dbl
Definition: opt.h:255
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:657
common internal and external API header
#define DEFAULT_NUMVAL(opt)
Definition: opt.c:144
#define class
Definition: math.h:25
int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
Definition: opt.c:403
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:79
#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 po...
Definition: opt.h:392
static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
Definition: opt.c:62
char * key
Definition: dict.h:75
int den
denominator
Definition: rational.h:45
union AVOption::@130 default_val
the default value for scalar options
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:328
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:56
char * value
Definition: dict.h:76
#define OFFSET(x)
Definition: avconv_opt.c:2182
enum AVOptionType type
Definition: opt.h:248
int len
int64_t i64
Definition: opt.h:254
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:280
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:207
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:448
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
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:704
float min
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:210
simple arithmetic expression evaluator
static int get_number(void *obj, const char *name, double *num, int *den, int64_t *intnum, int search_flags)
Definition: opt.c:374