70쀆MCA:0 0 0 K FEH%FRV=xoyLGv̶j/5& 8$EX$A (1B4֖d lso absolutely be * avoided that the current state is "unstable" and can "flip-flop" between * the send/receive APIs allowing progress. For example, it's not allowed that * the codec randomly decides that it actually wants to consume a packet now * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an * avcodec_send_packet() call. * @} */ /** * @defgroup lavc_core Core functions/structures. * @ingroup libavc * * Basic definitions, functions for querying libavcodec capabilities, * allocating core structures, etc. * @{ */ /** * @ingroup lavc_encoding */ typedef struct RcOverride{ int start_frame; int end_frame; int qscale; // If this is 0 then quality_factor will be used instead. float qual** * IAMF Recon Gain Info Parameter Data associated with the audio frame. This * metadata is in the form of the AVIAMFParamDefinition struct and contains * information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model * and Formats standard. */ AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM, /** * Ambient viewing environment metadata, as defined by H.274. This metadata * should be associated with a video stream and contains data in the form * of the AVAmbientViewingEnvironment struct. */ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT, /** * The number of pixels to discard from the top/bottom/left/right border of the * decoded frame to obtain the sub-rectangle intended for presentation. * * @code * u32le crop_top * u32le crop_bottom * u32le crop_left * u32le crop_right * @endcode */ AV_PKT_DATA_FRAME_CROPPING, /** * Raw LCEVC payload data, as a uint8_t array, with NAL emulation * bytes intact. */ AV_PKT_DATA_LCEVC, /** * This side data contains information about the reference display width(s) * and reference viewing distance(s) as well as information about the * corresponding reference stereo pair(s), i.e., the pair(s) of views to be * displayed for the viewer's left and right eyes on the reference display * at the reference viewing distance. * The payload is the AV3DReferenceDisplaysInfo struct defined in * libavutil/tdrdi.h. */ AV_PKT_DATA_3D_REFERENCE_DISPLAYS, /** * Contains the last received RTCP SR (Sender Report) information * in the form of the AVRTCPSenderReport struct. */ AV_PKT_DATA_RTCP_SR, /** * Extensible image file format metadata. The payload is a buffer containing * EXIF metadata, starting with either 49 49 2a 00, or 4d 4d 00 2a. */ AV_PKT_DATA_EXIF, /** * The number of side data types. * This is notto Dirac Decoder/Encoder * @author Marco Gerards * @author David Conrad * @author Jordi Ortiz */ #include #include #include "libavutil/pixfmt.h" #include "libavutil/rational.h" /** * The spec limits the number of wavelet decompositions to 4 for both * level 1 (VC-2) and 128 (long-gop default). * 5 decompositions is the maximum before >16-bit buffers are needed. * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting * the others to 4 decompositions (or 3 for the fidelity filter). * * We use this instead of MAX_DECOMPOSITIONS to save some memory. */ #define MAX_DWT_LEVELS 5 /** * Parse code values: * * Dirac Specification -> * 9.6.1 Table 9.1 * * VC-2 Specification -> * 10.4.1 Table 10.1 */ enum DiracParseCodes { DIRAC_PCODE_SEQ_HEADER = 0x00, DIRAC_PCODE_END_SEQ = 0x10, DIRAC_PCODE_AUX = 0x20, DIRAC_PCODE_PAD = 0x30, DIRAC_PCODE_PICTURE_CODED = 0x08, DIRAC_PCODE_PICTURE_RAW = 0x48, DIRAC_PCODE_PICTURE_LOW_DEL = 0xC8, DIRAC_PCODE_PICTURE_HQ = 0xE8, DIRAC_PCODE_INTER_NOREF_CO1 = 0x0A, DIRAC_PCODE_INTER_NOREF_CO2 = 0x09, DIRAC_PCODE_INTER_REF_CO1 = 0x0D, DIRAC_PCODE_INTER_REF_CO2 = 0x0E, DIRAC_PCODE_INTRA_REF_CO = 0x0C, DIRAC_PCODE_INTRA_REF_RAW = 0x4C, DIRAC_PCODE_INTRA_REF_PICT = 0xCC, DIRAC_PCODE_MAGIC = 0x42424344, }; typedef struct DiracVersionInfo { int major; int minor; } DiracVersionInfo; typedef struct AVDiracSeqHeader { unsigned width; unsigned height; uint8_t chroma_format; ///< 0: 444 1: 422 2: 420 uint8_t interlaced; uint8_t top_field_first; uint8_t frame_rate_index; ///< index into dirac_frame_rate[] uint8_t aspect_ratio_index; ///< index into dirac_aspect_ratio[] uint16_t clean_width; uint16_t clean_height; uint16_t clean_left_offset; uint16_t clean_right_offset; 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. #define AV_PROFILE_UNKNOWN -99 #define AV_PROFILE_RESERVED -100 #define AV_PROFILE_AAC_MAIN 0 #define AV_PROFILE_AAC_LOW 1 #define AV_PROFILE_AAC_SSR 2 #define AV_PROFILE_AAC_LTP 3 #define AV_PROFILE_AAC_HE 4 #define AV_PROFILE_AAC_HE_V2 28 #define AV_PROFILE_AAC_LD 22 #define AV_PROFILE_AAC_ELD 38 #define AV_PROFILE_AAC_USAC 41 #define AV_PROFILE_MPEG2_AAC_LOW 128 #dePACITY \ (AV_SMPTE_291M_ANC_PAYLOAD_CAPACITY + 4) /* 4 for did, sdid_or_dbn, data_count, and checksum */ /** max number of bytes that can be stored in the payload of AVSmpte436mCodedAnc */ #define AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY (((AV_SMPTE_436M_CODED_ANC_SAMPLE_CAPACITY + 2) / 3) * 4) /** * An encoded ANC packet within a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data. * The repeated section of Table 7 (page 13) of: * https://pub.smpte.org/latest/st436/s436m-2006.pdf */ typedef struct AVSmpte436mCodedAnc { uint16_t line_number; AVSmpte436mWrappingType wrapping_type; AVSmpte436mPayloadSampleCoding payload_sample_coding; uint16_t payload_sample_count; uint32_t payload_array_length; /** the payload, has size payload_array_length. * can be decoded into AVSmpte291mAnc8bit */ uint8_t payload[AV_SMPTE_436M_CODED_ANC_PAYLOAD_CAPACITY]; } AVSmpte436mCodedAnc; /** * Validate a AVSmpte436mCodedAnc structure. Doesn't check if the payload is valid. * @param[in] anc ANC packet to validate * @return 0 on success, AVERROR codes otherwise. */ int av_smpte_436m_coded_anc_validate(const AVSmpte436mCodedAnc *anc); /** * Encode ANC packets into a single AV_CODEC_ID_SMPTE_436M_ANC AVPacket's data. * @param[in] anc_packet_count number of ANC packets to encode * @param[in] anc_packets the ANC packets to encode * @param[in] size the size of out. ignored if out is NULL. * @param[out] out Output bytes. Doesn't write anything if out is NULL. * @return the number of bytes written on success, AVERROR codes otherwise. * If out is NULL, returns the number of bytes it would have written. */ int av_smpte_436m_anc_encode(uint8_t *out, int size, int anc_packet_count, const AVSmpte436mCodedAnc *anc_packets); struct AVPacket; /** * Append more ANC packets to a siEC_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, AV_CODEC_ID_AC4, AV_CODEC_ID_OSQ, AV_CODEC_ID_QOA, AV_CODEC_ID_LC3, AV_CODEC_ID_G728, AV_CODEC_ID_AHX, /* 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, AV_CODEC_ID_IVTV_VBI, /* 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_SMPTE_2038, AV_CODEC_ID_LCEVC, AV_CODEC_ID_SMPTE_436M_ANC, 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 e 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. Number of frames per second, for streams with constant frame * durations. Should be set to { 0, 1 } when some frames have differing * durations or if the value is not known. * * @note This field corresponds to values that are stored in codec-level * headers and is typically overridden by container/transport-layer * timestamps, when available. It should thus be used only as a last resort, * when no higher-level timing information is available. directory read context. * @return >=0 on success or negative on error. */ int avio_close_dir(AVIODirContext **s); /** * Free entry allocated by avio_read_dir(). * * @param entry entry to be freed. */ void avio_free_directory_entry(AVIODirEntry **entry); /** * Allocate and initialize an AVIOContext for buffered I/O. It must be later * freed with avio_context_free(). * * @param buffer Memory block for input/output operations via AVIOContext. * The buffer must be allocated with av_malloc() and friends. * It may be freed and replaced with a new buffer by libavformat. * AVIOContext.buffer holds the buffer currently in use, * which must be later freed with av_free(). * @param buffer_size The buffer size is very important for performance. * For protocols with fixed blocksize it should be set to this blocksize. * For others a typical size is a cache page, e.g. 4kb. * @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. * * @return Allocated AVIOContext or NULL on failure. */ AVIOContext *avio_alloc_context( unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), int (*write_packet)(void *opaque, const uint8_t *buf, int buf_size), int64_t (*seek)(void *opaque, int64_t offset, int whence)); /** * Free the supplied IO cor buffering requirements. Typically * means the end of a packet. */ AVIO_DATA_MARKER_FLUSH_POINT, }; /** * Bytestream IO Context. * New public fields can be added with minor version bumps. * Removal, reordering and changes to existing public fields require * a major version bump. * sizeof(AVIOContext) must not be used outside libav*. * * @note None of the function pointers in AVIOContext should be called * directly, they should only be set by the client application * when implementing custom I/O. Normally these are set to the * function pointers specified in avio_alloc_context() */ typedef struct AVIOContext { /** * A class for private options. * * If this AVIOContext is created by avio_open2(), av_class is set and * passes the options down to protocols. * * If this AVIOContext is manually allocated, then av_class may be set by * the caller. * * warning -- this field can be NULL, be sure to not pass this AVIOContext * to any av_opt_* functions in that case. */ const AVClass *av_class; /* * The following shows the relationship between buffer, buf_ptr, * buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing * (since AVIOContext is used for both): * ********************************************************************************** * READING ********************************************************************************** * * | buffer_size | * |---------------------------------------| * | | * * buffer buf_ptr buf_end * +---------------+-----------------------+ * |/ / / / / / / /|/ / / / / / /| * indicate a user-triggered event. The muxer will clear the flags for * events it has handled in av_[interleaved]_write_frame(). */ int event_flags; /** * - demuxing: the demuxer read new metadata from the file and updated * AVStream.metadata accordingly * - muxing: the user updated AVStream.metadata and wishes the muxer to write * it into the file */ #define AVSTREAM_EVENT_FLAG_METADATA_UPDATED 0x0001 /** * - demuxing: new packets for this stream were read from the file. This * event is informational only and does not guarantee that new packets * for this stream will necessarily be returned from av_read_frame(). */ #define AVSTREAM_EVENT_FLAG_NEW_PACKETS (1 << 1) /** * Real base framerate of the stream. * This is the lowest framerate with which all timestamps can be * represented accurately (it is the least common multiple of all * framerates in the stream). Note, this value is just a guess! * For example, if the time base is 1/90000 and all frames have either * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1. */ AVRational r_frame_rate; /** * Number of bits in timestamps. Used for wrapping control. * * - demuxing: set by libavformat * - muxing: set by libavformat * */ int pts_wrap_bits; } AVStream; /** * AVStreamGroupTileGrid holds information on how to combine several * independent images on a single canvas for presentation. * * The output should be a @ref AVStreamGroupTileGrid.background "background" * colored @ref AVStreamGroupTileGrid.coded_width "coded_width" x * @ref AVStreamGroupTileGrid.coded_height "coded_height" canvas where a * @ref AVStreamGroupTileGrid.nb_tiles "nb_tiles" amount of tiles are placed in * the order they appear in the @ref AVStreamGroupTileGrid.offsets "offsets" * array, at the exact offset described for them. In particular, if two or more * tiles overlap, the image with higher is a realloc * which is inefficient. Thus this function should only be used * when there is no reasonable way to know (an upper bound of) * the final size. * * @param s associated IO context * @param pkt packet * @param size amount of data to read * @return >0 (read size) if OK, AVERROR_xxx otherwise, previous data * will not be lost even if an error occurs. */ int av_append_packet(AVIOContext *s, AVPacket *pkt, int size); /*************************************************/ /* input/output formats */ struct AVCodecTag; /** * This structure contains the data a format has to probe a file. */ typedef struct AVProbeData { const char *filename; unsigned char *buf; /**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. */ int buf_size; /**< Size of buf except extra allocated bytes */ const char *mime_type; /**< mime_type, when known. */ } AVProbeData; #define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4) #define AVPROBE_SCORE_STREAM_RETRY (AVPROBE_SCORE_MAX/4-1) #define AVPROBE_SCORE_EXTENSION 50 ///< score for file extension #define AVPROBE_SCORE_MIME_BONUS 30 ///< score added for matching mime type #define AVPROBE_SCORE_MAX 100 ///< maximum score #define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer /// Demuxer will use avio_open, no opened file should be provided by the caller. #define AVFMT_NOFILE 0x0001 #define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */ /** * The muxer/demuxer is experimental and should be used with caution. * * It will not be selected automatically, and must be specified explicitly. */ #define AVFMT_EXPERIMENTAL 0x0004 #define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */ #define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */ #define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */ #define AVFMT_GENERIC_INDEX 0x0100 /**< UsPacket.stream_index. This packet may be passed straight into the libavcodec * decoding functions avcodec_send_packet() or avcodec_decode_subtitle2() if the * caller wishes to decode the data. * * AVPacket.pts, AVPacket.dts and AVPacket.duration timing information will be * set if known. They may also be unset (i.e. AV_NOPTS_VALUE for * pts/dts, 0 for duration) if the stream does not provide them. The timing * information will be in AVStream.time_base units, i.e. it has to be * multiplied by the timebase to convert them to seconds. * * A packet returned by av_read_frame() is always reference-counted, * i.e. AVPacket.buf is set and the user may keep it indefinitely. * The packet must be freed with av_packet_unref() when it is no * longer needed. * * @section lavf_decoding_seek Seeking * @} * * @defgroup lavf_encoding Muxing * @{ * Muxers take encoded data in the form of @ref AVPacket "AVPackets" and write * it into files or other output bytestreams in the specified container format. * * The main API functions for muxing are avformat_write_header() for writing the * file header, av_write_frame() / av_interleaved_write_frame() for writing the * packets and av_write_trailer() for finalizing the file. * * At the beginning of the muxing process, the caller must first call * avformat_alloc_context() to create a muxing context. The caller then sets up * the muxer by filling the various fields in this context: * * - The @ref AVFormatContext.oformat "oformat" field must be set to select the * muxer that will be used. * - Unless the format is of the AVFMT_NOFILE type, the @ref AVFormatContext.pb * "pb" field must be set to an opened IO context, either returned from * avio_open2() or a custom one. * - Unless the format is of the AVFMT_NOSTREAMS type, at least one stream must * be created with the avformat_new_stream() function. The caller should fill * the @ref AVStream.codecpar "stream codec parameters" information, such as the T_NE(RGBF32BE, RGBF32LE) #define AV_PIX_FMT_RGBAF32 AV_PIX_FMT_NE(RGBAF32BE, RGBAF32LE) #define AV_PIX_FMT_RGB96 AV_PIX_FMT_NE(RGB96BE, RGB96LE) #define AV_PIX_FMT_RGBA128 AV_PIX_FMT_NE(RGBA128BE, RGBA128LE) /** * 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. */ 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_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_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 = AVCOL_PRI_EBU3213, AVCOL_PRI_NB, ///< Not part of ABI /* The following entries are not part of H.273, but custom extensions */ AVCOL_PRI_EXT_BASE = 256, AVCOL_PRI_V_GAMUT = AVCOL_PRI_EXT_BASE, AVCOL_PRI_EXT_NB ///< Not part of ABI }; /** * Color Transfer Characteristic. * These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2. */ enum AVColorTransferCharacteristic { AVCOL_TRC_RESERVED0 = 0, AV_PIX_FMT_P212LE, ///< interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian AV_PIX_FMT_P412BE, ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian AV_PIX_FMT_P412LE, ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian AV_PIX_FMT_GBRAP14BE, ///< planar GBR 4:4:4:4 56bpp, big-endian AV_PIX_FMT_GBRAP14LE, ///< planar GBR 4:4:4:4 56bpp, little-endian /** * Hardware surfaces for Direct3D 12. * * data[0] points to an AVD3D12VAFrame */ AV_PIX_FMT_D3D12, AV_PIX_FMT_AYUV, ///< packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV... AV_PIX_FMT_UYVA, ///< packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA... AV_PIX_FMT_VYU444, ///< packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU... AV_PIX_FMT_V30XBE, ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), big-endian AV_PIX_FMT_V30XLE, ///< packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian AV_PIX_FMT_RGBF16BE, ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., big-endian AV_PIX_FMT_RGBF16LE, ///< IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., little-endian AV_PIX_FMT_RGBA128BE, ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian AV_PIX_FMT_RGBA128LE, ///< packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian AV_PIX_FMT_RGB96BE, ///< packed RGBA 32:32:32, 96bpp, RGBRGB..., big-endian AV_PIX_FMT_RGB96LE, ///< packed RGBA 32:32:32, 96bpp, RGBRGB..., little-endian AV_PIX_FMT_Y216BE, ///< packed YUV 4:2:2 like YUYV422, 32bpp, big-endian AV_PIX_FMT_Y216LE, ///< packed YUV 4:2:2 like YUYV422, 32bpp, little-endian AV_PIX_FMT_XV48BE, ///< packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefi_PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits AV_PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) AV_PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 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_NV21, ///< as above, but U and V bytes are swapped AV_PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB... AV_PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA... AV_PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR... AV_PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA... AV_PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian AV_PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian 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) 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 AV_PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian AV_PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian AV_PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined AV_PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined AV_PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), t surface using * equirectangular projection. */ AV_SPHERICAL_EQUIRECTANGULAR, /** * Video frame is split into 6 faces of a cube, and arranged on a * 3x2 layout. Faces are oriented upwards for the front, left, right, * and back faces. The up face is oriented so the top of the face is * forwards and the down face is oriented so the top of the face is * to the back. */ AV_SPHERICAL_CUBEMAP, /** * Video represents a portion of a sphere mapped on a flat surface * using equirectangular projection. The @ref bounding fields indicate * the position of the current video in a larger surface. */ AV_SPHERICAL_EQUIRECTANGULAR_TILE, /** * Video frame displays as a 180 degree equirectangular projection. */ AV_SPHERICAL_HALF_EQUIRECTANGULAR, /** * Video frame displays on a flat, rectangular 2D surface. */ AV_SPHERICAL_RECTILINEAR, /** * Fisheye projection (Apple). * See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/fisheye */ AV_SPHERICAL_FISHEYE, /** * Parametric Immersive projection (Apple). * See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/parametricimmersive */ AV_SPHERICAL_PARAMETRIC_IMMERSIVE, }; /** * This structure describes how to handle spherical videos, outlining * information about projection, initial layout, and any other view modifier. * * @note The struct must be allocated with av_spherical_alloc() and * its size is not a part of the public ABI. */ typedef struct AVSphericalMapping { /** * Projection type. */ enum AVSphericalProjection projection; /** * @name Initial orientation * @{ * There fields describe additional rotations applied to the sphere after * the video frame is mapped onto it. The sphere is rotated around the * viewer, who remains stationary. The order of transformation is alws for you. It provides a generic, * reusable API for @ref lavu_hash "all hash functions" implemented in libavutil. * If you just need to use one particular hash function, use the @ref lavu_hash * "individual hash" directly. * * @section Sample Code * * A basic template for using the Generic Hashing API follows: * * @code * struct AVHashContext *ctx = NULL; * const char *hash_name = NULL; * uint8_t *output_buf = NULL; * * // Select from a string returned by av_hash_names() * hash_name = ...; * * // Allocate a hash context * ret = av_hash_alloc(&ctx, hash_name); * if (ret < 0) * return ret; * * // Initialize the hash context * av_hash_init(ctx); * * // Update the hash context with data * while (data_left) { * av_hash_update(ctx, data, size); * } * * // Now we have no more data, so it is time to finalize the hash and get the * // output. But we need to first allocate an output buffer. Note that you can * // use any memory allocation function, including malloc(), not just * // av_malloc(). * output_buf = av_malloc(av_hash_get_size(ctx)); * if (!output_buf) * return AVERROR(ENOMEM); * * // Finalize the hash context. * // You can use any of the av_hash_final*() functions provided, for other * // output formats. If you do so, be sure to adjust the memory allocation * // above. See the function documentation below for the exact amount of extra * // memory needed. * av_hash_final(ctx, output_buffer); * * // Free the context * av_hash_freep(&ctx); * @endcode * * @section Hash Function-Specific Information * If the CRC32 hash is selected, the #AV_CRC_32_IEEE polynomial will be * used. * * If the Murmur3 hash is selected, the default seed will be used. See @ref * lavu_murmur3_seedinfo "Murmur3" for more information. * * @{ */ /** * @example ffhash.c * This example is a simple command line application that takes one or more * arguments. It demonstrates a typical use of the hashing API with allocation, * ng and we will crash now. */ #define AV_LOG_PANIC 0 /** * Something went wrong and recovery is not possible. * For example, no header was found for a format which depends * on headers or an illegal combination of parameters is used. */ #define AV_LOG_FATAL 8 /** * Something went wrong and cannot losslessly be recovered. * However, not all future data is affected. */ #define AV_LOG_ERROR 16 /** * Something somehow does not look correct. This may or may not * lead to problems. An example would be the use of '-vstrict -2'. */ #define AV_LOG_WARNING 24 /** * Standard information. */ #define AV_LOG_INFO 32 /** * Detailed information. */ #define AV_LOG_VERBOSE 40 /** * Stuff which is only useful for libav* developers. */ #define AV_LOG_DEBUG 48 /** * Extremely verbose debugging, useful for libav* development. */ #define AV_LOG_TRACE 56 #define AV_LOG_MAX_OFFSET (AV_LOG_TRACE - AV_LOG_QUIET) /** * @} */ /** * Sets additional colors for extended debugging sessions. * @code av_log(ctx, AV_LOG_DEBUG|AV_LOG_C(134), "Message in purple\n"); @endcode * Requires 256color terminal support. Uses outside debugging is not * recommended. */ #define AV_LOG_C(x) ((x) << 8) /** * Send the specified message to the log if the level is less than or equal * to the current av_log_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_set_callback * * @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 level The importance level of the message expressed using a @ref * lavu_log_constants "Logging Constant". * @param fmt The format string (printf-compatible) that specifies how * subsequent arguments are converted to output. */ void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4); /** * If unset, this will be set from the device_context field on init. * * Deallocating the AVHWDeviceContext will always release this interface, * and it does not matter whether it was user-allocated. */ ID3D11VideoContext *video_context; /** * Callbacks for locking. They protect accesses to device_context and * video_context calls. They also protect access to the internal staging * texture (for av_hwframe_transfer_data() calls). They do NOT protect * access to hwcontext or decoder state in general. * * If unset on init, the hwcontext implementation will set them to use an * internal mutex. * * The underlying lock must be recursive. lock_ctx is for free use by the * locking implementation. */ void (*lock)(void *lock_ctx); void (*unlock)(void *lock_ctx); void *lock_ctx; /** * D3D11_TEXTURE2D_DESC.BindFlags to be applied to D3D11 resources allocated * for frames using this device context. * * It applies globally to all AVD3D11VAFramesContext allocated from this device context. */ UINT BindFlags; /** * D3D11_TEXTURE2D_DESC.MiscFlags to be applied to D3D11 resources allocated * for frames using this device context. * * It applies globally to all AVD3D11VAFramesContext allocated from this device context. */ UINT MiscFlags; } AVD3D11VADeviceContext; /** * D3D11 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. * * This has no use outside of custom allocation, and AVFrame AVBufferRef do not * necessarily point to an instance of this struct. */ typedef struct AVD3D11FrameDescriptor { /** * The texture in which the frame is located. The reference count is * managed by the AVBufferRef, and destroying the reference will release V_WN48(p, v) # elif !defined(AV_WN48) && defined(AV_WL48) # define AV_WN48(p, v) AV_WL48(p, v) # endif # if defined(AV_RN64) && !defined(AV_RL64) # define AV_RL64(p) AV_RN64(p) # elif !defined(AV_RN64) && defined(AV_RL64) # define AV_RN64(p) AV_RL64(p) # endif # if defined(AV_WN64) && !defined(AV_WL64) # define AV_WL64(p, v) AV_WN64(p, v) # elif !defined(AV_WN64) && defined(AV_WL64) # define AV_WN64(p, v) AV_WL64(p, v) # endif #endif /* !AV_HAVE_BIGENDIAN */ /* * Define AV_[RW]N helper macros to simplify definitions not provided * by per-arch headers. */ #if defined(__GNUC__) || defined(__clang__) union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; 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 # define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) # define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) #elif AV_HAVE_FAST_UNALIGNED # define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) # define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) #else #ifndef AV_RB16 # define AV_RB16(x) \ ((((const uint8_t*)(x))[0] << 8) | \ ((const uint8_t*)(x))[1]) #endif #ifndef AV_WB16 # define AV_WB16(p, val) do { \ uint16_t d = (val); \ ((uint8_t*)(p))[1] = (d); \ ((uint8_t*)(p))[0] = (d)>>8; \ } while(0) #endif #ifndef AV_RL16 # define AV_RL16(x) \ ((((const uint8_t*)(x))[1] << 8) | \ ((const uint8_t*)(x))[0]) #endif #ifndef AV_WL16 # define AV_WL16(p, ve 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. */ attribute_deprecated int queue_family_decode_index; attribute_deprecated int nb_decode_queues; #endif #if FF_API_VULKAN_SYNC_QUEUES /** * Locks a queue, preventing other threads from submitting any command * buffers to this queue. * If set to NULL, will be set to lavu-internal functions that utilize a * mutex. * * Deprecated: use VK_KHR_internally_synchronized_queues. */ attribute_deprecated void (*lock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index); /** * Similar to lock_queue(), unlocks a queue. Must only be called after locking. * * Deprecated: use VK_KHR_internally_synchronized_queues. */ attribute_deprecated void (*unlock_queue)(struct AVHWDeviceContext *ctx, uint32_t queue_family, uint32_t index); #endif /** * Queue families used. Must be preferentially ordered. List may contain * duplicates. * * For compatibility reasons, all the enabled queue families listed above * (queue_family_(tx/comp/encode/decode)_index) must also be included in * this list until they're removed after deprecation. */ AVVulkanDeviceQueueFamily qf[64]; int nb_qf; } 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), /* Disables multiplane images. * This is required to export/import images from CUDA. */ AV_VK_FRAME_FLAG_DISABLE_MULTIPLANE = (1ULL << 2), } AVVkFrameFlags; /** * Allocated as AVHWFramesContext.hwctx, used to set pool-specific options */ typedef struct AVVulkanFramesCt for it. * * This is a convenience function intended to cover the simple cases. Callers * who need to fine-tune device creation/management should open the device * manually and then wrap it in an AVHWDeviceContext using * av_hwdevice_ctx_alloc()/av_hwdevice_ctx_init(). * * The returned context is already initialized and ready for use, the caller * should not call av_hwdevice_ctx_init() on it. The user_opaque/free fields of * the created AVHWDeviceContext are set by this function and should not be * touched by the caller. * * @param device_ctx On success, a reference to the newly-created device context * will be written here. The reference is owned by the caller * and must be released with av_buffer_unref() when no longer * needed. On failure, NULL will be written to this pointer. * @param type The type of the device to create. * @param device A type-specific string identifying the device to open. * @param opts A dictionary of additional (type-specific) options to use in * opening the device. The dictionary remains owned by the caller. * @param flags currently unused * * @return 0 on success, a negative AVERROR code on failure. */ int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags); /** * Create a new device of the specified type from an existing device. * * If the source device is a device of the target type or was originally * derived from such a device (possibly through one or more intermediate * devices of other types), then this will return a reference to the * existing device of the same type as is requested. * * Otherwise, it will attempt to derive a new device from the given source * device. If direct derivation to the new type is not implemented, it will * attempt the same derivation from each ancestor of the source device in * turn looking for an implL L L R R R R * LLLLRRRR L L L L R R R R * @endcode */ AV_STEREO3D_SIDEBYSIDE_QUINCUNX, /** * Views are packed per line, as if interlaced. * * @code{.unparsed} * LLLLLLLL * RRRRRRRR * LLLLLLLL * ... * @endcode */ AV_STEREO3D_LINES, /** * Views are packed per column. * * @code{.unparsed} * LRLRLRLR * LRLRLRLR * LRLRLRLR * ... * @endcode */ AV_STEREO3D_COLUMNS, /** * Video is stereoscopic but the packing is unspecified. */ AV_STEREO3D_UNSPEC, }; /** * 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, /** * Content is unspecified. */ AV_STEREO3D_VIEW_UNSPEC, }; /** * List of possible primary eyes. */ enum AVStereo3DPrimaryEye { /** * Neither eye. */ AV_PRIMARY_EYE_NONE, /** * Left eye. */ AV_PRIMARY_EYE_LEFT, /** * Right eye */ AV_PRIMARY_EYE_RIGHT, }; /** * Inverted views, Right/Bottom represents the left view. */ #define AV_STEREO3D_FLAG_INVERT (1 << 0) /** * Stereo 3D type: this structure describes how two videos are packed * within a single video surface, with additional information as needed. * * @note The struct must be allocated with av_stereo3d_alloc() and * its size is not a part of the public ABI. */ typedef struct AVStereo3D { /** * How views are packed within the video. */ enum AVStereo3DType type; /** * Additional information about the frame packing. */ int flags; /** * Determines which views are packed. */ enum AVStereo3DView view; /** * Which eyeonly streams. */ int subsampling_x, subsampling_y; /** * Intended video signal characteristics. */ enum AVColorRange color_range; enum AVColorPrimaries color_primaries; enum AVColorTransferCharacteristic color_trc; enum AVColorSpace color_space; /** * Intended bit depth, or 0 for unknown/unspecified. */ int bit_depth_luma; int bit_depth_chroma; /** * 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); /** * Select the most appropriate film grain parameters set for the frame, * taking into account the frame's format, resolution and video signal * characteristics. * * @note, for H.274, this may select a film grain parameter set with * greater chroma resolution than the frame. Users should take care to * correctly adjust the chroma grain frequency to the frame. */ const AVFilmGrainParams *av_film_grain_params_select(const AVFrame *frame); #endif /* AVUTIL_FILM_GRAIN_PARAMS_H */ /* * Copyright (c) 2007 Mans Rullgard * * ///< F (single precision FP) #define AV_CPU_FLAG_RVD (1 << 2) ///< D (double precision FP) #endif #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 #if FF_API_RISCV_FD_ZBA #define AV_CPU_FLAG_RVB_ADDR (1 << 8) ///< Address bit-manipulations #endif #define AV_CPU_FLAG_RV_ZVBB (1 << 9) ///< Vector basic bit-manipulations #define AV_CPU_FLAG_RV_MISALIGNED (1 <<10) ///< Fast misaligned accesses #define AV_CPU_FLAG_RVB (1 <<11) ///< B (bit manipulations) // WASM extensions #define AV_CPU_FLAG_SIMD128 (1 << 0) /** * Return the flags which specify extensions supported by the CPU. * The returned value is affected by av_force_cpu_flags() if that was used * before. So av_get_cpu_flags() can easily be used in an application to * detect the enabled cpu flags. */ int av_get_cpu_flags(void); /** * Disables cpu detection and forces the specified flags. * -1 is a special case that disables forcing of specific flags. */ void av_force_cpu_flags(int flags); /** * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. * * @return negative on error. */ int av_parse_cpu_caps(unsigned *flags, const char *s); /** * @return the number of logical CPU cores present. */ 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. * * Note that this is affected by the build configuration and the CPU flags mask, * so e.g. if the CPU supports AVX, but libavutil has been built with * --disable-avx or the AV_CPU_FLAG_AVX fl 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 * @ingroup lavu_sha512 * Public header for SHA-512 implementation. */ #ifndef AVUTIL_SHA512_H #define AVUTIL_SHA512_H #include #include #include "attributes.h" /** * @defgroup lavu_sha512 SHA-512 * @ingroup lavu_hash * SHA-512 (Secure Hash Algorithm) hash function implementations. * * This module supports the following SHA-2 hash functions: * * - SHA-512/224: 224 bits * - SHA-512/256: 256 bits * - SHA-384: 384 bits * - SHA-512: 512 bits * * @see For SHA-1, SHA-256, and variants thereof, see @ref lavu_sha. * * @{ */ extern const int av_sha512_size; struct AVSHA512; /** * Allocate an AVSHA512 context. */ struct AVSHA512 *av_sha512_alloc(void); /** * Initialize SHA-2 512 hashing. * * @param context pointer to the function context (of size av_sha512_size) * @param bits number of bits in digest (224, 256, 384 or 512 bits) * @return zero if initialization succeeded, -1 otherwise */ int av_sha512_init(struct AVSHA512* context, int bits); /** * Update hash value. * * @param context hash function context * @param data input data to update hash with * @param len input data length */ void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len); /** * Finish hashing and output digest value. * * @param context hash function context * @param digest buffer where output digest value is stored */ void av_sha512_final(struct AVSHA512* context, uint8_t *digest); /** * @} */ #endif /* AVUTIL_SHA512_H */ /* * Copyright (C) 2007 Michael Niedermayer * Copyright (C) 2013 James Almer INT_MAX / sizeof(*(val)) ? \ AVERROR(EINVAL) : \ av_opt_set_bin(obj, name, (const uint8_t *)(val), \ av_int_list_length(val, term) * sizeof(*(val)), flags)) #endif /** * Add, replace, or remove elements for an array option. Which of these * operations is performed depends on the values of val and search_flags. * * @param start_elem Index of the first array element to modify; must not be * larger than array size as returned by * av_opt_get_array_size(). * @param nb_elems number of array elements to modify; when val is NULL, * start_elem+nb_elems must not be larger than array size as * returned by av_opt_get_array_size() * * @param val_type Option type corresponding to the type of val, ignored when val is * NULL. * * The effect of this function will will be as if av_opt_setX() * was called for each element, where X is specified by type. * E.g. AV_OPT_TYPE_STRING corresponds to av_opt_set(). * * Typically this should be the same as the scalarized type of * the AVOption being set, but certain conversions are a /** * Look for an option in an object. Consider only options which * have all the specified flags set. * * @param[in] obj A pointer to a struct whose first element is a * pointer to an AVClass. * Alternatively a double pointer to an AVClass, if * AV_OPT_SEARCH_FAKE_OBJ search flag is set. * @param[in] name The name of the option to look for. * @param[in] unit When searching for named constants, name of the unit * it belongs to. * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG). * @param search_flags A combination of AV_OPT_SEARCH_*. * @param[out] target_obj if non-NULL, an object to which the option belongs will be * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present * in search_flags. This parameter is ignored if search_flags contain * AV_OPT_SEARCH_FAKE_OBJ. * * @return A pointer to the option found, or NULL if no option * was found. */ const AVOption *av_opt_find2(void *obj, const char *name, const char *unit, int opt_flags, int search_flags, void **target_obj); /** * Show the obj options. * * @param req_flags requested flags for the options to show. Show only the * options for which it is opt->flags & req_flags. * @param rej_flags rejected flags for the options to show. Show only the * options for which it is !(opt->flags & req_flags). * @param av_log_obj log context to use for showing the options */ int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags); /** * Extract a key-value pair from the beginning of a string. * * @param ropts pointer to the options string, will be updated to * point to the rest of the string (one of the pairs_sep * or the final NUL) * @param key_val_sep a 0-terminated list of characters used to separate * key from value, for example '=' * @param pairs_r struct, you must ensure that the AVClass pointer * is set to the correct value. Then, av_opt_set_defaults() can be called to * initialize defaults. After that the struct is ready to be used with the * AVOptions API. * * When cleaning up, you may use the av_opt_free() function to automatically * free all the allocated string and binary options. * * Continuing with the above example: * * @code * test_struct *alloc_test_struct(void) * { * test_struct *ret = av_mallocz(sizeof(*ret)); * ret->class = &test_class; * av_opt_set_defaults(ret); * return ret; * } * void free_test_struct(test_struct **foo) * { * av_opt_free(*foo); * av_freep(foo); * } * @endcode * * @subsection avoptions_implement_nesting Nesting * It may happen that an AVOptions-enabled struct contains another * AVOptions-enabled struct as a member (e.g. AVCodecContext in * 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 * parent struct's AVClass. * Assuming that the test_struct from above now also contains a * child_struct field: * * @code * typedef struct child_struct { * AVClass *class; * int flags_opt; * } child_struct; * static const AVOption child_opts[] = { * { "test_flags", "This is a test option of flags type.", * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX }, * { NULL }, * }; * static const AVClass child_class = { * .class_name = "child class", * .item_name = av_default_item_name, * .option = child_opts, * .version = LIBAVUTIL_VERSION_INT, * }; * * void *child_next(void *obj, voide AVUTIL_REFSTRUCT_H #include /** * RefStruct is an API for creating reference-counted objects * with minimal overhead. The API is designed for objects, * not buffers like the AVBuffer API. The main differences * to the AVBuffer API are as follows: * * - It uses void* instead of uint8_t* as its base type due to * its focus on objects. * - There are no equivalents of AVBuffer and AVBufferRef. * E.g. there is no way to get the usable size of the object: * The user is supposed to know what is at the other end of * the pointer. It also avoids one level of indirection. * - Custom allocators are not supported. This allows to simplify * the implementation and reduce the amount of allocations. * - It also has the advantage that the user's free callback need * only free the resources owned by the object, but not the * object itself. * - Because referencing (and replacing) an object managed by the * RefStruct API does not involve allocations, they can not fail * and therefore need not be checked. * * @note Referencing and unreferencing the buffers is thread-safe and thus * may be done from multiple threads simultaneously without any need for * additional locking. */ /** * This union is used for all opaque parameters in this API to spare the user * to cast const away in case the opaque to use is const-qualified. * * The functions provided by this API with an AVRefStructOpaque come in pairs * named foo_c and foo. The foo function accepts void* as opaque and is just * a wrapper around the foo_c function; "_c" means "(potentially) const". */ typedef union { void *nc; const void *c; } AVRefStructOpaque; /** * If this flag is set in av_refstruct_alloc_ext_c(), the object will not * be initially zeroed. */ #define AV_REFSTRUCT_FLAG_NO_ZEROING (1 << 0) /** * Allocate a refcounted object of usable size `size` managed via * the RefStruct API. * * By default (in the absence of flags to the contrary), * th_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 */ int av_expr_parse(AVExpr **expr, const char *s, const char * const *const_names, const char * const *func1_names, double (* const *funcs1)(void *, double), const char * const *func2_names, double (* const *funcs2)(void *, double, double), int log_offset, void *log_ctx); /** * 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 up to 5 entries. * @ption, plus an array of {@code nb_subblocks} * amount of subblocks of the given type and initializes the variables. Can be * freed with a normal av_free() call. * * @param size if non-NULL, the size in bytes of the resulting data array is written here. */ AVIAMFParamDefinition *av_iamf_param_definition_alloc(enum AVIAMFParamDefinitionType type, unsigned int nb_subblocks, size_t *size); /** * Get the subblock at the specified {@code idx}. Must be between 0 and nb_subblocks - 1. * * The @ref AVIAMFParamDefinition.type "param definition type" defines * the struct type of the returned pointer. */ static av_always_inline void* av_iamf_param_definition_get_subblock(const AVIAMFParamDefinition *par, unsigned int idx) { av_assert0(idx < par->nb_subblocks); return (void *)((uint8_t *)par + par->subblocks_offset + idx * par->subblock_size); } /** * @} * @addtogroup lavu_iamf_audio * @{ */ enum AVIAMFAmbisonicsMode { AV_IAMF_AMBISONICS_MODE_MONO, AV_IAMF_AMBISONICS_MODE_PROJECTION, }; /** * Recon gain information for the layer is present in AVIAMFReconGain */ #define AV_IAMF_LAYER_FLAG_RECON_GAIN (1 << 0) /** * A layer defining a Channel Layout in the Audio Element. * * When @ref AVIAMFAudioElement.audio_element_type "the parent's Audio Element type" * is AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL, this corresponds to an Scalable Channel * Layout layer as defined in section 3.6.2 of IAMF. * For AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE, it is an Ambisonics channel * layout as defined in section 3.6.3 of IAMF. * * @note The struct should be allocated with av_iamf_audio_element_add_layer() * and its size is not a part of the public ABI. */ typedef struct AVIAMFLayer { const AVClass *av_class; AVChannelLayout ch_layout; /** * A bitmask which may contain a combination of AV_IAMF_LAYER_FLAG_* flags. */ unsigned int flags; /** * Output gain channel flags aived 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_QSV_H #define AVUTIL_HWCONTEXT_QSV_H #include /** * @file * An API-specific header for AV_HWDEVICE_TYPE_QSV. * * AVHWFramesContext.pool must contain AVBufferRefs whose data pointer points * to a mfxFrameSurface1 struct. */ /** * This struct is allocated as AVHWDeviceContext.hwctx */ 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; /** * This struct is allocated as AVHWFramesContext.hwctx */ typedef struct AVQSVFramesContext { /** * A pointer to a mfxFrameSurface1 struct * * It is available when nb_surfaces is non-zero. */ mfxFrameSurface1 *surfaces; /** * Number of frames in the pool * * It is 0 for dynamic frame pools or AVHWFramesContext.initial_pool_size * for fixed frame pools. * * Note only oneVPL GPU runtime 2.9+ can support dynamic frame pools * on d3d11va or vaapi */ int nb_surfaces; /** * A combination of MFX_MEMTYPE_* describing the frame pool. */ int frame_type; /** * A pointer to a mfxFrameInfo struct * * It is available when nb_surfaces is 0, all buffers allocated from the * pool have the same mfxFrameInfo. */ mfxFrameInfo *info; } AVQSVFramesContext; #endif /* AVUTIL_HWCONTEXT_QSV_H */ /* * Copyright (c) 2023 Jan Ekström >63) ^ 0x7FFFFFFF); else return (int32_t)a; } /** * Clip a signed integer into the -(2^p),(2^p-1) range. * @param a value to clip * @param p bit position to clip at * @return clipped value */ static av_always_inline av_const int av_clip_intp2_c(int a, int p) { if (((unsigned)a + (1U << p)) & ~((2U << p) - 1)) return (a >> 31) ^ ((1 << p) - 1); else return a; } /** * Clip a signed integer to an unsigned power of two range. * @param a value to clip * @param p bit position to clip at * @return clipped value */ static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p) { if (a & ~((1U<> 31 & ((1U<= 2 if (p > 31) abort(); #endif return a & ((1U << p) - 1); } #if FF_API_MOD_UINTP2 #ifndef av_mod_uintp2 # define av_mod_uintp2 av_mod_uintp2_c #endif attribute_deprecated static av_always_inline av_const unsigned av_mod_uintp2_c(unsigned a, unsigned p) { return av_zero_extend_c(a, p); } #endif /** * Add two signed 32-bit values with saturation. * * @param a one value * @param b another value * @return sum with signed saturation */ static av_always_inline int av_sat_add32_c(int a, int b) { return av_clipl_int32((int64_t)a + b); } /** * Add a doubled value to another value with saturation at both stages. * * @param a first value * @param b value doubled and added to a * @return sum sat(dth, 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(). * * The data pointers and the linesizes must be aligned to the maximum required * by the CPU architecture. * * @note The linesize parameters have the type ptrdiff_t here, while they are * int for av_image_copy(). * @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_uc_from(uint8_t * const dst_data[4], const ptrdiff_t dst_linesizes[4], const uint8_t * const src_data[4], const ptrdiff_t src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height); /** * Setup the data pointers and linesizes based on the specified image * parameters and the provided array. * * The fields of the given image are filled in by using the src * address which points to the image data buffer. Depending on the * specified pixel format, one or multiple image data pointers and * line sizes will be set. If a planar format is specified, several * pointers will be set pointing to the different picture planes and * the line sizes of the different planes will be stored in the * lines_sizes array. Call with src == NULL to get the required * size for the src buffer. * * To allocate the buffer and fill in the dst_data and dst_linesize in * one call, use av_image_alloc(). * * @param dst_data data pointers to be filled in * @param dst_linesize linesizes for the image in dst_data to be filled in * @param src buffer which will contain or contains the actual image data, can be NULL * @param pix_fmt the pixel format of the image * @param width the width of the image in pixels * @param height the height o native endian * format of name. * For example in a little-endian system, first looks for "gray16", * then for "gray16le". * * Finally if no pixel format has been found, returns AV_PIX_FMT_NONE. */ enum AVPixelFormat av_get_pix_fmt(const char *name); /** * Return the short name for a pixel format, NULL in case pix_fmt is * unknown. * * @see av_get_pix_fmt(), av_get_pix_fmt_string() */ const char *av_get_pix_fmt_name(enum AVPixelFormat pix_fmt); /** * Print in buf the string corresponding to the pixel format with * number pix_fmt, or a header if pix_fmt is negative. * * @param buf the buffer where to write the string * @param buf_size the size of buf * @param pix_fmt the number of the pixel format to print the * corresponding info string, or a negative value to print the * corresponding header. */ char *av_get_pix_fmt_string(char *buf, int buf_size, enum AVPixelFormat pix_fmt); /** * Read a line from an image, and write the values of the * pixel format component c to dst. * * @param data the array containing the pointers to the planes of the image * @param linesize the array containing the linesizes of the image * @param desc the pixel format descriptor for the image * @param x the horizontal coordinate of the first pixel to read * @param y the vertical coordinate of the first pixel to read * @param w the width of the line to read, that is the number of * values to write to dst * @param read_pal_component if not zero and the format is a paletted * 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 re* @file * @brief Public header for libavutil TEA algorithm * @defgroup lavu_tea TEA * @ingroup lavu_crypto * @{ */ extern const int av_tea_size; struct AVTEA; /** * Allocate an AVTEA context * To free the struct: av_free(ptr) */ struct AVTEA *av_tea_alloc(void); /** * Initialize an AVTEA context. * * @param ctx an AVTEA context * @param key a key of 16 bytes used for encryption/decryption * @param rounds the number of rounds in TEA (64 is the "standard") */ void av_tea_init(struct AVTEA *ctx, const uint8_t key[16], int rounds); /** * Encrypt or decrypt a buffer using a previously initialized context. * * @param ctx an AVTEA context * @param dst destination array, can be equal to src * @param src source array, can be equal to dst * @param count number of 8 byte blocks * @param iv initialization vector for CBC mode, if NULL then ECB will be used * @param decrypt 0 for encryption, 1 for decryption */ void av_tea_crypt(struct AVTEA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); /** * @} */ #endif /* AVUTIL_TEA_H */ /* * Copyright (c) 2016 Neil Birkbeck * * 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_MASTERING_DISPLAY_METADATA_H #define AVUTILnchors; /** * 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; tional which will contain the detected * frame rate * @param[in] str the string to parse: it has to be a string in the format * rate_num / rate_den, a float number or a valid video rate abbreviation * @return >= 0 on success, a negative error code otherwise */ 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 * component. * The alpha component may be a string composed by "0x" followed by an * hexadecimal number or a decimal number between 0.0 and 1.0, which * represents the opacity value (0x00/0.0 means completely transparent, * 0xff/1.0 completely opaque). * If the alpha component is not specified then 0xff is assumed. * The string "random" will result in a random color. * @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). */ int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx); /** * Get the name of a color from the internal table of hard-coded named * colors. * * This function is meant to enumerate the color names recognized by * av_parse_color(). * * @param color_idx index of the requested color, starting from 0 * @param rgb if not NULL, will point to a 3@li compensation unsupported by resampler, or * @li swr_init() fails when called. */ int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance); /** * Set a customized input channel mapping. * * @param[in,out] s allocated Swr context, not yet initialized * @param[in] channel_map customized input channel mapping (array of channel * indexes, -1 for a muted channel) * @return >= 0 on success, or AVERROR error code in case of failure. */ int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map); /** * Generate a channel mixing matrix. * * This function is the one used internally by libswresample for building the * default mixing matrix. It is made public just as a utility function for * building custom matrices. * * @param in_layout input channel layout * @param out_layout output channel layout * @param center_mix_level mix level for the center channel * @param surround_mix_level mix level for the surround channel(s) * @param lfe_mix_level mix level for the low-frequency effects channel * @param rematrix_maxval if 1.0, coefficients will be normalized to prevent * overflow. if INT_MAX, coefficients will not be * normalized. * @param[out] matrix mixing coefficients; matrix[i + stride * o] is * the weight of input channel i in output channel o. * @param stride distance between adjacent input channels in the * matrix array * @param matrix_encoding matrixed stereo downmix mode (e.g. dplii) * @param log_ctx parent logging context, can be NULL * @return 0 on success, negative AVERROR code on failure */ int swr_build_matrix2(const AVChannelLayout *in_layout, const AVChannelLayout *out_layout, double center_mix_level, double surro * * The following code demonstrates the conversion loop assuming the parameters * from above and caller-defined functions get_input() and handle_output(): * @code * uint8_t **input; * int in_samples; * * while (get_input(&input, &in_samples)) { * uint8_t *output; * int out_samples = av_rescale_rnd(swr_get_delay(swr, 48000) + * in_samples, 44100, 48000, AV_ROUND_UP); * av_samples_alloc(&output, NULL, 2, out_samples, * AV_SAMPLE_FMT_S16, 0); * out_samples = swr_convert(swr, &output, out_samples, * input, in_samples); * handle_output(output, out_samples); * av_freep(&output); * } * @endcode * * When the conversion is finished, the conversion * context and everything associated with it must be freed with swr_free(). * A swr_close() function is also available, but it exists mainly for * compatibility with libavresample, and is not required to be called. * * There will be no memory leak if the data is not completely flushed before * swr_free(). */ #include #include "libavutil/channel_layout.h" #include "libavutil/frame.h" #include "libavutil/samplefmt.h" #include "libswresample/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 "libswresample/version.h" #endif /** * @name Option constants * These constants are used for the @ref avoptions interface for lswr. * @{ * */ #define SWR_FLAG_RESAMPLE 1 ///< Force resampling even if equal sample rate //TODO use int resample ? //long term TODO can we enable this dynamically? /** Dithering algorithms */ enum SwrDitherType { SWR_DITHER_NONE = 0, SWR_DITHER_RECTANGULAR, SWR_DITHER_TRIANGULAR, SWR_DITHER_TRIANGULAR_HIGHPASS, SWR_DITHER_NS = 64, ///< not paprivate * 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 ating 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 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 (oavcodec */ const struct AVHWAccel *hwaccel; /** * Legacy hardware accelerator context. * * For some hardware acceleration methods, the caller may use this field to * signal hwaccel-specific data to the codec. The struct pointed to by this * pointer is hwaccel-dependent and defined in the respective header. Please * refer to the FFmpeg HW accelerator documentation to know how to fill * this. * * In most cases this field is optional - the necessary information may also * be provided to libavcodec through @ref hw_frames_ctx or @ref * hw_device_ctx (see avcodec_get_hw_config()). However, in some cases it * may be the only method of signalling some (optional) information. * * The struct and its contents are owned by the caller. * * - encoding: May be set by the caller before avcodec_open2(). Must remain * valid until avcodec_free_context(). * - decoding: May be set by the caller in the get_format() callback. * Must remain valid until the next get_format() call, * or avcodec_free_context() (whichever comes first). */ void *hwaccel_context; /** * A reference to the AVHWFramesContext describing the input (for encoding) * or output (decoding) frames. The reference is set by the caller and * afterwards owned (and freed) by libavcodec - it should never be read by * the caller after being set. * * - decoding: This field should be set by the caller from the get_format() * callback. The previous reference (if any) will always be * unreffed by libavcodec before the get_format() call. * * If the default get_buffer2() is used with a hwaccel pixel * format, then this AVHWFramesContext will be used for * allocating the frame buffers. * * - encoding: For hardware encoders configured to use a hwastore a framerate value in the compressed * bitstream, the decoder may export it here. { 0, 1} when * unknown. * - encoding: May be used to signal the framerate of CFR content to an * encoder. */ AVRational framerate; /** * Codec delay. * * Encoding: Number of frames delay there will be from the encoder input to * the decoder output. (we assume the decoder matches the spec) * Decoding: Number of frames delay in addition to what a standard decoder * as specified in the spec would produce. * * Video: * Number of frames the decoded output will be delayed relative to the * encoded input. * * Audio: * For encoding, this field is unused (see initial_padding). * * For decoding, this is the number of samples the decoder needs to * output before the decoder's output is valid. When seeking, you should * start decoding this many samples prior to your desired seek point. * * - encoding: Set by libavcodec. * - decoding: Set by libavcodec. */ int delay; /* video only */ /** * picture width / height. * * @note Those fields may not match the values of the last * AVFrame output by avcodec_receive_frame() due frame * reordering. * * - encoding: MUST be set by user. * - decoding: May be set by the user before opening the decoder if known e.g. * from the container. Some decoders will require the dimensions * to be set by the caller. During decoding, the decoder may * overwrite those values as required while parsing the data. */ int width, height; /** * Bitstream width / height, may be different from width/height e.g. when * the decoded frame is cropped before being output or lowres is enabled. * * @note Those field may not match the value of th 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 { 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_pacNVAL) The packet side data type does not have a matching * frame side data type. * @retval AVERROR(ENOMEM) Failed to add a side data entry to the array, or * similar. */ int av_packet_side_data_to_frame(struct AVFrameSideData ***sd, int *nb_sd, const AVPacketSideData *src, unsigned int flags); const char *av_packet_side_data_name(enum AVPacketSideDataType type); /** * @} */ /** * @defgroup lavc_packet AVPacket * * Types and functions for working with AVPacket. * @{ */ /** * 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 pauct. * * If the entry was present and removed successfully, a positive number is returned. * If the entry was not found, zero is returned. * If an error occurred, a negative number is returned. */ int av_exif_remove_entry(void *logctx, AVExifMetadata *ifd, uint16_t id, int flags); /** * Decodes the EXIF data provided in the buffer and writes it into the * struct *ifd. If this function succeeds, the IFD is owned by the caller * and must be cleared after use by calling av_exif_free(); If this function * fails and returns a negative value, it will call av_exif_free(ifd) before * returning. */ int av_exif_parse_buffer(void *logctx, const uint8_t *data, size_t size, AVExifMetadata *ifd, enum AVExifHeaderMode header_mode); /** * Allocates a buffer using av_malloc of an appropriate size and writes the * EXIF data represented by ifd into that buffer. * * Upon error, *buffer will be NULL. The buffer becomes owned by the caller upon * success. The *buffer argument must be NULL before calling. */ int av_exif_write(void *logctx, const AVExifMetadata *ifd, AVBufferRef **buffer, enum AVExifHeaderMode header_mode); /** * Frees all resources associated with the given EXIF metadata struct. * Does not free the pointer passed itself, in case it is stack-allocated. * The pointer passed to this function must be freed by the caller, * if it is heap-allocated. Passing NULL is permitted. */ void av_exif_free(AVExifMetadata *ifd); /** * Recursively reads all tags from the IFD and stores them in the * provided metadata dictionary. */ int av_exif_ifd_to_dict(void *logctx, const AVExifMetadata *ifd, AVDictionary **metadata); /** * Allocates a duplicate of the provided EXIF metadata struct. The caller owns * the duplicate and must free it with av_exif_free. Returns NULL if the duplication * process failed. */ AVExifMetadata *av_exif_clone_ifd(const AVExifMetadata *ifd); /** * Convert a display matrix used by AV_FRAME_DATA_DISPLAYMAT * 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; /** * RTCP SR (Sender Report) information * * The received sender report information for an RTSP * stream, exposed as AV_PKT_DATA_RTCP_SR side data. */ typedef struct AVRTCPSenderReport { uint32_t ssrc; ///< Synchronization source identifier uint64_t ntp_timestamp; ///< NTP time when the report was sent uint32_t rtp_timestamp; ///< RTP time when the report was sent uint32_t sender_nb_packets; ///< Total number of packets sent uint32_t sender_nb_bytes; ///< Total number of bytes sent (excluding headers or padding) } AVRTCPSenderReport; /** * 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 /* * Android MediaCodec public API * * Copyright (c) 2016 Matthieu nst VdpPictureInfo *, uint32_t, const VdpBitstreamBuffer *); /** * This structure is used to share data between the libavcodec library and * the client video application. * This structure will be allocated and stored in AVCodecContext.hwaccel_context * by av_vdpau_bind_context(). Members can be set by the user once * during initialization or through each AVCodecContext.get_buffer() * function call. In any case, they must be valid prior to calling * decoding functions. * * The size of this structure is not a part of the public ABI and must not * be used outside of libavcodec. */ typedef struct AVVDPAUContext { /** * VDPAU decoder handle * * Set by user. */ VdpDecoder decoder; /** * VDPAU decoder render callback * * Set by the user. */ VdpDecoderRender *render; AVVDPAU_Render2 render2; } AVVDPAUContext; /** * Associate a VDPAU device with a codec context for hardware acceleration. * This function is meant to be called from the get_format() codec callback, * or earlier. It can also be called after avcodec_flush_buffers() to change * the underlying VDPAU device mid-stream (e.g. to recover from non-transparent * display preemption). * * @note get_format() must return AV_PIX_FMT_VDPAU if this function completes * successfully. * * @param avctx decoding context whose get_format() callback is invoked * @param device VDPAU device handle to use for hardware acceleration * @param get_proc_address VDPAU device driver * @param flags zero of more OR'd AV_HWACCEL_FLAG_* flags * * @return 0 on success, an AVERROR code on failure. */ int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device, VdpGetProcAddress *get_proc_address, unsigned flags); /** * Gets the parameters to create an adequate VDPAU video surface for the codec * context using VDPAU hardware decoding acceleration. * * @note Behavior is undefined if the contexDEC_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 *ndef AVCODEC_CODEC_PAR_H #define AVCODEC_CODEC_PAR_H #include #include "libavutil/avutil.h" #include "libavutil/channel_layout.h" #include "libavutil/rational.h" #include "libavutil/pixfmt.h" #include "codec_id.h" #include "defs.h" #include "packet.h" /** * @addtogroup lavc_core * @{ */ /** * 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; /** * Additional data associated with the entire stream. * * Should be allocated with av_packet_side_data_new() or * av_packet_side_data_add(), and will be freed by avcodec_parameters_free(). */ AVPacketSideData *coded_side_data; /** * Amount of entries in @ref coded_side_data. */ int nb_coded_side_data; /** * - 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). OContext can be used only for writing. * * @param s Used to return the pointer to the created AVIOContext. * In case of failure the pointed to value is set to NULL. * @param url resource to access * @param flags flags which control how the resource indicated by url * is to be opened * @param int_cb an interrupt callback to be used at the protocols level * @param options A dictionary filled with protocol-private options. On return * this parameter will be destroyed and replaced with a dict containing options * that were not found. May be NULL. * @return >= 0 in case of success, a negative value corresponding to an * AVERROR code in case of failure */ int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options); /** * Close the resource accessed by the AVIOContext s and free it. * This function can only be used if s was opened by avio_open(). * * The internal buffer is automatically flushed before closing the * resource. * * @return 0 on success, an AVERROR < 0 on error. * @see avio_closep */ int avio_close(AVIOContext *s); /** * Close the resource accessed by the AVIOContext *s, free it * and set the pointer pointing to it to NULL. * This function can only be used if s was opened by avio_open(). * * The internal buffer is automatically flushed before closing the * resource. * * @return 0 on success, an AVERROR < 0 on error. * @see avio_close */ int avio_closep(AVIOContext **s); /** * Open a write only memory stream. * * @param s new IO context * @return zero if no error. */ int avio_open_dyn_buf(AVIOContext **s); /** * Return the written size and a pointer to the buffer. * The AVIOContext stream is left intact. * The buffer must NOT be freed. * No padding is added to the buffer. * * @param s IO context * @param pbuffer pointer to a byte buffer * @return the length of the byte buffer */ int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer); /**To ensure all the streams are interleaved correctly, * av_interleaved_write_frame() will wait until it has at least one packet * for each stream before actually writing any packets to the output file. * When some streams are "sparse" (i.e. there are large gaps between * successive packets), this can result in excessive buffering. * * This field specifies the maximum difference between the timestamps of the * first and the last packet in the muxing queue, above which libavformat * will output a packet regardless of whether it has queued a packet for all * the streams. * * Muxing only, set by the caller before avformat_write_header(). */ int64_t max_interleave_delta; /** * Maximum number of packets to read while waiting for the first timestamp. * Decoding only. */ int max_ts_probe; /** * Max chunk time in microseconds. * Note, not all formats support this and unpredictable things may happen if it is used when not supported. * - encoding: Set by user * - decoding: unused */ int max_chunk_duration; /** * Max chunk size in bytes * Note, not all formats support this and unpredictable things may happen if it is used when not supported. * - encoding: Set by user * - decoding: unused */ int max_chunk_size; /** * Maximum number of packets that can be probed * - encoding: unused * - decoding: set by user */ int max_probe_packets; /** * Allow non-standard and experimental extension * @see AVCodecContext.strict_std_compliance */ int strict_std_compliance; /** * Flags indicating events happening on the file, a combination of * AVFMT_EVENT_FLAG_*. * * - demuxing: may be set by the demuxer in avformat_open_input(), * avformat_find_stream_info() and av_read_frame(). Flags must be cleared * by the user once the event has been handled. pixels to be cropped from the bottom edge of the * final image before presentation. */ int height; /** * Additional data associated with the grid. * * Should be allocated with av_packet_side_data_new() or * av_packet_side_data_add(), and will be freed by avformat_free_context(). */ AVPacketSideData *coded_side_data; /** * Amount of entries in @ref coded_side_data. */ int nb_coded_side_data; } AVStreamGroupTileGrid; /** * AVStreamGroupLCEVC is meant to define the relation between video streams * and a data stream containing LCEVC enhancement layer NALUs. * * No more than one stream of * @ref AVCodecParameters.codec_id "codec_id" AV_CODEC_ID_LCEVC shall be present. */ typedef struct AVStreamGroupLCEVC { const AVClass *av_class; /** * Index of the LCEVC data stream in AVStreamGroup. */ unsigned int lcevc_index; /** * Width of the final stream for presentation. */ int width; /** * Height of the final image for presentation. */ int height; } AVStreamGroupLCEVC; enum AVStreamGroupParamsType { AV_STREAM_GROUP_PARAMS_NONE, AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT, AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION, AV_STREAM_GROUP_PARAMS_TILE_GRID, AV_STREAM_GROUP_PARAMS_LCEVC, }; struct AVIAMFAudioElement; struct AVIAMFMixPresentation; typedef struct AVStreamGroup { /** * A class for @ref avoptions. Set by avformat_stream_group_create(). */ const AVClass *av_class; void *priv_data; /** * Group index in AVFormatContext. */ unsigned int index; /** * Group type-specific group ID. * * decoding: set by libavformat * encoding: may set by the user */ int64_t id; /** * Group type * * decoding: set by libavformat on group creation * encoding: set by avformat_stream_group_create() */ enum AVStreamGroupParamsType type; (1 << 21) /** * @return The AV_DISPOSITION_* flag corresponding to disp or a negative error * code if disp does not correspond to a known stream disposition. */ int av_disposition_from_string(const char *disp); /** * @param disposition a combination of AV_DISPOSITION_* values * @return The string description corresponding to the lowest set bit in * disposition. NULL when the lowest set bit does not correspond * to a known disposition or when disposition is 0. */ const char *av_disposition_to_string(int disposition); /** * Options for behavior on timestamp wrap detection. */ #define AV_PTS_WRAP_IGNORE 0 ///< ignore the wrap #define AV_PTS_WRAP_ADD_OFFSET 1 ///< add the format specific offset on wrap detection #define AV_PTS_WRAP_SUB_OFFSET -1 ///< subtract the format specific offset on wrap detection /** * Stream structure. * New fields can be added to the end with minor version bumps. * Removal, reordering and changes to existing fields require a major * version bump. * sizeof(AVStream) must not be used outside libav*. */ typedef struct AVStream { /** * A class for @ref avoptions. Set on stream creation. */ const AVClass *av_class; int index; /**< stream index in AVFormatContext */ /** * Format-specific stream ID. * decoding: set by libavformat * encoding: set by the user, replaced by libavformat if left unset */ int id; /** * Codec parameters associated with this stream. Allocated and freed by * libavformat in avformat_new_stream() and avformat_free_context() * respectively. * * - demuxing: filled by libavformat on stream creation or in * avformat_find_stream_info() * - muxing: filled by the caller before avformat_write_header() */ AVCodecParameters *codecpar; void *priv_data; /** * This is the fundamental unit of time (in seconds) in terms * of which frame timestamps ao please add any ticket numbers that you believe might be affected here #define LIBAVFORMAT_VERSION_MAJOR 62 /** * 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 < 63) #define FF_API_INTERNAL_TIMING (LIBAVFORMAT_VERSION_MAJOR < 63) #define FF_API_NO_DEFAULT_TLS_VERIFY (LIBAVFORMAT_VERSION_MAJOR < 63) #define FF_API_R_FRAME_RATE 1 #endif /* AVFORMAT_VERSION_MAJOR_H */ /* * 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_H #define AVFORMAT_VERSION_H /** * @file * @ingroup libavf * Libavformat version macros */ #include "libavutil/version.h" #include "version_major.h" #def