Merge commit '619a433eca2c5655c41b799e0b06380020fb1498'
authorJames Almer <jamrial@gmail.com>
Mon, 23 Oct 2017 21:18:00 +0000 (18:18 -0300)
committerJames Almer <jamrial@gmail.com>
Mon, 23 Oct 2017 21:18:00 +0000 (18:18 -0300)
* commit '619a433eca2c5655c41b799e0b06380020fb1498':
  lavu: Drop deprecated option type

Merged-by: James Almer <jamrial@gmail.com>
1  2 
libavutil/opt.h
libavutil/version.h

diff --combined libavutil/opt.h
@@@ -2,20 -2,20 +2,20 @@@
   * AVOptions
   * copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -31,9 -31,6 +31,9 @@@
  #include "avutil.h"
  #include "dict.h"
  #include "log.h"
 +#include "pixfmt.h"
 +#include "samplefmt.h"
 +#include "version.h"
  
  /**
   * @defgroup avoptions AVOptions
@@@ -47,7 -44,7 +47,7 @@@
   * This section describes how to add AVOptions capabilities to a struct.
   *
   * All AVOptions-related information is stored in an AVClass. Therefore
 - * the first member of the struct must be a pointer to an AVClass describing it.
 + * the first member of the struct should be a pointer to an AVClass describing it.
   * The option field of the AVClass must be set to a NULL-terminated static array
   * of AVOptions. Each AVOption must have a non-empty name, a type, a default
   * value and for number-type AVOptions also a range of allowed values. It must
@@@ -58,7 -55,7 +58,7 @@@
   * The following example illustrates an AVOptions-enabled struct:
   * @code
   * typedef struct test_struct {
 - *     AVClass *class;
 + *     const AVClass *class;
   *     int      int_opt;
   *     char    *str_opt;
   *     uint8_t *bin_opt;
@@@ -84,7 -81,7 +84,7 @@@
   * @endcode
   *
   * Next, when allocating your struct, you must ensure that the AVClass pointer
 - * is set to the correct value. Then, av_opt_set_defaults() must be called to
 + * is set to the correct value. Then, av_opt_set_defaults() can be called to
   * initialize defaults. After that the struct is ready to be used with the
   * AVOptions API.
   *
@@@ -96,7 -93,7 +96,7 @@@
   * @code
   * test_struct *alloc_test_struct(void)
   * {
 - *     test_struct *ret = av_malloc(sizeof(*ret));
 + *     test_struct *ret = av_mallocz(sizeof(*ret));
   *     ret->class = &test_class;
   *     av_opt_set_defaults(ret);
   *     return ret;
   *
   * @subsection avoptions_implement_named_constants Named constants
   *      It is possible to create named constants for options. Simply set the unit
 - *      field of the option the constants should apply to to a string and
 + *      field of the option the constants should apply to a string and
   *      create the constants themselves as options of type AV_OPT_TYPE_CONST
   *      with their unit field set to the same string.
   *      Their default_val field should contain the value of the named
   *
   * @section avoptions_use Using AVOptions
   * This section deals with accessing options in an AVOptions-enabled struct.
 - * Such structs in Libav are e.g. AVCodecContext in libavcodec or
 + * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or
   * AVFormatContext in libavformat.
   *
   * @subsection avoptions_use_examine Examining AVOptions
   * In some cases it may be more convenient to put all options into an
   * AVDictionary and call av_opt_set_dict() on it. A specific case of this
   * are the format/codec open functions in lavf/lavc which take a dictionary
 - * filled with option as a parameter. This allows to set some options
 + * filled with option as a parameter. This makes it possible to set some options
   * that cannot be set otherwise, since e.g. the input file format is not known
   * before the file is actually opened.
   */
@@@ -228,16 -225,7 +228,16 @@@ enum AVOptionType
      AV_OPT_TYPE_RATIONAL,
      AV_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
      AV_OPT_TYPE_DICT,
 +    AV_OPT_TYPE_UINT64,
      AV_OPT_TYPE_CONST = 128,
 +    AV_OPT_TYPE_IMAGE_SIZE = MKBETAG('S','I','Z','E'), ///< offset must point to two consecutive integers
 +    AV_OPT_TYPE_PIXEL_FMT  = MKBETAG('P','F','M','T'),
 +    AV_OPT_TYPE_SAMPLE_FMT = MKBETAG('S','F','M','T'),
 +    AV_OPT_TYPE_VIDEO_RATE = MKBETAG('V','R','A','T'), ///< offset must point to AVRational
 +    AV_OPT_TYPE_DURATION   = MKBETAG('D','U','R',' '),
 +    AV_OPT_TYPE_COLOR      = MKBETAG('C','O','L','R'),
 +    AV_OPT_TYPE_CHANNEL_LAYOUT = MKBETAG('C','H','L','A'),
 +    AV_OPT_TYPE_BOOL           = MKBETAG('B','O','O','L'),
  };
  
  /**
@@@ -275,9 -263,6 +275,6 @@@ typedef struct AVOption 
      int flags;
  #define AV_OPT_FLAG_ENCODING_PARAM  1   ///< a generic parameter which can be set by the user for muxing or encoding
  #define AV_OPT_FLAG_DECODING_PARAM  2   ///< a generic parameter which can be set by the user for demuxing or decoding
- #if FF_API_OPT_TYPE_METADATA
- #define AV_OPT_FLAG_METADATA        4   ///< some data extracted or inserted into the file like title, comment, ...
- #endif
  #define AV_OPT_FLAG_AUDIO_PARAM     8
  #define AV_OPT_FLAG_VIDEO_PARAM     16
  #define AV_OPT_FLAG_SUBTITLE_PARAM  32
   * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
   */
  #define AV_OPT_FLAG_READONLY        128
 +#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
  //FIXME think about enc-audio, ... style flags
  
      /**
  } AVOption;
  
  /**
 + * A single allowed range of values, or a single allowed value.
 + */
 +typedef struct AVOptionRange {
 +    const char *str;
 +    /**
 +     * Value range.
 +     * For string ranges this represents the min/max length.
 +     * For dimensions this represents the min/max pixel count or width/height in multi-component case.
 +     */
 +    double value_min, value_max;
 +    /**
 +     * Value's component range.
 +     * For string this represents the unicode range for chars, 0-127 limits to ASCII.
 +     */
 +    double component_min, component_max;
 +    /**
 +     * Range flag.
 +     * If set to 1 the struct encodes a range, if set to 0 a single value.
 +     */
 +    int is_range;
 +} AVOptionRange;
 +
 +/**
 + * List of AVOptionRange structs.
 + */
 +typedef struct AVOptionRanges {
 +    /**
 +     * Array of option ranges.
 +     *
 +     * Most of option types use just one component.
 +     * Following describes multi-component option types:
 +     *
 +     * AV_OPT_TYPE_IMAGE_SIZE:
 +     * component index 0: range of pixel count (width * height).
 +     * component index 1: range of width.
 +     * component index 2: range of height.
 +     *
 +     * @note To obtain multi-component version of this structure, user must
 +     *       provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or
 +     *       av_opt_query_ranges_default function.
 +     *
 +     * Multi-component range can be read as in following example:
 +     *
 +     * @code
 +     * int range_index, component_index;
 +     * AVOptionRanges *ranges;
 +     * AVOptionRange *range[3]; //may require more than 3 in the future.
 +     * av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
 +     * for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
 +     *     for (component_index = 0; component_index < ranges->nb_components; component_index++)
 +     *         range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index];
 +     *     //do something with range here.
 +     * }
 +     * av_opt_freep_ranges(&ranges);
 +     * @endcode
 +     */
 +    AVOptionRange **range;
 +    /**
 +     * Number of ranges per component.
 +     */
 +    int nb_ranges;
 +    /**
 +     * Number of componentes.
 +     */
 +    int nb_components;
 +} AVOptionRanges;
 +
 +/**
   * Show the obj options.
   *
   * @param req_flags requested flags for the options to show. Show only the
@@@ -388,23 -304,11 +385,23 @@@ int av_opt_show2(void *obj, void *av_lo
  void av_opt_set_defaults(void *s);
  
  /**
 + * Set the values of all AVOption fields to their default values. Only these
 + * AVOption fields for which (opt->flags & mask) == flags will have their
 + * default applied to s.
 + *
 + * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
 + * @param mask combination of AV_OPT_FLAG_*
 + * @param flags combination of AV_OPT_FLAG_*
 + */
 +void av_opt_set_defaults2(void *s, int mask, int flags);
 +
 +/**
   * Parse the key/value pairs list in opts. For each key/value pair
   * found, stores the value in the field in ctx that is named like the
   * key. ctx must be an AVClass context, storing is done using
   * AVOptions.
   *
 + * @param opts options string to parse, may be NULL
   * @param key_val_sep a 0-terminated list of characters used to
   * separate key from value
   * @param pairs_sep a 0-terminated list of characters used to separate
@@@ -419,36 -323,6 +416,36 @@@ int av_set_options_string(void *ctx, co
                            const char *key_val_sep, const char *pairs_sep);
  
  /**
 + * Parse the key-value pairs list in opts. For each key=value pair found,
 + * set the value of the corresponding option in ctx.
 + *
 + * @param ctx          the AVClass object to set options on
 + * @param opts         the options string, key-value pairs separated by a
 + *                     delimiter
 + * @param shorthand    a NULL-terminated array of options names for shorthand
 + *                     notation: if the first field in opts has no key part,
 + *                     the key is taken from the first element of shorthand;
 + *                     then again for the second, etc., until either opts is
 + *                     finished, shorthand is finished or a named option is
 + *                     found; after that, all options must be named
 + * @param key_val_sep  a 0-terminated list of characters used to separate
 + *                     key from value, for example '='
 + * @param pairs_sep    a 0-terminated list of characters used to separate
 + *                     two pairs from each other, for example ':' or ','
 + * @return  the number of successfully set key=value pairs, or a negative
 + *          value corresponding to an AVERROR code in case of error:
 + *          AVERROR(EINVAL) if opts cannot be parsed,
 + *          the error code issued by av_set_string3() if a key/value pair
 + *          cannot be set
 + *
 + * Options names must use only the following characters: a-z A-Z 0-9 - . / _
 + * Separators must use characters distinct from option names and from each
 + * other.
 + */
 +int av_opt_set_from_string(void *ctx, const char *opts,
 +                           const char *const *shorthand,
 +                           const char *key_val_sep, const char *pairs_sep);
 +/**
   * Free all allocated objects in obj.
   */
  void av_opt_free(void *obj);
   */
  int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name);
  
 -/*
 +/**
   * Set all the options from a given dictionary on an object.
   *
   * @param obj a struct whose first element is a pointer to AVClass
   */
  int av_opt_set_dict(void *obj, struct AVDictionary **options);
  
 +
 +/**
 + * Set all the options from a given dictionary on an object.
 + *
 + * @param obj a struct whose first element is a pointer to AVClass
 + * @param options options to process. This dictionary will be freed and replaced
 + *                by a new one containing all options not found in obj.
 + *                Of course this new dictionary needs to be freed by caller
 + *                with av_dict_free().
 + * @param search_flags A combination of AV_OPT_SEARCH_*.
 + *
 + * @return 0 on success, a negative AVERROR if some option was found in obj,
 + *         but could not be set.
 + *
 + * @see av_dict_copy()
 + */
 +int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags);
 +
 +/**
 + * Extract a key-value pair from the beginning of a string.
 + *
 + * @param ropts        pointer to the options string, will be updated to
 + *                     point to the rest of the string (one of the pairs_sep
 + *                     or the final NUL)
 + * @param key_val_sep  a 0-terminated list of characters used to separate
 + *                     key from value, for example '='
 + * @param pairs_sep    a 0-terminated list of characters used to separate
 + *                     two pairs from each other, for example ':' or ','
 + * @param flags        flags; see the AV_OPT_FLAG_* values below
 + * @param rkey         parsed key; must be freed using av_free()
 + * @param rval         parsed value; must be freed using av_free()
 + *
 + * @return  >=0 for success, or a negative value corresponding to an
 + *          AVERROR code in case of error; in particular:
 + *          AVERROR(EINVAL) if no key is present
 + *
 + */
 +int av_opt_get_key_value(const char **ropts,
 +                         const char *key_val_sep, const char *pairs_sep,
 +                         unsigned flags,
 +                         char **rkey, char **rval);
 +
 +enum {
 +
 +    /**
 +     * Accept to parse a value without a key; the key will then be returned
 +     * as NULL.
 +     */
 +    AV_OPT_FLAG_IMPLICIT_KEY = 1,
 +};
 +
  /**
   * @defgroup opt_eval_funcs Evaluating option strings
   * @{
@@@ -554,28 -377,15 +551,28 @@@ int av_opt_eval_q     (void *obj, cons
   * @}
   */
  
 -#define AV_OPT_SEARCH_CHILDREN   0x0001 /**< Search in possible children of the
 -                                             given object first. */
 +#define AV_OPT_SEARCH_CHILDREN   (1 << 0) /**< Search in possible children of the
 +                                               given object first. */
  /**
   *  The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
   *  instead of a required pointer to a struct containing AVClass. This is
   *  useful for searching for options without needing to allocate the corresponding
   *  object.
   */
 -#define AV_OPT_SEARCH_FAKE_OBJ   0x0002
 +#define AV_OPT_SEARCH_FAKE_OBJ   (1 << 1)
 +
 +/**
 + *  In av_opt_get, return NULL if the option has a pointer type and is set to NULL,
 + *  rather than returning an empty string.
 + */
 +#define AV_OPT_ALLOW_NULL (1 << 2)
 +
 +/**
 + *  Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than
 + *  one component for certain option types.
 + *  @see AVOptionRanges for details.
 + */
 +#define AV_OPT_MULTI_COMPONENT_RANGE (1 << 12)
  
  /**
   * Look for an option in an object. Consider only options which
@@@ -684,33 -494,11 +681,33 @@@ int av_opt_set_int     (void *obj, cons
  int av_opt_set_double  (void *obj, const char *name, double      val, int search_flags);
  int av_opt_set_q       (void *obj, const char *name, AVRational  val, int search_flags);
  int av_opt_set_bin     (void *obj, const char *name, const uint8_t *val, int size, int search_flags);
 +int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags);
 +int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
 +int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
 +int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
 +int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags);
  /**
   * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
   * caller still owns val is and responsible for freeing it.
   */
  int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags);
 +
 +/**
 + * Set a binary option to an integer list.
 + *
 + * @param obj    AVClass object to set options on
 + * @param name   name of the binary option
 + * @param val    pointer to an integer list (must have the correct type with
 + *               regard to the contents of the list)
 + * @param term   list terminator (usually 0 or -1)
 + * @param flags  search flags
 + */
 +#define av_opt_set_int_list(obj, name, val, term, flags) \
 +    (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
 +     AVERROR(EINVAL) : \
 +     av_opt_set_bin(obj, name, (const uint8_t *)(val), \
 +                    av_int_list_length(val, term) * sizeof(*(val)), flags))
 +
  /**
   * @}
   */
   * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
   * is passed here, then the option may be found in a child of obj.
   * @param[out] out_val value of the option will be written here
 - * @return 0 on success, a negative error code otherwise
 + * @return >=0 on success, a negative error code otherwise
   */
  /**
 - * @note the returned string will av_malloc()ed and must be av_free()ed by the caller
 + * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
 + *
 + * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has
 + * AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set
 + * to NULL instead of an allocated empty string.
   */
  int av_opt_get         (void *obj, const char *name, int search_flags, uint8_t   **out_val);
  int av_opt_get_int     (void *obj, const char *name, int search_flags, int64_t    *out_val);
  int av_opt_get_double  (void *obj, const char *name, int search_flags, double     *out_val);
  int av_opt_get_q       (void *obj, const char *name, int search_flags, AVRational *out_val);
 +int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out);
 +int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
 +int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
 +int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
 +int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout);
  /**
   * @param[out] out_val The returned dictionary is a copy of the actual value and must
   * be freed with av_dict_free() by the caller
   */
  int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val);
 +/**
 + * @}
 + */
 +/**
 + * Gets a pointer to the requested field in a struct.
 + * This function allows accessing a struct even when its fields are moved or
 + * renamed since the application making the access has been compiled,
 + *
 + * @returns a pointer to the field, it can be cast to the correct type and read
 + *          or written to.
 + */
 +void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
 +
 +/**
 + * Free an AVOptionRanges struct and set it to NULL.
 + */
 +void av_opt_freep_ranges(AVOptionRanges **ranges);
 +
 +/**
 + * Get a list of allowed ranges for the given option.
 + *
 + * The returned list may depend on other fields in obj like for example profile.
 + *
 + * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
 + *              AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
 + *              AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
 + *
 + * The result must be freed with av_opt_freep_ranges.
 + *
 + * @return number of compontents returned on success, a negative errro code otherwise
 + */
 +int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags);
  
  /**
   * Copy options from src object into dest object.
  int av_opt_copy(void *dest, const void *src);
  
  /**
 - * @}
 + * Get a default list of allowed ranges for the given option.
 + *
 + * This list is constructed without using the AVClass.query_ranges() callback
 + * and can be used as fallback from within the callback.
 + *
 + * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
 + *              AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
 + *              AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
 + *
 + * The result must be freed with av_opt_free_ranges.
 + *
 + * @return number of compontents returned on success, a negative errro code otherwise
 + */
 +int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags);
 +
 +/**
 + * Check if given option is set to its default value.
 + *
 + * Options o must belong to the obj. This function must not be called to check child's options state.
 + * @see av_opt_is_set_to_default_by_name().
 + *
 + * @param obj  AVClass object to check option on
 + * @param o    option to be checked
 + * @return     >0 when option is set to its default,
 + *              0 when option is not set its default,
 + *             <0 on error
 + */
 +int av_opt_is_set_to_default(void *obj, const AVOption *o);
 +
 +/**
 + * Check if given option is set to its default value.
 + *
 + * @param obj          AVClass object to check option on
 + * @param name         option name
 + * @param search_flags combination of AV_OPT_SEARCH_*
 + * @return             >0 when option is set to its default,
 + *                     0 when option is not set its default,
 + *                     <0 on error
 + */
 +int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags);
 +
 +
 +#define AV_OPT_SERIALIZE_SKIP_DEFAULTS              0x00000001  ///< Serialize options that are not set to default values only.
 +#define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT            0x00000002  ///< Serialize options that exactly match opt_flags only.
 +
 +/**
 + * Serialize object's options.
 + *
 + * Create a string containing object's serialized options.
 + * Such string may be passed back to av_opt_set_from_string() in order to restore option values.
 + * A key/value or pairs separator occurring in the serialized value or
 + * name string are escaped through the av_escape() function.
 + *
 + * @param[in]  obj           AVClass object to serialize
 + * @param[in]  opt_flags     serialize options with all the specified flags set (AV_OPT_FLAG)
 + * @param[in]  flags         combination of AV_OPT_SERIALIZE_* flags
 + * @param[out] buffer        Pointer to buffer that will be allocated with string containg serialized options.
 + *                           Buffer must be freed by the caller when is no longer needed.
 + * @param[in]  key_val_sep   character used to separate key from value
 + * @param[in]  pairs_sep     character used to separate two pairs from each other
 + * @return                   >= 0 on success, negative on error
 + * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
 + */
 +int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
 +                     const char key_val_sep, const char pairs_sep);
 +/**
   * @}
   */
  
