avutil (JavaCPP Presets for FFmpeg 3.2.1-1.3 API)

java.lang.Object
- org.bytedeco.javacpp.presets.avutil
- - org.bytedeco.javacpp.avutil

All Implemented Interfaces:

InfoMapper
```
public class avutil
extends avutil
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`avutil.Alloc_int` Allocate and initialize a buffer pool.
`static class`	`avutil.Alloc_Pointer_int` Allocate and initialize a buffer pool with a more complex allocator.
`static class`	`avutil.AVAudioFifo` Context for an Audio FIFO Buffer.
`static class`	`avutil.AVBPrint`
`static class`	`avutil.AVBuffer` A reference counted buffer type.
`static class`	`avutil.AVBufferPool` The buffer pool.
`static class`	`avutil.AVBufferRef` A reference to a data buffer.
`static class`	`avutil.AVClass` Describe the class of an AVClass context structure.
`static class`	`avutil.AVComponentDescriptor` \}
`static class`	`avutil.AVDictionary`
`static class`	`avutil.AVDictionaryEntry`
`static class`	`avutil.AVDownmixInfo` This structure describes optional metadata relevant to a downmix procedure.
`static class`	`avutil.AVFifoBuffer` \file a very simple circular buffer FIFO implementation
`static class`	`avutil.AVFrame` This structure describes decoded (raw) audio or video data.
`static class`	`avutil.AVFrameSideData` Structure to hold side data for an AVFrame.
`static class`	`avutil.AVMotionVector`
`static class`	`avutil.AVOption` AVOption
`static class`	`avutil.AVOptionRange` A single allowed range of values, or a single allowed value.
`static class`	`avutil.AVOptionRanges` List of AVOptionRange structs.
`static class`	`avutil.AVPixFmtDescriptor` Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes of an image.
`static class`	`avutil.AVRational` Rational number (pair of numerator and denominator).
`static class`	`avutil.AVStereo3D` Stereo 3D type: this structure describes how two videos are packed within a single video surface, with additional information as needed.
`static class`	`avutil.Callback_Pointer_int_BytePointer_Pointer` Set the logging callback \note The callback must be thread safe, even if the application does not use threads itself as some codecs are multithreaded.
`static class`	`avutil.Callback_Pointer_int_String_Pointer`
`static class`	`avutil.Free_Pointer_byte__`
`static class`	`avutil.Free_Pointer_ByteBuffer`
`static class`	`avutil.Free_Pointer_BytePointer` Create an AVBuffer from an existing array.
`static class`	`avutil.Func_Pointer_Pointer_int` Feed data at specific position from an AVFifoBuffer to a user-supplied callback.
`static class`	`avutil.Int_func_Pointer_Pointer_int` Feed data from a user-supplied callback to an AVFifoBuffer.
`static class`	`avutil.LogCallback` \} \}
`static class`	`avutil.Pool_free_Pointer`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AV_AFD_14_9` enum AVActiveFormatDescription
`static int`	`AV_AFD_16_9` enum AVActiveFormatDescription
`static int`	`AV_AFD_16_9_SP_14_9` enum AVActiveFormatDescription
`static int`	`AV_AFD_4_3` enum AVActiveFormatDescription
`static int`	`AV_AFD_4_3_SP_14_9` enum AVActiveFormatDescription
`static int`	`AV_AFD_SAME` enum AVActiveFormatDescription
`static int`	`AV_AFD_SP_4_3` enum AVActiveFormatDescription
`static int`	`AV_BUFFER_FLAG_READONLY` Always treat the buffer as read-only, even when it has only one reference.
`static int`	`AV_CH_BACK_CENTER`
`static int`	`AV_CH_BACK_LEFT`
`static int`	`AV_CH_BACK_RIGHT`
`static int`	`AV_CH_FRONT_CENTER`
`static int`	`AV_CH_FRONT_LEFT` \defgroup channel_masks Audio channel masks A channel layout is a 64-bits integer with a bit set for every channel.
`static int`	`AV_CH_FRONT_LEFT_OF_CENTER`
`static int`	`AV_CH_FRONT_RIGHT`
`static int`	`AV_CH_FRONT_RIGHT_OF_CENTER`
`static int`	`AV_CH_LAYOUT_2_1`
`static int`	`AV_CH_LAYOUT_2_2`
`static int`	`AV_CH_LAYOUT_2POINT1`
`static int`	`AV_CH_LAYOUT_3POINT1`
`static int`	`AV_CH_LAYOUT_4POINT0`
`static int`	`AV_CH_LAYOUT_4POINT1`
`static int`	`AV_CH_LAYOUT_5POINT0`
`static int`	`AV_CH_LAYOUT_5POINT0_BACK`
`static int`	`AV_CH_LAYOUT_5POINT1`
`static int`	`AV_CH_LAYOUT_5POINT1_BACK`
`static int`	`AV_CH_LAYOUT_6POINT0`
`static int`	`AV_CH_LAYOUT_6POINT0_FRONT`
`static int`	`AV_CH_LAYOUT_6POINT1`
`static int`	`AV_CH_LAYOUT_6POINT1_BACK`
`static int`	`AV_CH_LAYOUT_6POINT1_FRONT`
`static int`	`AV_CH_LAYOUT_7POINT0`
`static int`	`AV_CH_LAYOUT_7POINT0_FRONT`
`static int`	`AV_CH_LAYOUT_7POINT1`
`static int`	`AV_CH_LAYOUT_7POINT1_WIDE`
`static int`	`AV_CH_LAYOUT_7POINT1_WIDE_BACK`
`static long`	`AV_CH_LAYOUT_HEXADECAGONAL`
`static int`	`AV_CH_LAYOUT_HEXAGONAL`
`static int`	`AV_CH_LAYOUT_MONO` \} \defgroup channel_mask_c Audio channel layouts \{
`static long`	`AV_CH_LAYOUT_NATIVE` Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests the channel order of the decoder output to be the native codec channel order.
`static int`	`AV_CH_LAYOUT_OCTAGONAL`
`static int`	`AV_CH_LAYOUT_QUAD`
`static int`	`AV_CH_LAYOUT_STEREO`
`static int`	`AV_CH_LAYOUT_STEREO_DOWNMIX`
`static int`	`AV_CH_LAYOUT_SURROUND`
`static int`	`AV_CH_LOW_FREQUENCY`
`static long`	`AV_CH_LOW_FREQUENCY_2`
`static int`	`AV_CH_SIDE_LEFT`
`static int`	`AV_CH_SIDE_RIGHT`
`static int`	`AV_CH_STEREO_LEFT` Stereo downmix.
`static int`	`AV_CH_STEREO_RIGHT` See AV_CH_STEREO_LEFT.
`static long`	`AV_CH_SURROUND_DIRECT_LEFT`
`static long`	`AV_CH_SURROUND_DIRECT_RIGHT`
`static int`	`AV_CH_TOP_BACK_CENTER`
`static int`	`AV_CH_TOP_BACK_LEFT`
`static int`	`AV_CH_TOP_BACK_RIGHT`
`static int`	`AV_CH_TOP_CENTER`
`static int`	`AV_CH_TOP_FRONT_CENTER`
`static int`	`AV_CH_TOP_FRONT_LEFT`
`static int`	`AV_CH_TOP_FRONT_RIGHT`
`static long`	`AV_CH_WIDE_LEFT`
`static long`	`AV_CH_WIDE_RIGHT`
`static int`	`AV_CLASS_CATEGORY_BITSTREAM_FILTER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DECODER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEMUXER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_INPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_OUTPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_ENCODER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_FILTER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_INPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_MUXER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_NA` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_NB` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_OUTPUT` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_SWRESAMPLER` enum AVClassCategory
`static int`	`AV_CLASS_CATEGORY_SWSCALER` enum AVClassCategory
`static int`	`AV_CPU_FLAG_3DNOW` AMD 3DNOW
`static int`	`AV_CPU_FLAG_3DNOWEXT` AMD 3DNowExt
`static int`	`AV_CPU_FLAG_AESNI` Advanced Encryption Standard functions
`static int`	`AV_CPU_FLAG_ALTIVEC` standard
`static int`	`AV_CPU_FLAG_ARMV5TE`
`static int`	`AV_CPU_FLAG_ARMV6`
`static int`	`AV_CPU_FLAG_ARMV6T2`
`static int`	`AV_CPU_FLAG_ARMV8`
`static int`	`AV_CPU_FLAG_ATOM` Atom processor, some SSSE3 instructions are slower
`static int`	`AV_CPU_FLAG_AVX` AVX functions: requires OS support even if YMM registers aren't used
`static int`	`AV_CPU_FLAG_AVX2` AVX2 functions: requires OS support even if YMM registers aren't used
`static int`	`AV_CPU_FLAG_AVXSLOW` AVX supported, but slow when using YMM registers (e.g.
`static int`	`AV_CPU_FLAG_BMI1` Bit Manipulation Instruction Set 1
`static int`	`AV_CPU_FLAG_BMI2` Bit Manipulation Instruction Set 2
`static int`	`AV_CPU_FLAG_CMOV` supports cmov instruction
`static int`	`AV_CPU_FLAG_FMA3` Haswell FMA3 functions
`static int`	`AV_CPU_FLAG_FMA4` Bulldozer FMA4 functions
`static int`	`AV_CPU_FLAG_FORCE` \} \}
`static int`	`AV_CPU_FLAG_MMX` standard MMX
`static int`	`AV_CPU_FLAG_MMX2` SSE integer functions or AMD MMX ext
`static int`	`AV_CPU_FLAG_MMXEXT` SSE integer functions or AMD MMX ext
`static int`	`AV_CPU_FLAG_NEON`
`static int`	`AV_CPU_FLAG_POWER8` ISA 2.07
`static int`	`AV_CPU_FLAG_SETEND`
`static int`	`AV_CPU_FLAG_SSE` SSE functions
`static int`	`AV_CPU_FLAG_SSE2` PIV SSE2 functions
`static int`	`AV_CPU_FLAG_SSE2SLOW` SSE2 supported, but usually not faster than regular MMX/SSE (e.g.
`static int`	`AV_CPU_FLAG_SSE3` Prescott SSE3 functions
`static int`	`AV_CPU_FLAG_SSE3SLOW` SSE3 supported, but usually not faster than regular MMX/SSE (e.g.
`static int`	`AV_CPU_FLAG_SSE4` Penryn SSE4.1 functions
`static int`	`AV_CPU_FLAG_SSE42` Nehalem SSE4.2 functions
`static int`	`AV_CPU_FLAG_SSSE3` Conroe SSSE3 functions
`static int`	`AV_CPU_FLAG_VFP`
`static int`	`AV_CPU_FLAG_VFP_VM` VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
`static int`	`AV_CPU_FLAG_VFPV3`
`static int`	`AV_CPU_FLAG_VSX` ISA 2.06
`static int`	`AV_CPU_FLAG_XOP` Bulldozer XOP functions
`static int`	`AV_DICT_APPEND` If the entry already exists, append to it.
`static int`	`AV_DICT_DONT_OVERWRITE` Don't overwrite existing entries.
`static int`	`AV_DICT_DONT_STRDUP_KEY` Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
`static int`	`AV_DICT_DONT_STRDUP_VAL` Take ownership of a value that's been allocated with av_malloc() or another memory allocation function.
`static int`	`AV_DICT_IGNORE_SUFFIX` Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
`static int`	`AV_DICT_MATCH_CASE` Only get an entry with exact-case key match.
`static int`	`AV_DICT_MULTIKEY` Allow to store several equal keys in the dictionary
`static int`	`AV_DOWNMIX_TYPE_DPLII` enum AVDownmixType
`static int`	`AV_DOWNMIX_TYPE_LORO` enum AVDownmixType
`static int`	`AV_DOWNMIX_TYPE_LTRT` enum AVDownmixType
`static int`	`AV_DOWNMIX_TYPE_NB` enum AVDownmixType
`static int`	`AV_DOWNMIX_TYPE_UNKNOWN` enum AVDownmixType
`static int`	`AV_ERROR_MAX_STRING_SIZE`
`static int`	`AV_FRAME_DATA_A53_CC` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_AFD` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_AUDIO_SERVICE_TYPE` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_DISPLAYMATRIX` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_DOWNMIX_INFO` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_GOP_TIMECODE` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_MASTERING_DISPLAY_METADATA` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_MATRIXENCODING` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_MOTION_VECTORS` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_PANSCAN` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_REPLAYGAIN` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_SKIP_SAMPLES` enum AVFrameSideDataType
`static int`	`AV_FRAME_DATA_STEREO3D` enum AVFrameSideDataType
`static int`	`AV_LOG_DEBUG` Stuff which is only useful for libav* developers.
`static int`	`AV_LOG_ERROR` Something went wrong and cannot losslessly be recovered.
`static int`	`AV_LOG_FATAL` Something went wrong and recovery is not possible.
`static int`	`AV_LOG_INFO` Standard information.
`static int`	`AV_LOG_MAX_OFFSET`
`static int`	`AV_LOG_PANIC` Something went really wrong and we will crash now.
`static int`	`AV_LOG_PRINT_LEVEL` Include the log severity in messages originating from codecs.
`static int`	`AV_LOG_QUIET` Print no output.
`static int`	`AV_LOG_SKIP_REPEATED` Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 would otherwise interfere and lead to "Last message repeated x times" messages below (f)printf messages with some bad luck.
`static int`	`AV_LOG_TRACE` Extremely verbose debugging, useful for libav* development.
`static int`	`AV_LOG_VERBOSE` Detailed information.
`static int`	`AV_LOG_WARNING` Something somehow does not look correct.
`static int`	`AV_MATRIX_ENCODING_DOLBY` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_DOLBYEX` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_DOLBYHEADPHONE` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_DPLII` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_DPLIIX` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_DPLIIZ` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_NB` enum AVMatrixEncoding
`static int`	`AV_MATRIX_ENCODING_NONE` enum AVMatrixEncoding
`static long`	`AV_NOPTS_VALUE`
`static int`	`AV_OPT_ALLOW_NULL` In av_opt_get, return NULL if the option has a pointer type and is set to NULL, rather than returning an empty string.
`static int`	`AV_OPT_FLAG_IMPLICIT_KEY` enum
`static int`	`AV_OPT_MULTI_COMPONENT_RANGE` Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than one component for certain option types.
`static int`	`AV_OPT_SEARCH_CHILDREN` Search in possible children of the given object first.
`static int`	`AV_OPT_SEARCH_FAKE_OBJ` The obj passed to av_opt_find() is fake -- only a double pointer to AVClass instead of a required pointer to a struct containing AVClass.
`static int`	`AV_OPT_SERIALIZE_OPT_FLAGS_EXACT` Serialize options that exactly match opt_flags only.
`static int`	`AV_OPT_SERIALIZE_SKIP_DEFAULTS` Serialize options that are not set to default values only.
`static int`	`AV_OPT_TYPE_BINARY` enum AVOptionType
`static int`	`AV_OPT_TYPE_BOOL`
`static int`	`AV_OPT_TYPE_CHANNEL_LAYOUT`
`static int`	`AV_OPT_TYPE_COLOR`
`static int`	`AV_OPT_TYPE_CONST` enum AVOptionType
`static int`	`AV_OPT_TYPE_DICT` enum AVOptionType
`static int`	`AV_OPT_TYPE_DOUBLE` enum AVOptionType
`static int`	`AV_OPT_TYPE_DURATION`
`static int`	`AV_OPT_TYPE_FLAGS` enum AVOptionType
`static int`	`AV_OPT_TYPE_FLOAT` enum AVOptionType
`static int`	`AV_OPT_TYPE_IMAGE_SIZE`
`static int`	`AV_OPT_TYPE_INT` enum AVOptionType
`static int`	`AV_OPT_TYPE_INT64` enum AVOptionType
`static int`	`AV_OPT_TYPE_PIXEL_FMT`
`static int`	`AV_OPT_TYPE_RATIONAL` enum AVOptionType
`static int`	`AV_OPT_TYPE_SAMPLE_FMT`
`static int`	`AV_OPT_TYPE_STRING` enum AVOptionType
`static int`	`AV_OPT_TYPE_VIDEO_RATE`
`static int`	`AV_PICTURE_TYPE_B` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_BI` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_I` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_NONE` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_P` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_S` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_SI` enum AVPictureType
`static int`	`AV_PICTURE_TYPE_SP` enum AVPictureType
`static int`	`AV_PIX_FMT_0BGR` enum AVPixelFormat
`static int`	`AV_PIX_FMT_0BGR32`
`static int`	`AV_PIX_FMT_0RGB` enum AVPixelFormat
`static int`	`AV_PIX_FMT_0RGB32`
`static int`	`AV_PIX_FMT_ABGR` enum AVPixelFormat
`static int`	`AV_PIX_FMT_ARGB` enum AVPixelFormat
`static int`	`AV_PIX_FMT_AYUV64`
`static int`	`AV_PIX_FMT_AYUV64BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_AYUV64LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_BGGR16`
`static int`	`AV_PIX_FMT_BAYER_BGGR16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_BGGR16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_BGGR8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GBRG16`
`static int`	`AV_PIX_FMT_BAYER_GBRG16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GBRG16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GBRG8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GRBG16`
`static int`	`AV_PIX_FMT_BAYER_GRBG16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GRBG16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_GRBG8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_RGGB16`
`static int`	`AV_PIX_FMT_BAYER_RGGB16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_RGGB16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BAYER_RGGB8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR0` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR24` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR32`
`static int`	`AV_PIX_FMT_BGR32_1`
`static int`	`AV_PIX_FMT_BGR4` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR4_BYTE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR444`
`static int`	`AV_PIX_FMT_BGR444BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR444LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR48`
`static int`	`AV_PIX_FMT_BGR48BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR48LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR555`
`static int`	`AV_PIX_FMT_BGR555BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR555LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR565`
`static int`	`AV_PIX_FMT_BGR565BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR565LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGR8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGRA` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGRA64`
`static int`	`AV_PIX_FMT_BGRA64BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_BGRA64LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_CUDA` enum AVPixelFormat
`static int`	`AV_PIX_FMT_D3D11VA_VLD` enum AVPixelFormat
`static int`	`AV_PIX_FMT_DXVA2_VLD` enum AVPixelFormat
`static int`	`AV_PIX_FMT_FLAG_ALPHA` The pixel format has an alpha channel.
`static int`	`AV_PIX_FMT_FLAG_BE` Pixel format is big-endian.
`static int`	`AV_PIX_FMT_FLAG_BITSTREAM` All values of a component are bit-wise packed end to end.
`static int`	`AV_PIX_FMT_FLAG_HWACCEL` Pixel format is an HW accelerated format.
`static int`	`AV_PIX_FMT_FLAG_PAL` Pixel format has a palette in data[1], values are indexes in this palette.
`static int`	`AV_PIX_FMT_FLAG_PLANAR` At least one pixel component is not in the first data plane.
`static int`	`AV_PIX_FMT_FLAG_PSEUDOPAL` The pixel format is "pseudo-paletted".
`static int`	`AV_PIX_FMT_FLAG_RGB` The pixel format contains RGB-like data (as opposed to YUV/grayscale).
`static int`	`AV_PIX_FMT_GBR24P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP10`
`static int`	`AV_PIX_FMT_GBRAP10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP12`
`static int`	`AV_PIX_FMT_GBRAP12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP16`
`static int`	`AV_PIX_FMT_GBRAP16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRAP16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP10`
`static int`	`AV_PIX_FMT_GBRP10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP12`
`static int`	`AV_PIX_FMT_GBRP12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP14`
`static int`	`AV_PIX_FMT_GBRP14BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP14LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP16`
`static int`	`AV_PIX_FMT_GBRP16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP9`
`static int`	`AV_PIX_FMT_GBRP9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GBRP9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GRAY16`
`static int`	`AV_PIX_FMT_GRAY16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GRAY16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GRAY8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_GRAY8A` enum AVPixelFormat
`static int`	`AV_PIX_FMT_MEDIACODEC` enum AVPixelFormat
`static int`	`AV_PIX_FMT_MMAL` enum AVPixelFormat
`static int`	`AV_PIX_FMT_MONOBLACK` enum AVPixelFormat
`static int`	`AV_PIX_FMT_MONOWHITE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NB` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NONE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NV12` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NV16` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NV20`
`static int`	`AV_PIX_FMT_NV20BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NV20LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_NV21` enum AVPixelFormat
`static int`	`AV_PIX_FMT_P010`
`static int`	`AV_PIX_FMT_P010BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_P010LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_PAL8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_QSV` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB0` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB24` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB32`
`static int`	`AV_PIX_FMT_RGB32_1`
`static int`	`AV_PIX_FMT_RGB4` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB4_BYTE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB444`
`static int`	`AV_PIX_FMT_RGB444BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB444LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB48`
`static int`	`AV_PIX_FMT_RGB48BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB48LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB555`
`static int`	`AV_PIX_FMT_RGB555BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB555LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB565`
`static int`	`AV_PIX_FMT_RGB565BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB565LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGB8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGBA` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGBA64`
`static int`	`AV_PIX_FMT_RGBA64BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_RGBA64LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_UYVY422` enum AVPixelFormat
`static int`	`AV_PIX_FMT_UYYVYY411` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VAAPI` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VAAPI_IDCT` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VAAPI_MOCO` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VAAPI_VLD` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDA` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDA_VLD` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_H264` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_MPEG1` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_MPEG2` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_MPEG4` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_VC1` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VDPAU_WMV3` enum AVPixelFormat
`static int`	`AV_PIX_FMT_VIDEOTOOLBOX` enum AVPixelFormat
`static int`	`AV_PIX_FMT_XVMC` enum AVPixelFormat
`static int`	`AV_PIX_FMT_XVMC_MPEG2_IDCT` enum AVPixelFormat
`static int`	`AV_PIX_FMT_XVMC_MPEG2_MC` enum AVPixelFormat
`static int`	`AV_PIX_FMT_XYZ12`
`static int`	`AV_PIX_FMT_XYZ12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_XYZ12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_Y400A` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YA16`
`static int`	`AV_PIX_FMT_YA16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YA16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YA8` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV410P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV411P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P10`
`static int`	`AV_PIX_FMT_YUV420P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P12`
`static int`	`AV_PIX_FMT_YUV420P12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P14`
`static int`	`AV_PIX_FMT_YUV420P14BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P14LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P16`
`static int`	`AV_PIX_FMT_YUV420P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P9`
`static int`	`AV_PIX_FMT_YUV420P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV420P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P10`
`static int`	`AV_PIX_FMT_YUV422P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P12`
`static int`	`AV_PIX_FMT_YUV422P12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P14`
`static int`	`AV_PIX_FMT_YUV422P14BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P14LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P16`
`static int`	`AV_PIX_FMT_YUV422P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P9`
`static int`	`AV_PIX_FMT_YUV422P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV422P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV440P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV440P10`
`static int`	`AV_PIX_FMT_YUV440P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV440P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV440P12`
`static int`	`AV_PIX_FMT_YUV440P12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV440P12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P10`
`static int`	`AV_PIX_FMT_YUV444P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P12`
`static int`	`AV_PIX_FMT_YUV444P12BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P12LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P14`
`static int`	`AV_PIX_FMT_YUV444P14BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P14LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P16`
`static int`	`AV_PIX_FMT_YUV444P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P9`
`static int`	`AV_PIX_FMT_YUV444P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUV444P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P10`
`static int`	`AV_PIX_FMT_YUVA420P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P16`
`static int`	`AV_PIX_FMT_YUVA420P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P9`
`static int`	`AV_PIX_FMT_YUVA420P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA420P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P10`
`static int`	`AV_PIX_FMT_YUVA422P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P16`
`static int`	`AV_PIX_FMT_YUVA422P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P9`
`static int`	`AV_PIX_FMT_YUVA422P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA422P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P10`
`static int`	`AV_PIX_FMT_YUVA444P10BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P10LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P16`
`static int`	`AV_PIX_FMT_YUVA444P16BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P16LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P9`
`static int`	`AV_PIX_FMT_YUVA444P9BE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVA444P9LE` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVJ411P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVJ420P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVJ422P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVJ440P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUVJ444P` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YUYV422` enum AVPixelFormat
`static int`	`AV_PIX_FMT_YVYU422` enum AVPixelFormat
`static int`	`AV_ROUND_DOWN` enum AVRounding
`static int`	`AV_ROUND_INF` enum AVRounding
`static int`	`AV_ROUND_NEAR_INF` enum AVRounding
`static int`	`AV_ROUND_PASS_MINMAX` enum AVRounding
`static int`	`AV_ROUND_UP` enum AVRounding
`static int`	`AV_ROUND_ZERO` enum AVRounding
`static int`	`AV_SAMPLE_FMT_DBL` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_DBLP` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_FLT` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_FLTP` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_NB` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_NONE` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S16` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S16P` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S32` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S32P` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S64` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_S64P` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_U8` enum AVSampleFormat
`static int`	`AV_SAMPLE_FMT_U8P` enum AVSampleFormat
`static int`	`AV_STEREO3D_2D` enum AVStereo3DType
`static int`	`AV_STEREO3D_CHECKERBOARD` enum AVStereo3DType
`static int`	`AV_STEREO3D_COLUMNS` enum AVStereo3DType
`static int`	`AV_STEREO3D_FLAG_INVERT` Inverted views, Right/Bottom represents the left view.
`static int`	`AV_STEREO3D_FRAMESEQUENCE` enum AVStereo3DType
`static int`	`AV_STEREO3D_LINES` enum AVStereo3DType
`static int`	`AV_STEREO3D_SIDEBYSIDE` enum AVStereo3DType
`static int`	`AV_STEREO3D_SIDEBYSIDE_QUINCUNX` enum AVStereo3DType
`static int`	`AV_STEREO3D_TOPBOTTOM` enum AVStereo3DType
`static int`	`AV_TIME_BASE` Internal time base represented as integer
`static int`	`AVCHROMA_LOC_BOTTOM` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_BOTTOMLEFT` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_CENTER` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_LEFT` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_NB` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_TOP` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_TOPLEFT` enum AVChromaLocation
`static int`	`AVCHROMA_LOC_UNSPECIFIED` enum AVChromaLocation
`static int`	`AVCOL_PRI_BT2020` enum AVColorPrimaries
`static int`	`AVCOL_PRI_BT470BG` enum AVColorPrimaries
`static int`	`AVCOL_PRI_BT470M` enum AVColorPrimaries
`static int`	`AVCOL_PRI_BT709` enum AVColorPrimaries
`static int`	`AVCOL_PRI_FILM` enum AVColorPrimaries
`static int`	`AVCOL_PRI_NB` enum AVColorPrimaries
`static int`	`AVCOL_PRI_RESERVED` enum AVColorPrimaries
`static int`	`AVCOL_PRI_RESERVED0` enum AVColorPrimaries
`static int`	`AVCOL_PRI_SMPTE170M` enum AVColorPrimaries
`static int`	`AVCOL_PRI_SMPTE240M` enum AVColorPrimaries
`static int`	`AVCOL_PRI_SMPTE431` enum AVColorPrimaries
`static int`	`AVCOL_PRI_SMPTE432` enum AVColorPrimaries
`static int`	`AVCOL_PRI_SMPTEST428_1` enum AVColorPrimaries
`static int`	`AVCOL_PRI_UNSPECIFIED` enum AVColorPrimaries
`static int`	`AVCOL_RANGE_JPEG` enum AVColorRange
`static int`	`AVCOL_RANGE_MPEG` enum AVColorRange
`static int`	`AVCOL_RANGE_NB` enum AVColorRange
`static int`	`AVCOL_RANGE_UNSPECIFIED` enum AVColorRange
`static int`	`AVCOL_SPC_BT2020_CL` enum AVColorSpace
`static int`	`AVCOL_SPC_BT2020_NCL` enum AVColorSpace
`static int`	`AVCOL_SPC_BT470BG` enum AVColorSpace
`static int`	`AVCOL_SPC_BT709` enum AVColorSpace
`static int`	`AVCOL_SPC_FCC` enum AVColorSpace
`static int`	`AVCOL_SPC_NB` enum AVColorSpace
`static int`	`AVCOL_SPC_RESERVED` enum AVColorSpace
`static int`	`AVCOL_SPC_RGB` enum AVColorSpace
`static int`	`AVCOL_SPC_SMPTE170M` enum AVColorSpace
`static int`	`AVCOL_SPC_SMPTE2085` enum AVColorSpace
`static int`	`AVCOL_SPC_SMPTE240M` enum AVColorSpace
`static int`	`AVCOL_SPC_UNSPECIFIED` enum AVColorSpace
`static int`	`AVCOL_SPC_YCGCO`
`static int`	`AVCOL_SPC_YCOCG` enum AVColorSpace
`static int`	`AVCOL_TRC_ARIB_STD_B67` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_BT1361_ECG` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_BT2020_10` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_BT2020_12` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_BT709` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_GAMMA22` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_GAMMA28` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_IEC61966_2_1` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_IEC61966_2_4` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_LINEAR` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_LOG` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_LOG_SQRT` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_NB` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_RESERVED` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_RESERVED0` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_SMPTE170M` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_SMPTE240M` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_SMPTEST2084` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_SMPTEST428_1` enum AVColorTransferCharacteristic
`static int`	`AVCOL_TRC_UNSPECIFIED` enum AVColorTransferCharacteristic
`static int`	`AVERROR_BSF_NOT_FOUND`
`static int`	`AVERROR_BUFFER_TOO_SMALL`
`static int`	`AVERROR_BUG`
`static int`	`AVERROR_BUG2`
`static int`	`AVERROR_DECODER_NOT_FOUND`
`static int`	`AVERROR_DEMUXER_NOT_FOUND`
`static int`	`AVERROR_ENCODER_NOT_FOUND`
`static int`	`AVERROR_EOF`
`static int`	`AVERROR_EXIT`
`static int`	`AVERROR_EXPERIMENTAL` Requested feature is flagged experimental.
`static int`	`AVERROR_EXTERNAL`
`static int`	`AVERROR_FILTER_NOT_FOUND`
`static int`	`AVERROR_HTTP_BAD_REQUEST`
`static int`	`AVERROR_HTTP_FORBIDDEN`
`static int`	`AVERROR_HTTP_NOT_FOUND`
`static int`	`AVERROR_HTTP_OTHER_4XX`
`static int`	`AVERROR_HTTP_SERVER_ERROR`
`static int`	`AVERROR_HTTP_UNAUTHORIZED`
`static int`	`AVERROR_INPUT_CHANGED` Input changed between calls.
`static int`	`AVERROR_INVALIDDATA`
`static int`	`AVERROR_MUXER_NOT_FOUND`
`static int`	`AVERROR_OPTION_NOT_FOUND`
`static int`	`AVERROR_OUTPUT_CHANGED` Output changed between calls.
`static int`	`AVERROR_PATCHWELCOME`
`static int`	`AVERROR_PROTOCOL_NOT_FOUND`
`static int`	`AVERROR_STREAM_NOT_FOUND`
`static int`	`AVERROR_UNKNOWN`
`static int`	`AVMEDIA_TYPE_ATTACHMENT` enum AVMediaType
`static int`	`AVMEDIA_TYPE_AUDIO` enum AVMediaType
`static int`	`AVMEDIA_TYPE_DATA` enum AVMediaType
`static int`	`AVMEDIA_TYPE_NB` enum AVMediaType
`static int`	`AVMEDIA_TYPE_SUBTITLE` enum AVMediaType
`static int`	`AVMEDIA_TYPE_UNKNOWN` enum AVMediaType
`static int`	`AVMEDIA_TYPE_VIDEO` enum AVMediaType
`static int`	`AVPALETTE_COUNT`
`static int`	`AVPALETTE_SIZE` \file pixel format definitions
`static int`	`FF_LAMBDA_MAX`
`static int`	`FF_LAMBDA_SCALE`
`static int`	`FF_LAMBDA_SHIFT` \defgroup lavu_const Constants \{ \defgroup lavu_enc Encoding specific \note those definition should move to avcodec \{
`static int`	`FF_LOSS_ALPHA` loss of alpha bits
`static int`	`FF_LOSS_CHROMA` loss of chroma (e.g.
`static int`	`FF_LOSS_COLORQUANT` loss due to color quantization
`static int`	`FF_LOSS_COLORSPACE` loss due to color space conversion
`static int`	`FF_LOSS_DEPTH` loss due to color depth change
`static int`	`FF_LOSS_RESOLUTION` loss due to resolution change
`static int`	`FF_QP2LAMBDA` factor to convert from H.263 QP to lambda
`static int`	`FF_QUALITY_SCALE`
`static String`	`FFMPEG_VERSION`
`static double`	`INFINITY`
`static double`	`M_E` \file \addtogroup lavu_math Mathematical utilities for working with timestamp and time base.
`static double`	`M_LN10`
`static double`	`M_LN2`
`static double`	`M_LOG2_10`
`static double`	`M_PHI`
`static double`	`M_PI`
`static double`	`M_PI_2`
`static double`	`M_SQRT1_2`
`static double`	`M_SQRT2`
`static double`	`NAN`

Constructor Summary

Constructors
Constructor and Description

avutil()

Constructors
Constructor and Description
`avutil()`

Method Summary

Methods
Modifier and Type	Method and Description
`static avutil.AVRational`	`av_add_q(avutil.AVRational b, avutil.AVRational c)` Add two rationals.
`static long`	`av_add_stable(avutil.AVRational ts_tb, long ts, avutil.AVRational inc_tb, long inc)` Add a value to a timestamp.
`static avutil.AVAudioFifo`	`av_audio_fifo_alloc(int sample_fmt, int channels, int nb_samples)` Allocate an AVAudioFifo.
`static int`	`av_audio_fifo_drain(avutil.AVAudioFifo af, int nb_samples)` Drain data from an AVAudioFifo.
`static void`	`av_audio_fifo_free(avutil.AVAudioFifo af)` Free an AVAudioFifo.
`static int`	`av_audio_fifo_peek_at(avutil.AVAudioFifo af, Pointer data, int nb_samples, int offset)`
`static int`	`av_audio_fifo_peek_at(avutil.AVAudioFifo af, PointerPointer data, int nb_samples, int offset)` Peek data from an AVAudioFifo.
`static int`	`av_audio_fifo_peek(avutil.AVAudioFifo af, Pointer data, int nb_samples)`
`static int`	`av_audio_fifo_peek(avutil.AVAudioFifo af, PointerPointer data, int nb_samples)` Peek data from an AVAudioFifo.
`static int`	`av_audio_fifo_read(avutil.AVAudioFifo af, Pointer data, int nb_samples)`
`static int`	`av_audio_fifo_read(avutil.AVAudioFifo af, PointerPointer data, int nb_samples)` Read data from an AVAudioFifo.
`static int`	`av_audio_fifo_realloc(avutil.AVAudioFifo af, int nb_samples)` Reallocate an AVAudioFifo.
`static void`	`av_audio_fifo_reset(avutil.AVAudioFifo af)` Reset the AVAudioFifo buffer.
`static int`	`av_audio_fifo_size(avutil.AVAudioFifo af)` Get the current number of samples in the AVAudioFifo available for reading.
`static int`	`av_audio_fifo_space(avutil.AVAudioFifo af)` Get the current number of samples in the AVAudioFifo available for writing.
`static int`	`av_audio_fifo_write(avutil.AVAudioFifo af, Pointer data, int nb_samples)`
`static int`	`av_audio_fifo_write(avutil.AVAudioFifo af, PointerPointer data, int nb_samples)` Write data to an AVAudioFifo.
`static void`	`av_bprint_channel_layout(avutil.AVBPrint bp, int nb_channels, long channel_layout)` Append a description of a channel layout to a bprint buffer.
`static avutil.AVBufferRef`	`av_buffer_alloc(int size)` Allocate an AVBuffer of the given size using av_malloc().
`static avutil.AVBufferRef`	`av_buffer_allocz(int size)` Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
`static avutil.AVBufferRef`	`av_buffer_create(byte[] data, int size, avutil.Free_Pointer_byte__ free, Pointer opaque, int flags)`
`static avutil.AVBufferRef`	`av_buffer_create(ByteBuffer data, int size, avutil.Free_Pointer_ByteBuffer free, Pointer opaque, int flags)`
`static avutil.AVBufferRef`	`av_buffer_create(BytePointer data, int size, avutil.Free_Pointer_BytePointer free, Pointer opaque, int flags)`
`static void`	`av_buffer_default_free(Pointer opaque, byte[] data)`
`static void`	`av_buffer_default_free(Pointer opaque, ByteBuffer data)`
`static void`	`av_buffer_default_free(Pointer opaque, BytePointer data)` Default free callback, which calls av_free() on the buffer data.
`static Pointer`	`av_buffer_get_opaque(avutil.AVBufferRef buf)`
`static int`	`av_buffer_get_ref_count(avutil.AVBufferRef buf)`
`static int`	`av_buffer_is_writable(avutil.AVBufferRef buf)`
`static int`	`av_buffer_make_writable(avutil.AVBufferRef buf)`
`static int`	`av_buffer_make_writable(PointerPointer buf)` Create a writable reference from a given buffer reference, avoiding data copy if possible.
`static avutil.AVBufferRef`	`av_buffer_pool_get(avutil.AVBufferPool pool)` Allocate a new AVBuffer, reusing an old buffer from the pool when available.
`static avutil.AVBufferPool`	`av_buffer_pool_init(int size, avutil.Alloc_int alloc)`
`static avutil.AVBufferPool`	`av_buffer_pool_init2(int size, Pointer opaque, avutil.Alloc_Pointer_int alloc, avutil.Pool_free_Pointer pool_free)`
`static void`	`av_buffer_pool_uninit(avutil.AVBufferPool pool)`
`static void`	`av_buffer_pool_uninit(PointerPointer pool)` Mark the pool as being available for freeing.
`static int`	`av_buffer_realloc(avutil.AVBufferRef buf, int size)`
`static int`	`av_buffer_realloc(PointerPointer buf, int size)` Reallocate a given buffer.
`static avutil.AVBufferRef`	`av_buffer_ref(avutil.AVBufferRef buf)` Create a new reference to an AVBuffer.
`static void`	`av_buffer_unref(avutil.AVBufferRef buf)`
`static void`	`av_buffer_unref(PointerPointer buf)` Free a given reference and automatically free the buffer if there are no more references to it.
`static Pointer`	`av_calloc(long nmemb, long size)` Non-inlined equivalent of av_mallocz_array().
`static long`	`av_channel_layout_extract_channel(long channel_layout, int index)` Get the channel with the given index in channel_layout.
`static BytePointer`	`av_chroma_location_name(int location)`
`static int`	`av_cmp_q(avutil.AVRational a, avutil.AVRational b)` Compare two rationals.
`static BytePointer`	`av_color_primaries_name(int primaries)`
`static BytePointer`	`av_color_range_name(int range)`
`static BytePointer`	`av_color_space_name(int space)`
`static BytePointer`	`av_color_transfer_name(int transfer)`
`static long`	`av_compare_mod(long a, long b, long mod)` Compare the remainders of two integer operands divided by a common divisor.
`static int`	`av_compare_ts(long ts_a, avutil.AVRational tb_a, long ts_b, avutil.AVRational tb_b)` Compare two timestamps each in its own time base.
`static int`	`av_cpu_count()`
`static avutil.AVRational`	`av_d2q(double d, int max)` Convert a double precision floating point number to a rational.
`static int`	`av_default_get_category(Pointer ptr)`
`static BytePointer`	`av_default_item_name(Pointer ctx)` Return the context name
`static int`	`av_dict_copy(avutil.AVDictionary dst, avutil.AVDictionary src, int flags)`
`static int`	`av_dict_copy(PointerPointer dst, avutil.AVDictionary src, int flags)` Copy entries from one AVDictionary struct into another.
`static int`	`av_dict_count(avutil.AVDictionary m)` Get number of entries in dictionary.
`static void`	`av_dict_free(avutil.AVDictionary m)`
`static void`	`av_dict_free(PointerPointer m)` Free all the memory allocated for an AVDictionary struct and all keys and values.
`static int`	`av_dict_get_string(avutil.AVDictionary m, byte[] buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_dict_get_string(avutil.AVDictionary m, ByteBuffer buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_dict_get_string(avutil.AVDictionary m, BytePointer buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_dict_get_string(avutil.AVDictionary m, PointerPointer buffer, byte key_val_sep, byte pairs_sep)` Get dictionary entries as a string.
`static avutil.AVDictionaryEntry`	`av_dict_get(avutil.AVDictionary m, BytePointer key, avutil.AVDictionaryEntry prev, int flags)` Get a dictionary entry with matching key.
`static avutil.AVDictionaryEntry`	`av_dict_get(avutil.AVDictionary m, String key, avutil.AVDictionaryEntry prev, int flags)`
`static int`	`av_dict_parse_string(avutil.AVDictionary pm, BytePointer str, BytePointer key_val_sep, BytePointer pairs_sep, int flags)`
`static int`	`av_dict_parse_string(avutil.AVDictionary pm, String str, String key_val_sep, String pairs_sep, int flags)`
`static int`	`av_dict_parse_string(PointerPointer pm, BytePointer str, BytePointer key_val_sep, BytePointer pairs_sep, int flags)` Parse the key/value pairs list and add the parsed entries to a dictionary.
`static int`	`av_dict_set_int(avutil.AVDictionary pm, BytePointer key, long value, int flags)`
`static int`	`av_dict_set_int(avutil.AVDictionary pm, String key, long value, int flags)`
`static int`	`av_dict_set_int(PointerPointer pm, BytePointer key, long value, int flags)` Convenience wrapper for av_dict_set that converts the value to a string and stores it.
`static int`	`av_dict_set(avutil.AVDictionary pm, BytePointer key, BytePointer value, int flags)`
`static int`	`av_dict_set(avutil.AVDictionary pm, String key, String value, int flags)`
`static int`	`av_dict_set(PointerPointer pm, BytePointer key, BytePointer value, int flags)` Set the given entry in *pm, overwriting an existing entry.
`static avutil.AVRational`	`av_div_q(avutil.AVRational b, avutil.AVRational c)` Divide one rational by another.
`static avutil.AVDownmixInfo`	`av_downmix_info_update_side_data(avutil.AVFrame frame)` Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
`static int`	`av_dynarray_add_nofree(Pointer tab_ptr, int[] nb_ptr, Pointer elem)`
`static int`	`av_dynarray_add_nofree(Pointer tab_ptr, IntBuffer nb_ptr, Pointer elem)`
`static int`	`av_dynarray_add_nofree(Pointer tab_ptr, IntPointer nb_ptr, Pointer elem)` Add an element to a dynamic array.
`static void`	`av_dynarray_add(Pointer tab_ptr, int[] nb_ptr, Pointer elem)`
`static void`	`av_dynarray_add(Pointer tab_ptr, IntBuffer nb_ptr, Pointer elem)`
`static void`	`av_dynarray_add(Pointer tab_ptr, IntPointer nb_ptr, Pointer elem)` Add the pointer to an element to a dynamic array.
`static Pointer`	`av_dynarray2_add(Pointer tab_ptr, int[] nb_ptr, long elem_size, byte[] elem_data)`
`static Pointer`	`av_dynarray2_add(Pointer tab_ptr, IntBuffer nb_ptr, long elem_size, ByteBuffer elem_data)`
`static Pointer`	`av_dynarray2_add(Pointer tab_ptr, IntPointer nb_ptr, long elem_size, BytePointer elem_data)`
`static Pointer`	`av_dynarray2_add(PointerPointer tab_ptr, IntPointer nb_ptr, long elem_size, BytePointer elem_data)` Add an element of size `elem_size` to a dynamic array.
`static void`	`av_fast_malloc(Pointer ptr, int[] size, long min_size)`
`static void`	`av_fast_malloc(Pointer ptr, IntBuffer size, long min_size)`
`static void`	`av_fast_malloc(Pointer ptr, IntPointer size, long min_size)` Allocate a buffer, reusing the given one if large enough.
`static void`	`av_fast_mallocz(Pointer ptr, int[] size, long min_size)`
`static void`	`av_fast_mallocz(Pointer ptr, IntBuffer size, long min_size)`
`static void`	`av_fast_mallocz(Pointer ptr, IntPointer size, long min_size)` Allocate and clear a buffer, reusing the given one if large enough.
`static Pointer`	`av_fast_realloc(Pointer ptr, int[] size, long min_size)`
`static Pointer`	`av_fast_realloc(Pointer ptr, IntBuffer size, long min_size)`
`static Pointer`	`av_fast_realloc(Pointer ptr, IntPointer size, long min_size)` Reallocate the given buffer if it is not large enough, otherwise do nothing.
`static avutil.AVFifoBuffer`	`av_fifo_alloc_array(long nmemb, long size)` Initialize an AVFifoBuffer.
`static avutil.AVFifoBuffer`	`av_fifo_alloc(int size)` Initialize an AVFifoBuffer.
`static void`	`av_fifo_drain(avutil.AVFifoBuffer f, int size)` Read and discard the specified amount of data from an AVFifoBuffer.
`static void`	`av_fifo_free(avutil.AVFifoBuffer f)` Free an AVFifoBuffer.
`static void`	`av_fifo_freep(avutil.AVFifoBuffer f)`
`static void`	`av_fifo_freep(PointerPointer f)` Free an AVFifoBuffer and reset pointer to NULL.
`static int`	`av_fifo_generic_peek_at(avutil.AVFifoBuffer f, Pointer dest, int offset, int buf_size, avutil.Func_Pointer_Pointer_int func)`
`static int`	`av_fifo_generic_peek(avutil.AVFifoBuffer f, Pointer dest, int buf_size, avutil.Func_Pointer_Pointer_int func)` Feed data from an AVFifoBuffer to a user-supplied callback.
`static int`	`av_fifo_generic_read(avutil.AVFifoBuffer f, Pointer dest, int buf_size, avutil.Func_Pointer_Pointer_int func)` Feed data from an AVFifoBuffer to a user-supplied callback.
`static int`	`av_fifo_generic_write(avutil.AVFifoBuffer f, Pointer src, int size, avutil.Int_func_Pointer_Pointer_int func)`
`static int`	`av_fifo_grow(avutil.AVFifoBuffer f, int additional_space)` Enlarge an AVFifoBuffer.
`static BytePointer`	`av_fifo_peek2(avutil.AVFifoBuffer f, int offs)` Return a pointer to the data stored in a FIFO buffer at a certain offset.
`static int`	`av_fifo_realloc2(avutil.AVFifoBuffer f, int size)` Resize an AVFifoBuffer.
`static void`	`av_fifo_reset(avutil.AVFifoBuffer f)` Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
`static int`	`av_fifo_size(avutil.AVFifoBuffer f)` Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from it.
`static int`	`av_fifo_space(avutil.AVFifoBuffer f)` Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write into it.
`static int`	`av_find_best_pix_fmt_of_2(int dst_pix_fmt1, int dst_pix_fmt2, int src_pix_fmt, int has_alpha, int[] loss_ptr)`
`static int`	`av_find_best_pix_fmt_of_2(int dst_pix_fmt1, int dst_pix_fmt2, int src_pix_fmt, int has_alpha, IntBuffer loss_ptr)`
`static int`	`av_find_best_pix_fmt_of_2(int dst_pix_fmt1, int dst_pix_fmt2, int src_pix_fmt, int has_alpha, IntPointer loss_ptr)` Compute what kind of losses will occur when converting from one specific pixel format to another.
`static int`	`av_find_nearest_q_idx(avutil.AVRational q, avutil.AVRational q_list)` Find the value in a list of rationals nearest a given reference rational.
`static Pointer`	`av_fopen_utf8(BytePointer path, BytePointer mode)` Open a file using a UTF-8 filename.
`static Pointer`	`av_fopen_utf8(String path, String mode)`
`static void`	`av_force_cpu_flags(int flags)` Disables cpu detection and forces the specified flags.
`static avutil.AVFrame`	`av_frame_alloc()` Allocate an AVFrame and set its fields to default values.
`static avutil.AVFrame`	`av_frame_clone(avutil.AVFrame src)` Create a new frame that references the same data as src.
`static int`	`av_frame_copy_props(avutil.AVFrame dst, avutil.AVFrame src)` Copy only "metadata" fields from src to dst.
`static int`	`av_frame_copy(avutil.AVFrame dst, avutil.AVFrame src)` Copy the frame data from src to dst.
`static void`	`av_frame_free(avutil.AVFrame frame)`
`static void`	`av_frame_free(PointerPointer frame)` Free the frame and any dynamically allocated objects in it, e.g.
`static long`	`av_frame_get_best_effort_timestamp(avutil.AVFrame frame)` Accessors for some AVFrame fields.
`static int`	`av_frame_get_buffer(avutil.AVFrame frame, int align)` Allocate new buffer(s) for audio or video data.
`static long`	`av_frame_get_channel_layout(avutil.AVFrame frame)`
`static int`	`av_frame_get_channels(avutil.AVFrame frame)`
`static int`	`av_frame_get_color_range(avutil.AVFrame frame)`
`static int`	`av_frame_get_colorspace(avutil.AVFrame frame)`
`static int`	`av_frame_get_decode_error_flags(avutil.AVFrame frame)`
`static avutil.AVDictionary`	`av_frame_get_metadata(avutil.AVFrame frame)`
`static long`	`av_frame_get_pkt_duration(avutil.AVFrame frame)`
`static long`	`av_frame_get_pkt_pos(avutil.AVFrame frame)`
`static int`	`av_frame_get_pkt_size(avutil.AVFrame frame)`
`static avutil.AVBufferRef`	`av_frame_get_plane_buffer(avutil.AVFrame frame, int plane)` Get the buffer reference a given data plane is stored in.
`static byte[]`	`av_frame_get_qp_table(avutil.AVFrame f, int[] stride, int[] type)`
`static ByteBuffer`	`av_frame_get_qp_table(avutil.AVFrame f, IntBuffer stride, IntBuffer type)`
`static BytePointer`	`av_frame_get_qp_table(avutil.AVFrame f, IntPointer stride, IntPointer type)`
`static int`	`av_frame_get_sample_rate(avutil.AVFrame frame)`
`static avutil.AVFrameSideData`	`av_frame_get_side_data(avutil.AVFrame frame, int type)`
`static int`	`av_frame_is_writable(avutil.AVFrame frame)` Check if the frame data is writable.
`static int`	`av_frame_make_writable(avutil.AVFrame frame)` Ensure that the frame data is writable, avoiding data copy if possible.
`static void`	`av_frame_move_ref(avutil.AVFrame dst, avutil.AVFrame src)` Move everything contained in src to dst and reset src.
`static avutil.AVFrameSideData`	`av_frame_new_side_data(avutil.AVFrame frame, int type, int size)` Add a new side data to a frame.
`static int`	`av_frame_ref(avutil.AVFrame dst, avutil.AVFrame src)` Set up a new reference to the data described by the source frame.
`static void`	`av_frame_remove_side_data(avutil.AVFrame frame, int type)` If side data of the supplied type exists in the frame, free it and remove it from the frame.
`static void`	`av_frame_set_best_effort_timestamp(avutil.AVFrame frame, long val)`
`static void`	`av_frame_set_channel_layout(avutil.AVFrame frame, long val)`
`static void`	`av_frame_set_channels(avutil.AVFrame frame, int val)`
`static void`	`av_frame_set_color_range(avutil.AVFrame frame, int val)`
`static void`	`av_frame_set_colorspace(avutil.AVFrame frame, int val)`
`static void`	`av_frame_set_decode_error_flags(avutil.AVFrame frame, int val)`
`static void`	`av_frame_set_metadata(avutil.AVFrame frame, avutil.AVDictionary val)`
`static void`	`av_frame_set_pkt_duration(avutil.AVFrame frame, long val)`
`static void`	`av_frame_set_pkt_pos(avutil.AVFrame frame, long val)`
`static void`	`av_frame_set_pkt_size(avutil.AVFrame frame, int val)`
`static int`	`av_frame_set_qp_table(avutil.AVFrame f, avutil.AVBufferRef buf, int stride, int type)`
`static void`	`av_frame_set_sample_rate(avutil.AVFrame frame, int val)`
`static BytePointer`	`av_frame_side_data_name(int type)`
`static void`	`av_frame_unref(avutil.AVFrame frame)` Unreference all the buffers referenced by frame and reset the frame fields.
`static void`	`av_free(Pointer ptr)` Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family.
`static void`	`av_freep(Pointer ptr)` Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family, and set the pointer pointing to it to `NULL`.
`static long`	`av_gcd(long a, long b)` Compute the greatest common divisor of two integer operands.
`static int`	`av_get_alt_sample_fmt(int sample_fmt, int planar)` Return the planar<->packed alternative form of the given sample format, or AV_SAMPLE_FMT_NONE on error.
`static int`	`av_get_bits_per_pixel(avutil.AVPixFmtDescriptor pixdesc)` Return the number of bits per pixel used by the pixel format described by pixdesc.
`static int`	`av_get_bytes_per_sample(int sample_fmt)` Return number of bytes per sample.
`static BytePointer`	`av_get_channel_description(long channel)` Get the description of a given channel.
`static int`	`av_get_channel_layout_channel_index(long channel_layout, long channel)` Get the index of a channel in channel_layout.
`static int`	`av_get_channel_layout_nb_channels(long channel_layout)` Return the number of channels in the channel layout.
`static void`	`av_get_channel_layout_string(byte[] buf, int buf_size, int nb_channels, long channel_layout)`
`static void`	`av_get_channel_layout_string(ByteBuffer buf, int buf_size, int nb_channels, long channel_layout)`
`static void`	`av_get_channel_layout_string(BytePointer buf, int buf_size, int nb_channels, long channel_layout)` Return a description of a channel layout.
`static long`	`av_get_channel_layout(BytePointer name)` Return a channel layout id that matches name, or 0 if no match is found.
`static long`	`av_get_channel_layout(String name)`
`static BytePointer`	`av_get_channel_name(long channel)` Get the name of a given channel.
`static BytePointer`	`av_get_colorspace_name(int val)` Get the name of a colorspace.
`static int`	`av_get_cpu_flags()` Return the flags which specify extensions supported by the CPU.
`static long`	`av_get_default_channel_layout(int nb_channels)` Return default channel layout for a given number of channels.
`static BytePointer`	`av_get_media_type_string(int media_type)` Return a string describing the media_type enum, NULL if media_type is unknown.
`static int`	`av_get_packed_sample_fmt(int sample_fmt)` Get the packed alternative form of the given sample format.
`static int`	`av_get_padded_bits_per_pixel(avutil.AVPixFmtDescriptor pixdesc)` Return the number of bits per pixel for the pixel format described by pixdesc, including any padding or unused bits.
`static byte`	`av_get_picture_type_char(int pict_type)` Return a single letter to describe the given picture type pict_type.
`static int`	`av_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, int has_alpha)` Compute what kind of losses will occur when converting from one specific pixel format to another.
`static BytePointer`	`av_get_pix_fmt_name(int pix_fmt)` Return the short name for a pixel format, NULL in case pix_fmt is unknown.
`static byte[]`	`av_get_pix_fmt_string(byte[] buf, int buf_size, int pix_fmt)`
`static ByteBuffer`	`av_get_pix_fmt_string(ByteBuffer buf, int buf_size, int pix_fmt)`
`static BytePointer`	`av_get_pix_fmt_string(BytePointer buf, int buf_size, int pix_fmt)` Print in buf the string corresponding to the pixel format with number pix_fmt, or a header if pix_fmt is negative.
`static int`	`av_get_pix_fmt(BytePointer name)` Return the pixel format corresponding to name.
`static int`	`av_get_pix_fmt(String name)`
`static int`	`av_get_planar_sample_fmt(int sample_fmt)` Get the planar alternative form of the given sample format.
`static BytePointer`	`av_get_sample_fmt_name(int sample_fmt)` Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
`static byte[]`	`av_get_sample_fmt_string(byte[] buf, int buf_size, int sample_fmt)`
`static ByteBuffer`	`av_get_sample_fmt_string(ByteBuffer buf, int buf_size, int sample_fmt)`
`static BytePointer`	`av_get_sample_fmt_string(BytePointer buf, int buf_size, int sample_fmt)` Generate a string corresponding to the sample format with sample_fmt, or a header if sample_fmt is negative.
`static int`	`av_get_sample_fmt(BytePointer name)` Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
`static int`	`av_get_sample_fmt(String name)`
`static int`	`av_get_standard_channel_layout(int index, long[] layout, byte[] name)`
`static int`	`av_get_standard_channel_layout(int index, LongBuffer layout, ByteBuffer name)`
`static int`	`av_get_standard_channel_layout(int index, LongPointer layout, BytePointer name)`
`static int`	`av_get_standard_channel_layout(int index, LongPointer layout, PointerPointer name)` Get the value and name of a standard channel layout.
`static avutil.AVRational`	`av_get_time_base_q()` Return the fractional representation of the internal time base.
`static int`	`av_image_alloc(byte[] pointers, int[] linesizes, int w, int h, int pix_fmt, int align)`
`static int`	`av_image_alloc(ByteBuffer pointers, IntBuffer linesizes, int w, int h, int pix_fmt, int align)`
`static int`	`av_image_alloc(BytePointer pointers, IntPointer linesizes, int w, int h, int pix_fmt, int align)`
`static int`	`av_image_alloc(PointerPointer pointers, IntPointer linesizes, int w, int h, int pix_fmt, int align)` Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordingly.
`static int`	`av_image_check_sar(int w, int h, avutil.AVRational sar)` Check if the given sample aspect ratio of an image is valid.
`static int`	`av_image_check_size(int w, int h, int log_offset, Pointer log_ctx)` Check if the given dimension of an image is valid, meaning that all bytes of the image can be addressed with a signed int.
`static void`	`av_image_copy_plane(byte[] dst, int dst_linesize, byte[] src, int src_linesize, int bytewidth, int height)`
`static void`	`av_image_copy_plane(ByteBuffer dst, int dst_linesize, ByteBuffer src, int src_linesize, int bytewidth, int height)`
`static void`	`av_image_copy_plane(BytePointer dst, int dst_linesize, BytePointer src, int src_linesize, int bytewidth, int height)` Copy image plane from src to dst.
`static int`	`av_image_copy_to_buffer(byte[] dst, int dst_size, byte[] src_data, int[] src_linesize, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_copy_to_buffer(ByteBuffer dst, int dst_size, ByteBuffer src_data, IntBuffer src_linesize, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_copy_to_buffer(BytePointer dst, int dst_size, BytePointer src_data, IntPointer src_linesize, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_copy_to_buffer(BytePointer dst, int dst_size, PointerPointer src_data, IntPointer src_linesize, int pix_fmt, int width, int height, int align)` Copy image data from an image into a buffer.
`static void`	`av_image_copy(byte[] dst_data, int[] dst_linesizes, byte[] src_data, int[] src_linesizes, int pix_fmt, int width, int height)`
`static void`	`av_image_copy(ByteBuffer dst_data, IntBuffer dst_linesizes, ByteBuffer src_data, IntBuffer src_linesizes, int pix_fmt, int width, int height)`
`static void`	`av_image_copy(BytePointer dst_data, IntPointer dst_linesizes, BytePointer src_data, IntPointer src_linesizes, int pix_fmt, int width, int height)`
`static void`	`av_image_copy(PointerPointer dst_data, IntPointer dst_linesizes, PointerPointer src_data, IntPointer src_linesizes, int pix_fmt, int width, int height)` Copy image in src_data to dst_data.
`static int`	`av_image_fill_arrays(byte[] dst_data, int[] dst_linesize, byte[] src, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_fill_arrays(ByteBuffer dst_data, IntBuffer dst_linesize, ByteBuffer src, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_fill_arrays(BytePointer dst_data, IntPointer dst_linesize, BytePointer src, int pix_fmt, int width, int height, int align)`
`static int`	`av_image_fill_arrays(PointerPointer dst_data, IntPointer dst_linesize, BytePointer src, int pix_fmt, int width, int height, int align)` Setup the data pointers and linesizes based on the specified image parameters and the provided array.
`static int`	`av_image_fill_linesizes(int[] linesizes, int pix_fmt, int width)`
`static int`	`av_image_fill_linesizes(IntBuffer linesizes, int pix_fmt, int width)`
`static int`	`av_image_fill_linesizes(IntPointer linesizes, int pix_fmt, int width)` Fill plane linesizes for an image with pixel format pix_fmt and width width.
`static void`	`av_image_fill_max_pixsteps(int[] max_pixsteps, int[] max_pixstep_comps, avutil.AVPixFmtDescriptor pixdesc)`
`static void`	`av_image_fill_max_pixsteps(IntBuffer max_pixsteps, IntBuffer max_pixstep_comps, avutil.AVPixFmtDescriptor pixdesc)`
`static void`	`av_image_fill_max_pixsteps(IntPointer max_pixsteps, IntPointer max_pixstep_comps, avutil.AVPixFmtDescriptor pixdesc)` Compute the max pixel step for each plane of an image with a format described by pixdesc.
`static int`	`av_image_fill_pointers(byte[] data, int pix_fmt, int height, byte[] ptr, int[] linesizes)`
`static int`	`av_image_fill_pointers(ByteBuffer data, int pix_fmt, int height, ByteBuffer ptr, IntBuffer linesizes)`
`static int`	`av_image_fill_pointers(BytePointer data, int pix_fmt, int height, BytePointer ptr, IntPointer linesizes)`
`static int`	`av_image_fill_pointers(PointerPointer data, int pix_fmt, int height, BytePointer ptr, IntPointer linesizes)` Fill plane data pointers for an image with pixel format pix_fmt and height height.
`static int`	`av_image_get_buffer_size(int pix_fmt, int width, int height, int align)` Return the size in bytes of the amount of data required to store an image with the given parameters.
`static int`	`av_image_get_linesize(int pix_fmt, int width, int plane)` Compute the size of an image line with format pix_fmt and width width for the plane plane.
`static int`	`av_int_list_length_for_size(int elsize, Pointer list, long term)` Compute the length of an integer list.
`static avutil.AVRational`	`av_inv_q(avutil.AVRational q)` Invert a rational.
`static void`	`av_log_default_callback(Pointer avcl, int level, BytePointer fmt, Pointer vl)` Default logging callback It prints the message to stderr, optionally colorizing it.
`static void`	`av_log_default_callback(Pointer avcl, int level, String fmt, Pointer vl)`
`static void`	`av_log_format_line(Pointer ptr, int level, BytePointer fmt, Pointer vl, byte[] line, int line_size, int[] print_prefix)`
`static void`	`av_log_format_line(Pointer ptr, int level, BytePointer fmt, Pointer vl, ByteBuffer line, int line_size, IntBuffer print_prefix)`
`static void`	`av_log_format_line(Pointer ptr, int level, BytePointer fmt, Pointer vl, BytePointer line, int line_size, IntPointer print_prefix)` Format a line of log the same way as the default callback.
`static void`	`av_log_format_line(Pointer ptr, int level, String fmt, Pointer vl, byte[] line, int line_size, int[] print_prefix)`
`static void`	`av_log_format_line(Pointer ptr, int level, String fmt, Pointer vl, ByteBuffer line, int line_size, IntBuffer print_prefix)`
`static void`	`av_log_format_line(Pointer ptr, int level, String fmt, Pointer vl, BytePointer line, int line_size, IntPointer print_prefix)`
`static int`	`av_log_format_line2(Pointer ptr, int level, BytePointer fmt, Pointer vl, byte[] line, int line_size, int[] print_prefix)`
`static int`	`av_log_format_line2(Pointer ptr, int level, BytePointer fmt, Pointer vl, ByteBuffer line, int line_size, IntBuffer print_prefix)`
`static int`	`av_log_format_line2(Pointer ptr, int level, BytePointer fmt, Pointer vl, BytePointer line, int line_size, IntPointer print_prefix)` Format a line of log the same way as the default callback.
`static int`	`av_log_format_line2(Pointer ptr, int level, String fmt, Pointer vl, byte[] line, int line_size, int[] print_prefix)`
`static int`	`av_log_format_line2(Pointer ptr, int level, String fmt, Pointer vl, ByteBuffer line, int line_size, IntBuffer print_prefix)`
`static int`	`av_log_format_line2(Pointer ptr, int level, String fmt, Pointer vl, BytePointer line, int line_size, IntPointer print_prefix)`
`static int`	`av_log_get_flags()`
`static int`	`av_log_get_level()` Get the current log level
`static void`	`av_log_set_callback(avutil.Callback_Pointer_int_BytePointer_Pointer callback)`
`static void`	`av_log_set_callback(avutil.Callback_Pointer_int_String_Pointer callback)`
`static void`	`av_log_set_flags(int arg)`
`static void`	`av_log_set_level(int level)` Set the log level
`static void`	`av_log(Pointer avcl, int level, BytePointer fmt)` Send the specified message to the log if the level is less than or equal to the current av_log_level.
`static void`	`av_log(Pointer avcl, int level, String fmt)`
`static byte[]`	`av_make_error_string(byte[] errbuf, long errbuf_size, int errnum)`
`static ByteBuffer`	`av_make_error_string(ByteBuffer errbuf, long errbuf_size, int errnum)`
`static BytePointer`	`av_make_error_string(BytePointer errbuf, long errbuf_size, int errnum)` Fill the provided buffer with a string containing an error string corresponding to the AVERROR code errnum.
`static avutil.AVRational`	`av_make_q(int num, int den)` Create an AVRational.
`static Pointer`	`av_malloc_array(long nmemb, long size)` Allocate a memory block for an array with av_malloc().
`static Pointer`	`av_malloc(long size)` Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU).
`static Pointer`	`av_mallocz_array(long nmemb, long size)` Allocate a memory block for an array with av_mallocz().
`static Pointer`	`av_mallocz(long size)` Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU) and zero all the bytes of the block.
`static void`	`av_max_alloc(long max)` Set the maximum size that may be allocated in one block.
`static void`	`av_memcpy_backptr(byte[] dst, int back, int cnt)`
`static void`	`av_memcpy_backptr(ByteBuffer dst, int back, int cnt)`
`static void`	`av_memcpy_backptr(BytePointer dst, int back, int cnt)` Overlapping memcpy() implementation.
`static Pointer`	`av_memdup(Pointer p, long size)` Duplicate a buffer with av_malloc().
`static avutil.AVRational`	`av_mul_q(avutil.AVRational b, avutil.AVRational c)` Multiply two rationals.
`static int`	`av_nearer_q(avutil.AVRational q, avutil.AVRational q1, avutil.AVRational q2)` Find which of the two rationals is closer to another rational.
`static long`	`AV_NOPTS_VALUE()` \brief Undefined timestamp value Usually reported by demuxer that work on containers that do not provide either pts or dts.
`static avutil.AVClass`	`av_opt_child_class_next(avutil.AVClass parent, avutil.AVClass prev)` Iterate over potential AVOptions-enabled children of parent.
`static Pointer`	`av_opt_child_next(Pointer obj, Pointer prev)` Iterate over AVOptions-enabled children of obj.
`static int`	`av_opt_copy(Pointer dest, Pointer src)` Copy options from src object into dest object.
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, BytePointer val, double[] double_out)`
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, BytePointer val, DoubleBuffer double_out)`
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, BytePointer val, DoublePointer double_out)`
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, String val, double[] double_out)`
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, String val, DoubleBuffer double_out)`
`static int`	`av_opt_eval_double(Pointer obj, avutil.AVOption o, String val, DoublePointer double_out)`
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, BytePointer val, int[] flags_out)`
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, BytePointer val, IntBuffer flags_out)`
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, BytePointer val, IntPointer flags_out)` \defgroup opt_eval_funcs Evaluating option strings \{ This group of functions can be used to evaluate option strings and get numbers out of them.
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, String val, int[] flags_out)`
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, String val, IntBuffer flags_out)`
`static int`	`av_opt_eval_flags(Pointer obj, avutil.AVOption o, String val, IntPointer flags_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, BytePointer val, float[] float_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, BytePointer val, FloatBuffer float_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, BytePointer val, FloatPointer float_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, String val, float[] float_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, String val, FloatBuffer float_out)`
`static int`	`av_opt_eval_float(Pointer obj, avutil.AVOption o, String val, FloatPointer float_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, BytePointer val, int[] int_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, BytePointer val, IntBuffer int_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, BytePointer val, IntPointer int_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, String val, int[] int_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, String val, IntBuffer int_out)`
`static int`	`av_opt_eval_int(Pointer obj, avutil.AVOption o, String val, IntPointer int_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, BytePointer val, long[] int64_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, BytePointer val, LongBuffer int64_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, BytePointer val, LongPointer int64_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, String val, long[] int64_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, String val, LongBuffer int64_out)`
`static int`	`av_opt_eval_int64(Pointer obj, avutil.AVOption o, String val, LongPointer int64_out)`
`static int`	`av_opt_eval_q(Pointer obj, avutil.AVOption o, BytePointer val, avutil.AVRational q_out)`
`static int`	`av_opt_eval_q(Pointer obj, avutil.AVOption o, String val, avutil.AVRational q_out)`
`static avutil.AVOption`	`av_opt_find(Pointer obj, BytePointer name, BytePointer unit, int opt_flags, int search_flags)` Look for an option in an object.
`static avutil.AVOption`	`av_opt_find(Pointer obj, String name, String unit, int opt_flags, int search_flags)`
`static avutil.AVOption`	`av_opt_find2(Pointer obj, BytePointer name, BytePointer unit, int opt_flags, int search_flags, Pointer target_obj)`
`static avutil.AVOption`	`av_opt_find2(Pointer obj, BytePointer name, BytePointer unit, int opt_flags, int search_flags, PointerPointer target_obj)` Look for an option in an object.
`static avutil.AVOption`	`av_opt_find2(Pointer obj, String name, String unit, int opt_flags, int search_flags, Pointer target_obj)`
`static int`	`av_opt_flag_is_set(Pointer obj, BytePointer field_name, BytePointer flag_name)` Check whether a particular flag is set in a flags field.
`static int`	`av_opt_flag_is_set(Pointer obj, String field_name, String flag_name)`
`static void`	`av_opt_free(Pointer obj)` Free all allocated objects in obj.
`static void`	`av_opt_freep_ranges(avutil.AVOptionRanges ranges)`
`static void`	`av_opt_freep_ranges(PointerPointer ranges)` Free an AVOptionRanges struct and set it to NULL.
`static int`	`av_opt_get_channel_layout(Pointer obj, BytePointer name, int search_flags, long[] ch_layout)`
`static int`	`av_opt_get_channel_layout(Pointer obj, BytePointer name, int search_flags, LongBuffer ch_layout)`
`static int`	`av_opt_get_channel_layout(Pointer obj, BytePointer name, int search_flags, LongPointer ch_layout)`
`static int`	`av_opt_get_channel_layout(Pointer obj, String name, int search_flags, long[] ch_layout)`
`static int`	`av_opt_get_channel_layout(Pointer obj, String name, int search_flags, LongBuffer ch_layout)`
`static int`	`av_opt_get_channel_layout(Pointer obj, String name, int search_flags, LongPointer ch_layout)`
`static int`	`av_opt_get_dict_val(Pointer obj, BytePointer name, int search_flags, avutil.AVDictionary out_val)`
`static int`	`av_opt_get_dict_val(Pointer obj, BytePointer name, int search_flags, PointerPointer out_val)`
`static int`	`av_opt_get_dict_val(Pointer obj, String name, int search_flags, avutil.AVDictionary out_val)`
`static int`	`av_opt_get_double(Pointer obj, BytePointer name, int search_flags, double[] out_val)`
`static int`	`av_opt_get_double(Pointer obj, BytePointer name, int search_flags, DoubleBuffer out_val)`
`static int`	`av_opt_get_double(Pointer obj, BytePointer name, int search_flags, DoublePointer out_val)`
`static int`	`av_opt_get_double(Pointer obj, String name, int search_flags, double[] out_val)`
`static int`	`av_opt_get_double(Pointer obj, String name, int search_flags, DoubleBuffer out_val)`
`static int`	`av_opt_get_double(Pointer obj, String name, int search_flags, DoublePointer out_val)`
`static int`	`av_opt_get_image_size(Pointer obj, BytePointer name, int search_flags, int[] w_out, int[] h_out)`
`static int`	`av_opt_get_image_size(Pointer obj, BytePointer name, int search_flags, IntBuffer w_out, IntBuffer h_out)`
`static int`	`av_opt_get_image_size(Pointer obj, BytePointer name, int search_flags, IntPointer w_out, IntPointer h_out)`
`static int`	`av_opt_get_image_size(Pointer obj, String name, int search_flags, int[] w_out, int[] h_out)`
`static int`	`av_opt_get_image_size(Pointer obj, String name, int search_flags, IntBuffer w_out, IntBuffer h_out)`
`static int`	`av_opt_get_image_size(Pointer obj, String name, int search_flags, IntPointer w_out, IntPointer h_out)`
`static int`	`av_opt_get_int(Pointer obj, BytePointer name, int search_flags, long[] out_val)`
`static int`	`av_opt_get_int(Pointer obj, BytePointer name, int search_flags, LongBuffer out_val)`
`static int`	`av_opt_get_int(Pointer obj, BytePointer name, int search_flags, LongPointer out_val)`
`static int`	`av_opt_get_int(Pointer obj, String name, int search_flags, long[] out_val)`
`static int`	`av_opt_get_int(Pointer obj, String name, int search_flags, LongBuffer out_val)`
`static int`	`av_opt_get_int(Pointer obj, String name, int search_flags, LongPointer out_val)`
`static int`	`av_opt_get_key_value(byte[] ropts, BytePointer key_val_sep, BytePointer pairs_sep, int flags, byte[] rkey, byte[] rval)`
`static int`	`av_opt_get_key_value(byte[] ropts, String key_val_sep, String pairs_sep, int flags, byte[] rkey, byte[] rval)`
`static int`	`av_opt_get_key_value(ByteBuffer ropts, BytePointer key_val_sep, BytePointer pairs_sep, int flags, ByteBuffer rkey, ByteBuffer rval)`
`static int`	`av_opt_get_key_value(ByteBuffer ropts, String key_val_sep, String pairs_sep, int flags, ByteBuffer rkey, ByteBuffer rval)`
`static int`	`av_opt_get_key_value(BytePointer ropts, BytePointer key_val_sep, BytePointer pairs_sep, int flags, BytePointer rkey, BytePointer rval)`
`static int`	`av_opt_get_key_value(BytePointer ropts, String key_val_sep, String pairs_sep, int flags, BytePointer rkey, BytePointer rval)`
`static int`	`av_opt_get_key_value(PointerPointer ropts, BytePointer key_val_sep, BytePointer pairs_sep, int flags, PointerPointer rkey, PointerPointer rval)` Extract a key-value pair from the beginning of a string.
`static int`	`av_opt_get_pixel_fmt(Pointer obj, BytePointer name, int search_flags, int[] out_fmt)`
`static int`	`av_opt_get_pixel_fmt(Pointer obj, BytePointer name, int search_flags, IntBuffer out_fmt)`
`static int`	`av_opt_get_pixel_fmt(Pointer obj, BytePointer name, int search_flags, IntPointer out_fmt)`
`static int`	`av_opt_get_pixel_fmt(Pointer obj, String name, int search_flags, int[] out_fmt)`
`static int`	`av_opt_get_pixel_fmt(Pointer obj, String name, int search_flags, IntBuffer out_fmt)`
`static int`	`av_opt_get_pixel_fmt(Pointer obj, String name, int search_flags, IntPointer out_fmt)`
`static int`	`av_opt_get_q(Pointer obj, BytePointer name, int search_flags, avutil.AVRational out_val)`
`static int`	`av_opt_get_q(Pointer obj, String name, int search_flags, avutil.AVRational out_val)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, BytePointer name, int search_flags, int[] out_fmt)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, BytePointer name, int search_flags, IntBuffer out_fmt)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, BytePointer name, int search_flags, IntPointer out_fmt)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, String name, int search_flags, int[] out_fmt)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, String name, int search_flags, IntBuffer out_fmt)`
`static int`	`av_opt_get_sample_fmt(Pointer obj, String name, int search_flags, IntPointer out_fmt)`
`static int`	`av_opt_get_video_rate(Pointer obj, BytePointer name, int search_flags, avutil.AVRational out_val)`
`static int`	`av_opt_get_video_rate(Pointer obj, String name, int search_flags, avutil.AVRational out_val)`
`static int`	`av_opt_get(Pointer obj, BytePointer name, int search_flags, byte[] out_val)`
`static int`	`av_opt_get(Pointer obj, BytePointer name, int search_flags, ByteBuffer out_val)`
`static int`	`av_opt_get(Pointer obj, BytePointer name, int search_flags, BytePointer out_val)`
`static int`	`av_opt_get(Pointer obj, BytePointer name, int search_flags, PointerPointer out_val)` \note the returned string will be av_malloc()ed and must be av_free()ed by the caller \note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set to NULL instead of an allocated empty string.
`static int`	`av_opt_get(Pointer obj, String name, int search_flags, byte[] out_val)`
`static int`	`av_opt_get(Pointer obj, String name, int search_flags, ByteBuffer out_val)`
`static int`	`av_opt_get(Pointer obj, String name, int search_flags, BytePointer out_val)`
`static int`	`av_opt_is_set_to_default_by_name(Pointer obj, BytePointer name, int search_flags)` Check if given option is set to its default value.
`static int`	`av_opt_is_set_to_default_by_name(Pointer obj, String name, int search_flags)`
`static int`	`av_opt_is_set_to_default(Pointer obj, avutil.AVOption o)` Check if given option is set to its default value.
`static avutil.AVOption`	`av_opt_next(Pointer obj, avutil.AVOption prev)` Iterate over all AVOptions belonging to obj.
`static Pointer`	`av_opt_ptr(avutil.AVClass avclass, Pointer obj, BytePointer name)` Gets a pointer to the requested field in a struct.
`static Pointer`	`av_opt_ptr(avutil.AVClass avclass, Pointer obj, String name)`
`static int`	`av_opt_query_ranges_default(avutil.AVOptionRanges arg0, Pointer obj, BytePointer key, int flags)`
`static int`	`av_opt_query_ranges_default(avutil.AVOptionRanges arg0, Pointer obj, String key, int flags)`
`static int`	`av_opt_query_ranges_default(PointerPointer arg0, Pointer obj, BytePointer key, int flags)` Get a default list of allowed ranges for the given option.
`static int`	`av_opt_query_ranges(avutil.AVOptionRanges arg0, Pointer obj, BytePointer key, int flags)`
`static int`	`av_opt_query_ranges(avutil.AVOptionRanges arg0, Pointer obj, String key, int flags)`
`static int`	`av_opt_query_ranges(PointerPointer arg0, Pointer obj, BytePointer key, int flags)` Get a list of allowed ranges for the given option.
`static int`	`av_opt_serialize(Pointer obj, int opt_flags, int flags, byte[] buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_opt_serialize(Pointer obj, int opt_flags, int flags, ByteBuffer buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_opt_serialize(Pointer obj, int opt_flags, int flags, BytePointer buffer, byte key_val_sep, byte pairs_sep)`
`static int`	`av_opt_serialize(Pointer obj, int opt_flags, int flags, PointerPointer buffer, byte key_val_sep, byte pairs_sep)` Serialize object's options.
`static int`	`av_opt_set_bin(Pointer obj, BytePointer name, byte[] val, int size, int search_flags)`
`static int`	`av_opt_set_bin(Pointer obj, BytePointer name, ByteBuffer val, int size, int search_flags)`
`static int`	`av_opt_set_bin(Pointer obj, BytePointer name, BytePointer val, int size, int search_flags)`
`static int`	`av_opt_set_bin(Pointer obj, String name, byte[] val, int size, int search_flags)`
`static int`	`av_opt_set_bin(Pointer obj, String name, ByteBuffer val, int size, int search_flags)`
`static int`	`av_opt_set_bin(Pointer obj, String name, BytePointer val, int size, int search_flags)`
`static int`	`av_opt_set_channel_layout(Pointer obj, BytePointer name, long ch_layout, int search_flags)`
`static int`	`av_opt_set_channel_layout(Pointer obj, String name, long ch_layout, int search_flags)`
`static void`	`av_opt_set_defaults(Pointer s)` Set the values of all AVOption fields to their default values.
`static void`	`av_opt_set_defaults2(Pointer s, int mask, int flags)` Set the values of all AVOption fields to their default values.
`static int`	`av_opt_set_dict_val(Pointer obj, BytePointer name, avutil.AVDictionary val, int search_flags)` \note Any old dictionary present is discarded and replaced with a copy of the new one.
`static int`	`av_opt_set_dict_val(Pointer obj, String name, avutil.AVDictionary val, int search_flags)`
`static int`	`av_opt_set_dict(Pointer obj, avutil.AVDictionary options)`
`static int`	`av_opt_set_dict(Pointer obj, PointerPointer options)` Set all the options from a given dictionary on an object.
`static int`	`av_opt_set_dict2(Pointer obj, avutil.AVDictionary options, int search_flags)`
`static int`	`av_opt_set_dict2(Pointer obj, PointerPointer options, int search_flags)` Set all the options from a given dictionary on an object.
`static int`	`av_opt_set_double(Pointer obj, BytePointer name, double val, int search_flags)`
`static int`	`av_opt_set_double(Pointer obj, String name, double val, int search_flags)`
`static int`	`av_opt_set_from_string(Pointer ctx, BytePointer opts, byte[] shorthand, BytePointer key_val_sep, BytePointer pairs_sep)`
`static int`	`av_opt_set_from_string(Pointer ctx, BytePointer opts, ByteBuffer shorthand, BytePointer key_val_sep, BytePointer pairs_sep)`
`static int`	`av_opt_set_from_string(Pointer ctx, BytePointer opts, BytePointer shorthand, BytePointer key_val_sep, BytePointer pairs_sep)`
`static int`	`av_opt_set_from_string(Pointer ctx, BytePointer opts, PointerPointer shorthand, BytePointer key_val_sep, BytePointer pairs_sep)` Parse the key-value pairs list in opts.
`static int`	`av_opt_set_from_string(Pointer ctx, String opts, byte[] shorthand, String key_val_sep, String pairs_sep)`
`static int`	`av_opt_set_from_string(Pointer ctx, String opts, ByteBuffer shorthand, String key_val_sep, String pairs_sep)`
`static int`	`av_opt_set_from_string(Pointer ctx, String opts, BytePointer shorthand, String key_val_sep, String pairs_sep)`
`static int`	`av_opt_set_image_size(Pointer obj, BytePointer name, int w, int h, int search_flags)`
`static int`	`av_opt_set_image_size(Pointer obj, String name, int w, int h, int search_flags)`
`static int`	`av_opt_set_int(Pointer obj, BytePointer name, long val, int search_flags)`
`static int`	`av_opt_set_int(Pointer obj, String name, long val, int search_flags)`
`static int`	`av_opt_set_pixel_fmt(Pointer obj, BytePointer name, int fmt, int search_flags)`
`static int`	`av_opt_set_pixel_fmt(Pointer obj, String name, int fmt, int search_flags)`
`static int`	`av_opt_set_q(Pointer obj, BytePointer name, avutil.AVRational val, int search_flags)`
`static int`	`av_opt_set_q(Pointer obj, String name, avutil.AVRational val, int search_flags)`
`static int`	`av_opt_set_sample_fmt(Pointer obj, BytePointer name, int fmt, int search_flags)`
`static int`	`av_opt_set_sample_fmt(Pointer obj, String name, int fmt, int search_flags)`
`static int`	`av_opt_set_video_rate(Pointer obj, BytePointer name, avutil.AVRational val, int search_flags)`
`static int`	`av_opt_set_video_rate(Pointer obj, String name, avutil.AVRational val, int search_flags)`
`static int`	`av_opt_set(Pointer obj, BytePointer name, BytePointer val, int search_flags)` \defgroup opt_set_funcs Option setting functions \{ Those functions set the field of obj with the given name to value.
`static int`	`av_opt_set(Pointer obj, String name, String val, int search_flags)`
`static int`	`av_opt_show2(Pointer obj, Pointer av_log_obj, int req_flags, int rej_flags)` Show the obj options.
`static int`	`AV_OPT_TYPE_BOOL()`
`static int`	`AV_OPT_TYPE_CHANNEL_LAYOUT()`
`static int`	`AV_OPT_TYPE_COLOR()`
`static int`	`AV_OPT_TYPE_DURATION()`
`static int`	`AV_OPT_TYPE_IMAGE_SIZE()`
`static int`	`AV_OPT_TYPE_PIXEL_FMT()`
`static int`	`AV_OPT_TYPE_SAMPLE_FMT()`
`static int`	`AV_OPT_TYPE_VIDEO_RATE()`
`static int`	`av_parse_cpu_caps(int[] flags, BytePointer s)`
`static int`	`av_parse_cpu_caps(int[] flags, String s)`
`static int`	`av_parse_cpu_caps(IntBuffer flags, BytePointer s)`
`static int`	`av_parse_cpu_caps(IntBuffer flags, String s)`
`static int`	`av_parse_cpu_caps(IntPointer flags, BytePointer s)` Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
`static int`	`av_parse_cpu_caps(IntPointer flags, String s)`
`static int`	`av_parse_cpu_flags(BytePointer s)` Deprecated.
`static int`	`av_parse_cpu_flags(String s)` Deprecated.
`static int`	`AV_PIX_FMT_0BGR32()`
`static int`	`AV_PIX_FMT_0RGB32()`
`static int`	`AV_PIX_FMT_AYUV64()`
`static int`	`AV_PIX_FMT_BAYER_BGGR16()`
`static int`	`AV_PIX_FMT_BAYER_GBRG16()`
`static int`	`AV_PIX_FMT_BAYER_GRBG16()`
`static int`	`AV_PIX_FMT_BAYER_RGGB16()`
`static int`	`AV_PIX_FMT_BGR32_1()`
`static int`	`AV_PIX_FMT_BGR32()`
`static int`	`AV_PIX_FMT_BGR444()`
`static int`	`AV_PIX_FMT_BGR48()`
`static int`	`AV_PIX_FMT_BGR555()`
`static int`	`AV_PIX_FMT_BGR565()`
`static int`	`AV_PIX_FMT_BGRA64()`
`static int`	`av_pix_fmt_count_planes(int pix_fmt)`
`static int`	`av_pix_fmt_desc_get_id(avutil.AVPixFmtDescriptor desc)`
`static avutil.AVPixFmtDescriptor`	`av_pix_fmt_desc_get(int pix_fmt)`
`static avutil.AVPixFmtDescriptor`	`av_pix_fmt_desc_next(avutil.AVPixFmtDescriptor prev)` Iterate over all pixel format descriptors known to libavutil.
`static int`	`AV_PIX_FMT_GBRAP10()`
`static int`	`AV_PIX_FMT_GBRAP12()`
`static int`	`AV_PIX_FMT_GBRAP16()`
`static int`	`AV_PIX_FMT_GBRP10()`
`static int`	`AV_PIX_FMT_GBRP12()`
`static int`	`AV_PIX_FMT_GBRP14()`
`static int`	`AV_PIX_FMT_GBRP16()`
`static int`	`AV_PIX_FMT_GBRP9()`
`static int`	`av_pix_fmt_get_chroma_sub_sample(int pix_fmt, int[] h_shift, int[] v_shift)`
`static int`	`av_pix_fmt_get_chroma_sub_sample(int pix_fmt, IntBuffer h_shift, IntBuffer v_shift)`
`static int`	`av_pix_fmt_get_chroma_sub_sample(int pix_fmt, IntPointer h_shift, IntPointer v_shift)` Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
`static int`	`AV_PIX_FMT_GRAY16()`
`static int`	`AV_PIX_FMT_NV20()`
`static int`	`AV_PIX_FMT_P010()`
`static int`	`AV_PIX_FMT_RGB32_1()`
`static int`	`AV_PIX_FMT_RGB32()`
`static int`	`AV_PIX_FMT_RGB444()`
`static int`	`AV_PIX_FMT_RGB48()`
`static int`	`AV_PIX_FMT_RGB555()`
`static int`	`AV_PIX_FMT_RGB565()`
`static int`	`AV_PIX_FMT_RGBA64()`
`static int`	`av_pix_fmt_swap_endianness(int pix_fmt)` Utility function to swap the endianness of a pixel format.
`static int`	`AV_PIX_FMT_XYZ12()`
`static int`	`AV_PIX_FMT_YA16()`
`static int`	`AV_PIX_FMT_YUV420P10()`
`static int`	`AV_PIX_FMT_YUV420P12()`
`static int`	`AV_PIX_FMT_YUV420P14()`
`static int`	`AV_PIX_FMT_YUV420P16()`
`static int`	`AV_PIX_FMT_YUV420P9()`
`static int`	`AV_PIX_FMT_YUV422P10()`
`static int`	`AV_PIX_FMT_YUV422P12()`
`static int`	`AV_PIX_FMT_YUV422P14()`
`static int`	`AV_PIX_FMT_YUV422P16()`
`static int`	`AV_PIX_FMT_YUV422P9()`
`static int`	`AV_PIX_FMT_YUV440P10()`
`static int`	`AV_PIX_FMT_YUV440P12()`
`static int`	`AV_PIX_FMT_YUV444P10()`
`static int`	`AV_PIX_FMT_YUV444P12()`
`static int`	`AV_PIX_FMT_YUV444P14()`
`static int`	`AV_PIX_FMT_YUV444P16()`
`static int`	`AV_PIX_FMT_YUV444P9()`
`static int`	`AV_PIX_FMT_YUVA420P10()`
`static int`	`AV_PIX_FMT_YUVA420P16()`
`static int`	`AV_PIX_FMT_YUVA420P9()`
`static int`	`AV_PIX_FMT_YUVA422P10()`
`static int`	`AV_PIX_FMT_YUVA422P16()`
`static int`	`AV_PIX_FMT_YUVA422P9()`
`static int`	`AV_PIX_FMT_YUVA444P10()`
`static int`	`AV_PIX_FMT_YUVA444P16()`
`static int`	`AV_PIX_FMT_YUVA444P9()`
`static double`	`av_q2d(avutil.AVRational a)` Convert an AVRational to a `double`.
`static int`	`av_q2intfloat(avutil.AVRational q)` Convert an AVRational to a IEEE 32-bit `float` expressed in fixed-point format.
`static void`	`av_read_image_line(short[] dst, byte[] data, int[] linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component)`
`static void`	`av_read_image_line(ShortBuffer dst, ByteBuffer data, IntBuffer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component)`
`static void`	`av_read_image_line(ShortPointer dst, BytePointer data, IntPointer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component)`
`static void`	`av_read_image_line(ShortPointer dst, PointerPointer data, IntPointer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w, int read_pal_component)` Read a line from an image, and write the values of the pixel format component c to dst.
`static Pointer`	`av_realloc_array(Pointer ptr, long nmemb, long size)` Allocate, reallocate, or free an array.
`static Pointer`	`av_realloc_f(Pointer ptr, long nelem, long elsize)` Allocate, reallocate, or free a block of memory.
`static Pointer`	`av_realloc(Pointer ptr, long size)` Allocate, reallocate, or free a block of memory.
`static int`	`av_reallocp_array(Pointer ptr, long nmemb, long size)` Allocate, reallocate, or free an array through a pointer to a pointer.
`static int`	`av_reallocp(Pointer ptr, long size)` Allocate, reallocate, or free a block of memory through a pointer to a pointer.
`static int`	`av_reduce(int[] dst_num, int[] dst_den, long num, long den, long max)`
`static int`	`av_reduce(IntBuffer dst_num, IntBuffer dst_den, long num, long den, long max)`
`static int`	`av_reduce(IntPointer dst_num, IntPointer dst_den, long num, long den, long max)` Reduce a fraction.
`static long`	`av_rescale_delta(avutil.AVRational in_tb, long in_ts, avutil.AVRational fs_tb, int duration, long[] last, avutil.AVRational out_tb)`
`static long`	`av_rescale_delta(avutil.AVRational in_tb, long in_ts, avutil.AVRational fs_tb, int duration, LongBuffer last, avutil.AVRational out_tb)`
`static long`	`av_rescale_delta(avutil.AVRational in_tb, long in_ts, avutil.AVRational fs_tb, int duration, LongPointer last, avutil.AVRational out_tb)` Rescale a timestamp while preserving known durations.
`static long`	`av_rescale_q_rnd(long a, avutil.AVRational bq, avutil.AVRational cq, int rnd)` Rescale a 64-bit integer by 2 rational numbers with specified rounding.
`static long`	`av_rescale_q(long a, avutil.AVRational bq, avutil.AVRational cq)` Rescale a 64-bit integer by 2 rational numbers.
`static long`	`av_rescale_rnd(long a, long b, long c, int rnd)` Rescale a 64-bit integer with specified rounding.
`static long`	`av_rescale(long a, long b, long c)` Rescale a 64-bit integer with rounding to nearest.
`static int`	`av_sample_fmt_is_planar(int sample_fmt)` Check if the sample format is planar.
`static int`	`av_samples_alloc_array_and_samples(PointerPointer audio_data, int[] linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_alloc_array_and_samples(PointerPointer audio_data, IntBuffer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_alloc_array_and_samples(PointerPointer audio_data, IntPointer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)` Allocate a data pointers array, samples buffer for nb_samples samples, and fill data pointers and linesize accordingly.
`static int`	`av_samples_alloc(byte[] audio_data, int[] linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_alloc(ByteBuffer audio_data, IntBuffer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_alloc(BytePointer audio_data, IntPointer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_alloc(PointerPointer audio_data, IntPointer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)` Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly.
`static int`	`av_samples_copy(byte[] dst, byte[] src, int dst_offset, int src_offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_copy(ByteBuffer dst, ByteBuffer src, int dst_offset, int src_offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_copy(BytePointer dst, BytePointer src, int dst_offset, int src_offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_copy(PointerPointer dst, PointerPointer src, int dst_offset, int src_offset, int nb_samples, int nb_channels, int sample_fmt)` Copy samples from src to dst.
`static int`	`av_samples_fill_arrays(byte[] audio_data, int[] linesize, byte[] buf, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_fill_arrays(ByteBuffer audio_data, IntBuffer linesize, ByteBuffer buf, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_fill_arrays(BytePointer audio_data, IntPointer linesize, BytePointer buf, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_fill_arrays(PointerPointer audio_data, IntPointer linesize, BytePointer buf, int nb_channels, int nb_samples, int sample_fmt, int align)` Fill plane data pointers and linesize for samples with sample format sample_fmt.
`static int`	`av_samples_get_buffer_size(int[] linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_get_buffer_size(IntBuffer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)`
`static int`	`av_samples_get_buffer_size(IntPointer linesize, int nb_channels, int nb_samples, int sample_fmt, int align)` Get the required buffer size for the given audio parameters.
`static int`	`av_samples_set_silence(byte[] audio_data, int offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_set_silence(ByteBuffer audio_data, int offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_set_silence(BytePointer audio_data, int offset, int nb_samples, int nb_channels, int sample_fmt)`
`static int`	`av_samples_set_silence(PointerPointer audio_data, int offset, int nb_samples, int nb_channels, int sample_fmt)` Fill an audio buffer with silence.
`static void`	`av_set_cpu_flags_mask(int mask)` Deprecated.
`static int`	`av_set_options_string(Pointer ctx, BytePointer opts, BytePointer key_val_sep, BytePointer pairs_sep)` Parse the key/value pairs list in opts.
`static int`	`av_set_options_string(Pointer ctx, String opts, String key_val_sep, String pairs_sep)`
`static int`	`av_size_mult(long a, long b, SizeTPointer r)` Multiply two `size_t` values checking for overflow.
`static avutil.AVStereo3D`	`av_stereo3d_alloc()` Allocate an AVStereo3D structure and set its fields to default values.
`static avutil.AVStereo3D`	`av_stereo3d_create_side_data(avutil.AVFrame frame)` Allocate a complete AVFrameSideData and add it to the frame.
`static int`	`av_stereo3d_from_name(BytePointer name)` Get the AVStereo3DType form a human-readable name.
`static int`	`av_stereo3d_from_name(String name)`
`static BytePointer`	`av_stereo3d_type_name(int type)` Provide a human-readable name of a given stereo3d type.
`static BytePointer`	`av_strdup(BytePointer s)` Duplicate a string.
`static ByteBuffer`	`av_strdup(String s)`
`static int`	`av_strerror(int errnum, byte[] errbuf, long errbuf_size)`
`static int`	`av_strerror(int errnum, ByteBuffer errbuf, long errbuf_size)`
`static int`	`av_strerror(int errnum, BytePointer errbuf, long errbuf_size)` Put a description of the AVERROR code errnum in errbuf.
`static BytePointer`	`av_strndup(BytePointer s, long len)` Duplicate a substring of a string.
`static ByteBuffer`	`av_strndup(String s, long len)`
`static avutil.AVRational`	`av_sub_q(avutil.AVRational b, avutil.AVRational c)` Subtract one rational from another.
`static BytePointer`	`av_version_info()` Return an informative version string.
`static void`	`av_vlog(Pointer avcl, int level, BytePointer fmt, Pointer vl)` Send the specified message to the log if the level is less than or equal to the current av_log_level.
`static void`	`av_vlog(Pointer avcl, int level, String fmt, Pointer vl)`
`static void`	`av_write_image_line(short[] src, byte[] data, int[] linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w)`
`static void`	`av_write_image_line(ShortBuffer src, ByteBuffer data, IntBuffer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w)`
`static void`	`av_write_image_line(ShortPointer src, BytePointer data, IntPointer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w)`
`static void`	`av_write_image_line(ShortPointer src, PointerPointer data, IntPointer linesize, avutil.AVPixFmtDescriptor desc, int x, int y, int c, int w)` Write the values from src to the pixel format component c of an image line.
`static Pointer`	`av_x_if_null(Pointer p, Pointer x)` Return x default pointer in case p is NULL.
`static int`	`AVERROR_BSF_NOT_FOUND()` Bitstream filter not found
`static int`	`AVERROR_BUFFER_TOO_SMALL()` Buffer too small
`static int`	`AVERROR_BUG()` Internal bug, also see AVERROR_BUG2
`static int`	`AVERROR_BUG2()` This is semantically identical to AVERROR_BUG it has been introduced in Libav after our AVERROR_BUG and with a modified value.
`static int`	`AVERROR_DECODER_NOT_FOUND()` Decoder not found
`static int`	`AVERROR_DEMUXER_NOT_FOUND()` Demuxer not found
`static int`	`AVERROR_ENCODER_NOT_FOUND()` Encoder not found
`static int`	`AVERROR_EOF()` End of file
`static int`	`AVERROR_EXIT()` Immediate exit was requested; the called function should not be restarted
`static int`	`AVERROR_EXTERNAL()` Generic error in an external library
`static int`	`AVERROR_FILTER_NOT_FOUND()` Filter not found
`static int`	`AVERROR_HTTP_BAD_REQUEST()`
`static int`	`AVERROR_HTTP_FORBIDDEN()`
`static int`	`AVERROR_HTTP_NOT_FOUND()`
`static int`	`AVERROR_HTTP_OTHER_4XX()`
`static int`	`AVERROR_HTTP_SERVER_ERROR()`
`static int`	`AVERROR_HTTP_UNAUTHORIZED()`
`static int`	`AVERROR_INVALIDDATA()` Invalid data found when processing input
`static int`	`AVERROR_MUXER_NOT_FOUND()` Muxer not found
`static int`	`AVERROR_OPTION_NOT_FOUND()` Option not found
`static int`	`AVERROR_PATCHWELCOME()` Not yet implemented in FFmpeg, patches welcome
`static int`	`AVERROR_PROTOCOL_NOT_FOUND()` Protocol not found
`static int`	`AVERROR_STREAM_NOT_FOUND()` Stream not found
`static int`	`AVERROR_UNKNOWN()` Unknown error, typically from an external library
`static PointerPointer`	`avpriv_frame_get_metadatap(avutil.AVFrame frame)`
`static BytePointer`	`avutil_configuration()` Return the libavutil build-time configuration.
`static BytePointer`	`avutil_license()` Return the libavutil license.
`static int`	`avutil_version()` Return the LIBAVUTIL_VERSION_INT constant.
`static double`	`INFINITY()`
`static void`	`log_callback(Pointer ptr, int level, BytePointer fmt, Pointer vl)`
`static void`	`log_callback(Pointer ptr, int level, String fmt, Pointer vl)`
`static avutil.LogCallback`	`logCallback()`
`static void`	`logCallback(avutil.LogCallback logCallback)`
`static double`	`NAN()`
`static void`	`setLogCallback(avutil.LogCallback lc)`

Methods inherited from class org.bytedeco.javacpp.presets.avutil
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- AVMEDIA_TYPE_UNKNOWN
```
public static final int AVMEDIA_TYPE_UNKNOWN
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_VIDEO
```
public static final int AVMEDIA_TYPE_VIDEO
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_AUDIO
```
public static final int AVMEDIA_TYPE_AUDIO
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_DATA
```
public static final int AVMEDIA_TYPE_DATA
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_SUBTITLE
```
public static final int AVMEDIA_TYPE_SUBTITLE
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_ATTACHMENT
```
public static final int AVMEDIA_TYPE_ATTACHMENT
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- AVMEDIA_TYPE_NB
```
public static final int AVMEDIA_TYPE_NB
```
  enum AVMediaType
  
  See Also:
  Constant Field Values
- FF_LAMBDA_SHIFT
```
public static final int FF_LAMBDA_SHIFT
```
  \defgroup lavu_const Constants \{ \defgroup lavu_enc Encoding specific \note those definition should move to avcodec \{
  
  See Also:
  Constant Field Values
- FF_LAMBDA_SCALE
```
public static final int FF_LAMBDA_SCALE
```
  See Also:
  Constant Field Values
- FF_QP2LAMBDA
```
public static final int FF_QP2LAMBDA
```
  factor to convert from H.263 QP to lambda
  
  See Also:
  Constant Field Values
- FF_LAMBDA_MAX
```
public static final int FF_LAMBDA_MAX
```
  See Also:
  Constant Field Values
- FF_QUALITY_SCALE
```
public static final int FF_QUALITY_SCALE
```
  See Also:
  Constant Field Values
- AV_NOPTS_VALUE
```
public static final long AV_NOPTS_VALUE
```
- AV_TIME_BASE
```
public static final int AV_TIME_BASE
```
  Internal time base represented as integer
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_NONE
```
public static final int AV_PICTURE_TYPE_NONE
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_I
```
public static final int AV_PICTURE_TYPE_I
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_P
```
public static final int AV_PICTURE_TYPE_P
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_B
```
public static final int AV_PICTURE_TYPE_B
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_S
```
public static final int AV_PICTURE_TYPE_S
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_SI
```
public static final int AV_PICTURE_TYPE_SI
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_SP
```
public static final int AV_PICTURE_TYPE_SP
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AV_PICTURE_TYPE_BI
```
public static final int AV_PICTURE_TYPE_BI
```
  enum AVPictureType
  
  See Also:
  Constant Field Values
- AVERROR_BSF_NOT_FOUND
```
public static final int AVERROR_BSF_NOT_FOUND
```
- AVERROR_BUG
```
public static final int AVERROR_BUG
```
- AVERROR_BUFFER_TOO_SMALL
```
public static final int AVERROR_BUFFER_TOO_SMALL
```
- AVERROR_DECODER_NOT_FOUND
```
public static final int AVERROR_DECODER_NOT_FOUND
```
- AVERROR_DEMUXER_NOT_FOUND
```
public static final int AVERROR_DEMUXER_NOT_FOUND
```
- AVERROR_ENCODER_NOT_FOUND
```
public static final int AVERROR_ENCODER_NOT_FOUND
```
- AVERROR_EOF
```
public static final int AVERROR_EOF
```
- AVERROR_EXIT
```
public static final int AVERROR_EXIT
```
- AVERROR_EXTERNAL
```
public static final int AVERROR_EXTERNAL
```
- AVERROR_FILTER_NOT_FOUND
```
public static final int AVERROR_FILTER_NOT_FOUND
```
- AVERROR_INVALIDDATA
```
public static final int AVERROR_INVALIDDATA
```
- AVERROR_MUXER_NOT_FOUND
```
public static final int AVERROR_MUXER_NOT_FOUND
```
- AVERROR_OPTION_NOT_FOUND
```
public static final int AVERROR_OPTION_NOT_FOUND
```
- AVERROR_PATCHWELCOME
```
public static final int AVERROR_PATCHWELCOME
```
- AVERROR_PROTOCOL_NOT_FOUND
```
public static final int AVERROR_PROTOCOL_NOT_FOUND
```
- AVERROR_STREAM_NOT_FOUND
```
public static final int AVERROR_STREAM_NOT_FOUND
```
- AVERROR_BUG2
```
public static final int AVERROR_BUG2
```
- AVERROR_UNKNOWN
```
public static final int AVERROR_UNKNOWN
```
- AVERROR_EXPERIMENTAL
```
public static final int AVERROR_EXPERIMENTAL
```
  Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
  
  See Also:
  Constant Field Values
- AVERROR_INPUT_CHANGED
```
public static final int AVERROR_INPUT_CHANGED
```
  Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
  
  See Also:
  Constant Field Values
- AVERROR_OUTPUT_CHANGED
```
public static final int AVERROR_OUTPUT_CHANGED
```
  Output changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_INPUT_CHANGED)
  
  See Also:
  Constant Field Values
- AVERROR_HTTP_BAD_REQUEST
```
public static final int AVERROR_HTTP_BAD_REQUEST
```
- AVERROR_HTTP_UNAUTHORIZED
```
public static final int AVERROR_HTTP_UNAUTHORIZED
```
- AVERROR_HTTP_FORBIDDEN
```
public static final int AVERROR_HTTP_FORBIDDEN
```
- AVERROR_HTTP_NOT_FOUND
```
public static final int AVERROR_HTTP_NOT_FOUND
```
- AVERROR_HTTP_OTHER_4XX
```
public static final int AVERROR_HTTP_OTHER_4XX
```
- AVERROR_HTTP_SERVER_ERROR
```
public static final int AVERROR_HTTP_SERVER_ERROR
```
- AV_ERROR_MAX_STRING_SIZE
```
public static final int AV_ERROR_MAX_STRING_SIZE
```
  See Also:
  Constant Field Values
- M_E
```
public static final double M_E
```
  \file \addtogroup lavu_math Mathematical utilities for working with timestamp and time base.
  
  See Also:
  Constant Field Values
- M_LN2
```
public static final double M_LN2
```
  See Also:
  Constant Field Values
- M_LN10
```
public static final double M_LN10
```
  See Also:
  Constant Field Values
- M_LOG2_10
```
public static final double M_LOG2_10
```
  See Also:
  Constant Field Values
- M_PHI
```
public static final double M_PHI
```
  See Also:
  Constant Field Values
- M_PI
```
public static final double M_PI
```
  See Also:
  Constant Field Values
- M_PI_2
```
public static final double M_PI_2
```
  See Also:
  Constant Field Values
- M_SQRT1_2
```
public static final double M_SQRT1_2
```
  See Also:
  Constant Field Values
- M_SQRT2
```
public static final double M_SQRT2
```
  See Also:
  Constant Field Values
- NAN
```
public static final double NAN
```
- INFINITY
```
public static final double INFINITY
```
- AV_ROUND_ZERO
```
public static final int AV_ROUND_ZERO
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_ROUND_INF
```
public static final int AV_ROUND_INF
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_ROUND_DOWN
```
public static final int AV_ROUND_DOWN
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_ROUND_UP
```
public static final int AV_ROUND_UP
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_ROUND_NEAR_INF
```
public static final int AV_ROUND_NEAR_INF
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_ROUND_PASS_MINMAX
```
public static final int AV_ROUND_PASS_MINMAX
```
  enum AVRounding
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_NA
```
public static final int AV_CLASS_CATEGORY_NA
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_INPUT
```
public static final int AV_CLASS_CATEGORY_INPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_OUTPUT
```
public static final int AV_CLASS_CATEGORY_OUTPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_MUXER
```
public static final int AV_CLASS_CATEGORY_MUXER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEMUXER
```
public static final int AV_CLASS_CATEGORY_DEMUXER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_ENCODER
```
public static final int AV_CLASS_CATEGORY_ENCODER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DECODER
```
public static final int AV_CLASS_CATEGORY_DECODER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_FILTER
```
public static final int AV_CLASS_CATEGORY_FILTER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_BITSTREAM_FILTER
```
public static final int AV_CLASS_CATEGORY_BITSTREAM_FILTER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_SWSCALER
```
public static final int AV_CLASS_CATEGORY_SWSCALER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_SWRESAMPLER
```
public static final int AV_CLASS_CATEGORY_SWRESAMPLER
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_OUTPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_OUTPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_DEVICE_INPUT
```
public static final int AV_CLASS_CATEGORY_DEVICE_INPUT
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_CLASS_CATEGORY_NB
```
public static final int AV_CLASS_CATEGORY_NB
```
  enum AVClassCategory
  
  See Also:
  Constant Field Values
- AV_LOG_QUIET
```
public static final int AV_LOG_QUIET
```
  Print no output.
  
  See Also:
  Constant Field Values
- AV_LOG_PANIC
```
public static final int AV_LOG_PANIC
```
  Something went really wrong and we will crash now.
  
  See Also:
  Constant Field Values
- AV_LOG_FATAL
```
public static final int AV_LOG_FATAL
```
  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.
  
  See Also:
  Constant Field Values
- AV_LOG_ERROR
```
public static final int AV_LOG_ERROR
```
  Something went wrong and cannot losslessly be recovered. However, not all future data is affected.
  
  See Also:
  Constant Field Values
- AV_LOG_WARNING
```
public static final int AV_LOG_WARNING
```
  Something somehow does not look correct. This may or may not lead to problems. An example would be the use of '-vstrict -2'.
  
  See Also:
  Constant Field Values
- AV_LOG_INFO
```
public static final int AV_LOG_INFO
```
  Standard information.
  
  See Also:
  Constant Field Values
- AV_LOG_VERBOSE
```
public static final int AV_LOG_VERBOSE
```
  Detailed information.
  
  See Also:
  Constant Field Values
- AV_LOG_DEBUG
```
public static final int AV_LOG_DEBUG
```
  Stuff which is only useful for libav* developers.
  
  See Also:
  Constant Field Values
- AV_LOG_TRACE
```
public static final int AV_LOG_TRACE
```
  Extremely verbose debugging, useful for libav* development.
  
  See Also:
  Constant Field Values
- AV_LOG_MAX_OFFSET
```
public static final int AV_LOG_MAX_OFFSET
```
  See Also:
  Constant Field Values
- AV_LOG_SKIP_REPEATED
```
public static final int AV_LOG_SKIP_REPEATED
```
  Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 would otherwise interfere and lead to "Last message repeated x times" messages below (f)printf messages with some bad luck. Also to receive the last, "last repeated" line if any, the user app must call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end
  
  See Also:
  Constant Field Values
- AV_LOG_PRINT_LEVEL
```
public static final int AV_LOG_PRINT_LEVEL
```
  Include the log severity in messages originating from codecs. Results in messages such as: [rawvideo \ 0xDEADBEEF] [error] encode did not produce valid pts
  
  See Also:
  Constant Field Values
- AV_BUFFER_FLAG_READONLY
```
public static final int AV_BUFFER_FLAG_READONLY
```
  Always treat the buffer as read-only, even when it has only one reference.
  
  See Also:
  Constant Field Values
- AVPALETTE_SIZE
```
public static final int AVPALETTE_SIZE
```
  \file pixel format definitions
  
  See Also:
  Constant Field Values
- AVPALETTE_COUNT
```
public static final int AVPALETTE_COUNT
```
  See Also:
  Constant Field Values
- AV_PIX_FMT_NONE
```
public static final int AV_PIX_FMT_NONE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P
```
public static final int AV_PIX_FMT_YUV420P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUYV422
```
public static final int AV_PIX_FMT_YUYV422
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB24
```
public static final int AV_PIX_FMT_RGB24
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR24
```
public static final int AV_PIX_FMT_BGR24
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P
```
public static final int AV_PIX_FMT_YUV422P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P
```
public static final int AV_PIX_FMT_YUV444P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV410P
```
public static final int AV_PIX_FMT_YUV410P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV411P
```
public static final int AV_PIX_FMT_YUV411P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GRAY8
```
public static final int AV_PIX_FMT_GRAY8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_MONOWHITE
```
public static final int AV_PIX_FMT_MONOWHITE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_MONOBLACK
```
public static final int AV_PIX_FMT_MONOBLACK
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_PAL8
```
public static final int AV_PIX_FMT_PAL8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVJ420P
```
public static final int AV_PIX_FMT_YUVJ420P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVJ422P
```
public static final int AV_PIX_FMT_YUVJ422P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVJ444P
```
public static final int AV_PIX_FMT_YUVJ444P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_XVMC_MPEG2_MC
```
public static final int AV_PIX_FMT_XVMC_MPEG2_MC
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_XVMC_MPEG2_IDCT
```
public static final int AV_PIX_FMT_XVMC_MPEG2_IDCT
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_XVMC
```
public static final int AV_PIX_FMT_XVMC
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_UYVY422
```
public static final int AV_PIX_FMT_UYVY422
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_UYYVYY411
```
public static final int AV_PIX_FMT_UYYVYY411
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR8
```
public static final int AV_PIX_FMT_BGR8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR4
```
public static final int AV_PIX_FMT_BGR4
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR4_BYTE
```
public static final int AV_PIX_FMT_BGR4_BYTE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB8
```
public static final int AV_PIX_FMT_RGB8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB4
```
public static final int AV_PIX_FMT_RGB4
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB4_BYTE
```
public static final int AV_PIX_FMT_RGB4_BYTE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NV12
```
public static final int AV_PIX_FMT_NV12
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NV21
```
public static final int AV_PIX_FMT_NV21
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_ARGB
```
public static final int AV_PIX_FMT_ARGB
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGBA
```
public static final int AV_PIX_FMT_RGBA
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_ABGR
```
public static final int AV_PIX_FMT_ABGR
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGRA
```
public static final int AV_PIX_FMT_BGRA
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GRAY16BE
```
public static final int AV_PIX_FMT_GRAY16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GRAY16LE
```
public static final int AV_PIX_FMT_GRAY16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV440P
```
public static final int AV_PIX_FMT_YUV440P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVJ440P
```
public static final int AV_PIX_FMT_YUVJ440P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P
```
public static final int AV_PIX_FMT_YUVA420P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_H264
```
public static final int AV_PIX_FMT_VDPAU_H264
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_MPEG1
```
public static final int AV_PIX_FMT_VDPAU_MPEG1
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_MPEG2
```
public static final int AV_PIX_FMT_VDPAU_MPEG2
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_WMV3
```
public static final int AV_PIX_FMT_VDPAU_WMV3
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_VC1
```
public static final int AV_PIX_FMT_VDPAU_VC1
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB48BE
```
public static final int AV_PIX_FMT_RGB48BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB48LE
```
public static final int AV_PIX_FMT_RGB48LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB565BE
```
public static final int AV_PIX_FMT_RGB565BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB565LE
```
public static final int AV_PIX_FMT_RGB565LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB555BE
```
public static final int AV_PIX_FMT_RGB555BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB555LE
```
public static final int AV_PIX_FMT_RGB555LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR565BE
```
public static final int AV_PIX_FMT_BGR565BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR565LE
```
public static final int AV_PIX_FMT_BGR565LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR555BE
```
public static final int AV_PIX_FMT_BGR555BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR555LE
```
public static final int AV_PIX_FMT_BGR555LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VAAPI_MOCO
```
public static final int AV_PIX_FMT_VAAPI_MOCO
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VAAPI_IDCT
```
public static final int AV_PIX_FMT_VAAPI_IDCT
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VAAPI_VLD
```
public static final int AV_PIX_FMT_VAAPI_VLD
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VAAPI
```
public static final int AV_PIX_FMT_VAAPI
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P16LE
```
public static final int AV_PIX_FMT_YUV420P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P16BE
```
public static final int AV_PIX_FMT_YUV420P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P16LE
```
public static final int AV_PIX_FMT_YUV422P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P16BE
```
public static final int AV_PIX_FMT_YUV422P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P16LE
```
public static final int AV_PIX_FMT_YUV444P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P16BE
```
public static final int AV_PIX_FMT_YUV444P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU_MPEG4
```
public static final int AV_PIX_FMT_VDPAU_MPEG4
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_DXVA2_VLD
```
public static final int AV_PIX_FMT_DXVA2_VLD
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB444LE
```
public static final int AV_PIX_FMT_RGB444LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB444BE
```
public static final int AV_PIX_FMT_RGB444BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR444LE
```
public static final int AV_PIX_FMT_BGR444LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR444BE
```
public static final int AV_PIX_FMT_BGR444BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YA8
```
public static final int AV_PIX_FMT_YA8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_Y400A
```
public static final int AV_PIX_FMT_Y400A
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GRAY8A
```
public static final int AV_PIX_FMT_GRAY8A
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR48BE
```
public static final int AV_PIX_FMT_BGR48BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR48LE
```
public static final int AV_PIX_FMT_BGR48LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P9BE
```
public static final int AV_PIX_FMT_YUV420P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P9LE
```
public static final int AV_PIX_FMT_YUV420P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P10BE
```
public static final int AV_PIX_FMT_YUV420P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P10LE
```
public static final int AV_PIX_FMT_YUV420P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P10BE
```
public static final int AV_PIX_FMT_YUV422P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P10LE
```
public static final int AV_PIX_FMT_YUV422P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P9BE
```
public static final int AV_PIX_FMT_YUV444P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P9LE
```
public static final int AV_PIX_FMT_YUV444P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P10BE
```
public static final int AV_PIX_FMT_YUV444P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P10LE
```
public static final int AV_PIX_FMT_YUV444P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P9BE
```
public static final int AV_PIX_FMT_YUV422P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P9LE
```
public static final int AV_PIX_FMT_YUV422P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDA_VLD
```
public static final int AV_PIX_FMT_VDA_VLD
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP
```
public static final int AV_PIX_FMT_GBRP
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBR24P
```
public static final int AV_PIX_FMT_GBR24P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP9BE
```
public static final int AV_PIX_FMT_GBRP9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP9LE
```
public static final int AV_PIX_FMT_GBRP9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP10BE
```
public static final int AV_PIX_FMT_GBRP10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP10LE
```
public static final int AV_PIX_FMT_GBRP10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP16BE
```
public static final int AV_PIX_FMT_GBRP16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP16LE
```
public static final int AV_PIX_FMT_GBRP16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P
```
public static final int AV_PIX_FMT_YUVA422P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P
```
public static final int AV_PIX_FMT_YUVA444P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P9BE
```
public static final int AV_PIX_FMT_YUVA420P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P9LE
```
public static final int AV_PIX_FMT_YUVA420P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P9BE
```
public static final int AV_PIX_FMT_YUVA422P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P9LE
```
public static final int AV_PIX_FMT_YUVA422P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P9BE
```
public static final int AV_PIX_FMT_YUVA444P9BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P9LE
```
public static final int AV_PIX_FMT_YUVA444P9LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P10BE
```
public static final int AV_PIX_FMT_YUVA420P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P10LE
```
public static final int AV_PIX_FMT_YUVA420P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P10BE
```
public static final int AV_PIX_FMT_YUVA422P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P10LE
```
public static final int AV_PIX_FMT_YUVA422P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P10BE
```
public static final int AV_PIX_FMT_YUVA444P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P10LE
```
public static final int AV_PIX_FMT_YUVA444P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P16BE
```
public static final int AV_PIX_FMT_YUVA420P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA420P16LE
```
public static final int AV_PIX_FMT_YUVA420P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P16BE
```
public static final int AV_PIX_FMT_YUVA422P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA422P16LE
```
public static final int AV_PIX_FMT_YUVA422P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P16BE
```
public static final int AV_PIX_FMT_YUVA444P16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVA444P16LE
```
public static final int AV_PIX_FMT_YUVA444P16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDPAU
```
public static final int AV_PIX_FMT_VDPAU
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_XYZ12LE
```
public static final int AV_PIX_FMT_XYZ12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_XYZ12BE
```
public static final int AV_PIX_FMT_XYZ12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NV16
```
public static final int AV_PIX_FMT_NV16
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NV20LE
```
public static final int AV_PIX_FMT_NV20LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NV20BE
```
public static final int AV_PIX_FMT_NV20BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGBA64BE
```
public static final int AV_PIX_FMT_RGBA64BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGBA64LE
```
public static final int AV_PIX_FMT_RGBA64LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGRA64BE
```
public static final int AV_PIX_FMT_BGRA64BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGRA64LE
```
public static final int AV_PIX_FMT_BGRA64LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YVYU422
```
public static final int AV_PIX_FMT_YVYU422
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VDA
```
public static final int AV_PIX_FMT_VDA
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YA16BE
```
public static final int AV_PIX_FMT_YA16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YA16LE
```
public static final int AV_PIX_FMT_YA16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP
```
public static final int AV_PIX_FMT_GBRAP
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP16BE
```
public static final int AV_PIX_FMT_GBRAP16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP16LE
```
public static final int AV_PIX_FMT_GBRAP16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_QSV
```
public static final int AV_PIX_FMT_QSV
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_MMAL
```
public static final int AV_PIX_FMT_MMAL
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_D3D11VA_VLD
```
public static final int AV_PIX_FMT_D3D11VA_VLD
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_CUDA
```
public static final int AV_PIX_FMT_CUDA
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_0RGB
```
public static final int AV_PIX_FMT_0RGB
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB0
```
public static final int AV_PIX_FMT_RGB0
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_0BGR
```
public static final int AV_PIX_FMT_0BGR
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BGR0
```
public static final int AV_PIX_FMT_BGR0
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P12BE
```
public static final int AV_PIX_FMT_YUV420P12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P12LE
```
public static final int AV_PIX_FMT_YUV420P12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P14BE
```
public static final int AV_PIX_FMT_YUV420P14BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV420P14LE
```
public static final int AV_PIX_FMT_YUV420P14LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P12BE
```
public static final int AV_PIX_FMT_YUV422P12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P12LE
```
public static final int AV_PIX_FMT_YUV422P12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P14BE
```
public static final int AV_PIX_FMT_YUV422P14BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV422P14LE
```
public static final int AV_PIX_FMT_YUV422P14LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P12BE
```
public static final int AV_PIX_FMT_YUV444P12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P12LE
```
public static final int AV_PIX_FMT_YUV444P12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P14BE
```
public static final int AV_PIX_FMT_YUV444P14BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV444P14LE
```
public static final int AV_PIX_FMT_YUV444P14LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP12BE
```
public static final int AV_PIX_FMT_GBRP12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP12LE
```
public static final int AV_PIX_FMT_GBRP12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP14BE
```
public static final int AV_PIX_FMT_GBRP14BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRP14LE
```
public static final int AV_PIX_FMT_GBRP14LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUVJ411P
```
public static final int AV_PIX_FMT_YUVJ411P
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_BGGR8
```
public static final int AV_PIX_FMT_BAYER_BGGR8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_RGGB8
```
public static final int AV_PIX_FMT_BAYER_RGGB8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GBRG8
```
public static final int AV_PIX_FMT_BAYER_GBRG8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GRBG8
```
public static final int AV_PIX_FMT_BAYER_GRBG8
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_BGGR16LE
```
public static final int AV_PIX_FMT_BAYER_BGGR16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_BGGR16BE
```
public static final int AV_PIX_FMT_BAYER_BGGR16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_RGGB16LE
```
public static final int AV_PIX_FMT_BAYER_RGGB16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_RGGB16BE
```
public static final int AV_PIX_FMT_BAYER_RGGB16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GBRG16LE
```
public static final int AV_PIX_FMT_BAYER_GBRG16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GBRG16BE
```
public static final int AV_PIX_FMT_BAYER_GBRG16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GRBG16LE
```
public static final int AV_PIX_FMT_BAYER_GRBG16LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_BAYER_GRBG16BE
```
public static final int AV_PIX_FMT_BAYER_GRBG16BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV440P10LE
```
public static final int AV_PIX_FMT_YUV440P10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV440P10BE
```
public static final int AV_PIX_FMT_YUV440P10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV440P12LE
```
public static final int AV_PIX_FMT_YUV440P12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_YUV440P12BE
```
public static final int AV_PIX_FMT_YUV440P12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_AYUV64LE
```
public static final int AV_PIX_FMT_AYUV64LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_AYUV64BE
```
public static final int AV_PIX_FMT_AYUV64BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_VIDEOTOOLBOX
```
public static final int AV_PIX_FMT_VIDEOTOOLBOX
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_P010LE
```
public static final int AV_PIX_FMT_P010LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_P010BE
```
public static final int AV_PIX_FMT_P010BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP12BE
```
public static final int AV_PIX_FMT_GBRAP12BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP12LE
```
public static final int AV_PIX_FMT_GBRAP12LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP10BE
```
public static final int AV_PIX_FMT_GBRAP10BE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_GBRAP10LE
```
public static final int AV_PIX_FMT_GBRAP10LE
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_MEDIACODEC
```
public static final int AV_PIX_FMT_MEDIACODEC
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_NB
```
public static final int AV_PIX_FMT_NB
```
  enum AVPixelFormat
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_RGB32
```
public static final int AV_PIX_FMT_RGB32
```
- AV_PIX_FMT_RGB32_1
```
public static final int AV_PIX_FMT_RGB32_1
```
- AV_PIX_FMT_BGR32
```
public static final int AV_PIX_FMT_BGR32
```
- AV_PIX_FMT_BGR32_1
```
public static final int AV_PIX_FMT_BGR32_1
```
- AV_PIX_FMT_0RGB32
```
public static final int AV_PIX_FMT_0RGB32
```
- AV_PIX_FMT_0BGR32
```
public static final int AV_PIX_FMT_0BGR32
```
- AV_PIX_FMT_GRAY16
```
public static final int AV_PIX_FMT_GRAY16
```
- AV_PIX_FMT_YA16
```
public static final int AV_PIX_FMT_YA16
```
- AV_PIX_FMT_RGB48
```
public static final int AV_PIX_FMT_RGB48
```
- AV_PIX_FMT_RGB565
```
public static final int AV_PIX_FMT_RGB565
```
- AV_PIX_FMT_RGB555
```
public static final int AV_PIX_FMT_RGB555
```
- AV_PIX_FMT_RGB444
```
public static final int AV_PIX_FMT_RGB444
```
- AV_PIX_FMT_RGBA64
```
public static final int AV_PIX_FMT_RGBA64
```
- AV_PIX_FMT_BGR48
```
public static final int AV_PIX_FMT_BGR48
```
- AV_PIX_FMT_BGR565
```
public static final int AV_PIX_FMT_BGR565
```
- AV_PIX_FMT_BGR555
```
public static final int AV_PIX_FMT_BGR555
```
- AV_PIX_FMT_BGR444
```
public static final int AV_PIX_FMT_BGR444
```
- AV_PIX_FMT_BGRA64
```
public static final int AV_PIX_FMT_BGRA64
```
- AV_PIX_FMT_YUV420P9
```
public static final int AV_PIX_FMT_YUV420P9
```
- AV_PIX_FMT_YUV422P9
```
public static final int AV_PIX_FMT_YUV422P9
```
- AV_PIX_FMT_YUV444P9
```
public static final int AV_PIX_FMT_YUV444P9
```
- AV_PIX_FMT_YUV420P10
```
public static final int AV_PIX_FMT_YUV420P10
```
- AV_PIX_FMT_YUV422P10
```
public static final int AV_PIX_FMT_YUV422P10
```
- AV_PIX_FMT_YUV440P10
```
public static final int AV_PIX_FMT_YUV440P10
```
- AV_PIX_FMT_YUV444P10
```
public static final int AV_PIX_FMT_YUV444P10
```
- AV_PIX_FMT_YUV420P12
```
public static final int AV_PIX_FMT_YUV420P12
```
- AV_PIX_FMT_YUV422P12
```
public static final int AV_PIX_FMT_YUV422P12
```
- AV_PIX_FMT_YUV440P12
```
public static final int AV_PIX_FMT_YUV440P12
```
- AV_PIX_FMT_YUV444P12
```
public static final int AV_PIX_FMT_YUV444P12
```
- AV_PIX_FMT_YUV420P14
```
public static final int AV_PIX_FMT_YUV420P14
```
- AV_PIX_FMT_YUV422P14
```
public static final int AV_PIX_FMT_YUV422P14
```
- AV_PIX_FMT_YUV444P14
```
public static final int AV_PIX_FMT_YUV444P14
```
- AV_PIX_FMT_YUV420P16
```
public static final int AV_PIX_FMT_YUV420P16
```
- AV_PIX_FMT_YUV422P16
```
public static final int AV_PIX_FMT_YUV422P16
```
- AV_PIX_FMT_YUV444P16
```
public static final int AV_PIX_FMT_YUV444P16
```
- AV_PIX_FMT_GBRP9
```
public static final int AV_PIX_FMT_GBRP9
```
- AV_PIX_FMT_GBRP10
```
public static final int AV_PIX_FMT_GBRP10
```
- AV_PIX_FMT_GBRP12
```
public static final int AV_PIX_FMT_GBRP12
```
- AV_PIX_FMT_GBRP14
```
public static final int AV_PIX_FMT_GBRP14
```
- AV_PIX_FMT_GBRP16
```
public static final int AV_PIX_FMT_GBRP16
```
- AV_PIX_FMT_GBRAP10
```
public static final int AV_PIX_FMT_GBRAP10
```
- AV_PIX_FMT_GBRAP12
```
public static final int AV_PIX_FMT_GBRAP12
```
- AV_PIX_FMT_GBRAP16
```
public static final int AV_PIX_FMT_GBRAP16
```
- AV_PIX_FMT_BAYER_BGGR16
```
public static final int AV_PIX_FMT_BAYER_BGGR16
```
- AV_PIX_FMT_BAYER_RGGB16
```
public static final int AV_PIX_FMT_BAYER_RGGB16
```
- AV_PIX_FMT_BAYER_GBRG16
```
public static final int AV_PIX_FMT_BAYER_GBRG16
```
- AV_PIX_FMT_BAYER_GRBG16
```
public static final int AV_PIX_FMT_BAYER_GRBG16
```
- AV_PIX_FMT_YUVA420P9
```
public static final int AV_PIX_FMT_YUVA420P9
```
- AV_PIX_FMT_YUVA422P9
```
public static final int AV_PIX_FMT_YUVA422P9
```
- AV_PIX_FMT_YUVA444P9
```
public static final int AV_PIX_FMT_YUVA444P9
```
- AV_PIX_FMT_YUVA420P10
```
public static final int AV_PIX_FMT_YUVA420P10
```
- AV_PIX_FMT_YUVA422P10
```
public static final int AV_PIX_FMT_YUVA422P10
```
- AV_PIX_FMT_YUVA444P10
```
public static final int AV_PIX_FMT_YUVA444P10
```
- AV_PIX_FMT_YUVA420P16
```
public static final int AV_PIX_FMT_YUVA420P16
```
- AV_PIX_FMT_YUVA422P16
```
public static final int AV_PIX_FMT_YUVA422P16
```
- AV_PIX_FMT_YUVA444P16
```
public static final int AV_PIX_FMT_YUVA444P16
```
- AV_PIX_FMT_XYZ12
```
public static final int AV_PIX_FMT_XYZ12
```
- AV_PIX_FMT_NV20
```
public static final int AV_PIX_FMT_NV20
```
- AV_PIX_FMT_AYUV64
```
public static final int AV_PIX_FMT_AYUV64
```
- AV_PIX_FMT_P010
```
public static final int AV_PIX_FMT_P010
```
- AVCOL_PRI_RESERVED0
```
public static final int AVCOL_PRI_RESERVED0
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_BT709
```
public static final int AVCOL_PRI_BT709
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_UNSPECIFIED
```
public static final int AVCOL_PRI_UNSPECIFIED
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_RESERVED
```
public static final int AVCOL_PRI_RESERVED
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_BT470M
```
public static final int AVCOL_PRI_BT470M
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_BT470BG
```
public static final int AVCOL_PRI_BT470BG
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_SMPTE170M
```
public static final int AVCOL_PRI_SMPTE170M
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_SMPTE240M
```
public static final int AVCOL_PRI_SMPTE240M
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_FILM
```
public static final int AVCOL_PRI_FILM
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_BT2020
```
public static final int AVCOL_PRI_BT2020
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_SMPTEST428_1
```
public static final int AVCOL_PRI_SMPTEST428_1
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_SMPTE431
```
public static final int AVCOL_PRI_SMPTE431
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_SMPTE432
```
public static final int AVCOL_PRI_SMPTE432
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_PRI_NB
```
public static final int AVCOL_PRI_NB
```
  enum AVColorPrimaries
  
  See Also:
  Constant Field Values
- AVCOL_TRC_RESERVED0
```
public static final int AVCOL_TRC_RESERVED0
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_BT709
```
public static final int AVCOL_TRC_BT709
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_UNSPECIFIED
```
public static final int AVCOL_TRC_UNSPECIFIED
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_RESERVED
```
public static final int AVCOL_TRC_RESERVED
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_GAMMA22
```
public static final int AVCOL_TRC_GAMMA22
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_GAMMA28
```
public static final int AVCOL_TRC_GAMMA28
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_SMPTE170M
```
public static final int AVCOL_TRC_SMPTE170M
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_SMPTE240M
```
public static final int AVCOL_TRC_SMPTE240M
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_LINEAR
```
public static final int AVCOL_TRC_LINEAR
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_LOG
```
public static final int AVCOL_TRC_LOG
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_LOG_SQRT
```
public static final int AVCOL_TRC_LOG_SQRT
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_IEC61966_2_4
```
public static final int AVCOL_TRC_IEC61966_2_4
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_BT1361_ECG
```
public static final int AVCOL_TRC_BT1361_ECG
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_IEC61966_2_1
```
public static final int AVCOL_TRC_IEC61966_2_1
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_BT2020_10
```
public static final int AVCOL_TRC_BT2020_10
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_BT2020_12
```
public static final int AVCOL_TRC_BT2020_12
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_SMPTEST2084
```
public static final int AVCOL_TRC_SMPTEST2084
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_SMPTEST428_1
```
public static final int AVCOL_TRC_SMPTEST428_1
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_ARIB_STD_B67
```
public static final int AVCOL_TRC_ARIB_STD_B67
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_TRC_NB
```
public static final int AVCOL_TRC_NB
```
  enum AVColorTransferCharacteristic
  
  See Also:
  Constant Field Values
- AVCOL_SPC_RGB
```
public static final int AVCOL_SPC_RGB
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_BT709
```
public static final int AVCOL_SPC_BT709
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_UNSPECIFIED
```
public static final int AVCOL_SPC_UNSPECIFIED
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_RESERVED
```
public static final int AVCOL_SPC_RESERVED
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_FCC
```
public static final int AVCOL_SPC_FCC
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_BT470BG
```
public static final int AVCOL_SPC_BT470BG
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_SMPTE170M
```
public static final int AVCOL_SPC_SMPTE170M
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_SMPTE240M
```
public static final int AVCOL_SPC_SMPTE240M
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_YCOCG
```
public static final int AVCOL_SPC_YCOCG
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_BT2020_NCL
```
public static final int AVCOL_SPC_BT2020_NCL
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_BT2020_CL
```
public static final int AVCOL_SPC_BT2020_CL
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_SMPTE2085
```
public static final int AVCOL_SPC_SMPTE2085
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_NB
```
public static final int AVCOL_SPC_NB
```
  enum AVColorSpace
  
  See Also:
  Constant Field Values
- AVCOL_SPC_YCGCO
```
public static final int AVCOL_SPC_YCGCO
```
  See Also:
  Constant Field Values
- AVCOL_RANGE_UNSPECIFIED
```
public static final int AVCOL_RANGE_UNSPECIFIED
```
  enum AVColorRange
  
  See Also:
  Constant Field Values
- AVCOL_RANGE_MPEG
```
public static final int AVCOL_RANGE_MPEG
```
  enum AVColorRange
  
  See Also:
  Constant Field Values
- AVCOL_RANGE_JPEG
```
public static final int AVCOL_RANGE_JPEG
```
  enum AVColorRange
  
  See Also:
  Constant Field Values
- AVCOL_RANGE_NB
```
public static final int AVCOL_RANGE_NB
```
  enum AVColorRange
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_UNSPECIFIED
```
public static final int AVCHROMA_LOC_UNSPECIFIED
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_LEFT
```
public static final int AVCHROMA_LOC_LEFT
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_CENTER
```
public static final int AVCHROMA_LOC_CENTER
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_TOPLEFT
```
public static final int AVCHROMA_LOC_TOPLEFT
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_TOP
```
public static final int AVCHROMA_LOC_TOP
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_BOTTOMLEFT
```
public static final int AVCHROMA_LOC_BOTTOMLEFT
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_BOTTOM
```
public static final int AVCHROMA_LOC_BOTTOM
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AVCHROMA_LOC_NB
```
public static final int AVCHROMA_LOC_NB
```
  enum AVChromaLocation
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_PANSCAN
```
public static final int AV_FRAME_DATA_PANSCAN
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_A53_CC
```
public static final int AV_FRAME_DATA_A53_CC
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_STEREO3D
```
public static final int AV_FRAME_DATA_STEREO3D
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_MATRIXENCODING
```
public static final int AV_FRAME_DATA_MATRIXENCODING
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_DOWNMIX_INFO
```
public static final int AV_FRAME_DATA_DOWNMIX_INFO
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_REPLAYGAIN
```
public static final int AV_FRAME_DATA_REPLAYGAIN
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_DISPLAYMATRIX
```
public static final int AV_FRAME_DATA_DISPLAYMATRIX
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_AFD
```
public static final int AV_FRAME_DATA_AFD
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_MOTION_VECTORS
```
public static final int AV_FRAME_DATA_MOTION_VECTORS
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_SKIP_SAMPLES
```
public static final int AV_FRAME_DATA_SKIP_SAMPLES
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_AUDIO_SERVICE_TYPE
```
public static final int AV_FRAME_DATA_AUDIO_SERVICE_TYPE
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
```
public static final int AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_FRAME_DATA_GOP_TIMECODE
```
public static final int AV_FRAME_DATA_GOP_TIMECODE
```
  enum AVFrameSideDataType
  
  See Also:
  Constant Field Values
- AV_AFD_SAME
```
public static final int AV_AFD_SAME
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_4_3
```
public static final int AV_AFD_4_3
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_16_9
```
public static final int AV_AFD_16_9
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_14_9
```
public static final int AV_AFD_14_9
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_4_3_SP_14_9
```
public static final int AV_AFD_4_3_SP_14_9
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_16_9_SP_14_9
```
public static final int AV_AFD_16_9_SP_14_9
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_AFD_SP_4_3
```
public static final int AV_AFD_SP_4_3
```
  enum AVActiveFormatDescription
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_NONE
```
public static final int AV_SAMPLE_FMT_NONE
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_U8
```
public static final int AV_SAMPLE_FMT_U8
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S16
```
public static final int AV_SAMPLE_FMT_S16
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S32
```
public static final int AV_SAMPLE_FMT_S32
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_FLT
```
public static final int AV_SAMPLE_FMT_FLT
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_DBL
```
public static final int AV_SAMPLE_FMT_DBL
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_U8P
```
public static final int AV_SAMPLE_FMT_U8P
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S16P
```
public static final int AV_SAMPLE_FMT_S16P
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S32P
```
public static final int AV_SAMPLE_FMT_S32P
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_FLTP
```
public static final int AV_SAMPLE_FMT_FLTP
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_DBLP
```
public static final int AV_SAMPLE_FMT_DBLP
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S64
```
public static final int AV_SAMPLE_FMT_S64
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_S64P
```
public static final int AV_SAMPLE_FMT_S64P
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_SAMPLE_FMT_NB
```
public static final int AV_SAMPLE_FMT_NB
```
  enum AVSampleFormat
  
  See Also:
  Constant Field Values
- AV_CH_FRONT_LEFT
```
public static final int AV_CH_FRONT_LEFT
```
  \defgroup channel_masks Audio channel masks A channel layout is a 64-bits integer with a bit set for every channel. The number of bits set must be equal to the number of channels. The value 0 means that the channel layout is not known. \note this data structure is not powerful enough to handle channels combinations that have the same channel multiple times, such as dual-mono. \{
  
  See Also:
  Constant Field Values
- AV_CH_FRONT_RIGHT
```
public static final int AV_CH_FRONT_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_FRONT_CENTER
```
public static final int AV_CH_FRONT_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_LOW_FREQUENCY
```
public static final int AV_CH_LOW_FREQUENCY
```
  See Also:
  Constant Field Values
- AV_CH_BACK_LEFT
```
public static final int AV_CH_BACK_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_BACK_RIGHT
```
public static final int AV_CH_BACK_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_FRONT_LEFT_OF_CENTER
```
public static final int AV_CH_FRONT_LEFT_OF_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_FRONT_RIGHT_OF_CENTER
```
public static final int AV_CH_FRONT_RIGHT_OF_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_BACK_CENTER
```
public static final int AV_CH_BACK_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_SIDE_LEFT
```
public static final int AV_CH_SIDE_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_SIDE_RIGHT
```
public static final int AV_CH_SIDE_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_TOP_CENTER
```
public static final int AV_CH_TOP_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_TOP_FRONT_LEFT
```
public static final int AV_CH_TOP_FRONT_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_TOP_FRONT_CENTER
```
public static final int AV_CH_TOP_FRONT_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_TOP_FRONT_RIGHT
```
public static final int AV_CH_TOP_FRONT_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_TOP_BACK_LEFT
```
public static final int AV_CH_TOP_BACK_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_TOP_BACK_CENTER
```
public static final int AV_CH_TOP_BACK_CENTER
```
  See Also:
  Constant Field Values
- AV_CH_TOP_BACK_RIGHT
```
public static final int AV_CH_TOP_BACK_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_STEREO_LEFT
```
public static final int AV_CH_STEREO_LEFT
```
  Stereo downmix.
  
  See Also:
  Constant Field Values
- AV_CH_STEREO_RIGHT
```
public static final int AV_CH_STEREO_RIGHT
```
  See AV_CH_STEREO_LEFT.
  
  See Also:
  Constant Field Values
- AV_CH_WIDE_LEFT
```
public static final long AV_CH_WIDE_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_WIDE_RIGHT
```
public static final long AV_CH_WIDE_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_SURROUND_DIRECT_LEFT
```
public static final long AV_CH_SURROUND_DIRECT_LEFT
```
  See Also:
  Constant Field Values
- AV_CH_SURROUND_DIRECT_RIGHT
```
public static final long AV_CH_SURROUND_DIRECT_RIGHT
```
  See Also:
  Constant Field Values
- AV_CH_LOW_FREQUENCY_2
```
public static final long AV_CH_LOW_FREQUENCY_2
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_NATIVE
```
public static final long AV_CH_LAYOUT_NATIVE
```
  Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests the channel order of the decoder output to be the native codec channel order.
  
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_MONO
```
public static final int AV_CH_LAYOUT_MONO
```
  \} \defgroup channel_mask_c Audio channel layouts \{
  
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_STEREO
```
public static final int AV_CH_LAYOUT_STEREO
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_2POINT1
```
public static final int AV_CH_LAYOUT_2POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_2_1
```
public static final int AV_CH_LAYOUT_2_1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_SURROUND
```
public static final int AV_CH_LAYOUT_SURROUND
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_3POINT1
```
public static final int AV_CH_LAYOUT_3POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_4POINT0
```
public static final int AV_CH_LAYOUT_4POINT0
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_4POINT1
```
public static final int AV_CH_LAYOUT_4POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_2_2
```
public static final int AV_CH_LAYOUT_2_2
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_QUAD
```
public static final int AV_CH_LAYOUT_QUAD
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_5POINT0
```
public static final int AV_CH_LAYOUT_5POINT0
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_5POINT1
```
public static final int AV_CH_LAYOUT_5POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_5POINT0_BACK
```
public static final int AV_CH_LAYOUT_5POINT0_BACK
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_5POINT1_BACK
```
public static final int AV_CH_LAYOUT_5POINT1_BACK
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_6POINT0
```
public static final int AV_CH_LAYOUT_6POINT0
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_6POINT0_FRONT
```
public static final int AV_CH_LAYOUT_6POINT0_FRONT
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_HEXAGONAL
```
public static final int AV_CH_LAYOUT_HEXAGONAL
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_6POINT1
```
public static final int AV_CH_LAYOUT_6POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_6POINT1_BACK
```
public static final int AV_CH_LAYOUT_6POINT1_BACK
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_6POINT1_FRONT
```
public static final int AV_CH_LAYOUT_6POINT1_FRONT
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_7POINT0
```
public static final int AV_CH_LAYOUT_7POINT0
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_7POINT0_FRONT
```
public static final int AV_CH_LAYOUT_7POINT0_FRONT
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_7POINT1
```
public static final int AV_CH_LAYOUT_7POINT1
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_7POINT1_WIDE
```
public static final int AV_CH_LAYOUT_7POINT1_WIDE
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_7POINT1_WIDE_BACK
```
public static final int AV_CH_LAYOUT_7POINT1_WIDE_BACK
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_OCTAGONAL
```
public static final int AV_CH_LAYOUT_OCTAGONAL
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_HEXADECAGONAL
```
public static final long AV_CH_LAYOUT_HEXADECAGONAL
```
  See Also:
  Constant Field Values
- AV_CH_LAYOUT_STEREO_DOWNMIX
```
public static final int AV_CH_LAYOUT_STEREO_DOWNMIX
```
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_NONE
```
public static final int AV_MATRIX_ENCODING_NONE
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DOLBY
```
public static final int AV_MATRIX_ENCODING_DOLBY
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DPLII
```
public static final int AV_MATRIX_ENCODING_DPLII
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DPLIIX
```
public static final int AV_MATRIX_ENCODING_DPLIIX
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DPLIIZ
```
public static final int AV_MATRIX_ENCODING_DPLIIZ
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DOLBYEX
```
public static final int AV_MATRIX_ENCODING_DOLBYEX
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_DOLBYHEADPHONE
```
public static final int AV_MATRIX_ENCODING_DOLBYHEADPHONE
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_MATRIX_ENCODING_NB
```
public static final int AV_MATRIX_ENCODING_NB
```
  enum AVMatrixEncoding
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_FORCE
```
public static final int AV_CPU_FLAG_FORCE
```
  \} \}
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_MMX
```
public static final int AV_CPU_FLAG_MMX
```
  standard MMX
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_MMXEXT
```
public static final int AV_CPU_FLAG_MMXEXT
```
  SSE integer functions or AMD MMX ext
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_MMX2
```
public static final int AV_CPU_FLAG_MMX2
```
  SSE integer functions or AMD MMX ext
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_3DNOW
```
public static final int AV_CPU_FLAG_3DNOW
```
  AMD 3DNOW
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE
```
public static final int AV_CPU_FLAG_SSE
```
  SSE functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE2
```
public static final int AV_CPU_FLAG_SSE2
```
  PIV SSE2 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE2SLOW
```
public static final int AV_CPU_FLAG_SSE2SLOW
```
  SSE2 supported, but usually not faster than regular MMX/SSE (e.g. Core1)
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_3DNOWEXT
```
public static final int AV_CPU_FLAG_3DNOWEXT
```
  AMD 3DNowExt
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE3
```
public static final int AV_CPU_FLAG_SSE3
```
  Prescott SSE3 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE3SLOW
```
public static final int AV_CPU_FLAG_SSE3SLOW
```
  SSE3 supported, but usually not faster than regular MMX/SSE (e.g. Core1)
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSSE3
```
public static final int AV_CPU_FLAG_SSSE3
```
  Conroe SSSE3 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ATOM
```
public static final int AV_CPU_FLAG_ATOM
```
  Atom processor, some SSSE3 instructions are slower
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE4
```
public static final int AV_CPU_FLAG_SSE4
```
  Penryn SSE4.1 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SSE42
```
public static final int AV_CPU_FLAG_SSE42
```
  Nehalem SSE4.2 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_AESNI
```
public static final int AV_CPU_FLAG_AESNI
```
  Advanced Encryption Standard functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_AVX
```
public static final int AV_CPU_FLAG_AVX
```
  AVX functions: requires OS support even if YMM registers aren't used
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_AVXSLOW
```
public static final int AV_CPU_FLAG_AVXSLOW
```
  AVX supported, but slow when using YMM registers (e.g. Bulldozer)
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_XOP
```
public static final int AV_CPU_FLAG_XOP
```
  Bulldozer XOP functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_FMA4
```
public static final int AV_CPU_FLAG_FMA4
```
  Bulldozer FMA4 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_CMOV
```
public static final int AV_CPU_FLAG_CMOV
```
  supports cmov instruction
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_AVX2
```
public static final int AV_CPU_FLAG_AVX2
```
  AVX2 functions: requires OS support even if YMM registers aren't used
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_FMA3
```
public static final int AV_CPU_FLAG_FMA3
```
  Haswell FMA3 functions
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_BMI1
```
public static final int AV_CPU_FLAG_BMI1
```
  Bit Manipulation Instruction Set 1
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_BMI2
```
public static final int AV_CPU_FLAG_BMI2
```
  Bit Manipulation Instruction Set 2
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ALTIVEC
```
public static final int AV_CPU_FLAG_ALTIVEC
```
  standard
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_VSX
```
public static final int AV_CPU_FLAG_VSX
```
  ISA 2.06
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_POWER8
```
public static final int AV_CPU_FLAG_POWER8
```
  ISA 2.07
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ARMV5TE
```
public static final int AV_CPU_FLAG_ARMV5TE
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ARMV6
```
public static final int AV_CPU_FLAG_ARMV6
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ARMV6T2
```
public static final int AV_CPU_FLAG_ARMV6T2
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_VFP
```
public static final int AV_CPU_FLAG_VFP
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_VFPV3
```
public static final int AV_CPU_FLAG_VFPV3
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_NEON
```
public static final int AV_CPU_FLAG_NEON
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_ARMV8
```
public static final int AV_CPU_FLAG_ARMV8
```
  See Also:
  Constant Field Values
- AV_CPU_FLAG_VFP_VM
```
public static final int AV_CPU_FLAG_VFP_VM
```
  VFPv2 vector mode, deprecated in ARMv7-A and unavailable in various CPUs implementations
  
  See Also:
  Constant Field Values
- AV_CPU_FLAG_SETEND
```
public static final int AV_CPU_FLAG_SETEND
```
  See Also:
  Constant Field Values
- AV_DICT_MATCH_CASE
```
public static final int AV_DICT_MATCH_CASE
```
  Only get an entry with exact-case key match. Only relevant in av_dict_get().
  
  See Also:
  Constant Field Values
- AV_DICT_IGNORE_SUFFIX
```
public static final int AV_DICT_IGNORE_SUFFIX
```
  Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string. Only relevant in av_dict_get().
  
  See Also:
  Constant Field Values
- AV_DICT_DONT_STRDUP_KEY
```
public static final int AV_DICT_DONT_STRDUP_KEY
```
  Take ownership of a key that's been allocated with av_malloc() or another memory allocation function.
  
  See Also:
  Constant Field Values
- AV_DICT_DONT_STRDUP_VAL
```
public static final int AV_DICT_DONT_STRDUP_VAL
```
  Take ownership of a value that's been allocated with av_malloc() or another memory allocation function.
  
  See Also:
  Constant Field Values
- AV_DICT_DONT_OVERWRITE
```
public static final int AV_DICT_DONT_OVERWRITE
```
  Don't overwrite existing entries.
  
  See Also:
  Constant Field Values
- AV_DICT_APPEND
```
public static final int AV_DICT_APPEND
```
  If the entry already exists, append to it. Note that no delimiter is added, the strings are simply concatenated.
  
  See Also:
  Constant Field Values
- AV_DICT_MULTIKEY
```
public static final int AV_DICT_MULTIKEY
```
  Allow to store several equal keys in the dictionary
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_FLAGS
```
public static final int AV_OPT_TYPE_FLAGS
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_INT
```
public static final int AV_OPT_TYPE_INT
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_INT64
```
public static final int AV_OPT_TYPE_INT64
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_DOUBLE
```
public static final int AV_OPT_TYPE_DOUBLE
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_FLOAT
```
public static final int AV_OPT_TYPE_FLOAT
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_STRING
```
public static final int AV_OPT_TYPE_STRING
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_RATIONAL
```
public static final int AV_OPT_TYPE_RATIONAL
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_BINARY
```
public static final int AV_OPT_TYPE_BINARY
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_DICT
```
public static final int AV_OPT_TYPE_DICT
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_CONST
```
public static final int AV_OPT_TYPE_CONST
```
  enum AVOptionType
  
  See Also:
  Constant Field Values
- AV_OPT_TYPE_IMAGE_SIZE
```
public static final int AV_OPT_TYPE_IMAGE_SIZE
```
- AV_OPT_TYPE_PIXEL_FMT
```
public static final int AV_OPT_TYPE_PIXEL_FMT
```
- AV_OPT_TYPE_SAMPLE_FMT
```
public static final int AV_OPT_TYPE_SAMPLE_FMT
```
- AV_OPT_TYPE_VIDEO_RATE
```
public static final int AV_OPT_TYPE_VIDEO_RATE
```
- AV_OPT_TYPE_DURATION
```
public static final int AV_OPT_TYPE_DURATION
```
- AV_OPT_TYPE_COLOR
```
public static final int AV_OPT_TYPE_COLOR
```
- AV_OPT_TYPE_CHANNEL_LAYOUT
```
public static final int AV_OPT_TYPE_CHANNEL_LAYOUT
```
- AV_OPT_TYPE_BOOL
```
public static final int AV_OPT_TYPE_BOOL
```
- AV_OPT_FLAG_IMPLICIT_KEY
```
public static final int AV_OPT_FLAG_IMPLICIT_KEY
```
  enum
  
  See Also:
  Constant Field Values
- AV_OPT_SEARCH_CHILDREN
```
public static final int AV_OPT_SEARCH_CHILDREN
```
  Search in possible children of the given object first.
  
  See Also:
  Constant Field Values
- AV_OPT_SEARCH_FAKE_OBJ
```
public static final int AV_OPT_SEARCH_FAKE_OBJ
```
  The obj passed to av_opt_find() is fake -- only a double pointer to AVClass instead of a required pointer to a struct containing AVClass. This is useful for searching for options without needing to allocate the corresponding object.
  
  See Also:
  Constant Field Values
- AV_OPT_ALLOW_NULL
```
public static final int AV_OPT_ALLOW_NULL
```
  In av_opt_get, return NULL if the option has a pointer type and is set to NULL, rather than returning an empty string.
  
  See Also:
  Constant Field Values
- AV_OPT_MULTI_COMPONENT_RANGE
```
public static final int AV_OPT_MULTI_COMPONENT_RANGE
```
  Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than one component for certain option types.
  
  See Also:
  for details., Constant Field Values
- AV_OPT_SERIALIZE_SKIP_DEFAULTS
```
public static final int AV_OPT_SERIALIZE_SKIP_DEFAULTS
```
  Serialize options that are not set to default values only.
  
  See Also:
  Constant Field Values
- AV_OPT_SERIALIZE_OPT_FLAGS_EXACT
```
public static final int AV_OPT_SERIALIZE_OPT_FLAGS_EXACT
```
  Serialize options that exactly match opt_flags only.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_BE
```
public static final int AV_PIX_FMT_FLAG_BE
```
  Pixel format is big-endian.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_PAL
```
public static final int AV_PIX_FMT_FLAG_PAL
```
  Pixel format has a palette in data[1], values are indexes in this palette.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_BITSTREAM
```
public static final int AV_PIX_FMT_FLAG_BITSTREAM
```
  All values of a component are bit-wise packed end to end.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_HWACCEL
```
public static final int AV_PIX_FMT_FLAG_HWACCEL
```
  Pixel format is an HW accelerated format.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_PLANAR
```
public static final int AV_PIX_FMT_FLAG_PLANAR
```
  At least one pixel component is not in the first data plane.
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_RGB
```
public static final int AV_PIX_FMT_FLAG_RGB
```
  The pixel format contains RGB-like data (as opposed to YUV/grayscale).
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_PSEUDOPAL
```
public static final int AV_PIX_FMT_FLAG_PSEUDOPAL
```
  The pixel format is "pseudo-paletted". This means that it contains a fixed palette in the 2nd plane but the palette is fixed/constant for each PIX_FMT. This allows interpreting the data as if it was PAL8, which can in some cases be simpler. Or the data can be interpreted purely based on the pixel format without using the palette. An example of a pseudo-paletted format is AV_PIX_FMT_GRAY8
  
  See Also:
  Constant Field Values
- AV_PIX_FMT_FLAG_ALPHA
```
public static final int AV_PIX_FMT_FLAG_ALPHA
```
  The pixel format has an alpha channel. This is set on all formats that support alpha in some way. The exception is AV_PIX_FMT_PAL8, which can carry alpha as part of the palette. Details are explained in the AVPixelFormat enum, and are also encoded in the corresponding AVPixFmtDescriptor. The alpha is always straight, never pre-multiplied. If a codec or a filter does not support alpha, it should set all alpha to opaque, or use the equivalent pixel formats without alpha component, e.g. AV_PIX_FMT_RGB0 (or AV_PIX_FMT_RGB24 etc.) instead of AV_PIX_FMT_RGBA.
  
  See Also:
  Constant Field Values
- FF_LOSS_RESOLUTION
```
public static final int FF_LOSS_RESOLUTION
```
  loss due to resolution change
  
  See Also:
  Constant Field Values
- FF_LOSS_DEPTH
```
public static final int FF_LOSS_DEPTH
```
  loss due to color depth change
  
  See Also:
  Constant Field Values
- FF_LOSS_COLORSPACE
```
public static final int FF_LOSS_COLORSPACE
```
  loss due to color space conversion
  
  See Also:
  Constant Field Values
- FF_LOSS_ALPHA
```
public static final int FF_LOSS_ALPHA
```
  loss of alpha bits
  
  See Also:
  Constant Field Values
- FF_LOSS_COLORQUANT
```
public static final int FF_LOSS_COLORQUANT
```
  loss due to color quantization
  
  See Also:
  Constant Field Values
- FF_LOSS_CHROMA
```
public static final int FF_LOSS_CHROMA
```
  loss of chroma (e.g. RGB to gray conversion)
  
  See Also:
  Constant Field Values
- AV_DOWNMIX_TYPE_UNKNOWN
```
public static final int AV_DOWNMIX_TYPE_UNKNOWN
```
  enum AVDownmixType
  
  See Also:
  Constant Field Values
- AV_DOWNMIX_TYPE_LORO
```
public static final int AV_DOWNMIX_TYPE_LORO
```
  enum AVDownmixType
  
  See Also:
  Constant Field Values
- AV_DOWNMIX_TYPE_LTRT
```
public static final int AV_DOWNMIX_TYPE_LTRT
```
  enum AVDownmixType
  
  See Also:
  Constant Field Values
- AV_DOWNMIX_TYPE_DPLII
```
public static final int AV_DOWNMIX_TYPE_DPLII
```
  enum AVDownmixType
  
  See Also:
  Constant Field Values
- AV_DOWNMIX_TYPE_NB
```
public static final int AV_DOWNMIX_TYPE_NB
```
  enum AVDownmixType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_2D
```
public static final int AV_STEREO3D_2D
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_SIDEBYSIDE
```
public static final int AV_STEREO3D_SIDEBYSIDE
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_TOPBOTTOM
```
public static final int AV_STEREO3D_TOPBOTTOM
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_FRAMESEQUENCE
```
public static final int AV_STEREO3D_FRAMESEQUENCE
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_CHECKERBOARD
```
public static final int AV_STEREO3D_CHECKERBOARD
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_SIDEBYSIDE_QUINCUNX
```
public static final int AV_STEREO3D_SIDEBYSIDE_QUINCUNX
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_LINES
```
public static final int AV_STEREO3D_LINES
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_COLUMNS
```
public static final int AV_STEREO3D_COLUMNS
```
  enum AVStereo3DType
  
  See Also:
  Constant Field Values
- AV_STEREO3D_FLAG_INVERT
```
public static final int AV_STEREO3D_FLAG_INVERT
```
  Inverted views, Right/Bottom represents the left view.
  
  See Also:
  Constant Field Values
- FFMPEG_VERSION
```
public static final String FFMPEG_VERSION
```
  See Also:
  Constant Field Values

Constructor Detail
- avutil
```
public avutil()
```

Method Detail

avutil_version

@NoException
@Cast(value="unsigned")
public static int avutil_version()

Return the LIBAVUTIL_VERSION_INT constant.

av_version_info
```
@NoException
@Cast(value="const char*")
public static BytePointer av_version_info()
```
Return an informative version string. This usually is the actual release version number or a git commit description. This string has no fixed format and can change any time. It should never be parsed by code.

avutil_configuration

@NoException
@Cast(value="const char*")
public static BytePointer avutil_configuration()

Return the libavutil build-time configuration.

avutil_license

@NoException
@Cast(value="const char*")
public static BytePointer avutil_license()

Return the libavutil license.

av_get_media_type_string

@NoException
@Cast(value="const char*")
public static BytePointer av_get_media_type_string(@Cast(value="AVMediaType")
                                                         int media_type)

Return a string describing the media_type enum, NULL if media_type is unknown.

AV_NOPTS_VALUE
```
@MemberGetter
@Cast(value="int64_t")
public static long AV_NOPTS_VALUE()
```
\brief Undefined timestamp value Usually reported by demuxer that work on containers that do not provide either pts or dts.

av_get_picture_type_char
```
@NoException
@Cast(value="char")
public static byte av_get_picture_type_char(@Cast(value="AVPictureType")
                                                  int pict_type)
```
Return a single letter to describe the given picture type pict_type.

Parameters:
[in] - pict_type the picture type @return a single character representing the picture type, '?' if pict_type is unknown

av_x_if_null

@NoException
public static Pointer av_x_if_null(@Const
                               Pointer p,
                               @Const
                               Pointer x)

Return x default pointer in case p is NULL.

av_int_list_length_for_size

@NoException
@Cast(value="unsigned")
public static int av_int_list_length_for_size(@Cast(value="unsigned")
                                                    int elsize,
                                                    @Const
                                                    Pointer list,
                                                    @Cast(value="uint64_t")
                                                    long term)

Compute the length of an integer list.

Parameters:: elsize - size in bytes of each list element (only 1, 2, 4 or 8); term - list terminator (usually 0 or -1); list - pointer to the list
Returns:: length of the list, in elements, not counting the terminator

av_fopen_utf8

@NoException
@Cast(value="FILE*")
public static Pointer av_fopen_utf8(@Cast(value="const char*")
                                          BytePointer path,
                                          @Cast(value="const char*")
                                          BytePointer mode)

Open a file using a UTF-8 filename. The API of this function matches POSIX fopen(), errors are returned through errno.

av_fopen_utf8

@NoException
@Cast(value="FILE*")
public static Pointer av_fopen_utf8(String path,
                                          String mode)

av_get_time_base_q
```
@NoException
@ByVal
public static avutil.AVRational av_get_time_base_q()
```
Return the fractional representation of the internal time base.

AVERROR_BSF_NOT_FOUND

@MemberGetter
public static int AVERROR_BSF_NOT_FOUND()

Bitstream filter not found

AVERROR_BUG

@MemberGetter
public static int AVERROR_BUG()

Internal bug, also see AVERROR_BUG2

AVERROR_BUFFER_TOO_SMALL

@MemberGetter
public static int AVERROR_BUFFER_TOO_SMALL()

Buffer too small

AVERROR_DECODER_NOT_FOUND

@MemberGetter
public static int AVERROR_DECODER_NOT_FOUND()

Decoder not found

AVERROR_DEMUXER_NOT_FOUND

@MemberGetter
public static int AVERROR_DEMUXER_NOT_FOUND()

Demuxer not found

AVERROR_ENCODER_NOT_FOUND

@MemberGetter
public static int AVERROR_ENCODER_NOT_FOUND()

Encoder not found

AVERROR_EOF

@MemberGetter
public static int AVERROR_EOF()

End of file

AVERROR_EXIT
```
@MemberGetter
public static int AVERROR_EXIT()
```
Immediate exit was requested; the called function should not be restarted

AVERROR_EXTERNAL

@MemberGetter
public static int AVERROR_EXTERNAL()

Generic error in an external library

AVERROR_FILTER_NOT_FOUND

@MemberGetter
public static int AVERROR_FILTER_NOT_FOUND()

Filter not found

AVERROR_INVALIDDATA
```
@MemberGetter
public static int AVERROR_INVALIDDATA()
```
Invalid data found when processing input

AVERROR_MUXER_NOT_FOUND

@MemberGetter
public static int AVERROR_MUXER_NOT_FOUND()

Muxer not found

AVERROR_OPTION_NOT_FOUND

@MemberGetter
public static int AVERROR_OPTION_NOT_FOUND()

Option not found

AVERROR_PATCHWELCOME
```
@MemberGetter
public static int AVERROR_PATCHWELCOME()
```
Not yet implemented in FFmpeg, patches welcome

AVERROR_PROTOCOL_NOT_FOUND

@MemberGetter
public static int AVERROR_PROTOCOL_NOT_FOUND()

Protocol not found

AVERROR_STREAM_NOT_FOUND

@MemberGetter
public static int AVERROR_STREAM_NOT_FOUND()

Stream not found

AVERROR_BUG2
```
@MemberGetter
public static int AVERROR_BUG2()
```
This is semantically identical to AVERROR_BUG it has been introduced in Libav after our AVERROR_BUG and with a modified value.

AVERROR_UNKNOWN
```
@MemberGetter
public static int AVERROR_UNKNOWN()
```
Unknown error, typically from an external library

AVERROR_HTTP_BAD_REQUEST

@MemberGetter
public static int AVERROR_HTTP_BAD_REQUEST()

AVERROR_HTTP_UNAUTHORIZED

@MemberGetter
public static int AVERROR_HTTP_UNAUTHORIZED()

AVERROR_HTTP_FORBIDDEN

@MemberGetter
public static int AVERROR_HTTP_FORBIDDEN()

AVERROR_HTTP_NOT_FOUND

@MemberGetter
public static int AVERROR_HTTP_NOT_FOUND()

AVERROR_HTTP_OTHER_4XX

@MemberGetter
public static int AVERROR_HTTP_OTHER_4XX()

AVERROR_HTTP_SERVER_ERROR

@MemberGetter
public static int AVERROR_HTTP_SERVER_ERROR()

av_strerror
```
@NoException
public static int av_strerror(int errnum,
                          @Cast(value="char*")
                          BytePointer errbuf,
                          @Cast(value="size_t")
                          long errbuf_size)
```
Put a description of the AVERROR code errnum in errbuf. In case of failure the global variable errno is set to indicate the error. Even in case of failure av_strerror() will print a generic error message indicating the errnum provided to errbuf.

Parameters:
errnum - error code to describe
errbuf - buffer to which description is written
errbuf_size - the size in bytes of errbuf

Returns:
0 on success, a negative value if a description for errnum cannot be found

av_strerror

@NoException
public static int av_strerror(int errnum,
                          @Cast(value="char*")
                          ByteBuffer errbuf,
                          @Cast(value="size_t")
                          long errbuf_size)

av_strerror

@NoException
public static int av_strerror(int errnum,
                          @Cast(value="char*")
                          byte[] errbuf,
                          @Cast(value="size_t")
                          long errbuf_size)

av_make_error_string

@NoException
@Cast(value="char*")
public static BytePointer av_make_error_string(@Cast(value="char*")
                                                     BytePointer errbuf,
                                                     @Cast(value="size_t")
                                                     long errbuf_size,
                                                     int errnum)

Fill the provided buffer with a string containing an error string corresponding to the AVERROR code errnum.

Parameters:: errbuf - a buffer; errbuf_size - size in bytes of errbuf; errnum - error code to describe
Returns:: the buffer in input, filled with the error description
See Also:: av_strerror()

av_make_error_string

@NoException
@Cast(value="char*")
public static ByteBuffer av_make_error_string(@Cast(value="char*")
                                                    ByteBuffer errbuf,
                                                    @Cast(value="size_t")
                                                    long errbuf_size,
                                                    int errnum)

av_make_error_string

@NoException
@Cast(value="char*")
public static byte[] av_make_error_string(@Cast(value="char*")
                                                byte[] errbuf,
                                                @Cast(value="size_t")
                                                long errbuf_size,
                                                int errnum)

av_malloc
```
@NoException
public static Pointer av_malloc(@Cast(value="size_t")
                            long size)
```
Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU).

Parameters:
size - Size in bytes for the memory block to be allocated

Returns:
Pointer to the allocated block, or NULL if the block cannot be allocated
See Also:
av_mallocz()

av_mallocz
```
@NoException
public static Pointer av_mallocz(@Cast(value="size_t")
                             long size)
```
Allocate a memory block with alignment suitable for all memory accesses (including vectors if available on the CPU) and zero all the bytes of the block.

Parameters:
size - Size in bytes for the memory block to be allocated

Returns:
Pointer to the allocated block, or NULL if it cannot be allocated
See Also:
av_malloc()

av_malloc_array
```
@NoException
public static Pointer av_malloc_array(@Cast(value="size_t")
                                  long nmemb,
                                  @Cast(value="size_t")
                                  long size)
```
Allocate a memory block for an array with av_malloc(). The allocated memory will have size size * nmemb bytes.

Parameters:
nmemb - Number of element
size - Size of a single element

Returns:
Pointer to the allocated block, or NULL if the block cannot be allocated
See Also:
av_malloc()

av_mallocz_array
```
@NoException
public static Pointer av_mallocz_array(@Cast(value="size_t")
                                   long nmemb,
                                   @Cast(value="size_t")
                                   long size)
```
Allocate a memory block for an array with av_mallocz(). The allocated memory will have size size * nmemb bytes.

Parameters:
nmemb - Number of elements
size - Size of the single element

Returns:
Pointer to the allocated block, or NULL if the block cannot be allocated
See Also:
av_mallocz(), av_malloc_array()

av_calloc

@NoException
public static Pointer av_calloc(@Cast(value="size_t")
                            long nmemb,
                            @Cast(value="size_t")
                            long size)

Non-inlined equivalent of av_mallocz_array(). Created for symmetry with the calloc() C function.

av_realloc
```
@NoException
public static Pointer av_realloc(Pointer ptr,
                             @Cast(value="size_t")
                             long size)
```
Allocate, reallocate, or free a block of memory. If ptr is NULL and size > 0, allocate a new block. If size is zero, free the memory block pointed to by ptr. Otherwise, expand or shrink that block of memory according to size.

Parameters:
ptr - Pointer to a memory block already allocated with av_realloc() or NULL
size - Size in bytes of the memory block to be allocated or reallocated

Returns:
Pointer to a newly-reallocated block or NULL if the block cannot be reallocated or the function is used to free the memory block \warning Unlike av_malloc(), the returned pointer is not guaranteed to be correctly aligned.
See Also:
av_fast_realloc(), av_reallocp()

av_reallocp
```
@NoException
public static int av_reallocp(Pointer ptr,
                          @Cast(value="size_t")
                          long size)
```
Allocate, reallocate, or free a block of memory through a pointer to a pointer. If *ptr is NULL and size > 0, allocate a new block. If size is zero, free the memory block pointed to by *ptr. Otherwise, expand or shrink that block of memory according to size.

Parameters:
[in,out] - ptr Pointer to a pointer to a memory block already allocated with av_realloc(), or a pointer to NULL. The pointer is updated on success, or freed on failure.
[in] - size Size in bytes for the memory block to be allocated or reallocated

Returns:
Zero on success, an AVERROR error code on failure \warning Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.

av_realloc_f

@NoException
public static Pointer av_realloc_f(Pointer ptr,
                               @Cast(value="size_t")
                               long nelem,
                               @Cast(value="size_t")
                               long elsize)

Allocate, reallocate, or free a block of memory. This function does the same thing as av_realloc(), except: - It takes two size arguments and allocates nelem * elsize bytes, after checking the result of the multiplication for integer overflow. - It frees the input block in case of failure, thus avoiding the memory leak with the classic

{.c}
   buf = realloc(buf);
   if (!buf)
       return -1;

pattern.

av_realloc_array
```
@NoException
public static Pointer av_realloc_array(Pointer ptr,
                                   @Cast(value="size_t")
                                   long nmemb,
                                   @Cast(value="size_t")
                                   long size)
```
Allocate, reallocate, or free an array. If ptr is NULL and nmemb > 0, allocate a new block. If nmemb is zero, free the memory block pointed to by ptr.

Parameters:
ptr - Pointer to a memory block already allocated with av_realloc() or NULL
nmemb - Number of elements in the array
size - Size of the single element of the array

Returns:
Pointer to a newly-reallocated block or NULL if the block cannot be reallocated or the function is used to free the memory block \warning Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.
See Also:
av_reallocp_array()

av_reallocp_array
```
@NoException
public static int av_reallocp_array(Pointer ptr,
                                @Cast(value="size_t")
                                long nmemb,
                                @Cast(value="size_t")
                                long size)
```
Allocate, reallocate, or free an array through a pointer to a pointer. If *ptr is NULL and nmemb > 0, allocate a new block. If nmemb is zero, free the memory block pointed to by *ptr.

Parameters:
[in,out] - ptr Pointer to a pointer to a memory block already allocated with av_realloc(), or a pointer to NULL. The pointer is updated on success, or freed on failure.
[in] - nmemb Number of elements
[in] - size Size of the single element

Returns:
Zero on success, an AVERROR error code on failure \warning Unlike av_malloc(), the allocated memory is not guaranteed to be correctly aligned.

av_fast_realloc
```
@NoException
public static Pointer av_fast_realloc(Pointer ptr,
                                  @Cast(value="unsigned int*")
                                  IntPointer size,
                                  @Cast(value="size_t")
                                  long min_size)
```
Reallocate the given buffer if it is not large enough, otherwise do nothing. If the given buffer is NULL, then a new uninitialized buffer is allocated. If the given buffer is not large enough, and reallocation fails, NULL is returned and *size is set to 0, but the original buffer is not changed or freed. A typical use pattern follows:
```
{.c}
 uint8_t *buf = ...;
 uint8_t *new_buf = av_fast_realloc(buf, &current_size, size_needed);
 if (!new_buf) {
     // Allocation failed; clean up original buffer
     av_freep(&buf);
     return AVERROR(ENOMEM);
 }
 
```
Parameters:
[in,out] - ptr Already allocated buffer, or NULL
[in,out] - size Pointer to current size of buffer ptr. *size is changed to min_size in case of success or 0 in case of failure
[in] - min_size New size of buffer ptr

Returns:
ptr if the buffer is large enough, a pointer to newly reallocated buffer if the buffer was not large enough, or NULL in case of error
See Also:
av_realloc(), av_fast_malloc()

av_fast_realloc

@NoException
public static Pointer av_fast_realloc(Pointer ptr,
                                  @Cast(value="unsigned int*")
                                  IntBuffer size,
                                  @Cast(value="size_t")
                                  long min_size)

av_fast_realloc

@NoException
public static Pointer av_fast_realloc(Pointer ptr,
                                  @Cast(value="unsigned int*")
                                  int[] size,
                                  @Cast(value="size_t")
                                  long min_size)

av_fast_malloc
```
@NoException
public static void av_fast_malloc(Pointer ptr,
                              @Cast(value="unsigned int*")
                              IntPointer size,
                              @Cast(value="size_t")
                              long min_size)
```
Allocate a buffer, reusing the given one if large enough. Contrary to av_fast_realloc(), the current buffer contents might not be preserved and on error the old buffer is freed, thus no special handling to avoid memleaks is necessary. *ptr is allowed to be NULL, in which case allocation always happens if size_needed is greater than 0.
```
{.c}
 uint8_t *buf = ...;
 av_fast_malloc(&buf, &current_size, size_needed);
 if (!buf) {
     // Allocation failed; buf already freed
     return AVERROR(ENOMEM);
 }
 
```
Parameters:
[in,out] - ptr Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure
[in,out] - size Pointer to current size of buffer *ptr. *size is changed to min_size in case of success or 0 in case of failure
[in] - min_size New size of buffer *ptr
See Also:
av_realloc(), av_fast_mallocz()

av_fast_malloc

@NoException
public static void av_fast_malloc(Pointer ptr,
                              @Cast(value="unsigned int*")
                              IntBuffer size,
                              @Cast(value="size_t")
                              long min_size)

av_fast_malloc

@NoException
public static void av_fast_malloc(Pointer ptr,
                              @Cast(value="unsigned int*")
                              int[] size,
                              @Cast(value="size_t")
                              long min_size)

av_fast_mallocz
```
@NoException
public static void av_fast_mallocz(Pointer ptr,
                               @Cast(value="unsigned int*")
                               IntPointer size,
                               @Cast(value="size_t")
                               long min_size)
```
Allocate and clear a buffer, reusing the given one if large enough. Like av_fast_malloc(), but all newly allocated space is initially cleared. Reused buffer is not cleared. *ptr is allowed to be NULL, in which case allocation always happens if size_needed is greater than 0.

Parameters:
[in,out] - ptr Pointer to pointer to an already allocated buffer. *ptr will be overwritten with pointer to new buffer on success or NULL on failure
[in,out] - size Pointer to current size of buffer *ptr. *size is changed to min_size in case of success or 0 in case of failure
[in] - min_size New size of buffer *ptr
See Also:
av_fast_malloc()

av_fast_mallocz

@NoException
public static void av_fast_mallocz(Pointer ptr,
                               @Cast(value="unsigned int*")
                               IntBuffer size,
                               @Cast(value="size_t")
                               long min_size)

av_fast_mallocz

@NoException
public static void av_fast_mallocz(Pointer ptr,
                               @Cast(value="unsigned int*")
                               int[] size,
                               @Cast(value="size_t")
                               long min_size)

av_free
```
@NoException
public static void av_free(Pointer ptr)
```
Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family.

Parameters:
ptr - Pointer to the memory block which should be freed. \note ptr = NULL is explicitly allowed. \note It is recommended that you use av_freep() instead, to prevent leaving behind dangling pointers.
See Also:
av_freep()

av_freep

@NoException
public static void av_freep(Pointer ptr)

Free a memory block which has been allocated with a function of av_malloc() or av_realloc() family, and set the pointer pointing to it to NULL.

{.c}
 uint8_t *buf = av_malloc(16);
 av_free(buf);
 // buf now contains a dangling pointer to freed memory, and accidental
 // dereference of buf will result in a use-after-free, which may be a
 // security risk.

 uint8_t *buf = av_malloc(16);
 av_freep(&buf);
 // buf is now NULL, and accidental dereference will only result in a
 // NULL-pointer dereference.

Parameters:: ptr - Pointer to the pointer to the memory block which should be freed \note *ptr = NULL is safe and leads to no action.
See Also:: av_free()

av_strdup

@NoException
@Cast(value="char*")
public static BytePointer av_strdup(@Cast(value="const char*")
                                          BytePointer s)

Duplicate a string.

Parameters:: s - String to be duplicated
Returns:: Pointer to a newly-allocated string containing a copy of s or NULL if the string cannot be allocated
See Also:: av_strndup()

av_strdup

@NoException
@Cast(value="char*")
public static ByteBuffer av_strdup(String s)

av_strndup

@NoException
@Cast(value="char*")
public static BytePointer av_strndup(@Cast(value="const char*")
                                           BytePointer s,
                                           @Cast(value="size_t")
                                           long len)

Duplicate a substring of a string.

Parameters:: s - String to be duplicated; len - Maximum length of the resulting string (not counting the terminating byte)
Returns:: Pointer to a newly-allocated string containing a substring of s or NULL if the string cannot be allocated

av_strndup

@NoException
@Cast(value="char*")
public static ByteBuffer av_strndup(String s,
                                          @Cast(value="size_t")
                                          long len)

av_memdup

@NoException
public static Pointer av_memdup(@Const
                            Pointer p,
                            @Cast(value="size_t")
                            long size)

Duplicate a buffer with av_malloc().

Parameters:: p - Buffer to be duplicated; size - Size in bytes of the buffer copied
Returns:: Pointer to a newly allocated buffer containing a copy of p or NULL if the buffer cannot be allocated

av_memcpy_backptr
```
@NoException
public static void av_memcpy_backptr(@Cast(value="uint8_t*")
                                 BytePointer dst,
                                 int back,
                                 int cnt)
```
Overlapping memcpy() implementation.

Parameters:
dst - Destination buffer
back - Number of bytes back to start copying (i.e. the initial size of the overlapping window); must be > 0
cnt - Number of bytes to copy; must be >= 0 \note cnt > back is valid, this will copy the bytes we just copied, thus creating a repeating pattern with a period length of back.

av_memcpy_backptr

@NoException
public static void av_memcpy_backptr(@Cast(value="uint8_t*")
                                 ByteBuffer dst,
                                 int back,
                                 int cnt)

av_memcpy_backptr

@NoException
public static void av_memcpy_backptr(@Cast(value="uint8_t*")
                                 byte[] dst,
                                 int back,
                                 int cnt)

av_dynarray_add
```
@NoException
public static void av_dynarray_add(Pointer tab_ptr,
                               IntPointer nb_ptr,
                               Pointer elem)
```
Add the pointer to an element to a dynamic array. The array to grow is supposed to be an array of pointers to structures, and the element to add must be a pointer to an already allocated structure. The array is reallocated when its size reaches powers of 2. Therefore, the amortized cost of adding an element is constant. In case of success, the pointer to the array is updated in order to point to the new grown array, and the number pointed to by nb_ptr is incremented. In case of failure, the array is freed, *tab_ptr is set to NULL and *nb_ptr is set to 0.

Parameters:
[in,out] - tab_ptr Pointer to the array to grow
[in,out] - nb_ptr Pointer to the number of elements in the array
[in] - elem Element to add
See Also:
av_dynarray_add_nofree(), av_dynarray2_add()

av_dynarray_add

@NoException
public static void av_dynarray_add(Pointer tab_ptr,
                               IntBuffer nb_ptr,
                               Pointer elem)

av_dynarray_add

@NoException
public static void av_dynarray_add(Pointer tab_ptr,
                               int[] nb_ptr,
                               Pointer elem)

av_dynarray_add_nofree
```
@NoException
public static int av_dynarray_add_nofree(Pointer tab_ptr,
                                     IntPointer nb_ptr,
                                     Pointer elem)
```
Add an element to a dynamic array. Function has the same functionality as av_dynarray_add(), but it doesn't free memory on fails. It returns error code instead and leave current buffer untouched.

Returns:
>=0 on success, negative otherwise
See Also:
av_dynarray_add(), av_dynarray2_add()

av_dynarray_add_nofree

@NoException
public static int av_dynarray_add_nofree(Pointer tab_ptr,
                                     IntBuffer nb_ptr,
                                     Pointer elem)

av_dynarray_add_nofree

@NoException
public static int av_dynarray_add_nofree(Pointer tab_ptr,
                                     int[] nb_ptr,
                                     Pointer elem)

av_dynarray2_add
```
@NoException
public static Pointer av_dynarray2_add(@Cast(value="void**")
                                   PointerPointer tab_ptr,
                                   IntPointer nb_ptr,
                                   @Cast(value="size_t")
                                   long elem_size,
                                   @Cast(value="const uint8_t*")
                                   BytePointer elem_data)
```
Add an element of size elem_size to a dynamic array. The array is reallocated when its number of elements reaches powers of 2. Therefore, the amortized cost of adding an element is constant. In case of success, the pointer to the array is updated in order to point to the new grown array, and the number pointed to by nb_ptr is incremented. In case of failure, the array is freed, *tab_ptr is set to NULL and *nb_ptr is set to 0.

Parameters:
[in,out] - tab_ptr Pointer to the array to grow
[in,out] - nb_ptr Pointer to the number of elements in the array
[in] - elem_size Size in bytes of an element in the array
[in] - elem_data Pointer to the data of the element to add. If NULL, the space of the newly added element is allocated but left uninitialized.

Returns:
Pointer to the data of the element to copy in the newly allocated space
See Also:
av_dynarray_add(), av_dynarray_add_nofree()

av_dynarray2_add

@NoException
public static Pointer av_dynarray2_add(@Cast(value="void**")@ByPtrPtr
                                   Pointer tab_ptr,
                                   IntPointer nb_ptr,
                                   @Cast(value="size_t")
                                   long elem_size,
                                   @Cast(value="const uint8_t*")
                                   BytePointer elem_data)

av_dynarray2_add

@NoException
public static Pointer av_dynarray2_add(@Cast(value="void**")@ByPtrPtr
                                   Pointer tab_ptr,
                                   IntBuffer nb_ptr,
                                   @Cast(value="size_t")
                                   long elem_size,
                                   @Cast(value="const uint8_t*")
                                   ByteBuffer elem_data)

av_dynarray2_add

@NoException
public static Pointer av_dynarray2_add(@Cast(value="void**")@ByPtrPtr
                                   Pointer tab_ptr,
                                   int[] nb_ptr,
                                   @Cast(value="size_t")
                                   long elem_size,
                                   @Cast(value="const uint8_t*")
                                   byte[] elem_data)

av_size_mult

@NoException
public static int av_size_mult(@Cast(value="size_t")
                           long a,
                           @Cast(value="size_t")
                           long b,
                           @Cast(value="size_t*")
                           SizeTPointer r)

Multiply two size_t values checking for overflow.

Parameters:: [in] - a,b Operands of multiplication; [out] - r Pointer to the result of the operation
Returns:: 0 on success, AVERROR(EINVAL) on overflow

av_max_alloc
```
@NoException
public static void av_max_alloc(@Cast(value="size_t")
                            long max)
```
Set the maximum size that may be allocated in one block. The value specified with this function is effective for all libavutil's \ref lavu_mem_funcs "heap management functions." By default, the max value is defined as INT_MAX.

Parameters:
max - Value to be set as the new maximum size \warning Exercise extreme caution when using this function. Don't touch this if you do not understand the full consequence of doing so.

NAN

@MemberGetter
public static double NAN()

INFINITY

@MemberGetter
public static double INFINITY()

av_gcd

@NoException
@Cast(value="int64_t")
@Const
public static long av_gcd(@Cast(value="int64_t")
                                      long a,
                                      @Cast(value="int64_t")
                                      long b)

Compute the greatest common divisor of two integer operands.

Parameters:: a,b - Operands
Returns:: GCD of a and b up to sign; if a >= 0 and b >= 0, return value is >= 0; if a == 0 and b == 0, returns 0.

av_rescale

@NoException
@Cast(value="int64_t")
public static long av_rescale(@Cast(value="int64_t")
                                    long a,
                                    @Cast(value="int64_t")
                                    long b,
                                    @Cast(value="int64_t")
                                    long c)

Rescale a 64-bit integer with rounding to nearest. The operation is mathematically equivalent to a * b / c, but writing that directly can overflow. This function is equivalent to av_rescale_rnd() with #AV_ROUND_NEAR_INF.

See Also:: av_rescale_rnd(), av_rescale_q(), av_rescale_q_rnd()

av_rescale_rnd

@NoException
@Cast(value="int64_t")
public static long av_rescale_rnd(@Cast(value="int64_t")
                                        long a,
                                        @Cast(value="int64_t")
                                        long b,
                                        @Cast(value="int64_t")
                                        long c,
                                        @Cast(value="AVRounding")
                                        int rnd)

Rescale a 64-bit integer with specified rounding. The operation is mathematically equivalent to a * b / c, but writing that directly can overflow, and does not support different rounding methods.

See Also:: av_rescale(), av_rescale_q(), av_rescale_q_rnd()

av_rescale_q

@NoException
@Cast(value="int64_t")
public static long av_rescale_q(@Cast(value="int64_t")
                                      long a,
                                      @ByVal
                                      avutil.AVRational bq,
                                      @ByVal
                                      avutil.AVRational cq)

Rescale a 64-bit integer by 2 rational numbers. The operation is mathematically equivalent to a * bq / cq. This function is equivalent to av_rescale_q_rnd() with #AV_ROUND_NEAR_INF.

See Also:: av_rescale(), av_rescale_rnd(), av_rescale_q_rnd()

av_rescale_q_rnd

@NoException
@Cast(value="int64_t")
public static long av_rescale_q_rnd(@Cast(value="int64_t")
                                          long a,
                                          @ByVal
                                          avutil.AVRational bq,
                                          @ByVal
                                          avutil.AVRational cq,
                                          @Cast(value="AVRounding")
                                          int rnd)

Rescale a 64-bit integer by 2 rational numbers with specified rounding. The operation is mathematically equivalent to a * bq / cq.

See Also:: av_rescale(), av_rescale_rnd(), av_rescale_q()

av_compare_ts

@NoException
public static int av_compare_ts(@Cast(value="int64_t")
                            long ts_a,
                            @ByVal
                            avutil.AVRational tb_a,
                            @Cast(value="int64_t")
                            long ts_b,
                            @ByVal
                            avutil.AVRational tb_b)

Compare two timestamps each in its own time base.

Returns:: One of the following values: - -1 if ts_a is before ts_b - 1 if ts_a is after ts_b - 0 if they represent the same position \warning The result of the function is undefined if one of the timestamps is outside the int64_t range when represented in the other's timebase.

av_compare_mod

@NoException
@Cast(value="int64_t")
public static long av_compare_mod(@Cast(value="uint64_t")
                                        long a,
                                        @Cast(value="uint64_t")
                                        long b,
                                        @Cast(value="uint64_t")
                                        long mod)

Compare the remainders of two integer operands divided by a common divisor. In other words, compare the least significant log2(mod) bits of integers a and b.

{.c}
 av_compare_mod(0x11, 0x02, 0x10) < 0 // since 0x11 % 0x10  (0x1) < 0x02 % 0x10  (0x2)
 av_compare_mod(0x11, 0x02, 0x20) > 0 // since 0x11 % 0x20 (0x11) > 0x02 % 0x20 (0x02)

Parameters:: a,b - Operands; mod - Divisor; must be a power of 2
Returns:: - a negative value if a % mod < b % mod - a positive value if a % mod > b % mod - zero if a % mod == b % mod

av_rescale_delta
```
@NoException
@Cast(value="int64_t")
public static long av_rescale_delta(@ByVal
                                          avutil.AVRational in_tb,
                                          @Cast(value="int64_t")
                                          long in_ts,
                                          @ByVal
                                          avutil.AVRational fs_tb,
                                          int duration,
                                          @Cast(value="int64_t*")
                                          LongPointer last,
                                          @ByVal
                                          avutil.AVRational out_tb)
```
Rescale a timestamp while preserving known durations. This function is designed to be called per audio packet to scale the input timestamp to a different time base. Compared to a simple av_rescale_q() call, this function is robust against possible inconsistent frame durations. The last parameter is a state variable that must be preserved for all subsequent calls for the same stream. For the first call, *last should be initialized to #AV_NOPTS_VALUE.

Parameters:
[in] - in_tb Input time base
[in] - in_ts Input timestamp
[in] - fs_tb Duration time base; typically this is finer-grained (greater) than in_tb and out_tb
[in] - duration Duration till the next call to this function (i.e. duration of the current packet/frame)
[in,out] - last Pointer to a timestamp expressed in terms of fs_tb, acting as a state variable
[in] - out_tb Output timebase

Returns:
Timestamp expressed in terms of out_tb \note In the context of this function, "duration" is in term of samples, not seconds.

av_rescale_delta

@NoException
@Cast(value="int64_t")
public static long av_rescale_delta(@ByVal
                                          avutil.AVRational in_tb,
                                          @Cast(value="int64_t")
                                          long in_ts,
                                          @ByVal
                                          avutil.AVRational fs_tb,
                                          int duration,
                                          @Cast(value="int64_t*")
                                          LongBuffer last,
                                          @ByVal
                                          avutil.AVRational out_tb)

av_rescale_delta

@NoException
@Cast(value="int64_t")
public static long av_rescale_delta(@ByVal
                                          avutil.AVRational in_tb,
                                          @Cast(value="int64_t")
                                          long in_ts,
                                          @ByVal
                                          avutil.AVRational fs_tb,
                                          int duration,
                                          @Cast(value="int64_t*")
                                          long[] last,
                                          @ByVal
                                          avutil.AVRational out_tb)

av_add_stable

@NoException
@Cast(value="int64_t")
public static long av_add_stable(@ByVal
                                       avutil.AVRational ts_tb,
                                       @Cast(value="int64_t")
                                       long ts,
                                       @ByVal
                                       avutil.AVRational inc_tb,
                                       @Cast(value="int64_t")
                                       long inc)

Add a value to a timestamp. This function guarantees that when the same value is repeatly added that no accumulation of rounding errors occurs.

Parameters:: [in] - ts Input timestamp; [in] - ts_tb Input timestamp time base; [in] - inc Value to be added; [in] - inc_tb Time base of inc

av_make_q
```
@NoException
@ByVal
public static avutil.AVRational av_make_q(int num,
                                            int den)
```
Create an AVRational. Useful for compilers that do not support compound literals. \note The return value is not reduced.

See Also:
av_reduce()

av_cmp_q

@NoException
public static int av_cmp_q(@ByVal
                       avutil.AVRational a,
                       @ByVal
                       avutil.AVRational b)

Compare two rationals.

Parameters:: a - First rational; b - Second rational
Returns:: One of the following values: - 0 if a == b - 1 if a > b - -1 if a < b - INT_MIN if one of the values is of the form 0 / 0

av_q2d

@NoException
public static double av_q2d(@ByVal
                        avutil.AVRational a)

Convert an AVRational to a double.

Parameters:: a - AVRational to convert
Returns:: a in floating-point form
See Also:: av_d2q()

av_reduce

@NoException
public static int av_reduce(IntPointer dst_num,
                        IntPointer dst_den,
                        @Cast(value="int64_t")
                        long num,
                        @Cast(value="int64_t")
                        long den,
                        @Cast(value="int64_t")
                        long max)

Reduce a fraction. This is useful for framerate calculations.

Parameters:: [out] - dst_num Destination numerator; [out] - dst_den Destination denominator; [in] - num Source numerator; [in] - den Source denominator; [in] - max Maximum allowed values for dst_num & dst_den
Returns:: 1 if the operation is exact, 0 otherwise

av_reduce

@NoException
public static int av_reduce(IntBuffer dst_num,
                        IntBuffer dst_den,
                        @Cast(value="int64_t")
                        long num,
                        @Cast(value="int64_t")
                        long den,
                        @Cast(value="int64_t")
                        long max)

av_reduce

@NoException
public static int av_reduce(int[] dst_num,
                        int[] dst_den,
                        @Cast(value="int64_t")
                        long num,
                        @Cast(value="int64_t")
                        long den,
                        @Cast(value="int64_t")
                        long max)

av_mul_q

@NoException
@ByVal
public static avutil.AVRational av_mul_q(@ByVal
                                           avutil.AVRational b,
                                           @ByVal
                                           avutil.AVRational c)

Multiply two rationals.

Parameters:: b - First rational; c - Second rational
Returns:: b*c

av_div_q

@NoException
@ByVal
public static avutil.AVRational av_div_q(@ByVal
                                           avutil.AVRational b,
                                           @ByVal
                                           avutil.AVRational c)

Divide one rational by another.

Parameters:: b - First rational; c - Second rational
Returns:: b/c

av_add_q

@NoException
@ByVal
public static avutil.AVRational av_add_q(@ByVal
                                           avutil.AVRational b,
                                           @ByVal
                                           avutil.AVRational c)

Add two rationals.

Parameters:: b - First rational; c - Second rational
Returns:: b+c

av_sub_q

@NoException
@ByVal
public static avutil.AVRational av_sub_q(@ByVal
                                           avutil.AVRational b,
                                           @ByVal
                                           avutil.AVRational c)

Subtract one rational from another.

Parameters:: b - First rational; c - Second rational
Returns:: b-c

av_inv_q

@NoException
@ByVal
public static avutil.AVRational av_inv_q(@ByVal
                                           avutil.AVRational q)

Invert a rational.

Parameters:: q - value
Returns:: 1 / q

av_d2q
```
@NoException
@ByVal
public static avutil.AVRational av_d2q(double d,
                                         int max)
```
Convert a double precision floating point number to a rational. In case of infinity, the returned value is expressed as {1, 0} or {-1, 0} depending on the sign.

Parameters:
d - double to convert
max - Maximum allowed numerator and denominator

Returns:
d in AVRational form
See Also:
av_q2d()

av_nearer_q

@NoException
public static int av_nearer_q(@ByVal
                          avutil.AVRational q,
                          @ByVal
                          avutil.AVRational q1,
                          @ByVal
                          avutil.AVRational q2)

Find which of the two rationals is closer to another rational.

Parameters:: q - Rational to be compared against; q1,q2 - Rationals to be tested
Returns:: One of the following values: - 1 if q1 is nearer to q than q2 - -1 if q2 is nearer to q than q1 - 0 if they have the same distance

av_find_nearest_q_idx

@NoException
public static int av_find_nearest_q_idx(@ByVal
                                    avutil.AVRational q,
                                    @Const
                                    avutil.AVRational q_list)

Find the value in a list of rationals nearest a given reference rational.

Parameters:: q - Reference rational; q_list - Array of rationals terminated by {0, 0}
Returns:: Index of the nearest value found in the array

av_q2intfloat
```
@NoException
@Cast(value="uint32_t")
public static int av_q2intfloat(@ByVal
                                      avutil.AVRational q)
```
Convert an AVRational to a IEEE 32-bit float expressed in fixed-point format.

Parameters:
q - Rational to be converted

Returns:
Equivalent floating-point value, expressed as an unsigned 32-bit integer. \note The returned value is platform-indepedant.

av_log
```
@NoException
public static void av_log(Pointer avcl,
                      int level,
                      @Cast(value="const char*")
                      BytePointer fmt)
```
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.

Parameters:
avcl - A pointer to an arbitrary struct of which the first field is a pointer to an AVClass struct or NULL if general log.
level - The importance level of the message expressed using a \ref lavu_log_constants "Logging Constant".
fmt - The format string (printf-compatible) that specifies how subsequent arguments are converted to output.
See Also:
av_log_set_callback

av_log

@NoException
public static void av_log(Pointer avcl,
                      int level,
                      String fmt)

av_vlog
```
@NoException
public static void av_vlog(Pointer avcl,
                       int level,
                       @Cast(value="const char*")
                       BytePointer fmt,
                       @ByVal@Cast(value="va_list*")
                       Pointer vl)
```
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.

Parameters:
avcl - A pointer to an arbitrary struct of which the first field is a pointer to an AVClass struct.
level - The importance level of the message expressed using a \ref lavu_log_constants "Logging Constant".
fmt - The format string (printf-compatible) that specifies how subsequent arguments are converted to output.
vl - The arguments referenced by the format string.
See Also:
av_log_set_callback

av_vlog

@NoException
public static void av_vlog(Pointer avcl,
                       int level,
                       String fmt,
                       @ByVal@Cast(value="va_list*")
                       Pointer vl)

av_log_get_level
```
@NoException
public static int av_log_get_level()
```
Get the current log level

Returns:
Current log level
See Also:
lavu_log_constants

av_log_set_level
```
@NoException
public static void av_log_set_level(int level)
```
Set the log level

Parameters:
level - Logging level
See Also:
lavu_log_constants

av_log_set_callback

@NoException
public static void av_log_set_callback(avutil.Callback_Pointer_int_BytePointer_Pointer callback)

av_log_set_callback

@NoException
public static void av_log_set_callback(avutil.Callback_Pointer_int_String_Pointer callback)

av_log_default_callback

@NoException
public static void av_log_default_callback(Pointer avcl,
                                       int level,
                                       @Cast(value="const char*")
                                       BytePointer fmt,
                                       @ByVal@Cast(value="va_list*")
                                       Pointer vl)

Default logging callback It prints the message to stderr, optionally colorizing it.

Parameters:: avcl - A pointer to an arbitrary struct of which the first field is a pointer to an AVClass struct.; level - The importance level of the message expressed using a \ref lavu_log_constants "Logging Constant".; fmt - The format string (printf-compatible) that specifies how subsequent arguments are converted to output.; vl - The arguments referenced by the format string.

av_log_default_callback

@NoException
public static void av_log_default_callback(Pointer avcl,
                                       int level,
                                       String fmt,
                                       @ByVal@Cast(value="va_list*")
                                       Pointer vl)

av_default_item_name

@NoException
@Cast(value="const char*")
public static BytePointer av_default_item_name(Pointer ctx)

Return the context name

Parameters:: ctx - The AVClass context
Returns:: The AVClass class_name

av_default_get_category

@NoException
@Cast(value="AVClassCategory")
public static int av_default_get_category(Pointer ptr)

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  BytePointer line,
                                  int line_size,
                                  IntPointer print_prefix)

Format a line of log the same way as the default callback.

Parameters:: line - buffer to receive the formatted line; line_size - size of the buffer; print_prefix - used to store whether the prefix must be printed; must point to a persistent integer initially set to 1

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  ByteBuffer line,
                                  int line_size,
                                  IntBuffer print_prefix)

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  byte[] line,
                                  int line_size,
                                  int[] print_prefix)

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  BytePointer line,
                                  int line_size,
                                  IntPointer print_prefix)

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  ByteBuffer line,
                                  int line_size,
                                  IntBuffer print_prefix)

av_log_format_line

@NoException
public static void av_log_format_line(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  byte[] line,
                                  int line_size,
                                  int[] print_prefix)

av_log_format_line2
```
@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  BytePointer line,
                                  int line_size,
                                  IntPointer print_prefix)
```
Format a line of log the same way as the default callback.

Parameters:
line - buffer to receive the formatted line; may be NULL if line_size is 0
line_size - size of the buffer; at most line_size-1 characters will be written to the buffer, plus one null terminator
print_prefix - used to store whether the prefix must be printed; must point to a persistent integer initially set to 1

Returns:
Returns a negative value if an error occurred, otherwise returns the number of characters that would have been written for a sufficiently large buffer, not including the terminating null character. If the return value is not less than line_size, it means that the log message was truncated to fit the buffer.

av_log_format_line2

@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  ByteBuffer line,
                                  int line_size,
                                  IntBuffer print_prefix)

av_log_format_line2

@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  byte[] line,
                                  int line_size,
                                  int[] print_prefix)

av_log_format_line2

@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  BytePointer line,
                                  int line_size,
                                  IntPointer print_prefix)

av_log_format_line2

@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  @Cast(value="const char*")
                                  BytePointer fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  ByteBuffer line,
                                  int line_size,
                                  IntBuffer print_prefix)

av_log_format_line2

@NoException
public static int av_log_format_line2(Pointer ptr,
                                  int level,
                                  String fmt,
                                  @ByVal@Cast(value="va_list*")
                                  Pointer vl,
                                  @Cast(value="char*")
                                  byte[] line,
                                  int line_size,
                                  int[] print_prefix)

av_log_set_flags

@NoException
public static void av_log_set_flags(int arg)

av_log_get_flags

@NoException
public static int av_log_get_flags()

av_buffer_alloc
```
@NoException
public static avutil.AVBufferRef av_buffer_alloc(int size)
```
Allocate an AVBuffer of the given size using av_malloc().

Returns:
an AVBufferRef of given size or NULL when out of memory

av_buffer_allocz
```
@NoException
public static avutil.AVBufferRef av_buffer_allocz(int size)
```
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.

av_buffer_create

@NoException
public static avutil.AVBufferRef av_buffer_create(@Cast(value="uint8_t*")
                                              BytePointer data,
                                              int size,
                                              avutil.Free_Pointer_BytePointer free,
                                              Pointer opaque,
                                              int flags)

av_buffer_create

@NoException
public static avutil.AVBufferRef av_buffer_create(@Cast(value="uint8_t*")
                                              ByteBuffer data,
                                              int size,
                                              avutil.Free_Pointer_ByteBuffer free,
                                              Pointer opaque,
                                              int flags)

av_buffer_create

@NoException
public static avutil.AVBufferRef av_buffer_create(@Cast(value="uint8_t*")
                                              byte[] data,
                                              int size,
                                              avutil.Free_Pointer_byte__ free,
                                              Pointer opaque,
                                              int flags)

av_buffer_default_free

@NoException
public static void av_buffer_default_free(Pointer opaque,
                                      @Cast(value="uint8_t*")
                                      BytePointer data)

Default free callback, which calls av_free() on the buffer data. This function is meant to be passed to av_buffer_create(), not called directly.

av_buffer_default_free

@NoException
public static void av_buffer_default_free(Pointer opaque,
                                      @Cast(value="uint8_t*")
                                      ByteBuffer data)

av_buffer_default_free

@NoException
public static void av_buffer_default_free(Pointer opaque,
                                      @Cast(value="uint8_t*")
                                      byte[] data)

av_buffer_ref
```
@NoException
public static avutil.AVBufferRef av_buffer_ref(avutil.AVBufferRef buf)
```
Create a new reference to an AVBuffer.

Returns:
a new AVBufferRef referring to the same AVBuffer as buf or NULL on failure.

av_buffer_unref
```
@NoException
public static void av_buffer_unref(@Cast(value="AVBufferRef**")
                               PointerPointer buf)
```
Free a given reference and automatically free the buffer if there are no more references to it.

Parameters:
buf - the reference to be freed. The pointer is set to NULL on return.

av_buffer_unref

@NoException
public static void av_buffer_unref(@ByPtrPtr
                               avutil.AVBufferRef buf)

av_buffer_is_writable
```
@NoException
public static int av_buffer_is_writable(@Const
                                    avutil.AVBufferRef buf)
```
Returns:
1 if the caller may write to the data referred to by buf (which is true if and only if buf is the only reference to the underlying AVBuffer). Return 0 otherwise. A positive answer is valid until av_buffer_ref() is called on buf.

av_buffer_get_opaque

@NoException
public static Pointer av_buffer_get_opaque(@Const
                                       avutil.AVBufferRef buf)

Returns:: the opaque parameter set by av_buffer_create.

av_buffer_get_ref_count

@NoException
public static int av_buffer_get_ref_count(@Const
                                      avutil.AVBufferRef buf)

av_buffer_make_writable
```
@NoException
public static int av_buffer_make_writable(@Cast(value="AVBufferRef**")
                                      PointerPointer buf)
```
Create a writable reference from a given buffer reference, avoiding data copy if possible.

Parameters:
buf - buffer reference to make writable. On success, buf is either left untouched, or it is unreferenced and a new writable AVBufferRef is written in its place. On failure, buf is left untouched.

Returns:
0 on success, a negative AVERROR on failure.

av_buffer_make_writable

@NoException
public static int av_buffer_make_writable(@ByPtrPtr
                                      avutil.AVBufferRef buf)

av_buffer_realloc
```
@NoException
public static int av_buffer_realloc(@Cast(value="AVBufferRef**")
                                PointerPointer buf,
                                int size)
```
Reallocate a given buffer.

Parameters:
buf - a buffer reference to reallocate. On success, buf will be unreferenced and a new reference with the required size will be written in its place. On failure buf will be left untouched. *buf may be NULL, then a new buffer is allocated.
size - required new buffer size.

Returns:
0 on success, a negative AVERROR on failure. \note the buffer is actually reallocated with av_realloc() only if it was initially allocated through av_buffer_realloc(NULL) and there is only one reference to it (i.e. the one passed to this function). In all other cases a new buffer is allocated and the data is copied.

av_buffer_realloc

@NoException
public static int av_buffer_realloc(@ByPtrPtr
                                avutil.AVBufferRef buf,
                                int size)

av_buffer_pool_init

@NoException
public static avutil.AVBufferPool av_buffer_pool_init(int size,
                                                  avutil.Alloc_int alloc)

av_buffer_pool_init2

@NoException
public static avutil.AVBufferPool av_buffer_pool_init2(int size,
                                                   Pointer opaque,
                                                   avutil.Alloc_Pointer_int alloc,
                                                   avutil.Pool_free_Pointer pool_free)

av_buffer_pool_uninit
```
@NoException
public static void av_buffer_pool_uninit(@Cast(value="AVBufferPool**")
                                     PointerPointer pool)
```
Mark the pool as being available for freeing. It will actually be freed only once all the allocated buffers associated with the pool are released. Thus it is safe to call this function while some of the allocated buffers are still in use.

Parameters:
pool - pointer to the pool to be freed. It will be set to NULL.

av_buffer_pool_uninit

@NoException
public static void av_buffer_pool_uninit(@ByPtrPtr
                                     avutil.AVBufferPool pool)

av_buffer_pool_get
```
@NoException
public static avutil.AVBufferRef av_buffer_pool_get(avutil.AVBufferPool pool)
```
Allocate a new AVBuffer, reusing an old buffer from the pool when available. This function may be called simultaneously from multiple threads.

Returns:
a reference to the new buffer on success, NULL on error.

AV_PIX_FMT_RGB32

@MemberGetter
public static int AV_PIX_FMT_RGB32()

AV_PIX_FMT_RGB32_1

@MemberGetter
public static int AV_PIX_FMT_RGB32_1()

AV_PIX_FMT_BGR32

@MemberGetter
public static int AV_PIX_FMT_BGR32()

AV_PIX_FMT_BGR32_1

@MemberGetter
public static int AV_PIX_FMT_BGR32_1()

AV_PIX_FMT_0RGB32

@MemberGetter
public static int AV_PIX_FMT_0RGB32()

AV_PIX_FMT_0BGR32

@MemberGetter
public static int AV_PIX_FMT_0BGR32()

AV_PIX_FMT_GRAY16

@MemberGetter
public static int AV_PIX_FMT_GRAY16()

AV_PIX_FMT_YA16

@MemberGetter
public static int AV_PIX_FMT_YA16()

AV_PIX_FMT_RGB48

@MemberGetter
public static int AV_PIX_FMT_RGB48()

AV_PIX_FMT_RGB565

@MemberGetter
public static int AV_PIX_FMT_RGB565()

AV_PIX_FMT_RGB555

@MemberGetter
public static int AV_PIX_FMT_RGB555()

AV_PIX_FMT_RGB444

@MemberGetter
public static int AV_PIX_FMT_RGB444()

AV_PIX_FMT_RGBA64

@MemberGetter
public static int AV_PIX_FMT_RGBA64()

AV_PIX_FMT_BGR48

@MemberGetter
public static int AV_PIX_FMT_BGR48()

AV_PIX_FMT_BGR565

@MemberGetter
public static int AV_PIX_FMT_BGR565()

AV_PIX_FMT_BGR555

@MemberGetter
public static int AV_PIX_FMT_BGR555()

AV_PIX_FMT_BGR444

@MemberGetter
public static int AV_PIX_FMT_BGR444()

AV_PIX_FMT_BGRA64

@MemberGetter
public static int AV_PIX_FMT_BGRA64()

AV_PIX_FMT_YUV420P9

@MemberGetter
public static int AV_PIX_FMT_YUV420P9()

AV_PIX_FMT_YUV422P9

@MemberGetter
public static int AV_PIX_FMT_YUV422P9()

AV_PIX_FMT_YUV444P9

@MemberGetter
public static int AV_PIX_FMT_YUV444P9()

AV_PIX_FMT_YUV420P10

@MemberGetter
public static int AV_PIX_FMT_YUV420P10()

AV_PIX_FMT_YUV422P10

@MemberGetter
public static int AV_PIX_FMT_YUV422P10()

AV_PIX_FMT_YUV440P10

@MemberGetter
public static int AV_PIX_FMT_YUV440P10()

AV_PIX_FMT_YUV444P10

@MemberGetter
public static int AV_PIX_FMT_YUV444P10()

AV_PIX_FMT_YUV420P12

@MemberGetter
public static int AV_PIX_FMT_YUV420P12()

AV_PIX_FMT_YUV422P12

@MemberGetter
public static int AV_PIX_FMT_YUV422P12()

AV_PIX_FMT_YUV440P12

@MemberGetter
public static int AV_PIX_FMT_YUV440P12()

AV_PIX_FMT_YUV444P12

@MemberGetter
public static int AV_PIX_FMT_YUV444P12()

AV_PIX_FMT_YUV420P14

@MemberGetter
public static int AV_PIX_FMT_YUV420P14()

AV_PIX_FMT_YUV422P14

@MemberGetter
public static int AV_PIX_FMT_YUV422P14()

AV_PIX_FMT_YUV444P14

@MemberGetter
public static int AV_PIX_FMT_YUV444P14()

AV_PIX_FMT_YUV420P16

@MemberGetter
public static int AV_PIX_FMT_YUV420P16()

AV_PIX_FMT_YUV422P16

@MemberGetter
public static int AV_PIX_FMT_YUV422P16()

AV_PIX_FMT_YUV444P16

@MemberGetter
public static int AV_PIX_FMT_YUV444P16()

AV_PIX_FMT_GBRP9

@MemberGetter
public static int AV_PIX_FMT_GBRP9()

AV_PIX_FMT_GBRP10

@MemberGetter
public static int AV_PIX_FMT_GBRP10()

AV_PIX_FMT_GBRP12

@MemberGetter
public static int AV_PIX_FMT_GBRP12()

AV_PIX_FMT_GBRP14

@MemberGetter
public static int AV_PIX_FMT_GBRP14()

AV_PIX_FMT_GBRP16

@MemberGetter
public static int AV_PIX_FMT_GBRP16()

AV_PIX_FMT_GBRAP10

@MemberGetter
public static int AV_PIX_FMT_GBRAP10()

AV_PIX_FMT_GBRAP12

@MemberGetter
public static int AV_PIX_FMT_GBRAP12()

AV_PIX_FMT_GBRAP16

@MemberGetter
public static int AV_PIX_FMT_GBRAP16()

AV_PIX_FMT_BAYER_BGGR16

@MemberGetter
public static int AV_PIX_FMT_BAYER_BGGR16()

AV_PIX_FMT_BAYER_RGGB16

@MemberGetter
public static int AV_PIX_FMT_BAYER_RGGB16()

AV_PIX_FMT_BAYER_GBRG16

@MemberGetter
public static int AV_PIX_FMT_BAYER_GBRG16()

AV_PIX_FMT_BAYER_GRBG16

@MemberGetter
public static int AV_PIX_FMT_BAYER_GRBG16()

AV_PIX_FMT_YUVA420P9

@MemberGetter
public static int AV_PIX_FMT_YUVA420P9()

AV_PIX_FMT_YUVA422P9

@MemberGetter
public static int AV_PIX_FMT_YUVA422P9()

AV_PIX_FMT_YUVA444P9

@MemberGetter
public static int AV_PIX_FMT_YUVA444P9()

AV_PIX_FMT_YUVA420P10

@MemberGetter
public static int AV_PIX_FMT_YUVA420P10()

AV_PIX_FMT_YUVA422P10

@MemberGetter
public static int AV_PIX_FMT_YUVA422P10()

AV_PIX_FMT_YUVA444P10

@MemberGetter
public static int AV_PIX_FMT_YUVA444P10()

AV_PIX_FMT_YUVA420P16

@MemberGetter
public static int AV_PIX_FMT_YUVA420P16()

AV_PIX_FMT_YUVA422P16

@MemberGetter
public static int AV_PIX_FMT_YUVA422P16()

AV_PIX_FMT_YUVA444P16

@MemberGetter
public static int AV_PIX_FMT_YUVA444P16()

AV_PIX_FMT_XYZ12

@MemberGetter
public static int AV_PIX_FMT_XYZ12()

AV_PIX_FMT_NV20

@MemberGetter
public static int AV_PIX_FMT_NV20()

AV_PIX_FMT_AYUV64

@MemberGetter
public static int AV_PIX_FMT_AYUV64()

AV_PIX_FMT_P010

@MemberGetter
public static int AV_PIX_FMT_P010()

av_frame_get_best_effort_timestamp

@NoException
@Cast(value="int64_t")
public static long av_frame_get_best_effort_timestamp(@Const
                                                            avutil.AVFrame frame)

Accessors for some AVFrame fields. The position of these field in the structure is not part of the ABI, they should not be accessed directly outside libavutil.

av_frame_set_best_effort_timestamp

@NoException
public static void av_frame_set_best_effort_timestamp(avutil.AVFrame frame,
                                                  @Cast(value="int64_t")
                                                  long val)

av_frame_get_pkt_duration

@NoException
@Cast(value="int64_t")
public static long av_frame_get_pkt_duration(@Const
                                                   avutil.AVFrame frame)

av_frame_set_pkt_duration

@NoException
public static void av_frame_set_pkt_duration(avutil.AVFrame frame,
                                         @Cast(value="int64_t")
                                         long val)

av_frame_get_pkt_pos

@NoException
@Cast(value="int64_t")
public static long av_frame_get_pkt_pos(@Const
                                              avutil.AVFrame frame)

av_frame_set_pkt_pos

@NoException
public static void av_frame_set_pkt_pos(avutil.AVFrame frame,
                                    @Cast(value="int64_t")
                                    long val)

av_frame_get_channel_layout

@NoException
@Cast(value="int64_t")
public static long av_frame_get_channel_layout(@Const
                                                     avutil.AVFrame frame)

av_frame_set_channel_layout

@NoException
public static void av_frame_set_channel_layout(avutil.AVFrame frame,
                                           @Cast(value="int64_t")
                                           long val)

av_frame_get_channels

@NoException
public static int av_frame_get_channels(@Const
                                    avutil.AVFrame frame)

av_frame_set_channels

@NoException
public static void av_frame_set_channels(avutil.AVFrame frame,
                                     int val)

av_frame_get_sample_rate

@NoException
public static int av_frame_get_sample_rate(@Const
                                       avutil.AVFrame frame)

av_frame_set_sample_rate

@NoException
public static void av_frame_set_sample_rate(avutil.AVFrame frame,
                                        int val)

av_frame_get_metadata

@NoException
public static avutil.AVDictionary av_frame_get_metadata(@Const
                                                    avutil.AVFrame frame)

av_frame_set_metadata

@NoException
public static void av_frame_set_metadata(avutil.AVFrame frame,
                                     avutil.AVDictionary val)

av_frame_get_decode_error_flags

@NoException
public static int av_frame_get_decode_error_flags(@Const
                                              avutil.AVFrame frame)

av_frame_set_decode_error_flags

@NoException
public static void av_frame_set_decode_error_flags(avutil.AVFrame frame,
                                               int val)

av_frame_get_pkt_size

@NoException
public static int av_frame_get_pkt_size(@Const
                                    avutil.AVFrame frame)

av_frame_set_pkt_size

@NoException
public static void av_frame_set_pkt_size(avutil.AVFrame frame,
                                     int val)

avpriv_frame_get_metadatap

@NoException
@Cast(value="AVDictionary**")
public static PointerPointer avpriv_frame_get_metadatap(avutil.AVFrame frame)

av_frame_get_qp_table

@NoException
public static BytePointer av_frame_get_qp_table(avutil.AVFrame f,
                                            IntPointer stride,
                                            IntPointer type)

av_frame_get_qp_table

@NoException
public static ByteBuffer av_frame_get_qp_table(avutil.AVFrame f,
                                           IntBuffer stride,
                                           IntBuffer type)

av_frame_get_qp_table

@NoException
public static byte[] av_frame_get_qp_table(avutil.AVFrame f,
                                       int[] stride,
                                       int[] type)

av_frame_set_qp_table

@NoException
public static int av_frame_set_qp_table(avutil.AVFrame f,
                                    avutil.AVBufferRef buf,
                                    int stride,
                                    int type)

av_frame_get_colorspace

@NoException
@Cast(value="AVColorSpace")
public static int av_frame_get_colorspace(@Const
                                                avutil.AVFrame frame)

av_frame_set_colorspace

@NoException
public static void av_frame_set_colorspace(avutil.AVFrame frame,
                                       @Cast(value="AVColorSpace")
                                       int val)

av_frame_get_color_range

@NoException
@Cast(value="AVColorRange")
public static int av_frame_get_color_range(@Const
                                                 avutil.AVFrame frame)

av_frame_set_color_range

@NoException
public static void av_frame_set_color_range(avutil.AVFrame frame,
                                        @Cast(value="AVColorRange")
                                        int val)

av_get_colorspace_name

@NoException
@Cast(value="const char*")
public static BytePointer av_get_colorspace_name(@Cast(value="AVColorSpace")
                                                       int val)

Get the name of a colorspace.

Returns:: a static string identifying the colorspace; can be NULL.

av_frame_alloc
```
@NoException
public static avutil.AVFrame av_frame_alloc()
```
Allocate an AVFrame and set its fields to default values. The resulting struct must be freed using av_frame_free().

Returns:
An AVFrame filled with default values or NULL on failure. \note this only allocates the AVFrame itself, not the data buffers. Those must be allocated through other means, e.g. with av_frame_get_buffer() or manually.

av_frame_free
```
@NoException
public static void av_frame_free(@Cast(value="AVFrame**")
                             PointerPointer frame)
```
Free the frame and any dynamically allocated objects in it, e.g. extended_data. If the frame is reference counted, it will be unreferenced first.

Parameters:
frame - frame to be freed. The pointer will be set to NULL.

av_frame_free

@NoException
public static void av_frame_free(@ByPtrPtr
                             avutil.AVFrame frame)

av_frame_ref
```
@NoException
public static int av_frame_ref(avutil.AVFrame dst,
                           @Const
                           avutil.AVFrame src)
```
Set up a new reference to the data described by the source frame. Copy frame properties from src to dst and create a new reference for each AVBufferRef from src. If src is not reference counted, new buffers are allocated and the data is copied. \warning: dst MUST have been either unreferenced with av_frame_unref(dst), or newly allocated with av_frame_alloc() before calling this function, or undefined behavior will occur.

Returns:
0 on success, a negative AVERROR on error

av_frame_clone
```
@NoException
public static avutil.AVFrame av_frame_clone(@Const
                                        avutil.AVFrame src)
```
Create a new frame that references the same data as src. This is a shortcut for av_frame_alloc()+av_frame_ref().

Returns:
newly created AVFrame on success, NULL on error.

av_frame_unref
```
@NoException
public static void av_frame_unref(avutil.AVFrame frame)
```
Unreference all the buffers referenced by frame and reset the frame fields.

av_frame_move_ref
```
@NoException
public static void av_frame_move_ref(avutil.AVFrame dst,
                                 avutil.AVFrame src)
```
Move everything contained in src to dst and reset src. \warning: dst is not unreferenced, but directly overwritten without reading or deallocating its contents. Call av_frame_unref(dst) manually before calling this function to ensure that no memory is leaked.

av_frame_get_buffer
```
@NoException
public static int av_frame_get_buffer(avutil.AVFrame frame,
                                  int align)
```
Allocate new buffer(s) for audio or video data. The following fields must be set on frame before calling this function: - format (pixel format for video, sample format for audio) - width and height for video - nb_samples and channel_layout for audio This function will fill AVFrame.data and AVFrame.buf arrays and, if necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf. For planar formats, one buffer will be allocated for each plane. \warning: if frame already has been allocated, calling this function will leak memory. In addition, undefined behavior can occur in certain cases.

Parameters:
frame - frame in which to store the new buffers.
align - required buffer size alignment

Returns:
0 on success, a negative AVERROR on error.

av_frame_is_writable
```
@NoException
public static int av_frame_is_writable(avutil.AVFrame frame)
```
Check if the frame data is writable.

Returns:
A positive value if the frame data is writable (which is true if and only if each of the underlying buffers has only one reference, namely the one stored in this frame). Return 0 otherwise. If 1 is returned the answer is valid until av_buffer_ref() is called on any of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).
See Also:
av_frame_make_writable(), av_buffer_is_writable()

av_frame_make_writable
```
@NoException
public static int av_frame_make_writable(avutil.AVFrame frame)
```
Ensure that the frame data is writable, avoiding data copy if possible. Do nothing if the frame is writable, allocate new buffers and copy the data if it is not.

Returns:
0 on success, a negative AVERROR on error.
See Also:
av_frame_is_writable(), av_buffer_is_writable(), av_buffer_make_writable()

av_frame_copy
```
@NoException
public static int av_frame_copy(avutil.AVFrame dst,
                            @Const
                            avutil.AVFrame src)
```
Copy the frame data from src to dst. This function does not allocate anything, dst must be already initialized and allocated with the same parameters as src. This function only copies the frame data (i.e. the contents of the data / extended data arrays), not any other properties.

Returns:
>= 0 on success, a negative AVERROR on error.

av_frame_copy_props
```
@NoException
public static int av_frame_copy_props(avutil.AVFrame dst,
                                  @Const
                                  avutil.AVFrame src)
```
Copy only "metadata" fields from src to dst. Metadata for the purpose of this function are those fields that do not affect the data layout in the buffers. E.g. pts, sample rate (for audio) or sample aspect ratio (for video), but not width/height or channel layout. Side data is also copied.

av_frame_get_plane_buffer
```
@NoException
public static avutil.AVBufferRef av_frame_get_plane_buffer(avutil.AVFrame frame,
                                                       int plane)
```
Get the buffer reference a given data plane is stored in.

Parameters:
plane - index of the data plane of interest in frame->extended_data.

Returns:
the buffer reference that contains the plane or NULL if the input frame is not valid.

av_frame_new_side_data

@NoException
public static avutil.AVFrameSideData av_frame_new_side_data(avutil.AVFrame frame,
                                                        @Cast(value="AVFrameSideDataType")
                                                        int type,
                                                        int size)

Add a new side data to a frame.

Parameters:: frame - a frame to which the side data should be added; type - type of the added side data; size - size of the side data
Returns:: newly added side data on success, NULL on error

av_frame_get_side_data

@NoException
public static avutil.AVFrameSideData av_frame_get_side_data(@Const
                                                        avutil.AVFrame frame,
                                                        @Cast(value="AVFrameSideDataType")
                                                        int type)

Returns:: a pointer to the side data of a given type on success, NULL if there is no side data with such type in this frame.

av_frame_remove_side_data

@NoException
public static void av_frame_remove_side_data(avutil.AVFrame frame,
                                         @Cast(value="AVFrameSideDataType")
                                         int type)

If side data of the supplied type exists in the frame, free it and remove it from the frame.

av_frame_side_data_name

@NoException
@Cast(value="const char*")
public static BytePointer av_frame_side_data_name(@Cast(value="AVFrameSideDataType")
                                                        int type)

Returns:: a string identifying the side data type

av_get_sample_fmt_name

@NoException
@Cast(value="const char*")
public static BytePointer av_get_sample_fmt_name(@Cast(value="AVSampleFormat")
                                                       int sample_fmt)

Return the name of sample_fmt, or NULL if sample_fmt is not recognized.

av_get_sample_fmt

@NoException
@Cast(value="AVSampleFormat")
public static int av_get_sample_fmt(@Cast(value="const char*")
                                          BytePointer name)

Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.

av_get_sample_fmt

@NoException
@Cast(value="AVSampleFormat")
public static int av_get_sample_fmt(String name)

av_get_alt_sample_fmt
```
@NoException
@Cast(value="AVSampleFormat")
public static int av_get_alt_sample_fmt(@Cast(value="AVSampleFormat")
                                              int sample_fmt,
                                              int planar)
```
Return the planar<->packed alternative form of the given sample format, or AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the requested planar/packed format, the format returned is the same as the input.

av_get_packed_sample_fmt
```
@NoException
@Cast(value="AVSampleFormat")
public static int av_get_packed_sample_fmt(@Cast(value="AVSampleFormat")
                                                 int sample_fmt)
```
Get the packed alternative form of the given sample format. If the passed sample_fmt is already in packed format, the format returned is the same as the input.

Returns:
the packed alternative form of the given sample format or AV_SAMPLE_FMT_NONE on error.

av_get_planar_sample_fmt
```
@NoException
@Cast(value="AVSampleFormat")
public static int av_get_planar_sample_fmt(@Cast(value="AVSampleFormat")
                                                 int sample_fmt)
```
Get the planar alternative form of the given sample format. If the passed sample_fmt is already in planar format, the format returned is the same as the input.

Returns:
the planar alternative form of the given sample format or AV_SAMPLE_FMT_NONE on error.

av_get_sample_fmt_string

@NoException
@Cast(value="char*")
public static BytePointer av_get_sample_fmt_string(@Cast(value="char*")
                                                         BytePointer buf,
                                                         int buf_size,
                                                         @Cast(value="AVSampleFormat")
                                                         int sample_fmt)

Generate a string corresponding to the sample format with sample_fmt, or a header if sample_fmt is negative.

Parameters:: buf - the buffer where to write the string; buf_size - the size of buf; sample_fmt - the number of the sample format to print the corresponding info string, or a negative value to print the corresponding header.
Returns:: the pointer to the filled buffer or NULL if sample_fmt is unknown or in case of other errors

av_get_sample_fmt_string

@NoException
@Cast(value="char*")
public static ByteBuffer av_get_sample_fmt_string(@Cast(value="char*")
                                                        ByteBuffer buf,
                                                        int buf_size,
                                                        @Cast(value="AVSampleFormat")
                                                        int sample_fmt)

av_get_sample_fmt_string

@NoException
@Cast(value="char*")
public static byte[] av_get_sample_fmt_string(@Cast(value="char*")
                                                    byte[] buf,
                                                    int buf_size,
                                                    @Cast(value="AVSampleFormat")
                                                    int sample_fmt)

av_get_bytes_per_sample
```
@NoException
public static int av_get_bytes_per_sample(@Cast(value="AVSampleFormat")
                                      int sample_fmt)
```
Return number of bytes per sample.

Parameters:
sample_fmt - the sample format

Returns:
number of bytes per sample or zero if unknown for the given sample format

av_sample_fmt_is_planar
```
@NoException
public static int av_sample_fmt_is_planar(@Cast(value="AVSampleFormat")
                                      int sample_fmt)
```
Check if the sample format is planar.

Parameters:
sample_fmt - the sample format to inspect

Returns:
1 if the sample format is planar, 0 if it is interleaved

av_samples_get_buffer_size

@NoException
public static int av_samples_get_buffer_size(IntPointer linesize,
                                         int nb_channels,
                                         int nb_samples,
                                         @Cast(value="AVSampleFormat")
                                         int sample_fmt,
                                         int align)

Get the required buffer size for the given audio parameters.

Parameters:: [out] - linesize calculated linesize, may be NULL; nb_channels - the number of channels; nb_samples - the number of samples in a single channel; sample_fmt - the sample format; align - buffer size alignment (0 = default, 1 = no alignment)
Returns:: required buffer size, or negative error code on failure

av_samples_get_buffer_size

@NoException
public static int av_samples_get_buffer_size(IntBuffer linesize,
                                         int nb_channels,
                                         int nb_samples,
                                         @Cast(value="AVSampleFormat")
                                         int sample_fmt,
                                         int align)

av_samples_get_buffer_size

@NoException
public static int av_samples_get_buffer_size(int[] linesize,
                                         int nb_channels,
                                         int nb_samples,
                                         @Cast(value="AVSampleFormat")
                                         int sample_fmt,
                                         int align)

av_samples_fill_arrays
```
@NoException
public static int av_samples_fill_arrays(@Cast(value="uint8_t**")
                                     PointerPointer audio_data,
                                     IntPointer linesize,
                                     @Cast(value="const uint8_t*")
                                     BytePointer buf,
                                     int nb_channels,
                                     int nb_samples,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt,
                                     int align)
```
Fill plane data pointers and linesize for samples with sample format sample_fmt. The audio_data array is filled with the pointers to the samples data planes: for planar, set the start point of each channel's data within the buffer, for packed, set the start point of the entire buffer only. The value pointed to by linesize is set to the aligned size of each channel's data buffer for planar layout, or to the aligned size of the buffer for all channels for packed layout. The buffer in buf must be big enough to contain all the samples (use av_samples_get_buffer_size() to compute its minimum size), otherwise the audio_data pointers will point to invalid data.

Parameters:
[out] - audio_data array to be filled with the pointer for each channel
[out] - linesize calculated linesize, may be NULL
buf - the pointer to a buffer containing the samples
nb_channels - the number of channels
nb_samples - the number of samples in a single channel
sample_fmt - the sample format
align - buffer size alignment (0 = default, 1 = no alignment)

Returns:
>=0 on success or a negative error code on failure \todo return minimum size in bytes required for the buffer in case of success at the next bump
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_samples_fill_arrays

@NoException
public static int av_samples_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                     BytePointer audio_data,
                                     IntPointer linesize,
                                     @Cast(value="const uint8_t*")
                                     BytePointer buf,
                                     int nb_channels,
                                     int nb_samples,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt,
                                     int align)

av_samples_fill_arrays

@NoException
public static int av_samples_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                     ByteBuffer audio_data,
                                     IntBuffer linesize,
                                     @Cast(value="const uint8_t*")
                                     ByteBuffer buf,
                                     int nb_channels,
                                     int nb_samples,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt,
                                     int align)

av_samples_fill_arrays

@NoException
public static int av_samples_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                     byte[] audio_data,
                                     int[] linesize,
                                     @Cast(value="const uint8_t*")
                                     byte[] buf,
                                     int nb_channels,
                                     int nb_samples,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt,
                                     int align)

av_samples_alloc
```
@NoException
public static int av_samples_alloc(@Cast(value="uint8_t**")
                               PointerPointer audio_data,
                               IntPointer linesize,
                               int nb_channels,
                               int nb_samples,
                               @Cast(value="AVSampleFormat")
                               int sample_fmt,
                               int align)
```
Allocate a samples buffer for nb_samples samples, and fill data pointers and linesize accordingly. The allocated samples buffer can be freed by using av_freep(&audio_data[0]) Allocated data will be initialized to silence.

Parameters:
[out] - audio_data array to be filled with the pointer for each channel
[out] - linesize aligned size for audio buffer(s), may be NULL
nb_channels - number of audio channels
nb_samples - number of samples per channel
align - buffer size alignment (0 = default, 1 = no alignment)

Returns:
>=0 on success or a negative error code on failure \todo return the size of the allocated buffer in case of success at the next bump
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout., av_samples_fill_arrays(), av_samples_alloc_array_and_samples()

av_samples_alloc

@NoException
public static int av_samples_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                               BytePointer audio_data,
                               IntPointer linesize,
                               int nb_channels,
                               int nb_samples,
                               @Cast(value="AVSampleFormat")
                               int sample_fmt,
                               int align)

av_samples_alloc

@NoException
public static int av_samples_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                               ByteBuffer audio_data,
                               IntBuffer linesize,
                               int nb_channels,
                               int nb_samples,
                               @Cast(value="AVSampleFormat")
                               int sample_fmt,
                               int align)

av_samples_alloc

@NoException
public static int av_samples_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                               byte[] audio_data,
                               int[] linesize,
                               int nb_channels,
                               int nb_samples,
                               @Cast(value="AVSampleFormat")
                               int sample_fmt,
                               int align)

av_samples_alloc_array_and_samples

@NoException
public static int av_samples_alloc_array_and_samples(@Cast(value="uint8_t***")
                                                 PointerPointer audio_data,
                                                 IntPointer linesize,
                                                 int nb_channels,
                                                 int nb_samples,
                                                 @Cast(value="AVSampleFormat")
                                                 int sample_fmt,
                                                 int align)

Allocate a data pointers array, samples buffer for nb_samples samples, and fill data pointers and linesize accordingly. This is the same as av_samples_alloc(), but also allocates the data pointers array.

See Also:: av_samples_alloc()

av_samples_alloc_array_and_samples

@NoException
public static int av_samples_alloc_array_and_samples(@Cast(value="uint8_t***")
                                                 PointerPointer audio_data,
                                                 IntBuffer linesize,
                                                 int nb_channels,
                                                 int nb_samples,
                                                 @Cast(value="AVSampleFormat")
                                                 int sample_fmt,
                                                 int align)

av_samples_alloc_array_and_samples

@NoException
public static int av_samples_alloc_array_and_samples(@Cast(value="uint8_t***")
                                                 PointerPointer audio_data,
                                                 int[] linesize,
                                                 int nb_channels,
                                                 int nb_samples,
                                                 @Cast(value="AVSampleFormat")
                                                 int sample_fmt,
                                                 int align)

av_samples_copy

@NoException
public static int av_samples_copy(@Cast(value="uint8_t**")
                              PointerPointer dst,
                              @Cast(value="uint8_t*const*")
                              PointerPointer src,
                              int dst_offset,
                              int src_offset,
                              int nb_samples,
                              int nb_channels,
                              @Cast(value="AVSampleFormat")
                              int sample_fmt)

Copy samples from src to dst.

Parameters:: dst - destination array of pointers to data planes; src - source array of pointers to data planes; dst_offset - offset in samples at which the data will be written to dst; src_offset - offset in samples at which the data will be read from src; nb_samples - number of samples to be copied; nb_channels - number of audio channels; sample_fmt - audio sample format

av_samples_copy

@NoException
public static int av_samples_copy(@Cast(value="uint8_t**")@ByPtrPtr
                              BytePointer dst,
                              @Cast(value="uint8_t*const*")@ByPtrPtr
                              BytePointer src,
                              int dst_offset,
                              int src_offset,
                              int nb_samples,
                              int nb_channels,
                              @Cast(value="AVSampleFormat")
                              int sample_fmt)

av_samples_copy

@NoException
public static int av_samples_copy(@Cast(value="uint8_t**")@ByPtrPtr
                              ByteBuffer dst,
                              @Cast(value="uint8_t*const*")@ByPtrPtr
                              ByteBuffer src,
                              int dst_offset,
                              int src_offset,
                              int nb_samples,
                              int nb_channels,
                              @Cast(value="AVSampleFormat")
                              int sample_fmt)

av_samples_copy

@NoException
public static int av_samples_copy(@Cast(value="uint8_t**")@ByPtrPtr
                              byte[] dst,
                              @Cast(value="uint8_t*const*")@ByPtrPtr
                              byte[] src,
                              int dst_offset,
                              int src_offset,
                              int nb_samples,
                              int nb_channels,
                              @Cast(value="AVSampleFormat")
                              int sample_fmt)

av_samples_set_silence

@NoException
public static int av_samples_set_silence(@Cast(value="uint8_t**")
                                     PointerPointer audio_data,
                                     int offset,
                                     int nb_samples,
                                     int nb_channels,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt)

Fill an audio buffer with silence.

Parameters:: audio_data - array of pointers to data planes; offset - offset in samples at which to start filling; nb_samples - number of samples to fill; nb_channels - number of audio channels; sample_fmt - audio sample format

av_samples_set_silence

@NoException
public static int av_samples_set_silence(@Cast(value="uint8_t**")@ByPtrPtr
                                     BytePointer audio_data,
                                     int offset,
                                     int nb_samples,
                                     int nb_channels,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt)

av_samples_set_silence

@NoException
public static int av_samples_set_silence(@Cast(value="uint8_t**")@ByPtrPtr
                                     ByteBuffer audio_data,
                                     int offset,
                                     int nb_samples,
                                     int nb_channels,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt)

av_samples_set_silence

@NoException
public static int av_samples_set_silence(@Cast(value="uint8_t**")@ByPtrPtr
                                     byte[] audio_data,
                                     int offset,
                                     int nb_samples,
                                     int nb_channels,
                                     @Cast(value="AVSampleFormat")
                                     int sample_fmt)

av_get_channel_layout
```
@NoException
@Cast(value="uint64_t")
public static long av_get_channel_layout(@Cast(value="const char*")
                                               BytePointer name)
```
Return a channel layout id that matches name, or 0 if no match is found. name can be one or several of the following notations, separated by '+' or '|': - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0, 5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix); - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC, SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR); - a number of channels, in decimal, optionally followed by 'c', yielding the default channel layout for that number of channels (@see av_get_default_channel_layout); - a channel layout mask, in hexadecimal starting with "0x" (see the AV_CH_* macros). \warning Starting from the next major bump the trailing character 'c' to specify a number of channels will be required, while a channel layout mask could also be specified as a decimal number (if and only if not followed by "c"). Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"

av_get_channel_layout

@NoException
@Cast(value="uint64_t")
public static long av_get_channel_layout(String name)

av_get_channel_layout_string

@NoException
public static void av_get_channel_layout_string(@Cast(value="char*")
                                            BytePointer buf,
                                            int buf_size,
                                            int nb_channels,
                                            @Cast(value="uint64_t")
                                            long channel_layout)

Return a description of a channel layout. If nb_channels is <= 0, it is guessed from the channel_layout.

Parameters:: buf - put here the string containing the channel layout; buf_size - size in bytes of the buffer

av_get_channel_layout_string

@NoException
public static void av_get_channel_layout_string(@Cast(value="char*")
                                            ByteBuffer buf,
                                            int buf_size,
                                            int nb_channels,
                                            @Cast(value="uint64_t")
                                            long channel_layout)

av_get_channel_layout_string

@NoException
public static void av_get_channel_layout_string(@Cast(value="char*")
                                            byte[] buf,
                                            int buf_size,
                                            int nb_channels,
                                            @Cast(value="uint64_t")
                                            long channel_layout)

av_bprint_channel_layout

@NoException
public static void av_bprint_channel_layout(avutil.AVBPrint bp,
                                        int nb_channels,
                                        @Cast(value="uint64_t")
                                        long channel_layout)

Append a description of a channel layout to a bprint buffer.

av_get_channel_layout_nb_channels

@NoException
public static int av_get_channel_layout_nb_channels(@Cast(value="uint64_t")
                                                long channel_layout)

Return the number of channels in the channel layout.

av_get_default_channel_layout

@NoException
@Cast(value="int64_t")
public static long av_get_default_channel_layout(int nb_channels)

Return default channel layout for a given number of channels.

av_get_channel_layout_channel_index

@NoException
public static int av_get_channel_layout_channel_index(@Cast(value="uint64_t")
                                                  long channel_layout,
                                                  @Cast(value="uint64_t")
                                                  long channel)

Get the index of a channel in channel_layout.

Parameters:: channel - a channel layout describing exactly one channel which must be present in channel_layout.
Returns:: index of channel in channel_layout on success, a negative AVERROR on error.

av_channel_layout_extract_channel

@NoException
@Cast(value="uint64_t")
public static long av_channel_layout_extract_channel(@Cast(value="uint64_t")
                                                           long channel_layout,
                                                           int index)

Get the channel with the given index in channel_layout.

av_get_channel_name

@NoException
@Cast(value="const char*")
public static BytePointer av_get_channel_name(@Cast(value="uint64_t")
                                                    long channel)

Get the name of a given channel.

Returns:: channel name on success, NULL on error.

av_get_channel_description

@NoException
@Cast(value="const char*")
public static BytePointer av_get_channel_description(@Cast(value="uint64_t")
                                                           long channel)

Get the description of a given channel.

Parameters:: channel - a channel layout with a single channel
Returns:: channel description on success, NULL on error

av_get_standard_channel_layout

@NoException
public static int av_get_standard_channel_layout(@Cast(value="unsigned")
                                             int index,
                                             @Cast(value="uint64_t*")
                                             LongPointer layout,
                                             @Cast(value="const char**")
                                             PointerPointer name)

Get the value and name of a standard channel layout.

Parameters:: [in] - index index in an internal list, starting at 0; [out] - layout channel layout mask; [out] - name name of the layout
Returns:: 0 if the layout exists, <0 if index is beyond the limits

av_get_standard_channel_layout

@NoException
public static int av_get_standard_channel_layout(@Cast(value="unsigned")
                                             int index,
                                             @Cast(value="uint64_t*")
                                             LongPointer layout,
                                             @Cast(value="const char**")@ByPtrPtr
                                             BytePointer name)

av_get_standard_channel_layout

@NoException
public static int av_get_standard_channel_layout(@Cast(value="unsigned")
                                             int index,
                                             @Cast(value="uint64_t*")
                                             LongBuffer layout,
                                             @Cast(value="const char**")@ByPtrPtr
                                             ByteBuffer name)

av_get_standard_channel_layout

@NoException
public static int av_get_standard_channel_layout(@Cast(value="unsigned")
                                             int index,
                                             @Cast(value="uint64_t*")
                                             long[] layout,
                                             @Cast(value="const char**")@ByPtrPtr
                                             byte[] name)

av_get_cpu_flags
```
@NoException
public static int av_get_cpu_flags()
```
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.

av_force_cpu_flags
```
@NoException
public static void av_force_cpu_flags(int flags)
```
Disables cpu detection and forces the specified flags. -1 is a special case that disables forcing of specific flags.

av_set_cpu_flags_mask
```
@NoException
@Deprecated
public static void av_set_cpu_flags_mask(int mask)
```
Deprecated.

Set a mask on flags returned by av_get_cpu_flags(). This function is mainly useful for testing. Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible \warning this function is not thread safe.

av_parse_cpu_flags
```
@NoException
@Deprecated
public static int av_parse_cpu_flags(@Cast(value="const char*")
                                            BytePointer s)
```
Deprecated.

Parse CPU flags from a string. The returned flags contain the specified flags as well as related unspecified flags. This function exists only for compatibility with libav. Please use av_parse_cpu_caps() when possible.

Returns:
a combination of AV_CPU_* flags, negative on error.

av_parse_cpu_flags

@NoException
@Deprecated
public static int av_parse_cpu_flags(String s)

Deprecated.

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                IntPointer flags,
                                @Cast(value="const char*")
                                BytePointer s)

Parse CPU caps from a string and update the given AV_CPU_* flags based on that.

Returns:: negative on error.

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                IntBuffer flags,
                                String s)

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                int[] flags,
                                @Cast(value="const char*")
                                BytePointer s)

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                IntPointer flags,
                                String s)

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                IntBuffer flags,
                                @Cast(value="const char*")
                                BytePointer s)

av_parse_cpu_caps

@NoException
public static int av_parse_cpu_caps(@Cast(value="unsigned*")
                                int[] flags,
                                String s)

av_cpu_count
```
@NoException
public static int av_cpu_count()
```
Returns:
the number of logical CPU cores present.

av_dict_get

@NoException
public static avutil.AVDictionaryEntry av_dict_get(@Const
                                               avutil.AVDictionary m,
                                               @Cast(value="const char*")
                                               BytePointer key,
                                               @Const
                                               avutil.AVDictionaryEntry prev,
                                               int flags)

Get a dictionary entry with matching key. The returned entry key or value must not be changed, or it will cause undefined behavior. To iterate through all the dictionary entries, you can set the matching key to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag.

Parameters:: prev - Set to the previous matching element to find the next. If set to NULL the first matching element is returned.; key - matching key; flags - a collection of AV_DICT_* flags controlling how the entry is retrieved
Returns:: found entry or NULL in case no matching entry was found in the dictionary

av_dict_get

@NoException
public static avutil.AVDictionaryEntry av_dict_get(@Const
                                               avutil.AVDictionary m,
                                               String key,
                                               @Const
                                               avutil.AVDictionaryEntry prev,
                                               int flags)

av_dict_count

@NoException
public static int av_dict_count(@Const
                            avutil.AVDictionary m)

Get number of entries in dictionary.

Parameters:: m - dictionary
Returns:: number of entries in dictionary

av_dict_set
```
@NoException
public static int av_dict_set(@Cast(value="AVDictionary**")
                          PointerPointer pm,
                          @Cast(value="const char*")
                          BytePointer key,
                          @Cast(value="const char*")
                          BytePointer value,
                          int flags)
```
Set the given entry in *pm, overwriting an existing entry. Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set, these arguments will be freed on error. Warning: Adding a new entry to a dictionary invalidates all existing entries previously returned with av_dict_get.

Parameters:
pm - pointer to a pointer to a dictionary struct. If *pm is NULL a dictionary struct is allocated and put in *pm.
key - entry key to add to *pm (will either be av_strduped or added as a new key depending on flags)
value - entry value to add to *pm (will be av_strduped or added as a new key depending on flags). Passing a NULL value will cause an existing entry to be deleted.

Returns:
>= 0 on success otherwise an error code <0

av_dict_set

@NoException
public static int av_dict_set(@ByPtrPtr
                          avutil.AVDictionary pm,
                          @Cast(value="const char*")
                          BytePointer key,
                          @Cast(value="const char*")
                          BytePointer value,
                          int flags)

av_dict_set

@NoException
public static int av_dict_set(@ByPtrPtr
                          avutil.AVDictionary pm,
                          String key,
                          String value,
                          int flags)

av_dict_set_int

@NoException
public static int av_dict_set_int(@Cast(value="AVDictionary**")
                              PointerPointer pm,
                              @Cast(value="const char*")
                              BytePointer key,
                              @Cast(value="int64_t")
                              long value,
                              int flags)

Convenience wrapper for av_dict_set that converts the value to a string and stores it. Note: If AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.

av_dict_set_int

@NoException
public static int av_dict_set_int(@ByPtrPtr
                              avutil.AVDictionary pm,
                              @Cast(value="const char*")
                              BytePointer key,
                              @Cast(value="int64_t")
                              long value,
                              int flags)

av_dict_set_int

@NoException
public static int av_dict_set_int(@ByPtrPtr
                              avutil.AVDictionary pm,
                              String key,
                              @Cast(value="int64_t")
                              long value,
                              int flags)

av_dict_parse_string

@NoException
public static int av_dict_parse_string(@Cast(value="AVDictionary**")
                                   PointerPointer pm,
                                   @Cast(value="const char*")
                                   BytePointer str,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   int flags)

Parse the key/value pairs list and add the parsed entries to a dictionary. In case of failure, all the successfully set entries are stored in *pm. You may need to manually free the created dictionary.

Parameters:: key_val_sep - a 0-terminated list of characters used to separate key from value; pairs_sep - a 0-terminated list of characters used to separate two pairs from each other; flags - flags to use when adding to dictionary. AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL are ignored since the key/value tokens will always be duplicated.
Returns:: 0 on success, negative AVERROR code on failure

av_dict_parse_string

@NoException
public static int av_dict_parse_string(@ByPtrPtr
                                   avutil.AVDictionary pm,
                                   @Cast(value="const char*")
                                   BytePointer str,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   int flags)

av_dict_parse_string

@NoException
public static int av_dict_parse_string(@ByPtrPtr
                                   avutil.AVDictionary pm,
                                   String str,
                                   String key_val_sep,
                                   String pairs_sep,
                                   int flags)

av_dict_copy
```
@NoException
public static int av_dict_copy(@Cast(value="AVDictionary**")
                           PointerPointer dst,
                           @Const
                           avutil.AVDictionary src,
                           int flags)
```
Copy entries from one AVDictionary struct into another.

Parameters:
dst - pointer to a pointer to a AVDictionary struct. If *dst is NULL, this function will allocate a struct for you and put it in *dst
src - pointer to source AVDictionary struct
flags - flags to use when setting entries in *dst \note metadata is read using the AV_DICT_IGNORE_SUFFIX flag

Returns:
0 on success, negative AVERROR code on failure. If dst was allocated by this function, callers should free the associated memory.

av_dict_copy

@NoException
public static int av_dict_copy(@ByPtrPtr
                           avutil.AVDictionary dst,
                           @Const
                           avutil.AVDictionary src,
                           int flags)

av_dict_free

@NoException
public static void av_dict_free(@Cast(value="AVDictionary**")
                            PointerPointer m)

Free all the memory allocated for an AVDictionary struct and all keys and values.

av_dict_free

@NoException
public static void av_dict_free(@ByPtrPtr
                            avutil.AVDictionary m)

av_dict_get_string
```
@NoException
public static int av_dict_get_string(@Const
                                 avutil.AVDictionary m,
                                 @Cast(value="char**")
                                 PointerPointer buffer,
                                 byte key_val_sep,
                                 byte pairs_sep)
```
Get dictionary entries as a string. Create a string containing dictionary's entries. Such string may be passed back to av_dict_parse_string(). \note String is escaped with backslashes ('\').

Parameters:
[in] - m dictionary
[out] - buffer Pointer to buffer that will be allocated with string containg entries. Buffer must be freed by the caller when is no longer needed.
[in] - key_val_sep character used to separate key from value
[in] - pairs_sep character used to separate two pairs from each other

Returns:
>= 0 on success, negative on error \warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.

av_dict_get_string

@NoException
public static int av_dict_get_string(@Const
                                 avutil.AVDictionary m,
                                 @Cast(value="char**")@ByPtrPtr
                                 BytePointer buffer,
                                 byte key_val_sep,
                                 byte pairs_sep)

av_dict_get_string

@NoException
public static int av_dict_get_string(@Const
                                 avutil.AVDictionary m,
                                 @Cast(value="char**")@ByPtrPtr
                                 ByteBuffer buffer,
                                 byte key_val_sep,
                                 byte pairs_sep)

av_dict_get_string

@NoException
public static int av_dict_get_string(@Const
                                 avutil.AVDictionary m,
                                 @Cast(value="char**")@ByPtrPtr
                                 byte[] buffer,
                                 byte key_val_sep,
                                 byte pairs_sep)

AV_OPT_TYPE_IMAGE_SIZE

@MemberGetter
public static int AV_OPT_TYPE_IMAGE_SIZE()

AV_OPT_TYPE_PIXEL_FMT

@MemberGetter
public static int AV_OPT_TYPE_PIXEL_FMT()

AV_OPT_TYPE_SAMPLE_FMT

@MemberGetter
public static int AV_OPT_TYPE_SAMPLE_FMT()

AV_OPT_TYPE_VIDEO_RATE

@MemberGetter
public static int AV_OPT_TYPE_VIDEO_RATE()

AV_OPT_TYPE_DURATION

@MemberGetter
public static int AV_OPT_TYPE_DURATION()

AV_OPT_TYPE_COLOR

@MemberGetter
public static int AV_OPT_TYPE_COLOR()

AV_OPT_TYPE_CHANNEL_LAYOUT

@MemberGetter
public static int AV_OPT_TYPE_CHANNEL_LAYOUT()

AV_OPT_TYPE_BOOL

@MemberGetter
public static int AV_OPT_TYPE_BOOL()

av_opt_show2
```
@NoException
public static int av_opt_show2(Pointer obj,
                           Pointer av_log_obj,
                           int req_flags,
                           int rej_flags)
```
Show the obj options.

Parameters:
req_flags - requested flags for the options to show. Show only the options for which it is opt->flags & req_flags.
rej_flags - rejected flags for the options to show. Show only the options for which it is !(opt->flags & req_flags).
av_log_obj - log context to use for showing the options

av_opt_set_defaults
```
@NoException
public static void av_opt_set_defaults(Pointer s)
```
Set the values of all AVOption fields to their default values.

Parameters:
s - an AVOption-enabled struct (its first member must be a pointer to AVClass)

av_opt_set_defaults2
```
@NoException
public static void av_opt_set_defaults2(Pointer s,
                                    int mask,
                                    int flags)
```
Set the values of all AVOption fields to their default values. Only these AVOption fields for which (opt->flags & mask) == flags will have their default applied to s.

Parameters:
s - an AVOption-enabled struct (its first member must be a pointer to AVClass)
mask - combination of AV_OPT_FLAG_*
flags - combination of AV_OPT_FLAG_*

av_set_options_string
```
@NoException
public static int av_set_options_string(Pointer ctx,
                                    @Cast(value="const char*")
                                    BytePointer opts,
                                    @Cast(value="const char*")
                                    BytePointer key_val_sep,
                                    @Cast(value="const char*")
                                    BytePointer pairs_sep)
```
Parse the key/value pairs list in opts. For each key/value pair found, stores the value in the field in ctx that is named like the key. ctx must be an AVClass context, storing is done using AVOptions.

Parameters:
opts - options string to parse, may be NULL
key_val_sep - a 0-terminated list of characters used to separate key from value
pairs_sep - a 0-terminated list of characters used to separate two pairs from each other

Returns:
the number of successfully set key/value pairs, or a negative value corresponding to an AVERROR code in case of error: AVERROR(EINVAL) if opts cannot be parsed, the error code issued by av_opt_set() if a key/value pair cannot be set

av_set_options_string

@NoException
public static int av_set_options_string(Pointer ctx,
                                    String opts,
                                    String key_val_sep,
                                    String pairs_sep)

av_opt_set_from_string
```
@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     @Cast(value="const char*")
                                     BytePointer opts,
                                     @Cast(value="const char*const*")
                                     PointerPointer shorthand,
                                     @Cast(value="const char*")
                                     BytePointer key_val_sep,
                                     @Cast(value="const char*")
                                     BytePointer pairs_sep)
```
Parse the key-value pairs list in opts. For each key=value pair found, set the value of the corresponding option in ctx.

Parameters:
ctx - the AVClass object to set options on
opts - the options string, key-value pairs separated by a delimiter
shorthand - a NULL-terminated array of options names for shorthand notation: if the first field in opts has no key part, the key is taken from the first element of shorthand; then again for the second, etc., until either opts is finished, shorthand is finished or a named option is found; after that, all options must be named
key_val_sep - a 0-terminated list of characters used to separate key from value, for example '='
pairs_sep - a 0-terminated list of characters used to separate two pairs from each other, for example ':' or ','

Returns:
the number of successfully set key=value pairs, or a negative value corresponding to an AVERROR code in case of error: AVERROR(EINVAL) if opts cannot be parsed, the error code issued by av_set_string3() if a key/value pair cannot be set Options names must use only the following characters: a-z A-Z 0-9 - . / _ Separators must use characters distinct from option names and from each other.

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     @Cast(value="const char*")
                                     BytePointer opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     BytePointer shorthand,
                                     @Cast(value="const char*")
                                     BytePointer key_val_sep,
                                     @Cast(value="const char*")
                                     BytePointer pairs_sep)

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     String opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     ByteBuffer shorthand,
                                     String key_val_sep,
                                     String pairs_sep)

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     @Cast(value="const char*")
                                     BytePointer opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     byte[] shorthand,
                                     @Cast(value="const char*")
                                     BytePointer key_val_sep,
                                     @Cast(value="const char*")
                                     BytePointer pairs_sep)

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     String opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     BytePointer shorthand,
                                     String key_val_sep,
                                     String pairs_sep)

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     @Cast(value="const char*")
                                     BytePointer opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     ByteBuffer shorthand,
                                     @Cast(value="const char*")
                                     BytePointer key_val_sep,
                                     @Cast(value="const char*")
                                     BytePointer pairs_sep)

av_opt_set_from_string

@NoException
public static int av_opt_set_from_string(Pointer ctx,
                                     String opts,
                                     @Cast(value="const char*const*")@ByPtrPtr
                                     byte[] shorthand,
                                     String key_val_sep,
                                     String pairs_sep)

av_opt_free

@NoException
public static void av_opt_free(Pointer obj)

Free all allocated objects in obj.

av_opt_flag_is_set

@NoException
public static int av_opt_flag_is_set(Pointer obj,
                                 @Cast(value="const char*")
                                 BytePointer field_name,
                                 @Cast(value="const char*")
                                 BytePointer flag_name)

Check whether a particular flag is set in a flags field.

Parameters:: field_name - the name of the flag field option; flag_name - the name of the flag to check
Returns:: non-zero if the flag is set, zero if the flag isn't set, isn't of the right type, or the flags field doesn't exist.

av_opt_flag_is_set

@NoException
public static int av_opt_flag_is_set(Pointer obj,
                                 String field_name,
                                 String flag_name)

av_opt_set_dict
```
@NoException
public static int av_opt_set_dict(Pointer obj,
                              @Cast(value="AVDictionary**")
                              PointerPointer options)
```
Set all the options from a given dictionary on an object.

Parameters:
obj - a struct whose first element is a pointer to AVClass
options - options to process. This dictionary will be freed and replaced by a new one containing all options not found in obj. Of course this new dictionary needs to be freed by caller with av_dict_free().

Returns:
0 on success, a negative AVERROR if some option was found in obj, but could not be set.
See Also:
av_dict_copy()

av_opt_set_dict

@NoException
public static int av_opt_set_dict(Pointer obj,
                              @ByPtrPtr
                              avutil.AVDictionary options)

av_opt_set_dict2
```
@NoException
public static int av_opt_set_dict2(Pointer obj,
                               @Cast(value="AVDictionary**")
                               PointerPointer options,
                               int search_flags)
```
Set all the options from a given dictionary on an object.

Parameters:
obj - a struct whose first element is a pointer to AVClass
options - options to process. This dictionary will be freed and replaced by a new one containing all options not found in obj. Of course this new dictionary needs to be freed by caller with av_dict_free().
search_flags - A combination of AV_OPT_SEARCH_*.

Returns:
0 on success, a negative AVERROR if some option was found in obj, but could not be set.
See Also:
av_dict_copy()

av_opt_set_dict2

@NoException
public static int av_opt_set_dict2(Pointer obj,
                               @ByPtrPtr
                               avutil.AVDictionary options,
                               int search_flags)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")
                                   PointerPointer ropts,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")
                                   PointerPointer rkey,
                                   @Cast(value="char**")
                                   PointerPointer rval)

Extract a key-value pair from the beginning of a string.

Parameters:: 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); key_val_sep - a 0-terminated list of characters used to separate key from value, for example '='; pairs_sep - a 0-terminated list of characters used to separate two pairs from each other, for example ':' or ','; flags - flags; see the AV_OPT_FLAG_* values below; rkey - parsed key; must be freed using av_free(); rval - parsed value; must be freed using av_free()
Returns:: >=0 for success, or a negative value corresponding to an AVERROR code in case of error; in particular: AVERROR(EINVAL) if no key is present

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   BytePointer ropts,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   BytePointer rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   BytePointer rval)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   ByteBuffer ropts,
                                   String key_val_sep,
                                   String pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   ByteBuffer rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   ByteBuffer rval)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   byte[] ropts,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   byte[] rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   byte[] rval)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   BytePointer ropts,
                                   String key_val_sep,
                                   String pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   BytePointer rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   BytePointer rval)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   ByteBuffer ropts,
                                   @Cast(value="const char*")
                                   BytePointer key_val_sep,
                                   @Cast(value="const char*")
                                   BytePointer pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   ByteBuffer rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   ByteBuffer rval)

av_opt_get_key_value

@NoException
public static int av_opt_get_key_value(@Cast(value="const char**")@ByPtrPtr
                                   byte[] ropts,
                                   String key_val_sep,
                                   String pairs_sep,
                                   @Cast(value="unsigned")
                                   int flags,
                                   @Cast(value="char**")@ByPtrPtr
                                   byte[] rkey,
                                   @Cast(value="char**")@ByPtrPtr
                                   byte[] rval)

av_opt_eval_flags
```
@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                IntPointer flags_out)
```
\defgroup opt_eval_funcs Evaluating option strings \{ This group of functions can be used to evaluate option strings and get numbers out of them. They do the same thing as av_opt_set(), except the result is written into the caller-supplied pointer.

Parameters:
obj - a struct whose first element is a pointer to AVClass.
o - an option for which the string is to be evaluated.
val - string to be evaluated.
*_out - value of the string will be written here.

Returns:
0 on success, a negative number on failure.

av_opt_eval_flags

@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                IntBuffer flags_out)

av_opt_eval_flags

@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                int[] flags_out)

av_opt_eval_flags

@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                IntPointer flags_out)

av_opt_eval_flags

@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                IntBuffer flags_out)

av_opt_eval_flags

@NoException
public static int av_opt_eval_flags(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                int[] flags_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              @Cast(value="const char*")
                              BytePointer val,
                              IntPointer int_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              String val,
                              IntBuffer int_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              @Cast(value="const char*")
                              BytePointer val,
                              int[] int_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              String val,
                              IntPointer int_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              @Cast(value="const char*")
                              BytePointer val,
                              IntBuffer int_out)

av_opt_eval_int

@NoException
public static int av_opt_eval_int(Pointer obj,
                              @Const
                              avutil.AVOption o,
                              String val,
                              int[] int_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                @Cast(value="int64_t*")
                                LongPointer int64_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                @Cast(value="int64_t*")
                                LongBuffer int64_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                @Cast(value="int64_t*")
                                long[] int64_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                @Cast(value="int64_t*")
                                LongPointer int64_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                @Cast(value="int64_t*")
                                LongBuffer int64_out)

av_opt_eval_int64

@NoException
public static int av_opt_eval_int64(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                @Cast(value="int64_t*")
                                long[] int64_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                FloatPointer float_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                FloatBuffer float_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                float[] float_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                FloatPointer float_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                @Cast(value="const char*")
                                BytePointer val,
                                FloatBuffer float_out)

av_opt_eval_float

@NoException
public static int av_opt_eval_float(Pointer obj,
                                @Const
                                avutil.AVOption o,
                                String val,
                                float[] float_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 @Cast(value="const char*")
                                 BytePointer val,
                                 DoublePointer double_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 String val,
                                 DoubleBuffer double_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 @Cast(value="const char*")
                                 BytePointer val,
                                 double[] double_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 String val,
                                 DoublePointer double_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 @Cast(value="const char*")
                                 BytePointer val,
                                 DoubleBuffer double_out)

av_opt_eval_double

@NoException
public static int av_opt_eval_double(Pointer obj,
                                 @Const
                                 avutil.AVOption o,
                                 String val,
                                 double[] double_out)

av_opt_eval_q

@NoException
public static int av_opt_eval_q(Pointer obj,
                            @Const
                            avutil.AVOption o,
                            @Cast(value="const char*")
                            BytePointer val,
                            avutil.AVRational q_out)

av_opt_eval_q

@NoException
public static int av_opt_eval_q(Pointer obj,
                            @Const
                            avutil.AVOption o,
                            String val,
                            avutil.AVRational q_out)

av_opt_find
```
@NoException
@Const
public static avutil.AVOption av_opt_find(Pointer obj,
                                            @Cast(value="const char*")
                                            BytePointer name,
                                            @Cast(value="const char*")
                                            BytePointer unit,
                                            int opt_flags,
                                            int search_flags)
```
Look for an option in an object. Consider only options which have all the specified flags set.

Parameters:
[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.
[in] - name The name of the option to look for.
[in] - unit When searching for named constants, name of the unit it belongs to.
opt_flags - Find only options with all the specified flags set (AV_OPT_FLAG).
search_flags - A combination of AV_OPT_SEARCH_*.

Returns:
A pointer to the option found, or NULL if no option was found. \note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable directly with av_opt_set(). Use special calls which take an options AVDictionary (e.g. avformat_open_input()) to set options found with this flag.

av_opt_find

@NoException
@Const
public static avutil.AVOption av_opt_find(Pointer obj,
                                            String name,
                                            String unit,
                                            int opt_flags,
                                            int search_flags)

av_opt_find2
```
@NoException
@Const
public static avutil.AVOption av_opt_find2(Pointer obj,
                                             @Cast(value="const char*")
                                             BytePointer name,
                                             @Cast(value="const char*")
                                             BytePointer unit,
                                             int opt_flags,
                                             int search_flags,
                                             @Cast(value="void**")
                                             PointerPointer target_obj)
```
Look for an option in an object. Consider only options which have all the specified flags set.

Parameters:
[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.
[in] - name The name of the option to look for.
[in] - unit When searching for named constants, name of the unit it belongs to.
opt_flags - Find only options with all the specified flags set (AV_OPT_FLAG).
search_flags - A combination of AV_OPT_SEARCH_*.
[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.

Returns:
A pointer to the option found, or NULL if no option was found.

av_opt_find2

@NoException
@Const
public static avutil.AVOption av_opt_find2(Pointer obj,
                                             @Cast(value="const char*")
                                             BytePointer name,
                                             @Cast(value="const char*")
                                             BytePointer unit,
                                             int opt_flags,
                                             int search_flags,
                                             @Cast(value="void**")@ByPtrPtr
                                             Pointer target_obj)

av_opt_find2

@NoException
@Const
public static avutil.AVOption av_opt_find2(Pointer obj,
                                             String name,
                                             String unit,
                                             int opt_flags,
                                             int search_flags,
                                             @Cast(value="void**")@ByPtrPtr
                                             Pointer target_obj)

av_opt_next

@NoException
@Const
public static avutil.AVOption av_opt_next(@Const
                                            Pointer obj,
                                            @Const
                                            avutil.AVOption prev)

Iterate over all AVOptions belonging to obj.

Parameters:: obj - an AVOptions-enabled struct or a double pointer to an AVClass describing it.; prev - result of the previous call to av_opt_next() on this object or NULL
Returns:: next AVOption or NULL

av_opt_child_next
```
@NoException
public static Pointer av_opt_child_next(Pointer obj,
                                    Pointer prev)
```
Iterate over AVOptions-enabled children of obj.

Parameters:
prev - result of a previous call to this function or NULL

Returns:
next AVOptions-enabled child or NULL

av_opt_child_class_next

@NoException
@Const
public static avutil.AVClass av_opt_child_class_next(@Const
                                                       avutil.AVClass parent,
                                                       @Const
                                                       avutil.AVClass prev)

Iterate over potential AVOptions-enabled children of parent.

Parameters:: prev - result of a previous call to this function or NULL
Returns:: AVClass corresponding to next potential child or NULL

av_opt_set
```
@NoException
public static int av_opt_set(Pointer obj,
                         @Cast(value="const char*")
                         BytePointer name,
                         @Cast(value="const char*")
                         BytePointer val,
                         int search_flags)
```
\defgroup opt_set_funcs Option setting functions \{ Those functions set the field of obj with the given name to value.

Parameters:
[in] - obj A struct whose first element is a pointer to an AVClass.
[in] - name the name of the field to set
[in] - val The value to set. In case of av_opt_set() if the field is not of a string type, then the given string is parsed. SI postfixes and some named scalars are supported. If the field is of a numeric type, it has to be a numeric or named scalar. Behavior with more than one scalar and +- infix operators is undefined. If the field is of a flags type, it has to be a sequence of numeric scalars or named flags separated by '+' or '-'. Prefixing a flag with '+' causes it to be set without affecting the other flags; similarly, '-' unsets a flag.
search_flags - flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN is passed here, then the option may be set on a child of obj.

Returns:
0 if the value has been set, or an AVERROR code in case of error: AVERROR_OPTION_NOT_FOUND if no matching option exists AVERROR(ERANGE) if the value is out of range AVERROR(EINVAL) if the value is not valid

av_opt_set

@NoException
public static int av_opt_set(Pointer obj,
                         String name,
                         String val,
                         int search_flags)

av_opt_set_int

@NoException
public static int av_opt_set_int(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             @Cast(value="int64_t")
                             long val,
                             int search_flags)

av_opt_set_int

@NoException
public static int av_opt_set_int(Pointer obj,
                             String name,
                             @Cast(value="int64_t")
                             long val,
                             int search_flags)

av_opt_set_double

@NoException
public static int av_opt_set_double(Pointer obj,
                                @Cast(value="const char*")
                                BytePointer name,
                                double val,
                                int search_flags)

av_opt_set_double

@NoException
public static int av_opt_set_double(Pointer obj,
                                String name,
                                double val,
                                int search_flags)

av_opt_set_q

@NoException
public static int av_opt_set_q(Pointer obj,
                           @Cast(value="const char*")
                           BytePointer name,
                           @ByVal
                           avutil.AVRational val,
                           int search_flags)

av_opt_set_q

@NoException
public static int av_opt_set_q(Pointer obj,
                           String name,
                           @ByVal
                           avutil.AVRational val,
                           int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             @Cast(value="const uint8_t*")
                             BytePointer val,
                             int size,
                             int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             String name,
                             @Cast(value="const uint8_t*")
                             ByteBuffer val,
                             int size,
                             int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             @Cast(value="const uint8_t*")
                             byte[] val,
                             int size,
                             int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             String name,
                             @Cast(value="const uint8_t*")
                             BytePointer val,
                             int size,
                             int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             @Cast(value="const uint8_t*")
                             ByteBuffer val,
                             int size,
                             int search_flags)

av_opt_set_bin

@NoException
public static int av_opt_set_bin(Pointer obj,
                             String name,
                             @Cast(value="const uint8_t*")
                             byte[] val,
                             int size,
                             int search_flags)

av_opt_set_image_size

@NoException
public static int av_opt_set_image_size(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int w,
                                    int h,
                                    int search_flags)

av_opt_set_image_size

@NoException
public static int av_opt_set_image_size(Pointer obj,
                                    String name,
                                    int w,
                                    int h,
                                    int search_flags)

av_opt_set_pixel_fmt

@NoException
public static int av_opt_set_pixel_fmt(Pointer obj,
                                   @Cast(value="const char*")
                                   BytePointer name,
                                   @Cast(value="AVPixelFormat")
                                   int fmt,
                                   int search_flags)

av_opt_set_pixel_fmt

@NoException
public static int av_opt_set_pixel_fmt(Pointer obj,
                                   String name,
                                   @Cast(value="AVPixelFormat")
                                   int fmt,
                                   int search_flags)

av_opt_set_sample_fmt

@NoException
public static int av_opt_set_sample_fmt(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    @Cast(value="AVSampleFormat")
                                    int fmt,
                                    int search_flags)

av_opt_set_sample_fmt

@NoException
public static int av_opt_set_sample_fmt(Pointer obj,
                                    String name,
                                    @Cast(value="AVSampleFormat")
                                    int fmt,
                                    int search_flags)

av_opt_set_video_rate

@NoException
public static int av_opt_set_video_rate(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    @ByVal
                                    avutil.AVRational val,
                                    int search_flags)

av_opt_set_video_rate

@NoException
public static int av_opt_set_video_rate(Pointer obj,
                                    String name,
                                    @ByVal
                                    avutil.AVRational val,
                                    int search_flags)

av_opt_set_channel_layout

@NoException
public static int av_opt_set_channel_layout(Pointer obj,
                                        @Cast(value="const char*")
                                        BytePointer name,
                                        @Cast(value="int64_t")
                                        long ch_layout,
                                        int search_flags)

av_opt_set_channel_layout

@NoException
public static int av_opt_set_channel_layout(Pointer obj,
                                        String name,
                                        @Cast(value="int64_t")
                                        long ch_layout,
                                        int search_flags)

av_opt_set_dict_val

@NoException
public static int av_opt_set_dict_val(Pointer obj,
                                  @Cast(value="const char*")
                                  BytePointer name,
                                  @Const
                                  avutil.AVDictionary val,
                                  int search_flags)

\note Any old dictionary present is discarded and replaced with a copy of the new one. The caller still owns val is and responsible for freeing it.

av_opt_set_dict_val

@NoException
public static int av_opt_set_dict_val(Pointer obj,
                                  String name,
                                  @Const
                                  avutil.AVDictionary val,
                                  int search_flags)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         @Cast(value="const char*")
                         BytePointer name,
                         int search_flags,
                         @Cast(value="uint8_t**")
                         PointerPointer out_val)

\note the returned string will be av_malloc()ed and must be av_free()ed by the caller \note if AV_OPT_ALLOW_NULL is set in search_flags in av_opt_get, and the option has AV_OPT_TYPE_STRING or AV_OPT_TYPE_BINARY and is set to NULL, *out_val will be set to NULL instead of an allocated empty string.

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         @Cast(value="const char*")
                         BytePointer name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         BytePointer out_val)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         String name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         ByteBuffer out_val)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         @Cast(value="const char*")
                         BytePointer name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         byte[] out_val)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         String name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         BytePointer out_val)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         @Cast(value="const char*")
                         BytePointer name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         ByteBuffer out_val)

av_opt_get

@NoException
public static int av_opt_get(Pointer obj,
                         String name,
                         int search_flags,
                         @Cast(value="uint8_t**")@ByPtrPtr
                         byte[] out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             LongPointer out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             String name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             LongBuffer out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             long[] out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             String name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             LongPointer out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             LongBuffer out_val)

av_opt_get_int

@NoException
public static int av_opt_get_int(Pointer obj,
                             String name,
                             int search_flags,
                             @Cast(value="int64_t*")
                             long[] out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                @Cast(value="const char*")
                                BytePointer name,
                                int search_flags,
                                DoublePointer out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                String name,
                                int search_flags,
                                DoubleBuffer out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                @Cast(value="const char*")
                                BytePointer name,
                                int search_flags,
                                double[] out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                String name,
                                int search_flags,
                                DoublePointer out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                @Cast(value="const char*")
                                BytePointer name,
                                int search_flags,
                                DoubleBuffer out_val)

av_opt_get_double

@NoException
public static int av_opt_get_double(Pointer obj,
                                String name,
                                int search_flags,
                                double[] out_val)

av_opt_get_q

@NoException
public static int av_opt_get_q(Pointer obj,
                           @Cast(value="const char*")
                           BytePointer name,
                           int search_flags,
                           avutil.AVRational out_val)

av_opt_get_q

@NoException
public static int av_opt_get_q(Pointer obj,
                           String name,
                           int search_flags,
                           avutil.AVRational out_val)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    IntPointer w_out,
                                    IntPointer h_out)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    String name,
                                    int search_flags,
                                    IntBuffer w_out,
                                    IntBuffer h_out)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    int[] w_out,
                                    int[] h_out)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    String name,
                                    int search_flags,
                                    IntPointer w_out,
                                    IntPointer h_out)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    IntBuffer w_out,
                                    IntBuffer h_out)

av_opt_get_image_size

@NoException
public static int av_opt_get_image_size(Pointer obj,
                                    String name,
                                    int search_flags,
                                    int[] w_out,
                                    int[] h_out)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   @Cast(value="const char*")
                                   BytePointer name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   IntPointer out_fmt)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   String name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   IntBuffer out_fmt)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   @Cast(value="const char*")
                                   BytePointer name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   int[] out_fmt)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   String name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   IntPointer out_fmt)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   @Cast(value="const char*")
                                   BytePointer name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   IntBuffer out_fmt)

av_opt_get_pixel_fmt

@NoException
public static int av_opt_get_pixel_fmt(Pointer obj,
                                   String name,
                                   int search_flags,
                                   @Cast(value="AVPixelFormat*")
                                   int[] out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    IntPointer out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    String name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    IntBuffer out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    int[] out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    String name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    IntPointer out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    IntBuffer out_fmt)

av_opt_get_sample_fmt

@NoException
public static int av_opt_get_sample_fmt(Pointer obj,
                                    String name,
                                    int search_flags,
                                    @Cast(value="AVSampleFormat*")
                                    int[] out_fmt)

av_opt_get_video_rate

@NoException
public static int av_opt_get_video_rate(Pointer obj,
                                    @Cast(value="const char*")
                                    BytePointer name,
                                    int search_flags,
                                    avutil.AVRational out_val)

av_opt_get_video_rate

@NoException
public static int av_opt_get_video_rate(Pointer obj,
                                    String name,
                                    int search_flags,
                                    avutil.AVRational out_val)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        @Cast(value="const char*")
                                        BytePointer name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        LongPointer ch_layout)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        String name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        LongBuffer ch_layout)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        @Cast(value="const char*")
                                        BytePointer name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        long[] ch_layout)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        String name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        LongPointer ch_layout)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        @Cast(value="const char*")
                                        BytePointer name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        LongBuffer ch_layout)

av_opt_get_channel_layout

@NoException
public static int av_opt_get_channel_layout(Pointer obj,
                                        String name,
                                        int search_flags,
                                        @Cast(value="int64_t*")
                                        long[] ch_layout)

av_opt_get_dict_val

@NoException
public static int av_opt_get_dict_val(Pointer obj,
                                  @Cast(value="const char*")
                                  BytePointer name,
                                  int search_flags,
                                  @Cast(value="AVDictionary**")
                                  PointerPointer out_val)

Parameters:: [out] - out_val The returned dictionary is a copy of the actual value and must be freed with av_dict_free() by the caller

av_opt_get_dict_val

@NoException
public static int av_opt_get_dict_val(Pointer obj,
                                  @Cast(value="const char*")
                                  BytePointer name,
                                  int search_flags,
                                  @ByPtrPtr
                                  avutil.AVDictionary out_val)

av_opt_get_dict_val

@NoException
public static int av_opt_get_dict_val(Pointer obj,
                                  String name,
                                  int search_flags,
                                  @ByPtrPtr
                                  avutil.AVDictionary out_val)

av_opt_ptr

@NoException
public static Pointer av_opt_ptr(@Const
                             avutil.AVClass avclass,
                             Pointer obj,
                             @Cast(value="const char*")
                             BytePointer name)

Gets a pointer to the requested field in a struct. This function allows accessing a struct even when its fields are moved or renamed since the application making the access has been compiled,

Returns:: a pointer to the field, it can be cast to the correct type and read or written to.

av_opt_ptr

@NoException
public static Pointer av_opt_ptr(@Const
                             avutil.AVClass avclass,
                             Pointer obj,
                             String name)

av_opt_freep_ranges

@NoException
public static void av_opt_freep_ranges(@Cast(value="AVOptionRanges**")
                                   PointerPointer ranges)

Free an AVOptionRanges struct and set it to NULL.

av_opt_freep_ranges

@NoException
public static void av_opt_freep_ranges(@ByPtrPtr
                                   avutil.AVOptionRanges ranges)

av_opt_query_ranges
```
@NoException
public static int av_opt_query_ranges(@Cast(value="AVOptionRanges**")
                                  PointerPointer arg0,
                                  Pointer obj,
                                  @Cast(value="const char*")
                                  BytePointer key,
                                  int flags)
```
Get a list of allowed ranges for the given option. The returned list may depend on other fields in obj like for example profile.

Parameters:
flags - is a bitmask of flags, undefined flags should not be set and should be ignored AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges The result must be freed with av_opt_freep_ranges.

Returns:
number of compontents returned on success, a negative errro code otherwise

av_opt_query_ranges

@NoException
public static int av_opt_query_ranges(@ByPtrPtr
                                  avutil.AVOptionRanges arg0,
                                  Pointer obj,
                                  @Cast(value="const char*")
                                  BytePointer key,
                                  int flags)

av_opt_query_ranges

@NoException
public static int av_opt_query_ranges(@ByPtrPtr
                                  avutil.AVOptionRanges arg0,
                                  Pointer obj,
                                  String key,
                                  int flags)

av_opt_copy
```
@NoException
public static int av_opt_copy(Pointer dest,
                          @Const
                          Pointer src)
```
Copy options from src object into dest object. Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object. Original memory allocated for such options is freed unless both src and dest options points to the same memory.

Parameters:
dest - Object to copy from
src - Object to copy into

Returns:
0 on success, negative on error

av_opt_query_ranges_default
```
@NoException
public static int av_opt_query_ranges_default(@Cast(value="AVOptionRanges**")
                                          PointerPointer arg0,
                                          Pointer obj,
                                          @Cast(value="const char*")
                                          BytePointer key,
                                          int flags)
```
Get a default list of allowed ranges for the given option. This list is constructed without using the AVClass.query_ranges() callback and can be used as fallback from within the callback.

Parameters:
flags - is a bitmask of flags, undefined flags should not be set and should be ignored AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges The result must be freed with av_opt_free_ranges.

Returns:
number of compontents returned on success, a negative errro code otherwise

av_opt_query_ranges_default

@NoException
public static int av_opt_query_ranges_default(@ByPtrPtr
                                          avutil.AVOptionRanges arg0,
                                          Pointer obj,
                                          @Cast(value="const char*")
                                          BytePointer key,
                                          int flags)

av_opt_query_ranges_default

@NoException
public static int av_opt_query_ranges_default(@ByPtrPtr
                                          avutil.AVOptionRanges arg0,
                                          Pointer obj,
                                          String key,
                                          int flags)

av_opt_is_set_to_default
```
@NoException
public static int av_opt_is_set_to_default(Pointer obj,
                                       @Const
                                       avutil.AVOption o)
```
Check if given option is set to its default value. Options o must belong to the obj. This function must not be called to check child's options state.

Parameters:
obj - AVClass object to check option on
o - option to be checked

Returns:
>0 when option is set to its default, 0 when option is not set its default, <0 on error
See Also:
av_opt_is_set_to_default_by_name().

av_opt_is_set_to_default_by_name

@NoException
public static int av_opt_is_set_to_default_by_name(Pointer obj,
                                               @Cast(value="const char*")
                                               BytePointer name,
                                               int search_flags)

Check if given option is set to its default value.

Parameters:: obj - AVClass object to check option on; name - option name; search_flags - combination of AV_OPT_SEARCH_*
Returns:: >0 when option is set to its default, 0 when option is not set its default, <0 on error

av_opt_is_set_to_default_by_name

@NoException
public static int av_opt_is_set_to_default_by_name(Pointer obj,
                                               String name,
                                               int search_flags)

av_opt_serialize
```
@NoException
public static int av_opt_serialize(Pointer obj,
                               int opt_flags,
                               int flags,
                               @Cast(value="char**")
                               PointerPointer buffer,
                               byte key_val_sep,
                               byte pairs_sep)
```
Serialize object's options. Create a string containing object's serialized options. Such string may be passed back to av_opt_set_from_string() in order to restore option values. A key/value or pairs separator occurring in the serialized value or name string are escaped through the av_escape() function.

Parameters:
[in] - obj AVClass object to serialize
[in] - opt_flags serialize options with all the specified flags set (AV_OPT_FLAG)
[in] - flags combination of AV_OPT_SERIALIZE_* flags
[out] - buffer Pointer to buffer that will be allocated with string containg serialized options. Buffer must be freed by the caller when is no longer needed.
[in] - key_val_sep character used to separate key from value
[in] - pairs_sep character used to separate two pairs from each other

Returns:
>= 0 on success, negative on error \warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.

av_opt_serialize

@NoException
public static int av_opt_serialize(Pointer obj,
                               int opt_flags,
                               int flags,
                               @Cast(value="char**")@ByPtrPtr
                               BytePointer buffer,
                               byte key_val_sep,
                               byte pairs_sep)

av_opt_serialize

@NoException
public static int av_opt_serialize(Pointer obj,
                               int opt_flags,
                               int flags,
                               @Cast(value="char**")@ByPtrPtr
                               ByteBuffer buffer,
                               byte key_val_sep,
                               byte pairs_sep)

av_opt_serialize

@NoException
public static int av_opt_serialize(Pointer obj,
                               int opt_flags,
                               int flags,
                               @Cast(value="char**")@ByPtrPtr
                               byte[] buffer,
                               byte key_val_sep,
                               byte pairs_sep)

av_get_bits_per_pixel
```
@NoException
public static int av_get_bits_per_pixel(@Const
                                    avutil.AVPixFmtDescriptor pixdesc)
```
Return the number of bits per pixel used by the pixel format described by pixdesc. Note that this is not the same as the number of bits per sample. The returned number of bits refers to the number of bits actually used for storing the pixel information, that is padding bits are not counted.

av_get_padded_bits_per_pixel

@NoException
public static int av_get_padded_bits_per_pixel(@Const
                                           avutil.AVPixFmtDescriptor pixdesc)

Return the number of bits per pixel for the pixel format described by pixdesc, including any padding or unused bits.

av_pix_fmt_desc_get

@NoException
@Const
public static avutil.AVPixFmtDescriptor av_pix_fmt_desc_get(@Cast(value="AVPixelFormat")
                                                              int pix_fmt)

Returns:: a pixel format descriptor for provided pixel format or NULL if this pixel format is unknown.

av_pix_fmt_desc_next

@NoException
@Const
public static avutil.AVPixFmtDescriptor av_pix_fmt_desc_next(@Const
                                                               avutil.AVPixFmtDescriptor prev)

Iterate over all pixel format descriptors known to libavutil.

Parameters:: prev - previous descriptor. NULL to get the first descriptor.
Returns:: next descriptor or NULL after the last descriptor

av_pix_fmt_desc_get_id

@NoException
@Cast(value="AVPixelFormat")
public static int av_pix_fmt_desc_get_id(@Const
                                               avutil.AVPixFmtDescriptor desc)

Returns:: an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc is not a valid pointer to a pixel format descriptor.

av_pix_fmt_get_chroma_sub_sample
```
@NoException
public static int av_pix_fmt_get_chroma_sub_sample(@Cast(value="AVPixelFormat")
                                               int pix_fmt,
                                               IntPointer h_shift,
                                               IntPointer v_shift)
```
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor. See av_get_chroma_sub_sample() for a function that asserts a valid pixel format instead of returning an error code. Its recommended that you use avcodec_get_chroma_sub_sample unless you do check the return code!

Parameters:
[in] - pix_fmt the pixel format
[out] - h_shift store log2_chroma_w (horizontal/width shift)
[out] - v_shift store log2_chroma_h (vertical/height shift)

Returns:
0 on success, AVERROR(ENOSYS) on invalid or unknown pixel format

av_pix_fmt_get_chroma_sub_sample

@NoException
public static int av_pix_fmt_get_chroma_sub_sample(@Cast(value="AVPixelFormat")
                                               int pix_fmt,
                                               IntBuffer h_shift,
                                               IntBuffer v_shift)

av_pix_fmt_get_chroma_sub_sample

@NoException
public static int av_pix_fmt_get_chroma_sub_sample(@Cast(value="AVPixelFormat")
                                               int pix_fmt,
                                               int[] h_shift,
                                               int[] v_shift)

av_pix_fmt_count_planes

@NoException
public static int av_pix_fmt_count_planes(@Cast(value="AVPixelFormat")
                                      int pix_fmt)

Returns:: number of planes in pix_fmt, a negative AVERROR if pix_fmt is not a valid pixel format.

av_color_range_name

@NoException
@Cast(value="const char*")
public static BytePointer av_color_range_name(@Cast(value="AVColorRange")
                                                    int range)

Returns:: the name for provided color range or NULL if unknown.

av_color_primaries_name

@NoException
@Cast(value="const char*")
public static BytePointer av_color_primaries_name(@Cast(value="AVColorPrimaries")
                                                        int primaries)

Returns:: the name for provided color primaries or NULL if unknown.

av_color_transfer_name

@NoException
@Cast(value="const char*")
public static BytePointer av_color_transfer_name(@Cast(value="AVColorTransferCharacteristic")
                                                       int transfer)

Returns:: the name for provided color transfer or NULL if unknown.

av_color_space_name

@NoException
@Cast(value="const char*")
public static BytePointer av_color_space_name(@Cast(value="AVColorSpace")
                                                    int space)

Returns:: the name for provided color space or NULL if unknown.

av_chroma_location_name

@NoException
@Cast(value="const char*")
public static BytePointer av_chroma_location_name(@Cast(value="AVChromaLocation")
                                                        int location)

Returns:: the name for provided chroma location or NULL if unknown.

av_get_pix_fmt
```
@NoException
@Cast(value="AVPixelFormat")
public static int av_get_pix_fmt(@Cast(value="const char*")
                                       BytePointer name)
```
Return the pixel format corresponding to name. If there is no pixel format with name name, then looks for a pixel format with the name corresponding to the 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.

av_get_pix_fmt

@NoException
@Cast(value="AVPixelFormat")
public static int av_get_pix_fmt(String name)

av_get_pix_fmt_name

@NoException
@Cast(value="const char*")
public static BytePointer av_get_pix_fmt_name(@Cast(value="AVPixelFormat")
                                                    int pix_fmt)

Return the short name for a pixel format, NULL in case pix_fmt is unknown.

See Also:: av_get_pix_fmt(), av_get_pix_fmt_string()

av_get_pix_fmt_string

@NoException
@Cast(value="char*")
public static BytePointer av_get_pix_fmt_string(@Cast(value="char*")
                                                      BytePointer buf,
                                                      int buf_size,
                                                      @Cast(value="AVPixelFormat")
                                                      int pix_fmt)

Print in buf the string corresponding to the pixel format with number pix_fmt, or a header if pix_fmt is negative.

Parameters:: buf - the buffer where to write the string; buf_size - the size of buf; pix_fmt - the number of the pixel format to print the corresponding info string, or a negative value to print the corresponding header.

av_get_pix_fmt_string

@NoException
@Cast(value="char*")
public static ByteBuffer av_get_pix_fmt_string(@Cast(value="char*")
                                                     ByteBuffer buf,
                                                     int buf_size,
                                                     @Cast(value="AVPixelFormat")
                                                     int pix_fmt)

av_get_pix_fmt_string

@NoException
@Cast(value="char*")
public static byte[] av_get_pix_fmt_string(@Cast(value="char*")
                                                 byte[] buf,
                                                 int buf_size,
                                                 @Cast(value="AVPixelFormat")
                                                 int pix_fmt)

av_read_image_line

@NoException
public static void av_read_image_line(@Cast(value="uint16_t*")
                                  ShortPointer dst,
                                  @Cast(value="const uint8_t**")
                                  PointerPointer data,
                                  @Const
                                  IntPointer linesize,
                                  @Const
                                  avutil.AVPixFmtDescriptor desc,
                                  int x,
                                  int y,
                                  int c,
                                  int w,
                                  int read_pal_component)

Read a line from an image, and write the values of the pixel format component c to dst.

Parameters:: data - the array containing the pointers to the planes of the image; linesize - the array containing the linesizes of the image; desc - the pixel format descriptor for the image; x - the horizontal coordinate of the first pixel to read; y - the vertical coordinate of the first pixel to read; w - the width of the line to read, that is the number of values to write to dst; 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.

av_read_image_line

@NoException
public static void av_read_image_line(@Cast(value="uint16_t*")
                                  ShortPointer dst,
                                  @Cast(value="const uint8_t**")@ByPtrPtr
                                  BytePointer data,
                                  @Const
                                  IntPointer linesize,
                                  @Const
                                  avutil.AVPixFmtDescriptor desc,
                                  int x,
                                  int y,
                                  int c,
                                  int w,
                                  int read_pal_component)

av_read_image_line

@NoException
public static void av_read_image_line(@Cast(value="uint16_t*")
                                  ShortBuffer dst,
                                  @Cast(value="const uint8_t**")@ByPtrPtr
                                  ByteBuffer data,
                                  @Const
                                  IntBuffer linesize,
                                  @Const
                                  avutil.AVPixFmtDescriptor desc,
                                  int x,
                                  int y,
                                  int c,
                                  int w,
                                  int read_pal_component)

av_read_image_line

@NoException
public static void av_read_image_line(@Cast(value="uint16_t*")
                                  short[] dst,
                                  @Cast(value="const uint8_t**")@ByPtrPtr
                                  byte[] data,
                                  @Const
                                  int[] linesize,
                                  @Const
                                  avutil.AVPixFmtDescriptor desc,
                                  int x,
                                  int y,
                                  int c,
                                  int w,
                                  int read_pal_component)

av_write_image_line

@NoException
public static void av_write_image_line(@Cast(value="const uint16_t*")
                                   ShortPointer src,
                                   @Cast(value="uint8_t**")
                                   PointerPointer data,
                                   @Const
                                   IntPointer linesize,
                                   @Const
                                   avutil.AVPixFmtDescriptor desc,
                                   int x,
                                   int y,
                                   int c,
                                   int w)

Write the values from src to the pixel format component c of an image line.

Parameters:: src - array containing the values to write; data - the array containing the pointers to the planes of the image to write into. It is supposed to be zeroed.; linesize - the array containing the linesizes of the image; desc - the pixel format descriptor for the image; x - the horizontal coordinate of the first pixel to write; y - the vertical coordinate of the first pixel to write; w - the width of the line to write, that is the number of values to write to the image line

av_write_image_line

@NoException
public static void av_write_image_line(@Cast(value="const uint16_t*")
                                   ShortPointer src,
                                   @Cast(value="uint8_t**")@ByPtrPtr
                                   BytePointer data,
                                   @Const
                                   IntPointer linesize,
                                   @Const
                                   avutil.AVPixFmtDescriptor desc,
                                   int x,
                                   int y,
                                   int c,
                                   int w)

av_write_image_line

@NoException
public static void av_write_image_line(@Cast(value="const uint16_t*")
                                   ShortBuffer src,
                                   @Cast(value="uint8_t**")@ByPtrPtr
                                   ByteBuffer data,
                                   @Const
                                   IntBuffer linesize,
                                   @Const
                                   avutil.AVPixFmtDescriptor desc,
                                   int x,
                                   int y,
                                   int c,
                                   int w)

av_write_image_line

@NoException
public static void av_write_image_line(@Cast(value="const uint16_t*")
                                   short[] src,
                                   @Cast(value="uint8_t**")@ByPtrPtr
                                   byte[] data,
                                   @Const
                                   int[] linesize,
                                   @Const
                                   avutil.AVPixFmtDescriptor desc,
                                   int x,
                                   int y,
                                   int c,
                                   int w)

av_pix_fmt_swap_endianness
```
@NoException
@Cast(value="AVPixelFormat")
public static int av_pix_fmt_swap_endianness(@Cast(value="AVPixelFormat")
                                                   int pix_fmt)
```
Utility function to swap the endianness of a pixel format.

Parameters:
[in] - pix_fmt the pixel format

Returns:
pixel format with swapped endianness if it exists, otherwise AV_PIX_FMT_NONE

av_get_pix_fmt_loss
```
@NoException
public static int av_get_pix_fmt_loss(@Cast(value="AVPixelFormat")
                                  int dst_pix_fmt,
                                  @Cast(value="AVPixelFormat")
                                  int src_pix_fmt,
                                  int has_alpha)
```
Compute what kind of losses will occur when converting from one specific pixel format to another. When converting from one pixel format to another, information loss may occur. For example, when converting from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when converting from some formats to other formats. These losses can involve loss of chroma, but also loss of resolution, loss of color depth, loss due to the color space conversion, loss of the alpha bits or loss due to color quantization. av_get_fix_fmt_loss() informs you about the various types of losses which will occur when converting from one pixel format to another.

Parameters:
[in] - dst_pix_fmt destination pixel format
[in] - src_pix_fmt source pixel format
[in] - has_alpha Whether the source pixel format alpha channel is used.

Returns:
Combination of flags informing you what kind of losses will occur (maximum loss for an invalid dst_pix_fmt).

av_find_best_pix_fmt_of_2
```
@NoException
@Cast(value="AVPixelFormat")
public static int av_find_best_pix_fmt_of_2(@Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt1,
                                                  @Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt2,
                                                  @Cast(value="AVPixelFormat")
                                                  int src_pix_fmt,
                                                  int has_alpha,
                                                  IntPointer loss_ptr)
```
Compute what kind of losses will occur when converting from one specific pixel format to another. When converting from one pixel format to another, information loss may occur. For example, when converting from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when converting from some formats to other formats. These losses can involve loss of chroma, but also loss of resolution, loss of color depth, loss due to the color space conversion, loss of the alpha bits or loss due to color quantization. av_get_fix_fmt_loss() informs you about the various types of losses which will occur when converting from one pixel format to another.

Parameters:
[in] - dst_pix_fmt destination pixel format
[in] - src_pix_fmt source pixel format
[in] - has_alpha Whether the source pixel format alpha channel is used.

Returns:
Combination of flags informing you what kind of losses will occur (maximum loss for an invalid dst_pix_fmt).

av_find_best_pix_fmt_of_2

@NoException
@Cast(value="AVPixelFormat")
public static int av_find_best_pix_fmt_of_2(@Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt1,
                                                  @Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt2,
                                                  @Cast(value="AVPixelFormat")
                                                  int src_pix_fmt,
                                                  int has_alpha,
                                                  IntBuffer loss_ptr)

av_find_best_pix_fmt_of_2

@NoException
@Cast(value="AVPixelFormat")
public static int av_find_best_pix_fmt_of_2(@Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt1,
                                                  @Cast(value="AVPixelFormat")
                                                  int dst_pix_fmt2,
                                                  @Cast(value="AVPixelFormat")
                                                  int src_pix_fmt,
                                                  int has_alpha,
                                                  int[] loss_ptr)

av_image_fill_max_pixsteps
```
@NoException
public static void av_image_fill_max_pixsteps(IntPointer max_pixsteps,
                                          IntPointer max_pixstep_comps,
                                          @Const
                                          avutil.AVPixFmtDescriptor pixdesc)
```
Compute the max pixel step for each plane of an image with a format described by pixdesc. The pixel step is the distance in bytes between the first byte of the group of bytes which describe a pixel component and the first byte of the successive group in the same plane for the same component.

Parameters:
max_pixsteps - an array which is filled with the max pixel step for each plane. Since a plane may contain different pixel components, the computed max_pixsteps[plane] is relative to the component in the plane with the max pixel step.
max_pixstep_comps - an array which is filled with the component for each plane which has the max pixel step. May be NULL.

av_image_fill_max_pixsteps

@NoException
public static void av_image_fill_max_pixsteps(IntBuffer max_pixsteps,
                                          IntBuffer max_pixstep_comps,
                                          @Const
                                          avutil.AVPixFmtDescriptor pixdesc)

av_image_fill_max_pixsteps

@NoException
public static void av_image_fill_max_pixsteps(int[] max_pixsteps,
                                          int[] max_pixstep_comps,
                                          @Const
                                          avutil.AVPixFmtDescriptor pixdesc)

av_image_get_linesize

@NoException
public static int av_image_get_linesize(@Cast(value="AVPixelFormat")
                                    int pix_fmt,
                                    int width,
                                    int plane)

Compute the size of an image line with format pix_fmt and width width for the plane plane.

Returns:: the computed size in bytes

av_image_fill_linesizes

@NoException
public static int av_image_fill_linesizes(IntPointer linesizes,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width)

Fill plane linesizes for an image with pixel format pix_fmt and width width.

Parameters:: linesizes - array to be filled with the linesize for each plane
Returns:: >= 0 in case of success, a negative error code otherwise

av_image_fill_linesizes

@NoException
public static int av_image_fill_linesizes(IntBuffer linesizes,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width)

av_image_fill_linesizes

@NoException
public static int av_image_fill_linesizes(int[] linesizes,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width)

av_image_fill_pointers

@NoException
public static int av_image_fill_pointers(@Cast(value="uint8_t**")
                                     PointerPointer data,
                                     @Cast(value="AVPixelFormat")
                                     int pix_fmt,
                                     int height,
                                     @Cast(value="uint8_t*")
                                     BytePointer ptr,
                                     @Const
                                     IntPointer linesizes)

Fill plane data pointers for an image with pixel format pix_fmt and height height.

Parameters:: data - pointers array to be filled with the pointer for each image plane; ptr - the pointer to a buffer which will contain the image; linesizes - the array containing the linesize for each plane, should be filled by av_image_fill_linesizes()
Returns:: the size in bytes required for the image buffer, a negative error code in case of failure

av_image_fill_pointers

@NoException
public static int av_image_fill_pointers(@Cast(value="uint8_t**")@ByPtrPtr
                                     BytePointer data,
                                     @Cast(value="AVPixelFormat")
                                     int pix_fmt,
                                     int height,
                                     @Cast(value="uint8_t*")
                                     BytePointer ptr,
                                     @Const
                                     IntPointer linesizes)

av_image_fill_pointers

@NoException
public static int av_image_fill_pointers(@Cast(value="uint8_t**")@ByPtrPtr
                                     ByteBuffer data,
                                     @Cast(value="AVPixelFormat")
                                     int pix_fmt,
                                     int height,
                                     @Cast(value="uint8_t*")
                                     ByteBuffer ptr,
                                     @Const
                                     IntBuffer linesizes)

av_image_fill_pointers

@NoException
public static int av_image_fill_pointers(@Cast(value="uint8_t**")@ByPtrPtr
                                     byte[] data,
                                     @Cast(value="AVPixelFormat")
                                     int pix_fmt,
                                     int height,
                                     @Cast(value="uint8_t*")
                                     byte[] ptr,
                                     @Const
                                     int[] linesizes)

av_image_alloc

@NoException
public static int av_image_alloc(@Cast(value="uint8_t**")
                             PointerPointer pointers,
                             IntPointer linesizes,
                             int w,
                             int h,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int align)

Allocate an image with size w and h and pixel format pix_fmt, and fill pointers and linesizes accordingly. The allocated image buffer has to be freed by using av_freep(&pointers[0]).

Parameters:: align - the value to use for buffer size alignment
Returns:: the size in bytes required for the image buffer, a negative error code in case of failure

av_image_alloc

@NoException
public static int av_image_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                             BytePointer pointers,
                             IntPointer linesizes,
                             int w,
                             int h,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int align)

av_image_alloc

@NoException
public static int av_image_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                             ByteBuffer pointers,
                             IntBuffer linesizes,
                             int w,
                             int h,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int align)

av_image_alloc

@NoException
public static int av_image_alloc(@Cast(value="uint8_t**")@ByPtrPtr
                             byte[] pointers,
                             int[] linesizes,
                             int w,
                             int h,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int align)

av_image_copy_plane

@NoException
public static void av_image_copy_plane(@Cast(value="uint8_t*")
                                   BytePointer dst,
                                   int dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   BytePointer src,
                                   int src_linesize,
                                   int bytewidth,
                                   int height)

Copy image plane from src to dst. That is, copy "height" number of lines of "bytewidth" bytes each. The first byte of each successive line is separated by *_linesize bytes. bytewidth must be contained by both absolute values of dst_linesize and src_linesize, otherwise the function behavior is undefined.

Parameters:: dst_linesize - linesize for the image plane in dst; src_linesize - linesize for the image plane in src

av_image_copy_plane

@NoException
public static void av_image_copy_plane(@Cast(value="uint8_t*")
                                   ByteBuffer dst,
                                   int dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   ByteBuffer src,
                                   int src_linesize,
                                   int bytewidth,
                                   int height)

av_image_copy_plane

@NoException
public static void av_image_copy_plane(@Cast(value="uint8_t*")
                                   byte[] dst,
                                   int dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   byte[] src,
                                   int src_linesize,
                                   int bytewidth,
                                   int height)

av_image_copy

@NoException
public static void av_image_copy(@Cast(value="uint8_t**")
                             PointerPointer dst_data,
                             IntPointer dst_linesizes,
                             @Cast(value="const uint8_t**")
                             PointerPointer src_data,
                             @Const
                             IntPointer src_linesizes,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int width,
                             int height)

Copy image in src_data to dst_data.

Parameters:: dst_linesizes - linesizes for the image in dst_data; src_linesizes - linesizes for the image in src_data

av_image_copy

@NoException
public static void av_image_copy(@Cast(value="uint8_t**")@ByPtrPtr
                             BytePointer dst_data,
                             IntPointer dst_linesizes,
                             @Cast(value="const uint8_t**")@ByPtrPtr
                             BytePointer src_data,
                             @Const
                             IntPointer src_linesizes,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int width,
                             int height)

av_image_copy

@NoException
public static void av_image_copy(@Cast(value="uint8_t**")@ByPtrPtr
                             ByteBuffer dst_data,
                             IntBuffer dst_linesizes,
                             @Cast(value="const uint8_t**")@ByPtrPtr
                             ByteBuffer src_data,
                             @Const
                             IntBuffer src_linesizes,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int width,
                             int height)

av_image_copy

@NoException
public static void av_image_copy(@Cast(value="uint8_t**")@ByPtrPtr
                             byte[] dst_data,
                             int[] dst_linesizes,
                             @Cast(value="const uint8_t**")@ByPtrPtr
                             byte[] src_data,
                             @Const
                             int[] src_linesizes,
                             @Cast(value="AVPixelFormat")
                             int pix_fmt,
                             int width,
                             int height)

av_image_fill_arrays
```
@NoException
public static int av_image_fill_arrays(@Cast(value="uint8_t**")
                                   PointerPointer dst_data,
                                   IntPointer dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   BytePointer src,
                                   @Cast(value="AVPixelFormat")
                                   int pix_fmt,
                                   int width,
                                   int height,
                                   int align)
```
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().

Parameters:
dst_data - data pointers to be filled in
dst_linesizes - linesizes for the image in dst_data to be filled in
src - buffer which will contain or contains the actual image data, can be NULL
pix_fmt - the pixel format of the image
width - the width of the image in pixels
height - the height of the image in pixels
align - the value used in src for linesize alignment

Returns:
the size in bytes required for src, a negative error code in case of failure

av_image_fill_arrays

@NoException
public static int av_image_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                   BytePointer dst_data,
                                   IntPointer dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   BytePointer src,
                                   @Cast(value="AVPixelFormat")
                                   int pix_fmt,
                                   int width,
                                   int height,
                                   int align)

av_image_fill_arrays

@NoException
public static int av_image_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                   ByteBuffer dst_data,
                                   IntBuffer dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   ByteBuffer src,
                                   @Cast(value="AVPixelFormat")
                                   int pix_fmt,
                                   int width,
                                   int height,
                                   int align)

av_image_fill_arrays

@NoException
public static int av_image_fill_arrays(@Cast(value="uint8_t**")@ByPtrPtr
                                   byte[] dst_data,
                                   int[] dst_linesize,
                                   @Cast(value="const uint8_t*")
                                   byte[] src,
                                   @Cast(value="AVPixelFormat")
                                   int pix_fmt,
                                   int width,
                                   int height,
                                   int align)

av_image_get_buffer_size

@NoException
public static int av_image_get_buffer_size(@Cast(value="AVPixelFormat")
                                       int pix_fmt,
                                       int width,
                                       int height,
                                       int align)

Return the size in bytes of the amount of data required to store an image with the given parameters.

Parameters:: [in] - align the assumed linesize alignment

av_image_copy_to_buffer

@NoException
public static int av_image_copy_to_buffer(@Cast(value="uint8_t*")
                                      BytePointer dst,
                                      int dst_size,
                                      @Cast(value="const uint8_t*const*")
                                      PointerPointer src_data,
                                      @Const
                                      IntPointer src_linesize,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width,
                                      int height,
                                      int align)

Copy image data from an image into a buffer. av_image_get_buffer_size() can be used to compute the required size for the buffer to fill.

Parameters:: dst - a buffer into which picture data will be copied; dst_size - the size in bytes of dst; src_data - pointers containing the source image data; src_linesizes - linesizes for the image in src_data; pix_fmt - the pixel format of the source image; width - the width of the source image in pixels; height - the height of the source image in pixels; align - the assumed linesize alignment for dst
Returns:: the number of bytes written to dst, or a negative value (error code) on error

av_image_copy_to_buffer

@NoException
public static int av_image_copy_to_buffer(@Cast(value="uint8_t*")
                                      BytePointer dst,
                                      int dst_size,
                                      @Cast(value="const uint8_t*const*")@ByPtrPtr
                                      BytePointer src_data,
                                      @Const
                                      IntPointer src_linesize,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width,
                                      int height,
                                      int align)

av_image_copy_to_buffer

@NoException
public static int av_image_copy_to_buffer(@Cast(value="uint8_t*")
                                      ByteBuffer dst,
                                      int dst_size,
                                      @Cast(value="const uint8_t*const*")@ByPtrPtr
                                      ByteBuffer src_data,
                                      @Const
                                      IntBuffer src_linesize,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width,
                                      int height,
                                      int align)

av_image_copy_to_buffer

@NoException
public static int av_image_copy_to_buffer(@Cast(value="uint8_t*")
                                      byte[] dst,
                                      int dst_size,
                                      @Cast(value="const uint8_t*const*")@ByPtrPtr
                                      byte[] src_data,
                                      @Const
                                      int[] src_linesize,
                                      @Cast(value="AVPixelFormat")
                                      int pix_fmt,
                                      int width,
                                      int height,
                                      int align)

av_image_check_size

@NoException
public static int av_image_check_size(@Cast(value="unsigned int")
                                  int w,
                                  @Cast(value="unsigned int")
                                  int h,
                                  int log_offset,
                                  Pointer log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of the image can be addressed with a signed int.

Parameters:: w - the width of the picture; h - the height of the picture; log_offset - the offset to sum to the log level for logging with log_ctx; log_ctx - the parent logging context, it may be NULL
Returns:: >= 0 if valid, a negative error code otherwise

av_image_check_sar
```
@NoException
public static int av_image_check_sar(@Cast(value="unsigned int")
                                 int w,
                                 @Cast(value="unsigned int")
                                 int h,
                                 @ByVal
                                 avutil.AVRational sar)
```
Check if the given sample aspect ratio of an image is valid. It is considered invalid if the denominator is 0 or if applying the ratio to the image size would make the smaller dimension less than 1. If the sar numerator is 0, it is considered unknown and will return as valid.

Parameters:
w - width of the image
h - height of the image
sar - sample aspect ratio of the image

Returns:
0 if valid, a negative AVERROR code otherwise

av_downmix_info_update_side_data
```
@NoException
public static avutil.AVDownmixInfo av_downmix_info_update_side_data(avutil.AVFrame frame)
```
Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing. If the side data is absent, it is created and added to the frame.

Parameters:
frame - the frame for which the side data is to be obtained or created

Returns:
the AVDownmixInfo structure to be edited by the caller, or NULL if the structure cannot be allocated.

av_stereo3d_alloc
```
@NoException
public static avutil.AVStereo3D av_stereo3d_alloc()
```
Allocate an AVStereo3D structure and set its fields to default values. The resulting struct can be freed using av_freep().

Returns:
An AVStereo3D filled with default values or NULL on failure.

av_stereo3d_create_side_data
```
@NoException
public static avutil.AVStereo3D av_stereo3d_create_side_data(avutil.AVFrame frame)
```
Allocate a complete AVFrameSideData and add it to the frame.

Parameters:
frame - The frame which side data is added to.

Returns:
The AVStereo3D structure to be filled by caller.

av_stereo3d_type_name

@NoException
@Cast(value="const char*")
public static BytePointer av_stereo3d_type_name(@Cast(value="unsigned int")
                                                      int type)

Provide a human-readable name of a given stereo3d type.

Parameters:: type - The input stereo3d type value.
Returns:: The name of the stereo3d value, or "unknown".

av_stereo3d_from_name

@NoException
public static int av_stereo3d_from_name(@Cast(value="const char*")
                                    BytePointer name)

Get the AVStereo3DType form a human-readable name.

Parameters:: type - The input string.
Returns:: The AVStereo3DType value, or -1 if not found.

av_stereo3d_from_name

@NoException
public static int av_stereo3d_from_name(String name)

av_fifo_alloc

@NoException
public static avutil.AVFifoBuffer av_fifo_alloc(@Cast(value="unsigned int")
                                            int size)

Initialize an AVFifoBuffer.

Parameters:: size - of FIFO
Returns:: AVFifoBuffer or NULL in case of memory allocation failure

av_fifo_alloc_array

@NoException
public static avutil.AVFifoBuffer av_fifo_alloc_array(@Cast(value="size_t")
                                                  long nmemb,
                                                  @Cast(value="size_t")
                                                  long size)

Initialize an AVFifoBuffer.

Parameters:: nmemb - number of elements; size - size of the single element
Returns:: AVFifoBuffer or NULL in case of memory allocation failure

av_fifo_free

@NoException
public static void av_fifo_free(avutil.AVFifoBuffer f)

Free an AVFifoBuffer.

Parameters:: f - AVFifoBuffer to free

av_fifo_freep

@NoException
public static void av_fifo_freep(@Cast(value="AVFifoBuffer**")
                             PointerPointer f)

Free an AVFifoBuffer and reset pointer to NULL.

Parameters:: f - AVFifoBuffer to free

av_fifo_freep

@NoException
public static void av_fifo_freep(@ByPtrPtr
                             avutil.AVFifoBuffer f)

av_fifo_reset
```
@NoException
public static void av_fifo_reset(avutil.AVFifoBuffer f)
```
Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.

Parameters:
f - AVFifoBuffer to reset

av_fifo_size
```
@NoException
public static int av_fifo_size(@Const
                           avutil.AVFifoBuffer f)
```
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from it.

Parameters:
f - AVFifoBuffer to read from

Returns:
size

av_fifo_space
```
@NoException
public static int av_fifo_space(@Const
                            avutil.AVFifoBuffer f)
```
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write into it.

Parameters:
f - AVFifoBuffer to write into

Returns:
size

av_fifo_generic_peek_at

@NoException
public static int av_fifo_generic_peek_at(avutil.AVFifoBuffer f,
                                      Pointer dest,
                                      int offset,
                                      int buf_size,
                                      avutil.Func_Pointer_Pointer_int func)

av_fifo_generic_peek

@NoException
public static int av_fifo_generic_peek(avutil.AVFifoBuffer f,
                                   Pointer dest,
                                   int buf_size,
                                   avutil.Func_Pointer_Pointer_int func)

Feed data from an AVFifoBuffer to a user-supplied callback. Similar as av_fifo_gereric_read but without discarding data.

Parameters:: f - AVFifoBuffer to read from; buf_size - number of bytes to read; func - generic read function; dest - data destination

av_fifo_generic_read

@NoException
public static int av_fifo_generic_read(avutil.AVFifoBuffer f,
                                   Pointer dest,
                                   int buf_size,
                                   avutil.Func_Pointer_Pointer_int func)

Feed data from an AVFifoBuffer to a user-supplied callback.

Parameters:: f - AVFifoBuffer to read from; buf_size - number of bytes to read; func - generic read function; dest - data destination

av_fifo_generic_write

@NoException
public static int av_fifo_generic_write(avutil.AVFifoBuffer f,
                                    Pointer src,
                                    int size,
                                    avutil.Int_func_Pointer_Pointer_int func)

av_fifo_realloc2
```
@NoException
public static int av_fifo_realloc2(avutil.AVFifoBuffer f,
                               @Cast(value="unsigned int")
                               int size)
```
Resize an AVFifoBuffer. In case of reallocation failure, the old FIFO is kept unchanged.

Parameters:
f - AVFifoBuffer to resize
size - new AVFifoBuffer size in bytes

Returns:
<0 for failure, >=0 otherwise

av_fifo_grow
```
@NoException
public static int av_fifo_grow(avutil.AVFifoBuffer f,
                           @Cast(value="unsigned int")
                           int additional_space)
```
Enlarge an AVFifoBuffer. In case of reallocation failure, the old FIFO is kept unchanged. The new fifo size may be larger than the requested size.

Parameters:
f - AVFifoBuffer to resize
additional_space - the amount of space in bytes to allocate in addition to av_fifo_size()

Returns:
<0 for failure, >=0 otherwise

av_fifo_drain
```
@NoException
public static void av_fifo_drain(avutil.AVFifoBuffer f,
                             int size)
```
Read and discard the specified amount of data from an AVFifoBuffer.

Parameters:
f - AVFifoBuffer to read from
size - amount of data to read in bytes

av_fifo_peek2
```
@NoException
@Cast(value="uint8_t*")
public static BytePointer av_fifo_peek2(@Const
                                              avutil.AVFifoBuffer f,
                                              int offs)
```
Return a pointer to the data stored in a FIFO buffer at a certain offset. The FIFO buffer is not modified.

Parameters:
f - AVFifoBuffer to peek at, f must be non-NULL
offs - an offset in bytes, its absolute value must be less than the used buffer size or the returned pointer will point outside to the buffer data. The used buffer size can be checked with av_fifo_size().

av_audio_fifo_free

@NoException
public static void av_audio_fifo_free(avutil.AVAudioFifo af)

Free an AVAudioFifo.

Parameters:: af - AVAudioFifo to free

av_audio_fifo_alloc

@NoException
public static avutil.AVAudioFifo av_audio_fifo_alloc(@Cast(value="AVSampleFormat")
                                                 int sample_fmt,
                                                 int channels,
                                                 int nb_samples)

Allocate an AVAudioFifo.

Parameters:: sample_fmt - sample format; channels - number of channels; nb_samples - initial allocation size, in samples
Returns:: newly allocated AVAudioFifo, or NULL on error

av_audio_fifo_realloc
```
@NoException
public static int av_audio_fifo_realloc(avutil.AVAudioFifo af,
                                    int nb_samples)
```
Reallocate an AVAudioFifo.

Parameters:
af - AVAudioFifo to reallocate
nb_samples - new allocation size, in samples

Returns:
0 if OK, or negative AVERROR code on failure

av_audio_fifo_write
```
@NoException
public static int av_audio_fifo_write(avutil.AVAudioFifo af,
                                  @Cast(value="void**")
                                  PointerPointer data,
                                  int nb_samples)
```
Write data to an AVAudioFifo. The AVAudioFifo will be reallocated automatically if the available space is less than nb_samples.

Parameters:
af - AVAudioFifo to write to
data - audio data plane pointers
nb_samples - number of samples to write

Returns:
number of samples actually written, or negative AVERROR code on failure. If successful, the number of samples actually written will always be nb_samples.
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_write

@NoException
public static int av_audio_fifo_write(avutil.AVAudioFifo af,
                                  @Cast(value="void**")@ByPtrPtr
                                  Pointer data,
                                  int nb_samples)

av_audio_fifo_peek
```
@NoException
public static int av_audio_fifo_peek(avutil.AVAudioFifo af,
                                 @Cast(value="void**")
                                 PointerPointer data,
                                 int nb_samples)
```
Peek data from an AVAudioFifo.

Parameters:
af - AVAudioFifo to read from
data - audio data plane pointers
nb_samples - number of samples to peek

Returns:
number of samples actually peek, or negative AVERROR code on failure. The number of samples actually peek will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_peek

@NoException
public static int av_audio_fifo_peek(avutil.AVAudioFifo af,
                                 @Cast(value="void**")@ByPtrPtr
                                 Pointer data,
                                 int nb_samples)

av_audio_fifo_peek_at
```
@NoException
public static int av_audio_fifo_peek_at(avutil.AVAudioFifo af,
                                    @Cast(value="void**")
                                    PointerPointer data,
                                    int nb_samples,
                                    int offset)
```
Peek data from an AVAudioFifo.

Parameters:
af - AVAudioFifo to read from
data - audio data plane pointers
nb_samples - number of samples to peek
offset - offset from current read position

Returns:
number of samples actually peek, or negative AVERROR code on failure. The number of samples actually peek will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_peek_at

@NoException
public static int av_audio_fifo_peek_at(avutil.AVAudioFifo af,
                                    @Cast(value="void**")@ByPtrPtr
                                    Pointer data,
                                    int nb_samples,
                                    int offset)

av_audio_fifo_read
```
@NoException
public static int av_audio_fifo_read(avutil.AVAudioFifo af,
                                 @Cast(value="void**")
                                 PointerPointer data,
                                 int nb_samples)
```
Read data from an AVAudioFifo.

Parameters:
af - AVAudioFifo to read from
data - audio data plane pointers
nb_samples - number of samples to read

Returns:
number of samples actually read, or negative AVERROR code on failure. The number of samples actually read will not be greater than nb_samples, and will only be less than nb_samples if av_audio_fifo_size is less than nb_samples.
See Also:
AVSampleFormat The documentation for AVSampleFormat describes the data layout.

av_audio_fifo_read

@NoException
public static int av_audio_fifo_read(avutil.AVAudioFifo af,
                                 @Cast(value="void**")@ByPtrPtr
                                 Pointer data,
                                 int nb_samples)

av_audio_fifo_drain
```
@NoException
public static int av_audio_fifo_drain(avutil.AVAudioFifo af,
                                  int nb_samples)
```
Drain data from an AVAudioFifo. Removes the data without reading it.

Parameters:
af - AVAudioFifo to drain
nb_samples - number of samples to drain

Returns:
0 if OK, or negative AVERROR code on failure

av_audio_fifo_reset
```
@NoException
public static void av_audio_fifo_reset(avutil.AVAudioFifo af)
```
Reset the AVAudioFifo buffer. This empties all data in the buffer.

Parameters:
af - AVAudioFifo to reset

av_audio_fifo_size
```
@NoException
public static int av_audio_fifo_size(avutil.AVAudioFifo af)
```
Get the current number of samples in the AVAudioFifo available for reading.

Parameters:
af - the AVAudioFifo to query

Returns:
number of samples available for reading

av_audio_fifo_space
```
@NoException
public static int av_audio_fifo_space(avutil.AVAudioFifo af)
```
Get the current number of samples in the AVAudioFifo available for writing.

Parameters:
af - the AVAudioFifo to query

Returns:
number of samples available for writing

logCallback

public static avutil.LogCallback logCallback()

logCallback

public static void logCallback(avutil.LogCallback logCallback)

log_callback

@NoException
public static void log_callback(Pointer ptr,
                            int level,
                            @Cast(value="const char*")
                            BytePointer fmt,
                            @ByVal@Cast(value="va_list*")
                            Pointer vl)

log_callback

@NoException
public static void log_callback(Pointer ptr,
                            int level,
                            String fmt,
                            @ByVal@Cast(value="va_list*")
                            Pointer vl)

setLogCallback

@NoException
public static void setLogCallback(avutil.LogCallback lc)

Class avutil

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.presets.avutil

Methods inherited from class java.lang.Object

Field Detail

AVMEDIA_TYPE_UNKNOWN

AVMEDIA_TYPE_VIDEO

AVMEDIA_TYPE_AUDIO

AVMEDIA_TYPE_DATA

AVMEDIA_TYPE_SUBTITLE

AVMEDIA_TYPE_ATTACHMENT

AVMEDIA_TYPE_NB

FF_LAMBDA_SHIFT

FF_LAMBDA_SCALE

FF_QP2LAMBDA

FF_LAMBDA_MAX

FF_QUALITY_SCALE

AV_NOPTS_VALUE

AV_TIME_BASE

AV_PICTURE_TYPE_NONE

AV_PICTURE_TYPE_I

AV_PICTURE_TYPE_P

AV_PICTURE_TYPE_B

AV_PICTURE_TYPE_S

AV_PICTURE_TYPE_SI

AV_PICTURE_TYPE_SP

AV_PICTURE_TYPE_BI

AVERROR_BSF_NOT_FOUND

AVERROR_BUG

AVERROR_BUFFER_TOO_SMALL

AVERROR_DECODER_NOT_FOUND

AVERROR_DEMUXER_NOT_FOUND

AVERROR_ENCODER_NOT_FOUND

AVERROR_EOF

AVERROR_EXIT

AVERROR_EXTERNAL

AVERROR_FILTER_NOT_FOUND

AVERROR_INVALIDDATA

AVERROR_MUXER_NOT_FOUND

AVERROR_OPTION_NOT_FOUND

AVERROR_PATCHWELCOME

AVERROR_PROTOCOL_NOT_FOUND

AVERROR_STREAM_NOT_FOUND

AVERROR_BUG2

AVERROR_UNKNOWN

AVERROR_EXPERIMENTAL

AVERROR_INPUT_CHANGED

AVERROR_OUTPUT_CHANGED

AVERROR_HTTP_BAD_REQUEST

AVERROR_HTTP_UNAUTHORIZED

AVERROR_HTTP_FORBIDDEN

AVERROR_HTTP_NOT_FOUND

AVERROR_HTTP_OTHER_4XX

AVERROR_HTTP_SERVER_ERROR

AV_ERROR_MAX_STRING_SIZE

M_E

M_LN2

M_LN10

M_LOG2_10

M_PHI

M_PI

M_PI_2

M_SQRT1_2

M_SQRT2

NAN

INFINITY

AV_ROUND_ZERO

AV_ROUND_INF

AV_ROUND_DOWN

AV_ROUND_UP

AV_ROUND_NEAR_INF

AV_ROUND_PASS_MINMAX

AV_CLASS_CATEGORY_NA

AV_CLASS_CATEGORY_INPUT

AV_CLASS_CATEGORY_OUTPUT

AV_CLASS_CATEGORY_MUXER

AV_CLASS_CATEGORY_DEMUXER