bug fix encoder=libmp3lame

add so
458 changed files with 33201 additions and 40185 deletions
--- a/output/include/arm64-v8a/config.h
+++ b/output/include/arm64-v8a/config.h
--- a/output/include/arm64-v8a/libavcodec/ac3_parser.h
+++ b/output/include/arm64-v8a/libavcodec/ac3_parser.h
@ -1,36 +0,0 @@
 /*
 * AC-3 parser prototypes
 * Copyright (c) 2003 Fabrice Bellard
 * Copyright (c) 2003 Michael Niedermayer
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_AC3_PARSER_H
 #define AVCODEC_AC3_PARSER_H
 #include <stddef.h>
 #include <stdint.h>
 /**
 * Extract the bitstream ID and the frame size from AC-3 data.
 */
 int av_ac3_parse_header(const uint8_t *buf, size_t size,
                        uint8_t *bitstream_id, uint16_t *frame_size);
 #endif /* AVCODEC_AC3_PARSER_H */
--- a/output/include/arm64-v8a/libavcodec/adts_parser.h
+++ b/output/include/arm64-v8a/libavcodec/adts_parser.h
@ -1,37 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_ADTS_PARSER_H
 #define AVCODEC_ADTS_PARSER_H
 #include <stddef.h>
 #include <stdint.h>
 #define AV_AAC_ADTS_HEADER_SIZE 7
 /**
 * Extract the number of samples and frames from AAC data.
 * @param[in]  buf     pointer to AAC data buffer
 * @param[out] samples Pointer to where number of samples is written
 * @param[out] frames  Pointer to where number of frames is written
 * @return Returns 0 on success, error code on failure.
 */
 int av_adts_header_parse(const uint8_t *buf, uint32_t *samples,
                         uint8_t *frames);
 #endif /* AVCODEC_ADTS_PARSER_H */
--- a/output/include/arm64-v8a/libavcodec/avcodec.h
+++ b/output/include/arm64-v8a/libavcodec/avcodec.h
--- a/output/include/arm64-v8a/libavcodec/avdct.h
+++ b/output/include/arm64-v8a/libavcodec/avdct.h
@ -67,10 +67,6 @@ typedef struct AVDCT {
                       ptrdiff_t line_size);
    int bits_per_sample;
    void (*get_pixels_unaligned)(int16_t *block /* align 16 */,
                       const uint8_t *pixels,
                       ptrdiff_t line_size);
 } AVDCT;
 /**
--- a/output/include/arm64-v8a/libavcodec/bsf.h
+++ b/output/include/arm64-v8a/libavcodec/bsf.h
@ -1,332 +0,0 @@
 /*
 * Bitstream filters public API
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_BSF_H
 #define AVCODEC_BSF_H
 #include "libavutil/dict.h"
 #include "libavutil/log.h"
 #include "libavutil/rational.h"
 #include "codec_id.h"
 #include "codec_par.h"
 #include "packet.h"
 /**
 * @defgroup lavc_bsf Bitstream filters
 * @ingroup libavc
 *
 * Bitstream filters transform encoded media data without decoding it. This
 * allows e.g. manipulating various header values. Bitstream filters operate on
 * @ref AVPacket "AVPackets".
 *
 * The bitstream filtering API is centered around two structures:
 * AVBitStreamFilter and AVBSFContext. The former represents a bitstream filter
 * in abstract, the latter a specific filtering process. Obtain an
 * AVBitStreamFilter using av_bsf_get_by_name() or av_bsf_iterate(), then pass
 * it to av_bsf_alloc() to create an AVBSFContext. Fill in the user-settable
 * AVBSFContext fields, as described in its documentation, then call
 * av_bsf_init() to prepare the filter context for use.
 *
 * Submit packets for filtering using av_bsf_send_packet(), obtain filtered
 * results with av_bsf_receive_packet(). When no more input packets will be
 * sent, submit a NULL AVPacket to signal the end of the stream to the filter.
 * av_bsf_receive_packet() will then return trailing packets, if any are
 * produced by the filter.
 *
 * Finally, free the filter context with av_bsf_free().
 * @{
 */
 /**
 * The bitstream filter state.
 *
 * This struct must be allocated with av_bsf_alloc() and freed with
 * av_bsf_free().
 *
 * The fields in the struct will only be changed (by the caller or by the
 * filter) as described in their documentation, and are to be considered
 * immutable otherwise.
 */
 typedef struct AVBSFContext {
    /**
     * A class for logging and AVOptions
     */
    const AVClass *av_class;
    /**
     * The bitstream filter this context is an instance of.
     */
    const struct AVBitStreamFilter *filter;
    /**
     * Opaque filter-specific private data. If filter->priv_class is non-NULL,
     * this is an AVOptions-enabled struct.
     */
    void *priv_data;
    /**
     * Parameters of the input stream. This field is allocated in
     * av_bsf_alloc(), it needs to be filled by the caller before
     * av_bsf_init().
     */
    AVCodecParameters *par_in;
    /**
     * Parameters of the output stream. This field is allocated in
     * av_bsf_alloc(), it is set by the filter in av_bsf_init().
     */
    AVCodecParameters *par_out;
    /**
     * The timebase used for the timestamps of the input packets. Set by the
     * caller before av_bsf_init().
     */
    AVRational time_base_in;
    /**
     * The timebase used for the timestamps of the output packets. Set by the
     * filter in av_bsf_init().
     */
    AVRational time_base_out;
 } AVBSFContext;
 typedef struct AVBitStreamFilter {
    const char *name;
    /**
     * A list of codec ids supported by the filter, terminated by
     * AV_CODEC_ID_NONE.
     * May be NULL, in that case the bitstream filter works with any codec id.
     */
    const enum AVCodecID *codec_ids;
    /**
     * A class for the private data, used to declare bitstream filter private
     * AVOptions. This field is NULL for bitstream filters that do not declare
     * any options.
     *
     * If this field is non-NULL, the first member of the filter private data
     * must be a pointer to AVClass, which will be set by libavcodec generic
     * code to this class.
     */
    const AVClass *priv_class;
 } AVBitStreamFilter;
 /**
 * @return a bitstream filter with the specified name or NULL if no such
 *         bitstream filter exists.
 */
 const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
 /**
 * Iterate over all registered bitstream filters.
 *
 * @param opaque a pointer where libavcodec will store the iteration state. Must
 *               point to NULL to start the iteration.
 *
 * @return the next registered bitstream filter or NULL when the iteration is
 *         finished
 */
 const AVBitStreamFilter *av_bsf_iterate(void **opaque);
 /**
 * Allocate a context for a given bitstream filter. The caller must fill in the
 * context parameters as described in the documentation and then call
 * av_bsf_init() before sending any data to the filter.
 *
 * @param filter the filter for which to allocate an instance.
 * @param[out] ctx a pointer into which the pointer to the newly-allocated context
 *                 will be written. It must be freed with av_bsf_free() after the
 *                 filtering is done.
 *
 * @return 0 on success, a negative AVERROR code on failure
 */
 int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
 /**
 * Prepare the filter for use, after all the parameters and options have been
 * set.
 *
 * @param ctx a AVBSFContext previously allocated with av_bsf_alloc()
 */
 int av_bsf_init(AVBSFContext *ctx);
 /**
 * Submit a packet for filtering.
 *
 * After sending each packet, the filter must be completely drained by calling
 * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
 * AVERROR_EOF.
 *
 * @param ctx an initialized AVBSFContext
 * @param pkt the packet to filter. The bitstream filter will take ownership of
 * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
 * If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
 * it signals the end of the stream (i.e. no more non-empty packets will be sent;
 * sending more empty packets does nothing) and will cause the filter to output
 * any packets it may have buffered internally.
 *
 * @return
 *  - 0 on success.
 *  - AVERROR(EAGAIN) if packets need to be retrieved from the filter (using
 *    av_bsf_receive_packet()) before new input can be consumed.
 *  - Another negative AVERROR value if an error occurs.
 */
 int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
 /**
 * Retrieve a filtered packet.
 *
 * @param ctx an initialized AVBSFContext
 * @param[out] pkt this struct will be filled with the contents of the filtered
 *                 packet. It is owned by the caller and must be freed using
 *                 av_packet_unref() when it is no longer needed.
 *                 This parameter should be "clean" (i.e. freshly allocated
 *                 with av_packet_alloc() or unreffed with av_packet_unref())
 *                 when this function is called. If this function returns
 *                 successfully, the contents of pkt will be completely
 *                 overwritten by the returned data. On failure, pkt is not
 *                 touched.
 *
 * @return
 *  - 0 on success.
 *  - AVERROR(EAGAIN) if more packets need to be sent to the filter (using
 *    av_bsf_send_packet()) to get more output.
 *  - AVERROR_EOF if there will be no further output from the filter.
 *  - Another negative AVERROR value if an error occurs.
 *
 * @note one input packet may result in several output packets, so after sending
 * a packet with av_bsf_send_packet(), this function needs to be called
 * repeatedly until it stops returning 0. It is also possible for a filter to
 * output fewer packets than were sent to it, so this function may return
 * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
 */
 int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
 /**
 * Reset the internal bitstream filter state. Should be called e.g. when seeking.
 */
 void av_bsf_flush(AVBSFContext *ctx);
 /**
 * Free a bitstream filter context and everything associated with it; write NULL
 * into the supplied pointer.
 */
 void av_bsf_free(AVBSFContext **ctx);
 /**
 * Get the AVClass for AVBSFContext. It can be used in combination with
 * AV_OPT_SEARCH_FAKE_OBJ for examining options.
 *
 * @see av_opt_find().
 */
 const AVClass *av_bsf_get_class(void);
 /**
 * Structure for chain/list of bitstream filters.
 * Empty list can be allocated by av_bsf_list_alloc().
 */
 typedef struct AVBSFList AVBSFList;
 /**
 * Allocate empty list of bitstream filters.
 * The list must be later freed by av_bsf_list_free()
 * or finalized by av_bsf_list_finalize().
 *
 * @return Pointer to @ref AVBSFList on success, NULL in case of failure
 */
 AVBSFList *av_bsf_list_alloc(void);
 /**
 * Free list of bitstream filters.
 *
 * @param lst Pointer to pointer returned by av_bsf_list_alloc()
 */
 void av_bsf_list_free(AVBSFList **lst);
 /**
 * Append bitstream filter to the list of bitstream filters.
 *
 * @param lst List to append to
 * @param bsf Filter context to be appended
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
 int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
 /**
 * Construct new bitstream filter context given it's name and options
 * and append it to the list of bitstream filters.
 *
 * @param lst      List to append to
 * @param bsf_name Name of the bitstream filter
 * @param options  Options for the bitstream filter, can be set to NULL
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
 int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
 /**
 * Finalize list of bitstream filters.
 *
 * This function will transform @ref AVBSFList to single @ref AVBSFContext,
 * so the whole chain of bitstream filters can be treated as single filter
 * freshly allocated by av_bsf_alloc().
 * If the call is successful, @ref AVBSFList structure is freed and lst
 * will be set to NULL. In case of failure, caller is responsible for
 * freeing the structure by av_bsf_list_free()
 *
 * @param      lst Filter list structure to be transformed
 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 *                 representing the chain of bitstream filters
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
 int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
 /**
 * Parse string describing list of bitstream filters and create single
 * @ref AVBSFContext describing the whole chain of bitstream filters.
 * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
 * allocated by av_bsf_alloc().
 *
 * @param      str String describing chain of bitstream filters in format
 *                 `bsf1[=opt1=val1:opt2=val2][,bsf2]`
 * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
 *                 representing the chain of bitstream filters
 *
 * @return >=0 on success, negative AVERROR in case of failure
 */
 int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
 /**
 * Get null/pass-through bitstream filter.
 *
 * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter
 *
 * @return
 */
 int av_bsf_get_null_filter(AVBSFContext **bsf);
 /**
 * @}
 */
 #endif // AVCODEC_BSF_H
--- a/output/include/arm64-v8a/libavcodec/codec.h
+++ b/output/include/arm64-v8a/libavcodec/codec.h
@ -1,375 +0,0 @@
 /*
 * AVCodec public API
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_CODEC_H
 #define AVCODEC_CODEC_H
 #include <stdint.h>
 #include "libavutil/avutil.h"
 #include "libavutil/hwcontext.h"
 #include "libavutil/log.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
 #include "libavutil/samplefmt.h"
 #include "libavcodec/codec_id.h"
 #include "libavcodec/version_major.h"
 /**
 * @addtogroup lavc_core
 * @{
 */
 /**
 * Decoder can use draw_horiz_band callback.
 */
 #define AV_CODEC_CAP_DRAW_HORIZ_BAND     (1 <<  0)
 /**
 * Codec uses get_buffer() or get_encode_buffer() for allocating buffers and
 * supports custom allocators.
 * If not set, it might not use get_buffer() or get_encode_buffer() at all, or
 * use operations that assume the buffer was allocated by
 * avcodec_default_get_buffer2 or avcodec_default_get_encode_buffer.
 */
 #define AV_CODEC_CAP_DR1                 (1 <<  1)
 /**
 * Encoder or decoder requires flushing with NULL input at the end in order to
 * give the complete and correct output.
 *
 * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
 *       with NULL data. The user can still send NULL data to the public encode
 *       or decode function, but libavcodec will not pass it along to the codec
 *       unless this flag is set.
 *
 * Decoders:
 * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
 * avpkt->size=0 at the end to get the delayed data until the decoder no longer
 * returns frames.
 *
 * Encoders:
 * The encoder needs to be fed with NULL data at the end of encoding until the
 * encoder no longer returns data.
 *
 * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
 *       flag also means that the encoder must set the pts and duration for
 *       each output packet. If this flag is not set, the pts and duration will
 *       be determined by libavcodec from the input frame.
 */
 #define AV_CODEC_CAP_DELAY               (1 <<  5)
 /**
 * Codec can be fed a final frame with a smaller size.
 * This can be used to prevent truncation of the last audio samples.
 */
 #define AV_CODEC_CAP_SMALL_LAST_FRAME    (1 <<  6)
 /**
 * Codec can output multiple frames per AVPacket
 * Normally demuxers return one frame at a time, demuxers which do not do
 * are connected to a parser to split what they return into proper frames.
 * This flag is reserved to the very rare category of codecs which have a
 * bitstream that cannot be split into frames without timeconsuming
 * operations like full decoding. Demuxers carrying such bitstreams thus
 * may return multiple frames in a packet. This has many disadvantages like
 * prohibiting stream copy in many cases thus it should only be considered
 * as a last resort.
 */
 #define AV_CODEC_CAP_SUBFRAMES           (1 <<  8)
 /**
 * Codec is experimental and is thus avoided in favor of non experimental
 * encoders
 */
 #define AV_CODEC_CAP_EXPERIMENTAL        (1 <<  9)
 /**
 * Codec should fill in channel configuration and samplerate instead of container
 */
 #define AV_CODEC_CAP_CHANNEL_CONF        (1 << 10)
 /**
 * Codec supports frame-level multithreading.
 */
 #define AV_CODEC_CAP_FRAME_THREADS       (1 << 12)
 /**
 * Codec supports slice-based (or partition-based) multithreading.
 */
 #define AV_CODEC_CAP_SLICE_THREADS       (1 << 13)
 /**
 * Codec supports changed parameters at any point.
 */
 #define AV_CODEC_CAP_PARAM_CHANGE        (1 << 14)
 /**
 * Codec supports multithreading through a method other than slice- or
 * frame-level multithreading. Typically this marks wrappers around
 * multithreading-capable external libraries.
 */
 #define AV_CODEC_CAP_OTHER_THREADS       (1 << 15)
 /**
 * Audio encoder supports receiving a different number of samples in each call.
 */
 #define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
 /**
 * Decoder is not a preferred choice for probing.
 * This indicates that the decoder is not a good choice for probing.
 * It could for example be an expensive to spin up hardware decoder,
 * or it could simply not provide a lot of useful information about
 * the stream.
 * A decoder marked with this flag should only be used as last resort
 * choice for probing.
 */
 #define AV_CODEC_CAP_AVOID_PROBING       (1 << 17)
 /**
 * Codec is backed by a hardware implementation. Typically used to
 * identify a non-hwaccel hardware decoder. For information about hwaccels, use
 * avcodec_get_hw_config() instead.
 */
 #define AV_CODEC_CAP_HARDWARE            (1 << 18)
 /**
 * Codec is potentially backed by a hardware implementation, but not
 * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
 * implementation provides some sort of internal fallback.
 */
 #define AV_CODEC_CAP_HYBRID              (1 << 19)
 /**
 * This encoder can reorder user opaque values from input AVFrames and return
 * them with corresponding output packets.
 * @see AV_CODEC_FLAG_COPY_OPAQUE
 */
 #define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
 /**
 * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
 * not set, the encoder must be closed and reopened to ensure that no frames
 * remain pending.
 */
 #define AV_CODEC_CAP_ENCODER_FLUSH   (1 << 21)
 /**
 * The encoder is able to output reconstructed frame data, i.e. raw frames that
 * would be produced by decoding the encoded bitstream.
 *
 * Reconstructed frame output is enabled by the AV_CODEC_FLAG_RECON_FRAME flag.
 */
 #define AV_CODEC_CAP_ENCODER_RECON_FRAME (1 << 22)
 /**
 * AVProfile.
 */
 typedef struct AVProfile {
    int profile;
    const char *name; ///< short name for the profile
 } AVProfile;
 /**
 * AVCodec.
 */
 typedef struct AVCodec {
    /**
     * Name of the codec implementation.
     * The name is globally unique among encoders and among decoders (but an
     * encoder and a decoder can share the same name).
     * This is the primary way to find a codec from the user perspective.
     */
    const char *name;
    /**
     * Descriptive name for the codec, meant to be more human readable than name.
     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
     */
    const char *long_name;
    enum AVMediaType type;
    enum AVCodecID id;
    /**
     * Codec capabilities.
     * see AV_CODEC_CAP_*
     */
    int capabilities;
    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
    const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
    const enum AVPixelFormat *pix_fmts;     ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
    const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
    const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * @deprecated use ch_layouts instead
     */
    attribute_deprecated
    const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
 #endif
    const AVClass *priv_class;              ///< AVClass for the private context
    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
    /**
     * Group name of the codec implementation.
     * This is a short symbolic name of the wrapper backing this codec. A
     * wrapper uses some kind of external implementation for the codec, such
     * as an external library, or a codec implementation provided by the OS or
     * the hardware.
     * If this field is NULL, this is a builtin, libavcodec native codec.
     * If non-NULL, this will be the suffix in AVCodec.name in most cases
     * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
     */
    const char *wrapper_name;
    /**
     * Array of supported channel layouts, terminated with a zeroed layout.
     */
    const AVChannelLayout *ch_layouts;
 } AVCodec;
 /**
 * Iterate over all registered codecs.
 *
 * @param opaque a pointer where libavcodec will store the iteration state. Must
 *               point to NULL to start the iteration.
 *
 * @return the next registered codec or NULL when the iteration is
 *         finished
 */
 const AVCodec *av_codec_iterate(void **opaque);
 /**
 * Find a registered decoder with a matching codec ID.
 *
 * @param id AVCodecID of the requested decoder
 * @return A decoder if one was found, NULL otherwise.
 */
 const AVCodec *avcodec_find_decoder(enum AVCodecID id);
 /**
 * Find a registered decoder with the specified name.
 *
 * @param name name of the requested decoder
 * @return A decoder if one was found, NULL otherwise.
 */
 const AVCodec *avcodec_find_decoder_by_name(const char *name);
 /**
 * Find a registered encoder with a matching codec ID.
 *
 * @param id AVCodecID of the requested encoder
 * @return An encoder if one was found, NULL otherwise.
 */
 const AVCodec *avcodec_find_encoder(enum AVCodecID id);
 /**
 * Find a registered encoder with the specified name.
 *
 * @param name name of the requested encoder
 * @return An encoder if one was found, NULL otherwise.
 */
 const AVCodec *avcodec_find_encoder_by_name(const char *name);
 /**
 * @return a non-zero number if codec is an encoder, zero otherwise
 */
 int av_codec_is_encoder(const AVCodec *codec);
 /**
 * @return a non-zero number if codec is a decoder, zero otherwise
 */
 int av_codec_is_decoder(const AVCodec *codec);
 /**
 * Return a name for the specified profile, if available.
 *
 * @param codec the codec that is searched for the given profile
 * @param profile the profile value for which a name is requested
 * @return A name for the profile if found, NULL otherwise.
 */
 const char *av_get_profile_name(const AVCodec *codec, int profile);
 enum {
    /**
     * The codec supports this format via the hw_device_ctx interface.
     *
     * When selecting this format, AVCodecContext.hw_device_ctx should
     * have been set to a device of the specified type before calling
     * avcodec_open2().
     */
    AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
    /**
     * The codec supports this format via the hw_frames_ctx interface.
     *
     * When selecting this format for a decoder,
     * AVCodecContext.hw_frames_ctx should be set to a suitable frames
     * context inside the get_format() callback.  The frames context
     * must have been created on a device of the specified type.
     *
     * When selecting this format for an encoder,
     * AVCodecContext.hw_frames_ctx should be set to the context which
     * will be used for the input frames before calling avcodec_open2().
     */
    AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
    /**
     * The codec supports this format by some internal method.
     *
     * This format can be selected without any additional configuration -
     * no device or frames context is required.
     */
    AV_CODEC_HW_CONFIG_METHOD_INTERNAL      = 0x04,
    /**
     * The codec supports this format by some ad-hoc method.
     *
     * Additional settings and/or function calls are required.  See the
     * codec-specific documentation for details.  (Methods requiring
     * this sort of configuration are deprecated and others should be
     * used in preference.)
     */
    AV_CODEC_HW_CONFIG_METHOD_AD_HOC        = 0x08,
 };
 typedef struct AVCodecHWConfig {
    /**
     * For decoders, a hardware pixel format which that decoder may be
     * able to decode to if suitable hardware is available.
     *
     * For encoders, a pixel format which the encoder may be able to
     * accept.  If set to AV_PIX_FMT_NONE, this applies to all pixel
     * formats supported by the codec.
     */
    enum AVPixelFormat pix_fmt;
    /**
     * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
     * setup methods which can be used with this configuration.
     */
    int methods;
    /**
     * The device type associated with the configuration.
     *
     * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
     * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
     */
    enum AVHWDeviceType device_type;
 } AVCodecHWConfig;
 /**
 * Retrieve supported hardware configurations for a codec.
 *
 * Values of index from zero to some maximum return the indexed configuration
 * descriptor; all other values return NULL.  If the codec does not support
 * any hardware configurations then it will always return NULL.
 */
 const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
 /**
 * @}
 */
 #endif /* AVCODEC_CODEC_H */
--- a/output/include/arm64-v8a/libavcodec/codec_desc.h
+++ b/output/include/arm64-v8a/libavcodec/codec_desc.h
@ -1,128 +0,0 @@
 /*
 * Codec descriptors public API
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_CODEC_DESC_H
 #define AVCODEC_CODEC_DESC_H
 #include "libavutil/avutil.h"
 #include "codec_id.h"
 /**
 * @addtogroup lavc_core
 * @{
 */
 /**
 * This struct describes the properties of a single codec described by an
 * AVCodecID.
 * @see avcodec_descriptor_get()
 */
 typedef struct AVCodecDescriptor {
    enum AVCodecID     id;
    enum AVMediaType type;
    /**
     * Name of the codec described by this descriptor. It is non-empty and
     * unique for each codec descriptor. It should contain alphanumeric
     * characters and '_' only.
     */
    const char      *name;
    /**
     * A more descriptive name for this codec. May be NULL.
     */
    const char *long_name;
    /**
     * Codec properties, a combination of AV_CODEC_PROP_* flags.
     */
    int             props;
    /**
     * MIME type(s) associated with the codec.
     * May be NULL; if not, a NULL-terminated array of MIME types.
     * The first item is always non-NULL and is the preferred MIME type.
     */
    const char *const *mime_types;
    /**
     * If non-NULL, an array of profiles recognized for this codec.
     * Terminated with FF_PROFILE_UNKNOWN.
     */
    const struct AVProfile *profiles;
 } AVCodecDescriptor;
 /**
 * Codec uses only intra compression.
 * Video and audio codecs only.
 */
 #define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
 /**
 * Codec supports lossy compression. Audio and video codecs only.
 * @note a codec may support both lossy and lossless
 * compression modes
 */
 #define AV_CODEC_PROP_LOSSY         (1 << 1)
 /**
 * Codec supports lossless compression. Audio and video codecs only.
 */
 #define AV_CODEC_PROP_LOSSLESS      (1 << 2)
 /**
 * Codec supports frame reordering. That is, the coded order (the order in which
 * the encoded packets are output by the encoders / stored / input to the
 * decoders) may be different from the presentation order of the corresponding
 * frames.
 *
 * For codecs that do not have this property set, PTS and DTS should always be
 * equal.
 */
 #define AV_CODEC_PROP_REORDER       (1 << 3)
 /**
 * Subtitle codec is bitmap based
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
 */
 #define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
 /**
 * Subtitle codec is text based.
 * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
 */
 #define AV_CODEC_PROP_TEXT_SUB      (1 << 17)
 /**
 * @return descriptor for given codec ID or NULL if no descriptor exists.
 */
 const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
 /**
 * Iterate over all codec descriptors known to libavcodec.
 *
 * @param prev previous descriptor. NULL to get the first descriptor.
 *
 * @return next descriptor or NULL after the last descriptor
 */
 const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
 /**
 * @return codec descriptor with the given name or NULL if no such descriptor
 *         exists.
 */
 const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
 /**
 * @}
 */
 #endif // AVCODEC_CODEC_DESC_H
--- a/output/include/arm64-v8a/libavcodec/codec_id.h
+++ b/output/include/arm64-v8a/libavcodec/codec_id.h
@ -1,661 +0,0 @@
 /*
 * Codec IDs
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_CODEC_ID_H
 #define AVCODEC_CODEC_ID_H
 #include "libavutil/avutil.h"
 #include "libavutil/samplefmt.h"
 #include "version_major.h"
 /**
 * @addtogroup lavc_core
 * @{
 */
 /**
 * Identify the syntax and semantics of the bitstream.
 * The principle is roughly:
 * Two decoders with the same ID can decode the same streams.
 * Two encoders with the same ID can encode compatible streams.
 * There may be slight deviations from the principle due to implementation
 * details.
 *
 * If you add a codec ID to this list, add it so that
 * 1. no value of an existing codec ID changes (that would break ABI),
 * 2. it is as close as possible to similar codecs
 *
 * After adding new codec IDs, do not forget to add an entry to the codec
 * descriptor list and bump libavcodec minor version.
 */
 enum AVCodecID {
    AV_CODEC_ID_NONE,
    /* video codecs */
    AV_CODEC_ID_MPEG1VIDEO,
    AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
    AV_CODEC_ID_H261,
    AV_CODEC_ID_H263,
    AV_CODEC_ID_RV10,
    AV_CODEC_ID_RV20,
    AV_CODEC_ID_MJPEG,
    AV_CODEC_ID_MJPEGB,
    AV_CODEC_ID_LJPEG,
    AV_CODEC_ID_SP5X,
    AV_CODEC_ID_JPEGLS,
    AV_CODEC_ID_MPEG4,
    AV_CODEC_ID_RAWVIDEO,
    AV_CODEC_ID_MSMPEG4V1,
    AV_CODEC_ID_MSMPEG4V2,
    AV_CODEC_ID_MSMPEG4V3,
    AV_CODEC_ID_WMV1,
    AV_CODEC_ID_WMV2,
    AV_CODEC_ID_H263P,
    AV_CODEC_ID_H263I,
    AV_CODEC_ID_FLV1,
    AV_CODEC_ID_SVQ1,
    AV_CODEC_ID_SVQ3,
    AV_CODEC_ID_DVVIDEO,
    AV_CODEC_ID_HUFFYUV,
    AV_CODEC_ID_CYUV,
    AV_CODEC_ID_H264,
    AV_CODEC_ID_INDEO3,
    AV_CODEC_ID_VP3,
    AV_CODEC_ID_THEORA,
    AV_CODEC_ID_ASV1,
    AV_CODEC_ID_ASV2,
    AV_CODEC_ID_FFV1,
    AV_CODEC_ID_4XM,
    AV_CODEC_ID_VCR1,
    AV_CODEC_ID_CLJR,
    AV_CODEC_ID_MDEC,
    AV_CODEC_ID_ROQ,
    AV_CODEC_ID_INTERPLAY_VIDEO,
    AV_CODEC_ID_XAN_WC3,
    AV_CODEC_ID_XAN_WC4,
    AV_CODEC_ID_RPZA,
    AV_CODEC_ID_CINEPAK,
    AV_CODEC_ID_WS_VQA,
    AV_CODEC_ID_MSRLE,
    AV_CODEC_ID_MSVIDEO1,
    AV_CODEC_ID_IDCIN,
    AV_CODEC_ID_8BPS,
    AV_CODEC_ID_SMC,
    AV_CODEC_ID_FLIC,
    AV_CODEC_ID_TRUEMOTION1,
    AV_CODEC_ID_VMDVIDEO,
    AV_CODEC_ID_MSZH,
    AV_CODEC_ID_ZLIB,
    AV_CODEC_ID_QTRLE,
    AV_CODEC_ID_TSCC,
    AV_CODEC_ID_ULTI,
    AV_CODEC_ID_QDRAW,
    AV_CODEC_ID_VIXL,
    AV_CODEC_ID_QPEG,
    AV_CODEC_ID_PNG,
    AV_CODEC_ID_PPM,
    AV_CODEC_ID_PBM,
    AV_CODEC_ID_PGM,
    AV_CODEC_ID_PGMYUV,
    AV_CODEC_ID_PAM,
    AV_CODEC_ID_FFVHUFF,
    AV_CODEC_ID_RV30,
    AV_CODEC_ID_RV40,
    AV_CODEC_ID_VC1,
    AV_CODEC_ID_WMV3,
    AV_CODEC_ID_LOCO,
    AV_CODEC_ID_WNV1,
    AV_CODEC_ID_AASC,
    AV_CODEC_ID_INDEO2,
    AV_CODEC_ID_FRAPS,
    AV_CODEC_ID_TRUEMOTION2,
    AV_CODEC_ID_BMP,
    AV_CODEC_ID_CSCD,
    AV_CODEC_ID_MMVIDEO,
    AV_CODEC_ID_ZMBV,
    AV_CODEC_ID_AVS,
    AV_CODEC_ID_SMACKVIDEO,
    AV_CODEC_ID_NUV,
    AV_CODEC_ID_KMVC,
    AV_CODEC_ID_FLASHSV,
    AV_CODEC_ID_CAVS,
    AV_CODEC_ID_JPEG2000,
    AV_CODEC_ID_VMNC,
    AV_CODEC_ID_VP5,
    AV_CODEC_ID_VP6,
    AV_CODEC_ID_VP6F,
    AV_CODEC_ID_TARGA,
    AV_CODEC_ID_DSICINVIDEO,
    AV_CODEC_ID_TIERTEXSEQVIDEO,
    AV_CODEC_ID_TIFF,
    AV_CODEC_ID_GIF,
    AV_CODEC_ID_DXA,
    AV_CODEC_ID_DNXHD,
    AV_CODEC_ID_THP,
    AV_CODEC_ID_SGI,
    AV_CODEC_ID_C93,
    AV_CODEC_ID_BETHSOFTVID,
    AV_CODEC_ID_PTX,
    AV_CODEC_ID_TXD,
    AV_CODEC_ID_VP6A,
    AV_CODEC_ID_AMV,
    AV_CODEC_ID_VB,
    AV_CODEC_ID_PCX,
    AV_CODEC_ID_SUNRAST,
    AV_CODEC_ID_INDEO4,
    AV_CODEC_ID_INDEO5,
    AV_CODEC_ID_MIMIC,
    AV_CODEC_ID_RL2,
    AV_CODEC_ID_ESCAPE124,
    AV_CODEC_ID_DIRAC,
    AV_CODEC_ID_BFI,
    AV_CODEC_ID_CMV,
    AV_CODEC_ID_MOTIONPIXELS,
    AV_CODEC_ID_TGV,
    AV_CODEC_ID_TGQ,
    AV_CODEC_ID_TQI,
    AV_CODEC_ID_AURA,
    AV_CODEC_ID_AURA2,
    AV_CODEC_ID_V210X,
    AV_CODEC_ID_TMV,
    AV_CODEC_ID_V210,
    AV_CODEC_ID_DPX,
    AV_CODEC_ID_MAD,
    AV_CODEC_ID_FRWU,
    AV_CODEC_ID_FLASHSV2,
    AV_CODEC_ID_CDGRAPHICS,
    AV_CODEC_ID_R210,
    AV_CODEC_ID_ANM,
    AV_CODEC_ID_BINKVIDEO,
    AV_CODEC_ID_IFF_ILBM,
 #define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
    AV_CODEC_ID_KGV1,
    AV_CODEC_ID_YOP,
    AV_CODEC_ID_VP8,
    AV_CODEC_ID_PICTOR,
    AV_CODEC_ID_ANSI,
    AV_CODEC_ID_A64_MULTI,
    AV_CODEC_ID_A64_MULTI5,
    AV_CODEC_ID_R10K,
    AV_CODEC_ID_MXPEG,
    AV_CODEC_ID_LAGARITH,
    AV_CODEC_ID_PRORES,
    AV_CODEC_ID_JV,
    AV_CODEC_ID_DFA,
    AV_CODEC_ID_WMV3IMAGE,
    AV_CODEC_ID_VC1IMAGE,
    AV_CODEC_ID_UTVIDEO,
    AV_CODEC_ID_BMV_VIDEO,
    AV_CODEC_ID_VBLE,
    AV_CODEC_ID_DXTORY,
    AV_CODEC_ID_V410,
    AV_CODEC_ID_XWD,
    AV_CODEC_ID_CDXL,
    AV_CODEC_ID_XBM,
    AV_CODEC_ID_ZEROCODEC,
    AV_CODEC_ID_MSS1,
    AV_CODEC_ID_MSA1,
    AV_CODEC_ID_TSCC2,
    AV_CODEC_ID_MTS2,
    AV_CODEC_ID_CLLC,
    AV_CODEC_ID_MSS2,
    AV_CODEC_ID_VP9,
    AV_CODEC_ID_AIC,
    AV_CODEC_ID_ESCAPE130,
    AV_CODEC_ID_G2M,
    AV_CODEC_ID_WEBP,
    AV_CODEC_ID_HNM4_VIDEO,
    AV_CODEC_ID_HEVC,
 #define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
    AV_CODEC_ID_FIC,
    AV_CODEC_ID_ALIAS_PIX,
    AV_CODEC_ID_BRENDER_PIX,
    AV_CODEC_ID_PAF_VIDEO,
    AV_CODEC_ID_EXR,
    AV_CODEC_ID_VP7,
    AV_CODEC_ID_SANM,
    AV_CODEC_ID_SGIRLE,
    AV_CODEC_ID_MVC1,
    AV_CODEC_ID_MVC2,
    AV_CODEC_ID_HQX,
    AV_CODEC_ID_TDSC,
    AV_CODEC_ID_HQ_HQA,
    AV_CODEC_ID_HAP,
    AV_CODEC_ID_DDS,
    AV_CODEC_ID_DXV,
    AV_CODEC_ID_SCREENPRESSO,
    AV_CODEC_ID_RSCC,
    AV_CODEC_ID_AVS2,
    AV_CODEC_ID_PGX,
    AV_CODEC_ID_AVS3,
    AV_CODEC_ID_MSP2,
    AV_CODEC_ID_VVC,
 #define AV_CODEC_ID_H266 AV_CODEC_ID_VVC
    AV_CODEC_ID_Y41P,
    AV_CODEC_ID_AVRP,
    AV_CODEC_ID_012V,
    AV_CODEC_ID_AVUI,
 #if FF_API_AYUV_CODECID
    AV_CODEC_ID_AYUV,
 #endif
    AV_CODEC_ID_TARGA_Y216,
    AV_CODEC_ID_V308,
    AV_CODEC_ID_V408,
    AV_CODEC_ID_YUV4,
    AV_CODEC_ID_AVRN,
    AV_CODEC_ID_CPIA,
    AV_CODEC_ID_XFACE,
    AV_CODEC_ID_SNOW,
    AV_CODEC_ID_SMVJPEG,
    AV_CODEC_ID_APNG,
    AV_CODEC_ID_DAALA,
    AV_CODEC_ID_CFHD,
    AV_CODEC_ID_TRUEMOTION2RT,
    AV_CODEC_ID_M101,
    AV_CODEC_ID_MAGICYUV,
    AV_CODEC_ID_SHEERVIDEO,
    AV_CODEC_ID_YLC,
    AV_CODEC_ID_PSD,
    AV_CODEC_ID_PIXLET,
    AV_CODEC_ID_SPEEDHQ,
    AV_CODEC_ID_FMVC,
    AV_CODEC_ID_SCPR,
    AV_CODEC_ID_CLEARVIDEO,
    AV_CODEC_ID_XPM,
    AV_CODEC_ID_AV1,
    AV_CODEC_ID_BITPACKED,
    AV_CODEC_ID_MSCC,
    AV_CODEC_ID_SRGC,
    AV_CODEC_ID_SVG,
    AV_CODEC_ID_GDV,
    AV_CODEC_ID_FITS,
    AV_CODEC_ID_IMM4,
    AV_CODEC_ID_PROSUMER,
    AV_CODEC_ID_MWSC,
    AV_CODEC_ID_WCMV,
    AV_CODEC_ID_RASC,
    AV_CODEC_ID_HYMT,
    AV_CODEC_ID_ARBC,
    AV_CODEC_ID_AGM,
    AV_CODEC_ID_LSCR,
    AV_CODEC_ID_VP4,
    AV_CODEC_ID_IMM5,
    AV_CODEC_ID_MVDV,
    AV_CODEC_ID_MVHA,
    AV_CODEC_ID_CDTOONS,
    AV_CODEC_ID_MV30,
    AV_CODEC_ID_NOTCHLC,
    AV_CODEC_ID_PFM,
    AV_CODEC_ID_MOBICLIP,
    AV_CODEC_ID_PHOTOCD,
    AV_CODEC_ID_IPU,
    AV_CODEC_ID_ARGO,
    AV_CODEC_ID_CRI,
    AV_CODEC_ID_SIMBIOSIS_IMX,
    AV_CODEC_ID_SGA_VIDEO,
    AV_CODEC_ID_GEM,
    AV_CODEC_ID_VBN,
    AV_CODEC_ID_JPEGXL,
    AV_CODEC_ID_QOI,
    AV_CODEC_ID_PHM,
    AV_CODEC_ID_RADIANCE_HDR,
    AV_CODEC_ID_WBMP,
    AV_CODEC_ID_MEDIA100,
    AV_CODEC_ID_VQC,
    /* various PCM "codecs" */
    AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
    AV_CODEC_ID_PCM_S16LE = 0x10000,
    AV_CODEC_ID_PCM_S16BE,
    AV_CODEC_ID_PCM_U16LE,
    AV_CODEC_ID_PCM_U16BE,
    AV_CODEC_ID_PCM_S8,
    AV_CODEC_ID_PCM_U8,
    AV_CODEC_ID_PCM_MULAW,
    AV_CODEC_ID_PCM_ALAW,
    AV_CODEC_ID_PCM_S32LE,
    AV_CODEC_ID_PCM_S32BE,
    AV_CODEC_ID_PCM_U32LE,
    AV_CODEC_ID_PCM_U32BE,
    AV_CODEC_ID_PCM_S24LE,
    AV_CODEC_ID_PCM_S24BE,
    AV_CODEC_ID_PCM_U24LE,
    AV_CODEC_ID_PCM_U24BE,
    AV_CODEC_ID_PCM_S24DAUD,
    AV_CODEC_ID_PCM_ZORK,
    AV_CODEC_ID_PCM_S16LE_PLANAR,
    AV_CODEC_ID_PCM_DVD,
    AV_CODEC_ID_PCM_F32BE,
    AV_CODEC_ID_PCM_F32LE,
    AV_CODEC_ID_PCM_F64BE,
    AV_CODEC_ID_PCM_F64LE,
    AV_CODEC_ID_PCM_BLURAY,
    AV_CODEC_ID_PCM_LXF,
    AV_CODEC_ID_S302M,
    AV_CODEC_ID_PCM_S8_PLANAR,
    AV_CODEC_ID_PCM_S24LE_PLANAR,
    AV_CODEC_ID_PCM_S32LE_PLANAR,
    AV_CODEC_ID_PCM_S16BE_PLANAR,
    AV_CODEC_ID_PCM_S64LE,
    AV_CODEC_ID_PCM_S64BE,
    AV_CODEC_ID_PCM_F16LE,
    AV_CODEC_ID_PCM_F24LE,
    AV_CODEC_ID_PCM_VIDC,
    AV_CODEC_ID_PCM_SGA,
    /* various ADPCM codecs */
    AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
    AV_CODEC_ID_ADPCM_IMA_WAV,
    AV_CODEC_ID_ADPCM_IMA_DK3,
    AV_CODEC_ID_ADPCM_IMA_DK4,
    AV_CODEC_ID_ADPCM_IMA_WS,
    AV_CODEC_ID_ADPCM_IMA_SMJPEG,
    AV_CODEC_ID_ADPCM_MS,
    AV_CODEC_ID_ADPCM_4XM,
    AV_CODEC_ID_ADPCM_XA,
    AV_CODEC_ID_ADPCM_ADX,
    AV_CODEC_ID_ADPCM_EA,
    AV_CODEC_ID_ADPCM_G726,
    AV_CODEC_ID_ADPCM_CT,
    AV_CODEC_ID_ADPCM_SWF,
    AV_CODEC_ID_ADPCM_YAMAHA,
    AV_CODEC_ID_ADPCM_SBPRO_4,
    AV_CODEC_ID_ADPCM_SBPRO_3,
    AV_CODEC_ID_ADPCM_SBPRO_2,
    AV_CODEC_ID_ADPCM_THP,
    AV_CODEC_ID_ADPCM_IMA_AMV,
    AV_CODEC_ID_ADPCM_EA_R1,
    AV_CODEC_ID_ADPCM_EA_R3,
    AV_CODEC_ID_ADPCM_EA_R2,
    AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
    AV_CODEC_ID_ADPCM_IMA_EA_EACS,
    AV_CODEC_ID_ADPCM_EA_XAS,
    AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
    AV_CODEC_ID_ADPCM_IMA_ISS,
    AV_CODEC_ID_ADPCM_G722,
    AV_CODEC_ID_ADPCM_IMA_APC,
    AV_CODEC_ID_ADPCM_VIMA,
    AV_CODEC_ID_ADPCM_AFC,
    AV_CODEC_ID_ADPCM_IMA_OKI,
    AV_CODEC_ID_ADPCM_DTK,
    AV_CODEC_ID_ADPCM_IMA_RAD,
    AV_CODEC_ID_ADPCM_G726LE,
    AV_CODEC_ID_ADPCM_THP_LE,
    AV_CODEC_ID_ADPCM_PSX,
    AV_CODEC_ID_ADPCM_AICA,
    AV_CODEC_ID_ADPCM_IMA_DAT4,
    AV_CODEC_ID_ADPCM_MTAF,
    AV_CODEC_ID_ADPCM_AGM,
    AV_CODEC_ID_ADPCM_ARGO,
    AV_CODEC_ID_ADPCM_IMA_SSI,
    AV_CODEC_ID_ADPCM_ZORK,
    AV_CODEC_ID_ADPCM_IMA_APM,
    AV_CODEC_ID_ADPCM_IMA_ALP,
    AV_CODEC_ID_ADPCM_IMA_MTF,
    AV_CODEC_ID_ADPCM_IMA_CUNNING,
    AV_CODEC_ID_ADPCM_IMA_MOFLEX,
    AV_CODEC_ID_ADPCM_IMA_ACORN,
    AV_CODEC_ID_ADPCM_XMD,
    /* AMR */
    AV_CODEC_ID_AMR_NB = 0x12000,
    AV_CODEC_ID_AMR_WB,
    /* RealAudio codecs*/
    AV_CODEC_ID_RA_144 = 0x13000,
    AV_CODEC_ID_RA_288,
    /* various DPCM codecs */
    AV_CODEC_ID_ROQ_DPCM = 0x14000,
    AV_CODEC_ID_INTERPLAY_DPCM,
    AV_CODEC_ID_XAN_DPCM,
    AV_CODEC_ID_SOL_DPCM,
    AV_CODEC_ID_SDX2_DPCM,
    AV_CODEC_ID_GREMLIN_DPCM,
    AV_CODEC_ID_DERF_DPCM,
    AV_CODEC_ID_WADY_DPCM,
    AV_CODEC_ID_CBD2_DPCM,
    /* audio codecs */
    AV_CODEC_ID_MP2 = 0x15000,
    AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
    AV_CODEC_ID_AAC,
    AV_CODEC_ID_AC3,
    AV_CODEC_ID_DTS,
    AV_CODEC_ID_VORBIS,
    AV_CODEC_ID_DVAUDIO,
    AV_CODEC_ID_WMAV1,
    AV_CODEC_ID_WMAV2,
    AV_CODEC_ID_MACE3,
    AV_CODEC_ID_MACE6,
    AV_CODEC_ID_VMDAUDIO,
    AV_CODEC_ID_FLAC,
    AV_CODEC_ID_MP3ADU,
    AV_CODEC_ID_MP3ON4,
    AV_CODEC_ID_SHORTEN,
    AV_CODEC_ID_ALAC,
    AV_CODEC_ID_WESTWOOD_SND1,
    AV_CODEC_ID_GSM, ///< as in Berlin toast format
    AV_CODEC_ID_QDM2,
    AV_CODEC_ID_COOK,
    AV_CODEC_ID_TRUESPEECH,
    AV_CODEC_ID_TTA,
    AV_CODEC_ID_SMACKAUDIO,
    AV_CODEC_ID_QCELP,
    AV_CODEC_ID_WAVPACK,
    AV_CODEC_ID_DSICINAUDIO,
    AV_CODEC_ID_IMC,
    AV_CODEC_ID_MUSEPACK7,
    AV_CODEC_ID_MLP,
    AV_CODEC_ID_GSM_MS, /* as found in WAV */
    AV_CODEC_ID_ATRAC3,
    AV_CODEC_ID_APE,
    AV_CODEC_ID_NELLYMOSER,
    AV_CODEC_ID_MUSEPACK8,
    AV_CODEC_ID_SPEEX,
    AV_CODEC_ID_WMAVOICE,
    AV_CODEC_ID_WMAPRO,
    AV_CODEC_ID_WMALOSSLESS,
    AV_CODEC_ID_ATRAC3P,
    AV_CODEC_ID_EAC3,
    AV_CODEC_ID_SIPR,
    AV_CODEC_ID_MP1,
    AV_CODEC_ID_TWINVQ,
    AV_CODEC_ID_TRUEHD,
    AV_CODEC_ID_MP4ALS,
    AV_CODEC_ID_ATRAC1,
    AV_CODEC_ID_BINKAUDIO_RDFT,
    AV_CODEC_ID_BINKAUDIO_DCT,
    AV_CODEC_ID_AAC_LATM,
    AV_CODEC_ID_QDMC,
    AV_CODEC_ID_CELT,
    AV_CODEC_ID_G723_1,
    AV_CODEC_ID_G729,
    AV_CODEC_ID_8SVX_EXP,
    AV_CODEC_ID_8SVX_FIB,
    AV_CODEC_ID_BMV_AUDIO,
    AV_CODEC_ID_RALF,
    AV_CODEC_ID_IAC,
    AV_CODEC_ID_ILBC,
    AV_CODEC_ID_OPUS,
    AV_CODEC_ID_COMFORT_NOISE,
    AV_CODEC_ID_TAK,
    AV_CODEC_ID_METASOUND,
    AV_CODEC_ID_PAF_AUDIO,
    AV_CODEC_ID_ON2AVC,
    AV_CODEC_ID_DSS_SP,
    AV_CODEC_ID_CODEC2,
    AV_CODEC_ID_FFWAVESYNTH,
    AV_CODEC_ID_SONIC,
    AV_CODEC_ID_SONIC_LS,
    AV_CODEC_ID_EVRC,
    AV_CODEC_ID_SMV,
    AV_CODEC_ID_DSD_LSBF,
    AV_CODEC_ID_DSD_MSBF,
    AV_CODEC_ID_DSD_LSBF_PLANAR,
    AV_CODEC_ID_DSD_MSBF_PLANAR,
    AV_CODEC_ID_4GV,
    AV_CODEC_ID_INTERPLAY_ACM,
    AV_CODEC_ID_XMA1,
    AV_CODEC_ID_XMA2,
    AV_CODEC_ID_DST,
    AV_CODEC_ID_ATRAC3AL,
    AV_CODEC_ID_ATRAC3PAL,
    AV_CODEC_ID_DOLBY_E,
    AV_CODEC_ID_APTX,
    AV_CODEC_ID_APTX_HD,
    AV_CODEC_ID_SBC,
    AV_CODEC_ID_ATRAC9,
    AV_CODEC_ID_HCOM,
    AV_CODEC_ID_ACELP_KELVIN,
    AV_CODEC_ID_MPEGH_3D_AUDIO,
    AV_CODEC_ID_SIREN,
    AV_CODEC_ID_HCA,
    AV_CODEC_ID_FASTAUDIO,
    AV_CODEC_ID_MSNSIREN,
    AV_CODEC_ID_DFPWM,
    AV_CODEC_ID_BONK,
    AV_CODEC_ID_MISC4,
    AV_CODEC_ID_APAC,
    AV_CODEC_ID_FTR,
    AV_CODEC_ID_WAVARC,
    AV_CODEC_ID_RKA,
    /* subtitle codecs */
    AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
    AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
    AV_CODEC_ID_DVB_SUBTITLE,
    AV_CODEC_ID_TEXT,  ///< raw UTF-8 text
    AV_CODEC_ID_XSUB,
    AV_CODEC_ID_SSA,
    AV_CODEC_ID_MOV_TEXT,
    AV_CODEC_ID_HDMV_PGS_SUBTITLE,
    AV_CODEC_ID_DVB_TELETEXT,
    AV_CODEC_ID_SRT,
    AV_CODEC_ID_MICRODVD,
    AV_CODEC_ID_EIA_608,
    AV_CODEC_ID_JACOSUB,
    AV_CODEC_ID_SAMI,
    AV_CODEC_ID_REALTEXT,
    AV_CODEC_ID_STL,
    AV_CODEC_ID_SUBVIEWER1,
    AV_CODEC_ID_SUBVIEWER,
    AV_CODEC_ID_SUBRIP,
    AV_CODEC_ID_WEBVTT,
    AV_CODEC_ID_MPL2,
    AV_CODEC_ID_VPLAYER,
    AV_CODEC_ID_PJS,
    AV_CODEC_ID_ASS,
    AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
    AV_CODEC_ID_TTML,
    AV_CODEC_ID_ARIB_CAPTION,
    /* other specific kind of codecs (generally used for attachments) */
    AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
    AV_CODEC_ID_TTF = 0x18000,
    AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
    AV_CODEC_ID_EPG,
    AV_CODEC_ID_BINTEXT,
    AV_CODEC_ID_XBIN,
    AV_CODEC_ID_IDF,
    AV_CODEC_ID_OTF,
    AV_CODEC_ID_SMPTE_KLV,
    AV_CODEC_ID_DVD_NAV,
    AV_CODEC_ID_TIMED_ID3,
    AV_CODEC_ID_BIN_DATA,
    AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
    AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
                                * stream (only used by libavformat) */
    AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
                                * stream (only used by libavformat) */
    AV_CODEC_ID_FFMETADATA = 0x21000,   ///< Dummy codec for streams containing only metadata information.
    AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
    /**
     * Dummy null video codec, useful mainly for development and debugging.
     * Null encoder/decoder discard all input and never return any output.
     */
    AV_CODEC_ID_VNULL,
    /**
     * Dummy null audio codec, useful mainly for development and debugging.
     * Null encoder/decoder discard all input and never return any output.
     */
    AV_CODEC_ID_ANULL,
 };
 /**
 * Get the type of the given codec.
 */
 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
 /**
 * Get the name of a codec.
 * @return  a static string identifying the codec; never NULL
 */
 const char *avcodec_get_name(enum AVCodecID id);
 /**
 * Return codec bits per sample.
 *
 * @param[in] codec_id the codec
 * @return Number of bits per sample or zero if unknown for the given codec.
 */
 int av_get_bits_per_sample(enum AVCodecID codec_id);
 /**
 * Return codec bits per sample.
 * Only return non-zero if the bits per sample is exactly correct, not an
 * approximation.
 *
 * @param[in] codec_id the codec
 * @return Number of bits per sample or zero if unknown for the given codec.
 */
 int av_get_exact_bits_per_sample(enum AVCodecID codec_id);
 /**
 * Return a name for the specified profile, if available.
 *
 * @param codec_id the ID of the codec to which the requested profile belongs
 * @param profile the profile value for which a name is requested
 * @return A name for the profile if found, NULL otherwise.
 *
 * @note unlike av_get_profile_name(), which searches a list of profiles
 *       supported by a specific decoder or encoder implementation, this
 *       function searches the list of profiles from the AVCodecDescriptor
 */
 const char *avcodec_profile_name(enum AVCodecID codec_id, int profile);
 /**
 * Return the PCM codec associated with a sample format.
 * @param be  endianness, 0 for little, 1 for big,
 *            -1 (or anything else) for native
 * @return  AV_CODEC_ID_PCM_* or AV_CODEC_ID_NONE
 */
 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be);
 /**
 * @}
 */
 #endif // AVCODEC_CODEC_ID_H
--- a/output/include/arm64-v8a/libavcodec/codec_par.h
+++ b/output/include/arm64-v8a/libavcodec/codec_par.h
@ -1,247 +0,0 @@
 /*
 * Codec parameters public API
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_CODEC_PAR_H
 #define AVCODEC_CODEC_PAR_H
 #include <stdint.h>
 #include "libavutil/avutil.h"
 #include "libavutil/channel_layout.h"
 #include "libavutil/rational.h"
 #include "libavutil/pixfmt.h"
 #include "codec_id.h"
 /**
 * @addtogroup lavc_core
 * @{
 */
 enum AVFieldOrder {
    AV_FIELD_UNKNOWN,
    AV_FIELD_PROGRESSIVE,
    AV_FIELD_TT,          ///< Top coded_first, top displayed first
    AV_FIELD_BB,          ///< Bottom coded first, bottom displayed first
    AV_FIELD_TB,          ///< Top coded first, bottom displayed first
    AV_FIELD_BT,          ///< Bottom coded first, top displayed first
 };
 /**
 * This struct describes the properties of an encoded stream.
 *
 * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
 * be allocated with avcodec_parameters_alloc() and freed with
 * avcodec_parameters_free().
 */
 typedef struct AVCodecParameters {
    /**
     * General type of the encoded data.
     */
    enum AVMediaType codec_type;
    /**
     * Specific type of the encoded data (the codec used).
     */
    enum AVCodecID   codec_id;
    /**
     * Additional information about the codec (corresponds to the AVI FOURCC).
     */
    uint32_t         codec_tag;
    /**
     * Extra binary data needed for initializing the decoder, codec-dependent.
     *
     * Must be allocated with av_malloc() and will be freed by
     * avcodec_parameters_free(). The allocated size of extradata must be at
     * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
     * bytes zeroed.
     */
    uint8_t *extradata;
    /**
     * Size of the extradata content in bytes.
     */
    int      extradata_size;
    /**
     * - video: the pixel format, the value corresponds to enum AVPixelFormat.
     * - audio: the sample format, the value corresponds to enum AVSampleFormat.
     */
    int format;
    /**
     * The average bitrate of the encoded data (in bits per second).
     */
    int64_t bit_rate;
    /**
     * The number of bits per sample in the codedwords.
     *
     * This is basically the bitrate per sample. It is mandatory for a bunch of
     * formats to actually decode them. It's the number of bits for one sample in
     * the actual coded bitstream.
     *
     * This could be for example 4 for ADPCM
     * For PCM formats this matches bits_per_raw_sample
     * Can be 0
     */
    int bits_per_coded_sample;
    /**
     * This is the number of valid bits in each output sample. If the
     * sample format has more bits, the least significant bits are additional
     * padding bits, which are always 0. Use right shifts to reduce the sample
     * to its actual size. For example, audio formats with 24 bit samples will
     * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
     * To get the original sample use "(int32_t)sample >> 8"."
     *
     * For ADPCM this might be 12 or 16 or similar
     * Can be 0
     */
    int bits_per_raw_sample;
    /**
     * Codec-specific bitstream restrictions that the stream conforms to.
     */
    int profile;
    int level;
    /**
     * Video only. The dimensions of the video frame in pixels.
     */
    int width;
    int height;
    /**
     * Video only. The aspect ratio (width / height) which a single pixel
     * should have when displayed.
     *
     * When the aspect ratio is unknown / undefined, the numerator should be
     * set to 0 (the denominator may have any value).
     */
    AVRational sample_aspect_ratio;
    /**
     * Video only. The order of the fields in interlaced video.
     */
    enum AVFieldOrder                  field_order;
    /**
     * Video only. Additional colorspace characteristics.
     */
    enum AVColorRange                  color_range;
    enum AVColorPrimaries              color_primaries;
    enum AVColorTransferCharacteristic color_trc;
    enum AVColorSpace                  color_space;
    enum AVChromaLocation              chroma_location;
    /**
     * Video only. Number of delayed frames.
     */
    int video_delay;
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * Audio only. The channel layout bitmask. May be 0 if the channel layout is
     * unknown or unspecified, otherwise the number of bits set must be equal to
     * the channels field.
     * @deprecated use ch_layout
     */
    attribute_deprecated
    uint64_t channel_layout;
    /**
     * Audio only. The number of audio channels.
     * @deprecated use ch_layout.nb_channels
     */
    attribute_deprecated
    int      channels;
 #endif
    /**
     * Audio only. The number of audio samples per second.
     */
    int      sample_rate;
    /**
     * Audio only. The number of bytes per coded audio frame, required by some
     * formats.
     *
     * Corresponds to nBlockAlign in WAVEFORMATEX.
     */
    int      block_align;
    /**
     * Audio only. Audio frame size, if known. Required by some formats to be static.
     */
    int      frame_size;
    /**
     * Audio only. The amount of padding (in samples) inserted by the encoder at
     * the beginning of the audio. I.e. this number of leading decoded samples
     * must be discarded by the caller to get the original audio without leading
     * padding.
     */
    int initial_padding;
    /**
     * Audio only. The amount of padding (in samples) appended by the encoder to
     * the end of the audio. I.e. this number of decoded samples must be
     * discarded by the caller from the end of the stream to get the original
     * audio without any trailing padding.
     */
    int trailing_padding;
    /**
     * Audio only. Number of samples to skip after a discontinuity.
     */
    int seek_preroll;
    /**
     * Audio only. The channel layout and number of channels.
     */
    AVChannelLayout ch_layout;
 } AVCodecParameters;
 /**
 * Allocate a new AVCodecParameters and set its fields to default values
 * (unknown/invalid/0). The returned struct must be freed with
 * avcodec_parameters_free().
 */
 AVCodecParameters *avcodec_parameters_alloc(void);
 /**
 * Free an AVCodecParameters instance and everything associated with it and
 * write NULL to the supplied pointer.
 */
 void avcodec_parameters_free(AVCodecParameters **par);
 /**
 * Copy the contents of src to dst. Any allocated fields in dst are freed and
 * replaced with newly allocated duplicates of the corresponding fields in src.
 *
 * @return >= 0 on success, a negative AVERROR code on failure.
 */
 int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
 /**
 * This function is the same as av_get_audio_frame_duration(), except it works
 * with AVCodecParameters instead of an AVCodecContext.
 */
 int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
 /**
 * @}
 */
 #endif // AVCODEC_CODEC_PAR_H
--- a/output/include/arm64-v8a/libavcodec/defs.h
+++ b/output/include/arm64-v8a/libavcodec/defs.h
@ -1,192 +0,0 @@
 /*
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_DEFS_H
 #define AVCODEC_DEFS_H
 /**
 * @file
 * @ingroup libavc
 * Misc types and constants that do not belong anywhere else.
 */
 #include <stdint.h>
 #include <stdlib.h>
 /**
 * @ingroup lavc_decoding
 * Required number of additionally allocated bytes at the end of the input bitstream for decoding.
 * This is mainly needed because some optimized bitstream readers read
 * 32 or 64 bit at once and could read over the end.<br>
 * Note: If the first 23 bits of the additional bytes are not 0, then damaged
 * MPEG bitstreams could cause overread and segfault.
 */
 #define AV_INPUT_BUFFER_PADDING_SIZE 64
 /**
 * Verify checksums embedded in the bitstream (could be of either encoded or
 * decoded data, depending on the format) and print an error message on mismatch.
 * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the
 * decoder/demuxer returning an error.
 */
 #define AV_EF_CRCCHECK       (1<<0)
 #define AV_EF_BITSTREAM      (1<<1)   ///< detect bitstream specification deviations
 #define AV_EF_BUFFER         (1<<2)   ///< detect improper bitstream length
 #define AV_EF_EXPLODE        (1<<3)   ///< abort decoding on minor error detection
 #define AV_EF_IGNORE_ERR     (1<<15)  ///< ignore errors and continue
 #define AV_EF_CAREFUL        (1<<16)  ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors
 #define AV_EF_COMPLIANT      (1<<17)  ///< consider all spec non compliances as errors
 #define AV_EF_AGGRESSIVE     (1<<18)  ///< consider things that a sane encoder/muxer should not do as an error
 #define FF_COMPLIANCE_VERY_STRICT   2 ///< Strictly conform to an older more strict version of the spec or reference software.
 #define FF_COMPLIANCE_STRICT        1 ///< Strictly conform to all the things in the spec no matter what consequences.
 #define FF_COMPLIANCE_NORMAL        0
 #define FF_COMPLIANCE_UNOFFICIAL   -1 ///< Allow unofficial extensions
 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
 /**
 * @ingroup lavc_decoding
 */
 enum AVDiscard{
    /* We leave some space between them for extensions (drop some
     * keyframes for intra-only or drop just some bidir frames). */
    AVDISCARD_NONE    =-16, ///< discard nothing
    AVDISCARD_DEFAULT =  0, ///< discard useless packets like 0 size packets in avi
    AVDISCARD_NONREF  =  8, ///< discard all non reference
    AVDISCARD_BIDIR   = 16, ///< discard all bidirectional frames
    AVDISCARD_NONINTRA= 24, ///< discard all non intra frames
    AVDISCARD_NONKEY  = 32, ///< discard all frames except keyframes
    AVDISCARD_ALL     = 48, ///< discard all
 };
 enum AVAudioServiceType {
    AV_AUDIO_SERVICE_TYPE_MAIN              = 0,
    AV_AUDIO_SERVICE_TYPE_EFFECTS           = 1,
    AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2,
    AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED  = 3,
    AV_AUDIO_SERVICE_TYPE_DIALOGUE          = 4,
    AV_AUDIO_SERVICE_TYPE_COMMENTARY        = 5,
    AV_AUDIO_SERVICE_TYPE_EMERGENCY         = 6,
    AV_AUDIO_SERVICE_TYPE_VOICE_OVER        = 7,
    AV_AUDIO_SERVICE_TYPE_KARAOKE           = 8,
    AV_AUDIO_SERVICE_TYPE_NB                   , ///< Not part of ABI
 };
 /**
 * Pan Scan area.
 * This specifies the area which should be displayed.
 * Note there may be multiple such areas for one frame.
 */
 typedef struct AVPanScan {
    /**
     * id
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
     */
    int id;
    /**
     * width and height in 1/16 pel
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
     */
    int width;
    int height;
    /**
     * position of the top left corner in 1/16 pel for up to 3 fields/frames
     * - encoding: Set by user.
     * - decoding: Set by libavcodec.
     */
    int16_t position[3][2];
 } AVPanScan;
 /**
 * This structure describes the bitrate properties of an encoded bitstream. It
 * roughly corresponds to a subset the VBV parameters for MPEG-2 or HRD
 * parameters for H.264/HEVC.
 */
 typedef struct AVCPBProperties {
    /**
     * Maximum bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int64_t max_bitrate;
    /**
     * Minimum bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int64_t min_bitrate;
    /**
     * Average bitrate of the stream, in bits per second.
     * Zero if unknown or unspecified.
     */
    int64_t avg_bitrate;
    /**
     * The size of the buffer to which the ratecontrol is applied, in bits.
     * Zero if unknown or unspecified.
     */
    int64_t buffer_size;
    /**
     * The delay between the time the packet this structure is associated with
     * is received and the time when it should be decoded, in periods of a 27MHz
     * clock.
     *
     * UINT64_MAX when unknown or unspecified.
     */
    uint64_t vbv_delay;
 } AVCPBProperties;
 /**
 * Allocate a CPB properties structure and initialize its fields to default
 * values.
 *
 * @param size if non-NULL, the size of the allocated struct will be written
 *             here. This is useful for embedding it in side data.
 *
 * @return the newly allocated struct or NULL on failure
 */
 AVCPBProperties *av_cpb_properties_alloc(size_t *size);
 /**
 * This structure supplies correlation between a packet timestamp and a wall clock
 * production time. The definition follows the Producer Reference Time ('prft')
 * as defined in ISO/IEC 14496-12
 */
 typedef struct AVProducerReferenceTime {
    /**
     * A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
     */
    int64_t wallclock;
    int flags;
 } AVProducerReferenceTime;
 /**
 * Encode extradata length to a buffer. Used by xiph codecs.
 *
 * @param s buffer to write to; must be at least (v/255+1) bytes long
 * @param v size of extradata in bytes
 * @return number of bytes written to the buffer.
 */
 unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
 #endif // AVCODEC_DEFS_H
--- a/output/include/arm64-v8a/libavcodec/dv_profile.h
+++ b/output/include/arm64-v8a/libavcodec/dv_profile.h
@ -23,6 +23,7 @@
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
 #include "avcodec.h"
 /* minimum number of bytes to read from a DV stream in order to
 * determine the profile */
--- a/output/include/arm64-v8a/libavcodec/mediacodec.h
+++ b/output/include/arm64-v8a/libavcodec/mediacodec.h
@ -85,19 +85,4 @@ typedef struct MediaCodecBuffer AVMediaCodecBuffer;
 */
 int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render);
 /**
 * Release a MediaCodec buffer and render it at the given time to the surface
 * that is associated with the decoder. The timestamp must be within one second
 * of the current `java/lang/System#nanoTime()` (which is implemented using
 * `CLOCK_MONOTONIC` on Android). See the Android MediaCodec documentation
 * of [`android/media/MediaCodec#releaseOutputBuffer(int,long)`][0] for more details.
 *
 * @param buffer the buffer to render
 * @param time timestamp in nanoseconds of when to render the buffer
 * @return 0 on success, < 0 otherwise
 *
 * [0]: https://developer.android.com/reference/android/media/MediaCodec#releaseOutputBuffer(int,%20long)
 */
 int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time);
 #endif /* AVCODEC_MEDIACODEC_H */
--- a/output/include/arm64-v8a/libavcodec/packet.h
+++ b/output/include/arm64-v8a/libavcodec/packet.h
@ -1,731 +0,0 @@
 /*
 * AVPacket public API
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_PACKET_H
 #define AVCODEC_PACKET_H
 #include <stddef.h>
 #include <stdint.h>
 #include "libavutil/attributes.h"
 #include "libavutil/buffer.h"
 #include "libavutil/dict.h"
 #include "libavutil/rational.h"
 #include "libavutil/version.h"
 #include "libavcodec/version_major.h"
 /**
 * @defgroup lavc_packet AVPacket
 *
 * Types and functions for working with AVPacket.
 * @{
 */
 enum AVPacketSideDataType {
    /**
     * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
     * bytes worth of palette. This side data signals that a new palette is
     * present.
     */
    AV_PKT_DATA_PALETTE,
    /**
     * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
     * that the extradata buffer was changed and the receiving side should
     * act upon it appropriately. The new extradata is embedded in the side
     * data buffer and should be immediately used for processing the current
     * frame or packet.
     */
    AV_PKT_DATA_NEW_EXTRADATA,
    /**
     * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
     * @code
     * u32le param_flags
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
     *     s32le channel_count
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
     *     u64le channel_layout
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
     *     s32le sample_rate
     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
     *     s32le width
     *     s32le height
     * @endcode
     */
    AV_PKT_DATA_PARAM_CHANGE,
    /**
     * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
     * structures with info about macroblocks relevant to splitting the
     * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
     * That is, it does not necessarily contain info about all macroblocks,
     * as long as the distance between macroblocks in the info is smaller
     * than the target payload size.
     * Each MB info structure is 12 bytes, and is laid out as follows:
     * @code
     * u32le bit offset from the start of the packet
     * u8    current quantizer at the start of the macroblock
     * u8    GOB number
     * u16le macroblock address within the GOB
     * u8    horizontal MV predictor
     * u8    vertical MV predictor
     * u8    horizontal MV predictor for block number 3
     * u8    vertical MV predictor for block number 3
     * @endcode
     */
    AV_PKT_DATA_H263_MB_INFO,
    /**
     * This side data should be associated with an audio stream and contains
     * ReplayGain information in form of the AVReplayGain struct.
     */
    AV_PKT_DATA_REPLAYGAIN,
    /**
     * This side data contains a 3x3 transformation matrix describing an affine
     * transformation that needs to be applied to the decoded video frames for
     * correct presentation.
     *
     * See libavutil/display.h for a detailed description of the data.
     */
    AV_PKT_DATA_DISPLAYMATRIX,
    /**
     * This side data should be associated with a video stream and contains
     * Stereoscopic 3D information in form of the AVStereo3D struct.
     */
    AV_PKT_DATA_STEREO3D,
    /**
     * This side data should be associated with an audio stream and corresponds
     * to enum AVAudioServiceType.
     */
    AV_PKT_DATA_AUDIO_SERVICE_TYPE,
    /**
     * This side data contains quality related information from the encoder.
     * @code
     * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
     * u8    picture type
     * u8    error count
     * u16   reserved
     * u64le[error count] sum of squared differences between encoder in and output
     * @endcode
     */
    AV_PKT_DATA_QUALITY_STATS,
    /**
     * This side data contains an integer value representing the stream index
     * of a "fallback" track.  A fallback track indicates an alternate
     * track to use when the current track can not be decoded for some reason.
     * e.g. no decoder available for codec.
     */
    AV_PKT_DATA_FALLBACK_TRACK,
    /**
     * This side data corresponds to the AVCPBProperties struct.
     */
    AV_PKT_DATA_CPB_PROPERTIES,
    /**
     * Recommmends skipping the specified number of samples
     * @code
     * u32le number of samples to skip from start of this packet
     * u32le number of samples to skip from end of this packet
     * u8    reason for start skip
     * u8    reason for end   skip (0=padding silence, 1=convergence)
     * @endcode
     */
    AV_PKT_DATA_SKIP_SAMPLES,
    /**
     * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
     * the packet may contain "dual mono" audio specific to Japanese DTV
     * and if it is true, recommends only the selected channel to be used.
     * @code
     * u8    selected channels (0=main/left, 1=sub/right, 2=both)
     * @endcode
     */
    AV_PKT_DATA_JP_DUALMONO,
    /**
     * A list of zero terminated key/value strings. There is no end marker for
     * the list, so it is required to rely on the side data size to stop.
     */
    AV_PKT_DATA_STRINGS_METADATA,
    /**
     * Subtitle event position
     * @code
     * u32le x1
     * u32le y1
     * u32le x2
     * u32le y2
     * @endcode
     */
    AV_PKT_DATA_SUBTITLE_POSITION,
    /**
     * Data found in BlockAdditional element of matroska container. There is
     * no end marker for the data, so it is required to rely on the side data
     * size to recognize the end. 8 byte id (as found in BlockAddId) followed
     * by data.
     */
    AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
    /**
     * The optional first identifier line of a WebVTT cue.
     */
    AV_PKT_DATA_WEBVTT_IDENTIFIER,
    /**
     * The optional settings (rendering instructions) that immediately
     * follow the timestamp specifier of a WebVTT cue.
     */
    AV_PKT_DATA_WEBVTT_SETTINGS,
    /**
     * A list of zero terminated key/value strings. There is no end marker for
     * the list, so it is required to rely on the side data size to stop. This
     * side data includes updated metadata which appeared in the stream.
     */
    AV_PKT_DATA_METADATA_UPDATE,
    /**
     * MPEGTS stream ID as uint8_t, this is required to pass the stream ID
     * information from the demuxer to the corresponding muxer.
     */
    AV_PKT_DATA_MPEGTS_STREAM_ID,
    /**
     * Mastering display metadata (based on SMPTE-2086:2014). This metadata
     * should be associated with a video stream and contains data in the form
     * of the AVMasteringDisplayMetadata struct.
     */
    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
    /**
     * This side data should be associated with a video stream and corresponds
     * to the AVSphericalMapping structure.
     */
    AV_PKT_DATA_SPHERICAL,
    /**
     * Content light level (based on CTA-861.3). This metadata should be
     * associated with a video stream and contains data in the form of the
     * AVContentLightMetadata struct.
     */
    AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
    /**
     * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
     * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
     * The number of bytes of CC data is AVPacketSideData.size.
     */
    AV_PKT_DATA_A53_CC,
    /**
     * This side data is encryption initialization data.
     * The format is not part of ABI, use av_encryption_init_info_* methods to
     * access.
     */
    AV_PKT_DATA_ENCRYPTION_INIT_INFO,
    /**
     * This side data contains encryption info for how to decrypt the packet.
     * The format is not part of ABI, use av_encryption_info_* methods to access.
     */
    AV_PKT_DATA_ENCRYPTION_INFO,
    /**
     * Active Format Description data consisting of a single byte as specified
     * in ETSI TS 101 154 using AVActiveFormatDescription enum.
     */
    AV_PKT_DATA_AFD,
    /**
     * Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
     * usually exported by some encoders (on demand through the prft flag set in the
     * AVCodecContext export_side_data field).
     */
    AV_PKT_DATA_PRFT,
    /**
     * ICC profile data consisting of an opaque octet buffer following the
     * format described by ISO 15076-1.
     */
    AV_PKT_DATA_ICC_PROFILE,
    /**
     * DOVI configuration
     * ref:
     * dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
     * dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
     * Tags are stored in struct AVDOVIDecoderConfigurationRecord.
     */
    AV_PKT_DATA_DOVI_CONF,
    /**
     * Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t
     * where the first uint32_t describes how many (1-3) of the other timecodes are used.
     * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
     * function in libavutil/timecode.h.
     */
    AV_PKT_DATA_S12M_TIMECODE,
    /**
     * HDR10+ dynamic metadata associated with a video frame. The metadata is in
     * the form of the AVDynamicHDRPlus struct and contains
     * information for color volume transform - application 4 of
     * SMPTE 2094-40:2016 standard.
     */
    AV_PKT_DATA_DYNAMIC_HDR10_PLUS,
    /**
     * The number of side data types.
     * This is not part of the public API/ABI in the sense that it may
     * change when new side data types are added.
     * This must stay the last enum value.
     * If its value becomes huge, some code using it
     * needs to be updated as it assumes it to be smaller than other limits.
     */
    AV_PKT_DATA_NB
 };
 #define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
 typedef struct AVPacketSideData {
    uint8_t *data;
    size_t   size;
    enum AVPacketSideDataType type;
 } AVPacketSideData;
 /**
 * This structure stores compressed data. It is typically exported by demuxers
 * and then passed as input to decoders, or received as output from encoders and
 * then passed to muxers.
 *
 * For video, it should typically contain one compressed frame. For audio it may
 * contain several compressed frames. Encoders are allowed to output empty
 * packets, with no compressed data, containing only side data
 * (e.g. to update some stream parameters at the end of encoding).
 *
 * The semantics of data ownership depends on the buf field.
 * If it is set, the packet data is dynamically allocated and is
 * valid indefinitely until a call to av_packet_unref() reduces the
 * reference count to 0.
 *
 * If the buf field is not set av_packet_ref() would make a copy instead
 * of increasing the reference count.
 *
 * The side data is always allocated with av_malloc(), copied by
 * av_packet_ref() and freed by av_packet_unref().
 *
 * sizeof(AVPacket) being a part of the public ABI is deprecated. once
 * av_init_packet() is removed, new packets will only be able to be allocated
 * with av_packet_alloc(), and new fields may be added to the end of the struct
 * with a minor bump.
 *
 * @see av_packet_alloc
 * @see av_packet_ref
 * @see av_packet_unref
 */
 typedef struct AVPacket {
    /**
     * A reference to the reference-counted buffer where the packet data is
     * stored.
     * May be NULL, then the packet data is not reference-counted.
     */
    AVBufferRef *buf;
    /**
     * Presentation timestamp in AVStream->time_base units; the time at which
     * the decompressed packet will be presented to the user.
     * Can be AV_NOPTS_VALUE if it is not stored in the file.
     * pts MUST be larger or equal to dts as presentation cannot happen before
     * decompression, unless one wants to view hex dumps. Some formats misuse
     * the terms dts and pts/cts to mean something different. Such timestamps
     * must be converted to true pts/dts before they are stored in AVPacket.
     */
    int64_t pts;
    /**
     * Decompression timestamp in AVStream->time_base units; the time at which
     * the packet is decompressed.
     * Can be AV_NOPTS_VALUE if it is not stored in the file.
     */
    int64_t dts;
    uint8_t *data;
    int   size;
    int   stream_index;
    /**
     * A combination of AV_PKT_FLAG values
     */
    int   flags;
    /**
     * Additional packet data that can be provided by the container.
     * Packet can contain several types of side information.
     */
    AVPacketSideData *side_data;
    int side_data_elems;
    /**
     * Duration of this packet in AVStream->time_base units, 0 if unknown.
     * Equals next_pts - this_pts in presentation order.
     */
    int64_t duration;
    int64_t pos;                            ///< byte position in stream, -1 if unknown
    /**
     * for some private data of the user
     */
    void *opaque;
    /**
     * AVBufferRef for free use by the API user. FFmpeg will never check the
     * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
     * the packet is unreferenced. av_packet_copy_props() calls create a new
     * reference with av_buffer_ref() for the target packet's opaque_ref field.
     *
     * This is unrelated to the opaque field, although it serves a similar
     * purpose.
     */
    AVBufferRef *opaque_ref;
    /**
     * Time base of the packet's timestamps.
     * In the future, this field may be set on packets output by encoders or
     * demuxers, but its value will be by default ignored on input to decoders
     * or muxers.
     */
    AVRational time_base;
 } AVPacket;
 #if FF_API_INIT_PACKET
 attribute_deprecated
 typedef struct AVPacketList {
    AVPacket pkt;
    struct AVPacketList *next;
 } AVPacketList;
 #endif
 #define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
 #define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
 /**
 * Flag is used to discard packets which are required to maintain valid
 * decoder state but are not required for output and should be dropped
 * after decoding.
 **/
 #define AV_PKT_FLAG_DISCARD   0x0004
 /**
 * The packet comes from a trusted source.
 *
 * Otherwise-unsafe constructs such as arbitrary pointers to data
 * outside the packet may be followed.
 */
 #define AV_PKT_FLAG_TRUSTED   0x0008
 /**
 * Flag is used to indicate packets that contain frames that can
 * be discarded by the decoder.  I.e. Non-reference frames.
 */
 #define AV_PKT_FLAG_DISPOSABLE 0x0010
 enum AVSideDataParamChangeFlags {
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * @deprecated those are not used by any decoder
     */
    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
 #endif
    AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE    = 0x0004,
    AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS     = 0x0008,
 };
 /**
 * Allocate an AVPacket and set its fields to default values.  The resulting
 * struct must be freed using av_packet_free().
 *
 * @return An AVPacket filled with default values or NULL on failure.
 *
 * @note this only allocates the AVPacket itself, not the data buffers. Those
 * must be allocated through other means such as av_new_packet.
 *
 * @see av_new_packet
 */
 AVPacket *av_packet_alloc(void);
 /**
 * Create a new packet that references the same data as src.
 *
 * This is a shortcut for av_packet_alloc()+av_packet_ref().
 *
 * @return newly created AVPacket on success, NULL on error.
 *
 * @see av_packet_alloc
 * @see av_packet_ref
 */
 AVPacket *av_packet_clone(const AVPacket *src);
 /**
 * Free the packet, if the packet is reference counted, it will be
 * unreferenced first.
 *
 * @param pkt packet to be freed. The pointer will be set to NULL.
 * @note passing NULL is a no-op.
 */
 void av_packet_free(AVPacket **pkt);
 #if FF_API_INIT_PACKET
 /**
 * Initialize optional fields of a packet with default values.
 *
 * Note, this does not touch the data and size members, which have to be
 * initialized separately.
 *
 * @param pkt packet
 *
 * @see av_packet_alloc
 * @see av_packet_unref
 *
 * @deprecated This function is deprecated. Once it's removed,
               sizeof(AVPacket) will not be a part of the ABI anymore.
 */
 attribute_deprecated
 void av_init_packet(AVPacket *pkt);
 #endif
 /**
 * Allocate the payload of a packet and initialize its fields with
 * default values.
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK, AVERROR_xxx otherwise
 */
 int av_new_packet(AVPacket *pkt, int size);
 /**
 * Reduce packet size, correctly zeroing padding
 *
 * @param pkt packet
 * @param size new size
 */
 void av_shrink_packet(AVPacket *pkt, int size);
 /**
 * Increase packet size, correctly zeroing padding
 *
 * @param pkt packet
 * @param grow_by number of bytes by which to increase the size of the packet
 */
 int av_grow_packet(AVPacket *pkt, int grow_by);
 /**
 * Initialize a reference-counted packet from av_malloc()ed data.
 *
 * @param pkt packet to be initialized. This function will set the data, size,
 *        and buf fields, all others are left untouched.
 * @param data Data allocated by av_malloc() to be used as packet data. If this
 *        function returns successfully, the data is owned by the underlying AVBuffer.
 *        The caller may not access the data through other means.
 * @param size size of data in bytes, without the padding. I.e. the full buffer
 *        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
 *
 * @return 0 on success, a negative AVERROR on error
 */
 int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
 /**
 * Allocate new information of a packet.
 *
 * @param pkt packet
 * @param type side information type
 * @param size side information size
 * @return pointer to fresh allocated data or NULL otherwise
 */
 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                                 size_t size);
 /**
 * Wrap an existing array as a packet side data.
 *
 * @param pkt packet
 * @param type side information type
 * @param data the side data array. It must be allocated with the av_malloc()
 *             family of functions. The ownership of the data is transferred to
 *             pkt.
 * @param size side information size
 * @return a non-negative number on success, a negative AVERROR code on
 *         failure. On failure, the packet is unchanged and the data remains
 *         owned by the caller.
 */
 int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                            uint8_t *data, size_t size);
 /**
 * Shrink the already allocated side data buffer
 *
 * @param pkt packet
 * @param type side information type
 * @param size new side information size
 * @return 0 on success, < 0 on failure
 */
 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                               size_t size);
 /**
 * Get side information from packet.
 *
 * @param pkt packet
 * @param type desired side information type
 * @param size If supplied, *size will be set to the size of the side data
 *             or to zero if the desired side data is not present.
 * @return pointer to data if present or NULL otherwise
 */
 uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
                                 size_t *size);
 const char *av_packet_side_data_name(enum AVPacketSideDataType type);
 /**
 * Pack a dictionary for use in side_data.
 *
 * @param dict The dictionary to pack.
 * @param size pointer to store the size of the returned data
 * @return pointer to data if successful, NULL otherwise
 */
 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
 /**
 * Unpack a dictionary from side_data.
 *
 * @param data data from side_data
 * @param size size of the data
 * @param dict the metadata storage dictionary
 * @return 0 on success, < 0 on failure
 */
 int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
                                AVDictionary **dict);
 /**
 * Convenience function to free all the side data stored.
 * All the other fields stay untouched.
 *
 * @param pkt packet
 */
 void av_packet_free_side_data(AVPacket *pkt);
 /**
 * Setup a new reference to the data described by a given packet
 *
 * If src is reference-counted, setup dst as a new reference to the
 * buffer in src. Otherwise allocate a new buffer in dst and copy the
 * data from src into it.
 *
 * All the other fields are copied from src.
 *
 * @see av_packet_unref
 *
 * @param dst Destination packet. Will be completely overwritten.
 * @param src Source packet
 *
 * @return 0 on success, a negative AVERROR on error. On error, dst
 *         will be blank (as if returned by av_packet_alloc()).
 */
 int av_packet_ref(AVPacket *dst, const AVPacket *src);
 /**
 * Wipe the packet.
 *
 * Unreference the buffer referenced by the packet and reset the
 * remaining packet fields to their default values.
 *
 * @param pkt The packet to be unreferenced.
 */
 void av_packet_unref(AVPacket *pkt);
 /**
 * Move every field in src to dst and reset src.
 *
 * @see av_packet_unref
 *
 * @param src Source packet, will be reset
 * @param dst Destination packet
 */
 void av_packet_move_ref(AVPacket *dst, AVPacket *src);
 /**
 * Copy only "properties" fields from src to dst.
 *
 * Properties for the purpose of this function are all the fields
 * beside those related to the packet data (buf, data, size)
 *
 * @param dst Destination packet
 * @param src Source packet
 *
 * @return 0 on success AVERROR on failure.
 */
 int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
 /**
 * Ensure the data described by a given packet is reference counted.
 *
 * @note This function does not ensure that the reference will be writable.
 *       Use av_packet_make_writable instead for that purpose.
 *
 * @see av_packet_ref
 * @see av_packet_make_writable
 *
 * @param pkt packet whose data should be made reference counted.
 *
 * @return 0 on success, a negative AVERROR on error. On failure, the
 *         packet is unchanged.
 */
 int av_packet_make_refcounted(AVPacket *pkt);
 /**
 * Create a writable reference for the data described by a given packet,
 * avoiding data copy if possible.
 *
 * @param pkt Packet whose data should be made writable.
 *
 * @return 0 on success, a negative AVERROR on failure. On failure, the
 *         packet is unchanged.
 */
 int av_packet_make_writable(AVPacket *pkt);
 /**
 * Convert valid timing fields (timestamps / durations) in a packet from one
 * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
 * ignored.
 *
 * @param pkt packet on which the conversion will be performed
 * @param tb_src source timebase, in which the timing fields in pkt are
 *               expressed
 * @param tb_dst destination timebase, to which the timing fields will be
 *               converted
 */
 void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
 /**
 * @}
 */
 #endif // AVCODEC_PACKET_H
--- a/output/include/arm64-v8a/libavcodec/qsv.h
+++ b/output/include/arm64-v8a/libavcodec/qsv.h
@ -21,7 +21,7 @@
 #ifndef AVCODEC_QSV_H
 #define AVCODEC_QSV_H
-#include <mfxvideo.h>
+#include <mfx/mfxvideo.h>
 #include "libavutil/buffer.h"
@ -61,8 +61,6 @@ typedef struct AVQSVContext {
     * required by the encoder and the user-provided value nb_opaque_surfaces.
     * The array of the opaque surfaces will be exported to the caller through
     * the opaque_surfaces field.
     *
     * The caller must set this field to zero for oneVPL (MFX_VERSION >= 2.0)
     */
    int opaque_alloc;
--- a/output/include/arm64-v8a/libavcodec/vaapi.h
+++ b/output/include/arm64-v8a/libavcodec/vaapi.h
@ -0,0 +1,195 @@
 /*
 * Video Acceleration API (shared data between FFmpeg and the video player)
 * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
 *
 * Copyright (C) 2008-2009 Splitted-Desktop Systems
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_VAAPI_H
 #define AVCODEC_VAAPI_H
 /**
 * @file
 * @ingroup lavc_codec_hwaccel_vaapi
 * Public libavcodec VA API header.
 */
 #include <stdint.h>
 #include "libavutil/attributes.h"
 #include "version.h"
 #if FF_API_STRUCT_VAAPI_CONTEXT
 /**
 * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
 * @ingroup lavc_codec_hwaccel
 * @{
 */
 /**
 * This structure is used to share data between the FFmpeg library and
 * the client video application.
 * This shall be zero-allocated and available as
 * AVCodecContext.hwaccel_context. All user members can be set once
 * during initialization or through each AVCodecContext.get_buffer()
 * function call. In any case, they must be valid prior to calling
 * decoding functions.
 *
 * Deprecated: use AVCodecContext.hw_frames_ctx instead.
 */
 struct attribute_deprecated vaapi_context {
    /**
     * Window system dependent data
     *
     * - encoding: unused
     * - decoding: Set by user
     */
    void *display;
    /**
     * Configuration ID
     *
     * - encoding: unused
     * - decoding: Set by user
     */
    uint32_t config_id;
    /**
     * Context ID (video decode pipeline)
     *
     * - encoding: unused
     * - decoding: Set by user
     */
    uint32_t context_id;
 #if FF_API_VAAPI_CONTEXT
    /**
     * VAPictureParameterBuffer ID
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    uint32_t pic_param_buf_id;
    /**
     * VAIQMatrixBuffer ID
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    uint32_t iq_matrix_buf_id;
    /**
     * VABitPlaneBuffer ID (for VC-1 decoding)
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    uint32_t bitplane_buf_id;
    /**
     * Slice parameter/data buffer IDs
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    uint32_t *slice_buf_ids;
    /**
     * Number of effective slice buffer IDs to send to the HW
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    unsigned int n_slice_buf_ids;
    /**
     * Size of pre-allocated slice_buf_ids
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    unsigned int slice_buf_ids_alloc;
    /**
     * Pointer to VASliceParameterBuffers
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    void *slice_params;
    /**
     * Size of a VASliceParameterBuffer element
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    unsigned int slice_param_size;
    /**
     * Size of pre-allocated slice_params
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    unsigned int slice_params_alloc;
    /**
     * Number of slices currently filled in
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    unsigned int slice_count;
    /**
     * Pointer to slice data buffer base
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    const uint8_t *slice_data;
    /**
     * Current size of slice data
     *
     * - encoding: unused
     * - decoding: Set by libavcodec
     */
    attribute_deprecated
    uint32_t slice_data_size;
 #endif
 };
 /* @} */
 #endif /* FF_API_STRUCT_VAAPI_CONTEXT */
 #endif /* AVCODEC_VAAPI_H */
--- a/output/include/arm64-v8a/libavcodec/vda.h
+++ b/output/include/arm64-v8a/libavcodec/vda.h
@ -0,0 +1,230 @@
 /*
 * VDA HW acceleration
 *
 * copyright (c) 2011 Sebastien Zwickert
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_VDA_H
 #define AVCODEC_VDA_H
 /**
 * @file
 * @ingroup lavc_codec_hwaccel_vda
 * Public libavcodec VDA header.
 */
 #include "libavcodec/avcodec.h"
 #include <stdint.h>
 // emmintrin.h is unable to compile with -std=c99 -Werror=missing-prototypes
 // http://openradar.appspot.com/8026390
 #undef __GNUC_STDC_INLINE__
 #define Picture QuickdrawPicture
 #include <VideoDecodeAcceleration/VDADecoder.h>
 #undef Picture
 #include "libavcodec/version.h"
 // extra flags not defined in VDADecoder.h
 enum {
    kVDADecodeInfo_Asynchronous = 1UL << 0,
    kVDADecodeInfo_FrameDropped = 1UL << 1
 };
 /**
 * @defgroup lavc_codec_hwaccel_vda VDA
 * @ingroup lavc_codec_hwaccel
 *
 * @{
 */
 /**
 * This structure is used to provide the necessary configurations and data
 * to the VDA FFmpeg HWAccel implementation.
 *
 * The application must make it available as AVCodecContext.hwaccel_context.
 */
 struct vda_context {
    /**
     * VDA decoder object.
     *
     * - encoding: unused
     * - decoding: Set/Unset by libavcodec.
     */
    VDADecoder          decoder;
    /**
     * The Core Video pixel buffer that contains the current image data.
     *
     * encoding: unused
     * decoding: Set by libavcodec. Unset by user.
     */
    CVPixelBufferRef    cv_buffer;
    /**
     * Use the hardware decoder in synchronous mode.
     *
     * encoding: unused
     * decoding: Set by user.
     */
    int                 use_sync_decoding;
    /**
     * The frame width.
     *
     * - encoding: unused
     * - decoding: Set/Unset by user.
     */
    int                 width;
    /**
     * The frame height.
     *
     * - encoding: unused
     * - decoding: Set/Unset by user.
     */
    int                 height;
    /**
     * The frame format.
     *
     * - encoding: unused
     * - decoding: Set/Unset by user.
     */
    int                 format;
    /**
     * The pixel format for output image buffers.
     *
     * - encoding: unused
     * - decoding: Set/Unset by user.
     */
    OSType              cv_pix_fmt_type;
    /**
     * unused
     */
    uint8_t             *priv_bitstream;
    /**
     * unused
     */
    int                 priv_bitstream_size;
    /**
     * unused
     */
    int                 priv_allocated_size;
    /**
     * Use av_buffer to manage buffer.
     * When the flag is set, the CVPixelBuffers returned by the decoder will
     * be released automatically, so you have to retain them if necessary.
     * Not setting this flag may cause memory leak.
     *
     * encoding: unused
     * decoding: Set by user.
     */
    int                 use_ref_buffer;
 };
 /** Create the video decoder. */
 int ff_vda_create_decoder(struct vda_context *vda_ctx,
                          uint8_t *extradata,
                          int extradata_size);
 /** Destroy the video decoder. */
 int ff_vda_destroy_decoder(struct vda_context *vda_ctx);
 /**
 * This struct holds all the information that needs to be passed
 * between the caller and libavcodec for initializing VDA decoding.
 * Its size is not a part of the public ABI, it must be allocated with
 * av_vda_alloc_context() and freed with av_free().
 */
 typedef struct AVVDAContext {
    /**
     * VDA decoder object. Created and freed by the caller.
     */
    VDADecoder decoder;
    /**
     * The output callback that must be passed to VDADecoderCreate.
     * Set by av_vda_alloc_context().
     */
    VDADecoderOutputCallback output_callback;
    /**
     * CVPixelBuffer Format Type that VDA will use for decoded frames; set by
     * the caller.
     */
    OSType cv_pix_fmt_type;
 } AVVDAContext;
 /**
 * Allocate and initialize a VDA context.
 *
 * This function should be called from the get_format() callback when the caller
 * selects the AV_PIX_FMT_VDA format. The caller must then create the decoder
 * object (using the output callback provided by libavcodec) that will be used
 * for VDA-accelerated decoding.
 *
 * When decoding with VDA is finished, the caller must destroy the decoder
 * object and free the VDA context using av_free().
 *
 * @return the newly allocated context or NULL on failure
 */
 AVVDAContext *av_vda_alloc_context(void);
 /**
 * This is a convenience function that creates and sets up the VDA context using
 * an internal implementation.
 *
 * @param avctx the corresponding codec context
 *
 * @return >= 0 on success, a negative AVERROR code on failure
 */
 int av_vda_default_init(AVCodecContext *avctx);
 /**
 * This is a convenience function that creates and sets up the VDA context using
 * an internal implementation.
 *
 * @param avctx the corresponding codec context
 * @param vdactx the VDA context to use
 *
 * @return >= 0 on success, a negative AVERROR code on failure
 */
 int av_vda_default_init2(AVCodecContext *avctx, AVVDAContext *vdactx);
 /**
 * This function must be called to free the VDA context initialized with
 * av_vda_default_init().
 *
 * @param avctx the corresponding codec context
 */
 void av_vda_default_free(AVCodecContext *avctx);
 /**
 * @}
 */
 #endif /* AVCODEC_VDA_H */
--- a/output/include/arm64-v8a/libavcodec/vdpau.h
+++ b/output/include/arm64-v8a/libavcodec/vdpau.h
@ -55,6 +55,16 @@
 #include "libavutil/attributes.h"
 #include "avcodec.h"
 #include "version.h"
 #if FF_API_BUFS_VDPAU
 union AVVDPAUPictureInfo {
    VdpPictureInfoH264        h264;
    VdpPictureInfoMPEG1Or2    mpeg;
    VdpPictureInfoVC1          vc1;
    VdpPictureInfoMPEG4Part2 mpeg4;
 };
 #endif
 struct AVCodecContext;
 struct AVFrame;
@ -92,6 +102,40 @@ typedef struct AVVDPAUContext {
     */
    VdpDecoderRender *render;
 #if FF_API_BUFS_VDPAU
    /**
     * VDPAU picture information
     *
     * Set by libavcodec.
     */
    attribute_deprecated
    union AVVDPAUPictureInfo info;
    /**
     * Allocated size of the bitstream_buffers table.
     *
     * Set by libavcodec.
     */
    attribute_deprecated
    int bitstream_buffers_allocated;
    /**
     * Useful bitstream buffers in the bitstream buffers table.
     *
     * Set by libavcodec.
     */
    attribute_deprecated
    int bitstream_buffers_used;
   /**
     * Table of bitstream buffers.
     * The user is responsible for freeing this buffer using av_freep().
     *
     * Set by libavcodec.
     */
    attribute_deprecated
    VdpBitstreamBuffer *bitstream_buffers;
 #endif
    AVVDPAU_Render2 render2;
 } AVVDPAUContext;
@ -152,6 +196,58 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
 */
 AVVDPAUContext *av_vdpau_alloc_context(void);
-/** @} */
+#if FF_API_VDPAU_PROFILE
 /**
 * Get a decoder profile that should be used for initializing a VDPAU decoder.
 * Should be called from the AVCodecContext.get_format() callback.
 *
 * @deprecated Use av_vdpau_bind_context() instead.
 *
 * @param avctx the codec context being used for decoding the stream
 * @param profile a pointer into which the result will be written on success.
 *                The contents of profile are undefined if this function returns
 *                an error.
 *
 * @return 0 on success (non-negative), a negative AVERROR on failure.
 */
 attribute_deprecated
 int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile);
 #endif
 #if FF_API_CAP_VDPAU
 /** @brief The videoSurface is used for rendering. */
 #define FF_VDPAU_STATE_USED_FOR_RENDER 1
 /**
 * @brief The videoSurface is needed for reference/prediction.
 * The codec manipulates this.
 */
 #define FF_VDPAU_STATE_USED_FOR_REFERENCE 2
 /**
 * @brief This structure is used as a callback between the FFmpeg
 * decoder (vd_) and presentation (vo_) module.
 * This is used for defining a video frame containing surface,
 * picture parameter, bitstream information etc which are passed
 * between the FFmpeg decoder and its clients.
 */
 struct vdpau_render_state {
    VdpVideoSurface surface; ///< Used as rendered surface, never changed.
    int state; ///< Holds FF_VDPAU_STATE_* values.
    /** picture parameter information for all supported codecs */
    union AVVDPAUPictureInfo info;
    /** Describe size/location of the compressed video data.
        Set to 0 when freeing bitstream_buffers. */
    int bitstream_buffers_allocated;
    int bitstream_buffers_used;
    /** The user is responsible for freeing this buffer using av_freep(). */
    VdpBitstreamBuffer *bitstream_buffers;
 };
 #endif
 /* @}*/
 #endif /* AVCODEC_VDPAU_H */
--- a/output/include/arm64-v8a/libavcodec/version.h
+++ b/output/include/arm64-v8a/libavcodec/version.h
@ -27,9 +27,8 @@
 #include "libavutil/version.h"
-#include "version_major.h"
+#define LIBAVCODEC_VERSION_MAJOR  57
-
+#define LIBAVCODEC_VERSION_MINOR 107
 #define LIBAVCODEC_VERSION_MINOR   3
 #define LIBAVCODEC_VERSION_MICRO 100
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@ -42,4 +41,203 @@
 #define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
 /**
 * 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_VIMA_DECODER
 #define FF_API_VIMA_DECODER     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AUDIO_CONVERT
 #define FF_API_AUDIO_CONVERT     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AVCODEC_RESAMPLE
 #define FF_API_AVCODEC_RESAMPLE  FF_API_AUDIO_CONVERT
 #endif
 #ifndef FF_API_MISSING_SAMPLE
 #define FF_API_MISSING_SAMPLE    (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LOWRES
 #define FF_API_LOWRES            (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_CAP_VDPAU
 #define FF_API_CAP_VDPAU         (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_BUFS_VDPAU
 #define FF_API_BUFS_VDPAU        (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_VOXWARE
 #define FF_API_VOXWARE           (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_SET_DIMENSIONS
 #define FF_API_SET_DIMENSIONS    (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_DEBUG_MV
 #define FF_API_DEBUG_MV          (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AC_VLC
 #define FF_API_AC_VLC            (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_OLD_MSMPEG4
 #define FF_API_OLD_MSMPEG4       (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_ASPECT_EXTENDED
 #define FF_API_ASPECT_EXTENDED   (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_ARCH_ALPHA
 #define FF_API_ARCH_ALPHA        (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_XVMC
 #define FF_API_XVMC              (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_ERROR_RATE
 #define FF_API_ERROR_RATE        (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_QSCALE_TYPE
 #define FF_API_QSCALE_TYPE       (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_MB_TYPE
 #define FF_API_MB_TYPE           (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_MAX_BFRAMES
 #define FF_API_MAX_BFRAMES       (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_NEG_LINESIZES
 #define FF_API_NEG_LINESIZES     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_EMU_EDGE
 #define FF_API_EMU_EDGE          (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_ARCH_SH4
 #define FF_API_ARCH_SH4          (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_ARCH_SPARC
 #define FF_API_ARCH_SPARC        (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_UNUSED_MEMBERS
 #define FF_API_UNUSED_MEMBERS    (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_IDCT_XVIDMMX
 #define FF_API_IDCT_XVIDMMX      (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_INPUT_PRESERVED
 #define FF_API_INPUT_PRESERVED   (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_NORMALIZE_AQP
 #define FF_API_NORMALIZE_AQP     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_GMC
 #define FF_API_GMC               (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_MV0
 #define FF_API_MV0               (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_CODEC_NAME
 #define FF_API_CODEC_NAME        (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AFD
 #define FF_API_AFD               (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_VISMV
 /* XXX: don't forget to drop the -vismv documentation */
 #define FF_API_VISMV             (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AUDIOENC_DELAY
 #define FF_API_AUDIOENC_DELAY    (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_VAAPI_CONTEXT
 #define FF_API_VAAPI_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_MERGE_SD
 #define FF_API_MERGE_SD          (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_AVCTX_TIMEBASE
 #define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_MPV_OPT
 #define FF_API_MPV_OPT           (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_STREAM_CODEC_TAG
 #define FF_API_STREAM_CODEC_TAG  (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_QUANT_BIAS
 #define FF_API_QUANT_BIAS        (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_RC_STRATEGY
 #define FF_API_RC_STRATEGY       (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_CODED_FRAME
 #define FF_API_CODED_FRAME       (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_MOTION_EST
 #define FF_API_MOTION_EST        (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_WITHOUT_PREFIX
 #define FF_API_WITHOUT_PREFIX    (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_SIDEDATA_ONLY_PKT
 #define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_VDPAU_PROFILE
 #define FF_API_VDPAU_PROFILE     (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_CONVERGENCE_DURATION
 #define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_AVPICTURE
 #define FF_API_AVPICTURE         (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_AVPACKET_OLD_API
 #define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_RTP_CALLBACK
 #define FF_API_RTP_CALLBACK      (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_VBV_DELAY
 #define FF_API_VBV_DELAY         (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_CODER_TYPE
 #define FF_API_CODER_TYPE        (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_STAT_BITS
 #define FF_API_STAT_BITS         (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_PRIVATE_OPT
 #define FF_API_PRIVATE_OPT      (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_ASS_TIMING
 #define FF_API_ASS_TIMING       (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_OLD_BSF
 #define FF_API_OLD_BSF          (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_COPY_CONTEXT
 #define FF_API_COPY_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_GET_CONTEXT_DEFAULTS
 #define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_NVENC_OLD_NAME
 #define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_STRUCT_VAAPI_CONTEXT
 #define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_MERGE_SD_API
 #define FF_API_MERGE_SD_API      (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_TAG_STRING
 #define FF_API_TAG_STRING        (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #ifndef FF_API_GETCHROMA
 #define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
 #endif /* AVCODEC_VERSION_H */
--- a/output/include/arm64-v8a/libavcodec/version_major.h
+++ b/output/include/arm64-v8a/libavcodec/version_major.h
@ -1,52 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVCODEC_VERSION_MAJOR_H
 #define AVCODEC_VERSION_MAJOR_H
 /**
 * @file
 * @ingroup libavc
 * Libavcodec version macros.
 */
 #define LIBAVCODEC_VERSION_MAJOR  60
 /**
 * 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.
 */
 #define FF_API_INIT_PACKET         (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_IDCT_NONE           (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_SVTAV1_OPTS         (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_AYUV_CODECID        (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_VT_OUTPUT_CALLBACK  (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_AVCODEC_CHROMA_POS  (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_VT_HWACCEL_CONTEXT  (LIBAVCODEC_VERSION_MAJOR < 61)
 #define FF_API_AVCTX_FRAME_NUMBER  (LIBAVCODEC_VERSION_MAJOR < 61)
 // reminder to remove CrystalHD decoders on next major bump
 #define FF_CODEC_CRYSTAL_HD        (LIBAVCODEC_VERSION_MAJOR < 61)
 #endif /* AVCODEC_VERSION_MAJOR_H */
--- a/output/include/arm64-v8a/libavcodec/videotoolbox.h
+++ b/output/include/arm64-v8a/libavcodec/videotoolbox.h
@ -29,15 +29,6 @@
 * Public libavcodec Videotoolbox header.
 */
 /**
 * @defgroup lavc_codec_hwaccel_videotoolbox VideoToolbox Decoder
 * @ingroup lavc_codec_hwaccel
 *
 * Hardware accelerated decoding using VideoToolbox on Apple Platforms
 *
 * @{
 */
 #include <stdint.h>
 #define Picture QuickdrawPicture
@ -46,8 +37,6 @@
 #include "libavcodec/avcodec.h"
 #include "libavutil/attributes.h"
 /**
 * This struct holds all the information that needs to be passed
 * between the caller and libavcodec for initializing Videotoolbox decoding.
@ -57,17 +46,15 @@
 typedef struct AVVideotoolboxContext {
    /**
     * Videotoolbox decompression session object.
     * Created and freed the caller.
     */
    VTDecompressionSessionRef session;
 #if FF_API_VT_OUTPUT_CALLBACK
    /**
     * The output callback that must be passed to the session.
     * Set by av_videottoolbox_default_init()
     */
    attribute_deprecated
    VTDecompressionOutputCallback output_callback;
 #endif
    /**
     * CVPixelBuffer Format Type that Videotoolbox will use for decoded frames.
@ -78,17 +65,17 @@ typedef struct AVVideotoolboxContext {
    /**
     * CoreMedia Format Description that Videotoolbox will use to create the decompression session.
     * Set by the caller.
     */
    CMVideoFormatDescriptionRef cm_fmt_desc;
    /**
     * CoreMedia codec type that Videotoolbox will use to create the decompression session.
     * Set by the caller.
     */
    int cm_codec_type;
 } AVVideotoolboxContext;
 #if FF_API_VT_HWACCEL_CONTEXT
 /**
 * Allocate and initialize a Videotoolbox context.
 *
@ -101,9 +88,7 @@ typedef struct AVVideotoolboxContext {
 * object and free the Videotoolbox context using av_free().
 *
 * @return the newly allocated context or NULL on failure
 * @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
 */
 attribute_deprecated
 AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
 /**
@ -113,9 +98,7 @@ AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
 * @param avctx the corresponding codec context
 *
 * @return >= 0 on success, a negative AVERROR code on failure
 * @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
 */
 attribute_deprecated
 int av_videotoolbox_default_init(AVCodecContext *avctx);
 /**
@ -126,9 +109,7 @@ int av_videotoolbox_default_init(AVCodecContext *avctx);
 * @param vtctx the Videotoolbox context to use
 *
 * @return >= 0 on success, a negative AVERROR code on failure
 * @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
 */
 attribute_deprecated
 int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx);
 /**
@ -136,13 +117,9 @@ int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *
 * av_videotoolbox_default_init().
 *
 * @param avctx the corresponding codec context
 * @deprecated Use AVCodecContext.hw_frames_ctx or hw_device_ctx instead.
 */
 attribute_deprecated
 void av_videotoolbox_default_free(AVCodecContext *avctx);
 #endif /* FF_API_VT_HWACCEL_CONTEXT */
 /**
 * @}
 */
--- a/output/include/arm64-v8a/libavcodec/xvmc.h
+++ b/output/include/arm64-v8a/libavcodec/xvmc.h
@ -27,11 +27,10 @@
 * Public libavcodec XvMC header.
 */
 #pragma message("XvMC is no longer supported; this header is deprecated and will be removed")
 #include <X11/extensions/XvMC.h>
 #include "libavutil/attributes.h"
 #include "version.h"
 #include "avcodec.h"
 /**
--- a/output/include/arm64-v8a/libavfilter/avfilter.h
+++ b/output/include/arm64-v8a/libavfilter/avfilter.h
@ -47,13 +47,7 @@
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
 #include "libavfilter/version_major.h"
 #ifndef HAVE_AV_CONFIG_H
 /* When included as part of the ffmpeg build, only include the major version
 * to avoid unnecessary rebuilds. When included externally, keep including
 * the full version information. */
 #include "libavfilter/version.h"
 #endif
 /**
 * Return the LIBAVFILTER_VERSION_INT constant.
@ -74,13 +68,18 @@ typedef struct AVFilterContext AVFilterContext;
 typedef struct AVFilterLink    AVFilterLink;
 typedef struct AVFilterPad     AVFilterPad;
 typedef struct AVFilterFormats AVFilterFormats;
-typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
+
 /**
 * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
 * AVFilter.inputs/outputs).
 */
 int avfilter_pad_count(const AVFilterPad *pads);
 /**
 * Get the name of an AVFilterPad.
 *
 * @param pads an array of AVFilterPads
- * @param pad_idx index of the pad in the array; it is the caller's
+ * @param pad_idx index of the pad in the array it; is the caller's
 *                responsibility to ensure the index is valid
 *
 * @return name of the pad_idx'th pad in pads
@ -115,22 +114,6 @@ enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx);
 * and processing them concurrently.
 */
 #define AVFILTER_FLAG_SLICE_THREADS         (1 << 2)
 /**
 * The filter is a "metadata" filter - it does not modify the frame data in any
 * way. It may only affect the metadata (i.e. those fields copied by
 * av_frame_copy_props()).
 *
 * More precisely, this means:
 * - video: the data of any frame output by the filter must be exactly equal to
 *   some frame that is received on one of its inputs. Furthermore, all frames
 *   produced on a given output must correspond to frames received on the same
 *   input and their order must be unchanged. Note that the filter may still
 *   drop or duplicate the frames.
 * - audio: the data produced by the filter on any of its outputs (viewed e.g.
 *   as an array of interleaved samples) must be exactly equal to the data
 *   received by the filter on one of its inputs.
 */
 #define AVFILTER_FLAG_METADATA_ONLY         (1 << 3)
 /**
 * Some filters support a generic "enable" expression option that can be used
 * to enable or disable a filter in the timeline. Filters supporting this
@ -172,16 +155,15 @@ typedef struct AVFilter {
    const char *description;
    /**
-     * List of static inputs.
+     * List of inputs, terminated by a zeroed element.
     *
     * NULL if there are no (static) inputs. Instances of filters with
     * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in
     * this list.
     */
    const AVFilterPad *inputs;
    /**
-     * List of static outputs.
+     * List of outputs, terminated by a zeroed element.
     *
     * NULL if there are no (static) outputs. Instances of filters with
     * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in
@ -212,22 +194,6 @@ typedef struct AVFilter {
     *****************************************************************
     */
    /**
     * The number of entries in the list of inputs.
     */
    uint8_t nb_inputs;
    /**
     * The number of entries in the list of outputs.
     */
    uint8_t nb_outputs;
    /**
     * This field determines the state of the formats union.
     * It is an enum FilterFormatsState value.
     */
    uint8_t formats_state;
    /**
     * Filter pre-initialization function
     *
@ -266,6 +232,19 @@ typedef struct AVFilter {
     */
    int (*init)(AVFilterContext *ctx);
    /**
     * Should be set instead of @ref AVFilter.init "init" by the filters that
     * want to pass a dictionary of AVOptions to nested contexts that are
     * allocated during init.
     *
     * On return, the options dict should be freed and replaced with one that
     * contains all the options which could not be processed by this filter (or
     * with NULL if all the options were processed).
     *
     * Otherwise the semantics is the same as for @ref AVFilter.init "init".
     */
    int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);
    /**
     * Filter uninitialization function.
     *
@ -278,11 +257,6 @@ typedef struct AVFilter {
     */
    void (*uninit)(AVFilterContext *ctx);
    /**
     * The state of the following union is determined by formats_state.
     * See the documentation of enum FilterFormatsState in internal.h.
     */
    union {
    /**
     * Query formats supported by the filter on its inputs and outputs.
     *
@ -290,63 +264,33 @@ typedef struct AVFilter {
     * and outputs are fixed), shortly before the format negotiation. This
     * callback may be called more than once.
     *
-         * This callback must set ::AVFilterLink's
+     * This callback must set AVFilterLink.out_formats on every input link and
-         * @ref AVFilterFormatsConfig.formats "outcfg.formats"
+     * AVFilterLink.in_formats on every output link to a list of pixel/sample
-         * on every input link and
+     * formats that the filter supports on that link. For audio links, this
-         * @ref AVFilterFormatsConfig.formats "incfg.formats"
+     * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
-         * on every output link to a list of pixel/sample formats that the filter
+     * @ref AVFilterLink.out_samplerates "out_samplerates" and
-         * supports on that link.
+     * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
-         * For audio links, this filter must also set
+     * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
-         * @ref AVFilterFormatsConfig.samplerates "incfg.samplerates"
+     *
-         *  /
+     * This callback may be NULL for filters with one input, in which case
-         * @ref AVFilterFormatsConfig.samplerates "outcfg.samplerates"
+     * libavfilter assumes that it supports all input formats and preserves
-         * and @ref AVFilterFormatsConfig.channel_layouts "incfg.channel_layouts"
+     * them on output.
         *  /
         * @ref AVFilterFormatsConfig.channel_layouts "outcfg.channel_layouts"
         * analogously.
         *
         * This callback must never be NULL if the union is in this state.
     *
     * @return zero on success, a negative value corresponding to an
     * AVERROR code otherwise
     */
-        int (*query_func)(AVFilterContext *);
+    int (*query_formats)(AVFilterContext *);
        /**
         * A pointer to an array of admissible pixel formats delimited
         * by AV_PIX_FMT_NONE. The generic code will use this list
         * to indicate that this filter supports each of these pixel formats,
         * provided that all inputs and outputs use the same pixel format.
         *
         * This list must never be NULL if the union is in this state.
         * The type of all inputs and outputs of filters using this must
         * be AVMEDIA_TYPE_VIDEO.
         */
        const enum AVPixelFormat *pixels_list;
        /**
         * Analogous to pixels, but delimited by AV_SAMPLE_FMT_NONE
         * and restricted to filters that only have AVMEDIA_TYPE_AUDIO
         * inputs and outputs.
         *
         * In addition to that the generic code will mark all inputs
         * and all outputs as supporting all sample rates and every
         * channel count and channel layout, as long as all inputs
         * and outputs use the same sample rate and channel count/layout.
         */
        const enum AVSampleFormat *samples_list;
        /**
         * Equivalent to { pix_fmt, AV_PIX_FMT_NONE } as pixels_list.
         */
        enum AVPixelFormat  pix_fmt;
        /**
         * Equivalent to { sample_fmt, AV_SAMPLE_FMT_NONE } as samples_list.
         */
        enum AVSampleFormat sample_fmt;
    } formats;
    int priv_size;      ///< size of private data to allocate for the filter
    int flags_internal; ///< Additional flags for avfilter internal use only.
    /**
     * Used by the filter registration system. Must not be touched by any other
     * code.
     */
    struct AVFilter *next;
    /**
     * Make the filter instance process a command.
     *
@ -361,6 +305,13 @@ typedef struct AVFilter {
     */
    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
    /**
     * Filter initialization function, alternative to the init()
     * callback. Args contains the user-supplied parameters, opaque is
     * used for providing binary data.
     */
    int (*init_opaque)(AVFilterContext *ctx, void *opaque);
    /**
     * Filter activation function.
     *
@ -376,11 +327,6 @@ typedef struct AVFilter {
    int (*activate)(AVFilterContext *ctx);
 } AVFilter;
 /**
 * Get the number of elements in an AVFilter's inputs or outputs array.
 */
 unsigned avfilter_filter_pad_count(const AVFilter *filter, int is_output);
 /**
 * Process multiple parts of the frame concurrently.
 */
@ -460,53 +406,8 @@ struct AVFilterContext {
     * a higher value suggests a more urgent activation.
     */
    unsigned ready;
    /**
     * Sets the number of extra hardware frames which the filter will
     * allocate on its output links for use in following filters or by
     * the caller.
     *
     * Some hardware filters require all frames that they will use for
     * output to be defined in advance before filtering starts.  For such
     * filters, any hardware frame pools used for output must therefore be
     * of fixed size.  The extra frames set here are on top of any number
     * that the filter needs internally in order to operate normally.
     *
     * This field must be set before the graph containing this filter is
     * configured.
     */
    int extra_hw_frames;
 };
 /**
 * Lists of formats / etc. supported by an end of a link.
 *
 * This structure is directly part of AVFilterLink, in two copies:
 * one for the source filter, one for the destination filter.
 * These lists are used for negotiating the format to actually be used,
 * which will be loaded into the format and channel_layout members of
 * AVFilterLink, when chosen.
 */
 typedef struct AVFilterFormatsConfig {
    /**
     * List of supported formats (pixel or sample).
     */
    AVFilterFormats *formats;
    /**
     * Lists of supported sample rates, only for audio.
     */
    AVFilterFormats  *samplerates;
    /**
     * Lists of supported channel layouts, only for audio.
     */
    AVFilterChannelLayouts  *channel_layouts;
 } AVFilterFormatsConfig;
 /**
 * A link between two filters. This contains pointers to the source and
 * destination filters between which this link exists, and the indexes of
@ -533,14 +434,7 @@ struct AVFilterLink {
    int h;                      ///< agreed upon image height
    AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
    /* These parameters apply only to audio */
-#if FF_API_OLD_CHANNEL_LAYOUT
+    uint64_t channel_layout;    ///< channel layout of current buffer (see libavutil/channel_layout.h)
    /**
     * channel layout of current buffer (see libavutil/channel_layout.h)
     * @deprecated use ch_layout
     */
    attribute_deprecated
    uint64_t channel_layout;
 #endif
    int sample_rate;            ///< samples per second
    int format;                 ///< agreed upon media format
@ -554,8 +448,6 @@ struct AVFilterLink {
     */
    AVRational time_base;
    AVChannelLayout ch_layout;  ///< channel layout of current buffer (see libavutil/channel_layout.h)
    /*****************************************************************
     * All fields below this line are not part of the public API. They
     * may not be used outside of libavfilter and can be changed and
@ -563,16 +455,33 @@ struct AVFilterLink {
     * New public fields should be added right above.
     *****************************************************************
     */
    /**
     * Lists of formats and channel layouts supported by the input and output
     * filters respectively. These lists are used for negotiating the format
     * to actually be used, which will be loaded into the format and
     * channel_layout members, above, when chosen.
     *
     */
    AVFilterFormats *in_formats;
    AVFilterFormats *out_formats;
    /**
-     * Lists of supported formats / etc. supported by the input filter.
+     * Lists of channel layouts and sample rates used for automatic
     * negotiation.
     */
-    AVFilterFormatsConfig incfg;
+    AVFilterFormats  *in_samplerates;
    AVFilterFormats *out_samplerates;
    struct AVFilterChannelLayouts  *in_channel_layouts;
    struct AVFilterChannelLayouts *out_channel_layouts;
    /**
-     * Lists of supported formats / etc. supported by the output filter.
+     * Audio only, the destination filter sets this to a non-zero value to
     * request that buffers with the given number of samples should be sent to
     * it. AVFilterPad.needs_fifo must also be set on the corresponding input
     * pad.
     * Last buffer before EOF will be padded with silence.
     */
-    AVFilterFormatsConfig outcfg;
+    int request_samples;
    /** stage of the initialization of the link properties (dimensions, etc) */
    enum {
@ -616,9 +525,20 @@ struct AVFilterLink {
     */
    AVRational frame_rate;
    /**
     * Buffer partially filled with samples to achieve a fixed/minimum size.
     */
    AVFrame *partial_buf;
    /**
     * Size of the partial buffer to allocate.
     * Must be between min_samples and max_samples.
     */
    int partial_buf_size;
    /**
     * Minimum number of samples to filter at once. If filter_frame() is
-     * called with fewer samples, it will accumulate them in fifo.
+     * called with fewer samples, it will accumulate them in partial_buf.
     * This field and the related ones must not be changed after filtering
     * has started.
     * If 0, all related fields are ignored.
@ -632,14 +552,19 @@ struct AVFilterLink {
    int max_samples;
    /**
-     * Number of past frames sent through the link.
+     * Number of channels.
     */
-    int64_t frame_count_in, frame_count_out;
+    int channels;
    /**
-     * Number of past samples sent through the link.
+     * Link processing flags.
     */
-    int64_t sample_count_in, sample_count_out;
+    unsigned flags;
    /**
     * Number of past frames sent through the link.
     */
    int64_t frame_count_in, frame_count_out;
    /**
     * A pointer to a FFFramePool struct.
@ -722,6 +647,19 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
 */
 void avfilter_link_free(AVFilterLink **link);
 /**
 * Get the number of channels of a link.
 */
 int avfilter_link_get_channels(AVFilterLink *link);
 /**
 * Set the closed field of a link.
 * @deprecated applications are not supposed to mess with links, they should
 * close the sinks.
 */
 attribute_deprecated
 void avfilter_link_set_closed(AVFilterLink *link, int closed);
 /**
 * Negotiate the media format, dimensions, etc of all inputs to a filter.
 *
@ -739,16 +677,26 @@ int avfilter_config_links(AVFilterContext *filter);
 */
 int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
 /** Initialize the filter system. Register all builtin filters. */
 void avfilter_register_all(void);
 #if FF_API_OLD_FILTER_REGISTER
 /** Uninitialize the filter system. Unregister all filters. */
 attribute_deprecated
 void avfilter_uninit(void);
 #endif
 /**
- * Iterate over all registered filters.
+ * Register a filter. This is only needed if you plan to use
 * avfilter_get_by_name later to lookup the AVFilter structure by name. A
 * filter can still by instantiated with avfilter_graph_alloc_filter even if it
 * is not registered.
 *
- * @param opaque a pointer where libavfilter will store the iteration state. Must
+ * @param filter the filter to register
- *               point to NULL to start the iteration.
+ * @return 0 if the registration was successful, a negative value
- *
+ * otherwise
 * @return the next registered filter or NULL when the iteration is
 *         finished
 */
-const AVFilter *av_filter_iterate(void **opaque);
+int avfilter_register(AVFilter *filter);
 /**
 * Get a filter definition matching the given name.
@ -757,9 +705,61 @@ const AVFilter *av_filter_iterate(void **opaque);
 * @return     the filter definition, if any matching one is registered.
 *             NULL if none found.
 */
-const AVFilter *avfilter_get_by_name(const char *name);
+#if !FF_API_NOCONST_GET_NAME
 const
 #endif
 AVFilter *avfilter_get_by_name(const char *name);
 /**
 * Iterate over all registered filters.
 * @return If prev is non-NULL, next registered filter after prev or NULL if
 * prev is the last filter. If prev is NULL, return the first registered filter.
 */
 const AVFilter *avfilter_next(const AVFilter *prev);
 #if FF_API_OLD_FILTER_REGISTER
 /**
 * If filter is NULL, returns a pointer to the first registered filter pointer,
 * if filter is non-NULL, returns the next pointer after filter.
 * If the returned pointer points to NULL, the last registered filter
 * was already reached.
 * @deprecated use avfilter_next()
 */
 attribute_deprecated
 AVFilter **av_filter_next(AVFilter **filter);
 #endif
 #if FF_API_AVFILTER_OPEN
 /**
 * Create a filter instance.
 *
 * @param filter_ctx put here a pointer to the created filter context
 * on success, NULL on failure
 * @param filter    the filter to create an instance of
 * @param inst_name Name to give to the new instance. Can be NULL for none.
 * @return >= 0 in case of success, a negative error code otherwise
 * @deprecated use avfilter_graph_alloc_filter() instead
 */
 attribute_deprecated
 int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name);
 #endif
 #if FF_API_AVFILTER_INIT_FILTER
 /**
 * Initialize a filter.
 *
 * @param filter the filter to initialize
 * @param args   A string of parameters to use when initializing the filter.
 *               The format and meaning of this string varies by filter.
 * @param opaque Any extra non-string data needed by the filter. The meaning
 *               of this parameter varies by filter.
 * @return       zero on success
 */
 attribute_deprecated
 int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque);
 #endif
 /**
 * Initialize a filter with the supplied parameters.
 *
@ -858,6 +858,9 @@ typedef struct AVFilterGraph {
    unsigned nb_filters;
    char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
 #if FF_API_LAVR_OPTS
    attribute_deprecated char *resample_lavr_opts;   ///< libavresample options to use for the auto-inserted resample filters
 #endif
    /**
     * Type of multithreading allowed for filters in this graph. A combination
@ -956,10 +959,24 @@ AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
 */
 AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, const char *name);
 #if FF_API_AVFILTER_OPEN
 /**
 * Add an existing filter instance to a filter graph.
 *
 * @param graphctx  the filter graph
 * @param filter the filter to be added
 *
 * @deprecated use avfilter_graph_alloc_filter() to allocate a filter in a
 * filter graph
 */
 attribute_deprecated
 int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter);
 #endif
 /**
 * Create and add a filter instance into an existing graph.
 * The filter instance is created from the filter filt and inited
- * with the parameter args. opaque is currently ignored.
+ * with the parameters args and opaque.
 *
 * In case of success put in *filt_ctx the pointer to the created
 * filter instance, otherwise set *filt_ctx to NULL.
@ -1108,317 +1125,6 @@ int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters,
                          AVFilterInOut **inputs,
                          AVFilterInOut **outputs);
 /**
 * Parameters of a filter's input or output pad.
 *
 * Created as a child of AVFilterParams by avfilter_graph_segment_parse().
 * Freed in avfilter_graph_segment_free().
 */
 typedef struct AVFilterPadParams {
    /**
     * An av_malloc()'ed string containing the pad label.
     *
     * May be av_free()'d and set to NULL by the caller, in which case this pad
     * will be treated as unlabeled for linking.
     * May also be replaced by another av_malloc()'ed string.
     */
    char *label;
 } AVFilterPadParams;
 /**
 * Parameters describing a filter to be created in a filtergraph.
 *
 * Created as a child of AVFilterGraphSegment by avfilter_graph_segment_parse().
 * Freed in avfilter_graph_segment_free().
 */
 typedef struct AVFilterParams {
    /**
     * The filter context.
     *
     * Created by avfilter_graph_segment_create_filters() based on
     * AVFilterParams.filter_name and instance_name.
     *
     * Callers may also create the filter context manually, then they should
     * av_free() filter_name and set it to NULL. Such AVFilterParams instances
     * are then skipped by avfilter_graph_segment_create_filters().
     */
    AVFilterContext     *filter;
    /**
     * Name of the AVFilter to be used.
     *
     * An av_malloc()'ed string, set by avfilter_graph_segment_parse(). Will be
     * passed to avfilter_get_by_name() by
     * avfilter_graph_segment_create_filters().
     *
     * Callers may av_free() this string and replace it with another one or
     * NULL. If the caller creates the filter instance manually, this string
     * MUST be set to NULL.
     *
     * When both AVFilterParams.filter an AVFilterParams.filter_name are NULL,
     * this AVFilterParams instance is skipped by avfilter_graph_segment_*()
     * functions.
     */
    char                *filter_name;
    /**
     * Name to be used for this filter instance.
     *
     * An av_malloc()'ed string, may be set by avfilter_graph_segment_parse() or
     * left NULL. The caller may av_free() this string and replace with another
     * one or NULL.
     *
     * Will be used by avfilter_graph_segment_create_filters() - passed as the
     * third argument to avfilter_graph_alloc_filter(), then freed and set to
     * NULL.
     */
    char                *instance_name;
    /**
     * Options to be apllied to the filter.
     *
     * Filled by avfilter_graph_segment_parse(). Afterwards may be freely
     * modified by the caller.
     *
     * Will be applied to the filter by avfilter_graph_segment_apply_opts()
     * with an equivalent of av_opt_set_dict2(filter, &opts, AV_OPT_SEARCH_CHILDREN),
     * i.e. any unapplied options will be left in this dictionary.
     */
    AVDictionary        *opts;
    AVFilterPadParams  **inputs;
    unsigned          nb_inputs;
    AVFilterPadParams  **outputs;
    unsigned          nb_outputs;
 } AVFilterParams;
 /**
 * A filterchain is a list of filter specifications.
 *
 * Created as a child of AVFilterGraphSegment by avfilter_graph_segment_parse().
 * Freed in avfilter_graph_segment_free().
 */
 typedef struct AVFilterChain {
    AVFilterParams  **filters;
    size_t         nb_filters;
 } AVFilterChain;
 /**
 * A parsed representation of a filtergraph segment.
 *
 * A filtergraph segment is conceptually a list of filterchains, with some
 * supplementary information (e.g. format conversion flags).
 *
 * Created by avfilter_graph_segment_parse(). Must be freed with
 * avfilter_graph_segment_free().
 */
 typedef struct AVFilterGraphSegment {
    /**
     * The filtergraph this segment is associated with.
     * Set by avfilter_graph_segment_parse().
     */
    AVFilterGraph *graph;
    /**
     * A list of filter chain contained in this segment.
     * Set in avfilter_graph_segment_parse().
     */
    AVFilterChain **chains;
    size_t       nb_chains;
    /**
     * A string containing a colon-separated list of key=value options applied
     * to all scale filters in this segment.
     *
     * May be set by avfilter_graph_segment_parse().
     * The caller may free this string with av_free() and replace it with a
     * different av_malloc()'ed string.
     */
    char *scale_sws_opts;
 } AVFilterGraphSegment;
 /**
 * Parse a textual filtergraph description into an intermediate form.
 *
 * This intermediate representation is intended to be modified by the caller as
 * described in the documentation of AVFilterGraphSegment and its children, and
 * then applied to the graph either manually or with other
 * avfilter_graph_segment_*() functions. See the documentation for
 * avfilter_graph_segment_apply() for the canonical way to apply
 * AVFilterGraphSegment.
 *
 * @param graph Filter graph the parsed segment is associated with. Will only be
 *              used for logging and similar auxiliary purposes. The graph will
 *              not be actually modified by this function - the parsing results
 *              are instead stored in seg for further processing.
 * @param graph_str a string describing the filtergraph segment
 * @param flags reserved for future use, caller must set to 0 for now
 * @param seg A pointer to the newly-created AVFilterGraphSegment is written
 *            here on success. The graph segment is owned by the caller and must
 *            be freed with avfilter_graph_segment_free() before graph itself is
 *            freed.
 *
 * @retval "non-negative number" success
 * @retval "negative error code" failure
 */
 int avfilter_graph_segment_parse(AVFilterGraph *graph, const char *graph_str,
                                 int flags, AVFilterGraphSegment **seg);
 /**
 * Create filters specified in a graph segment.
 *
 * Walk through the creation-pending AVFilterParams in the segment and create
 * new filter instances for them.
 * Creation-pending params are those where AVFilterParams.filter_name is
 * non-NULL (and hence AVFilterParams.filter is NULL). All other AVFilterParams
 * instances are ignored.
 *
 * For any filter created by this function, the corresponding
 * AVFilterParams.filter is set to the newly-created filter context,
 * AVFilterParams.filter_name and AVFilterParams.instance_name are freed and set
 * to NULL.
 *
 * @param seg the filtergraph segment to process
 * @param flags reserved for future use, caller must set to 0 for now
 *
 * @retval "non-negative number" Success, all creation-pending filters were
 *                               successfully created
 * @retval AVERROR_FILTER_NOT_FOUND some filter's name did not correspond to a
 *                                  known filter
 * @retval "another negative error code" other failures
 *
 * @note Calling this function multiple times is safe, as it is idempotent.
 */
 int avfilter_graph_segment_create_filters(AVFilterGraphSegment *seg, int flags);
 /**
 * Apply parsed options to filter instances in a graph segment.
 *
 * Walk through all filter instances in the graph segment that have option
 * dictionaries associated with them and apply those options with
 * av_opt_set_dict2(..., AV_OPT_SEARCH_CHILDREN). AVFilterParams.opts is
 * replaced by the dictionary output by av_opt_set_dict2(), which should be
 * empty (NULL) if all options were successfully applied.
 *
 * If any options could not be found, this function will continue processing all
 * other filters and finally return AVERROR_OPTION_NOT_FOUND (unless another
 * error happens). The calling program may then deal with unapplied options as
 * it wishes.
 *
 * Any creation-pending filters (see avfilter_graph_segment_create_filters())
 * present in the segment will cause this function to fail. AVFilterParams with
 * no associated filter context are simply skipped.
 *
 * @param seg the filtergraph segment to process
 * @param flags reserved for future use, caller must set to 0 for now
 *
 * @retval "non-negative number" Success, all options were successfully applied.
 * @retval AVERROR_OPTION_NOT_FOUND some options were not found in a filter
 * @retval "another negative error code" other failures
 *
 * @note Calling this function multiple times is safe, as it is idempotent.
 */
 int avfilter_graph_segment_apply_opts(AVFilterGraphSegment *seg, int flags);
 /**
 * Initialize all filter instances in a graph segment.
 *
 * Walk through all filter instances in the graph segment and call
 * avfilter_init_dict(..., NULL) on those that have not been initialized yet.
 *
 * Any creation-pending filters (see avfilter_graph_segment_create_filters())
 * present in the segment will cause this function to fail. AVFilterParams with
 * no associated filter context or whose filter context is already initialized,
 * are simply skipped.
 *
 * @param seg the filtergraph segment to process
 * @param flags reserved for future use, caller must set to 0 for now
 *
 * @retval "non-negative number" Success, all filter instances were successfully
 *                               initialized
 * @retval "negative error code" failure
 *
 * @note Calling this function multiple times is safe, as it is idempotent.
 */
 int avfilter_graph_segment_init(AVFilterGraphSegment *seg, int flags);
 /**
 * Link filters in a graph segment.
 *
 * Walk through all filter instances in the graph segment and try to link all
 * unlinked input and output pads. Any creation-pending filters (see
 * avfilter_graph_segment_create_filters()) present in the segment will cause
 * this function to fail. Disabled filters and already linked pads are skipped.
 *
 * Every filter output pad that has a corresponding AVFilterPadParams with a
 * non-NULL label is
 * - linked to the input with the matching label, if one exists;
 * - exported in the outputs linked list otherwise, with the label preserved.
 * Unlabeled outputs are
 * - linked to the first unlinked unlabeled input in the next non-disabled
 *   filter in the chain, if one exists
 * - exported in the ouputs linked list otherwise, with NULL label
 *
 * Similarly, unlinked input pads are exported in the inputs linked list.
 *
 * @param seg the filtergraph segment to process
 * @param flags reserved for future use, caller must set to 0 for now
 * @param[out] inputs  a linked list of all free (unlinked) inputs of the
 *                     filters in this graph segment will be returned here. It
 *                     is to be freed by the caller using avfilter_inout_free().
 * @param[out] outputs a linked list of all free (unlinked) outputs of the
 *                     filters in this graph segment will be returned here. It
 *                     is to be freed by the caller using avfilter_inout_free().
 *
 * @retval "non-negative number" success
 * @retval "negative error code" failure
 *
 * @note Calling this function multiple times is safe, as it is idempotent.
 */
 int avfilter_graph_segment_link(AVFilterGraphSegment *seg, int flags,
                                AVFilterInOut **inputs,
                                AVFilterInOut **outputs);
 /**
 * Apply all filter/link descriptions from a graph segment to the associated filtergraph.
 *
 * This functions is currently equivalent to calling the following in sequence:
 * - avfilter_graph_segment_create_filters();
 * - avfilter_graph_segment_apply_opts();
 * - avfilter_graph_segment_init();
 * - avfilter_graph_segment_link();
 * failing if any of them fails. This list may be extended in the future.
 *
 * Since the above functions are idempotent, the caller may call some of them
 * manually, then do some custom processing on the filtergraph, then call this
 * function to do the rest.
 *
 * @param seg the filtergraph segment to process
 * @param flags reserved for future use, caller must set to 0 for now
 * @param[out] inputs passed to avfilter_graph_segment_link()
 * @param[out] outputs passed to avfilter_graph_segment_link()
 *
 * @retval "non-negative number" success
 * @retval "negative error code" failure
 *
 * @note Calling this function multiple times is safe, as it is idempotent.
 */
 int avfilter_graph_segment_apply(AVFilterGraphSegment *seg, int flags,
                                 AVFilterInOut **inputs,
                                 AVFilterInOut **outputs);
 /**
 * Free the provided AVFilterGraphSegment and everything associated with it.
 *
 * @param seg double pointer to the AVFilterGraphSegment to be freed. NULL will
 * be written to this pointer on exit from this function.
 *
 * @note
 * The filter contexts (AVFilterParams.filter) are owned by AVFilterGraph rather
 * than AVFilterGraphSegment, so they are not freed.
 */
 void avfilter_graph_segment_free(AVFilterGraphSegment **seg);
 /**
 * Send a command to one or more filter instances.
 *
--- a/output/include/arm64-v8a/libavfilter/avfiltergraph.h
+++ b/output/include/arm64-v8a/libavfilter/avfiltergraph.h
@ -1,4 +1,7 @@
 /*
 * Filter graphs
 * copyright (c) 2007 Bobby Bingham
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
@ -16,20 +19,10 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
-#ifndef SWSCALE_VERSION_MAJOR_H
+#ifndef AVFILTER_AVFILTERGRAPH_H
-#define SWSCALE_VERSION_MAJOR_H
+#define AVFILTER_AVFILTERGRAPH_H
 /**
 * @file
 * swscale version macros
 */
-#define LIBSWSCALE_VERSION_MAJOR   7
+#include "avfilter.h"
-
+#include "libavutil/log.h"
 /**
 * 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.
 */
-#endif /* SWSCALE_VERSION_MAJOR_H */
+#endif /* AVFILTER_AVFILTERGRAPH_H */
--- a/output/include/arm64-v8a/libavfilter/buffersink.h
+++ b/output/include/arm64-v8a/libavfilter/buffersink.h
@ -31,41 +31,6 @@
 * @defgroup lavfi_buffersink Buffer sink API
 * @ingroup lavfi
 * @{
 *
 * The buffersink and abuffersink filters are there to connect filter graphs
 * to applications. They have a single input, connected to the graph, and no
 * output. Frames must be extracted using av_buffersink_get_frame() or
 * av_buffersink_get_samples().
 *
 * The format negotiated by the graph during configuration can be obtained
 * using the accessor functions:
 * - av_buffersink_get_time_base(),
 * - av_buffersink_get_format(),
 * - av_buffersink_get_frame_rate(),
 * - av_buffersink_get_w(),
 * - av_buffersink_get_h(),
 * - av_buffersink_get_sample_aspect_ratio(),
 * - av_buffersink_get_channels(),
 * - av_buffersink_get_ch_layout(),
 * - av_buffersink_get_sample_rate().
 *
 * The layout returned by av_buffersink_get_ch_layout() must de uninitialized
 * by the caller.
 *
 * The format can be constrained by setting options, using av_opt_set() and
 * related functions with the AV_OPT_SEARCH_CHILDREN flag.
 *  - pix_fmts (int list),
 *  - sample_fmts (int list),
 *  - sample_rates (int list),
 *  - ch_layouts (string),
 *  - channel_counts (int list),
 *  - all_channel_counts (bool).
 * Most of these options are of type binary, and should be set using
 * av_opt_set_int_list() or av_opt_set_bin(). If they are not set, all
 * corresponding formats are accepted.
 *
 * As a special case, if ch_layouts is not set, all valid channel layouts are
 * accepted except for UNSPEC layouts, unless all_channel_counts is set.
 */
 /**
@ -94,6 +59,38 @@ int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flag
 */
 #define AV_BUFFERSINK_FLAG_NO_REQUEST 2
 /**
 * Struct to use for initializing a buffersink context.
 */
 typedef struct AVBufferSinkParams {
    const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
 } AVBufferSinkParams;
 /**
 * Create an AVBufferSinkParams structure.
 *
 * Must be freed with av_free().
 */
 AVBufferSinkParams *av_buffersink_params_alloc(void);
 /**
 * Struct to use for initializing an abuffersink context.
 */
 typedef struct AVABufferSinkParams {
    const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
    const int64_t *channel_layouts;         ///< list of allowed channel layouts, terminated by -1
    const int *channel_counts;              ///< list of allowed channel counts, terminated by -1
    int all_channel_counts;                 ///< if not 0, accept any channel count or layout
    int *sample_rates;                      ///< list of allowed sample rates, terminated by -1
 } AVABufferSinkParams;
 /**
 * Create an AVABufferSinkParams structure.
 *
 * Must be freed with av_free().
 */
 AVABufferSinkParams *av_abuffersink_params_alloc(void);
 /**
 * Set the frame size for an audio buffer sink.
 *
@ -119,12 +116,7 @@ int              av_buffersink_get_h                   (const AVFilterContext *c
 AVRational       av_buffersink_get_sample_aspect_ratio (const AVFilterContext *ctx);
 int              av_buffersink_get_channels            (const AVFilterContext *ctx);
 #if FF_API_OLD_CHANNEL_LAYOUT
 attribute_deprecated
 uint64_t         av_buffersink_get_channel_layout      (const AVFilterContext *ctx);
 #endif
 int              av_buffersink_get_ch_layout           (const AVFilterContext *ctx,
                                                        AVChannelLayout *ch_layout);
 int              av_buffersink_get_sample_rate         (const AVFilterContext *ctx);
 AVBufferRef *    av_buffersink_get_hw_frames_ctx       (const AVFilterContext *ctx);
@ -159,7 +151,7 @@ int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame);
 *              the end of stream, when it can contain less than nb_samples.
 *
 * @return The return codes have the same meaning as for
- *         av_buffersink_get_frame().
+ *         av_buffersink_get_samples().
 *
 * @warning do not mix this function with av_buffersink_get_frame(). Use only one or
 * the other with a single sink, not both.
--- a/output/include/arm64-v8a/libavfilter/buffersrc.h
+++ b/output/include/arm64-v8a/libavfilter/buffersrc.h
@ -106,23 +106,14 @@ typedef struct AVBufferSrcParameters {
    AVBufferRef *hw_frames_ctx;
    /**
-     * Audio only, the audio sampling rate in samples per second.
+     * Audio only, the audio sampling rate in samples per secon.
     */
    int sample_rate;
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * Audio only, the audio channel layout
     * @deprecated use ch_layout
     */
    attribute_deprecated
    uint64_t channel_layout;
 #endif
    /**
     * Audio only, the audio channel layout
     */
    AVChannelLayout ch_layout;
 } AVBufferSrcParameters;
 /**
--- a/output/include/arm64-v8a/libavfilter/version.h
+++ b/output/include/arm64-v8a/libavfilter/version.h
@ -29,12 +29,10 @@
 #include "libavutil/version.h"
-#include "version_major.h"
+#define LIBAVFILTER_VERSION_MAJOR   6
-
+#define LIBAVFILTER_VERSION_MINOR 107
 #define LIBAVFILTER_VERSION_MINOR   3
 #define LIBAVFILTER_VERSION_MICRO 100
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
                                               LIBAVFILTER_VERSION_MINOR, \
                                               LIBAVFILTER_VERSION_MICRO)
@ -45,4 +43,32 @@
 #define LIBAVFILTER_IDENT       "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION)
 /**
 * 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.
 */
 #ifndef FF_API_OLD_FILTER_OPTS
 #define FF_API_OLD_FILTER_OPTS              (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_OLD_FILTER_OPTS_ERROR
 #define FF_API_OLD_FILTER_OPTS_ERROR        (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_AVFILTER_OPEN
 #define FF_API_AVFILTER_OPEN                (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_AVFILTER_INIT_FILTER
 #define FF_API_AVFILTER_INIT_FILTER         (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_OLD_FILTER_REGISTER
 #define FF_API_OLD_FILTER_REGISTER          (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_NOCONST_GET_NAME
 #define FF_API_NOCONST_GET_NAME             (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #ifndef FF_API_LAVR_OPTS
 #define FF_API_LAVR_OPTS                    (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
 #endif /* AVFILTER_VERSION_H */
--- a/output/include/arm64-v8a/libavfilter/version_major.h
+++ b/output/include/arm64-v8a/libavfilter/version_major.h
@ -1,38 +0,0 @@
 /*
 * Version macros.
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVFILTER_VERSION_MAJOR_H
 #define AVFILTER_VERSION_MAJOR_H
 /**
 * @file
 * @ingroup lavfi
 * Libavfilter version macros
 */
 #define LIBAVFILTER_VERSION_MAJOR   9
 /**
 * 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.
 */
 #endif /* AVFILTER_VERSION_MAJOR_H */
--- a/output/include/arm64-v8a/libavformat/avformat.h
+++ b/output/include/arm64-v8a/libavformat/avformat.h
--- a/output/include/arm64-v8a/libavformat/avio.h
+++ b/output/include/arm64-v8a/libavformat/avio.h
@ -27,13 +27,12 @@
 */
 #include <stdint.h>
 #include <stdio.h>
-#include "libavutil/attributes.h"
+#include "libavutil/common.h"
 #include "libavutil/dict.h"
 #include "libavutil/log.h"
-#include "libavformat/version_major.h"
+#include "libavformat/version.h"
 /**
 * Seeking works like for a local file.
@ -101,13 +100,9 @@ typedef struct AVIODirEntry {
    int64_t filemode;                     /**< Unix file mode, -1 if unknown. */
 } AVIODirEntry;
 #if FF_API_AVIODIRCONTEXT
 typedef struct AVIODirContext {
    struct URLContext *url_context;
 } AVIODirContext;
 #else
 typedef struct AVIODirContext AVIODirContext;
 #endif
 /**
 * Different data types that can be returned via the AVIO
@ -153,9 +148,9 @@ enum AVIODataMarkerType {
 /**
 * Bytestream IO Context.
- * New public fields can be added with minor version bumps.
+ * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing public fields require
+ * Removal, reordering and changes to existing fields require a major
- * a major version bump.
+ * version bump.
 * sizeof(AVIOContext) must not be used outside libav*.
 *
 * @note None of the function pointers in AVIOContext should be called
@ -241,15 +236,14 @@ typedef struct AVIOContext {
    int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
    int64_t (*seek)(void *opaque, int64_t offset, int whence);
    int64_t pos;            /**< position in the file of the current buffer */
-    int eof_reached;        /**< true if was unable to read due to error or eof */
+    int must_flush;         /**< unused */
-    int error;              /**< contains the error code or 0 if no error happened */
+    int eof_reached;        /**< true if eof reached */
    int write_flag;         /**< true if open for writing */
    int max_packet_size;
    int min_packet_size;    /**< Try to buffer at least this amount of data
                                 before flushing it. */
    unsigned long checksum;
    unsigned char *checksum_ptr;
    unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
    int error;              /**< contains the error code or 0 if no error happened */
    /**
     * Pause or resume playback for network streaming protocols - e.g. MMS.
     */
@ -266,6 +260,12 @@ typedef struct AVIOContext {
     */
    int seekable;
    /**
     * max filesize, used to limit allocations
     * This field is internal to libavformat and access from outside is not allowed.
     */
    int64_t maxsize;
    /**
     * avio_read and avio_write should if possible be satisfied directly
     * instead of going through a buffer, and avio_seek will always
@ -273,6 +273,37 @@ typedef struct AVIOContext {
     */
    int direct;
    /**
     * Bytes read statistic
     * This field is internal to libavformat and access from outside is not allowed.
     */
    int64_t bytes_read;
    /**
     * seek statistic
     * This field is internal to libavformat and access from outside is not allowed.
     */
    int seek_count;
    /**
     * writeout statistic
     * This field is internal to libavformat and access from outside is not allowed.
     */
    int writeout_count;
    /**
     * Original buffer size
     * used internally after probing and ensure seekback to reset the buffer size
     * This field is internal to libavformat and access from outside is not allowed.
     */
    int orig_buffer_size;
    /**
     * Threshold to favor readahead over seek.
     * This is current internal only, do not use from outside.
     */
    int short_seek_threshold;
    /**
     * ',' separated list of allowed protocols.
     */
@ -296,20 +327,29 @@ typedef struct AVIOContext {
    int ignore_boundary_point;
    /**
-     * Maximum reached position before a backward seek in the write buffer,
+     * Internal, not meant to be used from outside of AVIOContext.
     * used keeping track of already written data for a later flush.
     */
-    unsigned char *buf_ptr_max;
+    enum AVIODataMarkerType current_type;
    int64_t last_time;
    /**
-     * Read-only statistic of bytes read for this AVIOContext.
+     * A callback that is used instead of short_seek_threshold.
     * This is current internal only, do not use from outside.
     */
-    int64_t bytes_read;
+    int (*short_seek_get)(void *opaque);
    int64_t written;
    /**
-     * Read-only statistic of bytes written for this AVIOContext.
+     * Maximum reached position before a backward seek in the write buffer,
     * used keeping track of already written data for a later flush.
     */
-    int64_t bytes_written;
+    unsigned char *buf_ptr_max;
    /**
     * Try to buffer at least this amount of data before flushing it
     */
    int min_packet_size;
 } AVIOContext;
 /**
@ -335,6 +375,25 @@ const char *avio_find_protocol_name(const char *url);
 */
 int avio_check(const char *url, int flags);
 /**
 * Move or rename a resource.
 *
 * @note url_src and url_dst should share the same protocol and authority.
 *
 * @param url_src url to resource to be moved
 * @param url_dst new url to resource if the operation succeeded
 * @return >=0 on success or negative on error.
 */
 int avpriv_io_move(const char *url_src, const char *url_dst);
 /**
 * Delete a resource.
 *
 * @param url resource to be deleted.
 * @return >=0 on success or negative on error.
 */
 int avpriv_io_delete(const char *url);
 /**
 * Open directory for reading.
 *
@ -393,8 +452,6 @@ void avio_free_directory_entry(AVIODirEntry **entry);
 * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.
 * @param opaque An opaque pointer to user-specific data.
 * @param read_packet  A function for refilling the buffer, may be NULL.
 *                     For stream protocols, must never return 0 but rather
 *                     a proper AVERROR code.
 * @param write_packet A function for writing the buffer contents, may be NULL.
 *        The function may not change the input buffers content.
 * @param seek A function for seeking to specified byte position, may be NULL.
@ -458,7 +515,6 @@ int avio_put_str16be(AVIOContext *s, const char *str);
 *
 * Zero-length ranges are omitted from the output.
 *
 * @param s    the AVIOContext
 * @param time the stream time the current bytestream pos corresponds to
 *             (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not
 *             applicable
@ -509,40 +565,21 @@ static av_always_inline int64_t avio_tell(AVIOContext *s)
 int64_t avio_size(AVIOContext *s);
 /**
- * Similar to feof() but also returns nonzero on read errors.
+ * feof() equivalent for AVIOContext.
- * @return non zero if and only if at end of file or a read error happened when reading.
+ * @return non zero if and only if end of file
 */
 int avio_feof(AVIOContext *s);
-
+#if FF_API_URL_FEOF
 /**
- * Writes a formatted string to the context taking a va_list.
+ * @deprecated use avio_feof()
 * @return number of bytes written, < 0 on error.
 */
-int avio_vprintf(AVIOContext *s, const char *fmt, va_list ap);
+attribute_deprecated
 int url_feof(AVIOContext *s);
 #endif
-/**
+/** @warning Writes up to 4 KiB per call */
 * Writes a formatted string to the context.
 * @return number of bytes written, < 0 on error.
 */
 int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
 /**
 * Write a NULL terminated array of strings to the context.
 * Usually you don't need to use this function directly but its macro wrapper,
 * avio_print.
 */
 void avio_print_string_array(AVIOContext *s, const char *strings[]);
 /**
 * Write strings (const char *) to the context.
 * This is a convenience macro around avio_print_string_array and it
 * automatically creates the string array from the variable argument list.
 * For simple string concatenations this function is more performant than using
 * avio_printf since it does not need a temporary buffer.
 */
 #define avio_print(s, ...) \
    avio_print_string_array(s, (const char*[]){__VA_ARGS__, NULL})
 /**
 * Force flushing of buffered data.
 *
@ -756,13 +793,6 @@ int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
 */
 const char *avio_enum_protocols(void **opaque, int output);
 /**
 * Get AVClass by names of available protocols.
 *
 * @return A AVClass of input protocol name or NULL
 */
 const AVClass *avio_protocol_get_class(const char *name);
 /**
 * Pause and resume playing - only meaningful if using a network streaming
 * protocol (e.g. MMS).
--- a/output/include/arm64-v8a/libavformat/version.h
+++ b/output/include/arm64-v8a/libavformat/version.h
@ -29,9 +29,10 @@
 #include "libavutil/version.h"
-#include "version_major.h"
+// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
-
+// Also please add any ticket numbers that you believe might be affected here
-#define LIBAVFORMAT_VERSION_MINOR   3
+#define LIBAVFORMAT_VERSION_MAJOR  57
 #define LIBAVFORMAT_VERSION_MINOR  83
 #define LIBAVFORMAT_VERSION_MICRO 100
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@ -44,4 +45,61 @@
 #define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
 /**
 * 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_LAVF_BITEXACT
 #define FF_API_LAVF_BITEXACT            (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_FRAC
 #define FF_API_LAVF_FRAC                (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_CODEC_TB
 #define FF_API_LAVF_CODEC_TB            (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_URL_FEOF
 #define FF_API_URL_FEOF                 (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_FMT_RAWPICTURE
 #define FF_API_LAVF_FMT_RAWPICTURE      (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_COMPUTE_PKT_FIELDS2
 #define FF_API_COMPUTE_PKT_FIELDS2      (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_OLD_OPEN_CALLBACKS
 #define FF_API_OLD_OPEN_CALLBACKS       (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_AVCTX
 #define FF_API_LAVF_AVCTX               (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_NOCONST_GET_SIDE_DATA
 #define FF_API_NOCONST_GET_SIDE_DATA    (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_HTTP_USER_AGENT
 #define FF_API_HTTP_USER_AGENT          (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_HLS_WRAP
 #define FF_API_HLS_WRAP                 (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_MERGE_SD
 #define FF_API_LAVF_MERGE_SD            (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_LAVF_KEEPSIDE_FLAG
 #define FF_API_LAVF_KEEPSIDE_FLAG       (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_OLD_ROTATE_API
 #define FF_API_OLD_ROTATE_API           (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
 #ifndef FF_API_R_FRAME_RATE
 #define FF_API_R_FRAME_RATE            1
 #endif
 #endif /* AVFORMAT_VERSION_H */
--- a/output/include/arm64-v8a/libavformat/version_major.h
+++ b/output/include/arm64-v8a/libavformat/version_major.h
@ -1,52 +0,0 @@
 /*
 * Version macros.
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVFORMAT_VERSION_MAJOR_H
 #define AVFORMAT_VERSION_MAJOR_H
 /**
 * @file
 * @ingroup libavf
 * Libavformat version macros
 */
 // Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
 // Also please add any ticket numbers that you believe might be affected here
 #define LIBAVFORMAT_VERSION_MAJOR  60
 /**
 * 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.
 *
 */
 #define FF_API_COMPUTE_PKT_FIELDS2      (LIBAVFORMAT_VERSION_MAJOR < 61)
 #define FF_API_GET_END_PTS              (LIBAVFORMAT_VERSION_MAJOR < 61)
 #define FF_API_AVIODIRCONTEXT           (LIBAVFORMAT_VERSION_MAJOR < 61)
 #define FF_API_AVFORMAT_IO_CLOSE        (LIBAVFORMAT_VERSION_MAJOR < 61)
 #define FF_API_R_FRAME_RATE            1
 #endif /* AVFORMAT_VERSION_MAJOR_H */
--- a/output/include/arm64-v8a/libavutil/adler32.h
+++ b/output/include/arm64-v8a/libavutil/adler32.h
@ -27,7 +27,6 @@
 #ifndef AVUTIL_ADLER32_H
 #define AVUTIL_ADLER32_H
 #include <stddef.h>
 #include <stdint.h>
 #include "attributes.h"
@ -39,8 +38,6 @@
 * @{
 */
 typedef uint32_t AVAdler;
 /**
 * Calculate the Adler32 checksum of a buffer.
 *
@ -53,8 +50,8 @@ typedef uint32_t AVAdler;
 * @param len   size of input buffer
 * @return      updated checksum
 */
-AVAdler av_adler32_update(AVAdler adler, const uint8_t *buf,
+unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
-                          size_t len) av_pure;
+                                unsigned int len) av_pure;
 /**
 * @}
--- a/output/include/arm64-v8a/libavutil/aes.h
+++ b/output/include/arm64-v8a/libavutil/aes.h
@ -24,6 +24,7 @@
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_aes AES
@ -42,9 +43,6 @@ struct AVAES *av_aes_alloc(void);
 /**
 * Initialize an AVAES context.
 *
 * @param a The AVAES context
 * @param key Pointer to the key
 * @param key_bits 128, 192 or 256
 * @param decrypt 0 for encryption, 1 for decryption
 */
@ -52,11 +50,9 @@ int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
 /**
 * Encrypt or decrypt a buffer using a previously initialized context.
- *
+ * @param count number of 16 byte blocks
 * @param a The AVAES context
 * @param dst destination array, can be equal to src
 * @param src source array, can be equal to dst
 * @param count number of 16 byte blocks
 * @param iv initialization vector for CBC mode, if NULL then ECB will be used
 * @param decrypt 0 for encryption, 1 for decryption
 */
--- a/output/include/arm64-v8a/libavutil/aes_ctr.h
+++ b/output/include/arm64-v8a/libavutil/aes_ctr.h
@ -22,15 +22,10 @@
 #ifndef AVUTIL_AES_CTR_H
 #define AVUTIL_AES_CTR_H
 /**
 * @defgroup lavu_aes_ctr AES-CTR
 * @ingroup lavu_crypto
 * @{
 */
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 #define AES_CTR_KEY_SIZE (16)
 #define AES_CTR_IV_SIZE (8)
@ -44,23 +39,17 @@ struct AVAESCTR *av_aes_ctr_alloc(void);
 /**
 * Initialize an AVAESCTR context.
 *
 * @param a The AVAESCTR context to initialize
 * @param key encryption key, must have a length of AES_CTR_KEY_SIZE
 */
 int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key);
 /**
 * Release an AVAESCTR context.
 *
 * @param a The AVAESCTR context
 */
 void av_aes_ctr_free(struct AVAESCTR *a);
 /**
 * Process a buffer using a previously initialized context.
 *
 * @param a The AVAESCTR context
 * @param dst destination array, can be equal to src
 * @param src source array, can be equal to dst
 * @param size the size of src and dst
@ -78,15 +67,10 @@ const uint8_t* av_aes_ctr_get_iv(struct AVAESCTR *a);
 void av_aes_ctr_set_random_iv(struct AVAESCTR *a);
 /**
- * Forcefully change the 8-byte iv
+ * Forcefully change the iv
 */
 void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t* iv);
 /**
 * Forcefully change the "full" 16-byte iv, including the counter
 */
 void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t* iv);
 /**
 * Increment the top 64 bit of the iv (performed after each frame)
 */
--- a/output/include/arm64-v8a/libavutil/ambient_viewing_environment.h
+++ b/output/include/arm64-v8a/libavutil/ambient_viewing_environment.h
@ -1,72 +0,0 @@
 /*
 * Copyright (c) 2023 Jan Ekström <jeebjp@gmail.com>
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H
 #define AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H
 #include <stddef.h>
 #include "frame.h"
 #include "rational.h"
 /**
 * Ambient viewing environment metadata as defined by H.274. The values are
 * saved in AVRationals so that they keep their exactness, while allowing for
 * easy access to a double value with f.ex. av_q2d.
 *
 * @note sizeof(AVAmbientViewingEnvironment) is not part of the public ABI, and
 *       it must be allocated using av_ambient_viewing_environment_alloc.
 */
 typedef struct AVAmbientViewingEnvironment {
    /**
     * Environmental illuminance of the ambient viewing environment in lux.
     */
    AVRational ambient_illuminance;
    /**
     * Normalized x chromaticity coordinate of the environmental ambient light
     * in the nominal viewing environment according to the CIE 1931 definition
     * of x and y as specified in ISO/CIE 11664-1.
     */
    AVRational ambient_light_x;
    /**
     * Normalized y chromaticity coordinate of the environmental ambient light
     * in the nominal viewing environment according to the CIE 1931 definition
     * of x and y as specified in ISO/CIE 11664-1.
     */
    AVRational ambient_light_y;
 } AVAmbientViewingEnvironment;
 /**
 * Allocate an AVAmbientViewingEnvironment structure.
 *
 * @return the newly allocated struct or NULL on failure
 */
 AVAmbientViewingEnvironment *av_ambient_viewing_environment_alloc(size_t *size);
 /**
 * Allocate and add an AVAmbientViewingEnvironment structure to an existing
 * AVFrame as side data.
 *
 * @return the newly allocated struct, or NULL on failure
 */
 AVAmbientViewingEnvironment *av_ambient_viewing_environment_create_side_data(AVFrame *frame);
 #endif /* AVUTIL_AMBIENT_VIEWING_ENVIRONMENT_H */
--- a/output/include/arm64-v8a/libavutil/attributes.h
+++ b/output/include/arm64-v8a/libavutil/attributes.h
@ -34,12 +34,6 @@
 #    define AV_GCC_VERSION_AT_MOST(x,y)  0
 #endif
 #ifdef __has_builtin
 #    define AV_HAS_BUILTIN(x) __has_builtin(x)
 #else
 #    define AV_HAS_BUILTIN(x) 0
 #endif
 #ifndef av_always_inline
 #if AV_GCC_VERSION_AT_LEAST(3,1)
 #    define av_always_inline __attribute__((always_inline)) inline
@ -72,19 +66,19 @@
 #    define av_noinline
 #endif
-#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(3,1)
 #    define av_pure __attribute__((pure))
 #else
 #    define av_pure
 #endif
-#if AV_GCC_VERSION_AT_LEAST(2,6) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(2,6)
 #    define av_const __attribute__((const))
 #else
 #    define av_const
 #endif
-#if AV_GCC_VERSION_AT_LEAST(4,3) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(4,3)
 #    define av_cold __attribute__((cold))
 #else
 #    define av_cold
@ -110,7 +104,7 @@
 * scheduled for removal.
 */
 #ifndef AV_NOWARN_DEPRECATED
-#if AV_GCC_VERSION_AT_LEAST(4,6) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(4,6)
 #    define AV_NOWARN_DEPRECATED(code) \
        _Pragma("GCC diagnostic push") \
        _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
@ -144,19 +138,19 @@
 #    define av_used
 #endif
-#if AV_GCC_VERSION_AT_LEAST(3,3) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(3,3)
 #   define av_alias __attribute__((may_alias))
 #else
 #   define av_alias
 #endif
-#if (defined(__GNUC__) || defined(__clang__)) && !defined(__INTEL_COMPILER)
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__)
 #    define av_uninit(x) x=x
 #else
 #    define av_uninit(x) x
 #endif
-#if defined(__GNUC__) || defined(__clang__)
+#ifdef __GNUC__
 #    define av_builtin_constant_p __builtin_constant_p
 #    define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos)))
 #else
@ -164,7 +158,7 @@
 #    define av_printf_format(fmtpos, attrpos)
 #endif
-#if AV_GCC_VERSION_AT_LEAST(2,5) || defined(__clang__)
+#if AV_GCC_VERSION_AT_LEAST(2,5)
 #    define av_noreturn __attribute__((noreturn))
 #else
 #    define av_noreturn
--- a/output/include/arm64-v8a/libavutil/audio_fifo.h
+++ b/output/include/arm64-v8a/libavutil/audio_fifo.h
@ -27,7 +27,8 @@
 #ifndef AVUTIL_AUDIO_FIFO_H
 #define AVUTIL_AUDIO_FIFO_H
-#include "attributes.h"
+#include "avutil.h"
 #include "fifo.h"
 #include "samplefmt.h"
 /**
--- a/output/include/arm64-v8a/libavutil/avassert.h
+++ b/output/include/arm64-v8a/libavutil/avassert.h
@ -28,8 +28,8 @@
 #define AVUTIL_AVASSERT_H
 #include <stdlib.h>
 #include "avutil.h"
 #include "log.h"
 #include "macros.h"
 /**
 * assert() equivalent, that is always enabled.
@ -66,7 +66,7 @@
 #endif
 /**
- * Assert that floating point operations can be executed.
+ * Assert that floating point opperations can be executed.
 *
 * This will av_assert0() that the cpu is not in MMX state on X86
 */
--- a/output/include/arm64-v8a/libavutil/avconfig.h
+++ b/output/include/arm64-v8a/libavutil/avconfig.h
@ -1,4 +1,4 @@
-/* Generated by ffmpeg configure */
+/* Generated by ffconf */
 #ifndef AVUTIL_AVCONFIG_H
 #define AVUTIL_AVCONFIG_H
 #define AV_HAVE_BIGENDIAN 0
--- a/output/include/arm64-v8a/libavutil/avstring.h
+++ b/output/include/arm64-v8a/libavutil/avstring.h
@ -24,7 +24,6 @@
 #include <stddef.h>
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @addtogroup lavu_string
@ -135,7 +134,6 @@ size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_forma
 /**
 * Get the count of continuous non zero chars starting from the beginning.
 *
 * @param s   the string whose length to count
 * @param len maximum number of characters to check in the string, that
 *            is the maximum value which is returned by the function
 */
@ -157,6 +155,11 @@ static inline size_t av_strnlen(const char *s, size_t len)
 */
 char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
 /**
 * Convert a number to an av_malloced string.
 */
 char *av_d2str(double d);
 /**
 * Unescape the given string until a non escaped terminating char,
 * and return the token corresponding to the unescaped string.
@ -271,21 +274,16 @@ char *av_strireplace(const char *str, const char *from, const char *to);
 /**
 * Thread safe basename.
- * @param path the string to parse, on DOS both \ and / are considered separators.
+ * @param path the path, on DOS both \ and / are considered separators.
 * @return pointer to the basename substring.
 * If path does not contain a slash, the function returns a copy of path.
 * If path is a NULL pointer or points to an empty string, a pointer
 * to a string "." is returned.
 */
 const char *av_basename(const char *path);
 /**
 * Thread safe dirname.
- * @param path the string to parse, on DOS both \ and / are considered separators.
+ * @param path the path, on DOS both \ and / are considered separators.
- * @return A pointer to a string that's the parent directory of path.
+ * @return the path with the separator replaced by the string terminator or ".".
- * If path is a NULL pointer or points to an empty string, a pointer
+ * @note the function may change the input string.
 * to a string "." is returned.
 * @note the function may modify the contents of the path, so copies should be passed.
 */
 const char *av_dirname(char *path);
@ -316,7 +314,6 @@ enum AVEscapeMode {
    AV_ESCAPE_MODE_AUTO,      ///< Use auto-selected escaping mode.
    AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
    AV_ESCAPE_MODE_QUOTE,     ///< Use single-quote escaping.
    AV_ESCAPE_MODE_XML,       ///< Use XML non-markup character data escaping.
 };
 /**
@ -336,19 +333,6 @@ enum AVEscapeMode {
 */
 #define AV_ESCAPE_FLAG_STRICT (1 << 1)
 /**
 * Within AV_ESCAPE_MODE_XML, additionally escape single quotes for single
 * quoted attributes.
 */
 #define AV_ESCAPE_FLAG_XML_SINGLE_QUOTES (1 << 2)
 /**
 * Within AV_ESCAPE_MODE_XML, additionally escape double quotes for double
 * quoted attributes.
 */
 #define AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES (1 << 3)
 /**
 * Escape string in src, and put the escaped string in an allocated
 * string in *dst, which must be freed with av_free().
@ -416,12 +400,6 @@ int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
 */
 int av_match_list(const char *name, const char *list, char separator);
 /**
 * See libc sscanf manual for more information.
 * Locale-independent sscanf implementation.
 */
 int av_sscanf(const char *string, const char *format, ...);
 /**
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/avutil.h
+++ b/output/include/arm64-v8a/libavutil/avutil.h
@ -331,18 +331,12 @@ unsigned av_int_list_length_for_size(unsigned elsize,
 #define av_int_list_length(list, term) \
    av_int_list_length_for_size(sizeof(*(list)), list, term)
 #if FF_API_AV_FOPEN_UTF8
 /**
 * Open a file using a UTF-8 filename.
 * The API of this function matches POSIX fopen(), errors are returned through
 * errno.
 * @deprecated Avoid using it, as on Windows, the FILE* allocated by this
 *             function may be allocated with a different CRT than the caller
 *             who uses the FILE*. No replacement provided in public API.
 */
 attribute_deprecated
 FILE *av_fopen_utf8(const char *path, const char *mode);
 #endif
 /**
 * Return the fractional representation of the internal time base.
--- a/output/include/arm64-v8a/libavutil/bprint.h
+++ b/output/include/arm64-v8a/libavutil/bprint.h
@ -18,12 +18,6 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 /**
 * @file
 * @ingroup lavu_avbprint
 * AVBPrint public header
 */
 #ifndef AVUTIL_BPRINT_H
 #define AVUTIL_BPRINT_H
@ -32,14 +26,6 @@
 #include "attributes.h"
 #include "avstring.h"
 /**
 * @defgroup lavu_avbprint AVBPrint
 * @ingroup lavu_data
 *
 * A buffer to print data progressively
 * @{
 */
 /**
 * Define a structure with extra padding to a fixed size
 * This helps ensuring binary compatibility with future versions.
@ -62,14 +48,14 @@ typedef struct name { \
 * Small buffers are kept in the structure itself, and thus require no
 * memory allocation at all (unless the contents of the buffer is needed
 * after the structure goes out of scope). This is almost as lightweight as
- * declaring a local `char buf[512]`.
+ * declaring a local "char buf[512]".
 *
 * The length of the string can go beyond the allocated size: the buffer is
 * then truncated, but the functions still keep account of the actual total
 * length.
 *
- * In other words, AVBPrint.len can be greater than AVBPrint.size and records
+ * In other words, buf->len can be greater than buf->size and records the
- * the total length of what would have been to the buffer if there had been
+ * total length of what would have been to the buffer if there had been
 * enough memory.
 *
 * Append operations do not need to be tested for failure: if a memory
@ -77,14 +63,17 @@ typedef struct name { \
 * is still updated. This situation can be tested with
 * av_bprint_is_complete().
 *
- * The AVBPrint.size_max field determines several possible behaviours:
+ * The size_max field determines several possible behaviours:
- * - `size_max = -1` (= `UINT_MAX`) or any large value will let the buffer be
+ *
 * size_max = -1 (= UINT_MAX) or any large value will let the buffer be
 * reallocated as necessary, with an amortized linear cost.
- * - `size_max = 0` prevents writing anything to the buffer: only the total
+ *
 * size_max = 0 prevents writing anything to the buffer: only the total
 * length is computed. The write operations can then possibly be repeated in
 * a buffer with exactly the necessary size
- *   (using `size_init = size_max = len + 1`).
+ * (using size_init = size_max = len + 1).
- * - `size_max = 1` is automatically replaced by the exact size available in the
+ *
 * size_max = 1 is automatically replaced by the exact size available in the
 * structure itself, thus ensuring no dynamic memory allocation. The
 * internal buffer is large enough to hold a reasonable paragraph of text,
 * such as the current paragraph.
@ -99,31 +88,12 @@ FF_PAD_STRUCTURE(AVBPrint, 1024,
 )
 /**
 * @name Max size special values
 * Convenience macros for special values for av_bprint_init() size_max
 * parameter.
 * @{
 */
 /**
 * Buffer will be reallocated as necessary, with an amortized linear cost.
 */
 #define AV_BPRINT_SIZE_UNLIMITED  ((unsigned)-1)
 /**
 * Use the exact size available in the AVBPrint structure itself.
 *
 * Thus ensuring no dynamic memory allocation. The internal buffer is large
 * enough to hold a reasonable paragraph of text, such as the current paragraph.
 */
 #define AV_BPRINT_SIZE_AUTOMATIC  1
 /**
 * Do not write anything to the buffer, only calculate the total length.
 *
 * The write operations can then possibly be repeated in a buffer with
 * exactly the necessary size (using `size_init = size_max = AVBPrint.len + 1`).
 */
 #define AV_BPRINT_SIZE_COUNT_ONLY 0
 /** @} */
 /**
 * Init a print buffer.
@ -131,12 +101,12 @@ FF_PAD_STRUCTURE(AVBPrint, 1024,
 * @param buf        buffer to init
 * @param size_init  initial size (including the final 0)
 * @param size_max   maximum size;
- *                   - `0` means do not write anything, just count the length
+ *                   0 means do not write anything, just count the length;
- *                   - `1` is replaced by the maximum value for automatic storage
+ *                   1 is replaced by the maximum value for automatic storage;
 *                   any large value means that the internal buffer will be
- *                       reallocated as needed up to that limit
+ *                   reallocated as needed up to that limit; -1 is converted to
- *                   - `-1` is converted to `UINT_MAX`, the largest limit possible.
+ *                   UINT_MAX, the largest limit possible.
- *                   Check also `AV_BPRINT_SIZE_*` macros.
+ *                   Check also AV_BPRINT_SIZE_* macros.
 */
 void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max);
@ -246,6 +216,4 @@ int av_bprint_finalize(AVBPrint *buf, char **ret_str);
 void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,
                      enum AVEscapeMode mode, int flags);
 /** @} */
 #endif /* AVUTIL_BPRINT_H */
--- a/output/include/arm64-v8a/libavutil/bswap.h
+++ b/output/include/arm64-v8a/libavutil/bswap.h
@ -40,8 +40,6 @@
 #   include "arm/bswap.h"
 #elif ARCH_AVR32
 #   include "avr32/bswap.h"
 #elif ARCH_RISCV
 #   include "riscv/bswap.h"
 #elif ARCH_SH4
 #   include "sh4/bswap.h"
 #elif ARCH_X86
--- a/output/include/arm64-v8a/libavutil/buffer.h
+++ b/output/include/arm64-v8a/libavutil/buffer.h
@ -25,7 +25,6 @@
 #ifndef AVUTIL_BUFFER_H
 #define AVUTIL_BUFFER_H
 #include <stddef.h>
 #include <stdint.h>
 /**
@ -91,7 +90,7 @@ typedef struct AVBufferRef {
    /**
     * Size of data in bytes.
     */
-    size_t   size;
+    int      size;
 } AVBufferRef;
 /**
@ -99,13 +98,13 @@ typedef struct AVBufferRef {
 *
 * @return an AVBufferRef of given size or NULL when out of memory
 */
-AVBufferRef *av_buffer_alloc(size_t size);
+AVBufferRef *av_buffer_alloc(int size);
 /**
 * Same as av_buffer_alloc(), except the returned buffer will be initialized
 * to zero.
 */
-AVBufferRef *av_buffer_allocz(size_t size);
+AVBufferRef *av_buffer_allocz(int size);
 /**
 * Always treat the buffer as read-only, even when it has only one
@ -128,7 +127,7 @@ AVBufferRef *av_buffer_allocz(size_t size);
 *
 * @return an AVBufferRef referring to data on success, NULL on failure.
 */
-AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
+AVBufferRef *av_buffer_create(uint8_t *data, int size,
                              void (*free)(void *opaque, uint8_t *data),
                              void *opaque, int flags);
@ -145,7 +144,7 @@ void av_buffer_default_free(void *opaque, uint8_t *data);
 * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on
 * failure.
 */
-AVBufferRef *av_buffer_ref(const AVBufferRef *buf);
+AVBufferRef *av_buffer_ref(AVBufferRef *buf);
 /**
 * Free a given reference and automatically free the buffer if there are no more
@ -196,23 +195,7 @@ int av_buffer_make_writable(AVBufferRef **buf);
 * reference to it (i.e. the one passed to this function). In all other cases
 * a new buffer is allocated and the data is copied.
 */
-int av_buffer_realloc(AVBufferRef **buf, size_t size);
+int av_buffer_realloc(AVBufferRef **buf, int size);
 /**
 * Ensure dst refers to the same data as src.
 *
 * When *dst is already equivalent to src, do nothing. Otherwise unreference dst
 * and replace it with a new reference to src.
 *
 * @param dst Pointer to either a valid buffer reference or NULL. On success,
 *            this will point to a buffer reference equivalent to src. On
 *            failure, dst will be left untouched.
 * @param src A buffer reference to replace dst with. May be NULL, then this
 *            function is equivalent to av_buffer_unref(dst).
 * @return 0 on success
 *         AVERROR(ENOMEM) on memory allocation failure.
 */
 int av_buffer_replace(AVBufferRef **dst, const AVBufferRef *src);
 /**
 * @}
@ -263,7 +246,7 @@ typedef struct AVBufferPool AVBufferPool;
 * (av_buffer_alloc()).
 * @return newly created buffer pool on success, NULL on error.
 */
-AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size));
+AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
 /**
 * Allocate and initialize a buffer pool with a more complex allocator.
@ -271,17 +254,16 @@ AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size
 * @param size size of each buffer in this pool
 * @param opaque arbitrary user data used by the allocator
 * @param alloc a function that will be used to allocate new buffers when the
- *              pool is empty. May be NULL, then the default allocator will be
+ *              pool is empty.
 *              used (av_buffer_alloc()).
 * @param pool_free a function that will be called immediately before the pool
 *                  is freed. I.e. after av_buffer_pool_uninit() is called
 *                  by the caller and all the frames are returned to the pool
 *                  and freed. It is intended to uninitialize the user opaque
- *                  data. May be NULL.
+ *                  data.
 * @return newly created buffer pool on success, NULL on error.
 */
-AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
+AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
-                                   AVBufferRef* (*alloc)(void *opaque, size_t size),
+                                   AVBufferRef* (*alloc)(void *opaque, int size),
                                   void (*pool_free)(void *opaque));
 /**
@ -302,19 +284,6 @@ void av_buffer_pool_uninit(AVBufferPool **pool);
 */
 AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
 /**
 * Query the original opaque parameter of an allocated buffer in the pool.
 *
 * @param ref a buffer reference to a buffer returned by av_buffer_pool_get.
 * @return the opaque parameter set by the buffer allocator function of the
 *         buffer pool.
 *
 * @note the opaque parameter of ref is used by the buffer pool implementation,
 * therefore you have to use this function to access the original opaque
 * parameter of an allocated buffer.
 */
 void *av_buffer_pool_buffer_get_opaque(const AVBufferRef *ref);
 /**
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/camellia.h
+++ b/output/include/arm64-v8a/libavutil/camellia.h
@ -59,7 +59,7 @@ int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits);
  * @param dst destination array, can be equal to src
  * @param src source array, can be equal to dst
  * @param count number of 16 byte blocks
-  * @param iv initialization vector for CBC mode, NULL for ECB mode
+  * @paran iv initialization vector for CBC mode, NULL for ECB mode
  * @param decrypt 0 for encryption, 1 for decryption
 */
 void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);
--- a/output/include/arm64-v8a/libavutil/channel_layout.h
+++ b/output/include/arm64-v8a/libavutil/channel_layout.h
@ -23,132 +23,17 @@
 #define AVUTIL_CHANNEL_LAYOUT_H
 #include <stdint.h>
 #include <stdlib.h>
 #include "version.h"
 #include "attributes.h"
 /**
 * @file
- * @ingroup lavu_audio_channels
+ * audio channel layout utility functions
 * Public libavutil channel layout APIs header.
 */
 /**
- * @defgroup lavu_audio_channels Audio channels
+ * @addtogroup lavu_audio
 * @ingroup lavu_audio
 *
 * Audio channel layout utility functions
 *
 * @{
 */
 enum AVChannel {
    ///< Invalid channel index
    AV_CHAN_NONE = -1,
    AV_CHAN_FRONT_LEFT,
    AV_CHAN_FRONT_RIGHT,
    AV_CHAN_FRONT_CENTER,
    AV_CHAN_LOW_FREQUENCY,
    AV_CHAN_BACK_LEFT,
    AV_CHAN_BACK_RIGHT,
    AV_CHAN_FRONT_LEFT_OF_CENTER,
    AV_CHAN_FRONT_RIGHT_OF_CENTER,
    AV_CHAN_BACK_CENTER,
    AV_CHAN_SIDE_LEFT,
    AV_CHAN_SIDE_RIGHT,
    AV_CHAN_TOP_CENTER,
    AV_CHAN_TOP_FRONT_LEFT,
    AV_CHAN_TOP_FRONT_CENTER,
    AV_CHAN_TOP_FRONT_RIGHT,
    AV_CHAN_TOP_BACK_LEFT,
    AV_CHAN_TOP_BACK_CENTER,
    AV_CHAN_TOP_BACK_RIGHT,
    /** Stereo downmix. */
    AV_CHAN_STEREO_LEFT = 29,
    /** See above. */
    AV_CHAN_STEREO_RIGHT,
    AV_CHAN_WIDE_LEFT,
    AV_CHAN_WIDE_RIGHT,
    AV_CHAN_SURROUND_DIRECT_LEFT,
    AV_CHAN_SURROUND_DIRECT_RIGHT,
    AV_CHAN_LOW_FREQUENCY_2,
    AV_CHAN_TOP_SIDE_LEFT,
    AV_CHAN_TOP_SIDE_RIGHT,
    AV_CHAN_BOTTOM_FRONT_CENTER,
    AV_CHAN_BOTTOM_FRONT_LEFT,
    AV_CHAN_BOTTOM_FRONT_RIGHT,
    /** Channel is empty can be safely skipped. */
    AV_CHAN_UNUSED = 0x200,
    /** Channel contains data, but its position is unknown. */
    AV_CHAN_UNKNOWN = 0x300,
    /**
     * Range of channels between AV_CHAN_AMBISONIC_BASE and
     * AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.
     *
     * Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and
     * AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is
     * `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.
     *
     * @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel
     * orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels
     * implicitly by their position in the stream.
     */
    AV_CHAN_AMBISONIC_BASE = 0x400,
    // leave space for 1024 ids, which correspond to maximum order-32 harmonics,
    // which should be enough for the foreseeable use cases
    AV_CHAN_AMBISONIC_END  = 0x7ff,
 };
 enum AVChannelOrder {
    /**
     * Only the channel count is specified, without any further information
     * about the channel order.
     */
    AV_CHANNEL_ORDER_UNSPEC,
    /**
     * The native channel order, i.e. the channels are in the same order in
     * which they are defined in the AVChannel enum. This supports up to 63
     * different channels.
     */
    AV_CHANNEL_ORDER_NATIVE,
    /**
     * The channel order does not correspond to any other predefined order and
     * is stored as an explicit map. For example, this could be used to support
     * layouts with 64 or more channels, or with empty/skipped (AV_CHAN_SILENCE)
     * channels at arbitrary positions.
     */
    AV_CHANNEL_ORDER_CUSTOM,
    /**
     * The audio is represented as the decomposition of the sound field into
     * spherical harmonics. Each channel corresponds to a single expansion
     * component. Channels are ordered according to ACN (Ambisonic Channel
     * Number).
     *
     * The channel with the index n in the stream contains the spherical
     * harmonic of degree l and order m given by
     * @code{.unparsed}
     *   l   = floor(sqrt(n)),
     *   m   = n - l * (l + 1).
     * @endcode
     *
     * Conversely given a spherical harmonic of degree l and order m, the
     * corresponding channel index n is given by
     * @code{.unparsed}
     *   n = l * (l + 1) + m.
     * @endcode
     *
     * Normalization is assumed to be SN3D (Schmidt Semi-Normalization)
     * as defined in AmbiX format $ 2.1.
     */
    AV_CHANNEL_ORDER_AMBISONIC,
 };
 /**
 * @defgroup channel_masks Audio channel masks
 *
@ -161,46 +46,36 @@ enum AVChannelOrder {
 *
 * @{
 */
-#define AV_CH_FRONT_LEFT             (1ULL << AV_CHAN_FRONT_LEFT           )
+#define AV_CH_FRONT_LEFT             0x00000001
-#define AV_CH_FRONT_RIGHT            (1ULL << AV_CHAN_FRONT_RIGHT          )
+#define AV_CH_FRONT_RIGHT            0x00000002
-#define AV_CH_FRONT_CENTER           (1ULL << AV_CHAN_FRONT_CENTER         )
+#define AV_CH_FRONT_CENTER           0x00000004
-#define AV_CH_LOW_FREQUENCY          (1ULL << AV_CHAN_LOW_FREQUENCY        )
+#define AV_CH_LOW_FREQUENCY          0x00000008
-#define AV_CH_BACK_LEFT              (1ULL << AV_CHAN_BACK_LEFT            )
+#define AV_CH_BACK_LEFT              0x00000010
-#define AV_CH_BACK_RIGHT             (1ULL << AV_CHAN_BACK_RIGHT           )
+#define AV_CH_BACK_RIGHT             0x00000020
-#define AV_CH_FRONT_LEFT_OF_CENTER   (1ULL << AV_CHAN_FRONT_LEFT_OF_CENTER )
+#define AV_CH_FRONT_LEFT_OF_CENTER   0x00000040
-#define AV_CH_FRONT_RIGHT_OF_CENTER  (1ULL << AV_CHAN_FRONT_RIGHT_OF_CENTER)
+#define AV_CH_FRONT_RIGHT_OF_CENTER  0x00000080
-#define AV_CH_BACK_CENTER            (1ULL << AV_CHAN_BACK_CENTER          )
+#define AV_CH_BACK_CENTER            0x00000100
-#define AV_CH_SIDE_LEFT              (1ULL << AV_CHAN_SIDE_LEFT            )
+#define AV_CH_SIDE_LEFT              0x00000200
-#define AV_CH_SIDE_RIGHT             (1ULL << AV_CHAN_SIDE_RIGHT           )
+#define AV_CH_SIDE_RIGHT             0x00000400
-#define AV_CH_TOP_CENTER             (1ULL << AV_CHAN_TOP_CENTER           )
+#define AV_CH_TOP_CENTER             0x00000800
-#define AV_CH_TOP_FRONT_LEFT         (1ULL << AV_CHAN_TOP_FRONT_LEFT       )
+#define AV_CH_TOP_FRONT_LEFT         0x00001000
-#define AV_CH_TOP_FRONT_CENTER       (1ULL << AV_CHAN_TOP_FRONT_CENTER     )
+#define AV_CH_TOP_FRONT_CENTER       0x00002000
-#define AV_CH_TOP_FRONT_RIGHT        (1ULL << AV_CHAN_TOP_FRONT_RIGHT      )
+#define AV_CH_TOP_FRONT_RIGHT        0x00004000
-#define AV_CH_TOP_BACK_LEFT          (1ULL << AV_CHAN_TOP_BACK_LEFT        )
+#define AV_CH_TOP_BACK_LEFT          0x00008000
-#define AV_CH_TOP_BACK_CENTER        (1ULL << AV_CHAN_TOP_BACK_CENTER      )
+#define AV_CH_TOP_BACK_CENTER        0x00010000
-#define AV_CH_TOP_BACK_RIGHT         (1ULL << AV_CHAN_TOP_BACK_RIGHT       )
+#define AV_CH_TOP_BACK_RIGHT         0x00020000
-#define AV_CH_STEREO_LEFT            (1ULL << AV_CHAN_STEREO_LEFT          )
+#define AV_CH_STEREO_LEFT            0x20000000  ///< Stereo downmix.
-#define AV_CH_STEREO_RIGHT           (1ULL << AV_CHAN_STEREO_RIGHT         )
+#define AV_CH_STEREO_RIGHT           0x40000000  ///< See AV_CH_STEREO_LEFT.
-#define AV_CH_WIDE_LEFT              (1ULL << AV_CHAN_WIDE_LEFT            )
+#define AV_CH_WIDE_LEFT              0x0000000080000000ULL
-#define AV_CH_WIDE_RIGHT             (1ULL << AV_CHAN_WIDE_RIGHT           )
+#define AV_CH_WIDE_RIGHT             0x0000000100000000ULL
-#define AV_CH_SURROUND_DIRECT_LEFT   (1ULL << AV_CHAN_SURROUND_DIRECT_LEFT )
+#define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
-#define AV_CH_SURROUND_DIRECT_RIGHT  (1ULL << AV_CHAN_SURROUND_DIRECT_RIGHT)
+#define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
-#define AV_CH_LOW_FREQUENCY_2        (1ULL << AV_CHAN_LOW_FREQUENCY_2      )
+#define AV_CH_LOW_FREQUENCY_2        0x0000000800000000ULL
 #define AV_CH_TOP_SIDE_LEFT          (1ULL << AV_CHAN_TOP_SIDE_LEFT        )
 #define AV_CH_TOP_SIDE_RIGHT         (1ULL << AV_CHAN_TOP_SIDE_RIGHT       )
 #define AV_CH_BOTTOM_FRONT_CENTER    (1ULL << AV_CHAN_BOTTOM_FRONT_CENTER  )
 #define AV_CH_BOTTOM_FRONT_LEFT      (1ULL << AV_CHAN_BOTTOM_FRONT_LEFT    )
 #define AV_CH_BOTTOM_FRONT_RIGHT     (1ULL << AV_CHAN_BOTTOM_FRONT_RIGHT   )
 #if FF_API_OLD_CHANNEL_LAYOUT
 /** Channel mask value used for AVCodecContext.request_channel_layout
    to indicate that the user requests the channel order of the decoder output
-    to be the native codec channel order.
+    to be the native codec channel order. */
    @deprecated channel order is now indicated in a special field in
                AVChannelLayout
    */
 #define AV_CH_LAYOUT_NATIVE          0x8000000000000000ULL
 #endif
 /**
 * @}
@ -232,12 +107,9 @@ enum AVChannelOrder {
 #define AV_CH_LAYOUT_7POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_7POINT1_WIDE      (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
 #define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
 #define AV_CH_LAYOUT_7POINT1_TOP_BACK  (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
 #define AV_CH_LAYOUT_OCTAGONAL         (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
 #define AV_CH_LAYOUT_CUBE              (AV_CH_LAYOUT_QUAD|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT)
 #define AV_CH_LAYOUT_HEXADECAGONAL     (AV_CH_LAYOUT_OCTAGONAL|AV_CH_WIDE_LEFT|AV_CH_WIDE_RIGHT|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT)
 #define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
 #define AV_CH_LAYOUT_22POINT2          (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER|AV_CH_BACK_CENTER|AV_CH_LOW_FREQUENCY_2|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT|AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT|AV_CH_TOP_FRONT_CENTER|AV_CH_TOP_CENTER|AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_RIGHT|AV_CH_TOP_SIDE_LEFT|AV_CH_TOP_SIDE_RIGHT|AV_CH_TOP_BACK_CENTER|AV_CH_BOTTOM_FRONT_CENTER|AV_CH_BOTTOM_FRONT_LEFT|AV_CH_BOTTOM_FRONT_RIGHT)
 enum AVMatrixEncoding {
    AV_MATRIX_ENCODING_NONE,
@ -250,164 +122,6 @@ enum AVMatrixEncoding {
    AV_MATRIX_ENCODING_NB
 };
 /**
 * @}
 */
 /**
 * An AVChannelCustom defines a single channel within a custom order layout
 *
 * Unlike most structures in FFmpeg, sizeof(AVChannelCustom) is a part of the
 * public ABI.
 *
 * No new fields may be added to it without a major version bump.
 */
 typedef struct AVChannelCustom {
    enum AVChannel id;
    char name[16];
    void *opaque;
 } AVChannelCustom;
 /**
 * An AVChannelLayout holds information about the channel layout of audio data.
 *
 * A channel layout here is defined as a set of channels ordered in a specific
 * way (unless the channel order is AV_CHANNEL_ORDER_UNSPEC, in which case an
 * AVChannelLayout carries only the channel count).
 * All orders may be treated as if they were AV_CHANNEL_ORDER_UNSPEC by
 * ignoring everything but the channel count, as long as av_channel_layout_check()
 * considers they are valid.
 *
 * Unlike most structures in FFmpeg, sizeof(AVChannelLayout) is a part of the
 * public ABI and may be used by the caller. E.g. it may be allocated on stack
 * or embedded in caller-defined structs.
 *
 * AVChannelLayout can be initialized as follows:
 * - default initialization with {0}, followed by setting all used fields
 *   correctly;
 * - by assigning one of the predefined AV_CHANNEL_LAYOUT_* initializers;
 * - with a constructor function, such as av_channel_layout_default(),
 *   av_channel_layout_from_mask() or av_channel_layout_from_string().
 *
 * The channel layout must be unitialized with av_channel_layout_uninit()
 *
 * Copying an AVChannelLayout via assigning is forbidden,
 * av_channel_layout_copy() must be used instead (and its return value should
 * be checked)
 *
 * No new fields may be added to it without a major version bump, except for
 * new elements of the union fitting in sizeof(uint64_t).
 */
 typedef struct AVChannelLayout {
    /**
     * Channel order used in this layout.
     * This is a mandatory field.
     */
    enum AVChannelOrder order;
    /**
     * Number of channels in this layout. Mandatory field.
     */
    int nb_channels;
    /**
     * Details about which channels are present in this layout.
     * For AV_CHANNEL_ORDER_UNSPEC, this field is undefined and must not be
     * used.
     */
    union {
        /**
         * This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used
         * for AV_CHANNEL_ORDER_AMBISONIC to signal non-diegetic channels.
         * It is a bitmask, where the position of each set bit means that the
         * AVChannel with the corresponding value is present.
         *
         * I.e. when (mask & (1 << AV_CHAN_FOO)) is non-zero, then AV_CHAN_FOO
         * is present in the layout. Otherwise it is not present.
         *
         * @note when a channel layout using a bitmask is constructed or
         * modified manually (i.e.  not using any of the av_channel_layout_*
         * functions), the code doing it must ensure that the number of set bits
         * is equal to nb_channels.
         */
        uint64_t mask;
        /**
         * This member must be used when the channel order is
         * AV_CHANNEL_ORDER_CUSTOM. It is a nb_channels-sized array, with each
         * element signalling the presence of the AVChannel with the
         * corresponding value in map[i].id.
         *
         * I.e. when map[i].id is equal to AV_CHAN_FOO, then AV_CH_FOO is the
         * i-th channel in the audio data.
         *
         * When map[i].id is in the range between AV_CHAN_AMBISONIC_BASE and
         * AV_CHAN_AMBISONIC_END (inclusive), the channel contains an ambisonic
         * component with ACN index (as defined above)
         * n = map[i].id - AV_CHAN_AMBISONIC_BASE.
         *
         * map[i].name may be filled with a 0-terminated string, in which case
         * it will be used for the purpose of identifying the channel with the
         * convenience functions below. Otherise it must be zeroed.
         */
        AVChannelCustom *map;
    } u;
    /**
     * For some private data of the user.
     */
    void *opaque;
 } AVChannelLayout;
 #define AV_CHANNEL_LAYOUT_MASK(nb, m) \
    { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = (nb), .u = { .mask = (m) }}
 /**
 * @name Common pre-defined channel layouts
 * @{
 */
 #define AV_CHANNEL_LAYOUT_MONO              AV_CHANNEL_LAYOUT_MASK(1,  AV_CH_LAYOUT_MONO)
 #define AV_CHANNEL_LAYOUT_STEREO            AV_CHANNEL_LAYOUT_MASK(2,  AV_CH_LAYOUT_STEREO)
 #define AV_CHANNEL_LAYOUT_2POINT1           AV_CHANNEL_LAYOUT_MASK(3,  AV_CH_LAYOUT_2POINT1)
 #define AV_CHANNEL_LAYOUT_2_1               AV_CHANNEL_LAYOUT_MASK(3,  AV_CH_LAYOUT_2_1)
 #define AV_CHANNEL_LAYOUT_SURROUND          AV_CHANNEL_LAYOUT_MASK(3,  AV_CH_LAYOUT_SURROUND)
 #define AV_CHANNEL_LAYOUT_3POINT1           AV_CHANNEL_LAYOUT_MASK(4,  AV_CH_LAYOUT_3POINT1)
 #define AV_CHANNEL_LAYOUT_4POINT0           AV_CHANNEL_LAYOUT_MASK(4,  AV_CH_LAYOUT_4POINT0)
 #define AV_CHANNEL_LAYOUT_4POINT1           AV_CHANNEL_LAYOUT_MASK(5,  AV_CH_LAYOUT_4POINT1)
 #define AV_CHANNEL_LAYOUT_2_2               AV_CHANNEL_LAYOUT_MASK(4,  AV_CH_LAYOUT_2_2)
 #define AV_CHANNEL_LAYOUT_QUAD              AV_CHANNEL_LAYOUT_MASK(4,  AV_CH_LAYOUT_QUAD)
 #define AV_CHANNEL_LAYOUT_5POINT0           AV_CHANNEL_LAYOUT_MASK(5,  AV_CH_LAYOUT_5POINT0)
 #define AV_CHANNEL_LAYOUT_5POINT1           AV_CHANNEL_LAYOUT_MASK(6,  AV_CH_LAYOUT_5POINT1)
 #define AV_CHANNEL_LAYOUT_5POINT0_BACK      AV_CHANNEL_LAYOUT_MASK(5,  AV_CH_LAYOUT_5POINT0_BACK)
 #define AV_CHANNEL_LAYOUT_5POINT1_BACK      AV_CHANNEL_LAYOUT_MASK(6,  AV_CH_LAYOUT_5POINT1_BACK)
 #define AV_CHANNEL_LAYOUT_6POINT0           AV_CHANNEL_LAYOUT_MASK(6,  AV_CH_LAYOUT_6POINT0)
 #define AV_CHANNEL_LAYOUT_6POINT0_FRONT     AV_CHANNEL_LAYOUT_MASK(6,  AV_CH_LAYOUT_6POINT0_FRONT)
 #define AV_CHANNEL_LAYOUT_HEXAGONAL         AV_CHANNEL_LAYOUT_MASK(6,  AV_CH_LAYOUT_HEXAGONAL)
 #define AV_CHANNEL_LAYOUT_6POINT1           AV_CHANNEL_LAYOUT_MASK(7,  AV_CH_LAYOUT_6POINT1)
 #define AV_CHANNEL_LAYOUT_6POINT1_BACK      AV_CHANNEL_LAYOUT_MASK(7,  AV_CH_LAYOUT_6POINT1_BACK)
 #define AV_CHANNEL_LAYOUT_6POINT1_FRONT     AV_CHANNEL_LAYOUT_MASK(7,  AV_CH_LAYOUT_6POINT1_FRONT)
 #define AV_CHANNEL_LAYOUT_7POINT0           AV_CHANNEL_LAYOUT_MASK(7,  AV_CH_LAYOUT_7POINT0)
 #define AV_CHANNEL_LAYOUT_7POINT0_FRONT     AV_CHANNEL_LAYOUT_MASK(7,  AV_CH_LAYOUT_7POINT0_FRONT)
 #define AV_CHANNEL_LAYOUT_7POINT1           AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_7POINT1)
 #define AV_CHANNEL_LAYOUT_7POINT1_WIDE      AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_7POINT1_WIDE)
 #define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_7POINT1_WIDE_BACK)
 #define AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK  AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_7POINT1_TOP_BACK)
 #define AV_CHANNEL_LAYOUT_OCTAGONAL         AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_OCTAGONAL)
 #define AV_CHANNEL_LAYOUT_CUBE              AV_CHANNEL_LAYOUT_MASK(8,  AV_CH_LAYOUT_CUBE)
 #define AV_CHANNEL_LAYOUT_HEXADECAGONAL     AV_CHANNEL_LAYOUT_MASK(16, AV_CH_LAYOUT_HEXADECAGONAL)
 #define AV_CHANNEL_LAYOUT_STEREO_DOWNMIX    AV_CHANNEL_LAYOUT_MASK(2,  AV_CH_LAYOUT_STEREO_DOWNMIX)
 #define AV_CHANNEL_LAYOUT_22POINT2          AV_CHANNEL_LAYOUT_MASK(24, AV_CH_LAYOUT_22POINT2)
 #define AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER \
    { .order = AV_CHANNEL_ORDER_AMBISONIC, .nb_channels = 4, .u = { .mask = 0 }}
 /** @} */
 struct AVBPrint;
 #if FF_API_OLD_CHANNEL_LAYOUT
 /**
 * @name Deprecated Functions
 * @{
 */
 /**
 * Return a channel layout id that matches name, or 0 if no match is found.
 *
@ -424,10 +138,7 @@ struct AVBPrint;
 *   AV_CH_* macros).
 *
 * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"
 *
 * @deprecated use av_channel_layout_from_string()
 */
 attribute_deprecated
 uint64_t av_get_channel_layout(const char *name);
 /**
@ -441,9 +152,7 @@ uint64_t av_get_channel_layout(const char *name);
 * @param[out] nb_channels      number of channels
 *
 * @return 0 on success, AVERROR(EINVAL) if the parsing fails.
 * @deprecated use av_channel_layout_from_string()
 */
 attribute_deprecated
 int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
 /**
@ -452,66 +161,47 @@ int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, i
 *
 * @param buf put here the string containing the channel layout
 * @param buf_size size in bytes of the buffer
 * @param nb_channels number of channels
 * @param channel_layout channel layout bitset
 * @deprecated use av_channel_layout_describe()
 */
 attribute_deprecated
 void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
 struct AVBPrint;
 /**
 * Append a description of a channel layout to a bprint buffer.
 * @deprecated use av_channel_layout_describe()
 */
 attribute_deprecated
 void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
 /**
 * Return the number of channels in the channel layout.
 * @deprecated use AVChannelLayout.nb_channels
 */
 attribute_deprecated
 int av_get_channel_layout_nb_channels(uint64_t channel_layout);
 /**
 * Return default channel layout for a given number of channels.
 *
 * @deprecated use av_channel_layout_default()
 */
 attribute_deprecated
 int64_t av_get_default_channel_layout(int nb_channels);
 /**
 * Get the index of a channel in channel_layout.
 *
 * @param channel_layout channel layout bitset
 * @param channel a channel layout describing exactly one channel which must be
 *                present in channel_layout.
 *
 * @return index of channel in channel_layout on success, a negative AVERROR
 *         on error.
 *
 * @deprecated use av_channel_layout_index_from_channel()
 */
 attribute_deprecated
 int av_get_channel_layout_channel_index(uint64_t channel_layout,
                                        uint64_t channel);
 /**
 * Get the channel with the given index in channel_layout.
 * @deprecated use av_channel_layout_channel_from_index()
 */
 attribute_deprecated
 uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
 /**
 * Get the name of a given channel.
 *
 * @return channel name on success, NULL on error.
 *
 * @deprecated use av_channel_name()
 */
 attribute_deprecated
 const char *av_get_channel_name(uint64_t channel);
 /**
@ -519,9 +209,7 @@ const char *av_get_channel_name(uint64_t channel);
 *
 * @param channel  a channel layout with a single channel
 * @return  channel description on success, NULL on error
 * @deprecated use av_channel_description()
 */
 attribute_deprecated
 const char *av_get_channel_description(uint64_t channel);
 /**
@ -532,251 +220,12 @@ const char *av_get_channel_description(uint64_t channel);
 * @param[out] name    name of the layout
 * @return  0  if the layout exists,
 *          <0 if index is beyond the limits
 * @deprecated use av_channel_layout_standard()
 */
 attribute_deprecated
 int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
                                   const char **name);
 /**
 * @}
 */
 #endif
 /**
 * Get a human readable string in an abbreviated form describing a given channel.
 * This is the inverse function of @ref av_channel_from_string().
 *
 * @param buf pre-allocated buffer where to put the generated string
 * @param buf_size size in bytes of the buffer.
 * @param channel the AVChannel whose name to get
 * @return amount of bytes needed to hold the output string, or a negative AVERROR
 *         on failure. If the returned value is bigger than buf_size, then the
 *         string was truncated.
 */
 int av_channel_name(char *buf, size_t buf_size, enum AVChannel channel);
 /**
 * bprint variant of av_channel_name().
 *
 * @note the string will be appended to the bprint buffer.
 */
 void av_channel_name_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
 /**
 * Get a human readable string describing a given channel.
 *
 * @param buf pre-allocated buffer where to put the generated string
 * @param buf_size size in bytes of the buffer.
 * @param channel the AVChannel whose description to get
 * @return amount of bytes needed to hold the output string, or a negative AVERROR
 *         on failure. If the returned value is bigger than buf_size, then the
 *         string was truncated.
 */
 int av_channel_description(char *buf, size_t buf_size, enum AVChannel channel);
 /**
 * bprint variant of av_channel_description().
 *
 * @note the string will be appended to the bprint buffer.
 */
 void av_channel_description_bprint(struct AVBPrint *bp, enum AVChannel channel_id);
 /**
 * This is the inverse function of @ref av_channel_name().
 *
 * @return the channel with the given name
 *         AV_CHAN_NONE when name does not identify a known channel
 */
 enum AVChannel av_channel_from_string(const char *name);
 /**
 * Initialize a native channel layout from a bitmask indicating which channels
 * are present.
 *
 * @param channel_layout the layout structure to be initialized
 * @param mask bitmask describing the channel layout
 *
 * @return 0 on success
 *         AVERROR(EINVAL) for invalid mask values
 */
 int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask);
 /**
 * Initialize a channel layout from a given string description.
 * The input string can be represented by:
 *  - the formal channel layout name (returned by av_channel_layout_describe())
 *  - single or multiple channel names (returned by av_channel_name(), eg. "FL",
 *    or concatenated with "+", each optionally containing a custom name after
 *    a "@", eg. "FL@Left+FR@Right+LFE")
 *  - a decimal or hexadecimal value of a native channel layout (eg. "4" or "0x4")
 *  - the number of channels with default layout (eg. "4c")
 *  - the number of unordered channels (eg. "4C" or "4 channels")
 *  - the ambisonic order followed by optional non-diegetic channels (eg.
 *    "ambisonic 2+stereo")
 *
 * @param channel_layout input channel layout
 * @param str string describing the channel layout
 * @return 0 channel layout was detected, AVERROR_INVALIDATATA otherwise
 */
 int av_channel_layout_from_string(AVChannelLayout *channel_layout,
                                  const char *str);
 /**
 * Get the default channel layout for a given number of channels.
 *
 * @param ch_layout the layout structure to be initialized
 * @param nb_channels number of channels
 */
 void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels);
 /**
 * Iterate over all standard channel layouts.
 *
 * @param opaque a pointer where libavutil will store the iteration state. Must
 *               point to NULL to start the iteration.
 *
 * @return the standard channel layout or NULL when the iteration is
 *         finished
 */
 const AVChannelLayout *av_channel_layout_standard(void **opaque);
 /**
 * Free any allocated data in the channel layout and reset the channel
 * count to 0.
 *
 * @param channel_layout the layout structure to be uninitialized
 */
 void av_channel_layout_uninit(AVChannelLayout *channel_layout);
 /**
 * Make a copy of a channel layout. This differs from just assigning src to dst
 * in that it allocates and copies the map for AV_CHANNEL_ORDER_CUSTOM.
 *
 * @note the destination channel_layout will be always uninitialized before copy.
 *
 * @param dst destination channel layout
 * @param src source channel layout
 * @return 0 on success, a negative AVERROR on error.
 */
 int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src);
 /**
 * Get a human-readable string describing the channel layout properties.
 * The string will be in the same format that is accepted by
 * @ref av_channel_layout_from_string(), allowing to rebuild the same
 * channel layout, except for opaque pointers.
 *
 * @param channel_layout channel layout to be described
 * @param buf pre-allocated buffer where to put the generated string
 * @param buf_size size in bytes of the buffer.
 * @return amount of bytes needed to hold the output string, or a negative AVERROR
 *         on failure. If the returned value is bigger than buf_size, then the
 *         string was truncated.
 */
 int av_channel_layout_describe(const AVChannelLayout *channel_layout,
                               char *buf, size_t buf_size);
 /**
 * bprint variant of av_channel_layout_describe().
 *
 * @note the string will be appended to the bprint buffer.
 * @return 0 on success, or a negative AVERROR value on failure.
 */
 int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout,
                                      struct AVBPrint *bp);
 /**
 * Get the channel with the given index in a channel layout.
 *
 * @param channel_layout input channel layout
 * @param idx index of the channel
 * @return channel with the index idx in channel_layout on success or
 *         AV_CHAN_NONE on failure (if idx is not valid or the channel order is
 *         unspecified)
 */
 enum AVChannel
 av_channel_layout_channel_from_index(const AVChannelLayout *channel_layout, unsigned int idx);
 /**
 * Get the index of a given channel in a channel layout. In case multiple
 * channels are found, only the first match will be returned.
 *
 * @param channel_layout input channel layout
 * @param channel the channel whose index to obtain
 * @return index of channel in channel_layout on success or a negative number if
 *         channel is not present in channel_layout.
 */
 int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout,
                                         enum AVChannel channel);
 /**
 * Get the index in a channel layout of a channel described by the given string.
 * In case multiple channels are found, only the first match will be returned.
 *
 * This function accepts channel names in the same format as
 * @ref av_channel_from_string().
 *
 * @param channel_layout input channel layout
 * @param name string describing the channel whose index to obtain
 * @return a channel index described by the given string, or a negative AVERROR
 *         value.
 */
 int av_channel_layout_index_from_string(const AVChannelLayout *channel_layout,
                                        const char *name);
 /**
 * Get a channel described by the given string.
 *
 * This function accepts channel names in the same format as
 * @ref av_channel_from_string().
 *
 * @param channel_layout input channel layout
 * @param name string describing the channel to obtain
 * @return a channel described by the given string in channel_layout on success
 *         or AV_CHAN_NONE on failure (if the string is not valid or the channel
 *         order is unspecified)
 */
 enum AVChannel
 av_channel_layout_channel_from_string(const AVChannelLayout *channel_layout,
                                      const char *name);
 /**
 * Find out what channels from a given set are present in a channel layout,
 * without regard for their positions.
 *
 * @param channel_layout input channel layout
 * @param mask a combination of AV_CH_* representing a set of channels
 * @return a bitfield representing all the channels from mask that are present
 *         in channel_layout
 */
 uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout,
                                  uint64_t mask);
 /**
 * Check whether a channel layout is valid, i.e. can possibly describe audio
 * data.
 *
 * @param channel_layout input channel layout
 * @return 1 if channel_layout is valid, 0 otherwise.
 */
 int av_channel_layout_check(const AVChannelLayout *channel_layout);
 /**
 * Check whether two channel layouts are semantically the same, i.e. the same
 * channels are present on the same positions in both.
 *
 * If one of the channel layouts is AV_CHANNEL_ORDER_UNSPEC, while the other is
 * not, they are considered to be unequal. If both are AV_CHANNEL_ORDER_UNSPEC,
 * they are considered equal iff the channel counts are the same in both.
 *
 * @param chl input channel layout
 * @param chl1 input channel layout
 * @return 0 if chl and chl1 are equal, 1 if they are not equal. A negative
 *         AVERROR code if one or both are invalid.
 */
 int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1);
 /**
 * @}
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/common.h
+++ b/output/include/arm64-v8a/libavutil/common.h
@ -41,11 +41,19 @@
 #include "attributes.h"
 #include "macros.h"
 #include "version.h"
 #include "libavutil/avconfig.h"
 #if AV_HAVE_BIGENDIAN
 #   define AV_NE(be, le) (be)
 #else
 #   define AV_NE(be, le) (le)
 #endif
 //rounded division & shift
 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
 /* assume b>0 */
-#define ROUNDED_DIV(a,b) (((a)>=0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
+#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
 /* Fast a/(1<<b) rounded toward +inf. Assume a>=0 and b>=0 */
 #define AV_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
                                                       : ((a) + (1<<(b)) - 1) >> (b))
@ -73,13 +81,23 @@
 #define FFNABS(a) ((a) <= 0 ? (a) : (-(a)))
 /**
- * Unsigned Absolute value.
+ * Comparator.
- * This takes the absolute value of a signed int and returns it as a unsigned.
+ * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
- * This also works with INT_MIN which would otherwise not be representable
+ * if x == y. This is useful for instance in a qsort comparator callback.
- * As with many macros, this evaluates its argument twice.
+ * Furthermore, compilers are able to optimize this to branchless code, and
 * there is no risk of overflow with signed types.
 * As with many macros, this evaluates its argument multiple times, it thus
 * must not have a side-effect.
 */
-#define FFABSU(a) ((a) <= 0 ? -(unsigned)(a) : (unsigned)(a))
+#define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
-#define FFABS64U(a) ((a) <= 0 ? -(uint64_t)(a) : (uint64_t)(a))
+
 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
 #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
 #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
 #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
 #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
 /* misc math functions */
@ -88,72 +106,8 @@
 #   include "intmath.h"
 #endif
-#ifndef av_ceil_log2
+/* Pull in unguarded fallback defines at the end of this file. */
-#   define av_ceil_log2     av_ceil_log2_c
+#include "common.h"
 #endif
 #ifndef av_clip
 #   define av_clip          av_clip_c
 #endif
 #ifndef av_clip64
 #   define av_clip64        av_clip64_c
 #endif
 #ifndef av_clip_uint8
 #   define av_clip_uint8    av_clip_uint8_c
 #endif
 #ifndef av_clip_int8
 #   define av_clip_int8     av_clip_int8_c
 #endif
 #ifndef av_clip_uint16
 #   define av_clip_uint16   av_clip_uint16_c
 #endif
 #ifndef av_clip_int16
 #   define av_clip_int16    av_clip_int16_c
 #endif
 #ifndef av_clipl_int32
 #   define av_clipl_int32   av_clipl_int32_c
 #endif
 #ifndef av_clip_intp2
 #   define av_clip_intp2    av_clip_intp2_c
 #endif
 #ifndef av_clip_uintp2
 #   define av_clip_uintp2   av_clip_uintp2_c
 #endif
 #ifndef av_mod_uintp2
 #   define av_mod_uintp2    av_mod_uintp2_c
 #endif
 #ifndef av_sat_add32
 #   define av_sat_add32     av_sat_add32_c
 #endif
 #ifndef av_sat_dadd32
 #   define av_sat_dadd32    av_sat_dadd32_c
 #endif
 #ifndef av_sat_sub32
 #   define av_sat_sub32     av_sat_sub32_c
 #endif
 #ifndef av_sat_dsub32
 #   define av_sat_dsub32    av_sat_dsub32_c
 #endif
 #ifndef av_sat_add64
 #   define av_sat_add64     av_sat_add64_c
 #endif
 #ifndef av_sat_sub64
 #   define av_sat_sub64     av_sat_sub64_c
 #endif
 #ifndef av_clipf
 #   define av_clipf         av_clipf_c
 #endif
 #ifndef av_clipd
 #   define av_clipd         av_clipd_c
 #endif
 #ifndef av_popcount
 #   define av_popcount      av_popcount_c
 #endif
 #ifndef av_popcount64
 #   define av_popcount64    av_popcount64_c
 #endif
 #ifndef av_parity
 #   define av_parity        av_parity_c
 #endif
 #ifndef av_log2
 av_const int av_log2(unsigned v);
@ -286,7 +240,7 @@ static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
 */
 static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p)
 {
-    return a & ((1U << p) - 1);
+    return a & ((1 << p) - 1);
 }
 /**
@ -306,80 +260,15 @@ static av_always_inline int av_sat_add32_c(int a, int b)
 *
 * @param  a first value
 * @param  b value doubled and added to a
- * @return sum sat(a + sat(2*b)) with signed saturation
+ * @return sum with signed saturation
 */
 static av_always_inline int av_sat_dadd32_c(int a, int b)
 {
    return av_sat_add32(a, av_sat_add32(b, b));
 }
 /**
 * Subtract two signed 32-bit values with saturation.
 *
 * @param  a one value
 * @param  b another value
 * @return difference with signed saturation
 */
 static av_always_inline int av_sat_sub32_c(int a, int b)
 {
    return av_clipl_int32((int64_t)a - b);
 }
 /**
 * Subtract a doubled value from another value with saturation at both stages.
 *
 * @param  a first value
 * @param  b value doubled and subtracted from a
 * @return difference sat(a - sat(2*b)) with signed saturation
 */
 static av_always_inline int av_sat_dsub32_c(int a, int b)
 {
    return av_sat_sub32(a, av_sat_add32(b, b));
 }
 /**
 * Add two signed 64-bit values with saturation.
 *
 * @param  a one value
 * @param  b another value
 * @return sum with signed saturation
 */
 static av_always_inline int64_t av_sat_add64_c(int64_t a, int64_t b) {
 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_add_overflow)
    int64_t tmp;
    return !__builtin_add_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
 #else
    int64_t s = a+(uint64_t)b;
    if ((int64_t)(a^b | ~s^b) >= 0)
        return INT64_MAX ^ (b >> 63);
    return s;
 #endif
 }
 /**
 * Subtract two signed 64-bit values with saturation.
 *
 * @param  a one value
 * @param  b another value
 * @return difference with signed saturation
 */
 static av_always_inline int64_t av_sat_sub64_c(int64_t a, int64_t b) {
 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_sub_overflow)
    int64_t tmp;
    return !__builtin_sub_overflow(a, b, &tmp) ? tmp : (tmp < 0 ? INT64_MAX : INT64_MIN);
 #else
    if (b <= 0 && a >= INT64_MAX + b)
        return INT64_MAX;
    if (b >= 0 && a <= INT64_MIN + b)
        return INT64_MIN;
    return a - b;
 #endif
 }
 /**
 * Clip a float value into the amin-amax range.
 * If a is nan or -inf amin will be returned.
 * If a is +inf amax will be returned.
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
@ -390,13 +279,13 @@ static av_always_inline av_const float av_clipf_c(float a, float amin, float ama
 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
    if (amin > amax) abort();
 #endif
-    return FFMIN(FFMAX(a, amin), amax);
+    if      (a < amin) return amin;
    else if (a > amax) return amax;
    else               return a;
 }
 /**
 * Clip a double value into the amin-amax range.
 * If a is nan or -inf amin will be returned.
 * If a is +inf amax will be returned.
 * @param a value to clip
 * @param amin minimum value of the clip range
 * @param amax maximum value of the clip range
@ -407,7 +296,9 @@ static av_always_inline av_const double av_clipd_c(double a, double amin, double
 #if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
    if (amin > amax) abort();
 #endif
-    return FFMIN(FFMAX(a, amin), amax);
+    if      (a < amin) return amin;
    else if (a > amax) return amax;
    else               return a;
 }
 /** Compute ceil(log2(x)).
@ -448,6 +339,9 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
    return av_popcount(v) & 1;
 }
 #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
 #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
 /**
 * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
 *
@ -455,9 +349,7 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
 * @param GET_BYTE Expression reading one byte from the input.
 *                 Evaluated up to 7 times (4 for the currently
 *                 assigned Unicode range).  With a memory buffer
- *                 input, this could be *ptr++, or if you want to make sure
+ *                 input, this could be *ptr++.
 *                 that *ptr stops at the end of a NULL terminated string then
 *                 *ptr ? *ptr++ : 0
 * @param ERROR    Expression to be evaluated on invalid input,
 *                 typically a goto statement.
 *
@ -471,11 +363,11 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
    {\
        uint32_t top = (val & 128) >> 1;\
        if ((val & 0xc0) == 0x80 || val >= 0xFE)\
-            {ERROR}\
+            ERROR\
        while (val & top) {\
-            unsigned int tmp = (GET_BYTE) - 128;\
+            int tmp= (GET_BYTE) - 128;\
            if(tmp>>6)\
-                {ERROR}\
+                ERROR\
            val= (val<<6) + tmp;\
            top <<= 5;\
        }\
@ -492,13 +384,13 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
 *                  typically a goto statement.
 */
 #define GET_UTF16(val, GET_16BIT, ERROR)\
-    val = (GET_16BIT);\
+    val = GET_16BIT;\
    {\
        unsigned int hi = val - 0xD800;\
        if (hi < 0x800) {\
-            val = (GET_16BIT) - 0xDC00;\
+            val = GET_16BIT - 0xDC00;\
            if (val > 0x3FFU || hi > 0x3FFU)\
-                {ERROR}\
+                ERROR\
            val += (hi<<10) + 0x10000;\
        }\
    }\
@ -576,3 +468,63 @@ static av_always_inline av_const int av_parity_c(uint32_t v)
 #endif /* HAVE_AV_CONFIG_H */
 #endif /* AVUTIL_COMMON_H */
 /*
 * The following definitions are outside the multiple inclusion guard
 * to ensure they are immediately available in intmath.h.
 */
 #ifndef av_ceil_log2
 #   define av_ceil_log2     av_ceil_log2_c
 #endif
 #ifndef av_clip
 #   define av_clip          av_clip_c
 #endif
 #ifndef av_clip64
 #   define av_clip64        av_clip64_c
 #endif
 #ifndef av_clip_uint8
 #   define av_clip_uint8    av_clip_uint8_c
 #endif
 #ifndef av_clip_int8
 #   define av_clip_int8     av_clip_int8_c
 #endif
 #ifndef av_clip_uint16
 #   define av_clip_uint16   av_clip_uint16_c
 #endif
 #ifndef av_clip_int16
 #   define av_clip_int16    av_clip_int16_c
 #endif
 #ifndef av_clipl_int32
 #   define av_clipl_int32   av_clipl_int32_c
 #endif
 #ifndef av_clip_intp2
 #   define av_clip_intp2    av_clip_intp2_c
 #endif
 #ifndef av_clip_uintp2
 #   define av_clip_uintp2   av_clip_uintp2_c
 #endif
 #ifndef av_mod_uintp2
 #   define av_mod_uintp2    av_mod_uintp2_c
 #endif
 #ifndef av_sat_add32
 #   define av_sat_add32     av_sat_add32_c
 #endif
 #ifndef av_sat_dadd32
 #   define av_sat_dadd32    av_sat_dadd32_c
 #endif
 #ifndef av_clipf
 #   define av_clipf         av_clipf_c
 #endif
 #ifndef av_clipd
 #   define av_clipd         av_clipd_c
 #endif
 #ifndef av_popcount
 #   define av_popcount      av_popcount_c
 #endif
 #ifndef av_popcount64
 #   define av_popcount64    av_popcount64_c
 #endif
 #ifndef av_parity
 #   define av_parity        av_parity_c
 #endif
--- a/output/include/arm64-v8a/libavutil/cpu.h
+++ b/output/include/arm64-v8a/libavutil/cpu.h
@ -23,6 +23,8 @@
 #include <stddef.h>
 #include "attributes.h"
 #define AV_CPU_FLAG_FORCE    0x80000000 /* force usage of selected flags (OR) */
    /* lower 16 bits - CPU features */
@ -53,9 +55,6 @@
 #define AV_CPU_FLAG_FMA3        0x10000 ///< Haswell FMA3 functions
 #define AV_CPU_FLAG_BMI1        0x20000 ///< Bit Manipulation Instruction Set 1
 #define AV_CPU_FLAG_BMI2        0x40000 ///< Bit Manipulation Instruction Set 2
 #define AV_CPU_FLAG_AVX512     0x100000 ///< AVX-512 functions: requires OS support even if YMM/ZMM registers aren't used
 #define AV_CPU_FLAG_AVX512ICL  0x200000 ///< F/CD/BW/DQ/VL/VNNI/IFMA/VBMI/VBMI2/VPOPCNTDQ/BITALG/GFNI/VAES/VPCLMULQDQ
 #define AV_CPU_FLAG_SLOW_GATHER  0x2000000 ///< CPU has slow gathers.
 #define AV_CPU_FLAG_ALTIVEC      0x0001 ///< standard
 #define AV_CPU_FLAG_VSX          0x0002 ///< ISA 2.06
@ -71,23 +70,6 @@
 #define AV_CPU_FLAG_VFP_VM       (1 << 7) ///< VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
 #define AV_CPU_FLAG_SETEND       (1 <<16)
 #define AV_CPU_FLAG_MMI          (1 << 0)
 #define AV_CPU_FLAG_MSA          (1 << 1)
 //Loongarch SIMD extension.
 #define AV_CPU_FLAG_LSX          (1 << 0)
 #define AV_CPU_FLAG_LASX         (1 << 1)
 // RISC-V extensions
 #define AV_CPU_FLAG_RVI          (1 << 0) ///< I (full GPR bank)
 #define AV_CPU_FLAG_RVF          (1 << 1) ///< F (single precision FP)
 #define AV_CPU_FLAG_RVD          (1 << 2) ///< D (double precision FP)
 #define AV_CPU_FLAG_RVV_I32      (1 << 3) ///< Vectors of 8/16/32-bit int's */
 #define AV_CPU_FLAG_RVV_F32      (1 << 4) ///< Vectors of float's */
 #define AV_CPU_FLAG_RVV_I64      (1 << 5) ///< Vectors of 64-bit int's */
 #define AV_CPU_FLAG_RVV_F64      (1 << 6) ///< Vectors of double's
 #define AV_CPU_FLAG_RVB_BASIC    (1 << 7) ///< Basic bit-manipulations
 /**
 * Return the flags which specify extensions supported by the CPU.
 * The returned value is affected by av_force_cpu_flags() if that was used
@ -102,6 +84,25 @@ int av_get_cpu_flags(void);
 */
 void av_force_cpu_flags(int flags);
 /**
 * Set a mask on flags returned by av_get_cpu_flags().
 * This function is mainly useful for testing.
 * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
 */
 attribute_deprecated void av_set_cpu_flags_mask(int mask);
 /**
 * Parse CPU flags from a string.
 *
 * The returned flags contain the specified flags as well as related unspecified flags.
 *
 * This function exists only for compatibility with libav.
 * Please use av_parse_cpu_caps() when possible.
 * @return a combination of AV_CPU_* flags, negative on error.
 */
 attribute_deprecated
 int av_parse_cpu_flags(const char *s);
 /**
 * Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
 *
@ -114,12 +115,6 @@ int av_parse_cpu_caps(unsigned *flags, const char *s);
 */
 int av_cpu_count(void);
 /**
 * Overrides cpu count detection and forces the specified count.
 * Count < 1 disables forcing of specific count.
 */
 void av_cpu_force_count(int count);
 /**
 * Get the maximum data alignment that may be required by FFmpeg.
 *
--- a/output/include/arm64-v8a/libavutil/crc.h
+++ b/output/include/arm64-v8a/libavutil/crc.h
@ -30,6 +30,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_crc32 CRC
@ -52,8 +53,11 @@ typedef enum {
    AV_CRC_32_IEEE,
    AV_CRC_32_IEEE_LE,  /*< reversed bitorder version of AV_CRC_32_IEEE */
    AV_CRC_16_ANSI_LE,  /*< reversed bitorder version of AV_CRC_16_ANSI */
 #if FF_API_CRC_BIG_TABLE
    AV_CRC_24_IEEE = 12,
 #else
    AV_CRC_24_IEEE,
-    AV_CRC_8_EBU,
+#endif /* FF_API_CRC_BIG_TABLE */
    AV_CRC_MAX,         /*< Not part of public API! Do not use outside libavutil. */
 }AVCRCId;
@ -84,10 +88,7 @@ const AVCRC *av_crc_get_table(AVCRCId crc_id);
 /**
 * Calculate the CRC of a block.
 * @param ctx initialized AVCRC array (see av_crc_init())
 * @param crc CRC of previous blocks if any or initial value for CRC
 * @param buffer buffer whose CRC to calculate
 * @param length length of the buffer
 * @return CRC updated with the data from the given block
 *
 * @see av_crc_init() "le" parameter
--- a/output/include/arm64-v8a/libavutil/csp.h
+++ b/output/include/arm64-v8a/libavutil/csp.h
@ -1,150 +0,0 @@
 /*
 * Copyright (c) 2015 Kevin Wheatley <kevin.j.wheatley@gmail.com>
 * Copyright (c) 2016 Ronald S. Bultje <rsbultje@gmail.com>
 * Copyright (c) 2023 Leo Izen <leo.izen@gmail.com>
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_CSP_H
 #define AVUTIL_CSP_H
 #include "pixfmt.h"
 #include "rational.h"
 /**
 * @file
 * Colorspace value utility functions for libavutil.
 * @ingroup lavu_math_csp
 * @author Ronald S. Bultje <rsbultje@gmail.com>
 * @author Leo Izen <leo.izen@gmail.com>
 * @author Kevin Wheatley <kevin.j.wheatley@gmail.com>
 */
 /**
 * @defgroup lavu_math_csp Colorspace Utility
 * @ingroup lavu_math
 * @{
 */
 /**
 * Struct containing luma coefficients to be used for RGB to YUV/YCoCg, or similar
 * calculations.
 */
 typedef struct AVLumaCoefficients {
    AVRational cr, cg, cb;
 } AVLumaCoefficients;
 /**
 * Struct containing chromaticity x and y values for the standard CIE 1931
 * chromaticity definition.
 */
 typedef struct AVCIExy {
    AVRational x, y;
 } AVCIExy;
 /**
 * Struct defining the red, green, and blue primary locations in terms of CIE
 * 1931 chromaticity x and y.
 */
 typedef struct AVPrimaryCoefficients {
    AVCIExy r, g, b;
 } AVPrimaryCoefficients;
 /**
 * Struct defining white point location in terms of CIE 1931 chromaticity x
 * and y.
 */
 typedef AVCIExy AVWhitepointCoefficients;
 /**
 * Struct that contains both white point location and primaries location, providing
 * the complete description of a color gamut.
 */
 typedef struct AVColorPrimariesDesc {
    AVWhitepointCoefficients wp;
    AVPrimaryCoefficients prim;
 } AVColorPrimariesDesc;
 /**
 * Function pointer representing a double -> double transfer function that performs
 * an EOTF transfer inversion. This function outputs linear light.
 */
 typedef double (*av_csp_trc_function)(double);
 /**
 * Retrieves the Luma coefficients necessary to construct a conversion matrix
 * from an enum constant describing the colorspace.
 * @param csp An enum constant indicating YUV or similar colorspace.
 * @return The Luma coefficients associated with that colorspace, or NULL
 *     if the constant is unknown to libavutil.
 */
 const AVLumaCoefficients *av_csp_luma_coeffs_from_avcsp(enum AVColorSpace csp);
 /**
 * Retrieves a complete gamut description from an enum constant describing the
 * color primaries.
 * @param prm An enum constant indicating primaries
 * @return A description of the colorspace gamut associated with that enum
 *     constant, or NULL if the constant is unknown to libavutil.
 */
 const AVColorPrimariesDesc *av_csp_primaries_desc_from_id(enum AVColorPrimaries prm);
 /**
 * Detects which enum AVColorPrimaries constant corresponds to the given complete
 * gamut description.
 * @see enum AVColorPrimaries
 * @param prm A description of the colorspace gamut
 * @return The enum constant associated with this gamut, or
 *     AVCOL_PRI_UNSPECIFIED if no clear match can be idenitified.
 */
 enum AVColorPrimaries av_csp_primaries_id_from_desc(const AVColorPrimariesDesc *prm);
 /**
 * Determine a suitable 'gamma' value to match the supplied
 * AVColorTransferCharacteristic.
 *
 * See Apple Technical Note TN2257 (https://developer.apple.com/library/mac/technotes/tn2257/_index.html)
 *
 * This function returns the gamma exponent for the OETF. For example, sRGB is approximated
 * by gamma 2.2, not by gamma 0.45455.
 *
 * @return Will return an approximation to the simple gamma function matching
 *         the supplied Transfer Characteristic, Will return 0.0 for any
 *         we cannot reasonably match against.
 */
 double av_csp_approximate_trc_gamma(enum AVColorTransferCharacteristic trc);
 /**
 * Determine the function needed to apply the given
 * AVColorTransferCharacteristic to linear input.
 *
 * The function returned should expect a nominal domain and range of [0.0-1.0]
 * values outside of this range maybe valid depending on the chosen
 * characteristic function.
 *
 * @return Will return pointer to the function matching the
 *         supplied Transfer Characteristic. If unspecified will
 *         return NULL:
 */
 av_csp_trc_function av_csp_trc_func_from_id(enum AVColorTransferCharacteristic trc);
 /**
 * @}
 */
 #endif /* AVUTIL_CSP_H */
--- a/output/include/arm64-v8a/libavutil/des.h
+++ b/output/include/arm64-v8a/libavutil/des.h
@ -43,8 +43,6 @@ AVDES *av_des_alloc(void);
 /**
 * @brief Initializes an AVDES context.
 *
 * @param d pointer to a AVDES structure to initialize
 * @param key pointer to the key to use
 * @param key_bits must be 64 or 192
 * @param decrypt 0 for encryption/CBC-MAC, 1 for decryption
 * @return zero on success, negative value otherwise
@ -54,10 +52,9 @@ int av_des_init(struct AVDES *d, const uint8_t *key, int key_bits, int decrypt);
 /**
 * @brief Encrypts / decrypts using the DES algorithm.
 *
- * @param d pointer to the AVDES structure
+ * @param count number of 8 byte blocks
 * @param dst destination array, can be equal to src, must be 8-byte aligned
 * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
 * @param count number of 8 byte blocks
 * @param iv initialization vector for CBC mode, if NULL then ECB will be used,
 *           must be 8-byte aligned
 * @param decrypt 0 for encryption, 1 for decryption
@ -67,10 +64,9 @@ void av_des_crypt(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count,
 /**
 * @brief Calculates CBC-MAC using the DES algorithm.
 *
- * @param d pointer to the AVDES structure
+ * @param count number of 8 byte blocks
 * @param dst destination array, can be equal to src, must be 8-byte aligned
 * @param src source array, can be equal to dst, must be 8-byte aligned, may be NULL
 * @param count number of 8 byte blocks
 */
 void av_des_mac(struct AVDES *d, uint8_t *dst, const uint8_t *src, int count);
--- a/output/include/arm64-v8a/libavutil/detection_bbox.h
+++ b/output/include/arm64-v8a/libavutil/detection_bbox.h
@ -1,108 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_DETECTION_BBOX_H
 #define AVUTIL_DETECTION_BBOX_H
 #include "rational.h"
 #include "avassert.h"
 #include "frame.h"
 typedef struct AVDetectionBBox {
    /**
     * Distance in pixels from the left/top edge of the frame,
     * together with width and height, defining the bounding box.
     */
    int x;
    int y;
    int w;
    int h;
 #define AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE 64
    /**
     * Detect result with confidence
     */
    char detect_label[AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE];
    AVRational detect_confidence;
    /**
     * At most 4 classifications based on the detected bounding box.
     * For example, we can get max 4 different attributes with 4 different
     * DNN models on one bounding box.
     * classify_count is zero if no classification.
     */
 #define AV_NUM_DETECTION_BBOX_CLASSIFY 4
    uint32_t classify_count;
    char classify_labels[AV_NUM_DETECTION_BBOX_CLASSIFY][AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE];
    AVRational classify_confidences[AV_NUM_DETECTION_BBOX_CLASSIFY];
 } AVDetectionBBox;
 typedef struct AVDetectionBBoxHeader {
    /**
     * Information about how the bounding box is generated.
     * for example, the DNN model name.
     */
    char source[256];
    /**
     * Number of bounding boxes in the array.
     */
    uint32_t nb_bboxes;
    /**
     * Offset in bytes from the beginning of this structure at which
     * the array of bounding boxes starts.
     */
    size_t bboxes_offset;
    /**
     * Size of each bounding box in bytes.
     */
    size_t bbox_size;
 } AVDetectionBBoxHeader;
 /*
 * Get the bounding box at the specified {@code idx}. Must be between 0 and nb_bboxes.
 */
 static av_always_inline AVDetectionBBox *
 av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
 {
    av_assert0(idx < header->nb_bboxes);
    return (AVDetectionBBox *)((uint8_t *)header + header->bboxes_offset +
                               idx * header->bbox_size);
 }
 /**
 * Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
 * AVDetectionBBox, and initializes the variables.
 * Can be freed with a normal av_free() call.
 *
 * @param nb_bboxes number of AVDetectionBBox structures to allocate
 * @param out_size if non-NULL, the size in bytes of the resulting data array is
 * written here.
 */
 AVDetectionBBoxHeader *av_detection_bbox_alloc(uint32_t nb_bboxes, size_t *out_size);
 /**
 * Allocates memory for AVDetectionBBoxHeader, plus an array of {@code nb_bboxes}
 * AVDetectionBBox, in the given AVFrame {@code frame} as AVFrameSideData of type
 * AV_FRAME_DATA_DETECTION_BBOXES and initializes the variables.
 */
 AVDetectionBBoxHeader *av_detection_bbox_create_side_data(AVFrame *frame, uint32_t nb_bboxes);
 #endif
--- a/output/include/arm64-v8a/libavutil/dict.h
+++ b/output/include/arm64-v8a/libavutil/dict.h
@ -32,6 +32,8 @@
 #include <stdint.h>
 #include "version.h"
 /**
 * @addtogroup lavu_dict AVDictionary
 * @ingroup lavu_data
@ -39,15 +41,13 @@
 * @brief Simple key:value store
 *
 * @{
- * Dictionaries are used for storing key-value pairs.
+ * Dictionaries are used for storing key:value pairs. To create
- *
+ * an AVDictionary, simply pass an address of a NULL pointer to
- * - To **create an AVDictionary**, simply pass an address of a NULL
+ * av_dict_set(). NULL can be used as an empty dictionary wherever
- *   pointer to av_dict_set(). NULL can be used as an empty dictionary
+ * a pointer to an AVDictionary is required.
- *   wherever a pointer to an AVDictionary is required.
+ * Use av_dict_get() to retrieve an entry or iterate over all
- * - To **insert an entry**, use av_dict_set().
+ * entries and finally av_dict_free() to free the dictionary
- * - Use av_dict_get() to **retrieve an entry**.
+ * and all its contents.
 * - To **iterate over all entries**, use av_dict_iterate().
 * - In order to **free the dictionary and all its contents**, use av_dict_free().
 *
 @code
   AVDictionary *d = NULL;           // "create" an empty dictionary
@ -59,18 +59,13 @@
   char *v = av_strdup("value");     // you can avoid copying them like this
   av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
-   while ((t = av_dict_iterate(d, t))) {
+   while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) {
       <....>                             // iterate over all entries in d
   }
   av_dict_free(&d);
 @endcode
 */
 /**
 * @name AVDictionary Flags
 * Flags that influence behavior of the matching of keys or insertion to the dictionary.
 * @{
 */
 #define AV_DICT_MATCH_CASE      1   /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */
 #define AV_DICT_IGNORE_SUFFIX   2   /**< Return first entry in a dictionary whose first part corresponds to the search key,
                                         ignoring the suffix of the found key string. Only relevant in av_dict_get(). */
@ -78,13 +73,10 @@
                                         allocated with av_malloc() or another memory allocation function. */
 #define AV_DICT_DONT_STRDUP_VAL 8   /**< Take ownership of a value that's been
                                         allocated with av_malloc() or another memory allocation function. */
-#define AV_DICT_DONT_OVERWRITE 16   /**< Don't overwrite existing entries. */
+#define AV_DICT_DONT_OVERWRITE 16   ///< Don't overwrite existing entries.
 #define AV_DICT_APPEND         32   /**< If the entry already exists, append to it.  Note that no
                                      delimiter is added, the strings are simply concatenated. */
 #define AV_DICT_MULTIKEY       64   /**< Allow to store several equal keys in the dictionary */
 /**
 * @}
 */
 typedef struct AVDictionaryEntry {
    char *key;
@ -99,44 +91,18 @@ typedef struct AVDictionary AVDictionary;
 * The returned entry key or value must not be changed, or it will
 * cause undefined behavior.
 *
 * To iterate through all the dictionary entries, you can set the matching key
 * to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag.
 *
 * @param prev Set to the previous matching element to find the next.
 *             If set to NULL the first matching element is returned.
- * @param key   Matching key
+ * @param key matching key
- * @param flags A collection of AV_DICT_* flags controlling how the
+ * @param flags a collection of AV_DICT_* flags controlling how the entry is retrieved
- *              entry is retrieved
+ * @return found entry or NULL in case no matching entry was found in the dictionary
 *
 * @return      Found entry or NULL in case no matching entry was found in the dictionary
 */
 AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
                               const AVDictionaryEntry *prev, int flags);
 /**
 * Iterate over a dictionary
 *
 * Iterates through all entries in the dictionary.
 *
 * @warning The returned AVDictionaryEntry key/value must not be changed.
 *
 * @warning As av_dict_set() invalidates all previous entries returned
 * by this function, it must not be called while iterating over the dict.
 *
 * Typical usage:
 * @code
 * const AVDictionaryEntry *e = NULL;
 * while ((e = av_dict_iterate(m, e))) {
 *     // ...
 * }
 * @endcode
 *
 * @param m     The dictionary to iterate over
 * @param prev  Pointer to the previous AVDictionaryEntry, NULL initially
 *
 * @retval AVDictionaryEntry* The next element in the dictionary
 * @retval NULL               No more elements in the dictionary
 */
 const AVDictionaryEntry *av_dict_iterate(const AVDictionary *m,
                                         const AVDictionaryEntry *prev);
 /**
 * Get number of entries in dictionary.
 *
@ -151,24 +117,23 @@ int av_dict_count(const AVDictionary *m);
 * Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,
 * these arguments will be freed on error.
 *
- * @warning Adding a new entry to a dictionary invalidates all existing entries
+ * Warning: Adding a new entry to a dictionary invalidates all existing entries
- * previously returned with av_dict_get() or av_dict_iterate().
+ * previously returned with av_dict_get.
 *
- * @param pm        Pointer to a pointer to a dictionary struct. If *pm is NULL
+ * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL
 * a dictionary struct is allocated and put in *pm.
- * @param key       Entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
+ * @param key entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
- * @param value     Entry value to add to *pm (will be av_strduped or added as a new key depending on flags).
+ * @param value entry value to add to *pm (will be av_strduped or added as a new key depending on flags).
 *        Passing a NULL value will cause an existing entry to be deleted.
 *
 * @return >= 0 on success otherwise an error code <0
 */
 int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
 /**
- * Convenience wrapper for av_dict_set() that converts the value to a string
+ * Convenience wrapper for av_dict_set that converts the value to a string
 * and stores it.
 *
- * Note: If ::AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.
+ * Note: If AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.
 */
 int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
@ -178,15 +143,14 @@ int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags
 * In case of failure, all the successfully set entries are stored in
 * *pm. You may need to manually free the created dictionary.
 *
- * @param key_val_sep  A 0-terminated list of characters used to separate
+ * @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
+ * @param pairs_sep    a 0-terminated list of characters used to separate
 *                     two pairs from each other
- * @param flags        Flags to use when adding to the dictionary.
+ * @param flags        flags to use when adding to dictionary.
- *                     ::AV_DICT_DONT_STRDUP_KEY and ::AV_DICT_DONT_STRDUP_VAL
+ *                     AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL
 *                     are ignored since the key/value tokens will always
 *                     be duplicated.
 *
 * @return             0 on success, negative AVERROR code on failure
 */
 int av_dict_parse_string(AVDictionary **pm, const char *str,
@ -195,14 +159,11 @@ int av_dict_parse_string(AVDictionary **pm, const char *str,
 /**
 * Copy entries from one AVDictionary struct into another.
- *
+ * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
 * @note Metadata is read using the ::AV_DICT_IGNORE_SUFFIX flag
 *
 * @param dst   Pointer to a pointer to a AVDictionary struct to copy into. If *dst is NULL,
 *            this function will allocate a struct for you and put it in *dst
- * @param src   Pointer to the source AVDictionary struct to copy items from.
+ * @param src pointer to source AVDictionary struct
- * @param flags Flags to use when setting entries in *dst
+ * @param flags flags to use when setting entries in *dst
- *
+ * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
 * @return 0 on success, negative AVERROR code on failure. If dst was allocated
 *           by this function, callers should free the associated memory.
 */
@ -221,15 +182,13 @@ void av_dict_free(AVDictionary **m);
 * Such string may be passed back to av_dict_parse_string().
 * @note String is escaped with backslashes ('\').
 *
- * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
+ * @param[in]  m             dictionary
 *
 * @param[in]  m             The dictionary
 * @param[out] buffer        Pointer to buffer that will be allocated with string containg entries.
 *                           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]  key_val_sep   character used to separate key from value
- * @param[in]  pairs_sep     Character used to separate two pairs from each other
+ * @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_dict_get_string(const AVDictionary *m, char **buffer,
                       const char key_val_sep, const char pairs_sep);
--- a/output/include/arm64-v8a/libavutil/display.h
+++ b/output/include/arm64-v8a/libavutil/display.h
@ -20,7 +20,6 @@
 /**
 * @file
 * @ingroup lavu_video_display
 * Display matrix
 */
@ -28,11 +27,18 @@
 #define AVUTIL_DISPLAY_H
 #include <stdint.h>
 #include "common.h"
 /**
- * @defgroup lavu_video_display Display transformation matrix functions
+ * @addtogroup lavu_video
- * @ingroup lavu_video
+ * @{
 *
 * @defgroup lavu_video_display Display transformation matrix functions
 * @{
 */
 /**
 * @addtogroup lavu_video_display
 * The display transformation matrix specifies an affine transformation that
 * should be applied to video frames for correct presentation. It is compatible
 * with the matrices stored in the ISO/IEC 14496-12 container format.
@ -66,8 +72,6 @@
 *   q' = (b * p + d * q + y) / z;
 *   z  =  u * p + v * q + w
 * @endcode
 *
 * @{
 */
 /**
@ -84,10 +88,10 @@
 double av_display_rotation_get(const int32_t matrix[9]);
 /**
- * Initialize a transformation matrix describing a pure clockwise
+ * Initialize a transformation matrix describing a pure counterclockwise
 * rotation by the specified angle (in degrees).
 *
- * @param[out] matrix a transformation matrix (will be fully overwritten
+ * @param matrix an allocated transformation matrix (will be fully overwritten
 *               by this function)
 * @param angle rotation angle in degrees.
 */
@ -96,13 +100,14 @@ void av_display_rotation_set(int32_t matrix[9], double angle);
 /**
 * Flip the input matrix horizontally and/or vertically.
 *
- * @param[in,out] matrix a transformation matrix
+ * @param matrix an allocated transformation matrix
 * @param hflip whether the matrix should be flipped horizontally
 * @param vflip whether the matrix should be flipped vertically
 */
 void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
 /**
 * @}
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/dovi_meta.h
+++ b/output/include/arm64-v8a/libavutil/dovi_meta.h
@ -1,236 +0,0 @@
 /*
 * Copyright (c) 2020 Vacing Fang <vacingfang@tencent.com>
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 /**
 * @file
 * DOVI configuration
 */
 #ifndef AVUTIL_DOVI_META_H
 #define AVUTIL_DOVI_META_H
 #include <stdint.h>
 #include <stddef.h>
 #include "rational.h"
 /*
 * DOVI configuration
 * ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2
        dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2
 * @code
 * uint8_t  dv_version_major, the major version number that the stream complies with
 * uint8_t  dv_version_minor, the minor version number that the stream complies with
 * uint8_t  dv_profile, the Dolby Vision profile
 * uint8_t  dv_level, the Dolby Vision level
 * uint8_t  rpu_present_flag
 * uint8_t  el_present_flag
 * uint8_t  bl_present_flag
 * uint8_t  dv_bl_signal_compatibility_id
 * @endcode
 *
 * @note The struct must be allocated with av_dovi_alloc() and
 *       its size is not a part of the public ABI.
 */
 typedef struct AVDOVIDecoderConfigurationRecord {
    uint8_t dv_version_major;
    uint8_t dv_version_minor;
    uint8_t dv_profile;
    uint8_t dv_level;
    uint8_t rpu_present_flag;
    uint8_t el_present_flag;
    uint8_t bl_present_flag;
    uint8_t dv_bl_signal_compatibility_id;
 } AVDOVIDecoderConfigurationRecord;
 /**
 * Allocate a AVDOVIDecoderConfigurationRecord structure and initialize its
 * fields to default values.
 *
 * @return the newly allocated struct or NULL on failure
 */
 AVDOVIDecoderConfigurationRecord *av_dovi_alloc(size_t *size);
 /**
 * Dolby Vision RPU data header.
 *
 * @note sizeof(AVDOVIRpuDataHeader) is not part of the public ABI.
 */
 typedef struct AVDOVIRpuDataHeader {
    uint8_t rpu_type;
    uint16_t rpu_format;
    uint8_t vdr_rpu_profile;
    uint8_t vdr_rpu_level;
    uint8_t chroma_resampling_explicit_filter_flag;
    uint8_t coef_data_type; /* informative, lavc always converts to fixed */
    uint8_t coef_log2_denom;
    uint8_t vdr_rpu_normalized_idc;
    uint8_t bl_video_full_range_flag;
    uint8_t bl_bit_depth; /* [8, 16] */
    uint8_t el_bit_depth; /* [8, 16] */
    uint8_t vdr_bit_depth; /* [8, 16] */
    uint8_t spatial_resampling_filter_flag;
    uint8_t el_spatial_resampling_filter_flag;
    uint8_t disable_residual_flag;
 } AVDOVIRpuDataHeader;
 enum AVDOVIMappingMethod {
    AV_DOVI_MAPPING_POLYNOMIAL = 0,
    AV_DOVI_MAPPING_MMR = 1,
 };
 /**
 * Coefficients of a piece-wise function. The pieces of the function span the
 * value ranges between two adjacent pivot values.
 */
 #define AV_DOVI_MAX_PIECES 8
 typedef struct AVDOVIReshapingCurve {
    uint8_t num_pivots;                         /* [2, 9] */
    uint16_t pivots[AV_DOVI_MAX_PIECES + 1];    /* sorted ascending */
    enum AVDOVIMappingMethod mapping_idc[AV_DOVI_MAX_PIECES];
    /* AV_DOVI_MAPPING_POLYNOMIAL */
    uint8_t poly_order[AV_DOVI_MAX_PIECES];     /* [1, 2] */
    int64_t poly_coef[AV_DOVI_MAX_PIECES][3];   /* x^0, x^1, x^2 */
    /* AV_DOVI_MAPPING_MMR */
    uint8_t mmr_order[AV_DOVI_MAX_PIECES];      /* [1, 3] */
    int64_t mmr_constant[AV_DOVI_MAX_PIECES];
    int64_t mmr_coef[AV_DOVI_MAX_PIECES][3/* order - 1 */][7];
 } AVDOVIReshapingCurve;
 enum AVDOVINLQMethod {
    AV_DOVI_NLQ_NONE = -1,
    AV_DOVI_NLQ_LINEAR_DZ = 0,
 };
 /**
 * Coefficients of the non-linear inverse quantization. For the interpretation
 * of these, see ETSI GS CCM 001.
 */
 typedef struct AVDOVINLQParams {
    uint16_t nlq_offset;
    uint64_t vdr_in_max;
    /* AV_DOVI_NLQ_LINEAR_DZ */
    uint64_t linear_deadzone_slope;
    uint64_t linear_deadzone_threshold;
 } AVDOVINLQParams;
 /**
 * Dolby Vision RPU data mapping parameters.
 *
 * @note sizeof(AVDOVIDataMapping) is not part of the public ABI.
 */
 typedef struct AVDOVIDataMapping {
    uint8_t vdr_rpu_id;
    uint8_t mapping_color_space;
    uint8_t mapping_chroma_format_idc;
    AVDOVIReshapingCurve curves[3]; /* per component */
    /* Non-linear inverse quantization */
    enum AVDOVINLQMethod nlq_method_idc;
    uint32_t num_x_partitions;
    uint32_t num_y_partitions;
    AVDOVINLQParams nlq[3]; /* per component */
 } AVDOVIDataMapping;
 /**
 * Dolby Vision RPU colorspace metadata parameters.
 *
 * @note sizeof(AVDOVIColorMetadata) is not part of the public ABI.
 */
 typedef struct AVDOVIColorMetadata {
    uint8_t dm_metadata_id;
    uint8_t scene_refresh_flag;
    /**
     * Coefficients of the custom Dolby Vision IPT-PQ matrices. These are to be
     * used instead of the matrices indicated by the frame's colorspace tags.
     * The output of rgb_to_lms_matrix is to be fed into a BT.2020 LMS->RGB
     * matrix based on a Hunt-Pointer-Estevez transform, but without any
     * crosstalk. (See the definition of the ICtCp colorspace for more
     * information.)
     */
    AVRational ycc_to_rgb_matrix[9]; /* before PQ linearization */
    AVRational ycc_to_rgb_offset[3]; /* input offset of neutral value */
    AVRational rgb_to_lms_matrix[9]; /* after PQ linearization */
    /**
     * Extra signal metadata (see Dolby patents for more info).
     */
    uint16_t signal_eotf;
    uint16_t signal_eotf_param0;
    uint16_t signal_eotf_param1;
    uint32_t signal_eotf_param2;
    uint8_t signal_bit_depth;
    uint8_t signal_color_space;
    uint8_t signal_chroma_format;
    uint8_t signal_full_range_flag; /* [0, 3] */
    uint16_t source_min_pq;
    uint16_t source_max_pq;
    uint16_t source_diagonal;
 } AVDOVIColorMetadata;
 /**
 * Combined struct representing a combination of header, mapping and color
 * metadata, for attaching to frames as side data.
 *
 * @note The struct must be allocated with av_dovi_metadata_alloc() and
 *       its size is not a part of the public ABI.
 */
 typedef struct AVDOVIMetadata {
    /**
     * Offset in bytes from the beginning of this structure at which the
     * respective structs start.
     */
    size_t header_offset;   /* AVDOVIRpuDataHeader */
    size_t mapping_offset;  /* AVDOVIDataMapping */
    size_t color_offset;    /* AVDOVIColorMetadata */
 } AVDOVIMetadata;
 static av_always_inline AVDOVIRpuDataHeader *
 av_dovi_get_header(const AVDOVIMetadata *data)
 {
    return (AVDOVIRpuDataHeader *)((uint8_t *) data + data->header_offset);
 }
 static av_always_inline AVDOVIDataMapping *
 av_dovi_get_mapping(const AVDOVIMetadata *data)
 {
    return (AVDOVIDataMapping *)((uint8_t *) data + data->mapping_offset);
 }
 static av_always_inline AVDOVIColorMetadata *
 av_dovi_get_color(const AVDOVIMetadata *data)
 {
    return (AVDOVIColorMetadata *)((uint8_t *) data + data->color_offset);
 }
 /**
 * Allocate an AVDOVIMetadata structure and initialize its
 * fields to default values.
 *
 * @param size If this parameter is non-NULL, the size in bytes of the
 *             allocated struct will be written here on success
 *
 * @return the newly allocated struct or NULL on failure
 */
 AVDOVIMetadata *av_dovi_metadata_alloc(size_t *size);
 #endif /* AVUTIL_DOVI_META_H */
--- a/output/include/arm64-v8a/libavutil/encryption_info.h
+++ b/output/include/arm64-v8a/libavutil/encryption_info.h
@ -1,205 +0,0 @@
 /**
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_ENCRYPTION_INFO_H
 #define AVUTIL_ENCRYPTION_INFO_H
 #include <stddef.h>
 #include <stdint.h>
 typedef struct AVSubsampleEncryptionInfo {
    /** The number of bytes that are clear. */
    unsigned int bytes_of_clear_data;
    /**
     * The number of bytes that are protected.  If using pattern encryption,
     * the pattern applies to only the protected bytes; if not using pattern
     * encryption, all these bytes are encrypted.
     */
    unsigned int bytes_of_protected_data;
 } AVSubsampleEncryptionInfo;
 /**
 * This describes encryption info for a packet.  This contains frame-specific
 * info for how to decrypt the packet before passing it to the decoder.
 *
 * The size of this struct is not part of the public ABI.
 */
 typedef struct AVEncryptionInfo {
    /** The fourcc encryption scheme, in big-endian byte order. */
    uint32_t scheme;
    /**
     * Only used for pattern encryption.  This is the number of 16-byte blocks
     * that are encrypted.
     */
    uint32_t crypt_byte_block;
    /**
     * Only used for pattern encryption.  This is the number of 16-byte blocks
     * that are clear.
     */
    uint32_t skip_byte_block;
    /**
     * The ID of the key used to encrypt the packet.  This should always be
     * 16 bytes long, but may be changed in the future.
     */
    uint8_t *key_id;
    uint32_t key_id_size;
    /**
     * The initialization vector.  This may have been zero-filled to be the
     * correct block size.  This should always be 16 bytes long, but may be
     * changed in the future.
     */
    uint8_t *iv;
    uint32_t iv_size;
    /**
     * An array of subsample encryption info specifying how parts of the sample
     * are encrypted.  If there are no subsamples, then the whole sample is
     * encrypted.
     */
    AVSubsampleEncryptionInfo *subsamples;
    uint32_t subsample_count;
 } AVEncryptionInfo;
 /**
 * This describes info used to initialize an encryption key system.
 *
 * The size of this struct is not part of the public ABI.
 */
 typedef struct AVEncryptionInitInfo {
    /**
     * A unique identifier for the key system this is for, can be NULL if it
     * is not known.  This should always be 16 bytes, but may change in the
     * future.
     */
    uint8_t* system_id;
    uint32_t system_id_size;
    /**
     * An array of key IDs this initialization data is for.  All IDs are the
     * same length.  Can be NULL if there are no known key IDs.
     */
    uint8_t** key_ids;
    /** The number of key IDs. */
    uint32_t num_key_ids;
    /**
     * The number of bytes in each key ID.  This should always be 16, but may
     * change in the future.
     */
    uint32_t key_id_size;
    /**
     * Key-system specific initialization data.  This data is copied directly
     * from the file and the format depends on the specific key system.  This
     * can be NULL if there is no initialization data; in that case, there
     * will be at least one key ID.
     */
    uint8_t* data;
    uint32_t data_size;
    /**
     * An optional pointer to the next initialization info in the list.
     */
    struct AVEncryptionInitInfo *next;
 } AVEncryptionInitInfo;
 /**
 * Allocates an AVEncryptionInfo structure and sub-pointers to hold the given
 * number of subsamples.  This will allocate pointers for the key ID, IV,
 * and subsample entries, set the size members, and zero-initialize the rest.
 *
 * @param subsample_count The number of subsamples.
 * @param key_id_size The number of bytes in the key ID, should be 16.
 * @param iv_size The number of bytes in the IV, should be 16.
 *
 * @return The new AVEncryptionInfo structure, or NULL on error.
 */
 AVEncryptionInfo *av_encryption_info_alloc(uint32_t subsample_count, uint32_t key_id_size, uint32_t iv_size);
 /**
 * Allocates an AVEncryptionInfo structure with a copy of the given data.
 * @return The new AVEncryptionInfo structure, or NULL on error.
 */
 AVEncryptionInfo *av_encryption_info_clone(const AVEncryptionInfo *info);
 /**
 * Frees the given encryption info object.  This MUST NOT be used to free the
 * side-data data pointer, that should use normal side-data methods.
 */
 void av_encryption_info_free(AVEncryptionInfo *info);
 /**
 * Creates a copy of the AVEncryptionInfo that is contained in the given side
 * data.  The resulting object should be passed to av_encryption_info_free()
 * when done.
 *
 * @return The new AVEncryptionInfo structure, or NULL on error.
 */
 AVEncryptionInfo *av_encryption_info_get_side_data(const uint8_t *side_data, size_t side_data_size);
 /**
 * Allocates and initializes side data that holds a copy of the given encryption
 * info.  The resulting pointer should be either freed using av_free or given
 * to av_packet_add_side_data().
 *
 * @return The new side-data pointer, or NULL.
 */
 uint8_t *av_encryption_info_add_side_data(
      const AVEncryptionInfo *info, size_t *side_data_size);
 /**
 * Allocates an AVEncryptionInitInfo structure and sub-pointers to hold the
 * given sizes.  This will allocate pointers and set all the fields.
 *
 * @return The new AVEncryptionInitInfo structure, or NULL on error.
 */
 AVEncryptionInitInfo *av_encryption_init_info_alloc(
    uint32_t system_id_size, uint32_t num_key_ids, uint32_t key_id_size, uint32_t data_size);
 /**
 * Frees the given encryption init info object.  This MUST NOT be used to free
 * the side-data data pointer, that should use normal side-data methods.
 */
 void av_encryption_init_info_free(AVEncryptionInitInfo* info);
 /**
 * Creates a copy of the AVEncryptionInitInfo that is contained in the given
 * side data.  The resulting object should be passed to
 * av_encryption_init_info_free() when done.
 *
 * @return The new AVEncryptionInitInfo structure, or NULL on error.
 */
 AVEncryptionInitInfo *av_encryption_init_info_get_side_data(
    const uint8_t* side_data, size_t side_data_size);
 /**
 * Allocates and initializes side data that holds a copy of the given encryption
 * init info.  The resulting pointer should be either freed using av_free or
 * given to av_packet_add_side_data().
 *
 * @return The new side-data pointer, or NULL.
 */
 uint8_t *av_encryption_init_info_add_side_data(
    const AVEncryptionInitInfo *info, size_t *side_data_size);
 #endif /* AVUTIL_ENCRYPTION_INFO_H */
--- a/output/include/arm64-v8a/libavutil/error.h
+++ b/output/include/arm64-v8a/libavutil/error.h
@ -27,8 +27,6 @@
 #include <errno.h>
 #include <stddef.h>
 #include "macros.h"
 /**
 * @addtogroup lavu_error
 *
--- a/output/include/arm64-v8a/libavutil/eval.h
+++ b/output/include/arm64-v8a/libavutil/eval.h
@ -26,6 +26,8 @@
 #ifndef AVUTIL_EVAL_H
 #define AVUTIL_EVAL_H
 #include "avutil.h"
 typedef struct AVExpr AVExpr;
 /**
@ -42,7 +44,6 @@ typedef struct AVExpr AVExpr;
 * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
 * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
 * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
 * @param log_offset log level offset, can be used to silence error messages
 * @param log_ctx parent logging context
 * @return >= 0 in case of success, a negative value corresponding to an
 * AVERROR code otherwise
@ -66,7 +67,6 @@ int av_expr_parse_and_eval(double *res, const char *s,
 * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
 * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
 * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
 * @param log_offset log level offset, can be used to silence error messages
 * @param log_ctx parent logging context
 * @return >= 0 in case of success, a negative value corresponding to an
 * AVERROR code otherwise
@ -80,39 +80,12 @@ int av_expr_parse(AVExpr **expr, const char *s,
 /**
 * Evaluate a previously parsed expression.
 *
 * @param e the AVExpr to evaluate
 * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names
 * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
 * @return the value of the expression
 */
 double av_expr_eval(AVExpr *e, const double *const_values, void *opaque);
 /**
 * Track the presence of variables and their number of occurrences in a parsed expression
 *
 * @param e the AVExpr to track variables in
 * @param counter a zero-initialized array where the count of each variable will be stored
 * @param size size of array
 * @return 0 on success, a negative value indicates that no expression or array was passed
 * or size was zero
 */
 int av_expr_count_vars(AVExpr *e, unsigned *counter, int size);
 /**
 * Track the presence of user provided functions and their number of occurrences
 * in a parsed expression.
 *
 * @param e the AVExpr to track user provided functions in
 * @param counter a zero-initialized array where the count of each function will be stored
 *                if you passed 5 functions with 2 arguments to av_expr_parse()
 *                then for arg=2 this will use upto 5 entries.
 * @param size size of array
 * @param arg number of arguments the counted functions have
 * @return 0 on success, a negative value indicates that no expression or array was passed
 * or size was zero
 */
 int av_expr_count_func(AVExpr *e, unsigned *counter, int size, int arg);
 /**
 * Free a parsed expression previously created with av_expr_parse().
 */
--- a/output/include/arm64-v8a/libavutil/ffversion.h
+++ b/output/include/arm64-v8a/libavutil/ffversion.h
@ -1,5 +1,5 @@
 /* Automatically generated by version.sh, do not manually edit! */
 #ifndef AVUTIL_FFVERSION_H
 #define AVUTIL_FFVERSION_H
-#define FFMPEG_VERSION "6.0"
+#define FFMPEG_VERSION "3.4.8"
 #endif /* AVUTIL_FFVERSION_H */
--- a/output/include/arm64-v8a/libavutil/fifo.h
+++ b/output/include/arm64-v8a/libavutil/fifo.h
@ -18,229 +18,16 @@
 /**
 * @file
- * @ingroup lavu_fifo
+ * a very simple circular buffer FIFO implementation
 * A generic FIFO API
 */
 #ifndef AVUTIL_FIFO_H
 #define AVUTIL_FIFO_H
 #include <stddef.h>
 #include <stdint.h>
-
+#include "avutil.h"
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_fifo AVFifo
 * @ingroup lavu_data
 *
 * @{
 * A generic FIFO API
 */
 typedef struct AVFifo AVFifo;
 /**
 * Callback for writing or reading from a FIFO, passed to (and invoked from) the
 * av_fifo_*_cb() functions. It may be invoked multiple times from a single
 * av_fifo_*_cb() call and may process less data than the maximum size indicated
 * by nb_elems.
 *
 * @param opaque the opaque pointer provided to the av_fifo_*_cb() function
 * @param buf the buffer for reading or writing the data, depending on which
 *            av_fifo_*_cb function is called
 * @param nb_elems On entry contains the maximum number of elements that can be
 *                 read from / written into buf. On success, the callback should
 *                 update it to contain the number of elements actually written.
 *
 * @return 0 on success, a negative error code on failure (will be returned from
 *         the invoking av_fifo_*_cb() function)
 */
 typedef int AVFifoCB(void *opaque, void *buf, size_t *nb_elems);
 /**
 * Automatically resize the FIFO on writes, so that the data fits. This
 * automatic resizing happens up to a limit that can be modified with
 * av_fifo_auto_grow_limit().
 */
 #define AV_FIFO_FLAG_AUTO_GROW      (1 << 0)
 /**
 * Allocate and initialize an AVFifo with a given element size.
 *
 * @param elems     initial number of elements that can be stored in the FIFO
 * @param elem_size Size in bytes of a single element. Further operations on
 *                  the returned FIFO will implicitly use this element size.
 * @param flags a combination of AV_FIFO_FLAG_*
 *
 * @return newly-allocated AVFifo on success, a negative error code on failure
 */
 AVFifo *av_fifo_alloc2(size_t elems, size_t elem_size,
                       unsigned int flags);
 /**
 * @return Element size for FIFO operations. This element size is set at
 *         FIFO allocation and remains constant during its lifetime
 */
 size_t av_fifo_elem_size(const AVFifo *f);
 /**
 * Set the maximum size (in elements) to which the FIFO can be resized
 * automatically. Has no effect unless AV_FIFO_FLAG_AUTO_GROW is used.
 */
 void av_fifo_auto_grow_limit(AVFifo *f, size_t max_elems);
 /**
 * @return number of elements available for reading from the given FIFO.
 */
 size_t av_fifo_can_read(const AVFifo *f);
 /**
 * @return Number of elements that can be written into the given FIFO without
 *         growing it.
 *
 *         In other words, this number of elements or less is guaranteed to fit
 *         into the FIFO. More data may be written when the
 *         AV_FIFO_FLAG_AUTO_GROW flag was specified at FIFO creation, but this
 *         may involve memory allocation, which can fail.
 */
 size_t av_fifo_can_write(const AVFifo *f);
 /**
 * Enlarge an AVFifo.
 *
 * On success, the FIFO will be large enough to hold exactly
 * inc + av_fifo_can_read() + av_fifo_can_write()
 * elements. In case of failure, the old FIFO is kept unchanged.
 *
 * @param f AVFifo to resize
 * @param inc number of elements to allocate for, in addition to the current
 *            allocated size
 * @return a non-negative number on success, a negative error code on failure
 */
 int av_fifo_grow2(AVFifo *f, size_t inc);
 /**
 * Write data into a FIFO.
 *
 * In case nb_elems > av_fifo_can_write(f) and the AV_FIFO_FLAG_AUTO_GROW flag
 * was not specified at FIFO creation, nothing is written and an error
 * is returned.
 *
 * Calling function is guaranteed to succeed if nb_elems <= av_fifo_can_write(f).
 *
 * @param f the FIFO buffer
 * @param buf Data to be written. nb_elems * av_fifo_elem_size(f) bytes will be
 *            read from buf on success.
 * @param nb_elems number of elements to write into FIFO
 *
 * @return a non-negative number on success, a negative error code on failure
 */
 int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems);
 /**
 * Write data from a user-provided callback into a FIFO.
 *
 * @param f the FIFO buffer
 * @param read_cb Callback supplying the data to the FIFO. May be called
 *                multiple times.
 * @param opaque opaque user data to be provided to read_cb
 * @param nb_elems Should point to the maximum number of elements that can be
 *                 written. Will be updated to contain the number of elements
 *                 actually written.
 *
 * @return non-negative number on success, a negative error code on failure
 */
 int av_fifo_write_from_cb(AVFifo *f, AVFifoCB read_cb,
                          void *opaque, size_t *nb_elems);
 /**
 * Read data from a FIFO.
 *
 * In case nb_elems > av_fifo_can_read(f), nothing is read and an error
 * is returned.
 *
 * @param f the FIFO buffer
 * @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes
 *            will be written into buf on success.
 * @param nb_elems number of elements to read from FIFO
 *
 * @return a non-negative number on success, a negative error code on failure
 */
 int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems);
 /**
 * Feed data from a FIFO into a user-provided callback.
 *
 * @param f the FIFO buffer
 * @param write_cb Callback the data will be supplied to. May be called
 *                 multiple times.
 * @param opaque opaque user data to be provided to write_cb
 * @param nb_elems Should point to the maximum number of elements that can be
 *                 read. Will be updated to contain the total number of elements
 *                 actually sent to the callback.
 *
 * @return non-negative number on success, a negative error code on failure
 */
 int av_fifo_read_to_cb(AVFifo *f, AVFifoCB write_cb,
                       void *opaque, size_t *nb_elems);
 /**
 * Read data from a FIFO without modifying FIFO state.
 *
 * Returns an error if an attempt is made to peek to nonexistent elements
 * (i.e. if offset + nb_elems is larger than av_fifo_can_read(f)).
 *
 * @param f the FIFO buffer
 * @param buf Buffer to store the data. nb_elems * av_fifo_elem_size(f) bytes
 *            will be written into buf.
 * @param nb_elems number of elements to read from FIFO
 * @param offset number of initial elements to skip.
 *
 * @return a non-negative number on success, a negative error code on failure
 */
 int av_fifo_peek(AVFifo *f, void *buf, size_t nb_elems, size_t offset);
 /**
 * Feed data from a FIFO into a user-provided callback.
 *
 * @param f the FIFO buffer
 * @param write_cb Callback the data will be supplied to. May be called
 *                 multiple times.
 * @param opaque opaque user data to be provided to write_cb
 * @param nb_elems Should point to the maximum number of elements that can be
 *                 read. Will be updated to contain the total number of elements
 *                 actually sent to the callback.
 * @param offset number of initial elements to skip; offset + *nb_elems must not
 *               be larger than av_fifo_can_read(f).
 *
 * @return a non-negative number on success, a negative error code on failure
 */
 int av_fifo_peek_to_cb(AVFifo *f, AVFifoCB write_cb, void *opaque,
                       size_t *nb_elems, size_t offset);
 /**
 * Discard the specified amount of data from an AVFifo.
 * @param size number of elements to discard, MUST NOT be larger than
 *             av_fifo_can_read(f)
 */
 void av_fifo_drain2(AVFifo *f, size_t size);
 /*
 * Empty the AVFifo.
 * @param f AVFifo to reset
 */
 void av_fifo_reset2(AVFifo *f);
 /**
 * Free an AVFifo and reset pointer to NULL.
 * @param f Pointer to an AVFifo to free. *f == NULL is allowed.
 */
 void av_fifo_freep2(AVFifo **f);
 #if FF_API_FIFO_OLD_API
 typedef struct AVFifoBuffer {
    uint8_t *buffer;
    uint8_t *rptr, *wptr, *end;
@ -251,9 +38,7 @@ typedef struct AVFifoBuffer {
 * Initialize an AVFifoBuffer.
 * @param size of FIFO
 * @return AVFifoBuffer or NULL in case of memory allocation failure
 * @deprecated use av_fifo_alloc2()
 */
 attribute_deprecated
 AVFifoBuffer *av_fifo_alloc(unsigned int size);
 /**
@ -261,33 +46,25 @@ AVFifoBuffer *av_fifo_alloc(unsigned int size);
 * @param nmemb number of elements
 * @param size  size of the single element
 * @return AVFifoBuffer or NULL in case of memory allocation failure
 * @deprecated use av_fifo_alloc2()
 */
 attribute_deprecated
 AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
 /**
 * Free an AVFifoBuffer.
 * @param f AVFifoBuffer to free
 * @deprecated use the AVFifo API with av_fifo_freep2()
 */
 attribute_deprecated
 void av_fifo_free(AVFifoBuffer *f);
 /**
 * Free an AVFifoBuffer and reset pointer to NULL.
 * @param f AVFifoBuffer to free
 * @deprecated use the AVFifo API with av_fifo_freep2()
 */
 attribute_deprecated
 void av_fifo_freep(AVFifoBuffer **f);
 /**
 * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
 * @param f AVFifoBuffer to reset
 * @deprecated use av_fifo_reset2() with the new AVFifo-API
 */
 attribute_deprecated
 void av_fifo_reset(AVFifoBuffer *f);
 /**
@ -295,9 +72,7 @@ void av_fifo_reset(AVFifoBuffer *f);
 * amount of data you can read from it.
 * @param f AVFifoBuffer to read from
 * @return size
 * @deprecated use av_fifo_can_read() with the new AVFifo-API
 */
 attribute_deprecated
 int av_fifo_size(const AVFifoBuffer *f);
 /**
@ -305,9 +80,7 @@ int av_fifo_size(const AVFifoBuffer *f);
 * amount of data you can write into it.
 * @param f AVFifoBuffer to write into
 * @return size
 * @deprecated use av_fifo_can_write() with the new AVFifo-API
 */
 attribute_deprecated
 int av_fifo_space(const AVFifoBuffer *f);
 /**
@ -318,13 +91,7 @@ int av_fifo_space(const AVFifoBuffer *f);
 * @param buf_size number of bytes to read
 * @param func generic read function
 * @param dest data destination
 *
 * @return a non-negative number on success, a negative error code on failure
 *
 * @deprecated use the new AVFifo-API with av_fifo_peek() when func == NULL,
 *             av_fifo_peek_to_cb() otherwise
 */
 attribute_deprecated
 int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int));
 /**
@ -334,13 +101,7 @@ int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_siz
 * @param buf_size number of bytes to read
 * @param func generic read function
 * @param dest data destination
 *
 * @return a non-negative number on success, a negative error code on failure
 *
 * @deprecated use the new AVFifo-API with av_fifo_peek() when func == NULL,
 *             av_fifo_peek_to_cb() otherwise
 */
 attribute_deprecated
 int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
 /**
@ -349,13 +110,7 @@ int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size, void (*func)
 * @param buf_size number of bytes to read
 * @param func generic read function
 * @param dest data destination
 *
 * @return a non-negative number on success, a negative error code on failure
 *
 * @deprecated use the new AVFifo-API with av_fifo_read() when func == NULL,
 *             av_fifo_read_to_cb() otherwise
 */
 attribute_deprecated
 int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
 /**
@ -369,12 +124,8 @@ int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)
 * func must return the number of bytes written to dest_buf, or <= 0 to
 * indicate no more data available to write.
 * If func is NULL, src is interpreted as a simple byte array for source data.
- * @return the number of bytes written to the FIFO or a negative error code on failure
+ * @return the number of bytes written to the FIFO
 *
 * @deprecated use the new AVFifo-API with av_fifo_write() when func == NULL,
 *             av_fifo_write_from_cb() otherwise
 */
 attribute_deprecated
 int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
 /**
@ -384,11 +135,7 @@ int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void
 * @param f AVFifoBuffer to resize
 * @param size new AVFifoBuffer size in bytes
 * @return <0 for failure, >=0 otherwise
 *
 * @deprecated use the new AVFifo-API with av_fifo_grow2() to increase FIFO size,
 *             decreasing FIFO size is not supported
 */
 attribute_deprecated
 int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
 /**
@ -399,24 +146,16 @@ int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
 * @param f AVFifoBuffer to resize
 * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size()
 * @return <0 for failure, >=0 otherwise
 *
 * @deprecated use the new AVFifo-API with av_fifo_grow2(); note that unlike
 * this function it adds to the allocated size, rather than to the used size
 */
 attribute_deprecated
 int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
 /**
 * Read and discard the specified amount of data from an AVFifoBuffer.
 * @param f AVFifoBuffer to read from
 * @param size amount of data to read in bytes
 *
 * @deprecated use the new AVFifo-API with av_fifo_drain2()
 */
 attribute_deprecated
 void av_fifo_drain(AVFifoBuffer *f, int size);
 #if FF_API_FIFO_PEEK2
 /**
 * Return a pointer to the data stored in a FIFO buffer at a certain offset.
 * The FIFO buffer is not modified.
@ -426,9 +165,7 @@ void av_fifo_drain(AVFifoBuffer *f, int size);
 *             than the used buffer size or the returned pointer will
 *             point outside to the buffer data.
 *             The used buffer size can be checked with av_fifo_size().
 * @deprecated use the new AVFifo-API with av_fifo_peek() or av_fifo_peek_to_cb()
 */
 attribute_deprecated
 static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
 {
    uint8_t *ptr = f->rptr + offs;
@ -438,11 +175,5 @@ static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
        ptr = f->end - (f->buffer - ptr);
    return ptr;
 }
 #endif
 #endif
 /**
 * @}
 */
 #endif /* AVUTIL_FIFO_H */
--- a/output/include/arm64-v8a/libavutil/file.h
+++ b/output/include/arm64-v8a/libavutil/file.h
@ -19,11 +19,9 @@
 #ifndef AVUTIL_FILE_H
 #define AVUTIL_FILE_H
 #include <stddef.h>
 #include <stdint.h>
-#include "version.h"
+#include "avutil.h"
 #include "attributes.h"
 /**
 * @file
@ -35,13 +33,8 @@
 * allocated buffer or map it with mmap() when available.
 * In case of success set *bufptr to the read or mmapped buffer, and
 * *size to the size in bytes of the buffer in *bufptr.
 * Unlike mmap this function succeeds with zero sized files, in this
 * case *bufptr will be set to NULL and *size will be set to 0.
 * The returned buffer must be released with av_file_unmap().
 *
 * @param filename path to the file
 * @param[out] bufptr pointee is set to the mapped or allocated buffer
 * @param[out] size pointee is set to the size in bytes of the buffer
 * @param log_offset loglevel offset used for logging
 * @param log_ctx context used for logging
 * @return a non negative number in case of success, a negative value
@ -54,13 +47,11 @@ int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
 /**
 * Unmap or free the buffer bufptr created by av_file_map().
 *
 * @param bufptr the buffer previously created with av_file_map()
 * @param size size in bytes of bufptr, must be the same as returned
 * by av_file_map()
 */
 void av_file_unmap(uint8_t *bufptr, size_t size);
 #if FF_API_AV_FOPEN_UTF8
 /**
 * Wrapper to work around the lack of mkstemp() on mingw.
 * Also, tries to create file in /tmp first, if possible.
@ -73,8 +64,6 @@ void av_file_unmap(uint8_t *bufptr, size_t size);
 *       libraries and could interfere with the calling application.
 * @deprecated as fd numbers cannot be passed saftely between libs on some platforms
 */
 attribute_deprecated
 int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx);
 #endif
 #endif /* AVUTIL_FILE_H */
--- a/output/include/arm64-v8a/libavutil/film_grain_params.h
+++ b/output/include/arm64-v8a/libavutil/film_grain_params.h
@ -1,260 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_FILM_GRAIN_PARAMS_H
 #define AVUTIL_FILM_GRAIN_PARAMS_H
 #include "frame.h"
 enum AVFilmGrainParamsType {
    AV_FILM_GRAIN_PARAMS_NONE = 0,
    /**
     * The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
     */
    AV_FILM_GRAIN_PARAMS_AV1,
    /**
     * The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
     */
    AV_FILM_GRAIN_PARAMS_H274,
 };
 /**
 * This structure describes how to handle film grain synthesis for AOM codecs.
 *
 * @note The struct must be allocated as part of AVFilmGrainParams using
 *       av_film_grain_params_alloc(). Its size is not a part of the public ABI.
 */
 typedef struct AVFilmGrainAOMParams {
    /**
     * Number of points, and the scale and value for each point of the
     * piecewise linear scaling function for the uma plane.
     */
    int num_y_points;
    uint8_t y_points[14][2 /* value, scaling */];
    /**
     * Signals whether to derive the chroma scaling function from the luma.
     * Not equivalent to copying the luma values and scales.
     */
    int chroma_scaling_from_luma;
    /**
     * If chroma_scaling_from_luma is set to 0, signals the chroma scaling
     * function parameters.
     */
    int num_uv_points[2 /* cb, cr */];
    uint8_t uv_points[2 /* cb, cr */][10][2 /* value, scaling */];
    /**
     * Specifies the shift applied to the chroma components. For AV1, its within
     * [8; 11] and determines the range and quantization of the film grain.
     */
    int scaling_shift;
    /**
     * Specifies the auto-regression lag.
     */
    int ar_coeff_lag;
    /**
     * Luma auto-regression coefficients. The number of coefficients is given by
     * 2 * ar_coeff_lag * (ar_coeff_lag + 1).
     */
    int8_t ar_coeffs_y[24];
    /**
     * Chroma auto-regression coefficients. The number of coefficients is given by
     * 2 * ar_coeff_lag * (ar_coeff_lag + 1) + !!num_y_points.
     */
    int8_t ar_coeffs_uv[2 /* cb, cr */][25];
    /**
     * Specifies the range of the auto-regressive coefficients. Values of 6,
     * 7, 8 and so on represent a range of [-2, 2), [-1, 1), [-0.5, 0.5) and
     * so on. For AV1 must be between 6 and 9.
     */
    int ar_coeff_shift;
    /**
     * Signals the down shift applied to the generated gaussian numbers during
     * synthesis.
     */
    int grain_scale_shift;
    /**
     * Specifies the luma/chroma multipliers for the index to the component
     * scaling function.
     */
    int uv_mult[2 /* cb, cr */];
    int uv_mult_luma[2 /* cb, cr */];
    /**
     * Offset used for component scaling function. For AV1 its a 9-bit value
     * with a range [-256, 255]
     */
    int uv_offset[2 /* cb, cr */];
    /**
     * Signals whether to overlap film grain blocks.
     */
    int overlap_flag;
    /**
     * Signals to clip to limited color levels after film grain application.
     */
    int limit_output_range;
 } AVFilmGrainAOMParams;
 /**
 * This structure describes how to handle film grain synthesis for codecs using
 * the ITU-T H.274 Versatile suplemental enhancement information message.
 *
 * @note The struct must be allocated as part of AVFilmGrainParams using
 *       av_film_grain_params_alloc(). Its size is not a part of the public ABI.
 */
 typedef struct AVFilmGrainH274Params {
    /**
     * Specifies the film grain simulation mode.
     * 0 = Frequency filtering, 1 = Auto-regression
     */
    int model_id;
    /**
     * Specifies the bit depth used for the luma component.
     */
    int bit_depth_luma;
    /**
     * Specifies the bit depth used for the chroma components.
     */
    int bit_depth_chroma;
    enum AVColorRange                  color_range;
    enum AVColorPrimaries              color_primaries;
    enum AVColorTransferCharacteristic color_trc;
    enum AVColorSpace                  color_space;
    /**
     * Specifies the blending mode used to blend the simulated film grain
     * with the decoded images.
     *
     * 0 = Additive, 1 = Multiplicative
     */
    int blending_mode_id;
    /**
     * Specifies a scale factor used in the film grain characterization equations.
     */
    int log2_scale_factor;
    /**
     * Indicates if the modelling of film grain for a given component is present.
     */
    int component_model_present[3 /* y, cb, cr */];
    /**
     * Specifies the number of intensity intervals for which a specific set of
     * model values has been estimated, with a range of [1, 256].
     */
    uint16_t num_intensity_intervals[3 /* y, cb, cr */];
    /**
     * Specifies the number of model values present for each intensity interval
     * in which the film grain has been modelled, with a range of [1, 6].
     */
    uint8_t num_model_values[3 /* y, cb, cr */];
    /**
     * Specifies the lower ounds of each intensity interval for whichthe set of
     * model values applies for the component.
     */
    uint8_t intensity_interval_lower_bound[3 /* y, cb, cr */][256 /* intensity interval */];
    /**
     * Specifies the upper bound of each intensity interval for which the set of
     * model values applies for the component.
     */
    uint8_t intensity_interval_upper_bound[3 /* y, cb, cr */][256 /* intensity interval */];
    /**
     * Specifies the model values for the component for each intensity interval.
     * - When model_id == 0, the following applies:
     *     For comp_model_value[y], the range of values is [0, 2^bit_depth_luma - 1]
     *     For comp_model_value[cb..cr], the range of values is [0, 2^bit_depth_chroma - 1]
     * - Otherwise, the following applies:
     *     For comp_model_value[y], the range of values is [-2^(bit_depth_luma - 1), 2^(bit_depth_luma - 1) - 1]
     *     For comp_model_value[cb..cr], the range of values is [-2^(bit_depth_chroma - 1), 2^(bit_depth_chroma - 1) - 1]
     */
    int16_t comp_model_value[3 /* y, cb, cr */][256 /* intensity interval */][6 /* model value */];
 } AVFilmGrainH274Params;
 /**
 * This structure describes how to handle film grain synthesis in video
 * for specific codecs. Must be present on every frame where film grain is
 * meant to be synthesised for correct presentation.
 *
 * @note The struct must be allocated with av_film_grain_params_alloc() and
 *       its size is not a part of the public ABI.
 */
 typedef struct AVFilmGrainParams {
    /**
     * Specifies the codec for which this structure is valid.
     */
    enum AVFilmGrainParamsType type;
    /**
     * Seed to use for the synthesis process, if the codec allows for it.
     *
     * @note For H.264, this refers to `pic_offset` as defined in
     *       SMPTE RDD 5-2006.
     */
    uint64_t seed;
    /**
     * Additional fields may be added both here and in any structure included.
     * If a codec's film grain structure differs slightly over another
     * codec's, fields within may change meaning depending on the type.
     */
    union {
        AVFilmGrainAOMParams aom;
        AVFilmGrainH274Params h274;
    } codec;
 } AVFilmGrainParams;
 /**
 * Allocate an AVFilmGrainParams structure and set its fields to
 * default values. The resulting struct can be freed using av_freep().
 * If size is not NULL it will be set to the number of bytes allocated.
 *
 * @return An AVFilmGrainParams filled with default values or NULL
 *         on failure.
 */
 AVFilmGrainParams *av_film_grain_params_alloc(size_t *size);
 /**
 * Allocate a complete AVFilmGrainParams and add it to the frame.
 *
 * @param frame The frame which side data is added to.
 *
 * @return The AVFilmGrainParams structure to be filled by caller.
 */
 AVFilmGrainParams *av_film_grain_params_create_side_data(AVFrame *frame);
 #endif /* AVUTIL_FILM_GRAIN_PARAMS_H */
--- a/output/include/arm64-v8a/libavutil/frame.h
+++ b/output/include/arm64-v8a/libavutil/frame.h
@ -30,7 +30,6 @@
 #include "avutil.h"
 #include "buffer.h"
 #include "channel_layout.h"
 #include "dict.h"
 #include "rational.h"
 #include "samplefmt.h"
@ -142,78 +141,6 @@ enum AVFrameSideDataType {
     * metadata key entry "name".
     */
    AV_FRAME_DATA_ICC_PROFILE,
    /**
     * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
     * where the first uint32_t describes how many (1-3) of the other timecodes are used.
     * The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
     * function in libavutil/timecode.h.
     */
    AV_FRAME_DATA_S12M_TIMECODE,
    /**
     * HDR dynamic metadata associated with a video frame. The payload is
     * an AVDynamicHDRPlus type and contains information for color
     * volume transform - application 4 of SMPTE 2094-40:2016 standard.
     */
    AV_FRAME_DATA_DYNAMIC_HDR_PLUS,
    /**
     * Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of
     * array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size.
     */
    AV_FRAME_DATA_REGIONS_OF_INTEREST,
    /**
     * Encoding parameters for a video frame, as described by AVVideoEncParams.
     */
    AV_FRAME_DATA_VIDEO_ENC_PARAMS,
    /**
     * User data unregistered metadata associated with a video frame.
     * This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose
     * The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of
     * uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte.
     */
    AV_FRAME_DATA_SEI_UNREGISTERED,
    /**
     * Film grain parameters for a frame, described by AVFilmGrainParams.
     * Must be present for every frame which should have film grain applied.
     */
    AV_FRAME_DATA_FILM_GRAIN_PARAMS,
    /**
     * Bounding boxes for object detection and classification,
     * as described by AVDetectionBBoxHeader.
     */
    AV_FRAME_DATA_DETECTION_BBOXES,
    /**
     * Dolby Vision RPU raw data, suitable for passing to x265
     * or other libraries. Array of uint8_t, with NAL emulation
     * bytes intact.
     */
    AV_FRAME_DATA_DOVI_RPU_BUFFER,
    /**
     * Parsed Dolby Vision metadata, suitable for passing to a software
     * implementation. The payload is the AVDOVIMetadata struct defined in
     * libavutil/dovi_meta.h.
     */
    AV_FRAME_DATA_DOVI_METADATA,
    /**
     * HDR Vivid dynamic metadata associated with a video frame. The payload is
     * an AVDynamicHDRVivid type and contains information for color
     * volume transform - CUVA 005.1-2021.
     */
    AV_FRAME_DATA_DYNAMIC_HDR_VIVID,
    /**
     * Ambient viewing environment metadata, as defined by H.274.
     */
    AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT,
 };
 enum AVActiveFormatDescription {
@ -236,67 +163,11 @@ enum AVActiveFormatDescription {
 typedef struct AVFrameSideData {
    enum AVFrameSideDataType type;
    uint8_t *data;
-    size_t   size;
+    int      size;
    AVDictionary *metadata;
    AVBufferRef *buf;
 } AVFrameSideData;
 /**
 * Structure describing a single Region Of Interest.
 *
 * When multiple regions are defined in a single side-data block, they
 * should be ordered from most to least important - some encoders are only
 * capable of supporting a limited number of distinct regions, so will have
 * to truncate the list.
 *
 * When overlapping regions are defined, the first region containing a given
 * area of the frame applies.
 */
 typedef struct AVRegionOfInterest {
    /**
     * Must be set to the size of this data structure (that is,
     * sizeof(AVRegionOfInterest)).
     */
    uint32_t self_size;
    /**
     * Distance in pixels from the top edge of the frame to the top and
     * bottom edges and from the left edge of the frame to the left and
     * right edges of the rectangle defining this region of interest.
     *
     * The constraints on a region are encoder dependent, so the region
     * actually affected may be slightly larger for alignment or other
     * reasons.
     */
    int top;
    int bottom;
    int left;
    int right;
    /**
     * Quantisation offset.
     *
     * Must be in the range -1 to +1.  A value of zero indicates no quality
     * change.  A negative value asks for better quality (less quantisation),
     * while a positive value asks for worse quality (greater quantisation).
     *
     * The range is calibrated so that the extreme values indicate the
     * largest possible offset - if the rest of the frame is encoded with the
     * worst possible quality, an offset of -1 indicates that this region
     * should be encoded with the best possible quality anyway.  Intermediate
     * values are then interpolated in some codec-dependent way.
     *
     * For example, in 10-bit H.264 the quantisation parameter varies between
     * -12 and 51.  A typical qoffset value of -1/10 therefore indicates that
     * this region should be encoded with a QP around one-tenth of the full
     * range better than the rest of the frame.  So, if most of the frame
     * were to be encoded with a QP of around 30, this region would get a QP
     * of around 24 (an offset of approximately -1/10 * (51 - -12) = -6.3).
     * An extreme value of -1 would indicate that this region should be
     * encoded with the best possible quality regardless of the treatment of
     * the rest of the frame - that is, should be encoded at a QP of -12.
     */
    AVRational qoffset;
 } AVRegionOfInterest;
 /**
 * This structure describes decoded (raw) audio or video data.
 *
@ -331,32 +202,21 @@ typedef struct AVFrame {
 #define AV_NUM_DATA_POINTERS 8
    /**
     * pointer to the picture/channel planes.
-     * This might be different from the first allocated byte. For video,
+     * This might be different from the first allocated byte
     * it could even point to the end of the image data.
     *
     * All pointers in data and extended_data must point into one of the
     * AVBufferRef in buf or extended_buf.
     *
     * Some decoders access areas outside 0,0 - width,height, please
     * see avcodec_align_dimensions2(). Some filters and swscale can read
     * up to 16 bytes beyond the planes, if these filters are to be used,
     * then 16 extra bytes must be allocated.
     *
-     * NOTE: Pointers not needed by the format MUST be set to NULL.
+     * NOTE: Except for hwaccel formats, pointers not needed by the format
-     *
+     * MUST be set to NULL.
     * @attention In case of video, the data[] pointers can point to the
     * end of image data in order to reverse line order, when used in
     * combination with negative values in the linesize[] array.
     */
    uint8_t *data[AV_NUM_DATA_POINTERS];
    /**
-     * For video, a positive or negative value, which is typically indicating
+     * For video, size in bytes of each picture line.
-     * the size in bytes of each picture line, but it can also be:
+     * For audio, size in bytes of each plane.
     * - the negative byte size of lines for vertical flipping
     *   (with data[n] pointing to the end of the data
     * - a positive or negative multiple of the byte size as for accessing
     *   even and odd fields of a frame (possibly flipped)
     *
     * For audio, only linesize[0] may be set. For planar audio, each channel
     * plane must be the same size.
@ -368,9 +228,6 @@ typedef struct AVFrame {
     *
     * @note The linesize may be larger than the size of usable data -- there
     * may be extra padding present for performance reasons.
     *
     * @attention In case of video, line size values can be negative to achieve
     * a vertically inverted iteration over image lines.
     */
    int linesize[AV_NUM_DATA_POINTERS];
@ -436,6 +293,15 @@ typedef struct AVFrame {
     */
    int64_t pts;
 #if FF_API_PKT_PTS
    /**
     * PTS copied from the AVPacket that was decoded to produce this frame.
     * @deprecated use the pts field instead
     */
    attribute_deprecated
    int64_t pkt_pts;
 #endif
    /**
     * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
     * This is also the Presentation time of this AVFrame calculated from
@ -443,26 +309,14 @@ typedef struct AVFrame {
     */
    int64_t pkt_dts;
    /**
     * Time base for the timestamps in this frame.
     * In the future, this field may be set on frames output by decoders or
     * filters, but its value will be by default ignored on input to encoders
     * or filters.
     */
    AVRational time_base;
 #if FF_API_FRAME_PICTURE_NUMBER
    /**
     * picture number in bitstream order
     */
    attribute_deprecated
    int coded_picture_number;
    /**
     * picture number in display order
     */
    attribute_deprecated
    int display_picture_number;
 #endif
    /**
     * quality (between 1 (good) and FF_LAMBDA_MAX (bad))
@ -474,6 +328,14 @@ typedef struct AVFrame {
     */
    void *opaque;
 #if FF_API_ERROR_FRAME
    /**
     * @deprecated unused
     */
    attribute_deprecated
    uint64_t error[AV_NUM_DATA_POINTERS];
 #endif
    /**
     * When decoding, this signals how much the picture must be delayed.
     * extra_delay = repeat_pict / (2*fps)
@ -495,7 +357,6 @@ typedef struct AVFrame {
     */
    int palette_has_changed;
 #if FF_API_REORDERED_OPAQUE
    /**
     * reordered opaque 64 bits (generally an integer or a double precision float
     * PTS but can be anything).
@ -503,32 +364,25 @@ typedef struct AVFrame {
     * that time,
     * the decoder reorders values as needed and sets AVFrame.reordered_opaque
     * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque
-     *
+     * @deprecated in favor of pkt_pts
     * @deprecated Use AV_CODEC_FLAG_COPY_OPAQUE instead
     */
    attribute_deprecated
    int64_t reordered_opaque;
 #endif
    /**
     * Sample rate of the audio data.
     */
    int sample_rate;
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * Channel layout of the audio data.
     * @deprecated use ch_layout instead
     */
    attribute_deprecated
    uint64_t channel_layout;
 #endif
    /**
-     * AVBuffer references backing the data for this frame. All the pointers in
+     * AVBuffer references backing the data for this frame. If all elements of
-     * data and extended_data must point inside one of the buffers in buf or
+     * this array are NULL, then this frame is not reference counted. This array
-     * extended_buf. This array must be filled contiguously -- if buf[i] is
+     * must be filled contiguously -- if buf[i] is non-NULL then buf[j] must
-     * non-NULL then buf[j] must also be non-NULL for all j < i.
+     * also be non-NULL for all j < i.
     *
     * There may be at most one AVBuffer per data plane, so for video this array
     * always contains all the references. For planar audio with more than
@ -618,18 +472,13 @@ typedef struct AVFrame {
     */
    int64_t pkt_pos;
 #if FF_API_PKT_DURATION
    /**
     * duration of the corresponding packet, expressed in
     * AVStream->time_base units, 0 if unknown.
     * - encoding: unused
     * - decoding: Read by user.
     *
     * @deprecated use duration instead
     */
    attribute_deprecated
    int64_t pkt_duration;
 #endif
    /**
     * metadata.
@ -648,19 +497,13 @@ typedef struct AVFrame {
    int decode_error_flags;
 #define FF_DECODE_ERROR_INVALID_BITSTREAM   1
 #define FF_DECODE_ERROR_MISSING_REFERENCE   2
 #define FF_DECODE_ERROR_CONCEALMENT_ACTIVE  4
 #define FF_DECODE_ERROR_DECODE_SLICES       8
 #if FF_API_OLD_CHANNEL_LAYOUT
    /**
     * number of audio channels, only used for audio.
     * - encoding: unused
     * - decoding: Read by user.
     * @deprecated use ch_layout instead
     */
    attribute_deprecated
    int channels;
 #endif
    /**
     * size of the corresponding packet containing the compressed
@ -671,6 +514,23 @@ typedef struct AVFrame {
     */
    int pkt_size;
 #if FF_API_FRAME_QP
    /**
     * QP table
     */
    attribute_deprecated
    int8_t *qscale_table;
    /**
     * QP store stride
     */
    attribute_deprecated
    int qstride;
    attribute_deprecated
    int qscale_type;
    AVBufferRef *qp_table_buf;
 #endif
    /**
     * For hwaccel-format frames, this should be a reference to the
     * AVHWFramesContext describing the frame.
@ -703,31 +563,45 @@ typedef struct AVFrame {
    /**
     * @}
     */
 } AVFrame;
-    /**
+/**
-     * AVBufferRef for internal use by a single libav* library.
+ * Accessors for some AVFrame fields. These used to be provided for ABI
-     * Must not be used to transfer data between libraries.
+ * compatibility, and do not need to be used anymore.
-     * Has to be NULL when ownership of the frame leaves the respective library.
+ */
-     *
+int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
-     * Code outside the FFmpeg libs should never check or change the contents of the buffer ref.
+void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
-     *
+int64_t av_frame_get_pkt_duration         (const AVFrame *frame);
-     * FFmpeg calls av_buffer_unref() on it when the frame is unreferenced.
+void    av_frame_set_pkt_duration         (AVFrame *frame, int64_t val);
-     * av_frame_copy_props() calls create a new reference with av_buffer_ref()
+int64_t av_frame_get_pkt_pos              (const AVFrame *frame);
-     * for the target frame's private_ref field.
+void    av_frame_set_pkt_pos              (AVFrame *frame, int64_t val);
-     */
+int64_t av_frame_get_channel_layout       (const AVFrame *frame);
-    AVBufferRef *private_ref;
+void    av_frame_set_channel_layout       (AVFrame *frame, int64_t val);
-
+int     av_frame_get_channels             (const AVFrame *frame);
-    /**
+void    av_frame_set_channels             (AVFrame *frame, int     val);
-     * Channel layout of the audio data.
+int     av_frame_get_sample_rate          (const AVFrame *frame);
-     */
+void    av_frame_set_sample_rate          (AVFrame *frame, int     val);
-    AVChannelLayout ch_layout;
+AVDictionary *av_frame_get_metadata       (const AVFrame *frame);
 void          av_frame_set_metadata       (AVFrame *frame, AVDictionary *val);
 int     av_frame_get_decode_error_flags   (const AVFrame *frame);
 void    av_frame_set_decode_error_flags   (AVFrame *frame, int     val);
 int     av_frame_get_pkt_size(const AVFrame *frame);
 void    av_frame_set_pkt_size(AVFrame *frame, int val);
 AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame);
 #if FF_API_FRAME_QP
 int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
 int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
 #endif
 enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
 void    av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
 enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
 void    av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
-    /**
+/**
-     * Duration of the frame, in the same units as pts. 0 if unknown.
+ * Get the name of a colorspace.
 * @return a static string identifying the colorspace; can be NULL.
 */
-    int64_t duration;
+const char *av_get_colorspace_name(enum AVColorSpace val);
 } AVFrame;
 /**
 * Allocate an AVFrame and set its fields to default values.  The resulting
@ -796,7 +670,7 @@ void av_frame_move_ref(AVFrame *dst, AVFrame *src);
 * The following fields must be set on frame before calling this function:
 * - format (pixel format for video, sample format for audio)
 * - width and height for video
- * - nb_samples and ch_layout for audio
+ * - nb_samples and channel_layout for audio
 *
 * This function will fill AVFrame.data and AVFrame.buf arrays and, if
 * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
@ -833,8 +707,7 @@ int av_frame_is_writable(AVFrame *frame);
 * Ensure that the frame data is writable, avoiding data copy if possible.
 *
 * Do nothing if the frame is writable, allocate new buffers and copy the data
- * if it is not. Non-refcounted frames behave as non-writable, i.e. a copy
+ * if it is not.
 * is always made.
 *
 * @return 0 on success, a negative AVERROR on error.
 *
@ -869,7 +742,6 @@ int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
 /**
 * Get the buffer reference a given data plane is stored in.
 *
 * @param frame the frame to get the plane's buffer from
 * @param plane index of the data plane of interest in frame->extended_data.
 *
 * @return the buffer reference that contains the plane or NULL if the input
@ -888,23 +760,7 @@ AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
 */
 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
                                        enum AVFrameSideDataType type,
-                                        size_t size);
+                                        int size);
 /**
 * Add a new side data to a frame from an existing AVBufferRef
 *
 * @param frame a frame to which the side data should be added
 * @param type  the type of the added side data
 * @param buf   an AVBufferRef to add as side data. The ownership of
 *              the reference is transferred to the frame.
 *
 * @return newly added side data on success, NULL on error. On failure
 *         the frame is unchanged and the AVBufferRef remains owned by
 *         the caller.
 */
 AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
                                                 enum AVFrameSideDataType type,
                                                 AVBufferRef *buf);
 /**
 * @return a pointer to the side data of a given type on success, NULL if there
@ -914,7 +770,8 @@ AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
                                        enum AVFrameSideDataType type);
 /**
- * Remove and free all side data instances of the given type.
+ * If side data of the supplied type exists in the frame, free it and remove it
 * from the frame.
 */
 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
--- a/output/include/arm64-v8a/libavutil/hash.h
+++ b/output/include/arm64-v8a/libavutil/hash.h
@ -27,7 +27,6 @@
 #ifndef AVUTIL_HASH_H
 #define AVUTIL_HASH_H
 #include <stddef.h>
 #include <stdint.h>
 /**
@ -180,7 +179,7 @@ void av_hash_init(struct AVHashContext *ctx);
 * @param[in]     src Data to be added to the hash context
 * @param[in]     len Size of the additional data
 */
-void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, size_t len);
+void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len);
 /**
 * Finalize a hash context and compute the actual hash value.
--- a/output/include/arm64-v8a/libavutil/hdr_dynamic_metadata.h
+++ b/output/include/arm64-v8a/libavutil/hdr_dynamic_metadata.h
@ -1,343 +0,0 @@
 /*
 * Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_HDR_DYNAMIC_METADATA_H
 #define AVUTIL_HDR_DYNAMIC_METADATA_H
 #include "frame.h"
 #include "rational.h"
 /**
 * Option for overlapping elliptical pixel selectors in an image.
 */
 enum AVHDRPlusOverlapProcessOption {
    AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING = 0,
    AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING = 1,
 };
 /**
 * Represents the percentile at a specific percentage in
 * a distribution.
 */
 typedef struct AVHDRPlusPercentile {
    /**
     * The percentage value corresponding to a specific percentile linearized
     * RGB value in the processing window in the scene. The value shall be in
     * the range of 0 to100, inclusive.
     */
    uint8_t percentage;
    /**
     * The linearized maxRGB value at a specific percentile in the processing
     * window in the scene. The value shall be in the range of 0 to 1, inclusive
     * and in multiples of 0.00001.
     */
    AVRational percentile;
 } AVHDRPlusPercentile;
 /**
 * Color transform parameters at a processing window in a dynamic metadata for
 * SMPTE 2094-40.
 */
 typedef struct AVHDRPlusColorTransformParams {
    /**
     * The relative x coordinate of the top left pixel of the processing
     * window. The value shall be in the range of 0 and 1, inclusive and
     * in multiples of 1/(width of Picture - 1). The value 1 corresponds
     * to the absolute coordinate of width of Picture - 1. The value for
     * first processing window shall be 0.
     */
    AVRational window_upper_left_corner_x;
    /**
     * The relative y coordinate of the top left pixel of the processing
     * window. The value shall be in the range of 0 and 1, inclusive and
     * in multiples of 1/(height of Picture - 1). The value 1 corresponds
     * to the absolute coordinate of height of Picture - 1. The value for
     * first processing window shall be 0.
     */
    AVRational window_upper_left_corner_y;
    /**
     * The relative x coordinate of the bottom right pixel of the processing
     * window. The value shall be in the range of 0 and 1, inclusive and
     * in multiples of 1/(width of Picture - 1). The value 1 corresponds
     * to the absolute coordinate of width of Picture - 1. The value for
     * first processing window shall be 1.
     */
    AVRational window_lower_right_corner_x;
    /**
     * The relative y coordinate of the bottom right pixel of the processing
     * window. The value shall be in the range of 0 and 1, inclusive and
     * in multiples of 1/(height of Picture - 1). The value 1 corresponds
     * to the absolute coordinate of height of Picture - 1. The value for
     * first processing window shall be 1.
     */
    AVRational window_lower_right_corner_y;
    /**
     * The x coordinate of the center position of the concentric internal and
     * external ellipses of the elliptical pixel selector in the processing
     * window. The value shall be in the range of 0 to (width of Picture - 1),
     * inclusive and in multiples of 1 pixel.
     */
    uint16_t center_of_ellipse_x;
    /**
     * The y coordinate of the center position of the concentric internal and
     * external ellipses of the elliptical pixel selector in the processing
     * window. The value shall be in the range of 0 to (height of Picture - 1),
     * inclusive and in multiples of 1 pixel.
     */
    uint16_t center_of_ellipse_y;
    /**
     * The clockwise rotation angle in degree of arc with respect to the
     * positive direction of the x-axis of the concentric internal and external
     * ellipses of the elliptical pixel selector in the processing window. The
     * value shall be in the range of 0 to 180, inclusive and in multiples of 1.
     */
    uint8_t rotation_angle;
    /**
     * The semi-major axis value of the internal ellipse of the elliptical pixel
     * selector in amount of pixels in the processing window. The value shall be
     * in the range of 1 to 65535, inclusive and in multiples of 1 pixel.
     */
    uint16_t semimajor_axis_internal_ellipse;
    /**
     * The semi-major axis value of the external ellipse of the elliptical pixel
     * selector in amount of pixels in the processing window. The value
     * shall not be less than semimajor_axis_internal_ellipse of the current
     * processing window. The value shall be in the range of 1 to 65535,
     * inclusive and in multiples of 1 pixel.
     */
    uint16_t semimajor_axis_external_ellipse;
    /**
     * The semi-minor axis value of the external ellipse of the elliptical pixel
     * selector in amount of pixels in the processing window. The value shall be
     * in the range of 1 to 65535, inclusive and in multiples of 1 pixel.
     */
    uint16_t semiminor_axis_external_ellipse;
    /**
     * Overlap process option indicates one of the two methods of combining
     * rendered pixels in the processing window in an image with at least one
     * elliptical pixel selector. For overlapping elliptical pixel selectors
     * in an image, overlap_process_option shall have the same value.
     */
    enum AVHDRPlusOverlapProcessOption overlap_process_option;
    /**
     * The maximum of the color components of linearized RGB values in the
     * processing window in the scene. The values should be in the range of 0 to
     * 1, inclusive and in multiples of 0.00001. maxscl[ 0 ], maxscl[ 1 ], and
     * maxscl[ 2 ] are corresponding to R, G, B color components respectively.
     */
    AVRational maxscl[3];
    /**
     * The average of linearized maxRGB values in the processing window in the
     * scene. The value should be in the range of 0 to 1, inclusive and in
     * multiples of 0.00001.
     */
    AVRational average_maxrgb;
    /**
     * The number of linearized maxRGB values at given percentiles in the
     * processing window in the scene. The maximum value shall be 15.
     */
    uint8_t num_distribution_maxrgb_percentiles;
    /**
     * The linearized maxRGB values at given percentiles in the
     * processing window in the scene.
     */
    AVHDRPlusPercentile distribution_maxrgb[15];
    /**
     * The fraction of selected pixels in the image that contains the brightest
     * pixel in the scene. The value shall be in the range of 0 to 1, inclusive
     * and in multiples of 0.001.
     */
    AVRational fraction_bright_pixels;
    /**
     * This flag indicates that the metadata for the tone mapping function in
     * the processing window is present (for value of 1).
     */
    uint8_t tone_mapping_flag;
    /**
     * The x coordinate of the separation point between the linear part and the
     * curved part of the tone mapping function. The value shall be in the range
     * of 0 to 1, excluding 0 and in multiples of 1/4095.
     */
    AVRational knee_point_x;
    /**
     * The y coordinate of the separation point between the linear part and the
     * curved part of the tone mapping function. The value shall be in the range
     * of 0 to 1, excluding 0 and in multiples of 1/4095.
     */
    AVRational knee_point_y;
    /**
     * The number of the intermediate anchor parameters of the tone mapping
     * function in the processing window. The maximum value shall be 15.
     */
    uint8_t num_bezier_curve_anchors;
    /**
     * The intermediate anchor parameters of the tone mapping function in the
     * processing window in the scene. The values should be in the range of 0
     * to 1, inclusive and in multiples of 1/1023.
     */
    AVRational bezier_curve_anchors[15];
    /**
     * This flag shall be equal to 0 in bitstreams conforming to this version of
     * this Specification. Other values are reserved for future use.
     */
    uint8_t color_saturation_mapping_flag;
    /**
     * The color saturation gain in the processing window in the scene. The
     * value shall be in the range of 0 to 63/8, inclusive and in multiples of
     * 1/8. The default value shall be 1.
     */
    AVRational color_saturation_weight;
 } AVHDRPlusColorTransformParams;
 /**
 * This struct represents dynamic metadata for color volume transform -
 * application 4 of SMPTE 2094-40:2016 standard.
 *
 * To be used as payload of a AVFrameSideData or AVPacketSideData with the
 * appropriate type.
 *
 * @note The struct should be allocated with
 * av_dynamic_hdr_plus_alloc() and its size is not a part of
 * the public ABI.
 */
 typedef struct AVDynamicHDRPlus {
    /**
     * Country code by Rec. ITU-T T.35 Annex A. The value shall be 0xB5.
     */
    uint8_t itu_t_t35_country_code;
    /**
     * Application version in the application defining document in ST-2094
     * suite. The value shall be set to 0.
     */
    uint8_t application_version;
    /**
     * The number of processing windows. The value shall be in the range
     * of 1 to 3, inclusive.
     */
    uint8_t num_windows;
    /**
     * The color transform parameters for every processing window.
     */
    AVHDRPlusColorTransformParams params[3];
    /**
     * The nominal maximum display luminance of the targeted system display,
     * in units of 0.0001 candelas per square metre. The value shall be in
     * the range of 0 to 10000, inclusive.
     */
    AVRational targeted_system_display_maximum_luminance;
    /**
     * This flag shall be equal to 0 in bit streams conforming to this version
     * of this Specification. The value 1 is reserved for future use.
     */
    uint8_t targeted_system_display_actual_peak_luminance_flag;
    /**
     * The number of rows in the targeted system_display_actual_peak_luminance
     * array. The value shall be in the range of 2 to 25, inclusive.
     */
    uint8_t num_rows_targeted_system_display_actual_peak_luminance;
    /**
     * The number of columns in the
     * targeted_system_display_actual_peak_luminance array. The value shall be
     * in the range of 2 to 25, inclusive.
     */
    uint8_t num_cols_targeted_system_display_actual_peak_luminance;
    /**
     * The normalized actual peak luminance of the targeted system display. The
     * values should be in the range of 0 to 1, inclusive and in multiples of
     * 1/15.
     */
    AVRational targeted_system_display_actual_peak_luminance[25][25];
    /**
     * This flag shall be equal to 0 in bitstreams conforming to this version of
     * this Specification. The value 1 is reserved for future use.
     */
    uint8_t mastering_display_actual_peak_luminance_flag;
    /**
     * The number of rows in the mastering_display_actual_peak_luminance array.
     * The value shall be in the range of 2 to 25, inclusive.
     */
    uint8_t num_rows_mastering_display_actual_peak_luminance;
    /**
     * The number of columns in the mastering_display_actual_peak_luminance
     * array. The value shall be in the range of 2 to 25, inclusive.
     */
    uint8_t num_cols_mastering_display_actual_peak_luminance;
    /**
     * The normalized actual peak luminance of the mastering display used for
     * mastering the image essence. The values should be in the range of 0 to 1,
     * inclusive and in multiples of 1/15.
     */
    AVRational mastering_display_actual_peak_luminance[25][25];
 } AVDynamicHDRPlus;
 /**
 * Allocate an AVDynamicHDRPlus structure and set its fields to
 * default values. The resulting struct can be freed using av_freep().
 *
 * @return An AVDynamicHDRPlus filled with default values or NULL
 *         on failure.
 */
 AVDynamicHDRPlus *av_dynamic_hdr_plus_alloc(size_t *size);
 /**
 * Allocate a complete AVDynamicHDRPlus and add it to the frame.
 * @param frame The frame which side data is added to.
 *
 * @return The AVDynamicHDRPlus structure to be filled by caller or NULL
 *         on failure.
 */
 AVDynamicHDRPlus *av_dynamic_hdr_plus_create_side_data(AVFrame *frame);
 #endif /* AVUTIL_HDR_DYNAMIC_METADATA_H */
--- a/output/include/arm64-v8a/libavutil/hdr_dynamic_vivid_metadata.h
+++ b/output/include/arm64-v8a/libavutil/hdr_dynamic_vivid_metadata.h
@ -1,285 +0,0 @@
 /*
 * Copyright (c) 2021 Limin Wang <lance.lmwang at gmail.com>
 *
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H
 #define AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H
 #include "frame.h"
 #include "rational.h"
 /**
 * Color tone mapping parameters at a processing window in a dynamic metadata for
 * CUVA 005.1:2021.
 */
 typedef struct AVHDRVividColorToneMappingParams {
    /**
     * The nominal maximum display luminance of the targeted system display,
     * in multiples of 1.0/4095 candelas per square metre. The value shall be in
     * the range of 0.0 to 1.0, inclusive.
     */
    AVRational targeted_system_display_maximum_luminance;
    /**
     * This flag indicates that transfer the base paramter(for value of 1)
     */
    int base_enable_flag;
    /**
     * base_param_m_p in the base parameter,
     * in multiples of 1.0/16383. The value shall be in
     * the range of 0.0 to 1.0, inclusive.
     */
    AVRational base_param_m_p;
    /**
     * base_param_m_m in the base parameter,
     * in multiples of 1.0/10. The value shall be in
     * the range of 0.0 to 6.3, inclusive.
     */
    AVRational base_param_m_m;
    /**
     * base_param_m_a in the base parameter,
     * in multiples of 1.0/1023. The value shall be in
     * the range of 0.0 to 1.0 inclusive.
     */
    AVRational base_param_m_a;
    /**
     * base_param_m_b in the base parameter,
     * in multiples of 1/1023. The value shall be in
     * the range of 0.0 to 1.0, inclusive.
     */
    AVRational base_param_m_b;
    /**
     * base_param_m_n in the base parameter,
     * in multiples of 1.0/10. The value shall be in
     * the range of 0.0 to 6.3, inclusive.
     */
    AVRational base_param_m_n;
    /**
     * indicates k1_0 in the base parameter,
     * base_param_k1 <= 1: k1_0 = base_param_k1
     * base_param_k1 > 1: reserved
     */
    int base_param_k1;
    /**
     * indicates k2_0 in the base parameter,
     * base_param_k2 <= 1: k2_0 = base_param_k2
     * base_param_k2 > 1: reserved
     */
    int base_param_k2;
    /**
     * indicates k3_0 in the base parameter,
     * base_param_k3 == 1: k3_0 = base_param_k3
     * base_param_k3 == 2: k3_0 = maximum_maxrgb
     * base_param_k3 > 2: reserved
     */
    int base_param_k3;
    /**
     * This flag indicates that delta mode of base paramter(for value of 1)
     */
    int base_param_Delta_enable_mode;
    /**
     * base_param_Delta in the base parameter,
     * in multiples of 1.0/127. The value shall be in
     * the range of 0.0 to 1.0, inclusive.
     */
    AVRational base_param_Delta;
    /**
     * indicates 3Spline_enable_flag in the base parameter,
     * This flag indicates that transfer three Spline of base paramter(for value of 1)
     */
    int three_Spline_enable_flag;
    /**
     * The number of three Spline. The value shall be in the range
     * of 1 to 2, inclusive.
     */
    int three_Spline_num;
    /**
     * The mode of three Spline. the value shall be in the range
     * of 0 to 3, inclusive.
     */
    int three_Spline_TH_mode;
    /**
     * three_Spline_TH_enable_MB is in the range of 0.0 to 1.0, inclusive
     * and in multiples of 1.0/255.
     *
     */
    AVRational three_Spline_TH_enable_MB;
    /**
     * 3Spline_TH_enable of three Spline.
     * The value shall be in the range of 0.0 to 1.0, inclusive.
     * and in multiples of 1.0/4095.
     */
    AVRational three_Spline_TH_enable;
    /**
     * 3Spline_TH_Delta1 of three Spline.
     * The value shall be in the range of 0.0 to 0.25, inclusive,
     * and in multiples of 0.25/1023.
     */
    AVRational three_Spline_TH_Delta1;
    /**
     * 3Spline_TH_Delta2 of three Spline.
     * The value shall be in the range of 0.0 to 0.25, inclusive,
     * and in multiples of 0.25/1023.
     */
    AVRational three_Spline_TH_Delta2;
    /**
     * 3Spline_enable_Strength of three Spline.
     * The value shall be in the range of 0.0 to 1.0, inclusive,
     * and in multiples of 1.0/255.
     */
    AVRational three_Spline_enable_Strength;
 } AVHDRVividColorToneMappingParams;
 /**
 * Color transform parameters at a processing window in a dynamic metadata for
 * CUVA 005.1:2021.
 */
 typedef struct AVHDRVividColorTransformParams {
    /**
     * Indicates the minimum brightness of the displayed content.
     * The values should be in the range of 0.0 to 1.0,
     * inclusive and in multiples of 1/4095.
     */
    AVRational minimum_maxrgb;
    /**
     * Indicates the average brightness of the displayed content.
     * The values should be in the range of 0.0 to 1.0,
     * inclusive and in multiples of 1/4095.
     */
    AVRational average_maxrgb;
    /**
     * Indicates the variance brightness of the displayed content.
     * The values should be in the range of 0.0 to 1.0,
     * inclusive and in multiples of 1/4095.
     */
    AVRational variance_maxrgb;
    /**
     * Indicates the maximum brightness of the displayed content.
     * The values should be in the range of 0.0 to 1.0, inclusive
     * and in multiples of 1/4095.
     */
    AVRational maximum_maxrgb;
    /**
     * This flag indicates that the metadata for the tone mapping function in
     * the processing window is present (for value of 1).
     */
    int tone_mapping_mode_flag;
    /**
     * The number of tone mapping param. The value shall be in the range
     * of 1 to 2, inclusive.
     */
    int tone_mapping_param_num;
    /**
     * The color tone mapping parameters.
     */
    AVHDRVividColorToneMappingParams tm_params[2];
    /**
     * This flag indicates that the metadata for the color saturation mapping in
     * the processing window is present (for value of 1).
     */
    int color_saturation_mapping_flag;
    /**
     * The number of color saturation param. The value shall be in the range
     * of 0 to 7, inclusive.
     */
    int color_saturation_num;
    /**
     * Indicates the color correction strength parameter.
     * The values should be in the range of 0.0 to 2.0, inclusive
     * and in multiples of 1/128.
     */
    AVRational color_saturation_gain[8];
 } AVHDRVividColorTransformParams;
 /**
 * This struct represents dynamic metadata for color volume transform -
 * CUVA 005.1:2021 standard
 *
 * To be used as payload of a AVFrameSideData or AVPacketSideData with the
 * appropriate type.
 *
 * @note The struct should be allocated with
 * av_dynamic_hdr_vivid_alloc() and its size is not a part of
 * the public ABI.
 */
 typedef struct AVDynamicHDRVivid {
    /**
     * The system start code. The value shall be set to 0x01.
     */
    uint8_t system_start_code;
    /**
     * The number of processing windows. The value shall be set to 0x01
     * if the system_start_code is 0x01.
     */
    uint8_t num_windows;
    /**
     * The color transform parameters for every processing window.
     */
    AVHDRVividColorTransformParams params[3];
 } AVDynamicHDRVivid;
 /**
 * Allocate an AVDynamicHDRVivid structure and set its fields to
 * default values. The resulting struct can be freed using av_freep().
 *
 * @return An AVDynamicHDRVivid filled with default values or NULL
 *         on failure.
 */
 AVDynamicHDRVivid *av_dynamic_hdr_vivid_alloc(size_t *size);
 /**
 * Allocate a complete AVDynamicHDRVivid and add it to the frame.
 * @param frame The frame which side data is added to.
 *
 * @return The AVDynamicHDRVivid structure to be filled by caller or NULL
 *         on failure.
 */
 AVDynamicHDRVivid *av_dynamic_hdr_vivid_create_side_data(AVFrame *frame);
 #endif /* AVUTIL_HDR_DYNAMIC_VIVID_METADATA_H */
--- a/output/include/arm64-v8a/libavutil/hmac.h
+++ b/output/include/arm64-v8a/libavutil/hmac.h
@ -23,6 +23,7 @@
 #include <stdint.h>
 #include "version.h"
 /**
 * @defgroup lavu_hmac HMAC
 * @ingroup lavu_crypto
@ -34,7 +35,7 @@ enum AVHMACType {
    AV_HMAC_SHA1,
    AV_HMAC_SHA224,
    AV_HMAC_SHA256,
-    AV_HMAC_SHA384,
+    AV_HMAC_SHA384 = 12,
    AV_HMAC_SHA512,
 };
--- a/output/include/arm64-v8a/libavutil/hwcontext.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext.h
@ -25,18 +25,15 @@
 #include "pixfmt.h"
 enum AVHWDeviceType {
    AV_HWDEVICE_TYPE_NONE,
    AV_HWDEVICE_TYPE_VDPAU,
    AV_HWDEVICE_TYPE_CUDA,
    AV_HWDEVICE_TYPE_VAAPI,
    AV_HWDEVICE_TYPE_DXVA2,
    AV_HWDEVICE_TYPE_QSV,
    AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
    AV_HWDEVICE_TYPE_NONE,
    AV_HWDEVICE_TYPE_D3D11VA,
    AV_HWDEVICE_TYPE_DRM,
    AV_HWDEVICE_TYPE_OPENCL,
    AV_HWDEVICE_TYPE_MEDIACODEC,
    AV_HWDEVICE_TYPE_VULKAN,
 };
 typedef struct AVHWDeviceInternal AVHWDeviceInternal;
@ -249,7 +246,7 @@ const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
 /**
 * Iterate over supported device types.
 *
- * @param prev AV_HWDEVICE_TYPE_NONE initially, then the previous type
+ * @param type AV_HWDEVICE_TYPE_NONE initially, then the previous type
 *             returned by this function in subsequent iterations.
 * @return The next usable device type from enum AVHWDeviceType, or
 *         AV_HWDEVICE_TYPE_NONE if there are no more.
@ -328,26 +325,6 @@ int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
                                   enum AVHWDeviceType type,
                                   AVBufferRef *src_ctx, int flags);
 /**
 * Create a new device of the specified type from an existing device.
 *
 * This function performs the same action as av_hwdevice_ctx_create_derived,
 * however, it is able to set options for the new device to be derived.
 *
 * @param dst_ctx On success, a reference to the newly-created
 *                AVHWDeviceContext.
 * @param type    The type of the new device to create.
 * @param src_ctx A reference to an existing AVHWDeviceContext which will be
 *                used to create the new device.
 * @param options Options for the new device to create, same format as in
 *                av_hwdevice_ctx_create.
 * @param flags   Currently unused; should be set to zero.
 * @return        Zero on success, a negative AVERROR code on failure.
 */
 int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ctx,
                                        enum AVHWDeviceType type,
                                        AVBufferRef *src_ctx,
                                        AVDictionary *options, int flags);
 /**
 * Allocate an AVHWFramesContext tied to a given device context.
@ -571,10 +548,6 @@ enum {
 * possible with the given arguments and hwframe setup, while other return
 * values indicate that it failed somehow.
 *
 * On failure, the destination frame will be left blank, except for the
 * hw_frames_ctx/format fields thay may have been set by the caller - those will
 * be preserved as they were.
 *
 * @param dst Destination frame, to contain the mapping.
 * @param src Source frame, to be mapped.
 * @param flags Some combination of AV_HWFRAME_MAP_* flags.
@ -591,7 +564,6 @@ int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
 *
 * @param derived_frame_ctx  On success, a reference to the newly created
 *                           AVHWFramesContext.
 * @param format             The AVPixelFormat for the derived context.
 * @param derived_device_ctx A reference to the device to create the new
 *                           AVHWFramesContext on.
 * @param source_frame_ctx   A reference to an existing AVHWFramesContext
--- a/output/include/arm64-v8a/libavutil/hwcontext_cuda.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_cuda.h
@ -41,7 +41,6 @@ typedef struct AVCUDADeviceContextInternal AVCUDADeviceContextInternal;
 */
 typedef struct AVCUDADeviceContext {
    CUcontext cuda_ctx;
    CUstream stream;
    AVCUDADeviceContextInternal *internal;
 } AVCUDADeviceContext;
@ -49,21 +48,4 @@ typedef struct AVCUDADeviceContext {
 * AVHWFramesContext.hwctx is currently not used
 */
 /**
 * @defgroup hwcontext_cuda Device context creation flags
 *
 * Flags for av_hwdevice_ctx_create.
 *
 * @{
 */
 /**
 * Use primary device context instead of creating a new one.
 */
 #define AV_CUDA_USE_PRIMARY_CONTEXT (1 << 0)
 /**
 * @}
 */
 #endif /* AVUTIL_HWCONTEXT_CUDA_H */
--- a/output/include/arm64-v8a/libavutil/hwcontext_d3d11va.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_d3d11va.h
@ -37,7 +37,6 @@
 */
 #include <d3d11.h>
 #include <stdint.h>
 /**
 * This struct is allocated as AVHWDeviceContext.hwctx
@ -164,15 +163,6 @@ typedef struct AVD3D11VAFramesContext {
     * This field is ignored/invalid if a user-allocated texture is provided.
     */
    UINT MiscFlags;
    /**
     * In case if texture structure member above is not NULL contains the same texture
     * pointer for all elements and different indexes into the array texture.
     * In case if texture structure member above is NULL, all elements contains
     * pointers to separate non-array textures and 0 indexes.
     * This field is ignored/invalid if a user-allocated texture is provided.
    */
    AVD3D11FrameDescriptor *texture_infos;
 } AVD3D11VAFramesContext;
 #endif /* AVUTIL_HWCONTEXT_D3D11VA_H */
--- a/output/include/arm64-v8a/libavutil/hwcontext_drm.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_drm.h
@ -58,9 +58,6 @@ typedef struct AVDRMObjectDescriptor {
    size_t size;
    /**
     * Format modifier applied to the object (DRM_FORMAT_MOD_*).
     *
     * If the format modifier is unknown then this should be set to
     * DRM_FORMAT_MOD_INVALID.
     */
    uint64_t format_modifier;
 } AVDRMObjectDescriptor;
--- a/output/include/arm64-v8a/libavutil/hwcontext_mediacodec.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_mediacodec.h
@ -1,61 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_HWCONTEXT_MEDIACODEC_H
 #define AVUTIL_HWCONTEXT_MEDIACODEC_H
 /**
 * MediaCodec details.
 *
 * Allocated as AVHWDeviceContext.hwctx
 */
 typedef struct AVMediaCodecDeviceContext {
    /**
     * android/view/Surface handle, to be filled by the user.
     *
     * This is the default surface used by decoders on this device.
     */
    void *surface;
    /**
     * Pointer to ANativeWindow.
     *
     * It both surface and native_window is NULL, try to create it
     * automatically if create_window is true and OS support
     * createPersistentInputSurface.
     *
     * It can be used as output surface for decoder and input surface for
     * encoder.
     */
    void *native_window;
    /**
     * Enable createPersistentInputSurface automatically.
     *
     * Disabled by default.
     *
     * It can be enabled by setting this flag directly, or by setting
     * AVDictionary of av_hwdevice_ctx_create(), with "create_window" as key.
     * The second method is useful for ffmpeg cmdline, e.g., we can enable it
     * via:
     *   -init_hw_device mediacodec=mediacodec,create_window=1
     */
    int create_window;
 } AVMediaCodecDeviceContext;
 #endif /* AVUTIL_HWCONTEXT_MEDIACODEC_H */
--- a/output/include/arm64-v8a/libavutil/hwcontext_opencl.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_opencl.h
@ -1,100 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_HWCONTEXT_OPENCL_H
 #define AVUTIL_HWCONTEXT_OPENCL_H
 #ifdef __APPLE__
 #include <OpenCL/cl.h>
 #else
 #include <CL/cl.h>
 #endif
 #include "frame.h"
 /**
 * @file
 * API-specific header for AV_HWDEVICE_TYPE_OPENCL.
 *
 * Pools allocated internally are always dynamic, and are primarily intended
 * to be used in OpenCL-only cases.  If interoperation is required, it is
 * typically required to allocate frames in the other API and then map the
 * frames context to OpenCL with av_hwframe_ctx_create_derived().
 */
 /**
 * OpenCL frame descriptor for pool allocation.
 *
 * In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
 * with the data pointer pointing at an object of this type describing the
 * planes of the frame.
 */
 typedef struct AVOpenCLFrameDescriptor {
    /**
     * Number of planes in the frame.
     */
    int nb_planes;
    /**
     * OpenCL image2d objects for each plane of the frame.
     */
    cl_mem planes[AV_NUM_DATA_POINTERS];
 } AVOpenCLFrameDescriptor;
 /**
 * OpenCL device details.
 *
 * Allocated as AVHWDeviceContext.hwctx
 */
 typedef struct AVOpenCLDeviceContext {
    /**
     * The primary device ID of the device.  If multiple OpenCL devices
     * are associated with the context then this is the one which will
     * be used for all operations internal to FFmpeg.
     */
    cl_device_id device_id;
    /**
     * The OpenCL context which will contain all operations and frames on
     * this device.
     */
    cl_context context;
    /**
     * The default command queue for this device, which will be used by all
     * frames contexts which do not have their own command queue.  If not
     * intialised by the user, a default queue will be created on the
     * primary device.
     */
    cl_command_queue command_queue;
 } AVOpenCLDeviceContext;
 /**
 * OpenCL-specific data associated with a frame pool.
 *
 * Allocated as AVHWFramesContext.hwctx.
 */
 typedef struct AVOpenCLFramesContext {
    /**
     * The command queue used for internal asynchronous operations on this
     * device (av_hwframe_transfer_data(), av_hwframe_map()).
     *
     * If this is not set, the command queue from the associated device is
     * used instead.
     */
    cl_command_queue command_queue;
 } AVOpenCLFramesContext;
 #endif /* AVUTIL_HWCONTEXT_OPENCL_H */
--- a/output/include/arm64-v8a/libavutil/hwcontext_qsv.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_qsv.h
@ -19,7 +19,7 @@
 #ifndef AVUTIL_HWCONTEXT_QSV_H
 #define AVUTIL_HWCONTEXT_QSV_H
-#include <mfxvideo.h>
+#include <mfx/mfxvideo.h>
 /**
 * @file
@ -34,17 +34,6 @@
 */
 typedef struct AVQSVDeviceContext {
    mfxSession session;
    /**
     * The mfxLoader handle used for mfxSession creation
     *
     * This field is only available for oneVPL user. For non-oneVPL user, this
     * field must be set to NULL.
     *
     * Filled by the user before calling av_hwdevice_ctx_init() and should be
     * cast to mfxLoader handle. Deallocating the AVHWDeviceContext will always
     * release this interface.
     */
    void *loader;
 } AVQSVDeviceContext;
 /**
--- a/output/include/arm64-v8a/libavutil/hwcontext_videotoolbox.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_videotoolbox.h
@ -23,21 +23,17 @@
 #include <VideoToolbox/VideoToolbox.h>
 #include "frame.h"
 #include "pixfmt.h"
 /**
 * @file
 * An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
 *
- * This API supports frame allocation using a native CVPixelBufferPool
+ * This API currently does not support frame allocation, as the raw VideoToolbox
- * instead of an AVBufferPool.
+ * API does allocation, and FFmpeg itself never has the need to allocate frames.
 *
 * If the API user sets a custom pool, AVHWFramesContext.pool must return
 * AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef.
 * Note that the underlying CVPixelBuffer could be retained by OS frameworks
 * depending on application usage, so it is preferable to let CoreVideo manage
 * the pool using the default implementation.
 *
 * Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always
 * NULL.
@ -55,42 +51,4 @@ enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt);
 */
 uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt);
 /**
 * Same as av_map_videotoolbox_format_from_pixfmt function, but can map and
 * return full range pixel formats via a flag.
 */
 uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range);
 /**
 * Convert an AVChromaLocation to a VideoToolbox/CoreVideo chroma location string.
 * Returns 0 if no known equivalent was found.
 */
 CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc);
 /**
 * Convert an AVColorSpace to a VideoToolbox/CoreVideo color matrix string.
 * Returns 0 if no known equivalent was found.
 */
 CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space);
 /**
 * Convert an AVColorPrimaries to a VideoToolbox/CoreVideo color primaries string.
 * Returns 0 if no known equivalent was found.
 */
 CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri);
 /**
 * Convert an AVColorTransferCharacteristic to a VideoToolbox/CoreVideo color transfer
 * function string.
 * Returns 0 if no known equivalent was found.
 */
 CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc);
 /**
 * Update a CVPixelBufferRef's metadata to based on an AVFrame.
 * Returns 0 if no known equivalent was found.
 */
 int av_vt_pixbuf_set_attachments(void *log_ctx,
                                 CVPixelBufferRef pixbuf, const struct AVFrame *src);
 #endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */
--- a/output/include/arm64-v8a/libavutil/hwcontext_vulkan.h
+++ b/output/include/arm64-v8a/libavutil/hwcontext_vulkan.h
@ -1,281 +0,0 @@
 /*
 * 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.
 *
 * 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 #ifndef AVUTIL_HWCONTEXT_VULKAN_H
 #define AVUTIL_HWCONTEXT_VULKAN_H
 #if defined(_WIN32) && !defined(VK_USE_PLATFORM_WIN32_KHR)
 #define VK_USE_PLATFORM_WIN32_KHR
 #endif
 #include <vulkan/vulkan.h>
 #include "pixfmt.h"
 #include "frame.h"
 /**
 * @file
 * API-specific header for AV_HWDEVICE_TYPE_VULKAN.
 *
 * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
 * with the data pointer set to an AVVkFrame.
 */
 /**
 * Main Vulkan context, allocated as AVHWDeviceContext.hwctx.
 * All of these can be set before init to change what the context uses
 */
 typedef struct AVVulkanDeviceContext {
    /**
     * Custom memory allocator, else NULL
     */
    const VkAllocationCallbacks *alloc;
    /**
     * Pointer to the instance-provided vkGetInstanceProcAddr loading function.
     * If NULL, will pick either libvulkan or libvolk, depending on libavutil's
     * compilation settings, and set this field.
     */
    PFN_vkGetInstanceProcAddr get_proc_addr;
    /**
     * Vulkan instance. Must be at least version 1.2.
     */
    VkInstance inst;
    /**
     * Physical device
     */
    VkPhysicalDevice phys_dev;
    /**
     * Active device
     */
    VkDevice act_dev;
    /**
     * This structure should be set to the set of features that present and enabled
     * during device creation. When a device is created by FFmpeg, it will default to
     * enabling all that are present of the shaderImageGatherExtended,
     * fragmentStoresAndAtomics, shaderInt64 and vertexPipelineStoresAndAtomics features.
     */
    VkPhysicalDeviceFeatures2 device_features;
    /**
     * Enabled instance extensions.
     * If supplying your own device context, set this to an array of strings, with
     * each entry containing the specified Vulkan extension string to enable.
     * Duplicates are possible and accepted.
     * If no extensions are enabled, set these fields to NULL, and 0 respectively.
     */
    const char * const *enabled_inst_extensions;
    int nb_enabled_inst_extensions;
    /**
     * Enabled device extensions. By default, VK_KHR_external_memory_fd,
     * VK_EXT_external_memory_dma_buf, VK_EXT_image_drm_format_modifier,
     * VK_KHR_external_semaphore_fd and VK_EXT_external_memory_host are enabled if found.
     * If supplying your own device context, these fields takes the same format as
     * the above fields, with the same conditions that duplicates are possible
     * and accepted, and that NULL and 0 respectively means no extensions are enabled.
     */
    const char * const *enabled_dev_extensions;
    int nb_enabled_dev_extensions;
    /**
     * Queue family index for graphics operations, and the number of queues
     * enabled for it. If unavaiable, will be set to -1. Not required.
     * av_hwdevice_create() will attempt to find a dedicated queue for each
     * queue family, or pick the one with the least unrelated flags set.
     * Queue indices here may overlap if a queue has to share capabilities.
     */
    int queue_family_index;
    int nb_graphics_queues;
    /**
     * Queue family index for transfer operations and the number of queues
     * enabled. Required.
     */
    int queue_family_tx_index;
    int nb_tx_queues;
    /**
     * Queue family index for compute operations and the number of queues
     * enabled. Required.
     */
    int queue_family_comp_index;
    int nb_comp_queues;
    /**
     * Queue family index for video encode ops, and the amount of queues enabled.
     * If the device doesn't support such, queue_family_encode_index will be -1.
     * Not required.
     */
    int queue_family_encode_index;
    int nb_encode_queues;
    /**
     * Queue family index for video decode ops, and the amount of queues enabled.
     * If the device doesn't support such, queue_family_decode_index will be -1.
     * Not required.
     */
    int queue_family_decode_index;
    int nb_decode_queues;
 } AVVulkanDeviceContext;
 /**
 * Defines the behaviour of frame allocation.
 */
 typedef enum AVVkFrameFlags {
    /* Unless this flag is set, autodetected flags will be OR'd based on the
     * device and tiling during av_hwframe_ctx_init(). */
    AV_VK_FRAME_FLAG_NONE              = (1ULL << 0),
    /* Image planes will be allocated in a single VkDeviceMemory, rather
     * than as per-plane VkDeviceMemory allocations. Required for exporting
     * to VAAPI on Intel devices. */
    AV_VK_FRAME_FLAG_CONTIGUOUS_MEMORY = (1ULL << 1),
 } AVVkFrameFlags;
 /**
 * Allocated as AVHWFramesContext.hwctx, used to set pool-specific options
 */
 typedef struct AVVulkanFramesContext {
    /**
     * Controls the tiling of allocated frames. If left as optimal tiling,
     * then during av_hwframe_ctx_init() will decide based on whether the device
     * supports DRM modifiers, or if the linear_images flag is set, otherwise
     * will allocate optimally-tiled images.
     */
    VkImageTiling tiling;
    /**
     * Defines extra usage of output frames. If left as 0, the following bits
     * are set: TRANSFER_SRC, TRANSFER_DST. SAMPLED and STORAGE.
     */
    VkImageUsageFlagBits usage;
    /**
     * Extension data for image creation.
     * If VkImageDrmFormatModifierListCreateInfoEXT is present in the chain,
     * and the device supports DRM modifiers, then images will be allocated
     * with the specific requested DRM modifiers.
     * Additional structures may be added at av_hwframe_ctx_init() time,
     * which will be freed automatically on uninit(), so users need only free
     * any structures they've allocated themselves.
     */
    void *create_pnext;
    /**
     * Extension data for memory allocation. Must have as many entries as
     * the number of planes of the sw_format.
     * This will be chained to VkExportMemoryAllocateInfo, which is used
     * to make all pool images exportable to other APIs if the necessary
     * extensions are present in enabled_dev_extensions.
     */
    void *alloc_pnext[AV_NUM_DATA_POINTERS];
    /**
     * A combination of AVVkFrameFlags. Unless AV_VK_FRAME_FLAG_NONE is set,
     * autodetected flags will be OR'd based on the device and tiling during
     * av_hwframe_ctx_init().
     */
    AVVkFrameFlags flags;
 } AVVulkanFramesContext;
 /*
 * Frame structure, the VkFormat of the image will always match
 * the pool's sw_format.
 * All frames, imported or allocated, will be created with the
 * VK_IMAGE_CREATE_ALIAS_BIT flag set, so the memory may be aliased if needed.
 *
 * If all queue family indices in the device context are the same,
 * images will be created with the EXCLUSIVE sharing mode. Otherwise, all images
 * will be created using the CONCURRENT sharing mode.
 *
 * @note the size of this structure is not part of the ABI, to allocate
 * you must use @av_vk_frame_alloc().
 */
 typedef struct AVVkFrame {
    /**
     * Vulkan images to which the memory is bound to.
     */
    VkImage img[AV_NUM_DATA_POINTERS];
    /**
     * The same tiling must be used for all images in the frame.
     */
    VkImageTiling tiling;
    /**
     * Memory backing the images. Could be less than the amount of planes,
     * in which case the offset value will indicate the binding offset of
     * each plane in the memory.
     */
    VkDeviceMemory mem[AV_NUM_DATA_POINTERS];
    size_t size[AV_NUM_DATA_POINTERS];
    /**
     * OR'd flags for all memory allocated
     */
    VkMemoryPropertyFlagBits flags;
    /**
     * Updated after every barrier
     */
    VkAccessFlagBits access[AV_NUM_DATA_POINTERS];
    VkImageLayout layout[AV_NUM_DATA_POINTERS];
    /**
     * Synchronization timeline semaphores, one for each sw_format plane.
     * Must not be freed manually. Must be waited on at every submission using
     * the value in sem_value, and must be signalled at every submission,
     * using an incremented value.
     */
    VkSemaphore sem[AV_NUM_DATA_POINTERS];
    /**
     * Up to date semaphore value at which each image becomes accessible.
     * Clients must wait on this value when submitting a command queue,
     * and increment it when signalling.
     */
    uint64_t sem_value[AV_NUM_DATA_POINTERS];
    /**
     * Internal data.
     */
    struct AVVkFrameInternal *internal;
    /**
     * Describes the binding offset of each plane to the VkDeviceMemory.
     */
    ptrdiff_t offset[AV_NUM_DATA_POINTERS];
 } AVVkFrame;
 /**
 * Allocates a single AVVkFrame and initializes everything as 0.
 * @note Must be freed via av_free()
 */
 AVVkFrame *av_vk_frame_alloc(void);
 /**
 * Returns the format of each image up to the number of planes for a given sw_format.
 * Returns NULL on unsupported formats.
 */
 const VkFormat *av_vkfmt_from_pixfmt(enum AVPixelFormat p);
 #endif /* AVUTIL_HWCONTEXT_VULKAN_H */
--- a/output/include/arm64-v8a/libavutil/imgutils.h
+++ b/output/include/arm64-v8a/libavutil/imgutils.h
@ -27,10 +27,8 @@
 * @{
 */
-#include <stddef.h>
+#include "avutil.h"
 #include <stdint.h>
 #include "pixdesc.h"
 #include "pixfmt.h"
 #include "rational.h"
 /**
@ -48,7 +46,6 @@
 * component in the plane with the max pixel step.
 * @param max_pixstep_comps an array which is filled with the component
 * for each plane which has the max pixel step. May be NULL.
 * @param pixdesc the AVPixFmtDescriptor for the image, describing its format
 */
 void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
                                const AVPixFmtDescriptor *pixdesc);
@ -66,35 +63,15 @@ int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);
 * width width.
 *
 * @param linesizes array to be filled with the linesize for each plane
 * @param pix_fmt the AVPixelFormat of the image
 * @param width width of the image in pixels
 * @return >= 0 in case of success, a negative error code otherwise
 */
 int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width);
 /**
 * Fill plane sizes for an image with pixel format pix_fmt and height height.
 *
 * @param size the array to be filled with the size of each image plane
 * @param pix_fmt the AVPixelFormat of the image
 * @param height height of the image in pixels
 * @param linesizes the array containing the linesize for each
 *        plane, should be filled by av_image_fill_linesizes()
 * @return >= 0 in case of success, a negative error code otherwise
 *
 * @note The linesize parameters have the type ptrdiff_t here, while they are
 *       int for av_image_fill_linesizes().
 */
 int av_image_fill_plane_sizes(size_t size[4], enum AVPixelFormat pix_fmt,
                              int height, const ptrdiff_t linesizes[4]);
 /**
 * Fill plane data pointers for an image with pixel format pix_fmt and
 * height height.
 *
 * @param data pointers array to be filled with the pointer for each image plane
 * @param pix_fmt the AVPixelFormat of the image
 * @param height height of the image in pixels
 * @param ptr the pointer to a buffer which will contain the image
 * @param linesizes the array containing the linesize for each
 * plane, should be filled by av_image_fill_linesizes()
@ -110,11 +87,6 @@ int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int hei
 * The allocated image buffer has to be freed by using
 * av_freep(&pointers[0]).
 *
 * @param pointers array to be filled with the pointer for each image plane
 * @param linesizes the array filled with the linesize for each plane
 * @param w width of the image in pixels
 * @param h height of the image in pixels
 * @param pix_fmt the AVPixelFormat of the image
 * @param align the value to use for buffer size alignment
 * @return the size in bytes required for the image buffer, a negative
 * error code in case of failure
@ -131,44 +103,18 @@ int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
 * bytewidth must be contained by both absolute values of dst_linesize
 * and src_linesize, otherwise the function behavior is undefined.
 *
 * @param dst          destination plane to copy to
 * @param dst_linesize linesize for the image plane in dst
 * @param src          source plane to copy from
 * @param src_linesize linesize for the image plane in src
 * @param height       height (number of lines) of the plane
 */
 void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
                         const uint8_t *src, int src_linesize,
                         int bytewidth, int height);
 /**
 * Copy image data located in uncacheable (e.g. GPU mapped) memory. Where
 * available, this function will use special functionality for reading from such
 * memory, which may result in greatly improved performance compared to plain
 * av_image_copy_plane().
 *
 * bytewidth must be contained by both absolute values of dst_linesize
 * and src_linesize, otherwise the function behavior is undefined.
 *
 * @note The linesize parameters have the type ptrdiff_t here, while they are
 *       int for av_image_copy_plane().
 * @note On x86, the linesizes currently need to be aligned to the cacheline
 *       size (i.e. 64) to get improved performance.
 */
 void av_image_copy_plane_uc_from(uint8_t       *dst, ptrdiff_t dst_linesize,
                                 const uint8_t *src, ptrdiff_t src_linesize,
                                 ptrdiff_t bytewidth, int height);
 /**
 * Copy image in src_data to dst_data.
 *
 * @param dst_data      destination image data buffer to copy to
 * @param dst_linesizes linesizes for the image in dst_data
 * @param src_data      source image data buffer to copy from
 * @param src_linesizes linesizes for the image in src_data
 * @param pix_fmt       the AVPixelFormat of the image
 * @param width         width of the image in pixels
 * @param height        height of the image in pixels
 */
 void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
                   const uint8_t *src_data[4], const int src_linesizes[4],
--- a/output/include/arm64-v8a/libavutil/intreadwrite.h
+++ b/output/include/arm64-v8a/libavutil/intreadwrite.h
@ -215,7 +215,7 @@ typedef union {
 * by per-arch headers.
 */
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__)
 union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
 union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
@ -224,7 +224,12 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
 #   define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
 #   define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
-#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_X64) || defined(_M_ARM64)) && AV_HAVE_FAST_UNALIGNED
+#elif defined(__DECC)
 #   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
 #   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
 #elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_X64)) && AV_HAVE_FAST_UNALIGNED
 #   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
 #   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
@ -542,21 +547,6 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
 #   define AV_WN64A(p, v) AV_WNA(64, p, v)
 #endif
 #if AV_HAVE_BIGENDIAN
 #   define AV_RLA(s, p)    av_bswap##s(AV_RN##s##A(p))
 #   define AV_WLA(s, p, v) AV_WN##s##A(p, av_bswap##s(v))
 #else
 #   define AV_RLA(s, p)    AV_RN##s##A(p)
 #   define AV_WLA(s, p, v) AV_WN##s##A(p, v)
 #endif
 #ifndef AV_RL64A
 #   define AV_RL64A(p) AV_RLA(64, p)
 #endif
 #ifndef AV_WL64A
 #   define AV_WL64A(p, v) AV_WLA(64, p, v)
 #endif
 /*
 * The AV_COPYxxU macros are suitable for copying data to/from unaligned
 * memory locations.
--- a/output/include/arm64-v8a/libavutil/lfg.h
+++ b/output/include/arm64-v8a/libavutil/lfg.h
@ -27,7 +27,7 @@
 /**
 * Context structure for the Lagged Fibonacci PRNG.
 * The exact layout, types and content of this struct may change and should
- * not be accessed directly. Only its `sizeof()` is guaranteed to stay the same
+ * not be accessed directly. Only its sizeof() is guranteed to stay the same
 * to allow easy instanciation.
 */
 typedef struct AVLFG {
@ -40,7 +40,7 @@ void av_lfg_init(AVLFG *c, unsigned int seed);
 /**
 * Seed the state of the ALFG using binary data.
 *
- * @return 0 on success, negative value (AVERROR) on failure.
+ * Return value: 0 on success, negative value (AVERROR) on failure.
 */
 int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length);
@ -73,7 +73,6 @@ static inline unsigned int av_mlfg_get(AVLFG *c){
 * Get the next two numbers generated by a Box-Muller Gaussian
 * generator using the random numbers issued by lfg.
 *
 * @param lfg pointer to the contex structure
 * @param out array where the two generated numbers are placed
 */
 void av_bmg_get(AVLFG *lfg, double out[2]);
--- a/output/include/arm64-v8a/libavutil/log.h
+++ b/output/include/arm64-v8a/libavutil/log.h
@ -22,6 +22,7 @@
 #define AVUTIL_LOG_H
 #include <stdarg.h>
 #include "avutil.h"
 #include "attributes.h"
 #include "version.h"
@ -106,6 +107,21 @@ typedef struct AVClass {
     */
    int parent_log_context_offset;
    /**
     * Return next AVOptions-enabled child or NULL
     */
    void* (*child_next)(void *obj, void *prev);
    /**
     * Return an AVClass corresponding to the next potential
     * AVOptions-enabled child.
     *
     * The difference between child_next and this is that
     * child_next iterates over _already existing_ objects, while
     * child_class_next iterates over _all possible_ children.
     */
    const struct AVClass* (*child_class_next)(const struct AVClass *prev);
    /**
     * Category used for visualization (like color)
     * This is only set if the category is equal for all objects using this class.
@ -124,26 +140,6 @@ typedef struct AVClass {
     * available since version (52.12)
     */
    int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
    /**
     * Return next AVOptions-enabled child or NULL
     */
    void* (*child_next)(void *obj, void *prev);
    /**
     * Iterate over the AVClasses corresponding to potential AVOptions-enabled
     * children.
     *
     * @param iter pointer to opaque iteration state. The caller must initialize
     *             *iter to NULL before the first call.
     * @return AVClass for the next AVOptions-enabled child or NULL if there are
     *         no more such children.
     *
     * @note The difference between child_next and this is that child_next
     *       iterates over _already existing_ objects, while child_class_iterate
     *       iterates over _all possible_ children.
     */
    const struct AVClass* (*child_class_iterate)(void **iter);
 } AVClass;
 /**
@ -237,27 +233,6 @@ typedef struct AVClass {
 */
 void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
 /**
 * Send the specified message to the log once with the initial_level and then with
 * the subsequent_level. By default, all logging messages are sent to
 * stderr. This behavior can be altered by setting a different logging callback
 * function.
 * @see av_log
 *
 * @param avcl A pointer to an arbitrary struct of which the first field is a
 *        pointer to an AVClass struct or NULL if general log.
 * @param initial_level importance level of the message expressed using a @ref
 *        lavu_log_constants "Logging Constant" for the first occurance.
 * @param subsequent_level importance level of the message expressed using a @ref
 *        lavu_log_constants "Logging Constant" after the first occurance.
 * @param fmt The format string (printf-compatible) that specifies how
 *        subsequent arguments are converted to output.
 * @param state a variable to keep trak of if a message has already been printed
 *        this must be initialized to 0 before the first use. The same state
 *        must not be accessed by 2 Threads simultaneously.
 */
 void av_log_once(void* avcl, int initial_level, int subsequent_level, int *state, const char *fmt, ...) av_printf_format(5, 6);
 /**
 * Send the specified message to the log if the level is less than or equal
@ -359,6 +334,20 @@ void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
 int av_log_format_line2(void *ptr, int level, const char *fmt, va_list vl,
                        char *line, int line_size, int *print_prefix);
 #if FF_API_DLOG
 /**
 * av_dlog macros
 * @deprecated unused
 * Useful to print debug messages that shouldn't get compiled in normally.
 */
 #ifdef DEBUG
 #    define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
 #else
 #    define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
 #endif
 #endif /* FF_API_DLOG */
 /**
 * Skip repeated messages, this requires the user app to use av_log() instead of
 * (f)printf as the 2 would otherwise interfere and lead to
--- a/output/include/arm64-v8a/libavutil/macros.h
+++ b/output/include/arm64-v8a/libavutil/macros.h
@ -25,36 +25,6 @@
 #ifndef AVUTIL_MACROS_H
 #define AVUTIL_MACROS_H
 #include "libavutil/avconfig.h"
 #if AV_HAVE_BIGENDIAN
 #   define AV_NE(be, le) (be)
 #else
 #   define AV_NE(be, le) (le)
 #endif
 /**
 * Comparator.
 * For two numerical expressions x and y, gives 1 if x > y, -1 if x < y, and 0
 * if x == y. This is useful for instance in a qsort comparator callback.
 * Furthermore, compilers are able to optimize this to branchless code, and
 * there is no risk of overflow with signed types.
 * As with many macros, this evaluates its argument multiple times, it thus
 * must not have a side-effect.
 */
 #define FFDIFFSIGN(x,y) (((x)>(y)) - ((x)<(y)))
 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
 #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
 #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
 #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
 #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
 #define MKTAG(a,b,c,d)   ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
 #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
 /**
 * @addtogroup preproc_misc Preprocessor String Macros
 *
--- a/output/include/arm64-v8a/libavutil/mastering_display_metadata.h
+++ b/output/include/arm64-v8a/libavutil/mastering_display_metadata.h
@ -1,4 +1,4 @@
-/*
+/**
 * Copyright (c) 2016 Neil Birkbeck <neil.birkbeck@gmail.com>
 *
 * This file is part of FFmpeg.
--- a/output/include/arm64-v8a/libavutil/mathematics.h
+++ b/output/include/arm64-v8a/libavutil/mathematics.h
@ -111,8 +111,7 @@ enum AVRounding {
 /**
 * Compute the greatest common divisor of two integer operands.
 *
- * @param a Operand
+ * @param a,b Operands
 * @param b Operand
 * @return GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0;
 * if a == 0 and b == 0, returns 0.
 */
@ -135,7 +134,6 @@ int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
 *
 * The operation is mathematically equivalent to `a * b / c`, but writing that
 * directly can overflow, and does not support different rounding methods.
 * If the result is not representable then INT64_MIN is returned.
 *
 * @see av_rescale(), av_rescale_q(), av_rescale_q_rnd()
 */
@ -187,8 +185,7 @@ int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
 * av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)
 * @endcode
 *
- * @param a Operand
+ * @param a,b Operands
 * @param b Operand
 * @param mod Divisor; must be a power of 2
 * @return
 *         - a negative value if `a % mod < b % mod`
--- a/output/include/arm64-v8a/libavutil/md5.h
+++ b/output/include/arm64-v8a/libavutil/md5.h
@ -31,6 +31,7 @@
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_md5 MD5
@ -63,7 +64,11 @@ void av_md5_init(struct AVMD5 *ctx);
 * @param src input data to update hash with
 * @param len input data length
 */
 #if FF_API_CRYPTO_SIZE_T
 void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len);
 #else
 void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len);
 #endif
 /**
 * Finish hashing and output digest value.
@ -80,7 +85,11 @@ void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
 * @param src The data to hash
 * @param len The length of the data, in bytes
 */
 #if FF_API_CRYPTO_SIZE_T
 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
 #else
 void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len);
 #endif
 /**
 * @}
--- a/output/include/arm64-v8a/libavutil/mem.h
+++ b/output/include/arm64-v8a/libavutil/mem.h
@ -31,8 +31,8 @@
 #include <stdint.h>
 #include "attributes.h"
 #include "error.h"
 #include "avutil.h"
 #include "version.h"
 /**
 * @addtogroup lavu_mem
@ -49,6 +49,70 @@
 * dealing with memory consistently possible on all platforms.
 *
 * @{
 *
 * @defgroup lavu_mem_macros Alignment Macros
 * Helper macros for declaring aligned variables.
 * @{
 */
 /**
 * @def DECLARE_ALIGNED(n,t,v)
 * Declare a variable that is aligned in memory.
 *
 * @code{.c}
 * DECLARE_ALIGNED(16, uint16_t, aligned_int) = 42;
 * DECLARE_ALIGNED(32, uint8_t, aligned_array)[128];
 *
 * // The default-alignment equivalent would be
 * uint16_t aligned_int = 42;
 * uint8_t aligned_array[128];
 * @endcode
 *
 * @param n Minimum alignment in bytes
 * @param t Type of the variable (or array element)
 * @param v Name of the variable
 */
 /**
 * @def DECLARE_ASM_CONST(n,t,v)
 * Declare a static constant aligned variable appropriate for use in inline
 * assembly code.
 *
 * @code{.c}
 * DECLARE_ASM_CONST(16, uint64_t, pw_08) = UINT64_C(0x0008000800080008);
 * @endcode
 *
 * @param n Minimum alignment in bytes
 * @param t Type of the variable (or array element)
 * @param v Name of the variable
 */
 #if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
    #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v
 #elif defined(__TI_COMPILER_VERSION__)
    #define DECLARE_ALIGNED(n,t,v)                      \
        AV_PRAGMA(DATA_ALIGN(v,n))                      \
        t __attribute__((aligned(n))) v
    #define DECLARE_ASM_CONST(n,t,v)                    \
        AV_PRAGMA(DATA_ALIGN(v,n))                      \
        static const t __attribute__((aligned(n))) v
 #elif defined(__DJGPP__)
    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (FFMIN(n, 16)))) v
    #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
 #elif defined(__GNUC__) || defined(__clang__)
    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
    #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (n))) v
 #elif defined(_MSC_VER)
    #define DECLARE_ALIGNED(n,t,v)      __declspec(align(n)) t v
    #define DECLARE_ASM_CONST(n,t,v)    __declspec(align(n)) static const t v
 #else
    #define DECLARE_ALIGNED(n,t,v)      t v
    #define DECLARE_ASM_CONST(n,t,v)    static const t v
 #endif
 /**
 * @}
 */
 /**
@ -142,7 +206,12 @@ void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
 *         be allocated
 * @see av_malloc()
 */
-av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
+av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
 {
    if (!size || nmemb >= INT_MAX / size)
        return NULL;
    return av_malloc(nmemb * size);
 }
 /**
 * Allocate a memory block for an array with av_mallocz().
@ -157,12 +226,25 @@ av_alloc_size(1, 2) void *av_malloc_array(size_t nmemb, size_t size);
 * @see av_mallocz()
 * @see av_malloc_array()
 */
-void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
+av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
 {
    if (!size || nmemb >= INT_MAX / size)
        return NULL;
    return av_mallocz(nmemb * size);
 }
 /**
 * Non-inlined equivalent of av_mallocz_array().
 *
 * Created for symmetry with the calloc() C function.
 */
 void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
 /**
 * Allocate, reallocate, or free a block of memory.
 *
- * If `ptr` is `NULL` and `size` > 0, allocate a new block. Otherwise, expand or
+ * If `ptr` is `NULL` and `size` > 0, allocate a new block. If `size` is
 * zero, free the memory block pointed to by `ptr`. Otherwise, expand or
 * shrink that block of memory according to `size`.
 *
 * @param ptr  Pointer to a memory block already allocated with
@ -171,11 +253,10 @@ void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib av_alloc_size(1, 2);
 *             reallocated
 *
 * @return Pointer to a newly-reallocated block or `NULL` if the block
- *         cannot be reallocated
+ *         cannot be reallocated or the function is used to free the memory block
 *
 * @warning Unlike av_malloc(), the returned pointer is not guaranteed to be
- *          correctly aligned. The returned pointer must be freed after even
+ *          correctly aligned.
 *          if size is zero.
 * @see av_fast_realloc()
 * @see av_reallocp()
 */
@ -223,7 +304,8 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
 /**
 * Allocate, reallocate, or free an array.
 *
- * If `ptr` is `NULL` and `nmemb` > 0, allocate a new block.
+ * If `ptr` is `NULL` and `nmemb` > 0, allocate a new block. If
 * `nmemb` is zero, free the memory block pointed to by `ptr`.
 *
 * @param ptr   Pointer to a memory block already allocated with
 *              av_realloc() or `NULL`
@ -231,19 +313,19 @@ void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
 * @param size  Size of the single element of the array
 *
 * @return Pointer to a newly-reallocated block or NULL if the block
- *         cannot be reallocated
+ *         cannot be reallocated or the function is used to free the memory block
 *
 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
- *          correctly aligned. The returned pointer must be freed after even if
+ *          correctly aligned.
 *          nmemb is zero.
 * @see av_reallocp_array()
 */
 av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
 /**
- * Allocate, reallocate an array through a pointer to a pointer.
+ * Allocate, reallocate, or free an array through a pointer to a pointer.
 *
- * If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block.
+ * If `*ptr` is `NULL` and `nmemb` > 0, allocate a new block. If `nmemb` is
 * zero, free the memory block pointed to by `*ptr`.
 *
 * @param[in,out] ptr   Pointer to a pointer to a memory block already
 *                      allocated with av_realloc(), or a pointer to `NULL`.
@ -254,7 +336,7 @@ av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
 * @return Zero on success, an AVERROR error code on failure
 *
 * @warning Unlike av_malloc(), the allocated memory is not guaranteed to be
- *          correctly aligned. *ptr must be freed after even if nmemb is zero.
+ *          correctly aligned.
 */
 int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
@ -280,10 +362,10 @@ int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
 * @endcode
 *
 * @param[in,out] ptr      Already allocated buffer, or `NULL`
- * @param[in,out] size     Pointer to the size of buffer `ptr`. `*size` is
+ * @param[in,out] size     Pointer to current size of buffer `ptr`. `*size` is
- *                         updated to the new allocated size, in particular 0
+ *                         changed to `min_size` in case of success or 0 in
- *                         in case of failure.
+ *                         case of failure
- * @param[in]     min_size Desired minimal size of buffer `ptr`
+ * @param[in]     min_size New size of buffer `ptr`
 * @return `ptr` if the buffer is large enough, a pointer to newly reallocated
 *         buffer if the buffer was not large enough, or `NULL` in case of
 *         error
@ -314,10 +396,10 @@ void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
 * @param[in,out] ptr      Pointer to pointer to an already allocated buffer.
 *                         `*ptr` will be overwritten with pointer to new
 *                         buffer on success or `NULL` on failure
- * @param[in,out] size     Pointer to the size of buffer `*ptr`. `*size` is
+ * @param[in,out] size     Pointer to current size of buffer `*ptr`. `*size` is
- *                         updated to the new allocated size, in particular 0
+ *                         changed to `min_size` in case of success or 0 in
- *                         in case of failure.
+ *                         case of failure
- * @param[in]     min_size Desired minimal size of buffer `*ptr`
+ * @param[in]     min_size New size of buffer `*ptr`
 * @see av_realloc()
 * @see av_fast_mallocz()
 */
@ -335,10 +417,10 @@ void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
 * @param[in,out] ptr      Pointer to pointer to an already allocated buffer.
 *                         `*ptr` will be overwritten with pointer to new
 *                         buffer on success or `NULL` on failure
- * @param[in,out] size     Pointer to the size of buffer `*ptr`. `*size` is
+ * @param[in,out] size     Pointer to current size of buffer `*ptr`. `*size` is
- *                         updated to the new allocated size, in particular 0
+ *                         changed to `min_size` in case of success or 0 in
- *                         in case of failure.
+ *                         case of failure
- * @param[in]     min_size Desired minimal size of buffer `*ptr`
+ * @param[in]     min_size New size of buffer `*ptr`
 * @see av_fast_malloc()
 */
 void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size);
@ -579,12 +661,20 @@ void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
 /**
 * Multiply two `size_t` values checking for overflow.
 *
- * @param[in]  a   Operand of multiplication
+ * @param[in]  a,b Operands of multiplication
 * @param[in]  b   Operand of multiplication
 * @param[out] r   Pointer to the result of the operation
 * @return 0 on success, AVERROR(EINVAL) on overflow
 */
-int av_size_mult(size_t a, size_t b, size_t *r);
+static inline int av_size_mult(size_t a, size_t b, size_t *r)
 {
    size_t t = a * b;
    /* Hack inspired from glibc: don't try the division if nelem and elsize
     * are both less than sqrt(SIZE_MAX). */
    if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
        return AVERROR(EINVAL);
    *r = t;
    return 0;
 }
 /**
 * Set the maximum size that may be allocated in one block.
--- a/output/include/arm64-v8a/libavutil/murmur3.h
+++ b/output/include/arm64-v8a/libavutil/murmur3.h
@ -27,7 +27,6 @@
 #ifndef AVUTIL_MURMUR3_H
 #define AVUTIL_MURMUR3_H
 #include <stddef.h>
 #include <stdint.h>
 /**
@ -98,7 +97,7 @@ void av_murmur3_init(struct AVMurMur3 *c);
 * @param[in]  src  Input data to update hash with
 * @param[in]  len  Number of bytes to read from `src`
 */
-void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, size_t len);
+void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len);
 /**
 * Finish hashing and output digest value.
--- a/output/include/arm64-v8a/libavutil/opt.h
+++ b/output/include/arm64-v8a/libavutil/opt.h
@ -29,11 +29,11 @@
 #include "rational.h"
 #include "avutil.h"
 #include "channel_layout.h"
 #include "dict.h"
 #include "log.h"
 #include "pixfmt.h"
 #include "samplefmt.h"
 #include "version.h"
 /**
 * @defgroup avoptions AVOptions
@ -114,7 +114,7 @@
 *      libavcodec exports generic options, while its priv_data field exports
 *      codec-specific options). In such a case, it is possible to set up the
 *      parent struct to export a child's options. To do that, simply
- *      implement AVClass.child_next() and AVClass.child_class_iterate() in the
+ *      implement AVClass.child_next() and AVClass.child_class_next() in the
 *      parent struct's AVClass.
 *      Assuming that the test_struct from above now also contains a
 *      child_struct field:
@ -143,25 +143,23 @@
 *              return t->child_struct;
 *          return NULL
 *      }
- *      const AVClass child_class_iterate(void **iter)
+ *      const AVClass child_class_next(const AVClass *prev)
 *      {
- *          const AVClass *c = *iter ? NULL : &child_class;
+ *          return prev ? NULL : &child_class;
 *          *iter = (void*)(uintptr_t)c;
 *          return c;
 *      }
 *      @endcode
- *      Putting child_next() and child_class_iterate() as defined above into
+ *      Putting child_next() and child_class_next() as defined above into
 *      test_class will now make child_struct's options accessible through
 *      test_struct (again, proper setup as described above needs to be done on
 *      child_struct right after it is created).
 *
 *      From the above example it might not be clear why both child_next()
- *      and child_class_iterate() are needed. The distinction is that child_next()
+ *      and child_class_next() are needed. The distinction is that child_next()
- *      iterates over actually existing objects, while child_class_iterate()
+ *      iterates over actually existing objects, while child_class_next()
 *      iterates over all possible child classes. E.g. if an AVCodecContext
 *      was initialized to use a codec which has private options, then its
 *      child_next() will return AVCodecContext.priv_data and finish
- *      iterating. OTOH child_class_iterate() on AVCodecContext.av_class will
+ *      iterating. OTOH child_class_next() on AVCodecContext.av_class will
 *      iterate over all available codecs with private options.
 *
 * @subsection avoptions_implement_named_constants Named constants
@ -196,7 +194,7 @@
 * For enumerating there are basically two cases. The first is when you want to
 * get all options that may potentially exist on the struct and its children
 * (e.g.  when constructing documentation). In that case you should call
- * av_opt_child_class_iterate() recursively on the parent struct's AVClass.  The
+ * av_opt_child_class_next() recursively on the parent struct's AVClass.  The
 * second case is when you have an already initialized struct with all its
 * children and you want to get all options that can be actually written or read
 * from it. In that case you should call av_opt_child_next() recursively (and
@ -231,18 +229,15 @@ enum AVOptionType{
    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,
+    AV_OPT_TYPE_CONST = 128,
-    AV_OPT_TYPE_IMAGE_SIZE, ///< offset must point to two consecutive integers
+    AV_OPT_TYPE_IMAGE_SIZE = MKBETAG('S','I','Z','E'), ///< offset must point to two consecutive integers
-    AV_OPT_TYPE_PIXEL_FMT,
+    AV_OPT_TYPE_PIXEL_FMT  = MKBETAG('P','F','M','T'),
-    AV_OPT_TYPE_SAMPLE_FMT,
+    AV_OPT_TYPE_SAMPLE_FMT = MKBETAG('S','F','M','T'),
-    AV_OPT_TYPE_VIDEO_RATE, ///< offset must point to AVRational
+    AV_OPT_TYPE_VIDEO_RATE = MKBETAG('V','R','A','T'), ///< offset must point to AVRational
-    AV_OPT_TYPE_DURATION,
+    AV_OPT_TYPE_DURATION   = MKBETAG('D','U','R',' '),
-    AV_OPT_TYPE_COLOR,
+    AV_OPT_TYPE_COLOR      = MKBETAG('C','O','L','R'),
-#if FF_API_OLD_CHANNEL_LAYOUT
+    AV_OPT_TYPE_CHANNEL_LAYOUT = MKBETAG('C','H','L','A'),
-    AV_OPT_TYPE_CHANNEL_LAYOUT,
+    AV_OPT_TYPE_BOOL           = MKBETAG('B','O','O','L'),
 #endif
    AV_OPT_TYPE_BOOL,
    AV_OPT_TYPE_CHLAYOUT,
 };
 /**
@ -280,6 +275,9 @@ 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
@ -292,11 +290,7 @@ typedef struct AVOption {
 * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
 */
 #define AV_OPT_FLAG_READONLY        128
 #define AV_OPT_FLAG_BSF_PARAM       (1<<8) ///< a generic parameter which can be set by the user for bit stream filtering
 #define AV_OPT_FLAG_RUNTIME_PARAM   (1<<15) ///< a generic parameter which can be set by the user at runtime
 #define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
 #define AV_OPT_FLAG_DEPRECATED      (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information
 #define AV_OPT_FLAG_CHILD_CONSTS    (1<<18) ///< set if option constants can also reside in child objects
 //FIXME think about enc-audio, ... style flags
    /**
@ -654,10 +648,10 @@ void *av_opt_child_next(void *obj, void *prev);
 /**
 * Iterate over potential AVOptions-enabled children of parent.
 *
- * @param iter a pointer where iteration state is stored.
+ * @param prev result of a previous call to this function or NULL
 * @return AVClass corresponding to next potential child or NULL
 */
-const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
+const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev);
 /**
 * @defgroup opt_set_funcs Option setting functions
@ -676,9 +670,6 @@ const AVClass *av_opt_child_class_iterate(const AVClass *parent, void **iter);
 * scalars or named flags separated by '+' or '-'. Prefixing a flag
 * with '+' causes it to be set without affecting the other flags;
 * similarly, '-' unsets a flag.
 * If the field is of a dictionary type, it has to be a ':' separated list of
 * key=value parameters. Values containing ':' special characters must be
 * escaped.
 * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
 * is passed here, then the option may be set on a child of obj.
 *
@ -697,11 +688,7 @@ int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_
 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);
 #if FF_API_OLD_CHANNEL_LAYOUT
 attribute_deprecated
 int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags);
 #endif
 int av_opt_set_chlayout(void *obj, const char *name, const AVChannelLayout *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.
@ -743,10 +730,9 @@ int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, in
 /**
 * @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
+ * @note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has
- * option is of type AV_OPT_TYPE_STRING, AV_OPT_TYPE_BINARY or AV_OPT_TYPE_DICT
+ * AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set
- * and is set to NULL, *out_val will be set to NULL instead of an allocated
+ * to NULL instead of an allocated empty string.
 * 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);
@ -756,11 +742,7 @@ int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_
 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);
 #if FF_API_OLD_CHANNEL_LAYOUT
 attribute_deprecated
 int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout);
 #endif
 int av_opt_get_chlayout(void *obj, const char *name, int search_flags, AVChannelLayout *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
@ -802,16 +784,9 @@ int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags
 /**
 * Copy options from src object into dest object.
 *
 * The underlying AVClass of both src and dest must coincide. The guarantee
 * below does not apply if this is not fulfilled.
 *
 * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
 * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
 *
 * Even on error it is guaranteed that allocated options from src and dest
 * no longer alias each other afterwards; in particular calling av_opt_free()
 * on both src and dest is safe afterwards if dest has been memdup'ed from src.
 *
 * @param dest Object to copy from
 * @param src  Object to copy into
 * @return 0 on success, negative on error
--- a/output/include/arm64-v8a/libavutil/parseutils.h
+++ b/output/include/arm64-v8a/libavutil/parseutils.h
@ -79,8 +79,6 @@ int av_parse_video_rate(AVRational *rate, const char *str);
 /**
 * Put the RGBA values that correspond to color_string in rgba_color.
 *
 * @param rgba_color 4-elements array of uint8_t values, where the respective
 * red, green, blue and alpha component values are written.
 * @param color_string a string specifying a color. It can be the name of
 * a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence,
 * possibly followed by "@" and a string representing the alpha
@ -94,8 +92,6 @@ int av_parse_video_rate(AVRational *rate, const char *str);
 * @param slen length of the initial part of color_string containing the
 * color. It can be set to -1 if color_string is a null terminated string
 * containing nothing else than the color.
 * @param log_ctx a pointer to an arbitrary struct of which the first field
 * is a pointer to an AVClass struct (used for av_log()). Can be NULL.
 * @return >= 0 in case of success, a negative value in case of
 * failure (for example if color_string cannot be parsed).
 */
@ -110,7 +106,7 @@ int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
 * av_parse_color().
 *
 * @param color_idx index of the requested color, starting from 0
- * @param rgb      if not NULL, will point to a 3-elements array with the color value in RGB
+ * @param rgbp      if not NULL, will point to a 3-elements array with the color value in RGB
 * @return the color name string or NULL if color_idx is not in the array
 */
 const char *av_get_known_color_name(int color_idx, const uint8_t **rgb);
@ -166,19 +162,19 @@ int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info
 * by the standard strptime().
 *
 * The supported input field descriptors are listed below.
- * - `%%H`: the hour as a decimal number, using a 24-hour clock, in the
+ * - %H: the hour as a decimal number, using a 24-hour clock, in the
 *   range '00' through '23'
- * - `%%J`: hours as a decimal number, in the range '0' through INT_MAX
+ * - %J: hours as a decimal number, in the range '0' through INT_MAX
- * - `%%M`: the minute as a decimal number, using a 24-hour clock, in the
+ * - %M: the minute as a decimal number, using a 24-hour clock, in the
 *   range '00' through '59'
- * - `%%S`: the second as a decimal number, using a 24-hour clock, in the
+ * - %S: the second as a decimal number, using a 24-hour clock, in the
 *   range '00' through '59'
- * - `%%Y`: the year as a decimal number, using the Gregorian calendar
+ * - %Y: the year as a decimal number, using the Gregorian calendar
- * - `%%m`: the month as a decimal number, in the range '1' through '12'
+ * - %m: the month as a decimal number, in the range '1' through '12'
- * - `%%d`: the day of the month as a decimal number, in the range '1'
+ * - %d: the day of the month as a decimal number, in the range '1'
 *   through '31'
- * - `%%T`: alias for `%%H:%%M:%%S`
+ * - %T: alias for '%H:%M:%S'
- * - `%%`: a literal `%`
+ * - %%: a literal '%'
 *
 * @return a pointer to the first character not processed in this function
 *         call. In case the input string contains more characters than
--- a/output/include/arm64-v8a/libavutil/pixdesc.h
+++ b/output/include/arm64-v8a/libavutil/pixdesc.h
@ -26,6 +26,7 @@
 #include "attributes.h"
 #include "pixfmt.h"
 #include "version.h"
 typedef struct AVComponentDescriptor {
    /**
@ -55,6 +56,17 @@ typedef struct AVComponentDescriptor {
     * Number of bits in the component.
     */
    int depth;
 #if FF_API_PLUS1_MINUS1
    /** deprecated, use step instead */
    attribute_deprecated int step_minus1;
    /** deprecated, use depth instead */
    attribute_deprecated int depth_minus1;
    /** deprecated, use offset instead */
    attribute_deprecated int offset_plus1;
 #endif
 } AVComponentDescriptor;
 /**
@ -135,10 +147,24 @@ typedef struct AVPixFmtDescriptor {
 */
 #define AV_PIX_FMT_FLAG_RGB          (1 << 5)
 /**
 * The pixel format is "pseudo-paletted". This means that it contains a
 * fixed palette in the 2nd plane but the palette is fixed/constant for each
 * PIX_FMT. This allows interpreting the data as if it was PAL8, which can
 * in some cases be simpler. Or the data can be interpreted purely based on
 * the pixel format without using the palette.
 * An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
 */
 #define AV_PIX_FMT_FLAG_PSEUDOPAL    (1 << 6)
 /**
 * The pixel format has an alpha channel. This is set on all formats that
- * support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always
+ * support alpha in some way. The exception is AV_PIX_FMT_PAL8, which can
- * straight, never pre-multiplied.
+ * carry alpha as part of the palette. Details are explained in the
 * AVPixelFormat enum, and are also encoded in the corresponding
 * AVPixFmtDescriptor.
 *
 * The alpha is always straight, never pre-multiplied.
 *
 * If a codec or a filter does not support alpha, it should set all alpha to
 * opaque, or use the equivalent pixel formats without alpha component, e.g.
@ -199,6 +225,11 @@ enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc);
 * Utility function to access log2_chroma_w log2_chroma_h from
 * the pixel format AVPixFmtDescriptor.
 *
 * See av_get_chroma_sub_sample() for a function that asserts a
 * valid pixel format instead of returning an error code.
 * Its recommended that you use avcodec_get_chroma_sub_sample unless
 * you do check the return code!
 *
 * @param[in]  pix_fmt the pixel format
 * @param[out] h_shift store log2_chroma_w (horizontal/width shift)
 * @param[out] v_shift store log2_chroma_h (vertical/height shift)
@ -264,28 +295,6 @@ const char *av_chroma_location_name(enum AVChromaLocation location);
 */
 int av_chroma_location_from_name(const char *name);
 /**
 * Converts AVChromaLocation to swscale x/y chroma position.
 *
 * The positions represent the chroma (0,0) position in a coordinates system
 * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 *
 * @param xpos  horizontal chroma sample position
 * @param ypos  vertical   chroma sample position
 */
 int av_chroma_location_enum_to_pos(int *xpos, int *ypos, enum AVChromaLocation pos);
 /**
 * Converts swscale x/y chroma position to AVChromaLocation.
 *
 * The positions represent the chroma (0,0) position in a coordinates system
 * with luma (0,0) representing the origin and luma(1,1) representing 256,256
 *
 * @param xpos  horizontal chroma sample position
 * @param ypos  vertical   chroma sample position
 */
 enum AVChromaLocation av_chroma_location_pos_to_enum(int xpos, int ypos);
 /**
 * Return the pixel format corresponding to name.
 *
@ -335,13 +344,7 @@ char *av_get_pix_fmt_string(char *buf, int buf_size,
 * format writes the values corresponding to the palette
 * component c in data[1] to dst, rather than the palette indexes in
 * data[0]. The behavior is undefined if the format is not paletted.
 * @param dst_element_size size of elements in dst array (2 or 4 byte)
 */
 void av_read_image_line2(void *dst, const uint8_t *data[4],
                        const int linesize[4], const AVPixFmtDescriptor *desc,
                        int x, int y, int c, int w, int read_pal_component,
                        int dst_element_size);
 void av_read_image_line(uint16_t *dst, const uint8_t *data[4],
                        const int linesize[4], const AVPixFmtDescriptor *desc,
                        int x, int y, int c, int w, int read_pal_component);
@ -359,12 +362,7 @@ void av_read_image_line(uint16_t *dst, const uint8_t *data[4],
 * @param y the vertical coordinate of the first pixel to write
 * @param w the width of the line to write, that is the number of
 * values to write to the image line
 * @param src_element_size size of elements in src array (2 or 4 byte)
 */
 void av_write_image_line2(const void *src, uint8_t *data[4],
                         const int linesize[4], const AVPixFmtDescriptor *desc,
                         int x, int y, int c, int w, int src_element_size);
 void av_write_image_line(const uint16_t *src, uint8_t *data[4],
                         const int linesize[4], const AVPixFmtDescriptor *desc,
                         int x, int y, int c, int w);
@ -385,9 +383,6 @@ enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt);
 #define FF_LOSS_ALPHA       0x0008 /**< loss of alpha bits */
 #define FF_LOSS_COLORQUANT  0x0010 /**< loss due to color quantization */
 #define FF_LOSS_CHROMA      0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
 #define FF_LOSS_EXCESS_RESOLUTION 0x0040 /**< loss due to unneeded extra resolution */
 #define FF_LOSS_EXCESS_DEPTH      0x0080 /**< loss due to unneeded extra color depth */
 /**
 * Compute what kind of losses will occur when converting from one specific
--- a/output/include/arm64-v8a/libavutil/pixelutils.h
+++ b/output/include/arm64-v8a/libavutil/pixelutils.h
@ -21,6 +21,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include "common.h"
 /**
 * Sum of abs(src1[x] - src2[x])
--- a/output/include/arm64-v8a/libavutil/pixfmt.h
+++ b/output/include/arm64-v8a/libavutil/pixfmt.h
@ -78,6 +78,11 @@ enum AVPixelFormat {
    AV_PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
    AV_PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
    AV_PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
 #if FF_API_XVMC
    AV_PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
    AV_PIX_FMT_XVMC_MPEG2_IDCT,
    AV_PIX_FMT_XVMC = AV_PIX_FMT_XVMC_MPEG2_IDCT,
 #endif /* FF_API_XVMC */
    AV_PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
    AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
    AV_PIX_FMT_BGR8,      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
@ -99,6 +104,13 @@ enum AVPixelFormat {
    AV_PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
    AV_PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
    AV_PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
 #if FF_API_VDPAU
    AV_PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
    AV_PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
    AV_PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
    AV_PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
    AV_PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
 #endif
    AV_PIX_FMT_RGB48BE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
    AV_PIX_FMT_RGB48LE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
@ -112,11 +124,21 @@ enum AVPixelFormat {
    AV_PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian   , X=unused/undefined
    AV_PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
 #if FF_API_VAAPI
    /** @name Deprecated pixel formats */
    /**@{*/
    AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
    AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
    AV_PIX_FMT_VAAPI_VLD,  ///< HW decoding through VA API, Picture.data[3] contains a VASurfaceID
    /**@}*/
    AV_PIX_FMT_VAAPI = AV_PIX_FMT_VAAPI_VLD,
 #else
    /**
     *  Hardware acceleration through VA-API, data[3] contains a
     *  VASurfaceID.
     */
    AV_PIX_FMT_VAAPI,
 #endif
    AV_PIX_FMT_YUV420P16LE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
    AV_PIX_FMT_YUV420P16BE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
@ -124,6 +146,9 @@ enum AVPixelFormat {
    AV_PIX_FMT_YUV422P16BE,  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
    AV_PIX_FMT_YUV444P16LE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
    AV_PIX_FMT_YUV444P16BE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
 #if FF_API_VDPAU
    AV_PIX_FMT_VDPAU_MPEG4,  ///< MPEG-4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
 #endif
    AV_PIX_FMT_DXVA2_VLD,    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
    AV_PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
@ -155,6 +180,7 @@ enum AVPixelFormat {
    AV_PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
    AV_PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
    AV_PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
    AV_PIX_FMT_VDA_VLD,    ///< hardware decoding through VDA
    AV_PIX_FMT_GBRP,      ///< planar GBR 4:4:4 24bpp
    AV_PIX_FMT_GBR24P = AV_PIX_FMT_GBRP, // alias for #AV_PIX_FMT_GBRP
    AV_PIX_FMT_GBRP9BE,   ///< planar GBR 4:4:4 27bpp, big-endian
@ -199,6 +225,8 @@ enum AVPixelFormat {
    AV_PIX_FMT_YVYU422,   ///< packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
    AV_PIX_FMT_VDA,          ///< HW acceleration through VDA, data[3] contains a CVPixelBufferRef
    AV_PIX_FMT_YA16BE,       ///< 16 bits gray, 16 bits alpha (big-endian)
    AV_PIX_FMT_YA16LE,       ///< 16 bits gray, 16 bits alpha (little-endian)
@ -208,34 +236,6 @@ enum AVPixelFormat {
    /**
     *  HW acceleration through QSV, data[3] contains a pointer to the
     *  mfxFrameSurface1 structure.
     *
     * Before FFmpeg 5.0:
     * mfxFrameSurface1.Data.MemId contains a pointer when importing
     * the following frames as QSV frames:
     *
     * VAAPI:
     * mfxFrameSurface1.Data.MemId contains a pointer to VASurfaceID
     *
     * DXVA2:
     * mfxFrameSurface1.Data.MemId contains a pointer to IDirect3DSurface9
     *
     * FFmpeg 5.0 and above:
     * mfxFrameSurface1.Data.MemId contains a pointer to the mfxHDLPair
     * structure when importing the following frames as QSV frames:
     *
     * VAAPI:
     * mfxHDLPair.first contains a VASurfaceID pointer.
     * mfxHDLPair.second is always MFX_INFINITE.
     *
     * DXVA2:
     * mfxHDLPair.first contains IDirect3DSurface9 pointer.
     * mfxHDLPair.second is always MFX_INFINITE.
     *
     * D3D11:
     * mfxHDLPair.first contains a ID3D11Texture2D pointer.
     * mfxHDLPair.second contains the texture array index of the frame if the
     * ID3D11Texture2D is an array texture, or always MFX_INFINITE if it is a
     * normal texture.
     */
    AV_PIX_FMT_QSV,
    /**
@ -252,7 +252,7 @@ enum AVPixelFormat {
     */
    AV_PIX_FMT_CUDA,
-    AV_PIX_FMT_0RGB,        ///< packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
+    AV_PIX_FMT_0RGB=0x123+4,///< packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
    AV_PIX_FMT_RGB0,        ///< packed RGB 8:8:8, 32bpp, RGBXRGBX...   X=unused/undefined
    AV_PIX_FMT_0BGR,        ///< packed BGR 8:8:8, 32bpp, XBGRXBGR...   X=unused/undefined
    AV_PIX_FMT_BGR0,        ///< packed BGR 8:8:8, 32bpp, BGRXBGRX...   X=unused/undefined
@ -275,23 +275,21 @@ enum AVPixelFormat {
    AV_PIX_FMT_GBRP14LE,    ///< planar GBR 4:4:4 42bpp, little-endian
    AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
-    AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
+    AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */
-    AV_PIX_FMT_BAYER_RGGB8,    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
+    AV_PIX_FMT_BAYER_RGGB8,    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */
-    AV_PIX_FMT_BAYER_GBRG8,    ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
+    AV_PIX_FMT_BAYER_GBRG8,    ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */
-    AV_PIX_FMT_BAYER_GRBG8,    ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
+    AV_PIX_FMT_BAYER_GRBG8,    ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */
-    AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
+    AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */
-    AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
+    AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */
-    AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
+    AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */
-    AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
+    AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */
-    AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
+    AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */
-    AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
+    AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */
-    AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
+    AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */
-    AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
+    AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */
-
+#if !FF_API_XVMC
 #if FF_API_XVMC
    AV_PIX_FMT_XVMC,///< XVideo Motion Acceleration via common packet passing
-#endif
+#endif /* !FF_API_XVMC */
    AV_PIX_FMT_YUV440P10LE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
    AV_PIX_FMT_YUV440P10BE, ///< planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
    AV_PIX_FMT_YUV440P12LE, ///< planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
@ -346,79 +344,6 @@ enum AVPixelFormat {
     * data[0] points to an AVDRMFrameDescriptor.
     */
    AV_PIX_FMT_DRM_PRIME,
    /**
     * Hardware surfaces for OpenCL.
     *
     * data[i] contain 2D image objects (typed in C as cl_mem, used
     * in OpenCL as image2d_t) for each plane of the surface.
     */
    AV_PIX_FMT_OPENCL,
    AV_PIX_FMT_GRAY14BE,   ///<        Y        , 14bpp, big-endian
    AV_PIX_FMT_GRAY14LE,   ///<        Y        , 14bpp, little-endian
    AV_PIX_FMT_GRAYF32BE,  ///< IEEE-754 single precision Y, 32bpp, big-endian
    AV_PIX_FMT_GRAYF32LE,  ///< IEEE-754 single precision Y, 32bpp, little-endian
    AV_PIX_FMT_YUVA422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
    AV_PIX_FMT_YUVA422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
    AV_PIX_FMT_YUVA444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
    AV_PIX_FMT_YUVA444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
    AV_PIX_FMT_NV24,      ///< planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
    AV_PIX_FMT_NV42,      ///< as above, but U and V bytes are swapped
    /**
     * Vulkan hardware images.
     *
     * data[0] points to an AVVkFrame
     */
    AV_PIX_FMT_VULKAN,
    AV_PIX_FMT_Y210BE,    ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
    AV_PIX_FMT_Y210LE,    ///< packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
    AV_PIX_FMT_X2RGB10LE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
    AV_PIX_FMT_X2RGB10BE, ///< packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
    AV_PIX_FMT_X2BGR10LE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
    AV_PIX_FMT_X2BGR10BE, ///< packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
    AV_PIX_FMT_P210BE,      ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
    AV_PIX_FMT_P210LE,      ///< interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
    AV_PIX_FMT_P410BE,      ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
    AV_PIX_FMT_P410LE,      ///< interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
    AV_PIX_FMT_P216BE,      ///< interleaved chroma YUV 4:2:2, 32bpp, big-endian
    AV_PIX_FMT_P216LE,      ///< interleaved chroma YUV 4:2:2, 32bpp, little-endian
    AV_PIX_FMT_P416BE,      ///< interleaved chroma YUV 4:4:4, 48bpp, big-endian
    AV_PIX_FMT_P416LE,      ///< interleaved chroma YUV 4:4:4, 48bpp, little-endian
    AV_PIX_FMT_VUYA,        ///< packed VUYA 4:4:4, 32bpp, VUYAVUYA...
    AV_PIX_FMT_RGBAF16BE,   ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian
    AV_PIX_FMT_RGBAF16LE,   ///< IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian
    AV_PIX_FMT_VUYX,        ///< packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
    AV_PIX_FMT_P012LE,      ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian
    AV_PIX_FMT_P012BE,      ///< like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian
    AV_PIX_FMT_Y212BE,      ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian
    AV_PIX_FMT_Y212LE,      ///< packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian
    AV_PIX_FMT_XV30BE,      ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined
    AV_PIX_FMT_XV30LE,      ///< packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined
    AV_PIX_FMT_XV36BE,      ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined
    AV_PIX_FMT_XV36LE,      ///< packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined
    AV_PIX_FMT_RGBF32BE,    ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian
    AV_PIX_FMT_RGBF32LE,    ///< IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian
    AV_PIX_FMT_RGBAF32BE,   ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
    AV_PIX_FMT_RGBAF32LE,   ///< IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
    AV_PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
 };
@ -439,7 +364,6 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_GRAY9  AV_PIX_FMT_NE(GRAY9BE,  GRAY9LE)
 #define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
 #define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
 #define AV_PIX_FMT_GRAY14 AV_PIX_FMT_NE(GRAY14BE, GRAY14LE)
 #define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
 #define AV_PIX_FMT_YA16   AV_PIX_FMT_NE(YA16BE,   YA16LE)
 #define AV_PIX_FMT_RGB48  AV_PIX_FMT_NE(RGB48BE,  RGB48LE)
@ -488,16 +412,12 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_GBRPF32    AV_PIX_FMT_NE(GBRPF32BE,  GBRPF32LE)
 #define AV_PIX_FMT_GBRAPF32   AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
 #define AV_PIX_FMT_GRAYF32    AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE)
 #define AV_PIX_FMT_YUVA420P9  AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
 #define AV_PIX_FMT_YUVA422P9  AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
 #define AV_PIX_FMT_YUVA444P9  AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
 #define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE)
 #define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE)
 #define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE)
 #define AV_PIX_FMT_YUVA422P12 AV_PIX_FMT_NE(YUVA422P12BE, YUVA422P12LE)
 #define AV_PIX_FMT_YUVA444P12 AV_PIX_FMT_NE(YUVA444P12BE, YUVA444P12LE)
 #define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE)
 #define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE)
 #define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE)
@ -506,54 +426,35 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_NV20       AV_PIX_FMT_NE(NV20BE,  NV20LE)
 #define AV_PIX_FMT_AYUV64     AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
 #define AV_PIX_FMT_P010       AV_PIX_FMT_NE(P010BE,  P010LE)
 #define AV_PIX_FMT_P012       AV_PIX_FMT_NE(P012BE,  P012LE)
 #define AV_PIX_FMT_P016       AV_PIX_FMT_NE(P016BE,  P016LE)
 #define AV_PIX_FMT_Y210       AV_PIX_FMT_NE(Y210BE,  Y210LE)
 #define AV_PIX_FMT_Y212       AV_PIX_FMT_NE(Y212BE,  Y212LE)
 #define AV_PIX_FMT_XV30       AV_PIX_FMT_NE(XV30BE,  XV30LE)
 #define AV_PIX_FMT_XV36       AV_PIX_FMT_NE(XV36BE,  XV36LE)
 #define AV_PIX_FMT_X2RGB10    AV_PIX_FMT_NE(X2RGB10BE, X2RGB10LE)
 #define AV_PIX_FMT_X2BGR10    AV_PIX_FMT_NE(X2BGR10BE, X2BGR10LE)
 #define AV_PIX_FMT_P210       AV_PIX_FMT_NE(P210BE, P210LE)
 #define AV_PIX_FMT_P410       AV_PIX_FMT_NE(P410BE, P410LE)
 #define AV_PIX_FMT_P216       AV_PIX_FMT_NE(P216BE, P216LE)
 #define AV_PIX_FMT_P416       AV_PIX_FMT_NE(P416BE, P416LE)
 #define AV_PIX_FMT_RGBAF16    AV_PIX_FMT_NE(RGBAF16BE, RGBAF16LE)
 #define AV_PIX_FMT_RGBF32     AV_PIX_FMT_NE(RGBF32BE, RGBF32LE)
 #define AV_PIX_FMT_RGBAF32    AV_PIX_FMT_NE(RGBAF32BE, RGBAF32LE)
 /**
  * Chromaticity coordinates of the source primaries.
-  * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273.
+  * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1.
  */
 enum AVColorPrimaries {
    AVCOL_PRI_RESERVED0   = 0,
-    AVCOL_PRI_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
+    AVCOL_PRI_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
    AVCOL_PRI_UNSPECIFIED = 2,
    AVCOL_PRI_RESERVED    = 3,
    AVCOL_PRI_BT470M      = 4,  ///< also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
    AVCOL_PRI_BT470BG     = 5,  ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
    AVCOL_PRI_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
-    AVCOL_PRI_SMPTE240M   = 7,  ///< identical to above, also called "SMPTE C" even though it uses D65
+    AVCOL_PRI_SMPTE240M   = 7,  ///< functionally identical to above
    AVCOL_PRI_FILM        = 8,  ///< colour filters using Illuminant C
    AVCOL_PRI_BT2020      = 9,  ///< ITU-R BT2020
    AVCOL_PRI_SMPTE428    = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
    AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
    AVCOL_PRI_SMPTE431    = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
    AVCOL_PRI_SMPTE432    = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
-    AVCOL_PRI_EBU3213     = 22, ///< EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors
+    AVCOL_PRI_JEDEC_P22   = 22, ///< JEDEC P22 phosphors
    AVCOL_PRI_JEDEC_P22   = AVCOL_PRI_EBU3213,
    AVCOL_PRI_NB                ///< Not part of ABI
 };
 /**
 * Color Transfer Characteristic.
- * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2.
+ * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2.
 */
 enum AVColorTransferCharacteristic {
    AVCOL_TRC_RESERVED0    = 0,
@ -582,18 +483,18 @@ enum AVColorTransferCharacteristic {
 /**
 * YUV colorspace type.
- * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3.
+ * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3.
 */
 enum AVColorSpace {
-    AVCOL_SPC_RGB         = 0,  ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
+    AVCOL_SPC_RGB         = 0,  ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
-    AVCOL_SPC_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
+    AVCOL_SPC_BT709       = 1,  ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
    AVCOL_SPC_UNSPECIFIED = 2,
-    AVCOL_SPC_RESERVED    = 3,  ///< reserved for future use by ITU-T and ISO/IEC just like 15-255 are
+    AVCOL_SPC_RESERVED    = 3,
    AVCOL_SPC_FCC         = 4,  ///< FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
    AVCOL_SPC_BT470BG     = 5,  ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
-    AVCOL_SPC_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
+    AVCOL_SPC_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
-    AVCOL_SPC_SMPTE240M   = 7,  ///< derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
+    AVCOL_SPC_SMPTE240M   = 7,  ///< functionally identical to above
-    AVCOL_SPC_YCGCO       = 8,  ///< used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+    AVCOL_SPC_YCGCO       = 8,  ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
    AVCOL_SPC_YCOCG       = AVCOL_SPC_YCGCO,
    AVCOL_SPC_BT2020_NCL  = 9,  ///< ITU-R BT2020 non-constant luminance system
    AVCOL_SPC_BT2020_CL   = 10, ///< ITU-R BT2020 constant luminance system
@ -605,60 +506,12 @@ enum AVColorSpace {
 };
 /**
- * Visual content value range.
+ * MPEG vs JPEG YUV range.
 *
 * These values are based on definitions that can be found in multiple
 * specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance
 * and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital
 * Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit
 * integer representation). At the time of writing, the BT.2100 one is
 * recommended, as it also defines the full range representation.
 *
 * Common definitions:
 *   - For RGB and luma planes such as Y in YCbCr and I in ICtCp,
 *     'E' is the original value in range of 0.0 to 1.0.
 *   - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original
 *     value in range of -0.5 to 0.5.
 *   - 'n' is the output bit depth.
 *   - For additional definitions such as rounding and clipping to valid n
 *     bit unsigned integer range, please refer to BT.2100 (Table 9).
 */
 enum AVColorRange {
    AVCOL_RANGE_UNSPECIFIED = 0,
-
+    AVCOL_RANGE_MPEG        = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges
-    /**
+    AVCOL_RANGE_JPEG        = 2, ///< the normal     2^n-1   "JPEG" YUV ranges
     * Narrow or limited range content.
     *
     * - For luma planes:
     *
     *       (219 * E + 16) * 2^(n-8)
     *
     *   F.ex. the range of 16-235 for 8 bits
     *
     * - For chroma planes:
     *
     *       (224 * E + 128) * 2^(n-8)
     *
     *   F.ex. the range of 16-240 for 8 bits
     */
    AVCOL_RANGE_MPEG        = 1,
    /**
     * Full range content.
     *
     * - For RGB and luma planes:
     *
     *       (2^n - 1) * E
     *
     *   F.ex. the range of 0-255 for 8 bits
     *
     * - For chroma planes:
     *
     *       (2^n - 1) * E + 2^(n - 1)
     *
     *   F.ex. the range of 1-255 for 8 bits
     */
    AVCOL_RANGE_JPEG        = 2,
    AVCOL_RANGE_NB               ///< Not part of ABI
 };
--- a/output/include/arm64-v8a/libavutil/rational.h
+++ b/output/include/arm64-v8a/libavutil/rational.h
@ -179,8 +179,7 @@ AVRational av_d2q(double d, int max) av_const;
 * Find which of the two rationals is closer to another rational.
 *
 * @param q     Rational to be compared against
- * @param q1    Rational to be tested
+ * @param q1,q2 Rationals to be tested
 * @param q2    Rational to be tested
 * @return One of the following values:
 *         - 1 if `q1` is nearer to `q` than `q2`
 *         - -1 if `q2` is nearer to `q` than `q1`
@ -208,12 +207,6 @@ int av_find_nearest_q_idx(AVRational q, const AVRational* q_list);
 */
 uint32_t av_q2intfloat(AVRational q);
 /**
 * Return the best rational so that a and b are multiple of it.
 * If the resulting denominator is larger than max_den, return def.
 */
 AVRational av_gcd_q(AVRational a, AVRational b, int max_den, AVRational def);
 /**
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/rc4.h
+++ b/output/include/arm64-v8a/libavutil/rc4.h
@ -42,8 +42,6 @@ AVRC4 *av_rc4_alloc(void);
 /**
 * @brief Initializes an AVRC4 context.
 *
 * @param d pointer to the AVRC4 context
 * @param key buffer containig the key
 * @param key_bits must be a multiple of 8
 * @param decrypt 0 for encryption, 1 for decryption, currently has no effect
 * @return zero on success, negative value otherwise
@ -53,7 +51,6 @@ int av_rc4_init(struct AVRC4 *d, const uint8_t *key, int key_bits, int decrypt);
 /**
 * @brief Encrypts / decrypts using the RC4 algorithm.
 *
 * @param d pointer to the AVRC4 context
 * @param count number of bytes
 * @param dst destination array, can be equal to src
 * @param src source array, can be equal to dst, may be NULL
--- a/output/include/arm64-v8a/libavutil/ripemd.h
+++ b/output/include/arm64-v8a/libavutil/ripemd.h
@ -28,10 +28,10 @@
 #ifndef AVUTIL_RIPEMD_H
 #define AVUTIL_RIPEMD_H
 #include <stddef.h>
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_ripemd RIPEMD
@ -66,7 +66,7 @@ int av_ripemd_init(struct AVRIPEMD* context, int bits);
 * @param data    input data to update hash with
 * @param len     input data length
 */
-void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, size_t len);
+void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, unsigned int len);
 /**
 * Finish hashing and output digest value.
--- a/output/include/arm64-v8a/libavutil/samplefmt.h
+++ b/output/include/arm64-v8a/libavutil/samplefmt.h
@ -21,6 +21,9 @@
 #include <stdint.h>
 #include "avutil.h"
 #include "attributes.h"
 /**
 * @addtogroup lavu_audio
 * @{
@ -192,8 +195,9 @@ int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,
 * @param nb_samples       the number of samples in a single channel
 * @param sample_fmt       the sample format
 * @param align            buffer size alignment (0 = default, 1 = no alignment)
- * @return                 minimum size in bytes required for the buffer on success,
+ * @return                 >=0 on success or a negative error code on failure
- *                         or a negative error code on failure
+ * @todo return minimum size in bytes required for the buffer in case
 * of success at the next bump
 */
 int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
                           const uint8_t *buf,
@ -213,7 +217,6 @@ int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,
 * @param[out] linesize    aligned size for audio buffer(s), may be NULL
 * @param nb_channels      number of audio channels
 * @param nb_samples       number of samples per channel
 * @param sample_fmt       the sample format
 * @param align            buffer size alignment (0 = default, 1 = no alignment)
 * @return                 >=0 on success or a negative error code on failure
 * @todo return the size of the allocated buffer in case of success at the next bump
--- a/output/include/arm64-v8a/libavutil/sha.h
+++ b/output/include/arm64-v8a/libavutil/sha.h
@ -31,6 +31,7 @@
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_sha SHA
@ -73,7 +74,11 @@ int av_sha_init(struct AVSHA* context, int bits);
 * @param data    input data to update hash with
 * @param len     input data length
 */
 #if FF_API_CRYPTO_SIZE_T
 void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len);
 #else
 void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len);
 #endif
 /**
 * Finish hashing and output digest value.
--- a/output/include/arm64-v8a/libavutil/sha512.h
+++ b/output/include/arm64-v8a/libavutil/sha512.h
@ -32,6 +32,7 @@
 #include <stdint.h>
 #include "attributes.h"
 #include "version.h"
 /**
 * @defgroup lavu_sha512 SHA-512
@ -75,7 +76,11 @@ int av_sha512_init(struct AVSHA512* context, int bits);
 * @param data    input data to update hash with
 * @param len     input data length
 */
 #if FF_API_CRYPTO_SIZE_T
 void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len);
 #else
 void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len);
 #endif
 /**
 * Finish hashing and output digest value.
--- a/output/include/arm64-v8a/libavutil/spherical.h
+++ b/output/include/arm64-v8a/libavutil/spherical.h
@ -20,7 +20,6 @@
 /**
 * @file
 * @ingroup lavu_video_spherical
 * Spherical video
 */
@ -31,14 +30,19 @@
 #include <stdint.h>
 /**
- * @defgroup lavu_video_spherical Spherical video mapping
+ * @addtogroup lavu_video
- * @ingroup lavu_video
+ * @{
 *
 * @defgroup lavu_video_spherical Spherical video mapping
 * @{
 */
 /**
 * @addtogroup lavu_video_spherical
 * A spherical video file contains surfaces that need to be mapped onto a
 * sphere. Depending on how the frame was converted, a different distortion
 * transformation or surface recomposition function needs to be applied before
 * the video should be mapped and displayed.
 * @{
 */
 /**
@ -221,6 +225,7 @@ const char *av_spherical_projection_name(enum AVSphericalProjection projection);
 */
 int av_spherical_from_name(const char *name);
 /**
 * @}
 * @}
 */
--- a/output/include/arm64-v8a/libavutil/stereo3d.h
+++ b/output/include/arm64-v8a/libavutil/stereo3d.h
@ -20,7 +20,6 @@
 /**
 * @file
 * @ingroup lavu_video_stereo3d
 * Stereoscopic video
 */
@ -32,15 +31,19 @@
 #include "frame.h"
 /**
- * @defgroup lavu_video_stereo3d Stereo3D types and functions
+ * @addtogroup lavu_video
- * @ingroup lavu_video
+ * @{
 *
 * @defgroup lavu_video_stereo3d Stereo3D types and functions
 * @{
 */
 /**
 * @addtogroup lavu_video_stereo3d
 * A stereoscopic video file consists in multiple views embedded in a single
 * frame, usually describing two views of a scene. This file describes all
 * possible codec-independent view arrangements.
- *
+ * */
 * @{
 */
 /**
 * List of possible 3D Types
@ -138,25 +141,6 @@ enum AVStereo3DType {
    AV_STEREO3D_COLUMNS,
 };
 /**
 * List of possible view types.
 */
 enum AVStereo3DView {
    /**
     * Frame contains two packed views.
     */
    AV_STEREO3D_VIEW_PACKED,
    /**
     * Frame contains only the left view.
     */
    AV_STEREO3D_VIEW_LEFT,
    /**
     * Frame contains only the right view.
     */
    AV_STEREO3D_VIEW_RIGHT,
 };
 /**
 * Inverted views, Right/Bottom represents the left view.
@ -180,11 +164,6 @@ typedef struct AVStereo3D {
     * Additional information about the frame packing.
     */
    int flags;
    /**
     * Determines which views are packed.
     */
    enum AVStereo3DView view;
 } AVStereo3D;
 /**
@ -223,6 +202,7 @@ const char *av_stereo3d_type_name(unsigned int type);
 int av_stereo3d_from_name(const char *name);
 /**
 * @}
 * @}
 */
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
luoye	aac3f8dc83	bug fix encoder=libmp3lame	1 year ago
luoye	cdf8257a11	bug fix encoder=libmp3lame	1 year ago
luoye	fe6eed6207	add so	2 years ago