diff --combined libavutil/version.h
@@@ -1,72 -1,47 +1,72 @@@
  /*
 - * This file is part of Libav.
 + * copyright (c) 2003 Fabrice Bellard
   *
 - * Libav is free software; you can redistribute it and/or
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +/**
 + * @file
 + * @ingroup lavu
 + * Libavutil version macros
 + */
 +
  #ifndef AVUTIL_VERSION_H
  #define AVUTIL_VERSION_H
  
  #include "macros.h"
  
  /**
 - * @defgroup version_utils Library Version Macros
 + * @addtogroup version_utils
   *
   * Useful to check and match library version in order to maintain
   * backward compatibility.
   *
 + * The FFmpeg libraries follow a versioning sheme very similar to
 + * Semantic Versioning (http://semver.org/)
 + * The difference is that the component called PATCH is called MICRO in FFmpeg
 + * and its value is reset to 100 instead of 0 to keep it above or equal to 100.
 + * Also we do not increase MICRO for every bugfix or change in git master.
 + *
 + * Prior to FFmpeg 3.2 point releases did not change any lib version number to
 + * avoid aliassing different git master checkouts.
 + * Starting with FFmpeg 3.2, the released library versions will occupy
 + * a separate MAJOR.MINOR that is not used on the master development branch.
 + * That is if we branch a release of master 55.10.123 we will bump to 55.11.100
 + * for the release and master will continue at 55.12.100 after it. Each new
 + * point release will then bump the MICRO improving the usefulness of the lib
 + * versions.
 + *
   * @{
   */
  
 -#define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c)
 +#define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
  #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
  #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
  
  /**
 - * @}
 + * Extract version components from the full ::AV_VERSION_INT int as returned
 + * by functions like ::avformat_version() and ::avcodec_version()
   */
 +#define AV_VERSION_MAJOR(a) ((a) >> 16)
 +#define AV_VERSION_MINOR(a) (((a) & 0x00FF00) >> 8)
 +#define AV_VERSION_MICRO(a) ((a) & 0xFF)
  
  /**
 - * @file
 - * @ingroup lavu
 - * Libavutil version macros
 + * @}
   */
  
  /**
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 56
 -#define LIBAVUTIL_VERSION_MINOR  0
 -#define LIBAVUTIL_VERSION_MICRO  0
 +
 +#define LIBAVUTIL_VERSION_MAJOR  56
 +#define LIBAVUTIL_VERSION_MINOR   0
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \
  #define LIBAVUTIL_IDENT         "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
  
  /**
 - * @}
 - *
 - * @defgroup depr_guards Deprecation guards
 + * @defgroup lavu_depr_guards Deprecation Guards
   * FF_API_* defines may be placed below to indicate public API that will be
   * dropped at a future version bump. The defines themselves are not part of
   * the public API and may change, break or disappear at any time.
   *
 + * @note, when bumping the major version it is recommended to manually
 + * disable each FF_API_* in its own commit instead of disabling them all
 + * at once through the bump. This improves the git bisect-ability of the change.
 + *
   * @{
   */
  
