ffmpeg

package module

Go to main page

Versions in this module

v0

v0.70.1

Apr 8, 2024

Changes in this version

+ const AVPALETTE_COUNT

+ const AVPALETTE_SIZE

+ const AV_CHANNEL_LAYOUT_RETYPE_FLAG_CANONICAL

+ const AV_CHANNEL_LAYOUT_RETYPE_FLAG_LOSSLESS

+ const AV_CH_LAYOUT_7POINT2POINT3

+ const AV_CH_LAYOUT_9POINT1POINT4_BACK

+ const AV_FRAME_SIDE_DATA_FLAG_UNIQUE

+ const AV_HWDEVICE_TYPE_D3D12VA

+ const AV_IAMF_AMBISONICS_MODE_MONO

+ const AV_IAMF_AMBISONICS_MODE_PROJECTION

+ const AV_IAMF_ANIMATION_TYPE_BEZIER

+ const AV_IAMF_ANIMATION_TYPE_LINEAR

+ const AV_IAMF_ANIMATION_TYPE_STEP

+ const AV_IAMF_AUDIO_ELEMENT_TYPE_CHANNEL

+ const AV_IAMF_AUDIO_ELEMENT_TYPE_SCENE

+ const AV_IAMF_HEADPHONES_MODE_BINAURAL

+ const AV_IAMF_HEADPHONES_MODE_STEREO

+ const AV_IAMF_LAYER_FLAG_RECON_GAIN

+ const AV_IAMF_PARAMETER_DEFINITION_DEMIXING

+ const AV_IAMF_PARAMETER_DEFINITION_MIX_GAIN

+ const AV_IAMF_PARAMETER_DEFINITION_RECON_GAIN

+ const AV_IAMF_SUBMIX_LAYOUT_TYPE_BINAURAL

+ const AV_IAMF_SUBMIX_LAYOUT_TYPE_LOUDSPEAKERS

+ const AV_OPT_TYPE_FLAG_ARRAY

+ const AV_PIX_FMT_D3D12

+ const AV_PIX_FMT_FLAG_XYZ

+ const AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT

+ const AV_PKT_DATA_IAMF_DEMIXING_INFO_PARAM

+ const AV_PKT_DATA_IAMF_MIX_GAIN_PARAM

+ const AV_PKT_DATA_IAMF_RECON_GAIN_INFO_PARAM

+ const AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT

+ const AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION

+ const AV_STREAM_GROUP_PARAMS_NONE

+ const AV_STREAM_GROUP_PARAMS_TILE_GRID

+ const AV_VIDEO_MAX_PLANES

+ func AvChannelLayoutCustomInit(channelLayout *AVChannelLayout, nbChannels int32) int32

+ func AvChannelLayoutRetype(channelLayout *AVChannelLayout, order AVChannelOrder, flags int32) int32

+ func AvFrameSideDataClone(sd ***AVFrameSideData, nbSd *int32, src *AVFrameSideData, flags uint32) int32

+ func AvFrameSideDataFree(sd ***AVFrameSideData, nbSd *int32)

+ func AvIamfAudioElementFree(audioElement **AVIAMFAudioElement)

+ func AvIamfMixPresentationFree(mixPresentation **AVIAMFMixPresentation)

+ func AvIamfParamDefinitionGetSubblock(par *AVIAMFParamDefinition, idx uint32) unsafe.Pointer

+ func AvImageFillColor(dstData []*uint8, dstLinesize []int, pixFmt AVPixelFormat, color []uint32, ...) int32

+ func AvTsMakeTimeString2(ts int64, tb AVRational) string

+ func AvformatStreamGroupAddStream(stg *AVStreamGroup, st *AVStream) int32

+ func AvformatStreamGroupName(_type AVStreamGroupParamsType) string

type AVBufferSrcParameters

+ func (bsrc *AVBufferSrcParameters) GetColorRange() AVColorRange

+ func (bsrc *AVBufferSrcParameters) GetColorRangeAddr() *AVColorRange

+ func (bsrc *AVBufferSrcParameters) GetColorSpace() AVColorSpace

+ func (bsrc *AVBufferSrcParameters) GetColorSpaceAddr() *AVColorSpace

+ func (bsrc *AVBufferSrcParameters) SetColorRange(v AVColorRange)

+ func (bsrc *AVBufferSrcParameters) SetColorSpace(v AVColorSpace)

type AVChannelLayout

+ func AV_CHANNEL_LAYOUT_7POINT2POINT3() *AVChannelLayout

+ func AV_CHANNEL_LAYOUT_9POINT1POINT4_BACK() *AVChannelLayout

type AVClass

+ func AvIamfAudioElementGetClass() *AVClass

+ func AvIamfMixPresentationGetClass() *AVClass

+ func AvIamfParamDefinitionGetClass() *AVClass

+ func AvStreamGroupGetClass() *AVClass

type AVCodecContext

+ func (avctx *AVCodecContext) GetDecodedSideData() []*AVFrameSideData

+ func (avctx *AVCodecContext) GetDecodedSideDataAddr() ***AVFrameSideData

+ func (avctx *AVCodecContext) GetNbDecodedSideData() int32

+ func (avctx *AVCodecContext) GetNbDecodedSideDataAddr() *int32

+ func (avctx *AVCodecContext) GetNbSideDataPreferPacket() uint32

+ func (avctx *AVCodecContext) GetNbSideDataPreferPacketAddr() *uint32

+ func (avctx *AVCodecContext) GetSideDataPreferPacket() []int32

+ func (avctx *AVCodecContext) GetSideDataPreferPacketAddr() **int32

+ func (avctx *AVCodecContext) SetDecodedSideData(v **AVFrameSideData)

+ func (avctx *AVCodecContext) SetNbDecodedSideData(v int32)

+ func (avctx *AVCodecContext) SetNbSideDataPreferPacket(v uint32)

+ func (avctx *AVCodecContext) SetSideDataPreferPacket(v *int32)

type AVColorRange

+ func AvBuffersinkGetColorRange(ctx *AVFilterContext) AVColorRange

type AVColorSpace

+ func AvBuffersinkGetColorspace(ctx *AVFilterContext) AVColorSpace

type AVFilmGrainParams

+ func AvFilmGrainParamsSelect(frame *AVFrame) *AVFilmGrainParams

+ func (fgp *AVFilmGrainParams) GetBitDepthChroma() int32

+ func (fgp *AVFilmGrainParams) GetBitDepthChromaAddr() *int32

+ func (fgp *AVFilmGrainParams) GetBitDepthLuma() int32

+ func (fgp *AVFilmGrainParams) GetBitDepthLumaAddr() *int32

+ func (fgp *AVFilmGrainParams) GetColorPrimaries() AVColorPrimaries

+ func (fgp *AVFilmGrainParams) GetColorPrimariesAddr() *AVColorPrimaries

+ func (fgp *AVFilmGrainParams) GetColorRange() AVColorRange

+ func (fgp *AVFilmGrainParams) GetColorRangeAddr() *AVColorRange

+ func (fgp *AVFilmGrainParams) GetColorSpace() AVColorSpace

+ func (fgp *AVFilmGrainParams) GetColorSpaceAddr() *AVColorSpace

+ func (fgp *AVFilmGrainParams) GetColorTrc() AVColorTransferCharacteristic

+ func (fgp *AVFilmGrainParams) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (fgp *AVFilmGrainParams) GetHeight() int32

+ func (fgp *AVFilmGrainParams) GetHeightAddr() *int32

+ func (fgp *AVFilmGrainParams) GetSubsamplingX() int32

+ func (fgp *AVFilmGrainParams) GetSubsamplingXAddr() *int32

+ func (fgp *AVFilmGrainParams) GetSubsamplingY() int32

+ func (fgp *AVFilmGrainParams) GetSubsamplingYAddr() *int32

+ func (fgp *AVFilmGrainParams) GetWidth() int32

+ func (fgp *AVFilmGrainParams) GetWidthAddr() *int32

+ func (fgp *AVFilmGrainParams) SetBitDepthChroma(v int32)

+ func (fgp *AVFilmGrainParams) SetBitDepthLuma(v int32)

+ func (fgp *AVFilmGrainParams) SetColorPrimaries(v AVColorPrimaries)

+ func (fgp *AVFilmGrainParams) SetColorRange(v AVColorRange)

+ func (fgp *AVFilmGrainParams) SetColorSpace(v AVColorSpace)

+ func (fgp *AVFilmGrainParams) SetColorTrc(v AVColorTransferCharacteristic)

+ func (fgp *AVFilmGrainParams) SetHeight(v int32)

+ func (fgp *AVFilmGrainParams) SetSubsamplingX(v int32)

+ func (fgp *AVFilmGrainParams) SetSubsamplingY(v int32)

+ func (fgp *AVFilmGrainParams) SetWidth(v int32)

type AVFilterLink

+ func (fltl *AVFilterLink) GetColorRange() AVColorRange

+ func (fltl *AVFilterLink) GetColorRangeAddr() *AVColorRange

+ func (fltl *AVFilterLink) GetColorspace() AVColorSpace

+ func (fltl *AVFilterLink) GetColorspaceAddr() *AVColorSpace

+ func (fltl *AVFilterLink) SetColorRange(v AVColorRange)

+ func (fltl *AVFilterLink) SetColorspace(v AVColorSpace)

type AVFormatContext

+ func (s *AVFormatContext) GetNbStreamGroups() uint32

+ func (s *AVFormatContext) GetNbStreamGroupsAddr() *uint32

+ func (s *AVFormatContext) GetStreamGroups() (v []*AVStreamGroup)

+ func (s *AVFormatContext) GetStreamGroupsAddr() ***AVStreamGroup

+ func (s *AVFormatContext) SetNbStreamGroups(v uint32)

+ func (s *AVFormatContext) SetStreamGroups(v **AVStreamGroup)

type AVFrameSideData

+ func AvFrameSideDataGet(sd **AVFrameSideData, nbSd int32, _type AVFrameSideDataType) *AVFrameSideData

+ func AvFrameSideDataGetC(sd **AVFrameSideData, nbSd int32, _type AVFrameSideDataType) *AVFrameSideData

+ func AvFrameSideDataNew(sd ***AVFrameSideData, nbSd *int32, _type AVFrameSideDataType, size uintptr, ...) *AVFrameSideData

+ type AVIAMFAmbisonicsMode = C.enum_AVIAMFAmbisonicsMode

+ type AVIAMFAnimationType = C.enum_AVIAMFAnimationType

+ type AVIAMFAudioElement C.struct_AVIAMFAudioElement

+ func AvIamfAudioElementAlloc() *AVIAMFAudioElement

+ func (aelm *AVIAMFAudioElement) GetAudioElementType() AVIAMFAudioElementType

+ func (aelm *AVIAMFAudioElement) GetAudioElementTypeAddr() *AVIAMFAudioElementType

+ func (aelm *AVIAMFAudioElement) GetAvClass() *AVClass

+ func (aelm *AVIAMFAudioElement) GetAvClassAddr() **AVClass

+ func (aelm *AVIAMFAudioElement) GetDefaultW() uint32

+ func (aelm *AVIAMFAudioElement) GetDefaultWAddr() *uint32

+ func (aelm *AVIAMFAudioElement) GetDemixingInfo() *AVIAMFParamDefinition

+ func (aelm *AVIAMFAudioElement) GetDemixingInfoAddr() **AVIAMFParamDefinition

+ func (aelm *AVIAMFAudioElement) GetLayers() []*AVIAMFLayer

+ func (aelm *AVIAMFAudioElement) GetLayersAddr() ***AVIAMFLayer

+ func (aelm *AVIAMFAudioElement) GetNbLayers() uint32

+ func (aelm *AVIAMFAudioElement) GetNbLayersAddr() *uint32

+ func (aelm *AVIAMFAudioElement) GetReconGainInfo() *AVIAMFParamDefinition

+ func (aelm *AVIAMFAudioElement) GetReconGainInfoAddr() **AVIAMFParamDefinition

+ func (aelm *AVIAMFAudioElement) SetAudioElementType(v AVIAMFAudioElementType)

+ func (aelm *AVIAMFAudioElement) SetAvClass(v *AVClass)

+ func (aelm *AVIAMFAudioElement) SetDefaultW(v uint32)

+ func (aelm *AVIAMFAudioElement) SetDemixingInfo(v *AVIAMFParamDefinition)

+ func (aelm *AVIAMFAudioElement) SetLayers(v **AVIAMFLayer)

+ func (aelm *AVIAMFAudioElement) SetNbLayers(v uint32)

+ func (aelm *AVIAMFAudioElement) SetReconGainInfo(v *AVIAMFParamDefinition)

+ type AVIAMFAudioElementType = C.enum_AVIAMFAudioElementType

+ type AVIAMFDemixingInfo C.struct_AVIAMFDemixingInfo

+ func (dmif *AVIAMFDemixingInfo) DmixpModeGet() uint32

+ func (dmif *AVIAMFDemixingInfo) GetAvClass() *AVClass

+ func (dmif *AVIAMFDemixingInfo) GetAvClassAddr() **AVClass

+ func (dmif *AVIAMFDemixingInfo) GetDmixpModeAddr() *uint32

+ func (dmif *AVIAMFDemixingInfo) GetSubblockDurationAddr() *uint32

+ func (dmif *AVIAMFDemixingInfo) SetAvClass(v *AVClass)

+ func (dmif *AVIAMFDemixingInfo) SetDmixpMode(v uint32)

+ func (dmif *AVIAMFDemixingInfo) SetSubblockDuration(v uint32)

+ func (dmif *AVIAMFDemixingInfo) SubblockDurationGet() uint32

+ type AVIAMFHeadphonesMode = C.enum_AVIAMFHeadphonesMode

+ type AVIAMFLayer C.struct_AVIAMFLayer

+ func AvIamfAudioElementAddLayer(audioElement *AVIAMFAudioElement) *AVIAMFLayer

+ func (layer *AVIAMFLayer) GetAmbisonicsMode() AVIAMFAmbisonicsMode

+ func (layer *AVIAMFLayer) GetAmbisonicsModeAddr() *AVIAMFAmbisonicsMode

+ func (layer *AVIAMFLayer) GetAvClass() *AVClass

+ func (layer *AVIAMFLayer) GetAvClassAddr() **AVClass

+ func (layer *AVIAMFLayer) GetChLayout() AVChannelLayout

+ func (layer *AVIAMFLayer) GetChLayoutAddr() *AVChannelLayout

+ func (layer *AVIAMFLayer) GetDemixingMatrix() *AVRational

+ func (layer *AVIAMFLayer) GetDemixingMatrixAddr() **AVRational

+ func (layer *AVIAMFLayer) GetFlags() uint32

+ func (layer *AVIAMFLayer) GetFlagsAddr() *uint32

+ func (layer *AVIAMFLayer) GetOutputGain() AVRational

+ func (layer *AVIAMFLayer) GetOutputGainAddr() *AVRational

+ func (layer *AVIAMFLayer) GetOutputGainFlags() uint32

+ func (layer *AVIAMFLayer) GetOutputGainFlagsAddr() *uint32

+ func (layer *AVIAMFLayer) SetAmbisonicsMode(v AVIAMFAmbisonicsMode)

+ func (layer *AVIAMFLayer) SetAvClass(v *AVClass)

+ func (layer *AVIAMFLayer) SetChLayout(v AVChannelLayout)

+ func (layer *AVIAMFLayer) SetDemixingMatrix(v *AVRational)

+ func (layer *AVIAMFLayer) SetFlags(v uint32)

+ func (layer *AVIAMFLayer) SetOutputGain(v AVRational)

+ func (layer *AVIAMFLayer) SetOutputGainFlags(v uint32)

+ type AVIAMFMixGain C.struct_AVIAMFMixGain

+ func (mxga *AVIAMFMixGain) GetAnimationType() AVIAMFAnimationType

+ func (mxga *AVIAMFMixGain) GetAnimationTypeAddr() *AVIAMFAnimationType

+ func (mxga *AVIAMFMixGain) GetAvClass() *AVClass

+ func (mxga *AVIAMFMixGain) GetAvClassAddr() **AVClass

+ func (mxga *AVIAMFMixGain) GetControlPointRelativeTime() AVRational

+ func (mxga *AVIAMFMixGain) GetControlPointRelativeTimeAddr() *AVRational

+ func (mxga *AVIAMFMixGain) GetControlPointValue() AVRational

+ func (mxga *AVIAMFMixGain) GetControlPointValueAddr() *AVRational

+ func (mxga *AVIAMFMixGain) GetEndPointValue() AVRational

+ func (mxga *AVIAMFMixGain) GetEndPointValueAddr() *AVRational

+ func (mxga *AVIAMFMixGain) GetStartPointValue() AVRational

+ func (mxga *AVIAMFMixGain) GetStartPointValueAddr() *AVRational

+ func (mxga *AVIAMFMixGain) GetSubblockDuration() uint32

+ func (mxga *AVIAMFMixGain) GetSubblockDurationAddr() *uint32

+ func (mxga *AVIAMFMixGain) SetAnimationType(v AVIAMFAnimationType)

+ func (mxga *AVIAMFMixGain) SetAvClass(v *AVClass)

+ func (mxga *AVIAMFMixGain) SetControlPointRelativeTime(v AVRational)

+ func (mxga *AVIAMFMixGain) SetControlPointValue(v AVRational)

+ func (mxga *AVIAMFMixGain) SetEndPointValue(v AVRational)

+ func (mxga *AVIAMFMixGain) SetStartPointValue(v AVRational)

+ func (mxga *AVIAMFMixGain) SetSubblockDuration(v uint32)

+ type AVIAMFMixPresentation C.struct_AVIAMFMixPresentation

+ func AvIamfMixPresentationAlloc() *AVIAMFMixPresentation

+ func (mpst *AVIAMFMixPresentation) GetAnnotations() *AVDictionary

+ func (mpst *AVIAMFMixPresentation) GetAnnotationsAddr() **AVDictionary

+ func (mpst *AVIAMFMixPresentation) GetAvClass() *AVClass

+ func (mpst *AVIAMFMixPresentation) GetAvClassAddr() **AVClass

+ func (mpst *AVIAMFMixPresentation) GetNbSubmixes() uint32

+ func (mpst *AVIAMFMixPresentation) GetNbSubmixesAddr() *uint32

+ func (mpst *AVIAMFMixPresentation) GetSubmixes() []*AVIAMFSubmix

+ func (mpst *AVIAMFMixPresentation) GetSubmixesAddr() ***AVIAMFSubmix

+ func (mpst *AVIAMFMixPresentation) SetAnnotations(v *AVDictionary)

+ func (mpst *AVIAMFMixPresentation) SetAvClass(v *AVClass)

+ func (mpst *AVIAMFMixPresentation) SetNbSubmixes(v uint32)

+ func (mpst *AVIAMFMixPresentation) SetSubmixes(v **AVIAMFSubmix)

+ type AVIAMFParamDefinition C.struct_AVIAMFParamDefinition

+ func AvIamfParamDefinitionAlloc(_type AVIAMFParamDefinitionType, nbSubblocks uint32, size *uintptr) *AVIAMFParamDefinition

+ func (pdef *AVIAMFParamDefinition) ConstantSubblockDurationGet() uint32

+ func (pdef *AVIAMFParamDefinition) DurationGet() uint32

+ func (pdef *AVIAMFParamDefinition) GetAvClass() *AVClass

+ func (pdef *AVIAMFParamDefinition) GetAvClassAddr() **AVClass

+ func (pdef *AVIAMFParamDefinition) GetConstantSubblockDurationAddr() *uint32

+ func (pdef *AVIAMFParamDefinition) GetDurationAddr() *uint32

+ func (pdef *AVIAMFParamDefinition) GetNbSubblocksAddr() *uint32

+ func (pdef *AVIAMFParamDefinition) GetParameterIdAddr() *uint32

+ func (pdef *AVIAMFParamDefinition) GetParameterRateAddr() *uint32

+ func (pdef *AVIAMFParamDefinition) GetSubblockSizeAddr() *uintptr

+ func (pdef *AVIAMFParamDefinition) GetSubblocksOffsetAddr() *uintptr

+ func (pdef *AVIAMFParamDefinition) GetTypeAddr() *AVIAMFParamDefinitionType

+ func (pdef *AVIAMFParamDefinition) NbSubblocksGet() uint32

+ func (pdef *AVIAMFParamDefinition) ParameterIdGet() uint32

+ func (pdef *AVIAMFParamDefinition) ParameterRateGet() uint32

+ func (pdef *AVIAMFParamDefinition) SetAvClass(v *AVClass)

+ func (pdef *AVIAMFParamDefinition) SetConstantSubblockDuration(v uint32)

+ func (pdef *AVIAMFParamDefinition) SetDuration(v uint32)

+ func (pdef *AVIAMFParamDefinition) SetNbSubblocks(v uint32)

+ func (pdef *AVIAMFParamDefinition) SetParameterId(v uint32)

+ func (pdef *AVIAMFParamDefinition) SetParameterRate(v uint32)

+ func (pdef *AVIAMFParamDefinition) SetSubblockSize(v uintptr)

+ func (pdef *AVIAMFParamDefinition) SetSubblocksOffset(v uintptr)

+ func (pdef *AVIAMFParamDefinition) SetType(v AVIAMFParamDefinitionType)

+ func (pdef *AVIAMFParamDefinition) SubblockSizeGet() uintptr

+ func (pdef *AVIAMFParamDefinition) SubblocksOffsetGet() uintptr

+ func (pdef *AVIAMFParamDefinition) TypeGet() AVIAMFParamDefinitionType

+ type AVIAMFParamDefinitionType = C.enum_AVIAMFParamDefinitionType

+ type AVIAMFReconGain C.struct_AVIAMFReconGain

+ func (rcgn *AVIAMFReconGain) GetAvClass() *AVClass

+ func (rcgn *AVIAMFReconGain) GetAvClassAddr() **AVClass

+ func (rcgn *AVIAMFReconGain) GetReconGain() (v [][]uint8)

+ func (rcgn *AVIAMFReconGain) GetReconGainAddr() **uint8

+ func (rcgn *AVIAMFReconGain) GetSubblockDuration() uint32

+ func (rcgn *AVIAMFReconGain) GetSubblockDurationAddr() *uint32

+ func (rcgn *AVIAMFReconGain) SetAvClass(v *AVClass)

+ func (rcgn *AVIAMFReconGain) SetReconGain(v [][]uint8)

+ func (rcgn *AVIAMFReconGain) SetSubblockDuration(v uint32)

+ type AVIAMFSubmix C.struct_AVIAMFSubmix

+ func AvIamfMixPresentationAddSubmix(mixPresentation *AVIAMFMixPresentation) *AVIAMFSubmix

+ func (smix *AVIAMFSubmix) GetAvClass() *AVClass

+ func (smix *AVIAMFSubmix) GetAvClassAddr() **AVClass

+ func (smix *AVIAMFSubmix) GetDefaultMixGain() AVRational

+ func (smix *AVIAMFSubmix) GetDefaultMixGainAddr() *AVRational

+ func (smix *AVIAMFSubmix) GetElements() []*AVIAMFSubmixElement

+ func (smix *AVIAMFSubmix) GetElementsAddr() ***AVIAMFSubmixElement

+ func (smix *AVIAMFSubmix) GetLayouts() []*AVIAMFSubmixLayout

+ func (smix *AVIAMFSubmix) GetLayoutsAddr() ***AVIAMFSubmixLayout

+ func (smix *AVIAMFSubmix) GetNbElements() uint32

+ func (smix *AVIAMFSubmix) GetNbElementsAddr() *uint32

+ func (smix *AVIAMFSubmix) GetNbLayouts() uint32

+ func (smix *AVIAMFSubmix) GetNbLayoutsAddr() *uint32

+ func (smix *AVIAMFSubmix) GetOutputMixConfig() *AVIAMFParamDefinition

+ func (smix *AVIAMFSubmix) GetOutputMixConfigAddr() **AVIAMFParamDefinition

+ func (smix *AVIAMFSubmix) SetAvClass(v *AVClass)

+ func (smix *AVIAMFSubmix) SetDefaultMixGain(v AVRational)

+ func (smix *AVIAMFSubmix) SetElements(v **AVIAMFSubmixElement)

+ func (smix *AVIAMFSubmix) SetLayouts(v **AVIAMFSubmixLayout)

+ func (smix *AVIAMFSubmix) SetNbElements(v uint32)

+ func (smix *AVIAMFSubmix) SetNbLayouts(v uint32)

+ func (smix *AVIAMFSubmix) SetOutputMixConfig(v *AVIAMFParamDefinition)

+ type AVIAMFSubmixElement C.struct_AVIAMFSubmixElement

+ func AvIamfSubmixAddElement(submix *AVIAMFSubmix) *AVIAMFSubmixElement

+ func (smel *AVIAMFSubmixElement) GetAnnotations() *AVDictionary

+ func (smel *AVIAMFSubmixElement) GetAnnotationsAddr() **AVDictionary

+ func (smel *AVIAMFSubmixElement) GetAudioElementId() uint32

+ func (smel *AVIAMFSubmixElement) GetAudioElementIdAddr() *uint32

+ func (smel *AVIAMFSubmixElement) GetAvClass() *AVClass

+ func (smel *AVIAMFSubmixElement) GetAvClassAddr() **AVClass

+ func (smel *AVIAMFSubmixElement) GetDefaultMixGain() AVRational

+ func (smel *AVIAMFSubmixElement) GetDefaultMixGainAddr() *AVRational

+ func (smel *AVIAMFSubmixElement) GetElementMixConfig() *AVIAMFParamDefinition

+ func (smel *AVIAMFSubmixElement) GetElementMixConfigAddr() **AVIAMFParamDefinition

+ func (smel *AVIAMFSubmixElement) GetHeadphonesRenderingMode() AVIAMFHeadphonesMode

+ func (smel *AVIAMFSubmixElement) GetHeadphonesRenderingModeAddr() *AVIAMFHeadphonesMode

+ func (smel *AVIAMFSubmixElement) SetAnnotations(v *AVDictionary)

+ func (smel *AVIAMFSubmixElement) SetAudioElementId(v uint32)

+ func (smel *AVIAMFSubmixElement) SetAvClass(v *AVClass)

+ func (smel *AVIAMFSubmixElement) SetDefaultMixGain(v AVRational)

+ func (smel *AVIAMFSubmixElement) SetElementMixConfig(v *AVIAMFParamDefinition)

+ func (smel *AVIAMFSubmixElement) SetHeadphonesRenderingMode(v AVIAMFHeadphonesMode)

+ type AVIAMFSubmixLayout C.struct_AVIAMFSubmixLayout

+ func AvIamfSubmixAddLayout(submix *AVIAMFSubmix) *AVIAMFSubmixLayout

+ func (smlo *AVIAMFSubmixLayout) GetAlbumAnchoredLoudness() AVRational

+ func (smlo *AVIAMFSubmixLayout) GetAlbumAnchoredLoudnessAddr() *AVRational

+ func (smlo *AVIAMFSubmixLayout) GetAvClass() *AVClass

+ func (smlo *AVIAMFSubmixLayout) GetAvClassAddr() **AVClass

+ func (smlo *AVIAMFSubmixLayout) GetDialogueAnchoredLoudness() AVRational

+ func (smlo *AVIAMFSubmixLayout) GetDialogueAnchoredLoudnessAddr() *AVRational

+ func (smlo *AVIAMFSubmixLayout) GetDigitalPeak() AVRational

+ func (smlo *AVIAMFSubmixLayout) GetDigitalPeakAddr() *AVRational

+ func (smlo *AVIAMFSubmixLayout) GetIntegratedLoudness() AVRational

+ func (smlo *AVIAMFSubmixLayout) GetIntegratedLoudnessAddr() *AVRational

+ func (smlo *AVIAMFSubmixLayout) GetLayoutType() AVIAMFSubmixLayoutType

+ func (smlo *AVIAMFSubmixLayout) GetLayoutTypeAddr() *AVIAMFSubmixLayoutType

+ func (smlo *AVIAMFSubmixLayout) GetSoundSystem() AVChannelLayout

+ func (smlo *AVIAMFSubmixLayout) GetSoundSystemAddr() *AVChannelLayout

+ func (smlo *AVIAMFSubmixLayout) GetTruePeak() AVRational

+ func (smlo *AVIAMFSubmixLayout) GetTruePeakAddr() *AVRational

+ func (smlo *AVIAMFSubmixLayout) SetAlbumAnchoredLoudness(v AVRational)

+ func (smlo *AVIAMFSubmixLayout) SetAvClass(v *AVClass)

+ func (smlo *AVIAMFSubmixLayout) SetDialogueAnchoredLoudness(v AVRational)

+ func (smlo *AVIAMFSubmixLayout) SetDigitalPeak(v AVRational)

+ func (smlo *AVIAMFSubmixLayout) SetIntegratedLoudness(v AVRational)

+ func (smlo *AVIAMFSubmixLayout) SetLayoutType(v AVIAMFSubmixLayoutType)

+ func (smlo *AVIAMFSubmixLayout) SetSoundSystem(v AVChannelLayout)

+ func (smlo *AVIAMFSubmixLayout) SetTruePeak(v AVRational)

+ type AVIAMFSubmixLayoutType = C.enum_AVIAMFSubmixLayoutType

+ type AVOptionArrayDef C.struct_AVOptionArrayDef

+ func (oadf *AVOptionArrayDef) GetDef() string

+ func (oadf *AVOptionArrayDef) GetSep() string

+ func (oadf *AVOptionArrayDef) GetSizeMax() uint32

+ func (oadf *AVOptionArrayDef) GetSizeMaxAddr() *uint32

+ func (oadf *AVOptionArrayDef) GetSizeMin() uint32

+ func (oadf *AVOptionArrayDef) GetSizeMinAddr() *uint32

+ func (oadf *AVOptionArrayDef) SetSep(v string)

+ func (oadf *AVOptionArrayDef) SetSizeMax(v uint32)

+ func (oadf *AVOptionArrayDef) SetSizeMin(v uint32)

+ type AVStreamGroup C.struct_AVStreamGroup

+ func AvformatStreamGroupCreate(s *AVFormatContext, _type AVStreamGroupParamsType, options **AVDictionary) *AVStreamGroup

+ func (sg *AVStreamGroup) GetAvClass() *AVClass

+ func (sg *AVStreamGroup) GetAvClassAddr() **AVClass

+ func (sg *AVStreamGroup) GetDisposition() int32

+ func (sg *AVStreamGroup) GetDispositionAddr() *int32

+ func (sg *AVStreamGroup) GetId() int64

+ func (sg *AVStreamGroup) GetIdAddr() *int64

+ func (sg *AVStreamGroup) GetIndex() uint32

+ func (sg *AVStreamGroup) GetIndexAddr() *uint32

+ func (sg *AVStreamGroup) GetMetadata() *AVDictionary

+ func (sg *AVStreamGroup) GetMetadataAddr() **AVDictionary

+ func (sg *AVStreamGroup) GetNbStreams() uint32

+ func (sg *AVStreamGroup) GetNbStreamsAddr() *uint32

+ func (sg *AVStreamGroup) GetParamsIamfAudioElement() *AVIAMFAudioElement

+ func (sg *AVStreamGroup) GetParamsIamfAudioElementAddr() **AVIAMFAudioElement

+ func (sg *AVStreamGroup) GetParamsIamfMixPresentation() *AVIAMFMixPresentation

+ func (sg *AVStreamGroup) GetParamsIamfMixPresentationAddr() **AVIAMFMixPresentation

+ func (sg *AVStreamGroup) GetParamsTileGrid() *AVStreamGroupTileGrid

+ func (sg *AVStreamGroup) GetParamsTileGridAddr() **AVStreamGroupTileGrid

+ func (sg *AVStreamGroup) GetPrivData() unsafe.Pointer

+ func (sg *AVStreamGroup) GetPrivDataAddr() *unsafe.Pointer

+ func (sg *AVStreamGroup) GetStreams() []*AVStream

+ func (sg *AVStreamGroup) GetStreamsAddr() ***AVStream

+ func (sg *AVStreamGroup) GetType() AVStreamGroupParamsType

+ func (sg *AVStreamGroup) GetTypeAddr() *AVStreamGroupParamsType

+ func (sg *AVStreamGroup) SetAvClass(v *AVClass)

+ func (sg *AVStreamGroup) SetDisposition(v int32)

+ func (sg *AVStreamGroup) SetId(v int64)

+ func (sg *AVStreamGroup) SetIndex(v uint32)

+ func (sg *AVStreamGroup) SetMetadata(v *AVDictionary)

+ func (sg *AVStreamGroup) SetNbStreams(v uint32)

+ func (sg *AVStreamGroup) SetParamsIamfAudioElement(v *AVIAMFAudioElement)

+ func (sg *AVStreamGroup) SetParamsIamfMixPresentation(v *AVIAMFMixPresentation)

+ func (sg *AVStreamGroup) SetParamsTileGrid(v *AVStreamGroupTileGrid)

+ func (sg *AVStreamGroup) SetPrivData(v unsafe.Pointer)

+ func (sg *AVStreamGroup) SetStreams(v **AVStream)

+ func (sg *AVStreamGroup) SetType(v AVStreamGroupParamsType)

+ type AVStreamGroupParamsType = C.enum_AVStreamGroupParamsType

+ type AVStreamGroupTileGrid C.struct_AVStreamGroupTileGrid

+ func (sgtg *AVStreamGroupTileGrid) GetAvClass() *AVClass

+ func (sgtg *AVStreamGroupTileGrid) GetAvClassAddr() **AVClass

+ func (sgtg *AVStreamGroupTileGrid) GetBackground() []uint8

+ func (sgtg *AVStreamGroupTileGrid) GetBackgroundAddr() **uint8

+ func (sgtg *AVStreamGroupTileGrid) GetCodedHeight() int32

+ func (sgtg *AVStreamGroupTileGrid) GetCodedHeightAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) GetCodedWidth() int32

+ func (sgtg *AVStreamGroupTileGrid) GetCodedWidthAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) GetHeight() int32

+ func (sgtg *AVStreamGroupTileGrid) GetHeightAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) GetHorizontalOffset() int32

+ func (sgtg *AVStreamGroupTileGrid) GetHorizontalOffsetAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) GetNbTiles() uint32

+ func (sgtg *AVStreamGroupTileGrid) GetNbTilesAddr() *uint32

+ func (sgtg *AVStreamGroupTileGrid) GetOffset() (v []struct{ ... })

+ func (sgtg *AVStreamGroupTileGrid) GetVerticalOffset() int32

+ func (sgtg *AVStreamGroupTileGrid) GetVerticalOffsetAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) GetWidth() int32

+ func (sgtg *AVStreamGroupTileGrid) GetWidthAddr() *int32

+ func (sgtg *AVStreamGroupTileGrid) SetAvClass(v *AVClass)

+ func (sgtg *AVStreamGroupTileGrid) SetBackground(v []uint8)

+ func (sgtg *AVStreamGroupTileGrid) SetCodedHeight(v int32)

+ func (sgtg *AVStreamGroupTileGrid) SetCodedWidth(v int32)

+ func (sgtg *AVStreamGroupTileGrid) SetHeight(v int32)

+ func (sgtg *AVStreamGroupTileGrid) SetHorizontalOffset(v int32)

+ func (sgtg *AVStreamGroupTileGrid) SetNbTiles(v uint32)

+ func (sgtg *AVStreamGroupTileGrid) SetOffsets(v unsafe.Pointer)

+ func (sgtg *AVStreamGroupTileGrid) SetVerticalOffset(v int32)

+ func (sgtg *AVStreamGroupTileGrid) SetWidth(v int32)

v0.61.1

Nov 18, 2023

v0.61.0

Nov 18, 2023

Changes in this version

+ const AVFILTER_FLAG_HWDEVICE

+ const AV_CH_LAYOUT_3POINT1POINT2

+ const AV_CH_LAYOUT_5POINT1POINT2_BACK

+ const AV_CH_LAYOUT_5POINT1POINT4_BACK

+ const AV_CH_LAYOUT_7POINT1POINT2

+ const AV_CH_LAYOUT_7POINT1POINT4_BACK

+ const AV_CODEC_ID_AC4

+ const AV_CODEC_ID_APAC

+ const AV_CODEC_ID_BONK

+ const AV_CODEC_ID_EVC

+ const AV_CODEC_ID_FTR

+ const AV_CODEC_ID_MEDIA100

+ const AV_CODEC_ID_MISC4

+ const AV_CODEC_ID_OSQ

+ const AV_CODEC_ID_PDV

+ const AV_CODEC_ID_RADIANCE_HDR

+ const AV_CODEC_ID_RKA

+ const AV_CODEC_ID_RTV1

+ const AV_CODEC_ID_VMIX

+ const AV_CODEC_ID_VQC

+ const AV_CODEC_ID_WAVARC

+ const AV_CODEC_ID_WBMP

+ const AV_CODEC_PROP_FIELDS

+ const AV_FRAME_FLAG_INTERLACED

+ const AV_FRAME_FLAG_KEY

+ const AV_FRAME_FLAG_TOP_FIELD_FIRST

+ const AV_HDR_PLUS_MAX_PAYLOAD_SIZE

+ const AV_LEVEL_UNKNOWN

+ const AV_PIX_FMT_GBRAP14BE

+ const AV_PIX_FMT_GBRAP14LE

+ const AV_PIX_FMT_P212BE

+ const AV_PIX_FMT_P212LE

+ const AV_PIX_FMT_P412BE

+ const AV_PIX_FMT_P412LE

+ const AV_PROFILE_AAC_ELD

+ const AV_PROFILE_AAC_HE

+ const AV_PROFILE_AAC_HE_V2

+ const AV_PROFILE_AAC_LD

+ const AV_PROFILE_AAC_LOW

+ const AV_PROFILE_AAC_LTP

+ const AV_PROFILE_AAC_MAIN

+ const AV_PROFILE_AAC_SSR

+ const AV_PROFILE_ARIB_PROFILE_A

+ const AV_PROFILE_ARIB_PROFILE_C

+ const AV_PROFILE_AV1_HIGH

+ const AV_PROFILE_AV1_MAIN

+ const AV_PROFILE_AV1_PROFESSIONAL

+ const AV_PROFILE_DNXHD

+ const AV_PROFILE_DNXHR_444

+ const AV_PROFILE_DNXHR_HQ

+ const AV_PROFILE_DNXHR_HQX

+ const AV_PROFILE_DNXHR_LB

+ const AV_PROFILE_DNXHR_SQ

+ const AV_PROFILE_DTS

+ const AV_PROFILE_DTS_96_24

+ const AV_PROFILE_DTS_ES

+ const AV_PROFILE_DTS_EXPRESS

+ const AV_PROFILE_DTS_HD_HRA

+ const AV_PROFILE_DTS_HD_MA

+ const AV_PROFILE_DTS_HD_MA_X

+ const AV_PROFILE_DTS_HD_MA_X_IMAX

+ const AV_PROFILE_EAC3_DDP_ATMOS

+ const AV_PROFILE_EVC_BASELINE

+ const AV_PROFILE_EVC_MAIN

+ const AV_PROFILE_H264_BASELINE

+ const AV_PROFILE_H264_CAVLC_444

+ const AV_PROFILE_H264_CONSTRAINED

+ const AV_PROFILE_H264_CONSTRAINED_BASELINE

+ const AV_PROFILE_H264_EXTENDED

+ const AV_PROFILE_H264_HIGH

+ const AV_PROFILE_H264_HIGH_10

+ const AV_PROFILE_H264_HIGH_10_INTRA

+ const AV_PROFILE_H264_HIGH_422

+ const AV_PROFILE_H264_HIGH_422_INTRA

+ const AV_PROFILE_H264_HIGH_444

+ const AV_PROFILE_H264_HIGH_444_INTRA

+ const AV_PROFILE_H264_HIGH_444_PREDICTIVE

+ const AV_PROFILE_H264_INTRA

+ const AV_PROFILE_H264_MAIN

+ const AV_PROFILE_H264_MULTIVIEW_HIGH

+ const AV_PROFILE_H264_STEREO_HIGH

+ const AV_PROFILE_HEVC_MAIN

+ const AV_PROFILE_HEVC_MAIN_10

+ const AV_PROFILE_HEVC_MAIN_STILL_PICTURE

+ const AV_PROFILE_HEVC_REXT

+ const AV_PROFILE_HEVC_SCC

+ const AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION

+ const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0

+ const AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1

+ const AV_PROFILE_JPEG2000_DCINEMA_2K

+ const AV_PROFILE_JPEG2000_DCINEMA_4K

+ const AV_PROFILE_KLVA_ASYNC

+ const AV_PROFILE_KLVA_SYNC

+ const AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT

+ const AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT

+ const AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS

+ const AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT

+ const AV_PROFILE_MJPEG_JPEG_LS

+ const AV_PROFILE_MPEG2_422

+ const AV_PROFILE_MPEG2_AAC_HE

+ const AV_PROFILE_MPEG2_AAC_LOW

+ const AV_PROFILE_MPEG2_HIGH

+ const AV_PROFILE_MPEG2_MAIN

+ const AV_PROFILE_MPEG2_SIMPLE

+ const AV_PROFILE_MPEG2_SNR_SCALABLE

+ const AV_PROFILE_MPEG2_SS

+ const AV_PROFILE_MPEG4_ADVANCED_CODING

+ const AV_PROFILE_MPEG4_ADVANCED_CORE

+ const AV_PROFILE_MPEG4_ADVANCED_REAL_TIME

+ const AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE

+ const AV_PROFILE_MPEG4_ADVANCED_SIMPLE

+ const AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE

+ const AV_PROFILE_MPEG4_CORE

+ const AV_PROFILE_MPEG4_CORE_SCALABLE

+ const AV_PROFILE_MPEG4_HYBRID

+ const AV_PROFILE_MPEG4_MAIN

+ const AV_PROFILE_MPEG4_N_BIT

+ const AV_PROFILE_MPEG4_SCALABLE_TEXTURE

+ const AV_PROFILE_MPEG4_SIMPLE

+ const AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION

+ const AV_PROFILE_MPEG4_SIMPLE_SCALABLE

+ const AV_PROFILE_MPEG4_SIMPLE_STUDIO

+ const AV_PROFILE_PRORES_4444

+ const AV_PROFILE_PRORES_HQ

+ const AV_PROFILE_PRORES_LT

+ const AV_PROFILE_PRORES_PROXY

+ const AV_PROFILE_PRORES_STANDARD

+ const AV_PROFILE_PRORES_XQ

+ const AV_PROFILE_RESERVED

+ const AV_PROFILE_SBC_MSBC

+ const AV_PROFILE_TRUEHD_ATMOS

+ const AV_PROFILE_UNKNOWN

+ const AV_PROFILE_VC1_ADVANCED

+ const AV_PROFILE_VC1_COMPLEX

+ const AV_PROFILE_VC1_MAIN

+ const AV_PROFILE_VC1_SIMPLE

+ const AV_PROFILE_VP9_0

+ const AV_PROFILE_VP9_1

+ const AV_PROFILE_VP9_2

+ const AV_PROFILE_VP9_3

+ const AV_PROFILE_VVC_MAIN_10

+ const AV_PROFILE_VVC_MAIN_10_444

+ const AV_TX_REAL_TO_IMAGINARY

+ const AV_TX_REAL_TO_REAL

+ const AV_VIDEO_HINT_TYPE_CHANGED

+ const AV_VIDEO_HINT_TYPE_CONSTANT

+ const FF_PROFILE_DTS_HD_MA_X

+ const FF_PROFILE_DTS_HD_MA_X_IMAX

+ const FF_PROFILE_EAC3_DDP_ATMOS

+ const FF_PROFILE_EVC_BASELINE

+ const FF_PROFILE_EVC_MAIN

+ const FF_PROFILE_HEVC_SCC

+ const FF_PROFILE_TRUEHD_ATMOS

+ func AvBesselI0(x float64) float64

+ func AvDynamicHdrPlusFromT35(s *AVDynamicHDRPlus, data *uint8, size uintptr) int32

+ func AvDynamicHdrPlusToT35(s *AVDynamicHDRPlus, data **uint8, size *uintptr) int32

+ func AvExecutorExecute(e *AVExecutor, t *AVTask)

+ func AvExecutorFree(e **AVExecutor)

+ func AvFrameReplace(dst, src *AVFrame) int32

+ func AvImageCopy2(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLinesizes []int32, ...)

+ func AvPacketSideDataFree(sd **AVPacketSideData, nbSd *int32)

+ func AvPacketSideDataName(_type AVPacketSideDataType) string

+ func AvPacketSideDataRemove(sd *AVPacketSideData, nbSd *int32, _type AVPacketSideDataType)

+ func AvRandomBytes[T Integer](buf *uint8, len T) int32

type AVChannelLayout

+ func AV_CHANNEL_LAYOUT_3POINT1POINT2() *AVChannelLayout

+ func AV_CHANNEL_LAYOUT_5POINT1POINT2_BACK() *AVChannelLayout

+ func AV_CHANNEL_LAYOUT_5POINT1POINT4_BACK() *AVChannelLayout

+ func AV_CHANNEL_LAYOUT_7POINT1POINT2() *AVChannelLayout

+ func AV_CHANNEL_LAYOUT_7POINT1POINT4_BACK() *AVChannelLayout

type AVCodecParameters

+ func (par *AVCodecParameters) GetCodedSideData() (v []AVPacketSideData)

+ func (par *AVCodecParameters) GetCodedSideDataAddr() **AVPacketSideData

+ func (par *AVCodecParameters) GetFramerate() AVRational

+ func (par *AVCodecParameters) GetFramerateAddr() *AVRational

+ func (par *AVCodecParameters) GetNbCodedSideData() int32

+ func (par *AVCodecParameters) GetNbCodedSideDataAddr() *int32

+ func (par *AVCodecParameters) SetCodedSideData(v *AVPacketSideData)

+ func (par *AVCodecParameters) SetFramerate(v AVRational)

+ func (par *AVCodecParameters) SetNbCodedSideData(v int32)

+ type AVExecutor C.struct_AVExecutor

+ func AvExecutorAlloc(callbacks *AVTaskCallbacks, threadCount int32) *AVExecutor

+ type AVHDRVivid3SplineParams C.struct_AVHDRVivid3SplineParams

+ func (d3sp *AVHDRVivid3SplineParams) GetEnableStrength() AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetEnableStrengthAddr() *AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThDelta1() AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThDelta1Addr() *AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThDelta2() AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThDelta2Addr() *AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThEnable() AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThEnableAddr() *AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThEnableMb() AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThEnableMbAddr() *AVRational

+ func (d3sp *AVHDRVivid3SplineParams) GetThMode() int32

+ func (d3sp *AVHDRVivid3SplineParams) GetThModeAddr() *int32

+ func (d3sp *AVHDRVivid3SplineParams) SetEnableStrength(v AVRational)

+ func (d3sp *AVHDRVivid3SplineParams) SetThDelta1(v AVRational)

+ func (d3sp *AVHDRVivid3SplineParams) SetThDelta2(v AVRational)

+ func (d3sp *AVHDRVivid3SplineParams) SetThEnable(v AVRational)

+ func (d3sp *AVHDRVivid3SplineParams) SetThEnableMb(v AVRational)

+ func (d3sp *AVHDRVivid3SplineParams) SetThMode(v int32)

type AVHDRVividColorToneMappingParams

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSpline() []AVHDRVivid3SplineParams

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineAddr() **AVHDRVivid3SplineParams

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSpline(v []AVHDRVivid3SplineParams)

type AVPacketSideData

+ func AvPacketSideDataAdd(sd **AVPacketSideData, nbSd *int32, _type AVPacketSideDataType, ...) *AVPacketSideData

+ func AvPacketSideDataGet(sd *AVPacketSideData, nbSd int32, _type AVPacketSideDataType) *AVPacketSideData

+ func AvPacketSideDataNew(psd **AVPacketSideData, pnbSd *int32, _type AVPacketSideDataType, size uintptr, ...) *AVPacketSideData

+ type AVTask C.struct_AVTask

+ func (t *AVTask) GetNext() *AVTask

+ func (t *AVTask) GetNextAddr() **AVTask

+ func (t *AVTask) SetNext(v *AVTask)

+ type AVTaskCallbacks C.struct_AVTaskCallbacks

+ func (cbs *AVTaskCallbacks) GetLocalContextSize() int32

+ func (cbs *AVTaskCallbacks) GetLocalContextSizeAddr() *int32

+ func (cbs *AVTaskCallbacks) GetPriorityHigher() AvExecutorPriorityHigherFunc

+ func (cbs *AVTaskCallbacks) GetPriorityHigherAddr() *AvExecutorPriorityHigherFunc

+ func (cbs *AVTaskCallbacks) GetReady() AvExecutorReadyFunc

+ func (cbs *AVTaskCallbacks) GetReadyAddr() *AvExecutorReadyFunc

+ func (cbs *AVTaskCallbacks) GetRun() AvExecutorRunFunc

+ func (cbs *AVTaskCallbacks) GetRunAddr() *AvExecutorRunFunc

+ func (cbs *AVTaskCallbacks) GetUserData() unsafe.Pointer

+ func (cbs *AVTaskCallbacks) GetUserDataAddr() *unsafe.Pointer

+ func (cbs *AVTaskCallbacks) SetLocalContextSize(v int32)

+ func (cbs *AVTaskCallbacks) SetPriorityHigher(v AvExecutorPriorityHigherFunc)

+ func (cbs *AVTaskCallbacks) SetReady(v AvExecutorReadyFunc)

+ func (cbs *AVTaskCallbacks) SetRun(v AvExecutorRunFunc)

+ func (cbs *AVTaskCallbacks) SetUserData(v CVoidPointer)

+ type AVVideoHint C.struct_AVVideoHint

+ func AvVideoHintAlloc(nbRects uintptr, outSize *uintptr) *AVVideoHint

+ func AvVideoHintCreateSideData(frame *AVFrame, nbRects uintptr) *AVVideoHint

+ func (hint *AVVideoHint) GetNbRects() uintptr

+ func (hint *AVVideoHint) GetNbRectsAddr() *uintptr

+ func (hint *AVVideoHint) GetRectOffset() uintptr

+ func (hint *AVVideoHint) GetRectOffsetAddr() *uintptr

+ func (hint *AVVideoHint) GetRectSize() uintptr

+ func (hint *AVVideoHint) GetRectSizeAddr() *uintptr

+ func (hint *AVVideoHint) GetType() AVVideoHintType

+ func (hint *AVVideoHint) GetTypeAddr() *AVVideoHintType

+ func (hint *AVVideoHint) SetNbRects(v uintptr)

+ func (hint *AVVideoHint) SetRectOffset(v uintptr)

+ func (hint *AVVideoHint) SetRectSize(v uintptr)

+ func (hint *AVVideoHint) SetType(v AVVideoHintType)

+ type AVVideoHintType = C.AVVideoHintType

+ type AVVideoRect C.struct_AVVideoRect

+ func AvVideoHintGetRect(hints *AVVideoHint, idx uintptr) *AVVideoRect

+ func AvVideoHintRects(hints *AVVideoHint) *AVVideoRect

+ func (rect *AVVideoRect) GetHeight() uint32

+ func (rect *AVVideoRect) GetHeightAddr() *uint32

+ func (rect *AVVideoRect) GetWidth() uint32

+ func (rect *AVVideoRect) GetWidthAddr() *uint32

+ func (rect *AVVideoRect) GetX() uint32

+ func (rect *AVVideoRect) GetXAddr() *uint32

+ func (rect *AVVideoRect) GetY() uint32

+ func (rect *AVVideoRect) GetYAddr() *uint32

+ func (rect *AVVideoRect) SetHeight(v uint32)

+ func (rect *AVVideoRect) SetWidth(v uint32)

+ func (rect *AVVideoRect) SetX(v uint32)

+ func (rect *AVVideoRect) SetY(v uint32)

+ type AvExecutorPriorityHigherFunc = C.av_executor_priority_higher_func

+ type AvExecutorReadyFunc = C.av_executor_ready_func

+ type AvExecutorRunFunc = C.av_executor_run_func

v0.60.11

Nov 15, 2023

Changes in this version

+ type AVDynamicHDRVivid = C.struct_AVDynamicHDRVivid

+ func AvDynamicHdrVividAlloc(size *uintptr) *AVDynamicHDRVivid

+ func AvDynamicHdrVividCreateSideData(frame *AVFrame) *AVDynamicHDRVivid

+ func (dhv *AVDynamicHDRVivid) GetNumWindows() uint8

+ func (dhv *AVDynamicHDRVivid) GetNumWindowsAddr() *uint8

+ func (dhv *AVDynamicHDRVivid) GetParams() []AVHDRVividColorTransformParams

+ func (dhv *AVDynamicHDRVivid) GetParamsAddr() **AVHDRVividColorTransformParams

+ func (dhv *AVDynamicHDRVivid) GetSystemStartCode() uint8

+ func (dhv *AVDynamicHDRVivid) GetSystemStartCodeAddr() *uint8

+ func (dhv *AVDynamicHDRVivid) SetNumWindows(v uint8)

+ func (dhv *AVDynamicHDRVivid) SetParams(v []AVHDRVividColorTransformParams)

+ func (dhv *AVDynamicHDRVivid) SetSystemStartCode(v uint8)

+ type AVHDRVividColorToneMappingParams C.struct_AVHDRVividColorToneMappingParams

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseEnableFlag() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseEnableFlagAddr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamDelta() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamDeltaAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamDeltaEnableMode() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamDeltaEnableModeAddr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK1() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK1Addr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK2() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK2Addr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK3() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamK3Addr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMA() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMAAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMB() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMBAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMM() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMMAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMN() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMNAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMP() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetBaseParamMPAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetTargetedSystemDisplayMaximumLuminance() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetTargetedSystemDisplayMaximumLuminanceAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableFlag() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableFlagAddr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableStrength() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableStrengthAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineNum() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineNumAddr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta1() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta1Addr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta2() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta2Addr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnable() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableMb() AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableMbAddr() *AVRational

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThMode() int32

+ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThModeAddr() *int32

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseEnableFlag(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamDelta(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamDeltaEnableMode(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamK1(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamK2(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamK3(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamMA(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamMB(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamMM(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamMN(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetBaseParamMP(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetTargetedSystemDisplayMaximumLuminance(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineEnableFlag(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineEnableStrength(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineNum(v int32)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThDelta1(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThDelta2(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThEnable(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThEnableMb(v AVRational)

+ func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThMode(v int32)

+ type AVHDRVividColorTransformParams C.struct_AVHDRVividColorTransformParams

+ func (ctfp *AVHDRVividColorTransformParams) GetAverageMaxrgb() AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetAverageMaxrgbAddr() *AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationGain() []AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationGainAddr() **AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationMappingFlag() int32

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationMappingFlagAddr() *int32

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationNum() int32

+ func (ctfp *AVHDRVividColorTransformParams) GetColorSaturationNumAddr() *int32

+ func (ctfp *AVHDRVividColorTransformParams) GetMaximumMaxrgb() AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetMaximumMaxrgbAddr() *AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetMinimumMaxrgb() AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetMinimumMaxrgbAddr() *AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetTmParams() []AVHDRVividColorToneMappingParams

+ func (ctfp *AVHDRVividColorTransformParams) GetTmParamsAddr() **AVHDRVividColorToneMappingParams

+ func (ctfp *AVHDRVividColorTransformParams) GetToneMappingModeFlag() int32

+ func (ctfp *AVHDRVividColorTransformParams) GetToneMappingModeFlagAddr() *int32

+ func (ctfp *AVHDRVividColorTransformParams) GetToneMappingParamNum() int32

+ func (ctfp *AVHDRVividColorTransformParams) GetToneMappingParamNumAddr() *int32

+ func (ctfp *AVHDRVividColorTransformParams) GetVarianceMaxrgb() AVRational

+ func (ctfp *AVHDRVividColorTransformParams) GetVarianceMaxrgbAddr() *AVRational

+ func (ctfp *AVHDRVividColorTransformParams) SetAverageMaxrgb(v AVRational)

+ func (ctfp *AVHDRVividColorTransformParams) SetColorSaturationGain(v []AVRational)

+ func (ctfp *AVHDRVividColorTransformParams) SetColorSaturationMappingFlag(v int32)

+ func (ctfp *AVHDRVividColorTransformParams) SetColorSaturationNum(v int32)

+ func (ctfp *AVHDRVividColorTransformParams) SetMaximumMaxrgb(v AVRational)

+ func (ctfp *AVHDRVividColorTransformParams) SetMinimumMaxrgb(v AVRational)

+ func (ctfp *AVHDRVividColorTransformParams) SetTmParams(v []AVHDRVividColorToneMappingParams)

+ func (ctfp *AVHDRVividColorTransformParams) SetToneMappingModeFlag(v int32)

+ func (ctfp *AVHDRVividColorTransformParams) SetToneMappingParamNum(v int32)

+ func (ctfp *AVHDRVividColorTransformParams) SetVarianceMaxrgb(v AVRational)

v0.60.10

Nov 5, 2023

v0.60.9

Nov 4, 2023

v0.60.8

Nov 4, 2023

v0.60.7

Nov 4, 2023

v0.60.6

Nov 3, 2023

v0.60.5

Nov 3, 2023

v0.60.4

Nov 3, 2023

v0.60.3

Nov 2, 2023

v0.60.2

Nov 2, 2023

v0.60.1

Nov 1, 2023

Changes in this version

+ const AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK

+ const AV_CHANNEL_LAYOUT_CUBE

+ const AV_CH_LAYOUT_7POINT1_TOP_BACK

+ const AV_CH_LAYOUT_CUBE

+ const AV_CODEC_CAP_ENCODER_RECON_FRAME

+ const AV_CODEC_FLAG2_ICC_PROFILES

+ const AV_CODEC_FLAG_COPY_OPAQUE

+ const AV_CODEC_FLAG_FRAME_DURATION

+ const AV_CODEC_FLAG_RECON_FRAME

+ const AV_CPU_FLAG_LASX

+ const AV_CPU_FLAG_LSX

+ const AV_CPU_FLAG_RVB_BASIC

+ const AV_CPU_FLAG_RVD

+ const AV_CPU_FLAG_RVF

+ const AV_CPU_FLAG_RVI

+ const AV_CPU_FLAG_RVV_F32

+ const AV_CPU_FLAG_RVV_F64

+ const AV_CPU_FLAG_RVV_I32

+ const AV_CPU_FLAG_RVV_I64

+ const AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT

+ const AV_FRAME_DATA_DYNAMIC_HDR_VIVID

+ const AV_HWACCEL_FLAG_UNSAFE_OUTPUT

+ const AV_PIX_FMT_P012BE

+ const AV_PIX_FMT_P012LE

+ const AV_PIX_FMT_P210BE

+ const AV_PIX_FMT_P210LE

+ const AV_PIX_FMT_P216BE

+ const AV_PIX_FMT_P216LE

+ const AV_PIX_FMT_P410BE

+ const AV_PIX_FMT_P410LE

+ const AV_PIX_FMT_P416BE

+ const AV_PIX_FMT_P416LE

+ const AV_PIX_FMT_RGBAF16BE

+ const AV_PIX_FMT_RGBAF16LE

+ const AV_PIX_FMT_RGBAF32BE

+ const AV_PIX_FMT_RGBAF32LE

+ const AV_PIX_FMT_RGBF32BE

+ const AV_PIX_FMT_RGBF32LE

+ const AV_PIX_FMT_VUYA

+ const AV_PIX_FMT_VUYX

+ const AV_PIX_FMT_X2BGR10BE

+ const AV_PIX_FMT_X2BGR10LE

+ const AV_PIX_FMT_XV30BE

+ const AV_PIX_FMT_XV30LE

+ const AV_PIX_FMT_XV36BE

+ const AV_PIX_FMT_XV36LE

+ const AV_PIX_FMT_Y212BE

+ const AV_PIX_FMT_Y212LE

+ const AV_TX_DOUBLE_DCT

+ const AV_TX_FLOAT_DCT

+ const AV_TX_INT32_DCT

+ const AV_TX_NB

+ func AvChromaLocationEnumToPos(xpos, ypos *int32, pos AVChromaLocation) int32

+ func AvCspApproximateTrcGamma(trc AVColorTransferCharacteristic) float64

+ func AvfilterGraphSegmentApply(seg *AVFilterGraphSegment, flags int32, intputs, outputs **AVFilterInOut) int32

+ func AvfilterGraphSegmentApplyOpts(seg *AVFilterGraphSegment, flags int32) int32

+ func AvfilterGraphSegmentCreateFilters(seg *AVFilterGraphSegment, flags int32) int32

+ func AvfilterGraphSegmentFree(seg **AVFilterGraphSegment)

+ func AvfilterGraphSegmentInit(seg *AVFilterGraphSegment, flags int32) int32

+ func AvfilterGraphSegmentLink(seg *AVFilterGraphSegment, flags int32, intputs, outputs **AVFilterInOut) int32

+ func AvfilterGraphSegmentParse(graph *AVFilterGraph, graphStr string, flags int32, seg **AVFilterGraphSegment) int32

+ type AVAmbientViewingEnvironment C.struct_AVAmbientViewingEnvironment

+ func AvAmbientViewingEnvironmentAlloc(size *uintptr) *AVAmbientViewingEnvironment

+ func AvAmbientViewingEnvironmentCreateSideData(frame *AVFrame) *AVAmbientViewingEnvironment

+ func (ave *AVAmbientViewingEnvironment) GetAmbientIlluminance() AVRational

+ func (ave *AVAmbientViewingEnvironment) GetAmbientIlluminanceAddr() *AVRational

+ func (ave *AVAmbientViewingEnvironment) GetAmbientLightX() AVRational

+ func (ave *AVAmbientViewingEnvironment) GetAmbientLightXAddr() *AVRational

+ func (ave *AVAmbientViewingEnvironment) GetAmbientLightY() AVRational

+ func (ave *AVAmbientViewingEnvironment) GetAmbientLightYAddr() *AVRational

+ func (ave *AVAmbientViewingEnvironment) SetAmbientIlluminance(v AVRational)

+ func (ave *AVAmbientViewingEnvironment) SetAmbientLightX(v AVRational)

+ func (ave *AVAmbientViewingEnvironment) SetAmbientLightY(v AVRational)

type AVChromaLocation

+ func AvChromaLocationPosToEnum(xpos, ypos int32) AVChromaLocation

type AVCodecContext

+ func (avctx *AVCodecContext) GetFrameNum() int64

+ func (avctx *AVCodecContext) GetFrameNumAddr() *int64

+ func (avctx *AVCodecContext) SetFrameNum(v int64)

type AVDictionaryEntry

+ func AvDictIterate(m *AVDictionary, prev *AVDictionaryEntry) *AVDictionaryEntry

+ type AVFilterChain C.struct_AVFilterChain

+ func (fc *AVFilterChain) GetFilters() []*AVFilterParams

+ func (fc *AVFilterChain) GetFiltersAddr() ***AVFilterParams

+ func (fc *AVFilterChain) GetNbFilters() uintptr

+ func (fc *AVFilterChain) GetNbFiltersAddr() *uintptr

+ func (fc *AVFilterChain) SetFilters(v **AVFilterParams)

+ func (fc *AVFilterChain) SetNbFilters(v uintptr)

+ type AVFilterGraphSegment C.struct_AVFilterGraphSegment

+ func (fgs *AVFilterGraphSegment) GetChains() []*AVFilterChain

+ func (fgs *AVFilterGraphSegment) GetChainsAddr() ***AVFilterChain

+ func (fgs *AVFilterGraphSegment) GetGraph() *AVFilterGraph

+ func (fgs *AVFilterGraphSegment) GetGraphAddr() **AVFilterGraph

+ func (fgs *AVFilterGraphSegment) GetNb_Chains() uintptr

+ func (fgs *AVFilterGraphSegment) GetNb_ChainsAddr() *uintptr

+ func (fgs *AVFilterGraphSegment) GetScale_Sws_Opts() string

+ func (fgs *AVFilterGraphSegment) SetChains(v **AVFilterChain)

+ func (fgs *AVFilterGraphSegment) SetGraph(v *AVFilterGraph)

+ func (fgs *AVFilterGraphSegment) SetNb_Chains(v uintptr)

+ func (fgs *AVFilterGraphSegment) SetScale_Sws_Opts(v string)

+ type AVFilterPadParams C.struct_AVFilterPadParams

+ func (fpp *AVFilterPadParams) GetLabel() string

+ func (fpp *AVFilterPadParams) SetLabel(v string)

+ type AVFilterParams C.struct_AVFilterParams

+ func (fp *AVFilterParams) GetFilter() *AVFilterContext

+ func (fp *AVFilterParams) GetFilterAddr() **AVFilterContext

+ func (fp *AVFilterParams) GetFilterName() string

+ func (fp *AVFilterParams) GetInputs() []*AVFilterPadParams

+ func (fp *AVFilterParams) GetInputsAddr() ***AVFilterPadParams

+ func (fp *AVFilterParams) GetInstanceName() string

+ func (fp *AVFilterParams) GetNbInputs() uint32

+ func (fp *AVFilterParams) GetNbInputsAddr() *uint32

+ func (fp *AVFilterParams) GetNbOutputs() uint32

+ func (fp *AVFilterParams) GetNbOutputsAddr() *uint32

+ func (fp *AVFilterParams) GetOpts() *AVDictionary

+ func (fp *AVFilterParams) GetOptsAddr() **AVDictionary

+ func (fp *AVFilterParams) GetOutputs() []*AVFilterPadParams

+ func (fp *AVFilterParams) GetOutputsAddr() ***AVFilterPadParams

+ func (fp *AVFilterParams) SetFilter(v *AVFilterContext)

+ func (fp *AVFilterParams) SetFilterName(v string)

+ func (fp *AVFilterParams) SetInputs(v **AVFilterPadParams)

+ func (fp *AVFilterParams) SetInstanceName(v string)

+ func (fp *AVFilterParams) SetNbInputs(v uint32)

+ func (fp *AVFilterParams) SetNbOutputs(v uint32)

+ func (fp *AVFilterParams) SetOpts(v *AVDictionary)

+ func (fp *AVFilterParams) SetOutputs(v **AVFilterPadParams)

type AVFrame

+ func (frame *AVFrame) GetDuration() int64

+ func (frame *AVFrame) GetDurationAddr() *int64

+ func (frame *AVFrame) SetDuration(v int64)

+ type AvCspTrcFunction = C.av_csp_trc_function

+ func AvCspTrcFuncFromId(trc AVColorTransferCharacteristic) AvCspTrcFunction

v0.51.11

Nov 18, 2023

Changes in this version

+ const AV_CODEC_ID_DFPWM

+ const AV_CODEC_ID_JPEGXL

+ const AV_CODEC_ID_PHM

+ const AV_CODEC_ID_QOI

+ const AV_CODEC_ID_VBN

v0.51.10

Nov 5, 2023

v0.51.9

Nov 4, 2023

v0.51.8

Nov 4, 2023

v0.51.7

Nov 4, 2023

v0.51.6

Nov 3, 2023

v0.51.5

Nov 3, 2023

v0.51.4

Nov 3, 2023

v0.51.3

Nov 2, 2023

v0.51.2

Nov 2, 2023

Changes in this version

type AVCodecContext

+ func (avctx *AVCodecContext) GetChLayout() AVChannelLayout

+ func (avctx *AVCodecContext) GetChLayoutAddr() *AVChannelLayout

+ func (avctx *AVCodecContext) SetChLayout(v AVChannelLayout)

type AVCodecParameters

+ func (par *AVCodecParameters) GetChLayout() AVChannelLayout

+ func (par *AVCodecParameters) GetChLayoutAddr() *AVChannelLayout

+ func (par *AVCodecParameters) SetChLayout(v AVChannelLayout)

v0.51.1

Nov 1, 2023

Changes in this version

+ const AV_CHANNEL_LAYOUT_22POINT2

+ const AV_CHANNEL_LAYOUT_2POINT1

+ const AV_CHANNEL_LAYOUT_2_1

+ const AV_CHANNEL_LAYOUT_2_2

+ const AV_CHANNEL_LAYOUT_3POINT1

+ const AV_CHANNEL_LAYOUT_4POINT0

+ const AV_CHANNEL_LAYOUT_4POINT1

+ const AV_CHANNEL_LAYOUT_5POINT0

+ const AV_CHANNEL_LAYOUT_5POINT0_BACK

+ const AV_CHANNEL_LAYOUT_5POINT1

+ const AV_CHANNEL_LAYOUT_5POINT1_BACK

+ const AV_CHANNEL_LAYOUT_6POINT0

+ const AV_CHANNEL_LAYOUT_6POINT0_FRONT

+ const AV_CHANNEL_LAYOUT_6POINT1

+ const AV_CHANNEL_LAYOUT_6POINT1_BACK

+ const AV_CHANNEL_LAYOUT_6POINT1_FRONT

+ const AV_CHANNEL_LAYOUT_7POINT0

+ const AV_CHANNEL_LAYOUT_7POINT0_FRONT

+ const AV_CHANNEL_LAYOUT_7POINT1

+ const AV_CHANNEL_LAYOUT_7POINT1_WIDE

+ const AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK

+ const AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER

+ const AV_CHANNEL_LAYOUT_HEXADECAGONAL

+ const AV_CHANNEL_LAYOUT_HEXAGONAL

+ const AV_CHANNEL_LAYOUT_MONO

+ const AV_CHANNEL_LAYOUT_OCTAGONAL

+ const AV_CHANNEL_LAYOUT_QUAD

+ const AV_CHANNEL_LAYOUT_STEREO

+ const AV_CHANNEL_LAYOUT_STEREO_DOWNMIX

+ const AV_CHANNEL_LAYOUT_SURROUND

+ const AV_CHANNEL_ORDER_AMBISONIC

+ const AV_CHANNEL_ORDER_CUSTOM

+ const AV_CHANNEL_ORDER_NATIVE

+ const AV_CHANNEL_ORDER_UNSPEC

+ const AV_CHAN_AMBISONIC_BASE

+ const AV_CHAN_AMBISONIC_END

+ const AV_CHAN_BACK_CENTER

+ const AV_CHAN_BACK_LEFT

+ const AV_CHAN_BACK_RIGHT

+ const AV_CHAN_BOTTOM_FRONT_CENTER

+ const AV_CHAN_BOTTOM_FRONT_LEFT

+ const AV_CHAN_BOTTOM_FRONT_RIGHT

+ const AV_CHAN_FRONT_CENTER

+ const AV_CHAN_FRONT_LEFT

+ const AV_CHAN_FRONT_LEFT_OF_CENTER

+ const AV_CHAN_FRONT_RIGHT

+ const AV_CHAN_FRONT_RIGHT_OF_CENTER

+ const AV_CHAN_LOW_FREQUENCY

+ const AV_CHAN_LOW_FREQUENCY_2

+ const AV_CHAN_NONE

+ const AV_CHAN_SIDE_LEFT

+ const AV_CHAN_SIDE_RIGHT

+ const AV_CHAN_STEREO_LEFT

+ const AV_CHAN_STEREO_RIGHT

+ const AV_CHAN_SURROUND_DIRECT_LEFT

+ const AV_CHAN_SURROUND_DIRECT_RIGHT

+ const AV_CHAN_TOP_BACK_CENTER

+ const AV_CHAN_TOP_BACK_LEFT

+ const AV_CHAN_TOP_BACK_RIGHT

+ const AV_CHAN_TOP_CENTER

+ const AV_CHAN_TOP_FRONT_CENTER

+ const AV_CHAN_TOP_FRONT_LEFT

+ const AV_CHAN_TOP_FRONT_RIGHT

+ const AV_CHAN_TOP_SIDE_LEFT

+ const AV_CHAN_TOP_SIDE_RIGHT

+ const AV_CHAN_UNKNOWN

+ const AV_CHAN_UNUSED

+ const AV_CHAN_WIDE_LEFT

+ const AV_CHAN_WIDE_RIGHT

+ const AV_CPU_FLAG_AVX512ICL

+ const AV_DISPOSITION_NON_DIEGETIC

+ const AV_FIFO_FLAG_AUTO_GROW

+ const AV_OPT_TYPE_CHLAYOUT

+ const AV_TX_DOUBLE_RDFT

+ const AV_TX_FLOAT_RDFT

+ const AV_TX_INT32_RDFT

+ const AV_UUID_LEN

+ const AV_UUID_STR_SIZE

+ func AvBuffersinkGetChLayout(ctx *AVFilterContext, chLayout *AVChannelLayout) int32

+ func AvChannelDescription(channel AVChannel) string

+ func AvChannelDescriptionBprint(bp *AVBPrint, channelId AVChannel)

+ func AvChannelLayoutCheck(channelLayout *AVChannelLayout) int32

+ func AvChannelLayoutCompare(chl, chl1 *AVChannelLayout) int32

+ func AvChannelLayoutCopy(dst, src *AVChannelLayout) int32

+ func AvChannelLayoutDefault(chLayout *AVChannelLayout, nbChannels int32)

+ func AvChannelLayoutDescribe(channelLayout *AVChannelLayout) string

+ func AvChannelLayoutDescribeBprint(channelLayout *AVChannelLayout, bp *AVBPrint) int32

+ func AvChannelLayoutFromMask(channelLayout *AVChannelLayout, mask uint64) int32

+ func AvChannelLayoutFromString(channelLayout *AVChannelLayout, str string) int32

+ func AvChannelLayoutIndexFromChannel(channelLayout *AVChannelLayout, channel AVChannel) int32

+ func AvChannelLayoutIndexFromString(channelLayout *AVChannelLayout, name string) int32

+ func AvChannelLayoutSubset(channelLayout *AVChannelLayout, mask uint64) uint64

+ func AvChannelLayoutUninit(channelLayout *AVChannelLayout)

+ func AvChannelName(channel AVChannel) string

+ func AvChannelNameBprint(bp *AVBPrint, channelId AVChannel)

+ func AvFifoAutoGrowLimit(f *AVFifo, maxElems T)

+ func AvFifoCanRead(f *AVFifo) uintptr

+ func AvFifoCanWrite(f *AVFifo) uintptr

+ func AvFifoDrain2(f *AVFifo, size T)

+ func AvFifoElemSize(f *AVFifo) uintptr

+ func AvFifoFreep2(f **AVFifo)

+ func AvFifoGrow2(f *AVFifo, inc T) int32

+ func AvFifoPeek(f *AVFifo, buf CVoidPointer, nbElems U, offset V) int32

+ func AvFifoPeekToCb(f *AVFifo, writeCb *AVFifoCB, opaque CVoidPointer, nbElems *uintptr, offset T) int32

+ func AvFifoRead(f *AVFifo, buf CVoidPointer, nbElems T) int32

+ func AvFifoReadToCb(f *AVFifo, writeCb *AVFifoCB, opaque CVoidPointer, nbElems *uintptr) int32

+ func AvFifoReset2(f *AVFifo)

+ func AvFifoWrite(f *AVFifo, buf CVoidPointer, nbElems T) int32

+ func AvFifoWriteFromCb(f *AVFifo, readCb *AVFifoCB, opaque CVoidPointer, nbElems *uintptr) int32

+ func AvOptGetChlayout(obj CVoidPointer, name string, searchFlags int32, layout *AVChannelLayout) int32

+ func AvOptSetChlayout(obj CVoidPointer, name string, layout *AVChannelLayout, searchFlags int32) int32

+ func AvUuidCopy(dest, src AVUUID)

+ func AvUuidEqual(uu1, uu2 AVUUID) int32

+ func AvUuidNil(uu AVUUID)

+ func AvUuidParse(in string, uu AVUUID) int32

+ func AvUuidUnparse(uu AVUUID) string

+ func AvUuidUrnParse(in string, uu AVUUID) int32

+ func SwrAllocSetOpts2(s **SwrContext, outChLayout *AVChannelLayout, outSampleFmt AVSampleFormat, ...) int32

+ func SwrBuildMatrix2(inLayout, outLayout *AVChannelLayout, ...) int32

type AVBufferSrcParameters

+ func (bsrc *AVBufferSrcParameters) GetChLayout() AVChannelLayout

+ func (bsrc *AVBufferSrcParameters) GetChLayoutAddr() *AVChannelLayout

+ func (bsrc *AVBufferSrcParameters) SetChLayout(v AVChannelLayout)

+ type AVCIExy C.struct_AVCIExy

+ func (cxy *AVCIExy) GetX() AVRational

+ func (cxy *AVCIExy) GetXAddr() *AVRational

+ func (cxy *AVCIExy) GetY() AVRational

+ func (cxy *AVCIExy) GetYAddr() *AVRational

+ func (cxy *AVCIExy) SetX(v AVRational)

+ func (cxy *AVCIExy) SetY(v AVRational)

+ type AVChannel = C.enum_AVChannel

+ func AvChannelFromString(name string) AVChannel

+ func AvChannelLayoutChannelFromIndex(channelLayout *AVChannelLayout, idx uint32) AVChannel

+ func AvChannelLayoutChannelFromString(channelLayout *AVChannelLayout, name string) AVChannel

+ type AVChannelCustom C.struct_AVChannelCustom

+ func (cc *AVChannelCustom) GetId() AVChannel

+ func (cc *AVChannelCustom) GetIdAddr() *AVChannel

+ func (cc *AVChannelCustom) GetName() string

+ func (cc *AVChannelCustom) GetOpaque() unsafe.Pointer

+ func (cc *AVChannelCustom) GetOpaqueAddr() *unsafe.Pointer

+ func (cc *AVChannelCustom) SetId(v AVChannel)

+ func (cc *AVChannelCustom) SetOpaque(v CVoidPointer)

+ type AVChannelLayout C.struct_AVChannelLayout

+ func AvChannelLayoutStandard(opaque CVoidPointerPointer) *AVChannelLayout

+ func AvMakeChannelLayout(i int) (cl *AVChannelLayout)

+ func (cl *AVChannelLayout) GetNbChannels() int32

+ func (cl *AVChannelLayout) GetNbChannelsAddr() *int32

+ func (cl *AVChannelLayout) GetOpaque() CVoidPointer

+ func (cl *AVChannelLayout) GetOpaqueAddr() *unsafe.Pointer

+ func (cl *AVChannelLayout) GetOrder() AVChannelOrder

+ func (cl *AVChannelLayout) GetOrderAddr() *AVChannelOrder

+ func (cl *AVChannelLayout) GetUMap() *AVChannelCustom

+ func (cl *AVChannelLayout) GetUMapAddr() **AVChannelCustom

+ func (cl *AVChannelLayout) GetUMask() uint64

+ func (cl *AVChannelLayout) GetUMaskAddr() *uint64

+ func (cl *AVChannelLayout) SetNbChannels(v int32)

+ func (cl *AVChannelLayout) SetOpaque(v unsafe.Pointer)

+ func (cl *AVChannelLayout) SetOrder(v AVChannelOrder)

+ func (cl *AVChannelLayout) SetUMap(v *AVChannelCustom)

+ func (cl *AVChannelLayout) SetUMask(v uint64)

+ type AVChannelOrder = C.enum_AVChannelOrder

type AVCodec

+ func (codec *AVCodec) GetChLayouts() []AVChannelLayout

type AVCodecContext

+ func (avctx *AVCodecContext) GetChLayouts() AVChannelLayout

+ func (avctx *AVCodecContext) GetChLayoutsAddr() *AVChannelLayout

+ func (avctx *AVCodecContext) SetChLayouts(v AVChannelLayout)

type AVCodecParameters

+ func (par *AVCodecParameters) GetChLayouts() AVChannelLayout

+ func (par *AVCodecParameters) GetChLayoutsAddr() *AVChannelLayout

+ func (par *AVCodecParameters) SetChLayouts(v AVChannelLayout)

type AVColorPrimaries

+ func AvCspPrimariesIdFromDesc(prm *AVColorPrimariesDesc) AVColorPrimaries

+ type AVColorPrimariesDesc C.struct_AVColorPrimariesDesc

+ func AvCspPrimariesDescFromId(prm AVColorPrimaries) *AVColorPrimariesDesc

+ func (cpd *AVColorPrimariesDesc) GetPrim() AVPrimaryCoefficients

+ func (cpd *AVColorPrimariesDesc) GetPrimAddr() *AVPrimaryCoefficients

+ func (cpd *AVColorPrimariesDesc) GetWp() AVWhitepointCoefficients

+ func (cpd *AVColorPrimariesDesc) GetWpAddr() *AVWhitepointCoefficients

+ func (cpd *AVColorPrimariesDesc) SetPrim(v AVPrimaryCoefficients)

+ func (cpd *AVColorPrimariesDesc) SetWp(v AVWhitepointCoefficients)

+ type AVFifo C.struct_AVFifo

+ func AvFifoAlloc2(elems U, elemSize V, flags uint32) *AVFifo

+ type AVFifoCB = C.AVFifoCB

type AVFilterLink

+ func (fltl *AVFilterLink) GetChLayout() AVChannelLayout

+ func (fltl *AVFilterLink) GetChLayoutAddr() *AVChannelLayout

+ func (fltl *AVFilterLink) SetChLayout(v AVChannelLayout)

type AVFrame

+ func (frame *AVFrame) GetChLayout() AVChannelLayout

+ func (frame *AVFrame) GetChLayoutAddr() *AVChannelLayout

+ func (frame *AVFrame) SetChLayout(v AVChannelLayout)

+ type AVLumaCoefficients C.struct_AVLumaCoefficients

+ func AvCspLumaCoeffsFromAvcsp(csp AVColorSpace) *AVLumaCoefficients

+ func (lc *AVLumaCoefficients) GetCb() AVRational

+ func (lc *AVLumaCoefficients) GetCbAddr() *AVRational

+ func (lc *AVLumaCoefficients) GetCg() AVRational

+ func (lc *AVLumaCoefficients) GetCgAddr() *AVRational

+ func (lc *AVLumaCoefficients) GetCr() AVRational

+ func (lc *AVLumaCoefficients) GetCrAddr() *AVRational

+ func (lc *AVLumaCoefficients) SetCb(v AVRational)

+ func (lc *AVLumaCoefficients) SetCg(v AVRational)

+ func (lc *AVLumaCoefficients) SetCr(v AVRational)

+ type AVPrimaryCoefficients C.struct_AVPrimaryCoefficients

+ func (pc *AVPrimaryCoefficients) GetB() AVCIExy

+ func (pc *AVPrimaryCoefficients) GetBAddr() *AVCIExy

+ func (pc *AVPrimaryCoefficients) GetG() AVCIExy

+ func (pc *AVPrimaryCoefficients) GetGAddr() *AVCIExy

+ func (pc *AVPrimaryCoefficients) GetR() AVCIExy

+ func (pc *AVPrimaryCoefficients) GetRAddr() *AVCIExy

+ func (pc *AVPrimaryCoefficients) SetB(v AVCIExy)

+ func (pc *AVPrimaryCoefficients) SetG(v AVCIExy)

+ func (pc *AVPrimaryCoefficients) SetR(v AVCIExy)

+ type AVUUID = []uint8

+ func AvMakeUUID() AVUUID

+ type AVWhitepointCoefficients = AVCIExy

v0.50.11

Nov 18, 2023

Changes in this version

+ const AV_CODEC_ID_GEM

+ const AV_CODEC_ID_MSNSIREN

v0.50.10

Nov 5, 2023

v0.50.5

Nov 4, 2023

v0.50.4

Nov 4, 2023

v0.50.3

Nov 4, 2023

v0.50.2

Nov 3, 2023

Changes in this version

+ func AvfilterFilterPadCount(filter *AVFilter, isOutput int32) uint32

v0.50.1

Oct 31, 2023

Changes in this version

+ const AVFILTER_FLAG_METADATA_ONLY

+ const AVFMT_EXPERIMENTAL

+ const AV_CPU_FLAG_SLOW_GATHER

+ const AV_FILM_GRAIN_PARAMS_H274

+ const AV_FRAME_DATA_DETECTION_BBOXES

+ const AV_FRAME_DATA_DOVI_METADATA

+ const AV_FRAME_DATA_DOVI_RPU_BUFFER

+ const AV_PIX_FMT_P210

+ const AV_PIX_FMT_P216

+ const AV_PIX_FMT_P410

+ const AV_PIX_FMT_P416

+ const AV_PIX_FMT_X2BGR10

+ const AV_PKT_DATA_DYNAMIC_HDR10_PLUS

+ const AV_TX_FULL_IMDCT

+ const AV_TX_UNALIGNED

+ const FF_CODEC_PROPERTY_FILM_GRAIN

+ func AvCpuForceCount(count int32)

+ func AvDispositionFromString(disp string) int32

+ func AvDispositionToString(disposition int32) string

+ func AvFormatIndexGetEntriesCount(st *AVStream) int32

+ func AvImageCopyPlaneUcFrom(dst *uint8, dstLinesize int, src *uint8, srcLinesize int, bytewidth int, ...)

+ func SwsFrameEnd(sctx *SwsContext)

+ func SwsFrameStart(sctx *SwsContext, dst, src *AVFrame) int32

+ func SwsReceiveSlice(sctx *SwsContext, sliceStart, sliceHeight uint32) int32

+ func SwsReceiveSliceAlignment(sctx *SwsContext) int32

+ func SwsScaleFrame(sctx *SwsContext, dst, src *AVFrame) int32

+ func SwsSendSlice(sctx *SwsContext, sliceStart, sliceHeight uint32) int32

type AVClass

+ func AvStreamGetClass() *AVClass

+ type AVFilmGrainH274Params C.struct_AVFilmGrainH274Params

+ func (h274p *AVFilmGrainH274Params) GetBitDepthChroma() int32

+ func (h274p *AVFilmGrainH274Params) GetBitDepthChromaAddr() *int32

+ func (h274p *AVFilmGrainH274Params) GetBitDepthLuma() int32

+ func (h274p *AVFilmGrainH274Params) GetBitDepthLumaAddr() *int32

+ func (h274p *AVFilmGrainH274Params) GetBlendingModeId() int32

+ func (h274p *AVFilmGrainH274Params) GetBlendingModeIdAddr() *int32

+ func (h274p *AVFilmGrainH274Params) GetColorPrimaries() AVColorPrimaries

+ func (h274p *AVFilmGrainH274Params) GetColorPrimariesAddr() *AVColorPrimaries

+ func (h274p *AVFilmGrainH274Params) GetColorRange() AVColorRange

+ func (h274p *AVFilmGrainH274Params) GetColorRangeAddr() *AVColorRange

+ func (h274p *AVFilmGrainH274Params) GetColorSpace() AVColorSpace

+ func (h274p *AVFilmGrainH274Params) GetColorSpaceAddr() *AVColorSpace

+ func (h274p *AVFilmGrainH274Params) GetColorTrc() AVColorTransferCharacteristic

+ func (h274p *AVFilmGrainH274Params) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (h274p *AVFilmGrainH274Params) GetCompModelValue() (v [][][]int16)

+ func (h274p *AVFilmGrainH274Params) GetCompModelValueAddr() **int16

+ func (h274p *AVFilmGrainH274Params) GetComponentModelPresent() []int32

+ func (h274p *AVFilmGrainH274Params) GetComponentModelPresentAddr() **int32

+ func (h274p *AVFilmGrainH274Params) GetIntensityIntervalLowerBound() (v [][]uint8)

+ func (h274p *AVFilmGrainH274Params) GetIntensityIntervalLowerBoundAddr() **uint8

+ func (h274p *AVFilmGrainH274Params) GetIntensityIntervalUpperBound() (v [][]uint8)

+ func (h274p *AVFilmGrainH274Params) GetIntensityIntervalUpperBoundAddr() **uint8

+ func (h274p *AVFilmGrainH274Params) GetLog2ScaleFactor() int32

+ func (h274p *AVFilmGrainH274Params) GetLog2ScaleFactorAddr() *int32

+ func (h274p *AVFilmGrainH274Params) GetModelId() int32

+ func (h274p *AVFilmGrainH274Params) GetModelIdAddr() *int32

+ func (h274p *AVFilmGrainH274Params) GetNumIntensityIntervals() []uint16

+ func (h274p *AVFilmGrainH274Params) GetNumIntensityIntervalsAddr() **uint16

+ func (h274p *AVFilmGrainH274Params) GetNumModelValues() []uint8

+ func (h274p *AVFilmGrainH274Params) GetNumModelValuesAddr() **uint8

+ func (h274p *AVFilmGrainH274Params) SetBitDepthChroma(v int32)

+ func (h274p *AVFilmGrainH274Params) SetBitDepthLuma(v int32)

+ func (h274p *AVFilmGrainH274Params) SetBlendingModeId(v int32)

+ func (h274p *AVFilmGrainH274Params) SetColorPrimaries(v AVColorPrimaries)

+ func (h274p *AVFilmGrainH274Params) SetColorRange(v AVColorRange)

+ func (h274p *AVFilmGrainH274Params) SetColorSpace(v AVColorSpace)

+ func (h274p *AVFilmGrainH274Params) SetColorTrc(v AVColorTransferCharacteristic)

+ func (h274p *AVFilmGrainH274Params) SetCompModelValue(v [][][]int16)

+ func (h274p *AVFilmGrainH274Params) SetComponentModelPresent(v []int32)

+ func (h274p *AVFilmGrainH274Params) SetIntensityIntervalLowerBound(v [][]uint8)

+ func (h274p *AVFilmGrainH274Params) SetIntensityIntervalUpperBound(v [][]uint8)

+ func (h274p *AVFilmGrainH274Params) SetLog2ScaleFactor(v int32)

+ func (h274p *AVFilmGrainH274Params) SetModelId(v int32)

+ func (h274p *AVFilmGrainH274Params) SetNumIntensityIntervals(v []uint16)

+ func (h274p *AVFilmGrainH274Params) SetNumModelValues(v []uint8)

type AVFormatContext

+ func (s *AVFormatContext) GetIoClose2() AvFormatContextIoClose2Func

+ func (s *AVFormatContext) GetIoClose2Addr() *AvFormatContextIoClose2Func

+ func (s *AVFormatContext) SetIoClose2(v AvFormatContextIoClose2Func)

type AVFrame

+ func (frame *AVFrame) GetTimeBase() AVRational

+ func (frame *AVFrame) GetTimeBaseAddr() *AVRational

+ func (frame *AVFrame) SetTimeBase(v AVRational)

type AVIOContext

+ func (ctx *AVIOContext) GetBytesWritten() int64

+ func (ctx *AVIOContext) GetBytesWrittenAddr() *int64

+ func (ctx *AVIOContext) SetBytesWritten(v int64)

type AVIndexEntry

+ func AvFormatIndexGetEntry(st *AVStream, idx int32) *AVIndexEntry

+ func AvFormatIndexGetEntryFromTimestamp(st *AVStream, wantedTimestamp int64, flags int32) *AVIndexEntry

type AVPacket

+ func (pkt *AVPacket) GetOpaque() unsafe.Pointer

+ func (pkt *AVPacket) GetOpaqueAddr() *unsafe.Pointer

+ func (pkt *AVPacket) GetOpaqueRef() *AVBufferRef

+ func (pkt *AVPacket) GetOpaqueRefAddr() **AVBufferRef

+ func (pkt *AVPacket) GetTimeBase() AVRational

+ func (pkt *AVPacket) GetTimeBaseAddr() *AVRational

+ func (pkt *AVPacket) SetOpaque(v CVoidPointer)

+ func (pkt *AVPacket) SetOpaqueRef(v *AVBufferRef)

+ func (pkt *AVPacket) SetTimeBase(v AVRational)

type AVStream

+ func (stm *AVStream) GetPtsWrapBits() int32

+ func (stm *AVStream) GetPtsWrapBitsAddr() *int32

+ func (stm *AVStream) SetPtsWrapBits(v int32)

+ type AvFormatContextIoClose2Func = C.av_format_context_io_close2_func

v0.44.11

Nov 18, 2023

v0.44.10

Nov 5, 2023

v0.44.7

Nov 4, 2023

v0.44.6

Nov 4, 2023

v0.44.5

Nov 4, 2023

v0.44.4

Nov 4, 2023

v0.44.3

Nov 3, 2023

v0.44.2

Nov 2, 2023

v0.44.1

Oct 31, 2023

Changes in this version

+ const AVSTREAM_EVENT_FLAG_NEW_PACKETS

+ const AV_CH_BOTTOM_FRONT_CENTER

+ const AV_CH_BOTTOM_FRONT_LEFT

+ const AV_CH_BOTTOM_FRONT_RIGHT

+ const AV_CH_LAYOUT_22POINT2

+ const AV_CH_TOP_SIDE_LEFT

+ const AV_CH_TOP_SIDE_RIGHT

+ const AV_CODEC_CAP_OTHER_THREADS

+ const AV_CODEC_EXPORT_DATA_FILM_GRAIN

+ const AV_CODEC_ID_ADPCM_IMA_MOFLEX

+ const AV_CODEC_ID_ARGO

+ const AV_CODEC_ID_AVS3

+ const AV_CODEC_ID_CRI

+ const AV_CODEC_ID_FASTAUDIO

+ const AV_CODEC_ID_H266

+ const AV_CODEC_ID_IPU

+ const AV_CODEC_ID_MOBICLIP

+ const AV_CODEC_ID_MSP2

+ const AV_CODEC_ID_PCM_SGA

+ const AV_CODEC_ID_PGX

+ const AV_CODEC_ID_PHOTOCD

+ const AV_CODEC_ID_SGA_VIDEO

+ const AV_CODEC_ID_SIMBIOSIS_IMX

+ const AV_CODEC_ID_VVC

+ const AV_CPU_FLAG_MMI

+ const AV_CPU_FLAG_MSA

+ const AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES

+ const AV_ESCAPE_FLAG_XML_SINGLE_QUOTES

+ const AV_ESCAPE_MODE_XML

+ const AV_FILM_GRAIN_PARAMS_AV1

+ const AV_FILM_GRAIN_PARAMS_NONE

+ const AV_FRAME_DATA_FILM_GRAIN_PARAMS

+ const AV_FRAME_DATA_SEI_UNREGISTERED

+ const AV_GET_ENCODE_BUFFER_FLAG_REF

+ const AV_PIX_FMT_X2RGB10

+ const AV_PIX_FMT_X2RGB10BE

+ const AV_PIX_FMT_X2RGB10LE

+ const AV_PKT_DATA_S12M_TIMECODE

+ const AV_TX_INPLACE

+ const AV_VIDEO_ENC_PARAMS_MPEG2

+ const FF_PROFILE_VVC_MAIN_10

+ const FF_PROFILE_VVC_MAIN_10_444

+ func AvBufferReplace(dst **AVBufferRef, src *AVBufferRef) int32

+ func AvCodecDefaultGetEncodeBuffer(avctx *AVCodecContext, pkt *AVPacket, flags int32) int32

+ func AvImageFillPlaneSizes(size []uintptr, pixFmt AVPixelFormat, height int32, linesizes []int) int32

+ func AvTimecodeGetSmpte(rate AVRational, drop, hh, mm, ss, ff int32) int32

+ func AvTimecodeInitFromComponents(tc *AVTimecode, rate AVRational, flags, hh, mm, ss, ff int32, ...) int32

+ func AvTimecodeMakeSmpteTcString2(rate AVRational, tcsmpte uint32, preventDf, skipField int32) (buf, bufPar string)

+ type AVAdler = C.AVAdler

type AVClass

+ func AvOptChildClassIterate(parent *AVClass, iter CVoidPointerPointer) *AVClass

type AVCodecContext

+ func (avctx *AVCodecContext) GetGetEncodeBuffer() AVCodecContextGetEncodeBufferFunc

+ func (avctx *AVCodecContext) GetGetEncodeBufferAddr() *AVCodecContextGetEncodeBufferFunc

+ func (avctx *AVCodecContext) SetGetEncodeBuffer(v AVCodecContextGetEncodeBufferFunc)

+ type AVCodecContextGetEncodeBufferFunc = C.avcodec_context_get_encode_buffer_func

+ type AVFilmGrainAOMParams C.struct_AVFilmGrainAOMParams

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffLag() int32

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffLagAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffShift() int32

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffShiftAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffsUv() (v [][]int8)

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffsUvAddr() **int8

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffsY() []int8

+ func (aomp *AVFilmGrainAOMParams) GetArCoeffsYAddr() **int8

+ func (aomp *AVFilmGrainAOMParams) GetChromaScalingFromLuma() int32

+ func (aomp *AVFilmGrainAOMParams) GetChromaScalingFromLumaAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetGrainScaleShift() int32

+ func (aomp *AVFilmGrainAOMParams) GetGrainScaleShiftAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetLimitOutputRange() int32

+ func (aomp *AVFilmGrainAOMParams) GetLimitOutputRangeAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetNumUvPoints() []int32

+ func (aomp *AVFilmGrainAOMParams) GetNumUvPointsAddr() **int32

+ func (aomp *AVFilmGrainAOMParams) GetNumYPoints() int32

+ func (aomp *AVFilmGrainAOMParams) GetNumYPointsAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetOverlapFlag() int32

+ func (aomp *AVFilmGrainAOMParams) GetOverlapFlagAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetScalingShift() int32

+ func (aomp *AVFilmGrainAOMParams) GetScalingShiftAddr() *int32

+ func (aomp *AVFilmGrainAOMParams) GetUvMult() []int32

+ func (aomp *AVFilmGrainAOMParams) GetUvMultAddr() **int32

+ func (aomp *AVFilmGrainAOMParams) GetUvMultLuma() []int32

+ func (aomp *AVFilmGrainAOMParams) GetUvMultLumaAddr() **int32

+ func (aomp *AVFilmGrainAOMParams) GetUvOffset() []int32

+ func (aomp *AVFilmGrainAOMParams) GetUvOffsetAddr() **int32

+ func (aomp *AVFilmGrainAOMParams) GetUvPoints() (v [][][]uint8)

+ func (aomp *AVFilmGrainAOMParams) GetUvPointsAddr() **uint8

+ func (aomp *AVFilmGrainAOMParams) GetYPoints() (v [][]uint8)

+ func (aomp *AVFilmGrainAOMParams) GetYPointsAddr() **uint8

+ func (aomp *AVFilmGrainAOMParams) SetArCoeffLag(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetArCoeffShift(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetArCoeffsUv(v [][]int8)

+ func (aomp *AVFilmGrainAOMParams) SetArCoeffsY(v []int8)

+ func (aomp *AVFilmGrainAOMParams) SetChromaScalingFromLuma(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetGrainScaleShift(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetLimitOutputRange(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetNumUvPoints(v []int32)

+ func (aomp *AVFilmGrainAOMParams) SetNumYPoints(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetOverlapFlag(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetScalingShift(v int32)

+ func (aomp *AVFilmGrainAOMParams) SetUvMult(v []int32)

+ func (aomp *AVFilmGrainAOMParams) SetUvMultLuma(v []int32)

+ func (aomp *AVFilmGrainAOMParams) SetUvOffset(v []int32)

+ func (aomp *AVFilmGrainAOMParams) SetUvPoints(v [][][]uint8)

+ func (aomp *AVFilmGrainAOMParams) SetYPoints(v [][]uint8)

+ type AVFilmGrainParams C.struct_AVFilmGrainParams

+ func AvFilmGrainParamsAlloc(size *uintptr) *AVFilmGrainParams

+ func AvFilmGrainParamsCreateSideData(frame *AVFrame) *AVFilmGrainParams

+ func (fgp *AVFilmGrainParams) GetCodecAom() AVFilmGrainAOMParams

+ func (fgp *AVFilmGrainParams) GetCodecAomAddr() *AVFilmGrainAOMParams

+ func (fgp *AVFilmGrainParams) GetSeed() uint64

+ func (fgp *AVFilmGrainParams) GetSeedAddr() *uint64

+ func (fgp *AVFilmGrainParams) GetType() AVFilmGrainParamsType

+ func (fgp *AVFilmGrainParams) GetTypeAddr() *AVFilmGrainParamsType

+ func (fgp *AVFilmGrainParams) SetCodecAom(v AVFilmGrainAOMParams)

+ func (fgp *AVFilmGrainParams) SetSeed(v uint64)

+ func (fgp *AVFilmGrainParams) SetType(v AVFilmGrainParamsType)

+ type AVFilmGrainParamsType = C.enum_AVFilmGrainParamsType

type AVFilterFormatsConfig

+ func (fltf *AVFilterFormatsConfig) GetChannelLayouts() *AVFilterChannelLayouts

+ func (fltf *AVFilterFormatsConfig) GetChannelLayoutsAddr() **AVFilterChannelLayouts

+ func (fltf *AVFilterFormatsConfig) GetFormats() *AVFilterFormats

+ func (fltf *AVFilterFormatsConfig) GetFormatsAddr() **AVFilterFormats

+ func (fltf *AVFilterFormatsConfig) GetSamplerates() *AVFilterFormats

+ func (fltf *AVFilterFormatsConfig) GetSampleratesAddr() **AVFilterFormats

+ func (fltf *AVFilterFormatsConfig) SetChannelLayouts(v *AVFilterChannelLayouts)

+ func (fltf *AVFilterFormatsConfig) SetFormats(v *AVFilterFormats)

+ func (fltf *AVFilterFormatsConfig) SetSamplerates(v *AVFilterFormats)

+ type AVTXFlags = C.enum_AVTXFlags

v0.43.11

Nov 18, 2023

v0.43.10

Nov 5, 2023

v0.43.5

Nov 4, 2023

v0.43.4

Nov 4, 2023

v0.43.3

Nov 4, 2023

v0.43.2

Nov 3, 2023

v0.43.1

Nov 2, 2023

Changes in this version

+ const AVCOL_PRI_EBU3213

+ const AV_CODEC_CAP_ENCODER_FLUSH

+ const AV_CODEC_EXPORT_DATA_MVS

+ const AV_CODEC_EXPORT_DATA_PRFT

+ const AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS

+ const AV_CODEC_ID_ACELP_KELVIN

+ const AV_CODEC_ID_ADPCM_ARGO

+ const AV_CODEC_ID_ADPCM_IMA_ALP

+ const AV_CODEC_ID_ADPCM_IMA_APM

+ const AV_CODEC_ID_ADPCM_IMA_CUNNING

+ const AV_CODEC_ID_ADPCM_IMA_MTF

+ const AV_CODEC_ID_ADPCM_IMA_SSI

+ const AV_CODEC_ID_ADPCM_ZORK

+ const AV_CODEC_ID_CDTOONS

+ const AV_CODEC_ID_DERF_DPCM

+ const AV_CODEC_ID_EPG

+ const AV_CODEC_ID_HCA

+ const AV_CODEC_ID_IMM5

+ const AV_CODEC_ID_MPEGH_3D_AUDIO

+ const AV_CODEC_ID_MV30

+ const AV_CODEC_ID_MVDV

+ const AV_CODEC_ID_MVHA

+ const AV_CODEC_ID_NOTCHLC

+ const AV_CODEC_ID_PFM

+ const AV_CODEC_ID_SIREN

+ const AV_FRAME_DATA_VIDEO_ENC_PARAMS

+ const AV_HWDEVICE_TYPE_VULKAN

+ const AV_OPT_FLAG_CHILD_CONSTS

+ const AV_OPT_FLAG_RUNTIME_PARAM

+ const AV_PIX_FMT_VULKAN

+ const AV_PIX_FMT_Y210

+ const AV_PIX_FMT_Y210BE

+ const AV_PIX_FMT_Y210LE

+ const AV_PKT_DATA_DOVI_CONF

+ const AV_PKT_DATA_ICC_PROFILE

+ const AV_PKT_DATA_PRFT

+ const AV_TX_DOUBLE_FFT

+ const AV_TX_DOUBLE_MDCT

+ const AV_TX_INT32_FFT

+ const AV_TX_INT32_MDCT

+ const AV_VIDEO_ENC_PARAMS_H264

+ const AV_VIDEO_ENC_PARAMS_NONE

+ const AV_VIDEO_ENC_PARAMS_VP9

+ const FF_PROFILE_KLVA_ASYNC

+ const FF_PROFILE_KLVA_SYNC

+ func AvBufferPoolBufferGetOpaque(buf *AVBufferRef) unsafe.Pointer

+ func AvHWDeviceCtxCreateDerivedOpts(dstCtx **AVBufferRef, _type AVHWDeviceType, srcCtx *AVBufferRef, ...) int32

+ func AvIOPrint(s *AVIOContext, va ...any)

+ func AvLogOnce(avcl CVoidPointer, initialLevel, subsequentLevel int32, state *int32, ...)

+ func AvSatAdd64C(a, b int64) int64

+ func AvSatSub64C(a, b int64) int64

type AVClass

+ func AvIOProtocolGetClass(name string) *AVClass

type AVCodecContext

+ func (avctx *AVCodecContext) GetExportSideData() int32

+ func (avctx *AVCodecContext) GetExportSideDataAddr() *int32

+ func (avctx *AVCodecContext) GetMaxSamples() int64

+ func (avctx *AVCodecContext) GetMaxSamplesAddr() *int64

+ func (avctx *AVCodecContext) SetExportSideData(v int32)

+ func (avctx *AVCodecContext) SetMaxSamples(v int64)

type AVComplexDouble

+ func AvMakeComxDouble(re, im float64) AVComplexDouble

+ func (cd *AVComplexDouble) GetIm() float64

+ func (cd *AVComplexDouble) GetImAddr() *float64

+ func (cd *AVComplexDouble) GetRe() float64

+ func (cd *AVComplexDouble) GetReAddr() *float64

+ func (cd *AVComplexDouble) SetIm(v float64)

+ func (cd *AVComplexDouble) SetRe(v float64)

type AVComplexInt32

+ func AvMakeComxInt32(re, im int32) AVComplexInt32

+ func (ci *AVComplexInt32) GetIm() int32

+ func (ci *AVComplexInt32) GetImAddr() *int32

+ func (ci *AVComplexInt32) GetRe() int32

+ func (ci *AVComplexInt32) GetReAddr() *int32

+ func (ci *AVComplexInt32) SetIm(v int32)

+ func (ci *AVComplexInt32) SetRe(v int32)

type AVDCT

+ func (dct *AVDCT) GetGetPixelsUnaligned() AVDCTGetPixelsUnalignedFunc

+ func (dct *AVDCT) GetGetPixelsUnalignedAddr() *AVDCTGetPixelsUnalignedFunc

+ func (dct *AVDCT) SetGetPixelsUnaligned(v AVDCTGetPixelsUnalignedFunc)

+ type AVDCTGetPixelsUnalignedFunc = C.avdct_get_pixels_unaligned_func

+ type AVDOVIDecoderConfigurationRecord C.struct_AVDOVIDecoderConfigurationRecord

+ func AvDoviAlloc(size *uintptr) *AVDOVIDecoderConfigurationRecord

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetBlPresentFlag() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetBlPresentFlagAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvBlSignalCompatibilityId() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvBlSignalCompatibilityIdAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvLevel() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvLevelAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvProfile() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvProfileAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvVersionMajor() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvVersionMajorAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvVersionMinor() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetDvVersionMinorAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetElPresentFlag() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetElPresentFlagAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetRpuPresentFlag() uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) GetRpuPresentFlagAddr() *uint8

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetBlPresentFlag(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetDvBlSignalCompatibilityId(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetDvLevel(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetDvProfile(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetDvVersionMajor(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetDvVersionMinor(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetElPresentFlag(v uint8)

+ func (dcr *AVDOVIDecoderConfigurationRecord) SetRpuPresentFlag(v uint8)

type AVFormatContext

+ func (s *AVFormatContext) GetMaxProbePackets() int32

+ func (s *AVFormatContext) GetMaxProbePacketsAddr() *int32

+ func (s *AVFormatContext) SetMaxProbePackets(v int32)

type AVProducerReferenceTime

+ func (prt *AVProducerReferenceTime) GetFlags() int32

+ func (prt *AVProducerReferenceTime) GetFlagsAddr() *int32

+ func (prt *AVProducerReferenceTime) GetWallclock() int64

+ func (prt *AVProducerReferenceTime) GetWallclockAddr() *int64

+ func (prt *AVProducerReferenceTime) SetFlags(v int32)

+ func (prt *AVProducerReferenceTime) SetWallclock(v int64)

type AVRational

+ func AvGcdQ(a, b AVRational, maxDen int32, def AVRational) AVRational

+ type AVVideoBlockParams C.struct_AVVideoBlockParams

+ func AvVideoEncParamsBlock(par *AVVideoEncParams, idx uint32) *AVVideoBlockParams

+ func (vbp *AVVideoBlockParams) GetDeltaQp() int32

+ func (vbp *AVVideoBlockParams) GetDeltaQpAddr() *int32

+ func (vbp *AVVideoBlockParams) GetH() int32

+ func (vbp *AVVideoBlockParams) GetHAddr() *int32

+ func (vbp *AVVideoBlockParams) GetSrcX() int32

+ func (vbp *AVVideoBlockParams) GetSrcXAddr() *int32

+ func (vbp *AVVideoBlockParams) GetSrcY() int32

+ func (vbp *AVVideoBlockParams) GetSrcYAddr() *int32

+ func (vbp *AVVideoBlockParams) GetW() int32

+ func (vbp *AVVideoBlockParams) GetWAddr() *int32

+ func (vbp *AVVideoBlockParams) SetDeltaQp(v int32)

+ func (vbp *AVVideoBlockParams) SetH(v int32)

+ func (vbp *AVVideoBlockParams) SetSrcX(v int32)

+ func (vbp *AVVideoBlockParams) SetSrcY(v int32)

+ func (vbp *AVVideoBlockParams) SetW(v int32)

+ type AVVideoEncParams C.struct_AVVideoEncParams

+ func AvVideoEncParamsAlloc(_type AVVideoEncParamsType, nbBlocks uint32, outSize *uintptr) *AVVideoEncParams

+ func AvVideoEncParamsCreateSideData(frame *AVFrame, _type AVVideoEncParamsType, nbBlocks uint32) *AVVideoEncParams

+ func (vep *AVVideoEncParams) GetBlockSize() uintptr

+ func (vep *AVVideoEncParams) GetBlockSizeAddr() *uintptr

+ func (vep *AVVideoEncParams) GetBlocksOffset() uintptr

+ func (vep *AVVideoEncParams) GetBlocksOffsetAddr() *uintptr

+ func (vep *AVVideoEncParams) GetDeltaQp() (v [][]int32)

+ func (vep *AVVideoEncParams) GetDeltaQpAddr() **int32

+ func (vep *AVVideoEncParams) GetNbBlocks() uint32

+ func (vep *AVVideoEncParams) GetNbBlocksAddr() *uint32

+ func (vep *AVVideoEncParams) GetQp() int32

+ func (vep *AVVideoEncParams) GetQpAddr() *int32

+ func (vep *AVVideoEncParams) GetType() AVVideoEncParamsType

+ func (vep *AVVideoEncParams) GetTypeAddr() *AVVideoEncParamsType

+ func (vep *AVVideoEncParams) SetBlockSize(v uintptr)

+ func (vep *AVVideoEncParams) SetBlocksOffset(v uintptr)

+ func (vep *AVVideoEncParams) SetDeltaQp(v [][]int32)

+ func (vep *AVVideoEncParams) SetNbBlocks(v uint32)

+ func (vep *AVVideoEncParams) SetQp(v int32)

+ func (vep *AVVideoEncParams) SetType(v AVVideoEncParamsType)

+ type AVVideoEncParamsType = C.enum_AVVideoEncParamsType

v0.42.11

Nov 18, 2023

v0.42.10

Nov 5, 2023

v0.42.5

Nov 4, 2023

v0.42.4

Nov 4, 2023

v0.42.3

Nov 4, 2023

v0.42.2

Nov 3, 2023

v0.42.1

Nov 2, 2023

Changes in this version

+ const AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

+ const AV_CODEC_FLAG_DROPCHANGED

+ const AV_CODEC_ID_ADPCM_AGM

+ const AV_CODEC_ID_AGM

+ const AV_CODEC_ID_ARBC

+ const AV_CODEC_ID_ARIB_CAPTION

+ const AV_CODEC_ID_HCOM

+ const AV_CODEC_ID_HYMT

+ const AV_CODEC_ID_LSCR

+ const AV_CODEC_ID_VP4

+ const AV_FRAME_DATA_DYNAMIC_HDR_PLUS

+ const AV_FRAME_DATA_REGIONS_OF_INTEREST

+ const AV_HDR_PLUS_OVERLAP_PROCESS_LAYERING

+ const AV_HDR_PLUS_OVERLAP_PROCESS_WEIGHTED_AVERAGING

+ const AV_PIX_FMT_NV24

+ const AV_PIX_FMT_NV42

+ const AV_PIX_FMT_YUVA422P12

+ const AV_PIX_FMT_YUVA422P12BE

+ const AV_PIX_FMT_YUVA422P12LE

+ const AV_PIX_FMT_YUVA444P12

+ const AV_PIX_FMT_YUVA444P12BE

+ const AV_PIX_FMT_YUVA444P12LE

+ const AV_TX_FLOAT_FFT

+ const AV_TX_FLOAT_MDCT

+ const FF_DECODE_ERROR_CONCEALMENT_ACTIVE

+ const FF_DECODE_ERROR_DECODE_SLICES

+ const FF_PROFILE_ARIB_PROFILE_A

+ const FF_PROFILE_ARIB_PROFILE_C

+ const FF_PROFILE_PRORES_4444

+ const FF_PROFILE_PRORES_HQ

+ const FF_PROFILE_PRORES_LT

+ const FF_PROFILE_PRORES_PROXY

+ const FF_PROFILE_PRORES_STANDARD

+ const FF_PROFILE_PRORES_XQ

+ func AvTxInit(ctx **AVTXContext, tx *AvTxFn, _type AVTXType, inv, len int32, ...) int32

+ func AvTxUninit(ctx **AVTXContext)

type AVCodecContext

+ func (avctx *AVCodecContext) GetDiscardDamagedPercentage() int32

+ func (avctx *AVCodecContext) GetDiscardDamagedPercentageAddr() *int32

+ func (avctx *AVCodecContext) SetDiscardDamagedPercentage(v int32)

+ type AVComplexDouble C.struct_AVComplexDouble

+ type AVComplexFloat C.struct_AVComplexFloat

+ func AvMakeComxFloat(re, im float32) AVComplexFloat

+ func (cf *AVComplexFloat) GetIm() float32

+ func (cf *AVComplexFloat) GetImAddr() *float32

+ func (cf *AVComplexFloat) GetRe() float32

+ func (cf *AVComplexFloat) GetReAddr() *float32

+ func (cf *AVComplexFloat) SetIm(v float32)

+ func (cf *AVComplexFloat) SetRe(v float32)

+ type AVComplexInt32 C.struct_AVComplexInt32

+ type AVDynamicHDRPlus C.struct_AVDynamicHDRPlus

+ func AvDynamicHdrPlusAlloc(size *uintptr) *AVDynamicHDRPlus

+ func AvDynamicHdrPlusCreateSideData(frame *AVFrame) *AVDynamicHDRPlus

+ func (dhp *AVDynamicHDRPlus) GetApplicationVersion() uint8

+ func (dhp *AVDynamicHDRPlus) GetApplicationVersionAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetItuTT35CountryCode() uint8

+ func (dhp *AVDynamicHDRPlus) GetItuTT35CountryCodeAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetMasteringDisplayActualPeakLuminance() (v [][]AVRational)

+ func (dhp *AVDynamicHDRPlus) GetMasteringDisplayActualPeakLuminanceAddr() **AVRational

+ func (dhp *AVDynamicHDRPlus) GetMasteringDisplayActualPeakLuminanceFlag() uint8

+ func (dhp *AVDynamicHDRPlus) GetMasteringDisplayActualPeakLuminanceFlagAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetNumColsMasteringDisplayActualPeakLuminance() uint8

+ func (dhp *AVDynamicHDRPlus) GetNumColsMasteringDisplayActualPeakLuminanceAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetNumColsTargetedSystemDisplayActualPeakLuminance() uint8

+ func (dhp *AVDynamicHDRPlus) GetNumColsTargetedSystemDisplayActualPeakLuminanceAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetNumRowsMasteringDisplayActualPeakLuminance() uint8

+ func (dhp *AVDynamicHDRPlus) GetNumRowsMasteringDisplayActualPeakLuminanceAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetNumRowsTargetedSystemDisplayActualPeakLuminance() uint8

+ func (dhp *AVDynamicHDRPlus) GetNumRowsTargetedSystemDisplayActualPeakLuminanceAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetNumWindows() uint8

+ func (dhp *AVDynamicHDRPlus) GetNumWindowsAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetParams() []AVHDRPlusColorTransformParams

+ func (dhp *AVDynamicHDRPlus) GetParamsAddr() **AVHDRPlusColorTransformParams

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayActualPeakLuminance() (v [][]AVRational)

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayActualPeakLuminanceAddr() **AVRational

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayActualPeakLuminanceFlag() uint8

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayActualPeakLuminanceFlagAddr() *uint8

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayMaximumLuminance() AVRational

+ func (dhp *AVDynamicHDRPlus) GetTargetedSystemDisplayMaximumLuminanceAddr() *AVRational

+ func (dhp *AVDynamicHDRPlus) SetApplicationVersion(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetItuTT35CountryCode(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetMasteringDisplayActualPeakLuminance(v [][]AVRational)

+ func (dhp *AVDynamicHDRPlus) SetMasteringDisplayActualPeakLuminanceFlag(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetNumColsMasteringDisplayActualPeakLuminance(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetNumColsTargetedSystemDisplayActualPeakLuminance(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetNumRowsMasteringDisplayActualPeakLuminance(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetNumRowsTargetedSystemDisplayActualPeakLuminance(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetNumWindows(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetParams(v []AVHDRPlusColorTransformParams)

+ func (dhp *AVDynamicHDRPlus) SetTargetedSystemDisplayActualPeakLuminance(v [][]AVRational)

+ func (dhp *AVDynamicHDRPlus) SetTargetedSystemDisplayActualPeakLuminanceFlag(v uint8)

+ func (dhp *AVDynamicHDRPlus) SetTargetedSystemDisplayMaximumLuminance(v AVRational)

+ type AVHDRPlusColorTransformParams C.struct_AVHDRPlusColorTransformParams

+ func (ctp *AVHDRPlusColorTransformParams) GetAverageMaxrgb() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetAverageMaxrgbAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetBezierCurveAnchors() []AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetBezierCurveAnchorsAddr() **AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetCenterOfEllipseX() uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetCenterOfEllipseXAddr() *uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetCenterOfEllipseY() uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetCenterOfEllipseYAddr() *uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetColorSaturationMappingFlag() uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetColorSaturationMappingFlagAddr() *uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetColorSaturationWeight() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetColorSaturationWeightAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetDistributionMaxrgb() []AVHDRPlusPercentile

+ func (ctp *AVHDRPlusColorTransformParams) GetDistributionMaxrgbAddr() **AVHDRPlusPercentile

+ func (ctp *AVHDRPlusColorTransformParams) GetFractionBrightPixels() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetFractionBrightPixelsAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetKneePointX() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetKneePointXAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetKneePointY() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetKneePointYAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetMaxscl() []AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetMaxsclAddr() **AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetNumBezierCurveAnchors() uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetNumBezierCurveAnchorsAddr() *uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetNumDistributionMaxrgbPercentiles() uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetNumDistributionMaxrgbPercentilesAddr() *uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetOverlapProcessOption() AVHDRPlusOverlapProcessOption

+ func (ctp *AVHDRPlusColorTransformParams) GetOverlapProcessOptionAddr() *AVHDRPlusOverlapProcessOption

+ func (ctp *AVHDRPlusColorTransformParams) GetRotationAngle() uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetRotationAngleAddr() *uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetSemimajorAxisExternalEllipse() uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetSemimajorAxisExternalEllipseAddr() *uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetSemimajorAxisInternalEllipse() uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetSemimajorAxisInternalEllipseAddr() *uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetSemiminorAxisExternalEllipse() uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetSemiminorAxisExternalEllipseAddr() *uint16

+ func (ctp *AVHDRPlusColorTransformParams) GetToneMappingFlag() uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetToneMappingFlagAddr() *uint8

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowLowerRightCornerX() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowLowerRightCornerXAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowLowerRightCornerY() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowLowerRightCornerYAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowUpperLeftCornerX() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowUpperLeftCornerXAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowUpperLeftCornerY() AVRational

+ func (ctp *AVHDRPlusColorTransformParams) GetWindowUpperLeftCornerYAddr() *AVRational

+ func (ctp *AVHDRPlusColorTransformParams) SetAverageMaxrgb(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetBezierCurveAnchors(v []AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetCenterOfEllipseX(v uint16)

+ func (ctp *AVHDRPlusColorTransformParams) SetCenterOfEllipseY(v uint16)

+ func (ctp *AVHDRPlusColorTransformParams) SetColorSaturationMappingFlag(v uint8)

+ func (ctp *AVHDRPlusColorTransformParams) SetColorSaturationWeight(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetDistributionMaxrgb(v []AVHDRPlusPercentile)

+ func (ctp *AVHDRPlusColorTransformParams) SetFractionBrightPixels(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetKneePointX(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetKneePointY(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetMaxscl(v []AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetNumBezierCurveAnchors(v uint8)

+ func (ctp *AVHDRPlusColorTransformParams) SetNumDistributionMaxrgbPercentiles(v uint8)

+ func (ctp *AVHDRPlusColorTransformParams) SetOverlapProcessOption(v AVHDRPlusOverlapProcessOption)

+ func (ctp *AVHDRPlusColorTransformParams) SetRotationAngle(v uint8)

+ func (ctp *AVHDRPlusColorTransformParams) SetSemimajorAxisExternalEllipse(v uint16)

+ func (ctp *AVHDRPlusColorTransformParams) SetSemimajorAxisInternalEllipse(v uint16)

+ func (ctp *AVHDRPlusColorTransformParams) SetSemiminorAxisExternalEllipse(v uint16)

+ func (ctp *AVHDRPlusColorTransformParams) SetToneMappingFlag(v uint8)

+ func (ctp *AVHDRPlusColorTransformParams) SetWindowLowerRightCornerX(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetWindowLowerRightCornerY(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetWindowUpperLeftCornerX(v AVRational)

+ func (ctp *AVHDRPlusColorTransformParams) SetWindowUpperLeftCornerY(v AVRational)

+ type AVHDRPlusOverlapProcessOption = C.enum_AVHDRPlusOverlapProcessOption

+ type AVHDRPlusPercentile C.struct_AVHDRPlusPercentile

+ func (pct *AVHDRPlusPercentile) GetPercentage() uint8

+ func (pct *AVHDRPlusPercentile) GetPercentageAddr() *uint8

+ func (pct *AVHDRPlusPercentile) GetPercentile() AVRational

+ func (pct *AVHDRPlusPercentile) GetPercentileAddr() *AVRational

+ func (pct *AVHDRPlusPercentile) SetPercentage(v uint8)

+ func (pct *AVHDRPlusPercentile) SetPercentile(v AVRational)

type AVRegionOfInterest

+ func (roi *AVRegionOfInterest) GetBottom() int32

+ func (roi *AVRegionOfInterest) GetBottomAddr() *int32

+ func (roi *AVRegionOfInterest) GetLeft() int32

+ func (roi *AVRegionOfInterest) GetLeftAddr() *int32

+ func (roi *AVRegionOfInterest) GetQoffset() AVRational

+ func (roi *AVRegionOfInterest) GetQoffsetAddr() *AVRational

+ func (roi *AVRegionOfInterest) GetRight() int32

+ func (roi *AVRegionOfInterest) GetRightAddr() *int32

+ func (roi *AVRegionOfInterest) GetSelfSize() uint32

+ func (roi *AVRegionOfInterest) GetSelfSizeAddr() *uint32

+ func (roi *AVRegionOfInterest) GetTop() int32

+ func (roi *AVRegionOfInterest) GetTopAddr() *int32

+ func (roi *AVRegionOfInterest) SetBottom(v int32)

+ func (roi *AVRegionOfInterest) SetLeft(v int32)

+ func (roi *AVRegionOfInterest) SetQoffset(v AVRational)

+ func (roi *AVRegionOfInterest) SetRight(v int32)

+ func (roi *AVRegionOfInterest) SetSelfSize(v uint32)

+ func (roi *AVRegionOfInterest) SetTop(v int32)

+ type AVTXContext C.struct_AVTXContext

+ type AVTXType = C.enum_AVTXType

+ type AvTxFn = C.av_tx_fn

v0.41.11

Nov 18, 2023

v0.41.10

Nov 5, 2023

v0.41.5

Nov 4, 2023

v0.41.4

Nov 4, 2023

v0.41.3

Nov 4, 2023

v0.41.2

Nov 3, 2023

v0.41.1

Nov 2, 2023

Changes in this version

+ const AV_CODEC_ID_ATRAC9

+ const AV_CODEC_ID_AVS2

+ const AV_CODEC_ID_IMM4

+ const AV_CODEC_ID_MWSC

+ const AV_CODEC_ID_PCM_VIDC

+ const AV_CODEC_ID_PROSUMER

+ const AV_CODEC_ID_RASC

+ const AV_CODEC_ID_TTML

+ const AV_CODEC_ID_WCMV

+ const AV_DISPOSITION_STILL_IMAGE

+ const AV_FRAME_DATA_S12M_TIMECODE

+ const AV_OPT_FLAG_DEPRECATED

+ const AV_PIX_FMT_GRAY14

+ const AV_PIX_FMT_GRAY14BE

+ const AV_PIX_FMT_GRAY14LE

+ const AV_PIX_FMT_GRAYF32

+ const AV_PIX_FMT_GRAYF32BE

+ const AV_PIX_FMT_GRAYF32LE

+ const AV_PKT_DATA_AFD

+ func AvBsfFlush(ctx *AVBSFContext)

+ func AvReadImageLine2(dst CVoidPointer, data []*uint8, linesize []int, desc *AVPixFmtDescriptor, ...)

+ func AvThreadMessageQueueNbElems(mq *AVThreadMessageQueue) int32

+ func AvWriteImageLine2(src CVoidPointer, data []*uint8, linesize []int, desc *AVPixFmtDescriptor, ...)

type AVEncryptionInitInfo

+ func (eii *AVEncryptionInitInfo) GetNext() *AVEncryptionInitInfo

+ func (eii *AVEncryptionInitInfo) GetNextAddr() **AVEncryptionInitInfo

+ func (eii *AVEncryptionInitInfo) SetNext(v *AVEncryptionInitInfo)

type AVFormatContext

+ func (s *AVFormatContext) GetSkipEstimateDurationFromPts() int32

+ func (s *AVFormatContext) GetSkipEstimateDurationFromPtsAddr() *int32

+ func (s *AVFormatContext) SetSkipEstimateDurationFromPts(v int32)

type AVProgram

+ func (pgm *AVProgram) GetPmtVersion() int32

+ func (pgm *AVProgram) GetPmtVersionAddr() *int32

+ func (pgm *AVProgram) SetPmtVersion(v int32)

v0.40.11

Nov 18, 2023

Changes in this version

+ const FF_LEVEL_UNKNOWN

type AVIOContext

+ func (ctx *AVIOContext) GetReadPacket() AVIOContextReadPacketFunc

+ func (ctx *AVIOContext) GetReadPacketAddr() *AVIOContextReadPacketFunc

+ func (ctx *AVIOContext) GetReadPause() AVIOContextReadPause

+ func (ctx *AVIOContext) GetReadPauseAddr() *AVIOContextReadPause

+ func (ctx *AVIOContext) GetReadSeek() AVIOContextReadSeek

+ func (ctx *AVIOContext) GetReadSeekAddr() *AVIOContextReadSeek

+ func (ctx *AVIOContext) GetSeek() AVIOContextSeekFunc

+ func (ctx *AVIOContext) GetSeekAddr() *AVIOContextSeekFunc

+ func (ctx *AVIOContext) GetUpdateChecksum() AVIOContextUpdateChecksum

+ func (ctx *AVIOContext) GetUpdateChecksumAddr() *AVIOContextUpdateChecksum

+ func (ctx *AVIOContext) GetWriteDataType() AVIOContextWriteDataType

+ func (ctx *AVIOContext) GetWriteDataTypeAddr() *AVIOContextWriteDataType

+ func (ctx *AVIOContext) GetWritePacket() AVIOContextWritePacketFunc

+ func (ctx *AVIOContext) GetWritePacketAddr() *AVIOContextWritePacketFunc

+ func (ctx *AVIOContext) SetReadPacket(v AVIOContextReadPacketFunc)

+ func (ctx *AVIOContext) SetReadPause(v AVIOContextReadPause)

+ func (ctx *AVIOContext) SetReadSeek(v AVIOContextReadSeek)

+ func (ctx *AVIOContext) SetSeek(v AVIOContextSeekFunc)

+ func (ctx *AVIOContext) SetUpdateChecksum(v AVIOContextUpdateChecksum)

+ func (ctx *AVIOContext) SetWriteDataType(v AVIOContextWriteDataType)

+ func (ctx *AVIOContext) SetWritePacket(v AVIOContextWritePacketFunc)

+ type AVIOContextReadPause = C.avio_context_read_pause

+ type AVIOContextReadSeek = C.avio_context_read_seek

+ type AVIOContextUpdateChecksum = C.avio_context_update_checksum

+ type AVIOContextWriteDataType = C.avio_context_write_data_type

v0.40.10

Nov 5, 2023

v0.40.5

Nov 4, 2023

v0.40.4

Nov 4, 2023

v0.40.3

Nov 4, 2023

v0.40.2

Nov 3, 2023

v0.40.1

Nov 2, 2023

Changes in this version

+ const AES_CTR_IV_SIZE

+ const AES_CTR_KEY_SIZE

+ const AVCHROMA_LOC_BOTTOM

+ const AVCHROMA_LOC_BOTTOMLEFT

+ const AVCHROMA_LOC_CENTER

+ const AVCHROMA_LOC_LEFT

+ const AVCHROMA_LOC_NB

+ const AVCHROMA_LOC_TOP

+ const AVCHROMA_LOC_TOPLEFT

+ const AVCHROMA_LOC_UNSPECIFIED

+ const AVCOL_PRI_BT2020

+ const AVCOL_PRI_BT470BG

+ const AVCOL_PRI_BT470M

+ const AVCOL_PRI_BT709

+ const AVCOL_PRI_FILM

+ const AVCOL_PRI_JEDEC_P22

+ const AVCOL_PRI_NB

+ const AVCOL_PRI_RESERVED

+ const AVCOL_PRI_RESERVED0

+ const AVCOL_PRI_SMPTE170M

+ const AVCOL_PRI_SMPTE240M

+ const AVCOL_PRI_SMPTE428

+ const AVCOL_PRI_SMPTE431

+ const AVCOL_PRI_SMPTE432

+ const AVCOL_PRI_SMPTEST428_1

+ const AVCOL_PRI_UNSPECIFIED

+ const AVCOL_RANGE_JPEG

+ const AVCOL_RANGE_MPEG

+ const AVCOL_RANGE_NB

+ const AVCOL_RANGE_UNSPECIFIED

+ const AVCOL_SPC_BT2020_CL

+ const AVCOL_SPC_BT2020_NCL

+ const AVCOL_SPC_BT470BG

+ const AVCOL_SPC_BT709

+ const AVCOL_SPC_CHROMA_DERIVED_CL

+ const AVCOL_SPC_CHROMA_DERIVED_NCL

+ const AVCOL_SPC_FCC

+ const AVCOL_SPC_ICTCP

+ const AVCOL_SPC_NB

+ const AVCOL_SPC_RESERVED

+ const AVCOL_SPC_RGB

+ const AVCOL_SPC_SMPTE170M

+ const AVCOL_SPC_SMPTE2085

+ const AVCOL_SPC_SMPTE240M

+ const AVCOL_SPC_UNSPECIFIED

+ const AVCOL_SPC_YCGCO

+ const AVCOL_SPC_YCOCG

+ const AVCOL_TRC_ARIB_STD_B67

+ const AVCOL_TRC_BT1361_ECG

+ const AVCOL_TRC_BT2020_10

+ const AVCOL_TRC_BT2020_12

+ const AVCOL_TRC_BT709

+ const AVCOL_TRC_GAMMA22

+ const AVCOL_TRC_GAMMA28

+ const AVCOL_TRC_IEC61966_2_1

+ const AVCOL_TRC_IEC61966_2_4

+ const AVCOL_TRC_LINEAR

+ const AVCOL_TRC_LOG

+ const AVCOL_TRC_LOG_SQRT

+ const AVCOL_TRC_NB

+ const AVCOL_TRC_RESERVED

+ const AVCOL_TRC_RESERVED0

+ const AVCOL_TRC_SMPTE170M

+ const AVCOL_TRC_SMPTE2084

+ const AVCOL_TRC_SMPTE240M

+ const AVCOL_TRC_SMPTE428

+ const AVCOL_TRC_SMPTEST2084

+ const AVCOL_TRC_SMPTEST428_1

+ const AVCOL_TRC_UNSPECIFIED

+ const AVDISCARD_ALL

+ const AVDISCARD_BIDIR

+ const AVDISCARD_DEFAULT

+ const AVDISCARD_NONE

+ const AVDISCARD_NONINTRA

+ const AVDISCARD_NONKEY

+ const AVDISCARD_NONREF

+ const AVERROR_BSF_NOT_FOUND

+ const AVERROR_BUFFER_TOO_SMALL

+ const AVERROR_BUG

+ const AVERROR_BUG2

+ const AVERROR_DECODER_NOT_FOUND

+ const AVERROR_DEMUXER_NOT_FOUND

+ const AVERROR_ENCODER_NOT_FOUND

+ const AVERROR_EOF

+ const AVERROR_EXIT

+ const AVERROR_EXPERIMENTAL

+ const AVERROR_EXTERNAL

+ const AVERROR_FILTER_NOT_FOUND

+ const AVERROR_HTTP_BAD_REQUEST

+ const AVERROR_HTTP_FORBIDDEN

+ const AVERROR_HTTP_NOT_FOUND

+ const AVERROR_HTTP_OTHER_4XX

+ const AVERROR_HTTP_SERVER_ERROR

+ const AVERROR_HTTP_UNAUTHORIZED

+ const AVERROR_INPUT_CHANGED

+ const AVERROR_INVALIDDATA

+ const AVERROR_MUXER_NOT_FOUND

+ const AVERROR_OPTION_NOT_FOUND

+ const AVERROR_OUTPUT_CHANGED

+ const AVERROR_PATCHWELCOME

+ const AVERROR_PROTOCOL_NOT_FOUND

+ const AVERROR_STREAM_NOT_FOUND

+ const AVERROR_UNKNOWN

+ const AVFILTER_AUTO_CONVERT_ALL

+ const AVFILTER_AUTO_CONVERT_NONE

+ const AVFILTER_CMD_FLAG_FAST

+ const AVFILTER_CMD_FLAG_ONE

+ const AVFILTER_FLAG_DYNAMIC_INPUTS

+ const AVFILTER_FLAG_DYNAMIC_OUTPUTS

+ const AVFILTER_FLAG_SLICE_THREADS

+ const AVFILTER_FLAG_SUPPORT_TIMELINE

+ const AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC

+ const AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL

+ const AVFILTER_THREAD_SLICE

+ const AVFMTCTX_NOHEADER

+ const AVFMTCTX_UNSEEKABLE

+ const AVFMT_ALLOW_FLUSH

+ const AVFMT_DURATION_FROM_BITRATE

+ const AVFMT_DURATION_FROM_PTS

+ const AVFMT_DURATION_FROM_STREAM

+ const AVFMT_EVENT_FLAG_METADATA_UPDATED

+ const AVFMT_FLAG_AUTO_BSF

+ const AVFMT_FLAG_BITEXACT

+ const AVFMT_FLAG_CUSTOM_IO

+ const AVFMT_FLAG_DISCARD_CORRUPT

+ const AVFMT_FLAG_FAST_SEEK

+ const AVFMT_FLAG_FLUSH_PACKETS

+ const AVFMT_FLAG_GENPTS

+ const AVFMT_FLAG_IGNDTS

+ const AVFMT_FLAG_IGNIDX

+ const AVFMT_FLAG_KEEP_SIDE_DATA

+ const AVFMT_FLAG_MP4A_LATM

+ const AVFMT_FLAG_NOBUFFER

+ const AVFMT_FLAG_NOFILLIN

+ const AVFMT_FLAG_NONBLOCK

+ const AVFMT_FLAG_NOPARSE

+ const AVFMT_FLAG_PRIV_OPT

+ const AVFMT_FLAG_SHORTEST

+ const AVFMT_FLAG_SORT_DTS

+ const AVFMT_GENERIC_INDEX

+ const AVFMT_GLOBALHEADER

+ const AVFMT_NEEDNUMBER

+ const AVFMT_NOBINSEARCH

+ const AVFMT_NODIMENSIONS

+ const AVFMT_NOFILE

+ const AVFMT_NOGENSEARCH

+ const AVFMT_NOSTREAMS

+ const AVFMT_NOTIMESTAMPS

+ const AVFMT_NO_BYTE_SEEK

+ const AVFMT_SEEK_TO_PTS

+ const AVFMT_SHOW_IDS

+ const AVFMT_TBCF_AUTO

+ const AVFMT_TBCF_DECODER

+ const AVFMT_TBCF_DEMUXER

+ const AVFMT_TBCF_R_FRAMERATE

+ const AVFMT_TS_DISCONT

+ const AVFMT_TS_NEGATIVE

+ const AVFMT_TS_NONSTRICT

+ const AVFMT_VARIABLE_FPS

+ const AVINDEX_DISCARD_FRAME

+ const AVINDEX_KEYFRAME

+ const AVIO_DATA_MARKER_BOUNDARY_POINT

+ const AVIO_DATA_MARKER_FLUSH_POINT

+ const AVIO_DATA_MARKER_HEADER

+ const AVIO_DATA_MARKER_SYNC_POINT

+ const AVIO_DATA_MARKER_TRAILER

+ const AVIO_DATA_MARKER_UNKNOWN

+ const AVIO_ENTRY_BLOCK_DEVICE

+ const AVIO_ENTRY_CHARACTER_DEVICE

+ const AVIO_ENTRY_DIRECTORY

+ const AVIO_ENTRY_FILE

+ const AVIO_ENTRY_NAMED_PIPE

+ const AVIO_ENTRY_SERVER

+ const AVIO_ENTRY_SHARE

+ const AVIO_ENTRY_SOCKET

+ const AVIO_ENTRY_SYMBOLIC_LINK

+ const AVIO_ENTRY_UNKNOWN

+ const AVIO_ENTRY_WORKGROUP

+ const AVIO_FLAG_DIRECT

+ const AVIO_FLAG_NONBLOCK

+ const AVIO_FLAG_READ

+ const AVIO_FLAG_READ_WRITE

+ const AVIO_FLAG_WRITE

+ const AVIO_SEEKABLE_NORMAL

+ const AVIO_SEEKABLE_TIME

+ const AVMEDIA_TYPE_ATTACHMENT

+ const AVMEDIA_TYPE_AUDIO

+ const AVMEDIA_TYPE_DATA

+ const AVMEDIA_TYPE_NB

+ const AVMEDIA_TYPE_SUBTITLE

+ const AVMEDIA_TYPE_UNKNOWN

+ const AVMEDIA_TYPE_VIDEO

+ const AVPROBE_SCORE_EXTENSION

+ const AVPROBE_SCORE_MAX

+ const AVPROBE_SCORE_MIME

+ const AVPROBE_SCORE_RETRY

+ const AVPROBE_SCORE_STREAM_RETRY

+ const AVSEEK_FLAG_ANY

+ const AVSEEK_FLAG_BACKWARD

+ const AVSEEK_FLAG_BYTE

+ const AVSEEK_FLAG_FRAME

+ const AVSEEK_FORCE

+ const AVSEEK_SIZE

+ const AVSTREAM_EVENT_FLAG_METADATA_UPDATED

+ const AVSTREAM_INIT_IN_INIT_OUTPUT

+ const AVSTREAM_INIT_IN_WRITE_HEADER

+ const AVSTREAM_PARSE_FULL

+ const AVSTREAM_PARSE_FULL_ONCE

+ const AVSTREAM_PARSE_FULL_RAW

+ const AVSTREAM_PARSE_HEADERS

+ const AVSTREAM_PARSE_NONE

+ const AVSTREAM_PARSE_TIMESTAMPS

+ const AV_AAC_ADTS_HEADER_SIZE

+ const AV_AFD_14_9

+ const AV_AFD_16_9

+ const AV_AFD_16_9_SP_14_9

+ const AV_AFD_4_3

+ const AV_AFD_4_3_SP_14_9

+ const AV_AFD_SAME

+ const AV_AFD_SP_4_3

+ const AV_APP_TO_DEV_GET_MUTE

+ const AV_APP_TO_DEV_GET_VOLUME

+ const AV_APP_TO_DEV_MUTE

+ const AV_APP_TO_DEV_NONE

+ const AV_APP_TO_DEV_PAUSE

+ const AV_APP_TO_DEV_PLAY

+ const AV_APP_TO_DEV_SET_VOLUME

+ const AV_APP_TO_DEV_TOGGLE_MUTE

+ const AV_APP_TO_DEV_TOGGLE_PAUSE

+ const AV_APP_TO_DEV_UNMUTE

+ const AV_APP_TO_DEV_WINDOW_REPAINT

+ const AV_APP_TO_DEV_WINDOW_SIZE

+ const AV_AUDIO_SERVICE_TYPE_COMMENTARY

+ const AV_AUDIO_SERVICE_TYPE_DIALOGUE

+ const AV_AUDIO_SERVICE_TYPE_EFFECTS

+ const AV_AUDIO_SERVICE_TYPE_EMERGENCY

+ const AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED

+ const AV_AUDIO_SERVICE_TYPE_KARAOKE

+ const AV_AUDIO_SERVICE_TYPE_MAIN

+ const AV_AUDIO_SERVICE_TYPE_NB

+ const AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED

+ const AV_AUDIO_SERVICE_TYPE_VOICE_OVER

+ const AV_BF_ROUNDS

+ const AV_BPRINT_SIZE_AUTOMATIC

+ const AV_BPRINT_SIZE_COUNT_ONLY

+ const AV_BPRINT_SIZE_UNLIMITED

+ const AV_BUFFERSINK_FLAG_NO_REQUEST

+ const AV_BUFFERSINK_FLAG_PEEK

+ const AV_BUFFERSRC_FLAG_KEEP_REF

+ const AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT

+ const AV_BUFFERSRC_FLAG_PUSH

+ const AV_BUFFER_FLAG_READONLY

+ const AV_CH_BACK_CENTER

+ const AV_CH_BACK_LEFT

+ const AV_CH_BACK_RIGHT

+ const AV_CH_FRONT_CENTER

+ const AV_CH_FRONT_LEFT

+ const AV_CH_FRONT_LEFT_OF_CENTER

+ const AV_CH_FRONT_RIGHT

+ const AV_CH_FRONT_RIGHT_OF_CENTER

+ const AV_CH_LAYOUT_2POINT1

+ const AV_CH_LAYOUT_2_1

+ const AV_CH_LAYOUT_2_2

+ const AV_CH_LAYOUT_3POINT1

+ const AV_CH_LAYOUT_4POINT0

+ const AV_CH_LAYOUT_4POINT1

+ const AV_CH_LAYOUT_5POINT0

+ const AV_CH_LAYOUT_5POINT0_BACK

+ const AV_CH_LAYOUT_5POINT1

+ const AV_CH_LAYOUT_5POINT1_BACK

+ const AV_CH_LAYOUT_6POINT0

+ const AV_CH_LAYOUT_6POINT0_FRONT

+ const AV_CH_LAYOUT_6POINT1

+ const AV_CH_LAYOUT_6POINT1_BACK

+ const AV_CH_LAYOUT_6POINT1_FRONT

+ const AV_CH_LAYOUT_7POINT0

+ const AV_CH_LAYOUT_7POINT0_FRONT

+ const AV_CH_LAYOUT_7POINT1

+ const AV_CH_LAYOUT_7POINT1_WIDE

+ const AV_CH_LAYOUT_7POINT1_WIDE_BACK

+ const AV_CH_LAYOUT_HEXADECAGONAL

+ const AV_CH_LAYOUT_HEXAGONAL

+ const AV_CH_LAYOUT_MAX_STRING_SIZE

+ const AV_CH_LAYOUT_MONO

+ const AV_CH_LAYOUT_NATIVE

+ const AV_CH_LAYOUT_OCTAGONAL

+ const AV_CH_LAYOUT_QUAD

+ const AV_CH_LAYOUT_STEREO

+ const AV_CH_LAYOUT_STEREO_DOWNMIX

+ const AV_CH_LAYOUT_SURROUND

+ const AV_CH_LOW_FREQUENCY

+ const AV_CH_LOW_FREQUENCY_2

+ const AV_CH_SIDE_LEFT

+ const AV_CH_SIDE_RIGHT

+ const AV_CH_STEREO_LEFT

+ const AV_CH_STEREO_RIGHT

+ const AV_CH_SURROUND_DIRECT_LEFT

+ const AV_CH_SURROUND_DIRECT_RIGHT

+ const AV_CH_TOP_BACK_CENTER

+ const AV_CH_TOP_BACK_LEFT

+ const AV_CH_TOP_BACK_RIGHT

+ const AV_CH_TOP_CENTER

+ const AV_CH_TOP_FRONT_CENTER

+ const AV_CH_TOP_FRONT_LEFT

+ const AV_CH_TOP_FRONT_RIGHT

+ const AV_CH_WIDE_LEFT

+ const AV_CH_WIDE_RIGHT

+ const AV_CLASS_CATEGORY_BITSTREAM_FILTER

+ const AV_CLASS_CATEGORY_DECODER

+ const AV_CLASS_CATEGORY_DEMUXER

+ const AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT

+ const AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT

+ const AV_CLASS_CATEGORY_DEVICE_INPUT

+ const AV_CLASS_CATEGORY_DEVICE_OUTPUT

+ const AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT

+ const AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT

+ const AV_CLASS_CATEGORY_ENCODER

+ const AV_CLASS_CATEGORY_FILTER

+ const AV_CLASS_CATEGORY_INPUT

+ const AV_CLASS_CATEGORY_MUXER

+ const AV_CLASS_CATEGORY_NA

+ const AV_CLASS_CATEGORY_NB

+ const AV_CLASS_CATEGORY_OUTPUT

+ const AV_CLASS_CATEGORY_SWRESAMPLER

+ const AV_CLASS_CATEGORY_SWSCALER

+ const AV_CODEC_CAP_AUTO_THREADS

+ const AV_CODEC_CAP_AVOID_PROBING

+ const AV_CODEC_CAP_CHANNEL_CONF

+ const AV_CODEC_CAP_DELAY

+ const AV_CODEC_CAP_DR1

+ const AV_CODEC_CAP_DRAW_HORIZ_BAND

+ const AV_CODEC_CAP_EXPERIMENTAL

+ const AV_CODEC_CAP_FRAME_THREADS

+ const AV_CODEC_CAP_HARDWARE

+ const AV_CODEC_CAP_HYBRID

+ const AV_CODEC_CAP_INTRA_ONLY

+ const AV_CODEC_CAP_LOSSLESS

+ const AV_CODEC_CAP_PARAM_CHANGE

+ const AV_CODEC_CAP_SLICE_THREADS

+ const AV_CODEC_CAP_SMALL_LAST_FRAME

+ const AV_CODEC_CAP_SUBFRAMES

+ const AV_CODEC_CAP_TRUNCATED

+ const AV_CODEC_CAP_VARIABLE_FRAME_SIZE

+ const AV_CODEC_FLAG2_CHUNKS

+ const AV_CODEC_FLAG2_DROP_FRAME_TIMECODE

+ const AV_CODEC_FLAG2_EXPORT_MVS

+ const AV_CODEC_FLAG2_FAST

+ const AV_CODEC_FLAG2_IGNORE_CROP

+ const AV_CODEC_FLAG2_LOCAL_HEADER

+ const AV_CODEC_FLAG2_NO_OUTPUT

+ const AV_CODEC_FLAG2_RO_FLUSH_NOOP

+ const AV_CODEC_FLAG2_SHOW_ALL

+ const AV_CODEC_FLAG2_SKIP_MANUAL

+ const AV_CODEC_FLAG_4MV

+ const AV_CODEC_FLAG_AC_PRED

+ const AV_CODEC_FLAG_BITEXACT

+ const AV_CODEC_FLAG_CLOSED_GOP

+ const AV_CODEC_FLAG_GLOBAL_HEADER

+ const AV_CODEC_FLAG_GRAY

+ const AV_CODEC_FLAG_INTERLACED_DCT

+ const AV_CODEC_FLAG_INTERLACED_ME

+ const AV_CODEC_FLAG_LOOP_FILTER

+ const AV_CODEC_FLAG_LOW_DELAY

+ const AV_CODEC_FLAG_OUTPUT_CORRUPT

+ const AV_CODEC_FLAG_PASS1

+ const AV_CODEC_FLAG_PASS2

+ const AV_CODEC_FLAG_PSNR

+ const AV_CODEC_FLAG_QPEL

+ const AV_CODEC_FLAG_QSCALE

+ const AV_CODEC_FLAG_TRUNCATED

+ const AV_CODEC_FLAG_UNALIGNED

+ const AV_CODEC_HW_CONFIG_METHOD_AD_HOC

+ const AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX

+ const AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX

+ const AV_CODEC_HW_CONFIG_METHOD_INTERNAL

+ const AV_CODEC_ID_012V

+ const AV_CODEC_ID_4GV

+ const AV_CODEC_ID_4XM

+ const AV_CODEC_ID_8BPS

+ const AV_CODEC_ID_8SVX_EXP

+ const AV_CODEC_ID_8SVX_FIB

+ const AV_CODEC_ID_A64_MULTI

+ const AV_CODEC_ID_A64_MULTI5

+ const AV_CODEC_ID_AAC

+ const AV_CODEC_ID_AAC_LATM

+ const AV_CODEC_ID_AASC

+ const AV_CODEC_ID_AC3

+ const AV_CODEC_ID_ADPCM_4XM

+ const AV_CODEC_ID_ADPCM_ADX

+ const AV_CODEC_ID_ADPCM_AFC

+ const AV_CODEC_ID_ADPCM_AICA

+ const AV_CODEC_ID_ADPCM_CT

+ const AV_CODEC_ID_ADPCM_DTK

+ const AV_CODEC_ID_ADPCM_EA

+ const AV_CODEC_ID_ADPCM_EA_MAXIS_XA

+ const AV_CODEC_ID_ADPCM_EA_R1

+ const AV_CODEC_ID_ADPCM_EA_R2

+ const AV_CODEC_ID_ADPCM_EA_R3

+ const AV_CODEC_ID_ADPCM_EA_XAS

+ const AV_CODEC_ID_ADPCM_G722

+ const AV_CODEC_ID_ADPCM_G726

+ const AV_CODEC_ID_ADPCM_G726LE

+ const AV_CODEC_ID_ADPCM_IMA_AMV

+ const AV_CODEC_ID_ADPCM_IMA_APC

+ const AV_CODEC_ID_ADPCM_IMA_DAT4

+ const AV_CODEC_ID_ADPCM_IMA_DK3

+ const AV_CODEC_ID_ADPCM_IMA_DK4

+ const AV_CODEC_ID_ADPCM_IMA_EA_EACS

+ const AV_CODEC_ID_ADPCM_IMA_EA_SEAD

+ const AV_CODEC_ID_ADPCM_IMA_ISS

+ const AV_CODEC_ID_ADPCM_IMA_OKI

+ const AV_CODEC_ID_ADPCM_IMA_QT

+ const AV_CODEC_ID_ADPCM_IMA_RAD

+ const AV_CODEC_ID_ADPCM_IMA_SMJPEG

+ const AV_CODEC_ID_ADPCM_IMA_WAV

+ const AV_CODEC_ID_ADPCM_IMA_WS

+ const AV_CODEC_ID_ADPCM_MS

+ const AV_CODEC_ID_ADPCM_MTAF

+ const AV_CODEC_ID_ADPCM_PSX

+ const AV_CODEC_ID_ADPCM_SBPRO_2

+ const AV_CODEC_ID_ADPCM_SBPRO_3

+ const AV_CODEC_ID_ADPCM_SBPRO_4

+ const AV_CODEC_ID_ADPCM_SWF

+ const AV_CODEC_ID_ADPCM_THP

+ const AV_CODEC_ID_ADPCM_THP_LE

+ const AV_CODEC_ID_ADPCM_VIMA

+ const AV_CODEC_ID_ADPCM_XA

+ const AV_CODEC_ID_ADPCM_YAMAHA

+ const AV_CODEC_ID_AIC

+ const AV_CODEC_ID_ALAC

+ const AV_CODEC_ID_ALIAS_PIX

+ const AV_CODEC_ID_AMR_NB

+ const AV_CODEC_ID_AMR_WB

+ const AV_CODEC_ID_AMV

+ const AV_CODEC_ID_ANM

+ const AV_CODEC_ID_ANSI

+ const AV_CODEC_ID_APE

+ const AV_CODEC_ID_APNG

+ const AV_CODEC_ID_APTX

+ const AV_CODEC_ID_APTX_HD

+ const AV_CODEC_ID_ASS

+ const AV_CODEC_ID_ASV1

+ const AV_CODEC_ID_ASV2

+ const AV_CODEC_ID_ATRAC1

+ const AV_CODEC_ID_ATRAC3

+ const AV_CODEC_ID_ATRAC3AL

+ const AV_CODEC_ID_ATRAC3P

+ const AV_CODEC_ID_ATRAC3PAL

+ const AV_CODEC_ID_AURA

+ const AV_CODEC_ID_AURA2

+ const AV_CODEC_ID_AV1

+ const AV_CODEC_ID_AVRN

+ const AV_CODEC_ID_AVRP

+ const AV_CODEC_ID_AVS

+ const AV_CODEC_ID_AVUI

+ const AV_CODEC_ID_AYUV

+ const AV_CODEC_ID_BETHSOFTVID

+ const AV_CODEC_ID_BFI

+ const AV_CODEC_ID_BINKAUDIO_DCT

+ const AV_CODEC_ID_BINKAUDIO_RDFT

+ const AV_CODEC_ID_BINKVIDEO

+ const AV_CODEC_ID_BINTEXT

+ const AV_CODEC_ID_BIN_DATA

+ const AV_CODEC_ID_BITPACKED

+ const AV_CODEC_ID_BMP

+ const AV_CODEC_ID_BMV_AUDIO

+ const AV_CODEC_ID_BMV_VIDEO

+ const AV_CODEC_ID_BRENDER_PIX

+ const AV_CODEC_ID_C93

+ const AV_CODEC_ID_CAVS

+ const AV_CODEC_ID_CDGRAPHICS

+ const AV_CODEC_ID_CDXL

+ const AV_CODEC_ID_CELT

+ const AV_CODEC_ID_CFHD

+ const AV_CODEC_ID_CINEPAK

+ const AV_CODEC_ID_CLEARVIDEO

+ const AV_CODEC_ID_CLJR

+ const AV_CODEC_ID_CLLC

+ const AV_CODEC_ID_CMV

+ const AV_CODEC_ID_CODEC2

+ const AV_CODEC_ID_COMFORT_NOISE

+ const AV_CODEC_ID_COOK

+ const AV_CODEC_ID_CPIA

+ const AV_CODEC_ID_CSCD

+ const AV_CODEC_ID_CYUV

+ const AV_CODEC_ID_DAALA

+ const AV_CODEC_ID_DDS

+ const AV_CODEC_ID_DFA

+ const AV_CODEC_ID_DIRAC

+ const AV_CODEC_ID_DNXHD

+ const AV_CODEC_ID_DOLBY_E

+ const AV_CODEC_ID_DPX

+ const AV_CODEC_ID_DSD_LSBF

+ const AV_CODEC_ID_DSD_LSBF_PLANAR

+ const AV_CODEC_ID_DSD_MSBF

+ const AV_CODEC_ID_DSD_MSBF_PLANAR

+ const AV_CODEC_ID_DSICINAUDIO

+ const AV_CODEC_ID_DSICINVIDEO

+ const AV_CODEC_ID_DSS_SP

+ const AV_CODEC_ID_DST

+ const AV_CODEC_ID_DTS

+ const AV_CODEC_ID_DVAUDIO

+ const AV_CODEC_ID_DVB_SUBTITLE

+ const AV_CODEC_ID_DVB_TELETEXT

+ const AV_CODEC_ID_DVD_NAV

+ const AV_CODEC_ID_DVD_SUBTITLE

+ const AV_CODEC_ID_DVVIDEO

+ const AV_CODEC_ID_DXA

+ const AV_CODEC_ID_DXTORY

+ const AV_CODEC_ID_DXV

+ const AV_CODEC_ID_EAC3

+ const AV_CODEC_ID_EIA_608

+ const AV_CODEC_ID_ESCAPE124

+ const AV_CODEC_ID_ESCAPE130

+ const AV_CODEC_ID_EVRC

+ const AV_CODEC_ID_EXR

+ const AV_CODEC_ID_FFMETADATA

+ const AV_CODEC_ID_FFV1

+ const AV_CODEC_ID_FFVHUFF

+ const AV_CODEC_ID_FFWAVESYNTH

+ const AV_CODEC_ID_FIC

+ const AV_CODEC_ID_FIRST_AUDIO

+ const AV_CODEC_ID_FIRST_SUBTITLE

+ const AV_CODEC_ID_FIRST_UNKNOWN

+ const AV_CODEC_ID_FITS

+ const AV_CODEC_ID_FLAC

+ const AV_CODEC_ID_FLASHSV

+ const AV_CODEC_ID_FLASHSV2

+ const AV_CODEC_ID_FLIC

+ const AV_CODEC_ID_FLV1

+ const AV_CODEC_ID_FMVC

+ const AV_CODEC_ID_FRAPS

+ const AV_CODEC_ID_FRWU

+ const AV_CODEC_ID_G2M

+ const AV_CODEC_ID_G723_1

+ const AV_CODEC_ID_G729

+ const AV_CODEC_ID_GDV

+ const AV_CODEC_ID_GIF

+ const AV_CODEC_ID_GREMLIN_DPCM

+ const AV_CODEC_ID_GSM

+ const AV_CODEC_ID_GSM_MS

+ const AV_CODEC_ID_H261

+ const AV_CODEC_ID_H263

+ const AV_CODEC_ID_H263I

+ const AV_CODEC_ID_H263P

+ const AV_CODEC_ID_H264

+ const AV_CODEC_ID_H265

+ const AV_CODEC_ID_HAP

+ const AV_CODEC_ID_HDMV_PGS_SUBTITLE

+ const AV_CODEC_ID_HDMV_TEXT_SUBTITLE

+ const AV_CODEC_ID_HEVC

+ const AV_CODEC_ID_HNM4_VIDEO

+ const AV_CODEC_ID_HQX

+ const AV_CODEC_ID_HQ_HQA

+ const AV_CODEC_ID_HUFFYUV

+ const AV_CODEC_ID_IAC

+ const AV_CODEC_ID_IDCIN

+ const AV_CODEC_ID_IDF

+ const AV_CODEC_ID_IFF_BYTERUN1

+ const AV_CODEC_ID_IFF_ILBM

+ const AV_CODEC_ID_ILBC

+ const AV_CODEC_ID_IMC

+ const AV_CODEC_ID_INDEO2

+ const AV_CODEC_ID_INDEO3

+ const AV_CODEC_ID_INDEO4

+ const AV_CODEC_ID_INDEO5

+ const AV_CODEC_ID_INTERPLAY_ACM

+ const AV_CODEC_ID_INTERPLAY_DPCM

+ const AV_CODEC_ID_INTERPLAY_VIDEO

+ const AV_CODEC_ID_JACOSUB

+ const AV_CODEC_ID_JPEG2000

+ const AV_CODEC_ID_JPEGLS

+ const AV_CODEC_ID_JV

+ const AV_CODEC_ID_KGV1

+ const AV_CODEC_ID_KMVC

+ const AV_CODEC_ID_LAGARITH

+ const AV_CODEC_ID_LJPEG

+ const AV_CODEC_ID_LOCO

+ const AV_CODEC_ID_M101

+ const AV_CODEC_ID_MACE3

+ const AV_CODEC_ID_MACE6

+ const AV_CODEC_ID_MAD

+ const AV_CODEC_ID_MAGICYUV

+ const AV_CODEC_ID_MDEC

+ const AV_CODEC_ID_METASOUND

+ const AV_CODEC_ID_MICRODVD

+ const AV_CODEC_ID_MIMIC

+ const AV_CODEC_ID_MJPEG

+ const AV_CODEC_ID_MJPEGB

+ const AV_CODEC_ID_MLP

+ const AV_CODEC_ID_MMVIDEO

+ const AV_CODEC_ID_MOTIONPIXELS

+ const AV_CODEC_ID_MOV_TEXT

+ const AV_CODEC_ID_MP1

+ const AV_CODEC_ID_MP2

+ const AV_CODEC_ID_MP3

+ const AV_CODEC_ID_MP3ADU

+ const AV_CODEC_ID_MP3ON4

+ const AV_CODEC_ID_MP4ALS

+ const AV_CODEC_ID_MPEG1VIDEO

+ const AV_CODEC_ID_MPEG2TS

+ const AV_CODEC_ID_MPEG2VIDEO

+ const AV_CODEC_ID_MPEG4

+ const AV_CODEC_ID_MPEG4SYSTEMS

+ const AV_CODEC_ID_MPL2

+ const AV_CODEC_ID_MSA1

+ const AV_CODEC_ID_MSCC

+ const AV_CODEC_ID_MSMPEG4V1

+ const AV_CODEC_ID_MSMPEG4V2

+ const AV_CODEC_ID_MSMPEG4V3

+ const AV_CODEC_ID_MSRLE

+ const AV_CODEC_ID_MSS1

+ const AV_CODEC_ID_MSS2

+ const AV_CODEC_ID_MSVIDEO1

+ const AV_CODEC_ID_MSZH

+ const AV_CODEC_ID_MTS2

+ const AV_CODEC_ID_MUSEPACK7

+ const AV_CODEC_ID_MUSEPACK8

+ const AV_CODEC_ID_MVC1

+ const AV_CODEC_ID_MVC2

+ const AV_CODEC_ID_MXPEG

+ const AV_CODEC_ID_NELLYMOSER

+ const AV_CODEC_ID_NONE

+ const AV_CODEC_ID_NUV

+ const AV_CODEC_ID_ON2AVC

+ const AV_CODEC_ID_OPUS

+ const AV_CODEC_ID_OTF

+ const AV_CODEC_ID_PAF_AUDIO

+ const AV_CODEC_ID_PAF_VIDEO

+ const AV_CODEC_ID_PAM

+ const AV_CODEC_ID_PBM

+ const AV_CODEC_ID_PCM_ALAW

+ const AV_CODEC_ID_PCM_BLURAY

+ const AV_CODEC_ID_PCM_DVD

+ const AV_CODEC_ID_PCM_F16LE

+ const AV_CODEC_ID_PCM_F24LE

+ const AV_CODEC_ID_PCM_F32BE

+ const AV_CODEC_ID_PCM_F32LE

+ const AV_CODEC_ID_PCM_F64BE

+ const AV_CODEC_ID_PCM_F64LE

+ const AV_CODEC_ID_PCM_LXF

+ const AV_CODEC_ID_PCM_MULAW

+ const AV_CODEC_ID_PCM_S16BE

+ const AV_CODEC_ID_PCM_S16BE_PLANAR

+ const AV_CODEC_ID_PCM_S16LE

+ const AV_CODEC_ID_PCM_S16LE_PLANAR

+ const AV_CODEC_ID_PCM_S24BE

+ const AV_CODEC_ID_PCM_S24DAUD

+ const AV_CODEC_ID_PCM_S24LE

+ const AV_CODEC_ID_PCM_S24LE_PLANAR

+ const AV_CODEC_ID_PCM_S32BE

+ const AV_CODEC_ID_PCM_S32LE

+ const AV_CODEC_ID_PCM_S32LE_PLANAR

+ const AV_CODEC_ID_PCM_S64BE

+ const AV_CODEC_ID_PCM_S64LE

+ const AV_CODEC_ID_PCM_S8

+ const AV_CODEC_ID_PCM_S8_PLANAR

+ const AV_CODEC_ID_PCM_U16BE

+ const AV_CODEC_ID_PCM_U16LE

+ const AV_CODEC_ID_PCM_U24BE

+ const AV_CODEC_ID_PCM_U24LE

+ const AV_CODEC_ID_PCM_U32BE

+ const AV_CODEC_ID_PCM_U32LE

+ const AV_CODEC_ID_PCM_U8

+ const AV_CODEC_ID_PCM_ZORK

+ const AV_CODEC_ID_PCX

+ const AV_CODEC_ID_PGM

+ const AV_CODEC_ID_PGMYUV

+ const AV_CODEC_ID_PICTOR

+ const AV_CODEC_ID_PIXLET

+ const AV_CODEC_ID_PJS

+ const AV_CODEC_ID_PNG

+ const AV_CODEC_ID_PPM

+ const AV_CODEC_ID_PROBE

+ const AV_CODEC_ID_PRORES

+ const AV_CODEC_ID_PSD

+ const AV_CODEC_ID_PTX

+ const AV_CODEC_ID_QCELP

+ const AV_CODEC_ID_QDM2

+ const AV_CODEC_ID_QDMC

+ const AV_CODEC_ID_QDRAW

+ const AV_CODEC_ID_QPEG

+ const AV_CODEC_ID_QTRLE

+ const AV_CODEC_ID_R10K

+ const AV_CODEC_ID_R210

+ const AV_CODEC_ID_RALF

+ const AV_CODEC_ID_RAWVIDEO

+ const AV_CODEC_ID_RA_144

+ const AV_CODEC_ID_RA_288

+ const AV_CODEC_ID_REALTEXT

+ const AV_CODEC_ID_RL2

+ const AV_CODEC_ID_ROQ

+ const AV_CODEC_ID_ROQ_DPCM

+ const AV_CODEC_ID_RPZA

+ const AV_CODEC_ID_RSCC

+ const AV_CODEC_ID_RV10

+ const AV_CODEC_ID_RV20

+ const AV_CODEC_ID_RV30

+ const AV_CODEC_ID_RV40

+ const AV_CODEC_ID_S302M

+ const AV_CODEC_ID_SAMI

+ const AV_CODEC_ID_SANM

+ const AV_CODEC_ID_SBC

+ const AV_CODEC_ID_SCPR

+ const AV_CODEC_ID_SCREENPRESSO

+ const AV_CODEC_ID_SCTE_35

+ const AV_CODEC_ID_SDX2_DPCM

+ const AV_CODEC_ID_SGI

+ const AV_CODEC_ID_SGIRLE

+ const AV_CODEC_ID_SHEERVIDEO

+ const AV_CODEC_ID_SHORTEN

+ const AV_CODEC_ID_SIPR

+ const AV_CODEC_ID_SMACKAUDIO

+ const AV_CODEC_ID_SMACKVIDEO

+ const AV_CODEC_ID_SMC

+ const AV_CODEC_ID_SMPTE_KLV

+ const AV_CODEC_ID_SMV

+ const AV_CODEC_ID_SMVJPEG

+ const AV_CODEC_ID_SNOW

+ const AV_CODEC_ID_SOL_DPCM

+ const AV_CODEC_ID_SONIC

+ const AV_CODEC_ID_SONIC_LS

+ const AV_CODEC_ID_SP5X

+ const AV_CODEC_ID_SPEEDHQ

+ const AV_CODEC_ID_SPEEX

+ const AV_CODEC_ID_SRGC

+ const AV_CODEC_ID_SRT

+ const AV_CODEC_ID_SSA

+ const AV_CODEC_ID_STL

+ const AV_CODEC_ID_SUBRIP

+ const AV_CODEC_ID_SUBVIEWER

+ const AV_CODEC_ID_SUBVIEWER1

+ const AV_CODEC_ID_SUNRAST

+ const AV_CODEC_ID_SVG

+ const AV_CODEC_ID_SVQ1

+ const AV_CODEC_ID_SVQ3

+ const AV_CODEC_ID_TAK

+ const AV_CODEC_ID_TARGA

+ const AV_CODEC_ID_TARGA_Y216

+ const AV_CODEC_ID_TDSC

+ const AV_CODEC_ID_TEXT

+ const AV_CODEC_ID_TGQ

+ const AV_CODEC_ID_TGV

+ const AV_CODEC_ID_THEORA

+ const AV_CODEC_ID_THP

+ const AV_CODEC_ID_TIERTEXSEQVIDEO

+ const AV_CODEC_ID_TIFF

+ const AV_CODEC_ID_TIMED_ID3

+ const AV_CODEC_ID_TMV

+ const AV_CODEC_ID_TQI

+ const AV_CODEC_ID_TRUEHD

+ const AV_CODEC_ID_TRUEMOTION1

+ const AV_CODEC_ID_TRUEMOTION2

+ const AV_CODEC_ID_TRUEMOTION2RT

+ const AV_CODEC_ID_TRUESPEECH

+ const AV_CODEC_ID_TSCC

+ const AV_CODEC_ID_TSCC2

+ const AV_CODEC_ID_TTA

+ const AV_CODEC_ID_TTF

+ const AV_CODEC_ID_TWINVQ

+ const AV_CODEC_ID_TXD

+ const AV_CODEC_ID_ULTI

+ const AV_CODEC_ID_UTVIDEO

+ const AV_CODEC_ID_V210

+ const AV_CODEC_ID_V210X

+ const AV_CODEC_ID_V308

+ const AV_CODEC_ID_V408

+ const AV_CODEC_ID_V410

+ const AV_CODEC_ID_VB

+ const AV_CODEC_ID_VBLE

+ const AV_CODEC_ID_VC1

+ const AV_CODEC_ID_VC1IMAGE

+ const AV_CODEC_ID_VCR1

+ const AV_CODEC_ID_VIXL

+ const AV_CODEC_ID_VMDAUDIO

+ const AV_CODEC_ID_VMDVIDEO

+ const AV_CODEC_ID_VMNC

+ const AV_CODEC_ID_VORBIS

+ const AV_CODEC_ID_VP3

+ const AV_CODEC_ID_VP5

+ const AV_CODEC_ID_VP6

+ const AV_CODEC_ID_VP6A

+ const AV_CODEC_ID_VP6F

+ const AV_CODEC_ID_VP7

+ const AV_CODEC_ID_VP8

+ const AV_CODEC_ID_VP9

+ const AV_CODEC_ID_VPLAYER

+ const AV_CODEC_ID_WAVPACK

+ const AV_CODEC_ID_WEBP

+ const AV_CODEC_ID_WEBVTT

+ const AV_CODEC_ID_WESTWOOD_SND1

+ const AV_CODEC_ID_WMALOSSLESS

+ const AV_CODEC_ID_WMAPRO

+ const AV_CODEC_ID_WMAV1

+ const AV_CODEC_ID_WMAV2

+ const AV_CODEC_ID_WMAVOICE

+ const AV_CODEC_ID_WMV1

+ const AV_CODEC_ID_WMV2

+ const AV_CODEC_ID_WMV3

+ const AV_CODEC_ID_WMV3IMAGE

+ const AV_CODEC_ID_WNV1

+ const AV_CODEC_ID_WRAPPED_AVFRAME

+ const AV_CODEC_ID_WS_VQA

+ const AV_CODEC_ID_XAN_DPCM

+ const AV_CODEC_ID_XAN_WC3

+ const AV_CODEC_ID_XAN_WC4

+ const AV_CODEC_ID_XBIN

+ const AV_CODEC_ID_XBM

+ const AV_CODEC_ID_XFACE

+ const AV_CODEC_ID_XMA1

+ const AV_CODEC_ID_XMA2

+ const AV_CODEC_ID_XPM

+ const AV_CODEC_ID_XSUB

+ const AV_CODEC_ID_XWD

+ const AV_CODEC_ID_Y41P

+ const AV_CODEC_ID_YLC

+ const AV_CODEC_ID_YOP

+ const AV_CODEC_ID_YUV4

+ const AV_CODEC_ID_ZEROCODEC

+ const AV_CODEC_ID_ZLIB

+ const AV_CODEC_ID_ZMBV

+ const AV_CODEC_PROP_BITMAP_SUB

+ const AV_CODEC_PROP_INTRA_ONLY

+ const AV_CODEC_PROP_LOSSLESS

+ const AV_CODEC_PROP_LOSSY

+ const AV_CODEC_PROP_REORDER

+ const AV_CODEC_PROP_TEXT_SUB

+ const AV_CPU_FLAG_3DNOW

+ const AV_CPU_FLAG_3DNOWEXT

+ const AV_CPU_FLAG_AESNI

+ const AV_CPU_FLAG_ALTIVEC

+ const AV_CPU_FLAG_ARMV5TE

+ const AV_CPU_FLAG_ARMV6

+ const AV_CPU_FLAG_ARMV6T2

+ const AV_CPU_FLAG_ARMV8

+ const AV_CPU_FLAG_ATOM

+ const AV_CPU_FLAG_AVX

+ const AV_CPU_FLAG_AVX2

+ const AV_CPU_FLAG_AVX512

+ const AV_CPU_FLAG_AVXSLOW

+ const AV_CPU_FLAG_BMI1

+ const AV_CPU_FLAG_BMI2

+ const AV_CPU_FLAG_CMOV

+ const AV_CPU_FLAG_FMA3

+ const AV_CPU_FLAG_FMA4

+ const AV_CPU_FLAG_FORCE

+ const AV_CPU_FLAG_MMX

+ const AV_CPU_FLAG_MMX2

+ const AV_CPU_FLAG_MMXEXT

+ const AV_CPU_FLAG_NEON

+ const AV_CPU_FLAG_POWER8

+ const AV_CPU_FLAG_SETEND

+ const AV_CPU_FLAG_SSE

+ const AV_CPU_FLAG_SSE2

+ const AV_CPU_FLAG_SSE2SLOW

+ const AV_CPU_FLAG_SSE3

+ const AV_CPU_FLAG_SSE3SLOW

+ const AV_CPU_FLAG_SSE4

+ const AV_CPU_FLAG_SSE42

+ const AV_CPU_FLAG_SSSE3

+ const AV_CPU_FLAG_SSSE3SLOW

+ const AV_CPU_FLAG_VFP

+ const AV_CPU_FLAG_VFPV3

+ const AV_CPU_FLAG_VFP_VM

+ const AV_CPU_FLAG_VSX

+ const AV_CPU_FLAG_XOP

+ const AV_CRC_16_ANSI

+ const AV_CRC_16_ANSI_LE

+ const AV_CRC_16_CCITT

+ const AV_CRC_24_IEEE

+ const AV_CRC_32_IEEE

+ const AV_CRC_32_IEEE_LE

+ const AV_CRC_8_ATM

+ const AV_CRC_8_EBU

+ const AV_CRC_MAX

+ const AV_DEV_TO_APP_BUFFER_OVERFLOW

+ const AV_DEV_TO_APP_BUFFER_READABLE

+ const AV_DEV_TO_APP_BUFFER_UNDERFLOW

+ const AV_DEV_TO_APP_BUFFER_WRITABLE

+ const AV_DEV_TO_APP_CREATE_WINDOW_BUFFER

+ const AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER

+ const AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER

+ const AV_DEV_TO_APP_MUTE_STATE_CHANGED

+ const AV_DEV_TO_APP_NONE

+ const AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER

+ const AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED

+ const AV_DICT_APPEND

+ const AV_DICT_DONT_OVERWRITE

+ const AV_DICT_DONT_STRDUP_KEY

+ const AV_DICT_DONT_STRDUP_VAL

+ const AV_DICT_IGNORE_SUFFIX

+ const AV_DICT_MATCH_CASE

+ const AV_DICT_MULTIKEY

+ const AV_DISPOSITION_ATTACHED_PIC

+ const AV_DISPOSITION_CAPTIONS

+ const AV_DISPOSITION_CLEAN_EFFECTS

+ const AV_DISPOSITION_COMMENT

+ const AV_DISPOSITION_DEFAULT

+ const AV_DISPOSITION_DEPENDENT

+ const AV_DISPOSITION_DESCRIPTIONS

+ const AV_DISPOSITION_DUB

+ const AV_DISPOSITION_FORCED

+ const AV_DISPOSITION_HEARING_IMPAIRED

+ const AV_DISPOSITION_KARAOKE

+ const AV_DISPOSITION_LYRICS

+ const AV_DISPOSITION_METADATA

+ const AV_DISPOSITION_ORIGINAL

+ const AV_DISPOSITION_TIMED_THUMBNAILS

+ const AV_DISPOSITION_VISUAL_IMPAIRED

+ const AV_DOWNMIX_TYPE_DPLII

+ const AV_DOWNMIX_TYPE_LORO

+ const AV_DOWNMIX_TYPE_LTRT

+ const AV_DOWNMIX_TYPE_NB

+ const AV_DOWNMIX_TYPE_UNKNOWN

+ const AV_EF_AGGRESSIVE

+ const AV_EF_BITSTREAM

+ const AV_EF_BUFFER

+ const AV_EF_CAREFUL

+ const AV_EF_COMPLIANT

+ const AV_EF_CRCCHECK

+ const AV_EF_EXPLODE

+ const AV_EF_IGNORE_ERR

+ const AV_ERROR_MAX_STRING_SIZE

+ const AV_ESCAPE_FLAG_STRICT

+ const AV_ESCAPE_FLAG_WHITESPACE

+ const AV_ESCAPE_MODE_AUTO

+ const AV_ESCAPE_MODE_BACKSLASH

+ const AV_ESCAPE_MODE_QUOTE

+ const AV_FIELD_BB

+ const AV_FIELD_BT

+ const AV_FIELD_PROGRESSIVE

+ const AV_FIELD_TB

+ const AV_FIELD_TT

+ const AV_FIELD_UNKNOWN

+ const AV_FOURCC_MAX_STRING_SIZE

+ const AV_FRAME_CROP_UNALIGNED

+ const AV_FRAME_DATA_A53_CC

+ const AV_FRAME_DATA_AFD

+ const AV_FRAME_DATA_AUDIO_SERVICE_TYPE

+ const AV_FRAME_DATA_CONTENT_LIGHT_LEVEL

+ const AV_FRAME_DATA_DISPLAYMATRIX

+ const AV_FRAME_DATA_DOWNMIX_INFO

+ const AV_FRAME_DATA_GOP_TIMECODE

+ const AV_FRAME_DATA_ICC_PROFILE

+ const AV_FRAME_DATA_MASTERING_DISPLAY_METADATA

+ const AV_FRAME_DATA_MATRIXENCODING

+ const AV_FRAME_DATA_MOTION_VECTORS

+ const AV_FRAME_DATA_PANSCAN

+ const AV_FRAME_DATA_QP_TABLE_DATA

+ const AV_FRAME_DATA_QP_TABLE_PROPERTIES

+ const AV_FRAME_DATA_REPLAYGAIN

+ const AV_FRAME_DATA_SKIP_SAMPLES

+ const AV_FRAME_DATA_SPHERICAL

+ const AV_FRAME_DATA_STEREO3D

+ const AV_FRAME_FLAG_CORRUPT

+ const AV_FRAME_FLAG_DISCARD

+ const AV_GET_BUFFER_FLAG_REF

+ const AV_HASH_MAX_SIZE

+ const AV_HAVE_BIGENDIAN

+ const AV_HAVE_FAST_UNALIGNED

+ const AV_HMAC_MD5

+ const AV_HMAC_SHA1

+ const AV_HMAC_SHA224

+ const AV_HMAC_SHA256

+ const AV_HMAC_SHA384

+ const AV_HMAC_SHA512

+ const AV_HWACCEL_CODEC_CAP_EXPERIMENTAL

+ const AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH

+ const AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH

+ const AV_HWACCEL_FLAG_IGNORE_LEVEL

+ const AV_HWDEVICE_TYPE_CUDA

+ const AV_HWDEVICE_TYPE_D3D11VA

+ const AV_HWDEVICE_TYPE_DRM

+ const AV_HWDEVICE_TYPE_DXVA2

+ const AV_HWDEVICE_TYPE_MEDIACODEC

+ const AV_HWDEVICE_TYPE_NONE

+ const AV_HWDEVICE_TYPE_OPENCL

+ const AV_HWDEVICE_TYPE_QSV

+ const AV_HWDEVICE_TYPE_VAAPI

+ const AV_HWDEVICE_TYPE_VDPAU

+ const AV_HWDEVICE_TYPE_VIDEOTOOLBOX

+ const AV_HWFRAME_MAP_DIRECT

+ const AV_HWFRAME_MAP_OVERWRITE

+ const AV_HWFRAME_MAP_READ

+ const AV_HWFRAME_MAP_WRITE

+ const AV_HWFRAME_TRANSFER_DIRECTION_FROM

+ const AV_HWFRAME_TRANSFER_DIRECTION_TO

+ const AV_INPUT_BUFFER_MIN_SIZE

+ const AV_INPUT_BUFFER_PADDING_SIZE

+ const AV_LOCK_CREATE

+ const AV_LOCK_DESTROY

+ const AV_LOCK_OBTAIN

+ const AV_LOCK_RELEASE

+ const AV_LOG_DEBUG

+ const AV_LOG_ERROR

+ const AV_LOG_FATAL

+ const AV_LOG_INFO

+ const AV_LOG_MAX_OFFSET

+ const AV_LOG_PANIC

+ const AV_LOG_PRINT_LEVEL

+ const AV_LOG_QUIET

+ const AV_LOG_SKIP_REPEATED

+ const AV_LOG_TRACE

+ const AV_LOG_VERBOSE

+ const AV_LOG_WARNING

+ const AV_LZO_ERROR

+ const AV_LZO_INPUT_DEPLETED

+ const AV_LZO_INPUT_PADDING

+ const AV_LZO_INVALID_BACKPTR

+ const AV_LZO_OUTPUT_FULL

+ const AV_LZO_OUTPUT_PADDING

+ const AV_MATRIX_ENCODING_DOLBY

+ const AV_MATRIX_ENCODING_DOLBYEX

+ const AV_MATRIX_ENCODING_DOLBYHEADPHONE

+ const AV_MATRIX_ENCODING_DPLII

+ const AV_MATRIX_ENCODING_DPLIIX

+ const AV_MATRIX_ENCODING_DPLIIZ

+ const AV_MATRIX_ENCODING_NB

+ const AV_MATRIX_ENCODING_NONE

+ const AV_NOPTS_VALUE

+ const AV_NUM_DATA_POINTERS

+ const AV_OPT_ALLOW_NULL

+ const AV_OPT_FLAG_AUDIO_PARAM

+ const AV_OPT_FLAG_BSF_PARAM

+ const AV_OPT_FLAG_DECODING_PARAM

+ const AV_OPT_FLAG_ENCODING_PARAM

+ const AV_OPT_FLAG_EXPORT

+ const AV_OPT_FLAG_FILTERING_PARAM

+ const AV_OPT_FLAG_IMPLICIT_KEY

+ const AV_OPT_FLAG_READONLY

+ const AV_OPT_FLAG_SUBTITLE_PARAM

+ const AV_OPT_FLAG_VIDEO_PARAM

+ const AV_OPT_MULTI_COMPONENT_RANGE

+ const AV_OPT_SEARCH_CHILDREN

+ const AV_OPT_SEARCH_FAKE_OBJ

+ const AV_OPT_SERIALIZE_OPT_FLAGS_EXACT

+ const AV_OPT_SERIALIZE_SKIP_DEFAULTS

+ const AV_OPT_TYPE_BINARY

+ const AV_OPT_TYPE_BOOL

+ const AV_OPT_TYPE_CHANNEL_LAYOUT

+ const AV_OPT_TYPE_COLOR

+ const AV_OPT_TYPE_CONST

+ const AV_OPT_TYPE_DICT

+ const AV_OPT_TYPE_DOUBLE

+ const AV_OPT_TYPE_DURATION

+ const AV_OPT_TYPE_FLAGS

+ const AV_OPT_TYPE_FLOAT

+ const AV_OPT_TYPE_IMAGE_SIZE

+ const AV_OPT_TYPE_INT

+ const AV_OPT_TYPE_INT64

+ const AV_OPT_TYPE_PIXEL_FMT

+ const AV_OPT_TYPE_RATIONAL

+ const AV_OPT_TYPE_SAMPLE_FMT

+ const AV_OPT_TYPE_STRING

+ const AV_OPT_TYPE_UINT64

+ const AV_OPT_TYPE_VIDEO_RATE

+ const AV_PARSER_PTS_NB

+ const AV_PICTURE_STRUCTURE_BOTTOM_FIELD

+ const AV_PICTURE_STRUCTURE_FRAME

+ const AV_PICTURE_STRUCTURE_TOP_FIELD

+ const AV_PICTURE_STRUCTURE_UNKNOWN

+ const AV_PICTURE_TYPE_B

+ const AV_PICTURE_TYPE_BI

+ const AV_PICTURE_TYPE_I

+ const AV_PICTURE_TYPE_NONE

+ const AV_PICTURE_TYPE_P

+ const AV_PICTURE_TYPE_S

+ const AV_PICTURE_TYPE_SI

+ const AV_PICTURE_TYPE_SP

+ const AV_PIX_FMT_0BGR

+ const AV_PIX_FMT_0BGR32

+ const AV_PIX_FMT_0RGB

+ const AV_PIX_FMT_0RGB32

+ const AV_PIX_FMT_ABGR

+ const AV_PIX_FMT_ARGB

+ const AV_PIX_FMT_AYUV64

+ const AV_PIX_FMT_AYUV64BE

+ const AV_PIX_FMT_AYUV64LE

+ const AV_PIX_FMT_BAYER_BGGR16

+ const AV_PIX_FMT_BAYER_BGGR16BE

+ const AV_PIX_FMT_BAYER_BGGR16LE

+ const AV_PIX_FMT_BAYER_BGGR8

+ const AV_PIX_FMT_BAYER_GBRG16

+ const AV_PIX_FMT_BAYER_GBRG16BE

+ const AV_PIX_FMT_BAYER_GBRG16LE

+ const AV_PIX_FMT_BAYER_GBRG8

+ const AV_PIX_FMT_BAYER_GRBG16

+ const AV_PIX_FMT_BAYER_GRBG16BE

+ const AV_PIX_FMT_BAYER_GRBG16LE

+ const AV_PIX_FMT_BAYER_GRBG8

+ const AV_PIX_FMT_BAYER_RGGB16

+ const AV_PIX_FMT_BAYER_RGGB16BE

+ const AV_PIX_FMT_BAYER_RGGB16LE

+ const AV_PIX_FMT_BAYER_RGGB8

+ const AV_PIX_FMT_BGR0

+ const AV_PIX_FMT_BGR24

+ const AV_PIX_FMT_BGR32

+ const AV_PIX_FMT_BGR32_1

+ const AV_PIX_FMT_BGR4

+ const AV_PIX_FMT_BGR444

+ const AV_PIX_FMT_BGR444BE

+ const AV_PIX_FMT_BGR444LE

+ const AV_PIX_FMT_BGR48

+ const AV_PIX_FMT_BGR48BE

+ const AV_PIX_FMT_BGR48LE

+ const AV_PIX_FMT_BGR4_BYTE

+ const AV_PIX_FMT_BGR555

+ const AV_PIX_FMT_BGR555BE

+ const AV_PIX_FMT_BGR555LE

+ const AV_PIX_FMT_BGR565

+ const AV_PIX_FMT_BGR565BE

+ const AV_PIX_FMT_BGR565LE

+ const AV_PIX_FMT_BGR8

+ const AV_PIX_FMT_BGRA

+ const AV_PIX_FMT_BGRA64

+ const AV_PIX_FMT_BGRA64BE

+ const AV_PIX_FMT_BGRA64LE

+ const AV_PIX_FMT_CUDA

+ const AV_PIX_FMT_D3D11

+ const AV_PIX_FMT_D3D11VA_VLD

+ const AV_PIX_FMT_DRM_PRIME

+ const AV_PIX_FMT_DXVA2_VLD

+ const AV_PIX_FMT_FLAG_ALPHA

+ const AV_PIX_FMT_FLAG_BAYER

+ const AV_PIX_FMT_FLAG_BE

+ const AV_PIX_FMT_FLAG_BITSTREAM

+ const AV_PIX_FMT_FLAG_FLOAT

+ const AV_PIX_FMT_FLAG_HWACCEL

+ const AV_PIX_FMT_FLAG_PAL

+ const AV_PIX_FMT_FLAG_PLANAR

+ const AV_PIX_FMT_FLAG_PSEUDOPAL

+ const AV_PIX_FMT_FLAG_RGB

+ const AV_PIX_FMT_GBR24P

+ const AV_PIX_FMT_GBRAP

+ const AV_PIX_FMT_GBRAP10

+ const AV_PIX_FMT_GBRAP10BE

+ const AV_PIX_FMT_GBRAP10LE

+ const AV_PIX_FMT_GBRAP12

+ const AV_PIX_FMT_GBRAP12BE

+ const AV_PIX_FMT_GBRAP12LE

+ const AV_PIX_FMT_GBRAP16

+ const AV_PIX_FMT_GBRAP16BE

+ const AV_PIX_FMT_GBRAP16LE

+ const AV_PIX_FMT_GBRAPF32

+ const AV_PIX_FMT_GBRAPF32BE

+ const AV_PIX_FMT_GBRAPF32LE

+ const AV_PIX_FMT_GBRP

+ const AV_PIX_FMT_GBRP10

+ const AV_PIX_FMT_GBRP10BE

+ const AV_PIX_FMT_GBRP10LE

+ const AV_PIX_FMT_GBRP12

+ const AV_PIX_FMT_GBRP12BE

+ const AV_PIX_FMT_GBRP12LE

+ const AV_PIX_FMT_GBRP14

+ const AV_PIX_FMT_GBRP14BE

+ const AV_PIX_FMT_GBRP14LE

+ const AV_PIX_FMT_GBRP16

+ const AV_PIX_FMT_GBRP16BE

+ const AV_PIX_FMT_GBRP16LE

+ const AV_PIX_FMT_GBRP9

+ const AV_PIX_FMT_GBRP9BE

+ const AV_PIX_FMT_GBRP9LE

+ const AV_PIX_FMT_GBRPF32

+ const AV_PIX_FMT_GBRPF32BE

+ const AV_PIX_FMT_GBRPF32LE

+ const AV_PIX_FMT_GRAY10

+ const AV_PIX_FMT_GRAY10BE

+ const AV_PIX_FMT_GRAY10LE

+ const AV_PIX_FMT_GRAY12

+ const AV_PIX_FMT_GRAY12BE

+ const AV_PIX_FMT_GRAY12LE

+ const AV_PIX_FMT_GRAY16

+ const AV_PIX_FMT_GRAY16BE

+ const AV_PIX_FMT_GRAY16LE

+ const AV_PIX_FMT_GRAY8

+ const AV_PIX_FMT_GRAY8A

+ const AV_PIX_FMT_GRAY9

+ const AV_PIX_FMT_GRAY9BE

+ const AV_PIX_FMT_GRAY9LE

+ const AV_PIX_FMT_MEDIACODEC

+ const AV_PIX_FMT_MMAL

+ const AV_PIX_FMT_MONOBLACK

+ const AV_PIX_FMT_MONOWHITE

+ const AV_PIX_FMT_NB

+ const AV_PIX_FMT_NONE

+ const AV_PIX_FMT_NV12

+ const AV_PIX_FMT_NV16

+ const AV_PIX_FMT_NV20

+ const AV_PIX_FMT_NV20BE

+ const AV_PIX_FMT_NV20LE

+ const AV_PIX_FMT_NV21

+ const AV_PIX_FMT_OPENCL

+ const AV_PIX_FMT_P010

+ const AV_PIX_FMT_P010BE

+ const AV_PIX_FMT_P010LE

+ const AV_PIX_FMT_P016

+ const AV_PIX_FMT_P016BE

+ const AV_PIX_FMT_P016LE

+ const AV_PIX_FMT_PAL8

+ const AV_PIX_FMT_QSV

+ const AV_PIX_FMT_RGB0

+ const AV_PIX_FMT_RGB24

+ const AV_PIX_FMT_RGB32

+ const AV_PIX_FMT_RGB32_1

+ const AV_PIX_FMT_RGB4

+ const AV_PIX_FMT_RGB444

+ const AV_PIX_FMT_RGB444BE

+ const AV_PIX_FMT_RGB444LE

+ const AV_PIX_FMT_RGB48

+ const AV_PIX_FMT_RGB48BE

+ const AV_PIX_FMT_RGB48LE

+ const AV_PIX_FMT_RGB4_BYTE

+ const AV_PIX_FMT_RGB555

+ const AV_PIX_FMT_RGB555BE

+ const AV_PIX_FMT_RGB555LE

+ const AV_PIX_FMT_RGB565

+ const AV_PIX_FMT_RGB565BE

+ const AV_PIX_FMT_RGB565LE

+ const AV_PIX_FMT_RGB8

+ const AV_PIX_FMT_RGBA

+ const AV_PIX_FMT_RGBA64

+ const AV_PIX_FMT_RGBA64BE

+ const AV_PIX_FMT_RGBA64LE

+ const AV_PIX_FMT_UYVY422

+ const AV_PIX_FMT_UYYVYY411

+ const AV_PIX_FMT_VAAPI

+ const AV_PIX_FMT_VAAPI_IDCT

+ const AV_PIX_FMT_VAAPI_MOCO

+ const AV_PIX_FMT_VAAPI_VLD

+ const AV_PIX_FMT_VDPAU

+ const AV_PIX_FMT_VIDEOTOOLBOX

+ const AV_PIX_FMT_XVMC

+ const AV_PIX_FMT_XYZ12

+ const AV_PIX_FMT_XYZ12BE

+ const AV_PIX_FMT_XYZ12LE

+ const AV_PIX_FMT_Y400A

+ const AV_PIX_FMT_YA16

+ const AV_PIX_FMT_YA16BE

+ const AV_PIX_FMT_YA16LE

+ const AV_PIX_FMT_YA8

+ const AV_PIX_FMT_YUV410P

+ const AV_PIX_FMT_YUV411P

+ const AV_PIX_FMT_YUV420P

+ const AV_PIX_FMT_YUV420P10

+ const AV_PIX_FMT_YUV420P10BE

+ const AV_PIX_FMT_YUV420P10LE

+ const AV_PIX_FMT_YUV420P12

+ const AV_PIX_FMT_YUV420P12BE

+ const AV_PIX_FMT_YUV420P12LE

+ const AV_PIX_FMT_YUV420P14

+ const AV_PIX_FMT_YUV420P14BE

+ const AV_PIX_FMT_YUV420P14LE

+ const AV_PIX_FMT_YUV420P16

+ const AV_PIX_FMT_YUV420P16BE

+ const AV_PIX_FMT_YUV420P16LE

+ const AV_PIX_FMT_YUV420P9

+ const AV_PIX_FMT_YUV420P9BE

+ const AV_PIX_FMT_YUV420P9LE

+ const AV_PIX_FMT_YUV422P

+ const AV_PIX_FMT_YUV422P10

+ const AV_PIX_FMT_YUV422P10BE

+ const AV_PIX_FMT_YUV422P10LE

+ const AV_PIX_FMT_YUV422P12

+ const AV_PIX_FMT_YUV422P12BE

+ const AV_PIX_FMT_YUV422P12LE

+ const AV_PIX_FMT_YUV422P14

+ const AV_PIX_FMT_YUV422P14BE

+ const AV_PIX_FMT_YUV422P14LE

+ const AV_PIX_FMT_YUV422P16

+ const AV_PIX_FMT_YUV422P16BE

+ const AV_PIX_FMT_YUV422P16LE

+ const AV_PIX_FMT_YUV422P9

+ const AV_PIX_FMT_YUV422P9BE

+ const AV_PIX_FMT_YUV422P9LE

+ const AV_PIX_FMT_YUV440P

+ const AV_PIX_FMT_YUV440P10

+ const AV_PIX_FMT_YUV440P10BE

+ const AV_PIX_FMT_YUV440P10LE

+ const AV_PIX_FMT_YUV440P12

+ const AV_PIX_FMT_YUV440P12BE

+ const AV_PIX_FMT_YUV440P12LE

+ const AV_PIX_FMT_YUV444P

+ const AV_PIX_FMT_YUV444P10

+ const AV_PIX_FMT_YUV444P10BE

+ const AV_PIX_FMT_YUV444P10LE

+ const AV_PIX_FMT_YUV444P12

+ const AV_PIX_FMT_YUV444P12BE

+ const AV_PIX_FMT_YUV444P12LE

+ const AV_PIX_FMT_YUV444P14

+ const AV_PIX_FMT_YUV444P14BE

+ const AV_PIX_FMT_YUV444P14LE

+ const AV_PIX_FMT_YUV444P16

+ const AV_PIX_FMT_YUV444P16BE

+ const AV_PIX_FMT_YUV444P16LE

+ const AV_PIX_FMT_YUV444P9

+ const AV_PIX_FMT_YUV444P9BE

+ const AV_PIX_FMT_YUV444P9LE

+ const AV_PIX_FMT_YUVA420P

+ const AV_PIX_FMT_YUVA420P10

+ const AV_PIX_FMT_YUVA420P10BE

+ const AV_PIX_FMT_YUVA420P10LE

+ const AV_PIX_FMT_YUVA420P16

+ const AV_PIX_FMT_YUVA420P16BE

+ const AV_PIX_FMT_YUVA420P16LE

+ const AV_PIX_FMT_YUVA420P9

+ const AV_PIX_FMT_YUVA420P9BE

+ const AV_PIX_FMT_YUVA420P9LE

+ const AV_PIX_FMT_YUVA422P

+ const AV_PIX_FMT_YUVA422P10

+ const AV_PIX_FMT_YUVA422P10BE

+ const AV_PIX_FMT_YUVA422P10LE

+ const AV_PIX_FMT_YUVA422P16

+ const AV_PIX_FMT_YUVA422P16BE

+ const AV_PIX_FMT_YUVA422P16LE

+ const AV_PIX_FMT_YUVA422P9

+ const AV_PIX_FMT_YUVA422P9BE

+ const AV_PIX_FMT_YUVA422P9LE

+ const AV_PIX_FMT_YUVA444P

+ const AV_PIX_FMT_YUVA444P10

+ const AV_PIX_FMT_YUVA444P10BE

+ const AV_PIX_FMT_YUVA444P10LE

+ const AV_PIX_FMT_YUVA444P16

+ const AV_PIX_FMT_YUVA444P16BE

+ const AV_PIX_FMT_YUVA444P16LE

+ const AV_PIX_FMT_YUVA444P9

+ const AV_PIX_FMT_YUVA444P9BE

+ const AV_PIX_FMT_YUVA444P9LE

+ const AV_PIX_FMT_YUVJ411P

+ const AV_PIX_FMT_YUVJ420P

+ const AV_PIX_FMT_YUVJ422P

+ const AV_PIX_FMT_YUVJ440P

+ const AV_PIX_FMT_YUVJ444P

+ const AV_PIX_FMT_YUYV422

+ const AV_PIX_FMT_YVYU422

+ const AV_PKT_DATA_A53_CC

+ const AV_PKT_DATA_AUDIO_SERVICE_TYPE

+ const AV_PKT_DATA_CONTENT_LIGHT_LEVEL

+ const AV_PKT_DATA_CPB_PROPERTIES

+ const AV_PKT_DATA_DISPLAYMATRIX

+ const AV_PKT_DATA_ENCRYPTION_INFO

+ const AV_PKT_DATA_ENCRYPTION_INIT_INFO

+ const AV_PKT_DATA_FALLBACK_TRACK

+ const AV_PKT_DATA_H263_MB_INFO

+ const AV_PKT_DATA_JP_DUALMONO

+ const AV_PKT_DATA_MASTERING_DISPLAY_METADATA

+ const AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL

+ const AV_PKT_DATA_METADATA_UPDATE

+ const AV_PKT_DATA_MPEGTS_STREAM_ID

+ const AV_PKT_DATA_NB

+ const AV_PKT_DATA_NEW_EXTRADATA

+ const AV_PKT_DATA_PALETTE

+ const AV_PKT_DATA_PARAM_CHANGE

+ const AV_PKT_DATA_QUALITY_FACTOR

+ const AV_PKT_DATA_QUALITY_STATS

+ const AV_PKT_DATA_REPLAYGAIN

+ const AV_PKT_DATA_SKIP_SAMPLES

+ const AV_PKT_DATA_SPHERICAL

+ const AV_PKT_DATA_STEREO3D

+ const AV_PKT_DATA_STRINGS_METADATA

+ const AV_PKT_DATA_SUBTITLE_POSITION

+ const AV_PKT_DATA_WEBVTT_IDENTIFIER

+ const AV_PKT_DATA_WEBVTT_SETTINGS

+ const AV_PKT_FLAG_CORRUPT

+ const AV_PKT_FLAG_DISCARD

+ const AV_PKT_FLAG_DISPOSABLE

+ const AV_PKT_FLAG_KEY

+ const AV_PKT_FLAG_TRUSTED

+ const AV_PROGRAM_RUNNING

+ const AV_PTS_WRAP_ADD_OFFSET

+ const AV_PTS_WRAP_IGNORE

+ const AV_PTS_WRAP_SUB_OFFSET

+ const AV_ROUND_DOWN

+ const AV_ROUND_INF

+ const AV_ROUND_NEAR_INF

+ const AV_ROUND_PASS_MINMAX

+ const AV_ROUND_UP

+ const AV_ROUND_ZERO

+ const AV_SAMPLE_FMT_DBL

+ const AV_SAMPLE_FMT_DBLP

+ const AV_SAMPLE_FMT_FLT

+ const AV_SAMPLE_FMT_FLTP

+ const AV_SAMPLE_FMT_NB

+ const AV_SAMPLE_FMT_NONE

+ const AV_SAMPLE_FMT_S16

+ const AV_SAMPLE_FMT_S16P

+ const AV_SAMPLE_FMT_S32

+ const AV_SAMPLE_FMT_S32P

+ const AV_SAMPLE_FMT_S64

+ const AV_SAMPLE_FMT_S64P

+ const AV_SAMPLE_FMT_U8

+ const AV_SAMPLE_FMT_U8P

+ const AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT

+ const AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT

+ const AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS

+ const AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE

+ const AV_SPHERICAL_CUBEMAP

+ const AV_SPHERICAL_EQUIRECTANGULAR

+ const AV_SPHERICAL_EQUIRECTANGULAR_TILE

+ const AV_STEREO3D_2D

+ const AV_STEREO3D_CHECKERBOARD

+ const AV_STEREO3D_COLUMNS

+ const AV_STEREO3D_FLAG_INVERT

+ const AV_STEREO3D_FRAMESEQUENCE

+ const AV_STEREO3D_LINES

+ const AV_STEREO3D_SIDEBYSIDE

+ const AV_STEREO3D_SIDEBYSIDE_QUINCUNX

+ const AV_STEREO3D_TOPBOTTOM

+ const AV_STEREO3D_VIEW_LEFT

+ const AV_STEREO3D_VIEW_PACKED

+ const AV_STEREO3D_VIEW_RIGHT

+ const AV_SUBTITLE_FLAG_FORCED

+ const AV_THREAD_MESSAGE_NONBLOCK

+ const AV_TIMECODE_FLAG_24HOURSMAX

+ const AV_TIMECODE_FLAG_ALLOWNEGATIVE

+ const AV_TIMECODE_FLAG_DROPFRAME

+ const AV_TIMECODE_STR_SIZE

+ const AV_TIME_BASE

+ const AV_TS_MAX_STRING_SIZE

+ const AV_UTF8_FLAG_ACCEPT_ALL

+ const AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES

+ const AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS

+ const AV_UTF8_FLAG_ACCEPT_SURROGATES

+ const AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES

+ const DCT_I

+ const DCT_II

+ const DCT_III

+ const DFT_C2R

+ const DFT_R2C

+ const DIRAC_PCODE_AUX

+ const DIRAC_PCODE_END_SEQ

+ const DIRAC_PCODE_INTER_NOREF_CO1

+ const DIRAC_PCODE_INTER_NOREF_CO2

+ const DIRAC_PCODE_INTER_REF_CO1

+ const DIRAC_PCODE_INTER_REF_CO2

+ const DIRAC_PCODE_INTRA_REF_CO

+ const DIRAC_PCODE_INTRA_REF_PICT

+ const DIRAC_PCODE_INTRA_REF_RAW

+ const DIRAC_PCODE_MAGIC

+ const DIRAC_PCODE_PAD

+ const DIRAC_PCODE_PICTURE_CODED

+ const DIRAC_PCODE_PICTURE_HQ

+ const DIRAC_PCODE_PICTURE_LOW_DEL

+ const DIRAC_PCODE_PICTURE_RAW

+ const DIRAC_PCODE_SEQ_HEADER

+ const DST_I

+ const DV_PROFILE_BYTES

+ const FFMPEG_VERSION

+ const FF_BUG_AMV

+ const FF_BUG_AUTODETECT

+ const FF_BUG_DC_CLIP

+ const FF_BUG_DIRECT_BLOCKSIZE

+ const FF_BUG_EDGE

+ const FF_BUG_HPEL_CHROMA

+ const FF_BUG_IEDGE

+ const FF_BUG_MS

+ const FF_BUG_NO_PADDING

+ const FF_BUG_QPEL_CHROMA

+ const FF_BUG_QPEL_CHROMA2

+ const FF_BUG_STD_QPEL

+ const FF_BUG_TRUNCATED

+ const FF_BUG_UMP4

+ const FF_BUG_XVID_ILACE

+ const FF_CMP_BIT

+ const FF_CMP_CHROMA

+ const FF_CMP_DCT

+ const FF_CMP_DCT264

+ const FF_CMP_DCTMAX

+ const FF_CMP_MEDIAN_SAD

+ const FF_CMP_NSSE

+ const FF_CMP_PSNR

+ const FF_CMP_RD

+ const FF_CMP_SAD

+ const FF_CMP_SATD

+ const FF_CMP_SSE

+ const FF_CMP_VSAD

+ const FF_CMP_VSSE

+ const FF_CMP_W53

+ const FF_CMP_W97

+ const FF_CMP_ZERO

+ const FF_CODEC_PROPERTY_CLOSED_CAPTIONS

+ const FF_CODEC_PROPERTY_LOSSLESS

+ const FF_CODER_TYPE_AC

+ const FF_CODER_TYPE_RAW

+ const FF_CODER_TYPE_RLE

+ const FF_CODER_TYPE_VLC

+ const FF_COMPLIANCE_EXPERIMENTAL

+ const FF_COMPLIANCE_NORMAL

+ const FF_COMPLIANCE_STRICT

+ const FF_COMPLIANCE_UNOFFICIAL

+ const FF_COMPLIANCE_VERY_STRICT

+ const FF_DCT_ALTIVEC

+ const FF_DCT_AUTO

+ const FF_DCT_FAAN

+ const FF_DCT_FASTINT

+ const FF_DCT_INT

+ const FF_DCT_MMX

+ const FF_DEBUG_BITSTREAM

+ const FF_DEBUG_BUFFERS

+ const FF_DEBUG_BUGS

+ const FF_DEBUG_DCT_COEFF

+ const FF_DEBUG_ER

+ const FF_DEBUG_GREEN_MD

+ const FF_DEBUG_MB_TYPE

+ const FF_DEBUG_MMCO

+ const FF_DEBUG_NOMC

+ const FF_DEBUG_PICT_INFO

+ const FF_DEBUG_QP

+ const FF_DEBUG_RC

+ const FF_DEBUG_SKIP

+ const FF_DEBUG_STARTCODE

+ const FF_DEBUG_THREADS

+ const FF_DEBUG_VIS_MV_B_BACK

+ const FF_DEBUG_VIS_MV_B_FOR

+ const FF_DEBUG_VIS_MV_P_FOR

+ const FF_DECODE_ERROR_INVALID_BITSTREAM

+ const FF_DECODE_ERROR_MISSING_REFERENCE

+ const FF_EC_DEBLOCK

+ const FF_EC_FAVOR_INTER

+ const FF_EC_GUESS_MVS

+ const FF_IDCT_ALTIVEC

+ const FF_IDCT_ARM

+ const FF_IDCT_AUTO

+ const FF_IDCT_FAAN

+ const FF_IDCT_INT

+ const FF_IDCT_NONE

+ const FF_IDCT_SIMPLE

+ const FF_IDCT_SIMPLEARM

+ const FF_IDCT_SIMPLEARMV5TE

+ const FF_IDCT_SIMPLEARMV6

+ const FF_IDCT_SIMPLEAUTO

+ const FF_IDCT_SIMPLEMMX

+ const FF_IDCT_SIMPLENEON

+ const FF_IDCT_XVID

+ const FF_LAMBDA_MAX

+ const FF_LAMBDA_SCALE

+ const FF_LAMBDA_SHIFT

+ const FF_LOSS_ALPHA

+ const FF_LOSS_CHROMA

+ const FF_LOSS_COLORQUANT

+ const FF_LOSS_COLORSPACE

+ const FF_LOSS_DEPTH

+ const FF_LOSS_RESOLUTION

+ const FF_MB_DECISION_BITS

+ const FF_MB_DECISION_RD

+ const FF_MB_DECISION_SIMPLE

+ const FF_PRED_LEFT

+ const FF_PRED_MEDIAN

+ const FF_PRED_PLANE

+ const FF_PROFILE_AAC_ELD

+ const FF_PROFILE_AAC_HE

+ const FF_PROFILE_AAC_HE_V2

+ const FF_PROFILE_AAC_LD

+ const FF_PROFILE_AAC_LOW

+ const FF_PROFILE_AAC_LTP

+ const FF_PROFILE_AAC_MAIN

+ const FF_PROFILE_AAC_SSR

+ const FF_PROFILE_AV1_HIGH

+ const FF_PROFILE_AV1_MAIN

+ const FF_PROFILE_AV1_PROFESSIONAL

+ const FF_PROFILE_DNXHD

+ const FF_PROFILE_DNXHR_444

+ const FF_PROFILE_DNXHR_HQ

+ const FF_PROFILE_DNXHR_HQX

+ const FF_PROFILE_DNXHR_LB

+ const FF_PROFILE_DNXHR_SQ

+ const FF_PROFILE_DTS

+ const FF_PROFILE_DTS_96_24

+ const FF_PROFILE_DTS_ES

+ const FF_PROFILE_DTS_EXPRESS

+ const FF_PROFILE_DTS_HD_HRA

+ const FF_PROFILE_DTS_HD_MA

+ const FF_PROFILE_H264_BASELINE

+ const FF_PROFILE_H264_CAVLC_444

+ const FF_PROFILE_H264_CONSTRAINED

+ const FF_PROFILE_H264_CONSTRAINED_BASELINE

+ const FF_PROFILE_H264_EXTENDED

+ const FF_PROFILE_H264_HIGH

+ const FF_PROFILE_H264_HIGH_10

+ const FF_PROFILE_H264_HIGH_10_INTRA

+ const FF_PROFILE_H264_HIGH_422

+ const FF_PROFILE_H264_HIGH_422_INTRA

+ const FF_PROFILE_H264_HIGH_444

+ const FF_PROFILE_H264_HIGH_444_INTRA

+ const FF_PROFILE_H264_HIGH_444_PREDICTIVE

+ const FF_PROFILE_H264_INTRA

+ const FF_PROFILE_H264_MAIN

+ const FF_PROFILE_H264_MULTIVIEW_HIGH

+ const FF_PROFILE_H264_STEREO_HIGH

+ const FF_PROFILE_HEVC_MAIN

+ const FF_PROFILE_HEVC_MAIN_10

+ const FF_PROFILE_HEVC_MAIN_STILL_PICTURE

+ const FF_PROFILE_HEVC_REXT

+ const FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION

+ const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0

+ const FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1

+ const FF_PROFILE_JPEG2000_DCINEMA_2K

+ const FF_PROFILE_JPEG2000_DCINEMA_4K

+ const FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT

+ const FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT

+ const FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS

+ const FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT

+ const FF_PROFILE_MJPEG_JPEG_LS

+ const FF_PROFILE_MPEG2_422

+ const FF_PROFILE_MPEG2_AAC_HE

+ const FF_PROFILE_MPEG2_AAC_LOW

+ const FF_PROFILE_MPEG2_HIGH

+ const FF_PROFILE_MPEG2_MAIN

+ const FF_PROFILE_MPEG2_SIMPLE

+ const FF_PROFILE_MPEG2_SNR_SCALABLE

+ const FF_PROFILE_MPEG2_SS

+ const FF_PROFILE_MPEG4_ADVANCED_CODING

+ const FF_PROFILE_MPEG4_ADVANCED_CORE

+ const FF_PROFILE_MPEG4_ADVANCED_REAL_TIME

+ const FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE

+ const FF_PROFILE_MPEG4_ADVANCED_SIMPLE

+ const FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE

+ const FF_PROFILE_MPEG4_CORE

+ const FF_PROFILE_MPEG4_CORE_SCALABLE

+ const FF_PROFILE_MPEG4_HYBRID

+ const FF_PROFILE_MPEG4_MAIN

+ const FF_PROFILE_MPEG4_N_BIT

+ const FF_PROFILE_MPEG4_SCALABLE_TEXTURE

+ const FF_PROFILE_MPEG4_SIMPLE

+ const FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION

+ const FF_PROFILE_MPEG4_SIMPLE_SCALABLE

+ const FF_PROFILE_MPEG4_SIMPLE_STUDIO

+ const FF_PROFILE_RESERVED

+ const FF_PROFILE_SBC_MSBC

+ const FF_PROFILE_UNKNOWN

+ const FF_PROFILE_VC1_ADVANCED

+ const FF_PROFILE_VC1_COMPLEX

+ const FF_PROFILE_VC1_MAIN

+ const FF_PROFILE_VC1_SIMPLE

+ const FF_PROFILE_VP9_0

+ const FF_PROFILE_VP9_1

+ const FF_PROFILE_VP9_2

+ const FF_PROFILE_VP9_3

+ const FF_QP2LAMBDA

+ const FF_QUALITY_SCALE

+ const FF_SUB_CHARENC_MODE_AUTOMATIC

+ const FF_SUB_CHARENC_MODE_DO_NOTHING

+ const FF_SUB_CHARENC_MODE_IGNORE

+ const FF_SUB_CHARENC_MODE_PRE_DECODER

+ const FF_SUB_TEXT_FMT_ASS

+ const FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS

+ const FF_THREAD_FRAME

+ const FF_THREAD_SLICE

+ const IDFT_C2R

+ const IDFT_R2C

+ const INT_MIN

+ const LIBAVCODEC_VERSION_MAJOR

+ const LIBAVCODEC_VERSION_MICRO

+ const LIBAVCODEC_VERSION_MINOR

+ const LIBAVDEVICE_VERSION_MAJOR

+ const LIBAVDEVICE_VERSION_MICRO

+ const LIBAVDEVICE_VERSION_MINOR

+ const LIBAVFILTER_VERSION_MAJOR

+ const LIBAVFILTER_VERSION_MICRO

+ const LIBAVFILTER_VERSION_MINOR

+ const LIBAVFORMAT_VERSION_MAJOR

+ const LIBAVFORMAT_VERSION_MICRO

+ const LIBAVFORMAT_VERSION_MINOR

+ const LIBAVUTIL_VERSION_MAJOR

+ const LIBAVUTIL_VERSION_MICRO

+ const LIBAVUTIL_VERSION_MINOR

+ const LIBPOSTPROC_VERSION_MAJOR

+ const LIBPOSTPROC_VERSION_MICRO

+ const LIBPOSTPROC_VERSION_MINOR

+ const LIBSWRESAMPLE_VERSION_MAJOR

+ const LIBSWRESAMPLE_VERSION_MICRO

+ const LIBSWRESAMPLE_VERSION_MINOR

+ const LIBSWSCALE_VERSION_MAJOR

+ const LIBSWSCALE_VERSION_MICRO

+ const LIBSWSCALE_VERSION_MINOR

+ const MAX_DWT_LEVELS

+ const NIL

+ const PP_CPU_CAPS_3DNOW

+ const PP_CPU_CAPS_ALTIVEC

+ const PP_CPU_CAPS_AUTO

+ const PP_CPU_CAPS_MMX

+ const PP_CPU_CAPS_MMX2

+ const PP_FORMAT

+ const PP_FORMAT_411

+ const PP_FORMAT_420

+ const PP_FORMAT_422

+ const PP_FORMAT_440

+ const PP_FORMAT_444

+ const PP_PICT_TYPE_QP2

+ const PP_QUALITY_MAX

+ const SLICE_FLAG_ALLOW_FIELD

+ const SLICE_FLAG_ALLOW_PLANE

+ const SLICE_FLAG_CODED_ORDER

+ const SUBTITLE_ASS

+ const SUBTITLE_BITMAP

+ const SUBTITLE_NONE

+ const SUBTITLE_TEXT

+ const SWR_DITHER_NB

+ const SWR_DITHER_NONE

+ const SWR_DITHER_NS

+ const SWR_DITHER_NS_F_WEIGHTED

+ const SWR_DITHER_NS_HIGH_SHIBATA

+ const SWR_DITHER_NS_IMPROVED_E_WEIGHTED

+ const SWR_DITHER_NS_LIPSHITZ

+ const SWR_DITHER_NS_LOW_SHIBATA

+ const SWR_DITHER_NS_MODIFIED_E_WEIGHTED

+ const SWR_DITHER_NS_SHIBATA

+ const SWR_DITHER_RECTANGULAR

+ const SWR_DITHER_TRIANGULAR

+ const SWR_DITHER_TRIANGULAR_HIGHPASS

+ const SWR_ENGINE_NB

+ const SWR_ENGINE_SOXR

+ const SWR_ENGINE_SWR

+ const SWR_FILTER_TYPE_BLACKMAN_NUTTALL

+ const SWR_FILTER_TYPE_CUBIC

+ const SWR_FILTER_TYPE_KAISER

+ const SWR_FLAG_RESAMPLE

+ const SWS_ACCURATE_RND

+ const SWS_AREA

+ const SWS_BICUBIC

+ const SWS_BICUBLIN

+ const SWS_BILINEAR

+ const SWS_BITEXACT

+ const SWS_CS_BT2020

+ const SWS_CS_DEFAULT

+ const SWS_CS_FCC

+ const SWS_CS_ITU601

+ const SWS_CS_ITU624

+ const SWS_CS_ITU709

+ const SWS_CS_SMPTE170M

+ const SWS_CS_SMPTE240M

+ const SWS_DIRECT_BGR

+ const SWS_ERROR_DIFFUSION

+ const SWS_FAST_BILINEAR

+ const SWS_FULL_CHR_H_INP

+ const SWS_FULL_CHR_H_INT

+ const SWS_GAUSS

+ const SWS_LANCZOS

+ const SWS_MAX_REDUCE_CUTOFF

+ const SWS_PARAM_DEFAULT

+ const SWS_POINT

+ const SWS_PRINT_INFO

+ const SWS_SINC

+ const SWS_SPLINE

+ const SWS_SRC_V_CHR_DROP_MASK

+ const SWS_SRC_V_CHR_DROP_SHIFT

+ const SWS_X

+ const VORBIS_FLAG_COMMENT

+ const VORBIS_FLAG_HEADER

+ const VORBIS_FLAG_SETUP

+ var AV_TIME_BASE_Q = AVRational(C.AV_TIME_BASE_Q)

+ var AvMd5Size = C.av_md5_size

+ func AVERROR(ie T) (oe int32)

+ func AVUNERROR(e int32) int32

+ func AV_BASE64_DECODE_SIZE(x T) T

+ func AV_BASE64_SIZE(x T) T

+ func AV_CEIL_RSHIFT(a U, b V) U

+ func AV_NE(be, le T) T

+ func AvAc3ParseHeader(buf *uint8, size uintptr, bitstreamID *uint8, frameSize *uint16) int32

+ func AvAddIndexEntry(st *AVStream, pos, timestamp int64, size, distance, flags int32) int32

+ func AvAddStable(tsTb AVRational, ts int64, incTb AVRational, inc int64) int32

+ func AvAdler32Update(adler uint32, buf *uint8, len uint32) uint32

+ func AvAdtsHeaderParse(buf *uint8, sample *uint32, frame *uint8) int32

+ func AvAesCrypt(a *AVAES, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvAesCtrCrypt(a *AVAESCTR, dst, src *uint8, size int32)

+ func AvAesCtrFree(a *AVAESCTR)

+ func AvAesCtrGetIv(a *AVAESCTR) *uint8

+ func AvAesCtrIncrementIv(a *AVAESCTR)

+ func AvAesCtrInit(a *AVAESCTR, key *uint8) int32

+ func AvAesCtrSetFullIv(a *AVAESCTR, iv *uint8)

+ func AvAesCtrSetIv(a *AVAESCTR, iv *uint8)

+ func AvAesCtrSetRandomIv(a *AVAESCTR)

+ func AvAesInit(a *AVAES, key *uint8, keyBits, decrypt int32) int32

+ func AvAppendPacket(s *AVIOContext, pkt *AVPacket, size int32) int32

+ func AvApplyBitstreamFilters(codec *AVCodecContext, pkt *AVPacket, bsfc *AVBitStreamFilterContext) int32

+ func AvAssert0(cond bool)

+ func AvAssert0Fpu()

+ func AvAudioFifoDrain(af *AVAudioFifo, nbSamples int32) int32

+ func AvAudioFifoFree(af *AVAudioFifo)

+ func AvAudioFifoPeek(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32

+ func AvAudioFifoPeekAt(af *AVAudioFifo, data CVoidPointerPointer, nbSamples, offset int32) int32

+ func AvAudioFifoRead(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32

+ func AvAudioFifoRealloc(af *AVAudioFifo, nbSamples int32) int32

+ func AvAudioFifoReset(af *AVAudioFifo)

+ func AvAudioFifoSize(af *AVAudioFifo) int32

+ func AvAudioFifoSpace(af *AVAudioFifo) int32

+ func AvAudioFifoWrite(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32

+ func AvBPrintChannelLayout(bp *AVBPrint, nbChannels int32, channelLayout uint64)

+ func AvBase64Decode(out *uint8, in *int8, outSize int32) int32

+ func AvBase64Encode(out *int8, outSize int32, in *uint8, inSize int32) *int8

+ func AvBitstreamFilterClose(bsfc *AVBitStreamFilterContext)

+ func AvBitstreamFilterFilter(bsfc *AVBitStreamFilterContext, avctx *AVCodecContext, args string, ...) int32

+ func AvBlowfishCrypt(ctx *AVBlowfish, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvBlowfishCryptEcb(ctx *AVBlowfish, xl, xr *uint32, decrypt int32)

+ func AvBlowfishInit(ctx *AVBlowfish, key *uint8, keyLen int32)

+ func AvBmgGet(lfg *AVLFG, out []float64)

+ func AvBprintAppendData(buf *AVBPrint, data *int8, size uint32)

+ func AvBprintChars(buf *AVBPrint, c int8, n uint32)

+ func AvBprintClear(buf *AVBPrint)

+ func AvBprintEscape(dstbuf *AVBPrint, src, specialChars *int8, mode AVEscapeMode, flags int32)

+ func AvBprintFinalize(buf *AVBPrint, retStr **int8) int32

+ func AvBprintGetBuffer(buf *AVBPrint, size uint32, mem **uint8, actualSize *uint32)

+ func AvBprintInit(buf *AVBPrint, sizeInit, sizeMax uint32)

+ func AvBprintInitForBuffer(buf *AVBPrint, buffer *int8, size uint32)

+ func AvBprintIsComplete(buf *AVBPrint) int32

+ func AvBprintf(buf *AVBPrint, _fmt string, va ...any)

+ func AvBsfAlloc(filter *AVBitStreamFilter, ctx **AVBSFContext) int32

+ func AvBsfFree(ctx **AVBSFContext)

+ func AvBsfGetNullFilter(bsf **AVBSFContext) int32

+ func AvBsfInit(ctx *AVBSFContext) int32

+ func AvBsfListAppend(lst *AVBSFList, bsf *AVBSFContext)

+ func AvBsfListAppend2(lst *AVBSFList, bsfName string, options **AVDictionary)

+ func AvBsfListFinalize(lst **AVBSFList, bsf **AVBSFContext) int32

+ func AvBsfListFree(lst **AVBSFList)

+ func AvBsfListParseStr(str string, bsf **AVBSFContext)

+ func AvBsfReceivePacket(ctx *AVBSFContext, pkt *AVPacket) int32

+ func AvBsfSendPacket(ctx *AVBSFContext, pkt *AVPacket) int32

+ func AvBswap16(x uint16) uint16

+ func AvBswap32(x uint32) uint32

+ func AvBswap64(x uint64) uint64

+ func AvBufferDefaultFree(opaque CVoidPointer, data *uint8)

+ func AvBufferGetOpaque(buf *AVBufferRef) unsafe.Pointer

+ func AvBufferGetRefCount(buf *AVBufferRef) int32

+ func AvBufferIsWritable(buf *AVBufferRef) int32

+ func AvBufferMakeWritable(buf **AVBufferRef) int32

+ func AvBufferPoolUninit(pool **AVBufferPool)

+ func AvBufferRealloc(buf **AVBufferRef, size int32) int32

+ func AvBufferUnref(buf **AVBufferRef)

+ func AvBuffersinkGetChannelLayout(ctx *AVFilterContext) uint64

+ func AvBuffersinkGetChannels(ctx *AVFilterContext) int32

+ func AvBuffersinkGetFormat(ctx *AVFilterContext) int32

+ func AvBuffersinkGetFrame(ctx *AVFilterContext, frame *AVFrame) int32

+ func AvBuffersinkGetFrameFlags(ctx *AVFilterContext, frame *AVFrame, flags int32) int32

+ func AvBuffersinkGetH(ctx *AVFilterContext) int32

+ func AvBuffersinkGetSampleRate(ctx *AVFilterContext) int32

+ func AvBuffersinkGetSamples(ctx *AVFilterContext, frame *AVFrame, nbSamples int32) int32

+ func AvBuffersinkGetW(ctx *AVFilterContext) int32

+ func AvBuffersinkSetFrameSize(ctx *AVFilterContext, frameSize uint32)

+ func AvBuffersrcAddFrame(ctx *AVFilterContext, frame *AVFrame) int32

+ func AvBuffersrcAddFrameFlags(ctx *AVFilterContext, frame *AVFrame, flags int32) int32

+ func AvBuffersrcClose(ctx *AVFilterContext, pts int64, flags uint32) int32

+ func AvBuffersrcGetNbFailedRequests(bufferSrc *AVFilterContext) uint32

+ func AvBuffersrcParametersSet(ctx *AVFilterContext, param *AVBufferSrcParameters) int32

+ func AvBuffersrcWriteFrame(ctx *AVFilterContext, frame *AVFrame) int32

+ func AvCalloc(nmemb U, size V) unsafe.Pointer

+ func AvCamelliaCrypt(ctx *AVCAMELLIA, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvCamelliaInit(ctx *AVCAMELLIA, key *uint8, keyBits int32) int32

+ func AvCast5Crypt(ctx *AVCAST5, dst, src *uint8, count, decrypt int32)

+ func AvCast5Crypt2(ctx *AVCAST5, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvCast5Init(ctx *AVCAST5, key *uint8, keyBits int32) int32

+ func AvCeilLog2C(x int32) int32

+ func AvChannelLayoutExtractChannel(channelLayout uint64, index int32) uint64

+ func AvChromaLocationFromName(name string) int32

+ func AvChromaLocationName(location AVChromaLocation) string

+ func AvClip64C(a, amin, amax int64) int64

+ func AvClipC(a, amin, amax int32) int32

+ func AvClipInt16C(a int32) int16

+ func AvClipInt8C(a int32) int8

+ func AvClipIntp2C(a, p int32) int32

+ func AvClipUint16C(a int32) uint16

+ func AvClipUint8C(a int32) uint8

+ func AvClipUintp2C(a, p int32) uint32

+ func AvClipdC(a, amin, amax float64) float64

+ func AvClipfC(a, amin, amax float32) float32

+ func AvCliplInt32C(a int64) int32

+ func AvCmpQ(a, b AVRational) int32

+ func AvCodecAlignDimensions(avctx *AVCodecContext, width, height *int32)

+ func AvCodecAlignDimensions2(avctx *AVCodecContext, width, height *int32, ...)

+ func AvCodecClose(avctx *AVCodecContext) int32

+ func AvCodecConfiguration() string

+ func AvCodecCopyContext(dest, src *AVCodecContext) int32

+ func AvCodecDctInit(dct *AVDCT) int32

+ func AvCodecDecodeAudio4(avctx *AVCodecContext, frame *AVFrame, gotFramePtr *int32, avpkt *AVPacket) int32

+ func AvCodecDecodeSubtitle2(avctx *AVCodecContext, sub *AVSubtitle, gotSubPtr *int32, avpkt *AVPacket) int32

+ func AvCodecDecodeVideo2(avctx *AVCodecContext, picture *AVFrame, gotPicturePtr *int32, avpkt *AVPacket) int32

+ func AvCodecDefaultExecute(avctx *AVCodecContext, f AVCodecContextExecuteFunc, arg CVoidPointer, ...) int32

+ func AvCodecDefaultExecute2(avctx *AVCodecContext, f AVCodecContextExecute2Func, arg CVoidPointer, ...) int32

+ func AvCodecDefaultGetBuffer2(avctx *AVCodecContext, frame *AVFrame, flags int32) int32

+ func AvCodecEncodeAudio2(avctx *AVCodecContext, avpkt *AVPacket, frame *AVFrame, gotPacketPtr *int32) int32

+ func AvCodecEncodeSubtitle(avctx *AVCodecContext, buf *uint8, bufSize int32, sub *AVSubtitle) int32

+ func AvCodecEncodeVideo2(avctx *AVCodecContext, avpkt *AVPacket, frame *AVFrame, gotPacketPtr *int32) int32

+ func AvCodecEnumToChromaPos(xpos, ypos *int32, pos AVChromaLocation) int32

+ func AvCodecFillAudioFrame(frame *AVFrame, nbChannels int32, sampleFmt AVSampleFormat, buf *uint8, ...) int32

+ func AvCodecFlushBuffers(avctx *AVCodecContext)

+ func AvCodecFreeContext(avctx **AVCodecContext)

+ func AvCodecGetChromaIntraMatrix(avctx *AVCodecContext) *uint16

+ func AvCodecGetChromaSubSample(pixFmt AVPixelFormat, hShift, vShift *int32)

+ func AvCodecGetContextDefaults3(avctx *AVCodecContext, c *AVCodec) int32

+ func AvCodecGetHwFramesParameters(avctx *AVCodecContext, deviceRef *AVBufferRef, hwPixFmt AVPixelFormat, ...) int32

+ func AvCodecGetLowres(avctx *AVCodecContext) int32

+ func AvCodecGetMaxLowres(c *AVCodec) int32

+ func AvCodecGetName(codecID AVCodecID) string

+ func AvCodecGetPixFmtLoss(dstPixFmt, srcPixFmt AVPixelFormat, hasAlpha int32) int32

+ func AvCodecGetSeekPreroll(avctx *AVCodecContext) int32

+ func AvCodecGetTag(tags **AVCodecTag, id AVCodecID) uint32

+ func AvCodecGetTag2(tags **AVCodecTag, id AVCodecID, tag *uint32) int32

+ func AvCodecIsDecoder(codec *AVCodec) int32

+ func AvCodecIsEncoder(codec *AVCodec) int32

+ func AvCodecIsOpen(avctx *AVCodecContext) int32

+ func AvCodecOpen2(avctx *AVCodecContext, c *AVCodec, d **AVDictionary) int32

+ func AvCodecParametersCopy(dst, src *AVCodecParameters) int32

+ func AvCodecParametersFree(par **AVCodecParameters)

+ func AvCodecParametersFromContext(par *AVCodecParameters, avctx *AVCodecContext) int32

+ func AvCodecParametersToContext(avctx *AVCodecContext, par *AVCodecParameters) int32

+ func AvCodecPixFmtToCodecTag(pixFmt AVPixelFormat) uint

+ func AvCodecProfileName(codecID AVCodecID, profile int32) string

+ func AvCodecReceiveFrame(avctx *AVCodecContext, frame *AVFrame) int32

+ func AvCodecReceivePacket(avctx *AVCodecContext, avpkt *AVPacket) int32

+ func AvCodecRegister(c *AVCodec)

+ func AvCodecRegisterAll()

+ func AvCodecSendFrame(avctx *AVCodecContext, frame *AVFrame) int32

+ func AvCodecSendPacket(avctx *AVCodecContext, avpkt *AVPacket) int32

+ func AvCodecSetChromaIntraMatrix(avctx *AVCodecContext, t *uint16)

+ func AvCodecSetCodecDescriptor(avctx *AVCodecContext, d *AVCodecDescriptor)

+ func AvCodecSetLowres(avctx *AVCodecContext, i int32)

+ func AvCodecSetPktTimebase(avctx *AVCodecContext, r AVRational)

+ func AvCodecSetSeekPreroll(avctx *AVCodecContext, i int32)

+ func AvCodecString(buf *int8, bufSize int32, enc *AVCodecContext, encode int32)

+ func AvCodecVersion() uint32

+ func AvColorPrimariesFromName(name string) int32

+ func AvColorPrimariesName(primaries AVColorPrimaries) string

+ func AvColorRangeFromName(name string) int32

+ func AvColorRangeName(_range AVColorRange) string

+ func AvColorSpaceFromName(name string) int32

+ func AvColorSpaceName(space AVColorSpace) string

+ func AvColorTransferFromName(name string) int32

+ func AvColorTransferName(transfer AVColorTransferCharacteristic) string

+ func AvCompareMod(a, b, mod uint64) int64

+ func AvCompareTs(tsA int64, tbA AVRational, tsB int64, tbB AVRational) int32

+ func AvCopyPacket(dst, src *AVPacket) int32

+ func AvCopyPacketSideData(dst, src *AVPacket) int32

+ func AvCpuCount() int32

+ func AvCpuMaxAlign() int32

+ func AvCrc(ctx *AVCRC, crc uint32, buffer *uint8, length uintptr) int32

+ func AvCrcInit(ctx *AVCRC, le, bits int32, poly uint32, ctxSize int32) int32

+ func AvDctCalc(d *DCTContext, data *FFTSample)

+ func AvDctEnd(d *DCTContext)

+ func AvDefaultItemName(ctx CVoidPointer) string

+ func AvDemuxerOpen(ic *AVFormatContext) int32

+ func AvDesCrypt(d *AVDES, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvDesInit(d *AVDES, key *uint8, keyBits, decrypt int32) int32

+ func AvDesMac(d *AVDES, dst, src *uint8, count int32)

+ func AvDeviceAppToDevControlMessage(s *AVFormatContext, _type AVAppToDevMessageType, data CVoidPointer, ...) int32

+ func AvDeviceCapabilitiesCreate(caps **AVDeviceCapabilitiesQuery, s *AVFormatContext, ...) int32

+ func AvDeviceCapabilitiesFree(caps **AVDeviceCapabilitiesQuery, s *AVFormatContext)

+ func AvDeviceConfiguration() string

+ func AvDeviceDevToAppControlMessage(s *AVFormatContext, _type AVDevToAppMessageType, data CVoidPointer, ...) int32

+ func AvDeviceFreeListDevices(deviceList **AVDeviceInfoList)

+ func AvDeviceLicense() string

+ func AvDeviceListDevices(s *AVFormatContext, deviceList **AVDeviceInfoList) int32

+ func AvDeviceListInputSources(device *AVInputFormat, deviceName string, deviceOptions *AVDictionary, ...) int32

+ func AvDeviceListOutputSinks(device *AVOutputFormat, deviceName string, deviceOptions *AVDictionary, ...) int32

+ func AvDeviceRegisterAll()

+ func AvDeviceVersion() uint32

+ func AvDictCopy(dst **AVDictionary, src *AVDictionary, flags int32) int32

+ func AvDictCount(m *AVDictionary) int32

+ func AvDictFree(m **AVDictionary)

+ func AvDictGetString(m *AVDictionary, buffer **int8, keyValSep, pairsSep string) int32

+ func AvDictParseString(pm **AVDictionary, str, keyValSep, pairsSep string, flags int32) int32

+ func AvDictSet(pm **AVDictionary, key, value string, flags int32) int32

+ func AvDictSetInt(pm **AVDictionary, key string, value int64, flags int32) int32

+ func AvDiracParseSequenceHeader(dsh **AVDiracSeqHeader, buf *uint8, bufSize uintptr, logCtx CVoidPointer) int32

+ func AvDisplayMatrixFlip(matrix []int32, hflip, vflip int32)

+ func AvDisplayRotationGet(matrix []int32) float64

+ func AvDisplayRotationSet(matrix []int32, angle float64)

+ func AvDouble2int(f float64) uint64

+ func AvDumpFormat(ic *AVFormatContext, index int32, url string, isOutput int32)

+ func AvDupPacket(pkt *AVPacket)

+ func AvDynarray2Add(tabPtr CVoidPointerPointer, nbPtr *int32, elemSize T, elemData *uint8) unsafe.Pointer

+ func AvDynarrayAdd(tabPtr CVoidPointer, nbPtr *int32, elem CVoidPointer)

+ func AvDynarrayAddNofree(tabPtr CVoidPointer, nbPtr *int32, elem CVoidPointer) int32

+ func AvEncryptionInfoAddSideData(info *AVEncryptionInfo, sideDataSize *uintptr) *uint8

+ func AvEncryptionInfoFree(info *AVEncryptionInfo)

+ func AvEncryptionInitInfoAddSideData(info *AVEncryptionInitInfo, sideDataSize *uintptr) *uint8

+ func AvEncryptionInitInfoFree(info *AVEncryptionInitInfo)

+ func AvErr2str(errnum int32) string

+ func AvFastMalloc(ptr CVoidPointer, size *uint32, minSize T)

+ func AvFastMallocz(ptr CVoidPointer, size *uint32, minSize T)

+ func AvFastPaddedMalloc(ptr CVoidPointer, size *uint32, minSize uintptr)

+ func AvFastPaddedMallocz(ptr CVoidPointer, size *uint32, minSize uintptr)

+ func AvFastRealloc(ptr CVoidPointer, size *uint32, minSize T) unsafe.Pointer

+ func AvFftEnd(s *FFTContext)

+ func AvFftPermute(s *FFTContext, z *FFTComplex)

+ func AvFifoDrain(f *AVFifoBuffer, size T)

+ func AvFifoFree(f *AVFifoBuffer)

+ func AvFifoFreep(f **AVFifoBuffer)

+ func AvFifoGenericPeek(f *AVFifoBuffer, dest CVoidPointer, bufSize int32, fn AvFifoPeekFunc) int32

+ func AvFifoGenericPeekAt(f *AVFifoBuffer, dest CVoidPointer, offset, bufSize int32, fn AvFifoPeekFunc) int32

+ func AvFifoGenericRead(f *AVFifoBuffer, dest CVoidPointer, bufSize int32, fn AvFifoReadFunc) int32

+ func AvFifoGenericWrite(f *AVFifoBuffer, src CVoidPointer, size int32, fn AvFifoWriteFunc) int32

+ func AvFifoGrow(f *AVFifoBuffer, additionalSpace T) int32

+ func AvFifoPeek2(f *AVFifoBuffer, offs T) *uint8

+ func AvFifoRealloc2(f *AVFifoBuffer, size T) int32

+ func AvFifoReset(f *AVFifoBuffer)

+ func AvFifoSize(f *AVFifoBuffer) int32

+ func AvFifoSpace(f *AVFifoBuffer) int32

+ func AvFileMap(filename string, bufptr **uint8, size *uintptr, logOffset int32, ...) int32

+ func AvFileUnmap(bufptr *uint8, size uintptr)

+ func AvFilenameNumberTest(filename string) int32

+ func AvFilterConfigLinks(filter *AVFilterContext) int32

+ func AvFilterConfiguration() string

+ func AvFilterFree(ctx *AVFilterContext)

+ func AvFilterGraphConfig(graph *AVFilterGraph, logCtx CVoidPointer) int32

+ func AvFilterGraphCreateFilter(filtCtx **AVFilterContext, filter *AVFilter, name, args string, ...) int32

+ func AvFilterGraphDump(graph *AVFilterGraph, options string) string

+ func AvFilterGraphFree(graph **AVFilterGraph)

+ func AvFilterGraphParse(graph *AVFilterGraph, filters string, inputs, outputs *AVFilterInOut, ...) int32

+ func AvFilterGraphParse2(graph *AVFilterGraph, filters string, inputs, outputs **AVFilterInOut) int32

+ func AvFilterGraphParsePtr(graph *AVFilterGraph, filters string, inputs, outputs **AVFilterInOut, ...) int32

+ func AvFilterGraphQueueCommand(graph *AVFilterGraph, target, cmd, arg string, flags int32, ts float64) int32

+ func AvFilterGraphRequestOldest(graph *AVFilterGraph) int32

+ func AvFilterGraphSendCommand(graph *AVFilterGraph, target, cmd, arg string, resLen, flags int32) (res string, ret int32)

+ func AvFilterGraphSetAutoConvert(graph *AVFilterGraph, flags uint32)

+ func AvFilterInitDict(ctx *AVFilterContext, options **AVDictionary) int32

+ func AvFilterInitStr(ctx *AVFilterContext, args string) int32

+ func AvFilterInoutFree(inout **AVFilterInOut)

+ func AvFilterInsertFilter(ctx *AVFilterContext, link *AVFilterLink, filtSrcpadIdx, filtDstpadIdx uint32) int32

+ func AvFilterLicense() string

+ func AvFilterLink(src *AVFilterContext, srcpad uint32, dst *AVFilterContext, dstpad uint32) int32

+ func AvFilterLinkFree(link **AVFilterLink)

+ func AvFilterLinkGetChannels(link *AVFilterLink) int32

+ func AvFilterLinkSetClosed(link *AVFilterLink, closed int32)

+ func AvFilterPadCount(pads *AVFilterPad) int32

+ func AvFilterPadGetName(pads *AVFilterPad, padIdx int32) string

+ func AvFilterProcessCommand(filter *AVFilterContext, cmd, arg string, resLen, flags int32) (res string, ret int32)

+ func AvFilterRegister(filter *AVFilter)

+ func AvFilterRegisterAll()

+ func AvFilterVersion() uint32

+ func AvFindBestStream(ic *AVFormatContext, _type AVMediaType, wantedStreamNb, relatedStream int32, ...) int32

+ func AvFindDefaultStreamIndex(ic *AVFormatContext) int32

+ func AvFindInfoTag(tag1, info string) (val string, ret int32)

+ func AvFindNearestQIdx(q AVRational, qList *AVRational) int32

+ func AvFloat2int(f float32) uint32

+ func AvForceCpuFlags(flags int32)

+ func AvFormatAllocOutputContext2(ctx **AVFormatContext, oformat *AVOutputFormat, formatName, filename string) int32

+ func AvFormatCloseInput(ic **AVFormatContext)

+ func AvFormatConfiguration() string

+ func AvFormatFindStreamInfo(ic *AVFormatContext, options **AVDictionary) int32

+ func AvFormatFlush(ic *AVFormatContext) int32

+ func AvFormatFreeContext(s *AVFormatContext)

+ func AvFormatGetOpaque(s *AVFormatContext) unsafe.Pointer

+ func AvFormatGetProbeScore(s *AVFormatContext) int32

+ func AvFormatInitOutput(ic *AVFormatContext, options **AVDictionary) int32

+ func AvFormatInjectGlobalSideData(s *AVFormatContext)

+ func AvFormatLicense() string

+ func AvFormatMatchStreamSpecifier(ic *AVFormatContext, st *AVStream, spec string) int32

+ func AvFormatNetworkDeinit() int32

+ func AvFormatNetworkInit() int32

+ func AvFormatOpenInput(ps **AVFormatContext, url string, fmt *AVInputFormat, options **AVDictionary) int32

+ func AvFormatQueryCodec(ofmt *AVOutputFormat, codeID AVCodecID, stdCompliance int32) int32

+ func AvFormatQueueAttachedPictures(ic *AVFormatContext) int32

+ func AvFormatSeekFile(ic *AVFormatContext, streamIndex int32, minTs, ts, maxTs int64, flags int32) int32

+ func AvFormatSetAudioCodec(s *AVFormatContext, c *AVCodec)

+ func AvFormatSetControlMessageCb(s *AVFormatContext, callback AVFormatControlMessageFunc)

+ func AvFormatSetDataCodec(s *AVFormatContext, c *AVCodec)

+ func AvFormatSetOpaque(s *AVFormatContext, opaque CVoidPointer)

+ func AvFormatSetOpenCb(s *AVFormatContext, callback AVOpenCallbackFunc)

+ func AvFormatSetSubtitleCodec(s *AVFormatContext, c *AVCodec)

+ func AvFormatSetVideoCodec(s *AVFormatContext, c *AVCodec)

+ func AvFormatTransferInternalStreamTimingInfo(ofmt *AVOutputFormat, ost, ist *AVStream, copyTb AVTimebaseSource) int32

+ func AvFormatVersion() uint32

+ func AvFormatWriteHeader(ic *AVFormatContext, options **AVDictionary) int32

+ func AvFourcc2str(fourcc uint32) string

+ func AvFourccMakeString(buf *int8, fourcc uint32) *int8

+ func AvFrameApplyCropping(frame *AVFrame, flags int32) int32

+ func AvFrameCopy(dst, src *AVFrame) int32

+ func AvFrameCopyProps(dst, src *AVFrame) int32

+ func AvFrameFree(frame **AVFrame)

+ func AvFrameGetBestEffortTimestamp(frame *AVFrame) int64

+ func AvFrameGetBuffer(frame *AVFrame, align int32) int32

+ func AvFrameGetChannelLayout(frame *AVFrame) int64

+ func AvFrameGetChannels(frame *AVFrame) int32

+ func AvFrameGetDecodeErrorFlags(frame *AVFrame) int32

+ func AvFrameGetPktDuration(frame *AVFrame) int64

+ func AvFrameGetPktPos(frame *AVFrame) int64

+ func AvFrameGetPktSize(frame *AVFrame) int32

+ func AvFrameGetQpTable(frame *AVFrame, stride, _type *int32) *int8

+ func AvFrameGetSampleRate(frame *AVFrame) int32

+ func AvFrameIsWritable(frame *AVFrame) int32

+ func AvFrameMakeWritable(frame *AVFrame) int32

+ func AvFrameMoveRef(dst, src *AVFrame)

+ func AvFrameRef(dst, src *AVFrame) int32

+ func AvFrameRemoveSideData(frame *AVFrame, _type AVFrameSideDataType)

+ func AvFrameSetBestEffortTimestamp(frame *AVFrame, val int64)

+ func AvFrameSetChannelLayout(frame *AVFrame, val int64)

+ func AvFrameSetChannels(frame *AVFrame, val int32)

+ func AvFrameSetColorRange(frame *AVFrame, val AVColorRange)

+ func AvFrameSetColorspace(frame *AVFrame, val AVColorSpace)

+ func AvFrameSetDecodeErrorFlags(frame *AVFrame, val int32)

+ func AvFrameSetMetadata(frame *AVFrame, val *AVDictionary)

+ func AvFrameSetPktDuration(frame *AVFrame, val int64)

+ func AvFrameSetPktPos(frame *AVFrame, val int64)

+ func AvFrameSetPktSize(frame *AVFrame, val int32)

+ func AvFrameSetQpTable(frame *AVFrame, buf *AVBufferRef, stride, _type int32) int32

+ func AvFrameSetSampleRate(frame *AVFrame, val int32)

+ func AvFrameSideDataName(_type AVFrameSideDataType) string

+ func AvFrameUnref(frame *AVFrame)

+ func AvFree(ptr CVoidPointer)

+ func AvFreePacket(pkt *AVPacket)

+ func AvFreep(ptr CVoidPointer)

+ func AvGcd(a, b T) T

+ func AvGetAudioFrameDuration(avctx *AVCodecContext, frameBytes int32) int32

+ func AvGetAudioFrameDuration2(par *AVCodecParameters, frameBytes int32) int32

+ func AvGetBitsPerPixel(pixdesc *AVPixFmtDescriptor) int32

+ func AvGetBitsPerSample(codecID AVCodecID) int32

+ func AvGetBytesPerSample(sampleFmt AVSampleFormat) int32

+ func AvGetChannelDescription(channel uint64) string

+ func AvGetChannelLayout(name string) uint64

+ func AvGetChannelLayoutChannelIndex(channelLayout, channel uint64) int32

+ func AvGetChannelLayoutNbChannels(channelLayout uint64) int32

+ func AvGetChannelLayoutString(nbChannels int32, channelLayout uint64) string

+ func AvGetChannelName(channel uint64) string

+ func AvGetCodecTagString(buf *int8, bufSize uintptr, codecTag uint32) int32

+ func AvGetColorspaceName(val AVColorSpace) string

+ func AvGetCpuFlags() int32

+ func AvGetDefaultChannelLayout(nbChannels int32) int64

+ func AvGetExactBitsPerSample(codecID AVCodecID) int32

+ func AvGetExtendedChannelLayout(name string, channelLayout *uint64, nbChannels *int32) int32

+ func AvGetFrameFilename(bufSize int32, path string, number int32) (output string, ret int32)

+ func AvGetFrameFilename2(bufSize int32, path string, number, flags int32) (output string, ret int32)

+ func AvGetKnownColorName(colorIdx int32, rgb **uint8) string

+ func AvGetMediaTypeString(mt AVMediaType) string

+ func AvGetOutputTimestamp(ic *AVFormatContext, stream int32, dts, wall *int64) int32

+ func AvGetPacket(s *AVIOContext, pkt *AVPacket, size int32) int32

+ func AvGetPaddedBitsPerPixel(pixdesc *AVPixFmtDescriptor) int32

+ func AvGetPictureTypeChar(pictType AVPictureType) string

+ func AvGetPixFmtLoss(dstPixFmt, srcPixFmt AVPixelFormat, hasAlpha int32) int32

+ func AvGetPixFmtName(pixFmt AVPixelFormat) string

+ func AvGetPixFmtString(buf *int8, bufSize int32, pixFmt AVPixelFormat) string

+ func AvGetProfileName(c *AVCodec, profile int32) string

+ func AvGetRandomSeed() uint32

+ func AvGetSampleFmtName(sampleFmt AVSampleFormat) string

+ func AvGetSampleFmtString(buf *int8, bufSize int32, sampleFmt AVSampleFormat) string

+ func AvGetStandardChannelLayout(index uint32, layout *uint64, name **int8) int32

+ func AvGettime() int64

+ func AvGettimeRelative() int64

+ func AvGettimeRelativeIsMonotonic() int32

+ func AvGrowPacket(pkt *AVPacket, growBy int32) int32

+ func AvHWDeviceCtxCreate(deviceCtx **AVBufferRef, _type AVHWDeviceType, device string, ...) int32

+ func AvHWDeviceCtxCreateDerived(dstCtx **AVBufferRef, _type AVHWDeviceType, srcCtx *AVBufferRef, flags int32) int32

+ func AvHWDeviceCtxInit(ref *AVBufferRef) int32

+ func AvHWDeviceGetTypeName(_type AVHWDeviceType) string

+ func AvHWDeviceHwconfigAlloc(deviceCtx *AVBufferRef) unsafe.Pointer

+ func AvHWFrameConstraintsFree(constraints **AVHWFramesConstraints)

+ func AvHWFrameCtxCreateDerived(derivedFrameCtx **AVBufferRef, format AVPixelFormat, ...) int32

+ func AvHWFrameCtxInit(ref *AVBufferRef) int32

+ func AvHWFrameGetBuffer(hwframeCtx *AVBufferRef, frame *AVFrame, flags int32) int32

+ func AvHWFrameMap(dst, src *AVFrame, flags int32) int32

+ func AvHWFrameTransferData(dst, src *AVFrame, flags int32) int32

+ func AvHWFrameTransferGetFormats(hwframeCtx *AVBufferRef, dir AVHWFrameTransferDirection, ...) int32

+ func AvHashAlloc(ctx **AVHashContext, name string) int32

+ func AvHashFinal(ctx *AVHashContext, dst *uint8)

+ func AvHashFinalB64(ctx *AVHashContext, dst *uint8, size int32)

+ func AvHashFinalBin(ctx *AVHashContext, dst *uint8, size int32)

+ func AvHashFinalHex(ctx *AVHashContext, dst *uint8, size int32)

+ func AvHashFreep(ctx **AVHashContext)

+ func AvHashGetName(ctx *AVHashContext) string

+ func AvHashGetSize(ctx *AVHashContext) int32

+ func AvHashInit(ctx *AVHashContext)

+ func AvHashNames(i int32) string

+ func AvHashUpdate(ctx *AVHashContext, src *uint8, len int32)

+ func AvHexDump(f *FILE, buf *uint8, size int32)

+ func AvHexDumpLog(avcl CVoidPointer, level int32, buf *uint8, size int32)

+ func AvHmacCalc(ctx *AVHMAC, data *uint8, len uint32, key *uint8, keylen uint32, out *uint8, ...) int32

+ func AvHmacFinal(ctx *AVHMAC, out *uint8, outlen uint32) int32

+ func AvHmacFree(ctx *AVHMAC)

+ func AvHmacInit(ctx *AVHMAC, key *uint8, keylen uint32)

+ func AvHmacUpdate(ctx *AVHMAC, data *uint8, len uint32)

+ func AvIOAccept(s *AVIOContext, c **AVIOContext) int32

+ func AvIOCheck(url string, flags int32) int32

+ func AvIOClose(s *AVIOContext) int32

+ func AvIOCloseDir(s **AVIODirContext) int32

+ func AvIOCloseDynBuf(s *AVIOContext, pbuffer **uint8) int32

+ func AvIOClosep(s **AVIOContext) int32

+ func AvIOContextFree(s **AVIOContext)

+ func AvIOEnumProtocols(opaque CVoidPointerPointer, output int32) string

+ func AvIOFeof(s *AVIOContext) int32

+ func AvIOFindProtocolName(url string) string

+ func AvIOFlush(s *AVIOContext)

+ func AvIOFreeDirectoryEntry(entry **AVIODirEntry)

+ func AvIOGetDynBuf(s *AVIOContext, pbuffer **uint8) int32

+ func AvIOGetStr(s *AVIOContext, maxLen int32, buf *int8, buflen int32) int32

+ func AvIOGetStr16be(s *AVIOContext, maxLen int32, buf *int8, buflen int32) int32

+ func AvIOGetStr16le(s *AVIOContext, maxLen int32, buf *int8, buflen int32) int32

+ func AvIOHandshake(s *AVIOContext) int32

+ func AvIOOpen(s **AVIOContext, url string, flags int32) int32

+ func AvIOOpen2(s **AVIOContext, url string, flags int32, intCb *AVIOInterruptCB, ...) int32

+ func AvIOOpenDir(s **AVIODirContext, url string, options **AVDictionary) int32

+ func AvIOOpenDynBuf(s **AVIOContext) int32

+ func AvIOPause(s *AVIOContext, pause int32) int32

+ func AvIOPrintf(s *AVIOContext, _fmt string, va ...any) int32

+ func AvIOPutStr(s *AVIOContext, str string) int32

+ func AvIOPutStr16be(s *AVIOContext, str string) int32

+ func AvIOPutStr16le(s *AVIOContext, str string) int32

+ func AvIOR8(s *AVIOContext) int32

+ func AvIORb16(s *AVIOContext) uint32

+ func AvIORb24(s *AVIOContext) uint32

+ func AvIORb32(s *AVIOContext) uint32

+ func AvIORb64(s *AVIOContext) uint64

+ func AvIORead(s *AVIOContext, buf *uint8, size int32) int32

+ func AvIOReadDir(s *AVIODirContext, next **AVIODirEntry) int32

+ func AvIOReadPartial(s *AVIOContext, buf *uint8, size int32) int32

+ func AvIOReadToBprint(s *AVIOContext, pb *AVBPrint, maxSize uintptr) int32

+ func AvIORl16(s *AVIOContext) uint32

+ func AvIORl24(s *AVIOContext) uint32

+ func AvIORl32(s *AVIOContext) uint32

+ func AvIORl64(s *AVIOContext) uint64

+ func AvIOSeek(s *AVIOContext, offset int64, whence int32) int64

+ func AvIOSeekTime(s *AVIOContext, streamIndex int32, timestamp int64, flags int32) int64

+ func AvIOSize(s *AVIOContext) int64

+ func AvIOSkip(s *AVIOContext, offset int64) int64

+ func AvIOTell(s *AVIOContext) int64

+ func AvIOW8(s *AVIOContext, b int32)

+ func AvIOWb16(s *AVIOContext, val uint32)

+ func AvIOWb24(s *AVIOContext, val uint32)

+ func AvIOWb32(s *AVIOContext, val uint32)

+ func AvIOWb64(s *AVIOContext, val uint64)

+ func AvIOWl16(s *AVIOContext, val uint32)

+ func AvIOWl24(s *AVIOContext, val uint32)

+ func AvIOWl32(s *AVIOContext, val uint32)

+ func AvIOWl64(s *AVIOContext, val uint64)

+ func AvIOWrite(s *AVIOContext, buf *uint8, size int32)

+ func AvIOWriteMarker(s *AVIOContext, time int64, _type AVIODataMarkerType)

+ func AvImageAlloc(pointers []*uint8, linesizes []int32, w, h int32, pixFmt AVPixelFormat, ...) int32

+ func AvImageCheckSar(w, h uint32, sar AVRational) int32

+ func AvImageCheckSize(w, h uint32, logOffset int32, logCtx CVoidPointer) int32

+ func AvImageCheckSize2(w, h uint32, maxPixels int64, pixFmt AVPixelFormat, logOffset int32, ...) int32

+ func AvImageCopy(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLinesizes []int32, ...)

+ func AvImageCopyPlane(dst *uint8, dstLinesize int32, src *uint8, srcLinesize int32, ...)

+ func AvImageCopyToBuffer(dst *uint8, dstSize int32, srcData []*uint8, srcLinesize []int32, ...) int32

+ func AvImageCopyUcFrom(dstData []*uint8, dstLinesizes []int, srcData []*uint8, srcLinesizes []int, ...)

+ func AvImageFillArrays(dstData []*uint8, dstLinesize []int32, src *uint8, pixFmt AVPixelFormat, ...)

+ func AvImageFillBlack(dstData []*uint8, dstLinesize []int, pixFmt AVPixelFormat, _range AVColorRange, ...) int32

+ func AvImageFillLinesizes(linesizes []int32, pixFmt AVPixelFormat, width int32) int32

+ func AvImageFillMaxPixsteps(maxPixsteps, maxPixstepComps []int32, pixdesc *AVPixFmtDescriptor)

+ func AvImageFillPointers(data []*uint8, pixFmt AVPixelFormat, height int32, ptr *uint8, ...) int32

+ func AvImageGetBufferSize(pixFmt AVPixelFormat, width, height, align int32) int32

+ func AvImageGetLinesize(pixFmt AVPixelFormat, width, plane int32) int32

+ func AvImdctCalc(s *FFTContext, output, input *FFTSample)

+ func AvImdctHalf(s *FFTContext, output, input *FFTSample)

+ func AvIndexSearchTimestamp(st *AVStream, timestamp int64, flags int32) int32

+ func AvInitPacket(pkt *AVPacket)

+ func AvInt2double(i uint64) float64

+ func AvInt2float(i uint32) float32

+ func AvIntListLength(list *U, term V) uint32

+ func AvIntListLengthForSize(elsize uint32, list CVoidPointer, term T) uint32

+ func AvInterleavedWriteFrame(ic *AVFormatContext, pkt *AVPacket) int32

+ func AvInterleavedWriteUncodedFrame(ic *AVFormatContext, streamIndex int32, frame *AVFrame) int32

+ func AvJniGetJavaVm(logCtx CVoidPointer)

+ func AvJniSetJavaVm(vm, logCtx CVoidPointer) int32

+ func AvLfgGet(c *AVLFG) uint32

+ func AvLfgInit(c *AVLFG, seed uint32)

+ func AvLfgInitFromData(c *AVLFG, data *uint8, length uint) int32

+ func AvLockmgrRegister(cb AVLockmgrCb) int32

+ func AvLog(avcl CVoidPointer, level int32, _fmt string, va ...any)

+ func AvLog2(v uint32) int32

+ func AvLog2With16bit(v uint32) int32

+ func AvLogGetFlags() int32

+ func AvLogGetLevel() int32

+ func AvLogSetCallback(f AVLogCallbackFunc)

+ func AvLogSetFlags(arg int32)

+ func AvLogSetLevel(level int32)

+ func AvLzo1xDecode(out CVoidPointer, outlen *int32, in CVoidPointer, inlen *int32) int32

+ func AvMakeErrorString(errbuf *int8, errbufSize uintptr, errnum int32) *int8

+ func AvMalloc(size T) unsafe.Pointer

+ func AvMallocArray(nmemb U, size V) unsafe.Pointer

+ func AvMallocz(size T) unsafe.Pointer

+ func AvMalloczArray(nmemb U, size V) unsafe.Pointer

+ func AvMatchExt(filename, extensions string) int32

+ func AvMaxAlloc(max T)

+ func AvMd5Final(ctx *AVMD5, dst *uint8)

+ func AvMd5Init(ctx *AVMD5)

+ func AvMd5Sum(dst, src *uint8, len int32)

+ func AvMd5Update(ctx *AVMD5, src *uint8, len int32)

+ func AvMdctCalc(s *FFTContext, output, input *FFTSample)

+ func AvMdctEnd(s *FFTContext)

+ func AvMemcpyBackptr(dst *uint8, back, cnt int32)

+ func AvMemdup(p CVoidPointer, size T) unsafe.Pointer

+ func AvMlfgGet(c *AVLFG) uint32

+ func AvModUintp2C(a, p uint32) uint32

+ func AvMurmur3Final(c *AVMurMur3, dst []uint8)

+ func AvMurmur3Init(c *AVMurMur3)

+ func AvMurmur3InitSeeded(c *AVMurMur3, seed uint64)

+ func AvMurmur3Update(c *AVMurMur3, src *uint8, len int32)

+ func AvNearerQ(q, q1, q2 AVRational) int32

+ func AvNewPacket(pkt *AVPacket, size int32) int32

+ func AvOptChildNext(obj, prev CVoidPointer) unsafe.Pointer

+ func AvOptCopy(dest, src CVoidPointer) int32

+ func AvOptEvalDouble(obj CVoidPointer, o *AVOption, val string, double_out *float64) int32

+ func AvOptEvalFlags(obj CVoidPointer, o *AVOption, val string, flags_out *int32) int32

+ func AvOptEvalFloat(obj CVoidPointer, o *AVOption, val string, float_out *float32) int32

+ func AvOptEvalInt(obj CVoidPointer, o *AVOption, val string, int_out *int32) int32

+ func AvOptEvalInt64(obj CVoidPointer, o *AVOption, val string, int64_out *int64) int32

+ func AvOptEvalQ(obj CVoidPointer, o *AVOption, val string, q_out *AVRational) int32

+ func AvOptFlagIsSet(obj CVoidPointer, fieldName, flagName string) int32

+ func AvOptFree(obj CVoidPointer)

+ func AvOptFreepRanges(ranges **AVOptionRanges)

+ func AvOptGet(obj CVoidPointer, name string, searchFlags int32, outVal **uint8) int32

+ func AvOptGetChannelLayout(obj CVoidPointer, name string, searchFlags int32, outVal *int64) int32

+ func AvOptGetDictVal(obj CVoidPointer, name string, searchFlags int32, outVal **AVDictionary) int32

+ func AvOptGetDouble(obj CVoidPointer, name string, searchFlags int32, outVal *float64) int32

+ func AvOptGetImageSize(obj CVoidPointer, name string, searchFlags int32, wOut, hOut *int32) int32

+ func AvOptGetInt(obj CVoidPointer, name string, searchFlags int32, outVal *int64) int32

+ func AvOptGetPixelFmt(obj CVoidPointer, name string, searchFlags int32, outFmt *AVPixelFormat) int32

+ func AvOptGetQ(obj CVoidPointer, name string, searchFlags int32, outVal *AVRational) int32

+ func AvOptGetSampleFmt(obj CVoidPointer, name string, searchFlags int32, outFmt *AVSampleFormat) int32

+ func AvOptGetVideoRate(obj CVoidPointer, name string, searchFlags int32, outVal *AVRational) int32

+ func AvOptIsSetToDefault(obj CVoidPointer, o *AVOption) int32

+ func AvOptIsSetToDefaultByName(obj CVoidPointer, name string, searchFlags int32) int32

+ func AvOptPtr(avclass *AVClass, obj CVoidPointer, name string)

+ func AvOptQueryRanges(ranges **AVOptionRanges, obj CVoidPointer, key string, flags int32) int32

+ func AvOptQueryRangesDefault(ranges **AVOptionRanges, obj CVoidPointer, key string, flags int32) int32

+ func AvOptSerialize(obj CVoidPointer, optFlags, flags int32, keyValSep, pairsSep string) (output string, ret int32)

+ func AvOptSet(obj CVoidPointer, name string, val string, searchFlags int32) int32

+ func AvOptSetBin(obj CVoidPointer, name string, val *U, size V, searchFlags int32) int32

+ func AvOptSetChannelLayout(obj CVoidPointer, name string, chLayout int64, searchFlags int32) int32

+ func AvOptSetDefaults(s CVoidPointer)

+ func AvOptSetDefaults2(s CVoidPointer, mask, flags int32)

+ func AvOptSetDict(obj CVoidPointer, options **AVDictionary) int32

+ func AvOptSetDict2(obj CVoidPointer, options **AVDictionary, searchFlags int32) int32

+ func AvOptSetDictVal(obj CVoidPointer, name string, val *AVDictionary, searchFlags int32) int32

+ func AvOptSetDouble(obj CVoidPointer, name string, val float64, searchFlags int32) int32

+ func AvOptSetImageSize(obj CVoidPointer, name string, w, h int32, searchFlags int32) int32

+ func AvOptSetInt(obj CVoidPointer, name string, val T, searchFlags int32) int32

+ func AvOptSetIntList(obj CVoidPointer, name string, val *U, term V, flags int32) int32

+ func AvOptSetPixelFmt(obj CVoidPointer, name string, fmt AVPixelFormat, searchFlags int32) int32

+ func AvOptSetQ(obj CVoidPointer, name string, val AVRational, searchFlags int32) int32

+ func AvOptSetSampleFmt(obj CVoidPointer, name string, fmt AVSampleFormat, searchFlags int32) int32

+ func AvOptSetVideoRate(obj CVoidPointer, name string, val AVRational, searchFlags int32) int32

+ func AvOptShow2(obj, avLogObj CVoidPointer, reqFlags, rejFlags int32) int32

+ func AvPacketAddSideData(pkt *AVPacket, _type AVPacketSideDataType, data *uint8, size uintptr) int32

+ func AvPacketCopyProps(dst, src *AVPacket) int32

+ func AvPacketFree(pkt **AVPacket)

+ func AvPacketFreeSideData(pkt *AVPacket)

+ func AvPacketFromData(pkt *AVPacket, data *uint8, size int32) int32

+ func AvPacketGetSideData(pkt *AVPacket, _type AVPacketSideDataType, size *int32) *uint8

+ func AvPacketMakeRefcounted(pkt *AVPacket)

+ func AvPacketMakeWritable(pkt *AVPacket)

+ func AvPacketMergeSideData(pkt *AVPacket) int32

+ func AvPacketMoveRef(dst, src *AVPacket)

+ func AvPacketNewSideData(pkt *AVPacket, _type AVPacketSideDataType, size int32) *uint8

+ func AvPacketPackDictionary(dict *AVDictionary, size *int32) *uint8

+ func AvPacketRef(dst, src *AVPacket) int32

+ func AvPacketRescaleTs(pkt *AVPacket, tbSrc, tbDst AVRational)

+ func AvPacketShrinkSideData(pkt *AVPacket, _type AVPacketSideDataType, size int32) int32

+ func AvPacketSplitSideData(pkt *AVPacket) int32

+ func AvPacketUnpackDictionary(data *uint8, size int32, dict **AVDictionary) int32

+ func AvPacketUnref(pkt *AVPacket)

+ func AvParityC(x uint32) int32

+ func AvParseColor(rgbaColor *uint8, colorString string, slen int32, logCtx CVoidPointer) int32

+ func AvParseCpuCaps(flags *uint32, str string) int32

+ func AvParseCpuFlags(str string) int32

+ func AvParseRatio(q *AVRational, str string, max, logOffset int32, logCtx CVoidPointer) int32

+ func AvParseRatioQuiet(q *AVRational, str string, max int32) int32

+ func AvParseTime(timeval *int64, timestr string, duration int32) int32

+ func AvParseVideoRate(rate *AVRational, str string) int32

+ func AvParseVideoSize(widthPtr, heightPtr *int32, str string) int32

+ func AvParserChange(s *AVCodecParserContext, avctx *AVCodecContext, outbuf **uint8, ...) int32

+ func AvParserClose(s *AVCodecParserContext)

+ func AvParserParse2(s *AVCodecParserContext, avctx *AVCodecContext, outbuf **uint8, ...) int32

+ func AvPictureAlloc(picture *AVPicture, pixFmt AVPixelFormat, width, height int32) int32

+ func AvPictureCopy(dst, src *AVPicture, pixFmt AVPixelFormat, width, height int32)

+ func AvPictureCrop(dst, src *AVPicture, pixFmt AVPixelFormat, topBand, leftBand int32) int32

+ func AvPictureFill(picture *AVPicture, ptr *uint8, pixFmt AVPixelFormat, width, height int32) int32

+ func AvPictureFree(picture *AVPicture)

+ func AvPictureGetSize(pixFmt AVPixelFormat, width, height int32) int32

+ func AvPictureLayout(src *AVPicture, pixFmt AVPixelFormat, width, height int32, dest *uint8, ...) int32

+ func AvPicturePad(dst, src *AVPicture, width, height int32, pixFmt AVPixelFormat, ...) int32

+ func AvPixFmtCountPlanes(pixFmt AVPixelFormat) int32

+ func AvPixFmtGetChromaSubSample(pixFmt AVPixelFormat, hShift, vShift *int32) int32

+ func AvPktDump2(f *FILE, pkt *AVPacket, dumpPayload int32, st *AVStream)

+ func AvPktDumpLog2(avcl CVoidPointer, level int32, pkt *AVPacket, dumpPayload int32, st *AVStream)

+ func AvPopcount64C(x uint64) int32

+ func AvPopcountC(x uint32) int32

+ func AvPrivIoDelete(url string) int32

+ func AvPrivIoMove(urlSrc, urlDst string) int32

+ func AvProbeInputBuffer(pb *AVIOContext, fmt **AVInputFormat, url string, logctx CVoidPointer, ...) int32

+ func AvProbeInputBuffer2(pb *AVIOContext, fmt **AVInputFormat, url string, logctx CVoidPointer, ...) int32

+ func AvProgramAddStreamIndex(ic *AVFormatContext, progid int32, idx uint32)

+ func AvQ2d(a AVRational) float64

+ func AvQ2intfloat(q AVRational) uint32

+ func AvRc4Crypt(d *AVRC4, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvRc4Init(d *AVRC4, key *uint8, keyBits int32, decrypt int32) int32

+ func AvRdftCalc(r *RDFTContext, data *FFTSample)

+ func AvRdftEnd(r *RDFTContext)

+ func AvReadFrame(ic *AVFormatContext, pkt *AVPacket) int32

+ func AvReadImageLine(dst *uint16, data []*uint8, linesize []int, desc *AVPixFmtDescriptor, ...)

+ func AvReadPause(ic *AVFormatContext) int32

+ func AvReadPlay(ic *AVFormatContext) int32

+ func AvRealloc(ptr CVoidPointer, size T) unsafe.Pointer

+ func AvReallocF(ptr CVoidPointer, nelem U, elsize V) unsafe.Pointer

+ func AvReallocp(ptr CVoidPointer, size T) int32

+ func AvReallocpArray(ptr CVoidPointer, nmemb U, size V) int32

+ func AvReduce(dstNum, dstDen *int32, num, den, max int64) int32

+ func AvRegisterAll()

+ func AvRegisterBitstreamFilter(bsf *AVBitStreamFilter)

+ func AvRegisterCodecParser(parser *AVCodecParser)

+ func AvRegisterHwaccel(hwaccel *AVHWAccel)

+ func AvRegisterInputFormat(format *AVInputFormat)

+ func AvRegisterOutputFormat(format *AVOutputFormat)

+ func AvRescale(a, b, c T) T

+ func AvRescaleDelta(inTb AVRational, inTs int64, fsTb AVRational, duration int32, last *int64, ...) int64

+ func AvRescaleQ(a T, bq, cq AVRational) T

+ func AvRescaleQRnd(a T, bq, cq AVRational, rnd AVRounding) T

+ func AvRescaleRnd(a, b, c T, rnd AVRounding) T

+ func AvRipemdFinal(context *AVRIPEMD, digest *uint8)

+ func AvRipemdInit(context *AVRIPEMD, bits int32) int32

+ func AvRipemdUpdate(context *AVRIPEMD, data *uint8, len uint32)

+ func AvSampleFmtIsPlanar(sampleFmt AVSampleFormat) int32

+ func AvSamplesAlloc(audioData **uint8, linesize *int32, nbChannels, nbSamples int32, ...) int32

+ func AvSamplesAllocArrayAndSamples(audioData ***uint8, linesize *int32, nbChannels, nbSamples int32, ...) int32

+ func AvSamplesCopy(dst, src **uint8, dstOffset, srcOffset int32, nbSamples, nbChannels int32, ...) int32

+ func AvSamplesFillArrays(audioData **uint8, linesize *int32, buf *uint8, nbChannels, nbSamples int32, ...) int32

+ func AvSamplesGetBufferSize(linesize *int32, nbChannels, nbSamples int32, sampleFmt AVSampleFormat, ...) int32

+ func AvSamplesSetSilence(audioData **uint8, offset int32, nbSamples, nbChannels int32, ...) int32

+ func AvSatAdd32C(a, b int32) int32

+ func AvSatDadd32C(a, b int32) int32

+ func AvSatDsub32C(a, b int32) int32

+ func AvSatSub32C(a, b int32) int32

+ func AvSdpCreate(ac []*AVFormatContext, nFiles, sdpSize int32) (sdp string, ret int32)

+ func AvSeekFrame(ic *AVFormatContext, streamIndex int32, timestamp int64, flags int32) int32

+ func AvSetCpuFlagsMask(mask int32)

+ func AvSetOptionsString(ctx CVoidPointer, opts, keyValSep, pairsSep string) int32

+ func AvSha512Final(ctx *AVSHA512, digest *uint8)

+ func AvSha512Init(context *AVSHA512, bits int32) int32

+ func AvSha512Update(ctx *AVSHA512, data *uint8, len uint32)

+ func AvShaFinal(ctx *AVSHA, digest *uint8)

+ func AvShaInit(context *AVSHA, bits int32) int32

+ func AvShaUpdate(ctx *AVSHA, data *uint8, len uint32)

+ func AvShrinkPacket(pkt *AVPacket, size int32)

+ func AvSizeMult(a, b T, r *uintptr) int32

+ func AvSphericalFromName(name string) int32

+ func AvSphericalProjectionName(projection AVSphericalProjection) string

+ func AvSphericalTileBounds(_map *AVSphericalMapping, width, height uintptr, ...)

+ func AvStereo3dFromName(name string) int32

+ func AvStereo3dTypeName(_type uint32) string

+ func AvStrdup(s *int8) *int8

+ func AvStreamAddSideData(st *AVStream, _type AVPacketSideDataType, data *uint8, size uintptr) int32

+ func AvStreamGetEndPts(s *AVStream) int64

+ func AvStreamGetRecommendedEncoderConfiguration(s *AVStream) string

+ func AvStreamGetSideData(st *AVStream, _type AVPacketSideDataType, size *int32) *uint8

+ func AvStreamNewSideData(st *AVStream, _type AVPacketSideDataType, size int32) *uint8

+ func AvStreamSetRFrameRate(s *AVStream, r AVRational)

+ func AvStreamSetRecommendedEncoderConfiguration(s *AVStream, configuration string)

+ func AvStrerror(errnum int32, errbuf *int8, errbufSize uintptr) int32

+ func AvStringIfNull(p, x string) string

+ func AvStrndup(s *int8, len T) *int8

+ func AvSubtitleFree(s *AVSubtitle)

+ func AvTeaCrypt(ctx *AVTEA, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvTeaInit(ctx *AVTEA, key []uint8, rounds int32)

+ func AvTempfile(prefix string, logOffset int32, logCtx CVoidPointer) (filename string, ret int32)

+ func AvThreadMessageFlush(mq *AVThreadMessageQueue)

+ func AvThreadMessageQueueAlloc(mq **AVThreadMessageQueue, nelem, elsize T) int32

+ func AvThreadMessageQueueFree(mq **AVThreadMessageQueue)

+ func AvThreadMessageQueueRecv(mq *AVThreadMessageQueue, msg CVoidPointer, flags uint32) int32

+ func AvThreadMessageQueueSend(mq *AVThreadMessageQueue, msg CVoidPointer, flags uint32) int32

+ func AvThreadMessageQueueSetErrRecv(mq *AVThreadMessageQueue, err int32)

+ func AvThreadMessageQueueSetErrSend(mq *AVThreadMessageQueue, err int32)

+ func AvThreadMessageQueueSetFreeFunc(mq *AVThreadMessageQueue, freeFunc AvThreadMessageFreeFunc)

+ func AvTimecodeAdjustNtscFramenum2(framenum, fps int32) int32

+ func AvTimecodeCheckFrameRate(rate AVRational) int32

+ func AvTimecodeGetSmpteFromFramenum(tc *AVTimecode, framenum int32) uint32

+ func AvTimecodeInit(tc *AVTimecode, rate AVRational, flags, frameStart int32, logCtx CVoidPointer) int32

+ func AvTimecodeInitFromString(tc *AVTimecode, rate AVRational, str string, logCtx CVoidPointer) int32

+ func AvTimecodeMakeMpegTcString(tc25bit uint32) (buf, bufPar string)

+ func AvTimecodeMakeSmpteTcString(tcsmpte uint32, preventDf int32) (buf, bufPar string)

+ func AvTimecodeMakeString(tc *AVTimecode, framenum int32) (buf, bufPar string)

+ func AvTreeDestroy(t *AVTreeNode)

+ func AvTreeEnumerate(t *AVTreeNode, opaque CVoidPointer, cmp AvTreeCmpFunc, enu AvTreeEnuFunc)

+ func AvTreeFind(root *AVTreeNode, key CVoidPointer, cmp AvTreeCmpFunc, next []unsafe.Pointer) unsafe.Pointer

+ func AvTreeInsert(rootp **AVTreeNode, key CVoidPointer, cmp AvTreeCmpFunc, next **AVTreeNode) unsafe.Pointer

+ func AvTs2str(ts T) string

+ func AvTs2timestr(ts T, tb *AVRational) string

+ func AvTsMakeString(ts int64) string

+ func AvTsMakeTimeString(ts int64, tb *AVRational) string

+ func AvTwofishCrypt(d *AVTWOFISH, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvTwofishInit(d *AVTWOFISH, key *uint8, keyBits int32) int32

+ func AvUrlSplit(url string) (proto, authorization, hostname string, port int32, path string)

+ func AvUsleep(usec uint32) int32

+ func AvVersionInfo() string

+ func AvVorbisParseFrame(s *AVVorbisParseContext, buf *uint8, bufSize int32) int32

+ func AvVorbisParseFrameFlags(s *AVVorbisParseContext, buf *uint8, bufSize int32, flags *int32) int32

+ func AvVorbisParseFree(s **AVVorbisParseContext)

+ func AvVorbisParseReset(s *AVVorbisParseContext)

+ func AvWriteFrame(ic *AVFormatContext, pkt *AVPacket) int32

+ func AvWriteImageLine(src *uint16, data []*uint8, linesize []int, desc *AVPixFmtDescriptor, ...)

+ func AvWriteTrailer(ic *AVFormatContext) int32

+ func AvWriteUncodedFrame(ic *AVFormatContext, streamIndex int32, frame *AVFrame) int32

+ func AvWriteUncodedFrameQuery(ic *AVFormatContext, streamIndex int32) int32

+ func AvXIfNull(p, x *T) *T

+ func AvXiphlacing(s *uint8, v int32) int32

+ func AvXteaCrypt(ctx *AVXTEA, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvXteaInit(ctx *AVXTEA, key []uint8)

+ func AvXteaLeCrypt(ctx *AVXTEA, dst, src *uint8, count int32, iv *uint8, decrypt int32)

+ func AvXteaLeInit(ctx *AVXTEA, key []uint8)

+ func Av_IS_INPUT_DEVICE(c AVClassCategory) bool

+ func Av_IS_OUTPUT_DEVICE(c AVClassCategory) bool

+ func Av_LOG_C(x int32) int32

+ func AvutilConfiguration() string

+ func AvutilLicense() string

+ func AvutilVersion() uint32

+ func CondExpr(cond bool, x, y T) T

+ func FFABS(a T) T

+ func FFABS64U(a T) uint64

+ func FFABSU(a T) uint32

+ func FFALIGN(x, a T) T

+ func FFDIFFSIGN(x, y T) int

+ func FFMAX(a, b T) T

+ func FFMAX3(a, b, c T) T

+ func FFMIN(a, b T) T

+ func FFMIN3(a, b, c T) T

+ func FFNABS(a T) T

+ func FFSIGNT(a T) T

+ func FFSWAP(a, b *T)

+ func FFUDIV(a, b T) T

+ func FFUMOD(a, b T) T

+ func FF_CEIL_RSHIFT(a U, b V) U

+ func FfFftCalc(s *FFTContext, z *FFTComplex)

+ func FreePointer(ptr CVoidPointer)

+ func MKBETAG(a, b, c, d uint32) uint32

+ func MKTAG(a, b, c, d uint32) uint32

+ func PlusPlus(x *T) T

+ func PointerOffset(ptr *U, offset V) *U

+ func PostprocConfiguration() string

+ func PostprocLicense() string

+ func PostprocVersion() uint32

+ func PpFreeContext(mode *PpContext)

+ func PpFreeMode(mode *PpMode)

+ func PpPostprocess(src []*uint8, srcStride []int32, dst []*uint8, dstStride []int32, ...)

+ func ROUNDED_DIV(a, b T) T

+ func RSHIFT(a U, b V) U

+ func SliceSlice(data **T, x X, y Y) (v [][]T)

+ func SliceTrunc(ptr *T, truncFunc func(T) bool) []T

+ func SliceTruncString(ptr **C.char) (v []string)

+ func StringCasting(s string) (allocPtr *C.char, freeFunc func())

+ func StringSliceCasting(ss []string) (allocPtrs []*C.char, freeFunc func())

+ func SwResampleConfiguration() string

+ func SwResampleLicense() string

+ func SwResampleVersion() uint32

+ func SwScaleConfiguration() string

+ func SwScaleLicense() string

+ func SwScaleVersion() uint32

+ func SwrBuildMatrix(inLayout, outLayout uint64, ...) int32

+ func SwrClose(s *SwrContext)

+ func SwrConfigFrame(s *SwrContext, out, in *AVFrame) int32

+ func SwrConvert(s *SwrContext, out **uint8, outCount int32, in **uint8, inCount int32) int32

+ func SwrConvertFrame(s *SwrContext, output, input *AVFrame) int32

+ func SwrDropOutput(s *SwrContext, count int32) int32

+ func SwrFree(s **SwrContext)

+ func SwrGetDelay(s *SwrContext, base T) T

+ func SwrGetOutSamples(s *SwrContext, inSamples int32) int32

+ func SwrInit(s *SwrContext) int32

+ func SwrInjectSilence(s *SwrContext, count int32) int32

+ func SwrIsInitialized(s *SwrContext) int32

+ func SwrNextPts(s *SwrContext, pts int64) int64

+ func SwrSetChannelMapping(s *SwrContext, channelMap *int32) int32

+ func SwrSetCompensation(s *SwrContext, sampleDelta, compensationDistance int32) int32

+ func SwrSetMatrix(s *SwrContext, matrix *float64, stride int32) int32

+ func SwsAddVec(a, b *SwsVector)

+ func SwsConvVec(a, b *SwsVector)

+ func SwsConvertPalette8ToPacked24(src, dst *uint8, numPixels int32, palette *uint8)

+ func SwsConvertPalette8ToPacked32(src, dst *uint8, numPixels int32, palette *uint8)

+ func SwsFreeContext(sctx *SwsContext)

+ func SwsFreeFilter(filter *SwsFilter)

+ func SwsFreeVec(a *SwsVector)

+ func SwsGetCoefficients(colorspace int32) *int32

+ func SwsGetColorSpaceDetails(sctx *SwsContext, invTable []int32, srcRange *int32, table []int32, ...) int32

+ func SwsInitContext(sctx *SwsContext, srcFilter, dstFilter *SwsFilter) int32

+ func SwsIsSupportedEndiannessConversion(pixFmt AVPixelFormat) int32

+ func SwsIsSupportedInput(pixFmt AVPixelFormat) int32

+ func SwsIsSupportedOutput(pixFmt AVPixelFormat) int32

+ func SwsNormalizeVec(a *SwsVector, height float64)

+ func SwsPrintVec2(a *SwsVector, logCtx *AVClass, logLevel int32)

+ func SwsScale(sctx *SwsContext, srcSlice []*uint8, srcStride []int32, ...) int32

+ func SwsScaleVec(a *SwsVector, scalar float64)

+ func SwsSetColorSpaceDetails(sctx *SwsContext, invTable []int32, srcRange int32, table []int32, ...) int32

+ func SwsShiftVec(a *SwsVector, shift int32)

+ func SwsSubVec(a, b *SwsVector)

+ func VoidPointer(a CVoidPointer) unsafe.Pointer

+ func VoidPointerPointer(a CVoidPointerPointer) *unsafe.Pointer

+ type AVABufferSinkParams C.struct_AVABufferSinkParams

+ func AvAbuffersinkParamsAlloc() *AVABufferSinkParams

+ func (absp *AVABufferSinkParams) GetAllChannelCounts() int32

+ func (absp *AVABufferSinkParams) GetChannelCounts() []int32

+ func (absp *AVABufferSinkParams) GetChannelLayouts() []int64

+ func (absp *AVABufferSinkParams) GetSampleFmts() []AVSampleFormat

+ func (absp *AVABufferSinkParams) GetSampleRates() []int32

+ type AVAES C.struct_AVAES

+ func AvAesAlloc() *AVAES

+ type AVAESCTR C.struct_AVAESCTR

+ func AvAesCtrAlloc() *AVAESCTR

+ type AVActiveFormatDescription = C.enum_AVActiveFormatDescription

+ type AVAppToDevMessageType = C.enum_AVAppToDevMessageType

+ type AVAudioFifo C.struct_AVAudioFifo

+ func AvAudioFifoAlloc(sampleFmt AVSampleFormat, channels, nbSamples int32) *AVAudioFifo

+ type AVAudioServiceType = C.enum_AVAudioServiceType

+ type AVBPrint C.struct_AVBPrint

+ type AVBSFContext C.struct_AVBSFContext

+ func (bsfc *AVBSFContext) GetAvClass() *AVClass

+ func (bsfc *AVBSFContext) GetAvClassAddr() **AVClass

+ func (bsfc *AVBSFContext) GetFilter() *AVBitStreamFilter

+ func (bsfc *AVBSFContext) GetFilterAddr() **AVBitStreamFilter

+ func (bsfc *AVBSFContext) GetInternal() *AVBSFInternal

+ func (bsfc *AVBSFContext) GetInternalAddr() **AVBSFInternal

+ func (bsfc *AVBSFContext) GetParIn() *AVCodecParameters

+ func (bsfc *AVBSFContext) GetParInAddr() **AVCodecParameters

+ func (bsfc *AVBSFContext) GetParOut() *AVCodecParameters

+ func (bsfc *AVBSFContext) GetParOutAddr() **AVCodecParameters

+ func (bsfc *AVBSFContext) GetPrivData() unsafe.Pointer

+ func (bsfc *AVBSFContext) GetPrivDataAddr() unsafe.Pointer

+ func (bsfc *AVBSFContext) GetTimeBaseIn() AVRational

+ func (bsfc *AVBSFContext) GetTimeBaseInAddr() *AVRational

+ func (bsfc *AVBSFContext) GetTimeBaseOut() AVRational

+ func (bsfc *AVBSFContext) GetTimeBaseOutAddr() *AVRational

+ func (bsfc *AVBSFContext) SetAvClass(v *AVClass)

+ func (bsfc *AVBSFContext) SetFilter(v *AVBitStreamFilter)

+ func (bsfc *AVBSFContext) SetInternal(v *AVBSFInternal)

+ func (bsfc *AVBSFContext) SetParIn(v *AVCodecParameters)

+ func (bsfc *AVBSFContext) SetParOut(v *AVCodecParameters)

+ func (bsfc *AVBSFContext) SetPrivData(v CVoidPointer)

+ func (bsfc *AVBSFContext) SetTimeBaseIn(v AVRational)

+ func (bsfc *AVBSFContext) SetTimeBaseOut(v AVRational)

+ type AVBSFInternal C.struct_AVBSFInternal

+ type AVBSFList C.struct_AVBSFList

+ func AvBsfListAlloc() *AVBSFList

+ type AVBitStreamFilter C.struct_AVBitStreamFilter

+ func AvBitstreamFilterNext(f *AVBitStreamFilter) *AVBitStreamFilter

+ func AvBsfGetByName(name string) *AVBitStreamFilter

+ func AvBsfIterate(opaque CVoidPointerPointer) *AVBitStreamFilter

+ func AvBsfNext(opaque CVoidPointerPointer) *AVBitStreamFilter

+ func (bsf *AVBitStreamFilter) GetCodecIds() []AVCodecID

+ func (bsf *AVBitStreamFilter) GetName() string

+ func (bsf *AVBitStreamFilter) GetPrivClass() *AVClass

+ func (bsf *AVBitStreamFilter) GetPrivClassAddr() **AVClass

+ func (bsf *AVBitStreamFilter) SetPrivClass(v *AVClass)

+ type AVBitStreamFilterContext C.struct_AVBitStreamFilterContext

+ func AvBitstreamFilterInit(name string) *AVBitStreamFilterContext

+ func (obsfc *AVBitStreamFilterContext) GetArgs() string

+ func (obsfc *AVBitStreamFilterContext) GetFilter() *AVBitStreamFilter

+ func (obsfc *AVBitStreamFilterContext) GetNext() *AVBitStreamFilterContext

+ func (obsfc *AVBitStreamFilterContext) GetParser() *AVCodecParserContext

+ func (obsfc *AVBitStreamFilterContext) GetPrivData() unsafe.Pointer

+ type AVBlowfish C.struct_AVBlowfish

+ func AvBlowfishAlloc() *AVBlowfish

+ func (bf *AVBlowfish) GetP() []uint32

+ func (bf *AVBlowfish) GetPAddr() **uint32

+ func (bf *AVBlowfish) GetS() (v [][]uint32)

+ func (bf *AVBlowfish) GetSAddr() **uint32

+ func (bf *AVBlowfish) SetP(v []uint32)

+ func (bf *AVBlowfish) SetS(v [][]uint32)

+ type AVBuffer C.struct_AVBuffer

+ type AVBufferFreeFunc = C.av_buffer_free_func

+ type AVBufferPool C.struct_AVBufferPool

+ func AvBufferPoolInit(size int32, alloc AVBufferPoolAllocFunc) *AVBufferPool

+ func AvBufferPoolInit2(size int32, opaque CVoidPointer, alloc AVBufferPoolAllocFunc, ...) *AVBufferPool

+ type AVBufferPoolAlloc2Func = C.av_buffer_pool_alloc2_func

+ type AVBufferPoolAllocFunc = C.av_buffer_pool_alloc_func

+ type AVBufferPoolFreeFunc = C.av_buffer_pool_free_func

+ type AVBufferRef C.struct_AVBufferRef

+ func AvBufferAlloc(size int32) *AVBufferRef

+ func AvBufferAllocz(size int32) *AVBufferRef

+ func AvBufferCreate(data *uint8, size int32, free AVBufferFreeFunc, opaque CVoidPointer, ...) *AVBufferRef

+ func AvBufferPoolGet(pool *AVBufferPool) *AVBufferRef

+ func AvBufferRef(buf *AVBufferRef) *AVBufferRef

+ func AvBuffersinkGetHwFramesCtx(ctx *AVFilterContext) *AVBufferRef

+ func AvFrameGetPlaneBuffer(frame *AVFrame, plane int32) *AVBufferRef

+ func AvHWDeviceCtxAlloc(prev AVHWDeviceType) *AVBufferRef

+ func AvHWFrameCtxAlloc(deviceCtx *AVBufferRef) *AVBufferRef

+ func (bf *AVBufferRef) GetBuffer() *AVBuffer

+ func (bf *AVBufferRef) GetData() *uint8

+ func (bf *AVBufferRef) GetSize() int32

+ type AVBufferSinkParams C.struct_AVBufferSinkParams

+ func AvBuffersinkParamsAlloc() *AVBufferSinkParams

+ func (bsp *AVBufferSinkParams) GetPixelFmts() []AVPixelFormat

+ type AVBufferSrcParameters C.struct_AVBufferSrcParameters

+ func AvBuffersrcParametersAlloc() *AVBufferSrcParameters

+ func (bsrc *AVBufferSrcParameters) GetChannelLayout() uint64

+ func (bsrc *AVBufferSrcParameters) GetChannelLayoutAddr() *uint64

+ func (bsrc *AVBufferSrcParameters) GetFormat() int32

+ func (bsrc *AVBufferSrcParameters) GetFormatAddr() *int32

+ func (bsrc *AVBufferSrcParameters) GetFrameRate() AVRational

+ func (bsrc *AVBufferSrcParameters) GetFrameRateAddr() *AVRational

+ func (bsrc *AVBufferSrcParameters) GetHeight() int32

+ func (bsrc *AVBufferSrcParameters) GetHeightAddr() *int32

+ func (bsrc *AVBufferSrcParameters) GetHwFramesCtx() *AVBufferRef

+ func (bsrc *AVBufferSrcParameters) GetHwFramesCtxAddr() **AVBufferRef

+ func (bsrc *AVBufferSrcParameters) GetSampleAspectRatio() AVRational

+ func (bsrc *AVBufferSrcParameters) GetSampleAspectRatioAddr() *AVRational

+ func (bsrc *AVBufferSrcParameters) GetSampleRate() int32

+ func (bsrc *AVBufferSrcParameters) GetSampleRateAddr() *int32

+ func (bsrc *AVBufferSrcParameters) GetTimeBase() AVRational

+ func (bsrc *AVBufferSrcParameters) GetTimeBaseAddr() *AVRational

+ func (bsrc *AVBufferSrcParameters) GetWidth() int32

+ func (bsrc *AVBufferSrcParameters) GetWidthAddr() *int32

+ func (bsrc *AVBufferSrcParameters) SetChannelLayout(v uint64)

+ func (bsrc *AVBufferSrcParameters) SetFormat(v int32)

+ func (bsrc *AVBufferSrcParameters) SetFrameRate(v AVRational)

+ func (bsrc *AVBufferSrcParameters) SetHeight(v int32)

+ func (bsrc *AVBufferSrcParameters) SetHwFramesCtx(v *AVBufferRef)

+ func (bsrc *AVBufferSrcParameters) SetSampleAspectRatio(v AVRational)

+ func (bsrc *AVBufferSrcParameters) SetSampleRate(v int32)

+ func (bsrc *AVBufferSrcParameters) SetTimeBase(v AVRational)

+ func (bsrc *AVBufferSrcParameters) SetWidth(v int32)

+ type AVCAMELLIA C.struct_AVCAMELLIA

+ func AvCamelliaAlloc() *AVCAMELLIA

+ type AVCAST5 C.struct_AVCAST5

+ func AvCast5Alloc() *AVCAST5

+ type AVCPBProperties C.struct_AVCPBProperties

+ func AvCpbPropertiesAlloc(size *uintptr) *AVCPBProperties

+ func (cpbp *AVCPBProperties) GetAvgBitrate() int32

+ func (cpbp *AVCPBProperties) GetAvgBitrateAddr() *int32

+ func (cpbp *AVCPBProperties) GetBufferSize() int32

+ func (cpbp *AVCPBProperties) GetBufferSizeAddr() *int32

+ func (cpbp *AVCPBProperties) GetMaxBitrate() int32

+ func (cpbp *AVCPBProperties) GetMaxBitrateAddr() *int32

+ func (cpbp *AVCPBProperties) GetMinBitrate() int32

+ func (cpbp *AVCPBProperties) GetMinBitrateAddr() *int32

+ func (cpbp *AVCPBProperties) GetVbvDelay() uint64

+ func (cpbp *AVCPBProperties) GetVbvDelayAddr() *uint64

+ func (cpbp *AVCPBProperties) SetAvgBitrate(v int32)

+ func (cpbp *AVCPBProperties) SetBufferSize(v int32)

+ func (cpbp *AVCPBProperties) SetMaxBitrate(v int32)

+ func (cpbp *AVCPBProperties) SetMinBitrate(v int32)

+ func (cpbp *AVCPBProperties) SetVbvDelay(v uint64)

+ type AVCRC C.AVCRC

+ func AvCrcGetTable(crcId AVCRCId) *AVCRC

+ type AVCRCId = C.AVCRCId

+ type AVChapter = C.struct_AVChapter

+ func (cpt *AVChapter) GetEnd() int64

+ func (cpt *AVChapter) GetEndAddr() *int64

+ func (cpt *AVChapter) GetId() int32

+ func (cpt *AVChapter) GetIdAddr() *int32

+ func (cpt *AVChapter) GetMetadata() *AVDictionary

+ func (cpt *AVChapter) GetMetadataAddr() **AVDictionary

+ func (cpt *AVChapter) GetStart() int64

+ func (cpt *AVChapter) GetStartAddr() *int64

+ func (cpt *AVChapter) GetTimeBase() AVRational

+ func (cpt *AVChapter) GetTimeBaseAddr() *AVRational

+ func (cpt *AVChapter) SetEnd(v int64)

+ func (cpt *AVChapter) SetId(v int32)

+ func (cpt *AVChapter) SetMetadata(v *AVDictionary)

+ func (cpt *AVChapter) SetStart(v int64)

+ func (cpt *AVChapter) SetTimeBase(v AVRational)

+ type AVChromaLocation = C.enum_AVChromaLocation

+ func AvCodecChromaPosToEnum(xpos, ypos int32) AVChromaLocation

+ type AVClass C.struct_AVClass

+ func AvBsfGetClass() *AVClass

+ func AvCodecDctGetClass() *AVClass

+ func AvCodecGetClass() *AVClass

+ func AvCodecGetFrameClass() *AVClass

+ func AvCodecGetSubtitleRectClass() *AVClass

+ func AvFilterGetClass() *AVClass

+ func AvFormatGetClass() *AVClass

+ func AvOptChildClassNext(parent, prev *AVClass) *AVClass

+ func SwrGetClass() *AVClass

+ func SwsGetClass() *AVClass

+ func (cls *AVClass) GetCategory() AVClassCategory

+ func (cls *AVClass) GetChildClassNext() AvClassChildClassNextFunc

+ func (cls *AVClass) GetChildClassNextAddr() *AvClassChildClassNextFunc

+ func (cls *AVClass) GetChildNext() AvClassChildNextFunc

+ func (cls *AVClass) GetChildNextAddr() *AvClassChildNextFunc

+ func (cls *AVClass) GetClassName() string

+ func (cls *AVClass) GetItemName() AvClassItemNameFunc

+ func (cls *AVClass) GetItemNameAddr() *AvClassItemNameFunc

+ func (cls *AVClass) GetLogLevelOffsetOffset() int32

+ func (cls *AVClass) GetOption() *AVOption

+ func (cls *AVClass) GetParentLogContextOffset() int32

+ func (cls *AVClass) GetVersion() int32

+ func (cls *AVClass) SetChildClassNext(v AvClassChildClassNextFunc)

+ func (cls *AVClass) SetChildNext(v AvClassChildNextFunc)

+ func (cls *AVClass) SetItemName(v AvClassItemNameFunc)

+ type AVClassCategory = int32

+ func AvDefaultGetCategory(ptr CVoidPointer) AVClassCategory

+ type AVCodec C.struct_AVCodec

+ func AvCodecFindDecoder(id AVCodecID) *AVCodec

+ func AvCodecFindDecoderByName(name string) *AVCodec

+ func AvCodecFindEncoder(id AVCodecID) *AVCodec

+ func AvCodecFindEncoderByName(name string) *AVCodec

+ func AvCodecIterate(opaque CVoidPointerPointer) *AVCodec

+ func AvCodecNext(c *AVCodec) *AVCodec

+ func AvFormatGetAudioCodec(s *AVFormatContext) *AVCodec

+ func AvFormatGetDataCodec(s *AVFormatContext) *AVCodec

+ func AvFormatGetSubtitleCodec(s *AVFormatContext) *AVCodec

+ func AvFormatGetVideoCodec(s *AVFormatContext) *AVCodec

+ func (codec *AVCodec) GetCapabilities() int32

+ func (codec *AVCodec) GetChannelLayouts() []uint64

+ func (codec *AVCodec) GetID() AVCodecID

+ func (codec *AVCodec) GetLongName() string

+ func (codec *AVCodec) GetMaxLowres() uint8

+ func (codec *AVCodec) GetName() string

+ func (codec *AVCodec) GetPixFmts() []AVPixelFormat

+ func (codec *AVCodec) GetProfiles() []AVProfile

+ func (codec *AVCodec) GetSampleFmts() []AVSampleFormat

+ func (codec *AVCodec) GetSupportedFramerates() []AVRational

+ func (codec *AVCodec) GetSupportedSamplerates() []int32

+ func (codec *AVCodec) GetType() AVMediaType

+ func (codec *AVCodec) GetWrapperName() string

+ type AVCodecContext C.struct_AVCodecContext

+ func AvCodecAllocContext3(c *AVCodec) *AVCodecContext

+ func (avctx *AVCodecContext) GetActiveThreadType() int32

+ func (avctx *AVCodecContext) GetActiveThreadTypeAddr() *int32

+ func (avctx *AVCodecContext) GetApplyCropping() int32

+ func (avctx *AVCodecContext) GetApplyCroppingAddr() *int32

+ func (avctx *AVCodecContext) GetAudioServiceType() AVAudioServiceType

+ func (avctx *AVCodecContext) GetAudioServiceTypeAddr() *AVAudioServiceType

+ func (avctx *AVCodecContext) GetAvClass() *AVClass

+ func (avctx *AVCodecContext) GetAvClassAddr() **AVClass

+ func (avctx *AVCodecContext) GetBFrameStrategy() int32

+ func (avctx *AVCodecContext) GetBFrameStrategyAddr() *int32

+ func (avctx *AVCodecContext) GetBQuantFactor() float32

+ func (avctx *AVCodecContext) GetBQuantFactorAddr() *float32

+ func (avctx *AVCodecContext) GetBQuantOffset() float32

+ func (avctx *AVCodecContext) GetBQuantOffsetAddr() *float32

+ func (avctx *AVCodecContext) GetBSensitivity() int32

+ func (avctx *AVCodecContext) GetBSensitivityAddr() *int32

+ func (avctx *AVCodecContext) GetBidirRefine() int32

+ func (avctx *AVCodecContext) GetBidirRefineAddr() *int32

+ func (avctx *AVCodecContext) GetBitRate() int64

+ func (avctx *AVCodecContext) GetBitRateAddr() *int64

+ func (avctx *AVCodecContext) GetBitRateTolerance() int32

+ func (avctx *AVCodecContext) GetBitRateToleranceAddr() *int32

+ func (avctx *AVCodecContext) GetBitsPerCodedSample() int32

+ func (avctx *AVCodecContext) GetBitsPerCodedSampleAddr() *int32

+ func (avctx *AVCodecContext) GetBitsPerRawSample() int32

+ func (avctx *AVCodecContext) GetBitsPerRawSampleAddr() *int32

+ func (avctx *AVCodecContext) GetBlockAlign() int32

+ func (avctx *AVCodecContext) GetBlockAlignAddr() *int32

+ func (avctx *AVCodecContext) GetBrdScale() int32

+ func (avctx *AVCodecContext) GetBrdScaleAddr() *int32

+ func (avctx *AVCodecContext) GetChannelLayout() uint64

+ func (avctx *AVCodecContext) GetChannelLayoutAddr() *uint64

+ func (avctx *AVCodecContext) GetChannels() int32

+ func (avctx *AVCodecContext) GetChannelsAddr() *int32

+ func (avctx *AVCodecContext) GetChromaIntraMatrix() *uint16

+ func (avctx *AVCodecContext) GetChromaIntraMatrixAddr() **uint16

+ func (avctx *AVCodecContext) GetChromaSampleLocation() AVChromaLocation

+ func (avctx *AVCodecContext) GetChromaSampleLocationAddr() *AVChromaLocation

+ func (avctx *AVCodecContext) GetChromaoffset() int32

+ func (avctx *AVCodecContext) GetChromaoffsetAddr() *int32

+ func (avctx *AVCodecContext) GetCodec() *AVCodec

+ func (avctx *AVCodecContext) GetCodecAddr() **AVCodec

+ func (avctx *AVCodecContext) GetCodecDescriptor() *AVCodecDescriptor

+ func (avctx *AVCodecContext) GetCodecDescriptorAddr() **AVCodecDescriptor

+ func (avctx *AVCodecContext) GetCodecId() AVCodecID

+ func (avctx *AVCodecContext) GetCodecIdAddr() *AVCodecID

+ func (avctx *AVCodecContext) GetCodecTag() uint32

+ func (avctx *AVCodecContext) GetCodecTagAddr() *uint32

+ func (avctx *AVCodecContext) GetCodecType() AVMediaType

+ func (avctx *AVCodecContext) GetCodecTypeAddr() *AVMediaType

+ func (avctx *AVCodecContext) GetCodecWhitelist() string

+ func (avctx *AVCodecContext) GetCodedFrame() *AVFrame

+ func (avctx *AVCodecContext) GetCodedFrameAddr() **AVFrame

+ func (avctx *AVCodecContext) GetCodedHeight() int32

+ func (avctx *AVCodecContext) GetCodedHeightAddr() *int32

+ func (avctx *AVCodecContext) GetCodedSideData() *AVPacketSideData

+ func (avctx *AVCodecContext) GetCodedSideDataAddr() **AVPacketSideData

+ func (avctx *AVCodecContext) GetCodedWidth() int32

+ func (avctx *AVCodecContext) GetCodedWidthAddr() *int32

+ func (avctx *AVCodecContext) GetCoderType() int32

+ func (avctx *AVCodecContext) GetCoderTypeAddr() *int32

+ func (avctx *AVCodecContext) GetColorPrimaries() AVColorPrimaries

+ func (avctx *AVCodecContext) GetColorPrimariesAddr() *AVColorPrimaries

+ func (avctx *AVCodecContext) GetColorRange() AVColorRange

+ func (avctx *AVCodecContext) GetColorRangeAddr() *AVColorRange

+ func (avctx *AVCodecContext) GetColorTrc() AVColorTransferCharacteristic

+ func (avctx *AVCodecContext) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (avctx *AVCodecContext) GetColorspace() AVColorSpace

+ func (avctx *AVCodecContext) GetColorspaceAddr() *AVColorSpace

+ func (avctx *AVCodecContext) GetCompressionLevel() int32

+ func (avctx *AVCodecContext) GetCompressionLevelAddr() *int32

+ func (avctx *AVCodecContext) GetContextModel() int32

+ func (avctx *AVCodecContext) GetContextModelAddr() *int32

+ func (avctx *AVCodecContext) GetCutoff() int32

+ func (avctx *AVCodecContext) GetCutoffAddr() *int32

+ func (avctx *AVCodecContext) GetDarkMasking() float32

+ func (avctx *AVCodecContext) GetDarkMaskingAddr() *float32

+ func (avctx *AVCodecContext) GetDctAlgo() int32

+ func (avctx *AVCodecContext) GetDctAlgoAddr() *int32

+ func (avctx *AVCodecContext) GetDebug() int32

+ func (avctx *AVCodecContext) GetDebugAddr() *int32

+ func (avctx *AVCodecContext) GetDebugMv() int32

+ func (avctx *AVCodecContext) GetDebugMvAddr() *int32

+ func (avctx *AVCodecContext) GetDelay() int32

+ func (avctx *AVCodecContext) GetDelayAddr() *int32

+ func (avctx *AVCodecContext) GetDiaSize() int32

+ func (avctx *AVCodecContext) GetDiaSizeAddr() *int32

+ func (avctx *AVCodecContext) GetDrawHorizBand() AVCodecContextDrawHorizBandFunc

+ func (avctx *AVCodecContext) GetDrawHorizBandAddr() *AVCodecContextDrawHorizBandFunc

+ func (avctx *AVCodecContext) GetDumpSeparator() *uint8

+ func (avctx *AVCodecContext) GetDumpSeparatorAddr() **uint8

+ func (avctx *AVCodecContext) GetErrRecognition() int32

+ func (avctx *AVCodecContext) GetErrRecognitionAddr() *int32

+ func (avctx *AVCodecContext) GetError() []uint64

+ func (avctx *AVCodecContext) GetErrorAddr() **uint64

+ func (avctx *AVCodecContext) GetErrorConcealment() int32

+ func (avctx *AVCodecContext) GetErrorConcealmentAddr() *int32

+ func (avctx *AVCodecContext) GetExecute() AvCodecContextInternalExecuteFunc

+ func (avctx *AVCodecContext) GetExecute2() AvCodecContextInternalExecute2Func

+ func (avctx *AVCodecContext) GetExecute2Addr() *AvCodecContextInternalExecute2Func

+ func (avctx *AVCodecContext) GetExecuteAddr() *AvCodecContextInternalExecuteFunc

+ func (avctx *AVCodecContext) GetExtraHwFrames() int32

+ func (avctx *AVCodecContext) GetExtraHwFramesAddr() *int32

+ func (avctx *AVCodecContext) GetExtradata() *uint8

+ func (avctx *AVCodecContext) GetExtradataAddr() **uint8

+ func (avctx *AVCodecContext) GetExtradataSize() int32

+ func (avctx *AVCodecContext) GetExtradataSizeAddr() *int32

+ func (avctx *AVCodecContext) GetFieldOrder() AVFieldOrder

+ func (avctx *AVCodecContext) GetFieldOrderAddr() *AVFieldOrder

+ func (avctx *AVCodecContext) GetFlags() int32

+ func (avctx *AVCodecContext) GetFlags2() int32

+ func (avctx *AVCodecContext) GetFlags2Addr() *int32

+ func (avctx *AVCodecContext) GetFlagsAddr() *int32

+ func (avctx *AVCodecContext) GetFrameBits() int32

+ func (avctx *AVCodecContext) GetFrameBitsAddr() *int32

+ func (avctx *AVCodecContext) GetFrameNumber() int32

+ func (avctx *AVCodecContext) GetFrameNumberAddr() *int32

+ func (avctx *AVCodecContext) GetFrameSize() int32

+ func (avctx *AVCodecContext) GetFrameSizeAddr() *int32

+ func (avctx *AVCodecContext) GetFrameSkipCmp() int32

+ func (avctx *AVCodecContext) GetFrameSkipCmpAddr() *int32

+ func (avctx *AVCodecContext) GetFrameSkipExp() int32

+ func (avctx *AVCodecContext) GetFrameSkipExpAddr() *int32

+ func (avctx *AVCodecContext) GetFrameSkipFactor() int32

+ func (avctx *AVCodecContext) GetFrameSkipFactorAddr() *int32

+ func (avctx *AVCodecContext) GetFrameSkipThreshold() int32

+ func (avctx *AVCodecContext) GetFrameSkipThresholdAddr() *int32

+ func (avctx *AVCodecContext) GetFramerate() AVRational

+ func (avctx *AVCodecContext) GetFramerateAddr() *AVRational

+ func (avctx *AVCodecContext) GetGetBuffer2() AVCodecContextGetBuffer2Func

+ func (avctx *AVCodecContext) GetGetBuffer2Addr() *AVCodecContextGetBuffer2Func

+ func (avctx *AVCodecContext) GetGetFormat() AVCodecContextGetFormatFunc

+ func (avctx *AVCodecContext) GetGetFormatAddr() *AVCodecContextGetFormatFunc

+ func (avctx *AVCodecContext) GetGlobalQuality() int32

+ func (avctx *AVCodecContext) GetGlobalQualityAddr() *int32

+ func (avctx *AVCodecContext) GetGopSize() int32

+ func (avctx *AVCodecContext) GetGopSizeAddr() *int32

+ func (avctx *AVCodecContext) GetHasBFrames() int32

+ func (avctx *AVCodecContext) GetHasBFramesAddr() *int32

+ func (avctx *AVCodecContext) GetHeaderBits() int32

+ func (avctx *AVCodecContext) GetHeaderBitsAddr() *int32

+ func (avctx *AVCodecContext) GetHeight() int32

+ func (avctx *AVCodecContext) GetHeightAddr() *int32

+ func (avctx *AVCodecContext) GetHwDeviceCtx() *AVBufferRef

+ func (avctx *AVCodecContext) GetHwDeviceCtxAddr() **AVBufferRef

+ func (avctx *AVCodecContext) GetHwFramesCtx() *AVBufferRef

+ func (avctx *AVCodecContext) GetHwFramesCtxAddr() **AVBufferRef

+ func (avctx *AVCodecContext) GetHwaccel() *AVHWAccel

+ func (avctx *AVCodecContext) GetHwaccelAddr() **AVHWAccel

+ func (avctx *AVCodecContext) GetHwaccelContext() unsafe.Pointer

+ func (avctx *AVCodecContext) GetHwaccelContextAddr() unsafe.Pointer

+ func (avctx *AVCodecContext) GetHwaccelFlags() int32

+ func (avctx *AVCodecContext) GetHwaccelFlagsAddr() *int32

+ func (avctx *AVCodecContext) GetICount() int32

+ func (avctx *AVCodecContext) GetICountAddr() *int32

+ func (avctx *AVCodecContext) GetIQuantFactor() float32

+ func (avctx *AVCodecContext) GetIQuantFactorAddr() *float32

+ func (avctx *AVCodecContext) GetIQuantOffset() float32

+ func (avctx *AVCodecContext) GetIQuantOffsetAddr() *float32

+ func (avctx *AVCodecContext) GetITexBits() int32

+ func (avctx *AVCodecContext) GetITexBitsAddr() *int32

+ func (avctx *AVCodecContext) GetIdctAlgo() int32

+ func (avctx *AVCodecContext) GetIdctAlgoAddr() *int32

+ func (avctx *AVCodecContext) GetIldctCmp() int32

+ func (avctx *AVCodecContext) GetIldctCmpAddr() *int32

+ func (avctx *AVCodecContext) GetInitialPadding() int32

+ func (avctx *AVCodecContext) GetInitialPaddingAddr() *int32

+ func (avctx *AVCodecContext) GetInterMatrix() *uint16

+ func (avctx *AVCodecContext) GetInterMatrixAddr() **uint16

+ func (avctx *AVCodecContext) GetIntraDcPrecision() int32

+ func (avctx *AVCodecContext) GetIntraDcPrecisionAddr() *int32

+ func (avctx *AVCodecContext) GetIntraMatrix() *uint16

+ func (avctx *AVCodecContext) GetIntraMatrixAddr() **uint16

+ func (avctx *AVCodecContext) GetKeyintMin() int32

+ func (avctx *AVCodecContext) GetKeyintMinAddr() *int32

+ func (avctx *AVCodecContext) GetLastPredictorCount() int32

+ func (avctx *AVCodecContext) GetLastPredictorCountAddr() *int32

+ func (avctx *AVCodecContext) GetLevel() int32

+ func (avctx *AVCodecContext) GetLevelAddr() *int32

+ func (avctx *AVCodecContext) GetLogLevelOffset() int32

+ func (avctx *AVCodecContext) GetLogLevelOffsetAddr() *int32

+ func (avctx *AVCodecContext) GetLowres() int32

+ func (avctx *AVCodecContext) GetLowresAddr() *int32

+ func (avctx *AVCodecContext) GetLumiMasking() float32

+ func (avctx *AVCodecContext) GetLumiMaskingAddr() *float32

+ func (avctx *AVCodecContext) GetMaxBFrames() int32

+ func (avctx *AVCodecContext) GetMaxBFramesAddr() *int32

+ func (avctx *AVCodecContext) GetMaxPixels() int64

+ func (avctx *AVCodecContext) GetMaxPixelsAddr() *int64

+ func (avctx *AVCodecContext) GetMaxPredictionOrder() int32

+ func (avctx *AVCodecContext) GetMaxPredictionOrderAddr() *int32

+ func (avctx *AVCodecContext) GetMaxQdiff() int32

+ func (avctx *AVCodecContext) GetMaxQdiffAddr() *int32

+ func (avctx *AVCodecContext) GetMbCmp() int32

+ func (avctx *AVCodecContext) GetMbCmpAddr() *int32

+ func (avctx *AVCodecContext) GetMbDecision() int32

+ func (avctx *AVCodecContext) GetMbDecisionAddr() *int32

+ func (avctx *AVCodecContext) GetMbLmax() int32

+ func (avctx *AVCodecContext) GetMbLmaxAddr() *int32

+ func (avctx *AVCodecContext) GetMbLmin() int32

+ func (avctx *AVCodecContext) GetMbLminAddr() *int32

+ func (avctx *AVCodecContext) GetMeCmp() int32

+ func (avctx *AVCodecContext) GetMeCmpAddr() *int32

+ func (avctx *AVCodecContext) GetMePenaltyCompensation() int32

+ func (avctx *AVCodecContext) GetMePenaltyCompensationAddr() *int32

+ func (avctx *AVCodecContext) GetMePreCmp() int32

+ func (avctx *AVCodecContext) GetMePreCmpAddr() *int32

+ func (avctx *AVCodecContext) GetMeSubCmp() int32

+ func (avctx *AVCodecContext) GetMeSubCmpAddr() *int32

+ func (avctx *AVCodecContext) GetMeSubpelQuality() int32

+ func (avctx *AVCodecContext) GetMeSubpelQualityAddr() *int32

+ func (avctx *AVCodecContext) GetMinPredictionOrder() int32

+ func (avctx *AVCodecContext) GetMinPredictionOrderAddr() *int32

+ func (avctx *AVCodecContext) GetMiscBits() int32

+ func (avctx *AVCodecContext) GetMiscBitsAddr() *int32

+ func (avctx *AVCodecContext) GetMpegQuant() int32

+ func (avctx *AVCodecContext) GetMpegQuantAddr() *int32

+ func (avctx *AVCodecContext) GetMv0Threshold() int32

+ func (avctx *AVCodecContext) GetMv0ThresholdAddr() *int32

+ func (avctx *AVCodecContext) GetMvBits() int32

+ func (avctx *AVCodecContext) GetMvBitsAddr() *int32

+ func (avctx *AVCodecContext) GetNbCodedSideData() int32

+ func (avctx *AVCodecContext) GetNbCodedSideDataAddr() *int32

+ func (avctx *AVCodecContext) GetNoiseReduction() int32

+ func (avctx *AVCodecContext) GetNoiseReductionAddr() *int32

+ func (avctx *AVCodecContext) GetNsseWeight() int32

+ func (avctx *AVCodecContext) GetNsseWeightAddr() *int32

+ func (avctx *AVCodecContext) GetOpaque() unsafe.Pointer

+ func (avctx *AVCodecContext) GetOpaqueAddr() unsafe.Pointer

+ func (avctx *AVCodecContext) GetPCount() int32

+ func (avctx *AVCodecContext) GetPCountAddr() *int32

+ func (avctx *AVCodecContext) GetPMasking() float32

+ func (avctx *AVCodecContext) GetPMaskingAddr() *float32

+ func (avctx *AVCodecContext) GetPTexBits() int32

+ func (avctx *AVCodecContext) GetPTexBitsAddr() *int32

+ func (avctx *AVCodecContext) GetPixFmt() AVPixelFormat

+ func (avctx *AVCodecContext) GetPixFmtAddr() *AVPixelFormat

+ func (avctx *AVCodecContext) GetPktTimebase() AVRational

+ func (avctx *AVCodecContext) GetPktTimebaseAddr() *AVRational

+ func (avctx *AVCodecContext) GetPreDiaSize() int32

+ func (avctx *AVCodecContext) GetPreDiaSizeAddr() *int32

+ func (avctx *AVCodecContext) GetPreMe() int32

+ func (avctx *AVCodecContext) GetPreMeAddr() *int32

+ func (avctx *AVCodecContext) GetPredictionMethod() int32

+ func (avctx *AVCodecContext) GetPredictionMethodAddr() *int32

+ func (avctx *AVCodecContext) GetPrivData() unsafe.Pointer

+ func (avctx *AVCodecContext) GetPrivDataAddr() unsafe.Pointer

+ func (avctx *AVCodecContext) GetProfile() int32

+ func (avctx *AVCodecContext) GetProfileAddr() *int32

+ func (avctx *AVCodecContext) GetProperties() uint32

+ func (avctx *AVCodecContext) GetPropertiesAddr() *uint32

+ func (avctx *AVCodecContext) GetPtsCorrectionLastDts() int64

+ func (avctx *AVCodecContext) GetPtsCorrectionLastDtsAddr() *int64

+ func (avctx *AVCodecContext) GetPtsCorrectionLastPts() int64

+ func (avctx *AVCodecContext) GetPtsCorrectionLastPtsAddr() *int64

+ func (avctx *AVCodecContext) GetPtsCorrectionNumFaultyDts() int64

+ func (avctx *AVCodecContext) GetPtsCorrectionNumFaultyDtsAddr() *int64

+ func (avctx *AVCodecContext) GetPtsCorrectionNumFaultyPts() int64

+ func (avctx *AVCodecContext) GetPtsCorrectionNumFaultyPtsAddr() *int64

+ func (avctx *AVCodecContext) GetQblur() float32

+ func (avctx *AVCodecContext) GetQblurAddr() *float32

+ func (avctx *AVCodecContext) GetQcompress() float32

+ func (avctx *AVCodecContext) GetQcompressAddr() *float32

+ func (avctx *AVCodecContext) GetQmax() int32

+ func (avctx *AVCodecContext) GetQmaxAddr() *int32

+ func (avctx *AVCodecContext) GetQmin() int32

+ func (avctx *AVCodecContext) GetQminAddr() *int32

+ func (avctx *AVCodecContext) GetRcBufferSize() int32

+ func (avctx *AVCodecContext) GetRcBufferSizeAddr() *int32

+ func (avctx *AVCodecContext) GetRcInitialBufferOccupancy() int32

+ func (avctx *AVCodecContext) GetRcInitialBufferOccupancyAddr() *int32

+ func (avctx *AVCodecContext) GetRcMaxAvailableVbvUse() float32

+ func (avctx *AVCodecContext) GetRcMaxAvailableVbvUseAddr() *float32

+ func (avctx *AVCodecContext) GetRcMaxRate() int64

+ func (avctx *AVCodecContext) GetRcMaxRateAddr() *int64

+ func (avctx *AVCodecContext) GetRcMinRate() int64

+ func (avctx *AVCodecContext) GetRcMinRateAddr() *int64

+ func (avctx *AVCodecContext) GetRcMinVbvOverflowUse() float32

+ func (avctx *AVCodecContext) GetRcMinVbvOverflowUseAddr() *float32

+ func (avctx *AVCodecContext) GetRcOverride() *RcOverride

+ func (avctx *AVCodecContext) GetRcOverrideAddr() **RcOverride

+ func (avctx *AVCodecContext) GetRcOverrideCount() int32

+ func (avctx *AVCodecContext) GetRcOverrideCountAddr() *int32

+ func (avctx *AVCodecContext) GetRefcountedFrames() int32

+ func (avctx *AVCodecContext) GetRefcountedFramesAddr() *int32

+ func (avctx *AVCodecContext) GetRefs() int32

+ func (avctx *AVCodecContext) GetRefsAddr() *int32

+ func (avctx *AVCodecContext) GetReorderedOpaque() int64

+ func (avctx *AVCodecContext) GetReorderedOpaqueAddr() *int64

+ func (avctx *AVCodecContext) GetRequestChannelLayout() uint64

+ func (avctx *AVCodecContext) GetRequestChannelLayoutAddr() *uint64

+ func (avctx *AVCodecContext) GetRequestSampleFmt() AVSampleFormat

+ func (avctx *AVCodecContext) GetRequestSampleFmtAddr() *AVSampleFormat

+ func (avctx *AVCodecContext) GetRtpCallback() AvCodecContextRtpCallbackFunc

+ func (avctx *AVCodecContext) GetRtpCallbackAddr() *AvCodecContextRtpCallbackFunc

+ func (avctx *AVCodecContext) GetRtpPayloadSize() int32

+ func (avctx *AVCodecContext) GetRtpPayloadSizeAddr() *int32

+ func (avctx *AVCodecContext) GetSampleAspectRatio() AVRational

+ func (avctx *AVCodecContext) GetSampleAspectRatioAddr() *AVRational

+ func (avctx *AVCodecContext) GetSampleFmt() AVSampleFormat

+ func (avctx *AVCodecContext) GetSampleFmtAddr() *AVSampleFormat

+ func (avctx *AVCodecContext) GetSampleRate() int32

+ func (avctx *AVCodecContext) GetSampleRateAddr() *int32

+ func (avctx *AVCodecContext) GetScenechangeThreshold() int32

+ func (avctx *AVCodecContext) GetScenechangeThresholdAddr() *int32

+ func (avctx *AVCodecContext) GetSeekPreroll() int32

+ func (avctx *AVCodecContext) GetSeekPrerollAddr() *int32

+ func (avctx *AVCodecContext) GetSideDataOnlyPackets() int32

+ func (avctx *AVCodecContext) GetSideDataOnlyPacketsAddr() *int32

+ func (avctx *AVCodecContext) GetSkipAlpha() int32

+ func (avctx *AVCodecContext) GetSkipAlphaAddr() *int32

+ func (avctx *AVCodecContext) GetSkipBottom() int32

+ func (avctx *AVCodecContext) GetSkipBottomAddr() *int32

+ func (avctx *AVCodecContext) GetSkipCount() int32

+ func (avctx *AVCodecContext) GetSkipCountAddr() *int32

+ func (avctx *AVCodecContext) GetSkipFrame() AVDiscard

+ func (avctx *AVCodecContext) GetSkipFrameAddr() *AVDiscard

+ func (avctx *AVCodecContext) GetSkipIdct() AVDiscard

+ func (avctx *AVCodecContext) GetSkipIdctAddr() *AVDiscard

+ func (avctx *AVCodecContext) GetSkipLoopFilter() AVDiscard

+ func (avctx *AVCodecContext) GetSkipLoopFilterAddr() *AVDiscard

+ func (avctx *AVCodecContext) GetSkipTop() int32

+ func (avctx *AVCodecContext) GetSkipTopAddr() *int32

+ func (avctx *AVCodecContext) GetSliceCount() int32

+ func (avctx *AVCodecContext) GetSliceCountAddr() *int32

+ func (avctx *AVCodecContext) GetSliceFlags() int32

+ func (avctx *AVCodecContext) GetSliceFlagsAddr() *int32

+ func (avctx *AVCodecContext) GetSliceOffset() *int32

+ func (avctx *AVCodecContext) GetSliceOffsetAddr() **int32

+ func (avctx *AVCodecContext) GetSlices() int32

+ func (avctx *AVCodecContext) GetSlicesAddr() *int32

+ func (avctx *AVCodecContext) GetSpatialCplxMasking() float32

+ func (avctx *AVCodecContext) GetSpatialCplxMaskingAddr() *float32

+ func (avctx *AVCodecContext) GetStatsIn() string

+ func (avctx *AVCodecContext) GetStatsOut() string

+ func (avctx *AVCodecContext) GetStrictStdCompliance() int32

+ func (avctx *AVCodecContext) GetStrictStdComplianceAddr() *int32

+ func (avctx *AVCodecContext) GetSubCharenc() string

+ func (avctx *AVCodecContext) GetSubCharencMode() int32

+ func (avctx *AVCodecContext) GetSubCharencModeAddr() *int32

+ func (avctx *AVCodecContext) GetSubTextFormat() int32

+ func (avctx *AVCodecContext) GetSubTextFormatAddr() *int32

+ func (avctx *AVCodecContext) GetSubtitleHeader() *uint8

+ func (avctx *AVCodecContext) GetSubtitleHeaderAddr() **uint8

+ func (avctx *AVCodecContext) GetSubtitleHeaderSize() int32

+ func (avctx *AVCodecContext) GetSubtitleHeaderSizeAddr() *int32

+ func (avctx *AVCodecContext) GetSwPixFmt() AVPixelFormat

+ func (avctx *AVCodecContext) GetSwPixFmtAddr() *AVPixelFormat

+ func (avctx *AVCodecContext) GetTemporalCplxMasking() float32

+ func (avctx *AVCodecContext) GetTemporalCplxMaskingAddr() *float32

+ func (avctx *AVCodecContext) GetThreadCount() int32

+ func (avctx *AVCodecContext) GetThreadCountAddr() *int32

+ func (avctx *AVCodecContext) GetThreadSafeCallbacks() int32

+ func (avctx *AVCodecContext) GetThreadSafeCallbacksAddr() *int32

+ func (avctx *AVCodecContext) GetThreadType() int32

+ func (avctx *AVCodecContext) GetThreadTypeAddr() *int32

+ func (avctx *AVCodecContext) GetTicksPerFrame() int32

+ func (avctx *AVCodecContext) GetTicksPerFrameAddr() *int32

+ func (avctx *AVCodecContext) GetTimeBase() AVRational

+ func (avctx *AVCodecContext) GetTimeBaseAddr() *AVRational

+ func (avctx *AVCodecContext) GetTimecodeFrameStart() int64

+ func (avctx *AVCodecContext) GetTimecodeFrameStartAddr() *int64

+ func (avctx *AVCodecContext) GetTrailingPadding() int32

+ func (avctx *AVCodecContext) GetTrailingPaddingAddr() *int32

+ func (avctx *AVCodecContext) GetTrellis() int32

+ func (avctx *AVCodecContext) GetTrellisAddr() *int32

+ func (avctx *AVCodecContext) GetVbvDelay() uint64

+ func (avctx *AVCodecContext) GetVbvDelayAddr() *uint64

+ func (avctx *AVCodecContext) GetWidth() int32

+ func (avctx *AVCodecContext) GetWidthAddr() *int32

+ func (avctx *AVCodecContext) GetWorkaroundBugs() int32

+ func (avctx *AVCodecContext) GetWorkaroundBugsAddr() *int32

+ func (avctx *AVCodecContext) SetActiveThreadType(v int32)

+ func (avctx *AVCodecContext) SetApplyCropping(v int32)

+ func (avctx *AVCodecContext) SetAudioServiceType(v AVAudioServiceType)

+ func (avctx *AVCodecContext) SetAvClass(v *AVClass)

+ func (avctx *AVCodecContext) SetBFrameStrategy(v int32)

+ func (avctx *AVCodecContext) SetBQuantFactor(v float32)

+ func (avctx *AVCodecContext) SetBQuantOffset(v float32)

+ func (avctx *AVCodecContext) SetBSensitivity(v int32)

+ func (avctx *AVCodecContext) SetBidirRefine(v int32)

+ func (avctx *AVCodecContext) SetBitRate(v int64)

+ func (avctx *AVCodecContext) SetBitRateTolerance(v int32)

+ func (avctx *AVCodecContext) SetBitsPerCodedSample(v int32)

+ func (avctx *AVCodecContext) SetBitsPerRawSample(v int32)

+ func (avctx *AVCodecContext) SetBlockAlign(v int32)

+ func (avctx *AVCodecContext) SetBrdScale(v int32)

+ func (avctx *AVCodecContext) SetChannelLayout(v uint64)

+ func (avctx *AVCodecContext) SetChannels(v int32)

+ func (avctx *AVCodecContext) SetChromaIntraMatrix(v *uint16)

+ func (avctx *AVCodecContext) SetChromaSampleLocation(v AVChromaLocation)

+ func (avctx *AVCodecContext) SetChromaoffset(v int32)

+ func (avctx *AVCodecContext) SetCodec(v *AVCodec)

+ func (avctx *AVCodecContext) SetCodecDescriptor(v *AVCodecDescriptor)

+ func (avctx *AVCodecContext) SetCodecId(v AVCodecID)

+ func (avctx *AVCodecContext) SetCodecTag(v uint32)

+ func (avctx *AVCodecContext) SetCodecType(v AVMediaType)

+ func (avctx *AVCodecContext) SetCodedFrame(v *AVFrame)

+ func (avctx *AVCodecContext) SetCodedHeight(v int32)

+ func (avctx *AVCodecContext) SetCodedSideData(v *AVPacketSideData)

+ func (avctx *AVCodecContext) SetCodedWidth(v int32)

+ func (avctx *AVCodecContext) SetCoderType(v int32)

+ func (avctx *AVCodecContext) SetColorPrimaries(v AVColorPrimaries)

+ func (avctx *AVCodecContext) SetColorRange(v AVColorRange)

+ func (avctx *AVCodecContext) SetColorTrc(v AVColorTransferCharacteristic)

+ func (avctx *AVCodecContext) SetColorspace(v AVColorSpace)

+ func (avctx *AVCodecContext) SetCompressionLevel(v int32)

+ func (avctx *AVCodecContext) SetContextModel(v int32)

+ func (avctx *AVCodecContext) SetCutoff(v int32)

+ func (avctx *AVCodecContext) SetDarkMasking(v float32)

+ func (avctx *AVCodecContext) SetDctAlgo(v int32)

+ func (avctx *AVCodecContext) SetDebug(v int32)

+ func (avctx *AVCodecContext) SetDebugMv(v int32)

+ func (avctx *AVCodecContext) SetDelay(v int32)

+ func (avctx *AVCodecContext) SetDiaSize(v int32)

+ func (avctx *AVCodecContext) SetDrawHorizBand(v AVCodecContextDrawHorizBandFunc)

+ func (avctx *AVCodecContext) SetDumpSeparator(v *uint8)

+ func (avctx *AVCodecContext) SetErrRecognition(v int32)

+ func (avctx *AVCodecContext) SetError(v []uint64)

+ func (avctx *AVCodecContext) SetErrorConcealment(v int32)

+ func (avctx *AVCodecContext) SetExecute(v AvCodecContextInternalExecuteFunc)

+ func (avctx *AVCodecContext) SetExecute2(v AvCodecContextInternalExecute2Func)

+ func (avctx *AVCodecContext) SetExtraHwFrames(v int32)

+ func (avctx *AVCodecContext) SetExtradata(v *uint8)

+ func (avctx *AVCodecContext) SetExtradataSize(v int32)

+ func (avctx *AVCodecContext) SetFieldOrder(v AVFieldOrder)

+ func (avctx *AVCodecContext) SetFlags(v int32)

+ func (avctx *AVCodecContext) SetFlags2(v int32)

+ func (avctx *AVCodecContext) SetFrameBits(v int32)

+ func (avctx *AVCodecContext) SetFrameNumber(v int32)

+ func (avctx *AVCodecContext) SetFrameSize(v int32)

+ func (avctx *AVCodecContext) SetFrameSkipCmp(v int32)

+ func (avctx *AVCodecContext) SetFrameSkipExp(v int32)

+ func (avctx *AVCodecContext) SetFrameSkipFactor(v int32)

+ func (avctx *AVCodecContext) SetFrameSkipThreshold(v int32)

+ func (avctx *AVCodecContext) SetFramerate(v AVRational)

+ func (avctx *AVCodecContext) SetGetBuffer2(v AVCodecContextGetBuffer2Func)

+ func (avctx *AVCodecContext) SetGetFormat(v AVCodecContextGetFormatFunc)

+ func (avctx *AVCodecContext) SetGlobalQuality(v int32)

+ func (avctx *AVCodecContext) SetGopSize(v int32)

+ func (avctx *AVCodecContext) SetHasBFrames(v int32)

+ func (avctx *AVCodecContext) SetHeaderBits(v int32)

+ func (avctx *AVCodecContext) SetHeight(v int32)

+ func (avctx *AVCodecContext) SetHwDeviceCtx(v *AVBufferRef)

+ func (avctx *AVCodecContext) SetHwFramesCtx(v *AVBufferRef)

+ func (avctx *AVCodecContext) SetHwaccel(v *AVHWAccel)

+ func (avctx *AVCodecContext) SetHwaccelContext(v CVoidPointer)

+ func (avctx *AVCodecContext) SetHwaccelFlags(v int32)

+ func (avctx *AVCodecContext) SetICount(v int32)

+ func (avctx *AVCodecContext) SetIQuantFactor(v float32)

+ func (avctx *AVCodecContext) SetIQuantOffset(v float32)

+ func (avctx *AVCodecContext) SetITexBits(v int32)

+ func (avctx *AVCodecContext) SetIdctAlgo(v int32)

+ func (avctx *AVCodecContext) SetIldctCmp(v int32)

+ func (avctx *AVCodecContext) SetInitialPadding(v int32)

+ func (avctx *AVCodecContext) SetInterMatrix(v *uint16)

+ func (avctx *AVCodecContext) SetIntraDcPrecision(v int32)

+ func (avctx *AVCodecContext) SetIntraMatrix(v *uint16)

+ func (avctx *AVCodecContext) SetKeyintMin(v int32)

+ func (avctx *AVCodecContext) SetLastPredictorCount(v int32)

+ func (avctx *AVCodecContext) SetLevel(v int32)

+ func (avctx *AVCodecContext) SetLogLevelOffset(v int32)

+ func (avctx *AVCodecContext) SetLowres(v int32)

+ func (avctx *AVCodecContext) SetLumiMasking(v float32)

+ func (avctx *AVCodecContext) SetMaxBFrames(v int32)

+ func (avctx *AVCodecContext) SetMaxPixels(v int64)

+ func (avctx *AVCodecContext) SetMaxPredictionOrder(v int32)

+ func (avctx *AVCodecContext) SetMaxQdiff(v int32)

+ func (avctx *AVCodecContext) SetMbCmp(v int32)

+ func (avctx *AVCodecContext) SetMbDecision(v int32)

+ func (avctx *AVCodecContext) SetMbLmax(v int32)

+ func (avctx *AVCodecContext) SetMbLmin(v int32)

+ func (avctx *AVCodecContext) SetMeCmp(v int32)

+ func (avctx *AVCodecContext) SetMePenaltyCompensation(v int32)

+ func (avctx *AVCodecContext) SetMePreCmp(v int32)

+ func (avctx *AVCodecContext) SetMeSubCmp(v int32)

+ func (avctx *AVCodecContext) SetMeSubpelQuality(v int32)

+ func (avctx *AVCodecContext) SetMinPredictionOrder(v int32)

+ func (avctx *AVCodecContext) SetMiscBits(v int32)

+ func (avctx *AVCodecContext) SetMpegQuant(v int32)

+ func (avctx *AVCodecContext) SetMv0Threshold(v int32)

+ func (avctx *AVCodecContext) SetMvBits(v int32)

+ func (avctx *AVCodecContext) SetNbCodedSideData(v int32)

+ func (avctx *AVCodecContext) SetNoiseReduction(v int32)

+ func (avctx *AVCodecContext) SetNsseWeight(v int32)

+ func (avctx *AVCodecContext) SetOpaque(v CVoidPointer)

+ func (avctx *AVCodecContext) SetPCount(v int32)

+ func (avctx *AVCodecContext) SetPMasking(v float32)

+ func (avctx *AVCodecContext) SetPTexBits(v int32)

+ func (avctx *AVCodecContext) SetPixFmt(v AVPixelFormat)

+ func (avctx *AVCodecContext) SetPktTimebase(v AVRational)

+ func (avctx *AVCodecContext) SetPreDiaSize(v int32)

+ func (avctx *AVCodecContext) SetPreMe(v int32)

+ func (avctx *AVCodecContext) SetPredictionMethod(v int32)

+ func (avctx *AVCodecContext) SetPrivData(v CVoidPointer)

+ func (avctx *AVCodecContext) SetProfile(v int32)

+ func (avctx *AVCodecContext) SetProperties(v uint32)

+ func (avctx *AVCodecContext) SetPtsCorrectionLastDts(v int64)

+ func (avctx *AVCodecContext) SetPtsCorrectionLastPts(v int64)

+ func (avctx *AVCodecContext) SetPtsCorrectionNumFaultyDts(v int64)

+ func (avctx *AVCodecContext) SetPtsCorrectionNumFaultyPts(v int64)

+ func (avctx *AVCodecContext) SetQblur(v float32)

+ func (avctx *AVCodecContext) SetQcompress(v float32)

+ func (avctx *AVCodecContext) SetQmax(v int32)

+ func (avctx *AVCodecContext) SetQmin(v int32)

+ func (avctx *AVCodecContext) SetRcBufferSize(v int32)

+ func (avctx *AVCodecContext) SetRcInitialBufferOccupancy(v int32)

+ func (avctx *AVCodecContext) SetRcMaxAvailableVbvUse(v float32)

+ func (avctx *AVCodecContext) SetRcMaxRate(v int64)

+ func (avctx *AVCodecContext) SetRcMinRate(v int64)

+ func (avctx *AVCodecContext) SetRcMinVbvOverflowUse(v float32)

+ func (avctx *AVCodecContext) SetRcOverride(v *RcOverride)

+ func (avctx *AVCodecContext) SetRcOverrideCount(v int32)

+ func (avctx *AVCodecContext) SetRefcountedFrames(v int32)

+ func (avctx *AVCodecContext) SetRefs(v int32)

+ func (avctx *AVCodecContext) SetReorderedOpaque(v int64)

+ func (avctx *AVCodecContext) SetRequestChannelLayout(v uint64)

+ func (avctx *AVCodecContext) SetRequestSampleFmt(v AVSampleFormat)

+ func (avctx *AVCodecContext) SetRtpCallback(v AvCodecContextRtpCallbackFunc)

+ func (avctx *AVCodecContext) SetRtpPayloadSize(v int32)

+ func (avctx *AVCodecContext) SetSampleAspectRatio(v AVRational)

+ func (avctx *AVCodecContext) SetSampleFmt(v AVSampleFormat)

+ func (avctx *AVCodecContext) SetSampleRate(v int32)

+ func (avctx *AVCodecContext) SetScenechangeThreshold(v int32)

+ func (avctx *AVCodecContext) SetSeekPreroll(v int32)

+ func (avctx *AVCodecContext) SetSideDataOnlyPackets(v int32)

+ func (avctx *AVCodecContext) SetSkipAlpha(v int32)

+ func (avctx *AVCodecContext) SetSkipBottom(v int32)

+ func (avctx *AVCodecContext) SetSkipCount(v int32)

+ func (avctx *AVCodecContext) SetSkipFrame(v AVDiscard)

+ func (avctx *AVCodecContext) SetSkipIdct(v AVDiscard)

+ func (avctx *AVCodecContext) SetSkipLoopFilter(v AVDiscard)

+ func (avctx *AVCodecContext) SetSkipTop(v int32)

+ func (avctx *AVCodecContext) SetSliceCount(v int32)

+ func (avctx *AVCodecContext) SetSliceFlags(v int32)

+ func (avctx *AVCodecContext) SetSliceOffset(v *int32)

+ func (avctx *AVCodecContext) SetSlices(v int32)

+ func (avctx *AVCodecContext) SetSpatialCplxMasking(v float32)

+ func (avctx *AVCodecContext) SetStrictStdCompliance(v int32)

+ func (avctx *AVCodecContext) SetSubCharencMode(v int32)

+ func (avctx *AVCodecContext) SetSubTextFormat(v int32)

+ func (avctx *AVCodecContext) SetSubtitleHeader(v *uint8)

+ func (avctx *AVCodecContext) SetSubtitleHeaderSize(v int32)

+ func (avctx *AVCodecContext) SetSwPixFmt(v AVPixelFormat)

+ func (avctx *AVCodecContext) SetTemporalCplxMasking(v float32)

+ func (avctx *AVCodecContext) SetThreadCount(v int32)

+ func (avctx *AVCodecContext) SetThreadSafeCallbacks(v int32)

+ func (avctx *AVCodecContext) SetThreadType(v int32)

+ func (avctx *AVCodecContext) SetTicksPerFrame(v int32)

+ func (avctx *AVCodecContext) SetTimeBase(v AVRational)

+ func (avctx *AVCodecContext) SetTimecodeFrameStart(v int64)

+ func (avctx *AVCodecContext) SetTrailingPadding(v int32)

+ func (avctx *AVCodecContext) SetTrellis(v int32)

+ func (avctx *AVCodecContext) SetVbvDelay(v uint64)

+ func (avctx *AVCodecContext) SetWidth(v int32)

+ func (avctx *AVCodecContext) SetWorkaroundBugs(v int32)

+ type AVCodecContextDrawHorizBandFunc = C.avcodec_context_draw_horiz_band_func

+ type AVCodecContextExecute2Func = C.avcodec_context_execute2_func

+ type AVCodecContextExecuteFunc = C.avcodec_context_execute_func

+ type AVCodecContextGetBuffer2Func = C.avcodec_context_get_buffer2_func

+ type AVCodecContextGetFormatFunc = C.avcodec_context_get_format_func

+ type AVCodecDescriptor C.struct_AVCodecDescriptor

+ func AvCodecDescriptorGet(id AVCodecID) *AVCodecDescriptor

+ func AvCodecDescriptorGetByName(name string) *AVCodecDescriptor

+ func AvCodecDescriptorNext(prev *AVCodecDescriptor) *AVCodecDescriptor

+ func AvCodecGetCodecDescriptor(avctx *AVCodecContext) *AVCodecDescriptor

+ func (hwc *AVCodecDescriptor) GetId() AVCodecID

+ func (hwc *AVCodecDescriptor) GetLongName() string

+ func (hwc *AVCodecDescriptor) GetMimeTypes() (v []string)

+ func (hwc *AVCodecDescriptor) GetName() string

+ func (hwc *AVCodecDescriptor) GetProfiles() []AVProfile

+ func (hwc *AVCodecDescriptor) GetProps() int32

+ func (hwc *AVCodecDescriptor) GetType() AVMediaType

+ type AVCodecHWConfig C.struct_AVCodecHWConfig

+ func AvCodecGetHwConfig(codec *AVCodec, index T) *AVCodecHWConfig

+ func (hwc *AVCodecHWConfig) GetDeviceType() AVHWDeviceType

+ func (hwc *AVCodecHWConfig) GetDeviceTypeAddr() *AVHWDeviceType

+ func (hwc *AVCodecHWConfig) GetMethods() int32

+ func (hwc *AVCodecHWConfig) GetMethodsAddr() *int32

+ func (hwc *AVCodecHWConfig) GetPixFmt() AVPixelFormat

+ func (hwc *AVCodecHWConfig) GetPixFmtAddr() *AVPixelFormat

+ func (hwc *AVCodecHWConfig) SetDeviceType(v AVHWDeviceType)

+ func (hwc *AVCodecHWConfig) SetMethods(v int32)

+ func (hwc *AVCodecHWConfig) SetPixFmt(v AVPixelFormat)

+ type AVCodecID = C.enum_AVCodecID

+ func AvCodecGetId(tags **AVCodecTag, tag uint32) AVCodecID

+ func AvGetPcmCodec(fmt AVSampleFormat, be int32) AVCodecID

+ func AvGuessCodec(fmt *AVOutputFormat, shortName, filename, mimeType string, _type AVMediaType) AVCodecID

+ type AVCodecParameters C.struct_AVCodecParameters

+ func AvCodecParametersAlloc() *AVCodecParameters

+ func (par *AVCodecParameters) GetBitRate() int64

+ func (par *AVCodecParameters) GetBitRateAddr() *int64

+ func (par *AVCodecParameters) GetBitsPerCodedSample() int32

+ func (par *AVCodecParameters) GetBitsPerCodedSampleAddr() *int32

+ func (par *AVCodecParameters) GetBitsPerRawSample() int32

+ func (par *AVCodecParameters) GetBitsPerRawSampleAddr() *int32

+ func (par *AVCodecParameters) GetBlockAlign() int32

+ func (par *AVCodecParameters) GetBlockAlignAddr() *int32

+ func (par *AVCodecParameters) GetChannelLayout() uint64

+ func (par *AVCodecParameters) GetChannelLayoutAddr() *uint64

+ func (par *AVCodecParameters) GetChannels() int32

+ func (par *AVCodecParameters) GetChannelsAddr() *int32

+ func (par *AVCodecParameters) GetChromaLocation() AVChromaLocation

+ func (par *AVCodecParameters) GetChromaLocationAddr() *AVChromaLocation

+ func (par *AVCodecParameters) GetCodecId() AVCodecID

+ func (par *AVCodecParameters) GetCodecIdAddr() *AVCodecID

+ func (par *AVCodecParameters) GetCodecTag() uint32

+ func (par *AVCodecParameters) GetCodecTagAddr() *uint32

+ func (par *AVCodecParameters) GetCodecType() AVMediaType

+ func (par *AVCodecParameters) GetCodecTypeAddr() *AVMediaType

+ func (par *AVCodecParameters) GetColorPrimaries() AVColorPrimaries

+ func (par *AVCodecParameters) GetColorPrimariesAddr() *AVColorPrimaries

+ func (par *AVCodecParameters) GetColorRange() AVColorRange

+ func (par *AVCodecParameters) GetColorRangeAddr() *AVColorRange

+ func (par *AVCodecParameters) GetColorSpace() AVColorSpace

+ func (par *AVCodecParameters) GetColorSpaceAddr() *AVColorSpace

+ func (par *AVCodecParameters) GetColorTrc() AVColorTransferCharacteristic

+ func (par *AVCodecParameters) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (par *AVCodecParameters) GetExtradata() *uint8

+ func (par *AVCodecParameters) GetExtradataAddr() *uint8

+ func (par *AVCodecParameters) GetExtradataSize() int32

+ func (par *AVCodecParameters) GetExtradataSizeAddr() *int32

+ func (par *AVCodecParameters) GetFieldOrder() AVFieldOrder

+ func (par *AVCodecParameters) GetFieldOrderAddr() *AVFieldOrder

+ func (par *AVCodecParameters) GetFormat() int32

+ func (par *AVCodecParameters) GetFormatAddr() *int32

+ func (par *AVCodecParameters) GetFrameSize() int32

+ func (par *AVCodecParameters) GetFrameSizeAddr() *int32

+ func (par *AVCodecParameters) GetHeight() int32

+ func (par *AVCodecParameters) GetHeightAddr() *int32

+ func (par *AVCodecParameters) GetInitialPadding() int32

+ func (par *AVCodecParameters) GetInitialPaddingAddr() *int32

+ func (par *AVCodecParameters) GetLevel() int32

+ func (par *AVCodecParameters) GetLevelAddr() *int32

+ func (par *AVCodecParameters) GetProfile() int32

+ func (par *AVCodecParameters) GetProfileAddr() *int32

+ func (par *AVCodecParameters) GetSampleAspectRatio() AVRational

+ func (par *AVCodecParameters) GetSampleAspectRatioAddr() *AVRational

+ func (par *AVCodecParameters) GetSampleRate() int32

+ func (par *AVCodecParameters) GetSampleRateAddr() *int32

+ func (par *AVCodecParameters) GetSeekPreroll() int32

+ func (par *AVCodecParameters) GetSeekPrerollAddr() *int32

+ func (par *AVCodecParameters) GetTrailingPadding() int32

+ func (par *AVCodecParameters) GetTrailingPaddingAddr() *int32

+ func (par *AVCodecParameters) GetVideoDelay() int32

+ func (par *AVCodecParameters) GetVideoDelayAddr() *int32

+ func (par *AVCodecParameters) GetWidth() int32

+ func (par *AVCodecParameters) GetWidthAddr() *int32

+ func (par *AVCodecParameters) SetBitRate(v int64)

+ func (par *AVCodecParameters) SetBitsPerCodedSample(v int32)

+ func (par *AVCodecParameters) SetBitsPerRawSample(v int32)

+ func (par *AVCodecParameters) SetBlockAlign(v int32)

+ func (par *AVCodecParameters) SetChannelLayout(v uint64)

+ func (par *AVCodecParameters) SetChannels(v int32)

+ func (par *AVCodecParameters) SetChromaLocation(v AVChromaLocation)

+ func (par *AVCodecParameters) SetCodecId(v AVCodecID)

+ func (par *AVCodecParameters) SetCodecTag(v uint32)

+ func (par *AVCodecParameters) SetCodecType(v AVMediaType)

+ func (par *AVCodecParameters) SetColorPrimaries(v AVColorPrimaries)

+ func (par *AVCodecParameters) SetColorRange(v AVColorRange)

+ func (par *AVCodecParameters) SetColorSpace(v AVColorSpace)

+ func (par *AVCodecParameters) SetColorTrc(v AVColorTransferCharacteristic)

+ func (par *AVCodecParameters) SetExtradata(v *uint8)

+ func (par *AVCodecParameters) SetExtradataSize(v int32)

+ func (par *AVCodecParameters) SetFieldOrder(v AVFieldOrder)

+ func (par *AVCodecParameters) SetFormat(v int32)

+ func (par *AVCodecParameters) SetFrameSize(v int32)

+ func (par *AVCodecParameters) SetHeight(v int32)

+ func (par *AVCodecParameters) SetInitialPadding(v int32)

+ func (par *AVCodecParameters) SetLevel(v int32)

+ func (par *AVCodecParameters) SetProfile(v int32)

+ func (par *AVCodecParameters) SetSampleAspectRatio(v AVRational)

+ func (par *AVCodecParameters) SetSampleRate(v int32)

+ func (par *AVCodecParameters) SetSeekPreroll(v int32)

+ func (par *AVCodecParameters) SetTrailingPadding(v int32)

+ func (par *AVCodecParameters) SetVideoDelay(v int32)

+ func (par *AVCodecParameters) SetWidth(v int32)

+ type AVCodecParser C.struct_AVCodecParser

+ func AvParserIterate(p CVoidPointerPointer) *AVCodecParser

+ func AvParserNext(c *AVCodecParser) *AVCodecParser

+ func (cp *AVCodecParser) GetCodecIds() []int32

+ func (cp *AVCodecParser) GetCodecIdsAddr() *int32

+ func (cp *AVCodecParser) GetNext() *AVCodecParser

+ func (cp *AVCodecParser) GetNextAddr() **AVCodecParser

+ func (cp *AVCodecParser) GetParserClose() AvcodecParserCloseFunc

+ func (cp *AVCodecParser) GetParserCloseAddr() *AvcodecParserCloseFunc

+ func (cp *AVCodecParser) GetParserInit() AvcodecParserInitFunc

+ func (cp *AVCodecParser) GetParserInitAddr() *AvcodecParserInitFunc

+ func (cp *AVCodecParser) GetParserParse() AvcodecParserParseFunc

+ func (cp *AVCodecParser) GetParserParseAddr() *AvcodecParserParseFunc

+ func (cp *AVCodecParser) GetPrivDataSize() int32

+ func (cp *AVCodecParser) GetPrivDataSizeAddr() *int32

+ func (cp *AVCodecParser) GetSplit() AvcodecParserSplitFunc

+ func (cp *AVCodecParser) GetSplitAddr() *AvcodecParserSplitFunc

+ func (cp *AVCodecParser) SetCodecIds(v []int32)

+ func (cp *AVCodecParser) SetNext(v *AVCodecParser)

+ func (cp *AVCodecParser) SetParserClose(v AvcodecParserCloseFunc)

+ func (cp *AVCodecParser) SetParserInit(v AvcodecParserInitFunc)

+ func (cp *AVCodecParser) SetParserParse(v AvcodecParserParseFunc)

+ func (cp *AVCodecParser) SetPrivDataSize(v int32)

+ func (cp *AVCodecParser) SetSplit(v AvcodecParserSplitFunc)

+ type AVCodecParserContext C.struct_AVCodecParserContext

+ func AvParserInit(codecID AVCodecID) *AVCodecParserContext

+ func AvStreamGetParser(s *AVStream) *AVCodecParserContext

+ func (cpc *AVCodecParserContext) GetCodedHeight() int32

+ func (cpc *AVCodecParserContext) GetCodedHeightAddr() *int32

+ func (cpc *AVCodecParserContext) GetCodedWidth() int32

+ func (cpc *AVCodecParserContext) GetCodedWidthAddr() *int32

+ func (cpc *AVCodecParserContext) GetConvergenceDuration() int64

+ func (cpc *AVCodecParserContext) GetConvergenceDurationAddr() *int64

+ func (cpc *AVCodecParserContext) GetCurFrameDts() []int64

+ func (cpc *AVCodecParserContext) GetCurFrameDtsAddr() **int64

+ func (cpc *AVCodecParserContext) GetCurFrameEnd() []int64

+ func (cpc *AVCodecParserContext) GetCurFrameEndAddr() **int64

+ func (cpc *AVCodecParserContext) GetCurFrameOffset() []int64

+ func (cpc *AVCodecParserContext) GetCurFrameOffsetAddr() **int64

+ func (cpc *AVCodecParserContext) GetCurFramePos() []int64

+ func (cpc *AVCodecParserContext) GetCurFramePosAddr() **int64

+ func (cpc *AVCodecParserContext) GetCurFramePts() []int64

+ func (cpc *AVCodecParserContext) GetCurFramePtsAddr() **int64

+ func (cpc *AVCodecParserContext) GetCurFrameStartIndex() int32

+ func (cpc *AVCodecParserContext) GetCurFrameStartIndexAddr() *int32

+ func (cpc *AVCodecParserContext) GetCurOffset() int64

+ func (cpc *AVCodecParserContext) GetCurOffsetAddr() *int64

+ func (cpc *AVCodecParserContext) GetDts() int64

+ func (cpc *AVCodecParserContext) GetDtsAddr() *int64

+ func (cpc *AVCodecParserContext) GetDtsRefDtsDelta() int32

+ func (cpc *AVCodecParserContext) GetDtsRefDtsDeltaAddr() *int32

+ func (cpc *AVCodecParserContext) GetDtsSyncPoint() int32

+ func (cpc *AVCodecParserContext) GetDtsSyncPointAddr() *int32

+ func (cpc *AVCodecParserContext) GetDuration() int32

+ func (cpc *AVCodecParserContext) GetDurationAddr() *int32

+ func (cpc *AVCodecParserContext) GetFetchTimestamp() int32

+ func (cpc *AVCodecParserContext) GetFetchTimestampAddr() *int32

+ func (cpc *AVCodecParserContext) GetFieldOrder() AVFieldOrder

+ func (cpc *AVCodecParserContext) GetFieldOrderAddr() *AVFieldOrder

+ func (cpc *AVCodecParserContext) GetFormat() int32

+ func (cpc *AVCodecParserContext) GetFormatAddr() *int32

+ func (cpc *AVCodecParserContext) GetFrameOffset() int64

+ func (cpc *AVCodecParserContext) GetFrameOffsetAddr() *int64

+ func (cpc *AVCodecParserContext) GetHeight() int32

+ func (cpc *AVCodecParserContext) GetHeightAddr() *int32

+ func (cpc *AVCodecParserContext) GetKeyFrame() int32

+ func (cpc *AVCodecParserContext) GetKeyFrameAddr() *int32

+ func (cpc *AVCodecParserContext) GetLastDts() int64

+ func (cpc *AVCodecParserContext) GetLastDtsAddr() *int64

+ func (cpc *AVCodecParserContext) GetLastPos() int64

+ func (cpc *AVCodecParserContext) GetLastPosAddr() *int64

+ func (cpc *AVCodecParserContext) GetLastPts() int64

+ func (cpc *AVCodecParserContext) GetLastPtsAddr() *int64

+ func (cpc *AVCodecParserContext) GetNextFrameOffset() int64

+ func (cpc *AVCodecParserContext) GetNextFrameOffsetAddr() *int64

+ func (cpc *AVCodecParserContext) GetOffset() int64

+ func (cpc *AVCodecParserContext) GetOffsetAddr() *int64

+ func (cpc *AVCodecParserContext) GetOutputPictureNumber() int32

+ func (cpc *AVCodecParserContext) GetOutputPictureNumberAddr() *int32

+ func (cpc *AVCodecParserContext) GetParser() *AVCodecParser

+ func (cpc *AVCodecParserContext) GetParserAddr() **AVCodecParser

+ func (cpc *AVCodecParserContext) GetPictType() int32

+ func (cpc *AVCodecParserContext) GetPictTypeAddr() *int32

+ func (cpc *AVCodecParserContext) GetPictureStructure() AVPictureStructure

+ func (cpc *AVCodecParserContext) GetPictureStructureAddr() *AVPictureStructure

+ func (cpc *AVCodecParserContext) GetPos() int64

+ func (cpc *AVCodecParserContext) GetPosAddr() *int64

+ func (cpc *AVCodecParserContext) GetPrivData() unsafe.Pointer

+ func (cpc *AVCodecParserContext) GetPrivDataAddr() *unsafe.Pointer

+ func (cpc *AVCodecParserContext) GetPts() int64

+ func (cpc *AVCodecParserContext) GetPtsAddr() *int64

+ func (cpc *AVCodecParserContext) GetPtsDtsDelta() int32

+ func (cpc *AVCodecParserContext) GetPtsDtsDeltaAddr() *int32

+ func (cpc *AVCodecParserContext) GetWidth() int32

+ func (cpc *AVCodecParserContext) GetWidthAddr() *int32

+ func (cpc *AVCodecParserContext) SetCodedHeight(v int32)

+ func (cpc *AVCodecParserContext) SetCodedWidth(v int32)

+ func (cpc *AVCodecParserContext) SetConvergenceDuration(v int64)

+ func (cpc *AVCodecParserContext) SetCurFrameDts(v []int64)

+ func (cpc *AVCodecParserContext) SetCurFrameEnd(v []int64)

+ func (cpc *AVCodecParserContext) SetCurFrameOffset(v []int64)

+ func (cpc *AVCodecParserContext) SetCurFramePos(v []int64)

+ func (cpc *AVCodecParserContext) SetCurFramePts(v []int64)

+ func (cpc *AVCodecParserContext) SetCurFrameStartIndex(v int32)

+ func (cpc *AVCodecParserContext) SetCurOffset(v int64)

+ func (cpc *AVCodecParserContext) SetDts(v int64)

+ func (cpc *AVCodecParserContext) SetDtsRefDtsDelta(v int32)

+ func (cpc *AVCodecParserContext) SetDtsSyncPoint(v int32)

+ func (cpc *AVCodecParserContext) SetDuration(v int32)

+ func (cpc *AVCodecParserContext) SetFetchTimestamp(v int32)

+ func (cpc *AVCodecParserContext) SetFieldOrder(v AVFieldOrder)

+ func (cpc *AVCodecParserContext) SetFormat(v int32)

+ func (cpc *AVCodecParserContext) SetFrameOffset(v int64)

+ func (cpc *AVCodecParserContext) SetHeight(v int32)

+ func (cpc *AVCodecParserContext) SetKeyFrame(v int32)

+ func (cpc *AVCodecParserContext) SetLastDts(v int64)

+ func (cpc *AVCodecParserContext) SetLastPos(v int64)

+ func (cpc *AVCodecParserContext) SetLastPts(v int64)

+ func (cpc *AVCodecParserContext) SetNextFrameOffset(v int64)

+ func (cpc *AVCodecParserContext) SetOffset(v int64)

+ func (cpc *AVCodecParserContext) SetOutputPictureNumber(v int32)

+ func (cpc *AVCodecParserContext) SetParser(v *AVCodecParser)

+ func (cpc *AVCodecParserContext) SetPictType(v int32)

+ func (cpc *AVCodecParserContext) SetPictureStructure(v AVPictureStructure)

+ func (cpc *AVCodecParserContext) SetPos(v int64)

+ func (cpc *AVCodecParserContext) SetPrivData(v CVoidPointer)

+ func (cpc *AVCodecParserContext) SetPts(v int64)

+ func (cpc *AVCodecParserContext) SetPtsDtsDelta(v int32)

+ func (cpc *AVCodecParserContext) SetWidth(v int32)

+ type AVCodecTag C.struct_AVCodecTag

+ func AvFormatGetMovAudioTags() *AVCodecTag

+ func AvFormatGetMovVideoTags() *AVCodecTag

+ func AvFormatGetRiffAudioTags() *AVCodecTag

+ func AvFormatGetRiffVideoTags() *AVCodecTag

+ type AVColorPrimaries = C.enum_AVColorPrimaries

+ type AVColorRange = C.enum_AVColorRange

+ func AvFrameGetColorRange(frame *AVFrame) AVColorRange

+ type AVColorSpace = C.enum_AVColorSpace

+ func AvFrameGetColorspace(frame *AVFrame) AVColorSpace

+ type AVColorTransferCharacteristic = C.enum_AVColorTransferCharacteristic

+ type AVComponentDescriptor C.struct_AVComponentDescriptor

+ func (cd *AVComponentDescriptor) GetDepth() int32

+ func (cd *AVComponentDescriptor) GetDepthAddr() *int32

+ func (cd *AVComponentDescriptor) GetDepthMinus1() int32

+ func (cd *AVComponentDescriptor) GetDepthMinus1Addr() *int32

+ func (cd *AVComponentDescriptor) GetOffset() int32

+ func (cd *AVComponentDescriptor) GetOffsetAddr() *int32

+ func (cd *AVComponentDescriptor) GetOffsetPlus1() int32

+ func (cd *AVComponentDescriptor) GetOffsetPlus1Addr() *int32

+ func (cd *AVComponentDescriptor) GetPlane() int32

+ func (cd *AVComponentDescriptor) GetPlaneAddr() *int32

+ func (cd *AVComponentDescriptor) GetShift() int32

+ func (cd *AVComponentDescriptor) GetShiftAddr() *int32

+ func (cd *AVComponentDescriptor) GetStep() int32

+ func (cd *AVComponentDescriptor) GetStepAddr() *int32

+ func (cd *AVComponentDescriptor) GetStepMinus1() int32

+ func (cd *AVComponentDescriptor) GetStepMinus1Addr() *int32

+ func (cd *AVComponentDescriptor) SetDepth(v int32)

+ func (cd *AVComponentDescriptor) SetDepthMinus1(v int32)

+ func (cd *AVComponentDescriptor) SetOffset(v int32)

+ func (cd *AVComponentDescriptor) SetOffsetPlus1(v int32)

+ func (cd *AVComponentDescriptor) SetPlane(v int32)

+ func (cd *AVComponentDescriptor) SetShift(v int32)

+ func (cd *AVComponentDescriptor) SetStep(v int32)

+ func (cd *AVComponentDescriptor) SetStepMinus1(v int32)

+ type AVContentLightMetadata C.struct_AVContentLightMetadata

+ func AvContentLightMetadataAlloc(size *uintptr) *AVContentLightMetadata

+ func AvContentLightMetadataCreateSideData(frame *AVFrame) *AVContentLightMetadata

+ func (clm *AVContentLightMetadata) GetMaxCLL() uint32

+ func (clm *AVContentLightMetadata) GetMaxCLLAddr() *uint32

+ func (clm *AVContentLightMetadata) GetMaxFALL() uint32

+ func (clm *AVContentLightMetadata) GetMaxFALLAddr() *uint32

+ func (clm *AVContentLightMetadata) SetMaxCLL(v uint32)

+ func (clm *AVContentLightMetadata) SetMaxFALL(v uint32)

+ type AVDCT C.struct_AVDCT

+ func AvCodecDctAlloc() *AVDCT

+ func (dct *AVDCT) GetAvClass() *AVClass

+ func (dct *AVDCT) GetAvClassAddr() **AVClass

+ func (dct *AVDCT) GetBitsPerSample() int32

+ func (dct *AVDCT) GetBitsPerSampleAddr() *int32

+ func (dct *AVDCT) GetDctAlgo() int32

+ func (dct *AVDCT) GetDctAlgoAddr() *int32

+ func (dct *AVDCT) GetFdct() AVDCTFdctFunc

+ func (dct *AVDCT) GetFdctAddr() *AVDCTFdctFunc

+ func (dct *AVDCT) GetGetPixels() AVDCTGetPixelsFunc

+ func (dct *AVDCT) GetGetPixelsAddr() *AVDCTGetPixelsFunc

+ func (dct *AVDCT) GetIdct() AVDCTIdctFunc

+ func (dct *AVDCT) GetIdctAddr() *AVDCTIdctFunc

+ func (dct *AVDCT) GetIdctAlgo() int32

+ func (dct *AVDCT) GetIdctAlgoAddr() *int32

+ func (dct *AVDCT) GetIdctPermutation() []uint8

+ func (dct *AVDCT) GetIdctPermutationAddr() **uint8

+ func (dct *AVDCT) SetAvClass(v *AVClass)

+ func (dct *AVDCT) SetBitsPerSample(v int32)

+ func (dct *AVDCT) SetDctAlgo(v int32)

+ func (dct *AVDCT) SetFdct(v AVDCTFdctFunc)

+ func (dct *AVDCT) SetGetPixels(v AVDCTGetPixelsFunc)

+ func (dct *AVDCT) SetIdct(v AVDCTIdctFunc)

+ func (dct *AVDCT) SetIdctAlgo(v int32)

+ func (dct *AVDCT) SetIdctPermutation(v []uint8)

+ type AVDCTFdctFunc = C.avdct_fdct_func

+ type AVDCTGetPixelsFunc = C.avdct_get_pixels_func

+ type AVDCTIdctFunc = C.avdct_idct_func

+ type AVDES C.struct_AVDES

+ func AvDesAlloc() *AVDES

+ func (d *AVDES) GetRoundKeys() (v [][]uint64)

+ func (d *AVDES) GetRoundKeysAddr() **uint64

+ func (d *AVDES) GetTripleDes() int32

+ func (d *AVDES) GetTripleDesAddr() *int32

+ func (d *AVDES) SetRoundKeys(v [][]uint64)

+ func (d *AVDES) SetTripleDes(v int32)

+ type AVDVProfile C.struct_AVDVProfile

+ func AvDvCodecProfile(width, height int32, pixFmt AVPixelFormat) *AVDVProfile

+ func AvDvCodecProfile2(width, height int32, pixFmt AVPixelFormat, frameRate AVRational) *AVDVProfile

+ func AvDvFrameProfile(sys *AVDVProfile, frame *uint8, bufSize uint32) *AVDVProfile

+ func (dvp *AVDVProfile) GetAudioMinSamples() []int32

+ func (dvp *AVDVProfile) GetAudioMinSamplesAddr() **int32

+ func (dvp *AVDVProfile) GetAudioSamplesDist() []int32

+ func (dvp *AVDVProfile) GetAudioSamplesDistAddr() **int32

+ func (dvp *AVDVProfile) GetAudioShuffle() []uint8

+ func (dvp *AVDVProfile) GetAudioShuffleAddr() **uint8

+ func (dvp *AVDVProfile) GetAudioStride() int32

+ func (dvp *AVDVProfile) GetAudioStrideAddr() *int32

+ func (dvp *AVDVProfile) GetBlockSizes() *uint8

+ func (dvp *AVDVProfile) GetBlockSizesAddr() **uint8

+ func (dvp *AVDVProfile) GetBpm() int32

+ func (dvp *AVDVProfile) GetBpmAddr() *int32

+ func (dvp *AVDVProfile) GetDifsegSize() int32

+ func (dvp *AVDVProfile) GetDifsegSizeAddr() *int32

+ func (dvp *AVDVProfile) GetDsf() int32

+ func (dvp *AVDVProfile) GetDsfAddr() *int32

+ func (dvp *AVDVProfile) GetFrameSize() int32

+ func (dvp *AVDVProfile) GetFrameSizeAddr() *int32

+ func (dvp *AVDVProfile) GetHeight() int32

+ func (dvp *AVDVProfile) GetHeightAddr() *int32

+ func (dvp *AVDVProfile) GetLtcDivisor() int32

+ func (dvp *AVDVProfile) GetLtcDivisorAddr() *int32

+ func (dvp *AVDVProfile) GetNDifchan() int32

+ func (dvp *AVDVProfile) GetNDifchanAddr() *int32

+ func (dvp *AVDVProfile) GetPixFmt() AVPixelFormat

+ func (dvp *AVDVProfile) GetPixFmtAddr() *AVPixelFormat

+ func (dvp *AVDVProfile) GetSar() []AVRational

+ func (dvp *AVDVProfile) GetSarAddr() **AVRational

+ func (dvp *AVDVProfile) GetTimeBase() AVRational

+ func (dvp *AVDVProfile) GetTimeBaseAddr() *AVRational

+ func (dvp *AVDVProfile) GetVideoStype() int32

+ func (dvp *AVDVProfile) GetVideoStypeAddr() *int32

+ func (dvp *AVDVProfile) GetWidth() int32

+ func (dvp *AVDVProfile) GetWidthAddr() *int32

+ func (dvp *AVDVProfile) SetAudioMinSamples(v []int32)

+ func (dvp *AVDVProfile) SetAudioSamplesDist(v []int32)

+ func (dvp *AVDVProfile) SetAudioShuffle(v []uint8)

+ func (dvp *AVDVProfile) SetAudioStride(v int32)

+ func (dvp *AVDVProfile) SetBlockSizes(v *uint8)

+ func (dvp *AVDVProfile) SetBpm(v int32)

+ func (dvp *AVDVProfile) SetDifsegSize(v int32)

+ func (dvp *AVDVProfile) SetDsf(v int32)

+ func (dvp *AVDVProfile) SetFrameSize(v int32)

+ func (dvp *AVDVProfile) SetHeight(v int32)

+ func (dvp *AVDVProfile) SetLtcDivisor(v int32)

+ func (dvp *AVDVProfile) SetNDifchan(v int32)

+ func (dvp *AVDVProfile) SetPixFmt(v AVPixelFormat)

+ func (dvp *AVDVProfile) SetSar(v []AVRational)

+ func (dvp *AVDVProfile) SetTimeBase(v AVRational)

+ func (dvp *AVDVProfile) SetVideoStype(v int32)

+ func (dvp *AVDVProfile) SetWidth(v int32)

+ type AVDevToAppMessageType = C.enum_AVDevToAppMessageType

+ type AVDeviceCapabilitiesQuery C.struct_AVDeviceCapabilitiesQuery

+ func (dc *AVDeviceCapabilitiesQuery) GetAvClass() *AVClass

+ func (dc *AVDeviceCapabilitiesQuery) GetAvClassAddr() **AVClass

+ func (dc *AVDeviceCapabilitiesQuery) GetChannelLayout() int64

+ func (dc *AVDeviceCapabilitiesQuery) GetChannelLayoutAddr() *int64

+ func (dc *AVDeviceCapabilitiesQuery) GetChannels() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetChannelsAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) GetCodec() AVCodecID

+ func (dc *AVDeviceCapabilitiesQuery) GetCodecAddr() *AVCodecID

+ func (dc *AVDeviceCapabilitiesQuery) GetDeviceContext() *AVFormatContext

+ func (dc *AVDeviceCapabilitiesQuery) GetDeviceContextAddr() **AVFormatContext

+ func (dc *AVDeviceCapabilitiesQuery) GetFps() AVRational

+ func (dc *AVDeviceCapabilitiesQuery) GetFpsAddr() *AVRational

+ func (dc *AVDeviceCapabilitiesQuery) GetFrameHeight() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetFrameHeightAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) GetFrameWidth() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetFrameWidthAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) GetPixelFormat() AVPixelFormat

+ func (dc *AVDeviceCapabilitiesQuery) GetPixelFormatAddr() *AVPixelFormat

+ func (dc *AVDeviceCapabilitiesQuery) GetSampleFormat() AVSampleFormat

+ func (dc *AVDeviceCapabilitiesQuery) GetSampleFormatAddr() *AVSampleFormat

+ func (dc *AVDeviceCapabilitiesQuery) GetSampleRate() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetSampleRateAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) GetWindowHeight() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetWindowHeightAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) GetWindowWidth() int32

+ func (dc *AVDeviceCapabilitiesQuery) GetWindowWidthAddr() *int32

+ func (dc *AVDeviceCapabilitiesQuery) SetAvClass(v *AVClass)

+ func (dc *AVDeviceCapabilitiesQuery) SetChannelLayout(v int64)

+ func (dc *AVDeviceCapabilitiesQuery) SetChannels(v int32)

+ func (dc *AVDeviceCapabilitiesQuery) SetCodec(v AVCodecID)

+ func (dc *AVDeviceCapabilitiesQuery) SetDeviceContext(v *AVFormatContext)

+ func (dc *AVDeviceCapabilitiesQuery) SetFps(v AVRational)

+ func (dc *AVDeviceCapabilitiesQuery) SetFrameHeight(v int32)

+ func (dc *AVDeviceCapabilitiesQuery) SetFrameWidth(v int32)

+ func (dc *AVDeviceCapabilitiesQuery) SetPixelFormat(v AVPixelFormat)

+ func (dc *AVDeviceCapabilitiesQuery) SetSampleFormat(v AVSampleFormat)

+ func (dc *AVDeviceCapabilitiesQuery) SetSampleRate(v int32)

+ func (dc *AVDeviceCapabilitiesQuery) SetWindowHeight(v int32)

+ func (dc *AVDeviceCapabilitiesQuery) SetWindowWidth(v int32)

+ type AVDeviceInfo C.struct_AVDeviceInfo

+ func (di *AVDeviceInfo) GetDeviceDescription() string

+ func (di *AVDeviceInfo) GetDeviceName() string

+ type AVDeviceInfoList C.struct_AVDeviceInfoList

+ func (dcl *AVDeviceInfoList) GetDefaultDevice() int32

+ func (dcl *AVDeviceInfoList) GetDevices() []*AVDeviceInfo

+ func (dcl *AVDeviceInfoList) GetNbDevices() int32

+ type AVDeviceRect C.struct_AVDeviceRect

+ func (dr *AVDeviceRect) GetHeight() int32

+ func (dr *AVDeviceRect) GetHeightAddr() *int32

+ func (dr *AVDeviceRect) GetWidth() int32

+ func (dr *AVDeviceRect) GetWidthAddr() *int32

+ func (dr *AVDeviceRect) GetX() int32

+ func (dr *AVDeviceRect) GetXAddr() *int32

+ func (dr *AVDeviceRect) GetY() int32

+ func (dr *AVDeviceRect) GetYAddr() *int32

+ func (dr *AVDeviceRect) SetHeight(v int32)

+ func (dr *AVDeviceRect) SetWidth(v int32)

+ func (dr *AVDeviceRect) SetX(v int32)

+ func (dr *AVDeviceRect) SetY(v int32)

+ type AVDictionary C.struct_AVDictionary

+ func AvFrameGetMetadata(frame *AVFrame) *AVDictionary

+ type AVDictionaryEntry C.struct_AVDictionaryEntry

+ func AvDictGet(m *AVDictionary, key string, prev *AVDictionaryEntry, flags int32) *AVDictionaryEntry

+ func (e *AVDictionaryEntry) GetKey() string

+ func (e *AVDictionaryEntry) GetValue() string

+ type AVDiracSeqHeader C.struct_AVDiracSeqHeader

+ func (dsh *AVDiracSeqHeader) GetAspectRatioIndex() uint8

+ func (dsh *AVDiracSeqHeader) GetAspectRatioIndexAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetBitDepth() int32

+ func (dsh *AVDiracSeqHeader) GetBitDepthAddr() *int32

+ func (dsh *AVDiracSeqHeader) GetChromaFormat() uint8

+ func (dsh *AVDiracSeqHeader) GetChromaFormatAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetCleanHeight() uint16

+ func (dsh *AVDiracSeqHeader) GetCleanHeightAddr() *uint16

+ func (dsh *AVDiracSeqHeader) GetCleanLeftOffset() uint16

+ func (dsh *AVDiracSeqHeader) GetCleanLeftOffsetAddr() *uint16

+ func (dsh *AVDiracSeqHeader) GetCleanRightOffset() uint16

+ func (dsh *AVDiracSeqHeader) GetCleanRightOffsetAddr() *uint16

+ func (dsh *AVDiracSeqHeader) GetCleanWidth() uint16

+ func (dsh *AVDiracSeqHeader) GetCleanWidthAddr() *uint16

+ func (dsh *AVDiracSeqHeader) GetColorPrimaries() AVColorPrimaries

+ func (dsh *AVDiracSeqHeader) GetColorPrimariesAddr() *AVColorPrimaries

+ func (dsh *AVDiracSeqHeader) GetColorRange() AVColorRange

+ func (dsh *AVDiracSeqHeader) GetColorRangeAddr() *AVColorRange

+ func (dsh *AVDiracSeqHeader) GetColorSpecIndex() uint8

+ func (dsh *AVDiracSeqHeader) GetColorSpecIndexAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetColorTrc() AVColorTransferCharacteristic

+ func (dsh *AVDiracSeqHeader) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (dsh *AVDiracSeqHeader) GetColorspace() AVColorSpace

+ func (dsh *AVDiracSeqHeader) GetColorspaceAddr() *AVColorSpace

+ func (dsh *AVDiracSeqHeader) GetFrameRateIndex() uint8

+ func (dsh *AVDiracSeqHeader) GetFrameRateIndexAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetFramerate() AVRational

+ func (dsh *AVDiracSeqHeader) GetFramerateAddr() *AVRational

+ func (dsh *AVDiracSeqHeader) GetHeight() uint32

+ func (dsh *AVDiracSeqHeader) GetHeightAddr() *uint32

+ func (dsh *AVDiracSeqHeader) GetInterlaced() uint8

+ func (dsh *AVDiracSeqHeader) GetInterlacedAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetLevel() int32

+ func (dsh *AVDiracSeqHeader) GetLevelAddr() *int32

+ func (dsh *AVDiracSeqHeader) GetPixFmt() AVPixelFormat

+ func (dsh *AVDiracSeqHeader) GetPixFmtAddr() *AVPixelFormat

+ func (dsh *AVDiracSeqHeader) GetPixelRangeIndex() uint8

+ func (dsh *AVDiracSeqHeader) GetPixelRangeIndexAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetProfile() int32

+ func (dsh *AVDiracSeqHeader) GetProfileAddr() *int32

+ func (dsh *AVDiracSeqHeader) GetSampleAspectRatio() AVRational

+ func (dsh *AVDiracSeqHeader) GetSampleAspectRatioAddr() *AVRational

+ func (dsh *AVDiracSeqHeader) GetTopFieldFirst() uint8

+ func (dsh *AVDiracSeqHeader) GetTopFieldFirstAddr() *uint8

+ func (dsh *AVDiracSeqHeader) GetVersion() DiracVersionInfo

+ func (dsh *AVDiracSeqHeader) GetVersionAddr() *DiracVersionInfo

+ func (dsh *AVDiracSeqHeader) GetWidth() uint32

+ func (dsh *AVDiracSeqHeader) GetWidthAddr() *uint32

+ func (dsh *AVDiracSeqHeader) SetAspectRatioIndex(v uint8)

+ func (dsh *AVDiracSeqHeader) SetBitDepth(v int32)

+ func (dsh *AVDiracSeqHeader) SetChromaFormat(v uint8)

+ func (dsh *AVDiracSeqHeader) SetCleanHeight(v uint16)

+ func (dsh *AVDiracSeqHeader) SetCleanLeftOffset(v uint16)

+ func (dsh *AVDiracSeqHeader) SetCleanRightOffset(v uint16)

+ func (dsh *AVDiracSeqHeader) SetCleanWidth(v uint16)

+ func (dsh *AVDiracSeqHeader) SetColorPrimaries(v AVColorPrimaries)

+ func (dsh *AVDiracSeqHeader) SetColorRange(v AVColorRange)

+ func (dsh *AVDiracSeqHeader) SetColorSpecIndex(v uint8)

+ func (dsh *AVDiracSeqHeader) SetColorTrc(v AVColorTransferCharacteristic)

+ func (dsh *AVDiracSeqHeader) SetColorspace(v AVColorSpace)

+ func (dsh *AVDiracSeqHeader) SetFrameRateIndex(v uint8)

+ func (dsh *AVDiracSeqHeader) SetFramerate(v AVRational)

+ func (dsh *AVDiracSeqHeader) SetHeight(v uint32)

+ func (dsh *AVDiracSeqHeader) SetInterlaced(v uint8)

+ func (dsh *AVDiracSeqHeader) SetLevel(v int32)

+ func (dsh *AVDiracSeqHeader) SetPixFmt(v AVPixelFormat)

+ func (dsh *AVDiracSeqHeader) SetPixelRangeIndex(v uint8)

+ func (dsh *AVDiracSeqHeader) SetProfile(v int32)

+ func (dsh *AVDiracSeqHeader) SetSampleAspectRatio(v AVRational)

+ func (dsh *AVDiracSeqHeader) SetTopFieldFirst(v uint8)

+ func (dsh *AVDiracSeqHeader) SetVersion(v DiracVersionInfo)

+ func (dsh *AVDiracSeqHeader) SetWidth(v uint32)

+ type AVDiscard = C.enum_AVDiscard

+ type AVDownmixInfo C.struct_AVDownmixInfo

+ func AvDownmixInfoUpdateSideData(frame *AVFrame) *AVDownmixInfo

+ func (di *AVDownmixInfo) GetCenterMixLevel() float64

+ func (di *AVDownmixInfo) GetCenterMixLevelAddr() *float64

+ func (di *AVDownmixInfo) GetCenterMixLevelLtrt() float64

+ func (di *AVDownmixInfo) GetCenterMixLevelLtrtAddr() *float64

+ func (di *AVDownmixInfo) GetLfeMixLevel() float64

+ func (di *AVDownmixInfo) GetLfeMixLevelAddr() *float64

+ func (di *AVDownmixInfo) GetPreferredDownmixType() AVDownmixType

+ func (di *AVDownmixInfo) GetPreferredDownmixTypeAddr() *AVDownmixType

+ func (di *AVDownmixInfo) GetSurroundMixLevel() float64

+ func (di *AVDownmixInfo) GetSurroundMixLevelAddr() *float64

+ func (di *AVDownmixInfo) GetSurroundMixLevelLtrt() float64

+ func (di *AVDownmixInfo) GetSurroundMixLevelLtrtAddr() *float64

+ func (di *AVDownmixInfo) SetCenterMixLevel(v float64)

+ func (di *AVDownmixInfo) SetCenterMixLevelLtrt(v float64)

+ func (di *AVDownmixInfo) SetLfeMixLevel(v float64)

+ func (di *AVDownmixInfo) SetPreferredDownmixType(v AVDownmixType)

+ func (di *AVDownmixInfo) SetSurroundMixLevel(v float64)

+ func (di *AVDownmixInfo) SetSurroundMixLevelLtrt(v float64)

+ type AVDownmixType = C.enum_AVDownmixType

+ type AVDurationEstimationMethod = C.enum_AVDurationEstimationMethod

+ func AvFmtCtxGetDurationEstimationMethod(s *AVFormatContext) AVDurationEstimationMethod

+ type AVEncryptionInfo C.struct_AVEncryptionInfo

+ func AvEncryptionInfoAlloc(subsampleCount, keyIdSize, ivSize uint32) *AVEncryptionInfo

+ func AvEncryptionInfoClone(info *AVEncryptionInfo) *AVEncryptionInfo

+ func AvEncryptionInfoGetSideData(sideData *uint8, sideDataSize uintptr) *AVEncryptionInfo

+ func (ei *AVEncryptionInfo) GetCryptByteBlock() uint32

+ func (ei *AVEncryptionInfo) GetCryptByteBlockAddr() *uint32

+ func (ei *AVEncryptionInfo) GetIv() *uint8

+ func (ei *AVEncryptionInfo) GetIvAddr() **uint8

+ func (ei *AVEncryptionInfo) GetIvSize() uint32

+ func (ei *AVEncryptionInfo) GetIvSizeAddr() *uint32

+ func (ei *AVEncryptionInfo) GetKeyId() *uint8

+ func (ei *AVEncryptionInfo) GetKeyIdAddr() **uint8

+ func (ei *AVEncryptionInfo) GetKeyIdSize() uint32

+ func (ei *AVEncryptionInfo) GetKeyIdSizeAddr() *uint32

+ func (ei *AVEncryptionInfo) GetScheme() uint32

+ func (ei *AVEncryptionInfo) GetSchemeAddr() *uint32

+ func (ei *AVEncryptionInfo) GetSkipByteBlock() uint32

+ func (ei *AVEncryptionInfo) GetSkipByteBlockAddr() *uint32

+ func (ei *AVEncryptionInfo) GetSubsampleCount() uint32

+ func (ei *AVEncryptionInfo) GetSubsampleCountAddr() *uint32

+ func (ei *AVEncryptionInfo) GetSubsamples() *AVSubsampleEncryptionInfo

+ func (ei *AVEncryptionInfo) GetSubsamplesAddr() **AVSubsampleEncryptionInfo

+ func (ei *AVEncryptionInfo) SetCryptByteBlock(v uint32)

+ func (ei *AVEncryptionInfo) SetIv(v *uint8)

+ func (ei *AVEncryptionInfo) SetIvSize(v uint32)

+ func (ei *AVEncryptionInfo) SetKeyId(v *uint8)

+ func (ei *AVEncryptionInfo) SetKeyIdSize(v uint32)

+ func (ei *AVEncryptionInfo) SetScheme(v uint32)

+ func (ei *AVEncryptionInfo) SetSkipByteBlock(v uint32)

+ func (ei *AVEncryptionInfo) SetSubsampleCount(v uint32)

+ func (ei *AVEncryptionInfo) SetSubsamples(v *AVSubsampleEncryptionInfo)

+ type AVEncryptionInitInfo C.struct_AVEncryptionInitInfo

+ func AvEncryptionInitInfoAlloc(systemIdSize, numKeyIds, keyIdSize, dataSize uint32) *AVEncryptionInitInfo

+ func AvEncryptionInitInfoGetSideData(sideData *uint8, sideDataSize uintptr) *AVEncryptionInitInfo

+ func (eii *AVEncryptionInitInfo) GetData() *uint8

+ func (eii *AVEncryptionInitInfo) GetDataAddr() **uint8

+ func (eii *AVEncryptionInitInfo) GetDataSize() uint32

+ func (eii *AVEncryptionInitInfo) GetDataSizeAddr() *uint32

+ func (eii *AVEncryptionInitInfo) GetKeyIdSize() uint32

+ func (eii *AVEncryptionInitInfo) GetKeyIdSizeAddr() *uint32

+ func (eii *AVEncryptionInitInfo) GetKeyIds() []*uint8

+ func (eii *AVEncryptionInitInfo) GetKeyIdsAddr() ***uint8

+ func (eii *AVEncryptionInitInfo) GetNumKeyIds() uint32

+ func (eii *AVEncryptionInitInfo) GetNumKeyIdsAddr() *uint32

+ func (eii *AVEncryptionInitInfo) GetSystemId() *uint8

+ func (eii *AVEncryptionInitInfo) GetSystemIdAddr() **uint8

+ func (eii *AVEncryptionInitInfo) GetSystemIdSize() uint32

+ func (eii *AVEncryptionInitInfo) GetSystemIdSizeAddr() *uint32

+ func (eii *AVEncryptionInitInfo) SetData(v *uint8)

+ func (eii *AVEncryptionInitInfo) SetDataSize(v uint32)

+ func (eii *AVEncryptionInitInfo) SetKeyIdSize(v uint32)

+ func (eii *AVEncryptionInitInfo) SetKeyIds(v **uint8)

+ func (eii *AVEncryptionInitInfo) SetNumKeyIds(v uint32)

+ func (eii *AVEncryptionInitInfo) SetSystemId(v *uint8)

+ func (eii *AVEncryptionInitInfo) SetSystemIdSize(v uint32)

+ type AVEscapeMode = C.enum_AVEscapeMode

+ type AVExpr C.struct_AVExpr

+ type AVFieldOrder = C.enum_AVFieldOrder

+ type AVFifoBuffer C.struct_AVFifoBuffer

+ func AvFifoAlloc(size T) *AVFifoBuffer

+ func AvFifoAllocArray(nmemb U, size V) *AVFifoBuffer

+ type AVFilter C.struct_AVFilter

+ func AvFilterGetByName(name string) *AVFilter

+ func AvFilterIterate(opaque CVoidPointerPointer) *AVFilter

+ func AvFilterNext(filter *AVFilter) *AVFilter

+ func (flt *AVFilter) GetDescription() string

+ func (flt *AVFilter) GetFlags() int32

+ func (flt *AVFilter) GetFlagsAddr() *int32

+ func (flt *AVFilter) GetInputs() *AVFilterPad

+ func (flt *AVFilter) GetInputsAddr() **AVFilterPad

+ func (flt *AVFilter) GetName() string

+ func (flt *AVFilter) GetOutputs() *AVFilterPad

+ func (flt *AVFilter) GetOutputsAddr() **AVFilterPad

+ func (flt *AVFilter) GetPrivClass() *AVClass

+ func (flt *AVFilter) GetPrivClassAddr() **AVClass

+ func (flt *AVFilter) SetFlags(v int32)

+ func (flt *AVFilter) SetInputs(v *AVFilterPad)

+ func (flt *AVFilter) SetOutputs(v *AVFilterPad)

+ func (flt *AVFilter) SetPrivClass(v *AVClass)

+ type AVFilterActionFunc = C.avfilter_action_func

+ type AVFilterChannelLayouts C.struct_AVFilterChannelLayouts

+ type AVFilterCommand C.struct_AVFilterCommand

+ type AVFilterContext C.struct_AVFilterContext

+ func AvFilterGraphAllocFilter(graph *AVFilterGraph, filter *AVFilter, name string) *AVFilterContext

+ func AvFilterGraphGetFilter(graph *AVFilterGraph, name string) *AVFilterContext

+ func (fltc *AVFilterContext) GetAvClass() *AVClass

+ func (fltc *AVFilterContext) GetAvClassAddr() **AVClass

+ func (fltc *AVFilterContext) GetCommandQueue() *AVFilterCommand

+ func (fltc *AVFilterContext) GetCommandQueueAddr() **AVFilterCommand

+ func (fltc *AVFilterContext) GetEnable() unsafe.Pointer

+ func (fltc *AVFilterContext) GetEnableAddr() *unsafe.Pointer

+ func (fltc *AVFilterContext) GetEnableStr() string

+ func (fltc *AVFilterContext) GetExtraHwFrames() int32

+ func (fltc *AVFilterContext) GetExtraHwFramesAddr() *int32

+ func (fltc *AVFilterContext) GetFilter() *AVFilter

+ func (fltc *AVFilterContext) GetFilterAddr() **AVFilter

+ func (fltc *AVFilterContext) GetGraph() *AVFilterGraph

+ func (fltc *AVFilterContext) GetGraphAddr() **AVFilterGraph

+ func (fltc *AVFilterContext) GetHwDeviceCtx() *AVBufferRef

+ func (fltc *AVFilterContext) GetHwDeviceCtxAddr() **AVBufferRef

+ func (fltc *AVFilterContext) GetInputPads() *AVFilterPad

+ func (fltc *AVFilterContext) GetInputPadsAddr() **AVFilterPad

+ func (fltc *AVFilterContext) GetInputs() []*AVFilterLink

+ func (fltc *AVFilterContext) GetInputsAddr() ***AVFilterLink

+ func (fltc *AVFilterContext) GetInternal() *AVFilterInternal

+ func (fltc *AVFilterContext) GetInternalAddr() **AVFilterInternal

+ func (fltc *AVFilterContext) GetIsDisabled() int32

+ func (fltc *AVFilterContext) GetIsDisabledAddr() *int32

+ func (fltc *AVFilterContext) GetName() string

+ func (fltc *AVFilterContext) GetNbInputs() uint32

+ func (fltc *AVFilterContext) GetNbInputsAddr() *uint32

+ func (fltc *AVFilterContext) GetNbOutputs() uint32

+ func (fltc *AVFilterContext) GetNbOutputsAddr() *uint32

+ func (fltc *AVFilterContext) GetNbThreads() int32

+ func (fltc *AVFilterContext) GetNbThreadsAddr() *int32

+ func (fltc *AVFilterContext) GetOutputPads() *AVFilterPad

+ func (fltc *AVFilterContext) GetOutputPadsAddr() **AVFilterPad

+ func (fltc *AVFilterContext) GetOutputs() []*AVFilterLink

+ func (fltc *AVFilterContext) GetOutputsAddr() ***AVFilterLink

+ func (fltc *AVFilterContext) GetPriv() unsafe.Pointer

+ func (fltc *AVFilterContext) GetPrivAddr() *unsafe.Pointer

+ func (fltc *AVFilterContext) GetReady() uint32

+ func (fltc *AVFilterContext) GetReadyAddr() *uint32

+ func (fltc *AVFilterContext) GetThreadType() int32

+ func (fltc *AVFilterContext) GetThreadTypeAddr() *int32

+ func (fltc *AVFilterContext) GetVarValues() *float64

+ func (fltc *AVFilterContext) GetVarValuesAddr() **float64

+ func (fltc *AVFilterContext) SetAvClass(v *AVClass)

+ func (fltc *AVFilterContext) SetCommandQueue(v *AVFilterCommand)

+ func (fltc *AVFilterContext) SetEnable(v CVoidPointer)

+ func (fltc *AVFilterContext) SetExtraHwFrames(v int32)

+ func (fltc *AVFilterContext) SetFilter(v *AVFilter)

+ func (fltc *AVFilterContext) SetGraph(v *AVFilterGraph)

+ func (fltc *AVFilterContext) SetHwDeviceCtx(v *AVBufferRef)

+ func (fltc *AVFilterContext) SetInputPads(v *AVFilterPad)

+ func (fltc *AVFilterContext) SetInputs(v **AVFilterLink)

+ func (fltc *AVFilterContext) SetInternal(v *AVFilterInternal)

+ func (fltc *AVFilterContext) SetIsDisabled(v int32)

+ func (fltc *AVFilterContext) SetName(v string)

+ func (fltc *AVFilterContext) SetNbInputs(v uint32)

+ func (fltc *AVFilterContext) SetNbOutputs(v uint32)

+ func (fltc *AVFilterContext) SetNbThreads(v int32)

+ func (fltc *AVFilterContext) SetOutputPads(v *AVFilterPad)

+ func (fltc *AVFilterContext) SetOutputs(v **AVFilterLink)

+ func (fltc *AVFilterContext) SetPriv(v CVoidPointer)

+ func (fltc *AVFilterContext) SetReady(v uint32)

+ func (fltc *AVFilterContext) SetThreadType(v int32)

+ func (fltc *AVFilterContext) SetVarValues(v *float64)

+ type AVFilterExecuteFunc = C.avfilter_execute_func

+ type AVFilterFormats C.struct_AVFilterFormats

+ type AVFilterFormatsConfig C.struct_AVFilterFormatsConfig

+ type AVFilterGraph C.struct_AVFilterGraph

+ func AvFilterGraphAlloc() *AVFilterGraph

+ func (fltg *AVFilterGraph) GetAresampleSwrOpts() string

+ func (fltg *AVFilterGraph) GetAvClass() *AVClass

+ func (fltg *AVFilterGraph) GetAvClassAddr() **AVClass

+ func (fltg *AVFilterGraph) GetExecute() *AVFilterExecuteFunc

+ func (fltg *AVFilterGraph) GetExecuteAddr() **AVFilterExecuteFunc

+ func (fltg *AVFilterGraph) GetFilters() []*AVFilterContext

+ func (fltg *AVFilterGraph) GetFiltersAddr() ***AVFilterContext

+ func (fltg *AVFilterGraph) GetInternal() *AVFilterGraphInternal

+ func (fltg *AVFilterGraph) GetInternalAddr() **AVFilterGraphInternal

+ func (fltg *AVFilterGraph) GetNbFilters() uint32

+ func (fltg *AVFilterGraph) GetNbFiltersAddr() *uint32

+ func (fltg *AVFilterGraph) GetNbThreads() int32

+ func (fltg *AVFilterGraph) GetNbThreadsAddr() *int32

+ func (fltg *AVFilterGraph) GetOpaque() unsafe.Pointer

+ func (fltg *AVFilterGraph) GetOpaqueAddr() *unsafe.Pointer

+ func (fltg *AVFilterGraph) GetResampleLavrOpts() string

+ func (fltg *AVFilterGraph) GetScaleSwsOpts() string

+ func (fltg *AVFilterGraph) GetThreadType() int32

+ func (fltg *AVFilterGraph) GetThreadTypeAddr() *int32

+ func (fltg *AVFilterGraph) SetAvClass(v *AVClass)

+ func (fltg *AVFilterGraph) SetExecute(v *AVFilterExecuteFunc)

+ func (fltg *AVFilterGraph) SetFilters(v **AVFilterContext)

+ func (fltg *AVFilterGraph) SetInternal(v *AVFilterGraphInternal)

+ func (fltg *AVFilterGraph) SetNbFilters(v uint32)

+ func (fltg *AVFilterGraph) SetNbThreads(v int32)

+ func (fltg *AVFilterGraph) SetOpaque(v CVoidPointer)

+ func (fltg *AVFilterGraph) SetThreadType(v int32)

+ type AVFilterGraphInternal C.struct_AVFilterGraphInternal

+ type AVFilterInOut C.struct_AVFilterInOut

+ func AvFilterInoutAlloc() *AVFilterInOut

+ func (fltio *AVFilterInOut) GetFilterCtx() *AVFilterContext

+ func (fltio *AVFilterInOut) GetFilterCtxAddr() **AVFilterContext

+ func (fltio *AVFilterInOut) GetName() string

+ func (fltio *AVFilterInOut) GetNext() *AVFilterInOut

+ func (fltio *AVFilterInOut) GetNextAddr() **AVFilterInOut

+ func (fltio *AVFilterInOut) GetPadIdx() int32

+ func (fltio *AVFilterInOut) GetPadIdxAddr() *int32

+ func (fltio *AVFilterInOut) SetFilterCtx(v *AVFilterContext)

+ func (fltio *AVFilterInOut) SetName(v string)

+ func (fltio *AVFilterInOut) SetNext(v *AVFilterInOut)

+ func (fltio *AVFilterInOut) SetPadIdx(v int32)

+ type AVFilterInternal C.struct_AVFilterInternal

+ type AVFilterLink C.struct_AVFilterLink

+ func (fltl *AVFilterLink) GetChannelLayout() uint64

+ func (fltl *AVFilterLink) GetChannelLayoutAddr() *uint64

+ func (fltl *AVFilterLink) GetDst() *AVFilterContext

+ func (fltl *AVFilterLink) GetDstAddr() **AVFilterContext

+ func (fltl *AVFilterLink) GetDstpad() *AVFilterPad

+ func (fltl *AVFilterLink) GetDstpadAddr() **AVFilterPad

+ func (fltl *AVFilterLink) GetFormat() int32

+ func (fltl *AVFilterLink) GetFormatAddr() *int32

+ func (fltl *AVFilterLink) GetH() int32

+ func (fltl *AVFilterLink) GetHAddr() *int32

+ func (fltl *AVFilterLink) GetSampleAspectRatio() AVRational

+ func (fltl *AVFilterLink) GetSampleAspectRatioAddr() *AVRational

+ func (fltl *AVFilterLink) GetSampleRate() int32

+ func (fltl *AVFilterLink) GetSampleRateAddr() *int32

+ func (fltl *AVFilterLink) GetSrc() *AVFilterContext

+ func (fltl *AVFilterLink) GetSrcAddr() **AVFilterContext

+ func (fltl *AVFilterLink) GetSrcpad() *AVFilterPad

+ func (fltl *AVFilterLink) GetSrcpadAddr() **AVFilterPad

+ func (fltl *AVFilterLink) GetTimeBase() AVRational

+ func (fltl *AVFilterLink) GetTimeBaseAddr() *AVRational

+ func (fltl *AVFilterLink) GetType() AVMediaType

+ func (fltl *AVFilterLink) GetTypeAddr() *AVMediaType

+ func (fltl *AVFilterLink) GetW() int32

+ func (fltl *AVFilterLink) GetWAddr() *int32

+ func (fltl *AVFilterLink) SetChannelLayout(v uint64)

+ func (fltl *AVFilterLink) SetDst(v *AVFilterContext)

+ func (fltl *AVFilterLink) SetDstpad(v *AVFilterPad)

+ func (fltl *AVFilterLink) SetFormat(v int32)

+ func (fltl *AVFilterLink) SetH(v int32)

+ func (fltl *AVFilterLink) SetSampleAspectRatio(v AVRational)

+ func (fltl *AVFilterLink) SetSampleRate(v int32)

+ func (fltl *AVFilterLink) SetSrc(v *AVFilterContext)

+ func (fltl *AVFilterLink) SetSrcpad(v *AVFilterPad)

+ func (fltl *AVFilterLink) SetTimeBase(v AVRational)

+ func (fltl *AVFilterLink) SetType(v AVMediaType)

+ func (fltl *AVFilterLink) SetW(v int32)

+ type AVFilterPad C.struct_AVFilterPad

+ type AVFormatContext C.struct_AVFormatContext

+ func AvFormatAllocContext() *AVFormatContext

+ func (s *AVFormatContext) GetAudioCodec() *AVCodec

+ func (s *AVFormatContext) GetAudioCodecAddr() **AVCodec

+ func (s *AVFormatContext) GetAudioCodecId() AVCodecID

+ func (s *AVFormatContext) GetAudioCodecIdAddr() *AVCodecID

+ func (s *AVFormatContext) GetAudioPreload() int32

+ func (s *AVFormatContext) GetAudioPreloadAddr() *int32

+ func (s *AVFormatContext) GetAvClass() *AVClass

+ func (s *AVFormatContext) GetAvClassAddr() **AVClass

+ func (s *AVFormatContext) GetAvioFlags() int32

+ func (s *AVFormatContext) GetAvioFlagsAddr() *int32

+ func (s *AVFormatContext) GetAvoidNegativeTs() int32

+ func (s *AVFormatContext) GetAvoidNegativeTsAddr() *int32

+ func (s *AVFormatContext) GetBitRate() int64

+ func (s *AVFormatContext) GetBitRateAddr() *int64

+ func (s *AVFormatContext) GetChapters() (v []*AVChapter)

+ func (s *AVFormatContext) GetChaptersAddr() ***AVChapter

+ func (s *AVFormatContext) GetCodecWhitelist() string

+ func (s *AVFormatContext) GetCorrectTsOverflow() uint32

+ func (s *AVFormatContext) GetCorrectTsOverflowAddr() *uint32

+ func (s *AVFormatContext) GetCtxFlags() int32

+ func (s *AVFormatContext) GetCtxFlagsAddr() *int32

+ func (s *AVFormatContext) GetDataCodec() *AVCodec

+ func (s *AVFormatContext) GetDataCodecAddr() **AVCodec

+ func (s *AVFormatContext) GetDataCodecId() AVCodecID

+ func (s *AVFormatContext) GetDataCodecIdAddr() *AVCodecID

+ func (s *AVFormatContext) GetDebug() int32

+ func (s *AVFormatContext) GetDebugAddr() *int32

+ func (s *AVFormatContext) GetDumpSeparator() *uint8

+ func (s *AVFormatContext) GetDumpSeparatorAddr() **uint8

+ func (s *AVFormatContext) GetDuration() int64

+ func (s *AVFormatContext) GetDurationAddr() *int64

+ func (s *AVFormatContext) GetDurationEstimationMethod() AVDurationEstimationMethod

+ func (s *AVFormatContext) GetDurationEstimationMethodAddr() *AVDurationEstimationMethod

+ func (s *AVFormatContext) GetErrorRecognition() int32

+ func (s *AVFormatContext) GetErrorRecognitionAddr() *int32

+ func (s *AVFormatContext) GetEventFlags() int32

+ func (s *AVFormatContext) GetEventFlagsAddr() *int32

+ func (s *AVFormatContext) GetFilename() string

+ func (s *AVFormatContext) GetFlags() int32

+ func (s *AVFormatContext) GetFlagsAddr() *int32

+ func (s *AVFormatContext) GetFlushPackets() int32

+ func (s *AVFormatContext) GetFlushPacketsAddr() *int32

+ func (s *AVFormatContext) GetFormatProbesize() int32

+ func (s *AVFormatContext) GetFormatProbesizeAddr() *int32

+ func (s *AVFormatContext) GetFormatWhitelist() string

+ func (s *AVFormatContext) GetFpsProbeSize() int32

+ func (s *AVFormatContext) GetFpsProbeSizeAddr() *int32

+ func (s *AVFormatContext) GetIformat() *AVInputFormat

+ func (s *AVFormatContext) GetIformatAddr() **AVInputFormat

+ func (s *AVFormatContext) GetInternal() *AVFormatInternal

+ func (s *AVFormatContext) GetInternalAddr() **AVFormatInternal

+ func (s *AVFormatContext) GetInterruptCallback() AVIOInterruptCB

+ func (s *AVFormatContext) GetInterruptCallbackAddr() *AVIOInterruptCB

+ func (s *AVFormatContext) GetIoClose() AvFormatContextIoCloseFunc

+ func (s *AVFormatContext) GetIoCloseAddr() *AvFormatContextIoCloseFunc

+ func (s *AVFormatContext) GetIoOpen() AvFormatContextIoOpenFunc

+ func (s *AVFormatContext) GetIoOpenAddr() *AvFormatContextIoOpenFunc

+ func (s *AVFormatContext) GetIoRepositioned() int32

+ func (s *AVFormatContext) GetIoRepositionedAddr() *int32

+ func (s *AVFormatContext) GetKey() *uint8

+ func (s *AVFormatContext) GetKeyAddr() **uint8

+ func (s *AVFormatContext) GetKeylen() int32

+ func (s *AVFormatContext) GetKeylenAddr() *int32

+ func (s *AVFormatContext) GetMaxAnalyzeDuration() int64

+ func (s *AVFormatContext) GetMaxAnalyzeDurationAddr() *int64

+ func (s *AVFormatContext) GetMaxChunkDuration() int32

+ func (s *AVFormatContext) GetMaxChunkDurationAddr() *int32

+ func (s *AVFormatContext) GetMaxChunkSize() int32

+ func (s *AVFormatContext) GetMaxChunkSizeAddr() *int32

+ func (s *AVFormatContext) GetMaxDelay() int32

+ func (s *AVFormatContext) GetMaxDelayAddr() *int32

+ func (s *AVFormatContext) GetMaxIndexSize() uint32

+ func (s *AVFormatContext) GetMaxIndexSizeAddr() *uint32

+ func (s *AVFormatContext) GetMaxInterleaveDelta() int64

+ func (s *AVFormatContext) GetMaxInterleaveDeltaAddr() *int64

+ func (s *AVFormatContext) GetMaxPictureBuffer() uint32

+ func (s *AVFormatContext) GetMaxPictureBufferAddr() *uint32

+ func (s *AVFormatContext) GetMaxStreams() int32

+ func (s *AVFormatContext) GetMaxStreamsAddr() *int32

+ func (s *AVFormatContext) GetMaxTsProbe() int32

+ func (s *AVFormatContext) GetMaxTsProbeAddr() *int32

+ func (s *AVFormatContext) GetMetadata() *AVDictionary

+ func (s *AVFormatContext) GetMetadataAddr() **AVDictionary

+ func (s *AVFormatContext) GetMetadataHeaderPadding() int32

+ func (s *AVFormatContext) GetMetadataHeaderPaddingAddr() *int32

+ func (s *AVFormatContext) GetNbChapters() uint32

+ func (s *AVFormatContext) GetNbChaptersAddr() *uint32

+ func (s *AVFormatContext) GetNbPrograms() uint32

+ func (s *AVFormatContext) GetNbProgramsAddr() *uint32

+ func (s *AVFormatContext) GetNbStreams() uint32

+ func (s *AVFormatContext) GetNbStreamsAddr() *uint32

+ func (s *AVFormatContext) GetOformat() *AVOutputFormat

+ func (s *AVFormatContext) GetOformatAddr() **AVOutputFormat

+ func (s *AVFormatContext) GetOpaque() unsafe.Pointer

+ func (s *AVFormatContext) GetOpaqueAddr() unsafe.Pointer

+ func (s *AVFormatContext) GetOpenCb() AvFormatContextOpenCb

+ func (s *AVFormatContext) GetOpenCbAddr() *AvFormatContextOpenCb

+ func (s *AVFormatContext) GetOutputTsOffset() int64

+ func (s *AVFormatContext) GetOutputTsOffsetAddr() *int64

+ func (s *AVFormatContext) GetPacketSize() uint32

+ func (s *AVFormatContext) GetPacketSizeAddr() *uint32

+ func (s *AVFormatContext) GetPb() *AVIOContext

+ func (s *AVFormatContext) GetPbAddr() **AVIOContext

+ func (s *AVFormatContext) GetPrivData() unsafe.Pointer

+ func (s *AVFormatContext) GetPrivDataAddr() unsafe.Pointer

+ func (s *AVFormatContext) GetProbeScore() int32

+ func (s *AVFormatContext) GetProbeScoreAddr() *int32

+ func (s *AVFormatContext) GetProbesize() int64

+ func (s *AVFormatContext) GetProbesizeAddr() *int64

+ func (s *AVFormatContext) GetPrograms() (v []*AVProgram)

+ func (s *AVFormatContext) GetProgramsAddr() ***AVProgram

+ func (s *AVFormatContext) GetProtocolBlacklist() string

+ func (s *AVFormatContext) GetProtocolWhitelist() string

+ func (s *AVFormatContext) GetSeek2any() int32

+ func (s *AVFormatContext) GetSeek2anyAddr() *int32

+ func (s *AVFormatContext) GetSkipInitialBytes() int64

+ func (s *AVFormatContext) GetSkipInitialBytesAddr() *int64

+ func (s *AVFormatContext) GetStartTime() int64

+ func (s *AVFormatContext) GetStartTimeAddr() *int64

+ func (s *AVFormatContext) GetStartTimeRealtime() int64

+ func (s *AVFormatContext) GetStartTimeRealtimeAddr() *int64

+ func (s *AVFormatContext) GetStreams() (v []*AVStream)

+ func (s *AVFormatContext) GetStreamsAddr() ***AVStream

+ func (s *AVFormatContext) GetStrictStdCompliance() int32

+ func (s *AVFormatContext) GetStrictStdComplianceAddr() *int32

+ func (s *AVFormatContext) GetSubtitleCodec() *AVCodec

+ func (s *AVFormatContext) GetSubtitleCodecAddr() **AVCodec

+ func (s *AVFormatContext) GetSubtitleCodecId() AVCodecID

+ func (s *AVFormatContext) GetSubtitleCodecIdAddr() *AVCodecID

+ func (s *AVFormatContext) GetTsId() int32

+ func (s *AVFormatContext) GetTsIdAddr() *int32

+ func (s *AVFormatContext) GetUrl() string

+ func (s *AVFormatContext) GetUseWallclockAsTimestamps() int32

+ func (s *AVFormatContext) GetUseWallclockAsTimestampsAddr() *int32

+ func (s *AVFormatContext) GetVideoCodec() *AVCodec

+ func (s *AVFormatContext) GetVideoCodecAddr() **AVCodec

+ func (s *AVFormatContext) GetVideoCodecId() AVCodecID

+ func (s *AVFormatContext) GetVideoCodecIdAddr() *AVCodecID

+ func (s *AVFormatContext) SetAudioCodec(v *AVCodec)

+ func (s *AVFormatContext) SetAudioCodecId(v AVCodecID)

+ func (s *AVFormatContext) SetAudioPreload(v int32)

+ func (s *AVFormatContext) SetAvClass(v *AVClass)

+ func (s *AVFormatContext) SetAvioFlags(v int32)

+ func (s *AVFormatContext) SetAvoidNegativeTs(v int32)

+ func (s *AVFormatContext) SetBitRate(v int64)

+ func (s *AVFormatContext) SetChapters(v **AVChapter)

+ func (s *AVFormatContext) SetCorrectTsOverflow(v uint32)

+ func (s *AVFormatContext) SetCtxFlags(v int32)

+ func (s *AVFormatContext) SetDataCodec(v *AVCodec)

+ func (s *AVFormatContext) SetDataCodecId(v AVCodecID)

+ func (s *AVFormatContext) SetDebug(v int32)

+ func (s *AVFormatContext) SetDumpSeparator(v *uint8)

+ func (s *AVFormatContext) SetDuration(v int64)

+ func (s *AVFormatContext) SetDurationEstimationMethod(v AVDurationEstimationMethod)

+ func (s *AVFormatContext) SetErrorRecognition(v int32)

+ func (s *AVFormatContext) SetEventFlags(v int32)

+ func (s *AVFormatContext) SetFlags(v int32)

+ func (s *AVFormatContext) SetFlushPackets(v int32)

+ func (s *AVFormatContext) SetFormatProbesize(v int32)

+ func (s *AVFormatContext) SetFpsProbeSize(v int32)

+ func (s *AVFormatContext) SetIformat(v *AVInputFormat)

+ func (s *AVFormatContext) SetInternal(v *AVFormatInternal)

+ func (s *AVFormatContext) SetInterruptCallback(v AVIOInterruptCB)

+ func (s *AVFormatContext) SetIoClose(v AvFormatContextIoCloseFunc)

+ func (s *AVFormatContext) SetIoOpen(v AvFormatContextIoOpenFunc)

+ func (s *AVFormatContext) SetIoRepositioned(v int32)

+ func (s *AVFormatContext) SetKey(v *uint8)

+ func (s *AVFormatContext) SetKeylen(v int32)

+ func (s *AVFormatContext) SetMaxAnalyzeDuration(v int64)

+ func (s *AVFormatContext) SetMaxChunkDuration(v int32)

+ func (s *AVFormatContext) SetMaxChunkSize(v int32)

+ func (s *AVFormatContext) SetMaxDelay(v int32)

+ func (s *AVFormatContext) SetMaxIndexSize(v uint32)

+ func (s *AVFormatContext) SetMaxInterleaveDelta(v int64)

+ func (s *AVFormatContext) SetMaxPictureBuffer(v uint32)

+ func (s *AVFormatContext) SetMaxStreams(v int32)

+ func (s *AVFormatContext) SetMaxTsProbe(v int32)

+ func (s *AVFormatContext) SetMetadata(v *AVDictionary)

+ func (s *AVFormatContext) SetMetadataHeaderPadding(v int32)

+ func (s *AVFormatContext) SetNbChapters(v uint32)

+ func (s *AVFormatContext) SetNbPrograms(v uint32)

+ func (s *AVFormatContext) SetNbStreams(v uint32)

+ func (s *AVFormatContext) SetOformat(v *AVOutputFormat)

+ func (s *AVFormatContext) SetOpaque(v CVoidPointer)

+ func (s *AVFormatContext) SetOpenCb(v AvFormatContextOpenCb)

+ func (s *AVFormatContext) SetOutputTsOffset(v int64)

+ func (s *AVFormatContext) SetPacketSize(v uint32)

+ func (s *AVFormatContext) SetPb(v *AVIOContext)

+ func (s *AVFormatContext) SetPrivData(v CVoidPointer)

+ func (s *AVFormatContext) SetProbeScore(v int32)

+ func (s *AVFormatContext) SetProbesize(v int64)

+ func (s *AVFormatContext) SetPrograms(v **AVProgram)

+ func (s *AVFormatContext) SetSeek2any(v int32)

+ func (s *AVFormatContext) SetSkipInitialBytes(v int64)

+ func (s *AVFormatContext) SetStartTime(v int64)

+ func (s *AVFormatContext) SetStartTimeRealtime(v int64)

+ func (s *AVFormatContext) SetStreams(v **AVStream)

+ func (s *AVFormatContext) SetStrictStdCompliance(v int32)

+ func (s *AVFormatContext) SetSubtitleCodec(v *AVCodec)

+ func (s *AVFormatContext) SetSubtitleCodecId(v AVCodecID)

+ func (s *AVFormatContext) SetTsId(v int32)

+ func (s *AVFormatContext) SetUrl(v string)

+ func (s *AVFormatContext) SetUseWallclockAsTimestamps(v int32)

+ func (s *AVFormatContext) SetVideoCodec(v *AVCodec)

+ func (s *AVFormatContext) SetVideoCodecId(v AVCodecID)

+ type AVFormatControlMessageFunc C.av_format_control_message

+ func AvFormatGetControlMessageCb(s *AVFormatContext) AVFormatControlMessageFunc

+ type AVFormatInternal C.struct_AVFormatInternal

+ type AVFrame C.struct_AVFrame

+ func AvFrameAlloc() *AVFrame

+ func AvFrameClone(frame *AVFrame) *AVFrame

+ func (frame *AVFrame) GetBestEffortTimestamp() int64

+ func (frame *AVFrame) GetBestEffortTimestampAddr() *int64

+ func (frame *AVFrame) GetBuf() []*AVBufferRef

+ func (frame *AVFrame) GetBufAddr() ***AVBufferRef

+ func (frame *AVFrame) GetChannelLayout() uint64

+ func (frame *AVFrame) GetChannelLayoutAddr() *uint64

+ func (frame *AVFrame) GetChannels() int32

+ func (frame *AVFrame) GetChannelsAddr() *int32

+ func (frame *AVFrame) GetChromaLocation() AVChromaLocation

+ func (frame *AVFrame) GetChromaLocationAddr() *AVChromaLocation

+ func (frame *AVFrame) GetCodedPictureNumber() int32

+ func (frame *AVFrame) GetCodedPictureNumberAddr() *int32

+ func (frame *AVFrame) GetColorPrimaries() AVColorPrimaries

+ func (frame *AVFrame) GetColorPrimariesAddr() *AVColorPrimaries

+ func (frame *AVFrame) GetColorRange() AVColorRange

+ func (frame *AVFrame) GetColorRangeAddr() *AVColorRange

+ func (frame *AVFrame) GetColorTrc() AVColorTransferCharacteristic

+ func (frame *AVFrame) GetColorTrcAddr() *AVColorTransferCharacteristic

+ func (frame *AVFrame) GetColorspace() AVColorSpace

+ func (frame *AVFrame) GetColorspaceAddr() *AVColorSpace

+ func (frame *AVFrame) GetCropBottom() uintptr

+ func (frame *AVFrame) GetCropBottomAddr() *uintptr

+ func (frame *AVFrame) GetCropLeft() uintptr

+ func (frame *AVFrame) GetCropLeftAddr() *uintptr

+ func (frame *AVFrame) GetCropRight() uintptr

+ func (frame *AVFrame) GetCropRightAddr() *uintptr

+ func (frame *AVFrame) GetCropTop() uintptr

+ func (frame *AVFrame) GetCropTopAddr() *uintptr

+ func (frame *AVFrame) GetData() []*uint8

+ func (frame *AVFrame) GetDataAddr() ***uint8

+ func (frame *AVFrame) GetDecodeErrorFlags() int32

+ func (frame *AVFrame) GetDecodeErrorFlagsAddr() *int32

+ func (frame *AVFrame) GetDisplayPictureNumber() int32

+ func (frame *AVFrame) GetDisplayPictureNumberAddr() *int32

+ func (frame *AVFrame) GetError() []uint64

+ func (frame *AVFrame) GetErrorAddr() **uint64

+ func (frame *AVFrame) GetExtendedBuf() []*AVBufferRef

+ func (frame *AVFrame) GetExtendedBufAddr() ***AVBufferRef

+ func (frame *AVFrame) GetExtendedData() **uint8

+ func (frame *AVFrame) GetExtendedDataAddr() ***uint8

+ func (frame *AVFrame) GetFlags() int32

+ func (frame *AVFrame) GetFlagsAddr() *int32

+ func (frame *AVFrame) GetFormat() int32

+ func (frame *AVFrame) GetFormatAddr() *int32

+ func (frame *AVFrame) GetHeight() int32

+ func (frame *AVFrame) GetHeightAddr() *int32

+ func (frame *AVFrame) GetHwFramesCtx() *AVBufferRef

+ func (frame *AVFrame) GetHwFramesCtxAddr() **AVBufferRef

+ func (frame *AVFrame) GetInterlacedFrame() int32

+ func (frame *AVFrame) GetInterlacedFrameAddr() *int32

+ func (frame *AVFrame) GetKeyFrame() int32

+ func (frame *AVFrame) GetKeyFrameAddr() *int32

+ func (frame *AVFrame) GetLinesize() []int32

+ func (frame *AVFrame) GetLinesizeAddr() **int32

+ func (frame *AVFrame) GetMetadata() *AVDictionary

+ func (frame *AVFrame) GetMetadataAddr() **AVDictionary

+ func (frame *AVFrame) GetNbExtendedBuf() int32

+ func (frame *AVFrame) GetNbExtendedBufAddr() *int32

+ func (frame *AVFrame) GetNbSamples() int32

+ func (frame *AVFrame) GetNbSamplesAddr() *int32

+ func (frame *AVFrame) GetNbSideData() int32

+ func (frame *AVFrame) GetNbSideDataAddr() *int32

+ func (frame *AVFrame) GetOpaqueRef() *AVBufferRef

+ func (frame *AVFrame) GetOpaqueRefAddr() **AVBufferRef

+ func (frame *AVFrame) GetPaletteHasChanged() int32

+ func (frame *AVFrame) GetPaletteHasChangedAddr() *int32

+ func (frame *AVFrame) GetPictType() AVPictureType

+ func (frame *AVFrame) GetPictTypeAddr() *AVPictureType

+ func (frame *AVFrame) GetPktDts() int64

+ func (frame *AVFrame) GetPktDtsAddr() *int64

+ func (frame *AVFrame) GetPktDuration() int64

+ func (frame *AVFrame) GetPktDurationAddr() *int64

+ func (frame *AVFrame) GetPktPos() int64

+ func (frame *AVFrame) GetPktPosAddr() *int64

+ func (frame *AVFrame) GetPktPts() int64

+ func (frame *AVFrame) GetPktPtsAddr() *int64

+ func (frame *AVFrame) GetPktSize() int32

+ func (frame *AVFrame) GetPktSizeAddr() *int32

+ func (frame *AVFrame) GetPrivateRef() *AVBufferRef

+ func (frame *AVFrame) GetPrivateRefAddr() **AVBufferRef

+ func (frame *AVFrame) GetPts() int64

+ func (frame *AVFrame) GetPtsAddr() *int64

+ func (frame *AVFrame) GetQpTableBuf() *AVBufferRef

+ func (frame *AVFrame) GetQpTableBufAddr() **AVBufferRef

+ func (frame *AVFrame) GetQscaleTable() *int8

+ func (frame *AVFrame) GetQscaleTableAddr() **int8

+ func (frame *AVFrame) GetQscaleType() int32

+ func (frame *AVFrame) GetQscaleTypeAddr() *int32

+ func (frame *AVFrame) GetQstride() int32

+ func (frame *AVFrame) GetQstrideAddr() *int32

+ func (frame *AVFrame) GetQuality() int32

+ func (frame *AVFrame) GetQualityAddr() *int32

+ func (frame *AVFrame) GetReorderedOpaque() int64

+ func (frame *AVFrame) GetReorderedOpaqueAddr() *int64

+ func (frame *AVFrame) GetRepeatPict() int32

+ func (frame *AVFrame) GetRepeatPictAddr() *int32

+ func (frame *AVFrame) GetSampleAspectRatio() AVRational

+ func (frame *AVFrame) GetSampleAspectRatioAddr() *AVRational

+ func (frame *AVFrame) GetSampleRate() int32

+ func (frame *AVFrame) GetSampleRateAddr() *int32

+ func (frame *AVFrame) GetSideData() []*AVFrameSideData

+ func (frame *AVFrame) GetSideDataAddr() ***AVFrameSideData

+ func (frame *AVFrame) GetTopFieldFirst() int32

+ func (frame *AVFrame) GetTopFieldFirstAddr() *int32

+ func (frame *AVFrame) GetWidth() int32

+ func (frame *AVFrame) GetWidthAddr() *int32

+ func (frame *AVFrame) SetBestEffortTimestamp(v int64)

+ func (frame *AVFrame) SetBuf(v []*AVBufferRef)

+ func (frame *AVFrame) SetChannelLayout(v uint64)

+ func (frame *AVFrame) SetChannels(v int32)

+ func (frame *AVFrame) SetChromaLocation(v AVChromaLocation)

+ func (frame *AVFrame) SetCodedPictureNumber(v int32)

+ func (frame *AVFrame) SetColorPrimaries(v AVColorPrimaries)

+ func (frame *AVFrame) SetColorRange(v AVColorRange)

+ func (frame *AVFrame) SetColorTrc(v AVColorTransferCharacteristic)

+ func (frame *AVFrame) SetColorspace(v AVColorSpace)

+ func (frame *AVFrame) SetCropBottom(v uintptr)

+ func (frame *AVFrame) SetCropLeft(v uintptr)

+ func (frame *AVFrame) SetCropRight(v uintptr)

+ func (frame *AVFrame) SetCropTop(v uintptr)

+ func (frame *AVFrame) SetData(v []*uint8)

+ func (frame *AVFrame) SetDecodeErrorFlags(v int32)

+ func (frame *AVFrame) SetDisplayPictureNumber(v int32)

+ func (frame *AVFrame) SetError(v []uint64)

+ func (frame *AVFrame) SetExtendedBuf(v **AVBufferRef)

+ func (frame *AVFrame) SetExtendedData(v **uint8)

+ func (frame *AVFrame) SetFlags(v int32)

+ func (frame *AVFrame) SetFormat(v int32)

+ func (frame *AVFrame) SetHeight(v int32)

+ func (frame *AVFrame) SetHwFramesCtx(v *AVBufferRef)

+ func (frame *AVFrame) SetInterlacedFrame(v int32)

+ func (frame *AVFrame) SetKeyFrame(v int32)

+ func (frame *AVFrame) SetLinesize(v []int32)

+ func (frame *AVFrame) SetMetadata(v *AVDictionary)

+ func (frame *AVFrame) SetNbExtendedBuf(v int32)

+ func (frame *AVFrame) SetNbSamples(v int32)

+ func (frame *AVFrame) SetNbSideData(v int32)

+ func (frame *AVFrame) SetOpaqueRef(v *AVBufferRef)

+ func (frame *AVFrame) SetPaletteHasChanged(v int32)

+ func (frame *AVFrame) SetPictType(v AVPictureType)

+ func (frame *AVFrame) SetPktDts(v int64)

+ func (frame *AVFrame) SetPktDuration(v int64)

+ func (frame *AVFrame) SetPktPos(v int64)

+ func (frame *AVFrame) SetPktPts(v int64)

+ func (frame *AVFrame) SetPktSize(v int32)

+ func (frame *AVFrame) SetPrivateRef(v *AVBufferRef)

+ func (frame *AVFrame) SetPts(v int64)

+ func (frame *AVFrame) SetQpTableBuf(v *AVBufferRef)

+ func (frame *AVFrame) SetQscaleTable(v *int8)

+ func (frame *AVFrame) SetQscaleType(v int32)

+ func (frame *AVFrame) SetQstride(v int32)

+ func (frame *AVFrame) SetQuality(v int32)

+ func (frame *AVFrame) SetReorderedOpaque(v int64)

+ func (frame *AVFrame) SetRepeatPict(v int32)

+ func (frame *AVFrame) SetSampleAspectRatio(v AVRational)

+ func (frame *AVFrame) SetSampleRate(v int32)

+ func (frame *AVFrame) SetSideData(v **AVFrameSideData)

+ func (frame *AVFrame) SetTopFieldFirst(v int32)

+ func (frame *AVFrame) SetWidth(v int32)

+ type AVFrameSideData C.struct_AVFrameSideData

+ func AvFrameGetSideData(frame *AVFrame, _type AVFrameSideDataType) *AVFrameSideData

+ func AvFrameNewSideData(frame *AVFrame, _type AVFrameSideDataType, size int32) *AVFrameSideData

+ func AvFrameNewSideDataFromBuf(frame *AVFrame, _type AVFrameSideDataType, buf *AVBufferRef) *AVFrameSideData

+ func (sd *AVFrameSideData) GetBuf() *AVBufferRef

+ func (sd *AVFrameSideData) GetBufAddr() **AVBufferRef

+ func (sd *AVFrameSideData) GetData() *uint8

+ func (sd *AVFrameSideData) GetDataAddr() **uint8

+ func (sd *AVFrameSideData) GetMetadata() *AVDictionary

+ func (sd *AVFrameSideData) GetMetadataAddr() **AVDictionary

+ func (sd *AVFrameSideData) GetSize() int32

+ func (sd *AVFrameSideData) GetSizeAddr() *int32

+ func (sd *AVFrameSideData) GetType() AVFrameSideDataType

+ func (sd *AVFrameSideData) GetTypeAddr() *AVFrameSideDataType

+ func (sd *AVFrameSideData) SetBuf(v *AVBufferRef)

+ func (sd *AVFrameSideData) SetData(v *uint8)

+ func (sd *AVFrameSideData) SetMetadata(v *AVDictionary)

+ func (sd *AVFrameSideData) SetSize(v int32)

+ func (sd *AVFrameSideData) SetType(v AVFrameSideDataType)

+ type AVFrameSideDataType = C.enum_AVFrameSideDataType

+ type AVHMAC C.struct_AVHMAC

+ func AvHmacAlloc(_type AVHMACType) *AVHMAC

+ type AVHMACType = C.enum_AVHMACType

+ type AVHWAccel C.struct_AVHWAccel

+ func AvHwaccelNext(hwaccel *AVHWAccel) *AVHWAccel

+ func (hwa *AVHWAccel) GetCapabilities() int32

+ func (hwa *AVHWAccel) GetCapabilitiesAddr() *int32

+ func (hwa *AVHWAccel) GetId() AVCodecID

+ func (hwa *AVHWAccel) GetIdAddr() *AVCodecID

+ func (hwa *AVHWAccel) GetName() string

+ func (hwa *AVHWAccel) GetPixFmt() AVPixelFormat

+ func (hwa *AVHWAccel) GetPixFmtAddr() *AVPixelFormat

+ func (hwa *AVHWAccel) GetType() AVMediaType

+ func (hwa *AVHWAccel) GetTypeAddr() *AVMediaType

+ func (hwa *AVHWAccel) SetCapabilities(v int32)

+ func (hwa *AVHWAccel) SetId(v AVCodecID)

+ func (hwa *AVHWAccel) SetPixFmt(v AVPixelFormat)

+ func (hwa *AVHWAccel) SetType(v AVMediaType)

+ type AVHWDeviceContext C.struct_AVHWDeviceContext

+ func (dc *AVHWDeviceContext) GetAvClass() *AVClass

+ func (dc *AVHWDeviceContext) GetAvClassAddr() **AVClass

+ func (dc *AVHWDeviceContext) GetHwctx() unsafe.Pointer

+ func (dc *AVHWDeviceContext) GetHwctxAddr() *unsafe.Pointer

+ func (dc *AVHWDeviceContext) GetInternal() *AVHWDeviceInternal

+ func (dc *AVHWDeviceContext) GetInternalAddr() **AVHWDeviceInternal

+ func (dc *AVHWDeviceContext) GetType() AVHWDeviceType

+ func (dc *AVHWDeviceContext) GetTypeAddr() *AVHWDeviceType

+ func (dc *AVHWDeviceContext) GetUserOpaque() unsafe.Pointer

+ func (dc *AVHWDeviceContext) GetUserOpaqueAddr() *unsafe.Pointer

+ func (dc *AVHWDeviceContext) SetAvClass(v *AVClass)

+ func (dc *AVHWDeviceContext) SetFree(v AVHWDeviceContextFreeFunc)

+ func (dc *AVHWDeviceContext) SetHwctx(v CVoidPointer)

+ func (dc *AVHWDeviceContext) SetInternal(v *AVHWDeviceInternal)

+ func (dc *AVHWDeviceContext) SetType(v AVHWDeviceType)

+ func (dc *AVHWDeviceContext) SetUserOpaque(v CVoidPointer)

+ type AVHWDeviceContextFreeFunc = C.av_hw_device_context_free_func

+ type AVHWDeviceInternal C.struct_AVHWDeviceInternal

+ type AVHWDeviceType = C.enum_AVHWDeviceType

+ func AvHWDeviceFindTypeByName(name string) AVHWDeviceType

+ func AvHWDeviceIterateTypes(prev AVHWDeviceType) AVHWDeviceType

+ type AVHWFrameTransferDirection = C.enum_AVHWFrameTransferDirection

+ type AVHWFramesConstraints C.struct_AVHWFramesConstraints

+ func AvHWDeviceGetHwframeConstraints(ref *AVBufferRef, hwconfig CVoidPointer) *AVHWFramesConstraints

+ func (fcs *AVHWFramesConstraints) GetMaxHeight() int32

+ func (fcs *AVHWFramesConstraints) GetMaxHeightAddr() *int32

+ func (fcs *AVHWFramesConstraints) GetMaxWidth() int32

+ func (fcs *AVHWFramesConstraints) GetMaxWidthAddr() *int32

+ func (fcs *AVHWFramesConstraints) GetMinHeight() int32

+ func (fcs *AVHWFramesConstraints) GetMinHeightAddr() *int32

+ func (fcs *AVHWFramesConstraints) GetMinWidth() int32

+ func (fcs *AVHWFramesConstraints) GetMinWidthAddr() *int32

+ func (fcs *AVHWFramesConstraints) GetValidHwFormats() []AVPixelFormat

+ func (fcs *AVHWFramesConstraints) GetValidHwFormatsAddr() **AVPixelFormat

+ func (fcs *AVHWFramesConstraints) GetValidSwFormats() []AVPixelFormat

+ func (fcs *AVHWFramesConstraints) GetValidSwFormatsAddr() **AVPixelFormat

+ func (fcs *AVHWFramesConstraints) SetMaxHeight(v int32)

+ func (fcs *AVHWFramesConstraints) SetMaxWidth(v int32)

+ func (fcs *AVHWFramesConstraints) SetMinHeight(v int32)

+ func (fcs *AVHWFramesConstraints) SetMinWidth(v int32)

+ func (fcs *AVHWFramesConstraints) SetValidHwFormats(v *AVPixelFormat)

+ func (fcs *AVHWFramesConstraints) SetValidSwFormats(v *AVPixelFormat)

+ type AVHWFramesContext C.struct_AVHWFramesContext

+ func (fc *AVHWFramesContext) GetAvClass() *AVClass

+ func (fc *AVHWFramesContext) GetAvClassAddr() **AVClass

+ func (fc *AVHWFramesContext) GetDeviceCtx() *AVHWDeviceContext

+ func (fc *AVHWFramesContext) GetDeviceCtxAddr() **AVHWDeviceContext

+ func (fc *AVHWFramesContext) GetDeviceRef() *AVBufferRef

+ func (fc *AVHWFramesContext) GetDeviceRefAddr() **AVBufferRef

+ func (fc *AVHWFramesContext) GetFormat() AVPixelFormat

+ func (fc *AVHWFramesContext) GetFormatAddr() *AVPixelFormat

+ func (fc *AVHWFramesContext) GetHeight() int32

+ func (fc *AVHWFramesContext) GetHeightAddr() *int32

+ func (fc *AVHWFramesContext) GetHwctx() unsafe.Pointer

+ func (fc *AVHWFramesContext) GetHwctxAddr() *unsafe.Pointer

+ func (fc *AVHWFramesContext) GetInitialPoolSize() int32

+ func (fc *AVHWFramesContext) GetInitialPoolSizeAddr() *int32

+ func (fc *AVHWFramesContext) GetInternal() *AVHWFramesInternal

+ func (fc *AVHWFramesContext) GetInternalAddr() **AVHWFramesInternal

+ func (fc *AVHWFramesContext) GetPool() *AVBufferPool

+ func (fc *AVHWFramesContext) GetPoolAddr() **AVBufferPool

+ func (fc *AVHWFramesContext) GetSwFormat() AVPixelFormat

+ func (fc *AVHWFramesContext) GetSwFormatAddr() *AVPixelFormat

+ func (fc *AVHWFramesContext) GetUserOpaque() unsafe.Pointer

+ func (fc *AVHWFramesContext) GetUserOpaqueAddr() *unsafe.Pointer

+ func (fc *AVHWFramesContext) GetWidth() int32

+ func (fc *AVHWFramesContext) GetWidthAddr() *int32

+ func (fc *AVHWFramesContext) SetAvClass(v *AVClass)

+ func (fc *AVHWFramesContext) SetDeviceCtx(v *AVHWDeviceContext)

+ func (fc *AVHWFramesContext) SetDeviceRef(v *AVBufferRef)

+ func (fc *AVHWFramesContext) SetFormat(v AVPixelFormat)

+ func (fc *AVHWFramesContext) SetFree(v AVHWFramesContextFreeFunc)

+ func (fc *AVHWFramesContext) SetHeight(v int32)

+ func (fc *AVHWFramesContext) SetHwctx(v CVoidPointer)

+ func (fc *AVHWFramesContext) SetInitialPoolSize(v int32)

+ func (fc *AVHWFramesContext) SetInternal(v *AVHWFramesInternal)

+ func (fc *AVHWFramesContext) SetPool(v *AVBufferPool)

+ func (fc *AVHWFramesContext) SetSwFormat(v AVPixelFormat)

+ func (fc *AVHWFramesContext) SetUserOpaque(v CVoidPointer)

+ func (fc *AVHWFramesContext) SetWidth(v int32)

+ type AVHWFramesContextFreeFunc = C.av_hw_frames_context_free_func

+ type AVHWFramesInternal C.struct_AVHWFramesInternal

+ type AVHashContext C.struct_AVHashContext

+ type AVIOContext C.struct_AVIOContext

+ func AvIOAllocContext(buffer *uint8, bufferSize, writeFlag int32, opaque CVoidPointer, ...) *AVIOContext

+ func (ctx *AVIOContext) GetAvClass() *AVClass

+ func (ctx *AVIOContext) GetAvClassAddr() **AVClass

+ func (ctx *AVIOContext) GetBufEnd() *uint8

+ func (ctx *AVIOContext) GetBufEndAddr() **uint8

+ func (ctx *AVIOContext) GetBufPtr() *uint8

+ func (ctx *AVIOContext) GetBufPtrAddr() **uint8

+ func (ctx *AVIOContext) GetBufPtrMax() *uint8

+ func (ctx *AVIOContext) GetBufPtrMaxAddr() **uint8

+ func (ctx *AVIOContext) GetBuffer() *uint8

+ func (ctx *AVIOContext) GetBufferAddr() **uint8

+ func (ctx *AVIOContext) GetBufferSize() int32

+ func (ctx *AVIOContext) GetBufferSizeAddr() *int32

+ func (ctx *AVIOContext) GetBytesRead() int64

+ func (ctx *AVIOContext) GetBytesReadAddr() *int64

+ func (ctx *AVIOContext) GetChecksum() uint32

+ func (ctx *AVIOContext) GetChecksumAddr() *uint32

+ func (ctx *AVIOContext) GetChecksumPtr() *uint8

+ func (ctx *AVIOContext) GetChecksumPtrAddr() **uint8

+ func (ctx *AVIOContext) GetCurrentType() AVIODataMarkerType

+ func (ctx *AVIOContext) GetCurrentTypeAddr() *AVIODataMarkerType

+ func (ctx *AVIOContext) GetDirect() int32

+ func (ctx *AVIOContext) GetDirectAddr() *int32

+ func (ctx *AVIOContext) GetEofReached() int32

+ func (ctx *AVIOContext) GetEofReachedAddr() *int32

+ func (ctx *AVIOContext) GetError() int32

+ func (ctx *AVIOContext) GetErrorAddr() *int32

+ func (ctx *AVIOContext) GetIgnoreBoundaryPoint() int32

+ func (ctx *AVIOContext) GetIgnoreBoundaryPointAddr() *int32

+ func (ctx *AVIOContext) GetLastTime() int64

+ func (ctx *AVIOContext) GetLastTimeAddr() *int64

+ func (ctx *AVIOContext) GetMaxPacketSize() int32

+ func (ctx *AVIOContext) GetMaxPacketSizeAddr() *int32

+ func (ctx *AVIOContext) GetMaxsize() int64

+ func (ctx *AVIOContext) GetMaxsizeAddr() *int64

+ func (ctx *AVIOContext) GetMinPacketSize() int32

+ func (ctx *AVIOContext) GetMinPacketSizeAddr() *int32

+ func (ctx *AVIOContext) GetOpaque() unsafe.Pointer

+ func (ctx *AVIOContext) GetOpaqueAddr() *unsafe.Pointer

+ func (ctx *AVIOContext) GetOrigBufferSize() int32

+ func (ctx *AVIOContext) GetOrigBufferSizeAddr() *int32

+ func (ctx *AVIOContext) GetPos() int64

+ func (ctx *AVIOContext) GetPosAddr() *int64

+ func (ctx *AVIOContext) GetProtocolBlacklist() string

+ func (ctx *AVIOContext) GetProtocolWhitelist() string

+ func (ctx *AVIOContext) GetSeekCount() int32

+ func (ctx *AVIOContext) GetSeekCountAddr() *int32

+ func (ctx *AVIOContext) GetSeekable() int32

+ func (ctx *AVIOContext) GetSeekableAddr() *int32

+ func (ctx *AVIOContext) GetShortSeekThreshold() int32

+ func (ctx *AVIOContext) GetShortSeekThresholdAddr() *int32

+ func (ctx *AVIOContext) GetWriteFlag() int32

+ func (ctx *AVIOContext) GetWriteFlagAddr() *int32

+ func (ctx *AVIOContext) GetWriteoutCount() int32

+ func (ctx *AVIOContext) GetWriteoutCountAddr() *int32

+ func (ctx *AVIOContext) GetWritten() int64

+ func (ctx *AVIOContext) GetWrittenAddr() *int64

+ func (ctx *AVIOContext) SetAvClass(v *AVClass)

+ func (ctx *AVIOContext) SetBufEnd(v *uint8)

+ func (ctx *AVIOContext) SetBufPtr(v *uint8)

+ func (ctx *AVIOContext) SetBufPtrMax(v *uint8)

+ func (ctx *AVIOContext) SetBuffer(v *uint8)

+ func (ctx *AVIOContext) SetBufferSize(v int32)

+ func (ctx *AVIOContext) SetBytesRead(v int64)

+ func (ctx *AVIOContext) SetChecksum(v uint32)

+ func (ctx *AVIOContext) SetChecksumPtr(v *uint8)

+ func (ctx *AVIOContext) SetCurrentType(v AVIODataMarkerType)

+ func (ctx *AVIOContext) SetDirect(v int32)

+ func (ctx *AVIOContext) SetEofReached(v int32)

+ func (ctx *AVIOContext) SetError(v int32)

+ func (ctx *AVIOContext) SetIgnoreBoundaryPoint(v int32)

+ func (ctx *AVIOContext) SetLastTime(v int64)

+ func (ctx *AVIOContext) SetMaxPacketSize(v int32)

+ func (ctx *AVIOContext) SetMaxsize(v int64)

+ func (ctx *AVIOContext) SetMinPacketSize(v int32)

+ func (ctx *AVIOContext) SetOpaque(v CVoidPointer)

+ func (ctx *AVIOContext) SetOrigBufferSize(v int32)

+ func (ctx *AVIOContext) SetPos(v int64)

+ func (ctx *AVIOContext) SetSeekCount(v int32)

+ func (ctx *AVIOContext) SetSeekable(v int32)

+ func (ctx *AVIOContext) SetShortSeekThreshold(v int32)

+ func (ctx *AVIOContext) SetWriteFlag(v int32)

+ func (ctx *AVIOContext) SetWriteoutCount(v int32)

+ func (ctx *AVIOContext) SetWritten(v int64)

+ type AVIOContextReadPacketFunc = C.avio_context_read_packet_func

+ type AVIOContextSeekFunc = C.avio_context_seek_func

+ type AVIOContextWritePacketFunc = C.avio_context_write_packet_func

+ type AVIODataMarkerType = C.enum_AVIODataMarkerType

+ type AVIODirContext C.struct_AVIODirContext

+ func (dc *AVIODirContext) GetURLContext() *URLContext

+ func (dc *AVIODirContext) GetURLContextAddr() **URLContext

+ func (dc *AVIODirContext) SetURLContext(v *URLContext)

+ type AVIODirEntry C.struct_AVIODirEntry

+ func (de *AVIODirEntry) GetAccessTimestamp() int64

+ func (de *AVIODirEntry) GetAccessTimestampAddr() *int64

+ func (de *AVIODirEntry) GetFilemode() int64

+ func (de *AVIODirEntry) GetFilemodeAddr() *int64

+ func (de *AVIODirEntry) GetGroupId() int64

+ func (de *AVIODirEntry) GetGroupIdAddr() *int64

+ func (de *AVIODirEntry) GetModificationTimestamp() int64

+ func (de *AVIODirEntry) GetModificationTimestampAddr() *int64

+ func (de *AVIODirEntry) GetName() string

+ func (de *AVIODirEntry) GetSize() int64

+ func (de *AVIODirEntry) GetSizeAddr() *int64

+ func (de *AVIODirEntry) GetStatusChangeTimestamp() int64

+ func (de *AVIODirEntry) GetStatusChangeTimestampAddr() *int64

+ func (de *AVIODirEntry) GetType() int32

+ func (de *AVIODirEntry) GetTypeAddr() *int32

+ func (de *AVIODirEntry) GetUserId() int64

+ func (de *AVIODirEntry) GetUserIdAddr() *int64

+ func (de *AVIODirEntry) GetUtf8() int32

+ func (de *AVIODirEntry) GetUtf8Addr() *int32

+ func (de *AVIODirEntry) SetAccessTimestamp(v int64)

+ func (de *AVIODirEntry) SetFilemode(v int64)

+ func (de *AVIODirEntry) SetGroupId(v int64)

+ func (de *AVIODirEntry) SetModificationTimestamp(v int64)

+ func (de *AVIODirEntry) SetSize(v int64)

+ func (de *AVIODirEntry) SetStatusChangeTimestamp(v int64)

+ func (de *AVIODirEntry) SetType(v int32)

+ func (de *AVIODirEntry) SetUserId(v int64)

+ func (de *AVIODirEntry) SetUtf8(v int32)

+ type AVIODirEntryType = int32

+ type AVIOInterruptCB C.struct_AVIOInterruptCB

+ func (icb *AVIOInterruptCB) GetCallback() AVIOInterruptCallbackFunc

+ func (icb *AVIOInterruptCB) GetCallbackAddr() *AVIOInterruptCallbackFunc

+ func (icb *AVIOInterruptCB) GetOpaque() unsafe.Pointer

+ func (icb *AVIOInterruptCB) GetOpaqueAddr() *unsafe.Pointer

+ func (icb *AVIOInterruptCB) SetCallback(v AVIOInterruptCallbackFunc)

+ func (icb *AVIOInterruptCB) SetOpaque(v CVoidPointer)

+ type AVIOInterruptCallbackFunc = C.avio_interrupt_callback_func

+ type AVIndexEntry C.struct_AVIndexEntry

+ func (ie *AVIndexEntry) GetFlags() int32

+ func (ie *AVIndexEntry) GetMinDistance() int32

+ func (ie *AVIndexEntry) GetMinDistanceAddr() *int32

+ func (ie *AVIndexEntry) GetPos() int64

+ func (ie *AVIndexEntry) GetPosAddr() *int64

+ func (ie *AVIndexEntry) GetSize() int32

+ func (ie *AVIndexEntry) GetTimestamp() int64

+ func (ie *AVIndexEntry) GetTimestampAddr() *int64

+ func (ie *AVIndexEntry) SetFlags(v int32)

+ func (ie *AVIndexEntry) SetMinDistance(v int32)

+ func (ie *AVIndexEntry) SetPos(v int64)

+ func (ie *AVIndexEntry) SetSize(v int32)

+ func (ie *AVIndexEntry) SetTimestamp(v int64)

+ type AVInputFormat C.struct_AVInputFormat

+ func AvDemuxerIterate(opaque CVoidPointerPointer) *AVInputFormat

+ func AvFindInputFormat(shortName string) *AVInputFormat

+ func AvIformatNext(f *AVInputFormat) *AVInputFormat

+ func AvInputAudioDeviceNext(d *AVInputFormat) *AVInputFormat

+ func AvInputVideoDeviceNext(d *AVInputFormat) *AVInputFormat

+ func AvProbeInputFormat(pd *AVProbeData, isOpened int32) *AVInputFormat

+ func AvProbeInputFormat2(pd *AVProbeData, isOpened int32, scoreMax *int32) *AVInputFormat

+ func AvProbeInputFormat3(pd *AVProbeData, isOpened int32, scoreRet *int32) *AVInputFormat

+ func (ifmt *AVInputFormat) GetExtensions() string

+ func (ifmt *AVInputFormat) GetFlags() int32

+ func (ifmt *AVInputFormat) GetFlagsAddr() *int32

+ func (ifmt *AVInputFormat) GetLongName() string

+ func (ifmt *AVInputFormat) GetMimeType() string

+ func (ifmt *AVInputFormat) GetName() string

+ func (ifmt *AVInputFormat) GetPrivClass() *AVClass

+ func (ifmt *AVInputFormat) GetPrivClassAddr() **AVClass

+ func (ifmt *AVInputFormat) SetFlags(v int32)

+ func (ifmt *AVInputFormat) SetPrivClass(v *AVClass)

+ type AVLFG C.struct_AVLFG

+ type AVLockOp = C.enum_AVLockOp

+ type AVLockmgrCb C.av_lockmgr_cb

+ type AVLogCallbackFunc = C.av_log_callback_func

+ type AVMD5 C.struct_AVMD5

+ func AvMd5Alloc() *AVMD5

+ type AVMasteringDisplayMetadata C.struct_AVMasteringDisplayMetadata

+ func AvMasteringDisplayMetadataAlloc() *AVMasteringDisplayMetadata

+ func AvMasteringDisplayMetadataCreateSideData(frame *AVFrame) *AVMasteringDisplayMetadata

+ func (mdm *AVMasteringDisplayMetadata) GetDisplayPrimaries() (v [][]AVRational)

+ func (mdm *AVMasteringDisplayMetadata) GetDisplayPrimariesAddr() **AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetHasLuminance() int32

+ func (mdm *AVMasteringDisplayMetadata) GetHasLuminanceAddr() *int32

+ func (mdm *AVMasteringDisplayMetadata) GetHasPrimaries() int32

+ func (mdm *AVMasteringDisplayMetadata) GetHasPrimariesAddr() *int32

+ func (mdm *AVMasteringDisplayMetadata) GetMaxLuminance() AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetMaxLuminanceAddr() *AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetMinLuminance() AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetMinLuminanceAddr() *AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetWhitePoint() []AVRational

+ func (mdm *AVMasteringDisplayMetadata) GetWhitePointAddr() **AVRational

+ func (mdm *AVMasteringDisplayMetadata) SetDisplayPrimaries(v [][]AVRational)

+ func (mdm *AVMasteringDisplayMetadata) SetHasLuminance(v int32)

+ func (mdm *AVMasteringDisplayMetadata) SetHasPrimaries(v int32)

+ func (mdm *AVMasteringDisplayMetadata) SetMaxLuminance(v AVRational)

+ func (mdm *AVMasteringDisplayMetadata) SetMinLuminance(v AVRational)

+ func (mdm *AVMasteringDisplayMetadata) SetWhitePoint(v []AVRational)

+ type AVMatrixEncoding = C.enum_AVMatrixEncoding

+ type AVMediaType = C.enum_AVMediaType

+ func AvBuffersinkGetType(ctx *AVFilterContext) AVMediaType

+ func AvCodecGetType(codecID AVCodecID) AVMediaType

+ func AvFilterPadGetType(pads *AVFilterPad, padIdx int32) AVMediaType

+ type AVMotionVector C.struct_AVMotionVector

+ func (mv *AVMotionVector) GetDstX() int16

+ func (mv *AVMotionVector) GetDstXAddr() *int16

+ func (mv *AVMotionVector) GetDstY() int16

+ func (mv *AVMotionVector) GetDstYAddr() *int16

+ func (mv *AVMotionVector) GetFlags() uint64

+ func (mv *AVMotionVector) GetFlagsAddr() *uint64

+ func (mv *AVMotionVector) GetH() uint8

+ func (mv *AVMotionVector) GetHAddr() *uint8

+ func (mv *AVMotionVector) GetMotionScale() uint16

+ func (mv *AVMotionVector) GetMotionScaleAddr() *uint16

+ func (mv *AVMotionVector) GetMotionX() int32

+ func (mv *AVMotionVector) GetMotionXAddr() *int32

+ func (mv *AVMotionVector) GetMotionY() int32

+ func (mv *AVMotionVector) GetMotionYAddr() *int32

+ func (mv *AVMotionVector) GetSource() int32

+ func (mv *AVMotionVector) GetSourceAddr() *int32

+ func (mv *AVMotionVector) GetSrcX() int16

+ func (mv *AVMotionVector) GetSrcXAddr() *int16

+ func (mv *AVMotionVector) GetSrcY() int16

+ func (mv *AVMotionVector) GetSrcYAddr() *int16

+ func (mv *AVMotionVector) GetW() uint8

+ func (mv *AVMotionVector) GetWAddr() *uint8

+ func (mv *AVMotionVector) SetDstX(v int16)

+ func (mv *AVMotionVector) SetDstY(v int16)

+ func (mv *AVMotionVector) SetFlags(v uint64)

+ func (mv *AVMotionVector) SetH(v uint8)

+ func (mv *AVMotionVector) SetMotionScale(v uint16)

+ func (mv *AVMotionVector) SetMotionX(v int32)

+ func (mv *AVMotionVector) SetMotionY(v int32)

+ func (mv *AVMotionVector) SetSource(v int32)

+ func (mv *AVMotionVector) SetSrcX(v int16)

+ func (mv *AVMotionVector) SetSrcY(v int16)

+ func (mv *AVMotionVector) SetW(v uint8)

+ type AVMurMur3 C.struct_AVMurMur3

+ func AvMurmur3Alloc() *AVMurMur3

+ type AVOpenCallbackFunc C.AVOpenCallback

+ func AvFormatGetOpenCb(s *AVFormatContext) AVOpenCallbackFunc

+ type AVOption C.struct_AVOption

+ func AvOptFind(obj CVoidPointer, name, unit string, optFlags, searchFlags int32) *AVOption

+ func AvOptFind2(obj CVoidPointer, name, unit string, optFlags, searchFlags int32, ...) *AVOption

+ func AvOptNext(obj CVoidPointer, prev *AVOption) *AVOption

+ func (opt *AVOption) GetDefaultValDbl() float64

+ func (opt *AVOption) GetDefaultValDblAddr() *float64

+ func (opt *AVOption) GetDefaultValI64() int64

+ func (opt *AVOption) GetDefaultValI64Addr() *int64

+ func (opt *AVOption) GetDefaultValQ() AVRational

+ func (opt *AVOption) GetDefaultValQAddr() *AVRational

+ func (opt *AVOption) GetDefaultValStr() string

+ func (opt *AVOption) GetDefaultValStrAddr() **int8

+ func (opt *AVOption) GetFlags() int32

+ func (opt *AVOption) GetFlagsAddr() *int32

+ func (opt *AVOption) GetHelp() string

+ func (opt *AVOption) GetMax() float64

+ func (opt *AVOption) GetMaxAddr() *float64

+ func (opt *AVOption) GetMin() float64

+ func (opt *AVOption) GetMinAddr() *float64

+ func (opt *AVOption) GetName() string

+ func (opt *AVOption) GetOffset() int32

+ func (opt *AVOption) GetOffsetAddr() *int32

+ func (opt *AVOption) GetType() AVOptionType

+ func (opt *AVOption) GetTypeAddr() *AVOptionType

+ func (opt *AVOption) GetUnit() string

+ func (opt *AVOption) SetDefaultValDbl(v float64)

+ func (opt *AVOption) SetDefaultValI64(v int64)

+ func (opt *AVOption) SetDefaultValQ(v AVRational)

+ func (opt *AVOption) SetDefaultValStr(v *int8)

+ func (opt *AVOption) SetFlags(v int32)

+ func (opt *AVOption) SetMax(v float64)

+ func (opt *AVOption) SetMin(v float64)

+ func (opt *AVOption) SetOffset(v int32)

+ func (opt *AVOption) SetType(v AVOptionType)

+ type AVOptionRange C.struct_AVOptionRange

+ func (optr *AVOptionRange) GetComponentMax() float64

+ func (optr *AVOptionRange) GetComponentMaxAddr() *float64

+ func (optr *AVOptionRange) GetComponentMin() float64

+ func (optr *AVOptionRange) GetComponentMinAddr() *float64

+ func (optr *AVOptionRange) GetIsRange() int32

+ func (optr *AVOptionRange) GetIsRangeAddr() *int32

+ func (optr *AVOptionRange) GetStr() string

+ func (optr *AVOptionRange) GetValueMax() float64

+ func (optr *AVOptionRange) GetValueMaxAddr() *float64

+ func (optr *AVOptionRange) GetValueMin() float64

+ func (optr *AVOptionRange) GetValueMinAddr() *float64

+ func (optr *AVOptionRange) SetComponentMax(v float64)

+ func (optr *AVOptionRange) SetComponentMin(v float64)

+ func (optr *AVOptionRange) SetIsRange(v int32)

+ func (optr *AVOptionRange) SetValueMax(v float64)

+ func (optr *AVOptionRange) SetValueMin(v float64)

+ type AVOptionRanges C.struct_AVOptionRanges

+ func (optrs *AVOptionRanges) GetNbComponents() int32

+ func (optrs *AVOptionRanges) GetNbRanges() int32

+ func (optrs *AVOptionRanges) GetRange() []*AVOptionRange

+ type AVOptionType = int32

+ type AVOutputFormat C.struct_AVOutputFormat

+ func AvGuessFormat(shortName, filename, mimeType string) *AVOutputFormat

+ func AvMuxerIterate(opaque CVoidPointerPointer) *AVOutputFormat

+ func AvOformatNext(f *AVOutputFormat) *AVOutputFormat

+ func AvOutputAudioDeviceNext(d *AVOutputFormat) *AVOutputFormat

+ func AvOutputVideoDeviceNext(d *AVOutputFormat) *AVOutputFormat

+ func (ofmt *AVOutputFormat) GetAudioCodec() AVCodecID

+ func (ofmt *AVOutputFormat) GetAudioCodecAddr() *AVCodecID

+ func (ofmt *AVOutputFormat) GetExtensions() string

+ func (ofmt *AVOutputFormat) GetFlags() int32

+ func (ofmt *AVOutputFormat) GetFlagsAddr() *int32

+ func (ofmt *AVOutputFormat) GetLongName() string

+ func (ofmt *AVOutputFormat) GetMimeType() string

+ func (ofmt *AVOutputFormat) GetName() string

+ func (ofmt *AVOutputFormat) GetPrivClass() *AVClass

+ func (ofmt *AVOutputFormat) GetPrivClassAddr() **AVClass

+ func (ofmt *AVOutputFormat) GetSubtitleCodec() AVCodecID

+ func (ofmt *AVOutputFormat) GetSubtitleCodecAddr() *AVCodecID

+ func (ofmt *AVOutputFormat) GetVideoCodec() AVCodecID

+ func (ofmt *AVOutputFormat) GetVideoCodecAddr() *AVCodecID

+ func (ofmt *AVOutputFormat) SetAudioCodec(v AVCodecID)

+ func (ofmt *AVOutputFormat) SetFlags(v int32)

+ func (ofmt *AVOutputFormat) SetPrivClass(v *AVClass)

+ func (ofmt *AVOutputFormat) SetSubtitleCodec(v AVCodecID)

+ func (ofmt *AVOutputFormat) SetVideoCodec(v AVCodecID)

+ type AVPacket C.struct_AVPacket

+ func AvPacketAlloc() *AVPacket

+ func AvPacketClone(pkt *AVPacket) *AVPacket

+ func (pkt *AVPacket) GetBuf() *AVBufferRef

+ func (pkt *AVPacket) GetBufAddr() **AVBufferRef

+ func (pkt *AVPacket) GetConvergenceDuration() int64

+ func (pkt *AVPacket) GetConvergenceDurationAddr() *int64

+ func (pkt *AVPacket) GetData() *uint8

+ func (pkt *AVPacket) GetDataAddr() **uint8

+ func (pkt *AVPacket) GetDts() int64

+ func (pkt *AVPacket) GetDtsAddr() *int64

+ func (pkt *AVPacket) GetDuration() int64

+ func (pkt *AVPacket) GetDurationAddr() *int64

+ func (pkt *AVPacket) GetFlags() int32

+ func (pkt *AVPacket) GetFlagsAddr() *int32

+ func (pkt *AVPacket) GetPos() int64

+ func (pkt *AVPacket) GetPosAddr() *int64

+ func (pkt *AVPacket) GetPts() int64

+ func (pkt *AVPacket) GetPtsAddr() *int64

+ func (pkt *AVPacket) GetSideData() *AVPacketSideData

+ func (pkt *AVPacket) GetSideDataAddr() **AVPacketSideData

+ func (pkt *AVPacket) GetSideDataElems() int32

+ func (pkt *AVPacket) GetSideDataElemsAddr() *int32

+ func (pkt *AVPacket) GetSize() int32

+ func (pkt *AVPacket) GetSizeAddr() *int32

+ func (pkt *AVPacket) GetStreamIndex() int32

+ func (pkt *AVPacket) GetStreamIndexAddr() *int32

+ func (pkt *AVPacket) SetBuf(v *AVBufferRef)

+ func (pkt *AVPacket) SetConvergenceDuration(v int64)

+ func (pkt *AVPacket) SetData(v *uint8)

+ func (pkt *AVPacket) SetDts(v int64)

+ func (pkt *AVPacket) SetDuration(v int64)

+ func (pkt *AVPacket) SetFlags(v int32)

+ func (pkt *AVPacket) SetPos(v int64)

+ func (pkt *AVPacket) SetPts(v int64)

+ func (pkt *AVPacket) SetSideData(v *AVPacketSideData)

+ func (pkt *AVPacket) SetSideDataElems(v int32)

+ func (pkt *AVPacket) SetSize(v int32)

+ func (pkt *AVPacket) SetStreamIndex(v int32)

+ type AVPacketList C.struct_AVPacketList

+ func (pl *AVPacketList) Get() *AVPacketList

+ func (pl *AVPacketList) GetAddr() **AVPacketList

+ func (pl *AVPacketList) Set(v *AVPacketList)

+ type AVPacketSideData C.struct_AVPacketSideData

+ func (psd *AVPacketSideData) GetData() *uint8

+ func (psd *AVPacketSideData) GetDataAddr() **uint8

+ func (psd *AVPacketSideData) GetSize() int32

+ func (psd *AVPacketSideData) GetSizeAddr() *int32

+ func (psd *AVPacketSideData) GetType() AVPacketSideDataType

+ func (psd *AVPacketSideData) GetTypeAddr() *AVPacketSideDataType

+ func (psd *AVPacketSideData) SetData(v *uint8)

+ func (psd *AVPacketSideData) SetSize(v int32)

+ func (psd *AVPacketSideData) SetType(v AVPacketSideDataType)

+ type AVPacketSideDataType = C.enum_AVPacketSideDataType

+ type AVPanScan C.struct_AVPanScan

+ func (psn *AVPanScan) GetHeight() int32

+ func (psn *AVPanScan) GetHeightAddr() *int32

+ func (psn *AVPanScan) GetId() int32

+ func (psn *AVPanScan) GetIdAddr() *int32

+ func (psn *AVPanScan) GetPosition() (v [][]int16)

+ func (psn *AVPanScan) GetPositionAddr() **int16

+ func (psn *AVPanScan) GetWidth() int32

+ func (psn *AVPanScan) GetWidthAddr() *int32

+ func (psn *AVPanScan) SetHeight(v int32)

+ func (psn *AVPanScan) SetId(v int32)

+ func (psn *AVPanScan) SetPosition(v [][]int16)

+ func (psn *AVPanScan) SetWidth(v int32)

+ type AVPicture C.struct_AVPicture

+ func (pct *AVPicture) GetData() []*uint8

+ func (pct *AVPicture) GetDataAddr() ***uint8

+ func (pct *AVPicture) GetLinesize() []int32

+ func (pct *AVPicture) GetLinesizeAddr() **int32

+ func (pct *AVPicture) SetData(v []*uint8)

+ func (pct *AVPicture) SetLinesize(v []int32)

+ type AVPictureStructure = C.enum_AVPictureStructure

+ type AVPictureType = C.enum_AVPictureType

+ type AVPixFmtDescriptor C.struct_AVPixFmtDescriptor

+ func AvPixFmtDescGet(pixFmt AVPixelFormat) *AVPixFmtDescriptor

+ func AvPixFmtDescNext(prev *AVPixFmtDescriptor) *AVPixFmtDescriptor

+ func (pfd *AVPixFmtDescriptor) GetAlias() string

+ func (pfd *AVPixFmtDescriptor) GetComp() []AVComponentDescriptor

+ func (pfd *AVPixFmtDescriptor) GetCompAddr() **AVComponentDescriptor

+ func (pfd *AVPixFmtDescriptor) GetFlags() uint64

+ func (pfd *AVPixFmtDescriptor) GetFlagsAddr() *uint64

+ func (pfd *AVPixFmtDescriptor) GetLog2ChromaH() uint8

+ func (pfd *AVPixFmtDescriptor) GetLog2ChromaHAddr() *uint8

+ func (pfd *AVPixFmtDescriptor) GetLog2ChromaW() uint8

+ func (pfd *AVPixFmtDescriptor) GetLog2ChromaWAddr() *uint8

+ func (pfd *AVPixFmtDescriptor) GetName() string

+ func (pfd *AVPixFmtDescriptor) GetNbComponents() uint8

+ func (pfd *AVPixFmtDescriptor) GetNbComponentsAddr() *uint8

+ func (pfd *AVPixFmtDescriptor) SetComp(v []AVComponentDescriptor)

+ func (pfd *AVPixFmtDescriptor) SetFlags(v uint64)

+ func (pfd *AVPixFmtDescriptor) SetLog2ChromaH(v uint8)

+ func (pfd *AVPixFmtDescriptor) SetLog2ChromaW(v uint8)

+ func (pfd *AVPixFmtDescriptor) SetNbComponents(v uint8)

+ type AVPixelFormat = C.enum_AVPixelFormat

+ func AvCodecDefaultGetFormat(avctx *AVCodecContext, fmt *AVPixelFormat) AVPixelFormat

+ func AvCodecFindBestPixFmt2(dstPixFmt1, dstPixFmt2, srcPixFmt AVPixelFormat, hasAlpha int32, ...) AVPixelFormat

+ func AvCodecFindBestPixFmtOf2(dstPixFmt1, dstPixFmt2, srcPixFmt AVPixelFormat, hasAlpha int32, ...) AVPixelFormat

+ func AvCodecFindBestPixFmtOfList(pixFmtList *AVPixelFormat, srcPixFmt AVPixelFormat, hasAlpha int32, ...) AVPixelFormat

+ func AvFindBestPixFmtOf2(dstPixFmt1, dstPixFmt2, srcPixFmt AVPixelFormat, hasAlpha int32, ...) AVPixelFormat

+ func AvGetPixFmt(name string) AVPixelFormat

+ func AvPixFmtDescGetId(desc *AVPixFmtDescriptor) AVPixelFormat

+ func AvPixFmtSwapEndianness(pixFmt AVPixelFormat) AVPixelFormat

+ type AVPixelutilsSadFn C.av_pixelutils_sad_fn

+ func AvPixelutilsGetSadFn(wBits, hBits, aligned int32, logCtx CVoidPointer) AVPixelutilsSadFn

+ type AVProbeData C.struct_AVProbeData

+ func (pd *AVProbeData) GetBuf() *uint8

+ func (pd *AVProbeData) GetBufAddr() **uint8

+ func (pd *AVProbeData) GetBufSize() int32

+ func (pd *AVProbeData) GetBufSizeAddr() *int32

+ func (pd *AVProbeData) GetFilename() string

+ func (pd *AVProbeData) GetMimeType() string

+ func (pd *AVProbeData) SetBuf(v *uint8)

+ func (pd *AVProbeData) SetBufSize(v int32)

+ type AVProducerReferenceTime C.struct_AVProducerReferenceTime

+ type AVProfile C.struct_AVProfile

+ func (p *AVProfile) GetName() string

+ func (p *AVProfile) GetProfile() int32

+ type AVProgram C.struct_AVProgram

+ func AvFindProgramFromStream(ic *AVFormatContext, last *AVProgram, s int32) *AVProgram

+ func AvNewProgram(s *AVFormatContext, id int32) *AVProgram

+ func (pgm *AVProgram) GetDiscard() AVDiscard

+ func (pgm *AVProgram) GetDiscardAddr() *AVDiscard

+ func (pgm *AVProgram) GetFlags() int32

+ func (pgm *AVProgram) GetFlagsAddr() *int32

+ func (pgm *AVProgram) GetId() int32

+ func (pgm *AVProgram) GetIdAddr() *int32

+ func (pgm *AVProgram) GetMetadata() *AVDictionary

+ func (pgm *AVProgram) GetMetadataAddr() **AVDictionary

+ func (pgm *AVProgram) GetNbStreamIndexes() uint32

+ func (pgm *AVProgram) GetNbStreamIndexesAddr() *uint32

+ func (pgm *AVProgram) GetPcrPid() int32

+ func (pgm *AVProgram) GetPcrPidAddr() *int32

+ func (pgm *AVProgram) GetPmtPid() int32

+ func (pgm *AVProgram) GetPmtPidAddr() *int32

+ func (pgm *AVProgram) GetProgramNum() int32

+ func (pgm *AVProgram) GetProgramNumAddr() *int32

+ func (pgm *AVProgram) GetStreamIndex() (v []uint32)

+ func (pgm *AVProgram) GetStreamIndexAddr() **uint32

+ func (pgm *AVProgram) SetDiscard(v AVDiscard)

+ func (pgm *AVProgram) SetFlags(v int32)

+ func (pgm *AVProgram) SetId(v int32)

+ func (pgm *AVProgram) SetMetadata(v *AVDictionary)

+ func (pgm *AVProgram) SetNbStreamIndexes(v uint32)

+ func (pgm *AVProgram) SetPcrPid(v int32)

+ func (pgm *AVProgram) SetPmtPid(v int32)

+ func (pgm *AVProgram) SetProgramNum(v int32)

+ func (pgm *AVProgram) SetStreamIndex(v *uint32)

+ type AVRC4 C.struct_AVRC4

+ func AvRc4Alloc() *AVRC4

+ type AVRIPEMD C.struct_AVRIPEMD

+ func AvRipemdAlloc() *AVRIPEMD

+ type AVRational C.struct_AVRational

+ func AvAddQ(a, b AVRational) AVRational

+ func AvBuffersinkGetFrameRate(ctx *AVFilterContext) AVRational

+ func AvBuffersinkGetSampleAspectRatio(ctx *AVFilterContext) AVRational

+ func AvBuffersinkGetTimeBase(ctx *AVFilterContext) AVRational

+ func AvCodecGetPktTimebase(avctx *AVCodecContext) AVRational

+ func AvD2Q(d float64, max int32) AVRational

+ func AvDivQ(a, b AVRational) AVRational

+ func AvGetTimeBaseQ() AVRational

+ func AvGuessFrameRate(ctx *AVFormatContext, stream *AVStream, frame *AVFrame) AVRational

+ func AvGuessSampleAspectRatio(format *AVFormatContext, stream *AVStream, frame *AVFrame) AVRational

+ func AvInvQ(q AVRational) AVRational

+ func AvMakeQ(num, den int32) AVRational

+ func AvMulQ(a, b AVRational) AVRational

+ func AvStreamGetCodecTimebase(st *AVStream) AVRational

+ func AvStreamGetRFrameRate(s *AVStream) AVRational

+ func AvSubQ(a, b AVRational) AVRational

+ func (q *AVRational) GetDen() int32

+ func (q *AVRational) GetNum() int32

+ type AVRegionOfInterest C.struct_AVRegionOfInterest

+ type AVReplayGain C.struct_AVReplayGain

+ func (rg *AVReplayGain) GetAlbumGain() int32

+ func (rg *AVReplayGain) GetAlbumGainAddr() *int32

+ func (rg *AVReplayGain) GetAlbumPeak() uint32

+ func (rg *AVReplayGain) GetAlbumPeakAddr() *uint32

+ func (rg *AVReplayGain) GetTrackGain() int32

+ func (rg *AVReplayGain) GetTrackGainAddr() *int32

+ func (rg *AVReplayGain) GetTrackPeak() uint32

+ func (rg *AVReplayGain) GetTrackPeakAddr() *uint32

+ func (rg *AVReplayGain) SetAlbumGain(v int32)

+ func (rg *AVReplayGain) SetAlbumPeak(v uint32)

+ func (rg *AVReplayGain) SetTrackGain(v int32)

+ func (rg *AVReplayGain) SetTrackPeak(v uint32)

+ type AVRounding = C.enum_AVRounding

+ type AVSHA C.struct_AVSHA

+ func AvShaAlloc() *AVSHA

+ type AVSHA512 C.struct_AVSHA512

+ func AvSha512Alloc() *AVSHA512

+ type AVSampleFormat = C.enum_AVSampleFormat

+ func AvGetAltSampleFmt(sampleFmt AVSampleFormat, planar int32) AVSampleFormat

+ func AvGetPackedSampleFmt(sampleFmt AVSampleFormat) AVSampleFormat

+ func AvGetPlanarSampleFmt(sampleFmt AVSampleFormat) AVSampleFormat

+ func AvGetSampleFmt(name string) AVSampleFormat

+ type AVSideDataParamChangeFlags = C.enum_AVSideDataParamChangeFlags

+ type AVSphericalMapping C.struct_AVSphericalMapping

+ func AvSphericalAlloc(size *uintptr) *AVSphericalMapping

+ func (smp *AVSphericalMapping) GetBoundBottom() uint32

+ func (smp *AVSphericalMapping) GetBoundBottomAddr() *uint32

+ func (smp *AVSphericalMapping) GetBoundLeft() uint32

+ func (smp *AVSphericalMapping) GetBoundLeftAddr() *uint32

+ func (smp *AVSphericalMapping) GetBoundRight() uint32

+ func (smp *AVSphericalMapping) GetBoundRightAddr() *uint32

+ func (smp *AVSphericalMapping) GetBoundTop() uint32

+ func (smp *AVSphericalMapping) GetBoundTopAddr() *uint32

+ func (smp *AVSphericalMapping) GetPadding() uint32

+ func (smp *AVSphericalMapping) GetPaddingAddr() *uint32

+ func (smp *AVSphericalMapping) GetPitch() int32

+ func (smp *AVSphericalMapping) GetPitchAddr() *int32

+ func (smp *AVSphericalMapping) GetProjection() AVSphericalProjection

+ func (smp *AVSphericalMapping) GetProjectionAddr() *AVSphericalProjection

+ func (smp *AVSphericalMapping) GetRoll() int32

+ func (smp *AVSphericalMapping) GetRollAddr() *int32

+ func (smp *AVSphericalMapping) GetYaw() int32

+ func (smp *AVSphericalMapping) GetYawAddr() *int32

+ func (smp *AVSphericalMapping) SetBoundBottom(v uint32)

+ func (smp *AVSphericalMapping) SetBoundLeft(v uint32)

+ func (smp *AVSphericalMapping) SetBoundRight(v uint32)

+ func (smp *AVSphericalMapping) SetBoundTop(v uint32)

+ func (smp *AVSphericalMapping) SetPadding(v uint32)

+ func (smp *AVSphericalMapping) SetPitch(v int32)

+ func (smp *AVSphericalMapping) SetProjection(v AVSphericalProjection)

+ func (smp *AVSphericalMapping) SetRoll(v int32)

+ func (smp *AVSphericalMapping) SetYaw(v int32)

+ type AVSphericalProjection = C.enum_AVSphericalProjection

+ type AVStereo3D C.struct_AVStereo3D

+ func AvStereo3dAlloc() *AVStereo3D

+ func AvStereo3dCreateSideData(frame *AVFrame) *AVStereo3D

+ func (s3d *AVStereo3D) GetFlags() int32

+ func (s3d *AVStereo3D) GetFlagsAddr() *int32

+ func (s3d *AVStereo3D) GetType() AVStereo3DType

+ func (s3d *AVStereo3D) GetTypeAddr() *AVStereo3DType

+ func (s3d *AVStereo3D) GetView() AVStereo3DView

+ func (s3d *AVStereo3D) GetViewAddr() *AVStereo3DView

+ func (s3d *AVStereo3D) SetFlags(v int32)

+ func (s3d *AVStereo3D) SetType(v AVStereo3DType)

+ func (s3d *AVStereo3D) SetView(v AVStereo3DView)

+ type AVStereo3DType = C.enum_AVStereo3DType

+ type AVStereo3DView = C.enum_AVStereo3DView

+ type AVStream C.struct_AVStream

+ func AvFormatNewStream(s *AVFormatContext, c *AVCodec) *AVStream

+ func (stm *AVStream) GetAttachedPic() AVPacket

+ func (stm *AVStream) GetAttachedPicAddr() *AVPacket

+ func (stm *AVStream) GetAvgFrameRate() AVRational

+ func (stm *AVStream) GetAvgFrameRateAddr() *AVRational

+ func (stm *AVStream) GetCodec() *AVCodecContext

+ func (stm *AVStream) GetCodecAddr() **AVCodecContext

+ func (stm *AVStream) GetCodecpar() *AVCodecParameters

+ func (stm *AVStream) GetCodecparAddr() **AVCodecParameters

+ func (stm *AVStream) GetDiscard() AVDiscard

+ func (stm *AVStream) GetDiscardAddr() *AVDiscard

+ func (stm *AVStream) GetDisposition() int32

+ func (stm *AVStream) GetDispositionAddr() *int32

+ func (stm *AVStream) GetDuration() int64

+ func (stm *AVStream) GetDurationAddr() *int64

+ func (stm *AVStream) GetEventFlags() int32

+ func (stm *AVStream) GetEventFlagsAddr() *int32

+ func (stm *AVStream) GetId() int32

+ func (stm *AVStream) GetIdAddr() *int32

+ func (stm *AVStream) GetIndex() int32

+ func (stm *AVStream) GetIndexAddr() *int32

+ func (stm *AVStream) GetMetadata() *AVDictionary

+ func (stm *AVStream) GetMetadataAddr() **AVDictionary

+ func (stm *AVStream) GetNbFrames() int64

+ func (stm *AVStream) GetNbFramesAddr() *int64

+ func (stm *AVStream) GetNbSideData() int32

+ func (stm *AVStream) GetNbSideDataAddr() *int32

+ func (stm *AVStream) GetPrivData() unsafe.Pointer

+ func (stm *AVStream) GetPrivDataAddr() unsafe.Pointer

+ func (stm *AVStream) GetRFrameRate() AVRational

+ func (stm *AVStream) GetRFrameRateAddr() *AVRational

+ func (stm *AVStream) GetRecommendedEncoderConfiguration() string

+ func (stm *AVStream) GetSampleAspectRatio() AVRational

+ func (stm *AVStream) GetSampleAspectRatioAddr() *AVRational

+ func (stm *AVStream) GetSideData() *AVPacketSideData

+ func (stm *AVStream) GetSideDataAddr() **AVPacketSideData

+ func (stm *AVStream) GetStartTime() int64

+ func (stm *AVStream) GetStartTimeAddr() *int64

+ func (stm *AVStream) GetTimeBase() AVRational

+ func (stm *AVStream) GetTimeBaseAddr() *AVRational

+ func (stm *AVStream) SetAttachedPic(v AVPacket)

+ func (stm *AVStream) SetAvgFrameRate(v AVRational)

+ func (stm *AVStream) SetCodec(v *AVCodecContext)

+ func (stm *AVStream) SetCodecpar(v *AVCodecParameters)

+ func (stm *AVStream) SetDiscard(v AVDiscard)

+ func (stm *AVStream) SetDisposition(v int32)

+ func (stm *AVStream) SetDuration(v int64)

+ func (stm *AVStream) SetEventFlags(v int32)

+ func (stm *AVStream) SetId(v int32)

+ func (stm *AVStream) SetIndex(v int32)

+ func (stm *AVStream) SetMetadata(v *AVDictionary)

+ func (stm *AVStream) SetNbFrames(v int64)

+ func (stm *AVStream) SetNbSideData(v int32)

+ func (stm *AVStream) SetPrivData(v CVoidPointer)

+ func (stm *AVStream) SetRFrameRate(v AVRational)

+ func (stm *AVStream) SetSampleAspectRatio(v AVRational)

+ func (stm *AVStream) SetSideData(v *AVPacketSideData)

+ func (stm *AVStream) SetStartTime(v int64)

+ func (stm *AVStream) SetTimeBase(v AVRational)

+ type AVStreamInternal C.struct_AVStreamInternal

+ type AVStreamParseType = C.enum_AVStreamParseType

+ type AVSubsampleEncryptionInfo C.struct_AVSubsampleEncryptionInfo

+ func (sei *AVSubsampleEncryptionInfo) GetBytesOfClearData() uint32

+ func (sei *AVSubsampleEncryptionInfo) GetBytesOfClearDataAddr() *uint32

+ func (sei *AVSubsampleEncryptionInfo) GetBytesOfProtectedData() uint32

+ func (sei *AVSubsampleEncryptionInfo) GetBytesOfProtectedDataAddr() *uint32

+ func (sei *AVSubsampleEncryptionInfo) SetBytesOfClearData(v uint32)

+ func (sei *AVSubsampleEncryptionInfo) SetBytesOfProtectedData(v uint32)

+ type AVSubtitle C.struct_AVSubtitle

+ func (sbt *AVSubtitle) GetEndDisplayTime() uint32

+ func (sbt *AVSubtitle) GetEndDisplayTimeAddr() *uint32

+ func (sbt *AVSubtitle) GetFormat() uint16

+ func (sbt *AVSubtitle) GetFormatAddr() *uint16

+ func (sbt *AVSubtitle) GetNumRects() uint32

+ func (sbt *AVSubtitle) GetNumRectsAddr() *uint32

+ func (sbt *AVSubtitle) GetPts() int64

+ func (sbt *AVSubtitle) GetPtsAddr() *int64

+ func (sbt *AVSubtitle) GetRects() []*AVSubtitleRect

+ func (sbt *AVSubtitle) GetRectsAddr() ***AVSubtitleRect

+ func (sbt *AVSubtitle) GetStartDisplayTime() uint32

+ func (sbt *AVSubtitle) GetStartDisplayTimeAddr() *uint32

+ func (sbt *AVSubtitle) SetEndDisplayTime(v uint32)

+ func (sbt *AVSubtitle) SetFormat(v uint16)

+ func (sbt *AVSubtitle) SetNumRects(v uint32)

+ func (sbt *AVSubtitle) SetPts(v int64)

+ func (sbt *AVSubtitle) SetRects(v **AVSubtitleRect)

+ func (sbt *AVSubtitle) SetStartDisplayTime(v uint32)

+ type AVSubtitleRect C.struct_AVSubtitleRect

+ func (sbtr *AVSubtitleRect) GetAss() string

+ func (sbtr *AVSubtitleRect) GetData() []*uint8

+ func (sbtr *AVSubtitleRect) GetDataAddr() ***uint8

+ func (sbtr *AVSubtitleRect) GetFlags() int32

+ func (sbtr *AVSubtitleRect) GetFlagsAddr() *int32

+ func (sbtr *AVSubtitleRect) GetH() int32

+ func (sbtr *AVSubtitleRect) GetHAddr() *int32

+ func (sbtr *AVSubtitleRect) GetLinesize() []int32

+ func (sbtr *AVSubtitleRect) GetLinesizeAddr() **int32

+ func (sbtr *AVSubtitleRect) GetNbColors() int32

+ func (sbtr *AVSubtitleRect) GetNbColorsAddr() *int32

+ func (sbtr *AVSubtitleRect) GetPict() AVPicture

+ func (sbtr *AVSubtitleRect) GetPictAddr() *AVPicture

+ func (sbtr *AVSubtitleRect) GetText() string

+ func (sbtr *AVSubtitleRect) GetType() AVSubtitleType

+ func (sbtr *AVSubtitleRect) GetTypeAddr() *AVSubtitleType

+ func (sbtr *AVSubtitleRect) GetW() int32

+ func (sbtr *AVSubtitleRect) GetWAddr() *int32

+ func (sbtr *AVSubtitleRect) GetX() int32

+ func (sbtr *AVSubtitleRect) GetXAddr() *int32

+ func (sbtr *AVSubtitleRect) GetY() int32

+ func (sbtr *AVSubtitleRect) GetYAddr() *int32

+ func (sbtr *AVSubtitleRect) SetData(v []*uint8)

+ func (sbtr *AVSubtitleRect) SetFlags(v int32)

+ func (sbtr *AVSubtitleRect) SetH(v int32)

+ func (sbtr *AVSubtitleRect) SetLinesize(v []int32)

+ func (sbtr *AVSubtitleRect) SetNbColors(v int32)

+ func (sbtr *AVSubtitleRect) SetPict(v AVPicture)

+ func (sbtr *AVSubtitleRect) SetType(v AVSubtitleType)

+ func (sbtr *AVSubtitleRect) SetW(v int32)

+ func (sbtr *AVSubtitleRect) SetX(v int32)

+ func (sbtr *AVSubtitleRect) SetY(v int32)

+ type AVSubtitleType = C.enum_AVSubtitleType

+ type AVTEA C.struct_AVTEA

+ func AvTeaAlloc() *AVTEA

+ type AVTWOFISH C.struct_AVTWOFISH

+ func AvTwofishAlloc() *AVTWOFISH

+ type AVThreadMessageFlags = C.enum_AVThreadMessageFlags

+ type AVThreadMessageQueue C.struct_AVThreadMessageQueue

+ type AVTimebaseSource = C.enum_AVTimebaseSource

+ type AVTimecode C.AVTimecode

+ func (tc *AVTimecode) GetFlags() uint32

+ func (tc *AVTimecode) GetFlagsAddr() *uint32

+ func (tc *AVTimecode) GetFps() uint32

+ func (tc *AVTimecode) GetFpsAddr() *uint32

+ func (tc *AVTimecode) GetRate() AVRational

+ func (tc *AVTimecode) GetRateAddr() *AVRational

+ func (tc *AVTimecode) GetStart() int32

+ func (tc *AVTimecode) GetStartAddr() *int32

+ func (tc *AVTimecode) SetFlags(v uint32)

+ func (tc *AVTimecode) SetFps(v uint32)

+ func (tc *AVTimecode) SetRate(v AVRational)

+ func (tc *AVTimecode) SetStart(v int32)

+ type AVTimecodeFlag = C.enum_AVTimecodeFlag

+ type AVTreeNode C.struct_AVTreeNode

+ func AvTreeNodeAlloc() *AVTreeNode

+ type AVVorbisParseContext C.struct_AVVorbisParseContext

+ func AvVorbisParseInit(extradata *uint8, extradataSize int32) *AVVorbisParseContext

+ type AVXTEA C.struct_AVXTEA

+ func AvXteaAlloc() *AVXTEA

+ func (dct *AVXTEA) GetKey() []uint32

+ func (dct *AVXTEA) GetKeyAddr() **uint32

+ func (dct *AVXTEA) SetKey(v []uint32)

+ type AvClassChildClassNextFunc = C.av_class_child_class_next_func

+ type AvClassChildNextFunc = C.av_class_child_next_func

+ type AvClassItemNameFunc = C.av_class_item_name_func

+ type AvCodecContextInternalExecute2Func = C.avcodec_context_internal_execute2_func

+ type AvCodecContextInternalExecuteFunc = C.avcodec_context_internal_execute_func

+ type AvCodecContextRtpCallbackFunc = C.avcodec_context_rtp_callback_func

+ type AvFifoPeekFunc = C.av_fifo_peek_func

+ type AvFifoReadFunc = C.av_fifo_read_func

+ type AvFifoWriteFunc = C.av_fifo_write_func

+ type AvFormatContextIoCloseFunc = C.av_format_context_io_close_func

+ type AvFormatContextIoOpenFunc = C.av_format_context_io_open_func

+ type AvFormatContextOpenCb = C.av_format_context_open_cb

+ type AvThreadMessageFreeFunc = C.av_thread_message_free_func

+ type AvTreeCmpFunc = C.av_tree_cmp_func

+ type AvTreeEnuFunc = C.av_tree_enu_func

+ type AvcodecParserCloseFunc = C.avcodec_parser_close_func

+ type AvcodecParserInitFunc = C.avcodec_parser_init_func

+ type AvcodecParserParseFunc = C.avcodec_parser_parse_func

+ type AvcodecParserSplitFunc = C.avcodec_parser_split_func

+ type CVoidPointer any

+ type CVoidPointerPointer any

+ type DCTContext C.struct_DCTContext

+ func AvDctInit(nbits int32, _type RDFTransformType) *DCTContext

+ type DCTTransformType = C.enum_DCTTransformType

+ type DiracParseCodes = C.enum_DiracParseCodes

+ type DiracVersionInfo C.struct_DiracVersionInfo

+ func (dvi *DiracVersionInfo) GetMajor() int32

+ func (dvi *DiracVersionInfo) GetMajorAddr() *int32

+ func (dvi *DiracVersionInfo) GetMinor() int32

+ func (dvi *DiracVersionInfo) GetMinorAddr() *int32

+ func (dvi *DiracVersionInfo) SetMajor(v int32)

+ func (dvi *DiracVersionInfo) SetMinor(v int32)

+ type FFTComplex C.struct_FFTComplex

+ func (fc *FFTComplex) GetIm() FFTSample

+ func (fc *FFTComplex) GetRe() FFTSample

+ type FFTContext C.struct_FFTContext

+ func AvFftInit(nbits, inverse int32) *FFTContext

+ func AvMdctInit(nbits, inverse int32, scale float64) *FFTContext

+ type FFTSample = C.FFTSample

+ type FILE C.FILE

+ func AvFopenUtf8(path, mode string) *FILE

+ type Integer interface

+ type MpegEncContext C.struct_MpegEncContext

+ type PpContext C.pp_context

+ func PpGetContext(width, height, flags int32) *PpContext

+ type PpMode C.pp_mode

+ func PpGetModeByNameAndQuality(name string, quality int32) *PpMode

+ type RDFTContext C.struct_RDFTContext

+ func AvRdftInit(nbits int32, trans RDFTransformType) *RDFTContext

+ type RDFTransformType = C.enum_RDFTransformType

+ type RcOverride C.struct_RcOverride

+ type SingedInteger interface

+ type SwrContext C.struct_SwrContext

+ func SwrAlloc() *SwrContext

+ func SwrAllocSetOpts(s *SwrContext, outChLayout int64, outSampleFmt AVSampleFormat, ...) *SwrContext

+ type SwrDitherType = C.enum_SwrDitherType

+ type SwrEngine = C.enum_SwrEngine

+ type SwrFilterType = C.enum_SwrFilterType

+ type SwsContext C.struct_SwsContext

+ func SwsAllocContext() *SwsContext

+ func SwsGetCachedContext(context *SwsContext, srcW, srcH int32, srcFormat AVPixelFormat, ...) *SwsContext

+ func SwsGetContext(srcW, srcH int32, srcFormat AVPixelFormat, dstW, dstH int32, ...) *SwsContext

+ type SwsFilter C.struct_SwsFilter

+ func SwsGetDefaultFilter(lumaGBlur, chromaGBlur float32, lumaSharpen, chromaSharpen float32, ...) *SwsFilter

+ func (sf *SwsFilter) GetChrH() *SwsVector

+ func (sf *SwsFilter) GetChrHAddr() **SwsVector

+ func (sf *SwsFilter) GetChrV() *SwsVector

+ func (sf *SwsFilter) GetChrVAddr() **SwsVector

+ func (sf *SwsFilter) GetLumH() *SwsVector

+ func (sf *SwsFilter) GetLumHAddr() **SwsVector

+ func (sf *SwsFilter) GetLumV() *SwsVector

+ func (sf *SwsFilter) GetLumVAddr() **SwsVector

+ func (sf *SwsFilter) SetChrH(v *SwsVector)

+ func (sf *SwsFilter) SetChrV(v *SwsVector)

+ func (sf *SwsFilter) SetLumH(v *SwsVector)

+ func (sf *SwsFilter) SetLumV(v *SwsVector)

+ type SwsVector C.struct_SwsVector

+ func SwsAllocVec(length int32) *SwsVector

+ func SwsCloneVec(a *SwsVector) *SwsVector

+ func SwsGetConstVec(c float64, length int32) *SwsVector

+ func SwsGetGaussianVec(variance, quality float64) *SwsVector

+ func SwsGetIdentityVec() *SwsVector

+ func (sv *SwsVector) GetCoeff() *float64

+ func (sv *SwsVector) GetCoeffAddr() **float64

+ func (sv *SwsVector) GetLength() int32

+ func (sv *SwsVector) GetLengthAddr() *int32

+ func (sv *SwsVector) SetCoeff(v *float64)

+ func (sv *SwsVector) SetLength(v int32)

+ type URLContext C.struct_URLContext

+ type UnsingedInteger interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL