Bug 1745284 Update bundled ffmpeg58 headers to 4.4.1 in order to work with AV1... (67f17519) · Commits · The Tor Project / Applications / Tor Browser

dom/media/platforms/ffmpeg/ffmpeg58/include/libavcodec/avcodec.h

+288 −2250

File changed.

Preview size limit exceeded, changes collapsed.

dom/media/platforms/ffmpeg/ffmpeg58/include/libavcodec/bsf.h

0 → 100644

+325 −0

Original line number	Diff line number	Diff line
		/*
		* 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"

		/**
		* @addtogroup lavc_core
		* @{
		*/

		typedef struct AVBSFInternal AVBSFInternal;

		/**
		* 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 libavcodec internal data. Must not be touched by the caller in any
		* way.
		*/
		AVBSFInternal *internal;

		/**
		* 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;

		/*****************************************************************
		* No fields below this line are part of the public API. They
		* may not be used outside of libavcodec and can be changed and
		* removed at will.
		* New public fields should be added right above.
		*****************************************************************
		*/

		int priv_data_size;
		int (init)(AVBSFContext ctx);
		int (filter)(AVBSFContext ctx, AVPacket *pkt);
		void (close)(AVBSFContext ctx);
		void (flush)(AVBSFContext ctx);
		} 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 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.
		*/
		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 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[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

dom/media/platforms/ffmpeg/ffmpeg58/include/libavcodec/codec.h

0 → 100644

+480 −0

File added.

Preview size limit exceeded, changes collapsed.

dom/media/platforms/ffmpeg/ffmpeg58/include/libavcodec/codec_desc.h

0 → 100644

+128 −0

Original line number	Diff line number	Diff line
		/*
		* 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

dom/media/platforms/ffmpeg/ffmpeg58/include/libavcodec/codec_id.h

0 → 100644

+629 −0

File added.

Preview size limit exceeded, changes collapsed.