- #ifndef FF_API_OPT_TYPE_METADATA
- #define FF_API_OPT_TYPE_METADATA        (LIBAVUTIL_VERSION_MAJOR < 56)
- #endif
  #ifndef FF_API_DLOG
  #define FF_API_DLOG                     (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
 -#ifndef FF_API_CRYPTO_CONTEXT
 -#define FF_API_CRYPTO_CONTEXT           (LIBAVUTIL_VERSION_MAJOR < 57)
 +#ifndef FF_API_VAAPI
 +#define FF_API_VAAPI                    (LIBAVUTIL_VERSION_MAJOR < 57)
 +#endif
 +#ifndef FF_API_FRAME_QP
 +#define FF_API_FRAME_QP                 (LIBAVUTIL_VERSION_MAJOR < 57)
  #endif
  #ifndef FF_API_PLUS1_MINUS1
  #define FF_API_PLUS1_MINUS1             (LIBAVUTIL_VERSION_MAJOR < 57)
  #ifndef FF_API_ERROR_FRAME
  #define FF_API_ERROR_FRAME              (LIBAVUTIL_VERSION_MAJOR < 57)
  #endif
 -#ifndef FF_API_VAAPI
 -#define FF_API_VAAPI                    (LIBAVUTIL_VERSION_MAJOR < 57)
 -#endif
  #ifndef FF_API_PKT_PTS
  #define FF_API_PKT_PTS                  (LIBAVUTIL_VERSION_MAJOR < 57)
  #endif
  
  /**
   * @}
 + * @}
   */
  
  #endif /* AVUTIL_VERSION_H */