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 
251  AV_OPT_TYPE_BINARY, ///< offset must point to a pointer immediately followed by an int for the length
255  AV_OPT_TYPE_IMAGE_SIZE, ///< offset must point to two consecutive ints
258  AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
264 
265  /**
266  * May be combined with another regular option type to declare an array
267  * option.
268  *
269  * For array options, @ref AVOption.offset should refer to a pointer
270  * corresponding to the option type. The pointer should be immediately
271  * followed by an unsigned int that will store the number of elements in the
272  * array.
273  */
275 };
276 
277 /**
278  * A generic parameter which can be set by the user for muxing or encoding.
279  */
280 #define AV_OPT_FLAG_ENCODING_PARAM (1 << 0)
281 /**
282  * A generic parameter which can be set by the user for demuxing or decoding.
283  */
284 #define AV_OPT_FLAG_DECODING_PARAM (1 << 1)
285 #define AV_OPT_FLAG_AUDIO_PARAM (1 << 3)
286 #define AV_OPT_FLAG_VIDEO_PARAM (1 << 4)
287 #define AV_OPT_FLAG_SUBTITLE_PARAM (1 << 5)
288 /**
289  * The option is intended for exporting values to the caller.
290  */
291 #define AV_OPT_FLAG_EXPORT (1 << 6)
292 /**
293  * The option may not be set through the AVOptions API, only read.
294  * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
295  */
296 #define AV_OPT_FLAG_READONLY (1 << 7)
297 /**
298  * A generic parameter which can be set by the user for bit stream filtering.
299  */
300 #define AV_OPT_FLAG_BSF_PARAM (1 << 8)
301 
302 /**
303  * A generic parameter which can be set by the user at runtime.
304  */
305 #define AV_OPT_FLAG_RUNTIME_PARAM (1 << 15)
306 /**
307  * A generic parameter which can be set by the user for filtering.
308  */
309 #define AV_OPT_FLAG_FILTERING_PARAM (1 << 16)
310 /**
311  * Set if option is deprecated, users should refer to AVOption.help text for
312  * more information.
313  */
314 #define AV_OPT_FLAG_DEPRECATED (1 << 17)
315 /**
316  * Set if option constants can also reside in child objects.
317  */
318 #define AV_OPT_FLAG_CHILD_CONSTS (1 << 18)
319 
320 /**
321  * May be set as default_val for AV_OPT_TYPE_FLAG_ARRAY options.
322  */
323 typedef struct AVOptionArrayDef {
324  /**
325  * Native access only.
326  *
327  * Default value of the option, as would be serialized by av_opt_get() (i.e.
328  * using the value of sep as the separator).
329  */
330  const char *def;
331 
332  /**
333  * Minimum number of elements in the array. When this field is non-zero, def
334  * must be non-NULL and contain at least this number of elements.
335  */
336  unsigned size_min;
337  /**
338  * Maximum number of elements in the array, 0 when unlimited.
339  */
340  unsigned size_max;
341 
342  /**
343  * Separator between array elements in string representations of this
344  * option, used by av_opt_set() and av_opt_get(). It must be a printable
345  * ASCII character, excluding alphanumeric and the backslash. A comma is
346  * used when sep=0.
347  *
348  * The separator and the backslash must be backslash-escaped in order to
349  * appear in string representations of the option value.
350  */
351  char sep;
353 
354 /**
355  * AVOption
356  */
357 typedef struct AVOption {
358  const char *name;
359 
360  /**
361  * short English help text
362  * @todo What about other languages?
363  */
364  const char *help;
365 
366  /**
367  * Native access only.
368  *
369  * The offset relative to the context structure where the option
370  * value is stored. It should be 0 for named constants.
371  */
372  int offset;
374 
375  /**
376  * Native access only, except when documented otherwise.
377  * the default value for scalar options
378  */
379  union {
380  int64_t i64;
381  double dbl;
382  const char *str;
383  /* TODO those are unused now */
385 
386  /**
387  * Used for AV_OPT_TYPE_FLAG_ARRAY options. May be NULL.
388  *
389  * Foreign access to some members allowed, as noted in AVOptionArrayDef
390  * documentation.
391  */
393  } default_val;
394  double min; ///< minimum valid value for the option
395  double max; ///< maximum valid value for the option
396 
397  /**
398  * A combination of AV_OPT_FLAG_*.
399  */
400  int flags;
401 
402  /**
403  * The logical unit to which the option belongs. Non-constant
404  * options and corresponding named constants share the same
405  * unit. May be NULL.
406  */
407  const char *unit;
408 } AVOption;
409 
410 /**
411  * A single allowed range of values, or a single allowed value.
412  */
413 typedef struct AVOptionRange {
414  const char *str;
415  /**
416  * Value range.
417  * For string ranges this represents the min/max length.
418  * For dimensions this represents the min/max pixel count or width/height in multi-component case.
419  */
421  /**
422  * Value's component range.
423  * For string this represents the unicode range for chars, 0-127 limits to ASCII.
424  */
426  /**
427  * Range flag.
428  * If set to 1 the struct encodes a range, if set to 0 a single value.
429  */
430  int is_range;
431 } AVOptionRange;
432 
433 /**
434  * List of AVOptionRange structs.
435  */
436 typedef struct AVOptionRanges {
437  /**
438  * Array of option ranges.
439  *
440  * Most of option types use just one component.
441  * Following describes multi-component option types:
442  *
443  * AV_OPT_TYPE_IMAGE_SIZE:
444  * component index 0: range of pixel count (width * height).
445  * component index 1: range of width.
446  * component index 2: range of height.
447  *
448  * @note To obtain multi-component version of this structure, user must
449  * provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or
450  * av_opt_query_ranges_default function.
451  *
452  * Multi-component range can be read as in following example:
453  *
454  * @code
455  * int range_index, component_index;
456  * AVOptionRanges *ranges;
457  * AVOptionRange *range[3]; //may require more than 3 in the future.
458  * av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
459  * for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
460  * for (component_index = 0; component_index < ranges->nb_components; component_index++)
461  * range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index];
462  * //do something with range here.
463  * }
464  * av_opt_freep_ranges(&ranges);
465  * @endcode
466  */
468  /**
469  * Number of ranges per component.
470  */
472  /**
473  * Number of componentes.
474  */
477 
478 /**
479  * @defgroup opt_mng AVOption (un)initialization and inspection.
480  * @{
481  */
482 
483 /**
484  * Set the values of all AVOption fields to their default values.
485  *
486  * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
487  */
488 void av_opt_set_defaults(void *s);
489 
490 /**
491  * Set the values of all AVOption fields to their default values. Only these
492  * AVOption fields for which (opt->flags & mask) == flags will have their
493  * default applied to s.
494  *
495  * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
496  * @param mask combination of AV_OPT_FLAG_*
497  * @param flags combination of AV_OPT_FLAG_*
498  */
499 void av_opt_set_defaults2(void *s, int mask, int flags);
500 
501 /**
502  * Free all allocated objects in obj.
503  */
504 void av_opt_free(void *obj);
505 
506 /**
507  * Iterate over all AVOptions belonging to obj.
508  *
509  * @param obj an AVOptions-enabled struct or a double pointer to an
510  * AVClass describing it.
511  * @param prev result of the previous call to av_opt_next() on this object
512  * or NULL
513  * @return next AVOption or NULL
514  */
515 const AVOption *av_opt_next(const void *obj, const AVOption *prev);
516 
517 /**
518  * Iterate over AVOptions-enabled children of obj.
519  *
520  * @param prev result of a previous call to this function or NULL
521  * @return next AVOptions-enabled child or NULL
522  */
523 void *av_opt_child_next(void *obj, void *prev);
524 
525 /**
526  * Iterate over potential AVOptions-enabled children of parent.
527  *
528  * @param iter a pointer where iteration state is stored.
529  * @return AVClass corresponding to next potential child or NULL
530  */
531 const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
532 
533 #define AV_OPT_SEARCH_CHILDREN (1 << 0) /**< Search in possible children of the
534  given object first. */
535 /**
536  * The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
537  * instead of a required pointer to a struct containing AVClass. This is
538  * useful for searching for options without needing to allocate the corresponding
539  * object.
540  */
541 #define AV_OPT_SEARCH_FAKE_OBJ (1 << 1)
542 
543 /**
544  * In av_opt_get, return NULL if the option has a pointer type and is set to NULL,
545  * rather than returning an empty string.
546  */
547 #define AV_OPT_ALLOW_NULL (1 << 2)
548 
549 /**
550  * Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than
551  * one component for certain option types.
552  * @see AVOptionRanges for details.
553  */
554 #define AV_OPT_MULTI_COMPONENT_RANGE (1 << 12)
555 
556 /**
557  * Look for an option in an object. Consider only options which
558  * have all the specified flags set.
559  *
560  * @param[in] obj A pointer to a struct whose first element is a
561  * pointer to an AVClass.
562  * Alternatively a double pointer to an AVClass, if
563  * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
564  * @param[in] name The name of the option to look for.
565  * @param[in] unit When searching for named constants, name of the unit
566  * it belongs to.
567  * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
568  * @param search_flags A combination of AV_OPT_SEARCH_*.
569  *
570  * @return A pointer to the option found, or NULL if no option
571  * was found.
572  *
573  * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable
574  * directly with av_opt_set(). Use special calls which take an options
575  * AVDictionary (e.g. avformat_open_input()) to set options found with this
576  * flag.
577  */
578 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
579  int opt_flags, int search_flags);
580 
581 /**
582  * Look for an option in an object. Consider only options which
583  * have all the specified flags set.
584  *
585  * @param[in] obj A pointer to a struct whose first element is a
586  * pointer to an AVClass.
587  * Alternatively a double pointer to an AVClass, if
588  * AV_OPT_SEARCH_FAKE_OBJ search flag is set.
589  * @param[in] name The name of the option to look for.
590  * @param[in] unit When searching for named constants, name of the unit
591  * it belongs to.
592  * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
593  * @param search_flags A combination of AV_OPT_SEARCH_*.
594  * @param[out] target_obj if non-NULL, an object to which the option belongs will be
595  * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present
596  * in search_flags. This parameter is ignored if search_flags contain
597  * AV_OPT_SEARCH_FAKE_OBJ.
598  *
599  * @return A pointer to the option found, or NULL if no option
600  * was found.
601  */
602 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
603  int opt_flags, int search_flags, void **target_obj);
604 
605 /**
606  * Show the obj options.
607  *
608  * @param req_flags requested flags for the options to show. Show only the
609  * options for which it is opt->flags & req_flags.
610  * @param rej_flags rejected flags for the options to show. Show only the
611  * options for which it is !(opt->flags & req_flags).
612  * @param av_log_obj log context to use for showing the options
613  */
614 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
615 
616 /**
617  * Extract a key-value pair from the beginning of a string.
618  *
619  * @param ropts pointer to the options string, will be updated to
620  * point to the rest of the string (one of the pairs_sep
621  * or the final NUL)
622  * @param key_val_sep a 0-terminated list of characters used to separate
623  * key from value, for example '='
624  * @param pairs_sep a 0-terminated list of characters used to separate
625  * two pairs from each other, for example ':' or ','
626  * @param flags flags; see the AV_OPT_FLAG_* values below
627  * @param rkey parsed key; must be freed using av_free()
628  * @param rval parsed value; must be freed using av_free()
629  *
630  * @return >=0 for success, or a negative value corresponding to an
631  * AVERROR code in case of error; in particular:
632  * AVERROR(EINVAL) if no key is present
633  *
634  */
635 int av_opt_get_key_value(const char **ropts,
636  const char *key_val_sep, const char *pairs_sep,
637  unsigned flags,
638  char **rkey, char **rval);
639 
640 enum {
641 
642  /**
643  * Accept to parse a value without a key; the key will then be returned
644  * as NULL.
645  */
647 };
648 
649 /**
650  * @}
651  */
652 
653 /**
654  * @defgroup opt_write Setting and modifying option values
655  * @{
656  */
657 
658 /**
659  * Parse the key/value pairs list in opts. For each key/value pair
660  * found, stores the value in the field in ctx that is named like the
661  * key. ctx must be an AVClass context, storing is done using
662  * AVOptions.
663  *
664  * @param opts options string to parse, may be NULL
665  * @param key_val_sep a 0-terminated list of characters used to
666  * separate key from value
667  * @param pairs_sep a 0-terminated list of characters used to separate
668  * two pairs from each other
669  * @return the number of successfully set key/value pairs, or a negative
670  * value corresponding to an AVERROR code in case of error:
671  * AVERROR(EINVAL) if opts cannot be parsed,
672  * the error code issued by av_opt_set() if a key/value pair
673  * cannot be set
674  */
675 int av_set_options_string(void *ctx, const char *opts,
676  const char *key_val_sep, const char *pairs_sep);
677 
678 /**
679  * Parse the key-value pairs list in opts. For each key=value pair found,
680  * set the value of the corresponding option in ctx.
681  *
682  * @param ctx the AVClass object to set options on
683  * @param opts the options string, key-value pairs separated by a
684  * delimiter
685  * @param shorthand a NULL-terminated array of options names for shorthand
686  * notation: if the first field in opts has no key part,
687  * the key is taken from the first element of shorthand;
688  * then again for the second, etc., until either opts is
689  * finished, shorthand is finished or a named option is
690  * found; after that, all options must be named
691  * @param key_val_sep a 0-terminated list of characters used to separate
692  * key from value, for example '='
693  * @param pairs_sep a 0-terminated list of characters used to separate
694  * two pairs from each other, for example ':' or ','
695  * @return the number of successfully set key=value pairs, or a negative
696  * value corresponding to an AVERROR code in case of error:
697  * AVERROR(EINVAL) if opts cannot be parsed,
698  * the error code issued by av_set_string3() if a key/value pair
699  * cannot be set
700  *
701  * Options names must use only the following characters: a-z A-Z 0-9 - . / _
702  * Separators must use characters distinct from option names and from each
703  * other.
704  */
705 int av_opt_set_from_string(void *ctx, const char *opts,
706  const char *const *shorthand,
707  const char *key_val_sep, const char *pairs_sep);
708 
709 /**
710  * Set all the options from a given dictionary on an object.
711  *
712  * @param obj a struct whose first element is a pointer to AVClass
713  * @param options options to process. This dictionary will be freed and replaced
714  * by a new one containing all options not found in obj.
715  * Of course this new dictionary needs to be freed by caller
716  * with av_dict_free().
717  *
718  * @return 0 on success, a negative AVERROR if some option was found in obj,
719  * but could not be set.
720  *
721  * @see av_dict_copy()
722  */
723 int av_opt_set_dict(void *obj, struct AVDictionary **options);
724 
725 
726 /**
727  * Set all the options from a given dictionary on an object.
728  *
729  * @param obj a struct whose first element is a pointer to AVClass
730  * @param options options to process. This dictionary will be freed and replaced
731  * by a new one containing all options not found in obj.
732  * Of course this new dictionary needs to be freed by caller
733  * with av_dict_free().
734  * @param search_flags A combination of AV_OPT_SEARCH_*.
735  *
736  * @return 0 on success, a negative AVERROR if some option was found in obj,
737  * but could not be set.
738  *
739  * @see av_dict_copy()
740  */
741 int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags);
742 
743 /**
744  * Copy options from src object into dest object.
745  *
746  * The underlying AVClass of both src and dest must coincide. The guarantee
747  * below does not apply if this is not fulfilled.
748  *
749  * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
750  * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
751  *
752  * Even on error it is guaranteed that allocated options from src and dest
753  * no longer alias each other afterwards; in particular calling av_opt_free()
754  * on both src and dest is safe afterwards if dest has been memdup'ed from src.
755  *
756  * @param dest Object to copy from
757  * @param src Object to copy into
758  * @return 0 on success, negative on error
759  */
760 int av_opt_copy(void *dest, const void *src);
761 
762 /**
763  * @defgroup opt_set_funcs Option setting functions
764  * @{
765  * Those functions set the field of obj with the given name to value.
766  *
767  * @param[in] obj A struct whose first element is a pointer to an AVClass.
768  * @param[in] name the name of the field to set
769  * @param[in] val The value to set. In case of av_opt_set() if the field is not
770  * of a string type, then the given string is parsed.
771  * SI postfixes and some named scalars are supported.
772  * If the field is of a numeric type, it has to be a numeric or named
773  * scalar. Behavior with more than one scalar and +- infix operators
774  * is undefined.
775  * If the field is of a flags type, it has to be a sequence of numeric
776  * scalars or named flags separated by '+' or '-'. Prefixing a flag
777  * with '+' causes it to be set without affecting the other flags;
778  * similarly, '-' unsets a flag.
779  * If the field is of a dictionary type, it has to be a ':' separated list of
780  * key=value parameters. Values containing ':' special characters must be
781  * escaped.
782  * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
783  * is passed here, then the option may be set on a child of obj.
784  *
785  * @return 0 if the value has been set, or an AVERROR code in case of
786  * error:
787  * AVERROR_OPTION_NOT_FOUND if no matching option exists
788  * AVERROR(ERANGE) if the value is out of range
789  * AVERROR(EINVAL) if the value is not valid
790  */
791 int av_opt_set (void *obj, const char *name, const char *val, int search_flags);
792 int av_opt_set_int (void *obj, const char *name, int64_t val, int search_flags);
793 int av_opt_set_double (void *obj, const char *name, double val, int search_flags);
794 int av_opt_set_q (void *obj, const char *name, AVRational val, int search_flags);
795 int av_opt_set_bin (void *obj, const char *name, const uint8_t *val, int size, int search_flags);
796 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags);
797 int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
798 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
799 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
800 /**
801  * @note Any old chlayout present is discarded and replaced with a copy of the new one. The
802  * caller still owns layout and is responsible for uninitializing it.
803  */
804 int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *layout, int search_flags);
805 /**
806  * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
807  * caller still owns val is and responsible for freeing it.
808  */
809 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags);
810 
811 /**
812  * Set a binary option to an integer list.
813  *
814  * @param obj AVClass object to set options on
815  * @param name name of the binary option
816  * @param val pointer to an integer list (must have the correct type with
817  * regard to the contents of the list)
818  * @param term list terminator (usually 0 or -1)
819  * @param flags search flags
820  */
821 #define av_opt_set_int_list(obj, name, val, term, flags) \
822  (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
823  AVERROR(EINVAL) : \
824  av_opt_set_bin(obj, name, (const uint8_t *)(val), \
825  av_int_list_length(val, term) * sizeof(*(val)), flags))
826 
827 /**
828  * @}
829  * @}
830  */
831 
832 /**
833  * @defgroup opt_read Reading option values
834  * @{
835  */
836 
837 /**
838  * @defgroup opt_get_funcs Option getting functions
839  * @{
840  * Those functions get a value of the option with the given name from an object.
841  *
842  * @param[in] obj a struct whose first element is a pointer to an AVClass.
843  * @param[in] name name of the option to get.
844  * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
845  * is passed here, then the option may be found in a child of obj.
846  * @param[out] out_val value of the option will be written here
847  * @return >=0 on success, a negative error code otherwise
848  */
849 /**
850  * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
851  *
852  * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the
853  * option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
854  * and is set to NULL, *out_val will be set to NULL instead of an allocated
855  * empty string.
856  */
857 int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val);
858 int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val);
859 int av_opt_get_double (void *obj, const char *name, int search_flags, double *out_val);
860 int av_opt_get_q (void *obj, const char *name, int search_flags, AVRational *out_val);
861 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out);
862 int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
863 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
864 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
865 /**
866  * @param[out] layout The returned layout is a copy of the actual value and must
867  * be freed with av_channel_layout_uninit() by the caller
868  */
869 int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *layout);
870 /**
871  * @param[out] out_val The returned dictionary is a copy of the actual value and must
872  * be freed with av_dict_free() by the caller
873  */
874 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val);
875 /**
876  * @}
877  */
878 
879 /**
880  * @defgroup opt_eval_funcs Evaluating option strings
881  * @{
882  * This group of functions can be used to evaluate option strings
883  * and get numbers out of them. They do the same thing as av_opt_set(),
884  * except the result is written into the caller-supplied pointer.
885  *
886  * @param obj a struct whose first element is a pointer to AVClass.
887  * @param o an option for which the string is to be evaluated.
888  * @param val string to be evaluated.
889  * @param *_out value of the string will be written here.
890  *
891  * @return 0 on success, a negative number on failure.
892  */
893 int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int *flags_out);
894 int av_opt_eval_int (void *obj, const AVOption *o, const char *val, int *int_out);
895 int av_opt_eval_uint (void *obj, const AVOption *o, const char *val, unsigned *uint_out);
896 int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t *int64_out);
897 int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float *float_out);
898 int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out);
899 int av_opt_eval_q (void *obj, const AVOption *o, const char *val, AVRational *q_out);
900 /**
901  * @}
902  */
903 
904 /**
905  * Gets a pointer to the requested field in a struct.
906  * This function allows accessing a struct even when its fields are moved or
907  * renamed since the application making the access has been compiled,
908  *
909  * @returns a pointer to the field, it can be cast to the correct type and read
910  * or written to.
911  */
912 void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
913 
914 /**
915  * Check if given option is set to its default value.
916  *
917  * Options o must belong to the obj. This function must not be called to check child's options state.
918  * @see av_opt_is_set_to_default_by_name().
919  *
920  * @param obj AVClass object to check option on
921  * @param o option to be checked
922  * @return >0 when option is set to its default,
923  * 0 when option is not set its default,
924  * <0 on error
925  */
926 int av_opt_is_set_to_default(void *obj, const AVOption *o);
927 
928 /**
929  * Check if given option is set to its default value.
930  *
931  * @param obj AVClass object to check option on
932  * @param name option name
933  * @param search_flags combination of AV_OPT_SEARCH_*
934  * @return >0 when option is set to its default,
935  * 0 when option is not set its default,
936  * <0 on error
937  */
938 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags);
939 
940 /**
941  * Check whether a particular flag is set in a flags field.
942  *
943  * @param field_name the name of the flag field option
944  * @param flag_name the name of the flag to check
945  * @return non-zero if the flag is set, zero if the flag isn't set,
946  * isn't of the right type, or the flags field doesn't exist.
947  */
948 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name);
949 
950 #define AV_OPT_SERIALIZE_SKIP_DEFAULTS 0x00000001 ///< Serialize options that are not set to default values only.
951 #define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT 0x00000002 ///< Serialize options that exactly match opt_flags only.
952 #define AV_OPT_SERIALIZE_SEARCH_CHILDREN 0x00000004 ///< Serialize options in possible children of the given object.
953 
954 /**
955  * Serialize object's options.
956  *
957  * Create a string containing object's serialized options.
958  * Such string may be passed back to av_opt_set_from_string() in order to restore option values.
959  * A key/value or pairs separator occurring in the serialized value or
960  * name string are escaped through the av_escape() function.
961  *
962  * @param[in] obj AVClass object to serialize
963  * @param[in] opt_flags serialize options with all the specified flags set (AV_OPT_FLAG)
964  * @param[in] flags combination of AV_OPT_SERIALIZE_* flags
965  * @param[out] buffer Pointer to buffer that will be allocated with string containg serialized options.
966  * Buffer must be freed by the caller when is no longer needed.
967  * @param[in] key_val_sep character used to separate key from value
968  * @param[in] pairs_sep character used to separate two pairs from each other
969  * @return >= 0 on success, negative on error
970  * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
971  */
972 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
973  const char key_val_sep, const char pairs_sep);
974 
975 /**
976  * @}
977  */
978 
979 /**
980  * Free an AVOptionRanges struct and set it to NULL.
981  */
982 void av_opt_freep_ranges(AVOptionRanges **ranges);
983 
984 /**
985  * Get a list of allowed ranges for the given option.
986  *
987  * The returned list may depend on other fields in obj like for example profile.
988  *
989  * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
990  * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
991  * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
992  *
993  * The result must be freed with av_opt_freep_ranges.
994  *
995  * @return number of compontents returned on success, a negative errro code otherwise
996  */
997 int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags);
998 
999 /**
1000  * Get a default list of allowed ranges for the given option.
1001  *
1002  * This list is constructed without using the AVClass.query_ranges() callback
1003  * and can be used as fallback from within the callback.
1004  *
1005  * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
1006  * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
1007  * AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
1008  *
1009  * The result must be freed with av_opt_free_ranges.
1010  *
1011  * @return number of compontents returned on success, a negative errro code otherwise
1012  */
1013 int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags);
1014 
1015 /**
1016  * @}
1017  */
1018 
1019 #endif /* AVUTIL_OPT_H */
AVOptionRange::is_range
int is_range
Range flag.
Definition: opt.h:430
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:1338
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:844
AVOption::i64
int64_t i64
Definition: opt.h:380
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:475
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:1654
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:1354
AV_OPT_TYPE_SAMPLE_FMT
@ AV_OPT_TYPE_SAMPLE_FMT
Definition: opt.h:257
AVOptionRange::value_max
double value_max
Definition: opt.h:420
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:2026
AVOptionArrayDef::sep
char sep
Separator between array elements in string representations of this option, used by av_opt_set() and a...
Definition: opt.h:351
AVOptionType
AVOptionType
Definition: opt.h:243
AVOptionArrayDef
May be set as default_val for AV_OPT_TYPE_FLAG_ARRAY options.
Definition: opt.h:323
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
offset must point to AVRational
Definition: opt.h:258
rational.h
AVOption::arr
const AVOptionArrayDef * arr
Used for AV_OPT_TYPE_FLAG_ARRAY options.
Definition: opt.h:392
AVOptionRange::value_min
double value_min
Value range.
Definition: opt.h:420
AVOptionRanges::nb_ranges
int nb_ranges
Number of ranges per component.
Definition: opt.h:471
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:804
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:1873
AVOption
AVOption.
Definition: opt.h:357
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:259
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:1973
AVOption::help
const char * help
short English help text
Definition: opt.h:364
AVOption::flags
int flags
A combination of AV_OPT_FLAG_*.
Definition: opt.h:400
AVDictionary
Definition: dict.c:34
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:250
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:2451
AV_OPT_TYPE_BINARY
@ AV_OPT_TYPE_BINARY
offset must point to a pointer immediately followed by an int for the length
Definition: opt.h:251
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:2260
AVOption::offset
int offset
Native access only.
Definition: opt.h:372
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:1851
samplefmt.h
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1925
val
static double val(void *priv, double ch)
Definition: aeval.c:78
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:747
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AVOptionArrayDef::def
const char * def
Native access only.
Definition: opt.h:330
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVOption::default_val
union AVOption::@407 default_val
Native access only, except when documented otherwise.
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:247
AVOptionRange::str
const char * str
Definition: opt.h:414
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:923
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:913
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:246
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:1793
ctx
AVFormatContext * ctx
Definition: movenc.c:49
key
const char * key
Definition: hwcontext_opencl.c:189
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:1312
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:1278
AVOptionArrayDef::size_max
unsigned size_max
Maximum number of elements in the array, 0 when unlimited.
Definition: opt.h:340
opts
AVDictionary * opts
Definition: movenc.c:51
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_opt_set_video_rate
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:866
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:814
av_opt_get_double
int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
Definition: opt.c:1232
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Definition: opt.h:260
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive ints
Definition: opt.h:255
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:252
AVOptionRange::component_min
double component_min
Value's component range.
Definition: opt.h:425
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:1317
AVOptionRanges::range
AVOptionRange ** range
Array of option ranges.
Definition: opt.h:467
AVOption::min
double min
minimum valid value for the option
Definition: opt.h:394
AV_OPT_TYPE_UINT
@ AV_OPT_TYPE_UINT
Definition: opt.h:263
AV_OPT_TYPE_CHLAYOUT
@ AV_OPT_TYPE_CHLAYOUT
Definition: opt.h:262
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1217
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:646
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:799
av_opt_copy
int av_opt_copy(void *dest, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2125
options
const OptionDef options[]
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:1967
AVOptionRange
A single allowed range of values, or a single allowed value.
Definition: opt.h:413
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
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:274
av_opt_set_chlayout
int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *layout, int search_flags)
Definition: opt.c:941
size
int size
Definition: twinvq_data.h:10344
AVOption::name
const char * name
Definition: opt.h:358
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:384
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:1642
av_opt_ptr
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:2033
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:248
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:1938
AVOption::str
const char * str
Definition: opt.h:382
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AVOptionRanges
List of AVOptionRange structs.
Definition: opt.h:436
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:381
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:373
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
Definition: opt.h:245
av_opt_get_chlayout
int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *layout)
Definition: opt.c:1322
av_opt_child_next
void * av_opt_child_next(void *obj, void *prev)
Iterate over AVOptions-enabled children of obj.
Definition: opt.c:2018
AV_OPT_TYPE_PIXEL_FMT
@ AV_OPT_TYPE_PIXEL_FMT
Definition: opt.h:256
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:1659
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:2169
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:2151
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:336
avutil.h
AVOption::unit
const char * unit
The logical unit to which the option belongs.
Definition: opt.h:407
av_opt_freep_ranges
void av_opt_freep_ranges(AVOptionRanges **ranges)
Free an AVOptionRanges struct and set it to NULL.
Definition: opt.c:2241
AVOptionRange::component_max
double component_max
Definition: opt.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1159
h
h
Definition: vp9dsp_template.c:2038
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:1962
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:1260
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
av_opt_set_q
int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
Definition: opt.c:809
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:918
AVOption::max
double max
maximum valid value for the option
Definition: opt.h:395
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
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:2396
AV_OPT_TYPE_UINT64
@ AV_OPT_TYPE_UINT64
Definition: opt.h:253
av_opt_get_q
int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
Definition: opt.c:1244