enums.gen.go

package ffmpeg

import "unsafe"

// #include <libavcodec/avcodec.h>
// #include <libavcodec/bsf.h>
// #include <libavcodec/codec.h>
// #include <libavcodec/codec_desc.h>
// #include <libavcodec/codec_id.h>
// #include <libavcodec/codec_par.h>
// #include <libavcodec/defs.h>
// #include <libavcodec/packet.h>
// #include <libavcodec/version.h>
// #include <libavcodec/version_major.h>
// #include <libavdevice/avdevice.h>
// #include <libavdevice/version.h>
// #include <libavdevice/version_major.h>
// #include <libavfilter/avfilter.h>
// #include <libavfilter/buffersink.h>
// #include <libavfilter/buffersrc.h>
// #include <libavfilter/version.h>
// #include <libavfilter/version_major.h>
// #include <libavformat/avformat.h>
// #include <libavformat/avio.h>
// #include <libavformat/version.h>
// #include <libavformat/version_major.h>
// #include <libavutil/adler32.h>
// #include <libavutil/aes.h>
// #include <libavutil/aes_ctr.h>
// #include <libavutil/ambient_viewing_environment.h>
// #include <libavutil/audio_fifo.h>
// #include <libavutil/avassert.h>
// #include <libavutil/avconfig.h>
// #include <libavutil/avstring.h>
// #include <libavutil/avutil.h>
// #include <libavutil/base64.h>
// #include <libavutil/blowfish.h>
// #include <libavutil/bprint.h>
// #include <libavutil/bswap.h>
// #include <libavutil/buffer.h>
// #include <libavutil/camellia.h>
// #include <libavutil/cast5.h>
// #include <libavutil/channel_layout.h>
// #include <libavutil/common.h>
// #include <libavutil/container_fifo.h>
// #include <libavutil/cpu.h>
// #include <libavutil/crc.h>
// #include <libavutil/csp.h>
// #include <libavutil/des.h>
// #include <libavutil/detection_bbox.h>
// #include <libavutil/dict.h>
// #include <libavutil/display.h>
// #include <libavutil/dovi_meta.h>
// #include <libavutil/downmix_info.h>
// #include <libavutil/encryption_info.h>
// #include <libavutil/error.h>
// #include <libavutil/eval.h>
// #include <libavutil/executor.h>
// #include <libavutil/ffversion.h>
// #include <libavutil/fifo.h>
// #include <libavutil/file.h>
// #include <libavutil/film_grain_params.h>
// #include <libavutil/frame.h>
// #include <libavutil/hash.h>
// #include <libavutil/hdr_dynamic_metadata.h>
// #include <libavutil/hdr_dynamic_vivid_metadata.h>
// #include <libavutil/hmac.h>
// #include <libavutil/hwcontext.h>
// #include <libavutil/iamf.h>
// #include <libavutil/imgutils.h>
// #include <libavutil/intfloat.h>
// #include <libavutil/lfg.h>
// #include <libavutil/log.h>
// #include <libavutil/lzo.h>
// #include <libavutil/macros.h>
// #include <libavutil/mastering_display_metadata.h>
// #include <libavutil/mathematics.h>
// #include <libavutil/mem.h>
// #include <libavutil/motion_vector.h>
// #include <libavutil/murmur3.h>
// #include <libavutil/opt.h>
// #include <libavutil/parseutils.h>
// #include <libavutil/pixdesc.h>
// #include <libavutil/pixelutils.h>
// #include <libavutil/pixfmt.h>
// #include <libavutil/random_seed.h>
// #include <libavutil/rational.h>
// #include <libavutil/rc4.h>
// #include <libavutil/replaygain.h>
// #include <libavutil/ripemd.h>
// #include <libavutil/samplefmt.h>
// #include <libavutil/sha.h>
// #include <libavutil/sha512.h>
// #include <libavutil/spherical.h>
// #include <libavutil/stereo3d.h>
// #include <libavutil/tdrdi.h>
// #include <libavutil/tea.h>
// #include <libavutil/threadmessage.h>
// #include <libavutil/time.h>
// #include <libavutil/timecode.h>
// #include <libavutil/timestamp.h>
// #include <libavutil/tree.h>
// #include <libavutil/twofish.h>
// #include <libavutil/tx.h>
// #include <libavutil/uuid.h>
// #include <libavutil/version.h>
// #include <libavutil/video_enc_params.h>
// #include <libavutil/video_hint.h>
// #include <libavutil/xtea.h>
// #include <libswresample/version.h>
// #include <libswresample/version_major.h>
// #include <libswresample/swresample.h>
// #include <libswscale/version.h>
// #include <libswscale/version_major.h>
// #include <libswscale/swscale.h>
import "C"

// --- Enum AVSubtitleType ---

// AVSubtitleType wraps AVSubtitleType.
type AVSubtitleType C.enum_AVSubtitleType

const SizeOfAVSubtitleType = C.sizeof_enum_AVSubtitleType

func ToAVSubtitleTypeArray(ptr unsafe.Pointer) *Array[AVSubtitleType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVSubtitleType]{
		elemSize: SizeOfAVSubtitleType,
		loadPtr: func(pointer unsafe.Pointer) AVSubtitleType {
			ptr := (*AVSubtitleType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVSubtitleType) {
			ptr := (*AVSubtitleType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVSubtitleTypeArray(size uint64) *Array[AVSubtitleType] {
	return ToAVSubtitleTypeArray(AVCalloc(size, SizeOfAVSubtitleType))
}

const (
	// SubtitleNone wraps SUBTITLE_NONE.
	SubtitleNone AVSubtitleType = C.SUBTITLE_NONE
	// SubtitleBitmap wraps SUBTITLE_BITMAP.
	//
	//	A bitmap, pict will be set
	SubtitleBitmap AVSubtitleType = C.SUBTITLE_BITMAP
	// SubtitleText wraps SUBTITLE_TEXT.
	/*
	   Plain text, the text field must be set by the decoder and is
	   authoritative. ass and pict fields may contain approximations.
	*/
	SubtitleText AVSubtitleType = C.SUBTITLE_TEXT
	// SubtitleAss wraps SUBTITLE_ASS.
	/*
	   Formatted text, the ass field must be set by the decoder and is
	   authoritative. pict and text fields may contain approximations.
	*/
	SubtitleAss AVSubtitleType = C.SUBTITLE_ASS
)

// --- Enum AVCodecConfig ---

// AVCodecConfig wraps AVCodecConfig.
type AVCodecConfig C.enum_AVCodecConfig

const SizeOfAVCodecConfig = C.sizeof_enum_AVCodecConfig

func ToAVCodecConfigArray(ptr unsafe.Pointer) *Array[AVCodecConfig] {
	if ptr == nil {
		return nil
	}

	return &Array[AVCodecConfig]{
		elemSize: SizeOfAVCodecConfig,
		loadPtr: func(pointer unsafe.Pointer) AVCodecConfig {
			ptr := (*AVCodecConfig)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVCodecConfig) {
			ptr := (*AVCodecConfig)(pointer)
			*ptr = value
		},
	}
}

func AllocAVCodecConfigArray(size uint64) *Array[AVCodecConfig] {
	return ToAVCodecConfigArray(AVCalloc(size, SizeOfAVCodecConfig))
}

const (
	// AVCodecConfigPixFormat wraps AV_CODEC_CONFIG_PIX_FORMAT.
	//
	//	AVPixelFormat, terminated by AV_PIX_FMT_NONE
	AVCodecConfigPixFormat AVCodecConfig = C.AV_CODEC_CONFIG_PIX_FORMAT
	// AVCodecConfigFrameRate wraps AV_CODEC_CONFIG_FRAME_RATE.
	//
	//	AVRational, terminated by {0, 0}
	AVCodecConfigFrameRate AVCodecConfig = C.AV_CODEC_CONFIG_FRAME_RATE
	// AVCodecConfigSampleRate wraps AV_CODEC_CONFIG_SAMPLE_RATE.
	//
	//	int, terminated by 0
	AVCodecConfigSampleRate AVCodecConfig = C.AV_CODEC_CONFIG_SAMPLE_RATE
	// AVCodecConfigSampleFormat wraps AV_CODEC_CONFIG_SAMPLE_FORMAT.
	//
	//	AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE
	AVCodecConfigSampleFormat AVCodecConfig = C.AV_CODEC_CONFIG_SAMPLE_FORMAT
	// AVCodecConfigChannelLayout wraps AV_CODEC_CONFIG_CHANNEL_LAYOUT.
	//
	//	AVChannelLayout, terminated by {0}
	AVCodecConfigChannelLayout AVCodecConfig = C.AV_CODEC_CONFIG_CHANNEL_LAYOUT
	// AVCodecConfigColorRange wraps AV_CODEC_CONFIG_COLOR_RANGE.
	//
	//	AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED
	AVCodecConfigColorRange AVCodecConfig = C.AV_CODEC_CONFIG_COLOR_RANGE
	// AVCodecConfigColorSpace wraps AV_CODEC_CONFIG_COLOR_SPACE.
	//
	//	AVColorSpace, terminated by AVCOL_SPC_UNSPECIFIED
	AVCodecConfigColorSpace AVCodecConfig = C.AV_CODEC_CONFIG_COLOR_SPACE
)

// --- Enum AVPictureStructure ---

// AVPictureStructure wraps AVPictureStructure.
type AVPictureStructure C.enum_AVPictureStructure

const SizeOfAVPictureStructure = C.sizeof_enum_AVPictureStructure

func ToAVPictureStructureArray(ptr unsafe.Pointer) *Array[AVPictureStructure] {
	if ptr == nil {
		return nil
	}

	return &Array[AVPictureStructure]{
		elemSize: SizeOfAVPictureStructure,
		loadPtr: func(pointer unsafe.Pointer) AVPictureStructure {
			ptr := (*AVPictureStructure)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVPictureStructure) {
			ptr := (*AVPictureStructure)(pointer)
			*ptr = value
		},
	}
}

func AllocAVPictureStructureArray(size uint64) *Array[AVPictureStructure] {
	return ToAVPictureStructureArray(AVCalloc(size, SizeOfAVPictureStructure))
}

const (
	// AVPictureStructureUnknown wraps AV_PICTURE_STRUCTURE_UNKNOWN.
	//
	//	unknown
	AVPictureStructureUnknown AVPictureStructure = C.AV_PICTURE_STRUCTURE_UNKNOWN
	// AVPictureStructureTopField wraps AV_PICTURE_STRUCTURE_TOP_FIELD.
	//
	//	coded as top field
	AVPictureStructureTopField AVPictureStructure = C.AV_PICTURE_STRUCTURE_TOP_FIELD
	// AVPictureStructureBottomField wraps AV_PICTURE_STRUCTURE_BOTTOM_FIELD.
	//
	//	coded as bottom field
	AVPictureStructureBottomField AVPictureStructure = C.AV_PICTURE_STRUCTURE_BOTTOM_FIELD
	// AVPictureStructureFrame wraps AV_PICTURE_STRUCTURE_FRAME.
	//
	//	coded as frame
	AVPictureStructureFrame AVPictureStructure = C.AV_PICTURE_STRUCTURE_FRAME
)

// --- Enum AVCodecID ---

// AVCodecID wraps AVCodecID.
/*
  Identify the syntax and semantics of the bitstream.
  The principle is roughly:
  Two decoders with the same ID can decode the same streams.
  Two encoders with the same ID can encode compatible streams.
  There may be slight deviations from the principle due to implementation
  details.

  If you add a codec ID to this list, add it so that
  1. no value of an existing codec ID changes (that would break ABI),
  2. it is as close as possible to similar codecs

  After adding new codec IDs, do not forget to add an entry to the codec
  descriptor list and bump libavcodec minor version.
*/
type AVCodecID C.enum_AVCodecID

const SizeOfAVCodecID = C.sizeof_enum_AVCodecID

func ToAVCodecIDArray(ptr unsafe.Pointer) *Array[AVCodecID] {
	if ptr == nil {
		return nil
	}

	return &Array[AVCodecID]{
		elemSize: SizeOfAVCodecID,
		loadPtr: func(pointer unsafe.Pointer) AVCodecID {
			ptr := (*AVCodecID)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVCodecID) {
			ptr := (*AVCodecID)(pointer)
			*ptr = value
		},
	}
}

func AllocAVCodecIDArray(size uint64) *Array[AVCodecID] {
	return ToAVCodecIDArray(AVCalloc(size, SizeOfAVCodecID))
}

const (
	// AVCodecIdNone wraps AV_CODEC_ID_NONE.
	AVCodecIdNone AVCodecID = C.AV_CODEC_ID_NONE
	// AVCodecIdMpeg1Video wraps AV_CODEC_ID_MPEG1VIDEO.
	//
	//	video codecs
	AVCodecIdMpeg1Video AVCodecID = C.AV_CODEC_ID_MPEG1VIDEO
	// AVCodecIdMpeg2Video wraps AV_CODEC_ID_MPEG2VIDEO.
	//
	//	preferred ID for MPEG-1/2 video decoding
	AVCodecIdMpeg2Video AVCodecID = C.AV_CODEC_ID_MPEG2VIDEO
	// AVCodecIdH261 wraps AV_CODEC_ID_H261.
	AVCodecIdH261 AVCodecID = C.AV_CODEC_ID_H261
	// AVCodecIdH263 wraps AV_CODEC_ID_H263.
	AVCodecIdH263 AVCodecID = C.AV_CODEC_ID_H263
	// AVCodecIdRv10 wraps AV_CODEC_ID_RV10.
	AVCodecIdRv10 AVCodecID = C.AV_CODEC_ID_RV10
	// AVCodecIdRv20 wraps AV_CODEC_ID_RV20.
	AVCodecIdRv20 AVCodecID = C.AV_CODEC_ID_RV20
	// AVCodecIdMjpeg wraps AV_CODEC_ID_MJPEG.
	AVCodecIdMjpeg AVCodecID = C.AV_CODEC_ID_MJPEG
	// AVCodecIdMjpegb wraps AV_CODEC_ID_MJPEGB.
	AVCodecIdMjpegb AVCodecID = C.AV_CODEC_ID_MJPEGB
	// AVCodecIdLjpeg wraps AV_CODEC_ID_LJPEG.
	AVCodecIdLjpeg AVCodecID = C.AV_CODEC_ID_LJPEG
	// AVCodecIdSp5X wraps AV_CODEC_ID_SP5X.
	AVCodecIdSp5X AVCodecID = C.AV_CODEC_ID_SP5X
	// AVCodecIdJpegls wraps AV_CODEC_ID_JPEGLS.
	AVCodecIdJpegls AVCodecID = C.AV_CODEC_ID_JPEGLS
	// AVCodecIdMpeg4 wraps AV_CODEC_ID_MPEG4.
	AVCodecIdMpeg4 AVCodecID = C.AV_CODEC_ID_MPEG4
	// AVCodecIdRawvideo wraps AV_CODEC_ID_RAWVIDEO.
	AVCodecIdRawvideo AVCodecID = C.AV_CODEC_ID_RAWVIDEO
	// AVCodecIdMsmpeg4V1 wraps AV_CODEC_ID_MSMPEG4V1.
	AVCodecIdMsmpeg4V1 AVCodecID = C.AV_CODEC_ID_MSMPEG4V1
	// AVCodecIdMsmpeg4V2 wraps AV_CODEC_ID_MSMPEG4V2.
	AVCodecIdMsmpeg4V2 AVCodecID = C.AV_CODEC_ID_MSMPEG4V2
	// AVCodecIdMsmpeg4V3 wraps AV_CODEC_ID_MSMPEG4V3.
	AVCodecIdMsmpeg4V3 AVCodecID = C.AV_CODEC_ID_MSMPEG4V3
	// AVCodecIdWmv1 wraps AV_CODEC_ID_WMV1.
	AVCodecIdWmv1 AVCodecID = C.AV_CODEC_ID_WMV1
	// AVCodecIdWmv2 wraps AV_CODEC_ID_WMV2.
	AVCodecIdWmv2 AVCodecID = C.AV_CODEC_ID_WMV2
	// AVCodecIdH263P wraps AV_CODEC_ID_H263P.
	AVCodecIdH263P AVCodecID = C.AV_CODEC_ID_H263P
	// AVCodecIdH263I wraps AV_CODEC_ID_H263I.
	AVCodecIdH263I AVCodecID = C.AV_CODEC_ID_H263I
	// AVCodecIdFlv1 wraps AV_CODEC_ID_FLV1.
	AVCodecIdFlv1 AVCodecID = C.AV_CODEC_ID_FLV1
	// AVCodecIdSvq1 wraps AV_CODEC_ID_SVQ1.
	AVCodecIdSvq1 AVCodecID = C.AV_CODEC_ID_SVQ1
	// AVCodecIdSvq3 wraps AV_CODEC_ID_SVQ3.
	AVCodecIdSvq3 AVCodecID = C.AV_CODEC_ID_SVQ3
	// AVCodecIdDvvideo wraps AV_CODEC_ID_DVVIDEO.
	AVCodecIdDvvideo AVCodecID = C.AV_CODEC_ID_DVVIDEO
	// AVCodecIdHuffyuv wraps AV_CODEC_ID_HUFFYUV.
	AVCodecIdHuffyuv AVCodecID = C.AV_CODEC_ID_HUFFYUV
	// AVCodecIdCyuv wraps AV_CODEC_ID_CYUV.
	AVCodecIdCyuv AVCodecID = C.AV_CODEC_ID_CYUV
	// AVCodecIdH264 wraps AV_CODEC_ID_H264.
	AVCodecIdH264 AVCodecID = C.AV_CODEC_ID_H264
	// AVCodecIdIndeo3 wraps AV_CODEC_ID_INDEO3.
	AVCodecIdIndeo3 AVCodecID = C.AV_CODEC_ID_INDEO3
	// AVCodecIdVp3 wraps AV_CODEC_ID_VP3.
	AVCodecIdVp3 AVCodecID = C.AV_CODEC_ID_VP3
	// AVCodecIdTheora wraps AV_CODEC_ID_THEORA.
	AVCodecIdTheora AVCodecID = C.AV_CODEC_ID_THEORA
	// AVCodecIdAsv1 wraps AV_CODEC_ID_ASV1.
	AVCodecIdAsv1 AVCodecID = C.AV_CODEC_ID_ASV1
	// AVCodecIdAsv2 wraps AV_CODEC_ID_ASV2.
	AVCodecIdAsv2 AVCodecID = C.AV_CODEC_ID_ASV2
	// AVCodecIdFFV1 wraps AV_CODEC_ID_FFV1.
	AVCodecIdFFV1 AVCodecID = C.AV_CODEC_ID_FFV1
	// AVCodecId4Xm wraps AV_CODEC_ID_4XM.
	AVCodecId4Xm AVCodecID = C.AV_CODEC_ID_4XM
	// AVCodecIdVcr1 wraps AV_CODEC_ID_VCR1.
	AVCodecIdVcr1 AVCodecID = C.AV_CODEC_ID_VCR1
	// AVCodecIdCljr wraps AV_CODEC_ID_CLJR.
	AVCodecIdCljr AVCodecID = C.AV_CODEC_ID_CLJR
	// AVCodecIdMdec wraps AV_CODEC_ID_MDEC.
	AVCodecIdMdec AVCodecID = C.AV_CODEC_ID_MDEC
	// AVCodecIdRoq wraps AV_CODEC_ID_ROQ.
	AVCodecIdRoq AVCodecID = C.AV_CODEC_ID_ROQ
	// AVCodecIdInterplayVideo wraps AV_CODEC_ID_INTERPLAY_VIDEO.
	AVCodecIdInterplayVideo AVCodecID = C.AV_CODEC_ID_INTERPLAY_VIDEO
	// AVCodecIdXanWc3 wraps AV_CODEC_ID_XAN_WC3.
	AVCodecIdXanWc3 AVCodecID = C.AV_CODEC_ID_XAN_WC3
	// AVCodecIdXanWc4 wraps AV_CODEC_ID_XAN_WC4.
	AVCodecIdXanWc4 AVCodecID = C.AV_CODEC_ID_XAN_WC4
	// AVCodecIdRpza wraps AV_CODEC_ID_RPZA.
	AVCodecIdRpza AVCodecID = C.AV_CODEC_ID_RPZA
	// AVCodecIdCinepak wraps AV_CODEC_ID_CINEPAK.
	AVCodecIdCinepak AVCodecID = C.AV_CODEC_ID_CINEPAK
	// AVCodecIdWsVqa wraps AV_CODEC_ID_WS_VQA.
	AVCodecIdWsVqa AVCodecID = C.AV_CODEC_ID_WS_VQA
	// AVCodecIdMsrle wraps AV_CODEC_ID_MSRLE.
	AVCodecIdMsrle AVCodecID = C.AV_CODEC_ID_MSRLE
	// AVCodecIdMsvideo1 wraps AV_CODEC_ID_MSVIDEO1.
	AVCodecIdMsvideo1 AVCodecID = C.AV_CODEC_ID_MSVIDEO1
	// AVCodecIdIdcin wraps AV_CODEC_ID_IDCIN.
	AVCodecIdIdcin AVCodecID = C.AV_CODEC_ID_IDCIN
	// AVCodecId8Bps wraps AV_CODEC_ID_8BPS.
	AVCodecId8Bps AVCodecID = C.AV_CODEC_ID_8BPS
	// AVCodecIdSmc wraps AV_CODEC_ID_SMC.
	AVCodecIdSmc AVCodecID = C.AV_CODEC_ID_SMC
	// AVCodecIdFlic wraps AV_CODEC_ID_FLIC.
	AVCodecIdFlic AVCodecID = C.AV_CODEC_ID_FLIC
	// AVCodecIdTruemotion1 wraps AV_CODEC_ID_TRUEMOTION1.
	AVCodecIdTruemotion1 AVCodecID = C.AV_CODEC_ID_TRUEMOTION1
	// AVCodecIdVmdvideo wraps AV_CODEC_ID_VMDVIDEO.
	AVCodecIdVmdvideo AVCodecID = C.AV_CODEC_ID_VMDVIDEO
	// AVCodecIdMszh wraps AV_CODEC_ID_MSZH.
	AVCodecIdMszh AVCodecID = C.AV_CODEC_ID_MSZH
	// AVCodecIdZlib wraps AV_CODEC_ID_ZLIB.
	AVCodecIdZlib AVCodecID = C.AV_CODEC_ID_ZLIB
	// AVCodecIdQtrle wraps AV_CODEC_ID_QTRLE.
	AVCodecIdQtrle AVCodecID = C.AV_CODEC_ID_QTRLE
	// AVCodecIdTscc wraps AV_CODEC_ID_TSCC.
	AVCodecIdTscc AVCodecID = C.AV_CODEC_ID_TSCC
	// AVCodecIdUlti wraps AV_CODEC_ID_ULTI.
	AVCodecIdUlti AVCodecID = C.AV_CODEC_ID_ULTI
	// AVCodecIdQdraw wraps AV_CODEC_ID_QDRAW.
	AVCodecIdQdraw AVCodecID = C.AV_CODEC_ID_QDRAW
	// AVCodecIdVixl wraps AV_CODEC_ID_VIXL.
	AVCodecIdVixl AVCodecID = C.AV_CODEC_ID_VIXL
	// AVCodecIdQpeg wraps AV_CODEC_ID_QPEG.
	AVCodecIdQpeg AVCodecID = C.AV_CODEC_ID_QPEG
	// AVCodecIdPng wraps AV_CODEC_ID_PNG.
	AVCodecIdPng AVCodecID = C.AV_CODEC_ID_PNG
	// AVCodecIdPpm wraps AV_CODEC_ID_PPM.
	AVCodecIdPpm AVCodecID = C.AV_CODEC_ID_PPM
	// AVCodecIdPbm wraps AV_CODEC_ID_PBM.
	AVCodecIdPbm AVCodecID = C.AV_CODEC_ID_PBM
	// AVCodecIdPgm wraps AV_CODEC_ID_PGM.
	AVCodecIdPgm AVCodecID = C.AV_CODEC_ID_PGM
	// AVCodecIdPgmyuv wraps AV_CODEC_ID_PGMYUV.
	AVCodecIdPgmyuv AVCodecID = C.AV_CODEC_ID_PGMYUV
	// AVCodecIdPam wraps AV_CODEC_ID_PAM.
	AVCodecIdPam AVCodecID = C.AV_CODEC_ID_PAM
	// AVCodecIdFFVhuff wraps AV_CODEC_ID_FFVHUFF.
	AVCodecIdFFVhuff AVCodecID = C.AV_CODEC_ID_FFVHUFF
	// AVCodecIdRv30 wraps AV_CODEC_ID_RV30.
	AVCodecIdRv30 AVCodecID = C.AV_CODEC_ID_RV30
	// AVCodecIdRv40 wraps AV_CODEC_ID_RV40.
	AVCodecIdRv40 AVCodecID = C.AV_CODEC_ID_RV40
	// AVCodecIdVc1 wraps AV_CODEC_ID_VC1.
	AVCodecIdVc1 AVCodecID = C.AV_CODEC_ID_VC1
	// AVCodecIdWmv3 wraps AV_CODEC_ID_WMV3.
	AVCodecIdWmv3 AVCodecID = C.AV_CODEC_ID_WMV3
	// AVCodecIdLoco wraps AV_CODEC_ID_LOCO.
	AVCodecIdLoco AVCodecID = C.AV_CODEC_ID_LOCO
	// AVCodecIdWnv1 wraps AV_CODEC_ID_WNV1.
	AVCodecIdWnv1 AVCodecID = C.AV_CODEC_ID_WNV1
	// AVCodecIdAasc wraps AV_CODEC_ID_AASC.
	AVCodecIdAasc AVCodecID = C.AV_CODEC_ID_AASC
	// AVCodecIdIndeo2 wraps AV_CODEC_ID_INDEO2.
	AVCodecIdIndeo2 AVCodecID = C.AV_CODEC_ID_INDEO2
	// AVCodecIdFraps wraps AV_CODEC_ID_FRAPS.
	AVCodecIdFraps AVCodecID = C.AV_CODEC_ID_FRAPS
	// AVCodecIdTruemotion2 wraps AV_CODEC_ID_TRUEMOTION2.
	AVCodecIdTruemotion2 AVCodecID = C.AV_CODEC_ID_TRUEMOTION2
	// AVCodecIdBmp wraps AV_CODEC_ID_BMP.
	AVCodecIdBmp AVCodecID = C.AV_CODEC_ID_BMP
	// AVCodecIdCscd wraps AV_CODEC_ID_CSCD.
	AVCodecIdCscd AVCodecID = C.AV_CODEC_ID_CSCD
	// AVCodecIdMmvideo wraps AV_CODEC_ID_MMVIDEO.
	AVCodecIdMmvideo AVCodecID = C.AV_CODEC_ID_MMVIDEO
	// AVCodecIdZmbv wraps AV_CODEC_ID_ZMBV.
	AVCodecIdZmbv AVCodecID = C.AV_CODEC_ID_ZMBV
	// AVCodecIdAVS wraps AV_CODEC_ID_AVS.
	AVCodecIdAVS AVCodecID = C.AV_CODEC_ID_AVS
	// AVCodecIdSmackvideo wraps AV_CODEC_ID_SMACKVIDEO.
	AVCodecIdSmackvideo AVCodecID = C.AV_CODEC_ID_SMACKVIDEO
	// AVCodecIdNuv wraps AV_CODEC_ID_NUV.
	AVCodecIdNuv AVCodecID = C.AV_CODEC_ID_NUV
	// AVCodecIdKmvc wraps AV_CODEC_ID_KMVC.
	AVCodecIdKmvc AVCodecID = C.AV_CODEC_ID_KMVC
	// AVCodecIdFlashsv wraps AV_CODEC_ID_FLASHSV.
	AVCodecIdFlashsv AVCodecID = C.AV_CODEC_ID_FLASHSV
	// AVCodecIdCavs wraps AV_CODEC_ID_CAVS.
	AVCodecIdCavs AVCodecID = C.AV_CODEC_ID_CAVS
	// AVCodecIdJpeg2000 wraps AV_CODEC_ID_JPEG2000.
	AVCodecIdJpeg2000 AVCodecID = C.AV_CODEC_ID_JPEG2000
	// AVCodecIdVmnc wraps AV_CODEC_ID_VMNC.
	AVCodecIdVmnc AVCodecID = C.AV_CODEC_ID_VMNC
	// AVCodecIdVp5 wraps AV_CODEC_ID_VP5.
	AVCodecIdVp5 AVCodecID = C.AV_CODEC_ID_VP5
	// AVCodecIdVp6 wraps AV_CODEC_ID_VP6.
	AVCodecIdVp6 AVCodecID = C.AV_CODEC_ID_VP6
	// AVCodecIdVp6F wraps AV_CODEC_ID_VP6F.
	AVCodecIdVp6F AVCodecID = C.AV_CODEC_ID_VP6F
	// AVCodecIdTarga wraps AV_CODEC_ID_TARGA.
	AVCodecIdTarga AVCodecID = C.AV_CODEC_ID_TARGA
	// AVCodecIdDsicinvideo wraps AV_CODEC_ID_DSICINVIDEO.
	AVCodecIdDsicinvideo AVCodecID = C.AV_CODEC_ID_DSICINVIDEO
	// AVCodecIdTiertexseqvideo wraps AV_CODEC_ID_TIERTEXSEQVIDEO.
	AVCodecIdTiertexseqvideo AVCodecID = C.AV_CODEC_ID_TIERTEXSEQVIDEO
	// AVCodecIdTiff wraps AV_CODEC_ID_TIFF.
	AVCodecIdTiff AVCodecID = C.AV_CODEC_ID_TIFF
	// AVCodecIdGif wraps AV_CODEC_ID_GIF.
	AVCodecIdGif AVCodecID = C.AV_CODEC_ID_GIF
	// AVCodecIdDxa wraps AV_CODEC_ID_DXA.
	AVCodecIdDxa AVCodecID = C.AV_CODEC_ID_DXA
	// AVCodecIdDnxhd wraps AV_CODEC_ID_DNXHD.
	AVCodecIdDnxhd AVCodecID = C.AV_CODEC_ID_DNXHD
	// AVCodecIdThp wraps AV_CODEC_ID_THP.
	AVCodecIdThp AVCodecID = C.AV_CODEC_ID_THP
	// AVCodecIdSgi wraps AV_CODEC_ID_SGI.
	AVCodecIdSgi AVCodecID = C.AV_CODEC_ID_SGI
	// AVCodecIdC93 wraps AV_CODEC_ID_C93.
	AVCodecIdC93 AVCodecID = C.AV_CODEC_ID_C93
	// AVCodecIdBethsoftvid wraps AV_CODEC_ID_BETHSOFTVID.
	AVCodecIdBethsoftvid AVCodecID = C.AV_CODEC_ID_BETHSOFTVID
	// AVCodecIdPtx wraps AV_CODEC_ID_PTX.
	AVCodecIdPtx AVCodecID = C.AV_CODEC_ID_PTX
	// AVCodecIdTxd wraps AV_CODEC_ID_TXD.
	AVCodecIdTxd AVCodecID = C.AV_CODEC_ID_TXD
	// AVCodecIdVp6A wraps AV_CODEC_ID_VP6A.
	AVCodecIdVp6A AVCodecID = C.AV_CODEC_ID_VP6A
	// AVCodecIdAmv wraps AV_CODEC_ID_AMV.
	AVCodecIdAmv AVCodecID = C.AV_CODEC_ID_AMV
	// AVCodecIdVb wraps AV_CODEC_ID_VB.
	AVCodecIdVb AVCodecID = C.AV_CODEC_ID_VB
	// AVCodecIdPcx wraps AV_CODEC_ID_PCX.
	AVCodecIdPcx AVCodecID = C.AV_CODEC_ID_PCX
	// AVCodecIdSunrast wraps AV_CODEC_ID_SUNRAST.
	AVCodecIdSunrast AVCodecID = C.AV_CODEC_ID_SUNRAST
	// AVCodecIdIndeo4 wraps AV_CODEC_ID_INDEO4.
	AVCodecIdIndeo4 AVCodecID = C.AV_CODEC_ID_INDEO4
	// AVCodecIdIndeo5 wraps AV_CODEC_ID_INDEO5.
	AVCodecIdIndeo5 AVCodecID = C.AV_CODEC_ID_INDEO5
	// AVCodecIdMimic wraps AV_CODEC_ID_MIMIC.
	AVCodecIdMimic AVCodecID = C.AV_CODEC_ID_MIMIC
	// AVCodecIdRl2 wraps AV_CODEC_ID_RL2.
	AVCodecIdRl2 AVCodecID = C.AV_CODEC_ID_RL2
	// AVCodecIdEscape124 wraps AV_CODEC_ID_ESCAPE124.
	AVCodecIdEscape124 AVCodecID = C.AV_CODEC_ID_ESCAPE124
	// AVCodecIdDirac wraps AV_CODEC_ID_DIRAC.
	AVCodecIdDirac AVCodecID = C.AV_CODEC_ID_DIRAC
	// AVCodecIdBfi wraps AV_CODEC_ID_BFI.
	AVCodecIdBfi AVCodecID = C.AV_CODEC_ID_BFI
	// AVCodecIdCmv wraps AV_CODEC_ID_CMV.
	AVCodecIdCmv AVCodecID = C.AV_CODEC_ID_CMV
	// AVCodecIdMotionpixels wraps AV_CODEC_ID_MOTIONPIXELS.
	AVCodecIdMotionpixels AVCodecID = C.AV_CODEC_ID_MOTIONPIXELS
	// AVCodecIdTgv wraps AV_CODEC_ID_TGV.
	AVCodecIdTgv AVCodecID = C.AV_CODEC_ID_TGV
	// AVCodecIdTgq wraps AV_CODEC_ID_TGQ.
	AVCodecIdTgq AVCodecID = C.AV_CODEC_ID_TGQ
	// AVCodecIdTqi wraps AV_CODEC_ID_TQI.
	AVCodecIdTqi AVCodecID = C.AV_CODEC_ID_TQI
	// AVCodecIdAura wraps AV_CODEC_ID_AURA.
	AVCodecIdAura AVCodecID = C.AV_CODEC_ID_AURA
	// AVCodecIdAura2 wraps AV_CODEC_ID_AURA2.
	AVCodecIdAura2 AVCodecID = C.AV_CODEC_ID_AURA2
	// AVCodecIdV210X wraps AV_CODEC_ID_V210X.
	AVCodecIdV210X AVCodecID = C.AV_CODEC_ID_V210X
	// AVCodecIdTmv wraps AV_CODEC_ID_TMV.
	AVCodecIdTmv AVCodecID = C.AV_CODEC_ID_TMV
	// AVCodecIdV210 wraps AV_CODEC_ID_V210.
	AVCodecIdV210 AVCodecID = C.AV_CODEC_ID_V210
	// AVCodecIdDpx wraps AV_CODEC_ID_DPX.
	AVCodecIdDpx AVCodecID = C.AV_CODEC_ID_DPX
	// AVCodecIdMad wraps AV_CODEC_ID_MAD.
	AVCodecIdMad AVCodecID = C.AV_CODEC_ID_MAD
	// AVCodecIdFrwu wraps AV_CODEC_ID_FRWU.
	AVCodecIdFrwu AVCodecID = C.AV_CODEC_ID_FRWU
	// AVCodecIdFlashsv2 wraps AV_CODEC_ID_FLASHSV2.
	AVCodecIdFlashsv2 AVCodecID = C.AV_CODEC_ID_FLASHSV2
	// AVCodecIdCdgraphics wraps AV_CODEC_ID_CDGRAPHICS.
	AVCodecIdCdgraphics AVCodecID = C.AV_CODEC_ID_CDGRAPHICS
	// AVCodecIdR210 wraps AV_CODEC_ID_R210.
	AVCodecIdR210 AVCodecID = C.AV_CODEC_ID_R210
	// AVCodecIdAnm wraps AV_CODEC_ID_ANM.
	AVCodecIdAnm AVCodecID = C.AV_CODEC_ID_ANM
	// AVCodecIdBinkvideo wraps AV_CODEC_ID_BINKVIDEO.
	AVCodecIdBinkvideo AVCodecID = C.AV_CODEC_ID_BINKVIDEO
	// AVCodecIdIffIlbm wraps AV_CODEC_ID_IFF_ILBM.
	AVCodecIdIffIlbm AVCodecID = C.AV_CODEC_ID_IFF_ILBM
	// AVCodecIdKgv1 wraps AV_CODEC_ID_KGV1.
	AVCodecIdKgv1 AVCodecID = C.AV_CODEC_ID_KGV1
	// AVCodecIdYop wraps AV_CODEC_ID_YOP.
	AVCodecIdYop AVCodecID = C.AV_CODEC_ID_YOP
	// AVCodecIdVp8 wraps AV_CODEC_ID_VP8.
	AVCodecIdVp8 AVCodecID = C.AV_CODEC_ID_VP8
	// AVCodecIdPictor wraps AV_CODEC_ID_PICTOR.
	AVCodecIdPictor AVCodecID = C.AV_CODEC_ID_PICTOR
	// AVCodecIdAnsi wraps AV_CODEC_ID_ANSI.
	AVCodecIdAnsi AVCodecID = C.AV_CODEC_ID_ANSI
	// AVCodecIdA64Multi wraps AV_CODEC_ID_A64_MULTI.
	AVCodecIdA64Multi AVCodecID = C.AV_CODEC_ID_A64_MULTI
	// AVCodecIdA64Multi5 wraps AV_CODEC_ID_A64_MULTI5.
	AVCodecIdA64Multi5 AVCodecID = C.AV_CODEC_ID_A64_MULTI5
	// AVCodecIdR10K wraps AV_CODEC_ID_R10K.
	AVCodecIdR10K AVCodecID = C.AV_CODEC_ID_R10K
	// AVCodecIdMxpeg wraps AV_CODEC_ID_MXPEG.
	AVCodecIdMxpeg AVCodecID = C.AV_CODEC_ID_MXPEG
	// AVCodecIdLagarith wraps AV_CODEC_ID_LAGARITH.
	AVCodecIdLagarith AVCodecID = C.AV_CODEC_ID_LAGARITH
	// AVCodecIdProres wraps AV_CODEC_ID_PRORES.
	AVCodecIdProres AVCodecID = C.AV_CODEC_ID_PRORES
	// AVCodecIdJv wraps AV_CODEC_ID_JV.
	AVCodecIdJv AVCodecID = C.AV_CODEC_ID_JV
	// AVCodecIdDfa wraps AV_CODEC_ID_DFA.
	AVCodecIdDfa AVCodecID = C.AV_CODEC_ID_DFA
	// AVCodecIdWmv3Image wraps AV_CODEC_ID_WMV3IMAGE.
	AVCodecIdWmv3Image AVCodecID = C.AV_CODEC_ID_WMV3IMAGE
	// AVCodecIdVc1Image wraps AV_CODEC_ID_VC1IMAGE.
	AVCodecIdVc1Image AVCodecID = C.AV_CODEC_ID_VC1IMAGE
	// AVCodecIdUtvideo wraps AV_CODEC_ID_UTVIDEO.
	AVCodecIdUtvideo AVCodecID = C.AV_CODEC_ID_UTVIDEO
	// AVCodecIdBmvVideo wraps AV_CODEC_ID_BMV_VIDEO.
	AVCodecIdBmvVideo AVCodecID = C.AV_CODEC_ID_BMV_VIDEO
	// AVCodecIdVble wraps AV_CODEC_ID_VBLE.
	AVCodecIdVble AVCodecID = C.AV_CODEC_ID_VBLE
	// AVCodecIdDxtory wraps AV_CODEC_ID_DXTORY.
	AVCodecIdDxtory AVCodecID = C.AV_CODEC_ID_DXTORY
	// AVCodecIdV410 wraps AV_CODEC_ID_V410.
	AVCodecIdV410 AVCodecID = C.AV_CODEC_ID_V410
	// AVCodecIdXwd wraps AV_CODEC_ID_XWD.
	AVCodecIdXwd AVCodecID = C.AV_CODEC_ID_XWD
	// AVCodecIdCdxl wraps AV_CODEC_ID_CDXL.
	AVCodecIdCdxl AVCodecID = C.AV_CODEC_ID_CDXL
	// AVCodecIdXbm wraps AV_CODEC_ID_XBM.
	AVCodecIdXbm AVCodecID = C.AV_CODEC_ID_XBM
	// AVCodecIdZerocodec wraps AV_CODEC_ID_ZEROCODEC.
	AVCodecIdZerocodec AVCodecID = C.AV_CODEC_ID_ZEROCODEC
	// AVCodecIdMss1 wraps AV_CODEC_ID_MSS1.
	AVCodecIdMss1 AVCodecID = C.AV_CODEC_ID_MSS1
	// AVCodecIdMsa1 wraps AV_CODEC_ID_MSA1.
	AVCodecIdMsa1 AVCodecID = C.AV_CODEC_ID_MSA1
	// AVCodecIdTscc2 wraps AV_CODEC_ID_TSCC2.
	AVCodecIdTscc2 AVCodecID = C.AV_CODEC_ID_TSCC2
	// AVCodecIdMts2 wraps AV_CODEC_ID_MTS2.
	AVCodecIdMts2 AVCodecID = C.AV_CODEC_ID_MTS2
	// AVCodecIdCllc wraps AV_CODEC_ID_CLLC.
	AVCodecIdCllc AVCodecID = C.AV_CODEC_ID_CLLC
	// AVCodecIdMss2 wraps AV_CODEC_ID_MSS2.
	AVCodecIdMss2 AVCodecID = C.AV_CODEC_ID_MSS2
	// AVCodecIdVp9 wraps AV_CODEC_ID_VP9.
	AVCodecIdVp9 AVCodecID = C.AV_CODEC_ID_VP9
	// AVCodecIdAic wraps AV_CODEC_ID_AIC.
	AVCodecIdAic AVCodecID = C.AV_CODEC_ID_AIC
	// AVCodecIdEscape130 wraps AV_CODEC_ID_ESCAPE130.
	AVCodecIdEscape130 AVCodecID = C.AV_CODEC_ID_ESCAPE130
	// AVCodecIdG2M wraps AV_CODEC_ID_G2M.
	AVCodecIdG2M AVCodecID = C.AV_CODEC_ID_G2M
	// AVCodecIdWebp wraps AV_CODEC_ID_WEBP.
	AVCodecIdWebp AVCodecID = C.AV_CODEC_ID_WEBP
	// AVCodecIdHnm4Video wraps AV_CODEC_ID_HNM4_VIDEO.
	AVCodecIdHnm4Video AVCodecID = C.AV_CODEC_ID_HNM4_VIDEO
	// AVCodecIdHevc wraps AV_CODEC_ID_HEVC.
	AVCodecIdHevc AVCodecID = C.AV_CODEC_ID_HEVC
	// AVCodecIdFic wraps AV_CODEC_ID_FIC.
	AVCodecIdFic AVCodecID = C.AV_CODEC_ID_FIC
	// AVCodecIdAliasPix wraps AV_CODEC_ID_ALIAS_PIX.
	AVCodecIdAliasPix AVCodecID = C.AV_CODEC_ID_ALIAS_PIX
	// AVCodecIdBrenderPix wraps AV_CODEC_ID_BRENDER_PIX.
	AVCodecIdBrenderPix AVCodecID = C.AV_CODEC_ID_BRENDER_PIX
	// AVCodecIdPafVideo wraps AV_CODEC_ID_PAF_VIDEO.
	AVCodecIdPafVideo AVCodecID = C.AV_CODEC_ID_PAF_VIDEO
	// AVCodecIdExr wraps AV_CODEC_ID_EXR.
	AVCodecIdExr AVCodecID = C.AV_CODEC_ID_EXR
	// AVCodecIdVp7 wraps AV_CODEC_ID_VP7.
	AVCodecIdVp7 AVCodecID = C.AV_CODEC_ID_VP7
	// AVCodecIdSanm wraps AV_CODEC_ID_SANM.
	AVCodecIdSanm AVCodecID = C.AV_CODEC_ID_SANM
	// AVCodecIdSgirle wraps AV_CODEC_ID_SGIRLE.
	AVCodecIdSgirle AVCodecID = C.AV_CODEC_ID_SGIRLE
	// AVCodecIdMvc1 wraps AV_CODEC_ID_MVC1.
	AVCodecIdMvc1 AVCodecID = C.AV_CODEC_ID_MVC1
	// AVCodecIdMvc2 wraps AV_CODEC_ID_MVC2.
	AVCodecIdMvc2 AVCodecID = C.AV_CODEC_ID_MVC2
	// AVCodecIdHqx wraps AV_CODEC_ID_HQX.
	AVCodecIdHqx AVCodecID = C.AV_CODEC_ID_HQX
	// AVCodecIdTdsc wraps AV_CODEC_ID_TDSC.
	AVCodecIdTdsc AVCodecID = C.AV_CODEC_ID_TDSC
	// AVCodecIdHqHqa wraps AV_CODEC_ID_HQ_HQA.
	AVCodecIdHqHqa AVCodecID = C.AV_CODEC_ID_HQ_HQA
	// AVCodecIdHap wraps AV_CODEC_ID_HAP.
	AVCodecIdHap AVCodecID = C.AV_CODEC_ID_HAP
	// AVCodecIdDds wraps AV_CODEC_ID_DDS.
	AVCodecIdDds AVCodecID = C.AV_CODEC_ID_DDS
	// AVCodecIdDxv wraps AV_CODEC_ID_DXV.
	AVCodecIdDxv AVCodecID = C.AV_CODEC_ID_DXV
	// AVCodecIdScreenpresso wraps AV_CODEC_ID_SCREENPRESSO.
	AVCodecIdScreenpresso AVCodecID = C.AV_CODEC_ID_SCREENPRESSO
	// AVCodecIdRscc wraps AV_CODEC_ID_RSCC.
	AVCodecIdRscc AVCodecID = C.AV_CODEC_ID_RSCC
	// AVCodecIdAVS2 wraps AV_CODEC_ID_AVS2.
	AVCodecIdAVS2 AVCodecID = C.AV_CODEC_ID_AVS2
	// AVCodecIdPgx wraps AV_CODEC_ID_PGX.
	AVCodecIdPgx AVCodecID = C.AV_CODEC_ID_PGX
	// AVCodecIdAVS3 wraps AV_CODEC_ID_AVS3.
	AVCodecIdAVS3 AVCodecID = C.AV_CODEC_ID_AVS3
	// AVCodecIdMsp2 wraps AV_CODEC_ID_MSP2.
	AVCodecIdMsp2 AVCodecID = C.AV_CODEC_ID_MSP2
	// AVCodecIdVvc wraps AV_CODEC_ID_VVC.
	AVCodecIdVvc AVCodecID = C.AV_CODEC_ID_VVC
	// AVCodecIdY41P wraps AV_CODEC_ID_Y41P.
	AVCodecIdY41P AVCodecID = C.AV_CODEC_ID_Y41P
	// AVCodecIdAVRp wraps AV_CODEC_ID_AVRP.
	AVCodecIdAVRp AVCodecID = C.AV_CODEC_ID_AVRP
	// AVCodecId012V wraps AV_CODEC_ID_012V.
	AVCodecId012V AVCodecID = C.AV_CODEC_ID_012V
	// AVCodecIdAVUi wraps AV_CODEC_ID_AVUI.
	AVCodecIdAVUi AVCodecID = C.AV_CODEC_ID_AVUI
	// AVCodecIdTargaY216 wraps AV_CODEC_ID_TARGA_Y216.
	AVCodecIdTargaY216 AVCodecID = C.AV_CODEC_ID_TARGA_Y216
	// AVCodecIdV308 wraps AV_CODEC_ID_V308.
	AVCodecIdV308 AVCodecID = C.AV_CODEC_ID_V308
	// AVCodecIdV408 wraps AV_CODEC_ID_V408.
	AVCodecIdV408 AVCodecID = C.AV_CODEC_ID_V408
	// AVCodecIdYuv4 wraps AV_CODEC_ID_YUV4.
	AVCodecIdYuv4 AVCodecID = C.AV_CODEC_ID_YUV4
	// AVCodecIdAVRn wraps AV_CODEC_ID_AVRN.
	AVCodecIdAVRn AVCodecID = C.AV_CODEC_ID_AVRN
	// AVCodecIdCpia wraps AV_CODEC_ID_CPIA.
	AVCodecIdCpia AVCodecID = C.AV_CODEC_ID_CPIA
	// AVCodecIdXface wraps AV_CODEC_ID_XFACE.
	AVCodecIdXface AVCodecID = C.AV_CODEC_ID_XFACE
	// AVCodecIdSnow wraps AV_CODEC_ID_SNOW.
	AVCodecIdSnow AVCodecID = C.AV_CODEC_ID_SNOW
	// AVCodecIdSmvjpeg wraps AV_CODEC_ID_SMVJPEG.
	AVCodecIdSmvjpeg AVCodecID = C.AV_CODEC_ID_SMVJPEG
	// AVCodecIdApng wraps AV_CODEC_ID_APNG.
	AVCodecIdApng AVCodecID = C.AV_CODEC_ID_APNG
	// AVCodecIdDaala wraps AV_CODEC_ID_DAALA.
	AVCodecIdDaala AVCodecID = C.AV_CODEC_ID_DAALA
	// AVCodecIdCfhd wraps AV_CODEC_ID_CFHD.
	AVCodecIdCfhd AVCodecID = C.AV_CODEC_ID_CFHD
	// AVCodecIdTruemotion2Rt wraps AV_CODEC_ID_TRUEMOTION2RT.
	AVCodecIdTruemotion2Rt AVCodecID = C.AV_CODEC_ID_TRUEMOTION2RT
	// AVCodecIdM101 wraps AV_CODEC_ID_M101.
	AVCodecIdM101 AVCodecID = C.AV_CODEC_ID_M101
	// AVCodecIdMagicyuv wraps AV_CODEC_ID_MAGICYUV.
	AVCodecIdMagicyuv AVCodecID = C.AV_CODEC_ID_MAGICYUV
	// AVCodecIdSheervideo wraps AV_CODEC_ID_SHEERVIDEO.
	AVCodecIdSheervideo AVCodecID = C.AV_CODEC_ID_SHEERVIDEO
	// AVCodecIdYlc wraps AV_CODEC_ID_YLC.
	AVCodecIdYlc AVCodecID = C.AV_CODEC_ID_YLC
	// AVCodecIdPsd wraps AV_CODEC_ID_PSD.
	AVCodecIdPsd AVCodecID = C.AV_CODEC_ID_PSD
	// AVCodecIdPixlet wraps AV_CODEC_ID_PIXLET.
	AVCodecIdPixlet AVCodecID = C.AV_CODEC_ID_PIXLET
	// AVCodecIdSpeedhq wraps AV_CODEC_ID_SPEEDHQ.
	AVCodecIdSpeedhq AVCodecID = C.AV_CODEC_ID_SPEEDHQ
	// AVCodecIdFmvc wraps AV_CODEC_ID_FMVC.
	AVCodecIdFmvc AVCodecID = C.AV_CODEC_ID_FMVC
	// AVCodecIdScpr wraps AV_CODEC_ID_SCPR.
	AVCodecIdScpr AVCodecID = C.AV_CODEC_ID_SCPR
	// AVCodecIdClearvideo wraps AV_CODEC_ID_CLEARVIDEO.
	AVCodecIdClearvideo AVCodecID = C.AV_CODEC_ID_CLEARVIDEO
	// AVCodecIdXpm wraps AV_CODEC_ID_XPM.
	AVCodecIdXpm AVCodecID = C.AV_CODEC_ID_XPM
	// AVCodecIdAV1 wraps AV_CODEC_ID_AV1.
	AVCodecIdAV1 AVCodecID = C.AV_CODEC_ID_AV1
	// AVCodecIdBitpacked wraps AV_CODEC_ID_BITPACKED.
	AVCodecIdBitpacked AVCodecID = C.AV_CODEC_ID_BITPACKED
	// AVCodecIdMscc wraps AV_CODEC_ID_MSCC.
	AVCodecIdMscc AVCodecID = C.AV_CODEC_ID_MSCC
	// AVCodecIdSrgc wraps AV_CODEC_ID_SRGC.
	AVCodecIdSrgc AVCodecID = C.AV_CODEC_ID_SRGC
	// AVCodecIdSvg wraps AV_CODEC_ID_SVG.
	AVCodecIdSvg AVCodecID = C.AV_CODEC_ID_SVG
	// AVCodecIdGdv wraps AV_CODEC_ID_GDV.
	AVCodecIdGdv AVCodecID = C.AV_CODEC_ID_GDV
	// AVCodecIdFits wraps AV_CODEC_ID_FITS.
	AVCodecIdFits AVCodecID = C.AV_CODEC_ID_FITS
	// AVCodecIdImm4 wraps AV_CODEC_ID_IMM4.
	AVCodecIdImm4 AVCodecID = C.AV_CODEC_ID_IMM4
	// AVCodecIdProsumer wraps AV_CODEC_ID_PROSUMER.
	AVCodecIdProsumer AVCodecID = C.AV_CODEC_ID_PROSUMER
	// AVCodecIdMwsc wraps AV_CODEC_ID_MWSC.
	AVCodecIdMwsc AVCodecID = C.AV_CODEC_ID_MWSC
	// AVCodecIdWcmv wraps AV_CODEC_ID_WCMV.
	AVCodecIdWcmv AVCodecID = C.AV_CODEC_ID_WCMV
	// AVCodecIdRasc wraps AV_CODEC_ID_RASC.
	AVCodecIdRasc AVCodecID = C.AV_CODEC_ID_RASC
	// AVCodecIdHymt wraps AV_CODEC_ID_HYMT.
	AVCodecIdHymt AVCodecID = C.AV_CODEC_ID_HYMT
	// AVCodecIdArbc wraps AV_CODEC_ID_ARBC.
	AVCodecIdArbc AVCodecID = C.AV_CODEC_ID_ARBC
	// AVCodecIdAgm wraps AV_CODEC_ID_AGM.
	AVCodecIdAgm AVCodecID = C.AV_CODEC_ID_AGM
	// AVCodecIdLscr wraps AV_CODEC_ID_LSCR.
	AVCodecIdLscr AVCodecID = C.AV_CODEC_ID_LSCR
	// AVCodecIdVp4 wraps AV_CODEC_ID_VP4.
	AVCodecIdVp4 AVCodecID = C.AV_CODEC_ID_VP4
	// AVCodecIdImm5 wraps AV_CODEC_ID_IMM5.
	AVCodecIdImm5 AVCodecID = C.AV_CODEC_ID_IMM5
	// AVCodecIdMvdv wraps AV_CODEC_ID_MVDV.
	AVCodecIdMvdv AVCodecID = C.AV_CODEC_ID_MVDV
	// AVCodecIdMvha wraps AV_CODEC_ID_MVHA.
	AVCodecIdMvha AVCodecID = C.AV_CODEC_ID_MVHA
	// AVCodecIdCdtoons wraps AV_CODEC_ID_CDTOONS.
	AVCodecIdCdtoons AVCodecID = C.AV_CODEC_ID_CDTOONS
	// AVCodecIdMv30 wraps AV_CODEC_ID_MV30.
	AVCodecIdMv30 AVCodecID = C.AV_CODEC_ID_MV30
	// AVCodecIdNotchlc wraps AV_CODEC_ID_NOTCHLC.
	AVCodecIdNotchlc AVCodecID = C.AV_CODEC_ID_NOTCHLC
	// AVCodecIdPfm wraps AV_CODEC_ID_PFM.
	AVCodecIdPfm AVCodecID = C.AV_CODEC_ID_PFM
	// AVCodecIdMobiclip wraps AV_CODEC_ID_MOBICLIP.
	AVCodecIdMobiclip AVCodecID = C.AV_CODEC_ID_MOBICLIP
	// AVCodecIdPhotocd wraps AV_CODEC_ID_PHOTOCD.
	AVCodecIdPhotocd AVCodecID = C.AV_CODEC_ID_PHOTOCD
	// AVCodecIdIpu wraps AV_CODEC_ID_IPU.
	AVCodecIdIpu AVCodecID = C.AV_CODEC_ID_IPU
	// AVCodecIdArgo wraps AV_CODEC_ID_ARGO.
	AVCodecIdArgo AVCodecID = C.AV_CODEC_ID_ARGO
	// AVCodecIdCri wraps AV_CODEC_ID_CRI.
	AVCodecIdCri AVCodecID = C.AV_CODEC_ID_CRI
	// AVCodecIdSimbiosisImx wraps AV_CODEC_ID_SIMBIOSIS_IMX.
	AVCodecIdSimbiosisImx AVCodecID = C.AV_CODEC_ID_SIMBIOSIS_IMX
	// AVCodecIdSgaVideo wraps AV_CODEC_ID_SGA_VIDEO.
	AVCodecIdSgaVideo AVCodecID = C.AV_CODEC_ID_SGA_VIDEO
	// AVCodecIdGem wraps AV_CODEC_ID_GEM.
	AVCodecIdGem AVCodecID = C.AV_CODEC_ID_GEM
	// AVCodecIdVbn wraps AV_CODEC_ID_VBN.
	AVCodecIdVbn AVCodecID = C.AV_CODEC_ID_VBN
	// AVCodecIdJpegxl wraps AV_CODEC_ID_JPEGXL.
	AVCodecIdJpegxl AVCodecID = C.AV_CODEC_ID_JPEGXL
	// AVCodecIdQoi wraps AV_CODEC_ID_QOI.
	AVCodecIdQoi AVCodecID = C.AV_CODEC_ID_QOI
	// AVCodecIdPhm wraps AV_CODEC_ID_PHM.
	AVCodecIdPhm AVCodecID = C.AV_CODEC_ID_PHM
	// AVCodecIdRadianceHdr wraps AV_CODEC_ID_RADIANCE_HDR.
	AVCodecIdRadianceHdr AVCodecID = C.AV_CODEC_ID_RADIANCE_HDR
	// AVCodecIdWbmp wraps AV_CODEC_ID_WBMP.
	AVCodecIdWbmp AVCodecID = C.AV_CODEC_ID_WBMP
	// AVCodecIdMedia100 wraps AV_CODEC_ID_MEDIA100.
	AVCodecIdMedia100 AVCodecID = C.AV_CODEC_ID_MEDIA100
	// AVCodecIdVqc wraps AV_CODEC_ID_VQC.
	AVCodecIdVqc AVCodecID = C.AV_CODEC_ID_VQC
	// AVCodecIdPdv wraps AV_CODEC_ID_PDV.
	AVCodecIdPdv AVCodecID = C.AV_CODEC_ID_PDV
	// AVCodecIdEvc wraps AV_CODEC_ID_EVC.
	AVCodecIdEvc AVCodecID = C.AV_CODEC_ID_EVC
	// AVCodecIdRtv1 wraps AV_CODEC_ID_RTV1.
	AVCodecIdRtv1 AVCodecID = C.AV_CODEC_ID_RTV1
	// AVCodecIdVmix wraps AV_CODEC_ID_VMIX.
	AVCodecIdVmix AVCodecID = C.AV_CODEC_ID_VMIX
	// AVCodecIdLead wraps AV_CODEC_ID_LEAD.
	AVCodecIdLead AVCodecID = C.AV_CODEC_ID_LEAD
	// AVCodecIdDnxuc wraps AV_CODEC_ID_DNXUC.
	AVCodecIdDnxuc AVCodecID = C.AV_CODEC_ID_DNXUC
	// AVCodecIdRv60 wraps AV_CODEC_ID_RV60.
	AVCodecIdRv60 AVCodecID = C.AV_CODEC_ID_RV60
	// AVCodecIdJpegxlAnim wraps AV_CODEC_ID_JPEGXL_ANIM.
	AVCodecIdJpegxlAnim AVCodecID = C.AV_CODEC_ID_JPEGXL_ANIM
	// AVCodecIdApv wraps AV_CODEC_ID_APV.
	AVCodecIdApv AVCodecID = C.AV_CODEC_ID_APV
	// AVCodecIdProresRaw wraps AV_CODEC_ID_PRORES_RAW.
	AVCodecIdProresRaw AVCodecID = C.AV_CODEC_ID_PRORES_RAW
	// AVCodecIdFirstAudio wraps AV_CODEC_ID_FIRST_AUDIO.
	//
	//	A dummy id pointing at the start of audio codecs
	AVCodecIdFirstAudio AVCodecID = C.AV_CODEC_ID_FIRST_AUDIO
	// AVCodecIdPcmS16Le wraps AV_CODEC_ID_PCM_S16LE.
	AVCodecIdPcmS16Le AVCodecID = C.AV_CODEC_ID_PCM_S16LE
	// AVCodecIdPcmS16Be wraps AV_CODEC_ID_PCM_S16BE.
	AVCodecIdPcmS16Be AVCodecID = C.AV_CODEC_ID_PCM_S16BE
	// AVCodecIdPcmU16Le wraps AV_CODEC_ID_PCM_U16LE.
	AVCodecIdPcmU16Le AVCodecID = C.AV_CODEC_ID_PCM_U16LE
	// AVCodecIdPcmU16Be wraps AV_CODEC_ID_PCM_U16BE.
	AVCodecIdPcmU16Be AVCodecID = C.AV_CODEC_ID_PCM_U16BE
	// AVCodecIdPcmS8 wraps AV_CODEC_ID_PCM_S8.
	AVCodecIdPcmS8 AVCodecID = C.AV_CODEC_ID_PCM_S8
	// AVCodecIdPcmU8 wraps AV_CODEC_ID_PCM_U8.
	AVCodecIdPcmU8 AVCodecID = C.AV_CODEC_ID_PCM_U8
	// AVCodecIdPcmMulaw wraps AV_CODEC_ID_PCM_MULAW.
	AVCodecIdPcmMulaw AVCodecID = C.AV_CODEC_ID_PCM_MULAW
	// AVCodecIdPcmAlaw wraps AV_CODEC_ID_PCM_ALAW.
	AVCodecIdPcmAlaw AVCodecID = C.AV_CODEC_ID_PCM_ALAW
	// AVCodecIdPcmS32Le wraps AV_CODEC_ID_PCM_S32LE.
	AVCodecIdPcmS32Le AVCodecID = C.AV_CODEC_ID_PCM_S32LE
	// AVCodecIdPcmS32Be wraps AV_CODEC_ID_PCM_S32BE.
	AVCodecIdPcmS32Be AVCodecID = C.AV_CODEC_ID_PCM_S32BE
	// AVCodecIdPcmU32Le wraps AV_CODEC_ID_PCM_U32LE.
	AVCodecIdPcmU32Le AVCodecID = C.AV_CODEC_ID_PCM_U32LE
	// AVCodecIdPcmU32Be wraps AV_CODEC_ID_PCM_U32BE.
	AVCodecIdPcmU32Be AVCodecID = C.AV_CODEC_ID_PCM_U32BE
	// AVCodecIdPcmS24Le wraps AV_CODEC_ID_PCM_S24LE.
	AVCodecIdPcmS24Le AVCodecID = C.AV_CODEC_ID_PCM_S24LE
	// AVCodecIdPcmS24Be wraps AV_CODEC_ID_PCM_S24BE.
	AVCodecIdPcmS24Be AVCodecID = C.AV_CODEC_ID_PCM_S24BE
	// AVCodecIdPcmU24Le wraps AV_CODEC_ID_PCM_U24LE.
	AVCodecIdPcmU24Le AVCodecID = C.AV_CODEC_ID_PCM_U24LE
	// AVCodecIdPcmU24Be wraps AV_CODEC_ID_PCM_U24BE.
	AVCodecIdPcmU24Be AVCodecID = C.AV_CODEC_ID_PCM_U24BE
	// AVCodecIdPcmS24Daud wraps AV_CODEC_ID_PCM_S24DAUD.
	AVCodecIdPcmS24Daud AVCodecID = C.AV_CODEC_ID_PCM_S24DAUD
	// AVCodecIdPcmZork wraps AV_CODEC_ID_PCM_ZORK.
	AVCodecIdPcmZork AVCodecID = C.AV_CODEC_ID_PCM_ZORK
	// AVCodecIdPcmS16LePlanar wraps AV_CODEC_ID_PCM_S16LE_PLANAR.
	AVCodecIdPcmS16LePlanar AVCodecID = C.AV_CODEC_ID_PCM_S16LE_PLANAR
	// AVCodecIdPcmDvd wraps AV_CODEC_ID_PCM_DVD.
	AVCodecIdPcmDvd AVCodecID = C.AV_CODEC_ID_PCM_DVD
	// AVCodecIdPcmF32Be wraps AV_CODEC_ID_PCM_F32BE.
	AVCodecIdPcmF32Be AVCodecID = C.AV_CODEC_ID_PCM_F32BE
	// AVCodecIdPcmF32Le wraps AV_CODEC_ID_PCM_F32LE.
	AVCodecIdPcmF32Le AVCodecID = C.AV_CODEC_ID_PCM_F32LE
	// AVCodecIdPcmF64Be wraps AV_CODEC_ID_PCM_F64BE.
	AVCodecIdPcmF64Be AVCodecID = C.AV_CODEC_ID_PCM_F64BE
	// AVCodecIdPcmF64Le wraps AV_CODEC_ID_PCM_F64LE.
	AVCodecIdPcmF64Le AVCodecID = C.AV_CODEC_ID_PCM_F64LE
	// AVCodecIdPcmBluray wraps AV_CODEC_ID_PCM_BLURAY.
	AVCodecIdPcmBluray AVCodecID = C.AV_CODEC_ID_PCM_BLURAY
	// AVCodecIdPcmLxf wraps AV_CODEC_ID_PCM_LXF.
	AVCodecIdPcmLxf AVCodecID = C.AV_CODEC_ID_PCM_LXF
	// AVCodecIdS302M wraps AV_CODEC_ID_S302M.
	AVCodecIdS302M AVCodecID = C.AV_CODEC_ID_S302M
	// AVCodecIdPcmS8Planar wraps AV_CODEC_ID_PCM_S8_PLANAR.
	AVCodecIdPcmS8Planar AVCodecID = C.AV_CODEC_ID_PCM_S8_PLANAR
	// AVCodecIdPcmS24LePlanar wraps AV_CODEC_ID_PCM_S24LE_PLANAR.
	AVCodecIdPcmS24LePlanar AVCodecID = C.AV_CODEC_ID_PCM_S24LE_PLANAR
	// AVCodecIdPcmS32LePlanar wraps AV_CODEC_ID_PCM_S32LE_PLANAR.
	AVCodecIdPcmS32LePlanar AVCodecID = C.AV_CODEC_ID_PCM_S32LE_PLANAR
	// AVCodecIdPcmS16BePlanar wraps AV_CODEC_ID_PCM_S16BE_PLANAR.
	AVCodecIdPcmS16BePlanar AVCodecID = C.AV_CODEC_ID_PCM_S16BE_PLANAR
	// AVCodecIdPcmS64Le wraps AV_CODEC_ID_PCM_S64LE.
	AVCodecIdPcmS64Le AVCodecID = C.AV_CODEC_ID_PCM_S64LE
	// AVCodecIdPcmS64Be wraps AV_CODEC_ID_PCM_S64BE.
	AVCodecIdPcmS64Be AVCodecID = C.AV_CODEC_ID_PCM_S64BE
	// AVCodecIdPcmF16Le wraps AV_CODEC_ID_PCM_F16LE.
	AVCodecIdPcmF16Le AVCodecID = C.AV_CODEC_ID_PCM_F16LE
	// AVCodecIdPcmF24Le wraps AV_CODEC_ID_PCM_F24LE.
	AVCodecIdPcmF24Le AVCodecID = C.AV_CODEC_ID_PCM_F24LE
	// AVCodecIdPcmVidc wraps AV_CODEC_ID_PCM_VIDC.
	AVCodecIdPcmVidc AVCodecID = C.AV_CODEC_ID_PCM_VIDC
	// AVCodecIdPcmSga wraps AV_CODEC_ID_PCM_SGA.
	AVCodecIdPcmSga AVCodecID = C.AV_CODEC_ID_PCM_SGA
	// AVCodecIdAdpcmImaQt wraps AV_CODEC_ID_ADPCM_IMA_QT.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaQt AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_QT
	// AVCodecIdAdpcmImaWav wraps AV_CODEC_ID_ADPCM_IMA_WAV.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaWav AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_WAV
	// AVCodecIdAdpcmImaDk3 wraps AV_CODEC_ID_ADPCM_IMA_DK3.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaDk3 AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_DK3
	// AVCodecIdAdpcmImaDk4 wraps AV_CODEC_ID_ADPCM_IMA_DK4.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaDk4 AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_DK4
	// AVCodecIdAdpcmImaWs wraps AV_CODEC_ID_ADPCM_IMA_WS.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaWs AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_WS
	// AVCodecIdAdpcmImaSmjpeg wraps AV_CODEC_ID_ADPCM_IMA_SMJPEG.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaSmjpeg AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_SMJPEG
	// AVCodecIdAdpcmMs wraps AV_CODEC_ID_ADPCM_MS.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmMs AVCodecID = C.AV_CODEC_ID_ADPCM_MS
	// AVCodecIdAdpcm4Xm wraps AV_CODEC_ID_ADPCM_4XM.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcm4Xm AVCodecID = C.AV_CODEC_ID_ADPCM_4XM
	// AVCodecIdAdpcmXa wraps AV_CODEC_ID_ADPCM_XA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmXa AVCodecID = C.AV_CODEC_ID_ADPCM_XA
	// AVCodecIdAdpcmAdx wraps AV_CODEC_ID_ADPCM_ADX.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmAdx AVCodecID = C.AV_CODEC_ID_ADPCM_ADX
	// AVCodecIdAdpcmEa wraps AV_CODEC_ID_ADPCM_EA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEa AVCodecID = C.AV_CODEC_ID_ADPCM_EA
	// AVCodecIdAdpcmG726 wraps AV_CODEC_ID_ADPCM_G726.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmG726 AVCodecID = C.AV_CODEC_ID_ADPCM_G726
	// AVCodecIdAdpcmCt wraps AV_CODEC_ID_ADPCM_CT.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmCt AVCodecID = C.AV_CODEC_ID_ADPCM_CT
	// AVCodecIdAdpcmSwf wraps AV_CODEC_ID_ADPCM_SWF.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmSwf AVCodecID = C.AV_CODEC_ID_ADPCM_SWF
	// AVCodecIdAdpcmYamaha wraps AV_CODEC_ID_ADPCM_YAMAHA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmYamaha AVCodecID = C.AV_CODEC_ID_ADPCM_YAMAHA
	// AVCodecIdAdpcmSbpro4 wraps AV_CODEC_ID_ADPCM_SBPRO_4.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmSbpro4 AVCodecID = C.AV_CODEC_ID_ADPCM_SBPRO_4
	// AVCodecIdAdpcmSbpro3 wraps AV_CODEC_ID_ADPCM_SBPRO_3.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmSbpro3 AVCodecID = C.AV_CODEC_ID_ADPCM_SBPRO_3
	// AVCodecIdAdpcmSbpro2 wraps AV_CODEC_ID_ADPCM_SBPRO_2.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmSbpro2 AVCodecID = C.AV_CODEC_ID_ADPCM_SBPRO_2
	// AVCodecIdAdpcmThp wraps AV_CODEC_ID_ADPCM_THP.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmThp AVCodecID = C.AV_CODEC_ID_ADPCM_THP
	// AVCodecIdAdpcmImaAmv wraps AV_CODEC_ID_ADPCM_IMA_AMV.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaAmv AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_AMV
	// AVCodecIdAdpcmEaR1 wraps AV_CODEC_ID_ADPCM_EA_R1.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEaR1 AVCodecID = C.AV_CODEC_ID_ADPCM_EA_R1
	// AVCodecIdAdpcmEaR3 wraps AV_CODEC_ID_ADPCM_EA_R3.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEaR3 AVCodecID = C.AV_CODEC_ID_ADPCM_EA_R3
	// AVCodecIdAdpcmEaR2 wraps AV_CODEC_ID_ADPCM_EA_R2.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEaR2 AVCodecID = C.AV_CODEC_ID_ADPCM_EA_R2
	// AVCodecIdAdpcmImaEaSead wraps AV_CODEC_ID_ADPCM_IMA_EA_SEAD.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaEaSead AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_EA_SEAD
	// AVCodecIdAdpcmImaEaEacs wraps AV_CODEC_ID_ADPCM_IMA_EA_EACS.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaEaEacs AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_EA_EACS
	// AVCodecIdAdpcmEaXas wraps AV_CODEC_ID_ADPCM_EA_XAS.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEaXas AVCodecID = C.AV_CODEC_ID_ADPCM_EA_XAS
	// AVCodecIdAdpcmEaMaxisXa wraps AV_CODEC_ID_ADPCM_EA_MAXIS_XA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmEaMaxisXa AVCodecID = C.AV_CODEC_ID_ADPCM_EA_MAXIS_XA
	// AVCodecIdAdpcmImaIss wraps AV_CODEC_ID_ADPCM_IMA_ISS.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaIss AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_ISS
	// AVCodecIdAdpcmG722 wraps AV_CODEC_ID_ADPCM_G722.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmG722 AVCodecID = C.AV_CODEC_ID_ADPCM_G722
	// AVCodecIdAdpcmImaApc wraps AV_CODEC_ID_ADPCM_IMA_APC.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaApc AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_APC
	// AVCodecIdAdpcmVima wraps AV_CODEC_ID_ADPCM_VIMA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmVima AVCodecID = C.AV_CODEC_ID_ADPCM_VIMA
	// AVCodecIdAdpcmAfc wraps AV_CODEC_ID_ADPCM_AFC.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmAfc AVCodecID = C.AV_CODEC_ID_ADPCM_AFC
	// AVCodecIdAdpcmImaOki wraps AV_CODEC_ID_ADPCM_IMA_OKI.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaOki AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_OKI
	// AVCodecIdAdpcmDtk wraps AV_CODEC_ID_ADPCM_DTK.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmDtk AVCodecID = C.AV_CODEC_ID_ADPCM_DTK
	// AVCodecIdAdpcmImaRad wraps AV_CODEC_ID_ADPCM_IMA_RAD.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaRad AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_RAD
	// AVCodecIdAdpcmG726Le wraps AV_CODEC_ID_ADPCM_G726LE.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmG726Le AVCodecID = C.AV_CODEC_ID_ADPCM_G726LE
	// AVCodecIdAdpcmThpLe wraps AV_CODEC_ID_ADPCM_THP_LE.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmThpLe AVCodecID = C.AV_CODEC_ID_ADPCM_THP_LE
	// AVCodecIdAdpcmPsx wraps AV_CODEC_ID_ADPCM_PSX.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmPsx AVCodecID = C.AV_CODEC_ID_ADPCM_PSX
	// AVCodecIdAdpcmAica wraps AV_CODEC_ID_ADPCM_AICA.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmAica AVCodecID = C.AV_CODEC_ID_ADPCM_AICA
	// AVCodecIdAdpcmImaDat4 wraps AV_CODEC_ID_ADPCM_IMA_DAT4.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaDat4 AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_DAT4
	// AVCodecIdAdpcmMtaf wraps AV_CODEC_ID_ADPCM_MTAF.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmMtaf AVCodecID = C.AV_CODEC_ID_ADPCM_MTAF
	// AVCodecIdAdpcmAgm wraps AV_CODEC_ID_ADPCM_AGM.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmAgm AVCodecID = C.AV_CODEC_ID_ADPCM_AGM
	// AVCodecIdAdpcmArgo wraps AV_CODEC_ID_ADPCM_ARGO.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmArgo AVCodecID = C.AV_CODEC_ID_ADPCM_ARGO
	// AVCodecIdAdpcmImaSsi wraps AV_CODEC_ID_ADPCM_IMA_SSI.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaSsi AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_SSI
	// AVCodecIdAdpcmZork wraps AV_CODEC_ID_ADPCM_ZORK.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmZork AVCodecID = C.AV_CODEC_ID_ADPCM_ZORK
	// AVCodecIdAdpcmImaApm wraps AV_CODEC_ID_ADPCM_IMA_APM.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaApm AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_APM
	// AVCodecIdAdpcmImaAlp wraps AV_CODEC_ID_ADPCM_IMA_ALP.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaAlp AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_ALP
	// AVCodecIdAdpcmImaMtf wraps AV_CODEC_ID_ADPCM_IMA_MTF.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaMtf AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_MTF
	// AVCodecIdAdpcmImaCunning wraps AV_CODEC_ID_ADPCM_IMA_CUNNING.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaCunning AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_CUNNING
	// AVCodecIdAdpcmImaMoflex wraps AV_CODEC_ID_ADPCM_IMA_MOFLEX.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaMoflex AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_MOFLEX
	// AVCodecIdAdpcmImaAcorn wraps AV_CODEC_ID_ADPCM_IMA_ACORN.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaAcorn AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_ACORN
	// AVCodecIdAdpcmXmd wraps AV_CODEC_ID_ADPCM_XMD.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmXmd AVCodecID = C.AV_CODEC_ID_ADPCM_XMD
	// AVCodecIdAdpcmImaXbox wraps AV_CODEC_ID_ADPCM_IMA_XBOX.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmImaXbox AVCodecID = C.AV_CODEC_ID_ADPCM_IMA_XBOX
	// AVCodecIdAdpcmSanyo wraps AV_CODEC_ID_ADPCM_SANYO.
	//
	//	various ADPCM codecs
	AVCodecIdAdpcmSanyo AVCodecID = C.AV_CODEC_ID_ADPCM_SANYO
	// AVCodecIdAmrNb wraps AV_CODEC_ID_AMR_NB.
	//
	//	AMR
	AVCodecIdAmrNb AVCodecID = C.AV_CODEC_ID_AMR_NB
	// AVCodecIdAmrWb wraps AV_CODEC_ID_AMR_WB.
	//
	//	AMR
	AVCodecIdAmrWb AVCodecID = C.AV_CODEC_ID_AMR_WB
	// AVCodecIdRa144 wraps AV_CODEC_ID_RA_144.
	//
	//	RealAudio codecs
	AVCodecIdRa144 AVCodecID = C.AV_CODEC_ID_RA_144
	// AVCodecIdRa288 wraps AV_CODEC_ID_RA_288.
	//
	//	RealAudio codecs
	AVCodecIdRa288 AVCodecID = C.AV_CODEC_ID_RA_288
	// AVCodecIdRoqDpcm wraps AV_CODEC_ID_ROQ_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdRoqDpcm AVCodecID = C.AV_CODEC_ID_ROQ_DPCM
	// AVCodecIdInterplayDpcm wraps AV_CODEC_ID_INTERPLAY_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdInterplayDpcm AVCodecID = C.AV_CODEC_ID_INTERPLAY_DPCM
	// AVCodecIdXanDpcm wraps AV_CODEC_ID_XAN_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdXanDpcm AVCodecID = C.AV_CODEC_ID_XAN_DPCM
	// AVCodecIdSolDpcm wraps AV_CODEC_ID_SOL_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdSolDpcm AVCodecID = C.AV_CODEC_ID_SOL_DPCM
	// AVCodecIdSdx2Dpcm wraps AV_CODEC_ID_SDX2_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdSdx2Dpcm AVCodecID = C.AV_CODEC_ID_SDX2_DPCM
	// AVCodecIdGremlinDpcm wraps AV_CODEC_ID_GREMLIN_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdGremlinDpcm AVCodecID = C.AV_CODEC_ID_GREMLIN_DPCM
	// AVCodecIdDerfDpcm wraps AV_CODEC_ID_DERF_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdDerfDpcm AVCodecID = C.AV_CODEC_ID_DERF_DPCM
	// AVCodecIdWadyDpcm wraps AV_CODEC_ID_WADY_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdWadyDpcm AVCodecID = C.AV_CODEC_ID_WADY_DPCM
	// AVCodecIdCbd2Dpcm wraps AV_CODEC_ID_CBD2_DPCM.
	//
	//	various DPCM codecs
	AVCodecIdCbd2Dpcm AVCodecID = C.AV_CODEC_ID_CBD2_DPCM
	// AVCodecIdMp2 wraps AV_CODEC_ID_MP2.
	//
	//	audio codecs
	AVCodecIdMp2 AVCodecID = C.AV_CODEC_ID_MP2
	// AVCodecIdMp3 wraps AV_CODEC_ID_MP3.
	//
	//	preferred ID for decoding MPEG audio layer 1, 2 or 3
	AVCodecIdMp3 AVCodecID = C.AV_CODEC_ID_MP3
	// AVCodecIdAac wraps AV_CODEC_ID_AAC.
	AVCodecIdAac AVCodecID = C.AV_CODEC_ID_AAC
	// AVCodecIdAc3 wraps AV_CODEC_ID_AC3.
	AVCodecIdAc3 AVCodecID = C.AV_CODEC_ID_AC3
	// AVCodecIdDts wraps AV_CODEC_ID_DTS.
	AVCodecIdDts AVCodecID = C.AV_CODEC_ID_DTS
	// AVCodecIdVorbis wraps AV_CODEC_ID_VORBIS.
	AVCodecIdVorbis AVCodecID = C.AV_CODEC_ID_VORBIS
	// AVCodecIdDvaudio wraps AV_CODEC_ID_DVAUDIO.
	AVCodecIdDvaudio AVCodecID = C.AV_CODEC_ID_DVAUDIO
	// AVCodecIdWmav1 wraps AV_CODEC_ID_WMAV1.
	AVCodecIdWmav1 AVCodecID = C.AV_CODEC_ID_WMAV1
	// AVCodecIdWmav2 wraps AV_CODEC_ID_WMAV2.
	AVCodecIdWmav2 AVCodecID = C.AV_CODEC_ID_WMAV2
	// AVCodecIdMace3 wraps AV_CODEC_ID_MACE3.
	AVCodecIdMace3 AVCodecID = C.AV_CODEC_ID_MACE3
	// AVCodecIdMace6 wraps AV_CODEC_ID_MACE6.
	AVCodecIdMace6 AVCodecID = C.AV_CODEC_ID_MACE6
	// AVCodecIdVmdaudio wraps AV_CODEC_ID_VMDAUDIO.
	AVCodecIdVmdaudio AVCodecID = C.AV_CODEC_ID_VMDAUDIO
	// AVCodecIdFlac wraps AV_CODEC_ID_FLAC.
	AVCodecIdFlac AVCodecID = C.AV_CODEC_ID_FLAC
	// AVCodecIdMp3Adu wraps AV_CODEC_ID_MP3ADU.
	AVCodecIdMp3Adu AVCodecID = C.AV_CODEC_ID_MP3ADU
	// AVCodecIdMp3On4 wraps AV_CODEC_ID_MP3ON4.
	AVCodecIdMp3On4 AVCodecID = C.AV_CODEC_ID_MP3ON4
	// AVCodecIdShorten wraps AV_CODEC_ID_SHORTEN.
	AVCodecIdShorten AVCodecID = C.AV_CODEC_ID_SHORTEN
	// AVCodecIdAlac wraps AV_CODEC_ID_ALAC.
	AVCodecIdAlac AVCodecID = C.AV_CODEC_ID_ALAC
	// AVCodecIdWestwoodSnd1 wraps AV_CODEC_ID_WESTWOOD_SND1.
	AVCodecIdWestwoodSnd1 AVCodecID = C.AV_CODEC_ID_WESTWOOD_SND1
	// AVCodecIdGsm wraps AV_CODEC_ID_GSM.
	//
	//	as in Berlin toast format
	AVCodecIdGsm AVCodecID = C.AV_CODEC_ID_GSM
	// AVCodecIdQdm2 wraps AV_CODEC_ID_QDM2.
	AVCodecIdQdm2 AVCodecID = C.AV_CODEC_ID_QDM2
	// AVCodecIdCook wraps AV_CODEC_ID_COOK.
	AVCodecIdCook AVCodecID = C.AV_CODEC_ID_COOK
	// AVCodecIdTruespeech wraps AV_CODEC_ID_TRUESPEECH.
	AVCodecIdTruespeech AVCodecID = C.AV_CODEC_ID_TRUESPEECH
	// AVCodecIdTta wraps AV_CODEC_ID_TTA.
	AVCodecIdTta AVCodecID = C.AV_CODEC_ID_TTA
	// AVCodecIdSmackaudio wraps AV_CODEC_ID_SMACKAUDIO.
	AVCodecIdSmackaudio AVCodecID = C.AV_CODEC_ID_SMACKAUDIO
	// AVCodecIdQcelp wraps AV_CODEC_ID_QCELP.
	AVCodecIdQcelp AVCodecID = C.AV_CODEC_ID_QCELP
	// AVCodecIdWavpack wraps AV_CODEC_ID_WAVPACK.
	AVCodecIdWavpack AVCodecID = C.AV_CODEC_ID_WAVPACK
	// AVCodecIdDsicinaudio wraps AV_CODEC_ID_DSICINAUDIO.
	AVCodecIdDsicinaudio AVCodecID = C.AV_CODEC_ID_DSICINAUDIO
	// AVCodecIdImc wraps AV_CODEC_ID_IMC.
	AVCodecIdImc AVCodecID = C.AV_CODEC_ID_IMC
	// AVCodecIdMusepack7 wraps AV_CODEC_ID_MUSEPACK7.
	AVCodecIdMusepack7 AVCodecID = C.AV_CODEC_ID_MUSEPACK7
	// AVCodecIdMlp wraps AV_CODEC_ID_MLP.
	AVCodecIdMlp AVCodecID = C.AV_CODEC_ID_MLP
	// AVCodecIdGsmMs wraps AV_CODEC_ID_GSM_MS.
	//
	//	as found in WAV
	AVCodecIdGsmMs AVCodecID = C.AV_CODEC_ID_GSM_MS
	// AVCodecIdAtrac3 wraps AV_CODEC_ID_ATRAC3.
	AVCodecIdAtrac3 AVCodecID = C.AV_CODEC_ID_ATRAC3
	// AVCodecIdApe wraps AV_CODEC_ID_APE.
	AVCodecIdApe AVCodecID = C.AV_CODEC_ID_APE
	// AVCodecIdNellymoser wraps AV_CODEC_ID_NELLYMOSER.
	AVCodecIdNellymoser AVCodecID = C.AV_CODEC_ID_NELLYMOSER
	// AVCodecIdMusepack8 wraps AV_CODEC_ID_MUSEPACK8.
	AVCodecIdMusepack8 AVCodecID = C.AV_CODEC_ID_MUSEPACK8
	// AVCodecIdSpeex wraps AV_CODEC_ID_SPEEX.
	AVCodecIdSpeex AVCodecID = C.AV_CODEC_ID_SPEEX
	// AVCodecIdWmavoice wraps AV_CODEC_ID_WMAVOICE.
	AVCodecIdWmavoice AVCodecID = C.AV_CODEC_ID_WMAVOICE
	// AVCodecIdWmapro wraps AV_CODEC_ID_WMAPRO.
	AVCodecIdWmapro AVCodecID = C.AV_CODEC_ID_WMAPRO
	// AVCodecIdWmalossless wraps AV_CODEC_ID_WMALOSSLESS.
	AVCodecIdWmalossless AVCodecID = C.AV_CODEC_ID_WMALOSSLESS
	// AVCodecIdAtrac3P wraps AV_CODEC_ID_ATRAC3P.
	AVCodecIdAtrac3P AVCodecID = C.AV_CODEC_ID_ATRAC3P
	// AVCodecIdEac3 wraps AV_CODEC_ID_EAC3.
	AVCodecIdEac3 AVCodecID = C.AV_CODEC_ID_EAC3
	// AVCodecIdSipr wraps AV_CODEC_ID_SIPR.
	AVCodecIdSipr AVCodecID = C.AV_CODEC_ID_SIPR
	// AVCodecIdMp1 wraps AV_CODEC_ID_MP1.
	AVCodecIdMp1 AVCodecID = C.AV_CODEC_ID_MP1
	// AVCodecIdTwinvq wraps AV_CODEC_ID_TWINVQ.
	AVCodecIdTwinvq AVCodecID = C.AV_CODEC_ID_TWINVQ
	// AVCodecIdTruehd wraps AV_CODEC_ID_TRUEHD.
	AVCodecIdTruehd AVCodecID = C.AV_CODEC_ID_TRUEHD
	// AVCodecIdMp4Als wraps AV_CODEC_ID_MP4ALS.
	AVCodecIdMp4Als AVCodecID = C.AV_CODEC_ID_MP4ALS
	// AVCodecIdAtrac1 wraps AV_CODEC_ID_ATRAC1.
	AVCodecIdAtrac1 AVCodecID = C.AV_CODEC_ID_ATRAC1
	// AVCodecIdBinkaudioRdft wraps AV_CODEC_ID_BINKAUDIO_RDFT.
	AVCodecIdBinkaudioRdft AVCodecID = C.AV_CODEC_ID_BINKAUDIO_RDFT
	// AVCodecIdBinkaudioDct wraps AV_CODEC_ID_BINKAUDIO_DCT.
	AVCodecIdBinkaudioDct AVCodecID = C.AV_CODEC_ID_BINKAUDIO_DCT
	// AVCodecIdAacLatm wraps AV_CODEC_ID_AAC_LATM.
	AVCodecIdAacLatm AVCodecID = C.AV_CODEC_ID_AAC_LATM
	// AVCodecIdQdmc wraps AV_CODEC_ID_QDMC.
	AVCodecIdQdmc AVCodecID = C.AV_CODEC_ID_QDMC
	// AVCodecIdCelt wraps AV_CODEC_ID_CELT.
	AVCodecIdCelt AVCodecID = C.AV_CODEC_ID_CELT
	// AVCodecIdG7231 wraps AV_CODEC_ID_G723_1.
	AVCodecIdG7231 AVCodecID = C.AV_CODEC_ID_G723_1
	// AVCodecIdG729 wraps AV_CODEC_ID_G729.
	AVCodecIdG729 AVCodecID = C.AV_CODEC_ID_G729
	// AVCodecId8SvxExp wraps AV_CODEC_ID_8SVX_EXP.
	AVCodecId8SvxExp AVCodecID = C.AV_CODEC_ID_8SVX_EXP
	// AVCodecId8SvxFib wraps AV_CODEC_ID_8SVX_FIB.
	AVCodecId8SvxFib AVCodecID = C.AV_CODEC_ID_8SVX_FIB
	// AVCodecIdBmvAudio wraps AV_CODEC_ID_BMV_AUDIO.
	AVCodecIdBmvAudio AVCodecID = C.AV_CODEC_ID_BMV_AUDIO
	// AVCodecIdRalf wraps AV_CODEC_ID_RALF.
	AVCodecIdRalf AVCodecID = C.AV_CODEC_ID_RALF
	// AVCodecIdIac wraps AV_CODEC_ID_IAC.
	AVCodecIdIac AVCodecID = C.AV_CODEC_ID_IAC
	// AVCodecIdIlbc wraps AV_CODEC_ID_ILBC.
	AVCodecIdIlbc AVCodecID = C.AV_CODEC_ID_ILBC
	// AVCodecIdOpus wraps AV_CODEC_ID_OPUS.
	AVCodecIdOpus AVCodecID = C.AV_CODEC_ID_OPUS
	// AVCodecIdComfortNoise wraps AV_CODEC_ID_COMFORT_NOISE.
	AVCodecIdComfortNoise AVCodecID = C.AV_CODEC_ID_COMFORT_NOISE
	// AVCodecIdTak wraps AV_CODEC_ID_TAK.
	AVCodecIdTak AVCodecID = C.AV_CODEC_ID_TAK
	// AVCodecIdMetasound wraps AV_CODEC_ID_METASOUND.
	AVCodecIdMetasound AVCodecID = C.AV_CODEC_ID_METASOUND
	// AVCodecIdPafAudio wraps AV_CODEC_ID_PAF_AUDIO.
	AVCodecIdPafAudio AVCodecID = C.AV_CODEC_ID_PAF_AUDIO
	// AVCodecIdOn2AVC wraps AV_CODEC_ID_ON2AVC.
	AVCodecIdOn2AVC AVCodecID = C.AV_CODEC_ID_ON2AVC
	// AVCodecIdDssSp wraps AV_CODEC_ID_DSS_SP.
	AVCodecIdDssSp AVCodecID = C.AV_CODEC_ID_DSS_SP
	// AVCodecIdCodec2 wraps AV_CODEC_ID_CODEC2.
	AVCodecIdCodec2 AVCodecID = C.AV_CODEC_ID_CODEC2
	// AVCodecIdFFWavesynth wraps AV_CODEC_ID_FFWAVESYNTH.
	AVCodecIdFFWavesynth AVCodecID = C.AV_CODEC_ID_FFWAVESYNTH
	// AVCodecIdSonic wraps AV_CODEC_ID_SONIC.
	AVCodecIdSonic AVCodecID = C.AV_CODEC_ID_SONIC
	// AVCodecIdSonicLs wraps AV_CODEC_ID_SONIC_LS.
	AVCodecIdSonicLs AVCodecID = C.AV_CODEC_ID_SONIC_LS
	// AVCodecIdEvrc wraps AV_CODEC_ID_EVRC.
	AVCodecIdEvrc AVCodecID = C.AV_CODEC_ID_EVRC
	// AVCodecIdSmv wraps AV_CODEC_ID_SMV.
	AVCodecIdSmv AVCodecID = C.AV_CODEC_ID_SMV
	// AVCodecIdDsdLsbf wraps AV_CODEC_ID_DSD_LSBF.
	AVCodecIdDsdLsbf AVCodecID = C.AV_CODEC_ID_DSD_LSBF
	// AVCodecIdDsdMsbf wraps AV_CODEC_ID_DSD_MSBF.
	AVCodecIdDsdMsbf AVCodecID = C.AV_CODEC_ID_DSD_MSBF
	// AVCodecIdDsdLsbfPlanar wraps AV_CODEC_ID_DSD_LSBF_PLANAR.
	AVCodecIdDsdLsbfPlanar AVCodecID = C.AV_CODEC_ID_DSD_LSBF_PLANAR
	// AVCodecIdDsdMsbfPlanar wraps AV_CODEC_ID_DSD_MSBF_PLANAR.
	AVCodecIdDsdMsbfPlanar AVCodecID = C.AV_CODEC_ID_DSD_MSBF_PLANAR
	// AVCodecId4Gv wraps AV_CODEC_ID_4GV.
	AVCodecId4Gv AVCodecID = C.AV_CODEC_ID_4GV
	// AVCodecIdInterplayAcm wraps AV_CODEC_ID_INTERPLAY_ACM.
	AVCodecIdInterplayAcm AVCodecID = C.AV_CODEC_ID_INTERPLAY_ACM
	// AVCodecIdXma1 wraps AV_CODEC_ID_XMA1.
	AVCodecIdXma1 AVCodecID = C.AV_CODEC_ID_XMA1
	// AVCodecIdXma2 wraps AV_CODEC_ID_XMA2.
	AVCodecIdXma2 AVCodecID = C.AV_CODEC_ID_XMA2
	// AVCodecIdDst wraps AV_CODEC_ID_DST.
	AVCodecIdDst AVCodecID = C.AV_CODEC_ID_DST
	// AVCodecIdAtrac3Al wraps AV_CODEC_ID_ATRAC3AL.
	AVCodecIdAtrac3Al AVCodecID = C.AV_CODEC_ID_ATRAC3AL
	// AVCodecIdAtrac3Pal wraps AV_CODEC_ID_ATRAC3PAL.
	AVCodecIdAtrac3Pal AVCodecID = C.AV_CODEC_ID_ATRAC3PAL
	// AVCodecIdDolbyE wraps AV_CODEC_ID_DOLBY_E.
	AVCodecIdDolbyE AVCodecID = C.AV_CODEC_ID_DOLBY_E
	// AVCodecIdAptx wraps AV_CODEC_ID_APTX.
	AVCodecIdAptx AVCodecID = C.AV_CODEC_ID_APTX
	// AVCodecIdAptxHd wraps AV_CODEC_ID_APTX_HD.
	AVCodecIdAptxHd AVCodecID = C.AV_CODEC_ID_APTX_HD
	// AVCodecIdSbc wraps AV_CODEC_ID_SBC.
	AVCodecIdSbc AVCodecID = C.AV_CODEC_ID_SBC
	// AVCodecIdAtrac9 wraps AV_CODEC_ID_ATRAC9.
	AVCodecIdAtrac9 AVCodecID = C.AV_CODEC_ID_ATRAC9
	// AVCodecIdHcom wraps AV_CODEC_ID_HCOM.
	AVCodecIdHcom AVCodecID = C.AV_CODEC_ID_HCOM
	// AVCodecIdAcelpKelvin wraps AV_CODEC_ID_ACELP_KELVIN.
	AVCodecIdAcelpKelvin AVCodecID = C.AV_CODEC_ID_ACELP_KELVIN
	// AVCodecIdMpegh3DAudio wraps AV_CODEC_ID_MPEGH_3D_AUDIO.
	AVCodecIdMpegh3DAudio AVCodecID = C.AV_CODEC_ID_MPEGH_3D_AUDIO
	// AVCodecIdSiren wraps AV_CODEC_ID_SIREN.
	AVCodecIdSiren AVCodecID = C.AV_CODEC_ID_SIREN
	// AVCodecIdHca wraps AV_CODEC_ID_HCA.
	AVCodecIdHca AVCodecID = C.AV_CODEC_ID_HCA
	// AVCodecIdFastaudio wraps AV_CODEC_ID_FASTAUDIO.
	AVCodecIdFastaudio AVCodecID = C.AV_CODEC_ID_FASTAUDIO
	// AVCodecIdMsnsiren wraps AV_CODEC_ID_MSNSIREN.
	AVCodecIdMsnsiren AVCodecID = C.AV_CODEC_ID_MSNSIREN
	// AVCodecIdDfpwm wraps AV_CODEC_ID_DFPWM.
	AVCodecIdDfpwm AVCodecID = C.AV_CODEC_ID_DFPWM
	// AVCodecIdBonk wraps AV_CODEC_ID_BONK.
	AVCodecIdBonk AVCodecID = C.AV_CODEC_ID_BONK
	// AVCodecIdMisc4 wraps AV_CODEC_ID_MISC4.
	AVCodecIdMisc4 AVCodecID = C.AV_CODEC_ID_MISC4
	// AVCodecIdApac wraps AV_CODEC_ID_APAC.
	AVCodecIdApac AVCodecID = C.AV_CODEC_ID_APAC
	// AVCodecIdFtr wraps AV_CODEC_ID_FTR.
	AVCodecIdFtr AVCodecID = C.AV_CODEC_ID_FTR
	// AVCodecIdWavarc wraps AV_CODEC_ID_WAVARC.
	AVCodecIdWavarc AVCodecID = C.AV_CODEC_ID_WAVARC
	// AVCodecIdRka wraps AV_CODEC_ID_RKA.
	AVCodecIdRka AVCodecID = C.AV_CODEC_ID_RKA
	// AVCodecIdAc4 wraps AV_CODEC_ID_AC4.
	AVCodecIdAc4 AVCodecID = C.AV_CODEC_ID_AC4
	// AVCodecIdOsq wraps AV_CODEC_ID_OSQ.
	AVCodecIdOsq AVCodecID = C.AV_CODEC_ID_OSQ
	// AVCodecIdQoa wraps AV_CODEC_ID_QOA.
	AVCodecIdQoa AVCodecID = C.AV_CODEC_ID_QOA
	// AVCodecIdLc3 wraps AV_CODEC_ID_LC3.
	AVCodecIdLc3 AVCodecID = C.AV_CODEC_ID_LC3
	// AVCodecIdG728 wraps AV_CODEC_ID_G728.
	AVCodecIdG728 AVCodecID = C.AV_CODEC_ID_G728
	// AVCodecIdFirstSubtitle wraps AV_CODEC_ID_FIRST_SUBTITLE.
	//
	//	A dummy ID pointing at the start of subtitle codecs.
	AVCodecIdFirstSubtitle AVCodecID = C.AV_CODEC_ID_FIRST_SUBTITLE
	// AVCodecIdDvdSubtitle wraps AV_CODEC_ID_DVD_SUBTITLE.
	AVCodecIdDvdSubtitle AVCodecID = C.AV_CODEC_ID_DVD_SUBTITLE
	// AVCodecIdDvbSubtitle wraps AV_CODEC_ID_DVB_SUBTITLE.
	AVCodecIdDvbSubtitle AVCodecID = C.AV_CODEC_ID_DVB_SUBTITLE
	// AVCodecIdText wraps AV_CODEC_ID_TEXT.
	//
	//	raw UTF-8 text
	AVCodecIdText AVCodecID = C.AV_CODEC_ID_TEXT
	// AVCodecIdXsub wraps AV_CODEC_ID_XSUB.
	AVCodecIdXsub AVCodecID = C.AV_CODEC_ID_XSUB
	// AVCodecIdSsa wraps AV_CODEC_ID_SSA.
	AVCodecIdSsa AVCodecID = C.AV_CODEC_ID_SSA
	// AVCodecIdMovText wraps AV_CODEC_ID_MOV_TEXT.
	AVCodecIdMovText AVCodecID = C.AV_CODEC_ID_MOV_TEXT
	// AVCodecIdHdmvPgsSubtitle wraps AV_CODEC_ID_HDMV_PGS_SUBTITLE.
	AVCodecIdHdmvPgsSubtitle AVCodecID = C.AV_CODEC_ID_HDMV_PGS_SUBTITLE
	// AVCodecIdDvbTeletext wraps AV_CODEC_ID_DVB_TELETEXT.
	AVCodecIdDvbTeletext AVCodecID = C.AV_CODEC_ID_DVB_TELETEXT
	// AVCodecIdSrt wraps AV_CODEC_ID_SRT.
	AVCodecIdSrt AVCodecID = C.AV_CODEC_ID_SRT
	// AVCodecIdMicrodvd wraps AV_CODEC_ID_MICRODVD.
	AVCodecIdMicrodvd AVCodecID = C.AV_CODEC_ID_MICRODVD
	// AVCodecIdEia608 wraps AV_CODEC_ID_EIA_608.
	AVCodecIdEia608 AVCodecID = C.AV_CODEC_ID_EIA_608
	// AVCodecIdJacosub wraps AV_CODEC_ID_JACOSUB.
	AVCodecIdJacosub AVCodecID = C.AV_CODEC_ID_JACOSUB
	// AVCodecIdSami wraps AV_CODEC_ID_SAMI.
	AVCodecIdSami AVCodecID = C.AV_CODEC_ID_SAMI
	// AVCodecIdRealtext wraps AV_CODEC_ID_REALTEXT.
	AVCodecIdRealtext AVCodecID = C.AV_CODEC_ID_REALTEXT
	// AVCodecIdStl wraps AV_CODEC_ID_STL.
	AVCodecIdStl AVCodecID = C.AV_CODEC_ID_STL
	// AVCodecIdSubviewer1 wraps AV_CODEC_ID_SUBVIEWER1.
	AVCodecIdSubviewer1 AVCodecID = C.AV_CODEC_ID_SUBVIEWER1
	// AVCodecIdSubviewer wraps AV_CODEC_ID_SUBVIEWER.
	AVCodecIdSubviewer AVCodecID = C.AV_CODEC_ID_SUBVIEWER
	// AVCodecIdSubrip wraps AV_CODEC_ID_SUBRIP.
	AVCodecIdSubrip AVCodecID = C.AV_CODEC_ID_SUBRIP
	// AVCodecIdWebvtt wraps AV_CODEC_ID_WEBVTT.
	AVCodecIdWebvtt AVCodecID = C.AV_CODEC_ID_WEBVTT
	// AVCodecIdMpl2 wraps AV_CODEC_ID_MPL2.
	AVCodecIdMpl2 AVCodecID = C.AV_CODEC_ID_MPL2
	// AVCodecIdVplayer wraps AV_CODEC_ID_VPLAYER.
	AVCodecIdVplayer AVCodecID = C.AV_CODEC_ID_VPLAYER
	// AVCodecIdPjs wraps AV_CODEC_ID_PJS.
	AVCodecIdPjs AVCodecID = C.AV_CODEC_ID_PJS
	// AVCodecIdAss wraps AV_CODEC_ID_ASS.
	AVCodecIdAss AVCodecID = C.AV_CODEC_ID_ASS
	// AVCodecIdHdmvTextSubtitle wraps AV_CODEC_ID_HDMV_TEXT_SUBTITLE.
	AVCodecIdHdmvTextSubtitle AVCodecID = C.AV_CODEC_ID_HDMV_TEXT_SUBTITLE
	// AVCodecIdTtml wraps AV_CODEC_ID_TTML.
	AVCodecIdTtml AVCodecID = C.AV_CODEC_ID_TTML
	// AVCodecIdAribCaption wraps AV_CODEC_ID_ARIB_CAPTION.
	AVCodecIdAribCaption AVCodecID = C.AV_CODEC_ID_ARIB_CAPTION
	// AVCodecIdIvtvVbi wraps AV_CODEC_ID_IVTV_VBI.
	AVCodecIdIvtvVbi AVCodecID = C.AV_CODEC_ID_IVTV_VBI
	// AVCodecIdFirstUnknown wraps AV_CODEC_ID_FIRST_UNKNOWN.
	//
	//	A dummy ID pointing at the start of various fake codecs.
	AVCodecIdFirstUnknown AVCodecID = C.AV_CODEC_ID_FIRST_UNKNOWN
	// AVCodecIdTtf wraps AV_CODEC_ID_TTF.
	AVCodecIdTtf AVCodecID = C.AV_CODEC_ID_TTF
	// AVCodecIdScte35 wraps AV_CODEC_ID_SCTE_35.
	//
	//	Contain timestamp estimated through PCR of program stream.
	AVCodecIdScte35 AVCodecID = C.AV_CODEC_ID_SCTE_35
	// AVCodecIdEpg wraps AV_CODEC_ID_EPG.
	AVCodecIdEpg AVCodecID = C.AV_CODEC_ID_EPG
	// AVCodecIdBintext wraps AV_CODEC_ID_BINTEXT.
	AVCodecIdBintext AVCodecID = C.AV_CODEC_ID_BINTEXT
	// AVCodecIdXbin wraps AV_CODEC_ID_XBIN.
	AVCodecIdXbin AVCodecID = C.AV_CODEC_ID_XBIN
	// AVCodecIdIdf wraps AV_CODEC_ID_IDF.
	AVCodecIdIdf AVCodecID = C.AV_CODEC_ID_IDF
	// AVCodecIdOtf wraps AV_CODEC_ID_OTF.
	AVCodecIdOtf AVCodecID = C.AV_CODEC_ID_OTF
	// AVCodecIdSmpteKlv wraps AV_CODEC_ID_SMPTE_KLV.
	AVCodecIdSmpteKlv AVCodecID = C.AV_CODEC_ID_SMPTE_KLV
	// AVCodecIdDvdNav wraps AV_CODEC_ID_DVD_NAV.
	AVCodecIdDvdNav AVCodecID = C.AV_CODEC_ID_DVD_NAV
	// AVCodecIdTimedId3 wraps AV_CODEC_ID_TIMED_ID3.
	AVCodecIdTimedId3 AVCodecID = C.AV_CODEC_ID_TIMED_ID3
	// AVCodecIdBinData wraps AV_CODEC_ID_BIN_DATA.
	AVCodecIdBinData AVCodecID = C.AV_CODEC_ID_BIN_DATA
	// AVCodecIdSmpte2038 wraps AV_CODEC_ID_SMPTE_2038.
	AVCodecIdSmpte2038 AVCodecID = C.AV_CODEC_ID_SMPTE_2038
	// AVCodecIdLcevc wraps AV_CODEC_ID_LCEVC.
	AVCodecIdLcevc AVCodecID = C.AV_CODEC_ID_LCEVC
	// AVCodecIdSmpte436MAnc wraps AV_CODEC_ID_SMPTE_436M_ANC.
	AVCodecIdSmpte436MAnc AVCodecID = C.AV_CODEC_ID_SMPTE_436M_ANC
	// AVCodecIdProbe wraps AV_CODEC_ID_PROBE.
	//
	//	codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
	AVCodecIdProbe AVCodecID = C.AV_CODEC_ID_PROBE
	// AVCodecIdMpeg2Ts wraps AV_CODEC_ID_MPEG2TS.
	/*
	   < _FAKE_ codec to indicate a raw MPEG-2 TS
	   stream (only used by libavformat)
	*/
	AVCodecIdMpeg2Ts AVCodecID = C.AV_CODEC_ID_MPEG2TS
	// AVCodecIdMpeg4Systems wraps AV_CODEC_ID_MPEG4SYSTEMS.
	/*
	   < _FAKE_ codec to indicate a MPEG-4 Systems
	   stream (only used by libavformat)
	*/
	AVCodecIdMpeg4Systems AVCodecID = C.AV_CODEC_ID_MPEG4SYSTEMS
	// AVCodecIdFFMetadata wraps AV_CODEC_ID_FFMETADATA.
	//
	//	Dummy codec for streams containing only metadata information.
	AVCodecIdFFMetadata AVCodecID = C.AV_CODEC_ID_FFMETADATA
	// AVCodecIdWrappedAVFrame wraps AV_CODEC_ID_WRAPPED_AVFRAME.
	//
	//	Passthrough codec, AVFrames wrapped in AVPacket
	AVCodecIdWrappedAVFrame AVCodecID = C.AV_CODEC_ID_WRAPPED_AVFRAME
	// AVCodecIdVnull wraps AV_CODEC_ID_VNULL.
	/*
	   Dummy null video codec, useful mainly for development and debugging.
	   Null encoder/decoder discard all input and never return any output.
	*/
	AVCodecIdVnull AVCodecID = C.AV_CODEC_ID_VNULL
	// AVCodecIdAnull wraps AV_CODEC_ID_ANULL.
	/*
	   Dummy null audio codec, useful mainly for development and debugging.
	   Null encoder/decoder discard all input and never return any output.
	*/
	AVCodecIdAnull AVCodecID = C.AV_CODEC_ID_ANULL
)

// --- Enum AVFieldOrder ---

// AVFieldOrder wraps AVFieldOrder.
type AVFieldOrder C.enum_AVFieldOrder

const SizeOfAVFieldOrder = C.sizeof_enum_AVFieldOrder

func ToAVFieldOrderArray(ptr unsafe.Pointer) *Array[AVFieldOrder] {
	if ptr == nil {
		return nil
	}

	return &Array[AVFieldOrder]{
		elemSize: SizeOfAVFieldOrder,
		loadPtr: func(pointer unsafe.Pointer) AVFieldOrder {
			ptr := (*AVFieldOrder)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVFieldOrder) {
			ptr := (*AVFieldOrder)(pointer)
			*ptr = value
		},
	}
}

func AllocAVFieldOrderArray(size uint64) *Array[AVFieldOrder] {
	return ToAVFieldOrderArray(AVCalloc(size, SizeOfAVFieldOrder))
}

const (
	// AVFieldUnknown wraps AV_FIELD_UNKNOWN.
	AVFieldUnknown AVFieldOrder = C.AV_FIELD_UNKNOWN
	// AVFieldProgressive wraps AV_FIELD_PROGRESSIVE.
	AVFieldProgressive AVFieldOrder = C.AV_FIELD_PROGRESSIVE
	// AVFieldTt wraps AV_FIELD_TT.
	//
	//	Top coded_first, top displayed first
	AVFieldTt AVFieldOrder = C.AV_FIELD_TT
	// AVFieldBb wraps AV_FIELD_BB.
	//
	//	Bottom coded first, bottom displayed first
	AVFieldBb AVFieldOrder = C.AV_FIELD_BB
	// AVFieldTb wraps AV_FIELD_TB.
	//
	//	Top coded first, bottom displayed first
	AVFieldTb AVFieldOrder = C.AV_FIELD_TB
	// AVFieldBt wraps AV_FIELD_BT.
	//
	//	Bottom coded first, top displayed first
	AVFieldBt AVFieldOrder = C.AV_FIELD_BT
)

// --- Enum AVDiscard ---

// AVDiscard wraps AVDiscard.
type AVDiscard C.enum_AVDiscard

const SizeOfAVDiscard = C.sizeof_enum_AVDiscard

func ToAVDiscardArray(ptr unsafe.Pointer) *Array[AVDiscard] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDiscard]{
		elemSize: SizeOfAVDiscard,
		loadPtr: func(pointer unsafe.Pointer) AVDiscard {
			ptr := (*AVDiscard)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDiscard) {
			ptr := (*AVDiscard)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDiscardArray(size uint64) *Array[AVDiscard] {
	return ToAVDiscardArray(AVCalloc(size, SizeOfAVDiscard))
}

const (
	// AVDiscardNone wraps AVDISCARD_NONE.
	//
	//	discard nothing
	AVDiscardNone AVDiscard = C.AVDISCARD_NONE
	// AVDiscardDefault wraps AVDISCARD_DEFAULT.
	//
	//	discard useless packets like 0 size packets in avi
	AVDiscardDefault AVDiscard = C.AVDISCARD_DEFAULT
	// AVDiscardNonref wraps AVDISCARD_NONREF.
	//
	//	discard all non reference
	AVDiscardNonref AVDiscard = C.AVDISCARD_NONREF
	// AVDiscardBidir wraps AVDISCARD_BIDIR.
	//
	//	discard all bidirectional frames
	AVDiscardBidir AVDiscard = C.AVDISCARD_BIDIR
	// AVDiscardNonintra wraps AVDISCARD_NONINTRA.
	//
	//	discard all non intra frames
	AVDiscardNonintra AVDiscard = C.AVDISCARD_NONINTRA
	// AVDiscardNonkey wraps AVDISCARD_NONKEY.
	//
	//	discard all frames except keyframes
	AVDiscardNonkey AVDiscard = C.AVDISCARD_NONKEY
	// AVDiscardAll wraps AVDISCARD_ALL.
	//
	//	discard all
	AVDiscardAll AVDiscard = C.AVDISCARD_ALL
)

// --- Enum AVAudioServiceType ---

// AVAudioServiceType wraps AVAudioServiceType.
type AVAudioServiceType C.enum_AVAudioServiceType

const SizeOfAVAudioServiceType = C.sizeof_enum_AVAudioServiceType

func ToAVAudioServiceTypeArray(ptr unsafe.Pointer) *Array[AVAudioServiceType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVAudioServiceType]{
		elemSize: SizeOfAVAudioServiceType,
		loadPtr: func(pointer unsafe.Pointer) AVAudioServiceType {
			ptr := (*AVAudioServiceType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVAudioServiceType) {
			ptr := (*AVAudioServiceType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVAudioServiceTypeArray(size uint64) *Array[AVAudioServiceType] {
	return ToAVAudioServiceTypeArray(AVCalloc(size, SizeOfAVAudioServiceType))
}

const (
	// AVAudioServiceTypeMain wraps AV_AUDIO_SERVICE_TYPE_MAIN.
	AVAudioServiceTypeMain AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_MAIN
	// AVAudioServiceTypeEffects wraps AV_AUDIO_SERVICE_TYPE_EFFECTS.
	AVAudioServiceTypeEffects AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_EFFECTS
	// AVAudioServiceTypeVisuallyImpaired wraps AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED.
	AVAudioServiceTypeVisuallyImpaired AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED
	// AVAudioServiceTypeHearingImpaired wraps AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED.
	AVAudioServiceTypeHearingImpaired AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED
	// AVAudioServiceTypeDialogue wraps AV_AUDIO_SERVICE_TYPE_DIALOGUE.
	AVAudioServiceTypeDialogue AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_DIALOGUE
	// AVAudioServiceTypeCommentary wraps AV_AUDIO_SERVICE_TYPE_COMMENTARY.
	AVAudioServiceTypeCommentary AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_COMMENTARY
	// AVAudioServiceTypeEmergency wraps AV_AUDIO_SERVICE_TYPE_EMERGENCY.
	AVAudioServiceTypeEmergency AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_EMERGENCY
	// AVAudioServiceTypeVoiceOver wraps AV_AUDIO_SERVICE_TYPE_VOICE_OVER.
	AVAudioServiceTypeVoiceOver AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_VOICE_OVER
	// AVAudioServiceTypeKaraoke wraps AV_AUDIO_SERVICE_TYPE_KARAOKE.
	AVAudioServiceTypeKaraoke AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_KARAOKE
	// AVAudioServiceTypeNb wraps AV_AUDIO_SERVICE_TYPE_NB.
	//
	//	Not part of ABI
	AVAudioServiceTypeNb AVAudioServiceType = C.AV_AUDIO_SERVICE_TYPE_NB
)

// --- Enum AVPacketSideDataType ---

// AVPacketSideDataType wraps AVPacketSideDataType.
type AVPacketSideDataType C.enum_AVPacketSideDataType

const SizeOfAVPacketSideDataType = C.sizeof_enum_AVPacketSideDataType

func ToAVPacketSideDataTypeArray(ptr unsafe.Pointer) *Array[AVPacketSideDataType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVPacketSideDataType]{
		elemSize: SizeOfAVPacketSideDataType,
		loadPtr: func(pointer unsafe.Pointer) AVPacketSideDataType {
			ptr := (*AVPacketSideDataType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVPacketSideDataType) {
			ptr := (*AVPacketSideDataType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVPacketSideDataTypeArray(size uint64) *Array[AVPacketSideDataType] {
	return ToAVPacketSideDataTypeArray(AVCalloc(size, SizeOfAVPacketSideDataType))
}

const (
	// AVPktDataPalette wraps AV_PKT_DATA_PALETTE.
	/*
	   An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
	   bytes worth of palette. This side data signals that a new palette is
	   present.
	*/
	AVPktDataPalette AVPacketSideDataType = C.AV_PKT_DATA_PALETTE
	// AVPktDataNewExtradata wraps AV_PKT_DATA_NEW_EXTRADATA.
	/*
	   The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
	   that the extradata buffer was changed and the receiving side should
	   act upon it appropriately. The new extradata is embedded in the side
	   data buffer and should be immediately used for processing the current
	   frame or packet.
	*/
	AVPktDataNewExtradata AVPacketSideDataType = C.AV_PKT_DATA_NEW_EXTRADATA
	// AVPktDataParamChange wraps AV_PKT_DATA_PARAM_CHANGE.
	/*
	   An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
	   @code
	   u32le param_flags
	   if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
	       s32le sample_rate
	   if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
	       s32le width
	       s32le height
	   @endcode
	*/
	AVPktDataParamChange AVPacketSideDataType = C.AV_PKT_DATA_PARAM_CHANGE
	// AVPktDataH263MbInfo wraps AV_PKT_DATA_H263_MB_INFO.
	/*
	   An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
	   structures with info about macroblocks relevant to splitting the
	   packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
	   That is, it does not necessarily contain info about all macroblocks,
	   as long as the distance between macroblocks in the info is smaller
	   than the target payload size.
	   Each MB info structure is 12 bytes, and is laid out as follows:
	   @code
	   u32le bit offset from the start of the packet
	   u8    current quantizer at the start of the macroblock
	   u8    GOB number
	   u16le macroblock address within the GOB
	   u8    horizontal MV predictor
	   u8    vertical MV predictor
	   u8    horizontal MV predictor for block number 3
	   u8    vertical MV predictor for block number 3
	   @endcode
	*/
	AVPktDataH263MbInfo AVPacketSideDataType = C.AV_PKT_DATA_H263_MB_INFO
	// AVPktDataReplaygain wraps AV_PKT_DATA_REPLAYGAIN.
	/*
	   This side data should be associated with an audio stream and contains
	   ReplayGain information in form of the AVReplayGain struct.
	*/
	AVPktDataReplaygain AVPacketSideDataType = C.AV_PKT_DATA_REPLAYGAIN
	// AVPktDataDisplaymatrix wraps AV_PKT_DATA_DISPLAYMATRIX.
	/*
	   This side data contains a 3x3 transformation matrix describing an affine
	   transformation that needs to be applied to the decoded video frames for
	   correct presentation.

	   See libavutil/display.h for a detailed description of the data.
	*/
	AVPktDataDisplaymatrix AVPacketSideDataType = C.AV_PKT_DATA_DISPLAYMATRIX
	// AVPktDataStereo3D wraps AV_PKT_DATA_STEREO3D.
	/*
	   This side data should be associated with a video stream and contains
	   Stereoscopic 3D information in form of the AVStereo3D struct.
	*/
	AVPktDataStereo3D AVPacketSideDataType = C.AV_PKT_DATA_STEREO3D
	// AVPktDataAudioServiceType wraps AV_PKT_DATA_AUDIO_SERVICE_TYPE.
	/*
	   This side data should be associated with an audio stream and corresponds
	   to enum AVAudioServiceType.
	*/
	AVPktDataAudioServiceType AVPacketSideDataType = C.AV_PKT_DATA_AUDIO_SERVICE_TYPE
	// AVPktDataQualityStats wraps AV_PKT_DATA_QUALITY_STATS.
	/*
	   This side data contains quality related information from the encoder.
	   @code
	   u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
	   u8    picture type
	   u8    error count
	   u16   reserved
	   u64le[error count] sum of squared differences between encoder in and output
	   @endcode
	*/
	AVPktDataQualityStats AVPacketSideDataType = C.AV_PKT_DATA_QUALITY_STATS
	// AVPktDataFallbackTrack wraps AV_PKT_DATA_FALLBACK_TRACK.
	/*
	   This side data contains an integer value representing the stream index
	   of a "fallback" track.  A fallback track indicates an alternate
	   track to use when the current track can not be decoded for some reason.
	   e.g. no decoder available for codec.
	*/
	AVPktDataFallbackTrack AVPacketSideDataType = C.AV_PKT_DATA_FALLBACK_TRACK
	// AVPktDataCpbProperties wraps AV_PKT_DATA_CPB_PROPERTIES.
	//
	//	This side data corresponds to the AVCPBProperties struct.
	AVPktDataCpbProperties AVPacketSideDataType = C.AV_PKT_DATA_CPB_PROPERTIES
	// AVPktDataSkipSamples wraps AV_PKT_DATA_SKIP_SAMPLES.
	/*
	   Recommends skipping the specified number of samples
	   @code
	   u32le number of samples to skip from start of this packet
	   u32le number of samples to skip from end of this packet
	   u8    reason for start skip
	   u8    reason for end   skip (0=padding silence, 1=convergence)
	   @endcode
	*/
	AVPktDataSkipSamples AVPacketSideDataType = C.AV_PKT_DATA_SKIP_SAMPLES
	// AVPktDataJpDualmono wraps AV_PKT_DATA_JP_DUALMONO.
	/*
	   An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
	   the packet may contain "dual mono" audio specific to Japanese DTV
	   and if it is true, recommends only the selected channel to be used.
	   @code
	   u8    selected channels (0=main/left, 1=sub/right, 2=both)
	   @endcode
	*/
	AVPktDataJpDualmono AVPacketSideDataType = C.AV_PKT_DATA_JP_DUALMONO
	// AVPktDataStringsMetadata wraps AV_PKT_DATA_STRINGS_METADATA.
	/*
	   A list of zero terminated key/value strings. There is no end marker for
	   the list, so it is required to rely on the side data size to stop.
	*/
	AVPktDataStringsMetadata AVPacketSideDataType = C.AV_PKT_DATA_STRINGS_METADATA
	// AVPktDataSubtitlePosition wraps AV_PKT_DATA_SUBTITLE_POSITION.
	/*
	   Subtitle event position
	   @code
	   u32le x1
	   u32le y1
	   u32le x2
	   u32le y2
	   @endcode
	*/
	AVPktDataSubtitlePosition AVPacketSideDataType = C.AV_PKT_DATA_SUBTITLE_POSITION
	// AVPktDataMatroskaBlockadditional wraps AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL.
	/*
	   Data found in BlockAdditional element of matroska container. There is
	   no end marker for the data, so it is required to rely on the side data
	   size to recognize the end. 8 byte id (as found in BlockAddId) followed
	   by data.
	*/
	AVPktDataMatroskaBlockadditional AVPacketSideDataType = C.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL
	// AVPktDataWebvttIdentifier wraps AV_PKT_DATA_WEBVTT_IDENTIFIER.
	//
	//	The optional first identifier line of a WebVTT cue.
	AVPktDataWebvttIdentifier AVPacketSideDataType = C.AV_PKT_DATA_WEBVTT_IDENTIFIER
	// AVPktDataWebvttSettings wraps AV_PKT_DATA_WEBVTT_SETTINGS.
	/*
	   The optional settings (rendering instructions) that immediately
	   follow the timestamp specifier of a WebVTT cue.
	*/
	AVPktDataWebvttSettings AVPacketSideDataType = C.AV_PKT_DATA_WEBVTT_SETTINGS
	// AVPktDataMetadataUpdate wraps AV_PKT_DATA_METADATA_UPDATE.
	/*
	   A list of zero terminated key/value strings. There is no end marker for
	   the list, so it is required to rely on the side data size to stop. This
	   side data includes updated metadata which appeared in the stream.
	*/
	AVPktDataMetadataUpdate AVPacketSideDataType = C.AV_PKT_DATA_METADATA_UPDATE
	// AVPktDataMpegtsStreamId wraps AV_PKT_DATA_MPEGTS_STREAM_ID.
	/*
	   MPEGTS stream ID as uint8_t, this is required to pass the stream ID
	   information from the demuxer to the corresponding muxer.
	*/
	AVPktDataMpegtsStreamId AVPacketSideDataType = C.AV_PKT_DATA_MPEGTS_STREAM_ID
	// AVPktDataMasteringDisplayMetadata wraps AV_PKT_DATA_MASTERING_DISPLAY_METADATA.
	/*
	   Mastering display metadata (based on SMPTE-2086:2014). This metadata
	   should be associated with a video stream and contains data in the form
	   of the AVMasteringDisplayMetadata struct.
	*/
	AVPktDataMasteringDisplayMetadata AVPacketSideDataType = C.AV_PKT_DATA_MASTERING_DISPLAY_METADATA
	// AVPktDataSpherical wraps AV_PKT_DATA_SPHERICAL.
	/*
	   This side data should be associated with a video stream and corresponds
	   to the AVSphericalMapping structure.
	*/
	AVPktDataSpherical AVPacketSideDataType = C.AV_PKT_DATA_SPHERICAL
	// AVPktDataContentLightLevel wraps AV_PKT_DATA_CONTENT_LIGHT_LEVEL.
	/*
	   Content light level (based on CTA-861.3). This metadata should be
	   associated with a video stream and contains data in the form of the
	   AVContentLightMetadata struct.
	*/
	AVPktDataContentLightLevel AVPacketSideDataType = C.AV_PKT_DATA_CONTENT_LIGHT_LEVEL
	// AVPktDataA53Cc wraps AV_PKT_DATA_A53_CC.
	/*
	   ATSC A53 Part 4 Closed Captions. This metadata should be associated with
	   a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
	   The number of bytes of CC data is AVPacketSideData.size.
	*/
	AVPktDataA53Cc AVPacketSideDataType = C.AV_PKT_DATA_A53_CC
	// AVPktDataEncryptionInitInfo wraps AV_PKT_DATA_ENCRYPTION_INIT_INFO.
	/*
	   This side data is encryption initialization data.
	   The format is not part of ABI, use av_encryption_init_info_* methods to
	   access.
	*/
	AVPktDataEncryptionInitInfo AVPacketSideDataType = C.AV_PKT_DATA_ENCRYPTION_INIT_INFO
	// AVPktDataEncryptionInfo wraps AV_PKT_DATA_ENCRYPTION_INFO.
	/*
	   This side data contains encryption info for how to decrypt the packet.
	   The format is not part of ABI, use av_encryption_info_* methods to access.
	*/
	AVPktDataEncryptionInfo AVPacketSideDataType = C.AV_PKT_DATA_ENCRYPTION_INFO
	// AVPktDataAfd wraps AV_PKT_DATA_AFD.
	/*
	   Active Format Description data consisting of a single byte as specified
	   in ETSI TS 101 154 using AVActiveFormatDescription enum.
	*/
	AVPktDataAfd AVPacketSideDataType = C.AV_PKT_DATA_AFD
	// AVPktDataPrft wraps AV_PKT_DATA_PRFT.
	/*
	   Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
	   usually exported by some encoders (on demand through the prft flag set in the
	   AVCodecContext export_side_data field).
	*/
	AVPktDataPrft AVPacketSideDataType = C.AV_PKT_DATA_PRFT
	// AVPktDataIccProfile wraps AV_PKT_DATA_ICC_PROFILE.
	/*
	   ICC profile data consisting of an opaque octet buffer following the
	   format described by ISO 15076-1.
	*/
	AVPktDataIccProfile AVPacketSideDataType = C.AV_PKT_DATA_ICC_PROFILE
	// AVPktDataDoviConf wraps AV_PKT_DATA_DOVI_CONF.
	/*
	   DOVI configuration
	   ref:
	   dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
	   dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
	   Tags are stored in struct AVDOVIDecoderConfigurationRecord.
	*/
	AVPktDataDoviConf AVPacketSideDataType = C.AV_PKT_DATA_DOVI_CONF
	// AVPktDataS12MTimecode wraps AV_PKT_DATA_S12M_TIMECODE.
	/*
	   Timecode which conforms to SMPTE ST 12-1:2014. The data is an array of 4 uint32_t
	   where the first uint32_t describes how many (1-3) of the other timecodes are used.
	   The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
	   function in libavutil/timecode.h.
	*/
	AVPktDataS12MTimecode AVPacketSideDataType = C.AV_PKT_DATA_S12M_TIMECODE
	// AVPktDataDynamicHdr10Plus wraps AV_PKT_DATA_DYNAMIC_HDR10_PLUS.
	/*
	   HDR10+ dynamic metadata associated with a video frame. The metadata is in
	   the form of the AVDynamicHDRPlus struct and contains
	   information for color volume transform - application 4 of
	   SMPTE 2094-40:2016 standard.
	*/
	AVPktDataDynamicHdr10Plus AVPacketSideDataType = C.AV_PKT_DATA_DYNAMIC_HDR10_PLUS
	// AVPktDataIamfMixGainParam wraps AV_PKT_DATA_IAMF_MIX_GAIN_PARAM.
	/*
	   IAMF Mix Gain Parameter Data associated with the audio frame. This metadata
	   is in the form of the AVIAMFParamDefinition struct and contains information
	   defined in sections 3.6.1 and 3.8.1 of the Immersive Audio Model and
	   Formats standard.
	*/
	AVPktDataIamfMixGainParam AVPacketSideDataType = C.AV_PKT_DATA_IAMF_MIX_GAIN_PARAM
	// AVPktDataIamfDemixingInfoParam wraps AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM.
	/*
	   IAMF Demixing Info Parameter Data associated with the audio frame. This
	   metadata is in the form of the AVIAMFParamDefinition struct and contains
	   information defined in sections 3.6.1 and 3.8.2 of the Immersive Audio Model
	   and Formats standard.
	*/
	AVPktDataIamfDemixingInfoParam AVPacketSideDataType = C.AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM
	// AVPktDataIamfReconGainInfoParam wraps AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM.
	/*
	   IAMF Recon Gain Info Parameter Data associated with the audio frame. This
	   metadata is in the form of the AVIAMFParamDefinition struct and contains
	   information defined in sections 3.6.1 and 3.8.3 of the Immersive Audio Model
	   and Formats standard.
	*/
	AVPktDataIamfReconGainInfoParam AVPacketSideDataType = C.AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM
	// AVPktDataAmbientViewingEnvironment wraps AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT.
	/*
	   Ambient viewing environment metadata, as defined by H.274. This metadata
	   should be associated with a video stream and contains data in the form
	   of the AVAmbientViewingEnvironment struct.
	*/
	AVPktDataAmbientViewingEnvironment AVPacketSideDataType = C.AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
	// AVPktDataFrameCropping wraps AV_PKT_DATA_FRAME_CROPPING.
	/*
	   The number of pixels to discard from the top/bottom/left/right border of the
	   decoded frame to obtain the sub-rectangle intended for presentation.

	   @code
	   u32le crop_top
	   u32le crop_bottom
	   u32le crop_left
	   u32le crop_right
	   @endcode
	*/
	AVPktDataFrameCropping AVPacketSideDataType = C.AV_PKT_DATA_FRAME_CROPPING
	// AVPktDataLcevc wraps AV_PKT_DATA_LCEVC.
	/*
	   Raw LCEVC payload data, as a uint8_t array, with NAL emulation
	   bytes intact.
	*/
	AVPktDataLcevc AVPacketSideDataType = C.AV_PKT_DATA_LCEVC
	// AVPktData3DReferenceDisplays wraps AV_PKT_DATA_3D_REFERENCE_DISPLAYS.
	/*
	   This side data contains information about the reference display width(s)
	   and reference viewing distance(s) as well as information about the
	   corresponding reference stereo pair(s), i.e., the pair(s) of views to be
	   displayed for the viewer's left and right eyes on the reference display
	   at the reference viewing distance.
	   The payload is the AV3DReferenceDisplaysInfo struct defined in
	   libavutil/tdrdi.h.
	*/
	AVPktData3DReferenceDisplays AVPacketSideDataType = C.AV_PKT_DATA_3D_REFERENCE_DISPLAYS
	// AVPktDataRtcpSr wraps AV_PKT_DATA_RTCP_SR.
	/*
	   Contains the last received RTCP SR (Sender Report) information
	   in the form of the AVRTCPSenderReport struct.
	*/
	AVPktDataRtcpSr AVPacketSideDataType = C.AV_PKT_DATA_RTCP_SR
	// AVPktDataNb wraps AV_PKT_DATA_NB.
	/*
	   The number of side data types.
	   This is not part of the public API/ABI in the sense that it may
	   change when new side data types are added.
	   This must stay the last enum value.
	   If its value becomes huge, some code using it
	   needs to be updated as it assumes it to be smaller than other limits.
	*/
	AVPktDataNb AVPacketSideDataType = C.AV_PKT_DATA_NB
)

// --- Enum AVSideDataParamChangeFlags ---

// AVSideDataParamChangeFlags wraps AVSideDataParamChangeFlags.
type AVSideDataParamChangeFlags C.enum_AVSideDataParamChangeFlags

const SizeOfAVSideDataParamChangeFlags = C.sizeof_enum_AVSideDataParamChangeFlags

func ToAVSideDataParamChangeFlagsArray(ptr unsafe.Pointer) *Array[AVSideDataParamChangeFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[AVSideDataParamChangeFlags]{
		elemSize: SizeOfAVSideDataParamChangeFlags,
		loadPtr: func(pointer unsafe.Pointer) AVSideDataParamChangeFlags {
			ptr := (*AVSideDataParamChangeFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVSideDataParamChangeFlags) {
			ptr := (*AVSideDataParamChangeFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocAVSideDataParamChangeFlagsArray(size uint64) *Array[AVSideDataParamChangeFlags] {
	return ToAVSideDataParamChangeFlagsArray(AVCalloc(size, SizeOfAVSideDataParamChangeFlags))
}

const (
	// AVSideDataParamChangeSampleRate wraps AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE.
	AVSideDataParamChangeSampleRate AVSideDataParamChangeFlags = C.AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE
	// AVSideDataParamChangeDimensions wraps AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS.
	AVSideDataParamChangeDimensions AVSideDataParamChangeFlags = C.AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS
)

// --- Enum AVAppToDevMessageType ---

// AVAppToDevMessageType wraps AVAppToDevMessageType.
//
//	Message types used by avdevice_app_to_dev_control_message().
type AVAppToDevMessageType C.enum_AVAppToDevMessageType

const SizeOfAVAppToDevMessageType = C.sizeof_enum_AVAppToDevMessageType

func ToAVAppToDevMessageTypeArray(ptr unsafe.Pointer) *Array[AVAppToDevMessageType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVAppToDevMessageType]{
		elemSize: SizeOfAVAppToDevMessageType,
		loadPtr: func(pointer unsafe.Pointer) AVAppToDevMessageType {
			ptr := (*AVAppToDevMessageType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVAppToDevMessageType) {
			ptr := (*AVAppToDevMessageType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVAppToDevMessageTypeArray(size uint64) *Array[AVAppToDevMessageType] {
	return ToAVAppToDevMessageTypeArray(AVCalloc(size, SizeOfAVAppToDevMessageType))
}

const (
	// AVAppToDevNone wraps AV_APP_TO_DEV_NONE.
	//
	//	Dummy message.
	AVAppToDevNone AVAppToDevMessageType = C.AV_APP_TO_DEV_NONE
	// AVAppToDevWindowSize wraps AV_APP_TO_DEV_WINDOW_SIZE.
	/*
	   Window size change message.

	   Message is sent to the device every time the application changes the size
	   of the window device renders to.
	   Message should also be sent right after window is created.

	   data: AVDeviceRect: new window size.
	*/
	AVAppToDevWindowSize AVAppToDevMessageType = C.AV_APP_TO_DEV_WINDOW_SIZE
	// AVAppToDevWindowRepaint wraps AV_APP_TO_DEV_WINDOW_REPAINT.
	/*
	   Repaint request message.

	   Message is sent to the device when window has to be repainted.

	   data: AVDeviceRect: area required to be repainted.
	         NULL: whole area is required to be repainted.
	*/
	AVAppToDevWindowRepaint AVAppToDevMessageType = C.AV_APP_TO_DEV_WINDOW_REPAINT
	// AVAppToDevPause wraps AV_APP_TO_DEV_PAUSE.
	/*
	   Request pause/play.

	   Application requests pause/unpause playback.
	   Mostly usable with devices that have internal buffer.
	   By default devices are not paused.

	   data: NULL
	*/
	AVAppToDevPause AVAppToDevMessageType = C.AV_APP_TO_DEV_PAUSE
	// AVAppToDevPlay wraps AV_APP_TO_DEV_PLAY.
	/*
	   Request pause/play.

	   Application requests pause/unpause playback.
	   Mostly usable with devices that have internal buffer.
	   By default devices are not paused.

	   data: NULL
	*/
	AVAppToDevPlay AVAppToDevMessageType = C.AV_APP_TO_DEV_PLAY
	// AVAppToDevTogglePause wraps AV_APP_TO_DEV_TOGGLE_PAUSE.
	/*
	   Request pause/play.

	   Application requests pause/unpause playback.
	   Mostly usable with devices that have internal buffer.
	   By default devices are not paused.

	   data: NULL
	*/
	AVAppToDevTogglePause AVAppToDevMessageType = C.AV_APP_TO_DEV_TOGGLE_PAUSE
	// AVAppToDevSetVolume wraps AV_APP_TO_DEV_SET_VOLUME.
	/*
	   Volume control message.

	   Set volume level. It may be device-dependent if volume
	   is changed per stream or system wide. Per stream volume
	   change is expected when possible.

	   data: double: new volume with range of 0.0 - 1.0.
	*/
	AVAppToDevSetVolume AVAppToDevMessageType = C.AV_APP_TO_DEV_SET_VOLUME
	// AVAppToDevMute wraps AV_APP_TO_DEV_MUTE.
	/*
	   Mute control messages.

	   Change mute state. It may be device-dependent if mute status
	   is changed per stream or system wide. Per stream mute status
	   change is expected when possible.

	   data: NULL.
	*/
	AVAppToDevMute AVAppToDevMessageType = C.AV_APP_TO_DEV_MUTE
	// AVAppToDevUnmute wraps AV_APP_TO_DEV_UNMUTE.
	/*
	   Mute control messages.

	   Change mute state. It may be device-dependent if mute status
	   is changed per stream or system wide. Per stream mute status
	   change is expected when possible.

	   data: NULL.
	*/
	AVAppToDevUnmute AVAppToDevMessageType = C.AV_APP_TO_DEV_UNMUTE
	// AVAppToDevToggleMute wraps AV_APP_TO_DEV_TOGGLE_MUTE.
	/*
	   Mute control messages.

	   Change mute state. It may be device-dependent if mute status
	   is changed per stream or system wide. Per stream mute status
	   change is expected when possible.

	   data: NULL.
	*/
	AVAppToDevToggleMute AVAppToDevMessageType = C.AV_APP_TO_DEV_TOGGLE_MUTE
	// AVAppToDevGetVolume wraps AV_APP_TO_DEV_GET_VOLUME.
	/*
	   Get volume/mute messages.

	   Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or
	   AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.

	   data: NULL.
	*/
	AVAppToDevGetVolume AVAppToDevMessageType = C.AV_APP_TO_DEV_GET_VOLUME
	// AVAppToDevGetMute wraps AV_APP_TO_DEV_GET_MUTE.
	/*
	   Get volume/mute messages.

	   Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or
	   AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.

	   data: NULL.
	*/
	AVAppToDevGetMute AVAppToDevMessageType = C.AV_APP_TO_DEV_GET_MUTE
)

// --- Enum AVDevToAppMessageType ---

// AVDevToAppMessageType wraps AVDevToAppMessageType.
//
//	Message types used by avdevice_dev_to_app_control_message().
type AVDevToAppMessageType C.enum_AVDevToAppMessageType

const SizeOfAVDevToAppMessageType = C.sizeof_enum_AVDevToAppMessageType

func ToAVDevToAppMessageTypeArray(ptr unsafe.Pointer) *Array[AVDevToAppMessageType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDevToAppMessageType]{
		elemSize: SizeOfAVDevToAppMessageType,
		loadPtr: func(pointer unsafe.Pointer) AVDevToAppMessageType {
			ptr := (*AVDevToAppMessageType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDevToAppMessageType) {
			ptr := (*AVDevToAppMessageType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDevToAppMessageTypeArray(size uint64) *Array[AVDevToAppMessageType] {
	return ToAVDevToAppMessageTypeArray(AVCalloc(size, SizeOfAVDevToAppMessageType))
}

const (
	// AVDevToAppNone wraps AV_DEV_TO_APP_NONE.
	//
	//	Dummy message.
	AVDevToAppNone AVDevToAppMessageType = C.AV_DEV_TO_APP_NONE
	// AVDevToAppCreateWindowBuffer wraps AV_DEV_TO_APP_CREATE_WINDOW_BUFFER.
	/*
	   Create window buffer message.

	   Device requests to create a window buffer. Exact meaning is device-
	   and application-dependent. Message is sent before rendering first
	   frame and all one-shot initializations should be done here.
	   Application is allowed to ignore preferred window buffer size.

	   @note: Application is obligated to inform about window buffer size
	          with AV_APP_TO_DEV_WINDOW_SIZE message.

	   data: AVDeviceRect: preferred size of the window buffer.
	         NULL: no preferred size of the window buffer.
	*/
	AVDevToAppCreateWindowBuffer AVDevToAppMessageType = C.AV_DEV_TO_APP_CREATE_WINDOW_BUFFER
	// AVDevToAppPrepareWindowBuffer wraps AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER.
	/*
	   Prepare window buffer message.

	   Device requests to prepare a window buffer for rendering.
	   Exact meaning is device- and application-dependent.
	   Message is sent before rendering of each frame.

	   data: NULL.
	*/
	AVDevToAppPrepareWindowBuffer AVDevToAppMessageType = C.AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER
	// AVDevToAppDisplayWindowBuffer wraps AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER.
	/*
	   Display window buffer message.

	   Device requests to display a window buffer.
	   Message is sent when new frame is ready to be displayed.
	   Usually buffers need to be swapped in handler of this message.

	   data: NULL.
	*/
	AVDevToAppDisplayWindowBuffer AVDevToAppMessageType = C.AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER
	// AVDevToAppDestroyWindowBuffer wraps AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER.
	/*
	   Destroy window buffer message.

	   Device requests to destroy a window buffer.
	   Message is sent when device is about to be destroyed and window
	   buffer is not required anymore.

	   data: NULL.
	*/
	AVDevToAppDestroyWindowBuffer AVDevToAppMessageType = C.AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER
	// AVDevToAppBufferOverflow wraps AV_DEV_TO_APP_BUFFER_OVERFLOW.
	/*
	   Buffer fullness status messages.

	   Device signals buffer overflow/underflow.

	   data: NULL.
	*/
	AVDevToAppBufferOverflow AVDevToAppMessageType = C.AV_DEV_TO_APP_BUFFER_OVERFLOW
	// AVDevToAppBufferUnderflow wraps AV_DEV_TO_APP_BUFFER_UNDERFLOW.
	/*
	   Buffer fullness status messages.

	   Device signals buffer overflow/underflow.

	   data: NULL.
	*/
	AVDevToAppBufferUnderflow AVDevToAppMessageType = C.AV_DEV_TO_APP_BUFFER_UNDERFLOW
	// AVDevToAppBufferReadable wraps AV_DEV_TO_APP_BUFFER_READABLE.
	/*
	   Buffer readable/writable.

	   Device informs that buffer is readable/writable.
	   When possible, device informs how many bytes can be read/write.

	   @warning Device may not inform when number of bytes than can be read/write changes.

	   data: int64_t: amount of bytes available to read/write.
	         NULL: amount of bytes available to read/write is not known.
	*/
	AVDevToAppBufferReadable AVDevToAppMessageType = C.AV_DEV_TO_APP_BUFFER_READABLE
	// AVDevToAppBufferWritable wraps AV_DEV_TO_APP_BUFFER_WRITABLE.
	/*
	   Buffer readable/writable.

	   Device informs that buffer is readable/writable.
	   When possible, device informs how many bytes can be read/write.

	   @warning Device may not inform when number of bytes than can be read/write changes.

	   data: int64_t: amount of bytes available to read/write.
	         NULL: amount of bytes available to read/write is not known.
	*/
	AVDevToAppBufferWritable AVDevToAppMessageType = C.AV_DEV_TO_APP_BUFFER_WRITABLE
	// AVDevToAppMuteStateChanged wraps AV_DEV_TO_APP_MUTE_STATE_CHANGED.
	/*
	   Mute state change message.

	   Device informs that mute state has changed.

	   data: int: 0 for not muted state, non-zero for muted state.
	*/
	AVDevToAppMuteStateChanged AVDevToAppMessageType = C.AV_DEV_TO_APP_MUTE_STATE_CHANGED
	// AVDevToAppVolumeLevelChanged wraps AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED.
	/*
	   Volume level change message.

	   Device informs that volume level has changed.

	   data: double: new volume with range of 0.0 - 1.0.
	*/
	AVDevToAppVolumeLevelChanged AVDevToAppMessageType = C.AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED
)

// --- Enum AVStreamParseType ---

// AVStreamParseType wraps AVStreamParseType.
type AVStreamParseType C.enum_AVStreamParseType

const SizeOfAVStreamParseType = C.sizeof_enum_AVStreamParseType

func ToAVStreamParseTypeArray(ptr unsafe.Pointer) *Array[AVStreamParseType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVStreamParseType]{
		elemSize: SizeOfAVStreamParseType,
		loadPtr: func(pointer unsafe.Pointer) AVStreamParseType {
			ptr := (*AVStreamParseType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVStreamParseType) {
			ptr := (*AVStreamParseType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVStreamParseTypeArray(size uint64) *Array[AVStreamParseType] {
	return ToAVStreamParseTypeArray(AVCalloc(size, SizeOfAVStreamParseType))
}

const (
	// AVStreamParseNone wraps AVSTREAM_PARSE_NONE.
	AVStreamParseNone AVStreamParseType = C.AVSTREAM_PARSE_NONE
	// AVStreamParseFull wraps AVSTREAM_PARSE_FULL.
	//
	//	full parsing and repack
	AVStreamParseFull AVStreamParseType = C.AVSTREAM_PARSE_FULL
	// AVStreamParseHeaders wraps AVSTREAM_PARSE_HEADERS.
	//
	//	Only parse headers, do not repack.
	AVStreamParseHeaders AVStreamParseType = C.AVSTREAM_PARSE_HEADERS
	// AVStreamParseTimestamps wraps AVSTREAM_PARSE_TIMESTAMPS.
	//
	//	full parsing and interpolation of timestamps for frames not starting on a packet boundary
	AVStreamParseTimestamps AVStreamParseType = C.AVSTREAM_PARSE_TIMESTAMPS
	// AVStreamParseFullOnce wraps AVSTREAM_PARSE_FULL_ONCE.
	//
	//	full parsing and repack of the first frame only, only implemented for H.264 currently
	AVStreamParseFullOnce AVStreamParseType = C.AVSTREAM_PARSE_FULL_ONCE
	// AVStreamParseFullRaw wraps AVSTREAM_PARSE_FULL_RAW.
	/*
	   < full parsing and repack with timestamp and position generation by parser for raw
	   this assumes that each packet in the file contains no demuxer level headers and
	   just codec level data, otherwise position generation would fail
	*/
	AVStreamParseFullRaw AVStreamParseType = C.AVSTREAM_PARSE_FULL_RAW
)

// --- Enum AVStreamGroupParamsType ---

// AVStreamGroupParamsType wraps AVStreamGroupParamsType.
type AVStreamGroupParamsType C.enum_AVStreamGroupParamsType

const SizeOfAVStreamGroupParamsType = C.sizeof_enum_AVStreamGroupParamsType

func ToAVStreamGroupParamsTypeArray(ptr unsafe.Pointer) *Array[AVStreamGroupParamsType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVStreamGroupParamsType]{
		elemSize: SizeOfAVStreamGroupParamsType,
		loadPtr: func(pointer unsafe.Pointer) AVStreamGroupParamsType {
			ptr := (*AVStreamGroupParamsType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVStreamGroupParamsType) {
			ptr := (*AVStreamGroupParamsType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVStreamGroupParamsTypeArray(size uint64) *Array[AVStreamGroupParamsType] {
	return ToAVStreamGroupParamsTypeArray(AVCalloc(size, SizeOfAVStreamGroupParamsType))
}

const (
	// AVStreamGroupParamsNone wraps AV_STREAM_GROUP_PARAMS_NONE.
	AVStreamGroupParamsNone AVStreamGroupParamsType = C.AV_STREAM_GROUP_PARAMS_NONE
	// AVStreamGroupParamsIamfAudioElement wraps AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT.
	AVStreamGroupParamsIamfAudioElement AVStreamGroupParamsType = C.AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT
	// AVStreamGroupParamsIamfMixPresentation wraps AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION.
	AVStreamGroupParamsIamfMixPresentation AVStreamGroupParamsType = C.AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION
	// AVStreamGroupParamsTileGrid wraps AV_STREAM_GROUP_PARAMS_TILE_GRID.
	AVStreamGroupParamsTileGrid AVStreamGroupParamsType = C.AV_STREAM_GROUP_PARAMS_TILE_GRID
	// AVStreamGroupParamsLcevc wraps AV_STREAM_GROUP_PARAMS_LCEVC.
	AVStreamGroupParamsLcevc AVStreamGroupParamsType = C.AV_STREAM_GROUP_PARAMS_LCEVC
)

// --- Enum AVDurationEstimationMethod ---

// AVDurationEstimationMethod wraps AVDurationEstimationMethod.
/*
  The duration of a video can be estimated through various ways, and this enum can be used
  to know how the duration was estimated.
*/
type AVDurationEstimationMethod C.enum_AVDurationEstimationMethod

const SizeOfAVDurationEstimationMethod = C.sizeof_enum_AVDurationEstimationMethod

func ToAVDurationEstimationMethodArray(ptr unsafe.Pointer) *Array[AVDurationEstimationMethod] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDurationEstimationMethod]{
		elemSize: SizeOfAVDurationEstimationMethod,
		loadPtr: func(pointer unsafe.Pointer) AVDurationEstimationMethod {
			ptr := (*AVDurationEstimationMethod)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDurationEstimationMethod) {
			ptr := (*AVDurationEstimationMethod)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDurationEstimationMethodArray(size uint64) *Array[AVDurationEstimationMethod] {
	return ToAVDurationEstimationMethodArray(AVCalloc(size, SizeOfAVDurationEstimationMethod))
}

const (
	// AVFmtDurationFromPts wraps AVFMT_DURATION_FROM_PTS.
	//
	//	Duration accurately estimated from PTSes
	AVFmtDurationFromPts AVDurationEstimationMethod = C.AVFMT_DURATION_FROM_PTS
	// AVFmtDurationFromStream wraps AVFMT_DURATION_FROM_STREAM.
	//
	//	Duration estimated from a stream with a known duration
	AVFmtDurationFromStream AVDurationEstimationMethod = C.AVFMT_DURATION_FROM_STREAM
	// AVFmtDurationFromBitrate wraps AVFMT_DURATION_FROM_BITRATE.
	//
	//	Duration estimated from bitrate (less accurate)
	AVFmtDurationFromBitrate AVDurationEstimationMethod = C.AVFMT_DURATION_FROM_BITRATE
)

// --- Enum AVTimebaseSource ---

// AVTimebaseSource wraps AVTimebaseSource.
type AVTimebaseSource C.enum_AVTimebaseSource

const SizeOfAVTimebaseSource = C.sizeof_enum_AVTimebaseSource

func ToAVTimebaseSourceArray(ptr unsafe.Pointer) *Array[AVTimebaseSource] {
	if ptr == nil {
		return nil
	}

	return &Array[AVTimebaseSource]{
		elemSize: SizeOfAVTimebaseSource,
		loadPtr: func(pointer unsafe.Pointer) AVTimebaseSource {
			ptr := (*AVTimebaseSource)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVTimebaseSource) {
			ptr := (*AVTimebaseSource)(pointer)
			*ptr = value
		},
	}
}

func AllocAVTimebaseSourceArray(size uint64) *Array[AVTimebaseSource] {
	return ToAVTimebaseSourceArray(AVCalloc(size, SizeOfAVTimebaseSource))
}

const (
	// AVFmtTbcfAuto wraps AVFMT_TBCF_AUTO.
	AVFmtTbcfAuto AVTimebaseSource = C.AVFMT_TBCF_AUTO
	// AVFmtTbcfDecoder wraps AVFMT_TBCF_DECODER.
	AVFmtTbcfDecoder AVTimebaseSource = C.AVFMT_TBCF_DECODER
	// AVFmtTbcfDemuxer wraps AVFMT_TBCF_DEMUXER.
	AVFmtTbcfDemuxer AVTimebaseSource = C.AVFMT_TBCF_DEMUXER
	// AVFmtTbcfRFramerate wraps AVFMT_TBCF_R_FRAMERATE.
	AVFmtTbcfRFramerate AVTimebaseSource = C.AVFMT_TBCF_R_FRAMERATE
)

// --- Enum AVIODirEntryType ---

// AVIODirEntryType wraps AVIODirEntryType.
//
//	Directory entry types.
type AVIODirEntryType C.enum_AVIODirEntryType

const SizeOfAVIODirEntryType = C.sizeof_enum_AVIODirEntryType

func ToAVIODirEntryTypeArray(ptr unsafe.Pointer) *Array[AVIODirEntryType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIODirEntryType]{
		elemSize: SizeOfAVIODirEntryType,
		loadPtr: func(pointer unsafe.Pointer) AVIODirEntryType {
			ptr := (*AVIODirEntryType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIODirEntryType) {
			ptr := (*AVIODirEntryType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIODirEntryTypeArray(size uint64) *Array[AVIODirEntryType] {
	return ToAVIODirEntryTypeArray(AVCalloc(size, SizeOfAVIODirEntryType))
}

const (
	// AVIOEntryUnknown wraps AVIO_ENTRY_UNKNOWN.
	AVIOEntryUnknown AVIODirEntryType = C.AVIO_ENTRY_UNKNOWN
	// AVIOEntryBlockDevice wraps AVIO_ENTRY_BLOCK_DEVICE.
	AVIOEntryBlockDevice AVIODirEntryType = C.AVIO_ENTRY_BLOCK_DEVICE
	// AVIOEntryCharacterDevice wraps AVIO_ENTRY_CHARACTER_DEVICE.
	AVIOEntryCharacterDevice AVIODirEntryType = C.AVIO_ENTRY_CHARACTER_DEVICE
	// AVIOEntryDirectory wraps AVIO_ENTRY_DIRECTORY.
	AVIOEntryDirectory AVIODirEntryType = C.AVIO_ENTRY_DIRECTORY
	// AVIOEntryNamedPipe wraps AVIO_ENTRY_NAMED_PIPE.
	AVIOEntryNamedPipe AVIODirEntryType = C.AVIO_ENTRY_NAMED_PIPE
	// AVIOEntrySymbolicLink wraps AVIO_ENTRY_SYMBOLIC_LINK.
	AVIOEntrySymbolicLink AVIODirEntryType = C.AVIO_ENTRY_SYMBOLIC_LINK
	// AVIOEntrySocket wraps AVIO_ENTRY_SOCKET.
	AVIOEntrySocket AVIODirEntryType = C.AVIO_ENTRY_SOCKET
	// AVIOEntryFile wraps AVIO_ENTRY_FILE.
	AVIOEntryFile AVIODirEntryType = C.AVIO_ENTRY_FILE
	// AVIOEntryServer wraps AVIO_ENTRY_SERVER.
	AVIOEntryServer AVIODirEntryType = C.AVIO_ENTRY_SERVER
	// AVIOEntryShare wraps AVIO_ENTRY_SHARE.
	AVIOEntryShare AVIODirEntryType = C.AVIO_ENTRY_SHARE
	// AVIOEntryWorkgroup wraps AVIO_ENTRY_WORKGROUP.
	AVIOEntryWorkgroup AVIODirEntryType = C.AVIO_ENTRY_WORKGROUP
)

// --- Enum AVIODataMarkerType ---

// AVIODataMarkerType wraps AVIODataMarkerType.
/*
  Different data types that can be returned via the AVIO
  write_data_type callback.
*/
type AVIODataMarkerType C.enum_AVIODataMarkerType

const SizeOfAVIODataMarkerType = C.sizeof_enum_AVIODataMarkerType

func ToAVIODataMarkerTypeArray(ptr unsafe.Pointer) *Array[AVIODataMarkerType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIODataMarkerType]{
		elemSize: SizeOfAVIODataMarkerType,
		loadPtr: func(pointer unsafe.Pointer) AVIODataMarkerType {
			ptr := (*AVIODataMarkerType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIODataMarkerType) {
			ptr := (*AVIODataMarkerType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIODataMarkerTypeArray(size uint64) *Array[AVIODataMarkerType] {
	return ToAVIODataMarkerTypeArray(AVCalloc(size, SizeOfAVIODataMarkerType))
}

const (
	// AVIODataMarkerHeader wraps AVIO_DATA_MARKER_HEADER.
	//
	//	Header data; this needs to be present for the stream to be decodeable.
	AVIODataMarkerHeader AVIODataMarkerType = C.AVIO_DATA_MARKER_HEADER
	// AVIODataMarkerSyncPoint wraps AVIO_DATA_MARKER_SYNC_POINT.
	/*
	   A point in the output bytestream where a decoder can start decoding
	   (i.e. a keyframe). A demuxer/decoder given the data flagged with
	   AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT,
	   should give decodeable results.
	*/
	AVIODataMarkerSyncPoint AVIODataMarkerType = C.AVIO_DATA_MARKER_SYNC_POINT
	// AVIODataMarkerBoundaryPoint wraps AVIO_DATA_MARKER_BOUNDARY_POINT.
	/*
	   A point in the output bytestream where a demuxer can start parsing
	   (for non self synchronizing bytestream formats). That is, any
	   non-keyframe packet start point.
	*/
	AVIODataMarkerBoundaryPoint AVIODataMarkerType = C.AVIO_DATA_MARKER_BOUNDARY_POINT
	// AVIODataMarkerUnknown wraps AVIO_DATA_MARKER_UNKNOWN.
	/*
	   This is any, unlabelled data. It can either be a muxer not marking
	   any positions at all, it can be an actual boundary/sync point
	   that the muxer chooses not to mark, or a later part of a packet/fragment
	   that is cut into multiple write callbacks due to limited IO buffer size.
	*/
	AVIODataMarkerUnknown AVIODataMarkerType = C.AVIO_DATA_MARKER_UNKNOWN
	// AVIODataMarkerTrailer wraps AVIO_DATA_MARKER_TRAILER.
	/*
	   Trailer data, which doesn't contain actual content, but only for
	   finalizing the output file.
	*/
	AVIODataMarkerTrailer AVIODataMarkerType = C.AVIO_DATA_MARKER_TRAILER
	// AVIODataMarkerFlushPoint wraps AVIO_DATA_MARKER_FLUSH_POINT.
	/*
	   A point in the output bytestream where the underlying AVIOContext might
	   flush the buffer depending on latency or buffering requirements. Typically
	   means the end of a packet.
	*/
	AVIODataMarkerFlushPoint AVIODataMarkerType = C.AVIO_DATA_MARKER_FLUSH_POINT
)

// --- Enum AVEscapeMode ---

// AVEscapeMode wraps AVEscapeMode.
type AVEscapeMode C.enum_AVEscapeMode

const SizeOfAVEscapeMode = C.sizeof_enum_AVEscapeMode

func ToAVEscapeModeArray(ptr unsafe.Pointer) *Array[AVEscapeMode] {
	if ptr == nil {
		return nil
	}

	return &Array[AVEscapeMode]{
		elemSize: SizeOfAVEscapeMode,
		loadPtr: func(pointer unsafe.Pointer) AVEscapeMode {
			ptr := (*AVEscapeMode)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVEscapeMode) {
			ptr := (*AVEscapeMode)(pointer)
			*ptr = value
		},
	}
}

func AllocAVEscapeModeArray(size uint64) *Array[AVEscapeMode] {
	return ToAVEscapeModeArray(AVCalloc(size, SizeOfAVEscapeMode))
}

const (
	// AVEscapeModeAuto wraps AV_ESCAPE_MODE_AUTO.
	//
	//	Use auto-selected escaping mode.
	AVEscapeModeAuto AVEscapeMode = C.AV_ESCAPE_MODE_AUTO
	// AVEscapeModeBackslash wraps AV_ESCAPE_MODE_BACKSLASH.
	//
	//	Use backslash escaping.
	AVEscapeModeBackslash AVEscapeMode = C.AV_ESCAPE_MODE_BACKSLASH
	// AVEscapeModeQuote wraps AV_ESCAPE_MODE_QUOTE.
	//
	//	Use single-quote escaping.
	AVEscapeModeQuote AVEscapeMode = C.AV_ESCAPE_MODE_QUOTE
	// AVEscapeModeXml wraps AV_ESCAPE_MODE_XML.
	//
	//	Use XML non-markup character data escaping.
	AVEscapeModeXml AVEscapeMode = C.AV_ESCAPE_MODE_XML
)

// --- Enum AVMediaType ---

// AVMediaType wraps AVMediaType.
//
//	@brief Media Type
type AVMediaType C.enum_AVMediaType

const SizeOfAVMediaType = C.sizeof_enum_AVMediaType

func ToAVMediaTypeArray(ptr unsafe.Pointer) *Array[AVMediaType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVMediaType]{
		elemSize: SizeOfAVMediaType,
		loadPtr: func(pointer unsafe.Pointer) AVMediaType {
			ptr := (*AVMediaType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVMediaType) {
			ptr := (*AVMediaType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVMediaTypeArray(size uint64) *Array[AVMediaType] {
	return ToAVMediaTypeArray(AVCalloc(size, SizeOfAVMediaType))
}

const (
	// AVMediaTypeUnknown wraps AVMEDIA_TYPE_UNKNOWN.
	//
	//	Usually treated as AVMEDIA_TYPE_DATA
	AVMediaTypeUnknown AVMediaType = C.AVMEDIA_TYPE_UNKNOWN
	// AVMediaTypeVideo wraps AVMEDIA_TYPE_VIDEO.
	AVMediaTypeVideo AVMediaType = C.AVMEDIA_TYPE_VIDEO
	// AVMediaTypeAudio wraps AVMEDIA_TYPE_AUDIO.
	AVMediaTypeAudio AVMediaType = C.AVMEDIA_TYPE_AUDIO
	// AVMediaTypeData wraps AVMEDIA_TYPE_DATA.
	//
	//	Opaque data information usually continuous
	AVMediaTypeData AVMediaType = C.AVMEDIA_TYPE_DATA
	// AVMediaTypeSubtitle wraps AVMEDIA_TYPE_SUBTITLE.
	AVMediaTypeSubtitle AVMediaType = C.AVMEDIA_TYPE_SUBTITLE
	// AVMediaTypeAttachment wraps AVMEDIA_TYPE_ATTACHMENT.
	//
	//	Opaque data information usually sparse
	AVMediaTypeAttachment AVMediaType = C.AVMEDIA_TYPE_ATTACHMENT
	// AVMediaTypeNb wraps AVMEDIA_TYPE_NB.
	AVMediaTypeNb AVMediaType = C.AVMEDIA_TYPE_NB
)

// --- Enum AVPictureType ---

// AVPictureType wraps AVPictureType.
type AVPictureType C.enum_AVPictureType

const SizeOfAVPictureType = C.sizeof_enum_AVPictureType

func ToAVPictureTypeArray(ptr unsafe.Pointer) *Array[AVPictureType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVPictureType]{
		elemSize: SizeOfAVPictureType,
		loadPtr: func(pointer unsafe.Pointer) AVPictureType {
			ptr := (*AVPictureType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVPictureType) {
			ptr := (*AVPictureType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVPictureTypeArray(size uint64) *Array[AVPictureType] {
	return ToAVPictureTypeArray(AVCalloc(size, SizeOfAVPictureType))
}

const (
	// AVPictureTypeNone wraps AV_PICTURE_TYPE_NONE.
	//
	//	Undefined
	AVPictureTypeNone AVPictureType = C.AV_PICTURE_TYPE_NONE
	// AVPictureTypeI wraps AV_PICTURE_TYPE_I.
	//
	//	Intra
	AVPictureTypeI AVPictureType = C.AV_PICTURE_TYPE_I
	// AVPictureTypeP wraps AV_PICTURE_TYPE_P.
	//
	//	Predicted
	AVPictureTypeP AVPictureType = C.AV_PICTURE_TYPE_P
	// AVPictureTypeB wraps AV_PICTURE_TYPE_B.
	//
	//	Bi-dir predicted
	AVPictureTypeB AVPictureType = C.AV_PICTURE_TYPE_B
	// AVPictureTypeS wraps AV_PICTURE_TYPE_S.
	//
	//	S(GMC)-VOP MPEG-4
	AVPictureTypeS AVPictureType = C.AV_PICTURE_TYPE_S
	// AVPictureTypeSi wraps AV_PICTURE_TYPE_SI.
	//
	//	Switching Intra
	AVPictureTypeSi AVPictureType = C.AV_PICTURE_TYPE_SI
	// AVPictureTypeSp wraps AV_PICTURE_TYPE_SP.
	//
	//	Switching Predicted
	AVPictureTypeSp AVPictureType = C.AV_PICTURE_TYPE_SP
	// AVPictureTypeBi wraps AV_PICTURE_TYPE_BI.
	//
	//	BI type
	AVPictureTypeBi AVPictureType = C.AV_PICTURE_TYPE_BI
)

// --- Enum AVChannel ---

// AVChannel wraps AVChannel.
type AVChannel C.enum_AVChannel

const SizeOfAVChannel = C.sizeof_enum_AVChannel

func ToAVChannelArray(ptr unsafe.Pointer) *Array[AVChannel] {
	if ptr == nil {
		return nil
	}

	return &Array[AVChannel]{
		elemSize: SizeOfAVChannel,
		loadPtr: func(pointer unsafe.Pointer) AVChannel {
			ptr := (*AVChannel)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVChannel) {
			ptr := (*AVChannel)(pointer)
			*ptr = value
		},
	}
}

func AllocAVChannelArray(size uint64) *Array[AVChannel] {
	return ToAVChannelArray(AVCalloc(size, SizeOfAVChannel))
}

const (
	// AVChanNone wraps AV_CHAN_NONE.
	//
	//	Invalid channel index
	AVChanNone AVChannel = C.AV_CHAN_NONE
	// AVChanFrontLeft wraps AV_CHAN_FRONT_LEFT.
	//
	//	Invalid channel index
	AVChanFrontLeft AVChannel = C.AV_CHAN_FRONT_LEFT
	// AVChanFrontRight wraps AV_CHAN_FRONT_RIGHT.
	//
	//	Invalid channel index
	AVChanFrontRight AVChannel = C.AV_CHAN_FRONT_RIGHT
	// AVChanFrontCenter wraps AV_CHAN_FRONT_CENTER.
	//
	//	Invalid channel index
	AVChanFrontCenter AVChannel = C.AV_CHAN_FRONT_CENTER
	// AVChanLowFrequency wraps AV_CHAN_LOW_FREQUENCY.
	//
	//	Invalid channel index
	AVChanLowFrequency AVChannel = C.AV_CHAN_LOW_FREQUENCY
	// AVChanBackLeft wraps AV_CHAN_BACK_LEFT.
	//
	//	Invalid channel index
	AVChanBackLeft AVChannel = C.AV_CHAN_BACK_LEFT
	// AVChanBackRight wraps AV_CHAN_BACK_RIGHT.
	//
	//	Invalid channel index
	AVChanBackRight AVChannel = C.AV_CHAN_BACK_RIGHT
	// AVChanFrontLeftOfCenter wraps AV_CHAN_FRONT_LEFT_OF_CENTER.
	//
	//	Invalid channel index
	AVChanFrontLeftOfCenter AVChannel = C.AV_CHAN_FRONT_LEFT_OF_CENTER
	// AVChanFrontRightOfCenter wraps AV_CHAN_FRONT_RIGHT_OF_CENTER.
	//
	//	Invalid channel index
	AVChanFrontRightOfCenter AVChannel = C.AV_CHAN_FRONT_RIGHT_OF_CENTER
	// AVChanBackCenter wraps AV_CHAN_BACK_CENTER.
	//
	//	Invalid channel index
	AVChanBackCenter AVChannel = C.AV_CHAN_BACK_CENTER
	// AVChanSideLeft wraps AV_CHAN_SIDE_LEFT.
	//
	//	Invalid channel index
	AVChanSideLeft AVChannel = C.AV_CHAN_SIDE_LEFT
	// AVChanSideRight wraps AV_CHAN_SIDE_RIGHT.
	//
	//	Invalid channel index
	AVChanSideRight AVChannel = C.AV_CHAN_SIDE_RIGHT
	// AVChanTopCenter wraps AV_CHAN_TOP_CENTER.
	//
	//	Invalid channel index
	AVChanTopCenter AVChannel = C.AV_CHAN_TOP_CENTER
	// AVChanTopFrontLeft wraps AV_CHAN_TOP_FRONT_LEFT.
	//
	//	Invalid channel index
	AVChanTopFrontLeft AVChannel = C.AV_CHAN_TOP_FRONT_LEFT
	// AVChanTopFrontCenter wraps AV_CHAN_TOP_FRONT_CENTER.
	//
	//	Invalid channel index
	AVChanTopFrontCenter AVChannel = C.AV_CHAN_TOP_FRONT_CENTER
	// AVChanTopFrontRight wraps AV_CHAN_TOP_FRONT_RIGHT.
	//
	//	Invalid channel index
	AVChanTopFrontRight AVChannel = C.AV_CHAN_TOP_FRONT_RIGHT
	// AVChanTopBackLeft wraps AV_CHAN_TOP_BACK_LEFT.
	//
	//	Invalid channel index
	AVChanTopBackLeft AVChannel = C.AV_CHAN_TOP_BACK_LEFT
	// AVChanTopBackCenter wraps AV_CHAN_TOP_BACK_CENTER.
	//
	//	Invalid channel index
	AVChanTopBackCenter AVChannel = C.AV_CHAN_TOP_BACK_CENTER
	// AVChanTopBackRight wraps AV_CHAN_TOP_BACK_RIGHT.
	//
	//	Invalid channel index
	AVChanTopBackRight AVChannel = C.AV_CHAN_TOP_BACK_RIGHT
	// AVChanStereoLeft wraps AV_CHAN_STEREO_LEFT.
	//
	//	Stereo downmix.
	AVChanStereoLeft AVChannel = C.AV_CHAN_STEREO_LEFT
	// AVChanStereoRight wraps AV_CHAN_STEREO_RIGHT.
	//
	//	See above.
	AVChanStereoRight AVChannel = C.AV_CHAN_STEREO_RIGHT
	// AVChanWideLeft wraps AV_CHAN_WIDE_LEFT.
	//
	//	See above.
	AVChanWideLeft AVChannel = C.AV_CHAN_WIDE_LEFT
	// AVChanWideRight wraps AV_CHAN_WIDE_RIGHT.
	//
	//	See above.
	AVChanWideRight AVChannel = C.AV_CHAN_WIDE_RIGHT
	// AVChanSurroundDirectLeft wraps AV_CHAN_SURROUND_DIRECT_LEFT.
	//
	//	See above.
	AVChanSurroundDirectLeft AVChannel = C.AV_CHAN_SURROUND_DIRECT_LEFT
	// AVChanSurroundDirectRight wraps AV_CHAN_SURROUND_DIRECT_RIGHT.
	//
	//	See above.
	AVChanSurroundDirectRight AVChannel = C.AV_CHAN_SURROUND_DIRECT_RIGHT
	// AVChanLowFrequency2 wraps AV_CHAN_LOW_FREQUENCY_2.
	//
	//	See above.
	AVChanLowFrequency2 AVChannel = C.AV_CHAN_LOW_FREQUENCY_2
	// AVChanTopSideLeft wraps AV_CHAN_TOP_SIDE_LEFT.
	//
	//	See above.
	AVChanTopSideLeft AVChannel = C.AV_CHAN_TOP_SIDE_LEFT
	// AVChanTopSideRight wraps AV_CHAN_TOP_SIDE_RIGHT.
	//
	//	See above.
	AVChanTopSideRight AVChannel = C.AV_CHAN_TOP_SIDE_RIGHT
	// AVChanBottomFrontCenter wraps AV_CHAN_BOTTOM_FRONT_CENTER.
	//
	//	See above.
	AVChanBottomFrontCenter AVChannel = C.AV_CHAN_BOTTOM_FRONT_CENTER
	// AVChanBottomFrontLeft wraps AV_CHAN_BOTTOM_FRONT_LEFT.
	//
	//	See above.
	AVChanBottomFrontLeft AVChannel = C.AV_CHAN_BOTTOM_FRONT_LEFT
	// AVChanBottomFrontRight wraps AV_CHAN_BOTTOM_FRONT_RIGHT.
	//
	//	See above.
	AVChanBottomFrontRight AVChannel = C.AV_CHAN_BOTTOM_FRONT_RIGHT
	// AVChanSideSurroundLeft wraps AV_CHAN_SIDE_SURROUND_LEFT.
	//
	//	+90 degrees, Lss, SiL
	AVChanSideSurroundLeft AVChannel = C.AV_CHAN_SIDE_SURROUND_LEFT
	// AVChanSideSurroundRight wraps AV_CHAN_SIDE_SURROUND_RIGHT.
	//
	//	-90 degrees, Rss, SiR
	AVChanSideSurroundRight AVChannel = C.AV_CHAN_SIDE_SURROUND_RIGHT
	// AVChanTopSurroundLeft wraps AV_CHAN_TOP_SURROUND_LEFT.
	//
	//	+110 degrees, Lvs, TpLS
	AVChanTopSurroundLeft AVChannel = C.AV_CHAN_TOP_SURROUND_LEFT
	// AVChanTopSurroundRight wraps AV_CHAN_TOP_SURROUND_RIGHT.
	//
	//	-110 degrees, Rvs, TpRS
	AVChanTopSurroundRight AVChannel = C.AV_CHAN_TOP_SURROUND_RIGHT
	// AVChanBinauralLeft wraps AV_CHAN_BINAURAL_LEFT.
	AVChanBinauralLeft AVChannel = C.AV_CHAN_BINAURAL_LEFT
	// AVChanBinauralRight wraps AV_CHAN_BINAURAL_RIGHT.
	AVChanBinauralRight AVChannel = C.AV_CHAN_BINAURAL_RIGHT
	// AVChanUnused wraps AV_CHAN_UNUSED.
	//
	//	Channel is empty can be safely skipped.
	AVChanUnused AVChannel = C.AV_CHAN_UNUSED
	// AVChanUnknown wraps AV_CHAN_UNKNOWN.
	//
	//	Channel contains data, but its position is unknown.
	AVChanUnknown AVChannel = C.AV_CHAN_UNKNOWN
	// AVChanAmbisonicBase wraps AV_CHAN_AMBISONIC_BASE.
	/*
	   Range of channels between AV_CHAN_AMBISONIC_BASE and
	   AV_CHAN_AMBISONIC_END represent Ambisonic components using the ACN system.

	   Given a channel id `<i>` between AV_CHAN_AMBISONIC_BASE and
	   AV_CHAN_AMBISONIC_END (inclusive), the ACN index of the channel `<n>` is
	   `<n> = <i> - AV_CHAN_AMBISONIC_BASE`.

	   @note these values are only used for AV_CHANNEL_ORDER_CUSTOM channel
	   orderings, the AV_CHANNEL_ORDER_AMBISONIC ordering orders the channels
	   implicitly by their position in the stream.
	*/
	AVChanAmbisonicBase AVChannel = C.AV_CHAN_AMBISONIC_BASE
	// AVChanAmbisonicEnd wraps AV_CHAN_AMBISONIC_END.
	/*
	   leave space for 1024 ids, which correspond to maximum order-32 harmonics,
	   which should be enough for the foreseeable use cases
	*/
	AVChanAmbisonicEnd AVChannel = C.AV_CHAN_AMBISONIC_END
)

// --- Enum AVChannelOrder ---

// AVChannelOrder wraps AVChannelOrder.
type AVChannelOrder C.enum_AVChannelOrder

const SizeOfAVChannelOrder = C.sizeof_enum_AVChannelOrder

func ToAVChannelOrderArray(ptr unsafe.Pointer) *Array[AVChannelOrder] {
	if ptr == nil {
		return nil
	}

	return &Array[AVChannelOrder]{
		elemSize: SizeOfAVChannelOrder,
		loadPtr: func(pointer unsafe.Pointer) AVChannelOrder {
			ptr := (*AVChannelOrder)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVChannelOrder) {
			ptr := (*AVChannelOrder)(pointer)
			*ptr = value
		},
	}
}

func AllocAVChannelOrderArray(size uint64) *Array[AVChannelOrder] {
	return ToAVChannelOrderArray(AVCalloc(size, SizeOfAVChannelOrder))
}

const (
	// AVChannelOrderUnspec wraps AV_CHANNEL_ORDER_UNSPEC.
	/*
	   Only the channel count is specified, without any further information
	   about the channel order.
	*/
	AVChannelOrderUnspec AVChannelOrder = C.AV_CHANNEL_ORDER_UNSPEC
	// AVChannelOrderNative wraps AV_CHANNEL_ORDER_NATIVE.
	/*
	   The native channel order, i.e. the channels are in the same order in
	   which they are defined in the AVChannel enum. This supports up to 63
	   different channels.
	*/
	AVChannelOrderNative AVChannelOrder = C.AV_CHANNEL_ORDER_NATIVE
	// AVChannelOrderCustom wraps AV_CHANNEL_ORDER_CUSTOM.
	/*
	   The channel order does not correspond to any other predefined order and
	   is stored as an explicit map. For example, this could be used to support
	   layouts with 64 or more channels, or with empty/skipped (AV_CHAN_UNUSED)
	   channels at arbitrary positions.
	*/
	AVChannelOrderCustom AVChannelOrder = C.AV_CHANNEL_ORDER_CUSTOM
	// AVChannelOrderAmbisonic wraps AV_CHANNEL_ORDER_AMBISONIC.
	/*
	   The audio is represented as the decomposition of the sound field into
	   spherical harmonics. Each channel corresponds to a single expansion
	   component. Channels are ordered according to ACN (Ambisonic Channel
	   Number).

	   The channel with the index n in the stream contains the spherical
	   harmonic of degree l and order m given by
	   @code{.unparsed}
	     l   = floor(sqrt(n)),
	     m   = n - l * (l + 1).
	   @endcode

	   Conversely given a spherical harmonic of degree l and order m, the
	   corresponding channel index n is given by
	   @code{.unparsed}
	     n = l * (l + 1) + m.
	   @endcode

	   Normalization is assumed to be SN3D (Schmidt Semi-Normalization)
	   as defined in AmbiX format $ 2.1.
	*/
	AVChannelOrderAmbisonic AVChannelOrder = C.AV_CHANNEL_ORDER_AMBISONIC
	// FFChannelOrderNb wraps FF_CHANNEL_ORDER_NB.
	//
	//	Number of channel orders, not part of ABI/API
	FFChannelOrderNb AVChannelOrder = C.FF_CHANNEL_ORDER_NB
)

// --- Enum AVMatrixEncoding ---

// AVMatrixEncoding wraps AVMatrixEncoding.
type AVMatrixEncoding C.enum_AVMatrixEncoding

const SizeOfAVMatrixEncoding = C.sizeof_enum_AVMatrixEncoding

func ToAVMatrixEncodingArray(ptr unsafe.Pointer) *Array[AVMatrixEncoding] {
	if ptr == nil {
		return nil
	}

	return &Array[AVMatrixEncoding]{
		elemSize: SizeOfAVMatrixEncoding,
		loadPtr: func(pointer unsafe.Pointer) AVMatrixEncoding {
			ptr := (*AVMatrixEncoding)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVMatrixEncoding) {
			ptr := (*AVMatrixEncoding)(pointer)
			*ptr = value
		},
	}
}

func AllocAVMatrixEncodingArray(size uint64) *Array[AVMatrixEncoding] {
	return ToAVMatrixEncodingArray(AVCalloc(size, SizeOfAVMatrixEncoding))
}

const (
	// AVMatrixEncodingNone wraps AV_MATRIX_ENCODING_NONE.
	AVMatrixEncodingNone AVMatrixEncoding = C.AV_MATRIX_ENCODING_NONE
	// AVMatrixEncodingDolby wraps AV_MATRIX_ENCODING_DOLBY.
	AVMatrixEncodingDolby AVMatrixEncoding = C.AV_MATRIX_ENCODING_DOLBY
	// AVMatrixEncodingDplii wraps AV_MATRIX_ENCODING_DPLII.
	AVMatrixEncodingDplii AVMatrixEncoding = C.AV_MATRIX_ENCODING_DPLII
	// AVMatrixEncodingDpliix wraps AV_MATRIX_ENCODING_DPLIIX.
	AVMatrixEncodingDpliix AVMatrixEncoding = C.AV_MATRIX_ENCODING_DPLIIX
	// AVMatrixEncodingDpliiz wraps AV_MATRIX_ENCODING_DPLIIZ.
	AVMatrixEncodingDpliiz AVMatrixEncoding = C.AV_MATRIX_ENCODING_DPLIIZ
	// AVMatrixEncodingDolbyex wraps AV_MATRIX_ENCODING_DOLBYEX.
	AVMatrixEncodingDolbyex AVMatrixEncoding = C.AV_MATRIX_ENCODING_DOLBYEX
	// AVMatrixEncodingDolbyheadphone wraps AV_MATRIX_ENCODING_DOLBYHEADPHONE.
	AVMatrixEncodingDolbyheadphone AVMatrixEncoding = C.AV_MATRIX_ENCODING_DOLBYHEADPHONE
	// AVMatrixEncodingNb wraps AV_MATRIX_ENCODING_NB.
	AVMatrixEncodingNb AVMatrixEncoding = C.AV_MATRIX_ENCODING_NB
)

// --- Enum AVContainerFifoFlags ---

// AVContainerFifoFlags wraps AVContainerFifoFlags.
type AVContainerFifoFlags C.enum_AVContainerFifoFlags

const SizeOfAVContainerFifoFlags = C.sizeof_enum_AVContainerFifoFlags

func ToAVContainerFifoFlagsArray(ptr unsafe.Pointer) *Array[AVContainerFifoFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[AVContainerFifoFlags]{
		elemSize: SizeOfAVContainerFifoFlags,
		loadPtr: func(pointer unsafe.Pointer) AVContainerFifoFlags {
			ptr := (*AVContainerFifoFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVContainerFifoFlags) {
			ptr := (*AVContainerFifoFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocAVContainerFifoFlagsArray(size uint64) *Array[AVContainerFifoFlags] {
	return ToAVContainerFifoFlagsArray(AVCalloc(size, SizeOfAVContainerFifoFlags))
}

const (
	// AVContainerFifoFlagRef wraps AV_CONTAINER_FIFO_FLAG_REF.
	/*
	   Signal to av_container_fifo_write() that it should make a new reference
	   to data in src rather than consume its contents.

	   @note you must handle this flag manually in your own fifo_transfer()
	         callback
	*/
	AVContainerFifoFlagRef AVContainerFifoFlags = C.AV_CONTAINER_FIFO_FLAG_REF
	// AVContainerFifoFlagUser wraps AV_CONTAINER_FIFO_FLAG_USER.
	/*
	   This and all higher bits in flags may be set to any value by the caller
	   and are guaranteed to be passed through to the fifo_transfer() callback
	   and not be interpreted by AVContainerFifo code.
	*/
	AVContainerFifoFlagUser AVContainerFifoFlags = C.AV_CONTAINER_FIFO_FLAG_USER
)

// --- Enum AVCRCId ---

// AVCRCId wraps AVCRCId.
type AVCRCId C.AVCRCId

const SizeOfAVCRCId = C.sizeof_AVCRCId

func ToAVCRCIdArray(ptr unsafe.Pointer) *Array[AVCRCId] {
	if ptr == nil {
		return nil
	}

	return &Array[AVCRCId]{
		elemSize: SizeOfAVCRCId,
		loadPtr: func(pointer unsafe.Pointer) AVCRCId {
			ptr := (*AVCRCId)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVCRCId) {
			ptr := (*AVCRCId)(pointer)
			*ptr = value
		},
	}
}

func AllocAVCRCIdArray(size uint64) *Array[AVCRCId] {
	return ToAVCRCIdArray(AVCalloc(size, SizeOfAVCRCId))
}

const (
	// AVCrc8Atm wraps AV_CRC_8_ATM.
	AVCrc8Atm AVCRCId = C.AV_CRC_8_ATM
	// AVCrc16Ansi wraps AV_CRC_16_ANSI.
	AVCrc16Ansi AVCRCId = C.AV_CRC_16_ANSI
	// AVCrc16Ccitt wraps AV_CRC_16_CCITT.
	AVCrc16Ccitt AVCRCId = C.AV_CRC_16_CCITT
	// AVCrc32Ieee wraps AV_CRC_32_IEEE.
	AVCrc32Ieee AVCRCId = C.AV_CRC_32_IEEE
	// AVCrc32IeeeLe wraps AV_CRC_32_IEEE_LE.
	//
	//	reversed bitorder version of AV_CRC_32_IEEE
	AVCrc32IeeeLe AVCRCId = C.AV_CRC_32_IEEE_LE
	// AVCrc16AnsiLe wraps AV_CRC_16_ANSI_LE.
	//
	//	reversed bitorder version of AV_CRC_16_ANSI
	AVCrc16AnsiLe AVCRCId = C.AV_CRC_16_ANSI_LE
	// AVCrc24Ieee wraps AV_CRC_24_IEEE.
	AVCrc24Ieee AVCRCId = C.AV_CRC_24_IEEE
	// AVCrc8Ebu wraps AV_CRC_8_EBU.
	AVCrc8Ebu AVCRCId = C.AV_CRC_8_EBU
	// AVCrcMax wraps AV_CRC_MAX.
	//
	//	Not part of public API! Do not use outside libavutil.
	AVCrcMax AVCRCId = C.AV_CRC_MAX
)

// --- Enum AVDOVICompression ---

// AVDOVICompression wraps AVDOVICompression.
type AVDOVICompression C.enum_AVDOVICompression

const SizeOfAVDOVICompression = C.sizeof_enum_AVDOVICompression

func ToAVDOVICompressionArray(ptr unsafe.Pointer) *Array[AVDOVICompression] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDOVICompression]{
		elemSize: SizeOfAVDOVICompression,
		loadPtr: func(pointer unsafe.Pointer) AVDOVICompression {
			ptr := (*AVDOVICompression)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDOVICompression) {
			ptr := (*AVDOVICompression)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDOVICompressionArray(size uint64) *Array[AVDOVICompression] {
	return ToAVDOVICompressionArray(AVCalloc(size, SizeOfAVDOVICompression))
}

const (
	// AVDoviCompressionNone wraps AV_DOVI_COMPRESSION_NONE.
	AVDoviCompressionNone AVDOVICompression = C.AV_DOVI_COMPRESSION_NONE
	// AVDoviCompressionLimited wraps AV_DOVI_COMPRESSION_LIMITED.
	AVDoviCompressionLimited AVDOVICompression = C.AV_DOVI_COMPRESSION_LIMITED
	// AVDoviCompressionReserved wraps AV_DOVI_COMPRESSION_RESERVED.
	AVDoviCompressionReserved AVDOVICompression = C.AV_DOVI_COMPRESSION_RESERVED
	// AVDoviCompressionExtended wraps AV_DOVI_COMPRESSION_EXTENDED.
	AVDoviCompressionExtended AVDOVICompression = C.AV_DOVI_COMPRESSION_EXTENDED
)

// --- Enum AVDOVIMappingMethod ---

// AVDOVIMappingMethod wraps AVDOVIMappingMethod.
type AVDOVIMappingMethod C.enum_AVDOVIMappingMethod

const SizeOfAVDOVIMappingMethod = C.sizeof_enum_AVDOVIMappingMethod

func ToAVDOVIMappingMethodArray(ptr unsafe.Pointer) *Array[AVDOVIMappingMethod] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDOVIMappingMethod]{
		elemSize: SizeOfAVDOVIMappingMethod,
		loadPtr: func(pointer unsafe.Pointer) AVDOVIMappingMethod {
			ptr := (*AVDOVIMappingMethod)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDOVIMappingMethod) {
			ptr := (*AVDOVIMappingMethod)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDOVIMappingMethodArray(size uint64) *Array[AVDOVIMappingMethod] {
	return ToAVDOVIMappingMethodArray(AVCalloc(size, SizeOfAVDOVIMappingMethod))
}

const (
	// AVDoviMappingPolynomial wraps AV_DOVI_MAPPING_POLYNOMIAL.
	AVDoviMappingPolynomial AVDOVIMappingMethod = C.AV_DOVI_MAPPING_POLYNOMIAL
	// AVDoviMappingMmr wraps AV_DOVI_MAPPING_MMR.
	AVDoviMappingMmr AVDOVIMappingMethod = C.AV_DOVI_MAPPING_MMR
)

// --- Enum AVDOVINLQMethod ---

// AVDOVINLQMethod wraps AVDOVINLQMethod.
type AVDOVINLQMethod C.enum_AVDOVINLQMethod

const SizeOfAVDOVINLQMethod = C.sizeof_enum_AVDOVINLQMethod

func ToAVDOVINLQMethodArray(ptr unsafe.Pointer) *Array[AVDOVINLQMethod] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDOVINLQMethod]{
		elemSize: SizeOfAVDOVINLQMethod,
		loadPtr: func(pointer unsafe.Pointer) AVDOVINLQMethod {
			ptr := (*AVDOVINLQMethod)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDOVINLQMethod) {
			ptr := (*AVDOVINLQMethod)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDOVINLQMethodArray(size uint64) *Array[AVDOVINLQMethod] {
	return ToAVDOVINLQMethodArray(AVCalloc(size, SizeOfAVDOVINLQMethod))
}

const (
	// AVDoviNlqNone wraps AV_DOVI_NLQ_NONE.
	AVDoviNlqNone AVDOVINLQMethod = C.AV_DOVI_NLQ_NONE
	// AVDoviNlqLinearDz wraps AV_DOVI_NLQ_LINEAR_DZ.
	AVDoviNlqLinearDz AVDOVINLQMethod = C.AV_DOVI_NLQ_LINEAR_DZ
)

// --- Enum AVDownmixType ---

// AVDownmixType wraps AVDownmixType.
//
//	Possible downmix types.
type AVDownmixType C.enum_AVDownmixType

const SizeOfAVDownmixType = C.sizeof_enum_AVDownmixType

func ToAVDownmixTypeArray(ptr unsafe.Pointer) *Array[AVDownmixType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVDownmixType]{
		elemSize: SizeOfAVDownmixType,
		loadPtr: func(pointer unsafe.Pointer) AVDownmixType {
			ptr := (*AVDownmixType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVDownmixType) {
			ptr := (*AVDownmixType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVDownmixTypeArray(size uint64) *Array[AVDownmixType] {
	return ToAVDownmixTypeArray(AVCalloc(size, SizeOfAVDownmixType))
}

const (
	// AVDownmixTypeUnknown wraps AV_DOWNMIX_TYPE_UNKNOWN.
	//
	//	Not indicated.
	AVDownmixTypeUnknown AVDownmixType = C.AV_DOWNMIX_TYPE_UNKNOWN
	// AVDownmixTypeLoro wraps AV_DOWNMIX_TYPE_LORO.
	//
	//	Lo/Ro 2-channel downmix (Stereo).
	AVDownmixTypeLoro AVDownmixType = C.AV_DOWNMIX_TYPE_LORO
	// AVDownmixTypeLtrt wraps AV_DOWNMIX_TYPE_LTRT.
	//
	//	Lt/Rt 2-channel downmix, Dolby Surround compatible.
	AVDownmixTypeLtrt AVDownmixType = C.AV_DOWNMIX_TYPE_LTRT
	// AVDownmixTypeDplii wraps AV_DOWNMIX_TYPE_DPLII.
	//
	//	Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible.
	AVDownmixTypeDplii AVDownmixType = C.AV_DOWNMIX_TYPE_DPLII
	// AVDownmixTypeNb wraps AV_DOWNMIX_TYPE_NB.
	//
	//	Number of downmix types. Not part of ABI.
	AVDownmixTypeNb AVDownmixType = C.AV_DOWNMIX_TYPE_NB
)

// --- Enum AVFilmGrainParamsType ---

// AVFilmGrainParamsType wraps AVFilmGrainParamsType.
type AVFilmGrainParamsType C.enum_AVFilmGrainParamsType

const SizeOfAVFilmGrainParamsType = C.sizeof_enum_AVFilmGrainParamsType

func ToAVFilmGrainParamsTypeArray(ptr unsafe.Pointer) *Array[AVFilmGrainParamsType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVFilmGrainParamsType]{
		elemSize: SizeOfAVFilmGrainParamsType,
		loadPtr: func(pointer unsafe.Pointer) AVFilmGrainParamsType {
			ptr := (*AVFilmGrainParamsType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVFilmGrainParamsType) {
			ptr := (*AVFilmGrainParamsType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVFilmGrainParamsTypeArray(size uint64) *Array[AVFilmGrainParamsType] {
	return ToAVFilmGrainParamsTypeArray(AVCalloc(size, SizeOfAVFilmGrainParamsType))
}

const (
	// AVFilmGrainParamsNone wraps AV_FILM_GRAIN_PARAMS_NONE.
	AVFilmGrainParamsNone AVFilmGrainParamsType = C.AV_FILM_GRAIN_PARAMS_NONE
	// AVFilmGrainParamsAV1 wraps AV_FILM_GRAIN_PARAMS_AV1.
	//
	//	The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
	AVFilmGrainParamsAV1 AVFilmGrainParamsType = C.AV_FILM_GRAIN_PARAMS_AV1
	// AVFilmGrainParamsH274 wraps AV_FILM_GRAIN_PARAMS_H274.
	//
	//	The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
	AVFilmGrainParamsH274 AVFilmGrainParamsType = C.AV_FILM_GRAIN_PARAMS_H274
)

// --- Enum AVFrameSideDataType ---

// AVFrameSideDataType wraps AVFrameSideDataType.
//
//	AVFrame is an abstraction for reference-counted raw multimedia data.
type AVFrameSideDataType C.enum_AVFrameSideDataType

const SizeOfAVFrameSideDataType = C.sizeof_enum_AVFrameSideDataType

func ToAVFrameSideDataTypeArray(ptr unsafe.Pointer) *Array[AVFrameSideDataType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVFrameSideDataType]{
		elemSize: SizeOfAVFrameSideDataType,
		loadPtr: func(pointer unsafe.Pointer) AVFrameSideDataType {
			ptr := (*AVFrameSideDataType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVFrameSideDataType) {
			ptr := (*AVFrameSideDataType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVFrameSideDataTypeArray(size uint64) *Array[AVFrameSideDataType] {
	return ToAVFrameSideDataTypeArray(AVCalloc(size, SizeOfAVFrameSideDataType))
}

const (
	// AVFrameDataPanscan wraps AV_FRAME_DATA_PANSCAN.
	//
	//	The data is the AVPanScan struct defined in libavcodec.
	AVFrameDataPanscan AVFrameSideDataType = C.AV_FRAME_DATA_PANSCAN
	// AVFrameDataA53Cc wraps AV_FRAME_DATA_A53_CC.
	/*
	   ATSC A53 Part 4 Closed Captions.
	   A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.
	   The number of bytes of CC data is AVFrameSideData.size.
	*/
	AVFrameDataA53Cc AVFrameSideDataType = C.AV_FRAME_DATA_A53_CC
	// AVFrameDataStereo3D wraps AV_FRAME_DATA_STEREO3D.
	/*
	   Stereoscopic 3d metadata.
	   The data is the AVStereo3D struct defined in libavutil/stereo3d.h.
	*/
	AVFrameDataStereo3D AVFrameSideDataType = C.AV_FRAME_DATA_STEREO3D
	// AVFrameDataMatrixencoding wraps AV_FRAME_DATA_MATRIXENCODING.
	//
	//	The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
	AVFrameDataMatrixencoding AVFrameSideDataType = C.AV_FRAME_DATA_MATRIXENCODING
	// AVFrameDataDownmixInfo wraps AV_FRAME_DATA_DOWNMIX_INFO.
	/*
	   Metadata relevant to a downmix procedure.
	   The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h.
	*/
	AVFrameDataDownmixInfo AVFrameSideDataType = C.AV_FRAME_DATA_DOWNMIX_INFO
	// AVFrameDataReplaygain wraps AV_FRAME_DATA_REPLAYGAIN.
	//
	//	ReplayGain information in the form of the AVReplayGain struct.
	AVFrameDataReplaygain AVFrameSideDataType = C.AV_FRAME_DATA_REPLAYGAIN
	// AVFrameDataDisplaymatrix wraps AV_FRAME_DATA_DISPLAYMATRIX.
	/*
	   This side data contains a 3x3 transformation matrix describing an affine
	   transformation that needs to be applied to the frame for correct
	   presentation.

	   See libavutil/display.h for a detailed description of the data.
	*/
	AVFrameDataDisplaymatrix AVFrameSideDataType = C.AV_FRAME_DATA_DISPLAYMATRIX
	// AVFrameDataAfd wraps AV_FRAME_DATA_AFD.
	/*
	   Active Format Description data consisting of a single byte as specified
	   in ETSI TS 101 154 using AVActiveFormatDescription enum.
	*/
	AVFrameDataAfd AVFrameSideDataType = C.AV_FRAME_DATA_AFD
	// AVFrameDataMotionVectors wraps AV_FRAME_DATA_MOTION_VECTORS.
	/*
	   Motion vectors exported by some codecs (on demand through the export_mvs
	   flag set in the libavcodec AVCodecContext flags2 option).
	   The data is the AVMotionVector struct defined in
	   libavutil/motion_vector.h.
	*/
	AVFrameDataMotionVectors AVFrameSideDataType = C.AV_FRAME_DATA_MOTION_VECTORS
	// AVFrameDataSkipSamples wraps AV_FRAME_DATA_SKIP_SAMPLES.
	/*
	   Recommends skipping the specified number of samples. This is exported
	   only if the "skip_manual" AVOption is set in libavcodec.
	   This has the same format as AV_PKT_DATA_SKIP_SAMPLES.
	   @code
	   u32le number of samples to skip from start of this packet
	   u32le number of samples to skip from end of this packet
	   u8    reason for start skip
	   u8    reason for end   skip (0=padding silence, 1=convergence)
	   @endcode
	*/
	AVFrameDataSkipSamples AVFrameSideDataType = C.AV_FRAME_DATA_SKIP_SAMPLES
	// AVFrameDataAudioServiceType wraps AV_FRAME_DATA_AUDIO_SERVICE_TYPE.
	/*
	   This side data must be associated with an audio frame and corresponds to
	   enum AVAudioServiceType defined in avcodec.h.
	*/
	AVFrameDataAudioServiceType AVFrameSideDataType = C.AV_FRAME_DATA_AUDIO_SERVICE_TYPE
	// AVFrameDataMasteringDisplayMetadata wraps AV_FRAME_DATA_MASTERING_DISPLAY_METADATA.
	/*
	   Mastering display metadata associated with a video frame. The payload is
	   an AVMasteringDisplayMetadata type and contains information about the
	   mastering display color volume.
	*/
	AVFrameDataMasteringDisplayMetadata AVFrameSideDataType = C.AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
	// AVFrameDataGopTimecode wraps AV_FRAME_DATA_GOP_TIMECODE.
	/*
	   The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.
	   This is set on the first frame of a GOP that has a temporal reference of 0.
	*/
	AVFrameDataGopTimecode AVFrameSideDataType = C.AV_FRAME_DATA_GOP_TIMECODE
	// AVFrameDataSpherical wraps AV_FRAME_DATA_SPHERICAL.
	/*
	   The data represents the AVSphericalMapping structure defined in
	   libavutil/spherical.h.
	*/
	AVFrameDataSpherical AVFrameSideDataType = C.AV_FRAME_DATA_SPHERICAL
	// AVFrameDataContentLightLevel wraps AV_FRAME_DATA_CONTENT_LIGHT_LEVEL.
	/*
	   Content light level (based on CTA-861.3). This payload contains data in
	   the form of the AVContentLightMetadata struct.
	*/
	AVFrameDataContentLightLevel AVFrameSideDataType = C.AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
	// AVFrameDataIccProfile wraps AV_FRAME_DATA_ICC_PROFILE.
	/*
	   The data contains an ICC profile as an opaque octet buffer following the
	   format described by ISO 15076-1 with an optional name defined in the
	   metadata key entry "name".
	*/
	AVFrameDataIccProfile AVFrameSideDataType = C.AV_FRAME_DATA_ICC_PROFILE
	// AVFrameDataS12MTimecode wraps AV_FRAME_DATA_S12M_TIMECODE.
	/*
	   Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
	   where the first uint32_t describes how many (1-3) of the other timecodes are used.
	   The timecode format is described in the documentation of av_timecode_get_smpte_from_framenum()
	   function in libavutil/timecode.h.
	*/
	AVFrameDataS12MTimecode AVFrameSideDataType = C.AV_FRAME_DATA_S12M_TIMECODE
	// AVFrameDataDynamicHdrPlus wraps AV_FRAME_DATA_DYNAMIC_HDR_PLUS.
	/*
	   HDR dynamic metadata associated with a video frame. The payload is
	   an AVDynamicHDRPlus type and contains information for color
	   volume transform - application 4 of SMPTE 2094-40:2016 standard.
	*/
	AVFrameDataDynamicHdrPlus AVFrameSideDataType = C.AV_FRAME_DATA_DYNAMIC_HDR_PLUS
	// AVFrameDataRegionsOfInterest wraps AV_FRAME_DATA_REGIONS_OF_INTEREST.
	/*
	   Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of
	   array element is implied by AVFrameSideData.size / AVRegionOfInterest.self_size.
	*/
	AVFrameDataRegionsOfInterest AVFrameSideDataType = C.AV_FRAME_DATA_REGIONS_OF_INTEREST
	// AVFrameDataVideoEncParams wraps AV_FRAME_DATA_VIDEO_ENC_PARAMS.
	//
	//	Encoding parameters for a video frame, as described by AVVideoEncParams.
	AVFrameDataVideoEncParams AVFrameSideDataType = C.AV_FRAME_DATA_VIDEO_ENC_PARAMS
	// AVFrameDataSeiUnregistered wraps AV_FRAME_DATA_SEI_UNREGISTERED.
	/*
	   User data unregistered metadata associated with a video frame.
	   This is the H.26[45] UDU SEI message, and shouldn't be used for any other purpose
	   The data is stored as uint8_t in AVFrameSideData.data which is 16 bytes of
	   uuid_iso_iec_11578 followed by AVFrameSideData.size - 16 bytes of user_data_payload_byte.
	*/
	AVFrameDataSeiUnregistered AVFrameSideDataType = C.AV_FRAME_DATA_SEI_UNREGISTERED
	// AVFrameDataFilmGrainParams wraps AV_FRAME_DATA_FILM_GRAIN_PARAMS.
	/*
	   Film grain parameters for a frame, described by AVFilmGrainParams.
	   Must be present for every frame which should have film grain applied.

	   May be present multiple times, for example when there are multiple
	   alternative parameter sets for different video signal characteristics.
	   The user should select the most appropriate set for the application.
	*/
	AVFrameDataFilmGrainParams AVFrameSideDataType = C.AV_FRAME_DATA_FILM_GRAIN_PARAMS
	// AVFrameDataDetectionBboxes wraps AV_FRAME_DATA_DETECTION_BBOXES.
	/*
	   Bounding boxes for object detection and classification,
	   as described by AVDetectionBBoxHeader.
	*/
	AVFrameDataDetectionBboxes AVFrameSideDataType = C.AV_FRAME_DATA_DETECTION_BBOXES
	// AVFrameDataDoviRpuBuffer wraps AV_FRAME_DATA_DOVI_RPU_BUFFER.
	/*
	   Dolby Vision RPU raw data, suitable for passing to x265
	   or other libraries. Array of uint8_t, with NAL emulation
	   bytes intact.
	*/
	AVFrameDataDoviRpuBuffer AVFrameSideDataType = C.AV_FRAME_DATA_DOVI_RPU_BUFFER
	// AVFrameDataDoviMetadata wraps AV_FRAME_DATA_DOVI_METADATA.
	/*
	   Parsed Dolby Vision metadata, suitable for passing to a software
	   implementation. The payload is the AVDOVIMetadata struct defined in
	   libavutil/dovi_meta.h.
	*/
	AVFrameDataDoviMetadata AVFrameSideDataType = C.AV_FRAME_DATA_DOVI_METADATA
	// AVFrameDataDynamicHdrVivid wraps AV_FRAME_DATA_DYNAMIC_HDR_VIVID.
	/*
	   HDR Vivid dynamic metadata associated with a video frame. The payload is
	   an AVDynamicHDRVivid type and contains information for color
	   volume transform - CUVA 005.1-2021.
	*/
	AVFrameDataDynamicHdrVivid AVFrameSideDataType = C.AV_FRAME_DATA_DYNAMIC_HDR_VIVID
	// AVFrameDataAmbientViewingEnvironment wraps AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT.
	//
	//	Ambient viewing environment metadata, as defined by H.274.
	AVFrameDataAmbientViewingEnvironment AVFrameSideDataType = C.AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
	// AVFrameDataVideoHint wraps AV_FRAME_DATA_VIDEO_HINT.
	/*
	   Provide encoder-specific hinting information about changed/unchanged
	   portions of a frame.  It can be used to pass information about which
	   macroblocks can be skipped because they didn't change from the
	   corresponding ones in the previous frame. This could be useful for
	   applications which know this information in advance to speed up
	   encoding.
	*/
	AVFrameDataVideoHint AVFrameSideDataType = C.AV_FRAME_DATA_VIDEO_HINT
	// AVFrameDataLcevc wraps AV_FRAME_DATA_LCEVC.
	/*
	   Raw LCEVC payload data, as a uint8_t array, with NAL emulation
	   bytes intact.
	*/
	AVFrameDataLcevc AVFrameSideDataType = C.AV_FRAME_DATA_LCEVC
	// AVFrameDataViewId wraps AV_FRAME_DATA_VIEW_ID.
	/*
	   This side data must be associated with a video frame.
	   The presence of this side data indicates that the video stream is
	   composed of multiple views (e.g. stereoscopic 3D content,
	   cf. H.264 Annex H or H.265 Annex G).
	   The data is an int storing the view ID.
	*/
	AVFrameDataViewId AVFrameSideDataType = C.AV_FRAME_DATA_VIEW_ID
	// AVFrameData3DReferenceDisplays wraps AV_FRAME_DATA_3D_REFERENCE_DISPLAYS.
	/*
	   This side data contains information about the reference display width(s)
	   and reference viewing distance(s) as well as information about the
	   corresponding reference stereo pair(s), i.e., the pair(s) of views to be
	   displayed for the viewer's left and right eyes on the reference display
	   at the reference viewing distance.
	   The payload is the AV3DReferenceDisplaysInfo struct defined in
	   libavutil/tdrdi.h.
	*/
	AVFrameData3DReferenceDisplays AVFrameSideDataType = C.AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
)

// --- Enum AVActiveFormatDescription ---

// AVActiveFormatDescription wraps AVActiveFormatDescription.
type AVActiveFormatDescription C.enum_AVActiveFormatDescription

const SizeOfAVActiveFormatDescription = C.sizeof_enum_AVActiveFormatDescription

func ToAVActiveFormatDescriptionArray(ptr unsafe.Pointer) *Array[AVActiveFormatDescription] {
	if ptr == nil {
		return nil
	}

	return &Array[AVActiveFormatDescription]{
		elemSize: SizeOfAVActiveFormatDescription,
		loadPtr: func(pointer unsafe.Pointer) AVActiveFormatDescription {
			ptr := (*AVActiveFormatDescription)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVActiveFormatDescription) {
			ptr := (*AVActiveFormatDescription)(pointer)
			*ptr = value
		},
	}
}

func AllocAVActiveFormatDescriptionArray(size uint64) *Array[AVActiveFormatDescription] {
	return ToAVActiveFormatDescriptionArray(AVCalloc(size, SizeOfAVActiveFormatDescription))
}

const (
	// AVAfdSame wraps AV_AFD_SAME.
	AVAfdSame AVActiveFormatDescription = C.AV_AFD_SAME
	// AVAfd43 wraps AV_AFD_4_3.
	AVAfd43 AVActiveFormatDescription = C.AV_AFD_4_3
	// AVAfd169 wraps AV_AFD_16_9.
	AVAfd169 AVActiveFormatDescription = C.AV_AFD_16_9
	// AVAfd149 wraps AV_AFD_14_9.
	AVAfd149 AVActiveFormatDescription = C.AV_AFD_14_9
	// AVAfd43Sp149 wraps AV_AFD_4_3_SP_14_9.
	AVAfd43Sp149 AVActiveFormatDescription = C.AV_AFD_4_3_SP_14_9
	// AVAfd169Sp149 wraps AV_AFD_16_9_SP_14_9.
	AVAfd169Sp149 AVActiveFormatDescription = C.AV_AFD_16_9_SP_14_9
	// AVAfdSp43 wraps AV_AFD_SP_4_3.
	AVAfdSp43 AVActiveFormatDescription = C.AV_AFD_SP_4_3
)

// --- Enum AVSideDataProps ---

// AVSideDataProps wraps AVSideDataProps.
type AVSideDataProps C.enum_AVSideDataProps

const SizeOfAVSideDataProps = C.sizeof_enum_AVSideDataProps

func ToAVSideDataPropsArray(ptr unsafe.Pointer) *Array[AVSideDataProps] {
	if ptr == nil {
		return nil
	}

	return &Array[AVSideDataProps]{
		elemSize: SizeOfAVSideDataProps,
		loadPtr: func(pointer unsafe.Pointer) AVSideDataProps {
			ptr := (*AVSideDataProps)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVSideDataProps) {
			ptr := (*AVSideDataProps)(pointer)
			*ptr = value
		},
	}
}

func AllocAVSideDataPropsArray(size uint64) *Array[AVSideDataProps] {
	return ToAVSideDataPropsArray(AVCalloc(size, SizeOfAVSideDataProps))
}

const (
	// AVSideDataPropGlobal wraps AV_SIDE_DATA_PROP_GLOBAL.
	/*
	   The side data type can be used in stream-global structures.
	   Side data types without this property are only meaningful on per-frame
	   basis.
	*/
	AVSideDataPropGlobal AVSideDataProps = C.AV_SIDE_DATA_PROP_GLOBAL
	// AVSideDataPropMulti wraps AV_SIDE_DATA_PROP_MULTI.
	/*
	   Multiple instances of this side data type can be meaningfully present in
	   a single side data array.
	*/
	AVSideDataPropMulti AVSideDataProps = C.AV_SIDE_DATA_PROP_MULTI
	// AVSideDataPropSizeDependent wraps AV_SIDE_DATA_PROP_SIZE_DEPENDENT.
	/*
	   Side data depends on the video dimensions. Side data with this property
	   loses its meaning when rescaling or cropping the image, unless
	   either recomputed or adjusted to the new resolution.
	*/
	AVSideDataPropSizeDependent AVSideDataProps = C.AV_SIDE_DATA_PROP_SIZE_DEPENDENT
	// AVSideDataPropColorDependent wraps AV_SIDE_DATA_PROP_COLOR_DEPENDENT.
	/*
	   Side data depends on the video color space. Side data with this property
	   loses its meaning when changing the video color encoding, e.g. by
	   adapting to a different set of primaries or transfer characteristics.
	*/
	AVSideDataPropColorDependent AVSideDataProps = C.AV_SIDE_DATA_PROP_COLOR_DEPENDENT
	// AVSideDataPropChannelDependent wraps AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT.
	/*
	   Side data depends on the channel layout. Side data with this property
	   loses its meaning when downmixing or upmixing, unless either recomputed
	   or adjusted to the new layout.
	*/
	AVSideDataPropChannelDependent AVSideDataProps = C.AV_SIDE_DATA_PROP_CHANNEL_DEPENDENT
)

// --- Enum AVHDRPlusOverlapProcessOption ---

// AVHDRPlusOverlapProcessOption wraps AVHDRPlusOverlapProcessOption.
//
//	Option for overlapping elliptical pixel selectors in an image.
type AVHDRPlusOverlapProcessOption C.enum_AVHDRPlusOverlapProcessOption

const SizeOfAVHDRPlusOverlapProcessOption = C.sizeof_enum_AVHDRPlusOverlapProcessOption

func ToAVHDRPlusOverlapProcessOptionArray(ptr unsafe.Pointer) *Array[AVHDRPlusOverlapProcessOption] {
	if ptr == nil {
		return nil
	}

	return &Array[AVHDRPlusOverlapProcessOption]{
		elemSize: SizeOfAVHDRPlusOverlapProcessOption,
		loadPtr: func(pointer unsafe.Pointer) AVHDRPlusOverlapProcessOption {
			ptr := (*AVHDRPlusOverlapProcessOption)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVHDRPlusOverlapProcessOption) {
			ptr := (*AVHDRPlusOverlapProcessOption)(pointer)
			*ptr = value
		},
	}
}

func AllocAVHDRPlusOverlapProcessOptionArray(size uint64) *Array[AVHDRPlusOverlapProcessOption] {
	return ToAVHDRPlusOverlapProcessOptionArray(AVCalloc(size, SizeOfAVHDRPlusOverlapProcessOption))
}

const (
	// AVHdrPlusOverlapProcessWeightedAVEraging wraps AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING.
	AVHdrPlusOverlapProcessWeightedAVEraging AVHDRPlusOverlapProcessOption = C.AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING
	// AVHdrPlusOverlapProcessLayering wraps AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING.
	AVHdrPlusOverlapProcessLayering AVHDRPlusOverlapProcessOption = C.AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING
)

// --- Enum AVHMACType ---

// AVHMACType wraps AVHMACType.
type AVHMACType C.enum_AVHMACType

const SizeOfAVHMACType = C.sizeof_enum_AVHMACType

func ToAVHMACTypeArray(ptr unsafe.Pointer) *Array[AVHMACType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVHMACType]{
		elemSize: SizeOfAVHMACType,
		loadPtr: func(pointer unsafe.Pointer) AVHMACType {
			ptr := (*AVHMACType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVHMACType) {
			ptr := (*AVHMACType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVHMACTypeArray(size uint64) *Array[AVHMACType] {
	return ToAVHMACTypeArray(AVCalloc(size, SizeOfAVHMACType))
}

const (
	// AVHmacMd5 wraps AV_HMAC_MD5.
	AVHmacMd5 AVHMACType = C.AV_HMAC_MD5
	// AVHmacSha1 wraps AV_HMAC_SHA1.
	AVHmacSha1 AVHMACType = C.AV_HMAC_SHA1
	// AVHmacSha224 wraps AV_HMAC_SHA224.
	AVHmacSha224 AVHMACType = C.AV_HMAC_SHA224
	// AVHmacSha256 wraps AV_HMAC_SHA256.
	AVHmacSha256 AVHMACType = C.AV_HMAC_SHA256
	// AVHmacSha384 wraps AV_HMAC_SHA384.
	AVHmacSha384 AVHMACType = C.AV_HMAC_SHA384
	// AVHmacSha512 wraps AV_HMAC_SHA512.
	AVHmacSha512 AVHMACType = C.AV_HMAC_SHA512
)

// --- Enum AVHWDeviceType ---

// AVHWDeviceType wraps AVHWDeviceType.
type AVHWDeviceType C.enum_AVHWDeviceType

const SizeOfAVHWDeviceType = C.sizeof_enum_AVHWDeviceType

func ToAVHWDeviceTypeArray(ptr unsafe.Pointer) *Array[AVHWDeviceType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVHWDeviceType]{
		elemSize: SizeOfAVHWDeviceType,
		loadPtr: func(pointer unsafe.Pointer) AVHWDeviceType {
			ptr := (*AVHWDeviceType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVHWDeviceType) {
			ptr := (*AVHWDeviceType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVHWDeviceTypeArray(size uint64) *Array[AVHWDeviceType] {
	return ToAVHWDeviceTypeArray(AVCalloc(size, SizeOfAVHWDeviceType))
}

const (
	// AVHWDeviceTypeNone wraps AV_HWDEVICE_TYPE_NONE.
	AVHWDeviceTypeNone AVHWDeviceType = C.AV_HWDEVICE_TYPE_NONE
	// AVHWDeviceTypeVdpau wraps AV_HWDEVICE_TYPE_VDPAU.
	AVHWDeviceTypeVdpau AVHWDeviceType = C.AV_HWDEVICE_TYPE_VDPAU
	// AVHWDeviceTypeCuda wraps AV_HWDEVICE_TYPE_CUDA.
	AVHWDeviceTypeCuda AVHWDeviceType = C.AV_HWDEVICE_TYPE_CUDA
	// AVHWDeviceTypeVaapi wraps AV_HWDEVICE_TYPE_VAAPI.
	AVHWDeviceTypeVaapi AVHWDeviceType = C.AV_HWDEVICE_TYPE_VAAPI
	// AVHWDeviceTypeDxva2 wraps AV_HWDEVICE_TYPE_DXVA2.
	AVHWDeviceTypeDxva2 AVHWDeviceType = C.AV_HWDEVICE_TYPE_DXVA2
	// AVHWDeviceTypeQsv wraps AV_HWDEVICE_TYPE_QSV.
	AVHWDeviceTypeQsv AVHWDeviceType = C.AV_HWDEVICE_TYPE_QSV
	// AVHWDeviceTypeVideotoolbox wraps AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
	AVHWDeviceTypeVideotoolbox AVHWDeviceType = C.AV_HWDEVICE_TYPE_VIDEOTOOLBOX
	// AVHWDeviceTypeD3D11Va wraps AV_HWDEVICE_TYPE_D3D11VA.
	AVHWDeviceTypeD3D11Va AVHWDeviceType = C.AV_HWDEVICE_TYPE_D3D11VA
	// AVHWDeviceTypeDrm wraps AV_HWDEVICE_TYPE_DRM.
	AVHWDeviceTypeDrm AVHWDeviceType = C.AV_HWDEVICE_TYPE_DRM
	// AVHWDeviceTypeOpencl wraps AV_HWDEVICE_TYPE_OPENCL.
	AVHWDeviceTypeOpencl AVHWDeviceType = C.AV_HWDEVICE_TYPE_OPENCL
	// AVHWDeviceTypeMediacodec wraps AV_HWDEVICE_TYPE_MEDIACODEC.
	AVHWDeviceTypeMediacodec AVHWDeviceType = C.AV_HWDEVICE_TYPE_MEDIACODEC
	// AVHWDeviceTypeVulkan wraps AV_HWDEVICE_TYPE_VULKAN.
	AVHWDeviceTypeVulkan AVHWDeviceType = C.AV_HWDEVICE_TYPE_VULKAN
	// AVHWDeviceTypeD3D12Va wraps AV_HWDEVICE_TYPE_D3D12VA.
	AVHWDeviceTypeD3D12Va AVHWDeviceType = C.AV_HWDEVICE_TYPE_D3D12VA
	// AVHWDeviceTypeAmf wraps AV_HWDEVICE_TYPE_AMF.
	AVHWDeviceTypeAmf AVHWDeviceType = C.AV_HWDEVICE_TYPE_AMF
	// AVHWDeviceTypeOhcodec wraps AV_HWDEVICE_TYPE_OHCODEC.
	//
	//	OpenHarmony Codec device
	AVHWDeviceTypeOhcodec AVHWDeviceType = C.AV_HWDEVICE_TYPE_OHCODEC
)

// --- Enum AVHWFrameTransferDirection ---

// AVHWFrameTransferDirection wraps AVHWFrameTransferDirection.
type AVHWFrameTransferDirection C.enum_AVHWFrameTransferDirection

const SizeOfAVHWFrameTransferDirection = C.sizeof_enum_AVHWFrameTransferDirection

func ToAVHWFrameTransferDirectionArray(ptr unsafe.Pointer) *Array[AVHWFrameTransferDirection] {
	if ptr == nil {
		return nil
	}

	return &Array[AVHWFrameTransferDirection]{
		elemSize: SizeOfAVHWFrameTransferDirection,
		loadPtr: func(pointer unsafe.Pointer) AVHWFrameTransferDirection {
			ptr := (*AVHWFrameTransferDirection)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVHWFrameTransferDirection) {
			ptr := (*AVHWFrameTransferDirection)(pointer)
			*ptr = value
		},
	}
}

func AllocAVHWFrameTransferDirectionArray(size uint64) *Array[AVHWFrameTransferDirection] {
	return ToAVHWFrameTransferDirectionArray(AVCalloc(size, SizeOfAVHWFrameTransferDirection))
}

const (
	// AVHWFrameTransferDirectionFrom wraps AV_HWFRAME_TRANSFER_DIRECTION_FROM.
	//
	//	Transfer the data from the queried hw frame.
	AVHWFrameTransferDirectionFrom AVHWFrameTransferDirection = C.AV_HWFRAME_TRANSFER_DIRECTION_FROM
	// AVHWFrameTransferDirectionTo wraps AV_HWFRAME_TRANSFER_DIRECTION_TO.
	//
	//	Transfer the data to the queried hw frame.
	AVHWFrameTransferDirectionTo AVHWFrameTransferDirection = C.AV_HWFRAME_TRANSFER_DIRECTION_TO
)

// --- Enum AVIAMFAnimationType ---

// AVIAMFAnimationType wraps AVIAMFAnimationType.
type AVIAMFAnimationType C.enum_AVIAMFAnimationType

const SizeOfAVIAMFAnimationType = C.sizeof_enum_AVIAMFAnimationType

func ToAVIAMFAnimationTypeArray(ptr unsafe.Pointer) *Array[AVIAMFAnimationType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFAnimationType]{
		elemSize: SizeOfAVIAMFAnimationType,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFAnimationType {
			ptr := (*AVIAMFAnimationType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFAnimationType) {
			ptr := (*AVIAMFAnimationType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFAnimationTypeArray(size uint64) *Array[AVIAMFAnimationType] {
	return ToAVIAMFAnimationTypeArray(AVCalloc(size, SizeOfAVIAMFAnimationType))
}

const (
	// AVIamfAnimationTypeStep wraps AV_IAMF_ANIMATION_TYPE_STEP.
	AVIamfAnimationTypeStep AVIAMFAnimationType = C.AV_IAMF_ANIMATION_TYPE_STEP
	// AVIamfAnimationTypeLinear wraps AV_IAMF_ANIMATION_TYPE_LINEAR.
	AVIamfAnimationTypeLinear AVIAMFAnimationType = C.AV_IAMF_ANIMATION_TYPE_LINEAR
	// AVIamfAnimationTypeBezier wraps AV_IAMF_ANIMATION_TYPE_BEZIER.
	AVIamfAnimationTypeBezier AVIAMFAnimationType = C.AV_IAMF_ANIMATION_TYPE_BEZIER
)

// --- Enum AVIAMFParamDefinitionType ---

// AVIAMFParamDefinitionType wraps AVIAMFParamDefinitionType.
type AVIAMFParamDefinitionType C.enum_AVIAMFParamDefinitionType

const SizeOfAVIAMFParamDefinitionType = C.sizeof_enum_AVIAMFParamDefinitionType

func ToAVIAMFParamDefinitionTypeArray(ptr unsafe.Pointer) *Array[AVIAMFParamDefinitionType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFParamDefinitionType]{
		elemSize: SizeOfAVIAMFParamDefinitionType,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFParamDefinitionType {
			ptr := (*AVIAMFParamDefinitionType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFParamDefinitionType) {
			ptr := (*AVIAMFParamDefinitionType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFParamDefinitionTypeArray(size uint64) *Array[AVIAMFParamDefinitionType] {
	return ToAVIAMFParamDefinitionTypeArray(AVCalloc(size, SizeOfAVIAMFParamDefinitionType))
}

const (
	// AVIamfParameterDefinitionMixGain wraps AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN.
	//
	//	Subblocks are of struct type AVIAMFMixGain
	AVIamfParameterDefinitionMixGain AVIAMFParamDefinitionType = C.AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN
	// AVIamfParameterDefinitionDemixing wraps AV_IAMF_PARAMETER_DEFINITION_DEMIXING.
	//
	//	Subblocks are of struct type AVIAMFDemixingInfo
	AVIamfParameterDefinitionDemixing AVIAMFParamDefinitionType = C.AV_IAMF_PARAMETER_DEFINITION_DEMIXING
	// AVIamfParameterDefinitionReconGain wraps AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN.
	//
	//	Subblocks are of struct type AVIAMFReconGain
	AVIamfParameterDefinitionReconGain AVIAMFParamDefinitionType = C.AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN
)

// --- Enum AVIAMFAmbisonicsMode ---

// AVIAMFAmbisonicsMode wraps AVIAMFAmbisonicsMode.
type AVIAMFAmbisonicsMode C.enum_AVIAMFAmbisonicsMode

const SizeOfAVIAMFAmbisonicsMode = C.sizeof_enum_AVIAMFAmbisonicsMode

func ToAVIAMFAmbisonicsModeArray(ptr unsafe.Pointer) *Array[AVIAMFAmbisonicsMode] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFAmbisonicsMode]{
		elemSize: SizeOfAVIAMFAmbisonicsMode,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFAmbisonicsMode {
			ptr := (*AVIAMFAmbisonicsMode)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFAmbisonicsMode) {
			ptr := (*AVIAMFAmbisonicsMode)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFAmbisonicsModeArray(size uint64) *Array[AVIAMFAmbisonicsMode] {
	return ToAVIAMFAmbisonicsModeArray(AVCalloc(size, SizeOfAVIAMFAmbisonicsMode))
}

const (
	// AVIamfAmbisonicsModeMono wraps AV_IAMF_AMBISONICS_MODE_MONO.
	AVIamfAmbisonicsModeMono AVIAMFAmbisonicsMode = C.AV_IAMF_AMBISONICS_MODE_MONO
	// AVIamfAmbisonicsModeProjection wraps AV_IAMF_AMBISONICS_MODE_PROJECTION.
	AVIamfAmbisonicsModeProjection AVIAMFAmbisonicsMode = C.AV_IAMF_AMBISONICS_MODE_PROJECTION
)

// --- Enum AVIAMFAudioElementType ---

// AVIAMFAudioElementType wraps AVIAMFAudioElementType.
type AVIAMFAudioElementType C.enum_AVIAMFAudioElementType

const SizeOfAVIAMFAudioElementType = C.sizeof_enum_AVIAMFAudioElementType

func ToAVIAMFAudioElementTypeArray(ptr unsafe.Pointer) *Array[AVIAMFAudioElementType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFAudioElementType]{
		elemSize: SizeOfAVIAMFAudioElementType,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFAudioElementType {
			ptr := (*AVIAMFAudioElementType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFAudioElementType) {
			ptr := (*AVIAMFAudioElementType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFAudioElementTypeArray(size uint64) *Array[AVIAMFAudioElementType] {
	return ToAVIAMFAudioElementTypeArray(AVCalloc(size, SizeOfAVIAMFAudioElementType))
}

const (
	// AVIamfAudioElementTypeChannel wraps AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL.
	AVIamfAudioElementTypeChannel AVIAMFAudioElementType = C.AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL
	// AVIamfAudioElementTypeScene wraps AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE.
	AVIamfAudioElementTypeScene AVIAMFAudioElementType = C.AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE
)

// --- Enum AVIAMFHeadphonesMode ---

// AVIAMFHeadphonesMode wraps AVIAMFHeadphonesMode.
type AVIAMFHeadphonesMode C.enum_AVIAMFHeadphonesMode

const SizeOfAVIAMFHeadphonesMode = C.sizeof_enum_AVIAMFHeadphonesMode

func ToAVIAMFHeadphonesModeArray(ptr unsafe.Pointer) *Array[AVIAMFHeadphonesMode] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFHeadphonesMode]{
		elemSize: SizeOfAVIAMFHeadphonesMode,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFHeadphonesMode {
			ptr := (*AVIAMFHeadphonesMode)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFHeadphonesMode) {
			ptr := (*AVIAMFHeadphonesMode)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFHeadphonesModeArray(size uint64) *Array[AVIAMFHeadphonesMode] {
	return ToAVIAMFHeadphonesModeArray(AVCalloc(size, SizeOfAVIAMFHeadphonesMode))
}

const (
	// AVIamfHeadphonesModeStereo wraps AV_IAMF_HEADPHONES_MODE_STEREO.
	//
	//	The referenced Audio Element shall be rendered to stereo loudspeakers.
	AVIamfHeadphonesModeStereo AVIAMFHeadphonesMode = C.AV_IAMF_HEADPHONES_MODE_STEREO
	// AVIamfHeadphonesModeBinaural wraps AV_IAMF_HEADPHONES_MODE_BINAURAL.
	//
	//	The referenced Audio Element shall be rendered with a binaural renderer.
	AVIamfHeadphonesModeBinaural AVIAMFHeadphonesMode = C.AV_IAMF_HEADPHONES_MODE_BINAURAL
)

// --- Enum AVIAMFSubmixLayoutType ---

// AVIAMFSubmixLayoutType wraps AVIAMFSubmixLayoutType.
type AVIAMFSubmixLayoutType C.enum_AVIAMFSubmixLayoutType

const SizeOfAVIAMFSubmixLayoutType = C.sizeof_enum_AVIAMFSubmixLayoutType

func ToAVIAMFSubmixLayoutTypeArray(ptr unsafe.Pointer) *Array[AVIAMFSubmixLayoutType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVIAMFSubmixLayoutType]{
		elemSize: SizeOfAVIAMFSubmixLayoutType,
		loadPtr: func(pointer unsafe.Pointer) AVIAMFSubmixLayoutType {
			ptr := (*AVIAMFSubmixLayoutType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVIAMFSubmixLayoutType) {
			ptr := (*AVIAMFSubmixLayoutType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVIAMFSubmixLayoutTypeArray(size uint64) *Array[AVIAMFSubmixLayoutType] {
	return ToAVIAMFSubmixLayoutTypeArray(AVCalloc(size, SizeOfAVIAMFSubmixLayoutType))
}

const (
	// AVIamfSubmixLayoutTypeLoudspeakers wraps AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS.
	/*
	   The layout follows the loudspeaker sound system convention of ITU-2051-3.
	   @ref AVIAMFSubmixLayout.sound_system must be set.
	*/
	AVIamfSubmixLayoutTypeLoudspeakers AVIAMFSubmixLayoutType = C.AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS
	// AVIamfSubmixLayoutTypeBinaural wraps AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL.
	/*
	   The layout is binaural.

	   @note @ref AVIAMFSubmixLayout.sound_system may be set to
	   AV_CHANNEL_LAYOUT_BINAURAL to simplify API usage, but it's not mandatory.
	*/
	AVIamfSubmixLayoutTypeBinaural AVIAMFSubmixLayoutType = C.AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL
)

// --- Enum AVClassCategory ---

// AVClassCategory wraps AVClassCategory.
type AVClassCategory C.AVClassCategory

const SizeOfAVClassCategory = C.sizeof_AVClassCategory

func ToAVClassCategoryArray(ptr unsafe.Pointer) *Array[AVClassCategory] {
	if ptr == nil {
		return nil
	}

	return &Array[AVClassCategory]{
		elemSize: SizeOfAVClassCategory,
		loadPtr: func(pointer unsafe.Pointer) AVClassCategory {
			ptr := (*AVClassCategory)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVClassCategory) {
			ptr := (*AVClassCategory)(pointer)
			*ptr = value
		},
	}
}

func AllocAVClassCategoryArray(size uint64) *Array[AVClassCategory] {
	return ToAVClassCategoryArray(AVCalloc(size, SizeOfAVClassCategory))
}

const (
	// AVClassCategoryNa wraps AV_CLASS_CATEGORY_NA.
	AVClassCategoryNa AVClassCategory = C.AV_CLASS_CATEGORY_NA
	// AVClassCategoryInput wraps AV_CLASS_CATEGORY_INPUT.
	AVClassCategoryInput AVClassCategory = C.AV_CLASS_CATEGORY_INPUT
	// AVClassCategoryOutput wraps AV_CLASS_CATEGORY_OUTPUT.
	AVClassCategoryOutput AVClassCategory = C.AV_CLASS_CATEGORY_OUTPUT
	// AVClassCategoryMuxer wraps AV_CLASS_CATEGORY_MUXER.
	AVClassCategoryMuxer AVClassCategory = C.AV_CLASS_CATEGORY_MUXER
	// AVClassCategoryDemuxer wraps AV_CLASS_CATEGORY_DEMUXER.
	AVClassCategoryDemuxer AVClassCategory = C.AV_CLASS_CATEGORY_DEMUXER
	// AVClassCategoryEncoder wraps AV_CLASS_CATEGORY_ENCODER.
	AVClassCategoryEncoder AVClassCategory = C.AV_CLASS_CATEGORY_ENCODER
	// AVClassCategoryDecoder wraps AV_CLASS_CATEGORY_DECODER.
	AVClassCategoryDecoder AVClassCategory = C.AV_CLASS_CATEGORY_DECODER
	// AVClassCategoryFilter wraps AV_CLASS_CATEGORY_FILTER.
	AVClassCategoryFilter AVClassCategory = C.AV_CLASS_CATEGORY_FILTER
	// AVClassCategoryBitstreamFilter wraps AV_CLASS_CATEGORY_BITSTREAM_FILTER.
	AVClassCategoryBitstreamFilter AVClassCategory = C.AV_CLASS_CATEGORY_BITSTREAM_FILTER
	// AVClassCategorySwscaler wraps AV_CLASS_CATEGORY_SWSCALER.
	AVClassCategorySwscaler AVClassCategory = C.AV_CLASS_CATEGORY_SWSCALER
	// AVClassCategorySwresampler wraps AV_CLASS_CATEGORY_SWRESAMPLER.
	AVClassCategorySwresampler AVClassCategory = C.AV_CLASS_CATEGORY_SWRESAMPLER
	// AVClassCategoryHWDevice wraps AV_CLASS_CATEGORY_HWDEVICE.
	AVClassCategoryHWDevice AVClassCategory = C.AV_CLASS_CATEGORY_HWDEVICE
	// AVClassCategoryDeviceVideoOutput wraps AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT.
	AVClassCategoryDeviceVideoOutput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
	// AVClassCategoryDeviceVideoInput wraps AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT.
	AVClassCategoryDeviceVideoInput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT
	// AVClassCategoryDeviceAudioOutput wraps AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT.
	AVClassCategoryDeviceAudioOutput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT
	// AVClassCategoryDeviceAudioInput wraps AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT.
	AVClassCategoryDeviceAudioInput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT
	// AVClassCategoryDeviceOutput wraps AV_CLASS_CATEGORY_DEVICE_OUTPUT.
	AVClassCategoryDeviceOutput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_OUTPUT
	// AVClassCategoryDeviceInput wraps AV_CLASS_CATEGORY_DEVICE_INPUT.
	AVClassCategoryDeviceInput AVClassCategory = C.AV_CLASS_CATEGORY_DEVICE_INPUT
	// AVClassCategoryNb wraps AV_CLASS_CATEGORY_NB.
	//
	//	not part of ABI/API
	AVClassCategoryNb AVClassCategory = C.AV_CLASS_CATEGORY_NB
)

// --- Enum AVClassStateFlags ---

// AVClassStateFlags wraps AVClassStateFlags.
type AVClassStateFlags C.enum_AVClassStateFlags

const SizeOfAVClassStateFlags = C.sizeof_enum_AVClassStateFlags

func ToAVClassStateFlagsArray(ptr unsafe.Pointer) *Array[AVClassStateFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[AVClassStateFlags]{
		elemSize: SizeOfAVClassStateFlags,
		loadPtr: func(pointer unsafe.Pointer) AVClassStateFlags {
			ptr := (*AVClassStateFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVClassStateFlags) {
			ptr := (*AVClassStateFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocAVClassStateFlagsArray(size uint64) *Array[AVClassStateFlags] {
	return ToAVClassStateFlagsArray(AVCalloc(size, SizeOfAVClassStateFlags))
}

const (
	// AVClassStateInitialized wraps AV_CLASS_STATE_INITIALIZED.
	/*
	   Object initialization has finished and it is now in the 'runtime' stage.
	   This affects e.g. what options can be set on the object (only
	   AV_OPT_FLAG_RUNTIME_PARAM options can be set on initialized objects).
	*/
	AVClassStateInitialized AVClassStateFlags = C.AV_CLASS_STATE_INITIALIZED
)

// --- Enum AVRounding ---

// AVRounding wraps AVRounding.
//
//	Rounding methods.
type AVRounding C.enum_AVRounding

const SizeOfAVRounding = C.sizeof_enum_AVRounding

func ToAVRoundingArray(ptr unsafe.Pointer) *Array[AVRounding] {
	if ptr == nil {
		return nil
	}

	return &Array[AVRounding]{
		elemSize: SizeOfAVRounding,
		loadPtr: func(pointer unsafe.Pointer) AVRounding {
			ptr := (*AVRounding)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVRounding) {
			ptr := (*AVRounding)(pointer)
			*ptr = value
		},
	}
}

func AllocAVRoundingArray(size uint64) *Array[AVRounding] {
	return ToAVRoundingArray(AVCalloc(size, SizeOfAVRounding))
}

const (
	// AVRoundZero wraps AV_ROUND_ZERO.
	//
	//	Round toward zero.
	AVRoundZero AVRounding = C.AV_ROUND_ZERO
	// AVRoundInf wraps AV_ROUND_INF.
	//
	//	Round away from zero.
	AVRoundInf AVRounding = C.AV_ROUND_INF
	// AVRoundDown wraps AV_ROUND_DOWN.
	//
	//	Round toward -infinity.
	AVRoundDown AVRounding = C.AV_ROUND_DOWN
	// AVRoundUp wraps AV_ROUND_UP.
	//
	//	Round toward +infinity.
	AVRoundUp AVRounding = C.AV_ROUND_UP
	// AVRoundNearInf wraps AV_ROUND_NEAR_INF.
	//
	//	Round to nearest and halfway cases away from zero.
	AVRoundNearInf AVRounding = C.AV_ROUND_NEAR_INF
	// AVRoundPassMinmax wraps AV_ROUND_PASS_MINMAX.
	/*
	   Flag telling rescaling functions to pass `INT64_MIN`/`MAX` through
	   unchanged, avoiding special cases for #AV_NOPTS_VALUE.

	   Unlike other values of the enumeration AVRounding, this value is a
	   bitmask that must be used in conjunction with another value of the
	   enumeration through a bitwise OR, in order to set behavior for normal
	   cases.

	   @code{.c}
	   av_rescale_rnd(3, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
	   Rescaling 3:
	       Calculating 3 * 1 / 2
	       3 / 2 is rounded up to 2
	       => 2

	   av_rescale_rnd(AV_NOPTS_VALUE, 1, 2, AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
	   Rescaling AV_NOPTS_VALUE:
	       AV_NOPTS_VALUE == INT64_MIN
	       AV_NOPTS_VALUE is passed through
	       => AV_NOPTS_VALUE
	   @endcode
	*/
	AVRoundPassMinmax AVRounding = C.AV_ROUND_PASS_MINMAX
)

// --- Enum AVOptionType ---

// AVOptionType wraps AVOptionType.
type AVOptionType C.enum_AVOptionType

const SizeOfAVOptionType = C.sizeof_enum_AVOptionType

func ToAVOptionTypeArray(ptr unsafe.Pointer) *Array[AVOptionType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVOptionType]{
		elemSize: SizeOfAVOptionType,
		loadPtr: func(pointer unsafe.Pointer) AVOptionType {
			ptr := (*AVOptionType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVOptionType) {
			ptr := (*AVOptionType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVOptionTypeArray(size uint64) *Array[AVOptionType] {
	return ToAVOptionTypeArray(AVCalloc(size, SizeOfAVOptionType))
}

const (
	// AVOptTypeFlags wraps AV_OPT_TYPE_FLAGS.
	//
	//	Underlying C type is unsigned int.
	AVOptTypeFlags AVOptionType = C.AV_OPT_TYPE_FLAGS
	// AVOptTypeInt wraps AV_OPT_TYPE_INT.
	//
	//	Underlying C type is int.
	AVOptTypeInt AVOptionType = C.AV_OPT_TYPE_INT
	// AVOptTypeInt64 wraps AV_OPT_TYPE_INT64.
	//
	//	Underlying C type is int64_t.
	AVOptTypeInt64 AVOptionType = C.AV_OPT_TYPE_INT64
	// AVOptTypeDouble wraps AV_OPT_TYPE_DOUBLE.
	//
	//	Underlying C type is double.
	AVOptTypeDouble AVOptionType = C.AV_OPT_TYPE_DOUBLE
	// AVOptTypeFloat wraps AV_OPT_TYPE_FLOAT.
	//
	//	Underlying C type is float.
	AVOptTypeFloat AVOptionType = C.AV_OPT_TYPE_FLOAT
	// AVOptTypeString wraps AV_OPT_TYPE_STRING.
	/*
	   Underlying C type is a uint8_t* that is either NULL or points to a C
	   string allocated with the av_malloc() family of functions.
	*/
	AVOptTypeString AVOptionType = C.AV_OPT_TYPE_STRING
	// AVOptTypeRational wraps AV_OPT_TYPE_RATIONAL.
	//
	//	Underlying C type is AVRational.
	AVOptTypeRational AVOptionType = C.AV_OPT_TYPE_RATIONAL
	// AVOptTypeBinary wraps AV_OPT_TYPE_BINARY.
	/*
	   Underlying C type is a uint8_t* that is either NULL or points to an array
	   allocated with the av_malloc() family of functions. The pointer is
	   immediately followed by an int containing the array length in bytes.
	*/
	AVOptTypeBinary AVOptionType = C.AV_OPT_TYPE_BINARY
	// AVOptTypeDict wraps AV_OPT_TYPE_DICT.
	//
	//	Underlying C type is AVDictionary*.
	AVOptTypeDict AVOptionType = C.AV_OPT_TYPE_DICT
	// AVOptTypeUint64 wraps AV_OPT_TYPE_UINT64.
	//
	//	Underlying C type is uint64_t.
	AVOptTypeUint64 AVOptionType = C.AV_OPT_TYPE_UINT64
	// AVOptTypeConst wraps AV_OPT_TYPE_CONST.
	/*
	   Special option type for declaring named constants. Does not correspond to
	   an actual field in the object, offset must be 0.
	*/
	AVOptTypeConst AVOptionType = C.AV_OPT_TYPE_CONST
	// AVOptTypeImageSize wraps AV_OPT_TYPE_IMAGE_SIZE.
	//
	//	Underlying C type is two consecutive integers.
	AVOptTypeImageSize AVOptionType = C.AV_OPT_TYPE_IMAGE_SIZE
	// AVOptTypePixelFmt wraps AV_OPT_TYPE_PIXEL_FMT.
	//
	//	Underlying C type is enum AVPixelFormat.
	AVOptTypePixelFmt AVOptionType = C.AV_OPT_TYPE_PIXEL_FMT
	// AVOptTypeSampleFmt wraps AV_OPT_TYPE_SAMPLE_FMT.
	//
	//	Underlying C type is enum AVSampleFormat.
	AVOptTypeSampleFmt AVOptionType = C.AV_OPT_TYPE_SAMPLE_FMT
	// AVOptTypeVideoRate wraps AV_OPT_TYPE_VIDEO_RATE.
	//
	//	Underlying C type is AVRational.
	AVOptTypeVideoRate AVOptionType = C.AV_OPT_TYPE_VIDEO_RATE
	// AVOptTypeDuration wraps AV_OPT_TYPE_DURATION.
	//
	//	Underlying C type is int64_t.
	AVOptTypeDuration AVOptionType = C.AV_OPT_TYPE_DURATION
	// AVOptTypeColor wraps AV_OPT_TYPE_COLOR.
	//
	//	Underlying C type is uint8_t[4].
	AVOptTypeColor AVOptionType = C.AV_OPT_TYPE_COLOR
	// AVOptTypeBool wraps AV_OPT_TYPE_BOOL.
	//
	//	Underlying C type is int.
	AVOptTypeBool AVOptionType = C.AV_OPT_TYPE_BOOL
	// AVOptTypeChlayout wraps AV_OPT_TYPE_CHLAYOUT.
	//
	//	Underlying C type is AVChannelLayout.
	AVOptTypeChlayout AVOptionType = C.AV_OPT_TYPE_CHLAYOUT
	// AVOptTypeUint wraps AV_OPT_TYPE_UINT.
	//
	//	Underlying C type is unsigned int.
	AVOptTypeUint AVOptionType = C.AV_OPT_TYPE_UINT
	// AVOptTypeFlagArray wraps AV_OPT_TYPE_FLAG_ARRAY.
	/*
	   May be combined with another regular option type to declare an array
	   option.

	   For array options, @ref AVOption.offset should refer to a pointer
	   corresponding to the option type. The pointer should be immediately
	   followed by an unsigned int that will store the number of elements in the
	   array.
	*/
	AVOptTypeFlagArray AVOptionType = C.AV_OPT_TYPE_FLAG_ARRAY
)

// --- Enum AVPixelFormat ---

// AVPixelFormat wraps AVPixelFormat.
/*
  Pixel format.

  @note
  AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA
  color is put together as:
   (A << 24) | (R << 16) | (G << 8) | B
  This is stored as BGRA on little-endian CPU architectures and ARGB on
  big-endian CPUs.

  @note
  If the resolution is not a multiple of the chroma subsampling factor
  then the chroma plane resolution must be rounded up.

  @par
  When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
  image data is stored in AVFrame.data[0]. The palette is transported in
  AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is
  formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is
  also endian-specific). Note also that the individual RGB32 palette
  components stored in AVFrame.data[1] should be in the range 0..255.
  This is important as many custom PAL8 video codecs that were designed
  to run on the IBM VGA graphics adapter use 6-bit palette components.

  @par
  For all the 8 bits per pixel formats, an RGB32 palette is in data[1] like
  for pal8. This palette is filled in automatically by the function
  allocating the picture.
*/
type AVPixelFormat C.enum_AVPixelFormat

const SizeOfAVPixelFormat = C.sizeof_enum_AVPixelFormat

func ToAVPixelFormatArray(ptr unsafe.Pointer) *Array[AVPixelFormat] {
	if ptr == nil {
		return nil
	}

	return &Array[AVPixelFormat]{
		elemSize: SizeOfAVPixelFormat,
		loadPtr: func(pointer unsafe.Pointer) AVPixelFormat {
			ptr := (*AVPixelFormat)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVPixelFormat) {
			ptr := (*AVPixelFormat)(pointer)
			*ptr = value
		},
	}
}

func AllocAVPixelFormatArray(size uint64) *Array[AVPixelFormat] {
	return ToAVPixelFormatArray(AVCalloc(size, SizeOfAVPixelFormat))
}

const (
	// AVPixFmtNone wraps AV_PIX_FMT_NONE.
	AVPixFmtNone AVPixelFormat = C.AV_PIX_FMT_NONE
	// AVPixFmtYuv420P wraps AV_PIX_FMT_YUV420P.
	//
	//	planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
	AVPixFmtYuv420P AVPixelFormat = C.AV_PIX_FMT_YUV420P
	// AVPixFmtYuyv422 wraps AV_PIX_FMT_YUYV422.
	//
	//	packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
	AVPixFmtYuyv422 AVPixelFormat = C.AV_PIX_FMT_YUYV422
	// AVPixFmtRgb24 wraps AV_PIX_FMT_RGB24.
	//
	//	packed RGB 8:8:8, 24bpp, RGBRGB...
	AVPixFmtRgb24 AVPixelFormat = C.AV_PIX_FMT_RGB24
	// AVPixFmtBgr24 wraps AV_PIX_FMT_BGR24.
	//
	//	packed RGB 8:8:8, 24bpp, BGRBGR...
	AVPixFmtBgr24 AVPixelFormat = C.AV_PIX_FMT_BGR24
	// AVPixFmtYuv422P wraps AV_PIX_FMT_YUV422P.
	//
	//	planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	AVPixFmtYuv422P AVPixelFormat = C.AV_PIX_FMT_YUV422P
	// AVPixFmtYuv444P wraps AV_PIX_FMT_YUV444P.
	//
	//	planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
	AVPixFmtYuv444P AVPixelFormat = C.AV_PIX_FMT_YUV444P
	// AVPixFmtYuv410P wraps AV_PIX_FMT_YUV410P.
	//
	//	planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
	AVPixFmtYuv410P AVPixelFormat = C.AV_PIX_FMT_YUV410P
	// AVPixFmtYuv411P wraps AV_PIX_FMT_YUV411P.
	//
	//	planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
	AVPixFmtYuv411P AVPixelFormat = C.AV_PIX_FMT_YUV411P
	// AVPixFmtGray8 wraps AV_PIX_FMT_GRAY8.
	//
	//	Y        ,  8bpp
	AVPixFmtGray8 AVPixelFormat = C.AV_PIX_FMT_GRAY8
	// AVPixFmtMonowhite wraps AV_PIX_FMT_MONOWHITE.
	//
	//	Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
	AVPixFmtMonowhite AVPixelFormat = C.AV_PIX_FMT_MONOWHITE
	// AVPixFmtMonoblack wraps AV_PIX_FMT_MONOBLACK.
	//
	//	Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
	AVPixFmtMonoblack AVPixelFormat = C.AV_PIX_FMT_MONOBLACK
	// AVPixFmtPal8 wraps AV_PIX_FMT_PAL8.
	//
	//	8 bits with AV_PIX_FMT_RGB32 palette
	AVPixFmtPal8 AVPixelFormat = C.AV_PIX_FMT_PAL8
	// AVPixFmtYuvj420P wraps AV_PIX_FMT_YUVJ420P.
	//
	//	planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
	AVPixFmtYuvj420P AVPixelFormat = C.AV_PIX_FMT_YUVJ420P
	// AVPixFmtYuvj422P wraps AV_PIX_FMT_YUVJ422P.
	//
	//	planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
	AVPixFmtYuvj422P AVPixelFormat = C.AV_PIX_FMT_YUVJ422P
	// AVPixFmtYuvj444P wraps AV_PIX_FMT_YUVJ444P.
	//
	//	planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
	AVPixFmtYuvj444P AVPixelFormat = C.AV_PIX_FMT_YUVJ444P
	// AVPixFmtUyvy422 wraps AV_PIX_FMT_UYVY422.
	//
	//	packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
	AVPixFmtUyvy422 AVPixelFormat = C.AV_PIX_FMT_UYVY422
	// AVPixFmtUyyvyy411 wraps AV_PIX_FMT_UYYVYY411.
	//
	//	packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
	AVPixFmtUyyvyy411 AVPixelFormat = C.AV_PIX_FMT_UYYVYY411
	// AVPixFmtBgr8 wraps AV_PIX_FMT_BGR8.
	//
	//	packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
	AVPixFmtBgr8 AVPixelFormat = C.AV_PIX_FMT_BGR8
	// AVPixFmtBgr4 wraps AV_PIX_FMT_BGR4.
	//
	//	packed RGB 1:2:1 bitstream,  4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
	AVPixFmtBgr4 AVPixelFormat = C.AV_PIX_FMT_BGR4
	// AVPixFmtBgr4Byte wraps AV_PIX_FMT_BGR4_BYTE.
	//
	//	packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
	AVPixFmtBgr4Byte AVPixelFormat = C.AV_PIX_FMT_BGR4_BYTE
	// AVPixFmtRgb8 wraps AV_PIX_FMT_RGB8.
	//
	//	packed RGB 3:3:2,  8bpp, (msb)3R 3G 2B(lsb)
	AVPixFmtRgb8 AVPixelFormat = C.AV_PIX_FMT_RGB8
	// AVPixFmtRgb4 wraps AV_PIX_FMT_RGB4.
	//
	//	packed RGB 1:2:1 bitstream,  4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
	AVPixFmtRgb4 AVPixelFormat = C.AV_PIX_FMT_RGB4
	// AVPixFmtRgb4Byte wraps AV_PIX_FMT_RGB4_BYTE.
	//
	//	packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
	AVPixFmtRgb4Byte AVPixelFormat = C.AV_PIX_FMT_RGB4_BYTE
	// AVPixFmtNv12 wraps AV_PIX_FMT_NV12.
	//
	//	planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
	AVPixFmtNv12 AVPixelFormat = C.AV_PIX_FMT_NV12
	// AVPixFmtNv21 wraps AV_PIX_FMT_NV21.
	//
	//	as above, but U and V bytes are swapped
	AVPixFmtNv21 AVPixelFormat = C.AV_PIX_FMT_NV21
	// AVPixFmtArgb wraps AV_PIX_FMT_ARGB.
	//
	//	packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
	AVPixFmtArgb AVPixelFormat = C.AV_PIX_FMT_ARGB
	// AVPixFmtRgba wraps AV_PIX_FMT_RGBA.
	//
	//	packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
	AVPixFmtRgba AVPixelFormat = C.AV_PIX_FMT_RGBA
	// AVPixFmtAbgr wraps AV_PIX_FMT_ABGR.
	//
	//	packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
	AVPixFmtAbgr AVPixelFormat = C.AV_PIX_FMT_ABGR
	// AVPixFmtBgra wraps AV_PIX_FMT_BGRA.
	//
	//	packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
	AVPixFmtBgra AVPixelFormat = C.AV_PIX_FMT_BGRA
	// AVPixFmtGray16Be wraps AV_PIX_FMT_GRAY16BE.
	//
	//	Y        , 16bpp, big-endian
	AVPixFmtGray16Be AVPixelFormat = C.AV_PIX_FMT_GRAY16BE
	// AVPixFmtGray16Le wraps AV_PIX_FMT_GRAY16LE.
	//
	//	Y        , 16bpp, little-endian
	AVPixFmtGray16Le AVPixelFormat = C.AV_PIX_FMT_GRAY16LE
	// AVPixFmtYuv440P wraps AV_PIX_FMT_YUV440P.
	//
	//	planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
	AVPixFmtYuv440P AVPixelFormat = C.AV_PIX_FMT_YUV440P
	// AVPixFmtYuvj440P wraps AV_PIX_FMT_YUVJ440P.
	//
	//	planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
	AVPixFmtYuvj440P AVPixelFormat = C.AV_PIX_FMT_YUVJ440P
	// AVPixFmtYuva420P wraps AV_PIX_FMT_YUVA420P.
	//
	//	planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
	AVPixFmtYuva420P AVPixelFormat = C.AV_PIX_FMT_YUVA420P
	// AVPixFmtRgb48Be wraps AV_PIX_FMT_RGB48BE.
	//
	//	packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
	AVPixFmtRgb48Be AVPixelFormat = C.AV_PIX_FMT_RGB48BE
	// AVPixFmtRgb48Le wraps AV_PIX_FMT_RGB48LE.
	//
	//	packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
	AVPixFmtRgb48Le AVPixelFormat = C.AV_PIX_FMT_RGB48LE
	// AVPixFmtRgb565Be wraps AV_PIX_FMT_RGB565BE.
	//
	//	packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
	AVPixFmtRgb565Be AVPixelFormat = C.AV_PIX_FMT_RGB565BE
	// AVPixFmtRgb565Le wraps AV_PIX_FMT_RGB565LE.
	//
	//	packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
	AVPixFmtRgb565Le AVPixelFormat = C.AV_PIX_FMT_RGB565LE
	// AVPixFmtRgb555Be wraps AV_PIX_FMT_RGB555BE.
	//
	//	packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian   , X=unused/undefined
	AVPixFmtRgb555Be AVPixelFormat = C.AV_PIX_FMT_RGB555BE
	// AVPixFmtRgb555Le wraps AV_PIX_FMT_RGB555LE.
	//
	//	packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
	AVPixFmtRgb555Le AVPixelFormat = C.AV_PIX_FMT_RGB555LE
	// AVPixFmtBgr565Be wraps AV_PIX_FMT_BGR565BE.
	//
	//	packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
	AVPixFmtBgr565Be AVPixelFormat = C.AV_PIX_FMT_BGR565BE
	// AVPixFmtBgr565Le wraps AV_PIX_FMT_BGR565LE.
	//
	//	packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
	AVPixFmtBgr565Le AVPixelFormat = C.AV_PIX_FMT_BGR565LE
	// AVPixFmtBgr555Be wraps AV_PIX_FMT_BGR555BE.
	//
	//	packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian   , X=unused/undefined
	AVPixFmtBgr555Be AVPixelFormat = C.AV_PIX_FMT_BGR555BE
	// AVPixFmtBgr555Le wraps AV_PIX_FMT_BGR555LE.
	//
	//	packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
	AVPixFmtBgr555Le AVPixelFormat = C.AV_PIX_FMT_BGR555LE
	// AVPixFmtVaapi wraps AV_PIX_FMT_VAAPI.
	/*
	   Hardware acceleration through VA-API, data[3] contains a
	   VASurfaceID.
	*/
	AVPixFmtVaapi AVPixelFormat = C.AV_PIX_FMT_VAAPI
	// AVPixFmtYuv420P16Le wraps AV_PIX_FMT_YUV420P16LE.
	//
	//	planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AVPixFmtYuv420P16Le AVPixelFormat = C.AV_PIX_FMT_YUV420P16LE
	// AVPixFmtYuv420P16Be wraps AV_PIX_FMT_YUV420P16BE.
	//
	//	planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AVPixFmtYuv420P16Be AVPixelFormat = C.AV_PIX_FMT_YUV420P16BE
	// AVPixFmtYuv422P16Le wraps AV_PIX_FMT_YUV422P16LE.
	//
	//	planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtYuv422P16Le AVPixelFormat = C.AV_PIX_FMT_YUV422P16LE
	// AVPixFmtYuv422P16Be wraps AV_PIX_FMT_YUV422P16BE.
	//
	//	planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtYuv422P16Be AVPixelFormat = C.AV_PIX_FMT_YUV422P16BE
	// AVPixFmtYuv444P16Le wraps AV_PIX_FMT_YUV444P16LE.
	//
	//	planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AVPixFmtYuv444P16Le AVPixelFormat = C.AV_PIX_FMT_YUV444P16LE
	// AVPixFmtYuv444P16Be wraps AV_PIX_FMT_YUV444P16BE.
	//
	//	planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AVPixFmtYuv444P16Be AVPixelFormat = C.AV_PIX_FMT_YUV444P16BE
	// AVPixFmtDxva2Vld wraps AV_PIX_FMT_DXVA2_VLD.
	//
	//	HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
	AVPixFmtDxva2Vld AVPixelFormat = C.AV_PIX_FMT_DXVA2_VLD
	// AVPixFmtRgb444Le wraps AV_PIX_FMT_RGB444LE.
	//
	//	packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
	AVPixFmtRgb444Le AVPixelFormat = C.AV_PIX_FMT_RGB444LE
	// AVPixFmtRgb444Be wraps AV_PIX_FMT_RGB444BE.
	//
	//	packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian,    X=unused/undefined
	AVPixFmtRgb444Be AVPixelFormat = C.AV_PIX_FMT_RGB444BE
	// AVPixFmtBgr444Le wraps AV_PIX_FMT_BGR444LE.
	//
	//	packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
	AVPixFmtBgr444Le AVPixelFormat = C.AV_PIX_FMT_BGR444LE
	// AVPixFmtBgr444Be wraps AV_PIX_FMT_BGR444BE.
	//
	//	packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian,    X=unused/undefined
	AVPixFmtBgr444Be AVPixelFormat = C.AV_PIX_FMT_BGR444BE
	// AVPixFmtYa8 wraps AV_PIX_FMT_YA8.
	//
	//	8 bits gray, 8 bits alpha
	AVPixFmtYa8 AVPixelFormat = C.AV_PIX_FMT_YA8
	// AVPixFmtY400A wraps AV_PIX_FMT_Y400A.
	//
	//	alias for AV_PIX_FMT_YA8
	AVPixFmtY400A AVPixelFormat = C.AV_PIX_FMT_Y400A
	// AVPixFmtGray8A wraps AV_PIX_FMT_GRAY8A.
	//
	//	alias for AV_PIX_FMT_YA8
	AVPixFmtGray8A AVPixelFormat = C.AV_PIX_FMT_GRAY8A
	// AVPixFmtBgr48Be wraps AV_PIX_FMT_BGR48BE.
	//
	//	packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
	AVPixFmtBgr48Be AVPixelFormat = C.AV_PIX_FMT_BGR48BE
	// AVPixFmtBgr48Le wraps AV_PIX_FMT_BGR48LE.
	//
	//	packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
	AVPixFmtBgr48Le AVPixelFormat = C.AV_PIX_FMT_BGR48LE
	// AVPixFmtYuv420P9Be wraps AV_PIX_FMT_YUV420P9BE.
	//
	//	planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AVPixFmtYuv420P9Be AVPixelFormat = C.AV_PIX_FMT_YUV420P9BE
	// AVPixFmtYuv420P9Le wraps AV_PIX_FMT_YUV420P9LE.
	//
	//	planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AVPixFmtYuv420P9Le AVPixelFormat = C.AV_PIX_FMT_YUV420P9LE
	// AVPixFmtYuv420P10Be wraps AV_PIX_FMT_YUV420P10BE.
	//
	//	planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AVPixFmtYuv420P10Be AVPixelFormat = C.AV_PIX_FMT_YUV420P10BE
	// AVPixFmtYuv420P10Le wraps AV_PIX_FMT_YUV420P10LE.
	//
	//	planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AVPixFmtYuv420P10Le AVPixelFormat = C.AV_PIX_FMT_YUV420P10LE
	// AVPixFmtYuv422P10Be wraps AV_PIX_FMT_YUV422P10BE.
	//
	//	planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtYuv422P10Be AVPixelFormat = C.AV_PIX_FMT_YUV422P10BE
	// AVPixFmtYuv422P10Le wraps AV_PIX_FMT_YUV422P10LE.
	//
	//	planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtYuv422P10Le AVPixelFormat = C.AV_PIX_FMT_YUV422P10LE
	// AVPixFmtYuv444P9Be wraps AV_PIX_FMT_YUV444P9BE.
	//
	//	planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AVPixFmtYuv444P9Be AVPixelFormat = C.AV_PIX_FMT_YUV444P9BE
	// AVPixFmtYuv444P9Le wraps AV_PIX_FMT_YUV444P9LE.
	//
	//	planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AVPixFmtYuv444P9Le AVPixelFormat = C.AV_PIX_FMT_YUV444P9LE
	// AVPixFmtYuv444P10Be wraps AV_PIX_FMT_YUV444P10BE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AVPixFmtYuv444P10Be AVPixelFormat = C.AV_PIX_FMT_YUV444P10BE
	// AVPixFmtYuv444P10Le wraps AV_PIX_FMT_YUV444P10LE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AVPixFmtYuv444P10Le AVPixelFormat = C.AV_PIX_FMT_YUV444P10LE
	// AVPixFmtYuv422P9Be wraps AV_PIX_FMT_YUV422P9BE.
	//
	//	planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtYuv422P9Be AVPixelFormat = C.AV_PIX_FMT_YUV422P9BE
	// AVPixFmtYuv422P9Le wraps AV_PIX_FMT_YUV422P9LE.
	//
	//	planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtYuv422P9Le AVPixelFormat = C.AV_PIX_FMT_YUV422P9LE
	// AVPixFmtGbrp wraps AV_PIX_FMT_GBRP.
	//
	//	planar GBR 4:4:4 24bpp
	AVPixFmtGbrp AVPixelFormat = C.AV_PIX_FMT_GBRP
	// AVPixFmtGbr24P wraps AV_PIX_FMT_GBR24P.
	//
	//	alias for #AV_PIX_FMT_GBRP
	AVPixFmtGbr24P AVPixelFormat = C.AV_PIX_FMT_GBR24P
	// AVPixFmtGbrp9Be wraps AV_PIX_FMT_GBRP9BE.
	//
	//	planar GBR 4:4:4 27bpp, big-endian
	AVPixFmtGbrp9Be AVPixelFormat = C.AV_PIX_FMT_GBRP9BE
	// AVPixFmtGbrp9Le wraps AV_PIX_FMT_GBRP9LE.
	//
	//	planar GBR 4:4:4 27bpp, little-endian
	AVPixFmtGbrp9Le AVPixelFormat = C.AV_PIX_FMT_GBRP9LE
	// AVPixFmtGbrp10Be wraps AV_PIX_FMT_GBRP10BE.
	//
	//	planar GBR 4:4:4 30bpp, big-endian
	AVPixFmtGbrp10Be AVPixelFormat = C.AV_PIX_FMT_GBRP10BE
	// AVPixFmtGbrp10Le wraps AV_PIX_FMT_GBRP10LE.
	//
	//	planar GBR 4:4:4 30bpp, little-endian
	AVPixFmtGbrp10Le AVPixelFormat = C.AV_PIX_FMT_GBRP10LE
	// AVPixFmtGbrp16Be wraps AV_PIX_FMT_GBRP16BE.
	//
	//	planar GBR 4:4:4 48bpp, big-endian
	AVPixFmtGbrp16Be AVPixelFormat = C.AV_PIX_FMT_GBRP16BE
	// AVPixFmtGbrp16Le wraps AV_PIX_FMT_GBRP16LE.
	//
	//	planar GBR 4:4:4 48bpp, little-endian
	AVPixFmtGbrp16Le AVPixelFormat = C.AV_PIX_FMT_GBRP16LE
	// AVPixFmtYuva422P wraps AV_PIX_FMT_YUVA422P.
	//
	//	planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
	AVPixFmtYuva422P AVPixelFormat = C.AV_PIX_FMT_YUVA422P
	// AVPixFmtYuva444P wraps AV_PIX_FMT_YUVA444P.
	//
	//	planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
	AVPixFmtYuva444P AVPixelFormat = C.AV_PIX_FMT_YUVA444P
	// AVPixFmtYuva420P9Be wraps AV_PIX_FMT_YUVA420P9BE.
	//
	//	planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
	AVPixFmtYuva420P9Be AVPixelFormat = C.AV_PIX_FMT_YUVA420P9BE
	// AVPixFmtYuva420P9Le wraps AV_PIX_FMT_YUVA420P9LE.
	//
	//	planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
	AVPixFmtYuva420P9Le AVPixelFormat = C.AV_PIX_FMT_YUVA420P9LE
	// AVPixFmtYuva422P9Be wraps AV_PIX_FMT_YUVA422P9BE.
	//
	//	planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
	AVPixFmtYuva422P9Be AVPixelFormat = C.AV_PIX_FMT_YUVA422P9BE
	// AVPixFmtYuva422P9Le wraps AV_PIX_FMT_YUVA422P9LE.
	//
	//	planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
	AVPixFmtYuva422P9Le AVPixelFormat = C.AV_PIX_FMT_YUVA422P9LE
	// AVPixFmtYuva444P9Be wraps AV_PIX_FMT_YUVA444P9BE.
	//
	//	planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
	AVPixFmtYuva444P9Be AVPixelFormat = C.AV_PIX_FMT_YUVA444P9BE
	// AVPixFmtYuva444P9Le wraps AV_PIX_FMT_YUVA444P9LE.
	//
	//	planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
	AVPixFmtYuva444P9Le AVPixelFormat = C.AV_PIX_FMT_YUVA444P9LE
	// AVPixFmtYuva420P10Be wraps AV_PIX_FMT_YUVA420P10BE.
	//
	//	planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
	AVPixFmtYuva420P10Be AVPixelFormat = C.AV_PIX_FMT_YUVA420P10BE
	// AVPixFmtYuva420P10Le wraps AV_PIX_FMT_YUVA420P10LE.
	//
	//	planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	AVPixFmtYuva420P10Le AVPixelFormat = C.AV_PIX_FMT_YUVA420P10LE
	// AVPixFmtYuva422P10Be wraps AV_PIX_FMT_YUVA422P10BE.
	//
	//	planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
	AVPixFmtYuva422P10Be AVPixelFormat = C.AV_PIX_FMT_YUVA422P10BE
	// AVPixFmtYuva422P10Le wraps AV_PIX_FMT_YUVA422P10LE.
	//
	//	planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	AVPixFmtYuva422P10Le AVPixelFormat = C.AV_PIX_FMT_YUVA422P10LE
	// AVPixFmtYuva444P10Be wraps AV_PIX_FMT_YUVA444P10BE.
	//
	//	planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
	AVPixFmtYuva444P10Be AVPixelFormat = C.AV_PIX_FMT_YUVA444P10BE
	// AVPixFmtYuva444P10Le wraps AV_PIX_FMT_YUVA444P10LE.
	//
	//	planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	AVPixFmtYuva444P10Le AVPixelFormat = C.AV_PIX_FMT_YUVA444P10LE
	// AVPixFmtYuva420P16Be wraps AV_PIX_FMT_YUVA420P16BE.
	//
	//	planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
	AVPixFmtYuva420P16Be AVPixelFormat = C.AV_PIX_FMT_YUVA420P16BE
	// AVPixFmtYuva420P16Le wraps AV_PIX_FMT_YUVA420P16LE.
	//
	//	planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
	AVPixFmtYuva420P16Le AVPixelFormat = C.AV_PIX_FMT_YUVA420P16LE
	// AVPixFmtYuva422P16Be wraps AV_PIX_FMT_YUVA422P16BE.
	//
	//	planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
	AVPixFmtYuva422P16Be AVPixelFormat = C.AV_PIX_FMT_YUVA422P16BE
	// AVPixFmtYuva422P16Le wraps AV_PIX_FMT_YUVA422P16LE.
	//
	//	planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
	AVPixFmtYuva422P16Le AVPixelFormat = C.AV_PIX_FMT_YUVA422P16LE
	// AVPixFmtYuva444P16Be wraps AV_PIX_FMT_YUVA444P16BE.
	//
	//	planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
	AVPixFmtYuva444P16Be AVPixelFormat = C.AV_PIX_FMT_YUVA444P16BE
	// AVPixFmtYuva444P16Le wraps AV_PIX_FMT_YUVA444P16LE.
	//
	//	planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
	AVPixFmtYuva444P16Le AVPixelFormat = C.AV_PIX_FMT_YUVA444P16LE
	// AVPixFmtVdpau wraps AV_PIX_FMT_VDPAU.
	//
	//	HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface
	AVPixFmtVdpau AVPixelFormat = C.AV_PIX_FMT_VDPAU
	// AVPixFmtXyz12Le wraps AV_PIX_FMT_XYZ12LE.
	//
	//	packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0
	AVPixFmtXyz12Le AVPixelFormat = C.AV_PIX_FMT_XYZ12LE
	// AVPixFmtXyz12Be wraps AV_PIX_FMT_XYZ12BE.
	//
	//	packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0
	AVPixFmtXyz12Be AVPixelFormat = C.AV_PIX_FMT_XYZ12BE
	// AVPixFmtNv16 wraps AV_PIX_FMT_NV16.
	//
	//	interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
	AVPixFmtNv16 AVPixelFormat = C.AV_PIX_FMT_NV16
	// AVPixFmtNv20Le wraps AV_PIX_FMT_NV20LE.
	//
	//	interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtNv20Le AVPixelFormat = C.AV_PIX_FMT_NV20LE
	// AVPixFmtNv20Be wraps AV_PIX_FMT_NV20BE.
	//
	//	interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtNv20Be AVPixelFormat = C.AV_PIX_FMT_NV20BE
	// AVPixFmtRgba64Be wraps AV_PIX_FMT_RGBA64BE.
	//
	//	packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
	AVPixFmtRgba64Be AVPixelFormat = C.AV_PIX_FMT_RGBA64BE
	// AVPixFmtRgba64Le wraps AV_PIX_FMT_RGBA64LE.
	//
	//	packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
	AVPixFmtRgba64Le AVPixelFormat = C.AV_PIX_FMT_RGBA64LE
	// AVPixFmtBgra64Be wraps AV_PIX_FMT_BGRA64BE.
	//
	//	packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
	AVPixFmtBgra64Be AVPixelFormat = C.AV_PIX_FMT_BGRA64BE
	// AVPixFmtBgra64Le wraps AV_PIX_FMT_BGRA64LE.
	//
	//	packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
	AVPixFmtBgra64Le AVPixelFormat = C.AV_PIX_FMT_BGRA64LE
	// AVPixFmtYvyu422 wraps AV_PIX_FMT_YVYU422.
	//
	//	packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
	AVPixFmtYvyu422 AVPixelFormat = C.AV_PIX_FMT_YVYU422
	// AVPixFmtYa16Be wraps AV_PIX_FMT_YA16BE.
	//
	//	16 bits gray, 16 bits alpha (big-endian)
	AVPixFmtYa16Be AVPixelFormat = C.AV_PIX_FMT_YA16BE
	// AVPixFmtYa16Le wraps AV_PIX_FMT_YA16LE.
	//
	//	16 bits gray, 16 bits alpha (little-endian)
	AVPixFmtYa16Le AVPixelFormat = C.AV_PIX_FMT_YA16LE
	// AVPixFmtGbrap wraps AV_PIX_FMT_GBRAP.
	//
	//	planar GBRA 4:4:4:4 32bpp
	AVPixFmtGbrap AVPixelFormat = C.AV_PIX_FMT_GBRAP
	// AVPixFmtGbrap16Be wraps AV_PIX_FMT_GBRAP16BE.
	//
	//	planar GBRA 4:4:4:4 64bpp, big-endian
	AVPixFmtGbrap16Be AVPixelFormat = C.AV_PIX_FMT_GBRAP16BE
	// AVPixFmtGbrap16Le wraps AV_PIX_FMT_GBRAP16LE.
	//
	//	planar GBRA 4:4:4:4 64bpp, little-endian
	AVPixFmtGbrap16Le AVPixelFormat = C.AV_PIX_FMT_GBRAP16LE
	// AVPixFmtQsv wraps AV_PIX_FMT_QSV.
	/*
	   HW acceleration through QSV, data[3] contains a pointer to the
	   mfxFrameSurface1 structure.

	   Before FFmpeg 5.0:
	   mfxFrameSurface1.Data.MemId contains a pointer when importing
	   the following frames as QSV frames:

	   VAAPI:
	   mfxFrameSurface1.Data.MemId contains a pointer to VASurfaceID

	   DXVA2:
	   mfxFrameSurface1.Data.MemId contains a pointer to IDirect3DSurface9

	   FFmpeg 5.0 and above:
	   mfxFrameSurface1.Data.MemId contains a pointer to the mfxHDLPair
	   structure when importing the following frames as QSV frames:

	   VAAPI:
	   mfxHDLPair.first contains a VASurfaceID pointer.
	   mfxHDLPair.second is always MFX_INFINITE.

	   DXVA2:
	   mfxHDLPair.first contains IDirect3DSurface9 pointer.
	   mfxHDLPair.second is always MFX_INFINITE.

	   D3D11:
	   mfxHDLPair.first contains a ID3D11Texture2D pointer.
	   mfxHDLPair.second contains the texture array index of the frame if the
	   ID3D11Texture2D is an array texture, or always MFX_INFINITE if it is a
	   normal texture.
	*/
	AVPixFmtQsv AVPixelFormat = C.AV_PIX_FMT_QSV
	// AVPixFmtMmal wraps AV_PIX_FMT_MMAL.
	/*
	   HW acceleration though MMAL, data[3] contains a pointer to the
	   MMAL_BUFFER_HEADER_T structure.
	*/
	AVPixFmtMmal AVPixelFormat = C.AV_PIX_FMT_MMAL
	// AVPixFmtD3D11VaVld wraps AV_PIX_FMT_D3D11VA_VLD.
	//
	//	HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer
	AVPixFmtD3D11VaVld AVPixelFormat = C.AV_PIX_FMT_D3D11VA_VLD
	// AVPixFmtCuda wraps AV_PIX_FMT_CUDA.
	/*
	   HW acceleration through CUDA. data[i] contain CUdeviceptr pointers
	   exactly as for system memory frames.
	*/
	AVPixFmtCuda AVPixelFormat = C.AV_PIX_FMT_CUDA
	// AVPixFmt0Rgb wraps AV_PIX_FMT_0RGB.
	//
	//	packed RGB 8:8:8, 32bpp, XRGBXRGB...   X=unused/undefined
	AVPixFmt0Rgb AVPixelFormat = C.AV_PIX_FMT_0RGB
	// AVPixFmtRgb0 wraps AV_PIX_FMT_RGB0.
	//
	//	packed RGB 8:8:8, 32bpp, RGBXRGBX...   X=unused/undefined
	AVPixFmtRgb0 AVPixelFormat = C.AV_PIX_FMT_RGB0
	// AVPixFmt0Bgr wraps AV_PIX_FMT_0BGR.
	//
	//	packed BGR 8:8:8, 32bpp, XBGRXBGR...   X=unused/undefined
	AVPixFmt0Bgr AVPixelFormat = C.AV_PIX_FMT_0BGR
	// AVPixFmtBgr0 wraps AV_PIX_FMT_BGR0.
	//
	//	packed BGR 8:8:8, 32bpp, BGRXBGRX...   X=unused/undefined
	AVPixFmtBgr0 AVPixelFormat = C.AV_PIX_FMT_BGR0
	// AVPixFmtYuv420P12Be wraps AV_PIX_FMT_YUV420P12BE.
	//
	//	planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AVPixFmtYuv420P12Be AVPixelFormat = C.AV_PIX_FMT_YUV420P12BE
	// AVPixFmtYuv420P12Le wraps AV_PIX_FMT_YUV420P12LE.
	//
	//	planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AVPixFmtYuv420P12Le AVPixelFormat = C.AV_PIX_FMT_YUV420P12LE
	// AVPixFmtYuv420P14Be wraps AV_PIX_FMT_YUV420P14BE.
	//
	//	planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
	AVPixFmtYuv420P14Be AVPixelFormat = C.AV_PIX_FMT_YUV420P14BE
	// AVPixFmtYuv420P14Le wraps AV_PIX_FMT_YUV420P14LE.
	//
	//	planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
	AVPixFmtYuv420P14Le AVPixelFormat = C.AV_PIX_FMT_YUV420P14LE
	// AVPixFmtYuv422P12Be wraps AV_PIX_FMT_YUV422P12BE.
	//
	//	planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtYuv422P12Be AVPixelFormat = C.AV_PIX_FMT_YUV422P12BE
	// AVPixFmtYuv422P12Le wraps AV_PIX_FMT_YUV422P12LE.
	//
	//	planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtYuv422P12Le AVPixelFormat = C.AV_PIX_FMT_YUV422P12LE
	// AVPixFmtYuv422P14Be wraps AV_PIX_FMT_YUV422P14BE.
	//
	//	planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
	AVPixFmtYuv422P14Be AVPixelFormat = C.AV_PIX_FMT_YUV422P14BE
	// AVPixFmtYuv422P14Le wraps AV_PIX_FMT_YUV422P14LE.
	//
	//	planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
	AVPixFmtYuv422P14Le AVPixelFormat = C.AV_PIX_FMT_YUV422P14LE
	// AVPixFmtYuv444P12Be wraps AV_PIX_FMT_YUV444P12BE.
	//
	//	planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AVPixFmtYuv444P12Be AVPixelFormat = C.AV_PIX_FMT_YUV444P12BE
	// AVPixFmtYuv444P12Le wraps AV_PIX_FMT_YUV444P12LE.
	//
	//	planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AVPixFmtYuv444P12Le AVPixelFormat = C.AV_PIX_FMT_YUV444P12LE
	// AVPixFmtYuv444P14Be wraps AV_PIX_FMT_YUV444P14BE.
	//
	//	planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
	AVPixFmtYuv444P14Be AVPixelFormat = C.AV_PIX_FMT_YUV444P14BE
	// AVPixFmtYuv444P14Le wraps AV_PIX_FMT_YUV444P14LE.
	//
	//	planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
	AVPixFmtYuv444P14Le AVPixelFormat = C.AV_PIX_FMT_YUV444P14LE
	// AVPixFmtGbrp12Be wraps AV_PIX_FMT_GBRP12BE.
	//
	//	planar GBR 4:4:4 36bpp, big-endian
	AVPixFmtGbrp12Be AVPixelFormat = C.AV_PIX_FMT_GBRP12BE
	// AVPixFmtGbrp12Le wraps AV_PIX_FMT_GBRP12LE.
	//
	//	planar GBR 4:4:4 36bpp, little-endian
	AVPixFmtGbrp12Le AVPixelFormat = C.AV_PIX_FMT_GBRP12LE
	// AVPixFmtGbrp14Be wraps AV_PIX_FMT_GBRP14BE.
	//
	//	planar GBR 4:4:4 42bpp, big-endian
	AVPixFmtGbrp14Be AVPixelFormat = C.AV_PIX_FMT_GBRP14BE
	// AVPixFmtGbrp14Le wraps AV_PIX_FMT_GBRP14LE.
	//
	//	planar GBR 4:4:4 42bpp, little-endian
	AVPixFmtGbrp14Le AVPixelFormat = C.AV_PIX_FMT_GBRP14LE
	// AVPixFmtYuvj411P wraps AV_PIX_FMT_YUVJ411P.
	//
	//	planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
	AVPixFmtYuvj411P AVPixelFormat = C.AV_PIX_FMT_YUVJ411P
	// AVPixFmtBayerBggr8 wraps AV_PIX_FMT_BAYER_BGGR8.
	//
	//	bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
	AVPixFmtBayerBggr8 AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR8
	// AVPixFmtBayerRggb8 wraps AV_PIX_FMT_BAYER_RGGB8.
	//
	//	bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
	AVPixFmtBayerRggb8 AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB8
	// AVPixFmtBayerGbrg8 wraps AV_PIX_FMT_BAYER_GBRG8.
	//
	//	bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples
	AVPixFmtBayerGbrg8 AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG8
	// AVPixFmtBayerGrbg8 wraps AV_PIX_FMT_BAYER_GRBG8.
	//
	//	bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples
	AVPixFmtBayerGrbg8 AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG8
	// AVPixFmtBayerBggr16Le wraps AV_PIX_FMT_BAYER_BGGR16LE.
	//
	//	bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian
	AVPixFmtBayerBggr16Le AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR16LE
	// AVPixFmtBayerBggr16Be wraps AV_PIX_FMT_BAYER_BGGR16BE.
	//
	//	bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian
	AVPixFmtBayerBggr16Be AVPixelFormat = C.AV_PIX_FMT_BAYER_BGGR16BE
	// AVPixFmtBayerRggb16Le wraps AV_PIX_FMT_BAYER_RGGB16LE.
	//
	//	bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian
	AVPixFmtBayerRggb16Le AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB16LE
	// AVPixFmtBayerRggb16Be wraps AV_PIX_FMT_BAYER_RGGB16BE.
	//
	//	bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian
	AVPixFmtBayerRggb16Be AVPixelFormat = C.AV_PIX_FMT_BAYER_RGGB16BE
	// AVPixFmtBayerGbrg16Le wraps AV_PIX_FMT_BAYER_GBRG16LE.
	//
	//	bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian
	AVPixFmtBayerGbrg16Le AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG16LE
	// AVPixFmtBayerGbrg16Be wraps AV_PIX_FMT_BAYER_GBRG16BE.
	//
	//	bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian
	AVPixFmtBayerGbrg16Be AVPixelFormat = C.AV_PIX_FMT_BAYER_GBRG16BE
	// AVPixFmtBayerGrbg16Le wraps AV_PIX_FMT_BAYER_GRBG16LE.
	//
	//	bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian
	AVPixFmtBayerGrbg16Le AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG16LE
	// AVPixFmtBayerGrbg16Be wraps AV_PIX_FMT_BAYER_GRBG16BE.
	//
	//	bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian
	AVPixFmtBayerGrbg16Be AVPixelFormat = C.AV_PIX_FMT_BAYER_GRBG16BE
	// AVPixFmtYuv440P10Le wraps AV_PIX_FMT_YUV440P10LE.
	//
	//	planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AVPixFmtYuv440P10Le AVPixelFormat = C.AV_PIX_FMT_YUV440P10LE
	// AVPixFmtYuv440P10Be wraps AV_PIX_FMT_YUV440P10BE.
	//
	//	planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	AVPixFmtYuv440P10Be AVPixelFormat = C.AV_PIX_FMT_YUV440P10BE
	// AVPixFmtYuv440P12Le wraps AV_PIX_FMT_YUV440P12LE.
	//
	//	planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
	AVPixFmtYuv440P12Le AVPixelFormat = C.AV_PIX_FMT_YUV440P12LE
	// AVPixFmtYuv440P12Be wraps AV_PIX_FMT_YUV440P12BE.
	//
	//	planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
	AVPixFmtYuv440P12Be AVPixelFormat = C.AV_PIX_FMT_YUV440P12BE
	// AVPixFmtAyuv64Le wraps AV_PIX_FMT_AYUV64LE.
	//
	//	packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
	AVPixFmtAyuv64Le AVPixelFormat = C.AV_PIX_FMT_AYUV64LE
	// AVPixFmtAyuv64Be wraps AV_PIX_FMT_AYUV64BE.
	//
	//	packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
	AVPixFmtAyuv64Be AVPixelFormat = C.AV_PIX_FMT_AYUV64BE
	// AVPixFmtVideotoolbox wraps AV_PIX_FMT_VIDEOTOOLBOX.
	//
	//	hardware decoding through Videotoolbox
	AVPixFmtVideotoolbox AVPixelFormat = C.AV_PIX_FMT_VIDEOTOOLBOX
	// AVPixFmtP010Le wraps AV_PIX_FMT_P010LE.
	//
	//	like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
	AVPixFmtP010Le AVPixelFormat = C.AV_PIX_FMT_P010LE
	// AVPixFmtP010Be wraps AV_PIX_FMT_P010BE.
	//
	//	like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
	AVPixFmtP010Be AVPixelFormat = C.AV_PIX_FMT_P010BE
	// AVPixFmtGbrap12Be wraps AV_PIX_FMT_GBRAP12BE.
	//
	//	planar GBR 4:4:4:4 48bpp, big-endian
	AVPixFmtGbrap12Be AVPixelFormat = C.AV_PIX_FMT_GBRAP12BE
	// AVPixFmtGbrap12Le wraps AV_PIX_FMT_GBRAP12LE.
	//
	//	planar GBR 4:4:4:4 48bpp, little-endian
	AVPixFmtGbrap12Le AVPixelFormat = C.AV_PIX_FMT_GBRAP12LE
	// AVPixFmtGbrap10Be wraps AV_PIX_FMT_GBRAP10BE.
	//
	//	planar GBR 4:4:4:4 40bpp, big-endian
	AVPixFmtGbrap10Be AVPixelFormat = C.AV_PIX_FMT_GBRAP10BE
	// AVPixFmtGbrap10Le wraps AV_PIX_FMT_GBRAP10LE.
	//
	//	planar GBR 4:4:4:4 40bpp, little-endian
	AVPixFmtGbrap10Le AVPixelFormat = C.AV_PIX_FMT_GBRAP10LE
	// AVPixFmtMediacodec wraps AV_PIX_FMT_MEDIACODEC.
	//
	//	hardware decoding through MediaCodec
	AVPixFmtMediacodec AVPixelFormat = C.AV_PIX_FMT_MEDIACODEC
	// AVPixFmtGray12Be wraps AV_PIX_FMT_GRAY12BE.
	//
	//	Y        , 12bpp, big-endian
	AVPixFmtGray12Be AVPixelFormat = C.AV_PIX_FMT_GRAY12BE
	// AVPixFmtGray12Le wraps AV_PIX_FMT_GRAY12LE.
	//
	//	Y        , 12bpp, little-endian
	AVPixFmtGray12Le AVPixelFormat = C.AV_PIX_FMT_GRAY12LE
	// AVPixFmtGray10Be wraps AV_PIX_FMT_GRAY10BE.
	//
	//	Y        , 10bpp, big-endian
	AVPixFmtGray10Be AVPixelFormat = C.AV_PIX_FMT_GRAY10BE
	// AVPixFmtGray10Le wraps AV_PIX_FMT_GRAY10LE.
	//
	//	Y        , 10bpp, little-endian
	AVPixFmtGray10Le AVPixelFormat = C.AV_PIX_FMT_GRAY10LE
	// AVPixFmtP016Le wraps AV_PIX_FMT_P016LE.
	//
	//	like NV12, with 16bpp per component, little-endian
	AVPixFmtP016Le AVPixelFormat = C.AV_PIX_FMT_P016LE
	// AVPixFmtP016Be wraps AV_PIX_FMT_P016BE.
	//
	//	like NV12, with 16bpp per component, big-endian
	AVPixFmtP016Be AVPixelFormat = C.AV_PIX_FMT_P016BE
	// AVPixFmtD3D11 wraps AV_PIX_FMT_D3D11.
	/*
	   Hardware surfaces for Direct3D11.

	   This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11
	   hwaccel API and filtering support AV_PIX_FMT_D3D11 only.

	   data[0] contains a ID3D11Texture2D pointer, and data[1] contains the
	   texture array index of the frame as intptr_t if the ID3D11Texture2D is
	   an array texture (or always 0 if it's a normal texture).
	*/
	AVPixFmtD3D11 AVPixelFormat = C.AV_PIX_FMT_D3D11
	// AVPixFmtGray9Be wraps AV_PIX_FMT_GRAY9BE.
	//
	//	Y        , 9bpp, big-endian
	AVPixFmtGray9Be AVPixelFormat = C.AV_PIX_FMT_GRAY9BE
	// AVPixFmtGray9Le wraps AV_PIX_FMT_GRAY9LE.
	//
	//	Y        , 9bpp, little-endian
	AVPixFmtGray9Le AVPixelFormat = C.AV_PIX_FMT_GRAY9LE
	// AVPixFmtGbrpf32Be wraps AV_PIX_FMT_GBRPF32BE.
	//
	//	IEEE-754 single precision planar GBR 4:4:4,     96bpp, big-endian
	AVPixFmtGbrpf32Be AVPixelFormat = C.AV_PIX_FMT_GBRPF32BE
	// AVPixFmtGbrpf32Le wraps AV_PIX_FMT_GBRPF32LE.
	//
	//	IEEE-754 single precision planar GBR 4:4:4,     96bpp, little-endian
	AVPixFmtGbrpf32Le AVPixelFormat = C.AV_PIX_FMT_GBRPF32LE
	// AVPixFmtGbrapf32Be wraps AV_PIX_FMT_GBRAPF32BE.
	//
	//	IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian
	AVPixFmtGbrapf32Be AVPixelFormat = C.AV_PIX_FMT_GBRAPF32BE
	// AVPixFmtGbrapf32Le wraps AV_PIX_FMT_GBRAPF32LE.
	//
	//	IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian
	AVPixFmtGbrapf32Le AVPixelFormat = C.AV_PIX_FMT_GBRAPF32LE
	// AVPixFmtDrmPrime wraps AV_PIX_FMT_DRM_PRIME.
	/*
	   DRM-managed buffers exposed through PRIME buffer sharing.

	   data[0] points to an AVDRMFrameDescriptor.
	*/
	AVPixFmtDrmPrime AVPixelFormat = C.AV_PIX_FMT_DRM_PRIME
	// AVPixFmtOpencl wraps AV_PIX_FMT_OPENCL.
	/*
	   Hardware surfaces for OpenCL.

	   data[i] contain 2D image objects (typed in C as cl_mem, used
	   in OpenCL as image2d_t) for each plane of the surface.
	*/
	AVPixFmtOpencl AVPixelFormat = C.AV_PIX_FMT_OPENCL
	// AVPixFmtGray14Be wraps AV_PIX_FMT_GRAY14BE.
	//
	//	Y        , 14bpp, big-endian
	AVPixFmtGray14Be AVPixelFormat = C.AV_PIX_FMT_GRAY14BE
	// AVPixFmtGray14Le wraps AV_PIX_FMT_GRAY14LE.
	//
	//	Y        , 14bpp, little-endian
	AVPixFmtGray14Le AVPixelFormat = C.AV_PIX_FMT_GRAY14LE
	// AVPixFmtGrayf32Be wraps AV_PIX_FMT_GRAYF32BE.
	//
	//	IEEE-754 single precision Y, 32bpp, big-endian
	AVPixFmtGrayf32Be AVPixelFormat = C.AV_PIX_FMT_GRAYF32BE
	// AVPixFmtGrayf32Le wraps AV_PIX_FMT_GRAYF32LE.
	//
	//	IEEE-754 single precision Y, 32bpp, little-endian
	AVPixFmtGrayf32Le AVPixelFormat = C.AV_PIX_FMT_GRAYF32LE
	// AVPixFmtYuva422P12Be wraps AV_PIX_FMT_YUVA422P12BE.
	//
	//	planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
	AVPixFmtYuva422P12Be AVPixelFormat = C.AV_PIX_FMT_YUVA422P12BE
	// AVPixFmtYuva422P12Le wraps AV_PIX_FMT_YUVA422P12LE.
	//
	//	planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
	AVPixFmtYuva422P12Le AVPixelFormat = C.AV_PIX_FMT_YUVA422P12LE
	// AVPixFmtYuva444P12Be wraps AV_PIX_FMT_YUVA444P12BE.
	//
	//	planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
	AVPixFmtYuva444P12Be AVPixelFormat = C.AV_PIX_FMT_YUVA444P12BE
	// AVPixFmtYuva444P12Le wraps AV_PIX_FMT_YUVA444P12LE.
	//
	//	planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
	AVPixFmtYuva444P12Le AVPixelFormat = C.AV_PIX_FMT_YUVA444P12LE
	// AVPixFmtNv24 wraps AV_PIX_FMT_NV24.
	//
	//	planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
	AVPixFmtNv24 AVPixelFormat = C.AV_PIX_FMT_NV24
	// AVPixFmtNv42 wraps AV_PIX_FMT_NV42.
	//
	//	as above, but U and V bytes are swapped
	AVPixFmtNv42 AVPixelFormat = C.AV_PIX_FMT_NV42
	// AVPixFmtVulkan wraps AV_PIX_FMT_VULKAN.
	/*
	   Vulkan hardware images.

	   data[0] points to an AVVkFrame
	*/
	AVPixFmtVulkan AVPixelFormat = C.AV_PIX_FMT_VULKAN
	// AVPixFmtY210Be wraps AV_PIX_FMT_Y210BE.
	//
	//	packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, big-endian
	AVPixFmtY210Be AVPixelFormat = C.AV_PIX_FMT_Y210BE
	// AVPixFmtY210Le wraps AV_PIX_FMT_Y210LE.
	//
	//	packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
	AVPixFmtY210Le AVPixelFormat = C.AV_PIX_FMT_Y210LE
	// AVPixFmtX2Rgb10Le wraps AV_PIX_FMT_X2RGB10LE.
	//
	//	packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
	AVPixFmtX2Rgb10Le AVPixelFormat = C.AV_PIX_FMT_X2RGB10LE
	// AVPixFmtX2Rgb10Be wraps AV_PIX_FMT_X2RGB10BE.
	//
	//	packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
	AVPixFmtX2Rgb10Be AVPixelFormat = C.AV_PIX_FMT_X2RGB10BE
	// AVPixFmtX2Bgr10Le wraps AV_PIX_FMT_X2BGR10LE.
	//
	//	packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
	AVPixFmtX2Bgr10Le AVPixelFormat = C.AV_PIX_FMT_X2BGR10LE
	// AVPixFmtX2Bgr10Be wraps AV_PIX_FMT_X2BGR10BE.
	//
	//	packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
	AVPixFmtX2Bgr10Be AVPixelFormat = C.AV_PIX_FMT_X2BGR10BE
	// AVPixFmtP210Be wraps AV_PIX_FMT_P210BE.
	//
	//	interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
	AVPixFmtP210Be AVPixelFormat = C.AV_PIX_FMT_P210BE
	// AVPixFmtP210Le wraps AV_PIX_FMT_P210LE.
	//
	//	interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
	AVPixFmtP210Le AVPixelFormat = C.AV_PIX_FMT_P210LE
	// AVPixFmtP410Be wraps AV_PIX_FMT_P410BE.
	//
	//	interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
	AVPixFmtP410Be AVPixelFormat = C.AV_PIX_FMT_P410BE
	// AVPixFmtP410Le wraps AV_PIX_FMT_P410LE.
	//
	//	interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
	AVPixFmtP410Le AVPixelFormat = C.AV_PIX_FMT_P410LE
	// AVPixFmtP216Be wraps AV_PIX_FMT_P216BE.
	//
	//	interleaved chroma YUV 4:2:2, 32bpp, big-endian
	AVPixFmtP216Be AVPixelFormat = C.AV_PIX_FMT_P216BE
	// AVPixFmtP216Le wraps AV_PIX_FMT_P216LE.
	//
	//	interleaved chroma YUV 4:2:2, 32bpp, little-endian
	AVPixFmtP216Le AVPixelFormat = C.AV_PIX_FMT_P216LE
	// AVPixFmtP416Be wraps AV_PIX_FMT_P416BE.
	//
	//	interleaved chroma YUV 4:4:4, 48bpp, big-endian
	AVPixFmtP416Be AVPixelFormat = C.AV_PIX_FMT_P416BE
	// AVPixFmtP416Le wraps AV_PIX_FMT_P416LE.
	//
	//	interleaved chroma YUV 4:4:4, 48bpp, little-endian
	AVPixFmtP416Le AVPixelFormat = C.AV_PIX_FMT_P416LE
	// AVPixFmtVuya wraps AV_PIX_FMT_VUYA.
	//
	//	packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA...
	AVPixFmtVuya AVPixelFormat = C.AV_PIX_FMT_VUYA
	// AVPixFmtRgbaf16Be wraps AV_PIX_FMT_RGBAF16BE.
	//
	//	IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian
	AVPixFmtRgbaf16Be AVPixelFormat = C.AV_PIX_FMT_RGBAF16BE
	// AVPixFmtRgbaf16Le wraps AV_PIX_FMT_RGBAF16LE.
	//
	//	IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian
	AVPixFmtRgbaf16Le AVPixelFormat = C.AV_PIX_FMT_RGBAF16LE
	// AVPixFmtVuyx wraps AV_PIX_FMT_VUYX.
	//
	//	packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
	AVPixFmtVuyx AVPixelFormat = C.AV_PIX_FMT_VUYX
	// AVPixFmtP012Le wraps AV_PIX_FMT_P012LE.
	//
	//	like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, little-endian
	AVPixFmtP012Le AVPixelFormat = C.AV_PIX_FMT_P012LE
	// AVPixFmtP012Be wraps AV_PIX_FMT_P012BE.
	//
	//	like NV12, with 12bpp per component, data in the high bits, zeros in the low bits, big-endian
	AVPixFmtP012Be AVPixelFormat = C.AV_PIX_FMT_P012BE
	// AVPixFmtY212Be wraps AV_PIX_FMT_Y212BE.
	//
	//	packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, big-endian
	AVPixFmtY212Be AVPixelFormat = C.AV_PIX_FMT_Y212BE
	// AVPixFmtY212Le wraps AV_PIX_FMT_Y212LE.
	//
	//	packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits, little-endian
	AVPixFmtY212Le AVPixelFormat = C.AV_PIX_FMT_Y212LE
	// AVPixFmtXv30Be wraps AV_PIX_FMT_XV30BE.
	//
	//	packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), big-endian, variant of Y410 where alpha channel is left undefined
	AVPixFmtXv30Be AVPixelFormat = C.AV_PIX_FMT_XV30BE
	// AVPixFmtXv30Le wraps AV_PIX_FMT_XV30LE.
	//
	//	packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channel is left undefined
	AVPixFmtXv30Le AVPixelFormat = C.AV_PIX_FMT_XV30LE
	// AVPixFmtXv36Be wraps AV_PIX_FMT_XV36BE.
	//
	//	packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian, variant of Y412 where alpha channel is left undefined
	AVPixFmtXv36Be AVPixelFormat = C.AV_PIX_FMT_XV36BE
	// AVPixFmtXv36Le wraps AV_PIX_FMT_XV36LE.
	//
	//	packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian, variant of Y412 where alpha channel is left undefined
	AVPixFmtXv36Le AVPixelFormat = C.AV_PIX_FMT_XV36LE
	// AVPixFmtRgbf32Be wraps AV_PIX_FMT_RGBF32BE.
	//
	//	IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian
	AVPixFmtRgbf32Be AVPixelFormat = C.AV_PIX_FMT_RGBF32BE
	// AVPixFmtRgbf32Le wraps AV_PIX_FMT_RGBF32LE.
	//
	//	IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian
	AVPixFmtRgbf32Le AVPixelFormat = C.AV_PIX_FMT_RGBF32LE
	// AVPixFmtRgbaf32Be wraps AV_PIX_FMT_RGBAF32BE.
	//
	//	IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
	AVPixFmtRgbaf32Be AVPixelFormat = C.AV_PIX_FMT_RGBAF32BE
	// AVPixFmtRgbaf32Le wraps AV_PIX_FMT_RGBAF32LE.
	//
	//	IEEE-754 single precision packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
	AVPixFmtRgbaf32Le AVPixelFormat = C.AV_PIX_FMT_RGBAF32LE
	// AVPixFmtP212Be wraps AV_PIX_FMT_P212BE.
	//
	//	interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian
	AVPixFmtP212Be AVPixelFormat = C.AV_PIX_FMT_P212BE
	// AVPixFmtP212Le wraps AV_PIX_FMT_P212LE.
	//
	//	interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian
	AVPixFmtP212Le AVPixelFormat = C.AV_PIX_FMT_P212LE
	// AVPixFmtP412Be wraps AV_PIX_FMT_P412BE.
	//
	//	interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian
	AVPixFmtP412Be AVPixelFormat = C.AV_PIX_FMT_P412BE
	// AVPixFmtP412Le wraps AV_PIX_FMT_P412LE.
	//
	//	interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian
	AVPixFmtP412Le AVPixelFormat = C.AV_PIX_FMT_P412LE
	// AVPixFmtGbrap14Be wraps AV_PIX_FMT_GBRAP14BE.
	//
	//	planar GBR 4:4:4:4 56bpp, big-endian
	AVPixFmtGbrap14Be AVPixelFormat = C.AV_PIX_FMT_GBRAP14BE
	// AVPixFmtGbrap14Le wraps AV_PIX_FMT_GBRAP14LE.
	//
	//	planar GBR 4:4:4:4 56bpp, little-endian
	AVPixFmtGbrap14Le AVPixelFormat = C.AV_PIX_FMT_GBRAP14LE
	// AVPixFmtD3D12 wraps AV_PIX_FMT_D3D12.
	/*
	   Hardware surfaces for Direct3D 12.

	   data[0] points to an AVD3D12VAFrame
	*/
	AVPixFmtD3D12 AVPixelFormat = C.AV_PIX_FMT_D3D12
	// AVPixFmtAyuv wraps AV_PIX_FMT_AYUV.
	//
	//	packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV...
	AVPixFmtAyuv AVPixelFormat = C.AV_PIX_FMT_AYUV
	// AVPixFmtUyva wraps AV_PIX_FMT_UYVA.
	//
	//	packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
	AVPixFmtUyva AVPixelFormat = C.AV_PIX_FMT_UYVA
	// AVPixFmtVyu444 wraps AV_PIX_FMT_VYU444.
	//
	//	packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU...
	AVPixFmtVyu444 AVPixelFormat = C.AV_PIX_FMT_VYU444
	// AVPixFmtV30Xbe wraps AV_PIX_FMT_V30XBE.
	//
	//	packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), big-endian
	AVPixFmtV30Xbe AVPixelFormat = C.AV_PIX_FMT_V30XBE
	// AVPixFmtV30Xle wraps AV_PIX_FMT_V30XLE.
	//
	//	packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian
	AVPixFmtV30Xle AVPixelFormat = C.AV_PIX_FMT_V30XLE
	// AVPixFmtRgbf16Be wraps AV_PIX_FMT_RGBF16BE.
	//
	//	IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., big-endian
	AVPixFmtRgbf16Be AVPixelFormat = C.AV_PIX_FMT_RGBF16BE
	// AVPixFmtRgbf16Le wraps AV_PIX_FMT_RGBF16LE.
	//
	//	IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., little-endian
	AVPixFmtRgbf16Le AVPixelFormat = C.AV_PIX_FMT_RGBF16LE
	// AVPixFmtRgba128Be wraps AV_PIX_FMT_RGBA128BE.
	//
	//	packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., big-endian
	AVPixFmtRgba128Be AVPixelFormat = C.AV_PIX_FMT_RGBA128BE
	// AVPixFmtRgba128Le wraps AV_PIX_FMT_RGBA128LE.
	//
	//	packed RGBA 32:32:32:32, 128bpp, RGBARGBA..., little-endian
	AVPixFmtRgba128Le AVPixelFormat = C.AV_PIX_FMT_RGBA128LE
	// AVPixFmtRgb96Be wraps AV_PIX_FMT_RGB96BE.
	//
	//	packed RGBA 32:32:32, 96bpp, RGBRGB..., big-endian
	AVPixFmtRgb96Be AVPixelFormat = C.AV_PIX_FMT_RGB96BE
	// AVPixFmtRgb96Le wraps AV_PIX_FMT_RGB96LE.
	//
	//	packed RGBA 32:32:32, 96bpp, RGBRGB..., little-endian
	AVPixFmtRgb96Le AVPixelFormat = C.AV_PIX_FMT_RGB96LE
	// AVPixFmtY216Be wraps AV_PIX_FMT_Y216BE.
	//
	//	packed YUV 4:2:2 like YUYV422, 32bpp, big-endian
	AVPixFmtY216Be AVPixelFormat = C.AV_PIX_FMT_Y216BE
	// AVPixFmtY216Le wraps AV_PIX_FMT_Y216LE.
	//
	//	packed YUV 4:2:2 like YUYV422, 32bpp, little-endian
	AVPixFmtY216Le AVPixelFormat = C.AV_PIX_FMT_Y216LE
	// AVPixFmtXv48Be wraps AV_PIX_FMT_XV48BE.
	//
	//	packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefined
	AVPixFmtXv48Be AVPixelFormat = C.AV_PIX_FMT_XV48BE
	// AVPixFmtXv48Le wraps AV_PIX_FMT_XV48LE.
	//
	//	packed XVYU 4:4:4, 64bpp, little-endian, variant of Y416 where alpha channel is left undefined
	AVPixFmtXv48Le AVPixelFormat = C.AV_PIX_FMT_XV48LE
	// AVPixFmtGbrpf16Be wraps AV_PIX_FMT_GBRPF16BE.
	//
	//	IEEE-754 half precision planer GBR 4:4:4, 48bpp, big-endian
	AVPixFmtGbrpf16Be AVPixelFormat = C.AV_PIX_FMT_GBRPF16BE
	// AVPixFmtGbrpf16Le wraps AV_PIX_FMT_GBRPF16LE.
	//
	//	IEEE-754 half precision planer GBR 4:4:4, 48bpp, little-endian
	AVPixFmtGbrpf16Le AVPixelFormat = C.AV_PIX_FMT_GBRPF16LE
	// AVPixFmtGbrapf16Be wraps AV_PIX_FMT_GBRAPF16BE.
	//
	//	IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian
	AVPixFmtGbrapf16Be AVPixelFormat = C.AV_PIX_FMT_GBRAPF16BE
	// AVPixFmtGbrapf16Le wraps AV_PIX_FMT_GBRAPF16LE.
	//
	//	IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian
	AVPixFmtGbrapf16Le AVPixelFormat = C.AV_PIX_FMT_GBRAPF16LE
	// AVPixFmtGrayf16Be wraps AV_PIX_FMT_GRAYF16BE.
	//
	//	IEEE-754 half precision Y, 16bpp, big-endian
	AVPixFmtGrayf16Be AVPixelFormat = C.AV_PIX_FMT_GRAYF16BE
	// AVPixFmtGrayf16Le wraps AV_PIX_FMT_GRAYF16LE.
	//
	//	IEEE-754 half precision Y, 16bpp, little-endian
	AVPixFmtGrayf16Le AVPixelFormat = C.AV_PIX_FMT_GRAYF16LE
	// AVPixFmtAmfSurface wraps AV_PIX_FMT_AMF_SURFACE.
	//
	//	HW acceleration through AMF. data[0] contain AMFSurface pointer
	AVPixFmtAmfSurface AVPixelFormat = C.AV_PIX_FMT_AMF_SURFACE
	// AVPixFmtGray32Be wraps AV_PIX_FMT_GRAY32BE.
	//
	//	Y        , 32bpp, big-endian
	AVPixFmtGray32Be AVPixelFormat = C.AV_PIX_FMT_GRAY32BE
	// AVPixFmtGray32Le wraps AV_PIX_FMT_GRAY32LE.
	//
	//	Y        , 32bpp, little-endian
	AVPixFmtGray32Le AVPixelFormat = C.AV_PIX_FMT_GRAY32LE
	// AVPixFmtYaf32Be wraps AV_PIX_FMT_YAF32BE.
	//
	//	IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, big-endian
	AVPixFmtYaf32Be AVPixelFormat = C.AV_PIX_FMT_YAF32BE
	// AVPixFmtYaf32Le wraps AV_PIX_FMT_YAF32LE.
	//
	//	IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, little-endian
	AVPixFmtYaf32Le AVPixelFormat = C.AV_PIX_FMT_YAF32LE
	// AVPixFmtYaf16Be wraps AV_PIX_FMT_YAF16BE.
	//
	//	IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, big-endian
	AVPixFmtYaf16Be AVPixelFormat = C.AV_PIX_FMT_YAF16BE
	// AVPixFmtYaf16Le wraps AV_PIX_FMT_YAF16LE.
	//
	//	IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, little-endian
	AVPixFmtYaf16Le AVPixelFormat = C.AV_PIX_FMT_YAF16LE
	// AVPixFmtGbrap32Be wraps AV_PIX_FMT_GBRAP32BE.
	//
	//	planar GBRA 4:4:4:4 128bpp, big-endian
	AVPixFmtGbrap32Be AVPixelFormat = C.AV_PIX_FMT_GBRAP32BE
	// AVPixFmtGbrap32Le wraps AV_PIX_FMT_GBRAP32LE.
	//
	//	planar GBRA 4:4:4:4 128bpp, little-endian
	AVPixFmtGbrap32Le AVPixelFormat = C.AV_PIX_FMT_GBRAP32LE
	// AVPixFmtYuv444P10Msbbe wraps AV_PIX_FMT_YUV444P10MSBBE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
	AVPixFmtYuv444P10Msbbe AVPixelFormat = C.AV_PIX_FMT_YUV444P10MSBBE
	// AVPixFmtYuv444P10Msble wraps AV_PIX_FMT_YUV444P10MSBLE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
	AVPixFmtYuv444P10Msble AVPixelFormat = C.AV_PIX_FMT_YUV444P10MSBLE
	// AVPixFmtYuv444P12Msbbe wraps AV_PIX_FMT_YUV444P12MSBBE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
	AVPixFmtYuv444P12Msbbe AVPixelFormat = C.AV_PIX_FMT_YUV444P12MSBBE
	// AVPixFmtYuv444P12Msble wraps AV_PIX_FMT_YUV444P12MSBLE.
	//
	//	planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
	AVPixFmtYuv444P12Msble AVPixelFormat = C.AV_PIX_FMT_YUV444P12MSBLE
	// AVPixFmtGbrp10Msbbe wraps AV_PIX_FMT_GBRP10MSBBE.
	//
	//	planar GBR 4:4:4 30bpp, lowest bits zero, big-endian
	AVPixFmtGbrp10Msbbe AVPixelFormat = C.AV_PIX_FMT_GBRP10MSBBE
	// AVPixFmtGbrp10Msble wraps AV_PIX_FMT_GBRP10MSBLE.
	//
	//	planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
	AVPixFmtGbrp10Msble AVPixelFormat = C.AV_PIX_FMT_GBRP10MSBLE
	// AVPixFmtGbrp12Msbbe wraps AV_PIX_FMT_GBRP12MSBBE.
	//
	//	planar GBR 4:4:4 36bpp, lowest bits zero, big-endian
	AVPixFmtGbrp12Msbbe AVPixelFormat = C.AV_PIX_FMT_GBRP12MSBBE
	// AVPixFmtGbrp12Msble wraps AV_PIX_FMT_GBRP12MSBLE.
	//
	//	planar GBR 4:4:4 36bpp, lowest bits zero, little-endian
	AVPixFmtGbrp12Msble AVPixelFormat = C.AV_PIX_FMT_GBRP12MSBLE
	// AVPixFmtOhcodec wraps AV_PIX_FMT_OHCODEC.
	AVPixFmtOhcodec AVPixelFormat = C.AV_PIX_FMT_OHCODEC
	// AVPixFmtNb wraps AV_PIX_FMT_NB.
	//
	//	number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
	AVPixFmtNb AVPixelFormat = C.AV_PIX_FMT_NB
)

// --- Enum AVColorPrimaries ---

// AVColorPrimaries wraps AVColorPrimaries.
/*
  Chromaticity coordinates of the source primaries.
  These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.1 and ITU-T H.273.
*/
type AVColorPrimaries C.enum_AVColorPrimaries

const SizeOfAVColorPrimaries = C.sizeof_enum_AVColorPrimaries

func ToAVColorPrimariesArray(ptr unsafe.Pointer) *Array[AVColorPrimaries] {
	if ptr == nil {
		return nil
	}

	return &Array[AVColorPrimaries]{
		elemSize: SizeOfAVColorPrimaries,
		loadPtr: func(pointer unsafe.Pointer) AVColorPrimaries {
			ptr := (*AVColorPrimaries)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVColorPrimaries) {
			ptr := (*AVColorPrimaries)(pointer)
			*ptr = value
		},
	}
}

func AllocAVColorPrimariesArray(size uint64) *Array[AVColorPrimaries] {
	return ToAVColorPrimariesArray(AVCalloc(size, SizeOfAVColorPrimaries))
}

const (
	// AVColPriReserved0 wraps AVCOL_PRI_RESERVED0.
	AVColPriReserved0 AVColorPrimaries = C.AVCOL_PRI_RESERVED0
	// AVColPriBt709 wraps AVCOL_PRI_BT709.
	//
	//	also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
	AVColPriBt709 AVColorPrimaries = C.AVCOL_PRI_BT709
	// AVColPriUnspecified wraps AVCOL_PRI_UNSPECIFIED.
	AVColPriUnspecified AVColorPrimaries = C.AVCOL_PRI_UNSPECIFIED
	// AVColPriReserved wraps AVCOL_PRI_RESERVED.
	AVColPriReserved AVColorPrimaries = C.AVCOL_PRI_RESERVED
	// AVColPriBt470M wraps AVCOL_PRI_BT470M.
	//
	//	also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
	AVColPriBt470M AVColorPrimaries = C.AVCOL_PRI_BT470M
	// AVColPriBt470Bg wraps AVCOL_PRI_BT470BG.
	//
	//	also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
	AVColPriBt470Bg AVColorPrimaries = C.AVCOL_PRI_BT470BG
	// AVColPriSmpte170M wraps AVCOL_PRI_SMPTE170M.
	//
	//	also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
	AVColPriSmpte170M AVColorPrimaries = C.AVCOL_PRI_SMPTE170M
	// AVColPriSmpte240M wraps AVCOL_PRI_SMPTE240M.
	//
	//	identical to above, also called "SMPTE C" even though it uses D65
	AVColPriSmpte240M AVColorPrimaries = C.AVCOL_PRI_SMPTE240M
	// AVColPriFilm wraps AVCOL_PRI_FILM.
	//
	//	colour filters using Illuminant C
	AVColPriFilm AVColorPrimaries = C.AVCOL_PRI_FILM
	// AVColPriBt2020 wraps AVCOL_PRI_BT2020.
	//
	//	ITU-R BT2020
	AVColPriBt2020 AVColorPrimaries = C.AVCOL_PRI_BT2020
	// AVColPriSmpte428 wraps AVCOL_PRI_SMPTE428.
	//
	//	SMPTE ST 428-1 (CIE 1931 XYZ)
	AVColPriSmpte428 AVColorPrimaries = C.AVCOL_PRI_SMPTE428
	// AVColPriSmptest4281 wraps AVCOL_PRI_SMPTEST428_1.
	AVColPriSmptest4281 AVColorPrimaries = C.AVCOL_PRI_SMPTEST428_1
	// AVColPriSmpte431 wraps AVCOL_PRI_SMPTE431.
	//
	//	SMPTE ST 431-2 (2011) / DCI P3
	AVColPriSmpte431 AVColorPrimaries = C.AVCOL_PRI_SMPTE431
	// AVColPriSmpte432 wraps AVCOL_PRI_SMPTE432.
	//
	//	SMPTE ST 432-1 (2010) / P3 D65 / Display P3
	AVColPriSmpte432 AVColorPrimaries = C.AVCOL_PRI_SMPTE432
	// AVColPriEbu3213 wraps AVCOL_PRI_EBU3213.
	//
	//	EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors
	AVColPriEbu3213 AVColorPrimaries = C.AVCOL_PRI_EBU3213
	// AVColPriJedecP22 wraps AVCOL_PRI_JEDEC_P22.
	AVColPriJedecP22 AVColorPrimaries = C.AVCOL_PRI_JEDEC_P22
	// AVColPriNb wraps AVCOL_PRI_NB.
	//
	//	Not part of ABI
	AVColPriNb AVColorPrimaries = C.AVCOL_PRI_NB
)

// --- Enum AVColorTransferCharacteristic ---

// AVColorTransferCharacteristic wraps AVColorTransferCharacteristic.
/*
  Color Transfer Characteristic.
  These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.2.
*/
type AVColorTransferCharacteristic C.enum_AVColorTransferCharacteristic

const SizeOfAVColorTransferCharacteristic = C.sizeof_enum_AVColorTransferCharacteristic

func ToAVColorTransferCharacteristicArray(ptr unsafe.Pointer) *Array[AVColorTransferCharacteristic] {
	if ptr == nil {
		return nil
	}

	return &Array[AVColorTransferCharacteristic]{
		elemSize: SizeOfAVColorTransferCharacteristic,
		loadPtr: func(pointer unsafe.Pointer) AVColorTransferCharacteristic {
			ptr := (*AVColorTransferCharacteristic)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVColorTransferCharacteristic) {
			ptr := (*AVColorTransferCharacteristic)(pointer)
			*ptr = value
		},
	}
}

func AllocAVColorTransferCharacteristicArray(size uint64) *Array[AVColorTransferCharacteristic] {
	return ToAVColorTransferCharacteristicArray(AVCalloc(size, SizeOfAVColorTransferCharacteristic))
}

const (
	// AVColTrcReserved0 wraps AVCOL_TRC_RESERVED0.
	AVColTrcReserved0 AVColorTransferCharacteristic = C.AVCOL_TRC_RESERVED0
	// AVColTrcBt709 wraps AVCOL_TRC_BT709.
	//
	//	also ITU-R BT1361
	AVColTrcBt709 AVColorTransferCharacteristic = C.AVCOL_TRC_BT709
	// AVColTrcUnspecified wraps AVCOL_TRC_UNSPECIFIED.
	AVColTrcUnspecified AVColorTransferCharacteristic = C.AVCOL_TRC_UNSPECIFIED
	// AVColTrcReserved wraps AVCOL_TRC_RESERVED.
	AVColTrcReserved AVColorTransferCharacteristic = C.AVCOL_TRC_RESERVED
	// AVColTrcGamma22 wraps AVCOL_TRC_GAMMA22.
	//
	//	also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
	AVColTrcGamma22 AVColorTransferCharacteristic = C.AVCOL_TRC_GAMMA22
	// AVColTrcGamma28 wraps AVCOL_TRC_GAMMA28.
	//
	//	also ITU-R BT470BG
	AVColTrcGamma28 AVColorTransferCharacteristic = C.AVCOL_TRC_GAMMA28
	// AVColTrcSmpte170M wraps AVCOL_TRC_SMPTE170M.
	//
	//	also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
	AVColTrcSmpte170M AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTE170M
	// AVColTrcSmpte240M wraps AVCOL_TRC_SMPTE240M.
	AVColTrcSmpte240M AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTE240M
	// AVColTrcLinear wraps AVCOL_TRC_LINEAR.
	//
	//	"Linear transfer characteristics"
	AVColTrcLinear AVColorTransferCharacteristic = C.AVCOL_TRC_LINEAR
	// AVColTrcLog wraps AVCOL_TRC_LOG.
	//
	//	"Logarithmic transfer characteristic (100:1 range)"
	AVColTrcLog AVColorTransferCharacteristic = C.AVCOL_TRC_LOG
	// AVColTrcLogSqrt wraps AVCOL_TRC_LOG_SQRT.
	//
	//	"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
	AVColTrcLogSqrt AVColorTransferCharacteristic = C.AVCOL_TRC_LOG_SQRT
	// AVColTrcIec6196624 wraps AVCOL_TRC_IEC61966_2_4.
	//
	//	IEC 61966-2-4
	AVColTrcIec6196624 AVColorTransferCharacteristic = C.AVCOL_TRC_IEC61966_2_4
	// AVColTrcBt1361Ecg wraps AVCOL_TRC_BT1361_ECG.
	//
	//	ITU-R BT1361 Extended Colour Gamut
	AVColTrcBt1361Ecg AVColorTransferCharacteristic = C.AVCOL_TRC_BT1361_ECG
	// AVColTrcIec6196621 wraps AVCOL_TRC_IEC61966_2_1.
	//
	//	IEC 61966-2-1 (sRGB or sYCC)
	AVColTrcIec6196621 AVColorTransferCharacteristic = C.AVCOL_TRC_IEC61966_2_1
	// AVColTrcBt202010 wraps AVCOL_TRC_BT2020_10.
	//
	//	ITU-R BT2020 for 10-bit system
	AVColTrcBt202010 AVColorTransferCharacteristic = C.AVCOL_TRC_BT2020_10
	// AVColTrcBt202012 wraps AVCOL_TRC_BT2020_12.
	//
	//	ITU-R BT2020 for 12-bit system
	AVColTrcBt202012 AVColorTransferCharacteristic = C.AVCOL_TRC_BT2020_12
	// AVColTrcSmpte2084 wraps AVCOL_TRC_SMPTE2084.
	//
	//	SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
	AVColTrcSmpte2084 AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTE2084
	// AVColTrcSmptest2084 wraps AVCOL_TRC_SMPTEST2084.
	AVColTrcSmptest2084 AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTEST2084
	// AVColTrcSmpte428 wraps AVCOL_TRC_SMPTE428.
	//
	//	SMPTE ST 428-1
	AVColTrcSmpte428 AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTE428
	// AVColTrcSmptest4281 wraps AVCOL_TRC_SMPTEST428_1.
	AVColTrcSmptest4281 AVColorTransferCharacteristic = C.AVCOL_TRC_SMPTEST428_1
	// AVColTrcAribStdB67 wraps AVCOL_TRC_ARIB_STD_B67.
	//
	//	ARIB STD-B67, known as "Hybrid log-gamma"
	AVColTrcAribStdB67 AVColorTransferCharacteristic = C.AVCOL_TRC_ARIB_STD_B67
	// AVColTrcNb wraps AVCOL_TRC_NB.
	//
	//	Not part of ABI
	AVColTrcNb AVColorTransferCharacteristic = C.AVCOL_TRC_NB
)

// --- Enum AVColorSpace ---

// AVColorSpace wraps AVColorSpace.
/*
  YUV colorspace type.
  These values match the ones defined by ISO/IEC 23091-2_2019 subclause 8.3.
*/
type AVColorSpace C.enum_AVColorSpace

const SizeOfAVColorSpace = C.sizeof_enum_AVColorSpace

func ToAVColorSpaceArray(ptr unsafe.Pointer) *Array[AVColorSpace] {
	if ptr == nil {
		return nil
	}

	return &Array[AVColorSpace]{
		elemSize: SizeOfAVColorSpace,
		loadPtr: func(pointer unsafe.Pointer) AVColorSpace {
			ptr := (*AVColorSpace)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVColorSpace) {
			ptr := (*AVColorSpace)(pointer)
			*ptr = value
		},
	}
}

func AllocAVColorSpaceArray(size uint64) *Array[AVColorSpace] {
	return ToAVColorSpaceArray(AVCalloc(size, SizeOfAVColorSpace))
}

const (
	// AVColSpcRgb wraps AVCOL_SPC_RGB.
	//
	//	order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
	AVColSpcRgb AVColorSpace = C.AVCOL_SPC_RGB
	// AVColSpcBt709 wraps AVCOL_SPC_BT709.
	//
	//	also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
	AVColSpcBt709 AVColorSpace = C.AVCOL_SPC_BT709
	// AVColSpcUnspecified wraps AVCOL_SPC_UNSPECIFIED.
	AVColSpcUnspecified AVColorSpace = C.AVCOL_SPC_UNSPECIFIED
	// AVColSpcReserved wraps AVCOL_SPC_RESERVED.
	//
	//	reserved for future use by ITU-T and ISO/IEC just like 15-255 are
	AVColSpcReserved AVColorSpace = C.AVCOL_SPC_RESERVED
	// AVColSpcFcc wraps AVCOL_SPC_FCC.
	//
	//	FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
	AVColSpcFcc AVColorSpace = C.AVCOL_SPC_FCC
	// AVColSpcBt470Bg wraps AVCOL_SPC_BT470BG.
	//
	//	also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
	AVColSpcBt470Bg AVColorSpace = C.AVCOL_SPC_BT470BG
	// AVColSpcSmpte170M wraps AVCOL_SPC_SMPTE170M.
	//
	//	also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
	AVColSpcSmpte170M AVColorSpace = C.AVCOL_SPC_SMPTE170M
	// AVColSpcSmpte240M wraps AVCOL_SPC_SMPTE240M.
	//
	//	derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
	AVColSpcSmpte240M AVColorSpace = C.AVCOL_SPC_SMPTE240M
	// AVColSpcYcgco wraps AVCOL_SPC_YCGCO.
	//
	//	used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
	AVColSpcYcgco AVColorSpace = C.AVCOL_SPC_YCGCO
	// AVColSpcYcocg wraps AVCOL_SPC_YCOCG.
	AVColSpcYcocg AVColorSpace = C.AVCOL_SPC_YCOCG
	// AVColSpcBt2020Ncl wraps AVCOL_SPC_BT2020_NCL.
	//
	//	ITU-R BT2020 non-constant luminance system
	AVColSpcBt2020Ncl AVColorSpace = C.AVCOL_SPC_BT2020_NCL
	// AVColSpcBt2020Cl wraps AVCOL_SPC_BT2020_CL.
	//
	//	ITU-R BT2020 constant luminance system
	AVColSpcBt2020Cl AVColorSpace = C.AVCOL_SPC_BT2020_CL
	// AVColSpcSmpte2085 wraps AVCOL_SPC_SMPTE2085.
	//
	//	SMPTE 2085, Y'D'zD'x
	AVColSpcSmpte2085 AVColorSpace = C.AVCOL_SPC_SMPTE2085
	// AVColSpcChromaDerivedNcl wraps AVCOL_SPC_CHROMA_DERIVED_NCL.
	//
	//	Chromaticity-derived non-constant luminance system
	AVColSpcChromaDerivedNcl AVColorSpace = C.AVCOL_SPC_CHROMA_DERIVED_NCL
	// AVColSpcChromaDerivedCl wraps AVCOL_SPC_CHROMA_DERIVED_CL.
	//
	//	Chromaticity-derived constant luminance system
	AVColSpcChromaDerivedCl AVColorSpace = C.AVCOL_SPC_CHROMA_DERIVED_CL
	// AVColSpcIctcp wraps AVCOL_SPC_ICTCP.
	//
	//	ITU-R BT.2100-0, ICtCp
	AVColSpcIctcp AVColorSpace = C.AVCOL_SPC_ICTCP
	// AVColSpcIptC2 wraps AVCOL_SPC_IPT_C2.
	//
	//	SMPTE ST 2128, IPT-C2
	AVColSpcIptC2 AVColorSpace = C.AVCOL_SPC_IPT_C2
	// AVColSpcYcgcoRe wraps AVCOL_SPC_YCGCO_RE.
	//
	//	YCgCo-R, even addition of bits
	AVColSpcYcgcoRe AVColorSpace = C.AVCOL_SPC_YCGCO_RE
	// AVColSpcYcgcoRo wraps AVCOL_SPC_YCGCO_RO.
	//
	//	YCgCo-R, odd addition of bits
	AVColSpcYcgcoRo AVColorSpace = C.AVCOL_SPC_YCGCO_RO
	// AVColSpcNb wraps AVCOL_SPC_NB.
	//
	//	Not part of ABI
	AVColSpcNb AVColorSpace = C.AVCOL_SPC_NB
)

// --- Enum AVColorRange ---

// AVColorRange wraps AVColorRange.
/*
  Visual content value range.

  These values are based on definitions that can be found in multiple
  specifications, such as ITU-T BT.709 (3.4 - Quantization of RGB, luminance
  and colour-difference signals), ITU-T BT.2020 (Table 5 - Digital
  Representation) as well as ITU-T BT.2100 (Table 9 - Digital 10- and 12-bit
  integer representation). At the time of writing, the BT.2100 one is
  recommended, as it also defines the full range representation.

  Common definitions:
    - For RGB and luma planes such as Y in YCbCr and I in ICtCp,
      'E' is the original value in range of 0.0 to 1.0.
    - For chroma planes such as Cb,Cr and Ct,Cp, 'E' is the original
      value in range of -0.5 to 0.5.
    - 'n' is the output bit depth.
    - For additional definitions such as rounding and clipping to valid n
      bit unsigned integer range, please refer to BT.2100 (Table 9).
*/
type AVColorRange C.enum_AVColorRange

const SizeOfAVColorRange = C.sizeof_enum_AVColorRange

func ToAVColorRangeArray(ptr unsafe.Pointer) *Array[AVColorRange] {
	if ptr == nil {
		return nil
	}

	return &Array[AVColorRange]{
		elemSize: SizeOfAVColorRange,
		loadPtr: func(pointer unsafe.Pointer) AVColorRange {
			ptr := (*AVColorRange)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVColorRange) {
			ptr := (*AVColorRange)(pointer)
			*ptr = value
		},
	}
}

func AllocAVColorRangeArray(size uint64) *Array[AVColorRange] {
	return ToAVColorRangeArray(AVCalloc(size, SizeOfAVColorRange))
}

const (
	// AVColRangeUnspecified wraps AVCOL_RANGE_UNSPECIFIED.
	AVColRangeUnspecified AVColorRange = C.AVCOL_RANGE_UNSPECIFIED
	// AVColRangeMpeg wraps AVCOL_RANGE_MPEG.
	/*
	   Narrow or limited range content.

	   - For luma planes:

	         (219 * E + 16) * 2^(n-8)

	     F.ex. the range of 16-235 for 8 bits

	   - For chroma planes:

	         (224 * E + 128) * 2^(n-8)

	     F.ex. the range of 16-240 for 8 bits
	*/
	AVColRangeMpeg AVColorRange = C.AVCOL_RANGE_MPEG
	// AVColRangeJpeg wraps AVCOL_RANGE_JPEG.
	/*
	   Full range content.

	   - For RGB and luma planes:

	         (2^n - 1) * E

	     F.ex. the range of 0-255 for 8 bits

	   - For chroma planes:

	         (2^n - 1) * E + 2^(n - 1)

	     F.ex. the range of 1-255 for 8 bits
	*/
	AVColRangeJpeg AVColorRange = C.AVCOL_RANGE_JPEG
	// AVColRangeNb wraps AVCOL_RANGE_NB.
	//
	//	Not part of ABI
	AVColRangeNb AVColorRange = C.AVCOL_RANGE_NB
)

// --- Enum AVChromaLocation ---

// AVChromaLocation wraps AVChromaLocation.
/*
  Location of chroma samples.

  Illustration showing the location of the first (top left) chroma sample of the
  image, the left shows only luma, the right
  shows the location of the chroma sample, the 2 could be imagined to overlay
  each other but are drawn separately due to limitations of ASCII

                 1st 2nd       1st 2nd horizontal luma sample positions
                  v   v         v   v
                  ______        ______
  *1st luma line > |X   X ...    |3 4 X ...     X are luma samples,
                 |             |1 2           1-6 are possible chroma positions
  *2nd luma line > |X   X ...    |5 6 X ...     0 is undefined/unknown position
*/
type AVChromaLocation C.enum_AVChromaLocation

const SizeOfAVChromaLocation = C.sizeof_enum_AVChromaLocation

func ToAVChromaLocationArray(ptr unsafe.Pointer) *Array[AVChromaLocation] {
	if ptr == nil {
		return nil
	}

	return &Array[AVChromaLocation]{
		elemSize: SizeOfAVChromaLocation,
		loadPtr: func(pointer unsafe.Pointer) AVChromaLocation {
			ptr := (*AVChromaLocation)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVChromaLocation) {
			ptr := (*AVChromaLocation)(pointer)
			*ptr = value
		},
	}
}

func AllocAVChromaLocationArray(size uint64) *Array[AVChromaLocation] {
	return ToAVChromaLocationArray(AVCalloc(size, SizeOfAVChromaLocation))
}

const (
	// AVChromaLocUnspecified wraps AVCHROMA_LOC_UNSPECIFIED.
	AVChromaLocUnspecified AVChromaLocation = C.AVCHROMA_LOC_UNSPECIFIED
	// AVChromaLocLeft wraps AVCHROMA_LOC_LEFT.
	//
	//	MPEG-2/4 4:2:0, H.264 default for 4:2:0
	AVChromaLocLeft AVChromaLocation = C.AVCHROMA_LOC_LEFT
	// AVChromaLocCenter wraps AVCHROMA_LOC_CENTER.
	//
	//	MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0
	AVChromaLocCenter AVChromaLocation = C.AVCHROMA_LOC_CENTER
	// AVChromaLocTopleft wraps AVCHROMA_LOC_TOPLEFT.
	//
	//	ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2
	AVChromaLocTopleft AVChromaLocation = C.AVCHROMA_LOC_TOPLEFT
	// AVChromaLocTop wraps AVCHROMA_LOC_TOP.
	AVChromaLocTop AVChromaLocation = C.AVCHROMA_LOC_TOP
	// AVChromaLocBottomleft wraps AVCHROMA_LOC_BOTTOMLEFT.
	AVChromaLocBottomleft AVChromaLocation = C.AVCHROMA_LOC_BOTTOMLEFT
	// AVChromaLocBottom wraps AVCHROMA_LOC_BOTTOM.
	AVChromaLocBottom AVChromaLocation = C.AVCHROMA_LOC_BOTTOM
	// AVChromaLocNb wraps AVCHROMA_LOC_NB.
	//
	//	Not part of ABI
	AVChromaLocNb AVChromaLocation = C.AVCHROMA_LOC_NB
)

// --- Enum AVSampleFormat ---

// AVSampleFormat wraps AVSampleFormat.
/*
  Audio sample formats

  - The data described by the sample format is always in native-endian order.
    Sample values can be expressed by native C types, hence the lack of a signed
    24-bit sample format even though it is a common raw audio data format.

  - The floating-point formats are based on full volume being in the range
    [-1.0, 1.0]. Any values outside this range are beyond full volume level.

  - The data layout as used in av_samples_fill_arrays() and elsewhere in FFmpeg
    (such as AVFrame in libavcodec) is as follows:

  @par
  For planar sample formats, each audio channel is in a separate data plane,
  and linesize is the buffer size, in bytes, for a single plane. All data
  planes must be the same size. For packed sample formats, only the first data
  plane is used, and samples for each channel are interleaved. In this case,
  linesize is the buffer size, in bytes, for the 1 plane.
*/
type AVSampleFormat C.enum_AVSampleFormat

const SizeOfAVSampleFormat = C.sizeof_enum_AVSampleFormat

func ToAVSampleFormatArray(ptr unsafe.Pointer) *Array[AVSampleFormat] {
	if ptr == nil {
		return nil
	}

	return &Array[AVSampleFormat]{
		elemSize: SizeOfAVSampleFormat,
		loadPtr: func(pointer unsafe.Pointer) AVSampleFormat {
			ptr := (*AVSampleFormat)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVSampleFormat) {
			ptr := (*AVSampleFormat)(pointer)
			*ptr = value
		},
	}
}

func AllocAVSampleFormatArray(size uint64) *Array[AVSampleFormat] {
	return ToAVSampleFormatArray(AVCalloc(size, SizeOfAVSampleFormat))
}

const (
	// AVSampleFmtNone wraps AV_SAMPLE_FMT_NONE.
	AVSampleFmtNone AVSampleFormat = C.AV_SAMPLE_FMT_NONE
	// AVSampleFmtU8 wraps AV_SAMPLE_FMT_U8.
	//
	//	unsigned 8 bits
	AVSampleFmtU8 AVSampleFormat = C.AV_SAMPLE_FMT_U8
	// AVSampleFmtS16 wraps AV_SAMPLE_FMT_S16.
	//
	//	signed 16 bits
	AVSampleFmtS16 AVSampleFormat = C.AV_SAMPLE_FMT_S16
	// AVSampleFmtS32 wraps AV_SAMPLE_FMT_S32.
	//
	//	signed 32 bits
	AVSampleFmtS32 AVSampleFormat = C.AV_SAMPLE_FMT_S32
	// AVSampleFmtFlt wraps AV_SAMPLE_FMT_FLT.
	//
	//	float
	AVSampleFmtFlt AVSampleFormat = C.AV_SAMPLE_FMT_FLT
	// AVSampleFmtDbl wraps AV_SAMPLE_FMT_DBL.
	//
	//	double
	AVSampleFmtDbl AVSampleFormat = C.AV_SAMPLE_FMT_DBL
	// AVSampleFmtU8P wraps AV_SAMPLE_FMT_U8P.
	//
	//	unsigned 8 bits, planar
	AVSampleFmtU8P AVSampleFormat = C.AV_SAMPLE_FMT_U8P
	// AVSampleFmtS16P wraps AV_SAMPLE_FMT_S16P.
	//
	//	signed 16 bits, planar
	AVSampleFmtS16P AVSampleFormat = C.AV_SAMPLE_FMT_S16P
	// AVSampleFmtS32P wraps AV_SAMPLE_FMT_S32P.
	//
	//	signed 32 bits, planar
	AVSampleFmtS32P AVSampleFormat = C.AV_SAMPLE_FMT_S32P
	// AVSampleFmtFltp wraps AV_SAMPLE_FMT_FLTP.
	//
	//	float, planar
	AVSampleFmtFltp AVSampleFormat = C.AV_SAMPLE_FMT_FLTP
	// AVSampleFmtDblp wraps AV_SAMPLE_FMT_DBLP.
	//
	//	double, planar
	AVSampleFmtDblp AVSampleFormat = C.AV_SAMPLE_FMT_DBLP
	// AVSampleFmtS64 wraps AV_SAMPLE_FMT_S64.
	//
	//	signed 64 bits
	AVSampleFmtS64 AVSampleFormat = C.AV_SAMPLE_FMT_S64
	// AVSampleFmtS64P wraps AV_SAMPLE_FMT_S64P.
	//
	//	signed 64 bits, planar
	AVSampleFmtS64P AVSampleFormat = C.AV_SAMPLE_FMT_S64P
	// AVSampleFmtNb wraps AV_SAMPLE_FMT_NB.
	//
	//	Number of sample formats. DO NOT USE if linking dynamically
	AVSampleFmtNb AVSampleFormat = C.AV_SAMPLE_FMT_NB
)

// --- Enum AVSphericalProjection ---

// AVSphericalProjection wraps AVSphericalProjection.
//
//	Projection of the video surface(s) on a sphere.
type AVSphericalProjection C.enum_AVSphericalProjection

const SizeOfAVSphericalProjection = C.sizeof_enum_AVSphericalProjection

func ToAVSphericalProjectionArray(ptr unsafe.Pointer) *Array[AVSphericalProjection] {
	if ptr == nil {
		return nil
	}

	return &Array[AVSphericalProjection]{
		elemSize: SizeOfAVSphericalProjection,
		loadPtr: func(pointer unsafe.Pointer) AVSphericalProjection {
			ptr := (*AVSphericalProjection)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVSphericalProjection) {
			ptr := (*AVSphericalProjection)(pointer)
			*ptr = value
		},
	}
}

func AllocAVSphericalProjectionArray(size uint64) *Array[AVSphericalProjection] {
	return ToAVSphericalProjectionArray(AVCalloc(size, SizeOfAVSphericalProjection))
}

const (
	// AVSphericalEquirectangular wraps AV_SPHERICAL_EQUIRECTANGULAR.
	/*
	   Video represents a sphere mapped on a flat surface using
	   equirectangular projection.
	*/
	AVSphericalEquirectangular AVSphericalProjection = C.AV_SPHERICAL_EQUIRECTANGULAR
	// AVSphericalCubemap wraps AV_SPHERICAL_CUBEMAP.
	/*
	   Video frame is split into 6 faces of a cube, and arranged on a
	   3x2 layout. Faces are oriented upwards for the front, left, right,
	   and back faces. The up face is oriented so the top of the face is
	   forwards and the down face is oriented so the top of the face is
	   to the back.
	*/
	AVSphericalCubemap AVSphericalProjection = C.AV_SPHERICAL_CUBEMAP
	// AVSphericalEquirectangularTile wraps AV_SPHERICAL_EQUIRECTANGULAR_TILE.
	/*
	   Video represents a portion of a sphere mapped on a flat surface
	   using equirectangular projection. The @ref bounding fields indicate
	   the position of the current video in a larger surface.
	*/
	AVSphericalEquirectangularTile AVSphericalProjection = C.AV_SPHERICAL_EQUIRECTANGULAR_TILE
	// AVSphericalHalfEquirectangular wraps AV_SPHERICAL_HALF_EQUIRECTANGULAR.
	//
	//	Video frame displays as a 180 degree equirectangular projection.
	AVSphericalHalfEquirectangular AVSphericalProjection = C.AV_SPHERICAL_HALF_EQUIRECTANGULAR
	// AVSphericalRectilinear wraps AV_SPHERICAL_RECTILINEAR.
	//
	//	Video frame displays on a flat, rectangular 2D surface.
	AVSphericalRectilinear AVSphericalProjection = C.AV_SPHERICAL_RECTILINEAR
	// AVSphericalFisheye wraps AV_SPHERICAL_FISHEYE.
	/*
	   Fisheye projection (Apple).
	   See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/fisheye
	*/
	AVSphericalFisheye AVSphericalProjection = C.AV_SPHERICAL_FISHEYE
	// AVSphericalParametricImmersive wraps AV_SPHERICAL_PARAMETRIC_IMMERSIVE.
	/*
	   Parametric Immersive projection (Apple).
	   See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/parametricimmersive
	*/
	AVSphericalParametricImmersive AVSphericalProjection = C.AV_SPHERICAL_PARAMETRIC_IMMERSIVE
)

// --- Enum AVStereo3DType ---

// AVStereo3DType wraps AVStereo3DType.
//
//	List of possible 3D Types
type AVStereo3DType C.enum_AVStereo3DType

const SizeOfAVStereo3DType = C.sizeof_enum_AVStereo3DType

func ToAVStereo3DTypeArray(ptr unsafe.Pointer) *Array[AVStereo3DType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVStereo3DType]{
		elemSize: SizeOfAVStereo3DType,
		loadPtr: func(pointer unsafe.Pointer) AVStereo3DType {
			ptr := (*AVStereo3DType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVStereo3DType) {
			ptr := (*AVStereo3DType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVStereo3DTypeArray(size uint64) *Array[AVStereo3DType] {
	return ToAVStereo3DTypeArray(AVCalloc(size, SizeOfAVStereo3DType))
}

const (
	// AVStereo3D2D wraps AV_STEREO3D_2D.
	//
	//	Video is not stereoscopic (and metadata has to be there).
	AVStereo3D2D AVStereo3DType = C.AV_STEREO3D_2D
	// AVStereo3DSidebyside wraps AV_STEREO3D_SIDEBYSIDE.
	/*
	   Views are next to each other.

	   @code{.unparsed}
	      LLLLRRRR
	      LLLLRRRR
	      LLLLRRRR
	      ...
	   @endcode
	*/
	AVStereo3DSidebyside AVStereo3DType = C.AV_STEREO3D_SIDEBYSIDE
	// AVStereo3DTopbottom wraps AV_STEREO3D_TOPBOTTOM.
	/*
	   Views are on top of each other.

	   @code{.unparsed}
	      LLLLLLLL
	      LLLLLLLL
	      RRRRRRRR
	      RRRRRRRR
	   @endcode
	*/
	AVStereo3DTopbottom AVStereo3DType = C.AV_STEREO3D_TOPBOTTOM
	// AVStereo3DFramesequence wraps AV_STEREO3D_FRAMESEQUENCE.
	/*
	   Views are alternated temporally.

	   @code{.unparsed}
	       frame0   frame1   frame2   ...
	      LLLLLLLL RRRRRRRR LLLLLLLL
	      LLLLLLLL RRRRRRRR LLLLLLLL
	      LLLLLLLL RRRRRRRR LLLLLLLL
	      ...      ...      ...
	   @endcode
	*/
	AVStereo3DFramesequence AVStereo3DType = C.AV_STEREO3D_FRAMESEQUENCE
	// AVStereo3DCheckerboard wraps AV_STEREO3D_CHECKERBOARD.
	/*
	   Views are packed in a checkerboard-like structure per pixel.

	   @code{.unparsed}
	      LRLRLRLR
	      RLRLRLRL
	      LRLRLRLR
	      ...
	   @endcode
	*/
	AVStereo3DCheckerboard AVStereo3DType = C.AV_STEREO3D_CHECKERBOARD
	// AVStereo3DSidebysideQuincunx wraps AV_STEREO3D_SIDEBYSIDE_QUINCUNX.
	/*
	   Views are next to each other, but when upscaling
	   apply a checkerboard pattern.

	   @code{.unparsed}
	       LLLLRRRR          L L L L    R R R R
	       LLLLRRRR    =>     L L L L  R R R R
	       LLLLRRRR          L L L L    R R R R
	       LLLLRRRR           L L L L  R R R R
	   @endcode
	*/
	AVStereo3DSidebysideQuincunx AVStereo3DType = C.AV_STEREO3D_SIDEBYSIDE_QUINCUNX
	// AVStereo3DLines wraps AV_STEREO3D_LINES.
	/*
	   Views are packed per line, as if interlaced.

	   @code{.unparsed}
	      LLLLLLLL
	      RRRRRRRR
	      LLLLLLLL
	      ...
	   @endcode
	*/
	AVStereo3DLines AVStereo3DType = C.AV_STEREO3D_LINES
	// AVStereo3DColumns wraps AV_STEREO3D_COLUMNS.
	/*
	   Views are packed per column.

	   @code{.unparsed}
	      LRLRLRLR
	      LRLRLRLR
	      LRLRLRLR
	      ...
	   @endcode
	*/
	AVStereo3DColumns AVStereo3DType = C.AV_STEREO3D_COLUMNS
	// AVStereo3DUnspec wraps AV_STEREO3D_UNSPEC.
	//
	//	Video is stereoscopic but the packing is unspecified.
	AVStereo3DUnspec AVStereo3DType = C.AV_STEREO3D_UNSPEC
)

// --- Enum AVStereo3DView ---

// AVStereo3DView wraps AVStereo3DView.
//
//	List of possible view types.
type AVStereo3DView C.enum_AVStereo3DView

const SizeOfAVStereo3DView = C.sizeof_enum_AVStereo3DView

func ToAVStereo3DViewArray(ptr unsafe.Pointer) *Array[AVStereo3DView] {
	if ptr == nil {
		return nil
	}

	return &Array[AVStereo3DView]{
		elemSize: SizeOfAVStereo3DView,
		loadPtr: func(pointer unsafe.Pointer) AVStereo3DView {
			ptr := (*AVStereo3DView)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVStereo3DView) {
			ptr := (*AVStereo3DView)(pointer)
			*ptr = value
		},
	}
}

func AllocAVStereo3DViewArray(size uint64) *Array[AVStereo3DView] {
	return ToAVStereo3DViewArray(AVCalloc(size, SizeOfAVStereo3DView))
}

const (
	// AVStereo3DViewPacked wraps AV_STEREO3D_VIEW_PACKED.
	//
	//	Frame contains two packed views.
	AVStereo3DViewPacked AVStereo3DView = C.AV_STEREO3D_VIEW_PACKED
	// AVStereo3DViewLeft wraps AV_STEREO3D_VIEW_LEFT.
	//
	//	Frame contains only the left view.
	AVStereo3DViewLeft AVStereo3DView = C.AV_STEREO3D_VIEW_LEFT
	// AVStereo3DViewRight wraps AV_STEREO3D_VIEW_RIGHT.
	//
	//	Frame contains only the right view.
	AVStereo3DViewRight AVStereo3DView = C.AV_STEREO3D_VIEW_RIGHT
	// AVStereo3DViewUnspec wraps AV_STEREO3D_VIEW_UNSPEC.
	//
	//	Content is unspecified.
	AVStereo3DViewUnspec AVStereo3DView = C.AV_STEREO3D_VIEW_UNSPEC
)

// --- Enum AVStereo3DPrimaryEye ---

// AVStereo3DPrimaryEye wraps AVStereo3DPrimaryEye.
//
//	List of possible primary eyes.
type AVStereo3DPrimaryEye C.enum_AVStereo3DPrimaryEye

const SizeOfAVStereo3DPrimaryEye = C.sizeof_enum_AVStereo3DPrimaryEye

func ToAVStereo3DPrimaryEyeArray(ptr unsafe.Pointer) *Array[AVStereo3DPrimaryEye] {
	if ptr == nil {
		return nil
	}

	return &Array[AVStereo3DPrimaryEye]{
		elemSize: SizeOfAVStereo3DPrimaryEye,
		loadPtr: func(pointer unsafe.Pointer) AVStereo3DPrimaryEye {
			ptr := (*AVStereo3DPrimaryEye)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVStereo3DPrimaryEye) {
			ptr := (*AVStereo3DPrimaryEye)(pointer)
			*ptr = value
		},
	}
}

func AllocAVStereo3DPrimaryEyeArray(size uint64) *Array[AVStereo3DPrimaryEye] {
	return ToAVStereo3DPrimaryEyeArray(AVCalloc(size, SizeOfAVStereo3DPrimaryEye))
}

const (
	// AVPrimaryEyeNone wraps AV_PRIMARY_EYE_NONE.
	//
	//	Neither eye.
	AVPrimaryEyeNone AVStereo3DPrimaryEye = C.AV_PRIMARY_EYE_NONE
	// AVPrimaryEyeLeft wraps AV_PRIMARY_EYE_LEFT.
	//
	//	Left eye.
	AVPrimaryEyeLeft AVStereo3DPrimaryEye = C.AV_PRIMARY_EYE_LEFT
	// AVPrimaryEyeRight wraps AV_PRIMARY_EYE_RIGHT.
	//
	//	Right eye
	AVPrimaryEyeRight AVStereo3DPrimaryEye = C.AV_PRIMARY_EYE_RIGHT
)

// --- Enum AVThreadMessageFlags ---

// AVThreadMessageFlags wraps AVThreadMessageFlags.
type AVThreadMessageFlags C.AVThreadMessageFlags

const SizeOfAVThreadMessageFlags = C.sizeof_AVThreadMessageFlags

func ToAVThreadMessageFlagsArray(ptr unsafe.Pointer) *Array[AVThreadMessageFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[AVThreadMessageFlags]{
		elemSize: SizeOfAVThreadMessageFlags,
		loadPtr: func(pointer unsafe.Pointer) AVThreadMessageFlags {
			ptr := (*AVThreadMessageFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVThreadMessageFlags) {
			ptr := (*AVThreadMessageFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocAVThreadMessageFlagsArray(size uint64) *Array[AVThreadMessageFlags] {
	return ToAVThreadMessageFlagsArray(AVCalloc(size, SizeOfAVThreadMessageFlags))
}

const (
	// AVThreadMessageNonblock wraps AV_THREAD_MESSAGE_NONBLOCK.
	/*
	   Perform non-blocking operation.
	   If this flag is set, send and recv operations are non-blocking and
	   return AVERROR(EAGAIN) immediately if they can not proceed.
	*/
	AVThreadMessageNonblock AVThreadMessageFlags = C.AV_THREAD_MESSAGE_NONBLOCK
)

// --- Enum AVTimecodeFlag ---

// AVTimecodeFlag wraps AVTimecodeFlag.
type AVTimecodeFlag C.enum_AVTimecodeFlag

const SizeOfAVTimecodeFlag = C.sizeof_enum_AVTimecodeFlag

func ToAVTimecodeFlagArray(ptr unsafe.Pointer) *Array[AVTimecodeFlag] {
	if ptr == nil {
		return nil
	}

	return &Array[AVTimecodeFlag]{
		elemSize: SizeOfAVTimecodeFlag,
		loadPtr: func(pointer unsafe.Pointer) AVTimecodeFlag {
			ptr := (*AVTimecodeFlag)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVTimecodeFlag) {
			ptr := (*AVTimecodeFlag)(pointer)
			*ptr = value
		},
	}
}

func AllocAVTimecodeFlagArray(size uint64) *Array[AVTimecodeFlag] {
	return ToAVTimecodeFlagArray(AVCalloc(size, SizeOfAVTimecodeFlag))
}

const (
	// AVTimecodeFlagDropframe wraps AV_TIMECODE_FLAG_DROPFRAME.
	//
	//	timecode is drop frame
	AVTimecodeFlagDropframe AVTimecodeFlag = C.AV_TIMECODE_FLAG_DROPFRAME
	// AVTimecodeFlag24Hoursmax wraps AV_TIMECODE_FLAG_24HOURSMAX.
	//
	//	timecode wraps after 24 hours
	AVTimecodeFlag24Hoursmax AVTimecodeFlag = C.AV_TIMECODE_FLAG_24HOURSMAX
	// AVTimecodeFlagAllownegative wraps AV_TIMECODE_FLAG_ALLOWNEGATIVE.
	//
	//	negative time values are allowed
	AVTimecodeFlagAllownegative AVTimecodeFlag = C.AV_TIMECODE_FLAG_ALLOWNEGATIVE
)

// --- Enum AVTXType ---

// AVTXType wraps AVTXType.
type AVTXType C.enum_AVTXType

const SizeOfAVTXType = C.sizeof_enum_AVTXType

func ToAVTXTypeArray(ptr unsafe.Pointer) *Array[AVTXType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVTXType]{
		elemSize: SizeOfAVTXType,
		loadPtr: func(pointer unsafe.Pointer) AVTXType {
			ptr := (*AVTXType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVTXType) {
			ptr := (*AVTXType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVTXTypeArray(size uint64) *Array[AVTXType] {
	return ToAVTXTypeArray(AVCalloc(size, SizeOfAVTXType))
}

const (
	// AVTxFloatFFT wraps AV_TX_FLOAT_FFT.
	/*
	   Standard complex to complex FFT with sample data type of AVComplexFloat,
	   AVComplexDouble or AVComplexInt32, for each respective variant.

	   Output is not 1/len normalized. Scaling currently unsupported.
	   The stride parameter must be set to the size of a single sample in bytes.
	*/
	AVTxFloatFFT AVTXType = C.AV_TX_FLOAT_FFT
	// AVTxDoubleFFT wraps AV_TX_DOUBLE_FFT.
	/*
	   Standard complex to complex FFT with sample data type of AVComplexFloat,
	   AVComplexDouble or AVComplexInt32, for each respective variant.

	   Output is not 1/len normalized. Scaling currently unsupported.
	   The stride parameter must be set to the size of a single sample in bytes.
	*/
	AVTxDoubleFFT AVTXType = C.AV_TX_DOUBLE_FFT
	// AVTxInt32FFT wraps AV_TX_INT32_FFT.
	/*
	   Standard complex to complex FFT with sample data type of AVComplexFloat,
	   AVComplexDouble or AVComplexInt32, for each respective variant.

	   Output is not 1/len normalized. Scaling currently unsupported.
	   The stride parameter must be set to the size of a single sample in bytes.
	*/
	AVTxInt32FFT AVTXType = C.AV_TX_INT32_FFT
	// AVTxFloatMdct wraps AV_TX_FLOAT_MDCT.
	/*
	   Standard MDCT with a sample data type of float, double or int32_t,
	   respectively. For the float and int32 variants, the scale type is
	   'float', while for the double variant, it's 'double'.
	   If scale is NULL, 1.0 will be used as a default.

	   Length is the frame size, not the window size (which is 2x frame).
	   For forward transforms, the stride specifies the spacing between each
	   sample in the output array in bytes. The input must be a flat array.

	   For inverse transforms, the stride specifies the spacing between each
	   sample in the input array in bytes. The output must be a flat array.

	   NOTE: the inverse transform is half-length, meaning the output will not
	   contain redundant data. This is what most codecs work with. To do a full
	   inverse transform, set the AV_TX_FULL_IMDCT flag on init.
	*/
	AVTxFloatMdct AVTXType = C.AV_TX_FLOAT_MDCT
	// AVTxDoubleMdct wraps AV_TX_DOUBLE_MDCT.
	/*
	   Standard MDCT with a sample data type of float, double or int32_t,
	   respectively. For the float and int32 variants, the scale type is
	   'float', while for the double variant, it's 'double'.
	   If scale is NULL, 1.0 will be used as a default.

	   Length is the frame size, not the window size (which is 2x frame).
	   For forward transforms, the stride specifies the spacing between each
	   sample in the output array in bytes. The input must be a flat array.

	   For inverse transforms, the stride specifies the spacing between each
	   sample in the input array in bytes. The output must be a flat array.

	   NOTE: the inverse transform is half-length, meaning the output will not
	   contain redundant data. This is what most codecs work with. To do a full
	   inverse transform, set the AV_TX_FULL_IMDCT flag on init.
	*/
	AVTxDoubleMdct AVTXType = C.AV_TX_DOUBLE_MDCT
	// AVTxInt32Mdct wraps AV_TX_INT32_MDCT.
	/*
	   Standard MDCT with a sample data type of float, double or int32_t,
	   respectively. For the float and int32 variants, the scale type is
	   'float', while for the double variant, it's 'double'.
	   If scale is NULL, 1.0 will be used as a default.

	   Length is the frame size, not the window size (which is 2x frame).
	   For forward transforms, the stride specifies the spacing between each
	   sample in the output array in bytes. The input must be a flat array.

	   For inverse transforms, the stride specifies the spacing between each
	   sample in the input array in bytes. The output must be a flat array.

	   NOTE: the inverse transform is half-length, meaning the output will not
	   contain redundant data. This is what most codecs work with. To do a full
	   inverse transform, set the AV_TX_FULL_IMDCT flag on init.
	*/
	AVTxInt32Mdct AVTXType = C.AV_TX_INT32_MDCT
	// AVTxFloatRdft wraps AV_TX_FLOAT_RDFT.
	/*
	   Real to complex and complex to real DFTs.
	   For the float and int32 variants, the scale type is 'float', while for
	   the double variant, it's a 'double'. If scale is NULL, 1.0 will be used
	   as a default.

	   For forward transforms (R2C), stride must be the spacing between two
	   samples in bytes. For inverse transforms, the stride must be set
	   to the spacing between two complex values in bytes.

	   The forward transform performs a real-to-complex DFT of N samples to
	   N/2+1 complex values.

	   The inverse transform performs a complex-to-real DFT of N/2+1 complex
	   values to N real samples. The output is not normalized, but can be
	   made so by setting the scale value to 1.0/len.
	   NOTE: the inverse transform always overwrites the input.
	*/
	AVTxFloatRdft AVTXType = C.AV_TX_FLOAT_RDFT
	// AVTxDoubleRdft wraps AV_TX_DOUBLE_RDFT.
	/*
	   Real to complex and complex to real DFTs.
	   For the float and int32 variants, the scale type is 'float', while for
	   the double variant, it's a 'double'. If scale is NULL, 1.0 will be used
	   as a default.

	   For forward transforms (R2C), stride must be the spacing between two
	   samples in bytes. For inverse transforms, the stride must be set
	   to the spacing between two complex values in bytes.

	   The forward transform performs a real-to-complex DFT of N samples to
	   N/2+1 complex values.

	   The inverse transform performs a complex-to-real DFT of N/2+1 complex
	   values to N real samples. The output is not normalized, but can be
	   made so by setting the scale value to 1.0/len.
	   NOTE: the inverse transform always overwrites the input.
	*/
	AVTxDoubleRdft AVTXType = C.AV_TX_DOUBLE_RDFT
	// AVTxInt32Rdft wraps AV_TX_INT32_RDFT.
	/*
	   Real to complex and complex to real DFTs.
	   For the float and int32 variants, the scale type is 'float', while for
	   the double variant, it's a 'double'. If scale is NULL, 1.0 will be used
	   as a default.

	   For forward transforms (R2C), stride must be the spacing between two
	   samples in bytes. For inverse transforms, the stride must be set
	   to the spacing between two complex values in bytes.

	   The forward transform performs a real-to-complex DFT of N samples to
	   N/2+1 complex values.

	   The inverse transform performs a complex-to-real DFT of N/2+1 complex
	   values to N real samples. The output is not normalized, but can be
	   made so by setting the scale value to 1.0/len.
	   NOTE: the inverse transform always overwrites the input.
	*/
	AVTxInt32Rdft AVTXType = C.AV_TX_INT32_RDFT
	// AVTxFloatDct wraps AV_TX_FLOAT_DCT.
	/*
	   Real to real (DCT) transforms.

	   The forward transform is a DCT-II.
	   The inverse transform is a DCT-III.

	   The input array is always overwritten. DCT-III requires that the
	   input be padded with 2 extra samples. Stride must be set to the
	   spacing between two samples in bytes.
	*/
	AVTxFloatDct AVTXType = C.AV_TX_FLOAT_DCT
	// AVTxDoubleDct wraps AV_TX_DOUBLE_DCT.
	/*
	   Real to real (DCT) transforms.

	   The forward transform is a DCT-II.
	   The inverse transform is a DCT-III.

	   The input array is always overwritten. DCT-III requires that the
	   input be padded with 2 extra samples. Stride must be set to the
	   spacing between two samples in bytes.
	*/
	AVTxDoubleDct AVTXType = C.AV_TX_DOUBLE_DCT
	// AVTxInt32Dct wraps AV_TX_INT32_DCT.
	/*
	   Real to real (DCT) transforms.

	   The forward transform is a DCT-II.
	   The inverse transform is a DCT-III.

	   The input array is always overwritten. DCT-III requires that the
	   input be padded with 2 extra samples. Stride must be set to the
	   spacing between two samples in bytes.
	*/
	AVTxInt32Dct AVTXType = C.AV_TX_INT32_DCT
	// AVTxFloatDctI wraps AV_TX_FLOAT_DCT_I.
	/*
	   Discrete Cosine Transform I

	   The forward transform is a DCT-I.
	   The inverse transform is a DCT-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxFloatDctI AVTXType = C.AV_TX_FLOAT_DCT_I
	// AVTxDoubleDctI wraps AV_TX_DOUBLE_DCT_I.
	/*
	   Discrete Cosine Transform I

	   The forward transform is a DCT-I.
	   The inverse transform is a DCT-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxDoubleDctI AVTXType = C.AV_TX_DOUBLE_DCT_I
	// AVTxInt32DctI wraps AV_TX_INT32_DCT_I.
	/*
	   Discrete Cosine Transform I

	   The forward transform is a DCT-I.
	   The inverse transform is a DCT-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxInt32DctI AVTXType = C.AV_TX_INT32_DCT_I
	// AVTxFloatDstI wraps AV_TX_FLOAT_DST_I.
	/*
	   Discrete Sine Transform I

	   The forward transform is a DST-I.
	   The inverse transform is a DST-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxFloatDstI AVTXType = C.AV_TX_FLOAT_DST_I
	// AVTxDoubleDstI wraps AV_TX_DOUBLE_DST_I.
	/*
	   Discrete Sine Transform I

	   The forward transform is a DST-I.
	   The inverse transform is a DST-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxDoubleDstI AVTXType = C.AV_TX_DOUBLE_DST_I
	// AVTxInt32DstI wraps AV_TX_INT32_DST_I.
	/*
	   Discrete Sine Transform I

	   The forward transform is a DST-I.
	   The inverse transform is a DST-I multiplied by 2/(N + 1).

	   The input array is always overwritten.
	*/
	AVTxInt32DstI AVTXType = C.AV_TX_INT32_DST_I
	// AVTxNb wraps AV_TX_NB.
	//
	//	Not part of the API, do not use
	AVTxNb AVTXType = C.AV_TX_NB
)

// --- Enum AVTXFlags ---

// AVTXFlags wraps AVTXFlags.
//
//	Flags for av_tx_init()
type AVTXFlags C.enum_AVTXFlags

const SizeOfAVTXFlags = C.sizeof_enum_AVTXFlags

func ToAVTXFlagsArray(ptr unsafe.Pointer) *Array[AVTXFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[AVTXFlags]{
		elemSize: SizeOfAVTXFlags,
		loadPtr: func(pointer unsafe.Pointer) AVTXFlags {
			ptr := (*AVTXFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVTXFlags) {
			ptr := (*AVTXFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocAVTXFlagsArray(size uint64) *Array[AVTXFlags] {
	return ToAVTXFlagsArray(AVCalloc(size, SizeOfAVTXFlags))
}

const (
	// AVTxInplace wraps AV_TX_INPLACE.
	/*
	   Allows for in-place transformations, where input == output.
	   May be unsupported or slower for some transform types.
	*/
	AVTxInplace AVTXFlags = C.AV_TX_INPLACE
	// AVTxUnaligned wraps AV_TX_UNALIGNED.
	/*
	   Relaxes alignment requirement for the in and out arrays of av_tx_fn().
	   May be slower with certain transform types.
	*/
	AVTxUnaligned AVTXFlags = C.AV_TX_UNALIGNED
	// AVTxFullImdct wraps AV_TX_FULL_IMDCT.
	/*
	   Performs a full inverse MDCT rather than leaving out samples that can be
	   derived through symmetry. Requires an output array of 'len' floats,
	   rather than the usual 'len/2' floats.
	   Ignored for all transforms but inverse MDCTs.
	*/
	AVTxFullImdct AVTXFlags = C.AV_TX_FULL_IMDCT
	// AVTxRealToReal wraps AV_TX_REAL_TO_REAL.
	/*
	   Perform a real to half-complex RDFT.
	   Only the real, or imaginary coefficients will
	   be output, depending on the flag used. Only available for forward RDFTs.
	   Output array must have enough space to hold N complex values
	   (regular size for a real to complex transform).
	*/
	AVTxRealToReal AVTXFlags = C.AV_TX_REAL_TO_REAL
	// AVTxRealToImaginary wraps AV_TX_REAL_TO_IMAGINARY.
	/*
	   Perform a real to half-complex RDFT.
	   Only the real, or imaginary coefficients will
	   be output, depending on the flag used. Only available for forward RDFTs.
	   Output array must have enough space to hold N complex values
	   (regular size for a real to complex transform).
	*/
	AVTxRealToImaginary AVTXFlags = C.AV_TX_REAL_TO_IMAGINARY
)

// --- Enum AVVideoEncParamsType ---

// AVVideoEncParamsType wraps AVVideoEncParamsType.
type AVVideoEncParamsType C.enum_AVVideoEncParamsType

const SizeOfAVVideoEncParamsType = C.sizeof_enum_AVVideoEncParamsType

func ToAVVideoEncParamsTypeArray(ptr unsafe.Pointer) *Array[AVVideoEncParamsType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVVideoEncParamsType]{
		elemSize: SizeOfAVVideoEncParamsType,
		loadPtr: func(pointer unsafe.Pointer) AVVideoEncParamsType {
			ptr := (*AVVideoEncParamsType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVVideoEncParamsType) {
			ptr := (*AVVideoEncParamsType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVVideoEncParamsTypeArray(size uint64) *Array[AVVideoEncParamsType] {
	return ToAVVideoEncParamsTypeArray(AVCalloc(size, SizeOfAVVideoEncParamsType))
}

const (
	// AVVideoEncParamsNone wraps AV_VIDEO_ENC_PARAMS_NONE.
	AVVideoEncParamsNone AVVideoEncParamsType = C.AV_VIDEO_ENC_PARAMS_NONE
	// AVVideoEncParamsVp9 wraps AV_VIDEO_ENC_PARAMS_VP9.
	/*
	   VP9 stores:
	   - per-frame base (luma AC) quantizer index, exported as AVVideoEncParams.qp
	   - deltas for luma DC, chroma AC and chroma DC, exported in the
	     corresponding entries in AVVideoEncParams.delta_qp
	   - per-segment delta, exported as for each block as AVVideoBlockParams.delta_qp

	   To compute the resulting quantizer index for a block:
	   - for luma AC, add the base qp and the per-block delta_qp, saturating to
	     unsigned 8-bit.
	   - for luma DC and chroma AC/DC, add the corresponding
	     AVVideoBlockParams.delta_qp to the luma AC index, again saturating to
	     unsigned 8-bit.
	*/
	AVVideoEncParamsVp9 AVVideoEncParamsType = C.AV_VIDEO_ENC_PARAMS_VP9
	// AVVideoEncParamsH264 wraps AV_VIDEO_ENC_PARAMS_H264.
	/*
	   H.264 stores:
	   - in PPS (per-picture):
	     * initial QP_Y (luma) value, exported as AVVideoEncParams.qp
	     * delta(s) for chroma QP values (same for both, or each separately),
	       exported as in the corresponding entries in AVVideoEncParams.delta_qp
	   - per-slice QP delta, not exported directly, added to the per-MB value
	   - per-MB delta; not exported directly; the final per-MB quantizer
	     parameter - QP_Y - minus the value in AVVideoEncParams.qp is exported
	     as AVVideoBlockParams.qp_delta.
	*/
	AVVideoEncParamsH264 AVVideoEncParamsType = C.AV_VIDEO_ENC_PARAMS_H264
	// AVVideoEncParamsMpeg2 wraps AV_VIDEO_ENC_PARAMS_MPEG2.
	/*
	   MPEG-2-compatible quantizer.

	   Summing the frame-level qp with the per-block delta_qp gives the
	   resulting quantizer for the block.
	*/
	AVVideoEncParamsMpeg2 AVVideoEncParamsType = C.AV_VIDEO_ENC_PARAMS_MPEG2
)

// --- Enum AVVideoHintType ---

// AVVideoHintType wraps AVVideoHintType.
type AVVideoHintType C.AVVideoHintType

const SizeOfAVVideoHintType = C.sizeof_AVVideoHintType

func ToAVVideoHintTypeArray(ptr unsafe.Pointer) *Array[AVVideoHintType] {
	if ptr == nil {
		return nil
	}

	return &Array[AVVideoHintType]{
		elemSize: SizeOfAVVideoHintType,
		loadPtr: func(pointer unsafe.Pointer) AVVideoHintType {
			ptr := (*AVVideoHintType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value AVVideoHintType) {
			ptr := (*AVVideoHintType)(pointer)
			*ptr = value
		},
	}
}

func AllocAVVideoHintTypeArray(size uint64) *Array[AVVideoHintType] {
	return ToAVVideoHintTypeArray(AVCalloc(size, SizeOfAVVideoHintType))
}

const (
	// AVVideoHintTypeConstant wraps AV_VIDEO_HINT_TYPE_CONSTANT.
	//
	//	rectangled delimit the constant areas (unchanged), default is changed
	AVVideoHintTypeConstant AVVideoHintType = C.AV_VIDEO_HINT_TYPE_CONSTANT
	// AVVideoHintTypeChanged wraps AV_VIDEO_HINT_TYPE_CHANGED.
	//
	//	rectangled delimit the constant areas (changed), default is not changed
	AVVideoHintTypeChanged AVVideoHintType = C.AV_VIDEO_HINT_TYPE_CHANGED
)

// --- Enum SwrDitherType ---

// SwrDitherType wraps SwrDitherType.
//
//	Dithering algorithms
type SwrDitherType C.enum_SwrDitherType

const SizeOfSwrDitherType = C.sizeof_enum_SwrDitherType

func ToSwrDitherTypeArray(ptr unsafe.Pointer) *Array[SwrDitherType] {
	if ptr == nil {
		return nil
	}

	return &Array[SwrDitherType]{
		elemSize: SizeOfSwrDitherType,
		loadPtr: func(pointer unsafe.Pointer) SwrDitherType {
			ptr := (*SwrDitherType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwrDitherType) {
			ptr := (*SwrDitherType)(pointer)
			*ptr = value
		},
	}
}

func AllocSwrDitherTypeArray(size uint64) *Array[SwrDitherType] {
	return ToSwrDitherTypeArray(AVCalloc(size, SizeOfSwrDitherType))
}

const (
	// SwrDitherNone wraps SWR_DITHER_NONE.
	SwrDitherNone SwrDitherType = C.SWR_DITHER_NONE
	// SwrDitherRectangular wraps SWR_DITHER_RECTANGULAR.
	SwrDitherRectangular SwrDitherType = C.SWR_DITHER_RECTANGULAR
	// SwrDitherTriangular wraps SWR_DITHER_TRIANGULAR.
	SwrDitherTriangular SwrDitherType = C.SWR_DITHER_TRIANGULAR
	// SwrDitherTriangularHighpass wraps SWR_DITHER_TRIANGULAR_HIGHPASS.
	SwrDitherTriangularHighpass SwrDitherType = C.SWR_DITHER_TRIANGULAR_HIGHPASS
	// SwrDitherNs wraps SWR_DITHER_NS.
	//
	//	not part of API/ABI
	SwrDitherNs SwrDitherType = C.SWR_DITHER_NS
	// SwrDitherNsLipshitz wraps SWR_DITHER_NS_LIPSHITZ.
	SwrDitherNsLipshitz SwrDitherType = C.SWR_DITHER_NS_LIPSHITZ
	// SwrDitherNsFWeighted wraps SWR_DITHER_NS_F_WEIGHTED.
	SwrDitherNsFWeighted SwrDitherType = C.SWR_DITHER_NS_F_WEIGHTED
	// SwrDitherNsModifiedEWeighted wraps SWR_DITHER_NS_MODIFIED_E_WEIGHTED.
	SwrDitherNsModifiedEWeighted SwrDitherType = C.SWR_DITHER_NS_MODIFIED_E_WEIGHTED
	// SwrDitherNsImprovedEWeighted wraps SWR_DITHER_NS_IMPROVED_E_WEIGHTED.
	SwrDitherNsImprovedEWeighted SwrDitherType = C.SWR_DITHER_NS_IMPROVED_E_WEIGHTED
	// SwrDitherNsShibata wraps SWR_DITHER_NS_SHIBATA.
	SwrDitherNsShibata SwrDitherType = C.SWR_DITHER_NS_SHIBATA
	// SwrDitherNsLowShibata wraps SWR_DITHER_NS_LOW_SHIBATA.
	SwrDitherNsLowShibata SwrDitherType = C.SWR_DITHER_NS_LOW_SHIBATA
	// SwrDitherNsHighShibata wraps SWR_DITHER_NS_HIGH_SHIBATA.
	SwrDitherNsHighShibata SwrDitherType = C.SWR_DITHER_NS_HIGH_SHIBATA
	// SwrDitherNb wraps SWR_DITHER_NB.
	//
	//	not part of API/ABI
	SwrDitherNb SwrDitherType = C.SWR_DITHER_NB
)

// --- Enum SwrEngine ---

// SwrEngine wraps SwrEngine.
//
//	Resampling Engines
type SwrEngine C.enum_SwrEngine

const SizeOfSwrEngine = C.sizeof_enum_SwrEngine

func ToSwrEngineArray(ptr unsafe.Pointer) *Array[SwrEngine] {
	if ptr == nil {
		return nil
	}

	return &Array[SwrEngine]{
		elemSize: SizeOfSwrEngine,
		loadPtr: func(pointer unsafe.Pointer) SwrEngine {
			ptr := (*SwrEngine)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwrEngine) {
			ptr := (*SwrEngine)(pointer)
			*ptr = value
		},
	}
}

func AllocSwrEngineArray(size uint64) *Array[SwrEngine] {
	return ToSwrEngineArray(AVCalloc(size, SizeOfSwrEngine))
}

const (
	// SwrEngineSwr wraps SWR_ENGINE_SWR.
	//
	//	SW Resampler
	SwrEngineSwr SwrEngine = C.SWR_ENGINE_SWR
	// SwrEngineSoxr wraps SWR_ENGINE_SOXR.
	//
	//	SoX Resampler
	SwrEngineSoxr SwrEngine = C.SWR_ENGINE_SOXR
	// SwrEngineNb wraps SWR_ENGINE_NB.
	//
	//	not part of API/ABI
	SwrEngineNb SwrEngine = C.SWR_ENGINE_NB
)

// --- Enum SwrFilterType ---

// SwrFilterType wraps SwrFilterType.
//
//	Resampling Filter Types
type SwrFilterType C.enum_SwrFilterType

const SizeOfSwrFilterType = C.sizeof_enum_SwrFilterType

func ToSwrFilterTypeArray(ptr unsafe.Pointer) *Array[SwrFilterType] {
	if ptr == nil {
		return nil
	}

	return &Array[SwrFilterType]{
		elemSize: SizeOfSwrFilterType,
		loadPtr: func(pointer unsafe.Pointer) SwrFilterType {
			ptr := (*SwrFilterType)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwrFilterType) {
			ptr := (*SwrFilterType)(pointer)
			*ptr = value
		},
	}
}

func AllocSwrFilterTypeArray(size uint64) *Array[SwrFilterType] {
	return ToSwrFilterTypeArray(AVCalloc(size, SizeOfSwrFilterType))
}

const (
	// SwrFilterTypeCubic wraps SWR_FILTER_TYPE_CUBIC.
	//
	//	Cubic
	SwrFilterTypeCubic SwrFilterType = C.SWR_FILTER_TYPE_CUBIC
	// SwrFilterTypeBlackmanNuttall wraps SWR_FILTER_TYPE_BLACKMAN_NUTTALL.
	//
	//	Blackman Nuttall windowed sinc
	SwrFilterTypeBlackmanNuttall SwrFilterType = C.SWR_FILTER_TYPE_BLACKMAN_NUTTALL
	// SwrFilterTypeKaiser wraps SWR_FILTER_TYPE_KAISER.
	//
	//	Kaiser windowed sinc
	SwrFilterTypeKaiser SwrFilterType = C.SWR_FILTER_TYPE_KAISER
)

// --- Enum SwsDither ---

// SwsDither wraps SwsDither.
/*
  ****************************
  Flags and quality settings *
  *****************************
*/
type SwsDither C.SwsDither

const SizeOfSwsDither = C.sizeof_SwsDither

func ToSwsDitherArray(ptr unsafe.Pointer) *Array[SwsDither] {
	if ptr == nil {
		return nil
	}

	return &Array[SwsDither]{
		elemSize: SizeOfSwsDither,
		loadPtr: func(pointer unsafe.Pointer) SwsDither {
			ptr := (*SwsDither)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwsDither) {
			ptr := (*SwsDither)(pointer)
			*ptr = value
		},
	}
}

func AllocSwsDitherArray(size uint64) *Array[SwsDither] {
	return ToSwsDitherArray(AVCalloc(size, SizeOfSwsDither))
}

const (
	// SwsDitherNone wraps SWS_DITHER_NONE.
	//
	//	disable dithering
	SwsDitherNone SwsDither = C.SWS_DITHER_NONE
	// SwsDitherAuto wraps SWS_DITHER_AUTO.
	//
	//	auto-select from preset
	SwsDitherAuto SwsDither = C.SWS_DITHER_AUTO
	// SwsDitherBayer wraps SWS_DITHER_BAYER.
	//
	//	ordered dither matrix
	SwsDitherBayer SwsDither = C.SWS_DITHER_BAYER
	// SwsDitherEd wraps SWS_DITHER_ED.
	//
	//	error diffusion
	SwsDitherEd SwsDither = C.SWS_DITHER_ED
	// SwsDitherADither wraps SWS_DITHER_A_DITHER.
	//
	//	arithmetic addition
	SwsDitherADither SwsDither = C.SWS_DITHER_A_DITHER
	// SwsDitherXDither wraps SWS_DITHER_X_DITHER.
	//
	//	arithmetic xor
	SwsDitherXDither SwsDither = C.SWS_DITHER_X_DITHER
	// SwsDitherNb wraps SWS_DITHER_NB.
	//
	//	not part of the ABI
	SwsDitherNb SwsDither = C.SWS_DITHER_NB
)

// --- Enum SwsAlphaBlend ---

// SwsAlphaBlend wraps SwsAlphaBlend.
type SwsAlphaBlend C.SwsAlphaBlend

const SizeOfSwsAlphaBlend = C.sizeof_SwsAlphaBlend

func ToSwsAlphaBlendArray(ptr unsafe.Pointer) *Array[SwsAlphaBlend] {
	if ptr == nil {
		return nil
	}

	return &Array[SwsAlphaBlend]{
		elemSize: SizeOfSwsAlphaBlend,
		loadPtr: func(pointer unsafe.Pointer) SwsAlphaBlend {
			ptr := (*SwsAlphaBlend)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwsAlphaBlend) {
			ptr := (*SwsAlphaBlend)(pointer)
			*ptr = value
		},
	}
}

func AllocSwsAlphaBlendArray(size uint64) *Array[SwsAlphaBlend] {
	return ToSwsAlphaBlendArray(AVCalloc(size, SizeOfSwsAlphaBlend))
}

const (
	// SwsAlphaBlendNone wraps SWS_ALPHA_BLEND_NONE.
	SwsAlphaBlendNone SwsAlphaBlend = C.SWS_ALPHA_BLEND_NONE
	// SwsAlphaBlendUniform wraps SWS_ALPHA_BLEND_UNIFORM.
	SwsAlphaBlendUniform SwsAlphaBlend = C.SWS_ALPHA_BLEND_UNIFORM
	// SwsAlphaBlendCheckerboard wraps SWS_ALPHA_BLEND_CHECKERBOARD.
	SwsAlphaBlendCheckerboard SwsAlphaBlend = C.SWS_ALPHA_BLEND_CHECKERBOARD
	// SwsAlphaBlendNb wraps SWS_ALPHA_BLEND_NB.
	//
	//	not part of the ABI
	SwsAlphaBlendNb SwsAlphaBlend = C.SWS_ALPHA_BLEND_NB
)

// --- Enum SwsFlags ---

// SwsFlags wraps SwsFlags.
type SwsFlags C.SwsFlags

const SizeOfSwsFlags = C.sizeof_SwsFlags

func ToSwsFlagsArray(ptr unsafe.Pointer) *Array[SwsFlags] {
	if ptr == nil {
		return nil
	}

	return &Array[SwsFlags]{
		elemSize: SizeOfSwsFlags,
		loadPtr: func(pointer unsafe.Pointer) SwsFlags {
			ptr := (*SwsFlags)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwsFlags) {
			ptr := (*SwsFlags)(pointer)
			*ptr = value
		},
	}
}

func AllocSwsFlagsArray(size uint64) *Array[SwsFlags] {
	return ToSwsFlagsArray(AVCalloc(size, SizeOfSwsFlags))
}

const (
	// SwsFastBilinear wraps SWS_FAST_BILINEAR.
	//
	//	fast bilinear filtering
	SwsFastBilinear SwsFlags = C.SWS_FAST_BILINEAR
	// SwsBilinear wraps SWS_BILINEAR.
	//
	//	bilinear filtering
	SwsBilinear SwsFlags = C.SWS_BILINEAR
	// SwsBicubic wraps SWS_BICUBIC.
	//
	//	2-tap cubic B-spline
	SwsBicubic SwsFlags = C.SWS_BICUBIC
	// SwsX wraps SWS_X.
	//
	//	experimental
	SwsX SwsFlags = C.SWS_X
	// SwsPoint wraps SWS_POINT.
	//
	//	nearest neighbor
	SwsPoint SwsFlags = C.SWS_POINT
	// SwsArea wraps SWS_AREA.
	//
	//	area averaging
	SwsArea SwsFlags = C.SWS_AREA
	// SwsBicublin wraps SWS_BICUBLIN.
	//
	//	bicubic luma, bilinear chroma
	SwsBicublin SwsFlags = C.SWS_BICUBLIN
	// SwsGauss wraps SWS_GAUSS.
	//
	//	gaussian approximation
	SwsGauss SwsFlags = C.SWS_GAUSS
	// SwsSinc wraps SWS_SINC.
	//
	//	unwindowed sinc
	SwsSinc SwsFlags = C.SWS_SINC
	// SwsLanczos wraps SWS_LANCZOS.
	//
	//	3-tap sinc/sinc
	SwsLanczos SwsFlags = C.SWS_LANCZOS
	// SwsSpline wraps SWS_SPLINE.
	//
	//	cubic Keys spline
	SwsSpline SwsFlags = C.SWS_SPLINE
	// SwsStrict wraps SWS_STRICT.
	/*
	   Return an error on underspecified conversions. Without this flag,
	   unspecified fields are defaulted to sensible values.
	*/
	SwsStrict SwsFlags = C.SWS_STRICT
	// SwsPrintInfo wraps SWS_PRINT_INFO.
	//
	//	Emit verbose log of scaling parameters.
	SwsPrintInfo SwsFlags = C.SWS_PRINT_INFO
	// SwsFullChrHInt wraps SWS_FULL_CHR_H_INT.
	/*
	   Perform full chroma upsampling when upscaling to RGB.

	   For example, when converting 50x50 yuv420p to 100x100 rgba, setting this flag
	   will scale the chroma plane from 25x25 to 100x100 (4:4:4), and then convert
	   the 100x100 yuv444p image to rgba in the final output step.

	   Without this flag, the chroma plane is instead scaled to 50x100 (4:2:2),
	   with a single chroma sample being reused for both of the horizontally
	   adjacent RGBA output pixels.
	*/
	SwsFullChrHInt SwsFlags = C.SWS_FULL_CHR_H_INT
	// SwsFullChrHInp wraps SWS_FULL_CHR_H_INP.
	/*
	   Perform full chroma interpolation when downscaling RGB sources.

	   For example, when converting a 100x100 rgba source to 50x50 yuv444p, setting
	   this flag will generate a 100x100 (4:4:4) chroma plane, which is then
	   downscaled to the required 50x50.

	   Without this flag, the chroma plane is instead generated at 50x100 (dropping
	   every other pixel), before then being downscaled to the required 50x50
	   resolution.
	*/
	SwsFullChrHInp SwsFlags = C.SWS_FULL_CHR_H_INP
	// SwsAccurateRnd wraps SWS_ACCURATE_RND.
	/*
	   Force bit-exact output. This will prevent the use of platform-specific
	   optimizations that may lead to slight difference in rounding, in favor
	   of always maintaining exact bit output compatibility with the reference
	   C code.

	   Note: It is recommended to set both of these flags simultaneously.
	*/
	SwsAccurateRnd SwsFlags = C.SWS_ACCURATE_RND
	// SwsBitexact wraps SWS_BITEXACT.
	/*
	   Force bit-exact output. This will prevent the use of platform-specific
	   optimizations that may lead to slight difference in rounding, in favor
	   of always maintaining exact bit output compatibility with the reference
	   C code.

	   Note: It is recommended to set both of these flags simultaneously.
	*/
	SwsBitexact SwsFlags = C.SWS_BITEXACT
	// SwsDirectBgr wraps SWS_DIRECT_BGR.
	//
	//	This flag has no effect
	SwsDirectBgr SwsFlags = C.SWS_DIRECT_BGR
	// SwsErrorDiffusion wraps SWS_ERROR_DIFFUSION.
	//
	//	Set `SwsContext.dither` instead
	SwsErrorDiffusion SwsFlags = C.SWS_ERROR_DIFFUSION
)

// --- Enum SwsIntent ---

// SwsIntent wraps SwsIntent.
type SwsIntent C.SwsIntent

const SizeOfSwsIntent = C.sizeof_SwsIntent

func ToSwsIntentArray(ptr unsafe.Pointer) *Array[SwsIntent] {
	if ptr == nil {
		return nil
	}

	return &Array[SwsIntent]{
		elemSize: SizeOfSwsIntent,
		loadPtr: func(pointer unsafe.Pointer) SwsIntent {
			ptr := (*SwsIntent)(pointer)
			return *ptr
		},
		ptr: ptr,
		storePtr: func(pointer unsafe.Pointer, value SwsIntent) {
			ptr := (*SwsIntent)(pointer)
			*ptr = value
		},
	}
}

func AllocSwsIntentArray(size uint64) *Array[SwsIntent] {
	return ToSwsIntentArray(AVCalloc(size, SizeOfSwsIntent))
}

const (
	// SwsIntentPerceptual wraps SWS_INTENT_PERCEPTUAL.
	//
	//	Perceptual tone mapping
	SwsIntentPerceptual SwsIntent = C.SWS_INTENT_PERCEPTUAL
	// SwsIntentRelativeColorimetric wraps SWS_INTENT_RELATIVE_COLORIMETRIC.
	//
	//	Relative colorimetric clipping
	SwsIntentRelativeColorimetric SwsIntent = C.SWS_INTENT_RELATIVE_COLORIMETRIC
	// SwsIntentSaturation wraps SWS_INTENT_SATURATION.
	//
	//	Saturation mapping
	SwsIntentSaturation SwsIntent = C.SWS_INTENT_SATURATION
	// SwsIntentAbsoluteColorimetric wraps SWS_INTENT_ABSOLUTE_COLORIMETRIC.
	//
	//	Absolute colorimetric clipping
	SwsIntentAbsoluteColorimetric SwsIntent = C.SWS_INTENT_ABSOLUTE_COLORIMETRIC
	// SwsIntentNb wraps SWS_INTENT_NB.
	//
	//	not part of the ABI
	SwsIntentNb SwsIntent = C.SWS_INTENT_NB
)