FFmpeg
opt.h
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 #ifndef AVUTIL_OPT_H
23 #define AVUTIL_OPT_H
24 
25 /**
26  * @file
27  * AVOptions
28  */
29 
30 #include "rational.h"
31 #include "avutil.h"
32 #include "channel_layout.h"
33 #include "dict.h"
34 #include "log.h"
35 #include "pixfmt.h"
36 #include "samplefmt.h"
37 
38 /**
39  * @defgroup avoptions AVOptions
40  * @ingroup lavu_data
41  * @{
42  * AVOptions provide a generic system to declare options on arbitrary structs
43  * ("objects"). An option can have a help text, a type and a range of possible
44  * values. Options may then be enumerated, read and written to.
45  *
46  * There are two modes of access to members of AVOption and its child structs.
47  * One is called 'native access', and refers to access from the code that
48  * declares the AVOption in question. The other is 'foreign access', and refers
49  * to access from other code.
50  *
51  * Certain struct members in this header are documented as 'native access only'
52  * or similar - it means that only the code that declared the AVOption in
53  * question is allowed to access the field. This allows us to extend the
54  * semantics of those fields without breaking API compatibility.
55  *
56  * @section avoptions_scope Scope of AVOptions
57  *
58  * AVOptions is designed to support any set of multimedia configuration options
59  * that can be defined at compile-time. Although it is mainly used to expose
60  * FFmpeg options, you are welcome to adapt it to your own use case.
61  *
62  * No single approach can ever fully solve the problem of configuration,
63  * but please submit a patch if you believe you have found a problem
64  * that is best solved by extending AVOptions.
65  *
66  * @section avoptions_implement Implementing AVOptions
67  * This section describes how to add AVOptions capabilities to a struct.
68  *
69  * All AVOptions-related information is stored in an AVClass. Therefore
70  * the first member of the struct should be a pointer to an AVClass describing it.
71  * The option field of the AVClass must be set to a NULL-terminated static array
72  * of AVOptions. Each AVOption must have a non-empty name, a type, a default
73  * value and for number-type AVOptions also a range of allowed values. It must
74  * also declare an offset in bytes from the start of the struct, where the field
75  * associated with this AVOption is located. Other fields in the AVOption struct
76  * should also be set when applicable, but are not required.
77  *
78  * The following example illustrates an AVOptions-enabled struct:
79  * @code
80  * typedef struct test_struct {
81  * const AVClass *class;
82  * int int_opt;
83  * char *str_opt;
84  * uint8_t *bin_opt;
85  * int bin_len;
86  * } test_struct;
87  *
88  * static const AVOption test_options[] = {
89  * { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt),
90  * AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX },
91  * { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt),
92  * AV_OPT_TYPE_STRING },
93  * { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt),
94  * AV_OPT_TYPE_BINARY },
95  * { NULL },
96  * };
97  *
98  * static const AVClass test_class = {
99  * .class_name = "test class",
100  * .item_name = av_default_item_name,
101  * .option = test_options,
102  * .version = LIBAVUTIL_VERSION_INT,
103  * };
104  * @endcode
105  *
106  * Next, when allocating your struct, you must ensure that the AVClass pointer
107  * is set to the correct value. Then, av_opt_set_defaults() can be called to
108  * initialize defaults. After that the struct is ready to be used with the
109  * AVOptions API.
110  *
111  * When cleaning up, you may use the av_opt_free() function to automatically
112  * free all the allocated string and binary options.
113  *
114  * Continuing with the above example:
115  *
116  * @code
117  * test_struct *alloc_test_struct(void)
118  * {
119  * test_struct *ret = av_mallocz(sizeof(*ret));
120  * ret->class = &test_class;
121  * av_opt_set_defaults(ret);
122  * return ret;
123  * }
124  * void free_test_struct(test_struct **foo)
125  * {
126  * av_opt_free(*foo);
127  * av_freep(foo);
128  * }
129  * @endcode
130  *
131  * @subsection avoptions_implement_nesting Nesting
132  * It may happen that an AVOptions-enabled struct contains another
133  * AVOptions-enabled struct as a member (e.g. AVCodecContext in
134  * libavcodec exports generic options, while its priv_data field exports
135  * codec-specific options). In such a case, it is possible to set up the
136  * parent struct to export a child's options. To do that, simply
137  * implement AVClass.child_next() and AVClass.child_class_iterate() in the
138  * parent struct's AVClass.
139  * Assuming that the test_struct from above now also contains a
140  * child_struct field:
141  *
142  * @code
143  * typedef struct child_struct {
144  * AVClass *class;
145  * int flags_opt;
146  * } child_struct;
147  * static const AVOption child_opts[] = {
148  * { "test_flags", "This is a test option of flags type.",
149  * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX },
150  * { NULL },
151  * };
152  * static const AVClass child_class = {
153  * .class_name = "child class",
154  * .item_name = av_default_item_name,
155  * .option = child_opts,
156  * .version = LIBAVUTIL_VERSION_INT,
157  * };
158  *
159  * void *child_next(void *obj, void *prev)
160  * {
161  * test_struct *t = obj;
162  * if (!prev && t->child_struct)
163  * return t->child_struct;
164  * return NULL
165  * }
166  * const AVClass child_class_iterate(void **iter)
167  * {
168  * const AVClass *c = *iter ? NULL : &child_class;
169  * *iter = (void*)(uintptr_t)c;
170  * return c;
171  * }
172  * @endcode
173  * Putting child_next() and child_class_iterate() as defined above into
174  * test_class will now make child_struct's options accessible through
175  * test_struct (again, proper setup as described above needs to be done on
176  * child_struct right after it is created).
177  *
178  * From the above example it might not be clear why both child_next()
179  * and child_class_iterate() are needed. The distinction is that child_next()
180  * iterates over actually existing objects, while child_class_iterate()
181  * iterates over all possible child classes. E.g. if an AVCodecContext
182  * was initialized to use a codec which has private options, then its
183  * child_next() will return AVCodecContext.priv_data and finish
184  * iterating. OTOH child_class_iterate() on AVCodecContext.av_class will
185  * iterate over all available codecs with private options.
186  *
187  * @subsection avoptions_implement_named_constants Named constants
188  * It is possible to create named constants for options. Simply set the unit
189  * field of the option the constants should apply to a string and
190  * create the constants themselves as options of type AV_OPT_TYPE_CONST
191  * with their unit field set to the same string.
192  * Their default_val field should contain the value of the named
193  * constant.
194  * For example, to add some named constants for the test_flags option
195  * above, put the following into the child_opts array:
196  * @code
197  * { "test_flags", "This is a test option of flags type.",
198  * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, "test_unit" },
199  * { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { .i64 = 16 }, 0, 0, "test_unit" },
200  * @endcode
201  *
202  * @section avoptions_use Using AVOptions
203  * This section deals with accessing options in an AVOptions-enabled struct.
204  * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or
205  * AVFormatContext in libavformat.
206  *
207  * @subsection avoptions_use_examine Examining AVOptions
208  * The basic functions for examining options are av_opt_next(), which iterates
209  * over all options defined for one object, and av_opt_find(), which searches
210  * for an option with the given name.
211  *
212  * The situation is more complicated with nesting. An AVOptions-enabled struct
213  * may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag
214  * to av_opt_find() will make the function search children recursively.
215  *
216  * For enumerating there are basically two cases. The first is when you want to
217  * get all options that may potentially exist on the struct and its children
218  * (e.g. when constructing documentation). In that case you should call
219  * av_opt_child_class_iterate() recursively on the parent struct's AVClass. The
220  * second case is when you have an already initialized struct with all its
221  * children and you want to get all options that can be actually written or read
222  * from it. In that case you should call av_opt_child_next() recursively (and
223  * av_opt_next() on each result).
224  *
225  * @subsection avoptions_use_get_set Reading and writing AVOptions
226  * When setting options, you often have a string read directly from the
227  * user. In such a case, simply passing it to av_opt_set() is enough. For
228  * non-string type options, av_opt_set() will parse the string according to the
229  * option type.
230  *
231  * Similarly av_opt_get() will read any option type and convert it to a string
232  * which will be returned. Do not forget that the string is allocated, so you
233  * have to free it with av_free().
234  *
235  * In some cases it may be more convenient to put all options into an
236  * AVDictionary and call av_opt_set_dict() on it. A specific case of this
237  * are the format/codec open functions in lavf/lavc which take a dictionary
238  * filled with option as a parameter. This makes it possible to set some options
239  * that cannot be set otherwise, since e.g. the input file format is not known
240  * before the file is actually opened.
241  */
242 
243 /**
244  * An option type determines:
245  * - for native access, the underlying C type of the field that an AVOption
246  * refers to;
247  * - for foreign access, the semantics of accessing the option through this API,
248  * e.g. which av_opt_get_*() and av_opt_set_*() functions can be called, or
249  * what format will av_opt_get()/av_opt_set() expect/produce.
250  */
252  /**
253  * Underlying C type is unsigned int.
254  */
256  /**
257  * Underlying C type is int.
258  */
260  /**
261  * Underlying C type is int64_t.
262  */
264  /**
265  * Underlying C type is double.
266  */
268  /**
269  * Underlying C type is float.
270  */
272  /**
273  * Underlying C type is a uint8_t* that is either NULL or points to a C
274  * string allocated with the av_malloc() family of functions.
275  */
277  /**
278  * Underlying C type is AVRational.
279  */
281  /**
282  * Underlying C type is a uint8_t* that is either NULL or points to an array
283  * allocated with the av_malloc() family of functions. The pointer is
284  * immediately followed by an int containing the array length in bytes.
285  */
287  /**
288  * Underlying C type is AVDictionary*.
289  */
291  /**
292  * Underlying C type is uint64_t.
293  */
295  /**
296  * Special option type for declaring named constants. Does not correspond to
297  * an actual field in the object, offset must be 0.
298  */
300  /**
301  * Underlying C type is two consecutive integers.
302  */
304  /**
305  * Underlying C type is enum AVPixelFormat.
306  */
308  /**
309  * Underlying C type is enum AVSampleFormat.
310  */
312  /**
313  * Underlying C type is AVRational.
314  */
316  /**
317  * Underlying C type is int64_t.
318  */
320  /**
321  * Underlying C type is uint8_t[4].
322  */
324  /**
325  * Underlying C type is int.
326  */
328  /**
329  * Underlying C type is AVChannelLayout.
330  */
332  /**
333  * Underlying C type is unsigned int.
334  */
336 
337  /**
338  * May be combined with another regular option type to declare an array
339  * option.
340  *
341  * For array options, @ref AVOption.offset should refer to a pointer
342  * corresponding to the option type. The pointer should be immediately
343  * followed by an unsigned int that will store the number of elements in the
344  * array.
345  */
347 };
348 
349 /**
350  * A generic parameter which can be set by the user for muxing or encoding.
351  */
352 #define AV_OPT_FLAG_ENCODING_PARAM (1 << 0)
353 /**
354  * A generic parameter which can be set by the user for demuxing or decoding.
355  */
356 #define AV_OPT_FLAG_DECODING_PARAM (1 << 1)
357 #define AV_OPT_FLAG_AUDIO_PARAM (1 << 3)
358 #define AV_OPT_FLAG_VIDEO_PARAM (1 << 4)
359 #define AV_OPT_FLAG_SUBTITLE_PARAM (1 << 5)
360 /**
361  * The option is intended for exporting values to the caller.
362  */
363 #define AV_OPT_FLAG_EXPORT (1 << 6)
364 /**
365  * The option may not be set through the AVOptions API, only read.
366  * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
367  */
368 #define AV_OPT_FLAG_READONLY (1 << 7)
369 /**
370  * A generic parameter which can be set by the user for bit stream filtering.
371  */
372 #define AV_OPT_FLAG_BSF_PARAM (1 << 8)
373 
374 /**
375  * A generic parameter which can be set by the user at runtime.
376  */
377 #define AV_OPT_FLAG_RUNTIME_PARAM (1 << 15)
378 /**
379  * A generic parameter which can be set by the user for filtering.
380  */
381 #define AV_OPT_FLAG_FILTERING_PARAM (1 << 16)
382 /**
383  * Set if option is deprecated, users should refer to AVOption.help text for
384  * more information.
385  */
386 #define AV_OPT_FLAG_DEPRECATED (1 << 17)
387 /**
388  * Set if option constants can also reside in child objects.
389  */
390 #define AV_OPT_FLAG_CHILD_CONSTS (1 << 18)
391 
392 /**
393  * May be set as default_val for AV_OPT_TYPE_FLAG_ARRAY options.
394  */
395 typedef struct AVOptionArrayDef {
396  /**
397  * Native access only.
398  *
399  * Default value of the option, as would be serialized by av_opt_get() (i.e.
400  * using the value of sep as the separator).
401  */
402  const char *def;
403 
404  /**
405  * Minimum number of elements in the array. When this field is non-zero, def
406  * must be non-NULL and contain at least this number of elements.
407  */
408  unsigned size_min;
409  /**
410  * Maximum number of elements in the array, 0 when unlimited.
411  */
412  unsigned size_max;
413 
414  /**
415  * Separator between array elements in string representations of this
416  * option, used by av_opt_set() and av_opt_get(). It must be a printable
417  * ASCII character, excluding alphanumeric and the backslash. A comma is
418  * used when sep=0.
419  *
420  * The separator and the backslash must be backslash-escaped in order to
421  * appear in string representations of the option value.
422  */
423  char sep;
425 
426 /**
427  * AVOption
428  */
429 typedef struct AVOption {
430  const char *name;
431 
432  /**
433  * short English help text
434  * @todo What about other languages?
435  */
436  const char *help;
437 
438  /**
439  * Native access only.
440  *
441  * The offset relative to the context structure where the option
442  * value is stored. It should be 0 for named constants.
443  */
444  int offset;
446 
447  /**
448  * Native access only, except when documented otherwise.
449  * the default value for scalar options
450  */
451  union {
453  double dbl;
454  const char *str;
455  /* TODO those are unused now */
457 
458  /**
459  * Used for AV_OPT_TYPE_FLAG_ARRAY options. May be NULL.
460  *
461  * Foreign access to some members allowed, as noted in AVOptionArrayDef
462  * documentation.
463  */
465  } default_val;
466  double min; ///< minimum valid value for the option
467  double max; ///< maximum valid value for the option
468 
469  /**
470  * A combination of AV_OPT_FLAG_*.
471  */
472  int flags;
473 
474  /**
475  * The logical unit to which the option belongs. Non-constant
476  * options and corresponding named constants share the same
477  * unit. May be NULL.
478  */
479  const char *unit;
480 } AVOption;
481 
482 /**
483  * A single allowed range of values, or a single allowed value.
484  */
485 typedef struct AVOptionRange {
486  const char *str;
487  /**
488  * Value range.
489  * For string ranges this represents the min/max length.
490  * For dimensions this represents the min/max pixel count or width/height in multi-component case.
491  */
493  /**
494  * Value's component range.
495  * For string this represents the unicode range for chars, 0-127 limits to ASCII.
496  */
498  /**
499  * Range flag.
500  * If set to 1 the struct encodes a range, if set to 0 a single value.
501  */
502  int is_range;
503 } AVOptionRange;
504 
505 /**
506  * List of AVOptionRange structs.
507  */
508 typedef struct AVOptionRanges {
509  /**
510  * Array of option ranges.
511  *
512  * Most of option types use just one component.
513  * Following describes multi-component option types:
514  *
515  * AV_OPT_TYPE_IMAGE_SIZE:
516  * component index 0: range of pixel count (width * height).
517  * component index 1: range of width.
518  * component index 2: range of height.
519  *
520  * @note To obtain multi-component version of this structure, user must
521  * provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or
522  * av_opt_query_ranges_default function.
523  *
524  * Multi-component range can be read as in following example:
525  *
526  * @code
527  * int range_index, component_index;
528  * AVOptionRanges *ranges;
529  * AVOptionRange *range[3]; //may require more than 3 in the future.
530  * av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
531  * for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
532  * for (component_index = 0; component_index < ranges->nb_components; component_index++)
533  * range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index];
534  * //do something with range here.
535  * }
536  * av_opt_freep_ranges(&ranges);
537  * @endcode
538  */
540  /**
541  * Number of ranges per component.
542  */
544  /**
545  * Number of componentes.
546  */
549 
550 /**
551  * @defgroup opt_mng AVOption (un)initialization and inspection.
552  * @{
553  */
554 
555 /**
556  * Set the values of all AVOption fields to their default values.
557  *
558  * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
559  */
560 void av_opt_set_defaults(void *s);
561 
562 /**
563  * Set the values of all AVOption fields to their default values. Only these
564  * AVOption fields for which (opt->flags & mask) == flags will have their
565  * default applied to s.
566  *
567  * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
568  * @param mask combination of AV_OPT_FLAG_*
569  * @param flags combination of AV_OPT_FLAG_*
570  */
571 void av_opt_set_defaults2(void *s, int mask, int flags);
572 
573 /**
574  * Free all allocated objects in obj.
575  */
576 void av_opt_free(void *obj);
577 
578 /**
579  * Iterate over all AVOptions belonging to obj.
580  *
581  * @param obj an AVOptions-enabled struct or a double pointer to an
582  * AVClass describing it.
583  * @param prev result of the previous call to av_opt_next() on this object
584  * or NULL
585  * @return next AVOption or NULL
586  */
587 const AVOption *av_opt_next(const void *obj, const AVOption *prev);
588 
589 /**
590  * Iterate over AVOptions-enabled children of obj.
591  *
592  * @param prev result of a previous call to this function or NULL
593  * @return next AVOptions-enabled child or NULL
594  */
595 void *av_opt_child_next(void *obj, void *prev);
596 
597 /**
598  * Iterate over potential AVOptions-enabled children of parent.
599  *
600  * @param iter a pointer where iteration state is stored.
601  * @return AVClass corresponding to next potential child or NULL
602  */
603 const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
604 
605 #define AV_OPT_SEARCH_CHILDREN (1 << 0) /**< Search in possible children of the
606  given object first. */
607 /**
608  * The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
609  * instead of a required pointer to a struct containing AVClass. This is
610  * useful for searching for options without needing to allocate the corresponding
611  * object.
612  */
613 #define AV_OPT_SEARCH_FAKE_OBJ (1 << 1)
614 
615 /**
616  * In av_opt_get, return NULL if the option has a pointer type and is set to NULL,
617  * rather than returning an empty string.
618  */
619 #define AV_OPT_ALLOW_NULL (1 << 2)
620 
621 /**
622  * May be used with av_opt_set_array() to signal that new elements should
623  * replace the existing ones in the indicated range.
624  */
625 #define AV_OPT_ARRAY_REPLACE (1 << 3)
626 
627 /**
628  * Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than
629  * one component for certain option types.
630  * @see AVOptionRanges for details.
631  */
632 #define AV_OPT_MULTI_COMPONENT_RANGE (1 << 12)
633 
634 /**
635  * Look for an option in an object. Consider only options which
636  * have all the specified flags set.
637  *
638  * @param[in] obj A pointer to a struct whose first element is a
639  * pointer to an AVClass.
640  * Alternatively a double pointer to an AVClass, if
641  * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
642  * @param[in] name The name of the option to look for.
643  * @param[in] unit When searching for named constants, name of the unit
644  * it belongs to.
645  * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
646  * @param search_flags A combination of AV_OPT_SEARCH_*.
647  *
648  * @return A pointer to the option found, or NULL if no option
649  * was found.
650  *
651  * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable
652  * directly with av_opt_set(). Use special calls which take an options
653  * AVDictionary (e.g. avformat_open_input()) to set options found with this
654  * flag.
655  */
656 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
657  int opt_flags, int search_flags);
658 
659 /**
660  * Look for an option in an object. Consider only options which
661  * have all the specified flags set.
662  *
663  * @param[in] obj A pointer to a struct whose first element is a
664  * pointer to an AVClass.
665  * Alternatively a double pointer to an AVClass, if
666  * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
667  * @param[in] name The name of the option to look for.
668  * @param[in] unit When searching for named constants, name of the unit
669  * it belongs to.
670  * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
671  * @param search_flags A combination of AV_OPT_SEARCH_*.
672  * @param[out] target_obj if non-NULL, an object to which the option belongs will be
673  * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present
674  * in search_flags. This parameter is ignored if search_flags contain
675  * AV_OPT_SEARCH_FAKE_OBJ.
676  *
677  * @return A pointer to the option found, or NULL if no option
678  * was found.
679  */
680 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
681  int opt_flags, int search_flags, void **target_obj);
682 
683 /**
684  * Show the obj options.
685  *
686  * @param req_flags requested flags for the options to show. Show only the
687  * options for which it is opt->flags & req_flags.
688  * @param rej_flags rejected flags for the options to show. Show only the
689  * options for which it is !(opt->flags & req_flags).
690  * @param av_log_obj log context to use for showing the options
691  */
692 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
693 
694 /**
695  * Extract a key-value pair from the beginning of a string.
696  *
697  * @param ropts pointer to the options string, will be updated to
698  * point to the rest of the string (one of the pairs_sep
699  * or the final NUL)
700  * @param key_val_sep a 0-terminated list of characters used to separate
701  * key from value, for example '='
702  * @param pairs_sep a 0-terminated list of characters used to separate
703  * two pairs from each other, for example ':' or ','
704  * @param flags flags; see the AV_OPT_FLAG_* values below
705  * @param rkey parsed key; must be freed using av_free()
706  * @param rval parsed value; must be freed using av_free()
707  *
708  * @return >=0 for success, or a negative value corresponding to an
709  * AVERROR code in case of error; in particular:
710  * AVERROR(EINVAL) if no key is present
711  *
712  */
713 int av_opt_get_key_value(const char **ropts,
714  const char *key_val_sep, const char *pairs_sep,
715  unsigned flags,
716  char **rkey, char **rval);
717 
718 enum {
719 
720  /**
721  * Accept to parse a value without a key; the key will then be returned
722  * as NULL.
723  */
725 };
726 
727 /**
728  * @}
729  */
730 
731 /**
732  * @defgroup opt_write Setting and modifying option values
733  * @{
734  */
735 
736 /**
737  * Parse the key/value pairs list in opts. For each key/value pair
738  * found, stores the value in the field in ctx that is named like the
739  * key. ctx must be an AVClass context, storing is done using
740  * AVOptions.
741  *
742  * @param opts options string to parse, may be NULL
743  * @param key_val_sep a 0-terminated list of characters used to
744  * separate key from value
745  * @param pairs_sep a 0-terminated list of characters used to separate
746  * two pairs from each other
747  * @return the number of successfully set key/value pairs, or a negative
748  * value corresponding to an AVERROR code in case of error:
749  * AVERROR(EINVAL) if opts cannot be parsed,
750  * the error code issued by av_opt_set() if a key/value pair
751  * cannot be set
752  */
753 int av_set_options_string(void *ctx, const char *opts,
754  const char *key_val_sep, const char *pairs_sep);
755 
756 /**
757  * Parse the key-value pairs list in opts. For each key=value pair found,
758  * set the value of the corresponding option in ctx.
759  *
760  * @param ctx the AVClass object to set options on
761  * @param opts the options string, key-value pairs separated by a
762  * delimiter
763  * @param shorthand a NULL-terminated array of options names for shorthand
764  * notation: if the first field in opts has no key part,
765  * the key is taken from the first element of shorthand;
766  * then again for the second, etc., until either opts is
767  * finished, shorthand is finished or a named option is
768  * found; after that, all options must be named
769  * @param key_val_sep a 0-terminated list of characters used to separate
770  * key from value, for example '='
771  * @param pairs_sep a 0-terminated list of characters used to separate
772  * two pairs from each other, for example ':' or ','
773  * @return the number of successfully set key=value pairs, or a negative
774  * value corresponding to an AVERROR code in case of error:
775  * AVERROR(EINVAL) if opts cannot be parsed,
776  * the error code issued by av_set_string3() if a key/value pair
777  * cannot be set
778  *
779  * Options names must use only the following characters: a-z A-Z 0-9 - . / _
780  * Separators must use characters distinct from option names and from each
781  * other.
782  */
783 int av_opt_set_from_string(void *ctx, const char *opts,
784  const char *const *shorthand,
785  const char *key_val_sep, const char *pairs_sep);
786 
787 /**
788  * Set all the options from a given dictionary on an object.
789  *
790  * @param obj a struct whose first element is a pointer to AVClass
791  * @param options options to process. This dictionary will be freed and replaced
792  * by a new one containing all options not found in obj.
793  * Of course this new dictionary needs to be freed by caller
794  * with av_dict_free().
795  *
796  * @return 0 on success, a negative AVERROR if some option was found in obj,
797  * but could not be set.
798  *
799  * @see av_dict_copy()
800  */
801 int av_opt_set_dict(void *obj, struct AVDictionary **options);
802 
803 
804 /**
805  * Set all the options from a given dictionary on an object.
806  *
807  * @param obj a struct whose first element is a pointer to AVClass
808  * @param options options to process. This dictionary will be freed and replaced
809  * by a new one containing all options not found in obj.
810  * Of course this new dictionary needs to be freed by caller
811  * with av_dict_free().
812  * @param search_flags A combination of AV_OPT_SEARCH_*.
813  *
814  * @return 0 on success, a negative AVERROR if some option was found in obj,
815  * but could not be set.
816  *
817  * @see av_dict_copy()
818  */
819 int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags);
820 
821 /**
822  * Copy options from src object into dest object.
823  *
824  * The underlying AVClass of both src and dest must coincide. The guarantee
825  * below does not apply if this is not fulfilled.
826  *
827  * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
828  * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
829  *
830  * Even on error it is guaranteed that allocated options from src and dest
831  * no longer alias each other afterwards; in particular calling av_opt_free()
832  * on both src and dest is safe afterwards if dest has been memdup'ed from src.
833  *
834  * @param dest Object to copy from
835  * @param src Object to copy into
836  * @return 0 on success, negative on error
837  */
838 int av_opt_copy(void *dest, const void *src);
839 
840 /**
841  * @defgroup opt_set_funcs Option setting functions
842  * @{
843  * Those functions set the field of obj with the given name to value.
844  *
845  * @param[in] obj A struct whose first element is a pointer to an AVClass.
846  * @param[in] name the name of the field to set
847  * @param[in] val The value to set. In case of av_opt_set() if the field is not
848  * of a string type, then the given string is parsed.
849  * SI postfixes and some named scalars are supported.
850  * If the field is of a numeric type, it has to be a numeric or named
851  * scalar. Behavior with more than one scalar and +- infix operators
852  * is undefined.
853  * If the field is of a flags type, it has to be a sequence of numeric
854  * scalars or named flags separated by '+' or '-'. Prefixing a flag
855  * with '+' causes it to be set without affecting the other flags;
856  * similarly, '-' unsets a flag.
857  * If the field is of a dictionary type, it has to be a ':' separated list of
858  * key=value parameters. Values containing ':' special characters must be
859  * escaped.
860  * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
861  * is passed here, then the option may be set on a child of obj.
862  *
863  * @return 0 if the value has been set, or an AVERROR code in case of
864  * error:
865  * AVERROR_OPTION_NOT_FOUND if no matching option exists
866  * AVERROR(ERANGE) if the value is out of range
867  * AVERROR(EINVAL) if the value is not valid
868  */
869 int av_opt_set (void *obj, const char *name, const char *val, int search_flags);
870 int av_opt_set_int (void *obj, const char *name, int64_t val, int search_flags);
871 int av_opt_set_double (void *obj, const char *name, double val, int search_flags);
872 int av_opt_set_q (void *obj, const char *name, AVRational val, int search_flags);
873 int av_opt_set_bin (void *obj, const char *name, const uint8_t *val, int size, int search_flags);
874 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags);
875 int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
876 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
877 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
878 /**
879  * @note Any old chlayout present is discarded and replaced with a copy of the new one. The
880  * caller still owns layout and is responsible for uninitializing it.
881  */
882 int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *layout, int search_flags);
883 /**
884  * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
885  * caller still owns val is and responsible for freeing it.
886  */
887 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags);
888 
889 #if FF_API_OPT_INT_LIST
890 /**
891  * Set a binary option to an integer list.
892  *
893  * @param obj AVClass object to set options on
894  * @param name name of the binary option
895  * @param val pointer to an integer list (must have the correct type with
896  * regard to the contents of the list)
897  * @param term list terminator (usually 0 or -1)
898  * @param flags search flags
899  */
900 #define av_opt_set_int_list(obj, name, val, term, flags) \
901  (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
902  AVERROR(EINVAL) : \
903  av_opt_set_bin(obj, name, (const uint8_t *)(val), \
904  av_int_list_length(val, term) * sizeof(*(val)), flags))
905 #endif
906 
907 /**
908  * Add, replace, or remove elements for an array option. Which of these
909  * operations is performed depends on the values of val and search_flags.
910  *
911  * @param start_elem Index of the first array element to modify; must not be
912  * larger than array size as returned by
913  * av_opt_get_array_size().
914  * @param nb_elems number of array elements to modify; when val is NULL,
915  * start_elem+nb_elems must not be larger than array size as
916  * returned by av_opt_get_array_size()
917  *
918  * @param val_type Option type corresponding to the type of val, ignored when val is
919  * NULL.
920  *
921  * The effect of this function will will be as if av_opt_setX()
922  * was called for each element, where X is specified by type.
923  * E.g. AV_OPT_TYPE_STRING corresponds to av_opt_set().
924  *
925  * Typically this should be the same as the scalarized type of
926  * the AVOption being set, but certain conversions are also
927  * possible - the same as those done by the corresponding
928  * av_opt_set*() function. E.g. any option type can be set from
929  * a string, numeric types can be set from int64, double, or
930  * rational, etc.
931  *
932  * @param val Array with nb_elems elements or NULL.
933  *
934  * When NULL, nb_elems array elements starting at start_elem are
935  * removed from the array. Any array elements remaining at the end
936  * are shifted by nb_elems towards the first element in order to keep
937  * the array contiguous.
938  *
939  * Otherwise (val is non-NULL), the type of val must match the
940  * underlying C type as documented for val_type.
941  *
942  * When AV_OPT_ARRAY_REPLACE is not set in search_flags, the array is
943  * enlarged by nb_elems, and the contents of val are inserted at
944  * start_elem. Previously existing array elements from start_elem
945  * onwards (if present) are shifted by nb_elems away from the first
946  * element in order to make space for the new elements.
947  *
948  * When AV_OPT_ARRAY_REPLACE is set in search_flags, the contents
949  * of val replace existing array elements from start_elem to
950  * start_elem+nb_elems (if present). New array size is
951  * max(start_elem + nb_elems, old array size).
952  */
953 int av_opt_set_array(void *obj, const char *name, int search_flags,
954  unsigned int start_elem, unsigned int nb_elems,
955  enum AVOptionType val_type, const void *val);
956 
957 /**
958  * @}
959  * @}
960  */
961 
962 /**
963  * @defgroup opt_read Reading option values
964  * @{
965  */
966 
967 /**
968  * @defgroup opt_get_funcs Option getting functions
969  * @{
970  * Those functions get a value of the option with the given name from an object.
971  *
972  * @param[in] obj a struct whose first element is a pointer to an AVClass.
973  * @param[in] name name of the option to get.
974  * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
975  * is passed here, then the option may be found in a child of obj.
976  * @param[out] out_val value of the option will be written here
977  * @return >=0 on success, a negative error code otherwise
978  */
979 /**
980  * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
981  *
982  * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the
983  * option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
984  * and is set to NULL, *out_val will be set to NULL instead of an allocated
985  * empty string.
986  */
987 int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val);
988 int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val);
989 int av_opt_get_double (void *obj, const char *name, int search_flags, double *out_val);
990 int av_opt_get_q (void *obj, const char *name, int search_flags, AVRational *out_val);
991 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out);
992 int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
993 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
994 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
995 /**
996  * @param[out] layout The returned layout is a copy of the actual value and must
997  * be freed with av_channel_layout_uninit() by the caller
998  */
999 int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *layout);
1000 /**
1001  * @param[out] out_val The returned dictionary is a copy of the actual value and must
1002  * be freed with av_dict_free() by the caller
1003  */
1004 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val);
1005 
1006 /**
1007  * For an array-type option, get the number of elements in the array.
1008  */
1009 int av_opt_get_array_size(void *obj, const char *name, int search_flags,
1010  unsigned int *out_val);
1011 
1012 /**
1013  * For an array-type option, retrieve the values of one or more array elements.
1014  *
1015  * @param start_elem index of the first array element to retrieve
1016  * @param nb_elems number of array elements to retrieve; start_elem+nb_elems
1017  * must not be larger than array size as returned by
1018  * av_opt_get_array_size()
1019  *
1020  * @param out_type Option type corresponding to the desired output.
1021  *
1022  * The array elements produced by this function will
1023  * will be as if av_opt_getX() was called for each element,
1024  * where X is specified by out_type. E.g. AV_OPT_TYPE_STRING
1025  * corresponds to av_opt_get().
1026  *
1027  * Typically this should be the same as the scalarized type of
1028  * the AVOption being retrieved, but certain conversions are
1029  * also possible - the same as those done by the corresponding
1030  * av_opt_get*() function. E.g. any option type can be retrieved
1031  * as a string, numeric types can be retrieved as int64, double,
1032  * or rational, etc.
1033  *
1034  * @param out_val Array with nb_elems members into which the output will be
1035  * written. The array type must match the underlying C type as
1036  * documented for out_type, and be zeroed on entry to this
1037  * function.
1038  *
1039  * For dynamically allocated types (strings, binary, dicts,
1040  * etc.), the result is owned and freed by the caller.
1041  */
1042 int av_opt_get_array(void *obj, const char *name, int search_flags,
1043  unsigned int start_elem, unsigned int nb_elems,
1044  enum AVOptionType out_type, void *out_val);
1045 /**
1046  * @}
1047  */
1048 
1049 /**
1050  * @defgroup opt_eval_funcs Evaluating option strings
1051  * @{
1052  * This group of functions can be used to evaluate option strings
1053  * and get numbers out of them. They do the same thing as av_opt_set(),
1054  * except the result is written into the caller-supplied pointer.
1055  *
1056  * @param obj a struct whose first element is a pointer to AVClass.
1057  * @param o an option for which the string is to be evaluated.
1058  * @param val string to be evaluated.
1059  * @param *_out value of the string will be written here.
1060  *
1061  * @return 0 on success, a negative number on failure.
1062  */
1063 int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int *flags_out);
1064 int av_opt_eval_int (void *obj, const AVOption *o, const char *val, int *int_out);
1065 int av_opt_eval_uint (void *obj, const AVOption *o, const char *val, unsigned *uint_out);
1066 int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t *int64_out);
1067 int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float *float_out);
1068 int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out);
1069 int av_opt_eval_q (void *obj, const AVOption *o, const char *val, AVRational *q_out);
1070 /**
1071  * @}
1072  */
1073 
1074 #if FF_API_OPT_PTR
1075 /**
1076  * Gets a pointer to the requested field in a struct.
1077  * This function allows accessing a struct even when its fields are moved or
1078  * renamed since the application making the access has been compiled,
1079  *
1080  * @returns a pointer to the field, it can be cast to the correct type and read
1081  * or written to.
1082  *
1083  * @deprecated direct access to AVOption-exported fields is not supported
1084  */
1086 void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
1087 #endif
1088 
1089 /**
1090  * Check if given option is set to its default value.
1091  *
1092  * Options o must belong to the obj. This function must not be called to check child's options state.
1093  * @see av_opt_is_set_to_default_by_name().
1094  *
1095  * @param obj AVClass object to check option on
1096  * @param o option to be checked
1097  * @return >0 when option is set to its default,
1098  * 0 when option is not set its default,
1099  * <0 on error
1100  */
1101 int av_opt_is_set_to_default(void *obj, const AVOption *o);
1102 
1103 /**
1104  * Check if given option is set to its default value.
1105  *
1106  * @param obj AVClass object to check option on
1107  * @param name option name
1108  * @param search_flags combination of AV_OPT_SEARCH_*
1109  * @return >0 when option is set to its default,
1110  * 0 when option is not set its default,
1111  * <0 on error
1112  */
1113 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags);
1114 
1115 /**
1116  * Check whether a particular flag is set in a flags field.
1117  *
1118  * @param field_name the name of the flag field option
1119  * @param flag_name the name of the flag to check
1120  * @return non-zero if the flag is set, zero if the flag isn't set,
1121  * isn't of the right type, or the flags field doesn't exist.
1122  */
1123 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name);
1124 
1125 #define AV_OPT_SERIALIZE_SKIP_DEFAULTS 0x00000001 ///< Serialize options that are not set to default values only.
1126 #define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT 0x00000002 ///< Serialize options that exactly match opt_flags only.
1127 #define AV_OPT_SERIALIZE_SEARCH_CHILDREN 0x00000004 ///< Serialize options in possible children of the given object.
1128 
1129 /**
1130  * Serialize object's options.
1131  *
1132  * Create a string containing object's serialized options.
1133  * Such string may be passed back to av_opt_set_from_string() in order to restore option values.
1134  * A key/value or pairs separator occurring in the serialized value or
1135  * name string are escaped through the av_escape() function.
1136  *
1137  * @param[in] obj AVClass object to serialize
1138  * @param[in] opt_flags serialize options with all the specified flags set (AV_OPT_FLAG)
1139  * @param[in] flags combination of AV_OPT_SERIALIZE_* flags
1140  * @param[out] buffer Pointer to buffer that will be allocated with string containg serialized options.
1141  * Buffer must be freed by the caller when is no longer needed.
1142  * @param[in] key_val_sep character used to separate key from value
1143  * @param[in] pairs_sep character used to separate two pairs from each other
1144  * @return >= 0 on success, negative on error
1145  * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
1146  */
1147 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
1148  const char key_val_sep, const char pairs_sep);
1149 
1150 /**
1151  * @}
1152  */
1153 
1154 /**
1155  * Free an AVOptionRanges struct and set it to NULL.
1156  */
1157 void av_opt_freep_ranges(AVOptionRanges **ranges);
1158 
1159 /**
1160  * Get a list of allowed ranges for the given option.
1161  *
1162  * The returned list may depend on other fields in obj like for example profile.
1163  *
1164  * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
1165  * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
1166  * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
1167  *
1168  * The result must be freed with av_opt_freep_ranges.
1169  *
1170  * @return number of compontents returned on success, a negative errro code otherwise
1171  */
1172 int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags);
1173 
1174 /**
1175  * Get a default list of allowed ranges for the given option.
1176  *
1177  * This list is constructed without using the AVClass.query_ranges() callback
1178  * and can be used as fallback from within the callback.
1179  *
1180  * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
1181  * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
1182  * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
1183  *
1184  * The result must be freed with av_opt_free_ranges.
1185  *
1186  * @return number of compontents returned on success, a negative errro code otherwise
1187  */
1188 int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags);
1189 
1190 /**
1191  * @}
1192  */
1193 
1194 #endif /* AVUTIL_OPT_H */
AVOptionRange::is_range
int is_range
Range flag.
Definition: opt.h:502
av_opt_get_dict_val
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
Definition: opt.c:1383
av_opt_eval_uint
int av_opt_eval_uint(void *obj, const AVOption *o, const char *val, unsigned *uint_out)
av_opt_set_image_size
int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
Definition: opt.c:922
AVOption::i64
int64_t i64
Definition: opt.h:452
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
AVOptionRanges::nb_components
int nb_components
Number of componentes.
Definition: opt.h:547
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1678
av_opt_flag_is_set
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:1399
AV_OPT_TYPE_SAMPLE_FMT
@ AV_OPT_TYPE_SAMPLE_FMT
Underlying C type is enum AVSampleFormat.
Definition: opt.h:311
AVOptionRange::value_max
double value_max
Definition: opt.h:492
av_opt_child_class_iterate
const AVClass * av_opt_child_class_iterate(const AVClass *parent, void **iter)
Iterate over potential AVOptions-enabled children of parent.
Definition: opt.c:2050
AVOptionArrayDef::sep
char sep
Separator between array elements in string representations of this option, used by av_opt_set() and a...
Definition: opt.h:423
AVOptionType
AVOptionType
An option type determines:
Definition: opt.h:251
AVOptionArrayDef
May be set as default_val for AV_OPT_TYPE_FLAG_ARRAY options.
Definition: opt.h:395
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
Underlying C type is AVRational.
Definition: opt.h:315
rational.h
int64_t
long long int64_t
Definition: coverity.c:34
AVOption::arr
const AVOptionArrayDef * arr
Used for AV_OPT_TYPE_FLAG_ARRAY options.
Definition: opt.h:464
AVOptionRange::value_min
double value_min
Value range.
Definition: opt.h:492
mask
int mask
Definition: mediacodecdec_common.c:154
AVOptionRanges::nb_ranges
int nb_ranges
Number of ranges per component.
Definition: opt.h:543
w
uint8_t w
Definition: llviddspenc.c:38
av_opt_set_double
int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
Definition: opt.c:885
av_opt_set_from_string
int av_opt_set_from_string(void *ctx, const char *opts, const char *const *shorthand, const char *key_val_sep, const char *pairs_sep)
Parse the key-value pairs list in opts.
Definition: opt.c:1897
AVOption
AVOption.
Definition: opt.h:429
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Underlying C type is int64_t.
Definition: opt.h:319
av_opt_find2
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:1997
AVOption::help
const char * help
short English help text
Definition: opt.h:436
AVOption::flags
int flags
A combination of AV_OPT_FLAG_*.
Definition: opt.h:472
AVDictionary
Definition: dict.c:34
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Underlying C type is AVRational.
Definition: opt.h:280
av_opt_serialize
int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer, const char key_val_sep, const char pairs_sep)
Serialize object's options.
Definition: opt.c:2770
AV_OPT_TYPE_BINARY
@ AV_OPT_TYPE_BINARY
Underlying C type is a uint8_t* that is either NULL or points to an array allocated with the av_mallo...
Definition: opt.h:286
av_opt_is_set_to_default
int av_opt_is_set_to_default(void *obj, const AVOption *o)
Check if given option is set to its default value.
Definition: opt.c:2579
AVOption::offset
int offset
Native access only.
Definition: opt.h:444
av_opt_get_key_value
int av_opt_get_key_value(const char **ropts, const char *key_val_sep, const char *pairs_sep, unsigned flags, char **rkey, char **rval)
Extract a key-value pair from the beginning of a string.
Definition: opt.c:1875
samplefmt.h
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
AVOptionArrayDef::def
const char * def
Native access only.
Definition: opt.h:402
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition: opt.h:267
AVOptionRange::str
const char * str
Definition: opt.h:486
av_opt_set_dict_val
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
Definition: opt.c:984
av_opt_set_pixel_fmt
int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
Definition: opt.c:974
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Underlying C type is int64_t.
Definition: opt.h:263
av_opt_eval_int64
int av_opt_eval_int64(void *obj, const AVOption *o, const char *val, int64_t *int64_out)
av_set_options_string
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:1817
av_opt_get_array_size
int av_opt_get_array_size(void *obj, const char *name, int search_flags, unsigned int *out_val)
For an array-type option, get the number of elements in the array.
Definition: opt.c:2177
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_opt_set_array
int av_opt_set_array(void *obj, const char *name, int search_flags, unsigned int start_elem, unsigned int nb_elems, enum AVOptionType val_type, const void *val)
Add, replace, or remove elements for an array option.
Definition: opt.c:2283
key
const char * key
Definition: hwcontext_opencl.c:189
AV_OPT_FLAG_IMPLICIT_KEY
@ AV_OPT_FLAG_IMPLICIT_KEY
Accept to parse a value without a key; the key will then be returned as NULL.
Definition: opt.h:724
av_opt_get_pixel_fmt
int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
Definition: opt.c:1357
av_opt_get_video_rate
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:1334
AVOptionArrayDef::size_max
unsigned size_max
Maximum number of elements in the array, 0 when unlimited.
Definition: opt.h:412
opts
AVDictionary * opts
Definition: movenc.c:51
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
av_opt_set_video_rate
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:945
av_opt_set_bin
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int size, int search_flags)
Definition: opt.c:895
av_opt_get_double
int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
Definition: opt.c:1288
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Underlying C type is uint8_t[4].
Definition: opt.h:323
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
Underlying C type is two consecutive integers.
Definition: opt.h:303
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Underlying C type is AVDictionary*.
Definition: opt.h:290
AVOptionRange::component_min
double component_min
Value's component range.
Definition: opt.h:497
options
Definition: swscale.c:42
av_opt_get_sample_fmt
int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
Definition: opt.c:1362
AVOptionRanges::range
AVOptionRange ** range
Array of option ranges.
Definition: opt.h:539
AVOption::min
double min
minimum valid value for the option
Definition: opt.h:466
av_opt_get_array
int av_opt_get_array(void *obj, const char *name, int search_flags, unsigned int start_elem, unsigned int nb_elems, enum AVOptionType out_type, void *out_val)
For an array-type option, retrieve the values of one or more array elements.
Definition: opt.c:2195
AV_OPT_TYPE_UINT
@ AV_OPT_TYPE_UINT
Underlying C type is unsigned int.
Definition: opt.h:335
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Underlying C type is AVChannelLayout.
Definition: opt.h:331
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1273
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:880
av_opt_copy
int av_opt_copy(void *dest, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2151
av_opt_find
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:1991
AVOptionRange
A single allowed range of values, or a single allowed value.
Definition: opt.h:485
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:317
AV_OPT_TYPE_FLAG_ARRAY
@ AV_OPT_TYPE_FLAG_ARRAY
May be combined with another regular option type to declare an array option.
Definition: opt.h:346
av_opt_set_chlayout
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *layout, int search_flags)
Definition: opt.c:1000
size
int size
Definition: twinvq_data.h:10344
AVOption::name
const char * name
Definition: opt.h:430
attribute_deprecated
#define attribute_deprecated
Definition: attributes.h:104
av_opt_eval_q
int av_opt_eval_q(void *obj, const AVOption *o, const char *val, AVRational *q_out)
AVOption::q
AVRational q
Definition: opt.h:456
av_opt_show2
int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
Show the obj options.
Definition: opt.c:1666
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
av_opt_next
const AVOption * av_opt_next(const void *obj, const AVOption *prev)
Iterate over all AVOptions belonging to obj.
Definition: opt.c:48
log.h
av_opt_set_dict2
int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition: opt.c:1962
AVOption::str
const char * str
Definition: opt.h:454
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AVOptionRanges
List of AVOptionRange structs.
Definition: opt.h:508
av_opt_eval_double
int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out)
av_opt_eval_flags
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
AVOption::dbl
double dbl
Definition: opt.h:453
pixfmt.h
av_opt_eval_int
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
dict.h
AVOption::type
enum AVOptionType type
Definition: opt.h:445
channel_layout.h
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
av_opt_get_chlayout
int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *layout)
Definition: opt.c:1367
av_opt_child_next
void * av_opt_child_next(void *obj, void *prev)
Iterate over AVOptions-enabled children of obj.
Definition: opt.c:2042
AV_OPT_TYPE_PIXEL_FMT
@ AV_OPT_TYPE_PIXEL_FMT
Underlying C type is enum AVPixelFormat.
Definition: opt.h:307
av_opt_set_defaults2
void av_opt_set_defaults2(void *s, int mask, int flags)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1683
AVOption::default_val
union AVOption::@455 default_val
Native access only, except when documented otherwise.
av_opt_query_ranges_default
int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags)
Get a default list of allowed ranges for the given option.
Definition: opt.c:2488
av_opt_query_ranges
int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags)
Get a list of allowed ranges for the given option.
Definition: opt.c:2470
av_opt_eval_float
int av_opt_eval_float(void *obj, const AVOption *o, const char *val, float *float_out)
AVOptionArrayDef::size_min
unsigned size_min
Minimum number of elements in the array.
Definition: opt.h:408
avutil.h
AVOption::unit
const char * unit
The logical unit to which the option belongs.
Definition: opt.h:479
av_opt_freep_ranges
void av_opt_freep_ranges(AVOptionRanges **ranges)
Free an AVOptionRanges struct and set it to NULL.
Definition: opt.c:2560
AVOptionRange::component_max
double component_max
Definition: opt.h:497
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1215
h
h
Definition: vp9dsp_template.c:2070
av_opt_set_dict
int av_opt_set_dict(void *obj, struct AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1986
av_opt_get_image_size
int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
Definition: opt.c:1316
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
av_opt_set_q
int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:890
av_opt_set_sample_fmt
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:979
AVOption::max
double max
maximum valid value for the option
Definition: opt.h:467
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
src
#define src
Definition: vp8dsp.c:248
av_opt_is_set_to_default_by_name
int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
Check if given option is set to its default value.
Definition: opt.c:2715
av_opt_ptr
attribute_deprecated void * av_opt_ptr(const AVClass *avclass, void *obj, const char *name)
Gets a pointer to the requested field in a struct.
Definition: opt.c:2058
AV_OPT_TYPE_UINT64
@ AV_OPT_TYPE_UINT64
Underlying C type is uint64_t.
Definition: opt.h:294
av_opt_get_q
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:1300