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  if (!ptr)
123  return AVERROR(ENOMEM);
124  while (*val) {
125  int a = hexchar2int(*val++);
126  int b = hexchar2int(*val++);
127  if (a < 0 || b < 0) {
128  av_free(bin);
129  return AVERROR(EINVAL);
130  }
131  *ptr++ = (a << 4) | b;
132  }
133  *dst = bin;
134  *lendst = len;
135 
136  return 0;
137 }
138 
139 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
140 {
141  av_freep(dst);
142  *dst = av_strdup(val);
143  return 0;
144 }
145 
146 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
147  opt->type == AV_OPT_TYPE_CONST || \
148  opt->type == AV_OPT_TYPE_FLAGS || \
149  opt->type == AV_OPT_TYPE_INT) ? \
150  opt->default_val.i64 : opt->default_val.dbl)
151 
152 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
153 {
154  int ret = 0, notfirst = 0;
155  for (;;) {
156  int i, den = 1;
157  char buf[256];
158  int cmd = 0;
159  double d, num = 1;
160  int64_t intnum = 1;
161 
162  i = 0;
163  if (*val == '+' || *val == '-') {
164  if (o->type == AV_OPT_TYPE_FLAGS)
165  cmd = *(val++);
166  else if (!notfirst)
167  buf[i++] = *val;
168  }
169 
170  for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
171  buf[i] = val[i];
172  buf[i] = 0;
173 
174  {
175  const AVOption *o_named = av_opt_find(target_obj, buf, o->unit, 0, 0);
176  if (o_named && o_named->type == AV_OPT_TYPE_CONST)
177  d = DEFAULT_NUMVAL(o_named);
178  else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
179  else if (!strcmp(buf, "max" )) d = o->max;
180  else if (!strcmp(buf, "min" )) d = o->min;
181  else if (!strcmp(buf, "none" )) d = 0;
182  else if (!strcmp(buf, "all" )) d = ~0;
183  else {
184  int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
185  if (res < 0) {
186  av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
187  return res;
188  }
189  }
190  }
191  if (o->type == AV_OPT_TYPE_FLAGS) {
192  read_number(o, dst, NULL, NULL, &intnum);
193  if (cmd == '+') d = intnum | (int64_t)d;
194  else if (cmd == '-') d = intnum &~(int64_t)d;
195  } else {
196  read_number(o, dst, &num, &den, &intnum);
197  if (cmd == '+') d = notfirst*num*intnum/den + d;
198  else if (cmd == '-') d = notfirst*num*intnum/den - d;
199  }
200 
201  if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
202  return ret;
203  val += i;
204  if (!*val)
205  return 0;
206  notfirst = 1;
207  }
208 
209  return 0;
210 }
211 
212 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
213 {
214  void *dst, *target_obj;
215  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
216  if (!o || !target_obj)
218  if (!val || o->flags & AV_OPT_FLAG_READONLY)
219  return AVERROR(EINVAL);
220 
221  dst = ((uint8_t*)target_obj) + o->offset;
222  switch (o->type) {
223  case AV_OPT_TYPE_STRING: return set_string(obj, o, val, dst);
224  case AV_OPT_TYPE_BINARY: return set_string_binary(obj, o, val, dst);
225  case AV_OPT_TYPE_FLAGS:
226  case AV_OPT_TYPE_INT:
227  case AV_OPT_TYPE_INT64:
228  case AV_OPT_TYPE_FLOAT:
229  case AV_OPT_TYPE_DOUBLE:
230  case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, target_obj, o, val, dst);
231  }
232 
233  av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
234  return AVERROR(EINVAL);
235 }
236 
237 #define OPT_EVAL_NUMBER(name, opttype, vartype)\
238  int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
239  {\
240  if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)\
241  return AVERROR(EINVAL);\
242  return set_string_number(obj, obj, o, val, name ## _out);\
243  }
244 
247 OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)
248 OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)
249 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)
251 
252 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
253  int search_flags)
254 {
255  void *dst, *target_obj;
256  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
257 
258  if (!o || !target_obj)
260 
261  if (o->flags & AV_OPT_FLAG_READONLY)
262  return AVERROR(EINVAL);
263 
264  dst = ((uint8_t*)target_obj) + o->offset;
265  return write_number(obj, o, dst, num, den, intnum);
266 }
267 
268 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
269 {
270  return set_number(obj, name, 1, 1, val, search_flags);
271 }
272 
273 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
274 {
275  return set_number(obj, name, val, 1, 1, search_flags);
276 }
277 
278 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
279 {
280  return set_number(obj, name, val.num, val.den, 1, search_flags);
281 }
282 
283 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
284 {
285  void *target_obj;
286  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
287  uint8_t *ptr;
288  uint8_t **dst;
289  int *lendst;
290 
291  if (!o || !target_obj)
293 
295  return AVERROR(EINVAL);
296 
297  ptr = av_malloc(len);
298  if (!ptr)
299  return AVERROR(ENOMEM);
300 
301  dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
302  lendst = (int *)(dst + 1);
303 
304  av_free(*dst);
305  *dst = ptr;
306  *lendst = len;
307  memcpy(ptr, val, len);
308 
309  return 0;
310 }
311 
312 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
313 {
314  void *target_obj;
315  AVDictionary **dst;
316  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
317 
318  if (!o || !target_obj)
320  if (o->flags & AV_OPT_FLAG_READONLY)
321  return AVERROR(EINVAL);
322 
323  dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
324  av_dict_free(dst);
325  av_dict_copy(dst, val, 0);
326 
327  return 0;
328 }
329 
330 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
331 {
332  void *dst, *target_obj;
333  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
334  uint8_t *bin, buf[128];
335  int len, i, ret;
336 
337  if (!o || !target_obj)
339 
340  dst = (uint8_t*)target_obj + o->offset;
341 
342  buf[0] = 0;
343  switch (o->type) {
344  case AV_OPT_TYPE_FLAGS: ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);break;
345  case AV_OPT_TYPE_INT: ret = snprintf(buf, sizeof(buf), "%d" , *(int *)dst);break;
346  case AV_OPT_TYPE_INT64: ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
347  case AV_OPT_TYPE_FLOAT: ret = snprintf(buf, sizeof(buf), "%f" , *(float *)dst);break;
348  case AV_OPT_TYPE_DOUBLE: ret = snprintf(buf, sizeof(buf), "%f" , *(double *)dst);break;
349  case AV_OPT_TYPE_RATIONAL: ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
350  case AV_OPT_TYPE_STRING:
351  if (*(uint8_t**)dst)
352  *out_val = av_strdup(*(uint8_t**)dst);
353  else
354  *out_val = av_strdup("");
355  return 0;
356  case AV_OPT_TYPE_BINARY:
357  len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
358  if ((uint64_t)len*2 + 1 > INT_MAX)
359  return AVERROR(EINVAL);
360  if (!(*out_val = av_malloc(len*2 + 1)))
361  return AVERROR(ENOMEM);
362  bin = *(uint8_t**)dst;
363  for (i = 0; i < len; i++)
364  snprintf(*out_val + i*2, 3, "%02X", bin[i]);
365  return 0;
366  default:
367  return AVERROR(EINVAL);
368  }
369 
370  if (ret >= sizeof(buf))
371  return AVERROR(EINVAL);
372  *out_val = av_strdup(buf);
373  return 0;
374 }
375 
376 static int get_number(void *obj, const char *name, double *num, int *den, int64_t *intnum,
377  int search_flags)
378 {
379  void *dst, *target_obj;
380  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
381  if (!o || !target_obj)
382  goto error;
383 
384  dst = ((uint8_t*)target_obj) + o->offset;
385 
386  return read_number(o, dst, num, den, intnum);
387 
388 error:
389  *den=*intnum=0;
390  return -1;
391 }
392 
393 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
394 {
395  int64_t intnum = 1;
396  double num = 1;
397  int ret, den = 1;
398 
399  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
400  return ret;
401  *out_val = num*intnum/den;
402  return 0;
403 }
404 
405 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
406 {
407  int64_t intnum = 1;
408  double num = 1;
409  int ret, den = 1;
410 
411  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
412  return ret;
413  *out_val = num*intnum/den;
414  return 0;
415 }
416 
417 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
418 {
419  int64_t intnum = 1;
420  double num = 1;
421  int ret, den = 1;
422 
423  if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
424  return ret;
425 
426  if (num == 1.0 && (int)intnum == intnum)
427  *out_val = (AVRational){intnum, den};
428  else
429  *out_val = av_d2q(num*intnum/den, 1<<24);
430  return 0;
431 }
432 
433 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
434 {
435  void *target_obj;
436  AVDictionary *src;
437  const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
438 
439  if (!o || !target_obj)
441  if (o->type != AV_OPT_TYPE_DICT)
442  return AVERROR(EINVAL);
443 
444  src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
445  av_dict_copy(out_val, src, 0);
446 
447  return 0;
448 }
449 
450 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
451 {
452  const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
453  const AVOption *flag = av_opt_find(obj, flag_name,
454  field ? field->unit : NULL, 0, 0);
455  int64_t res;
456 
457  if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
458  av_opt_get_int(obj, field_name, 0, &res) < 0)
459  return 0;
460  return res & flag->default_val.i64;
461 }
462 
463 static void opt_list(void *obj, void *av_log_obj, const char *unit,
464  int req_flags, int rej_flags)
465 {
466  const AVOption *opt=NULL;
467 
468  while ((opt = av_opt_next(obj, opt))) {
469  if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
470  continue;
471 
472  /* Don't print CONST's on level one.
473  * Don't print anything but CONST's on level two.
474  * Only print items from the requested unit.
475  */
476  if (!unit && opt->type==AV_OPT_TYPE_CONST)
477  continue;
478  else if (unit && opt->type!=AV_OPT_TYPE_CONST)
479  continue;
480  else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
481  continue;
482  else if (unit && opt->type == AV_OPT_TYPE_CONST)
483  av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
484  else
485  av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
486 
487  switch (opt->type) {
488  case AV_OPT_TYPE_FLAGS:
489  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
490  break;
491  case AV_OPT_TYPE_INT:
492  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
493  break;
494  case AV_OPT_TYPE_INT64:
495  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
496  break;
497  case AV_OPT_TYPE_DOUBLE:
498  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
499  break;
500  case AV_OPT_TYPE_FLOAT:
501  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
502  break;
503  case AV_OPT_TYPE_STRING:
504  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
505  break;
507  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
508  break;
509  case AV_OPT_TYPE_BINARY:
510  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
511  break;
512  case AV_OPT_TYPE_CONST:
513  default:
514  av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
515  break;
516  }
517  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
518  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
519  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
520  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
521  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
522  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT) ? 'X' : '.');
523  av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY) ? 'R' : '.');
524 
525  if (opt->help)
526  av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
527  av_log(av_log_obj, AV_LOG_INFO, "\n");
528  if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
529  opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
530  }
531  }
532 }
533 
534 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
535 {
536  if (!obj)
537  return -1;
538 
539  av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
540 
541  opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
542 
543  return 0;
544 }
545 
546 void av_opt_set_defaults(void *s)
547 {
548  const AVOption *opt = NULL;
549  while ((opt = av_opt_next(s, opt))) {
550  if (opt->flags & AV_OPT_FLAG_READONLY)
551  continue;
552 
553  switch (opt->type) {
554  case AV_OPT_TYPE_CONST:
555  /* Nothing to be done here */
556  break;
557  case AV_OPT_TYPE_FLAGS:
558  case AV_OPT_TYPE_INT:
559  case AV_OPT_TYPE_INT64:
560  av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
561  break;
562  case AV_OPT_TYPE_DOUBLE:
563  case AV_OPT_TYPE_FLOAT: {
564  double val;
565  val = opt->default_val.dbl;
566  av_opt_set_double(s, opt->name, val, 0);
567  }
568  break;
569  case AV_OPT_TYPE_RATIONAL: {
570  AVRational val;
571  val = av_d2q(opt->default_val.dbl, INT_MAX);
572  av_opt_set_q(s, opt->name, val, 0);
573  }
574  break;
575  case AV_OPT_TYPE_STRING:
576  av_opt_set(s, opt->name, opt->default_val.str, 0);
577  break;
578  case AV_OPT_TYPE_BINARY:
579  case AV_OPT_TYPE_DICT:
580  /* Cannot set defaults for these types */
581  break;
582  default:
583  av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
584  }
585  }
586 }
587 
605 static int parse_key_value_pair(void *ctx, const char **buf,
606  const char *key_val_sep, const char *pairs_sep)
607 {
608  char *key = av_get_token(buf, key_val_sep);
609  char *val;
610  int ret;
611 
612  if (!key)
613  return AVERROR(ENOMEM);
614 
615  if (*key && strspn(*buf, key_val_sep)) {
616  (*buf)++;
617  val = av_get_token(buf, pairs_sep);
618  if (!val) {
619  av_freep(&key);
620  return AVERROR(ENOMEM);
621  }
622  } else {
623  av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
624  av_free(key);
625  return AVERROR(EINVAL);
626  }
627 
628  av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
629 
630  ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
631  if (ret == AVERROR_OPTION_NOT_FOUND)
632  av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
633 
634  av_free(key);
635  av_free(val);
636  return ret;
637 }
638 
639 int av_set_options_string(void *ctx, const char *opts,
640  const char *key_val_sep, const char *pairs_sep)
641 {
642  int ret, count = 0;
643 
644  if (!opts)
645  return 0;
646 
647  while (*opts) {
648  if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
649  return ret;
650  count++;
651 
652  if (*opts)
653  opts++;
654  }
655 
656  return count;
657 }
658 
659 void av_opt_free(void *obj)
660 {
661  const AVOption *o = NULL;
662  while ((o = av_opt_next(obj, o))) {
663  switch (o->type) {
664  case AV_OPT_TYPE_STRING:
665  case AV_OPT_TYPE_BINARY:
666  av_freep((uint8_t *)obj + o->offset);
667  break;
668 
669  case AV_OPT_TYPE_DICT:
670  av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
671  break;
672 
673  default:
674  break;
675  }
676  }
677 }
678 
680 {
681  AVDictionaryEntry *t = NULL;
682  AVDictionary *tmp = NULL;
683  int ret = 0;
684 
685  while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
686  ret = av_opt_set(obj, t->key, t->value, 0);
687  if (ret == AVERROR_OPTION_NOT_FOUND)
688  av_dict_set(&tmp, t->key, t->value, 0);
689  else if (ret < 0) {
690  av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
691  break;
692  }
693  ret = 0;
694  }
695  av_dict_free(options);
696  *options = tmp;
697  return ret;
698 }
699 
700 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
701  int opt_flags, int search_flags)
702 {
703  return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
704 }
705 
706 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
707  int opt_flags, int search_flags, void **target_obj)
708 {
709  const AVClass *c = *(AVClass**)obj;
710  const AVOption *o = NULL;
711 
712  if (!c)
713  return NULL;
714 
715  if (search_flags & AV_OPT_SEARCH_CHILDREN) {
716  if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
717  const AVClass *child = NULL;
718  while (child = av_opt_child_class_next(c, child))
719  if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
720  return o;
721  } else {
722  void *child = NULL;
723  while (child = av_opt_child_next(obj, child))
724  if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
725  return o;
726  }
727  }
728 
729  while (o = av_opt_next(obj, o)) {
730  if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
731  ((!unit && o->type != AV_OPT_TYPE_CONST) ||
732  (unit && o->unit && !strcmp(o->unit, unit)))) {
733  if (target_obj) {
734  if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
735  *target_obj = obj;
736  else
737  *target_obj = NULL;
738  }
739  return o;
740  }
741  }
742  return NULL;
743 }
744 
745 void *av_opt_child_next(void *obj, void *prev)
746 {
747  const AVClass *c = *(AVClass**)obj;
748  if (c->child_next)
749  return c->child_next(obj, prev);
750  return NULL;
751 }
752 
753 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
754 {
755  if (parent->child_class_next)
756  return parent->child_class_next(prev);
757  return NULL;
758 }
759 
760 #ifdef TEST
761 
762 typedef struct TestContext
763 {
764  const AVClass *class;
765  int num;
766  int toggle;
767  char *string;
768  int flags;
769  AVRational rational;
770 } TestContext;
771 
772 #define OFFSET(x) offsetof(TestContext, x)
773 
774 #define TEST_FLAG_COOL 01
775 #define TEST_FLAG_LAME 02
776 #define TEST_FLAG_MU 04
777 
778 static const AVOption test_options[]= {
779 {"num", "set num", OFFSET(num), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 100 },
780 {"toggle", "set toggle", OFFSET(toggle), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1 },
781 {"rational", "set rational", OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10 },
782 {"string", "set string", OFFSET(string), AV_OPT_TYPE_STRING, {0}, CHAR_MIN, CHAR_MAX },
783 {"flags", "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, 0, "flags" },
784 {"cool", "set cool flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_COOL}, INT_MIN, INT_MAX, 0, "flags" },
785 {"lame", "set lame flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_LAME}, INT_MIN, INT_MAX, 0, "flags" },
786 {"mu", "set mu flag ", 0, AV_OPT_TYPE_CONST, {.i64 = TEST_FLAG_MU}, INT_MIN, INT_MAX, 0, "flags" },
787 {NULL},
788 };
789 
790 static const char *test_get_name(void *ctx)
791 {
792  return "test";
793 }
794 
795 static const AVClass test_class = {
796  "TestContext",
797  test_get_name,
798  test_options
799 };
800 
801 int main(void)
802 {
803  int i;
804 
805  printf("\nTesting av_set_options_string()\n");
806  {
807  TestContext test_ctx;
808  const char *options[] = {
809  "",
810  ":",
811  "=",
812  "foo=:",
813  ":=foo",
814  "=foo",
815  "foo=",
816  "foo",
817  "foo=val",
818  "foo==val",
819  "toggle=:",
820  "string=:",
821  "toggle=1 : foo",
822  "toggle=100",
823  "toggle==1",
824  "flags=+mu-lame : num=42: toggle=0",
825  "num=42 : string=blahblah",
826  "rational=0 : rational=1/2 : rational=1/-1",
827  "rational=-1/0",
828  };
829 
830  test_ctx.class = &test_class;
831  av_opt_set_defaults(&test_ctx);
832  test_ctx.string = av_strdup("default");
833 
835 
836  for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
837  av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
838  if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
839  av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
840  printf("\n");
841  }
842  }
843 
844  return 0;
845 }
846 
847 #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:433
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:278
#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:745
void av_log_set_level(int level)
Set the log level.
Definition: log.c:191
const AVClass * av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:753
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:546
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:639
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:283
#define FF_ARRAY_ELEMS(a)
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:417
static void opt_list(void *obj, void *av_log_obj, const char *unit, int req_flags, int rej_flags)
Definition: opt.c:463
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:312
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:273
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:2187
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:268
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
int main(int argc, char **argv)
Definition: avconv.c:2609
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:700
static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
Definition: opt.c:139
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:605
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:152
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:393
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:679
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:252
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:534
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:270
#define OPT_EVAL_NUMBER(name, opttype, vartype)
Definition: opt.c:237
#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:659
common internal and external API header
#define DEFAULT_NUMVAL(opt)
Definition: opt.c:146
#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:405
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 poi...
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:330
#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:2186
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:450
#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:706
float min
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:212
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:376