package/ffmpeg-dev-go
1
0
Fork 0
mirror of https://github.com/qrtc/ffmpeg-dev-go.git synced 2025-09-27 04:06:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

2023-10-19 14:31:46 CST W42D4

Browse Source
This commit is contained in:
aggresss
2023-10-19 14:31:46 +08:00
parent 762aa14362
commit 0f95831c39
52 changed files with 9140 additions and 4324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3190
avcodec.go
View File

File diff suppressed because it is too large Load Diff

13
avcodec_avdct.go
View File

@@ -5,19 +5,20 @@ package ffmpeg
*/
import "C"
type AvDCT C.struct_AVDCT
// AVDCT
type AVDCT C.struct_AVDCT
// AvCodecDctAlloc allocates a AVDCT context.
func AvCodecDctAlloc() *AvDCT {
return (*AvDCT)(C.avcodec_dct_alloc())
func AvCodecDctAlloc() *AVDCT {
return (*AVDCT)(C.avcodec_dct_alloc())
}
// AvCodecDctInit
func AvCodecDctInit(dct *AvDCT) int32 {
func AvCodecDctInit(dct *AVDCT) int32 {
return (int32)(C.avcodec_dct_init((*C.struct_AVDCT)(dct)))
}
// AvCodecDctGetClass
func AvCodecDctGetClass() *AvClass {
return (*AvClass)(C.avcodec_dct_get_class())
func AvCodecDctGetClass() *AVClass {
return (*AVClass)(C.avcodec_dct_get_class())
}

39
avcodec_avfft.go
View File

@@ -5,60 +5,64 @@ package ffmpeg
*/
import "C"
type FftSample C.FFTSample
// FFTSample
type FFTSample C.FFTSample
type FftComplex C.struct_FFTComplex
// FFTComplex
type FFTComplex C.struct_FFTComplex
type FftContext C.struct_FFTContext
// FFTContext
type FFTContext C.struct_FFTContext
// AvFftInit sets up a complex FFT.
func AvFftInit(nbits, inverse int32) *FftContext {
return (*FftContext)(C.av_fft_init((C.int)(nbits), (C.int)(inverse)))
func AvFftInit(nbits, inverse int32) *FFTContext {
return (*FFTContext)(C.av_fft_init((C.int)(nbits), (C.int)(inverse)))
}
// AvFftPermute does the permutation needed BEFORE calling FfFftCalc().
func AvFftPermute(s *FftContext, z *FftComplex) {
func AvFftPermute(s *FFTContext, z *FFTComplex) {
C.av_fft_permute((*C.struct_FFTContext)(s), (*C.struct_FFTComplex)(z))
}
// FfFftCalc does a complex FFT with the parameters defined in AvFftInit().
func FfFftCalc(s *FftContext, z *FftComplex) {
func FfFftCalc(s *FFTContext, z *FFTComplex) {
C.av_fft_calc((*C.struct_FFTContext)(s), (*C.struct_FFTComplex)(z))
}
// AvFftEnd
func AvFftEnd(s *FftContext) {
func AvFftEnd(s *FFTContext) {
C.av_fft_end((*C.struct_FFTContext)(s))
}
// AvMdctInit
func AvMdctInit(nbits, inverse int32, scale float64) *FftContext {
return (*FftContext)(C.av_mdct_init((C.int)(nbits), (C.int)(inverse), (C.double)(scale)))
func AvMdctInit(nbits, inverse int32, scale float64) *FFTContext {
return (*FFTContext)(C.av_mdct_init((C.int)(nbits), (C.int)(inverse), (C.double)(scale)))
}
// AvImdctCalc
func AvImdctCalc(s *FftContext, output, input *FftSample) {
func AvImdctCalc(s *FFTContext, output, input *FFTSample) {
C.av_imdct_calc((*C.struct_FFTContext)(s),
(*C.FFTSample)(output), (*C.FFTSample)(input))
}
// AvImdctHalf
func AvImdctHalf(s *FftContext, output, input *FftSample) {
func AvImdctHalf(s *FFTContext, output, input *FFTSample) {
C.av_imdct_half((*C.struct_FFTContext)(s),
(*C.FFTSample)(output), (*C.FFTSample)(input))
}
// AvMdctCalc
func AvMdctCalc(s *FftContext, output, input *FftSample) {
func AvMdctCalc(s *FFTContext, output, input *FFTSample) {
C.av_mdct_calc((*C.struct_FFTContext)(s),
(*C.FFTSample)(output), (*C.FFTSample)(input))
}
// AvMdctEnd
func AvMdctEnd(s *FftContext) {
func AvMdctEnd(s *FFTContext) {
C.av_mdct_end((*C.struct_FFTContext)(s))
}
// RDFTransformType
type RDFTransformType = C.enum_RDFTransformType
const (
@@ -68,6 +72,7 @@ const (
DFT_C2R = RDFTransformType(C.DFT_C2R)
)
// RDFTContext
type RDFTContext C.struct_RDFTContext
// AvRdftInit
@@ -77,7 +82,7 @@ func AvRdftInit(nbits int32, trans RDFTransformType) *RDFTContext {
}
// AvRdftCalc
func AvRdftCalc(r *RDFTContext, data *FftSample) {
func AvRdftCalc(r *RDFTContext, data *FFTSample) {
C.av_rdft_calc((*C.struct_RDFTContext)(r), (*C.FFTSample)(data))
}
@@ -86,8 +91,10 @@ func AvRdftEnd(r *RDFTContext) {
C.av_rdft_end((*C.struct_RDFTContext)(r))
}
// DCTContext
type DCTContext C.struct_DCTContext
// DCTTransformType
type DCTTransformType = C.enum_DCTTransformType
const (
@@ -104,7 +111,7 @@ func AvDctInit(nbits int32, _type RDFTransformType) *DCTContext {
}
// AvDctCalc
func AvDctCalc(d *DCTContext, data *FftSample) {
func AvDctCalc(d *DCTContext, data *FFTSample) {
C.av_dct_calc((*C.struct_DCTContext)(d), (*C.FFTSample)(data))
}

166
avcodec_bsf.go
View File

@@ -6,240 +6,234 @@ package ffmpeg
import "C"
import "unsafe"
// AvBSFInternal
type AvBSFInternal C.struct_AVBSFInternal
// AVBSFInternal
type AVBSFInternal C.struct_AVBSFInternal
// AvBSFContext
type AvBSFContext C.struct_AVBSFContext
// AVBSFContext
type AVBSFContext C.struct_AVBSFContext
// Custom: GetAvClass gets `AVBSFContext.av_class` value.
func (bsfc *AvBSFContext) GetAvClass() *AvClass {
return (*AvClass)(bsfc.av_class)
func (bsfc *AVBSFContext) GetAvClass() *AVClass {
return (*AVClass)(bsfc.av_class)
}
// Custom: SetAvClass sets `AVBSFContext.av_class` value.
func (bsfc *AvBSFContext) SetAvClass(v *AvClass) {
func (bsfc *AVBSFContext) SetAvClass(v *AVClass) {
bsfc.av_class = (*C.struct_AVClass)(v)
}
// Custom: GetAvClassAddr gets `AVBSFContext.av_class` address.
func (bsfc *AvBSFContext) GetAvClassAddr() **AvClass {
return (**AvClass)(unsafe.Pointer(&bsfc.av_class))
func (bsfc *AVBSFContext) GetAvClassAddr() **AVClass {
return (**AVClass)(unsafe.Pointer(&bsfc.av_class))
}
// Custom: GetFilter gets `AVBSFContext.filter` value.
func (bsfc *AvBSFContext) GetFilter() *AvBitStreamFilter {
return (*AvBitStreamFilter)(bsfc.filter)
func (bsfc *AVBSFContext) GetFilter() *AVBitStreamFilter {
return (*AVBitStreamFilter)(bsfc.filter)
}
// Custom: SetFilter sets `AVBSFContext.filter` value.
func (bsfc *AvBSFContext) SetFilter(v *AvBitStreamFilter) {
func (bsfc *AVBSFContext) SetFilter(v *AVBitStreamFilter) {
bsfc.filter = (*C.struct_AVBitStreamFilter)(v)
}
// Custom: GetFilterAddr gets `AVBSFContext.filter` address.
func (bsfc *AvBSFContext) GetFilterAddr() **AvBitStreamFilter {
return (**AvBitStreamFilter)(unsafe.Pointer(&bsfc.filter))
func (bsfc *AVBSFContext) GetFilterAddr() **AVBitStreamFilter {
return (**AVBitStreamFilter)(unsafe.Pointer(&bsfc.filter))
}
// Custom: GetInternal gets `AVBSFContext.internal` value.
func (bsfc *AvBSFContext) GetInternal() *AvBSFInternal {
return (*AvBSFInternal)(bsfc.internal)
func (bsfc *AVBSFContext) GetInternal() *AVBSFInternal {
return (*AVBSFInternal)(bsfc.internal)
}
// Custom: SetInternal sets `AVBSFContext.internal` value.
func (bsfc *AvBSFContext) SetInternal(v *AvBSFInternal) {
func (bsfc *AVBSFContext) SetInternal(v *AVBSFInternal) {
bsfc.internal = (*C.struct_AVBSFInternal)(v)
}
// Custom: GetInternalAddr gets `AVBSFContext.internal` address.
func (bsfc *AvBSFContext) GetInternalAddr() **AvBSFInternal {
return (**AvBSFInternal)(unsafe.Pointer(&bsfc.internal))
func (bsfc *AVBSFContext) GetInternalAddr() **AVBSFInternal {
return (**AVBSFInternal)(unsafe.Pointer(&bsfc.internal))
}
// Custom: GetPrivData gets `AVBSFContext.priv_data` value.
func (bsfc *AvBSFContext) GetPrivData() unsafe.Pointer {
func (bsfc *AVBSFContext) GetPrivData() unsafe.Pointer {
return bsfc.priv_data
}
// Custom: SetPrivData sets `AVBSFContext.priv_data` value.
func (bsfc *AvBSFContext) SetPrivData(v unsafe.Pointer) {
bsfc.priv_data = v
func (bsfc *AVBSFContext) SetPrivData(v CVoidPointer) {
bsfc.priv_data = VoidPointer(v)
}
// Custom: GetPrivDataAddr gets `AVBSFContext.priv_data` address.
func (bsfc *AvBSFContext) GetPrivDataAddr() unsafe.Pointer {
func (bsfc *AVBSFContext) GetPrivDataAddr() unsafe.Pointer {
return (unsafe.Pointer)(&bsfc.priv_data)
}
// Custom: GetParIn gets `AVBSFContext.par_in` value.
func (bsfc *AvBSFContext) GetParIn() *AvCodecParameters {
return (*AvCodecParameters)(bsfc.par_in)
func (bsfc *AVBSFContext) GetParIn() *AVCodecParameters {
return (*AVCodecParameters)(bsfc.par_in)
}
// Custom: SetParIn sets `AVBSFContext.par_in` value.
func (bsfc *AvBSFContext) SetParIn(v *AvCodecParameters) {
func (bsfc *AVBSFContext) SetParIn(v *AVCodecParameters) {
bsfc.par_in = (*C.struct_AVCodecParameters)(v)
}
// Custom: GetParInAddr gets `AVBSFContext.par_in` address.
func (bsfc *AvBSFContext) GetParInAddr() **AvCodecParameters {
return (**AvCodecParameters)(unsafe.Pointer(&bsfc.par_in))
func (bsfc *AVBSFContext) GetParInAddr() **AVCodecParameters {
return (**AVCodecParameters)(unsafe.Pointer(&bsfc.par_in))
}
// Custom: GetParOut gets `AVBSFContext.par_out` value.
func (bsfc *AvBSFContext) GetParOut() *AvCodecParameters {
return (*AvCodecParameters)(bsfc.par_out)
func (bsfc *AVBSFContext) GetParOut() *AVCodecParameters {
return (*AVCodecParameters)(bsfc.par_out)
}
// Custom: SetParOut sets `AVBSFContext.par_out` value.
func (bsfc *AvBSFContext) SetParOut(v *AvCodecParameters) {
func (bsfc *AVBSFContext) SetParOut(v *AVCodecParameters) {
bsfc.par_out = (*C.struct_AVCodecParameters)(v)
}
// Custom: GetParOutAddr gets `AVBSFContext.par_out` address.
func (bsfc *AvBSFContext) GetParOutAddr() **AvCodecParameters {
return (**AvCodecParameters)(unsafe.Pointer(&bsfc.par_out))
func (bsfc *AVBSFContext) GetParOutAddr() **AVCodecParameters {
return (**AVCodecParameters)(unsafe.Pointer(&bsfc.par_out))
}
// Custom: GetTimeBaseIn gets `AVBSFContext.time_base_in` value.
func (bsfc *AvBSFContext) GetTimeBaseIn() AvRational {
return (AvRational)(bsfc.time_base_in)
func (bsfc *AVBSFContext) GetTimeBaseIn() AVRational {
return (AVRational)(bsfc.time_base_in)
}
// Custom: SetTimeBaseIn sets `AVBSFContext.time_base_in` value.
func (bsfc *AvBSFContext) SetTimeBaseIn(v AvRational) {
bsfc.time_base_in = (C.AVRational)(v)
func (bsfc *AVBSFContext) SetTimeBaseIn(v AVRational) {
bsfc.time_base_in = (C.struct_AVRational)(v)
}
// Custom: GetTimeBaseInAddr gets `AVBSFContext.time_base_in` address.
func (bsfc *AvBSFContext) GetTimeBaseInAddr() *AvRational {
return (*AvRational)(&bsfc.time_base_in)
func (bsfc *AVBSFContext) GetTimeBaseInAddr() *AVRational {
return (*AVRational)(&bsfc.time_base_in)
}
// Custom: GetTimeBaseOut gets `AVBSFContext.time_base_out` value.
func (bsfc *AvBSFContext) GetTimeBaseOut() AvRational {
return (AvRational)(bsfc.time_base_out)
func (bsfc *AVBSFContext) GetTimeBaseOut() AVRational {
return (AVRational)(bsfc.time_base_out)
}
// Custom: SetTimeBaseOut sets `AVBSFContext.time_base_out` value.
func (bsfc *AvBSFContext) SetTimeBaseOut(v AvRational) {
bsfc.time_base_out = (C.AVRational)(v)
func (bsfc *AVBSFContext) SetTimeBaseOut(v AVRational) {
bsfc.time_base_out = (C.struct_AVRational)(v)
}
// Custom: GetTimeBaseOutAddr gets `AVBSFContext.time_base_out` address.
func (bsfc *AvBSFContext) GetTimeBaseOutAddr() *AvRational {
return (*AvRational)(&bsfc.time_base_out)
func (bsfc *AVBSFContext) GetTimeBaseOutAddr() *AVRational {
return (*AVRational)(&bsfc.time_base_out)
}
// AvBitStreamFilter
type AvBitStreamFilter C.struct_AVBitStreamFilter
// AVBitStreamFilter
type AVBitStreamFilter C.struct_AVBitStreamFilter
// Custom: GetName gets `AVBitStreamFilter.name` value.
func (bsf *AvBitStreamFilter) GetName() string {
func (bsf *AVBitStreamFilter) GetName() string {
return C.GoString(bsf.name)
}
// Custom: GetCodecIds gets `AVBitStreamFilter.codec_ids` value.
func (bsf *AvBitStreamFilter) GetCodecIds() (v []AvCodecID) {
if bsf.codec_ids == nil {
return v
}
ptr := (*AvCodecID)(bsf.codec_ids)
for *ptr != AV_CODEC_ID_NONE {
v = append(v, *ptr)
ptr = (*AvCodecID)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (bsf *AVBitStreamFilter) GetCodecIds() []AVCodecID {
return TruncSlice((*AVCodecID)(bsf.codec_ids), func(ac AVCodecID) bool {
return ac == AV_CODEC_ID_NONE
})
}
// Custom: GetPrivClass gets `AVBitStreamFilter.priv_class` value.
func (bsf *AvBitStreamFilter) GetPrivClass() *AvClass {
return (*AvClass)(bsf.priv_class)
func (bsf *AVBitStreamFilter) GetPrivClass() *AVClass {
return (*AVClass)(bsf.priv_class)
}
// Custom: SetPrivClass sets `AVBitStreamFilter.priv_class` value.
func (bsf *AvBitStreamFilter) SetPrivClass(v *AvClass) {
func (bsf *AVBitStreamFilter) SetPrivClass(v *AVClass) {
bsf.priv_class = (*C.struct_AVClass)(v)
}
// Custom: GetPrivClassAddr gets `AVBitStreamFilter.priv_class` address.
func (bsf *AvBitStreamFilter) GetPrivClassAddr() **AvClass {
return (**AvClass)(unsafe.Pointer(&bsf.priv_class))
func (bsf *AVBitStreamFilter) GetPrivClassAddr() **AVClass {
return (**AVClass)(unsafe.Pointer(&bsf.priv_class))
}
// AvBsfGetByName returns a bitstream filter with the specified name or NULL if no such
// bitstream filter exists.
func AvBsfGetByName(name string) *AvBitStreamFilter {
func AvBsfGetByName(name string) *AVBitStreamFilter {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (*AvBitStreamFilter)(C.av_bsf_get_by_name((*C.char)(namePtr)))
return (*AVBitStreamFilter)(C.av_bsf_get_by_name((*C.char)(namePtr)))
}
// AvBsfIterate iterates over all registered bitstream filters.
func AvBsfIterate(opaque *unsafe.Pointer) *AvBitStreamFilter {
return (*AvBitStreamFilter)(C.av_bsf_iterate(opaque))
func AvBsfIterate(opaque CVoidPointerPointer) *AVBitStreamFilter {
return (*AVBitStreamFilter)(C.av_bsf_iterate(VoidPointerPointer(opaque)))
}
// AvBsfAlloc allocates a context for a given bitstream filter.
func AvBsfAlloc(filter *AvBitStreamFilter, ctx **AvBSFContext) int32 {
func AvBsfAlloc(filter *AVBitStreamFilter, ctx **AVBSFContext) int32 {
return (int32)(C.av_bsf_alloc((*C.struct_AVBitStreamFilter)(filter),
(**C.struct_AVBSFContext)(unsafe.Pointer(ctx))))
}
// AvBsfInit prepares the filter for use, after all the parameters and options have been set.
func AvBsfInit(ctx *AvBSFContext) int32 {
func AvBsfInit(ctx *AVBSFContext) int32 {
return (int32)(C.av_bsf_init((*C.struct_AVBSFContext)(ctx)))
}
// AvBsfSendPacket submits a packet for filtering.
func AvBsfSendPacket(ctx *AvBSFContext, pkt *AvPacket) int32 {
func AvBsfSendPacket(ctx *AVBSFContext, pkt *AVPacket) int32 {
return (int32)(C.av_bsf_send_packet((*C.struct_AVBSFContext)(ctx),
(*C.struct_AVPacket)(pkt)))
}
// AvBsfReceivePacket retrieves a filtered packet.
func AvBsfReceivePacket(ctx *AvBSFContext, pkt *AvPacket) int32 {
func AvBsfReceivePacket(ctx *AVBSFContext, pkt *AVPacket) int32 {
return (int32)(C.av_bsf_receive_packet((*C.struct_AVBSFContext)(ctx),
(*C.struct_AVPacket)(pkt)))
}
// AvBsfFlush resets the internal bitstream filter state. Should be called e.g. when seeking.
func AvBsfFlush(ctx *AvBSFContext) {
func AvBsfFlush(ctx *AVBSFContext) {
C.av_bsf_flush((*C.struct_AVBSFContext)(ctx))
}
// AvBsfFree frees a bitstream filter context.
func AvBsfFree(ctx **AvBSFContext) {
func AvBsfFree(ctx **AVBSFContext) {
C.av_bsf_free((**C.struct_AVBSFContext)(unsafe.Pointer(ctx)))
}
// AvBsfGetClass gets the AVClass for AVBSFContext.
func AvBsfGetClass() *AvClass {
return (*AvClass)(C.av_bsf_get_class())
func AvBsfGetClass() *AVClass {
return (*AVClass)(C.av_bsf_get_class())
}
type AvBSFList C.struct_AVBSFList
// AVBSFList
type AVBSFList C.struct_AVBSFList
// AvBsfListAlloc allocates empty list of bitstream filters.
func AvBsfListAlloc() *AvBSFList {
return (*AvBSFList)(C.av_bsf_list_alloc())
func AvBsfListAlloc() *AVBSFList {
return (*AVBSFList)(C.av_bsf_list_alloc())
}
// AvBsfListFree frees list of bitstream filters.
func AvBsfListFree(lst **AvBSFList) {
func AvBsfListFree(lst **AVBSFList) {
C.av_bsf_list_free((**C.struct_AVBSFList)(unsafe.Pointer(lst)))
}
// AvBsfListAppend appends bitstream filter to the list of bitstream filters.
func AvBsfListAppend(lst *AvBSFList, bsf *AvBSFContext) {
func AvBsfListAppend(lst *AVBSFList, bsf *AVBSFContext) {
C.av_bsf_list_append((*C.struct_AVBSFList)(lst),
(*C.struct_AVBSFContext)(bsf))
}
// AvBsfListAppend2
func AvBsfListAppend2(lst *AvBSFList, bsfName string, options **AvDictionary) {
func AvBsfListAppend2(lst *AVBSFList, bsfName string, options **AVDictionary) {
bsfNamePtr, bsfNameFunc := StringCasting(bsfName)
defer bsfNameFunc()
C.av_bsf_list_append2((*C.struct_AVBSFList)(lst),
@@ -247,20 +241,20 @@ func AvBsfListAppend2(lst *AvBSFList, bsfName string, options **AvDictionary) {
}
// AvBsfListFinalize finalizes list of bitstream filters.
func AvBsfListFinalize(lst **AvBSFList, bsf **AvBSFContext) int32 {
func AvBsfListFinalize(lst **AVBSFList, bsf **AVBSFContext) int32 {
return (int32)(C.av_bsf_list_finalize((**C.struct_AVBSFList)(unsafe.Pointer(lst)),
(**C.struct_AVBSFContext)(unsafe.Pointer(bsf))))
}
// AvBsfListParseStr parses string describing list of bitstream filters and creates single
// AVBSFContext describing the whole chain of bitstream filters.
func AvBsfListParseStr(str string, bsf **AvBSFContext) {
// AvBSFContext describing the whole chain of bitstream filters.
func AvBsfListParseStr(str string, bsf **AVBSFContext) {
strPtr, strFunc := StringCasting(str)
defer strFunc()
C.av_bsf_list_parse_str((*C.char)(strPtr), (**C.struct_AVBSFContext)(unsafe.Pointer(bsf)))
}
// AvBsfGetNullFilter gets null/pass-through bitstream filter.
func AvBsfGetNullFilter(bsf **AvBSFContext) int32 {
func AvBsfGetNullFilter(bsf **AVBSFContext) int32 {
return (int32)(C.av_bsf_get_null_filter((**C.struct_AVBSFContext)(unsafe.Pointer(bsf))))
}

199
avcodec_codec.go
View File

@@ -4,7 +4,6 @@ package ffmpeg
#include <libavcodec/codec.h>
*/
import "C"
import "unsafe"
const (
AV_CODEC_CAP_DRAW_HORIZ_BAND = C.AV_CODEC_CAP_DRAW_HORIZ_BAND
@@ -30,178 +29,135 @@ const (
AV_CODEC_CAP_ENCODER_FLUSH = C.AV_CODEC_CAP_ENCODER_FLUSH
)
// AvProfile
type AvProfile C.struct_AVProfile
// AVProfile
type AVProfile C.struct_AVProfile
// Custom: GetProfile gets `AVProfile.profile` value.
func (p *AvProfile) GetProfile() int32 {
func (p *AVProfile) GetProfile() int32 {
return (int32)(p.profile)
}
// Custom: GetName gets `AVProfile.name` value.
func (p *AvProfile) GetName() string {
func (p *AVProfile) GetName() string {
return C.GoString(p.name)
}
// AvCodec
type AvCodec C.struct_AVCodec
// AVCodec
type AVCodec C.struct_AVCodec
// Custom: GetName gets `AVCodec.name` value.
func (codec *AvCodec) GetName() string {
func (codec *AVCodec) GetName() string {
return C.GoString(codec.name)
}
// Custom: GetLongName gets `AVCodec.long_name` value.
func (codec *AvCodec) GetLongName() string {
func (codec *AVCodec) GetLongName() string {
return C.GoString(codec.long_name)
}
// Custom: GetType gets `AVCodec.type` value.
func (codec *AvCodec) GetType() AvMediaType {
return (AvMediaType)(codec._type)
func (codec *AVCodec) GetType() AVMediaType {
return (AVMediaType)(codec._type)
}
// Custom: GetType gets `AVCodec.id` value.
func (codec *AvCodec) GetID() AvCodecID {
return (AvCodecID)(codec.id)
func (codec *AVCodec) GetID() AVCodecID {
return (AVCodecID)(codec.id)
}
// Custom: GetCapabilities gets `AVCodec.capabilities` value.
func (codec *AvCodec) GetCapabilities() int32 {
func (codec *AVCodec) GetCapabilities() int32 {
return (int32)(codec.capabilities)
}
// Custom: GetSupportedFramerates gets `AVCodec.supportedFramerates` value.
func (codec *AvCodec) GetSupportedFramerates() (v []AvRational) {
if codec.supported_framerates == nil {
return v
}
zeroQ := AvMakeQ(0, 0)
ptr := (*AvRational)(codec.supported_framerates)
for AvCmpQ(zeroQ, *ptr) != 0 {
v = append(v, *ptr)
ptr = (*AvRational)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetSupportedFramerates() []AVRational {
return TruncSlice((*AVRational)(codec.supported_framerates), func(ar AVRational) bool {
return ar.GetNum() == 0 && ar.GetDen() == 0
})
}
// Custom: GetPixFmts gets `AVCodec.pix_fmts` value.
func (codec *AvCodec) GetPixFmts() (v []AvPixelFormat) {
if codec.pix_fmts == nil {
return v
}
ptr := (*AvPixelFormat)(codec.pix_fmts)
for *ptr != AV_PIX_FMT_NONE {
v = append(v, *ptr)
ptr = (*AvPixelFormat)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetPixFmts() []AVPixelFormat {
return TruncSlice((*AVPixelFormat)(codec.pix_fmts), func(pf AVPixelFormat) bool {
return pf == AV_PIX_FMT_NONE
})
}
// Custom: GetSupportedSamplerates gets `AVCodec.supported_samplerates` value.
func (codec *AvCodec) GetSupportedSamplerates() (v []int32) {
if codec.supported_samplerates == nil {
return v
}
ptr := (*int32)(codec.supported_samplerates)
for *ptr != 0 {
v = append(v, *ptr)
ptr = (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetSupportedSamplerates() []int32 {
return TruncSlice((*int32)(codec.supported_samplerates), func(i int32) bool {
return i == 0
})
}
// Custom: GetSampleFmts gets `AVCodec.sample_fmts` value.
func (codec *AvCodec) GetSampleFmts() (v []AvSampleFormat) {
if codec.sample_fmts == nil {
return v
}
ptr := (*AvSampleFormat)(codec.sample_fmts)
for *ptr != AV_SAMPLE_FMT_NONE {
v = append(v, *ptr)
ptr = (*AvSampleFormat)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetSampleFmts() []AVSampleFormat {
return TruncSlice((*AVSampleFormat)(codec.sample_fmts), func(sf AVSampleFormat) bool {
return sf == AV_SAMPLE_FMT_NONE
})
}
// Custom: GetChannelLayouts gets `AVCodec.channel_layouts` value.
func (codec *AvCodec) GetChannelLayouts() (v []uint64) {
if codec.channel_layouts == nil {
return v
}
ptr := (*uint64)(codec.channel_layouts)
for *ptr != 0 {
v = append(v, *ptr)
ptr = (*uint64)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetChannelLayouts() []uint64 {
return TruncSlice((*uint64)(codec.channel_layouts), func(u uint64) bool {
return u == 0
})
}
// Custom: GetMaxLowres gets `AVCodec.max_lowres` value.
func (codec *AvCodec) GetMaxLowres() uint8 {
func (codec *AVCodec) GetMaxLowres() uint8 {
return (uint8)(codec.max_lowres)
}
// Custom: GetProfiles gets `AVCodec.profiles` value.
func (codec *AvCodec) GetProfiles() (v []AvProfile) {
if codec.profiles == nil {
return v
}
ptr := (*AvProfile)(codec.profiles)
for ptr.GetProfile() != FF_PROFILE_UNKNOWN {
v = append(v, *ptr)
ptr = (*AvProfile)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
func (codec *AVCodec) GetProfiles() []AVProfile {
return TruncSlice((*AVProfile)(codec.profiles), func(ap AVProfile) bool {
return ap.GetProfile() == FF_PROFILE_UNKNOWN
})
}
// Custom: GetWrapperName gets `AVCodec.wrapper_name` value.
func (codec *AvCodec) GetWrapperName() string {
func (codec *AVCodec) GetWrapperName() string {
return C.GoString(codec.wrapper_name)
}
// AvCodecIterate iterates over all registered codecs.
func AvCodecIterate(opaque *unsafe.Pointer) *AvCodec {
return (*AvCodec)(C.av_codec_iterate(opaque))
func AvCodecIterate(opaque CVoidPointerPointer) *AVCodec {
return (*AVCodec)(C.av_codec_iterate(VoidPointerPointer(opaque)))
}
// AvCodecFindDecoder finds a registered decoder with a matching codec ID.
func AvCodecFindDecoder(id AvCodecID) *AvCodec {
return (*AvCodec)(C.avcodec_find_decoder((C.enum_AVCodecID)(id)))
func AvCodecFindDecoder(id AVCodecID) *AVCodec {
return (*AVCodec)(C.avcodec_find_decoder((C.enum_AVCodecID)(id)))
}
// AvCodecFindDecoderByName finds a registered decoder with the specified name.
func AvCodecFindDecoderByName(name string) *AvCodec {
func AvCodecFindDecoderByName(name string) *AVCodec {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (*AvCodec)(C.avcodec_find_decoder_by_name((*C.char)(namePtr)))
return (*AVCodec)(C.avcodec_find_decoder_by_name((*C.char)(namePtr)))
}
// AvCodecFindEncoder finds a registered encoder with a matching codec ID.
func AvCodecFindEncoder(id AvCodecID) *AvCodec {
return (*AvCodec)(C.avcodec_find_encoder((C.enum_AVCodecID)(id)))
func AvCodecFindEncoder(id AVCodecID) *AVCodec {
return (*AVCodec)(C.avcodec_find_encoder((C.enum_AVCodecID)(id)))
}
// AvCodecFindEncoderByName finds a registered encoder with the specified name.
func AvCodecFindEncoderByName(name string) *AvCodec {
func AvCodecFindEncoderByName(name string) *AVCodec {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (*AvCodec)(C.avcodec_find_encoder_by_name((*C.char)(namePtr)))
return (*AVCodec)(C.avcodec_find_encoder_by_name((*C.char)(namePtr)))
}
// AvCodecIsEncoder returns a non-zero number if codec is an encoder, zero otherwise
func AvCodecIsEncoder(codec *AvCodec) int32 {
func AvCodecIsEncoder(codec *AVCodec) int32 {
return (int32)(C.av_codec_is_encoder((*C.struct_AVCodec)(codec)))
}
// AvCodecIsDecoder returns a non-zero number if codec is an decoder, zero otherwise
func AvCodecIsDecoder(codec *AvCodec) int32 {
func AvCodecIsDecoder(codec *AVCodec) int32 {
return (int32)(C.av_codec_is_decoder((*C.struct_AVCodec)(codec)))
}
@@ -212,10 +168,55 @@ const (
AV_CODEC_HW_CONFIG_METHOD_AD_HOC = int32(C.AV_CODEC_HW_CONFIG_METHOD_AD_HOC)
)
// AvCodecHWConfig
type AvCodecHWConfig C.struct_AVCodecHWConfig
// AVCodecHWConfig
type AVCodecHWConfig C.struct_AVCodecHWConfig
// Custom: GetPixFmt gets `AVCodecHWConfig.pix_fmt` value.
func (hwc *AVCodecHWConfig) GetPixFmt() AVPixelFormat {
return (AVPixelFormat)(hwc.pix_fmt)
}
// Custom: SetPixFmt sets `AVCodecHWConfig.pix_fmt` value.
func (hwc *AVCodecHWConfig) SetPixFmt(v AVPixelFormat) {
hwc.pix_fmt = (C.enum_AVPixelFormat)(v)
}
// Custom: GetPixFmtAddr gets `AVCodecHWConfig.pix_fmt` address.
func (hwc *AVCodecHWConfig) GetPixFmtAddr() *AVPixelFormat {
return (*AVPixelFormat)(&hwc.pix_fmt)
}
// Custom: GetMethods gets `AVCodecHWConfig.methods` value.
func (hwc *AVCodecHWConfig) GetMethods() int32 {
return (int32)(hwc.methods)
}
// Custom: SetMethods sets `AVCodecHWConfig.methods` value.
func (hwc *AVCodecHWConfig) SetMethods(v int32) {
hwc.methods = (C.int)(v)
}
// Custom: GetMethodsAddr gets `AVCodecHWConfig.methods` address.
func (hwc *AVCodecHWConfig) GetMethodsAddr() *int32 {
return (*int32)(&hwc.methods)
}
// Custom: GetDeviceType gets `AVCodecHWConfig.device_type` value.
func (hwc *AVCodecHWConfig) GetDeviceType() AVHWDeviceType {
return (AVHWDeviceType)(hwc.device_type)
}
// Custom: SetDeviceType sets `AVCodecHWConfig.device_type` value.
func (hwc *AVCodecHWConfig) SetDeviceType(v AVHWDeviceType) {
hwc.device_type = (C.enum_AVHWDeviceType)(v)
}
// Custom: GetDeviceTypeAddr gets `AVCodecHWConfig.device_type` address.
func (hwc *AVCodecHWConfig) GetDeviceTypeAddr() *AVHWDeviceType {
return (*AVHWDeviceType)(&hwc.device_type)
}
// AvCodecGetHwConfig retrieves supported hardware configurations for a codec.
func AvCodecGetHwConfig(codec *AvCodec, index int32) *AvCodecHWConfig {
return (*AvCodecHWConfig)(C.avcodec_get_hw_config((*C.struct_AVCodec)(codec), (C.int)(index)))
func AvCodecGetHwConfig[T HelperInteger](codec *AVCodec, index T) *AVCodecHWConfig {
return (*AVCodecHWConfig)(C.avcodec_get_hw_config((*C.struct_AVCodec)(codec), (C.int)(index)))
}

53
avcodec_codec_desc.go
View File

@@ -5,8 +5,45 @@ package ffmpeg
*/
import "C"
// AvCodecDescriptor
type AvCodecDescriptor C.struct_AVCodecDescriptor
// AVCodecDescriptor
type AVCodecDescriptor C.struct_AVCodecDescriptor
// Custom: GetId gets `AVCodecDescriptor.id` value.
func (hwc *AVCodecDescriptor) GetId() AVCodecID {
return (AVCodecID)(hwc.id)
}
// Custom: GetType gets `AVCodecDescriptor.type` value.
func (hwc *AVCodecDescriptor) GetType() AVMediaType {
return (AVMediaType)(hwc._type)
}
// Custom: GetName gets `AVCodecDescriptor.name` value.
func (hwc *AVCodecDescriptor) GetName() string {
return C.GoString(hwc.name)
}
// Custom: GetLongName gets `AVCodecDescriptor.long_name` value.
func (hwc *AVCodecDescriptor) GetLongName() string {
return C.GoString(hwc.long_name)
}
// Custom: GetProps gets `AVCodecDescriptor.props` value.
func (hwc *AVCodecDescriptor) GetProps() int32 {
return (int32)(hwc.props)
}
// Custom: GetMimeTypes gets `AVCodecDescriptor.mime_types` value.
func (hwc *AVCodecDescriptor) GetMimeTypes() (v []string) {
return TruncStringSlice(hwc.mime_types)
}
// Custom: GetProfiles gets `AVCodecDescriptor.profiles` value.
func (hwc *AVCodecDescriptor) GetProfiles() []AVProfile {
return TruncSlice((*AVProfile)(hwc.profiles), func(ap AVProfile) bool {
return ap.GetProfile() == FF_PROFILE_UNKNOWN
})
}
const (
AV_CODEC_PROP_INTRA_ONLY = C.AV_CODEC_PROP_INTRA_ONLY
@@ -18,19 +55,19 @@ const (
)
// AvCodecDescriptorGet returns descriptor for given codec ID or NULL if no descriptor exists.
func AvCodecDescriptorGet(id AvCodecID) *AvCodecDescriptor {
return (*AvCodecDescriptor)(C.avcodec_descriptor_get((C.enum_AVCodecID)(id)))
func AvCodecDescriptorGet(id AVCodecID) *AVCodecDescriptor {
return (*AVCodecDescriptor)(C.avcodec_descriptor_get((C.enum_AVCodecID)(id)))
}
// AvCodecDescriptorNext iterates over all codec descriptors known to libavcodec.
func AvCodecDescriptorNext(prev *AvCodecDescriptor) *AvCodecDescriptor {
return (*AvCodecDescriptor)(C.avcodec_descriptor_next((*C.struct_AVCodecDescriptor)(prev)))
func AvCodecDescriptorNext(prev *AVCodecDescriptor) *AVCodecDescriptor {
return (*AVCodecDescriptor)(C.avcodec_descriptor_next((*C.struct_AVCodecDescriptor)(prev)))
}
// AvCodecDescriptorGetByName returns codec descriptor with the given name or NULL
// if no such descriptor exists.
func AvCodecDescriptorGetByName(name string) *AvCodecDescriptor {
func AvCodecDescriptorGetByName(name string) *AVCodecDescriptor {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (*AvCodecDescriptor)(C.avcodec_descriptor_get_by_name((*C.char)(namePtr)))
return (*AVCodecDescriptor)(C.avcodec_descriptor_get_by_name((*C.char)(namePtr)))
}

1006
avcodec_codec_id.go
View File

File diff suppressed because it is too large Load Diff

239
avcodec_codec_par.go
View File

@@ -6,469 +6,470 @@ package ffmpeg
import "C"
import "unsafe"
type AvFieldOrder = C.enum_AVFieldOrder
// AVFieldOrder
type AVFieldOrder = C.enum_AVFieldOrder
const (
AV_FIELD_UNKNOWN = AvFieldOrder(C.AV_FIELD_UNKNOWN)
AV_FIELD_PROGRESSIVE = AvFieldOrder(C.AV_FIELD_PROGRESSIVE)
AV_FIELD_TT = AvFieldOrder(C.AV_FIELD_TT)
AV_FIELD_BB = AvFieldOrder(C.AV_FIELD_BB)
AV_FIELD_TB = AvFieldOrder(C.AV_FIELD_TB)
AV_FIELD_BT = AvFieldOrder(C.AV_FIELD_BT)
AV_FIELD_UNKNOWN = AVFieldOrder(C.AV_FIELD_UNKNOWN)
AV_FIELD_PROGRESSIVE = AVFieldOrder(C.AV_FIELD_PROGRESSIVE)
AV_FIELD_TT = AVFieldOrder(C.AV_FIELD_TT)
AV_FIELD_BB = AVFieldOrder(C.AV_FIELD_BB)
AV_FIELD_TB = AVFieldOrder(C.AV_FIELD_TB)
AV_FIELD_BT = AVFieldOrder(C.AV_FIELD_BT)
)
// AvCodecParameters
type AvCodecParameters C.struct_AVCodecParameters
// AVCodecParameters
type AVCodecParameters C.struct_AVCodecParameters
// Custom: GetCodecType gets `AVCodecParameters.codec_type` value.
func (par *AvCodecParameters) GetCodecType() AvMediaType {
return (AvMediaType)(par.codec_type)
func (par *AVCodecParameters) GetCodecType() AVMediaType {
return (AVMediaType)(par.codec_type)
}
// Custom: SetCodecType sets `AVCodecParameters.codec_type` value.
func (par *AvCodecParameters) SetCodecType(v AvMediaType) {
func (par *AVCodecParameters) SetCodecType(v AVMediaType) {
par.codec_type = (C.enum_AVMediaType)(v)
}
// Custom: GetCodecTypeAddr gets `AVCodecParameters.codec_type` address.
func (par *AvCodecParameters) GetCodecTypeAddr() *AvMediaType {
return (*AvMediaType)(unsafe.Pointer(&par.codec_type))
func (par *AVCodecParameters) GetCodecTypeAddr() *AVMediaType {
return (*AVMediaType)(unsafe.Pointer(&par.codec_type))
}
// Custom: GetCodecId gets `AVCodecParameters.codec_id` value.
func (par *AvCodecParameters) GetCodecId() AvCodecID {
return (AvCodecID)(par.codec_id)
func (par *AVCodecParameters) GetCodecId() AVCodecID {
return (AVCodecID)(par.codec_id)
}
// Custom: SetCodecId sets `AVCodecParameters.codec_id` value.
func (par *AvCodecParameters) SetCodecId(v AvCodecID) {
func (par *AVCodecParameters) SetCodecId(v AVCodecID) {
par.codec_id = (C.enum_AVCodecID)(v)
}
// Custom: GetCodecIdAddr gets `AVCodecParameters.codec_id` address.
func (par *AvCodecParameters) GetCodecIdAddr() *AvCodecID {
return (*AvCodecID)(unsafe.Pointer(&par.codec_id))
func (par *AVCodecParameters) GetCodecIdAddr() *AVCodecID {
return (*AVCodecID)(unsafe.Pointer(&par.codec_id))
}
// Custom: GetCodecTag gets `AVCodecParameters.codec_tag` value.
func (par *AvCodecParameters) GetCodecTag() uint32 {
func (par *AVCodecParameters) GetCodecTag() uint32 {
return (uint32)(par.codec_tag)
}
// Custom: SetCodecTag sets `AVCodecParameters.codec_tag` value.
func (par *AvCodecParameters) SetCodecTag(v uint32) {
func (par *AVCodecParameters) SetCodecTag(v uint32) {
par.codec_tag = (C.uint)(v)
}
// Custom: GetCodecTagAddr gets `AVCodecParameters.codec_tag` address.
func (par *AvCodecParameters) GetCodecTagAddr() *uint32 {
func (par *AVCodecParameters) GetCodecTagAddr() *uint32 {
return (*uint32)(&par.codec_tag)
}
// Custom: GetExtradata gets `AVCodecParameters.extradata` value.
func (par *AvCodecParameters) GetExtradata() *uint8 {
func (par *AVCodecParameters) GetExtradata() *uint8 {
return (*uint8)(par.extradata)
}
// Custom: SetExtradata sets `AVCodecParameters.extradata` value.
func (par *AvCodecParameters) SetExtradata(v *uint8) {
func (par *AVCodecParameters) SetExtradata(v *uint8) {
par.extradata = (*C.uint8_t)(v)
}
// Custom: GetExtradataAddr gets `AVCodecParameters.extradata` address.
func (par *AvCodecParameters) GetExtradataAddr() *uint8 {
func (par *AVCodecParameters) GetExtradataAddr() *uint8 {
return (*uint8)(unsafe.Pointer(&par.extradata))
}
// Custom: GetExtradataSize gets `AVCodecParameters.extradata_size` value.
func (par *AvCodecParameters) GetExtradataSize() int32 {
func (par *AVCodecParameters) GetExtradataSize() int32 {
return (int32)(par.extradata_size)
}
// Custom: SetExtradataSize sets `AVCodecParameters.extradata_size` value.
func (par *AvCodecParameters) SetExtradataSize(v int32) {
func (par *AVCodecParameters) SetExtradataSize(v int32) {
par.extradata_size = (C.int)(v)
}
// Custom: GetExtradataSizeAddr gets `AVCodecParameters.extradata_size` address.
func (par *AvCodecParameters) GetExtradataSizeAddr() *int32 {
func (par *AVCodecParameters) GetExtradataSizeAddr() *int32 {
return (*int32)(&par.extradata_size)
}
// Custom: GetFormat gets `AVCodecParameters.format` value.
func (par *AvCodecParameters) GetFormat() int32 {
func (par *AVCodecParameters) GetFormat() int32 {
return (int32)(par.format)
}
// Custom: SetFormat sets `AVCodecParameters.format` value.
func (par *AvCodecParameters) SetFormat(v int32) {
func (par *AVCodecParameters) SetFormat(v int32) {
par.format = (C.int)(v)
}
// Custom: GetFormatAddr gets `AVCodecParameters.format` address.
func (par *AvCodecParameters) GetFormatAddr() *int32 {
func (par *AVCodecParameters) GetFormatAddr() *int32 {
return (*int32)(&par.format)
}
// Custom: GetBitRate gets `AVCodecParameters.bit_rate` value.
func (par *AvCodecParameters) GetBitRate() int64 {
func (par *AVCodecParameters) GetBitRate() int64 {
return (int64)(par.bit_rate)
}
// Custom: SetBitRate sets `AVCodecParameters.bit_rate` value.
func (par *AvCodecParameters) SetBitRate(v int64) {
func (par *AVCodecParameters) SetBitRate(v int64) {
par.bit_rate = (C.int64_t)(v)
}
// Custom: GetBitRateAddr gets `AVCodecParameters.bit_rate` address.
func (par *AvCodecParameters) GetBitRateAddr() *int64 {
func (par *AVCodecParameters) GetBitRateAddr() *int64 {
return (*int64)(&par.bit_rate)
}
// Custom: GetBitsPerCodedSample gets `AVCodecParameters.bits_per_coded_sample` value.
func (par *AvCodecParameters) GetBitsPerCodedSample() int32 {
func (par *AVCodecParameters) GetBitsPerCodedSample() int32 {
return (int32)(par.bits_per_coded_sample)
}
// Custom: SetBitsPerCodedSample sets `AVCodecParameters.bits_per_coded_sample` value.
func (par *AvCodecParameters) SetBitsPerCodedSample(v int32) {
func (par *AVCodecParameters) SetBitsPerCodedSample(v int32) {
par.bits_per_coded_sample = (C.int)(v)
}
// Custom: GetBitsPerCodedSampleAddr gets `AVCodecParameters.bits_per_coded_sample` address.
func (par *AvCodecParameters) GetBitsPerCodedSampleAddr() *int32 {
func (par *AVCodecParameters) GetBitsPerCodedSampleAddr() *int32 {
return (*int32)(&par.bits_per_coded_sample)
}
// Custom: GetBitsPerRawSample gets `AVCodecParameters.bits_per_raw_sample` value.
func (par *AvCodecParameters) GetBitsPerRawSample() int32 {
func (par *AVCodecParameters) GetBitsPerRawSample() int32 {
return (int32)(par.bits_per_raw_sample)
}
// Custom: SetBitsPerRawSample sets `AVCodecParameters.bits_per_raw_sample` value.
func (par *AvCodecParameters) SetBitsPerRawSample(v int32) {
func (par *AVCodecParameters) SetBitsPerRawSample(v int32) {
par.bits_per_raw_sample = (C.int)(v)
}
// Custom: GetBitsPerRawSampleAddr gets `AVCodecParameters.bits_per_raw_sample` address.
func (par *AvCodecParameters) GetBitsPerRawSampleAddr() *int32 {
func (par *AVCodecParameters) GetBitsPerRawSampleAddr() *int32 {
return (*int32)(&par.bits_per_raw_sample)
}
// Custom: GetProfile gets `AVCodecParameters.profile` value.
func (par *AvCodecParameters) GetProfile() int32 {
func (par *AVCodecParameters) GetProfile() int32 {
return (int32)(par.profile)
}
// Custom: SetProfile sets `AVCodecParameters.profile` value.
func (par *AvCodecParameters) SetProfile(v int32) {
func (par *AVCodecParameters) SetProfile(v int32) {
par.profile = (C.int)(v)
}
// Custom: GetProfileAddr gets `AVCodecParameters.profile` address.
func (par *AvCodecParameters) GetProfileAddr() *int32 {
func (par *AVCodecParameters) GetProfileAddr() *int32 {
return (*int32)(&par.profile)
}
// Custom: GetLevel gets `AVCodecParameters.level` value.
func (par *AvCodecParameters) GetLevel() int32 {
func (par *AVCodecParameters) GetLevel() int32 {
return (int32)(par.level)
}
// Custom: SetLevel sets `AVCodecParameters.level` value.
func (par *AvCodecParameters) SetLevel(v int32) {
func (par *AVCodecParameters) SetLevel(v int32) {
par.level = (C.int)(v)
}
// Custom: GetLevelAddr gets `AVCodecParameters.level` address.
func (par *AvCodecParameters) GetLevelAddr() *int32 {
func (par *AVCodecParameters) GetLevelAddr() *int32 {
return (*int32)(&par.level)
}
// Custom: GetWidth gets `AVCodecParameters.width` value.
func (par *AvCodecParameters) GetWidth() int32 {
func (par *AVCodecParameters) GetWidth() int32 {
return (int32)(par.width)
}
// Custom: SetWidth sets `AVCodecParameters.width` value.
func (par *AvCodecParameters) SetWidth(v int32) {
func (par *AVCodecParameters) SetWidth(v int32) {
par.width = (C.int)(v)
}
// Custom: GetWidthAddr gets `AVCodecParameters.width` address.
func (par *AvCodecParameters) GetWidthAddr() *int32 {
func (par *AVCodecParameters) GetWidthAddr() *int32 {
return (*int32)(&par.width)
}
// Custom: GetHeight gets `AVCodecParameters.height` value.
func (par *AvCodecParameters) GetHeight() int32 {
func (par *AVCodecParameters) GetHeight() int32 {
return (int32)(par.height)
}
// Custom: SetHeight sets `AVCodecParameters.height` value.
func (par *AvCodecParameters) SetHeight(v int32) {
func (par *AVCodecParameters) SetHeight(v int32) {
par.height = (C.int)(v)
}
// Custom: GetHeightAddr gets `AVCodecParameters.height` address.
func (par *AvCodecParameters) GetHeightAddr() *int32 {
func (par *AVCodecParameters) GetHeightAddr() *int32 {
return (*int32)(&par.height)
}
// Custom: GetSampleAspectRatio gets `AVCodecParameters.sample_aspect_ratio` value.
func (par *AvCodecParameters) GetSampleAspectRatio() AvRational {
return (AvRational)(par.sample_aspect_ratio)
func (par *AVCodecParameters) GetSampleAspectRatio() AVRational {
return (AVRational)(par.sample_aspect_ratio)
}
// Custom: SetSampleAspectRatio sets `AVCodecParameters.sample_aspect_ratio` value.
func (par *AvCodecParameters) SetSampleAspectRatio(v AvRational) {
func (par *AVCodecParameters) SetSampleAspectRatio(v AVRational) {
par.sample_aspect_ratio = (C.struct_AVRational)(v)
}
// Custom: GetSampleAspectRatioAddr gets `AVCodecParameters.sample_aspect_ratio` address.
func (par *AvCodecParameters) GetSampleAspectRatioAddr() *AvRational {
return (*AvRational)(&par.sample_aspect_ratio)
func (par *AVCodecParameters) GetSampleAspectRatioAddr() *AVRational {
return (*AVRational)(&par.sample_aspect_ratio)
}
// Custom: GetFieldOrder gets `AVCodecParameters.field_order` value.
func (par *AvCodecParameters) GetFieldOrder() AvFieldOrder {
return (AvFieldOrder)(par.field_order)
func (par *AVCodecParameters) GetFieldOrder() AVFieldOrder {
return (AVFieldOrder)(par.field_order)
}
// Custom: SetFieldOrder sets `AVCodecParameters.field_order` value.
func (par *AvCodecParameters) SetFieldOrder(v AvFieldOrder) {
func (par *AVCodecParameters) SetFieldOrder(v AVFieldOrder) {
par.field_order = (C.enum_AVFieldOrder)(v)
}
// Custom: GetFieldOrderAddr gets `AVCodecParameters.field_order` address.
func (par *AvCodecParameters) GetFieldOrderAddr() *AvFieldOrder {
return (*AvFieldOrder)(unsafe.Pointer(&par.field_order))
func (par *AVCodecParameters) GetFieldOrderAddr() *AVFieldOrder {
return (*AVFieldOrder)(unsafe.Pointer(&par.field_order))
}
// Custom: GetColorRange gets `AVCodecParameters.color_range` value.
func (par *AvCodecParameters) GetColorRange() AvColorRange {
return (AvColorRange)(par.color_range)
func (par *AVCodecParameters) GetColorRange() AVColorRange {
return (AVColorRange)(par.color_range)
}
// Custom: SetColorRange sets `AVCodecParameters.color_range` value.
func (par *AvCodecParameters) SetColorRange(v AvColorRange) {
func (par *AVCodecParameters) SetColorRange(v AVColorRange) {
par.color_range = (C.enum_AVColorRange)(v)
}
// Custom: GetColorRangeAddr gets `AVCodecParameters.color_range` address.
func (par *AvCodecParameters) GetColorRangeAddr() *AvColorRange {
return (*AvColorRange)(unsafe.Pointer(&par.color_range))
func (par *AVCodecParameters) GetColorRangeAddr() *AVColorRange {
return (*AVColorRange)(unsafe.Pointer(&par.color_range))
}
// Custom: GetColorPrimaries gets `AVCodecParameters.color_primaries` value.
func (par *AvCodecParameters) GetColorPrimaries() AvColorPrimaries {
return (AvColorPrimaries)(par.color_primaries)
func (par *AVCodecParameters) GetColorPrimaries() AVColorPrimaries {
return (AVColorPrimaries)(par.color_primaries)
}
// Custom: SetColorPrimaries sets `AVCodecParameters.color_primaries` value.
func (par *AvCodecParameters) SetColorPrimaries(v AvColorPrimaries) {
func (par *AVCodecParameters) SetColorPrimaries(v AVColorPrimaries) {
par.color_primaries = (C.enum_AVColorPrimaries)(v)
}
// Custom: GetColorPrimariesAddr gets `AVCodecParameters.color_primaries` address.
func (par *AvCodecParameters) GetColorPrimariesAddr() *AvColorPrimaries {
return (*AvColorPrimaries)(unsafe.Pointer(&par.color_primaries))
func (par *AVCodecParameters) GetColorPrimariesAddr() *AVColorPrimaries {
return (*AVColorPrimaries)(unsafe.Pointer(&par.color_primaries))
}
// Custom: GetColorTrc gets `AVCodecParameters.color_trc` value.
func (par *AvCodecParameters) GetColorTrc() AvColorTransferCharacteristic {
return (AvColorTransferCharacteristic)(par.color_trc)
func (par *AVCodecParameters) GetColorTrc() AVColorTransferCharacteristic {
return (AVColorTransferCharacteristic)(par.color_trc)
}
// Custom: SetColorTrc sets `AVCodecParameters.color_trc` value.
func (par *AvCodecParameters) SetColorTrc(v AvColorTransferCharacteristic) {
func (par *AVCodecParameters) SetColorTrc(v AVColorTransferCharacteristic) {
par.color_trc = (C.enum_AVColorTransferCharacteristic)(v)
}
// Custom: GetColorTrcAddr gets `AVCodecParameters.color_trc` address.
func (par *AvCodecParameters) GetColorTrcAddr() *AvColorTransferCharacteristic {
return (*AvColorTransferCharacteristic)(unsafe.Pointer(&par.color_trc))
func (par *AVCodecParameters) GetColorTrcAddr() *AVColorTransferCharacteristic {
return (*AVColorTransferCharacteristic)(unsafe.Pointer(&par.color_trc))
}
// Custom: GetColorSpace gets `AVCodecParameters.color_space` value.
func (par *AvCodecParameters) GetColorSpace() AvColorSpace {
return (AvColorSpace)(par.color_space)
func (par *AVCodecParameters) GetColorSpace() AVColorSpace {
return (AVColorSpace)(par.color_space)
}
// Custom: SetColorSpace sets `AVCodecParameters.color_space` value.
func (par *AvCodecParameters) SetColorSpace(v AvColorSpace) {
func (par *AVCodecParameters) SetColorSpace(v AVColorSpace) {
par.color_space = (C.enum_AVColorSpace)(v)
}
// Custom: GetColorSpaceAddr gets `AVCodecParameters.color_space` address.
func (par *AvCodecParameters) GetColorSpaceAddr() *AvColorSpace {
return (*AvColorSpace)(unsafe.Pointer(&par.color_space))
func (par *AVCodecParameters) GetColorSpaceAddr() *AVColorSpace {
return (*AVColorSpace)(unsafe.Pointer(&par.color_space))
}
// Custom: GetChromaLocation gets `AVCodecParameters.chroma_location` value.
func (par *AvCodecParameters) GetChromaLocation() AvChromaLocation {
return (AvChromaLocation)(par.chroma_location)
func (par *AVCodecParameters) GetChromaLocation() AVChromaLocation {
return (AVChromaLocation)(par.chroma_location)
}
// Custom: SetChromaLocation sets `AVCodecParameters.chroma_location` value.
func (par *AvCodecParameters) SetChromaLocation(v AvChromaLocation) {
func (par *AVCodecParameters) SetChromaLocation(v AVChromaLocation) {
par.chroma_location = (C.enum_AVChromaLocation)(v)
}
// Custom: GetChromaLocationAddr gets `AVCodecParameters.chroma_location` address.
func (par *AvCodecParameters) GetChromaLocationAddr() *AvChromaLocation {
return (*AvChromaLocation)(unsafe.Pointer(&par.chroma_location))
func (par *AVCodecParameters) GetChromaLocationAddr() *AVChromaLocation {
return (*AVChromaLocation)(unsafe.Pointer(&par.chroma_location))
}
// Custom: GetVideoDelay gets `AVCodecParameters.video_delay` value.
func (par *AvCodecParameters) GetVideoDelay() int32 {
func (par *AVCodecParameters) GetVideoDelay() int32 {
return (int32)(par.video_delay)
}
// Custom: SetVideoDelay sets `AVCodecParameters.video_delay` value.
func (par *AvCodecParameters) SetVideoDelay(v int32) {
func (par *AVCodecParameters) SetVideoDelay(v int32) {
par.video_delay = (C.int)(v)
}
// Custom: GetVideoDelayAddr gets `AVCodecParameters.video_delay` address.
func (par *AvCodecParameters) GetVideoDelayAddr() *int32 {
func (par *AVCodecParameters) GetVideoDelayAddr() *int32 {
return (*int32)(&par.video_delay)
}
// Custom: GetChannelLayout gets `AVCodecParameters.channel_layout` value.
func (par *AvCodecParameters) GetChannelLayout() uint64 {
func (par *AVCodecParameters) GetChannelLayout() uint64 {
return (uint64)(par.channel_layout)
}
// Custom: SetChannelLayout sets `AVCodecParameters.channel_layout` value.
func (par *AvCodecParameters) SetChannelLayout(v uint64) {
func (par *AVCodecParameters) SetChannelLayout(v uint64) {
par.channel_layout = (C.uint64_t)(v)
}
// Custom: GetChannelLayoutAddr gets `AVCodecParameters.channel_layout` address.
func (par *AvCodecParameters) GetChannelLayoutAddr() *uint64 {
func (par *AVCodecParameters) GetChannelLayoutAddr() *uint64 {
return (*uint64)(&par.channel_layout)
}
// Custom: GetChannels gets `AVCodecParameters.channels` value.
func (par *AvCodecParameters) GetChannels() int32 {
func (par *AVCodecParameters) GetChannels() int32 {
return (int32)(par.channels)
}
// Custom: SetChannels sets `AVCodecParameters.channels` value.
func (par *AvCodecParameters) SetChannels(v int32) {
func (par *AVCodecParameters) SetChannels(v int32) {
par.channels = (C.int)(v)
}
// Custom: GetChannelsAddr gets `AVCodecParameters.channels` address.
func (par *AvCodecParameters) GetChannelsAddr() *int32 {
func (par *AVCodecParameters) GetChannelsAddr() *int32 {
return (*int32)(&par.channels)
}
// Custom: GetSampleRate gets `AVCodecParameters.sample_rate` value.
func (par *AvCodecParameters) GetSampleRate() int32 {
func (par *AVCodecParameters) GetSampleRate() int32 {
return (int32)(par.sample_rate)
}
// Custom: SetSampleRate sets `AVCodecParameters.sample_rate` value.
func (par *AvCodecParameters) SetSampleRate(v int32) {
func (par *AVCodecParameters) SetSampleRate(v int32) {
par.sample_rate = (C.int)(v)
}
// Custom: GetSampleRateAddr gets `AVCodecParameters.sample_rate` address.
func (par *AvCodecParameters) GetSampleRateAddr() *int32 {
func (par *AVCodecParameters) GetSampleRateAddr() *int32 {
return (*int32)(&par.sample_rate)
}
// Custom: GetBlockAlign gets `AVCodecParameters.block_align` value.
func (par *AvCodecParameters) GetBlockAlign() int32 {
func (par *AVCodecParameters) GetBlockAlign() int32 {
return (int32)(par.block_align)
}
// Custom: SetBlockAlign sets `AVCodecParameters.block_align` value.
func (par *AvCodecParameters) SetBlockAlign(v int32) {
func (par *AVCodecParameters) SetBlockAlign(v int32) {
par.block_align = (C.int)(v)
}
// Custom: GetBlockAlignAddr gets `AVCodecParameters.block_align` address.
func (par *AvCodecParameters) GetBlockAlignAddr() *int32 {
func (par *AVCodecParameters) GetBlockAlignAddr() *int32 {
return (*int32)(&par.block_align)
}
// Custom: GetFrameSize gets `AVCodecParameters.frame_size` value.
func (par *AvCodecParameters) GetFrameSize() int32 {
func (par *AVCodecParameters) GetFrameSize() int32 {
return (int32)(par.frame_size)
}
// Custom: SetFrameSize sets `AVCodecParameters.frame_size` value.
func (par *AvCodecParameters) SetFrameSize(v int32) {
func (par *AVCodecParameters) SetFrameSize(v int32) {
par.frame_size = (C.int)(v)
}
// Custom: GetFrameSizeAddr gets `AVCodecParameters.frame_size` address.
func (par *AvCodecParameters) GetFrameSizeAddr() *int32 {
func (par *AVCodecParameters) GetFrameSizeAddr() *int32 {
return (*int32)(&par.frame_size)
}
// Custom: GetInitialPadding gets `AVCodecParameters.initial_padding` value.
func (par *AvCodecParameters) GetInitialPadding() int32 {
func (par *AVCodecParameters) GetInitialPadding() int32 {
return (int32)(par.initial_padding)
}
// Custom: SetInitialPadding sets `AVCodecParameters.initial_padding` value.
func (par *AvCodecParameters) SetInitialPadding(v int32) {
func (par *AVCodecParameters) SetInitialPadding(v int32) {
par.initial_padding = (C.int)(v)
}
// Custom: GetInitialPaddingAddr gets `AVCodecParameters.initial_padding` address.
func (par *AvCodecParameters) GetInitialPaddingAddr() *int32 {
func (par *AVCodecParameters) GetInitialPaddingAddr() *int32 {
return (*int32)(&par.initial_padding)
}
// Custom: GetTrailingPadding gets `AVCodecParameters.trailing_padding` value.
func (par *AvCodecParameters) GetTrailingPadding() int32 {
func (par *AVCodecParameters) GetTrailingPadding() int32 {
return (int32)(par.trailing_padding)
}
// Custom: SetTrailingPadding sets `AVCodecParameters.trailing_padding` value.
func (par *AvCodecParameters) SetTrailingPadding(v int32) {
func (par *AVCodecParameters) SetTrailingPadding(v int32) {
par.trailing_padding = (C.int)(v)
}
// Custom: GetTrailingPaddingAddr gets `AVCodecParameters.trailing_padding` address.
func (par *AvCodecParameters) GetTrailingPaddingAddr() *int32 {
func (par *AVCodecParameters) GetTrailingPaddingAddr() *int32 {
return (*int32)(&par.trailing_padding)
}
// Custom: GetSeekPreroll gets `AVCodecParameters.seek_preroll` value.
func (par *AvCodecParameters) GetSeekPreroll() int32 {
func (par *AVCodecParameters) GetSeekPreroll() int32 {
return (int32)(par.seek_preroll)
}
// Custom: SetSeekPreroll sets `AVCodecParameters.seek_preroll` value.
func (par *AvCodecParameters) SetSeekPreroll(v int32) {
func (par *AVCodecParameters) SetSeekPreroll(v int32) {
par.seek_preroll = (C.int)(v)
}
// Custom: GetSeekPrerollAddr gets `AVCodecParameters.seek_preroll` address.
func (par *AvCodecParameters) GetSeekPrerollAddr() *int32 {
func (par *AVCodecParameters) GetSeekPrerollAddr() *int32 {
return (*int32)(&par.seek_preroll)
}
// AvCodecParametersAlloc allocates a new AVCodecParameters and set its fields to default values
// (unknown/invalid/0). The returned struct must be freed with AvCodecParametersFree().
func AvCodecParametersAlloc() *AvCodecParameters {
return (*AvCodecParameters)(C.avcodec_parameters_alloc())
// (unknown/invalid/0). The returned struct must be freed with AVCodecParametersFree().
func AvCodecParametersAlloc() *AVCodecParameters {
return (*AVCodecParameters)(C.avcodec_parameters_alloc())
}
// AvCodecParametersFree frees an AVCodecParameters instance and everything associated with it and
// write NULL to the supplied pointer.
func AvCodecParametersFree(par **AvCodecParameters) {
func AvCodecParametersFree(par **AVCodecParameters) {
C.avcodec_parameters_free((**C.struct_AVCodecParameters)(unsafe.Pointer(par)))
}
// AvCodecParametersCopy copies the contents of src to dst.
func AvCodecParametersCopy(dst, src *AvCodecParameters) int32 {
func AvCodecParametersCopy(dst, src *AVCodecParameters) int32 {
return (int32)(C.avcodec_parameters_copy((*C.struct_AVCodecParameters)(dst),
(*C.struct_AVCodecParameters)(src)))
}

8
avcodec_d3d11va.go Normal file
View File

@@ -0,0 +1,8 @@
//go:build ffmpeg_hw_d3d11va
package ffmpeg
/*
#include <libavcodec/d3d11va.h>
*/
import "C"

302
avcodec_packet.go
View File

@@ -6,237 +6,297 @@ package ffmpeg
import "C"
import "unsafe"
// AvPacketSideDataType
type AvPacketSideDataType = C.enum_AVPacketSideDataType
// AVPacketSideDataType
type AVPacketSideDataType = C.enum_AVPacketSideDataType
const (
AV_PKT_DATA_PALETTE = AvPacketSideDataType(C.AV_PKT_DATA_PALETTE)
AV_PKT_DATA_NEW_EXTRADATA = AvPacketSideDataType(C.AV_PKT_DATA_NEW_EXTRADATA)
AV_PKT_DATA_PARAM_CHANGE = AvPacketSideDataType(C.AV_PKT_DATA_PARAM_CHANGE)
AV_PKT_DATA_H263_MB_INFO = AvPacketSideDataType(C.AV_PKT_DATA_H263_MB_INFO)
AV_PKT_DATA_REPLAYGAIN = AvPacketSideDataType(C.AV_PKT_DATA_REPLAYGAIN)
AV_PKT_DATA_DISPLAYMATRIX = AvPacketSideDataType(C.AV_PKT_DATA_DISPLAYMATRIX)
AV_PKT_DATA_STEREO3D = AvPacketSideDataType(C.AV_PKT_DATA_STEREO3D)
AV_PKT_DATA_AUDIO_SERVICE_TYPE = AvPacketSideDataType(C.AV_PKT_DATA_AUDIO_SERVICE_TYPE)
AV_PKT_DATA_QUALITY_STATS = AvPacketSideDataType(C.AV_PKT_DATA_QUALITY_STATS)
AV_PKT_DATA_FALLBACK_TRACK = AvPacketSideDataType(C.AV_PKT_DATA_FALLBACK_TRACK)
AV_PKT_DATA_CPB_PROPERTIES = AvPacketSideDataType(C.AV_PKT_DATA_CPB_PROPERTIES)
AV_PKT_DATA_SKIP_SAMPLES = AvPacketSideDataType(C.AV_PKT_DATA_SKIP_SAMPLES)
AV_PKT_DATA_JP_DUALMONO = AvPacketSideDataType(C.AV_PKT_DATA_JP_DUALMONO)
AV_PKT_DATA_STRINGS_METADATA = AvPacketSideDataType(C.AV_PKT_DATA_STRINGS_METADATA)
AV_PKT_DATA_SUBTITLE_POSITION = AvPacketSideDataType(C.AV_PKT_DATA_SUBTITLE_POSITION)
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL = AvPacketSideDataType(C.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL)
AV_PKT_DATA_WEBVTT_IDENTIFIER = AvPacketSideDataType(C.AV_PKT_DATA_WEBVTT_IDENTIFIER)
AV_PKT_DATA_WEBVTT_SETTINGS = AvPacketSideDataType(C.AV_PKT_DATA_WEBVTT_SETTINGS)
AV_PKT_DATA_METADATA_UPDATE = AvPacketSideDataType(C.AV_PKT_DATA_METADATA_UPDATE)
AV_PKT_DATA_MPEGTS_STREAM_ID = AvPacketSideDataType(C.AV_PKT_DATA_MPEGTS_STREAM_ID)
AV_PKT_DATA_MASTERING_DISPLAY_METADATA = AvPacketSideDataType(C.AV_PKT_DATA_MASTERING_DISPLAY_METADATA)
AV_PKT_DATA_SPHERICAL = AvPacketSideDataType(C.AV_PKT_DATA_SPHERICAL)
AV_PKT_DATA_CONTENT_LIGHT_LEVEL = AvPacketSideDataType(C.AV_PKT_DATA_CONTENT_LIGHT_LEVEL)
AV_PKT_DATA_A53_CC = AvPacketSideDataType(C.AV_PKT_DATA_A53_CC)
AV_PKT_DATA_ENCRYPTION_INIT_INFO = AvPacketSideDataType(C.AV_PKT_DATA_ENCRYPTION_INIT_INFO)
AV_PKT_DATA_ENCRYPTION_INFO = AvPacketSideDataType(C.AV_PKT_DATA_ENCRYPTION_INFO)
AV_PKT_DATA_AFD = AvPacketSideDataType(C.AV_PKT_DATA_AFD)
AV_PKT_DATA_PRFT = AvPacketSideDataType(C.AV_PKT_DATA_PRFT)
AV_PKT_DATA_ICC_PROFILE = AvPacketSideDataType(C.AV_PKT_DATA_ICC_PROFILE)
AV_PKT_DATA_DOVI_CONF = AvPacketSideDataType(C.AV_PKT_DATA_DOVI_CONF)
AV_PKT_DATA_S12M_TIMECODE = AvPacketSideDataType(C.AV_PKT_DATA_S12M_TIMECODE)
AV_PKT_DATA_NB = AvPacketSideDataType(C.AV_PKT_DATA_NB)
AV_PKT_DATA_PALETTE = AVPacketSideDataType(C.AV_PKT_DATA_PALETTE)
AV_PKT_DATA_NEW_EXTRADATA = AVPacketSideDataType(C.AV_PKT_DATA_NEW_EXTRADATA)
AV_PKT_DATA_PARAM_CHANGE = AVPacketSideDataType(C.AV_PKT_DATA_PARAM_CHANGE)
AV_PKT_DATA_H263_MB_INFO = AVPacketSideDataType(C.AV_PKT_DATA_H263_MB_INFO)
AV_PKT_DATA_REPLAYGAIN = AVPacketSideDataType(C.AV_PKT_DATA_REPLAYGAIN)
AV_PKT_DATA_DISPLAYMATRIX = AVPacketSideDataType(C.AV_PKT_DATA_DISPLAYMATRIX)
AV_PKT_DATA_STEREO3D = AVPacketSideDataType(C.AV_PKT_DATA_STEREO3D)
AV_PKT_DATA_AUDIO_SERVICE_TYPE = AVPacketSideDataType(C.AV_PKT_DATA_AUDIO_SERVICE_TYPE)
AV_PKT_DATA_QUALITY_STATS = AVPacketSideDataType(C.AV_PKT_DATA_QUALITY_STATS)
AV_PKT_DATA_FALLBACK_TRACK = AVPacketSideDataType(C.AV_PKT_DATA_FALLBACK_TRACK)
AV_PKT_DATA_CPB_PROPERTIES = AVPacketSideDataType(C.AV_PKT_DATA_CPB_PROPERTIES)
AV_PKT_DATA_SKIP_SAMPLES = AVPacketSideDataType(C.AV_PKT_DATA_SKIP_SAMPLES)
AV_PKT_DATA_JP_DUALMONO = AVPacketSideDataType(C.AV_PKT_DATA_JP_DUALMONO)
AV_PKT_DATA_STRINGS_METADATA = AVPacketSideDataType(C.AV_PKT_DATA_STRINGS_METADATA)
AV_PKT_DATA_SUBTITLE_POSITION = AVPacketSideDataType(C.AV_PKT_DATA_SUBTITLE_POSITION)
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL = AVPacketSideDataType(C.AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL)
AV_PKT_DATA_WEBVTT_IDENTIFIER = AVPacketSideDataType(C.AV_PKT_DATA_WEBVTT_IDENTIFIER)
AV_PKT_DATA_WEBVTT_SETTINGS = AVPacketSideDataType(C.AV_PKT_DATA_WEBVTT_SETTINGS)
AV_PKT_DATA_METADATA_UPDATE = AVPacketSideDataType(C.AV_PKT_DATA_METADATA_UPDATE)
AV_PKT_DATA_MPEGTS_STREAM_ID = AVPacketSideDataType(C.AV_PKT_DATA_MPEGTS_STREAM_ID)
AV_PKT_DATA_MASTERING_DISPLAY_METADATA = AVPacketSideDataType(C.AV_PKT_DATA_MASTERING_DISPLAY_METADATA)
AV_PKT_DATA_SPHERICAL = AVPacketSideDataType(C.AV_PKT_DATA_SPHERICAL)
AV_PKT_DATA_CONTENT_LIGHT_LEVEL = AVPacketSideDataType(C.AV_PKT_DATA_CONTENT_LIGHT_LEVEL)
AV_PKT_DATA_A53_CC = AVPacketSideDataType(C.AV_PKT_DATA_A53_CC)
AV_PKT_DATA_ENCRYPTION_INIT_INFO = AVPacketSideDataType(C.AV_PKT_DATA_ENCRYPTION_INIT_INFO)
AV_PKT_DATA_ENCRYPTION_INFO = AVPacketSideDataType(C.AV_PKT_DATA_ENCRYPTION_INFO)
AV_PKT_DATA_AFD = AVPacketSideDataType(C.AV_PKT_DATA_AFD)
AV_PKT_DATA_PRFT = AVPacketSideDataType(C.AV_PKT_DATA_PRFT)
AV_PKT_DATA_ICC_PROFILE = AVPacketSideDataType(C.AV_PKT_DATA_ICC_PROFILE)
AV_PKT_DATA_DOVI_CONF = AVPacketSideDataType(C.AV_PKT_DATA_DOVI_CONF)
AV_PKT_DATA_S12M_TIMECODE = AVPacketSideDataType(C.AV_PKT_DATA_S12M_TIMECODE)
AV_PKT_DATA_NB = AVPacketSideDataType(C.AV_PKT_DATA_NB)
)
const (
// Deprecated: No use
AV_PKT_DATA_QUALITY_FACTOR = AvPacketSideDataType(C.AV_PKT_DATA_QUALITY_FACTOR)
AV_PKT_DATA_QUALITY_FACTOR = AVPacketSideDataType(C.AV_PKT_DATA_QUALITY_FACTOR)
)
// AvPacketSideData
type AvPacketSideData C.struct_AVPacketSideData
// AVPacketSideData
type AVPacketSideData C.struct_AVPacketSideData
// AvPacket
type AvPacket C.struct_AVPacket
// Custom: GetData gets `AVPacketSideData.data` value.
func (psd *AVPacketSideData) GetData() *uint8 {
return (*uint8)(psd.data)
}
// Custom: SetData sets `AVPacketSideData.data` value.
func (psd *AVPacketSideData) SetData(v *uint8) {
psd.data = (*C.uint8_t)(v)
}
// Custom: GetDataAddr gets `AVPacketSideData.data` address.
func (psd *AVPacketSideData) GetDataAddr() **uint8 {
return (**uint8)(unsafe.Pointer(&psd.data))
}
// Custom: GetSize gets `AVPacketSideData.size` value.
func (psd *AVPacketSideData) GetSize() int32 {
return (int32)(psd.size)
}
// Custom: SetSize sets `AVPacketSideData.size` value.
func (psd *AVPacketSideData) SetSize(v int32) {
psd.size = (C.int)(v)
}
// Custom: GetSizeAddr gets `AVPacketSideData.size` address.
func (psd *AVPacketSideData) GetSizeAddr() *int32 {
return (*int32)(&psd.size)
}
// Custom: GetType gets `AVPacketSideData.type` value.
func (psd *AVPacketSideData) GetType() AVPacketSideDataType {
return (AVPacketSideDataType)(psd._type)
}
// Custom: SetType sets `AVPacketSideData.type` value.
func (psd *AVPacketSideData) SetType(v AVPacketSideDataType) {
psd._type = (C.enum_AVPacketSideDataType)(v)
}
// Custom: GetTypeAddr gets `AVPacketSideData.type` address.
func (psd *AVPacketSideData) GetTypeAddr() *AVPacketSideDataType {
return (*AVPacketSideDataType)(&psd._type)
}
// AVPacket
type AVPacket C.struct_AVPacket
// Custom: GetBuf gets `AVPacket.buf` value.
func (pkt *AvPacket) GetBuf() *AvBufferRef {
return (*AvBufferRef)(pkt.buf)
func (pkt *AVPacket) GetBuf() *AVBufferRef {
return (*AVBufferRef)(pkt.buf)
}
// Custom: SetBuf sets `AVPacket.buf` value.
func (pkt *AvPacket) SetBuf(v *AvBufferRef) {
func (pkt *AVPacket) SetBuf(v *AVBufferRef) {
pkt.buf = (*C.struct_AVBufferRef)(v)
}
// Custom: GetBufAddr gets `AVPacket.buf` address.
func (pkt *AvPacket) GetBufAddr() **AvBufferRef {
return (**AvBufferRef)(unsafe.Pointer(&pkt.buf))
func (pkt *AVPacket) GetBufAddr() **AVBufferRef {
return (**AVBufferRef)(unsafe.Pointer(&pkt.buf))
}
// Custom: GetPts gets `AVPacket.pts` value.
func (pkt *AvPacket) GetPts() int64 {
func (pkt *AVPacket) GetPts() int64 {
return (int64)(pkt.pts)
}
// Custom: SetPts sets `AVPacket.pts` value.
func (pkt *AvPacket) SetPts(v int64) {
func (pkt *AVPacket) SetPts(v int64) {
pkt.pts = (C.int64_t)(v)
}
// Custom: GetPtsAddr gets `AVPacket.pts` address.
func (pkt *AvPacket) GetPtsAddr() *int64 {
func (pkt *AVPacket) GetPtsAddr() *int64 {
return (*int64)(&pkt.pts)
}
// Custom: GetDts gets `AVPacket.dts` value.
func (pkt *AvPacket) GetDts() int64 {
func (pkt *AVPacket) GetDts() int64 {
return (int64)(pkt.dts)
}
// Custom: SetDts sets `AVPacket.dts` value.
func (pkt *AvPacket) SetDts(v int64) {
func (pkt *AVPacket) SetDts(v int64) {
pkt.dts = (C.int64_t)(v)
}
// Custom: GetDtsAddr gets `AVPacket.dts` address.
func (pkt *AvPacket) GetDtsAddr() *int64 {
func (pkt *AVPacket) GetDtsAddr() *int64 {
return (*int64)(&pkt.dts)
}
// Custom: GetData gets `AVPacket.data` value.
func (pkt *AvPacket) GetData() *uint8 {
func (pkt *AVPacket) GetData() *uint8 {
return (*uint8)(pkt.data)
}
// Custom: SetData sets `AVPacket.data` value.
func (pkt *AvPacket) SetData(v *uint8) {
func (pkt *AVPacket) SetData(v *uint8) {
pkt.data = (*C.uint8_t)(v)
}
// Custom: GetDataAddr gets `AVPacket.data` address.
func (pkt *AvPacket) GetDataAddr() **uint8 {
func (pkt *AVPacket) GetDataAddr() **uint8 {
return (**uint8)(unsafe.Pointer(&pkt.data))
}
// Custom: GetSize gets `AVPacket.size` value.
func (pkt *AvPacket) GetSize() int32 {
func (pkt *AVPacket) GetSize() int32 {
return (int32)(pkt.size)
}
// Custom: SetSize sets `AVPacket.size` value.
func (pkt *AvPacket) SetSize(v int32) {
func (pkt *AVPacket) SetSize(v int32) {
pkt.size = (C.int)(v)
}
// Custom: GetSizeAddr gets `AVPacket.size` address.
func (pkt *AvPacket) GetSizeAddr() *int32 {
func (pkt *AVPacket) GetSizeAddr() *int32 {
return (*int32)(&pkt.size)
}
// Custom: GetStreamIndex gets `AVPacket.stream_index` value.
func (pkt *AvPacket) GetStreamIndex() int32 {
func (pkt *AVPacket) GetStreamIndex() int32 {
return (int32)(pkt.stream_index)
}
// Custom: SetStreamIndex sets `AVPacket.stream_index` value.
func (pkt *AvPacket) SetStreamIndex(v int32) {
func (pkt *AVPacket) SetStreamIndex(v int32) {
pkt.stream_index = (C.int)(v)
}
// Custom: GetStreamIndexAddr gets `AVPacket.stream_index` address.
func (pkt *AvPacket) GetStreamIndexAddr() *int32 {
func (pkt *AVPacket) GetStreamIndexAddr() *int32 {
return (*int32)(&pkt.stream_index)
}
// Custom: GetFlags gets `AVPacket.flags` value.
func (pkt *AvPacket) GetFlags() int32 {
func (pkt *AVPacket) GetFlags() int32 {
return (int32)(pkt.flags)
}
// Custom: SetFlags sets `AVPacket.flags` value.
func (pkt *AvPacket) SetFlags(v int32) {
func (pkt *AVPacket) SetFlags(v int32) {
pkt.flags = (C.int)(v)
}
// Custom: GetFlagsAddr gets `AVPacket.flags` address.
func (pkt *AvPacket) GetFlagsAddr() *int32 {
func (pkt *AVPacket) GetFlagsAddr() *int32 {
return (*int32)(&pkt.flags)
}
// Custom: GetSideData gets `AVPacket.side_data` value.
func (pkt *AvPacket) GetSideData() *AvPacketSideData {
return (*AvPacketSideData)(pkt.side_data)
func (pkt *AVPacket) GetSideData() *AVPacketSideData {
return (*AVPacketSideData)(pkt.side_data)
}
// Custom: SetSideData sets `AVPacket.side_data` value.
func (pkt *AvPacket) SetSideData(v *AvPacketSideData) {
func (pkt *AVPacket) SetSideData(v *AVPacketSideData) {
pkt.side_data = (*C.struct_AVPacketSideData)(v)
}
// Custom: GetSideDataAddr gets `AVPacket.side_data` address.
func (pkt *AvPacket) GetSideDataAddr() **AvPacketSideData {
return (**AvPacketSideData)(unsafe.Pointer(&pkt.side_data))
func (pkt *AVPacket) GetSideDataAddr() **AVPacketSideData {
return (**AVPacketSideData)(unsafe.Pointer(&pkt.side_data))
}
// Custom: GetSideDataElems gets `AVPacket.side_data_elems` value.
func (pkt *AvPacket) GetSideDataElems() int32 {
func (pkt *AVPacket) GetSideDataElems() int32 {
return (int32)(pkt.side_data_elems)
}
// Custom: SetSideDataElems sets `AVPacket.side_data_elems` value.
func (pkt *AvPacket) SetSideDataElems(v int32) {
func (pkt *AVPacket) SetSideDataElems(v int32) {
pkt.side_data_elems = (C.int)(v)
}
// Custom: GetSideDataElemsAddr gets `AVPacket.side_data_elems` address.
func (pkt *AvPacket) GetSideDataElemsAddr() *int32 {
func (pkt *AVPacket) GetSideDataElemsAddr() *int32 {
return (*int32)(&pkt.side_data_elems)
}
// Custom: GetDuration gets `AVPacket.duration` value.
func (pkt *AvPacket) GetDuration() int64 {
func (pkt *AVPacket) GetDuration() int64 {
return (int64)(pkt.duration)
}
// Custom: SetDuration sets `AVPacket.duration` value.
func (pkt *AvPacket) SetDuration(v int64) {
func (pkt *AVPacket) SetDuration(v int64) {
pkt.duration = (C.int64_t)(v)
}
// Custom: GetDurationAddr gets `AVPacket.duration` address.
func (pkt *AvPacket) GetDurationAddr() *int64 {
func (pkt *AVPacket) GetDurationAddr() *int64 {
return (*int64)(&pkt.duration)
}
// Custom: GetPos gets `AVPacket.pos` value.
func (pkt *AvPacket) GetPos() int64 {
func (pkt *AVPacket) GetPos() int64 {
return (int64)(pkt.pos)
}
// Custom: SetPos sets `AVPacket.pos` value.
func (pkt *AvPacket) SetPos(v int64) {
func (pkt *AVPacket) SetPos(v int64) {
pkt.pos = (C.int64_t)(v)
}
// Custom: GetPosAddr gets `AVPacket.pos` address.
func (pkt *AvPacket) GetPosAddr() *int64 {
func (pkt *AVPacket) GetPosAddr() *int64 {
return (*int64)(&pkt.pos)
}
// Custom: GetConvergenceDuration gets `AVPacket.convergence_duration` value.
func (pkt *AvPacket) GetConvergenceDuration() int64 {
func (pkt *AVPacket) GetConvergenceDuration() int64 {
return (int64)(pkt.convergence_duration)
}
// Custom: SetConvergenceDuration sets `AVPacket.convergence_duration` value.
func (pkt *AvPacket) SetConvergenceDuration(v int64) {
func (pkt *AVPacket) SetConvergenceDuration(v int64) {
pkt.convergence_duration = (C.int64_t)(v)
}
// Custom: GetConvergenceDurationAddr gets `AVPacket.convergence_duration` address.
func (pkt *AvPacket) GetConvergenceDurationAddr() *int64 {
func (pkt *AVPacket) GetConvergenceDurationAddr() *int64 {
return (*int64)(&pkt.convergence_duration)
}
// AvPacketList
type AvPacketList C.struct_AVPacketList
// AVPacketList
type AVPacketList C.struct_AVPacketList
// Custom: Getgets `AVPacketList.next` value.
func (pl *AVPacketList) Get() *AVPacketList {
return (*AVPacketList)(pl.next)
}
// Custom: Set sets `AVPacketList.next` value.
func (pl *AVPacketList) Set(v *AVPacketList) {
pl.next = (*C.struct_AVPacketList)(v)
}
// Custom: GetAddr gets `AVPacketList.next` address.
func (pl *AVPacketList) GetAddr() **AVPacketList {
return (**AVPacketList)(unsafe.Pointer(&pl.next))
}
const (
AV_PKT_FLAG_KEY = C.AV_PKT_FLAG_KEY
@@ -246,164 +306,164 @@ const (
AV_PKT_FLAG_DISPOSABLE = C.AV_PKT_FLAG_DISPOSABLE
)
// AvSideDataParamChangeFlags
type AvSideDataParamChangeFlags = C.enum_AVSideDataParamChangeFlags
// AVSideDataParamChangeFlags
type AVSideDataParamChangeFlags = C.enum_AVSideDataParamChangeFlags
const (
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = AvSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = AvSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = AvSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = AvSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = AVSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = AVSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = AVSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = AVSideDataParamChangeFlags(C.AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
)
// AvPacketAlloc allocates an AVPacket and set its fields to default values. The resulting
// struct must be freed using AvPacketFree().
func AvPacketAlloc() *AvPacket {
return (*AvPacket)(C.av_packet_alloc())
// struct must be freed using AVPacketFree().
func AvPacketAlloc() *AVPacket {
return (*AVPacket)(C.av_packet_alloc())
}
// AvPacketClone creates a new packet that references the same data as src.
func AvPacketClone(pkt *AvPacket) *AvPacket {
return (*AvPacket)(C.av_packet_clone((*C.struct_AVPacket)(pkt)))
func AvPacketClone(pkt *AVPacket) *AVPacket {
return (*AVPacket)(C.av_packet_clone((*C.struct_AVPacket)(pkt)))
}
// AvPacketFree frees the packet, if the packet is reference counted, it will be
// unreferenced first.
func AvPacketFree(pkt **AvPacket) {
func AvPacketFree(pkt **AVPacket) {
C.av_packet_free((**C.struct_AVPacket)(unsafe.Pointer(pkt)))
}
// AvNewPacket allocates the payload of a packet and initialize its fields with
// default values.
func AvNewPacket(pkt *AvPacket, size int32) int32 {
func AvNewPacket(pkt *AVPacket, size int32) int32 {
return (int32)(C.av_new_packet((*C.struct_AVPacket)(pkt), (C.int)(size)))
}
// AvShrinkPacket reduces packet size, correctly zeroing padding
func AvShrinkPacket(pkt *AvPacket, size int32) {
func AvShrinkPacket(pkt *AVPacket, size int32) {
C.av_shrink_packet((*C.struct_AVPacket)(pkt), (C.int)(size))
}
// AvGrowPacket increases packet size, correctly zeroing padding
func AvGrowPacket(pkt *AvPacket, growBy int32) int32 {
func AvGrowPacket(pkt *AVPacket, growBy int32) int32 {
return (int32)(C.av_grow_packet((*C.struct_AVPacket)(pkt), (C.int)(growBy)))
}
// AvPacketFromData initializes a reference-counted packet from AvMalloc()ed data.
func AvPacketFromData(pkt *AvPacket, data *uint8, size int32) int32 {
func AvPacketFromData(pkt *AVPacket, data *uint8, size int32) int32 {
return (int32)(C.av_packet_from_data((*C.struct_AVPacket)(pkt),
(*C.uint8_t)(data), (C.int)(size)))
}
// Deprecated: Use AvPacketRef() or AvPacketMakeRefcounted() instead.
func AvDupPacket(pkt *AvPacket) {
// Deprecated: Use AVPacketRef() or AVPacketMakeRefcounted() instead.
func AvDupPacket(pkt *AVPacket) {
C.av_dup_packet((*C.struct_AVPacket)(pkt))
}
// Deprecated: Use AvPacketRef instead.
// Deprecated: Use AVPacketRef instead.
// AvCopyPacket copies packet, including contents
func AvCopyPacket(dst, src *AvPacket) int32 {
func AvCopyPacket(dst, src *AVPacket) int32 {
return (int32)(C.av_copy_packet((*C.struct_AVPacket)(dst), (*C.struct_AVPacket)(src)))
}
// Deprecated: Use AvPacketCopyProps instead.
// Deprecated: Use AVPacketCopyProps instead.
// AvCopyPacketSideData copies packet side data
func AvCopyPacketSideData(dst, src *AvPacket) int32 {
func AvCopyPacketSideData(dst, src *AVPacket) int32 {
return (int32)(C.av_copy_packet_side_data((*C.struct_AVPacket)(dst), (*C.struct_AVPacket)(src)))
}
// Deprecated: Use AvPacketUnref() instead.
// Deprecated: Use AVPacketUnref() instead.
// AvFreePacket frees a packet.
func AvFreePacket(pkt *AvPacket) {
func AvFreePacket(pkt *AVPacket) {
C.av_free_packet((*C.struct_AVPacket)(pkt))
}
// AvPacketNewSideData allocates new information of a packet.
func AvPacketNewSideData(pkt *AvPacket, _type AvPacketSideDataType, size int32) *uint8 {
func AvPacketNewSideData(pkt *AVPacket, _type AVPacketSideDataType, size int32) *uint8 {
return (*uint8)(C.av_packet_new_side_data((*C.struct_AVPacket)(pkt),
(C.enum_AVPacketSideDataType)(_type), (C.int)(size)))
}
// AvPacketAddSideData wraps an existing array as a packet side data.
func AvPacketAddSideData(pkt *AvPacket, _type AvPacketSideDataType, data *uint8, size uint) int32 {
func AvPacketAddSideData(pkt *AVPacket, _type AVPacketSideDataType, data *uint8, size uint) int32 {
return (int32)(C.av_packet_add_side_data((*C.struct_AVPacket)(pkt),
(C.enum_AVPacketSideDataType)(_type), (*C.uint8_t)(data), (C.size_t)(size)))
}
// AvPacketShrinkSideData shrinks the already allocated side data buffer.
func AvPacketShrinkSideData(pkt *AvPacket, _type AvPacketSideDataType, size int32) int32 {
func AvPacketShrinkSideData(pkt *AVPacket, _type AVPacketSideDataType, size int32) int32 {
return (int32)(C.av_packet_shrink_side_data((*C.struct_AVPacket)(pkt),
(C.enum_AVPacketSideDataType)(_type), (C.int)(size)))
}
// AvPacketGetSideData gets side information from packet.
func AvPacketGetSideData(pkt *AvPacket, _type AvPacketSideDataType, size *int32) *uint8 {
func AvPacketGetSideData(pkt *AVPacket, _type AVPacketSideDataType, size *int32) *uint8 {
return (*uint8)(C.av_packet_get_side_data((*C.struct_AVPacket)(pkt),
(C.enum_AVPacketSideDataType)(_type), (*C.int)(size)))
}
// Deprecated: No use
func AvPacketMergeSideData(pkt *AvPacket) int32 {
func AvPacketMergeSideData(pkt *AVPacket) int32 {
return (int32)(C.av_packet_merge_side_data((*C.struct_AVPacket)(pkt)))
}
// Deprecated: No use
func AvPacketSplitSideData(pkt *AvPacket) int32 {
func AvPacketSplitSideData(pkt *AVPacket) int32 {
return (int32)(C.av_packet_split_side_data((*C.struct_AVPacket)(pkt)))
}
// AvPacketPackDictionary packs a dictionary for use in side_data.
func AvPacketPackDictionary(dict *AvDictionary, size *int32) *uint8 {
func AvPacketPackDictionary(dict *AVDictionary, size *int32) *uint8 {
return (*uint8)(C.av_packet_pack_dictionary((*C.struct_AVDictionary)(dict),
(*C.int)(size)))
}
// AvPacketUnpackDictionary unpacks a dictionary from side_data.
func AvPacketUnpackDictionary(data *uint8, size int32, dict **AvDictionary) int32 {
func AvPacketUnpackDictionary(data *uint8, size int32, dict **AVDictionary) int32 {
return (int32)(C.av_packet_unpack_dictionary((*C.uint8_t)(data), (C.int)(size),
(**C.struct_AVDictionary)(unsafe.Pointer(dict))))
}
// AvPacketFreeSideData is a convenience function to free all the side data stored.
func AvPacketFreeSideData(pkt *AvPacket) {
func AvPacketFreeSideData(pkt *AVPacket) {
C.av_packet_free_side_data((*C.struct_AVPacket)(pkt))
}
// AvPacketRef setups a new reference to the data described by a given packet
func AvPacketRef(dst, src *AvPacket) int32 {
func AvPacketRef(dst, src *AVPacket) int32 {
return (int32)(C.av_packet_ref((*C.struct_AVPacket)(dst), (*C.struct_AVPacket)(src)))
}
// AvPacketUnref unreferences the buffer referenced by the packet and reset the
// remaining packet fields to their default values.
func AvPacketUnref(pkt *AvPacket) {
func AvPacketUnref(pkt *AVPacket) {
C.av_packet_unref((*C.struct_AVPacket)(pkt))
}
// AvPacketMoveRef moves every field in src to dst and reset src.
func AvPacketMoveRef(dst, src *AvPacket) {
func AvPacketMoveRef(dst, src *AVPacket) {
C.av_packet_move_ref((*C.struct_AVPacket)(dst), (*C.struct_AVPacket)(src))
}
// AvPacketCopyProps copies only "properties" fields from src to dst.
func AvPacketCopyProps(dst, src *AvPacket) int32 {
func AvPacketCopyProps(dst, src *AVPacket) int32 {
return (int32)(C.av_packet_copy_props((*C.struct_AVPacket)(dst), (*C.struct_AVPacket)(src)))
}
// AvPacketMakeRefcounted ensures the data described by a given packet is reference counted.
func AvPacketMakeRefcounted(pkt *AvPacket) {
func AvPacketMakeRefcounted(pkt *AVPacket) {
C.av_packet_make_refcounted((*C.struct_AVPacket)(pkt))
}
// AvPacketMakeWritable creates a writable reference for the data described by a given packet,
// avoiding data copy if possible.
func AvPacketMakeWritable(pkt *AvPacket) {
func AvPacketMakeWritable(pkt *AVPacket) {
C.av_packet_make_writable((*C.struct_AVPacket)(pkt))
}
// AvPacketRescaleTs converts valid timing fields (timestamps / durations) in a packet from one
// timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be ignored.
func AvPacketRescaleTs(pkt *AvPacket, tbSrc, tbDst AvRational) {
func AvPacketRescaleTs(pkt *AVPacket, tbSrc, tbDst AVRational) {
C.av_packet_rescale_ts((*C.struct_AVPacket)(pkt),
(C.struct_AVRational)(tbSrc), (C.struct_AVRational)(tbDst))
}

17
avcodec_vorbis_parser.go
View File

@@ -6,16 +6,17 @@ package ffmpeg
import "C"
import "unsafe"
type AvVorbisParseContext C.struct_AVVorbisParseContext
// AVVorbisParseContext
type AVVorbisParseContext C.struct_AVVorbisParseContext
// AvVorbisParseInit allocates and initialize the Vorbis parser using headers in the extradata.
func AvVorbisParseInit(extradata *uint8, extradataSize int32) *AvVorbisParseContext {
return (*AvVorbisParseContext)(C.av_vorbis_parse_init((*C.uint8_t)(extradata),
func AvVorbisParseInit(extradata *uint8, extradataSize int32) *AVVorbisParseContext {
return (*AVVorbisParseContext)(C.av_vorbis_parse_init((*C.uint8_t)(extradata),
(C.int)(extradataSize)))
}
// AvVorbisParseFree frees the parser and everything associated with it.
func AvVorbisParseFree(s **AvVorbisParseContext) {
func AvVorbisParseFree(s **AVVorbisParseContext) {
C.av_vorbis_parse_free((**C.struct_AVVorbisParseContext)(unsafe.Pointer(s)))
}
@@ -26,18 +27,18 @@ const (
)
// AvVorbisParseFrameFlags gets the duration for a Vorbis packet.
func AvVorbisParseFrameFlags(s *AvVorbisParseContext, buf *uint8, bufSize int32, flags *int32) int32 {
func AvVorbisParseFrameFlags(s *AVVorbisParseContext, buf *uint8, bufSize int32, flags *int32) int32 {
return (int32)(C.av_vorbis_parse_frame_flags((*C.struct_AVVorbisParseContext)(s),
(*C.uint8_t)(buf), (C.int)(bufSize), (*C.int)(flags)))
}
// AvVorbisParseFrame gets the duration for a Vorbis packet.
func AvVorbisParseFrame(s *AvVorbisParseContext, buf *uint8, bufSize int32) int32 {
func AvVorbisParseFrame(s *AVVorbisParseContext, buf *uint8, bufSize int32) int32 {
return (int32)(C.av_vorbis_parse_frame((*C.struct_AVVorbisParseContext)(s),
(*C.uint8_t)(buf), (C.int)(bufSize)))
}
// AvVorbisParseReset
func AvVorbisParseReset(s *AvVorbisParseContext) {
// AVVorbisParseReset
func AvVorbisParseReset(s *AVVorbisParseContext) {
C.av_vorbis_parse_reset((*C.struct_AVVorbisParseContext)(s))
}

407
avdevice.go
View File

@@ -27,113 +27,404 @@ func AvDeviceRegisterAll() {
}
// AvInputAudioDeviceNext iterates audio input devices.
func AvInputAudioDeviceNext(d *AvInputFormat) *AvInputFormat {
return (*AvInputFormat)(C.av_input_audio_device_next((*C.struct_AVInputFormat)(d)))
func AvInputAudioDeviceNext(d *AVInputFormat) *AVInputFormat {
return (*AVInputFormat)(C.av_input_audio_device_next((*C.struct_AVInputFormat)(d)))
}
// AvInputVideoDeviceNext iterates video input devices.
func AvInputVideoDeviceNext(d *AvInputFormat) *AvInputFormat {
return (*AvInputFormat)(C.av_input_video_device_next((*C.struct_AVInputFormat)(d)))
func AvInputVideoDeviceNext(d *AVInputFormat) *AVInputFormat {
return (*AVInputFormat)(C.av_input_video_device_next((*C.struct_AVInputFormat)(d)))
}
// AvOutputAudioDeviceNext iterates audio output devices.
func AvOutputAudioDeviceNext(d *AvOutputFormat) *AvOutputFormat {
return (*AvOutputFormat)(C.av_output_audio_device_next((*C.struct_AVOutputFormat)(d)))
func AvOutputAudioDeviceNext(d *AVOutputFormat) *AVOutputFormat {
return (*AVOutputFormat)(C.av_output_audio_device_next((*C.struct_AVOutputFormat)(d)))
}
// AvOutputVideoDeviceNext iterates video output devices.
func AvOutputVideoDeviceNext(d *AvOutputFormat) *AvOutputFormat {
return (*AvOutputFormat)(C.av_output_video_device_next((*C.struct_AVOutputFormat)(d)))
func AvOutputVideoDeviceNext(d *AVOutputFormat) *AVOutputFormat {
return (*AVOutputFormat)(C.av_output_video_device_next((*C.struct_AVOutputFormat)(d)))
}
// AvDeviceRect
type AvDeviceRect C.struct_AVDeviceRect
// AVDeviceRect
type AVDeviceRect C.struct_AVDeviceRect
// AvAppToDevMessageType
type AvAppToDevMessageType = C.enum_AVAppToDevMessageType
// Custom: GetX gets `AVDeviceRect.x` value.
func (dr *AVDeviceRect) GetX() int32 {
return (int32)(dr.x)
}
// Custom: SetX sets `AVDeviceRect.x` value.
func (dr *AVDeviceRect) SetX(v int32) {
dr.x = (C.int)(v)
}
// Custom: GetXAddr gets `AVDeviceRect.x` address.
func (dr *AVDeviceRect) GetXAddr() *int32 {
return (*int32)(&dr.x)
}
// Custom: GetY gets `AVDeviceRect.y` value.
func (dr *AVDeviceRect) GetY() int32 {
return (int32)(dr.y)
}
// Custom: SetY sets `AVDeviceRect.y` value.
func (dr *AVDeviceRect) SetY(v int32) {
dr.y = (C.int)(v)
}
// Custom: GetYAddr gets `AVDeviceRect.y` address.
func (dr *AVDeviceRect) GetYAddr() *int32 {
return (*int32)(&dr.y)
}
// Custom: GetWidth gets `AVDeviceRect.width` value.
func (dr *AVDeviceRect) GetWidth() int32 {
return (int32)(dr.width)
}
// Custom: SetWidth sets `AVDeviceRect.width` value.
func (dr *AVDeviceRect) SetWidth(v int32) {
dr.width = (C.int)(v)
}
// Custom: GetWidthAddr gets `AVDeviceRect.width` address.
func (dr *AVDeviceRect) GetWidthAddr() *int32 {
return (*int32)(&dr.width)
}
// Custom: GetHeight gets `AVDeviceRect.height` value.
func (dr *AVDeviceRect) GetHeight() int32 {
return (int32)(dr.height)
}
// Custom: SetHeight sets `AVDeviceRect.height` value.
func (dr *AVDeviceRect) SetHeight(v int32) {
dr.height = (C.int)(v)
}
// Custom: GetHeightAddr gets `AVDeviceRect.height` address.
func (dr *AVDeviceRect) GetHeightAddr() *int32 {
return (*int32)(&dr.height)
}
// AVAppToDevMessageType
type AVAppToDevMessageType = C.enum_AVAppToDevMessageType
const (
AV_APP_TO_DEV_NONE = AvAppToDevMessageType(C.AV_APP_TO_DEV_NONE)
AV_APP_TO_DEV_WINDOW_SIZE = AvAppToDevMessageType(C.AV_APP_TO_DEV_WINDOW_SIZE)
AV_APP_TO_DEV_WINDOW_REPAINT = AvAppToDevMessageType(C.AV_APP_TO_DEV_WINDOW_REPAINT)
AV_APP_TO_DEV_PAUSE = AvAppToDevMessageType(C.AV_APP_TO_DEV_PAUSE)
AV_APP_TO_DEV_PLAY = AvAppToDevMessageType(C.AV_APP_TO_DEV_PLAY)
AV_APP_TO_DEV_TOGGLE_PAUSE = AvAppToDevMessageType(C.AV_APP_TO_DEV_TOGGLE_PAUSE)
AV_APP_TO_DEV_SET_VOLUME = AvAppToDevMessageType(C.AV_APP_TO_DEV_SET_VOLUME)
AV_APP_TO_DEV_MUTE = AvAppToDevMessageType(C.AV_APP_TO_DEV_MUTE)
AV_APP_TO_DEV_UNMUTE = AvAppToDevMessageType(C.AV_APP_TO_DEV_UNMUTE)
AV_APP_TO_DEV_TOGGLE_MUTE = AvAppToDevMessageType(C.AV_APP_TO_DEV_TOGGLE_MUTE)
AV_APP_TO_DEV_GET_VOLUME = AvAppToDevMessageType(C.AV_APP_TO_DEV_GET_VOLUME)
AV_APP_TO_DEV_GET_MUTE = AvAppToDevMessageType(C.AV_APP_TO_DEV_GET_MUTE)
AV_APP_TO_DEV_NONE = AVAppToDevMessageType(C.AV_APP_TO_DEV_NONE)
AV_APP_TO_DEV_WINDOW_SIZE = AVAppToDevMessageType(C.AV_APP_TO_DEV_WINDOW_SIZE)
AV_APP_TO_DEV_WINDOW_REPAINT = AVAppToDevMessageType(C.AV_APP_TO_DEV_WINDOW_REPAINT)
AV_APP_TO_DEV_PAUSE = AVAppToDevMessageType(C.AV_APP_TO_DEV_PAUSE)
AV_APP_TO_DEV_PLAY = AVAppToDevMessageType(C.AV_APP_TO_DEV_PLAY)
AV_APP_TO_DEV_TOGGLE_PAUSE = AVAppToDevMessageType(C.AV_APP_TO_DEV_TOGGLE_PAUSE)
AV_APP_TO_DEV_SET_VOLUME = AVAppToDevMessageType(C.AV_APP_TO_DEV_SET_VOLUME)
AV_APP_TO_DEV_MUTE = AVAppToDevMessageType(C.AV_APP_TO_DEV_MUTE)
AV_APP_TO_DEV_UNMUTE = AVAppToDevMessageType(C.AV_APP_TO_DEV_UNMUTE)
AV_APP_TO_DEV_TOGGLE_MUTE = AVAppToDevMessageType(C.AV_APP_TO_DEV_TOGGLE_MUTE)
AV_APP_TO_DEV_GET_VOLUME = AVAppToDevMessageType(C.AV_APP_TO_DEV_GET_VOLUME)
AV_APP_TO_DEV_GET_MUTE = AVAppToDevMessageType(C.AV_APP_TO_DEV_GET_MUTE)
)
// AvDevToAppMessageType
type AvDevToAppMessageType = C.enum_AVDevToAppMessageType
// AVDevToAppMessageType
type AVDevToAppMessageType = C.enum_AVDevToAppMessageType
const (
AV_DEV_TO_APP_NONE = AvDevToAppMessageType(C.AV_DEV_TO_APP_NONE)
AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = AvDevToAppMessageType(C.AV_DEV_TO_APP_CREATE_WINDOW_BUFFER)
AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = AvDevToAppMessageType(C.AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER)
AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = AvDevToAppMessageType(C.AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER)
AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = AvDevToAppMessageType(C.AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER)
AV_DEV_TO_APP_BUFFER_OVERFLOW = AvDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_OVERFLOW)
AV_DEV_TO_APP_BUFFER_UNDERFLOW = AvDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_UNDERFLOW)
AV_DEV_TO_APP_BUFFER_READABLE = AvDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_READABLE)
AV_DEV_TO_APP_BUFFER_WRITABLE = AvDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_WRITABLE)
AV_DEV_TO_APP_MUTE_STATE_CHANGED = AvDevToAppMessageType(C.AV_DEV_TO_APP_MUTE_STATE_CHANGED)
AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = AvDevToAppMessageType(C.AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED)
AV_DEV_TO_APP_NONE = AVDevToAppMessageType(C.AV_DEV_TO_APP_NONE)
AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = AVDevToAppMessageType(C.AV_DEV_TO_APP_CREATE_WINDOW_BUFFER)
AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = AVDevToAppMessageType(C.AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER)
AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = AVDevToAppMessageType(C.AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER)
AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = AVDevToAppMessageType(C.AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER)
AV_DEV_TO_APP_BUFFER_OVERFLOW = AVDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_OVERFLOW)
AV_DEV_TO_APP_BUFFER_UNDERFLOW = AVDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_UNDERFLOW)
AV_DEV_TO_APP_BUFFER_READABLE = AVDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_READABLE)
AV_DEV_TO_APP_BUFFER_WRITABLE = AVDevToAppMessageType(C.AV_DEV_TO_APP_BUFFER_WRITABLE)
AV_DEV_TO_APP_MUTE_STATE_CHANGED = AVDevToAppMessageType(C.AV_DEV_TO_APP_MUTE_STATE_CHANGED)
AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = AVDevToAppMessageType(C.AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED)
)
// AvDeviceAppToDevControlMessage sends control message from application to device.
func AvDeviceAppToDevControlMessage(s *AvFormatContext,
_type AvAppToDevMessageType, data unsafe.Pointer, dataSize uint) int32 {
func AvDeviceAppToDevControlMessage(s *AVFormatContext,
_type AVAppToDevMessageType, data CVoidPointer, dataSize uint) int32 {
return (int32)(C.avdevice_app_to_dev_control_message((*C.struct_AVFormatContext)(s),
(C.enum_AVAppToDevMessageType)(_type), data, (C.size_t)(dataSize)))
(C.enum_AVAppToDevMessageType)(_type), VoidPointer(data), (C.size_t)(dataSize)))
}
// AvDeviceDevToAppControlMessage sends control message from device to application.
func AvDeviceDevToAppControlMessage(s *AvFormatContext,
_type AvDevToAppMessageType, data unsafe.Pointer, dataSize uint) int32 {
func AvDeviceDevToAppControlMessage(s *AVFormatContext,
_type AVDevToAppMessageType, data CVoidPointer, dataSize uint) int32 {
return (int32)(C.avdevice_dev_to_app_control_message((*C.struct_AVFormatContext)(s),
(C.enum_AVDevToAppMessageType)(_type), data, (C.size_t)(dataSize)))
(C.enum_AVDevToAppMessageType)(_type), VoidPointer(data), (C.size_t)(dataSize)))
}
// AvDeviceCapabilitiesQuery
type AvDeviceCapabilitiesQuery C.struct_AVDeviceCapabilitiesQuery
// AVDeviceCapabilitiesQuery
type AVDeviceCapabilitiesQuery C.struct_AVDeviceCapabilitiesQuery
// Custom: GetAvClass gets `AVDeviceCapabilitiesQuery.av_class` value.
func (dc *AVDeviceCapabilitiesQuery) GetAvClass() *AVClass {
return (*AVClass)(dc.av_class)
}
// Custom: SetAvClass sets `AVDeviceCapabilitiesQuery.av_class` value.
func (dc *AVDeviceCapabilitiesQuery) SetAvClass(v *AVClass) {
dc.av_class = (*C.struct_AVClass)(v)
}
// Custom: GetAvClassAddr gets `AVDeviceCapabilitiesQuery.av_class` address.
func (dc *AVDeviceCapabilitiesQuery) GetAvClassAddr() **AVClass {
return (**AVClass)(unsafe.Pointer(&dc.av_class))
}
// Custom: GetDeviceContext gets `AVDeviceCapabilitiesQuery.device_context` value.
func (dc *AVDeviceCapabilitiesQuery) GetDeviceContext() *AVFormatContext {
return (*AVFormatContext)(dc.device_context)
}
// Custom: SetDeviceContext sets `AVDeviceCapabilitiesQuery.device_context` value.
func (dc *AVDeviceCapabilitiesQuery) SetDeviceContext(v *AVFormatContext) {
dc.device_context = (*C.struct_AVFormatContext)(v)
}
// Custom: GetDeviceContextAddr gets `AVDeviceCapabilitiesQuery.device_context` address.
func (dc *AVDeviceCapabilitiesQuery) GetDeviceContextAddr() **AVFormatContext {
return (**AVFormatContext)(unsafe.Pointer(&dc.device_context))
}
// Custom: GetCodec gets `AVDeviceCapabilitiesQuery.codec` value.
func (dc *AVDeviceCapabilitiesQuery) GetCodec() AVCodecID {
return (AVCodecID)(dc.codec)
}
// Custom: SetCodec sets `AVDeviceCapabilitiesQuery.codec` value.
func (dc *AVDeviceCapabilitiesQuery) SetCodec(v AVCodecID) {
dc.codec = (C.enum_AVCodecID)(v)
}
// Custom: GetCodecAddr gets `AVDeviceCapabilitiesQuery.codec` address.
func (dc *AVDeviceCapabilitiesQuery) GetCodecAddr() *AVCodecID {
return (*AVCodecID)(&dc.codec)
}
// Custom: GetSampleFormat gets `AVDeviceCapabilitiesQuery.sample_format` value.
func (dc *AVDeviceCapabilitiesQuery) GetSampleFormat() AVSampleFormat {
return (AVSampleFormat)(dc.sample_format)
}
// Custom: SetSampleFormat sets `AVDeviceCapabilitiesQuery.sample_format` value.
func (dc *AVDeviceCapabilitiesQuery) SetSampleFormat(v AVSampleFormat) {
dc.sample_format = (C.enum_AVSampleFormat)(v)
}
// Custom: GetSampleFormatAddr gets `AVDeviceCapabilitiesQuery.sample_format` address.
func (dc *AVDeviceCapabilitiesQuery) GetSampleFormatAddr() *AVSampleFormat {
return (*AVSampleFormat)(&dc.sample_format)
}
// Custom: GetPixelFormat gets `AVDeviceCapabilitiesQuery.pixel_format` value.
func (dc *AVDeviceCapabilitiesQuery) GetPixelFormat() AVPixelFormat {
return (AVPixelFormat)(dc.pixel_format)
}
// Custom: SetPixelFormat sets `AVDeviceCapabilitiesQuery.pixel_format` value.
func (dc *AVDeviceCapabilitiesQuery) SetPixelFormat(v AVPixelFormat) {
dc.pixel_format = (C.enum_AVPixelFormat)(v)
}
// Custom: GetPixelFormatAddr gets `AVDeviceCapabilitiesQuery.pixel_format` address.
func (dc *AVDeviceCapabilitiesQuery) GetPixelFormatAddr() *AVPixelFormat {
return (*AVPixelFormat)(&dc.pixel_format)
}
// Custom: GetSampleRate gets `AVDeviceCapabilitiesQuery.sample_rate` value.
func (dc *AVDeviceCapabilitiesQuery) GetSampleRate() int32 {
return (int32)(dc.sample_rate)
}
// Custom: SetSampleRate sets `AVDeviceCapabilitiesQuery.sample_rate` value.
func (dc *AVDeviceCapabilitiesQuery) SetSampleRate(v int32) {
dc.sample_rate = (C.int)(v)
}
// Custom: GetSampleRateAddr gets `AVDeviceCapabilitiesQuery.sample_rate` address.
func (dc *AVDeviceCapabilitiesQuery) GetSampleRateAddr() *int32 {
return (*int32)(&dc.sample_rate)
}
// Custom: GetChannels gets `AVDeviceCapabilitiesQuery.channels` value.
func (dc *AVDeviceCapabilitiesQuery) GetChannels() int32 {
return (int32)(dc.channels)
}
// Custom: SetChannels sets `AVDeviceCapabilitiesQuery.channels` value.
func (dc *AVDeviceCapabilitiesQuery) SetChannels(v int32) {
dc.channels = (C.int)(v)
}
// Custom: GetChannelsAddr gets `AVDeviceCapabilitiesQuery.channels` address.
func (dc *AVDeviceCapabilitiesQuery) GetChannelsAddr() *int32 {
return (*int32)(&dc.channels)
}
// Custom: GetChannelLayout gets `AVDeviceCapabilitiesQuery.channel_layout` value.
func (dc *AVDeviceCapabilitiesQuery) GetChannelLayout() int64 {
return (int64)(dc.channel_layout)
}
// Custom: SetChannelLayout sets `AVDeviceCapabilitiesQuery.channel_layout` value.
func (dc *AVDeviceCapabilitiesQuery) SetChannelLayout(v int64) {
dc.channel_layout = (C.int64_t)(v)
}
// Custom: GetChannelLayoutAddr gets `AVDeviceCapabilitiesQuery.channel_layout` address.
func (dc *AVDeviceCapabilitiesQuery) GetChannelLayoutAddr() *int64 {
return (*int64)(&dc.channel_layout)
}
// Custom: GetWindowWidth gets `AVDeviceCapabilitiesQuery.window_width` value.
func (dc *AVDeviceCapabilitiesQuery) GetWindowWidth() int32 {
return (int32)(dc.window_width)
}
// Custom: SetWindowWidth sets `AVDeviceCapabilitiesQuery.window_width` value.
func (dc *AVDeviceCapabilitiesQuery) SetWindowWidth(v int32) {
dc.window_width = (C.int)(v)
}
// Custom: GetWindowWidthAddr gets `AVDeviceCapabilitiesQuery.window_width` address.
func (dc *AVDeviceCapabilitiesQuery) GetWindowWidthAddr() *int32 {
return (*int32)(&dc.window_width)
}
// Custom: GetWindowHeight gets `AVDeviceCapabilitiesQuery.window_height` value.
func (dc *AVDeviceCapabilitiesQuery) GetWindowHeight() int32 {
return (int32)(dc.window_height)
}
// Custom: SetWindowHeight sets `AVDeviceCapabilitiesQuery.window_height` value.
func (dc *AVDeviceCapabilitiesQuery) SetWindowHeight(v int32) {
dc.window_height = (C.int)(v)
}
// Custom: GetWindowHeightAddr gets `AVDeviceCapabilitiesQuery.window_height` address.
func (dc *AVDeviceCapabilitiesQuery) GetWindowHeightAddr() *int32 {
return (*int32)(&dc.window_height)
}
// Custom: GetFrameWidth gets `AVDeviceCapabilitiesQuery.frame_width` value.
func (dc *AVDeviceCapabilitiesQuery) GetFrameWidth() int32 {
return (int32)(dc.frame_width)
}
// Custom: SetFrameWidth sets `AVDeviceCapabilitiesQuery.frame_width` value.
func (dc *AVDeviceCapabilitiesQuery) SetFrameWidth(v int32) {
dc.frame_width = (C.int)(v)
}
// Custom: GetFrameWidthAddr gets `AVDeviceCapabilitiesQuery.frame_width` address.
func (dc *AVDeviceCapabilitiesQuery) GetFrameWidthAddr() *int32 {
return (*int32)(&dc.frame_width)
}
// Custom: GetFrameHeight gets `AVDeviceCapabilitiesQuery.frame_height` value.
func (dc *AVDeviceCapabilitiesQuery) GetFrameHeight() int32 {
return (int32)(dc.frame_height)
}
// Custom: SetFrameHeight sets `AVDeviceCapabilitiesQuery.frame_height` value.
func (dc *AVDeviceCapabilitiesQuery) SetFrameHeight(v int32) {
dc.frame_height = (C.int)(v)
}
// Custom: GetFrameHeightAddr gets `AVDeviceCapabilitiesQuery.frame_height` address.
func (dc *AVDeviceCapabilitiesQuery) GetFrameHeightAddr() *int32 {
return (*int32)(&dc.frame_height)
}
// Custom: GetFps gets `AVDeviceCapabilitiesQuery.fps` value.
func (dc *AVDeviceCapabilitiesQuery) GetFps() AVRational {
return (AVRational)(dc.fps)
}
// Custom: SetFps sets `AVDeviceCapabilitiesQuery.fps` value.
func (dc *AVDeviceCapabilitiesQuery) SetFps(v AVRational) {
dc.fps = (C.struct_AVRational)(v)
}
// Custom: GetFpsAddr gets `AVDeviceCapabilitiesQuery.fps` address.
func (dc *AVDeviceCapabilitiesQuery) GetFpsAddr() *AVRational {
return (*AVRational)(&dc.fps)
}
// Deprecated: No use
func AvDeviceCapabilitiesCreate(caps **AvDeviceCapabilitiesQuery,
s *AvFormatContext, deviceOptions **AvDictionary) int32 {
func AvDeviceCapabilitiesCreate(caps **AVDeviceCapabilitiesQuery,
s *AVFormatContext, deviceOptions **AVDictionary) int32 {
return (int32)(C.avdevice_capabilities_create((**C.struct_AVDeviceCapabilitiesQuery)(unsafe.Pointer(caps)),
(*C.struct_AVFormatContext)(s), (**C.struct_AVDictionary)(unsafe.Pointer(deviceOptions))))
}
// Deprecated: No use
func AvDeviceCapabilitiesFree(caps **AvDeviceCapabilitiesQuery, s *AvFormatContext) {
func AvDeviceCapabilitiesFree(caps **AVDeviceCapabilitiesQuery, s *AVFormatContext) {
C.avdevice_capabilities_free((**C.struct_AVDeviceCapabilitiesQuery)(unsafe.Pointer(caps)),
(*C.struct_AVFormatContext)(s))
}
// AvDeviceInfo
type AvDeviceInfo C.struct_AVDeviceInfo
// AVDeviceInfo
type AVDeviceInfo C.struct_AVDeviceInfo
// AvDeviceInfoList
type AvDeviceInfoList C.struct_AVDeviceInfoList
// Custom: GetDeviceName gets `AVDeviceInfo.device_name` value.
func (di *AVDeviceInfo) GetDeviceName() string {
return C.GoString(di.device_name)
}
// Custom: GetDeviceDescription gets `AVDeviceInfo.device_description` value.
func (di *AVDeviceInfo) GetDeviceDescription() string {
return C.GoString(di.device_description)
}
// AVDeviceInfoList
type AVDeviceInfoList C.struct_AVDeviceInfoList
// Custom: GetDevices gets `AVDeviceInfoList.devices` value.
func (dcl *AVDeviceInfoList) GetDevices() []*AVDeviceInfo {
if dcl.devices == nil {
return nil
}
return unsafe.Slice((**AVDeviceInfo)(unsafe.Pointer(dcl.devices)), dcl.nb_devices)
}
// Custom: GetDevicesIndex gets `AVDeviceInfoList.devices` index value.
func (dcl *AVDeviceInfoList) GetDevicesIdx(idx int) *AVDeviceInfo {
if idx >= int(dcl.nb_devices) {
return nil
}
return PointerOffset((*AVDeviceInfo)(*dcl.devices), idx)
}
// Custom: GetNbDevices gets `AVDeviceInfoList.nb_devices` value.
func (dcl *AVDeviceInfoList) GetNbDevices() int32 {
return (int32)(dcl.nb_devices)
}
// Custom: GetDefaultDevice gets `AVDeviceInfoList.default_device` value.
func (dcl *AVDeviceInfoList) GetDefaultDevice() int32 {
return (int32)(dcl.default_device)
}
// AvDeviceListDevices returns available device names and their parameters.
func AvDeviceListDevices(s *AvFormatContext, deviceList **AvDeviceInfoList) int32 {
func AvDeviceListDevices(s *AVFormatContext, deviceList **AVDeviceInfoList) int32 {
return (int32)(C.avdevice_list_devices((*C.struct_AVFormatContext)(s),
(**C.struct_AVDeviceInfoList)(unsafe.Pointer(deviceList))))
}
// AvDeviceFreeListDevices frees result of AvDeviceListDevices().
func AvDeviceFreeListDevices(deviceList **AvDeviceInfoList) {
func AvDeviceFreeListDevices(deviceList **AVDeviceInfoList) {
C.avdevice_free_list_devices((**C.struct_AVDeviceInfoList)(unsafe.Pointer(deviceList)))
}
// AvDeviceListInputSources lists input devices.
func AvDeviceListInputSources(device *AvInputFormat, deviceName string,
deviceOptions *AvDictionary, deviceList **AvDeviceInfoList) int32 {
func AvDeviceListInputSources(device *AVInputFormat, deviceName string,
deviceOptions *AVDictionary, deviceList **AVDeviceInfoList) int32 {
deviceNamePtr, deviceNameFunc := StringCasting(deviceName)
defer deviceNameFunc()
return (int32)(C.avdevice_list_input_sources((*C.struct_AVInputFormat)(device),
@@ -142,8 +433,8 @@ func AvDeviceListInputSources(device *AvInputFormat, deviceName string,
}
// AvDeviceListOutputSinks lists output devices.
func AvDeviceListOutputSinks(device *AvOutputFormat, deviceName string,
deviceOptions *AvDictionary, deviceList **AvDeviceInfoList) int32 {
func AvDeviceListOutputSinks(device *AVOutputFormat, deviceName string,
deviceOptions *AVDictionary, deviceList **AVDeviceInfoList) int32 {
deviceNamePtr, deviceNameFunc := StringCasting(deviceName)
defer deviceNameFunc()
return (int32)(C.avdevice_list_output_sinks((*C.struct_AVOutputFormat)(device),

981
avfilter.go
View File

File diff suppressed because it is too large Load Diff

100
avfilter_buffersink.go
View File

@@ -6,7 +6,7 @@ package ffmpeg
import "C"
// AvBuffersinkGetFrameFlags gets a frame with filtered data from sink and put it in frame.
func AvBuffersinkGetFrameFlags(ctx *AvFilterContext, frame *AvFrame, flags int32) int32 {
func AvBuffersinkGetFrameFlags(ctx *AVFilterContext, frame *AVFrame, flags int32) int32 {
return (int32)(C.av_buffersink_get_frame_flags((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame), (C.int)(flags)))
}
@@ -16,89 +16,131 @@ const (
AV_BUFFERSINK_FLAG_NO_REQUEST = C.AV_BUFFERSINK_FLAG_NO_REQUEST
)
type AvBufferSinkParams C.struct_AVBufferSinkParams
// AVBufferSinkParams
type AVBufferSinkParams C.struct_AVBufferSinkParams
// Deprecated: No use
func AvBuffersinkParamsAlloc() *AvBufferSinkParams {
return (*AvBufferSinkParams)(C.av_buffersink_params_alloc())
// Custom: GetPixelFmts gets `AVBufferSinkParams.pixel_fmts` value.
func (bsp *AVBufferSinkParams) GetPixelFmts() []AVPixelFormat {
return TruncSlice((*AVPixelFormat)(bsp.pixel_fmts), func(pf AVPixelFormat) bool {
return pf == AV_PIX_FMT_NONE
})
}
type AvABufferSinkParams C.struct_AVABufferSinkParams
// Deprecated: No use
func AvBuffersinkParamsAlloc() *AVBufferSinkParams {
return (*AVBufferSinkParams)(C.av_buffersink_params_alloc())
}
// AVABufferSinkParams
type AVABufferSinkParams C.struct_AVABufferSinkParams
// Custom: GetSampleFmts gets `AVABufferSinkParams.sample_fmts` value.
func (absp *AVABufferSinkParams) GetSampleFmts() []AVSampleFormat {
return TruncSlice((*AVSampleFormat)(absp.sample_fmts), func(sf AVSampleFormat) bool {
return sf == AV_SAMPLE_FMT_NONE
})
}
// Custom: GetChannelLayouts gets `AVABufferSinkParams.channel_layouts` value.
func (absp *AVABufferSinkParams) GetChannelLayouts() []int64 {
return TruncSlice((*int64)(absp.channel_layouts), func(i int64) bool {
return i == -1
})
}
// Custom: GetChannelCounts gets `AVABufferSinkParams.channel_counts` value.
func (absp *AVABufferSinkParams) GetChannelCounts() []int32 {
return TruncSlice((*int32)(absp.channel_counts), func(i int32) bool {
return i == -1
})
}
// Custom: GetAllChannelCounts gets `AVABufferSinkParams.all_channel_counts` value.
func (absp *AVABufferSinkParams) GetAllChannelCounts() int32 {
return (int32)(absp.all_channel_counts)
}
// Custom: GetSampleRates gets `AVABufferSinkParams.sample_rates` value.
func (absp *AVABufferSinkParams) GetSampleRates() []int32 {
return TruncSlice((*int32)(absp.sample_rates), func(i int32) bool {
return i == -1
})
}
// Deprecated: No use
func AvAbuffersinkParamsAlloc() *AvABufferSinkParams {
return (*AvABufferSinkParams)(C.av_abuffersink_params_alloc())
func AvAbuffersinkParamsAlloc() *AVABufferSinkParams {
return (*AVABufferSinkParams)(C.av_abuffersink_params_alloc())
}
// AvBuffersinkSetFrameSize sets the frame size for an audio buffer sink.
func AvBuffersinkSetFrameSize(ctx *AvFilterContext, frameSize uint32) {
func AvBuffersinkSetFrameSize(ctx *AVFilterContext, frameSize uint32) {
C.av_buffersink_set_frame_size((*C.struct_AVFilterContext)(ctx), (C.uint)(frameSize))
}
// AvBuffersinkGetType
func AvBuffersinkGetType(ctx *AvFilterContext) AvMediaType {
return (AvMediaType)(C.av_buffersink_get_type((*C.struct_AVFilterContext)(ctx)))
func AvBuffersinkGetType(ctx *AVFilterContext) AVMediaType {
return (AVMediaType)(C.av_buffersink_get_type((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetTimeBase
func AvBuffersinkGetTimeBase(ctx *AvFilterContext) AvRational {
return (AvRational)(C.av_buffersink_get_time_base((*C.struct_AVFilterContext)(ctx)))
func AvBuffersinkGetTimeBase(ctx *AVFilterContext) AVRational {
return (AVRational)(C.av_buffersink_get_time_base((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetFormat
func AvBuffersinkGetFormat(ctx *AvFilterContext) int32 {
func AvBuffersinkGetFormat(ctx *AVFilterContext) int32 {
return (int32)(C.av_buffersink_get_format((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetFrameRate
func AvBuffersinkGetFrameRate(ctx *AvFilterContext) AvRational {
return (AvRational)(C.av_buffersink_get_frame_rate((*C.struct_AVFilterContext)(ctx)))
func AvBuffersinkGetFrameRate(ctx *AVFilterContext) AVRational {
return (AVRational)(C.av_buffersink_get_frame_rate((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetW
func AvBuffersinkGetW(ctx *AvFilterContext) int32 {
func AvBuffersinkGetW(ctx *AVFilterContext) int32 {
return (int32)(C.av_buffersink_get_w((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetH
func AvBuffersinkGetH(ctx *AvFilterContext) int32 {
func AvBuffersinkGetH(ctx *AVFilterContext) int32 {
return (int32)(C.av_buffersink_get_h((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetSampleAspectRatio
func AvBuffersinkGetSampleAspectRatio(ctx *AvFilterContext) AvRational {
return (AvRational)(C.av_buffersink_get_sample_aspect_ratio((*C.struct_AVFilterContext)(ctx)))
func AvBuffersinkGetSampleAspectRatio(ctx *AVFilterContext) AVRational {
return (AVRational)(C.av_buffersink_get_sample_aspect_ratio((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetChannels
func AvBuffersinkGetChannels(ctx *AvFilterContext) int32 {
func AvBuffersinkGetChannels(ctx *AVFilterContext) int32 {
return (int32)(C.av_buffersink_get_channels((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetChannelLayout
func AvBuffersinkGetChannelLayout(ctx *AvFilterContext) uint64 {
func AvBuffersinkGetChannelLayout(ctx *AVFilterContext) uint64 {
return (uint64)(C.av_buffersink_get_channel_layout((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetSampleRate
func AvBuffersinkGetSampleRate(ctx *AvFilterContext) int32 {
func AvBuffersinkGetSampleRate(ctx *AVFilterContext) int32 {
return (int32)(C.av_buffersink_get_sample_rate((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetHwFramesCtx
func AvBuffersinkGetHwFramesCtx(ctx *AvFilterContext) *AvBufferRef {
return (*AvBufferRef)(C.av_buffersink_get_hw_frames_ctx((*C.struct_AVFilterContext)(ctx)))
func AvBuffersinkGetHwFramesCtx(ctx *AVFilterContext) *AVBufferRef {
return (*AVBufferRef)(C.av_buffersink_get_hw_frames_ctx((*C.struct_AVFilterContext)(ctx)))
}
// AvBuffersinkGetFrame gets a frame with filtered data from sink and put it in frame.
func AvBuffersinkGetFrame(ctx *AvFilterContext, frame *AvFrame) int32 {
func AvBuffersinkGetFrame(ctx *AVFilterContext, frame *AVFrame) int32 {
return (int32)(C.av_buffersink_get_frame((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame)))
}
// AvBuffersinkGetSamples same as AvBuffersinkGetFrame(), but with the ability to specify the number
// of samples read. This function is less efficient than AvBuffersinkGetFrame(), because it copies the data around.
func AvBuffersinkGetSamples(ctx *AvFilterContext, frame *AvFrame, nbSamples int32) int32 {
// AvBuffersinkGetSamples same as AVBuffersinkGetFrame(), but with the ability to specify the number
// of samples read. This function is less efficient than AVBuffersinkGetFrame(), because it copies the data around.
func AvBuffersinkGetSamples(ctx *AVFilterContext, frame *AVFrame, nbSamples int32) int32 {
return (int32)(C.av_buffersink_get_samples((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame), (C.int)(nbSamples)))
}

155
avfilter_buffersrc.go
View File

@@ -4,6 +4,7 @@ package ffmpeg
#include <libavfilter/buffersrc.h>
*/
import "C"
import "unsafe"
const (
AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = int32(C.AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT)
@@ -12,44 +13,180 @@ const (
)
// AvBuffersrcGetNbFailedRequests gets the number of failed requests.
func AvBuffersrcGetNbFailedRequests(bufferSrc *AvFilterContext) uint32 {
func AvBuffersrcGetNbFailedRequests(bufferSrc *AVFilterContext) uint32 {
return (uint32)(C.av_buffersrc_get_nb_failed_requests((*C.struct_AVFilterContext)(bufferSrc)))
}
type AvBufferSrcParameters C.struct_AVBufferSrcParameters
// AVBufferSrcParameters
type AVBufferSrcParameters C.struct_AVBufferSrcParameters
// Custom: GetFormat gets `AVBufferSrcParameters.format` value.
func (bsrc *AVBufferSrcParameters) GetFormat() int32 {
return (int32)(bsrc.format)
}
// Custom: SetFormat sets `AVBufferSrcParameters.format` value.
func (bsrc *AVBufferSrcParameters) SetFormat(v int32) {
bsrc.format = (C.int)(v)
}
// Custom: GetFormatAddr gets `AVBufferSrcParameters.format` address.
func (bsrc *AVBufferSrcParameters) GetFormatAddr() *int32 {
return (*int32)(&bsrc.format)
}
// Custom: GetTimeBase gets `AVBufferSrcParameters.time_base` value.
func (bsrc *AVBufferSrcParameters) GetTimeBase() AVRational {
return (AVRational)(bsrc.time_base)
}
// Custom: SetTimeBase sets `AVBufferSrcParameters.time_base` value.
func (bsrc *AVBufferSrcParameters) SetTimeBase(v AVRational) {
bsrc.time_base = (C.struct_AVRational)(v)
}
// Custom: GetTimeBaseAddr gets `AVBufferSrcParameters.time_base` address.
func (bsrc *AVBufferSrcParameters) GetTimeBaseAddr() *AVRational {
return (*AVRational)(&bsrc.time_base)
}
// Custom: GetWidth gets `AVBufferSrcParameters.width` value.
func (bsrc *AVBufferSrcParameters) GetWidth() int32 {
return (int32)(bsrc.width)
}
// Custom: SetWidth sets `AVBufferSrcParameters.width` value.
func (bsrc *AVBufferSrcParameters) SetWidth(v int32) {
bsrc.width = (C.int)(v)
}
// Custom: GetWidthAddr gets `AVBufferSrcParameters.width` address.
func (bsrc *AVBufferSrcParameters) GetWidthAddr() *int32 {
return (*int32)(&bsrc.width)
}
// Custom: GetHeight gets `AVBufferSrcParameters.height` value.
func (bsrc *AVBufferSrcParameters) GetHeight() int32 {
return (int32)(bsrc.height)
}
// Custom: SetHeight sets `AVBufferSrcParameters.height` value.
func (bsrc *AVBufferSrcParameters) SetHeight(v int32) {
bsrc.height = (C.int)(v)
}
// Custom: GetHeightAddr gets `AVBufferSrcParameters.height` address.
func (bsrc *AVBufferSrcParameters) GetHeightAddr() *int32 {
return (*int32)(&bsrc.height)
}
// Custom: GetSampleAspectRatio gets `AVBufferSrcParameters.sample_aspect_ratio` value.
func (bsrc *AVBufferSrcParameters) GetSampleAspectRatio() AVRational {
return (AVRational)(bsrc.sample_aspect_ratio)
}
// Custom: SetSampleAspectRatio sets `AVBufferSrcParameters.sample_aspect_ratio` value.
func (bsrc *AVBufferSrcParameters) SetSampleAspectRatio(v AVRational) {
bsrc.sample_aspect_ratio = (C.struct_AVRational)(v)
}
// Custom: GetSampleAspectRatioAddr gets `AVBufferSrcParameters.sample_aspect_ratio` address.
func (bsrc *AVBufferSrcParameters) GetSampleAspectRatioAddr() *AVRational {
return (*AVRational)(&bsrc.sample_aspect_ratio)
}
// Custom: GetFrameRate gets `AVBufferSrcParameters.frame_rate` value.
func (bsrc *AVBufferSrcParameters) GetFrameRate() AVRational {
return (AVRational)(bsrc.frame_rate)
}
// Custom: SetFrameRate sets `AVBufferSrcParameters.frame_rate` value.
func (bsrc *AVBufferSrcParameters) SetFrameRate(v AVRational) {
bsrc.frame_rate = (C.struct_AVRational)(v)
}
// Custom: GetFrameRateAddr gets `AVBufferSrcParameters.frame_rate` address.
func (bsrc *AVBufferSrcParameters) GetFrameRateAddr() *AVRational {
return (*AVRational)(&bsrc.frame_rate)
}
// Custom: GetHwFramesCtx gets `AVBufferSrcParameters.hw_frames_ctx` value.
func (bsrc *AVBufferSrcParameters) GetHwFramesCtx() *AVBufferRef {
return (*AVBufferRef)(bsrc.hw_frames_ctx)
}
// Custom: SetHwFramesCtx sets `AVBufferSrcParameters.hw_frames_ctx` value.
func (bsrc *AVBufferSrcParameters) SetHwFramesCtx(v *AVBufferRef) {
bsrc.hw_frames_ctx = (*C.struct_AVBufferRef)(v)
}
// Custom: GetHwFramesCtxAddr gets `AVBufferSrcParameters.hw_frames_ctx` address.
func (bsrc *AVBufferSrcParameters) GetHwFramesCtxAddr() **AVBufferRef {
return (**AVBufferRef)(unsafe.Pointer(&bsrc.hw_frames_ctx))
}
// Custom: GetSampleRate gets `AVBufferSrcParameters.sample_rate` value.
func (bsrc *AVBufferSrcParameters) GetSampleRate() int32 {
return (int32)(bsrc.sample_rate)
}
// Custom: SetSampleRate sets `AVBufferSrcParameters.sample_rate` value.
func (bsrc *AVBufferSrcParameters) SetSampleRate(v int32) {
bsrc.sample_rate = (C.int)(v)
}
// Custom: GetSampleRateAddr gets `AVBufferSrcParameters.sample_rate` address.
func (bsrc *AVBufferSrcParameters) GetSampleRateAddr() *int32 {
return (*int32)(&bsrc.sample_rate)
}
// Custom: GetChannelLayout gets `AVBufferSrcParameters.channel_layout` value.
func (bsrc *AVBufferSrcParameters) GetChannelLayout() uint64 {
return (uint64)(bsrc.channel_layout)
}
// Custom: SetChannelLayout sets `AVBufferSrcParameters.channel_layout` value.
func (bsrc *AVBufferSrcParameters) SetChannelLayout(v uint64) {
bsrc.channel_layout = (C.uint64_t)(v)
}
// Custom: GetChannelLayoutAddr gets `AVBufferSrcParameters.channel_layout` address.
func (bsrc *AVBufferSrcParameters) GetChannelLayoutAddr() *uint64 {
return (*uint64)(&bsrc.channel_layout)
}
// AvBuffersrcParametersAlloc allocates a new AVBufferSrcParameters instance. It should be freed by the
// caller with AvFree().
func AvBuffersrcParametersAlloc() *AvBufferSrcParameters {
return (*AvBufferSrcParameters)(C.av_buffersrc_parameters_alloc())
func AvBuffersrcParametersAlloc() *AVBufferSrcParameters {
return (*AVBufferSrcParameters)(C.av_buffersrc_parameters_alloc())
}
// AvBuffersrcParametersSet initializes the buffersrc or abuffersrc filter with the provided parameters.
func AvBuffersrcParametersSet(ctx *AvFilterContext, param *AvBufferSrcParameters) int32 {
func AvBuffersrcParametersSet(ctx *AVFilterContext, param *AVBufferSrcParameters) int32 {
return (int32)(C.av_buffersrc_parameters_set((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVBufferSrcParameters)(param)))
}
// AvBuffersrcWriteFrame adds a frame to the buffer source.
func AvBuffersrcWriteFrame(ctx *AvFilterContext, frame *AvFrame) int32 {
func AvBuffersrcWriteFrame(ctx *AVFilterContext, frame *AVFrame) int32 {
return (int32)(C.av_buffersrc_write_frame((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame)))
}
// AvBuffersrcAddFrame adds a frame to the buffer source.
func AvBuffersrcAddFrame(ctx *AvFilterContext, frame *AvFrame) int32 {
func AvBuffersrcAddFrame(ctx *AVFilterContext, frame *AVFrame) int32 {
return (int32)(C.av_buffersrc_add_frame((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame)))
}
// AvBuffersrcAddFrameFlags adds a frame to the buffer source.
func AvBuffersrcAddFrameFlags(ctx *AvFilterContext, frame *AvFrame, flags int32) int32 {
func AvBuffersrcAddFrameFlags(ctx *AVFilterContext, frame *AVFrame, flags int32) int32 {
return (int32)(C.av_buffersrc_add_frame_flags((*C.struct_AVFilterContext)(ctx),
(*C.struct_AVFrame)(frame), (C.int)(flags)))
}
// AvBuffersrcClose closes the buffer source after EOF.
func AvBuffersrcClose(ctx *AvFilterContext, pts int64, flags uint32) int32 {
func AvBuffersrcClose(ctx *AVFilterContext, pts int64, flags uint32) int32 {
return (int32)(C.av_buffersrc_close((*C.struct_AVFilterContext)(ctx),
(C.int64_t)(pts), (C.uint)(flags)))
}

1365
avformat.go
View File

File diff suppressed because it is too large Load Diff

813
avformat_avio.go
View File

File diff suppressed because it is too large Load Diff

48
avutil.go
View File

@@ -31,21 +31,21 @@ func AvutilLicense() string {
}
// Media Type
type AvMediaType = C.enum_AVMediaType
type AVMediaType = C.enum_AVMediaType
const (
AVMEDIA_TYPE_UNKNOWN = AvMediaType(C.AVMEDIA_TYPE_UNKNOWN)
AVMEDIA_TYPE_VIDEO = AvMediaType(C.AVMEDIA_TYPE_VIDEO)
AVMEDIA_TYPE_AUDIO = AvMediaType(C.AVMEDIA_TYPE_AUDIO)
AVMEDIA_TYPE_DATA = AvMediaType(C.AVMEDIA_TYPE_DATA)
AVMEDIA_TYPE_SUBTITLE = AvMediaType(C.AVMEDIA_TYPE_SUBTITLE)
AVMEDIA_TYPE_ATTACHMENT = AvMediaType(C.AVMEDIA_TYPE_ATTACHMENT)
AVMEDIA_TYPE_NB = AvMediaType(C.AVMEDIA_TYPE_NB)
AVMEDIA_TYPE_UNKNOWN = AVMediaType(C.AVMEDIA_TYPE_UNKNOWN)
AVMEDIA_TYPE_VIDEO = AVMediaType(C.AVMEDIA_TYPE_VIDEO)
AVMEDIA_TYPE_AUDIO = AVMediaType(C.AVMEDIA_TYPE_AUDIO)
AVMEDIA_TYPE_DATA = AVMediaType(C.AVMEDIA_TYPE_DATA)
AVMEDIA_TYPE_SUBTITLE = AVMediaType(C.AVMEDIA_TYPE_SUBTITLE)
AVMEDIA_TYPE_ATTACHMENT = AVMediaType(C.AVMEDIA_TYPE_ATTACHMENT)
AVMEDIA_TYPE_NB = AVMediaType(C.AVMEDIA_TYPE_NB)
)
// AvGetMediaTypeString returns a string describing the MediaType,
// Empty string if media_type is unknown.
func AvGetMediaTypeString(mt AvMediaType) string {
func AvGetMediaTypeString(mt AVMediaType) string {
return C.GoString(C.av_get_media_type_string((C.enum_AVMediaType)(mt)))
}
@@ -64,25 +64,25 @@ const (
)
var (
AV_TIME_BASE_Q = AvRational(C.AV_TIME_BASE_Q)
AV_TIME_BASE_Q = AVRational(C.AV_TIME_BASE_Q)
)
// AvPictureType, pixel formats and basic image planes manipulation.
type AvPictureType = C.enum_AVPictureType
type AVPictureType = C.enum_AVPictureType
const (
AV_PICTURE_TYPE_NONE = AvPictureType(C.AV_PICTURE_TYPE_NONE)
AV_PICTURE_TYPE_I = AvPictureType(C.AV_PICTURE_TYPE_I)
AV_PICTURE_TYPE_P = AvPictureType(C.AV_PICTURE_TYPE_P)
AV_PICTURE_TYPE_B = AvPictureType(C.AV_PICTURE_TYPE_B)
AV_PICTURE_TYPE_S = AvPictureType(C.AV_PICTURE_TYPE_S)
AV_PICTURE_TYPE_SI = AvPictureType(C.AV_PICTURE_TYPE_SI)
AV_PICTURE_TYPE_SP = AvPictureType(C.AV_PICTURE_TYPE_SP)
AV_PICTURE_TYPE_BI = AvPictureType(C.AV_PICTURE_TYPE_BI)
AV_PICTURE_TYPE_NONE = AVPictureType(C.AV_PICTURE_TYPE_NONE)
AV_PICTURE_TYPE_I = AVPictureType(C.AV_PICTURE_TYPE_I)
AV_PICTURE_TYPE_P = AVPictureType(C.AV_PICTURE_TYPE_P)
AV_PICTURE_TYPE_B = AVPictureType(C.AV_PICTURE_TYPE_B)
AV_PICTURE_TYPE_S = AVPictureType(C.AV_PICTURE_TYPE_S)
AV_PICTURE_TYPE_SI = AVPictureType(C.AV_PICTURE_TYPE_SI)
AV_PICTURE_TYPE_SP = AVPictureType(C.AV_PICTURE_TYPE_SP)
AV_PICTURE_TYPE_BI = AVPictureType(C.AV_PICTURE_TYPE_BI)
)
// AvGetPictureTypeChar returns a single letter to describe the given picture type.
func AvGetPictureTypeChar(pictType AvPictureType) string {
func AvGetPictureTypeChar(pictType AVPictureType) string {
c := C.av_get_picture_type_char((C.enum_AVPictureType)(pictType))
return C.GoStringN(&c, 1)
}
@@ -93,8 +93,8 @@ func AvXIfNull(p, x unsafe.Pointer) unsafe.Pointer {
}
// AvIntListLengthForSize computes the length of an integer list.
func AvIntListLengthForSize(elsize uint32, list unsafe.Pointer, term uint64) uint32 {
return (uint32)(C.av_int_list_length_for_size((C.uint)(elsize), list, (C.uint64_t)(term)))
func AvIntListLengthForSize(elsize uint32, list CVoidPointer, term uint64) uint32 {
return (uint32)(C.av_int_list_length_for_size((C.uint)(elsize), VoidPointer(list), (C.uint64_t)(term)))
}
// AvIntListLength
@@ -113,8 +113,8 @@ func AvFopenUtf8(path, mode string) *FILE {
}
// AvGetTimeBaseQ returns the fractional representation of the internal time base.
func AvGetTimeBaseQ() AvRational {
return (AvRational)(C.av_get_time_base_q())
func AvGetTimeBaseQ() AVRational {
return (AVRational)(C.av_get_time_base_q())
}
const (

35
avutil_audio_fifo.go
View File

@@ -4,63 +4,62 @@ package ffmpeg
#include <libavutil/audio_fifo.h>
*/
import "C"
import "unsafe"
type AvAudioFifo C.struct_AVAudioFifo
type AVAudioFifo C.struct_AVAudioFifo
// AvAudioFifoFree frees an AVAudioFifo.
func AvAudioFifoFree(af *AvAudioFifo) {
func AvAudioFifoFree(af *AVAudioFifo) {
C.av_audio_fifo_free((*C.struct_AVAudioFifo)(af))
}
// AvAudioFifoAlloc allocates an AVAudioFifo.
func AvAudioFifoAlloc(sampleFmt AvSampleFormat, channels, nbSamples int32) *AvAudioFifo {
return (*AvAudioFifo)(C.av_audio_fifo_alloc((C.enum_AVSampleFormat)(sampleFmt),
func AvAudioFifoAlloc(sampleFmt AVSampleFormat, channels, nbSamples int32) *AVAudioFifo {
return (*AVAudioFifo)(C.av_audio_fifo_alloc((C.enum_AVSampleFormat)(sampleFmt),
(C.int)(channels), (C.int)(nbSamples)))
}
// AvAudioFifoRealloc reallocate an AVAudioFifo.
func AvAudioFifoRealloc(af *AvAudioFifo, nbSamples int32) int32 {
func AvAudioFifoRealloc(af *AVAudioFifo, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_realloc((*C.struct_AVAudioFifo)(af), (C.int)(nbSamples)))
}
// AvAudioFifoWrite writes data to an AVAudioFifo.
func AvAudioFifoWrite(af *AvAudioFifo, data *unsafe.Pointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_write((*C.struct_AVAudioFifo)(af), data, (C.int)(nbSamples)))
func AvAudioFifoWrite(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_write((*C.struct_AVAudioFifo)(af), VoidPointerPointer(data), (C.int)(nbSamples)))
}
// AvAudioFifoPeek peeks data from an AVAudioFifo.
func AvAudioFifoPeek(af *AvAudioFifo, data *unsafe.Pointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_peek((*C.struct_AVAudioFifo)(af), data, (C.int)(nbSamples)))
func AvAudioFifoPeek(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_peek((*C.struct_AVAudioFifo)(af), VoidPointerPointer(data), (C.int)(nbSamples)))
}
// AvAudioFifoPeekAt peeks data from an AVAudioFifo.
func AvAudioFifoPeekAt(af *AvAudioFifo, data *unsafe.Pointer, nbSamples, offset int32) int32 {
return (int32)(C.av_audio_fifo_peek_at((*C.struct_AVAudioFifo)(af), data,
func AvAudioFifoPeekAt(af *AVAudioFifo, data CVoidPointerPointer, nbSamples, offset int32) int32 {
return (int32)(C.av_audio_fifo_peek_at((*C.struct_AVAudioFifo)(af), VoidPointerPointer(data),
(C.int)(nbSamples), (C.int)(offset)))
}
// AvAudioFifoRead reads data from an AVAudioFifo.
func AvAudioFifoRead(af *AvAudioFifo, data *unsafe.Pointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_read((*C.struct_AVAudioFifo)(af), data, (C.int)(nbSamples)))
func AvAudioFifoRead(af *AVAudioFifo, data CVoidPointerPointer, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_read((*C.struct_AVAudioFifo)(af), VoidPointerPointer(data), (C.int)(nbSamples)))
}
// AvAudioFifoDrain drains data from an AVAudioFifo.
func AvAudioFifoDrain(af *AvAudioFifo, nbSamples int32) int32 {
func AvAudioFifoDrain(af *AVAudioFifo, nbSamples int32) int32 {
return (int32)(C.av_audio_fifo_drain((*C.struct_AVAudioFifo)(af), (C.int)(nbSamples)))
}
// AvAudioFifoReset resets the AVAudioFifo buffer.
func AvAudioFifoReset(af *AvAudioFifo) {
func AvAudioFifoReset(af *AVAudioFifo) {
C.av_audio_fifo_reset((*C.struct_AVAudioFifo)(af))
}
// AvAudioFifoSize gets the current number of samples in the AVAudioFifo available for reading.
func AvAudioFifoSize(af *AvAudioFifo) int32 {
func AvAudioFifoSize(af *AVAudioFifo) int32 {
return (int32)(C.av_audio_fifo_size((*C.struct_AVAudioFifo)(af)))
}
// AvAudioFifoSpace gets the current number of samples in the AVAudioFifo available for writing.
func AvAudioFifoSpace(af *AvAudioFifo) int32 {
func AvAudioFifoSpace(af *AVAudioFifo) int32 {
return (int32)(C.av_audio_fifo_space((*C.struct_AVAudioFifo)(af)))
}

101
avutil_buffer.go
View File

@@ -11,119 +11,134 @@ typedef void (*av_buffer_pool_free_func)(void* opaque);
import "C"
import "unsafe"
// AvBufferRef
type AvBuffer C.struct_AVBuffer
// AVBufferRef
type AVBuffer C.struct_AVBuffer
// AvBufferRef
type AvBufferRef C.struct_AVBufferRef
// AVBufferRef
type AVBufferRef C.struct_AVBufferRef
// AvBufferAlloc allocates an AVBuffer of the given size using AvMalloc().
func AvBufferAlloc(size int32) *AvBufferRef {
return (*AvBufferRef)(C.av_buffer_alloc((C.int)(size)))
// Custom: GetBuffer gets `AVBufferRef.buffer` value.
func (bf *AVBufferRef) GetBuffer() *AVBuffer {
return (*AVBuffer)(bf.buffer)
}
// AvBufferAllocz same as AvBufferAlloc(), except the returned buffer will be initialized
// Custom: GetData gets `AVBufferRef.data` value.
func (bf *AVBufferRef) GetData() *uint8 {
return (*uint8)(bf.data)
}
// Custom: GetSize gets `AVBufferRef.size` value.
func (bf *AVBufferRef) GetSize() int32 {
return (int32)(bf.size)
}
// AvBufferAlloc allocates an AVBuffer of the given size using AvMalloc().
func AvBufferAlloc(size int32) *AVBufferRef {
return (*AVBufferRef)(C.av_buffer_alloc((C.int)(size)))
}
// AvBufferAllocz same as AVBufferAlloc(), except the returned buffer will be initialized
// to zero.
func AvBufferAllocz(size int32) *AvBufferRef {
return (*AvBufferRef)(C.av_buffer_allocz((C.int)(size)))
func AvBufferAllocz(size int32) *AVBufferRef {
return (*AVBufferRef)(C.av_buffer_allocz((C.int)(size)))
}
const AV_BUFFER_FLAG_READONLY = C.AV_BUFFER_FLAG_READONLY
// typedef void (*av_buffer_free_func)(void *opaque, uint8_t *data)
type AvBufferFreeFunc C.av_buffer_free_func
type AVBufferFreeFunc = C.av_buffer_free_func
// AvBufferCreate Create an AvBuffer from an existing array.
func AvBufferCreate(data *uint8, size int32, free AvBufferFreeFunc, opaque unsafe.Pointer, flags int32) *AvBufferRef {
return (*AvBufferRef)(C.av_buffer_create((*C.uint8_t)(data), (C.int)(size),
(C.av_buffer_free_func)(free), opaque, (C.int)(flags)))
// AvBufferCreate Create an AVBuffer from an existing array.
func AvBufferCreate(data *uint8, size int32, free AVBufferFreeFunc, opaque CVoidPointer, flags int32) *AVBufferRef {
return (*AVBufferRef)(C.av_buffer_create((*C.uint8_t)(data), (C.int)(size),
(C.av_buffer_free_func)(free), VoidPointer(opaque), (C.int)(flags)))
}
// AvBufferDefaultFree frees buffer data.
func AvBufferDefaultFree(opaque unsafe.Pointer, data *uint8) {
C.av_buffer_default_free(opaque, (*C.uint8_t)(data))
func AvBufferDefaultFree(opaque CVoidPointer, data *uint8) {
C.av_buffer_default_free(VoidPointer(opaque), (*C.uint8_t)(data))
}
// AvBufferRef creates a new reference to an AVBuffer.
func AvBufferReference(buf *AvBufferRef) *AvBufferRef {
return (*AvBufferRef)(C.av_buffer_ref((*C.struct_AVBufferRef)(buf)))
func AvBufferRef(buf *AVBufferRef) *AVBufferRef {
return (*AVBufferRef)(C.av_buffer_ref((*C.struct_AVBufferRef)(buf)))
}
// AvBufferUnreference frees a given reference and automatically free the buffer if there are no more
// AvBufferUnref frees a given reference and automatically free the buffer if there are no more
// references to it.
func AvBufferUnreference(buf **AvBufferRef) {
func AvBufferUnref(buf **AVBufferRef) {
C.av_buffer_unref((**C.struct_AVBufferRef)(unsafe.Pointer(buf)))
}
// AvBufferIsWritable returns 1 if the caller may write to the data referred to by buf (which is
// true if and only if buf is the only reference to the underlying AVBuffer).
// Return 0 otherwise.
func AvBufferIsWritable(buf *AvBufferRef) int32 {
func AvBufferIsWritable(buf *AVBufferRef) int32 {
return (int32)(C.av_buffer_is_writable((*C.struct_AVBufferRef)(buf)))
}
// AvBufferGetOpaque returns the opaque parameter set by AvBufferCreate.
func AvBufferGetOpaque(buf *AvBufferRef) unsafe.Pointer {
return (unsafe.Pointer)(C.av_buffer_get_opaque((*C.struct_AVBufferRef)(buf)))
// AvBufferGetOpaque returns the opaque parameter set by AVBufferCreate.
func AvBufferGetOpaque(buf *AVBufferRef) unsafe.Pointer {
return C.av_buffer_get_opaque((*C.struct_AVBufferRef)(buf))
}
// AvBufferGetRefCount
func AvBufferGetRefCount(buf *AvBufferRef) int32 {
func AvBufferGetRefCount(buf *AVBufferRef) int32 {
return (int32)(C.av_buffer_get_ref_count((*C.struct_AVBufferRef)(buf)))
}
// AvBufferMakeWritable creates a writable reference from a given buffer reference,
// avoiding data copy if possible.
func AvBufferMakeWritable(buf **AvBufferRef) int32 {
func AvBufferMakeWritable(buf **AVBufferRef) int32 {
return (int32)(C.av_buffer_make_writable((**C.struct_AVBufferRef)(unsafe.Pointer(buf))))
}
// AvBufferRealloc reallocates a given buffer.
func AvBufferRealloc(buf **AvBufferRef, size int32) int32 {
func AvBufferRealloc(buf **AVBufferRef, size int32) int32 {
return (int32)(C.av_buffer_realloc((**C.struct_AVBufferRef)(unsafe.Pointer(buf)), (C.int)(size)))
}
// AvBufferReplace ensures dst refers to the same data as src.
func AvBufferReplace(dst **AvBufferRef, src *AvBufferRef) int32 {
func AvBufferReplace(dst **AVBufferRef, src *AVBufferRef) int32 {
return (int32)(C.av_buffer_replace((**C.struct_AVBufferRef)(unsafe.Pointer(dst)),
(*C.struct_AVBufferRef)(src)))
}
type AvBufferPool C.struct_AVBufferPool
type AVBufferPool C.struct_AVBufferPool
// typedef AVBufferRef* (*av_buffer_pool_alloc_func)(int size)
type AvBufferPoolAllocFunc C.av_buffer_pool_alloc_func
type AVBufferPoolAllocFunc = C.av_buffer_pool_alloc_func
// typedef AVBufferRef* (*av_buffer_pool_alloc2_func)(void* opaque, int size)
type AvBufferPoolAlloc2Func C.av_buffer_pool_alloc2_func
type AVBufferPoolAlloc2Func = C.av_buffer_pool_alloc2_func
// typedef void (*av_buffer_pool_free_func)(void* opaque)
type AvBufferPoolFreeFunc C.av_buffer_pool_free_func
type AVBufferPoolFreeFunc = C.av_buffer_pool_free_func
// AvBufferPoolInit allocates and initializes a buffer pool.
func av_buffer_pool_init(size int32, alloc AvBufferPoolAllocFunc) *AvBufferPool {
return (*AvBufferPool)(C.av_buffer_pool_init((C.int)(size), (C.av_buffer_pool_alloc_func)(alloc)))
func AvBufferPoolInit(size int32, alloc AVBufferPoolAllocFunc) *AVBufferPool {
return (*AVBufferPool)(C.av_buffer_pool_init((C.int)(size), (C.av_buffer_pool_alloc_func)(alloc)))
}
// AvBufferPoolInit2 allocates and initialize a buffer pool with a more complex allocator.
func AvBufferPoolInit2(size int32, opaque unsafe.Pointer,
alloc AvBufferPoolAllocFunc, free AvBufferPoolFreeFunc) *AvBufferPool {
return (*AvBufferPool)(C.av_buffer_pool_init2((C.int)(size), opaque,
func AvBufferPoolInit2(size int32, opaque CVoidPointer,
alloc AVBufferPoolAllocFunc, free AVBufferPoolFreeFunc) *AVBufferPool {
return (*AVBufferPool)(C.av_buffer_pool_init2((C.int)(size), VoidPointer(opaque),
(C.av_buffer_pool_alloc_func)(alloc),
(C.av_buffer_pool_free_func)(free)))
}
// AvBufferPoolUninit marks the pool as being available for freeing.
func AvBufferPoolUninit(pool **AvBufferPool) {
func AvBufferPoolUninit(pool **AVBufferPool) {
C.av_buffer_pool_uninit((**C.struct_AVBufferPool)(unsafe.Pointer(pool)))
}
// AvBufferPoolGet allocates a new AVBuffer, reusing an old buffer from the pool when available.
func AvBufferPoolGet(pool *AvBufferPool) *AvBufferRef {
return (*AvBufferRef)(C.av_buffer_pool_get((*C.struct_AVBufferPool)(pool)))
func AvBufferPoolGet(pool *AVBufferPool) *AVBufferRef {
return (*AVBufferRef)(C.av_buffer_pool_get((*C.struct_AVBufferPool)(pool)))
}
// AvBufferPoolBufferGetOpaque queries the original opaque parameter of an allocated buffer in the pool.
func AvBufferPoolBufferGetOpaque(buf *AvBufferRef) unsafe.Pointer {
return (unsafe.Pointer)(C.av_buffer_pool_buffer_get_opaque((*C.struct_AVBufferRef)(buf)))
func AvBufferPoolBufferGetOpaque(buf *AVBufferRef) unsafe.Pointer {
return C.av_buffer_pool_buffer_get_opaque((*C.struct_AVBufferRef)(buf))
}

22
avutil_channel_layout.go
View File

@@ -73,17 +73,17 @@ const (
AV_CH_LAYOUT_22POINT2 = uint64(C.AV_CH_LAYOUT_22POINT2)
)
type AvMatrixEncoding = C.enum_AVMatrixEncoding
type AVMatrixEncoding = C.enum_AVMatrixEncoding
const (
AV_MATRIX_ENCODING_NONE = AvMatrixEncoding(C.AV_MATRIX_ENCODING_NONE)
AV_MATRIX_ENCODING_DOLBY = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBY)
AV_MATRIX_ENCODING_DPLII = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DPLII)
AV_MATRIX_ENCODING_DPLIIX = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DPLIIX)
AV_MATRIX_ENCODING_DPLIIZ = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DPLIIZ)
AV_MATRIX_ENCODING_DOLBYEX = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBYEX)
AV_MATRIX_ENCODING_DOLBYHEADPHONE = AvMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBYHEADPHONE)
AV_MATRIX_ENCODING_NB = AvMatrixEncoding(C.AV_MATRIX_ENCODING_NB)
AV_MATRIX_ENCODING_NONE = AVMatrixEncoding(C.AV_MATRIX_ENCODING_NONE)
AV_MATRIX_ENCODING_DOLBY = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBY)
AV_MATRIX_ENCODING_DPLII = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DPLII)
AV_MATRIX_ENCODING_DPLIIX = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DPLIIX)
AV_MATRIX_ENCODING_DPLIIZ = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DPLIIZ)
AV_MATRIX_ENCODING_DOLBYEX = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBYEX)
AV_MATRIX_ENCODING_DOLBYHEADPHONE = AVMatrixEncoding(C.AV_MATRIX_ENCODING_DOLBYHEADPHONE)
AV_MATRIX_ENCODING_NB = AVMatrixEncoding(C.AV_MATRIX_ENCODING_NB)
)
// AvGetChannelLayout returns a channel layout id that matches name, or 0 if no match is found.
@@ -111,8 +111,8 @@ func AvGetChannelLayoutString(nbChannels int32, channelLayout uint64) string {
return C.GoString((*C.char)(&buf[0]))
}
// AvBprintChannelLayout appends a description of a channel layout to a bprint buffer.
func AvBprintChannelLayout(bp *AvBPrint, nbChannels int32, channelLayout uint64) {
// AvBPrintChannelLayout appends a description of a channel layout to a bprint buffer.
func AvBPrintChannelLayout(bp *AVBPrint, nbChannels int32, channelLayout uint64) {
C.av_bprint_channel_layout((*C.struct_AVBPrint)(bp),
(C.int)(nbChannels), (C.uint64_t)(channelLayout))
}

32
avutil_dict.go
View File

@@ -16,26 +16,36 @@ const (
AV_DICT_MULTIKEY = C.AV_DICT_MULTIKEY
)
type AvDictionaryEntry C.struct_AVDictionaryEntry
type AVDictionaryEntry C.struct_AVDictionaryEntry
// Custom: GetKey gets `AVDictionaryEntry.key` value.
func (e *AVDictionaryEntry) GetKey() string {
return C.GoString(e.key)
}
// Custom: GetValue gets `AVDictionaryEntry.value` value.
func (e *AVDictionaryEntry) GetValue() string {
return C.GoString(e.value)
}
// AvDictionary gets a dictionary entry with matching key.
type AvDictionary C.struct_AVDictionary
type AVDictionary C.struct_AVDictionary
// AvDictGet
func AvDictGet(m *AvDictionary, key string, prev *AvDictionaryEntry, flags int32) *AvDictionaryEntry {
func AvDictGet(m *AVDictionary, key string, prev *AVDictionaryEntry, flags int32) *AVDictionaryEntry {
keyPtr, keyFunc := StringCasting(key)
defer keyFunc()
return (*AvDictionaryEntry)(C.av_dict_get((*C.struct_AVDictionary)(m),
return (*AVDictionaryEntry)(C.av_dict_get((*C.struct_AVDictionary)(m),
(*C.char)(keyPtr), (*C.struct_AVDictionaryEntry)(prev), (C.int)(flags)))
}
// AvDictCount gets number of entries in dictionary.
func AvDictCount(m *AvDictionary) int32 {
func AvDictCount(m *AVDictionary) int32 {
return (int32)(C.av_dict_count((*C.struct_AVDictionary)(m)))
}
// AvDictSet sets the given entry in *pm, overwriting an existing entry.
func AvDictSet(pm **AvDictionary, key, value string, flags int32) int32 {
func AvDictSet(pm **AVDictionary, key, value string, flags int32) int32 {
keyPtr, keyFunc := StringCasting(key)
defer keyFunc()
valuePtr, valueFunc := StringCasting(value)
@@ -45,7 +55,7 @@ func AvDictSet(pm **AvDictionary, key, value string, flags int32) int32 {
}
// AvDictSetInt sets the given entry in *pm, overwriting an existing entry.
func AvDictSetInt(pm **AvDictionary, key string, value int64, flags int32) int32 {
func AvDictSetInt(pm **AVDictionary, key string, value int64, flags int32) int32 {
keyPtr, keyFunc := StringCasting(key)
defer keyFunc()
return (int32)(C.av_dict_set_int((**C.struct_AVDictionary)(unsafe.Pointer(pm)),
@@ -53,7 +63,7 @@ func AvDictSetInt(pm **AvDictionary, key string, value int64, flags int32) int32
}
// AvDictParseString parses the key/value pairs list and add the parsed entries to a dictionary.
func AvDictParseString(pm **AvDictionary, str, keyValSep, pairsSep string, flags int32) int32 {
func AvDictParseString(pm **AVDictionary, str, keyValSep, pairsSep string, flags int32) int32 {
strPtr, strFunc := StringCasting(str)
defer strFunc()
keyValSepPtr, keyValSepFunc := StringCasting(keyValSep)
@@ -65,18 +75,18 @@ func AvDictParseString(pm **AvDictionary, str, keyValSep, pairsSep string, flags
}
// AvDictCopy copies entries from one AVDictionary struct into another.
func AvDictCopy(dst **AvDictionary, src *AvDictionary, flags int32) int32 {
func AvDictCopy(dst **AVDictionary, src *AVDictionary, flags int32) int32 {
return (int32)(C.av_dict_copy((**C.struct_AVDictionary)(unsafe.Pointer(dst)),
(*C.struct_AVDictionary)(src), (C.int)(flags)))
}
// AvDictFree frees all the memory allocated for an AVDictionary struct and all keys and values.
func AvDictFree(m **AvDictionary) {
func AvDictFree(m **AVDictionary) {
C.av_dict_free((**C.struct_AVDictionary)(unsafe.Pointer(m)))
}
// AvDictGetString get dictionary entries as a string.
func AvDictGetString(m *AvDictionary, buffer **int8, keyValSep, pairsSep string) int32 {
func AvDictGetString(m *AVDictionary, buffer **int8, keyValSep, pairsSep string) int32 {
keyValSepPtr, keyValSepFunc := StringCasting(keyValSep)
defer keyValSepFunc()
pairsSepPtr, pairsSepFunc := StringCasting(pairsSep)

7
avutil_error.go
View File

@@ -7,11 +7,12 @@ package ffmpeg
import "C"
// AVERROR returns a negative error code from a POSIX error code, to return from library functions.
func AVERROR(e int32) int32 {
func AVERROR[T HelperInteger](ie T) (oe int32) {
oe = (int32)(ie)
if C.EDOM > 0 {
return (-e)
return (-oe)
}
return e
return oe
}
// AVUNERROR returns a POSIX error code from a library function error return value.

818
avutil_frame.go
View File

File diff suppressed because it is too large Load Diff

546
avutil_hwcontext.go Normal file
View File

@@ -0,0 +1,546 @@
package ffmpeg
/*
#include <libavutil/hwcontext.h>
typedef void (*av_hw_device_context_free_func)(struct AVHWDeviceContext *ctx);
typedef void (*av_hw_frames_context_free_func)(struct AVHWFramesContext *ctx);
*/
import "C"
import "unsafe"
// AVHWDeviceType
type AVHWDeviceType = C.enum_AVHWDeviceType
const (
AV_HWDEVICE_TYPE_NONE = AVHWDeviceType(C.AV_HWDEVICE_TYPE_NONE)
AV_HWDEVICE_TYPE_VDPAU = AVHWDeviceType(C.AV_HWDEVICE_TYPE_VDPAU)
AV_HWDEVICE_TYPE_CUDA = AVHWDeviceType(C.AV_HWDEVICE_TYPE_CUDA)
AV_HWDEVICE_TYPE_VAAPI = AVHWDeviceType(C.AV_HWDEVICE_TYPE_VAAPI)
AV_HWDEVICE_TYPE_DXVA2 = AVHWDeviceType(C.AV_HWDEVICE_TYPE_DXVA2)
AV_HWDEVICE_TYPE_QSV = AVHWDeviceType(C.AV_HWDEVICE_TYPE_QSV)
AV_HWDEVICE_TYPE_VIDEOTOOLBOX = AVHWDeviceType(C.AV_HWDEVICE_TYPE_VIDEOTOOLBOX)
AV_HWDEVICE_TYPE_D3D11VA = AVHWDeviceType(C.AV_HWDEVICE_TYPE_D3D11VA)
AV_HWDEVICE_TYPE_DRM = AVHWDeviceType(C.AV_HWDEVICE_TYPE_DRM)
AV_HWDEVICE_TYPE_OPENCL = AVHWDeviceType(C.AV_HWDEVICE_TYPE_OPENCL)
AV_HWDEVICE_TYPE_MEDIACODEC = AVHWDeviceType(C.AV_HWDEVICE_TYPE_MEDIACODEC)
AV_HWDEVICE_TYPE_VULKAN = AVHWDeviceType(C.AV_HWDEVICE_TYPE_VULKAN)
)
type AVHWDeviceInternal C.struct_AVHWDeviceInternal
type AVHWDeviceContext C.struct_AVHWDeviceContext
type AVHWDeviceContextFreeFunc = C.av_hw_device_context_free_func
// Custom: GetAvClass gets `AVHWDeviceContext.av_class` value.
func (dc *AVHWDeviceContext) GetAvClass() *AVClass {
return (*AVClass)(dc.av_class)
}
// Custom: SetAvClass sets `AVHWDeviceContext.av_class` value.
func (dc *AVHWDeviceContext) SetAvClass(v *AVClass) {
dc.av_class = (*C.struct_AVClass)(v)
}
// Custom: GetAvClassAddr gets `AVHWDeviceContext.av_class` address.
func (dc *AVHWDeviceContext) GetAvClassAddr() **AVClass {
return (**AVClass)(unsafe.Pointer(&dc.av_class))
}
// Custom: GetInternal gets `AVHWDeviceContext.internal` value.
func (dc *AVHWDeviceContext) GetInternal() *AVHWDeviceInternal {
return (*AVHWDeviceInternal)(dc.internal)
}
// Custom: SetInternal sets `AVHWDeviceContext.internal` value.
func (dc *AVHWDeviceContext) SetInternal(v *AVHWDeviceInternal) {
dc.internal = (*C.struct_AVHWDeviceInternal)(v)
}
// Custom: GetInternalAddr gets `AVHWDeviceContext.internal` address.
func (dc *AVHWDeviceContext) GetInternalAddr() **AVHWDeviceInternal {
return (**AVHWDeviceInternal)(unsafe.Pointer(&dc.internal))
}
// Custom: GetType gets `AVHWDeviceContext.type` value.
func (dc *AVHWDeviceContext) GetType() AVHWDeviceType {
return (AVHWDeviceType)(dc._type)
}
// Custom: SetType sets `AVHWDeviceContext.type` value.
func (dc *AVHWDeviceContext) SetType(v AVHWDeviceType) {
dc._type = (C.enum_AVHWDeviceType)(v)
}
// Custom: GetTypeAddr gets `AVHWDeviceContext.type` address.
func (dc *AVHWDeviceContext) GetTypeAddr() *AVHWDeviceType {
return (*AVHWDeviceType)(&dc._type)
}
// Custom: GetHwctx gets `AVHWDeviceContext.hwctx` value.
func (dc *AVHWDeviceContext) GetHwctx() unsafe.Pointer {
return dc.hwctx
}
// Custom: SetHwctx sets `AVHWDeviceContext.hwctx` value.
func (dc *AVHWDeviceContext) SetHwctx(v CVoidPointer) {
dc.hwctx = VoidPointer(v)
}
// Custom: GetHwctxAddr gets `AVHWDeviceContext.hwctx` address.
func (dc *AVHWDeviceContext) GetHwctxAddr() *unsafe.Pointer {
return &dc.hwctx
}
// Custom: SetFree sets `AVHWDeviceContext.free` value.
func (dc *AVHWDeviceContext) SetFree(v AVHWDeviceContextFreeFunc) {
dc.free = (C.av_hw_device_context_free_func)(v)
}
// Custom: GetUserOpaque gets `AVHWDeviceContext.user_opaque` value.
func (dc *AVHWDeviceContext) GetUserOpaque() unsafe.Pointer {
return dc.user_opaque
}
// Custom: SetUserOpaque sets `AVHWDeviceContext.user_opaque` value.
func (dc *AVHWDeviceContext) SetUserOpaque(v CVoidPointer) {
dc.user_opaque = VoidPointer(v)
}
// Custom: GetUserOpaqueAddr gets `AVHWDeviceContext.user_opaque` address.
func (dc *AVHWDeviceContext) GetUserOpaqueAddr() *unsafe.Pointer {
return &dc.user_opaque
}
type AVHWFramesInternal C.struct_AVHWFramesInternal
type AVHWFramesContext C.struct_AVHWFramesContext
type AVHWFramesContextFreeFunc = C.av_hw_frames_context_free_func
// Custom: GetAvClass gets `AVHWFramesContext.av_class` value.
func (fc *AVHWFramesContext) GetAvClass() *AVClass {
return (*AVClass)(fc.av_class)
}
// Custom: SetAvClass sets `AVHWFramesContext.av_class` value.
func (fc *AVHWFramesContext) SetAvClass(v *AVClass) {
fc.av_class = (*C.struct_AVClass)(v)
}
// Custom: GetAvClassAddr gets `AVHWFramesContext.av_class` address.
func (fc *AVHWFramesContext) GetAvClassAddr() **AVClass {
return (**AVClass)(unsafe.Pointer(&fc.av_class))
}
// Custom: GetInternal gets `AVHWFramesContext.internal` value.
func (fc *AVHWFramesContext) GetInternal() *AVHWFramesInternal {
return (*AVHWFramesInternal)(fc.internal)
}
// Custom: SetInternal sets `AVHWFramesContext.internal` value.
func (fc *AVHWFramesContext) SetInternal(v *AVHWFramesInternal) {
fc.internal = (*C.struct_AVHWFramesInternal)(v)
}
// Custom: GetInternalAddr gets `AVHWFramesContext.internal` address.
func (fc *AVHWFramesContext) GetInternalAddr() **AVHWFramesInternal {
return (**AVHWFramesInternal)(unsafe.Pointer(&fc.internal))
}
// Custom: GetDeviceRef gets `AVHWFramesContext.device_ref` value.
func (fc *AVHWFramesContext) GetDeviceRef() *AVBufferRef {
return (*AVBufferRef)(fc.device_ref)
}
// Custom: SetDeviceRef sets `AVHWFramesContext.device_ref` value.
func (fc *AVHWFramesContext) SetDeviceRef(v *AVBufferRef) {
fc.device_ref = (*C.struct_AVBufferRef)(v)
}
// Custom: GetDeviceRefAddr gets `AVHWFramesContext.device_ref` address.
func (fc *AVHWFramesContext) GetDeviceRefAddr() **AVBufferRef {
return (**AVBufferRef)(unsafe.Pointer(&fc.device_ref))
}
// Custom: GetDeviceCtx gets `AVHWFramesContext.device_ctx` value.
func (fc *AVHWFramesContext) GetDeviceCtx() *AVHWDeviceContext {
return (*AVHWDeviceContext)(fc.device_ctx)
}
// Custom: SetDeviceCtx sets `AVHWFramesContext.device_ctx` value.
func (fc *AVHWFramesContext) SetDeviceCtx(v *AVHWDeviceContext) {
fc.device_ctx = (*C.struct_AVHWDeviceContext)(v)
}
// Custom: GetDeviceCtxAddr gets `AVHWFramesContext.device_ctx` address.
func (fc *AVHWFramesContext) GetDeviceCtxAddr() **AVHWDeviceContext {
return (**AVHWDeviceContext)(unsafe.Pointer(&fc.device_ctx))
}
// Custom: GetHwctx gets `AVHWFramesContext.hwctx` value.
func (fc *AVHWFramesContext) GetHwctx() unsafe.Pointer {
return (unsafe.Pointer)(fc.hwctx)
}
// Custom: SetHwctx sets `AVHWFramesContext.hwctx` value.
func (fc *AVHWFramesContext) SetHwctx(v CVoidPointer) {
fc.hwctx = VoidPointer(v)
}
// Custom: GetHwctxAddr gets `AVHWFramesContext.hwctx` address.
func (fc *AVHWFramesContext) GetHwctxAddr() *unsafe.Pointer {
return (*unsafe.Pointer)(&fc.hwctx)
}
// Custom: SetFree sets `AVHWFramesContext.free` value.
func (fc *AVHWFramesContext) SetFree(v AVHWFramesContextFreeFunc) {
fc.free = (C.av_hw_frames_context_free_func)(v)
}
// Custom: GetUserOpaque gets `AVHWFramesContext.user_opaque` value.
func (fc *AVHWFramesContext) GetUserOpaque() unsafe.Pointer {
return (unsafe.Pointer)(fc.user_opaque)
}
// Custom: SetUserOpaque sets `AVHWFramesContext.user_opaque` value.
func (fc *AVHWFramesContext) SetUserOpaque(v CVoidPointer) {
fc.user_opaque = VoidPointer(v)
}
// Custom: GetUserOpaqueAddr gets `AVHWFramesContext.user_opaque` address.
func (fc *AVHWFramesContext) GetUserOpaqueAddr() *unsafe.Pointer {
return (*unsafe.Pointer)(&fc.user_opaque)
}
// Custom: GetPool gets `AVHWFramesContext.pool` value.
func (fc *AVHWFramesContext) GetPool() *AVBufferPool {
return (*AVBufferPool)(fc.pool)
}
// Custom: SetPool sets `AVHWFramesContext.pool` value.
func (fc *AVHWFramesContext) SetPool(v *AVBufferPool) {
fc.pool = (*C.struct_AVBufferPool)(v)
}
// Custom: GetPoolAddr gets `AVHWFramesContext.pool` address.
func (fc *AVHWFramesContext) GetPoolAddr() **AVBufferPool {
return (**AVBufferPool)(unsafe.Pointer(&fc.pool))
}
// Custom: GetInitialPoolSize gets `AVHWFramesContext.initial_pool_size` value.
func (fc *AVHWFramesContext) GetInitialPoolSize() int32 {
return (int32)(fc.initial_pool_size)
}
// Custom: SetInitialPoolSize sets `AVHWFramesContext.initial_pool_size` value.
func (fc *AVHWFramesContext) SetInitialPoolSize(v int32) {
fc.initial_pool_size = (C.int)(v)
}
// Custom: GetInitialPoolSizeAddr gets `AVHWFramesContext.initial_pool_size` address.
func (fc *AVHWFramesContext) GetInitialPoolSizeAddr() *int32 {
return (*int32)(&fc.initial_pool_size)
}
// Custom: GetFormat gets `AVHWFramesContext.format` value.
func (fc *AVHWFramesContext) GetFormat() AVPixelFormat {
return (AVPixelFormat)(fc.format)
}
// Custom: SetFormat sets `AVHWFramesContext.format` value.
func (fc *AVHWFramesContext) SetFormat(v AVPixelFormat) {
fc.format = (C.enum_AVPixelFormat)(v)
}
// Custom: GetFormatAddr gets `AVHWFramesContext.format` address.
func (fc *AVHWFramesContext) GetFormatAddr() *AVPixelFormat {
return (*AVPixelFormat)(&fc.format)
}
// Custom: GetSwFormat gets `AVHWFramesContext.sw_format` value.
func (fc *AVHWFramesContext) GetSwFormat() AVPixelFormat {
return (AVPixelFormat)(fc.sw_format)
}
// Custom: SetSwFormat sets `AVHWFramesContext.sw_format` value.
func (fc *AVHWFramesContext) SetSwFormat(v AVPixelFormat) {
fc.sw_format = (C.enum_AVPixelFormat)(v)
}
// Custom: GetSwFormatAddr gets `AVHWFramesContext.sw_format` address.
func (fc *AVHWFramesContext) GetSwFormatAddr() *AVPixelFormat {
return (*AVPixelFormat)(&fc.sw_format)
}
// Custom: GetWidth gets `AVHWFramesContext.width` value.
func (fc *AVHWFramesContext) GetWidth() int32 {
return (int32)(fc.width)
}
// Custom: SetWidth sets `AVHWFramesContext.width` value.
func (fc *AVHWFramesContext) SetWidth(v int32) {
fc.width = (C.int)(v)
}
// Custom: GetWidthAddr gets `AVHWFramesContext.width` address.
func (fc *AVHWFramesContext) GetWidthAddr() *int32 {
return (*int32)(&fc.width)
}
// Custom: GetHeight gets `AVHWFramesContext.height` value.
func (fc *AVHWFramesContext) GetHeight() int32 {
return (int32)(fc.height)
}
// Custom: SetHeight sets `AVHWFramesContext.height` value.
func (fc *AVHWFramesContext) SetHeight(v int32) {
fc.height = (C.int)(v)
}
// Custom: GetHeightAddr gets `AVHWFramesContext.height` address.
func (fc *AVHWFramesContext) GetHeightAddr() *int32 {
return (*int32)(&fc.height)
}
// AvHWDeviceFindTypeByName looks up an AVHWDeviceType by name.
func AvHWDeviceFindTypeByName(name string) AVHWDeviceType {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (AVHWDeviceType)(C.av_hwdevice_find_type_by_name((*C.char)(namePtr)))
}
// AvHWDeviceGetTypeName gets the string name of an AVHWDeviceType.
func AvHWDeviceGetTypeName(_type AVHWDeviceType) string {
return C.GoString(C.av_hwdevice_get_type_name((C.enum_AVHWDeviceType)(_type)))
}
// AvHWDeviceIterateTypes iterates over supported device types.
func AvHWDeviceIterateTypes(prev AVHWDeviceType) AVHWDeviceType {
return (AVHWDeviceType)(C.av_hwdevice_iterate_types((C.enum_AVHWDeviceType)(prev)))
}
// AvHWDeviceCtxAlloc allocates an AVHWDeviceContext for a given hardware type.
func AvHWDeviceCtxAlloc(prev AVHWDeviceType) *AVBufferRef {
return (*AVBufferRef)(C.av_hwdevice_ctx_alloc((C.enum_AVHWDeviceType)(prev)))
}
// AvHWDeviceCtxInit finalizes the device context before use.
func AvHWDeviceCtxInit(ref *AVBufferRef) int32 {
return (int32)(C.av_hwdevice_ctx_init((*C.struct_AVBufferRef)(ref)))
}
// AvHWDeviceCtxCreate opens a device of the specified type and create an AVHWDeviceContext for it.
func AvHWDeviceCtxCreate(deviceCtx **AVBufferRef, _type AVHWDeviceType,
device string, opts *AVDictionary, flags int32) int32 {
devicePtr, deviceFunc := StringCasting(device)
defer deviceFunc()
return (int32)(C.av_hwdevice_ctx_create(
(**C.struct_AVBufferRef)(unsafe.Pointer(deviceCtx)),
(C.enum_AVHWDeviceType)(_type),
(*C.char)(devicePtr),
(*C.struct_AVDictionary)(opts),
(C.int)(flags)))
}
// AvHWDeviceCtxCreateDerived creates a new device of the specified type from an existing device.
func AvHWDeviceCtxCreateDerived(dstCtx **AVBufferRef, _type AVHWDeviceType,
srcCtx *AVBufferRef, flags int32) int32 {
return (int32)(C.av_hwdevice_ctx_create_derived(
(**C.struct_AVBufferRef)(unsafe.Pointer(dstCtx)),
(C.enum_AVHWDeviceType)(_type),
(*C.struct_AVBufferRef)(srcCtx),
(C.int)(flags)))
}
// AvHWDeviceCtxCreateDerivedOpts creates a new device of the specified type from an existing device.
func AvHWDeviceCtxCreateDerivedOpts(dstCtx **AVBufferRef, _type AVHWDeviceType,
srcCtx *AVBufferRef, options *AVDictionary, flags int32) int32 {
return (int32)(C.av_hwdevice_ctx_create_derived_opts(
(**C.struct_AVBufferRef)(unsafe.Pointer(dstCtx)),
(C.enum_AVHWDeviceType)(_type),
(*C.struct_AVBufferRef)(srcCtx),
(*C.struct_AVDictionary)(options),
(C.int)(flags)))
}
// AvHWFrameCtxAlloc allocates an AVHWFramesContext tied to a given device context.
func AvHWFrameCtxAlloc(deviceCtx *AVBufferRef) *AVBufferRef {
return (*AVBufferRef)(C.av_hwframe_ctx_alloc((*C.struct_AVBufferRef)(deviceCtx)))
}
// AvHWFrameCtxInit finalizes the context before use.
func AvHWFrameCtxInit(ref *AVBufferRef) int32 {
return (int32)(C.av_hwframe_ctx_init((*C.struct_AVBufferRef)(ref)))
}
// AvHWFrameGetBuffer allocates a new frame attached to the given AVHWFramesContext.
func AvHWFrameGetBuffer(hwframeCtx *AVBufferRef, frame *AVFrame, flags int32) int32 {
return (int32)(C.av_hwframe_get_buffer((*C.struct_AVBufferRef)(hwframeCtx),
(*C.struct_AVFrame)(frame), (C.int)(flags)))
}
// AvHWFrameTransferData copies data to or from a hw surface.
func AvHWFrameTransferData(dst, src *AVFrame, flags int32) int32 {
return (int32)(C.av_hwframe_transfer_data(
(*C.struct_AVFrame)(dst),
(*C.struct_AVFrame)(src),
(C.int)(flags)))
}
type AVHWFrameTransferDirection = C.enum_AVHWFrameTransferDirection
const (
AV_HWFRAME_TRANSFER_DIRECTION_FROM = AVHWFrameTransferDirection(C.AV_HWFRAME_TRANSFER_DIRECTION_FROM)
AV_HWFRAME_TRANSFER_DIRECTION_TO = AVHWFrameTransferDirection(C.AV_HWFRAME_TRANSFER_DIRECTION_TO)
)
// AvHWFrameTransferGetFormats gets a list of possible source or target formats usable in
// AvHWFrameTransferData().
func AvHWFrameTransferGetFormats(hwframeCtx *AVBufferRef, dir AVHWFrameTransferDirection,
formats **AVPixelFormat, flags int32) int32 {
return (int32)(C.av_hwframe_transfer_get_formats((*C.struct_AVBufferRef)(hwframeCtx),
(C.enum_AVHWFrameTransferDirection)(dir),
(**C.enum_AVPixelFormat)(unsafe.Pointer(formats)),
(C.int)(flags)))
}
type AVHWFramesConstraints C.struct_AVHWFramesConstraints
// Custom: GetValidHwFormats gets `AVHWFramesConstraints.valid_hw_formats` value.
func (fcs *AVHWFramesConstraints) GetValidHwFormats() []AVPixelFormat {
return TruncSlice((*AVPixelFormat)(fcs.valid_hw_formats), func(pf AVPixelFormat) bool {
return pf == AV_PIX_FMT_NONE
})
}
// Custom: SetValidHwFormats sets `AVHWFramesConstraints.valid_hw_formats` value.
func (fcs *AVHWFramesConstraints) SetValidHwFormats(v *AVPixelFormat) {
fcs.valid_hw_formats = (*C.enum_AVPixelFormat)(v)
}
// Custom: GetValidHwFormatsAddr gets `AVHWFramesConstraints.valid_hw_formats` address.
func (fcs *AVHWFramesConstraints) GetValidHwFormatsAddr() **AVPixelFormat {
return (**AVPixelFormat)(&fcs.valid_hw_formats)
}
// Custom: GetValidSwFormats gets `AVHWFramesConstraints.valid_sw_formats` value.
func (fcs *AVHWFramesConstraints) GetValidSwFormats() []AVPixelFormat {
return TruncSlice((*AVPixelFormat)(fcs.valid_sw_formats), func(pf AVPixelFormat) bool {
return pf == AV_PIX_FMT_NONE
})
}
// Custom: SetValidSwFormats sets `AVHWFramesConstraints.valid_sw_formats` value.
func (fcs *AVHWFramesConstraints) SetValidSwFormats(v *AVPixelFormat) {
fcs.valid_sw_formats = (*C.enum_AVPixelFormat)(v)
}
// Custom: GetValidSwFormatsAddr gets `AVHWFramesConstraints.valid_sw_formats` address.
func (fcs *AVHWFramesConstraints) GetValidSwFormatsAddr() **AVPixelFormat {
return (**AVPixelFormat)(&fcs.valid_sw_formats)
}
// Custom: GetMinWidth gets `AVHWFramesConstraints.min_width` value.
func (fcs *AVHWFramesConstraints) GetMinWidth() int32 {
return (int32)(fcs.min_width)
}
// Custom: SetMinWidth sets `AVHWFramesConstraints.min_width` value.
func (fcs *AVHWFramesConstraints) SetMinWidth(v int32) {
fcs.min_width = (C.int)(v)
}
// Custom: GetMinWidthAddr gets `AVHWFramesConstraints.min_width` address.
func (fcs *AVHWFramesConstraints) GetMinWidthAddr() *int32 {
return (*int32)(&fcs.min_width)
}
// Custom: GetMinHeight gets `AVHWFramesConstraints.min_height` value.
func (fcs *AVHWFramesConstraints) GetMinHeight() int32 {
return (int32)(fcs.min_height)
}
// Custom: SetMinHeight sets `AVHWFramesConstraints.min_height` value.
func (fcs *AVHWFramesConstraints) SetMinHeight(v int32) {
fcs.min_height = (C.int)(v)
}
// Custom: GetMinHeightAddr gets `AVHWFramesConstraints.min_height` address.
func (fcs *AVHWFramesConstraints) GetMinHeightAddr() *int32 {
return (*int32)(&fcs.min_height)
}
// Custom: GetMaxWidth gets `AVHWFramesConstraints.max_width` value.
func (fcs *AVHWFramesConstraints) GetMaxWidth() int32 {
return (int32)(fcs.max_width)
}
// Custom: SetMaxWidth sets `AVHWFramesConstraints.max_width` value.
func (fcs *AVHWFramesConstraints) SetMaxWidth(v int32) {
fcs.max_width = (C.int)(v)
}
// Custom: GetMaxWidthAddr gets `AVHWFramesConstraints.max_width` address.
func (fcs *AVHWFramesConstraints) GetMaxWidthAddr() *int32 {
return (*int32)(&fcs.max_width)
}
// Custom: GetMaxHeight gets `AVHWFramesConstraints.max_height` value.
func (fcs *AVHWFramesConstraints) GetMaxHeight() int32 {
return (int32)(fcs.max_height)
}
// Custom: SetMaxHeight sets `AVHWFramesConstraints.max_height` value.
func (fcs *AVHWFramesConstraints) SetMaxHeight(v int32) {
fcs.max_height = (C.int)(v)
}
// Custom: GetMaxHeightAddr gets `AVHWFramesConstraints.max_height` address.
func (fcs *AVHWFramesConstraints) GetMaxHeightAddr() *int32 {
return (*int32)(&fcs.max_height)
}
// AvHWDeviceHwconfigAlloc allocates a HW-specific configuration structure for a given HW device.
func AvHWDeviceHwconfigAlloc(deviceCtx *AVBufferRef) unsafe.Pointer {
return C.av_hwdevice_hwconfig_alloc((*C.struct_AVBufferRef)(deviceCtx))
}
// AvHWDeviceGetHwframeConstraints
func AvHWDeviceGetHwframeConstraints(ref *AVBufferRef, hwconfig CVoidPointer) *AVHWFramesConstraints {
return (*AVHWFramesConstraints)(C.av_hwdevice_get_hwframe_constraints(
(*C.struct_AVBufferRef)(ref), VoidPointer(hwconfig)))
}
// AvHWFrameConstraintsFree frees an AVHWFrameConstraints structure.
func AvHWFrameConstraintsFree(constraints **AVHWFramesConstraints) {
C.av_hwframe_constraints_free((**C.struct_AVHWFramesConstraints)(unsafe.Pointer(constraints)))
}
const (
AV_HWFRAME_MAP_READ = int32(C.AV_HWFRAME_MAP_READ)
AV_HWFRAME_MAP_WRITE = int32(C.AV_HWFRAME_MAP_WRITE)
AV_HWFRAME_MAP_OVERWRITE = int32(C.AV_HWFRAME_MAP_OVERWRITE)
AV_HWFRAME_MAP_DIRECT = int32(C.AV_HWFRAME_MAP_DIRECT)
)
// AvHWFrameMap maps a hardware frame.
func AvHWFrameMap(dst, src *AVFrame, flags int32) int32 {
return (int32)(C.av_hwframe_map(
(*C.struct_AVFrame)(dst),
(*C.struct_AVFrame)(src),
(C.int)(flags)))
}
// AvHWFrameCtxCreateDerived creates and initialises an AVHWFramesContext as a mapping of another existing
// AvHWFramesContext on a different device.
func AvHWFrameCtxCreateDerived(derivedFrameCtx **AVBufferRef, format AVPixelFormat,
derivedDeviceCtx, sourceFrameCtx *AVBufferRef, flags int32) int32 {
return (int32)(C.av_hwframe_ctx_create_derived(
(**C.struct_AVBufferRef)(unsafe.Pointer(derivedFrameCtx)),
(C.enum_AVPixelFormat)(format),
(*C.struct_AVBufferRef)(derivedDeviceCtx),
(*C.struct_AVBufferRef)(sourceFrameCtx),
(C.int)(flags)))
}

136
avutil_imgutils.go
View File

@@ -10,12 +10,12 @@ import (
// AvImageFillMaxPixsteps computes the max pixel step for each plane of an image with a
// format described by pixdesc.
func AvImageFillMaxPixsteps(maxPixsteps, maxPixstepComps []int32, pixdesc *AvPixFmtDescriptor) {
if len(maxPixsteps) != 4 {
panic("maxPixsteps need len = 4")
func AvImageFillMaxPixsteps(maxPixsteps, maxPixstepComps []int32, pixdesc *AVPixFmtDescriptor) {
if len(maxPixsteps) < 4 {
panic("maxPixsteps len < 4")
}
if len(maxPixstepComps) != 4 {
panic("maxPixstepComps need len = 4")
if len(maxPixstepComps) < 4 {
panic("maxPixstepComps len < 4")
}
C.av_image_fill_max_pixsteps((*C.int)(&maxPixsteps[0]), (*C.int)(&maxPixstepComps[0]),
(*C.struct_AVPixFmtDescriptor)(pixdesc))
@@ -23,40 +23,40 @@ func AvImageFillMaxPixsteps(maxPixsteps, maxPixstepComps []int32, pixdesc *AvPix
// AvImageGetLinesize computes the size of an image line with format pix_fmt and width
// width for the plane plane.
func AvImageGetLinesize(pixFmt AvPixelFormat, width, plane int32) int32 {
func AvImageGetLinesize(pixFmt AVPixelFormat, width, plane int32) int32 {
return (int32)(C.av_image_get_linesize((C.enum_AVPixelFormat)(pixFmt),
(C.int)(width), (C.int)(plane)))
}
// AvImageFillLinesizes fills plane linesizes for an image with pixel format pix_fmt and width width.
func AvImageFillLinesizes(linesizes []int32, pixFmt AvPixelFormat, width int32) int32 {
if len(linesizes) != 4 {
panic("linesizes need len = 4")
func AvImageFillLinesizes(linesizes []int32, pixFmt AVPixelFormat, width int32) int32 {
if len(linesizes) < 4 {
panic("linesizes len < 4")
}
return (int32)(C.av_image_fill_linesizes((*C.int)(&linesizes[0]),
(C.enum_AVPixelFormat)(pixFmt), (C.int)(width)))
}
// AvImageFillPlaneSizes fills plane sizes for an image with pixel format pix_fmt and height height.
func AvImageFillPlaneSizes(size []uint, pixFmt AvPixelFormat, height int32, linesizes []int) int32 {
if len(size) != 4 {
panic("size need len = 4")
func AvImageFillPlaneSizes(size []uint, pixFmt AVPixelFormat, height int32, linesizes []int) int32 {
if len(size) < 4 {
panic("size len < 4")
}
if len(linesizes) != 4 {
panic("linesizes need len = 4")
if len(linesizes) < 4 {
panic("linesizes len < 4")
}
return (int32)(C.av_image_fill_plane_sizes((*C.size_t)(unsafe.Pointer(&size[0])),
(C.enum_AVPixelFormat)(pixFmt), (C.int)(height), (*C.ptrdiff_t)(unsafe.Pointer(&linesizes[0]))))
}
// AvImageFillPointers fills plane data pointers for an image with pixel format pix_fmt and height height.
func AvImageFillPointers(data []*uint8, pixFmt AvPixelFormat,
func AvImageFillPointers(data []*uint8, pixFmt AVPixelFormat,
height int32, ptr *uint8, linesizes []int32) int32 {
if len(data) != 4 {
panic("data need len = 4")
if len(data) < 4 {
panic("data len < 4")
}
if len(linesizes) != 4 {
panic("linesizes need len = 4")
if len(linesizes) < 4 {
panic("linesizes len < 4")
}
return (int32)(C.av_image_fill_pointers((**C.uint8_t)(unsafe.Pointer(&data[0])),
(C.enum_AVPixelFormat)(pixFmt), (C.int)(height), (*C.uint8_t)(ptr),
@@ -66,12 +66,12 @@ func AvImageFillPointers(data []*uint8, pixFmt AvPixelFormat,
// AvImageAlloc allocates an image with size w and h and pixel format pix_fmt, and
// fill pointers and linesizes accordingly.
func AvImageAlloc(pointers []*uint8, linesizes []int32, w, h int32,
pixFmt AvPixelFormat, align int32) int32 {
if len(pointers) != 4 {
panic("pointers need len = 4")
pixFmt AVPixelFormat, align int32) int32 {
if len(pointers) < 4 {
panic("pointers len < 4")
}
if len(linesizes) != 4 {
panic("linesizes need len = 4")
if len(linesizes) < 4 {
panic("linesizes len < 4")
}
return (int32)(C.av_image_alloc((**C.uint8_t)(unsafe.Pointer(&pointers[0])),
(*C.int)(&linesizes[0]),
@@ -88,18 +88,18 @@ func AvImageCopyPlane(dst *uint8, dstLinesize int32, src *uint8,
// AvImageCopy copies image in src_data to dst_data.
func AvImageCopy(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLinesizes []int32,
pixFmt AvPixelFormat, width, height int32) {
if len(dstData) != 4 {
panic("dstData need len = 4")
pixFmt AVPixelFormat, width, height int32) {
if len(dstData) < 4 {
panic("dstData len < 4")
}
if len(dstLinesizes) != 4 {
panic("dstLinesizes need len = 4")
if len(dstLinesizes) < 4 {
panic("dstLinesizes len < 4")
}
if len(srcData) != 4 {
panic("srcData need len = 4")
if len(srcData) < 4 {
panic("srcData len < 4")
}
if len(srcLinesizes) != 4 {
panic("srcLinesizes need len = 4")
if len(srcLinesizes) < 4 {
panic("srcLinesizes len < 4")
}
C.av_image_copy((**C.uint8_t)(unsafe.Pointer(&dstData[0])),
(*C.int)(&dstLinesizes[0]),
@@ -110,18 +110,18 @@ func AvImageCopy(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLi
// AvImageCopyUcFrom copies image data located in uncacheable (e.g. GPU mapped) memory.
func AvImageCopyUcFrom(dstData []*uint8, dstLinesizes []int, srcData []*uint8, srcLinesizes []int,
pixFmt AvPixelFormat, width, height int32) {
if len(dstData) != 4 {
panic("dstData need len = 4")
pixFmt AVPixelFormat, width, height int32) {
if len(dstData) < 4 {
panic("dstData len < 4")
}
if len(dstLinesizes) != 4 {
panic("dstLinesizes need len = 4")
if len(dstLinesizes) < 4 {
panic("dstLinesizes len < 4")
}
if len(srcData) != 4 {
panic("srcData need len = 4")
if len(srcData) < 4 {
panic("srcData len < 4")
}
if len(srcLinesizes) != 4 {
panic("srcLinesizes need len = 4")
if len(srcLinesizes) < 4 {
panic("srcLinesizes len < 4")
}
C.av_image_copy_uc_from((**C.uint8_t)(unsafe.Pointer(&dstData[0])),
(*C.ptrdiff_t)(unsafe.Pointer(&dstLinesizes[0])),
@@ -133,12 +133,12 @@ func AvImageCopyUcFrom(dstData []*uint8, dstLinesizes []int, srcData []*uint8, s
// AvImageFillArrays setups the data pointers and linesizes based on the specified image
// parameters and the provided array.
func AvImageFillArrays(dstData []*uint8, dstLinesize []int32, src *uint8,
pixFmt AvPixelFormat, width, height, align int32) {
if len(dstData) != 4 {
panic("dstData need len = 4")
pixFmt AVPixelFormat, width, height, align int32) {
if len(dstData) < 4 {
panic("dstData len < 4")
}
if len(dstLinesize) != 4 {
panic("dstLinesize need len = 4")
if len(dstLinesize) < 4 {
panic("dstLinesize len < 4")
}
C.av_image_fill_arrays((**C.uint8_t)(unsafe.Pointer(&dstData[0])),
(*C.int)(&dstLinesize[0]),
@@ -148,53 +148,53 @@ func AvImageFillArrays(dstData []*uint8, dstLinesize []int32, src *uint8,
// AvImageGetBufferSize Return the size in bytes of the amount of data required to store an
// image with the given parameters.
func AvImageGetBufferSize(pixFmt AvPixelFormat, width, height, align int32) int32 {
func AvImageGetBufferSize(pixFmt AVPixelFormat, width, height, align int32) int32 {
return (int32)(C.av_image_get_buffer_size((C.enum_AVPixelFormat)(pixFmt),
(C.int)(width), (C.int)(height), (C.int)(align)))
}
// av_image_copy_to_buffer
func av_image_copy_to_buffer(dst *uint8, dstSize int32, srcData []*uint8, srcLinesize []int32,
pixFmt AvPixelFormat, width, height, align int32) {
if len(srcData) != 4 {
panic("srcData need len = 4")
// AvImageCopyToBuffer copies image data from an image into a buffer.
func AvImageCopyToBuffer(dst *uint8, dstSize int32, srcData []*uint8, srcLinesize []int32,
pixFmt AVPixelFormat, width, height, align int32) int32 {
if len(srcData) < 4 {
panic("srcData len < 4")
}
if len(srcLinesize) != 4 {
panic("srcLinesize need len = 4")
if len(srcLinesize) < 4 {
panic("srcLinesize len < 4")
}
C.av_image_copy_to_buffer((*C.uint8_t)(dst), (C.int)(dstSize),
return (int32)(C.av_image_copy_to_buffer((*C.uint8_t)(dst), (C.int)(dstSize),
(**C.uint8_t)(unsafe.Pointer(&srcData[0])), (*C.int)(&srcLinesize[0]),
(C.enum_AVPixelFormat)(pixFmt), (C.int)(width), (C.int)(height), (C.int)(align))
(C.enum_AVPixelFormat)(pixFmt), (C.int)(width), (C.int)(height), (C.int)(align)))
}
// AvImageCheckSize checks if the given dimension of an image is valid, meaning that all
// bytes of the image can be addressed with a signed int.
func AvImageCheckSize(w, h uint32, logOffset int32, logCtx unsafe.Pointer) int32 {
return (int32)(C.av_image_check_size((C.uint)(w), (C.uint)(h), (C.int)(logOffset), logCtx))
func AvImageCheckSize(w, h uint32, logOffset int32, logCtx CVoidPointer) int32 {
return (int32)(C.av_image_check_size((C.uint)(w), (C.uint)(h), (C.int)(logOffset), VoidPointer(logCtx)))
}
// AvImageCheckSize2 checks if the given dimension of an image is valid, meaning that all
// bytes of a plane of an image with the specified pix_fmt can be addressed with a signed int.
func AvImageCheckSize2(w, h uint32, maxPixels int64, pixFmt AvPixelFormat,
logOffset int32, logCtx unsafe.Pointer) int32 {
func AvImageCheckSize2(w, h uint32, maxPixels int64, pixFmt AVPixelFormat,
logOffset int32, logCtx CVoidPointer) int32 {
return (int32)(C.av_image_check_size2((C.uint)(w), (C.uint)(h),
(C.int64_t)(maxPixels), (C.enum_AVPixelFormat)(pixFmt),
(C.int)(logOffset), logCtx))
(C.int)(logOffset), VoidPointer(logCtx)))
}
// AvImageCheckSar checks if the given sample aspect ratio of an image is valid.
func AvImageCheckSar(w, h uint32, sar AvRational) int32 {
func AvImageCheckSar(w, h uint32, sar AVRational) int32 {
return (int32)(C.av_image_check_sar((C.uint)(w), (C.uint)(h), (C.struct_AVRational)(sar)))
}
// AvImageFillBlack overwrites the image data with black.
func AvImageFillBlack(dstData []*uint8, dstLinesize []int,
pixFmt AvPixelFormat, _range AvColorRange, width, height int32) int32 {
if len(dstData) != 4 {
panic("dstData need len = 4")
pixFmt AVPixelFormat, _range AVColorRange, width, height int32) int32 {
if len(dstData) < 4 {
panic("dstData len < 4")
}
if len(dstLinesize) != 4 {
panic("dstLinesize need len = 4")
if len(dstLinesize) < 4 {
panic("dstLinesize len < 4")
}
return (int32)(C.av_image_fill_black((**C.uint8_t)(unsafe.Pointer(&dstData[0])),
(*C.ptrdiff_t)(unsafe.Pointer(&dstLinesize[0])),

103
avutil_log.go
View File

@@ -17,47 +17,76 @@ typedef void (*av_log_callback_func)(void*, int, const char*, va_list);
import "C"
import (
"fmt"
"unsafe"
)
// AvClassCategory
type AvClassCategory = int32
// AVClassCategory
type AVClassCategory = int32
const (
AV_CLASS_CATEGORY_NA = AvClassCategory(C.AV_CLASS_CATEGORY_NA)
AV_CLASS_CATEGORY_INPUT = AvClassCategory(C.AV_CLASS_CATEGORY_INPUT)
AV_CLASS_CATEGORY_OUTPUT = AvClassCategory(C.AV_CLASS_CATEGORY_OUTPUT)
AV_CLASS_CATEGORY_MUXER = AvClassCategory(C.AV_CLASS_CATEGORY_MUXER)
AV_CLASS_CATEGORY_DEMUXER = AvClassCategory(C.AV_CLASS_CATEGORY_DEMUXER)
AV_CLASS_CATEGORY_ENCODER = AvClassCategory(C.AV_CLASS_CATEGORY_ENCODER)
AV_CLASS_CATEGORY_DECODER = AvClassCategory(C.AV_CLASS_CATEGORY_DECODER)
AV_CLASS_CATEGORY_FILTER = AvClassCategory(C.AV_CLASS_CATEGORY_FILTER)
AV_CLASS_CATEGORY_BITSTREAM_FILTER = AvClassCategory(C.AV_CLASS_CATEGORY_BITSTREAM_FILTER)
AV_CLASS_CATEGORY_SWSCALER = AvClassCategory(C.AV_CLASS_CATEGORY_SWSCALER)
AV_CLASS_CATEGORY_SWRESAMPLER = AvClassCategory(C.AV_CLASS_CATEGORY_SWRESAMPLER)
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT)
AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT)
AV_CLASS_CATEGORY_DEVICE_OUTPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_INPUT = AvClassCategory(C.AV_CLASS_CATEGORY_DEVICE_INPUT)
AV_CLASS_CATEGORY_NB = AvClassCategory(C.AV_CLASS_CATEGORY_NB)
AV_CLASS_CATEGORY_NA = AVClassCategory(C.AV_CLASS_CATEGORY_NA)
AV_CLASS_CATEGORY_INPUT = AVClassCategory(C.AV_CLASS_CATEGORY_INPUT)
AV_CLASS_CATEGORY_OUTPUT = AVClassCategory(C.AV_CLASS_CATEGORY_OUTPUT)
AV_CLASS_CATEGORY_MUXER = AVClassCategory(C.AV_CLASS_CATEGORY_MUXER)
AV_CLASS_CATEGORY_DEMUXER = AVClassCategory(C.AV_CLASS_CATEGORY_DEMUXER)
AV_CLASS_CATEGORY_ENCODER = AVClassCategory(C.AV_CLASS_CATEGORY_ENCODER)
AV_CLASS_CATEGORY_DECODER = AVClassCategory(C.AV_CLASS_CATEGORY_DECODER)
AV_CLASS_CATEGORY_FILTER = AVClassCategory(C.AV_CLASS_CATEGORY_FILTER)
AV_CLASS_CATEGORY_BITSTREAM_FILTER = AVClassCategory(C.AV_CLASS_CATEGORY_BITSTREAM_FILTER)
AV_CLASS_CATEGORY_SWSCALER = AVClassCategory(C.AV_CLASS_CATEGORY_SWSCALER)
AV_CLASS_CATEGORY_SWRESAMPLER = AVClassCategory(C.AV_CLASS_CATEGORY_SWRESAMPLER)
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT)
AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT)
AV_CLASS_CATEGORY_DEVICE_OUTPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_OUTPUT)
AV_CLASS_CATEGORY_DEVICE_INPUT = AVClassCategory(C.AV_CLASS_CATEGORY_DEVICE_INPUT)
AV_CLASS_CATEGORY_NB = AVClassCategory(C.AV_CLASS_CATEGORY_NB)
)
func AV_IS_INPUT_DEVICE(c AvClassCategory) bool {
func Av_IS_INPUT_DEVICE(c AVClassCategory) bool {
return c == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT ||
c == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT ||
c == AV_CLASS_CATEGORY_DEVICE_INPUT
}
func AV_IS_OUTPUT_DEVICE(c AvClassCategory) bool {
func Av_IS_OUTPUT_DEVICE(c AVClassCategory) bool {
return c == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT ||
c == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT ||
c == AV_CLASS_CATEGORY_DEVICE_OUTPUT
}
// AvClass
type AvClass C.struct_AVClass
// AVClass
type AVClass C.struct_AVClass
// Custom: GetClassName gets `AVClass.class_name` value.
func (cls *AVClass) GetClassName() string {
return C.GoString(cls.class_name)
}
// Custom: GetOption gets `AVClass.option` value.
func (cls *AVClass) GetOption() *AVOption {
return (*AVOption)(cls.option)
}
// Custom: GetVersion gets `AVClass.version` value.
func (cls *AVClass) GetVersion() int32 {
return (int32)(cls.version)
}
// Custom: GetLogLevelOffsetOffset gets `AVClass.log_level_offset_offset` value.
func (cls *AVClass) GetLogLevelOffsetOffset() int32 {
return (int32)(cls.log_level_offset_offset)
}
// Custom: GetParentLogContextOffset gets `AVClass.parent_log_context_offset` value.
func (cls *AVClass) GetParentLogContextOffset() int32 {
return (int32)(cls.parent_log_context_offset)
}
// Custom: GetCategory gets `AVClass.category` value.
func (cls *AVClass) GetCategory() AVClassCategory {
return (AVClassCategory)(cls.category)
}
const (
AV_LOG_QUIET = int32(C.AV_LOG_QUIET)
@@ -75,27 +104,27 @@ const (
AV_LOG_MAX_OFFSET = int32(C.AV_LOG_MAX_OFFSET)
)
// AV_LOG_C sets additional colors for extended debugging sessions.
func AV_LOG_C(x int32) int32 {
// Av_LOG_C sets additional colors for extended debugging sessions.
func Av_LOG_C(x int32) int32 {
return x << 8
}
// AvLog sends the specified message to the log if the level is less than or equal
// to the current av_log_level. By default, all logging messages are sent to stderr.
// This behavior can be altered by setting a different logging callback function.
func AvLog(avcl unsafe.Pointer, level int32, _fmt string, va ...any) {
func AvLog(avcl CVoidPointer, level int32, _fmt string, va ...any) {
strPtr, strFunc := StringCasting(fmt.Sprintf(_fmt, va...))
defer strFunc()
C.av_log_wrap(avcl, (C.int)(level), (*C.char)(strPtr))
C.av_log_wrap(VoidPointer(avcl), (C.int)(level), (*C.char)(strPtr))
}
// AvLogOnce sends the specified message to the log once with the initial_level and then with
// the subsequent_level. By default, all logging messages are sent to stderr.
// This behavior can be altered by setting a different logging callback function.
func AvLogOnce(avcl unsafe.Pointer, initialLevel, subsequentLevel int32, state *int32, _fmt string, va ...any) {
func AvLogOnce(avcl CVoidPointer, initialLevel, subsequentLevel int32, state *int32, _fmt string, va ...any) {
fmtPtr, fmtFunc := StringCasting(fmt.Sprintf(_fmt, va...))
defer fmtFunc()
C.av_log_once_wrap(avcl, (C.int)(initialLevel), (C.int)(subsequentLevel), (*C.int)(state), (*C.char)(fmtPtr))
C.av_log_once_wrap(VoidPointer(avcl), (C.int)(initialLevel), (C.int)(subsequentLevel), (*C.int)(state), (*C.char)(fmtPtr))
}
// NONEED: av_vlog
@@ -111,23 +140,23 @@ func AvLogSetLevel(level int32) {
}
// typedef void (*av_log_callback_func)(void*, int, const char*, va_list)
type AvLogCallbackFunc C.av_log_callback_func
type AVLogCallbackFunc = C.av_log_callback_func
// AvLogSetCallback sets the logging callback
func AvLogSetCallback(f AvLogCallbackFunc) {
func AvLogSetCallback(f AVLogCallbackFunc) {
C.av_log_set_callback(f)
}
// NONEED: av_log_default_callback
// AvDefaultItemName returns the context name
func AvDefaultItemName(ctx unsafe.Pointer) string {
return C.GoString(C.av_default_item_name(ctx))
func AvDefaultItemName(ctx CVoidPointer) string {
return C.GoString(C.av_default_item_name(VoidPointer(ctx)))
}
// AvDefaultGetCategory
func AvDefaultGetCategory(ptr unsafe.Pointer) AvClassCategory {
return (AvClassCategory)(C.av_default_get_category(ptr))
func AvDefaultGetCategory(ptr CVoidPointer) AVClassCategory {
return (AVClassCategory)(C.av_default_get_category(VoidPointer(ptr)))
}
// NONEED: av_log_format_line

28
avutil_mathematics.go
View File

@@ -5,15 +5,15 @@ package ffmpeg
*/
import "C"
type AvRounding = C.enum_AVRounding
type AVRounding = C.enum_AVRounding
const (
AV_ROUND_ZERO = AvRounding(C.AV_ROUND_ZERO)
AV_ROUND_INF = AvRounding(C.AV_ROUND_INF)
AV_ROUND_DOWN = AvRounding(C.AV_ROUND_DOWN)
AV_ROUND_UP = AvRounding(C.AV_ROUND_UP)
AV_ROUND_NEAR_INF = AvRounding(C.AV_ROUND_NEAR_INF)
AV_ROUND_PASS_MINMAX = AvRounding(C.AV_ROUND_PASS_MINMAX)
AV_ROUND_ZERO = AVRounding(C.AV_ROUND_ZERO)
AV_ROUND_INF = AVRounding(C.AV_ROUND_INF)
AV_ROUND_DOWN = AVRounding(C.AV_ROUND_DOWN)
AV_ROUND_UP = AVRounding(C.AV_ROUND_UP)
AV_ROUND_NEAR_INF = AVRounding(C.AV_ROUND_NEAR_INF)
AV_ROUND_PASS_MINMAX = AVRounding(C.AV_ROUND_PASS_MINMAX)
)
// AvGcd computes the greatest common divisor of two integer operands.
@@ -27,24 +27,24 @@ func AvRescale(a, b, c int64) int64 {
}
// AvRescaleRnd rescales a 64-bit integer with specified rounding.
func AvRescaleRnd(a, b, c int64, rnd AvRounding) int64 {
func AvRescaleRnd(a, b, c int64, rnd AVRounding) int64 {
return (int64)(C.av_rescale_rnd((C.int64_t)(a), (C.int64_t)(b), (C.int64_t)(c),
(C.enum_AVRounding)(rnd)))
}
// AvRescaleQ rescales a 64-bit integer by 2 rational numbers.
func AvRescaleQ(a int64, bq, cq AvRational) int64 {
func AvRescaleQ(a int64, bq, cq AVRational) int64 {
return (int64)(C.av_rescale_q((C.int64_t)(a), (C.struct_AVRational)(bq), (C.struct_AVRational)(cq)))
}
// AvRescaleQRnd rescales a 64-bit integer by 2 rational numbers with specified rounding.
func AvRescaleQRnd(a int64, bq, cq AvRational, rnd AvRounding) int64 {
func AvRescaleQRnd(a int64, bq, cq AVRational, rnd AVRounding) int64 {
return (int64)(C.av_rescale_q_rnd((C.int64_t)(a), (C.struct_AVRational)(bq), (C.struct_AVRational)(cq),
(C.enum_AVRounding)(rnd)))
}
// AvCompareTs compares two timestamps each in its own time base.
func AvCompareTs(tsA int64, tbA AvRational, tsB int64, tbB AvRational) int32 {
func AvCompareTs(tsA int64, tbA AVRational, tsB int64, tbB AVRational) int32 {
return (int32)(C.av_compare_ts((C.int64_t)(tsA), (C.struct_AVRational)(tbA),
(C.int64_t)(tsB), (C.struct_AVRational)(tbB)))
}
@@ -55,8 +55,8 @@ func AvCompareMod(a, b, mod uint64) int64 {
}
// AvRescaleDelta rescales a timestamp while preserving known durations.
func AvRescaleDelta(inTb AvRational, inTs int64, fsTb AvRational,
duration int32, last *int64, outTb AvRational) int64 {
func AvRescaleDelta(inTb AVRational, inTs int64, fsTb AVRational,
duration int32, last *int64, outTb AVRational) int64 {
return (int64)(C.av_rescale_delta((C.struct_AVRational)(inTb),
(C.int64_t)(inTs),
(C.struct_AVRational)(fsTb),
@@ -66,7 +66,7 @@ func AvRescaleDelta(inTb AvRational, inTs int64, fsTb AvRational,
}
// AvAddStable adds a value to a timestamp.
func AvAddStable(tsTb AvRational, ts int64, incTb AvRational, inc int64) int32 {
func AvAddStable(tsTb AVRational, ts int64, incTb AVRational, inc int64) int32 {
return (int32)(C.av_add_stable((C.struct_AVRational)(tsTb), (C.int64_t)(ts),
(C.struct_AVRational)(incTb), (C.int64_t)(inc)))
}

16
avutil_md5.go
View File

@@ -9,26 +9,26 @@ var (
AvMd5Size = C.av_md5_size
)
// AvMD5
type AvMD5 C.struct_AVMD5
// AVMD5
type AVMD5 C.struct_AVMD5
// AvMd5Alloc allocates an AvMD5 context.
func AvMd5Alloc() *AvMD5 {
return (*AvMD5)(C.av_md5_alloc())
// AvMd5Alloc allocates an AVMD5 context.
func AvMd5Alloc() *AVMD5 {
return (*AVMD5)(C.av_md5_alloc())
}
// AvMd5Init initializes MD5 hashing.
func AvMd5Init(ctx *AvMD5) {
func AvMd5Init(ctx *AVMD5) {
C.av_md5_init((*C.struct_AVMD5)(ctx))
}
// AvMd5Update updates hash value.
func AvMd5Update(ctx *AvMD5, src *uint8, len int32) {
func AvMd5Update(ctx *AVMD5, src *uint8, len int32) {
C.av_md5_update((*C.struct_AVMD5)(ctx), (*C.uint8_t)(src), (C.int)(len))
}
// AvMd5Final finishs hashing and output digest value.
func AvMd5Final(ctx *AvMD5, dst *uint8) {
func AvMd5Final(ctx *AVMD5, dst *uint8) {
C.av_md5_final((*C.struct_AVMD5)(ctx), (*C.uint8_t)(dst))
}

82
avutil_mem.go
View File

@@ -8,77 +8,77 @@ import "unsafe"
// AvMalloc allocates a memory block with alignment suitable for all memory accesses
// (including vectors if available on the CPU).
func AvMalloc(size uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_malloc((C.size_t)(size)))
func AvMalloc[T HelperInteger](size T) unsafe.Pointer {
return C.av_malloc((C.size_t)(size))
}
// AvMallocz allocates a memory block with alignment suitable for all memory accesses
// (including vectors if available on the CPU) and zero all the bytes of the
// block.
func AvMallocz(size uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_mallocz((C.size_t)(size)))
func AvMallocz[T HelperInteger](size T) unsafe.Pointer {
return C.av_mallocz((C.size_t)(size))
}
// AvMallocArray allocates a memory block for an array with AvMalloc().
func AvMallocArray(nmemb, size uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_malloc_array((C.size_t)(nmemb), (C.size_t)(size)))
func AvMallocArray[U, V HelperInteger](nmemb U, size V) unsafe.Pointer {
return C.av_malloc_array((C.size_t)(nmemb), (C.size_t)(size))
}
// AvMalloczArray allocates a memory block for an array with AvMallocz().
func AvMalloczArray(nmemb, size uint) unsafe.Pointer {
func AvMalloczArray[U, V HelperInteger](nmemb U, size V) unsafe.Pointer {
return C.av_mallocz_array((C.size_t)(nmemb), (C.size_t)(size))
}
// AvCalloc is non-inlined equivalent of AvMalloczArray().
func AvCalloc(nmemb, size uint) unsafe.Pointer {
func AvCalloc[U, V HelperInteger](nmemb U, size V) unsafe.Pointer {
return C.av_calloc((C.size_t)(nmemb), (C.size_t)(size))
}
// AvRealloc allocates, reallocates, or frees a block of memory.
func AvRealloc(ptr unsafe.Pointer, size uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_realloc(ptr, (C.size_t)(size)))
func AvRealloc[T HelperInteger](ptr CVoidPointer, size T) unsafe.Pointer {
return C.av_realloc(VoidPointer(ptr), (C.size_t)(size))
}
// AvReallocp allocates, reallocates, or frees a block of memory through a pointer to a pointer.
func AvReallocp(ptr unsafe.Pointer, size uint) int32 {
return (int32)(C.av_reallocp(ptr, (C.size_t)(size)))
func AvReallocp[T HelperInteger](ptr CVoidPointer, size T) int32 {
return (int32)(C.av_reallocp(VoidPointer(ptr), (C.size_t)(size)))
}
// AvReallocF allocates, reallocates, or frees a block of memory.
func AvReallocF(ptr unsafe.Pointer, nelem, elsize uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_realloc_f(ptr, (C.size_t)(nelem), (C.size_t)(elsize)))
func AvReallocF[U, V HelperInteger](ptr CVoidPointer, nelem U, elsize V) unsafe.Pointer {
return C.av_realloc_f(VoidPointer(ptr), (C.size_t)(nelem), (C.size_t)(elsize))
}
// AvReallocpArray allocates, reallocates, or frees an array through a pointer to a pointer.
func AvReallocpArray(ptr unsafe.Pointer, nmemb, size uint) int32 {
return (int32)(C.av_reallocp_array(ptr, (C.size_t)(nmemb), (C.size_t)(size)))
func AvReallocpArray[U, V HelperInteger](ptr CVoidPointer, nmemb U, size V) int32 {
return (int32)(C.av_reallocp_array(VoidPointer(ptr), (C.size_t)(nmemb), (C.size_t)(size)))
}
// AvFastRealloc reallocates the given buffer if it is not large enough, otherwise do nothing.
func AvFastRealloc(ptr unsafe.Pointer, size *uint32, minSize uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_fast_realloc(ptr, (*C.uint)(size), (C.size_t)(minSize)))
func AvFastRealloc[T HelperInteger](ptr CVoidPointer, size *uint32, minSize T) unsafe.Pointer {
return C.av_fast_realloc(VoidPointer(ptr), (*C.uint)(size), (C.size_t)(minSize))
}
// AvFastMalloc allocates a buffer, reusing the given one if large enough.
func AvFastMalloc(ptr unsafe.Pointer, size *uint32, minSize uint) {
C.av_fast_malloc(ptr, (*C.uint)(size), (C.size_t)(minSize))
func AvFastMalloc[T HelperInteger](ptr CVoidPointer, size *uint32, minSize T) {
C.av_fast_malloc(VoidPointer(ptr), (*C.uint)(size), (C.size_t)(minSize))
}
// AvFastMallocz allocates and clear a buffer, reusing the given one if large enough.
func AvFastMallocz(ptr unsafe.Pointer, size *uint32, minSize uint) {
C.av_fast_mallocz(ptr, (*C.uint)(size), (C.size_t)(minSize))
func AvFastMallocz[T HelperInteger](ptr CVoidPointer, size *uint32, minSize T) {
C.av_fast_mallocz(VoidPointer(ptr), (*C.uint)(size), (C.size_t)(minSize))
}
// AvFree free a memory block which has been allocated with a function of AvMalloc()
// or AvRealloc() family.
func AvFree(ptr unsafe.Pointer) {
C.av_free(ptr)
func AvFree(ptr CVoidPointer) {
C.av_free(VoidPointer(ptr))
}
// AvFreep frees a memory block which has been allocated with a function of AvMalloc()
// or AvRealloc() family, and set the pointer pointing to it to `NULL`.
func AvFreep(ptr unsafe.Pointer) {
C.av_freep(ptr)
func AvFreep(ptr CVoidPointer) {
C.av_freep(VoidPointer(ptr))
}
// AvStrdup
@@ -87,43 +87,43 @@ func AvStrdup(s *int8) *int8 {
}
// AvStrndup
func AvStrndup(s *int8, len uint) *int8 {
func AvStrndup[T HelperInteger](s *int8, len T) *int8 {
return (*int8)(C.av_strndup((*C.char)(s), (C.size_t)(len)))
}
// AvMemdup duplicates a buffer with av_malloc().
func AvMemdup(p unsafe.Pointer, size uint) unsafe.Pointer {
return (unsafe.Pointer)(C.av_memdup(p, (C.size_t)(size)))
func AvMemdup[T HelperInteger](p CVoidPointer, size T) unsafe.Pointer {
return C.av_memdup(VoidPointer(p), (C.size_t)(size))
}
// Overlapping memcpy() implementation.
func av_memcpy_backptr(dst *uint8, back, cnt int32) {
// AvMemcpyBackptr overlaps memcpy() implementation.
func AvMemcpyBackptr(dst *uint8, back, cnt int32) {
C.av_memcpy_backptr((*C.uint8_t)(dst), (C.int)(back), (C.int)(cnt))
}
// AvDynarrayAdd adds the pointer to an element to a dynamic array.
func AvDynarrayAdd(tabPtr unsafe.Pointer, nbPtr *int32, elem unsafe.Pointer) {
C.av_dynarray_add(tabPtr, (*C.int)(nbPtr), elem)
func AvDynarrayAdd(tabPtr CVoidPointer, nbPtr *int32, elem CVoidPointer) {
C.av_dynarray_add(VoidPointer(tabPtr), (*C.int)(nbPtr), VoidPointer(elem))
}
// AvDynarrayAddNofree adds an element to a dynamic array.
func AvDynarrayAddNofree(tabPtr unsafe.Pointer, nbPtr *int32, elem unsafe.Pointer) int32 {
return (int32)(C.av_dynarray_add_nofree(tabPtr, (*C.int)(nbPtr), elem))
func AvDynarrayAddNofree(tabPtr CVoidPointer, nbPtr *int32, elem CVoidPointer) int32 {
return (int32)(C.av_dynarray_add_nofree(VoidPointer(tabPtr), (*C.int)(nbPtr), VoidPointer(elem)))
}
// AvDynarray2Add adds an element of size `elem_size` to a dynamic array.
func AvDynarray2Add(tabPtr *unsafe.Pointer, nbPtr *int32,
elemSize uint, elemData *uint8) unsafe.Pointer {
return (unsafe.Pointer)(C.av_dynarray2_add(tabPtr,
(*C.int)(nbPtr), (C.size_t)(elemSize), (*C.uint8_t)(elemData)))
func AvDynarray2Add[T HelperInteger](tabPtr CVoidPointerPointer, nbPtr *int32,
elemSize T, elemData *uint8) unsafe.Pointer {
return C.av_dynarray2_add(VoidPointerPointer(tabPtr),
(*C.int)(nbPtr), (C.size_t)(elemSize), (*C.uint8_t)(elemData))
}
// AvSizeMult multiplies two `size_t` values checking for overflow.
func AvSizeMult(a, b uint, r *uint) int32 {
func AvSizeMult[T HelperInteger](a, b T, r *uint) int32 {
return (int32)(C.av_size_mult((C.size_t)(a), (C.size_t)(b), (*C.size_t)(unsafe.Pointer(r))))
}
// AvMaxAlloc sets the maximum size that may be allocated in one block.
func AvMaxAlloc(max uint) {
func AvMaxAlloc[T HelperInteger](max T) {
C.av_max_alloc((C.size_t)(max))
}

68
avutil_motion_vector.go
View File

@@ -5,169 +5,169 @@ package ffmpeg
*/
import "C"
type AvMotionVector C.struct_AVMotionVector
type AVMotionVector C.struct_AVMotionVector
// Custom: GetSource gets `AVMotionVector.source` value.
func (mv *AvMotionVector) GetSource() int32 {
func (mv *AVMotionVector) GetSource() int32 {
return (int32)(mv.source)
}
// Custom: SetSource sets `AVMotionVector.source` value.
func (mv *AvMotionVector) SetSource(v int32) {
func (mv *AVMotionVector) SetSource(v int32) {
mv.source = (C.int32_t)(v)
}
// Custom: GetSourceAddr gets `AVMotionVector.source` address.
func (mv *AvMotionVector) GetSourceAddr() *int32 {
func (mv *AVMotionVector) GetSourceAddr() *int32 {
return (*int32)(&mv.source)
}
// Custom: GetW gets `AVMotionVector.w` value.
func (mv *AvMotionVector) GetW() uint8 {
func (mv *AVMotionVector) GetW() uint8 {
return (uint8)(mv.w)
}
// Custom: SetW sets `AVMotionVector.w` value.
func (mv *AvMotionVector) SetW(v uint8) {
func (mv *AVMotionVector) SetW(v uint8) {
mv.w = (C.uint8_t)(v)
}
// Custom: GetWAddr gets `AVMotionVector.w` address.
func (mv *AvMotionVector) GetWAddr() *uint8 {
func (mv *AVMotionVector) GetWAddr() *uint8 {
return (*uint8)(&mv.w)
}
// Custom: GetH gets `AVMotionVector.h` value.
func (mv *AvMotionVector) GetH() uint8 {
func (mv *AVMotionVector) GetH() uint8 {
return (uint8)(mv.h)
}
// Custom: SetH sets `AVMotionVector.h` value.
func (mv *AvMotionVector) SetH(v uint8) {
func (mv *AVMotionVector) SetH(v uint8) {
mv.h = (C.uint8_t)(v)
}
// Custom: GetHAddr gets `AVMotionVector.h` address.
func (mv *AvMotionVector) GetHAddr() *uint8 {
func (mv *AVMotionVector) GetHAddr() *uint8 {
return (*uint8)(&mv.h)
}
// Custom: GetSrcX gets `AVMotionVector.src_x` value.
func (mv *AvMotionVector) GetSrcX() int16 {
func (mv *AVMotionVector) GetSrcX() int16 {
return (int16)(mv.src_x)
}
// Custom: SetSrcX sets `AVMotionVector.src_x` value.
func (mv *AvMotionVector) SetSrcX(v int16) {
func (mv *AVMotionVector) SetSrcX(v int16) {
mv.src_x = (C.int16_t)(v)
}
// Custom: GetSrcXAddr gets `AVMotionVector.src_x` address.
func (mv *AvMotionVector) GetSrcXAddr() *int16 {
func (mv *AVMotionVector) GetSrcXAddr() *int16 {
return (*int16)(&mv.src_x)
}
// Custom: GetSrcY gets `AVMotionVector.src_y` value.
func (mv *AvMotionVector) GetSrcY() int16 {
func (mv *AVMotionVector) GetSrcY() int16 {
return (int16)(mv.src_y)
}
// Custom: SetSrcY sets `AVMotionVector.src_y` value.
func (mv *AvMotionVector) SetSrcY(v int16) {
func (mv *AVMotionVector) SetSrcY(v int16) {
mv.src_y = (C.int16_t)(v)
}
// Custom: GetSrcYAddr gets `AVMotionVector.src_y` address.
func (mv *AvMotionVector) GetSrcYAddr() *int16 {
func (mv *AVMotionVector) GetSrcYAddr() *int16 {
return (*int16)(&mv.src_y)
}
// Custom: GetDstX gets `AVMotionVector.dst_x` value.
func (mv *AvMotionVector) GetDstX() int16 {
func (mv *AVMotionVector) GetDstX() int16 {
return (int16)(mv.dst_x)
}
// Custom: SetDstX sets `AVMotionVector.dst_x` value.
func (mv *AvMotionVector) SetDstX(v int16) {
func (mv *AVMotionVector) SetDstX(v int16) {
mv.dst_x = (C.int16_t)(v)
}
// Custom: GetDstXAddr gets `AVMotionVector.dst_x` address.
func (mv *AvMotionVector) GetDstXAddr() *int16 {
func (mv *AVMotionVector) GetDstXAddr() *int16 {
return (*int16)(&mv.dst_x)
}
// Custom: GetDstY gets `AVMotionVector.dst_y` value.
func (mv *AvMotionVector) GetDstY() int16 {
func (mv *AVMotionVector) GetDstY() int16 {
return (int16)(mv.dst_y)
}
// Custom: SetDstY sets `AVMotionVector.dst_y` value.
func (mv *AvMotionVector) SetDstY(v int16) {
func (mv *AVMotionVector) SetDstY(v int16) {
mv.dst_y = (C.int16_t)(v)
}
// Custom: GetDstYAddr gets `AVMotionVector.dst_y` address.
func (mv *AvMotionVector) GetDstYAddr() *int16 {
func (mv *AVMotionVector) GetDstYAddr() *int16 {
return (*int16)(&mv.dst_y)
}
// Custom: GetFlags gets `AVMotionVector.flags` value.
func (mv *AvMotionVector) GetFlags() uint64 {
func (mv *AVMotionVector) GetFlags() uint64 {
return (uint64)(mv.flags)
}
// Custom: SetFlags sets `AVMotionVector.flags` value.
func (mv *AvMotionVector) SetFlags(v uint64) {
func (mv *AVMotionVector) SetFlags(v uint64) {
mv.flags = (C.uint64_t)(v)
}
// Custom: GetFlagsAddr gets `AVMotionVector.flags` address.
func (mv *AvMotionVector) GetFlagsAddr() *uint64 {
func (mv *AVMotionVector) GetFlagsAddr() *uint64 {
return (*uint64)(&mv.flags)
}
// Custom: GetMotionX gets `AVMotionVector.motion_x` value.
func (mv *AvMotionVector) GetMotionX() int32 {
func (mv *AVMotionVector) GetMotionX() int32 {
return (int32)(mv.motion_x)
}
// Custom: SetMotionX sets `AVMotionVector.motion_x` value.
func (mv *AvMotionVector) SetMotionX(v int32) {
func (mv *AVMotionVector) SetMotionX(v int32) {
mv.motion_x = (C.int32_t)(v)
}
// Custom: GetMotionXAddr gets `AVMotionVector.motion_x` address.
func (mv *AvMotionVector) GetMotionXAddr() *int32 {
func (mv *AVMotionVector) GetMotionXAddr() *int32 {
return (*int32)(&mv.motion_x)
}
// Custom: GetMotionY gets `AVMotionVector.motion_y` value.
func (mv *AvMotionVector) GetMotionY() int32 {
func (mv *AVMotionVector) GetMotionY() int32 {
return (int32)(mv.motion_y)
}
// Custom: SetMotionY sets `AVMotionVector.motion_y` value.
func (mv *AvMotionVector) SetMotionY(v int32) {
func (mv *AVMotionVector) SetMotionY(v int32) {
mv.motion_y = (C.int32_t)(v)
}
// Custom: GetMotionYAddr gets `AVMotionVector.motion_y` address.
func (mv *AvMotionVector) GetMotionYAddr() *int32 {
func (mv *AVMotionVector) GetMotionYAddr() *int32 {
return (*int32)(&mv.motion_y)
}
// Custom: GetMotionScale gets `AVMotionVector.motion_scale` value.
func (mv *AvMotionVector) GetMotionScale() uint16 {
func (mv *AVMotionVector) GetMotionScale() uint16 {
return (uint16)(mv.motion_scale)
}
// Custom: SetMotionScale sets `AVMotionVector.motion_scale` value.
func (mv *AvMotionVector) SetMotionScale(v uint16) {
func (mv *AVMotionVector) SetMotionScale(v uint16) {
mv.motion_scale = (C.uint16_t)(v)
}
// Custom: GetMotionScaleAddr gets `AVMotionVector.motion_scale` address.
func (mv *AvMotionVector) GetMotionScaleAddr() *uint16 {
func (mv *AVMotionVector) GetMotionScaleAddr() *uint16 {
return (*uint16)(&mv.motion_scale)
}

22
avutil_murmur3.go
View File

@@ -5,32 +5,32 @@ package ffmpeg
*/
import "C"
type AvMurMur3 C.struct_AVMurMur3
type AVMurMur3 C.struct_AVMurMur3
// AvMurmur3Alloc allocates an AVMurMur3 hash context.
func AvMurmur3Alloc() *AvMurMur3 {
return (*AvMurMur3)(C.av_murmur3_alloc())
func AvMurmur3Alloc() *AVMurMur3 {
return (*AVMurMur3)(C.av_murmur3_alloc())
}
// AvMurmur3InitSeeded initializes or reinitializes an AvMurMur3 hash context with a seed.
func AvMurmur3InitSeeded(c *AvMurMur3, seed uint64) {
// AvMurmur3InitSeeded initializes or reinitializes an AVMurMur3 hash context with a seed.
func AvMurmur3InitSeeded(c *AVMurMur3, seed uint64) {
C.av_murmur3_init_seeded((*C.struct_AVMurMur3)(c), (C.uint64_t)(seed))
}
// AvMurmur3Init initializes or reinitializes an AVMurMur3 hash context.
func AvMurmur3Init(c *AvMurMur3) {
func AvMurmur3Init(c *AVMurMur3) {
C.av_murmur3_init((*C.struct_AVMurMur3)(c))
}
// AvMurmur3Update updates hash context with new data.
func AvMurmur3Update(c *AvMurMur3, src *uint8, len int32) {
func AvMurmur3Update(c *AVMurMur3, src *uint8, len int32) {
C.av_murmur3_update((*C.struct_AVMurMur3)(c), (*C.uint8_t)(src), (C.int)(len))
}
// av_murmur3_final
func av_murmur3_final(c *AvMurMur3, dst []uint8) {
if len(dst) != 16 {
panic("dst need len = 16")
// AvMurmur3Final finishes hashing and output digest value.
func AvMurmur3Final(c *AVMurMur3, dst []uint8) {
if len(dst) < 16 {
panic("dst len < 16")
}
C.av_murmur3_final((*C.struct_AVMurMur3)(c), (*C.uint8_t)(&dst[0]))
}

488
avutil_opt.go
View File

@@ -3,6 +3,22 @@ package ffmpeg
/*
#include <libavutil/opt.h>
int64_t get_av_option_default_val_i64(AVOption *opt) {
return opt->default_val.i64;
}
double get_av_option_default_val_dbl(AVOption *opt) {
return opt->default_val.dbl;
}
const char* get_av_option_default_val_str(AVOption *opt) {
return opt->default_val.str;
}
AVRational get_av_option_default_val_q(AVOption *opt) {
return opt->default_val.q;
}
int av_opt_set_int_list_wrap(void *obj, const char *name, void *val, uint64_t term, int flags, int size) {
if (av_int_list_length(val, term) > INT_MAX / size) {
return AVERROR(EINVAL);
@@ -15,32 +31,138 @@ import (
"unsafe"
)
// AvOptionType
type AvOptionType = int32
// AVOptionType
type AVOptionType = int32
const (
AV_OPT_TYPE_FLAGS = AvOptionType(C.AV_OPT_TYPE_FLAGS)
AV_OPT_TYPE_INT = AvOptionType(C.AV_OPT_TYPE_INT)
AV_OPT_TYPE_INT64 = AvOptionType(C.AV_OPT_TYPE_INT64)
AV_OPT_TYPE_DOUBLE = AvOptionType(C.AV_OPT_TYPE_DOUBLE)
AV_OPT_TYPE_FLOAT = AvOptionType(C.AV_OPT_TYPE_FLOAT)
AV_OPT_TYPE_STRING = AvOptionType(C.AV_OPT_TYPE_STRING)
AV_OPT_TYPE_RATIONAL = AvOptionType(C.AV_OPT_TYPE_RATIONAL)
AV_OPT_TYPE_BINARY = AvOptionType(C.AV_OPT_TYPE_BINARY)
AV_OPT_TYPE_DICT = AvOptionType(C.AV_OPT_TYPE_DICT)
AV_OPT_TYPE_UINT64 = AvOptionType(C.AV_OPT_TYPE_UINT64)
AV_OPT_TYPE_CONST = AvOptionType(C.AV_OPT_TYPE_CONST)
AV_OPT_TYPE_IMAGE_SIZE = AvOptionType(C.AV_OPT_TYPE_IMAGE_SIZE)
AV_OPT_TYPE_PIXEL_FMT = AvOptionType(C.AV_OPT_TYPE_PIXEL_FMT)
AV_OPT_TYPE_SAMPLE_FMT = AvOptionType(C.AV_OPT_TYPE_SAMPLE_FMT)
AV_OPT_TYPE_VIDEO_RATE = AvOptionType(C.AV_OPT_TYPE_VIDEO_RATE)
AV_OPT_TYPE_DURATION = AvOptionType(C.AV_OPT_TYPE_DURATION)
AV_OPT_TYPE_COLOR = AvOptionType(C.AV_OPT_TYPE_COLOR)
AV_OPT_TYPE_CHANNEL_LAYOUT = AvOptionType(C.AV_OPT_TYPE_CHANNEL_LAYOUT)
AV_OPT_TYPE_BOOL = AvOptionType(C.AV_OPT_TYPE_BOOL)
AV_OPT_TYPE_FLAGS = AVOptionType(C.AV_OPT_TYPE_FLAGS)
AV_OPT_TYPE_INT = AVOptionType(C.AV_OPT_TYPE_INT)
AV_OPT_TYPE_INT64 = AVOptionType(C.AV_OPT_TYPE_INT64)
AV_OPT_TYPE_DOUBLE = AVOptionType(C.AV_OPT_TYPE_DOUBLE)
AV_OPT_TYPE_FLOAT = AVOptionType(C.AV_OPT_TYPE_FLOAT)
AV_OPT_TYPE_STRING = AVOptionType(C.AV_OPT_TYPE_STRING)
AV_OPT_TYPE_RATIONAL = AVOptionType(C.AV_OPT_TYPE_RATIONAL)
AV_OPT_TYPE_BINARY = AVOptionType(C.AV_OPT_TYPE_BINARY)
AV_OPT_TYPE_DICT = AVOptionType(C.AV_OPT_TYPE_DICT)
AV_OPT_TYPE_UINT64 = AVOptionType(C.AV_OPT_TYPE_UINT64)
AV_OPT_TYPE_CONST = AVOptionType(C.AV_OPT_TYPE_CONST)
AV_OPT_TYPE_IMAGE_SIZE = AVOptionType(C.AV_OPT_TYPE_IMAGE_SIZE)
AV_OPT_TYPE_PIXEL_FMT = AVOptionType(C.AV_OPT_TYPE_PIXEL_FMT)
AV_OPT_TYPE_SAMPLE_FMT = AVOptionType(C.AV_OPT_TYPE_SAMPLE_FMT)
AV_OPT_TYPE_VIDEO_RATE = AVOptionType(C.AV_OPT_TYPE_VIDEO_RATE)
AV_OPT_TYPE_DURATION = AVOptionType(C.AV_OPT_TYPE_DURATION)
AV_OPT_TYPE_COLOR = AVOptionType(C.AV_OPT_TYPE_COLOR)
AV_OPT_TYPE_CHANNEL_LAYOUT = AVOptionType(C.AV_OPT_TYPE_CHANNEL_LAYOUT)
AV_OPT_TYPE_BOOL = AVOptionType(C.AV_OPT_TYPE_BOOL)
)
type AvOption C.struct_AVOption
// AVOption
type AVOption C.struct_AVOption
// Custom: GetName gets `AVOption.name` value.
func (opt *AVOption) GetName() string {
return C.GoString(opt.name)
}
// Custom: GetHelp gets `AVOption.help` value.
func (opt *AVOption) GetHelp() string {
return C.GoString(opt.help)
}
// Custom: GetOffset gets `AVOption.offset` value.
func (opt *AVOption) GetOffset() int32 {
return (int32)(opt.offset)
}
// Custom: SetOffset sets `AVOption.offset` value.
func (opt *AVOption) SetOffset(v int32) {
opt.offset = (C.int)(v)
}
// Custom: GetOffsetAddr gets `AVOption.offset` address.
func (opt *AVOption) GetOffsetAddr() *int32 {
return (*int32)(&opt.offset)
}
// Custom: GetType gets `AVOption.type` value.
func (opt *AVOption) GetType() AVOptionType {
return (AVOptionType)(opt._type)
}
// Custom: SetType sets `AVOption.type` value.
func (opt *AVOption) SetType(v AVOptionType) {
opt._type = (C.enum_AVOptionType)(v)
}
// Custom: GetTypeAddr gets `AVOption.type` address.
func (opt *AVOption) GetTypeAddr() *AVOptionType {
return (*AVOptionType)(unsafe.Pointer(&opt._type))
}
// Custom: GetDefaultValI64 gets `AVOption.default_val.i64` value.
func (opt *AVOption) GetDefaultValI64() int64 {
return (int64)(C.get_av_option_default_val_i64((*C.struct_AVOption)(opt)))
}
// Custom: GetDefaultValDbl gets `AVOption.default_val.dbl` value.
func (opt *AVOption) GetDefaultValDbl() float64 {
return (float64)(C.get_av_option_default_val_dbl((*C.struct_AVOption)(opt)))
}
// Custom: GetDefaultValStr gets `AVOption.default_val.str` value.
func (opt *AVOption) GetDefaultValStr() string {
return C.GoString(C.get_av_option_default_val_str((*C.struct_AVOption)(opt)))
}
// Custom: GetDefaultValQ gets `AVOption.default_val.q` value.
func (opt *AVOption) GetDefaultValQ() AVRational {
return (AVRational)(C.get_av_option_default_val_q((*C.struct_AVOption)(opt)))
}
// Custom: GetMin gets `AVOption.min` value.
func (opt *AVOption) GetMin() float64 {
return (float64)(opt.min)
}
// Custom: SetMin sets `AVOption.min` value.
func (opt *AVOption) SetMin(v float64) {
opt.min = (C.double)(v)
}
// Custom: GetMinAddr gets `AVOption.min` address.
func (opt *AVOption) GetMinAddr() *float64 {
return (*float64)(&opt.min)
}
// Custom: GetMax gets `AVOption.max` value.
func (opt *AVOption) GetMax() float64 {
return (float64)(opt.max)
}
// Custom: SetMax sets `AVOption.max` value.
func (opt *AVOption) SetMax(v float64) {
opt.max = (C.double)(v)
}
// Custom: GetMaxAddr gets `AVOption.max` address.
func (opt *AVOption) GetMaxAddr() *float64 {
return (*float64)(&opt.max)
}
// Custom: GetFlags gets `AVOption.flags` value.
func (opt *AVOption) GetFlags() int32 {
return (int32)(opt.flags)
}
// Custom: SetFlags sets `AVOption.flags` value.
func (opt *AVOption) SetFlags(v int32) {
opt.flags = (C.int)(v)
}
// Custom: GetFlagsAddr gets `AVOption.flags` address.
func (opt *AVOption) GetFlagsAddr() *int32 {
return (*int32)(&opt.flags)
}
const (
AV_OPT_FLAG_ENCODING_PARAM = int32(C.AV_OPT_FLAG_ENCODING_PARAM)
@@ -59,63 +181,177 @@ const (
AV_OPT_FLAG_CHILD_CONSTS = int32(C.AV_OPT_FLAG_CHILD_CONSTS)
)
type AvOptionRange C.struct_AVOptionRange
// Custom: GetUnit gets `AVOption.unit` value.
func (opt *AVOption) GetUnit() string {
return C.GoString(opt.unit)
}
type AvOptionRanges C.struct_AVOptionRanges
// AVOptionRange
type AVOptionRange C.struct_AVOptionRange
// Custom: GetStr gets `AVOptionRange.str` value.
func (optr *AVOptionRange) GetStr() string {
return C.GoString(optr.str)
}
// Custom: GetValueMin gets `AVOptionRange.value_min` value.
func (optr *AVOptionRange) GetValueMin() float64 {
return (float64)(optr.value_min)
}
// Custom: SetValueMin sets `AVOptionRange.value_min` value.
func (optr *AVOptionRange) SetValueMin(v float64) {
optr.value_min = (C.double)(v)
}
// Custom: GetValueMinAddr gets `AVOptionRange.value_min` address.
func (optr *AVOptionRange) GetValueMinAddr() *float64 {
return (*float64)(&optr.value_min)
}
// Custom: GetValueMax gets `AVOptionRange.value_max` value.
func (optr *AVOptionRange) GetValueMax() float64 {
return (float64)(optr.value_max)
}
// Custom: SetValueMax sets `AVOptionRange.value_max` value.
func (optr *AVOptionRange) SetValueMax(v float64) {
optr.value_max = (C.double)(v)
}
// Custom: GetValueMaxAddr gets `AVOptionRange.value_max` address.
func (optr *AVOptionRange) GetValueMaxAddr() *float64 {
return (*float64)(&optr.value_max)
}
// Custom: GetComponentMin gets `AVOptionRange.component_min` value.
func (optr *AVOptionRange) GetComponentMin() float64 {
return (float64)(optr.component_min)
}
// Custom: SetComponentMin sets `AVOptionRange.component_min` value.
func (optr *AVOptionRange) SetComponentMin(v float64) {
optr.component_min = (C.double)(v)
}
// Custom: GetComponentMinAddr gets `AVOptionRange.component_min` address.
func (optr *AVOptionRange) GetComponentMinAddr() *float64 {
return (*float64)(&optr.component_min)
}
// Custom: GetComponentMax gets `AVOptionRange.component_max` value.
func (optr *AVOptionRange) GetComponentMax() float64 {
return (float64)(optr.component_max)
}
// Custom: SetComponentMax sets `AVOptionRange.component_max` value.
func (optr *AVOptionRange) SetComponentMax(v float64) {
optr.component_max = (C.double)(v)
}
// Custom: GetComponentMaxAddr gets `AVOptionRange.component_max` address.
func (optr *AVOptionRange) GetComponentMaxAddr() *float64 {
return (*float64)(&optr.component_max)
}
// Custom: GetIsRange gets `AVOptionRange.is_range` value.
func (optr *AVOptionRange) GetIsRange() int32 {
return (int32)(optr.is_range)
}
// Custom: SetIsRange sets `AVOptionRange.is_range` value.
func (optr *AVOptionRange) SetIsRange(v int32) {
optr.is_range = (C.int)(v)
}
// Custom: GetIsRangeAddr gets `AVOptionRange.is_range` address.
func (optr *AVOptionRange) GetIsRangeAddr() *int32 {
return (*int32)(&optr.is_range)
}
// AVOptionRanges
type AVOptionRanges C.struct_AVOptionRanges
// Custom: GetRange gets `AVOptionRanges.range` value.
func (optrs *AVOptionRanges) GetRange() []*AVOptionRange {
if optrs._range == nil {
return nil
}
return unsafe.Slice((**AVOptionRange)(unsafe.Pointer(optrs._range)),
optrs.nb_components*optrs.nb_ranges)
}
// Custom: GetRangeIdx gets `AVOptionRanges.range` index value.
func (optrs *AVOptionRanges) GetRangeIdx(idx int) *AVOptionRange {
if idx >= int(optrs.nb_components*optrs.nb_ranges) {
return nil
}
return PointerOffset((*AVOptionRange)(*optrs._range), idx)
}
// Custom: GetNbRanges gets `AVOptionRanges.nb_ranges` value.
func (optrs *AVOptionRanges) GetNbRanges() int32 {
return (int32)(optrs.nb_ranges)
}
// Custom: GetNbComponents gets `AVOptionRanges.nb_components` value.
func (optrs *AVOptionRanges) GetNbComponents() int32 {
return (int32)(optrs.nb_components)
}
// AvOptShow2 shows the obj options.
func AvOptShow2(obj, avLogObj unsafe.Pointer, reqFlags, rejFlags int32) int32 {
return (int32)(C.av_opt_show2(obj, avLogObj, (C.int)(reqFlags), (C.int)(rejFlags)))
func AvOptShow2(obj, avLogObj CVoidPointer, reqFlags, rejFlags int32) int32 {
return (int32)(C.av_opt_show2(VoidPointer(obj), VoidPointer(avLogObj), (C.int)(reqFlags), (C.int)(rejFlags)))
}
// AvOptSetDefaults sets the values of all AVOption fields to their default values.
func AvOptSetDefaults(s unsafe.Pointer) {
C.av_opt_set_defaults(s)
func AvOptSetDefaults(s CVoidPointer) {
C.av_opt_set_defaults(VoidPointer(s))
}
// AvOptSetDefaults2 sets the values of all AVOption fields to their default values.
func AvOptSetDefaults2(s unsafe.Pointer, mask, flags int32) {
C.av_opt_set_defaults2(s, (C.int)(mask), (C.int)(flags))
func AvOptSetDefaults2(s CVoidPointer, mask, flags int32) {
C.av_opt_set_defaults2(VoidPointer(s), (C.int)(mask), (C.int)(flags))
}
// AvSetOptionsString parses the key/value pairs list in opts. For each key/value pair
// found, stores the value in the field in ctx that is named like the
// key. ctx must be an AVClass context, storing is done using AVOptions.
func AvSetOptionsString(ctx unsafe.Pointer, opts, keyValSep, pairsSep string) int32 {
func AvSetOptionsString(ctx CVoidPointer, opts, keyValSep, pairsSep string) int32 {
optsPtr, optsFunc := StringCasting(opts)
defer optsFunc()
keyValSepPtr, keyValSepFunc := StringCasting(keyValSep)
defer keyValSepFunc()
pairsSepPtr, pairsSepFunc := StringCasting(pairsSep)
defer pairsSepFunc()
return (int32)(C.av_set_options_string(ctx, (*C.char)(optsPtr),
return (int32)(C.av_set_options_string(VoidPointer(ctx), (*C.char)(optsPtr),
(*C.char)(keyValSepPtr), (*C.char)(pairsSepPtr)))
}
// NONEED: av_opt_set_from_string
// AvOptFree frees all allocated objects in obj.
func AvOptFree(obj unsafe.Pointer) {
C.av_opt_free(obj)
func AvOptFree(obj CVoidPointer) {
C.av_opt_free(VoidPointer(obj))
}
// AvOptFlagIsSet checks whether a particular flag is set in a flags field.
func AvOptFlagIsSet(obj unsafe.Pointer, fieldName, flagName string) int32 {
func AvOptFlagIsSet(obj CVoidPointer, fieldName, flagName string) int32 {
fieldNamePtr, fieldNameFunc := StringCasting(fieldName)
defer fieldNameFunc()
flagNamePtr, flagNameFunc := StringCasting(flagName)
defer flagNameFunc()
return (int32)(C.av_opt_flag_is_set(obj, (*C.char)(fieldNamePtr), (*C.char)(flagNamePtr)))
return (int32)(C.av_opt_flag_is_set(VoidPointer(obj), (*C.char)(fieldNamePtr), (*C.char)(flagNamePtr)))
}
// AvOptSetDict sets all the options from a given dictionary on an object.
func AvOptSetDict(obj unsafe.Pointer, options **AvDictionary) int32 {
return (int32)(C.av_opt_set_dict(obj, (**C.struct_AVDictionary)(unsafe.Pointer(options))))
func AvOptSetDict(obj CVoidPointer, options **AVDictionary) int32 {
return (int32)(C.av_opt_set_dict(VoidPointer(obj), (**C.struct_AVDictionary)(unsafe.Pointer(options))))
}
// AvOptSetDict2 sets all the options from a given dictionary on an object.
func AvOptSetDict2(obj unsafe.Pointer, options **AvDictionary, searchFlags int32) int32 {
return (int32)(C.av_opt_set_dict2(obj, (**C.struct_AVDictionary)(unsafe.Pointer(options)),
func AvOptSetDict2(obj CVoidPointer, options **AVDictionary, searchFlags int32) int32 {
return (int32)(C.av_opt_set_dict2(VoidPointer(obj), (**C.struct_AVDictionary)(unsafe.Pointer(options)),
(C.int)(searchFlags)))
}
@@ -126,45 +362,45 @@ const (
)
// AvOptEvalFlags
func AvOptEvalFlags(obj unsafe.Pointer, o *AvOption, val string, flags_out *int32) int32 {
func AvOptEvalFlags(obj CVoidPointer, o *AVOption, val string, flags_out *int32) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_flags(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int)(flags_out)))
return (int32)(C.av_opt_eval_flags(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int)(flags_out)))
}
// AvOptEvalInt
func AvOptEvalInt(obj unsafe.Pointer, o *AvOption, val string, int_out *int32) int32 {
func AvOptEvalInt(obj CVoidPointer, o *AVOption, val string, int_out *int32) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_int(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int)(int_out)))
return (int32)(C.av_opt_eval_int(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int)(int_out)))
}
// AvOptEvalInt64
func AvOptEvalInt64(obj unsafe.Pointer, o *AvOption, val string, int64_out *int64) int32 {
func AvOptEvalInt64(obj CVoidPointer, o *AVOption, val string, int64_out *int64) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_int64(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int64_t)(int64_out)))
return (int32)(C.av_opt_eval_int64(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.int64_t)(int64_out)))
}
// AvOptEvalFloat
func AvOptEvalFloat(obj unsafe.Pointer, o *AvOption, val string, float_out *float32) int32 {
func AvOptEvalFloat(obj CVoidPointer, o *AVOption, val string, float_out *float32) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_float(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.float)(float_out)))
return (int32)(C.av_opt_eval_float(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.float)(float_out)))
}
// AvOptEvalDouble
func AvOptEvalDouble(obj unsafe.Pointer, o *AvOption, val string, double_out *float64) int32 {
func AvOptEvalDouble(obj CVoidPointer, o *AVOption, val string, double_out *float64) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_double(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.double)(double_out)))
return (int32)(C.av_opt_eval_double(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.double)(double_out)))
}
// AvOptEvalQ
func AvOptEvalQ(obj unsafe.Pointer, o *AvOption, val string, q_out *AvRational) int32 {
func AvOptEvalQ(obj CVoidPointer, o *AVOption, val string, q_out *AVRational) int32 {
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_eval_q(obj, (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.struct_AVRational)(q_out)))
return (int32)(C.av_opt_eval_q(VoidPointer(obj), (*C.struct_AVOption)(o), (*C.char)(valPtr), (*C.struct_AVRational)(q_out)))
}
const (
@@ -176,252 +412,252 @@ const (
// AvOptFind looks for an option in an object. Consider only options which
// have all the specified flags set.
func AvOptFind(obj unsafe.Pointer, name, unit string, optFlags, searchFlags int32) *AvOption {
func AvOptFind(obj CVoidPointer, name, unit string, optFlags, searchFlags int32) *AVOption {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
unitPtr, unitFunc := StringCasting(unit)
defer unitFunc()
return (*AvOption)(C.av_opt_find(obj, (*C.char)(namePtr), (*C.char)(unitPtr),
return (*AVOption)(C.av_opt_find(VoidPointer(obj), (*C.char)(namePtr), (*C.char)(unitPtr),
(C.int)(optFlags), (C.int)(searchFlags)))
}
// AvOptFind2 looks for an option in an object. Consider only options which
// have all the specified flags set.
func AvOptFind2(obj unsafe.Pointer, name, unit string, optFlags, searchFlags int32,
targetObj *unsafe.Pointer) *AvOption {
func AvOptFind2(obj CVoidPointer, name, unit string, optFlags, searchFlags int32,
targetObj CVoidPointerPointer) *AVOption {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
unitPtr, unitFunc := StringCasting(unit)
defer unitFunc()
return (*AvOption)(C.av_opt_find2(obj, (*C.char)(namePtr), (*C.char)(unitPtr),
(C.int)(optFlags), (C.int)(searchFlags), targetObj))
return (*AVOption)(C.av_opt_find2(VoidPointer(obj), (*C.char)(namePtr), (*C.char)(unitPtr),
(C.int)(optFlags), (C.int)(searchFlags), VoidPointerPointer(targetObj)))
}
// AvOptNext iterates over all AVOptions belonging to obj.
func AvOptNext(obj unsafe.Pointer, prev *AvOption) *AvOption {
return (*AvOption)(C.av_opt_next(obj, (*C.struct_AVOption)(prev)))
func AvOptNext(obj CVoidPointer, prev *AVOption) *AVOption {
return (*AVOption)(C.av_opt_next(VoidPointer(obj), (*C.struct_AVOption)(prev)))
}
// AvOptChildNext iterates over AVOptions-enabled children of obj.
func AvOptChildNext(obj, prev unsafe.Pointer) unsafe.Pointer {
return C.av_opt_child_next(obj, prev)
func AvOptChildNext(obj, prev CVoidPointer) unsafe.Pointer {
return C.av_opt_child_next(VoidPointer(obj), VoidPointer(prev))
}
// Deprecated: Use AvOptChildClassIterate instead.
func AvOptChildClassNext(parent, prev *AvClass) *AvClass {
return (*AvClass)(C.av_opt_child_class_next((*C.struct_AVClass)(parent),
func AvOptChildClassNext(parent, prev *AVClass) *AVClass {
return (*AVClass)(C.av_opt_child_class_next((*C.struct_AVClass)(parent),
(*C.struct_AVClass)(prev)))
}
// AvOptChildClassIterate iterates over potential AVOptions-enabled children of parent.
func AvOptChildClassIterate(parent *AvClass, iter *unsafe.Pointer) *AvClass {
return (*AvClass)(C.av_opt_child_class_iterate((*C.struct_AVClass)(parent), iter))
func AvOptChildClassIterate(parent *AVClass, iter CVoidPointerPointer) *AVClass {
return (*AVClass)(C.av_opt_child_class_iterate((*C.struct_AVClass)(parent), VoidPointerPointer(iter)))
}
// AvOptSet
func AvOptSet(obj unsafe.Pointer, name string, val string, searchFlags int32) int32 {
func AvOptSet(obj CVoidPointer, name string, val string, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
valPtr, valFunc := StringCasting(val)
defer valFunc()
return (int32)(C.av_opt_set(obj, (*C.char)(namePtr), (*C.char)(valPtr), (C.int)(searchFlags)))
return (int32)(C.av_opt_set(VoidPointer(obj), (*C.char)(namePtr), (*C.char)(valPtr), (C.int)(searchFlags)))
}
// AvOptSetInt
func AvOptSetInt(obj unsafe.Pointer, name string, val int64, searchFlags int32) int32 {
func AvOptSetInt(obj CVoidPointer, name string, val int64, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_int(obj, (*C.char)(namePtr), (C.int64_t)(val), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_int(VoidPointer(obj), (*C.char)(namePtr), (C.int64_t)(val), (C.int)(searchFlags)))
}
// AvOptSetDouble
func AvOptSetDouble(obj unsafe.Pointer, name string, val float64, searchFlags int32) int32 {
func AvOptSetDouble(obj CVoidPointer, name string, val float64, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_double(obj, (*C.char)(namePtr), (C.double)(val), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_double(VoidPointer(obj), (*C.char)(namePtr), (C.double)(val), (C.int)(searchFlags)))
}
// AvOptSetQ
func AvOptSetQ(obj unsafe.Pointer, name string, val AvRational, searchFlags int32) int32 {
func AvOptSetQ(obj CVoidPointer, name string, val AVRational, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_q(obj, (*C.char)(namePtr), (C.AVRational)(val), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_q(VoidPointer(obj), (*C.char)(namePtr), (C.struct_AVRational)(val), (C.int)(searchFlags)))
}
// AvOptSetBin
func AvOptSetBin(obj unsafe.Pointer, name string, val *uint8, size int32, searchFlags int32) int32 {
func AvOptSetBin(obj CVoidPointer, name string, val *uint8, size int32, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_bin(obj, (*C.char)(namePtr), (*C.uint8_t)(val), (C.int)(size), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_bin(VoidPointer(obj), (*C.char)(namePtr), (*C.uint8_t)(val), (C.int)(size), (C.int)(searchFlags)))
}
// AvOptSetImageSize
func AvOptSetImageSize(obj unsafe.Pointer, name string, w, h int32, searchFlags int32) int32 {
func AvOptSetImageSize(obj CVoidPointer, name string, w, h int32, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_image_size(obj, (*C.char)(namePtr), (C.int)(w), (C.int)(h), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_image_size(VoidPointer(obj), (*C.char)(namePtr), (C.int)(w), (C.int)(h), (C.int)(searchFlags)))
}
// AvOptSetPixelFmt
func AvOptSetPixelFmt(obj unsafe.Pointer, name string, fmt AvPixelFormat, searchFlags int32) int32 {
func AvOptSetPixelFmt(obj CVoidPointer, name string, fmt AVPixelFormat, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_pixel_fmt(obj, (*C.char)(namePtr), (C.enum_AVPixelFormat)(fmt), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_pixel_fmt(VoidPointer(obj), (*C.char)(namePtr), (C.enum_AVPixelFormat)(fmt), (C.int)(searchFlags)))
}
// AvOptSetSampleFmt
func AvOptSetSampleFmt(obj unsafe.Pointer, name string, fmt AvSampleFormat, searchFlags int32) int32 {
func AvOptSetSampleFmt(obj CVoidPointer, name string, fmt AVSampleFormat, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_sample_fmt(obj, (*C.char)(namePtr), (C.enum_AVSampleFormat)(fmt), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_sample_fmt(VoidPointer(obj), (*C.char)(namePtr), (C.enum_AVSampleFormat)(fmt), (C.int)(searchFlags)))
}
// AvOptSetVideoRate
func AvOptSetVideoRate(obj unsafe.Pointer, name string, val AvRational, searchFlags int32) int32 {
func AvOptSetVideoRate(obj CVoidPointer, name string, val AVRational, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_video_rate(obj, (*C.char)(namePtr), (C.struct_AVRational)(val), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_video_rate(VoidPointer(obj), (*C.char)(namePtr), (C.struct_AVRational)(val), (C.int)(searchFlags)))
}
// AvOptSetChannelLayout
func AvOptSetChannelLayout(obj unsafe.Pointer, name string, chLayout int64, searchFlags int32) int32 {
func AvOptSetChannelLayout(obj CVoidPointer, name string, chLayout int64, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_channel_layout(obj, (*C.char)(namePtr), (C.int64_t)(chLayout), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_channel_layout(VoidPointer(obj), (*C.char)(namePtr), (C.int64_t)(chLayout), (C.int)(searchFlags)))
}
// AvOptSetDictVal
func AvOptSetDictVal(obj unsafe.Pointer, name string, val *AvDictionary, searchFlags int32) int32 {
func AvOptSetDictVal(obj CVoidPointer, name string, val *AVDictionary, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_set_dict_val(obj, (*C.char)(namePtr), (*C.struct_AVDictionary)(val), (C.int)(searchFlags)))
return (int32)(C.av_opt_set_dict_val(VoidPointer(obj), (*C.char)(namePtr), (*C.struct_AVDictionary)(val), (C.int)(searchFlags)))
}
// AvOptSetIntList sets a binary option to an integer list.
func av_opt_set_int_list[T HelperInteger](obj unsafe.Pointer, name string,
func AvOptSetIntList[T HelperInteger](obj CVoidPointer, name string,
val *T, term uint64, flags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
size := (int32)(unsafe.Sizeof(*val))
return (int32)(C.av_opt_set_int_list_wrap(obj, (*C.char)(namePtr),
return (int32)(C.av_opt_set_int_list_wrap(VoidPointer(obj), (*C.char)(namePtr),
unsafe.Pointer(val), (C.uint64_t)(term), (C.int)(flags), (C.int)(size)))
}
// AvOptGet
func AvOptGet(obj unsafe.Pointer, name string, searchFlags int32, outVal **uint8) int32 {
func AvOptGet(obj CVoidPointer, name string, searchFlags int32, outVal **uint8) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get(obj, (*C.char)(namePtr), (C.int)(searchFlags),
return (int32)(C.av_opt_get(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags),
(**C.uint8_t)(unsafe.Pointer(outVal))))
}
// AvOptGetInt
func AvOptGetInt(obj unsafe.Pointer, name string, searchFlags int32, outVal *int64) int32 {
func AvOptGetInt(obj CVoidPointer, name string, searchFlags int32, outVal *int64) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_int(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.int64_t)(outVal)))
return (int32)(C.av_opt_get_int(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.int64_t)(outVal)))
}
// AvOptGetDouble
func AvOptGetDouble(obj unsafe.Pointer, name string, searchFlags int32, outVal *float64) int32 {
func AvOptGetDouble(obj CVoidPointer, name string, searchFlags int32, outVal *float64) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_double(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.double)(outVal)))
return (int32)(C.av_opt_get_double(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.double)(outVal)))
}
// AvOptGetQ
func AvOptGetQ(obj unsafe.Pointer, name string, searchFlags int32, outVal *AvRational) int32 {
func AvOptGetQ(obj CVoidPointer, name string, searchFlags int32, outVal *AVRational) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_q(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.struct_AVRational)(outVal)))
return (int32)(C.av_opt_get_q(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.struct_AVRational)(outVal)))
}
// AvOptGetImageSize
func AvOptGetImageSize(obj unsafe.Pointer, name string, searchFlags int32, wOut, hOut *int32) int32 {
func AvOptGetImageSize(obj CVoidPointer, name string, searchFlags int32, wOut, hOut *int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_image_size(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.int)(wOut), (*C.int)(hOut)))
return (int32)(C.av_opt_get_image_size(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.int)(wOut), (*C.int)(hOut)))
}
// AvOptGetPixelFmt
func AvOptGetPixelFmt(obj unsafe.Pointer, name string, searchFlags int32, outFmt *AvPixelFormat) int32 {
func AvOptGetPixelFmt(obj CVoidPointer, name string, searchFlags int32, outFmt *AVPixelFormat) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_pixel_fmt(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.enum_AVPixelFormat)(outFmt)))
return (int32)(C.av_opt_get_pixel_fmt(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.enum_AVPixelFormat)(outFmt)))
}
// AvOptGetSampleFmt
func AvOptGetSampleFmt(obj unsafe.Pointer, name string, searchFlags int32, outFmt *AvSampleFormat) int32 {
func AvOptGetSampleFmt(obj CVoidPointer, name string, searchFlags int32, outFmt *AVSampleFormat) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_sample_fmt(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.enum_AVSampleFormat)(outFmt)))
return (int32)(C.av_opt_get_sample_fmt(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.enum_AVSampleFormat)(outFmt)))
}
// AvOptGetVideoRate
func AvOptGetVideoRate(obj unsafe.Pointer, name string, searchFlags int32, outVal *AvRational) int32 {
func AvOptGetVideoRate(obj CVoidPointer, name string, searchFlags int32, outVal *AVRational) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_video_rate(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.struct_AVRational)(outVal)))
return (int32)(C.av_opt_get_video_rate(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.struct_AVRational)(outVal)))
}
// AvOptGetChannelLayout
func AvOptGetChannelLayout(obj unsafe.Pointer, name string, searchFlags int32, outVal *int64) int32 {
func AvOptGetChannelLayout(obj CVoidPointer, name string, searchFlags int32, outVal *int64) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_channel_layout(obj, (*C.char)(namePtr), (C.int)(searchFlags), (*C.int64_t)(outVal)))
return (int32)(C.av_opt_get_channel_layout(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags), (*C.int64_t)(outVal)))
}
// AvOptGetDictVal
func AvOptGetDictVal(obj unsafe.Pointer, name string, searchFlags int32, outVal **AvDictionary) int32 {
func AvOptGetDictVal(obj CVoidPointer, name string, searchFlags int32, outVal **AVDictionary) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_get_dict_val(obj, (*C.char)(namePtr), (C.int)(searchFlags),
return (int32)(C.av_opt_get_dict_val(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags),
(**C.struct_AVDictionary)(unsafe.Pointer(outVal))))
}
// AvOptPtr gets a pointer to the requested field in a struct.
func AvOptPtr(avclass *AvClass, obj unsafe.Pointer, name string) {
func AvOptPtr(avclass *AVClass, obj CVoidPointer, name string) {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
C.av_opt_ptr((*C.struct_AVClass)(avclass), obj, (*C.char)(namePtr))
C.av_opt_ptr((*C.struct_AVClass)(avclass), VoidPointer(obj), (*C.char)(namePtr))
}
// AvOptFreepRanges frees an AvOptionRanges struct and set it to NULL.
func AvOptFreepRanges(ranges **AvOptionRanges) {
// AvOptFreepRanges frees an AVOptionRanges struct and set it to NULL.
func AvOptFreepRanges(ranges **AVOptionRanges) {
C.av_opt_freep_ranges((**C.struct_AVOptionRanges)(unsafe.Pointer(ranges)))
}
// AvOptQueryRanges gets a list of allowed ranges for the given option.
func AvOptQueryRanges(ranges **AvOptionRanges, obj unsafe.Pointer, key string, flags int32) int32 {
func AvOptQueryRanges(ranges **AVOptionRanges, obj CVoidPointer, key string, flags int32) int32 {
keyPtr, keyFunc := StringCasting(key)
defer keyFunc()
return (int32)(C.av_opt_query_ranges((**C.struct_AVOptionRanges)(unsafe.Pointer(ranges)),
obj, (*C.char)(keyPtr), (C.int)(flags)))
VoidPointer(obj), (*C.char)(keyPtr), (C.int)(flags)))
}
// AvOptCopy copies options from src object into dest object.
func AvOptCopy(dest, src unsafe.Pointer) int32 {
return (int32)(C.av_opt_copy(dest, src))
func AvOptCopy(dest, src CVoidPointer) int32 {
return (int32)(C.av_opt_copy(VoidPointer(dest), VoidPointer(src)))
}
// AvOptQueryRangesDefault gets a default list of allowed ranges for the given option.
func AvOptQueryRangesDefault(ranges **AvOptionRanges, obj unsafe.Pointer, key string, flags int32) int32 {
func AvOptQueryRangesDefault(ranges **AVOptionRanges, obj CVoidPointer, key string, flags int32) int32 {
keyPtr, keyFunc := StringCasting(key)
defer keyFunc()
return (int32)(C.av_opt_query_ranges_default((**C.struct_AVOptionRanges)(unsafe.Pointer(ranges)),
obj, (*C.char)(keyPtr), (C.int)(flags)))
VoidPointer(obj), (*C.char)(keyPtr), (C.int)(flags)))
}
// AvOptIsSetToDefault checks if given option is set to its default value.
func AvOptIsSetToDefault(obj unsafe.Pointer, o *AvOption) int32 {
return (int32)(C.av_opt_is_set_to_default(obj, (*C.struct_AVOption)(o)))
func AvOptIsSetToDefault(obj CVoidPointer, o *AVOption) int32 {
return (int32)(C.av_opt_is_set_to_default(VoidPointer(obj), (*C.struct_AVOption)(o)))
}
// AvOptIsSetToDefaultByName checks if given option is set to its default value.
func AvOptIsSetToDefaultByName(obj unsafe.Pointer, name string, searchFlags int32) int32 {
func AvOptIsSetToDefaultByName(obj CVoidPointer, name string, searchFlags int32) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (int32)(C.av_opt_is_set_to_default_by_name(obj, (*C.char)(namePtr), (C.int)(searchFlags)))
return (int32)(C.av_opt_is_set_to_default_by_name(VoidPointer(obj), (*C.char)(namePtr), (C.int)(searchFlags)))
}
const (
@@ -430,13 +666,13 @@ const (
)
// AvOptSerialize serializes object's options.
func AvOptSerialize(obj unsafe.Pointer, optFlags, flags int32, keyValSep, pairsSep string) (output string, ret int32) {
func AvOptSerialize(obj CVoidPointer, optFlags, flags int32, keyValSep, pairsSep string) (output string, ret int32) {
var buffer *C.char
keyValSepPtr, keyValSepFunc := StringCasting(keyValSep)
defer keyValSepFunc()
pairsSepPtr, pairsSepFunc := StringCasting(pairsSep)
defer pairsSepFunc()
ret = (int32)(C.av_opt_serialize(obj, (C.int)(optFlags), (C.int)(flags),
ret = (int32)(C.av_opt_serialize(VoidPointer(obj), (C.int)(optFlags), (C.int)(flags),
(**C.char)(unsafe.Pointer(&buffer)), (C.char)(*keyValSepPtr), (C.char)(*pairsSepPtr)))
return C.GoString(buffer), ret
}

12
avutil_parseutils.go
View File

@@ -7,15 +7,15 @@ import "C"
import "unsafe"
// AvParseRatio parses str and store the parsed ratio in q.
func AvParseRatio(q *AvRational, str string, max, logOffset int32, logCtx unsafe.Pointer) int32 {
func AvParseRatio(q *AVRational, str string, max, logOffset int32, logCtx CVoidPointer) int32 {
strPtr, strFunc := StringCasting(str)
defer strFunc()
return (int32)(C.av_parse_ratio((*C.struct_AVRational)(q),
(*C.char)(strPtr), (C.int)(max), (C.int)(logOffset), logCtx))
(*C.char)(strPtr), (C.int)(max), (C.int)(logOffset), VoidPointer(logCtx)))
}
// AvParseRatioQuiet
func AvParseRatioQuiet(q *AvRational, str string, max int32) int32 {
func AvParseRatioQuiet(q *AVRational, str string, max int32) int32 {
strPtr, strFunc := StringCasting(str)
defer strFunc()
return (int32)(C.av_parse_ratio((*C.struct_AVRational)(q),
@@ -30,17 +30,17 @@ func AvParseVideoSize(widthPtr, heightPtr *int32, str string) int32 {
}
// AvParseVideoRate parses str and store the detected values in *rate.
func AvParseVideoRate(rate *AvRational, str string) int32 {
func AvParseVideoRate(rate *AVRational, str string) int32 {
strPtr, strFunc := StringCasting(str)
defer strFunc()
return (int32)(C.av_parse_video_rate((*C.struct_AVRational)(rate), (*C.char)(strPtr)))
}
// AvParseColor puts the RGBA values that correspond to color_string in rgba_color.
func AvParseColor(rgbaColor *uint8, colorString string, slen int32, logCtx unsafe.Pointer) int32 {
func AvParseColor(rgbaColor *uint8, colorString string, slen int32, logCtx CVoidPointer) int32 {
strPtr, strFunc := StringCasting(colorString)
defer strFunc()
return (int32)(C.av_parse_color((*C.uint8_t)(rgbaColor), (*C.char)(strPtr), (C.int)(slen), logCtx))
return (int32)(C.av_parse_color((*C.uint8_t)(rgbaColor), (*C.char)(strPtr), (C.int)(slen), VoidPointer(logCtx)))
}
// AvGetKnownColorName gets the name of a color from the internal table of hard-coded named colors.

282
avutil_pixdesc.go
View File

@@ -6,9 +6,175 @@ package ffmpeg
import "C"
import "unsafe"
type AvComponentDescriptor C.struct_AVComponentDescriptor
type AVComponentDescriptor C.struct_AVComponentDescriptor
type AvPixFmtDescriptor C.struct_AVPixFmtDescriptor
// Custom: GetPlane gets `AVComponentDescriptor.plane` value.
func (cd *AVComponentDescriptor) GetPlane() int32 {
return (int32)(cd.plane)
}
// Custom: SetPlane sets `AVComponentDescriptor.plane` value.
func (cd *AVComponentDescriptor) SetPlane(v int32) {
cd.plane = (C.int)(v)
}
// Custom: GetPlaneAddr gets `AVComponentDescriptor.plane` address.
func (cd *AVComponentDescriptor) GetPlaneAddr() *int32 {
return (*int32)(&cd.plane)
}
// Custom: GetStep gets `AVComponentDescriptor.step` value.
func (cd *AVComponentDescriptor) GetStep() int32 {
return (int32)(cd.step)
}
// Custom: SetStep sets `AVComponentDescriptor.step` value.
func (cd *AVComponentDescriptor) SetStep(v int32) {
cd.step = (C.int)(v)
}
// Custom: GetStepAddr gets `AVComponentDescriptor.step` address.
func (cd *AVComponentDescriptor) GetStepAddr() *int32 {
return (*int32)(&cd.step)
}
// Custom: GetOffset gets `AVComponentDescriptor.offset` value.
func (cd *AVComponentDescriptor) GetOffset() int32 {
return (int32)(cd.offset)
}
// Custom: SetOffset sets `AVComponentDescriptor.offset` value.
func (cd *AVComponentDescriptor) SetOffset(v int32) {
cd.offset = (C.int)(v)
}
// Custom: GetOffsetAddr gets `AVComponentDescriptor.offset` address.
func (cd *AVComponentDescriptor) GetOffsetAddr() *int32 {
return (*int32)(&cd.offset)
}
// Custom: GetShift gets `AVComponentDescriptor.shift` value.
func (cd *AVComponentDescriptor) GetShift() int32 {
return (int32)(cd.shift)
}
// Custom: SetShift sets `AVComponentDescriptor.shift` value.
func (cd *AVComponentDescriptor) SetShift(v int32) {
cd.shift = (C.int)(v)
}
// Custom: GetShiftAddr gets `AVComponentDescriptor.shift` address.
func (cd *AVComponentDescriptor) GetShiftAddr() *int32 {
return (*int32)(&cd.shift)
}
// Custom: GetDepth gets `AVComponentDescriptor.depth` value.
func (cd *AVComponentDescriptor) GetDepth() int32 {
return (int32)(cd.depth)
}
// Custom: SetDepth sets `AVComponentDescriptor.depth` value.
func (cd *AVComponentDescriptor) SetDepth(v int32) {
cd.depth = (C.int)(v)
}
// Custom: GetDepthAddr gets `AVComponentDescriptor.depth` address.
func (cd *AVComponentDescriptor) GetDepthAddr() *int32 {
return (*int32)(&cd.depth)
}
// AVPixFmtDescriptor
type AVPixFmtDescriptor C.struct_AVPixFmtDescriptor
// Custom: GetName gets `AVPixFmtDescriptor.name` value.
func (pfd *AVPixFmtDescriptor) GetName() string {
return C.GoString(pfd.name)
}
// Custom: GetNbComponents gets `AVPixFmtDescriptor.nb_components` value.
func (pfd *AVPixFmtDescriptor) GetNbComponents() uint8 {
return (uint8)(pfd.nb_components)
}
// Custom: SetNbComponents sets `AVPixFmtDescriptor.nb_components` value.
func (pfd *AVPixFmtDescriptor) SetNbComponents(v uint8) {
pfd.nb_components = (C.uint8_t)(v)
}
// Custom: GetNbComponentsAddr gets `AVPixFmtDescriptor.nb_components` address.
func (pfd *AVPixFmtDescriptor) GetNbComponentsAddr() *uint8 {
return (*uint8)(&pfd.nb_components)
}
// Custom: GetLog2ChromaW gets `AVPixFmtDescriptor.log2_chroma_w` value.
func (pfd *AVPixFmtDescriptor) GetLog2ChromaW() uint8 {
return (uint8)(pfd.log2_chroma_w)
}
// Custom: SetLog2ChromaW sets `AVPixFmtDescriptor.log2_chroma_w` value.
func (pfd *AVPixFmtDescriptor) SetLog2ChromaW(v uint8) {
pfd.log2_chroma_w = (C.uint8_t)(v)
}
// Custom: GetLog2ChromaWAddr gets `AVPixFmtDescriptor.log2_chroma_w` address.
func (pfd *AVPixFmtDescriptor) GetLog2ChromaWAddr() *uint8 {
return (*uint8)(&pfd.log2_chroma_w)
}
// Custom: GetLog2ChromaH gets `AVPixFmtDescriptor.log2_chroma_h` value.
func (pfd *AVPixFmtDescriptor) GetLog2ChromaH() uint8 {
return (uint8)(pfd.log2_chroma_h)
}
// Custom: SetLog2ChromaH sets `AVPixFmtDescriptor.log2_chroma_h` value.
func (pfd *AVPixFmtDescriptor) SetLog2ChromaH(v uint8) {
pfd.log2_chroma_h = (C.uint8_t)(v)
}
// Custom: GetLog2ChromaHAddr gets `AVPixFmtDescriptor.log2_chroma_h` address.
func (pfd *AVPixFmtDescriptor) GetLog2ChromaHAddr() *uint8 {
return (*uint8)(&pfd.log2_chroma_h)
}
// Custom: GetFlags gets `AVPixFmtDescriptor.flags` value.
func (pfd *AVPixFmtDescriptor) GetFlags() uint64 {
return (uint64)(pfd.flags)
}
// Custom: SetFlags sets `AVPixFmtDescriptor.flags` value.
func (pfd *AVPixFmtDescriptor) SetFlags(v uint64) {
pfd.flags = (C.uint64_t)(v)
}
// Custom: GetFlagsAddr gets `AVPixFmtDescriptor.flags` address.
func (pfd *AVPixFmtDescriptor) GetFlagsAddr() *uint64 {
return (*uint64)(&pfd.flags)
}
// Custom: GetComp gets `AVPixFmtDescriptor.comp` value.
func (pfd *AVPixFmtDescriptor) GetComp(idx int) []AVComponentDescriptor {
return unsafe.Slice((*AVComponentDescriptor)(&pfd.comp[0]), idx)
}
// Custom: GetCompIdx gets `AVPixFmtDescriptor.comp` index value.
func (pfd *AVPixFmtDescriptor) GetCompIdx(idx int) AVComponentDescriptor {
return (AVComponentDescriptor)(pfd.comp[idx])
}
// Custom: SetCompIdx sets `AVPixFmtDescriptor.comp` index value.
func (pfd *AVPixFmtDescriptor) SetCompIdx(idx int, v AVComponentDescriptor) {
pfd.comp[idx] = (C.struct_AVComponentDescriptor)(v)
}
// Custom: GetCompIdxAddr gets `AVPixFmtDescriptor.comp` index address.
func (pfd *AVPixFmtDescriptor) GetCompIdxAddr(idx int) *AVComponentDescriptor {
return (*AVComponentDescriptor)(&pfd.comp[idx])
}
// Custom: GetAlias gets `AVPixFmtDescriptor.alias` value.
func (pfd *AVPixFmtDescriptor) GetAlias() string {
return C.GoString(pfd.alias)
}
const (
AV_PIX_FMT_FLAG_BE = C.AV_PIX_FMT_FLAG_BE
@@ -25,51 +191,51 @@ const (
// AvGetBitsPerPixel returns the number of bits per pixel used by the pixel format
// described by pixdesc.
func AvGetBitsPerPixel(pixdesc *AvPixFmtDescriptor) int32 {
func AvGetBitsPerPixel(pixdesc *AVPixFmtDescriptor) int32 {
return (int32)(C.av_get_bits_per_pixel((*C.struct_AVPixFmtDescriptor)(pixdesc)))
}
// AvGetPaddedBitsPerPixel returns the number of bits per pixel for the pixel format
// described by pixdesc, including any padding or unused bits.
func AvGetPaddedBitsPerPixel(pixdesc *AvPixFmtDescriptor) int32 {
func AvGetPaddedBitsPerPixel(pixdesc *AVPixFmtDescriptor) int32 {
return (int32)(C.av_get_padded_bits_per_pixel((*C.struct_AVPixFmtDescriptor)(pixdesc)))
}
// AvPixFmtDescGet returns a pixel format descriptor for provided pixel format or NULL if
// this pixel format is unknown.
func AvPixFmtDescGet(pixFmt AvPixelFormat) *AvPixFmtDescriptor {
return (*AvPixFmtDescriptor)(C.av_pix_fmt_desc_get((C.enum_AVPixelFormat)(pixFmt)))
func AvPixFmtDescGet(pixFmt AVPixelFormat) *AVPixFmtDescriptor {
return (*AVPixFmtDescriptor)(C.av_pix_fmt_desc_get((C.enum_AVPixelFormat)(pixFmt)))
}
// AvPixFmtDescNext iterates over all pixel format descriptors known to libavutil.
func AvPixFmtDescNext(prev *AvPixFmtDescriptor) *AvPixFmtDescriptor {
return (*AvPixFmtDescriptor)(C.av_pix_fmt_desc_next((*C.struct_AVPixFmtDescriptor)(prev)))
func AvPixFmtDescNext(prev *AVPixFmtDescriptor) *AVPixFmtDescriptor {
return (*AVPixFmtDescriptor)(C.av_pix_fmt_desc_next((*C.struct_AVPixFmtDescriptor)(prev)))
}
// AvPixFmtDescGetId returns an AvPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc
// AvPixFmtDescGetId returns an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc
// is not a valid pointer to a pixel format descriptor.
func AvPixFmtDescGetId(desc *AvPixFmtDescriptor) AvPixelFormat {
return (AvPixelFormat)(C.av_pix_fmt_desc_get_id((*C.struct_AVPixFmtDescriptor)(desc)))
func AvPixFmtDescGetId(desc *AVPixFmtDescriptor) AVPixelFormat {
return (AVPixelFormat)(C.av_pix_fmt_desc_get_id((*C.struct_AVPixFmtDescriptor)(desc)))
}
// AvPixFmtGetChromaSubSample accesses log2_chroma_w log2_chroma_h from the pixel format AvPixFmtDescriptor.
func AvPixFmtGetChromaSubSample(pixFmt AvPixelFormat, hShift, vShift *int32) int32 {
// AvPixFmtGetChromaSubSample accesses log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
func AvPixFmtGetChromaSubSample(pixFmt AVPixelFormat, hShift, vShift *int32) int32 {
return (int32)(C.av_pix_fmt_get_chroma_sub_sample((C.enum_AVPixelFormat)(pixFmt),
(*C.int)(hShift), (*C.int)(vShift)))
}
// AvPixFmtCountPlanes returns number of planes in pix_fmt, a negative AvERROR if pix_fmt is not a
// valid pixel format.
func AvPixFmtCountPlanes(pixFmt AvPixelFormat) int32 {
func AvPixFmtCountPlanes(pixFmt AVPixelFormat) int32 {
return (int32)(C.av_pix_fmt_count_planes((C.enum_AVPixelFormat)(pixFmt)))
}
// AvColorRangeName returns the name for provided color range or NULL if unknown.
func AvColorRangeName(_range AvColorRange) string {
func AvColorRangeName(_range AVColorRange) string {
return C.GoString(C.av_color_range_name((C.enum_AVColorRange)(_range)))
}
// AvColorRangeFromName returns the AvColorRange value for name or an AvError if not found.
// AvColorRangeFromName returns the AVColorRange value for name or an AvError if not found.
func AvColorRangeFromName(name string) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
@@ -77,11 +243,11 @@ func AvColorRangeFromName(name string) int32 {
}
// AvColorPrimariesName returns the name for provided color primaries or NULL if unknown.
func AvColorPrimariesName(primaries AvColorPrimaries) string {
func AvColorPrimariesName(primaries AVColorPrimaries) string {
return C.GoString(C.av_color_primaries_name((C.enum_AVColorRange)(primaries)))
}
// AvColorPrimariesFromName returns the AvColorPrimaries value for name or an AVError if not found.
// AvColorPrimariesFromName returns the AVColorPrimaries value for name or an AVError if not found.
func AvColorPrimariesFromName(name string) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
@@ -89,11 +255,11 @@ func AvColorPrimariesFromName(name string) int32 {
}
// AvColorTransferName returns the name for provided color transfer or NULL if unknown.
func AvColorTransferName(transfer AvColorTransferCharacteristic) string {
func AvColorTransferName(transfer AVColorTransferCharacteristic) string {
return C.GoString(C.av_color_transfer_name((C.enum_AVColorTransferCharacteristic)(transfer)))
}
// AvColorTransferFromName returns the AvColorTransferCharacteristic value for name or an AvError if not found.
// AvColorTransferFromName returns the AVColorTransferCharacteristic value for name or an AvError if not found.
func AvColorTransferFromName(name string) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
@@ -101,11 +267,11 @@ func AvColorTransferFromName(name string) int32 {
}
// AvColorSpaceName returns the name for provided color space or NULL if unknown.
func AvColorSpaceName(space AvColorSpace) string {
func AvColorSpaceName(space AVColorSpace) string {
return C.GoString(C.av_color_space_name((C.enum_AVColorSpace)(space)))
}
// AvColorSpaceFromName returns the AvColorSpace value for name or an AvError if not found.
// AvColorSpaceFromName returns the AVColorSpace value for name or an AvError if not found.
func AvColorSpaceFromName(name string) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
@@ -113,11 +279,11 @@ func AvColorSpaceFromName(name string) int32 {
}
// AvChromaLocationName returns the name for provided chroma location or NULL if unknown.
func AvChromaLocationName(location AvChromaLocation) string {
func AvChromaLocationName(location AVChromaLocation) string {
return C.GoString(C.av_chroma_location_name((C.enum_AVChromaLocation)(location)))
}
// AvChromaLocationFromName returns the AvChromaLocation value for name or an AVError if not found.
// AvChromaLocationFromName returns the AVChromaLocation value for name or an AVError if not found.
func AvChromaLocationFromName(name string) int32 {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
@@ -125,35 +291,35 @@ func AvChromaLocationFromName(name string) int32 {
}
// AvGetPixFmt returns the pixel format corresponding to name.
func AvGetPixFmt(name string) AvPixelFormat {
func AvGetPixFmt(name string) AVPixelFormat {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (AvPixelFormat)(C.av_get_pix_fmt((*C.char)(namePtr)))
return (AVPixelFormat)(C.av_get_pix_fmt((*C.char)(namePtr)))
}
// AvGetPixFmtName returns the short name for a pixel format, NULL in case pix_fmt is unknown.
func AvGetPixFmtName(pixFmt AvPixelFormat) string {
func AvGetPixFmtName(pixFmt AVPixelFormat) string {
return C.GoString(C.av_get_pix_fmt_name((C.enum_AVPixelFormat)(pixFmt)))
}
// AvGetPixFmtString prints in buf the string corresponding to the pixel format with
// number pix_fmt, or a header if pix_fmt is negative.
func AvGetPixFmtString(buf *int8, bufSize int32, pixFmt AvPixelFormat) string {
func AvGetPixFmtString(buf *int8, bufSize int32, pixFmt AVPixelFormat) string {
return C.GoString(C.av_get_pix_fmt_string((*C.char)(buf), (C.int)(bufSize),
(C.enum_AVPixelFormat)(pixFmt)))
}
// AvReadImageLine2 reads a line from an image, and write the values of the
// pixel format component c to dst.
func AvReadImageLine2(dst unsafe.Pointer, data []*uint8, linesize []int,
desc *AvPixFmtDescriptor, x, y, c, w, readPalComponent, dstElementSize int32) {
if len(data) != 4 {
panic("data need len = 4")
func AvReadImageLine2(dst CVoidPointer, data []*uint8, linesize []int,
desc *AVPixFmtDescriptor, x, y, c, w, readPalComponent, dstElementSize int32) {
if len(data) < 4 {
panic("data len < 4")
}
if len(linesize) != 4 {
panic("linesize need len = 4")
if len(linesize) < 4 {
panic("linesize len < 4")
}
C.av_read_image_line2(dst,
C.av_read_image_line2(VoidPointer(dst),
(**C.uint8_t)(unsafe.Pointer(&data[0])),
(*C.int)(unsafe.Pointer(&linesize[0])),
(*C.struct_AVPixFmtDescriptor)(desc),
@@ -164,12 +330,12 @@ func AvReadImageLine2(dst unsafe.Pointer, data []*uint8, linesize []int,
// AvReadImageLine reads a line from an image, and write the values of the
// pixel format component c to dst.
func AvReadImageLine(dst *uint16, data []*uint8, linesize []int,
desc *AvPixFmtDescriptor, x, y, c, w, readPalComponent int32) {
if len(data) != 4 {
panic("data need len = 4")
desc *AVPixFmtDescriptor, x, y, c, w, readPalComponent int32) {
if len(data) < 4 {
panic("data len < 4")
}
if len(linesize) != 4 {
panic("linesize need len = 4")
if len(linesize) < 4 {
panic("linesize len < 4")
}
C.av_read_image_line((*C.uint16_t)(dst),
(**C.uint8_t)(unsafe.Pointer(&data[0])),
@@ -180,15 +346,15 @@ func AvReadImageLine(dst *uint16, data []*uint8, linesize []int,
}
// AvWriteImageLine2 writes the values from src to the pixel format component c of an image line.
func AvWriteImageLine2(src unsafe.Pointer, data []*uint8, linesize []int,
desc *AvPixFmtDescriptor, x, y, c, w, srcElementSize int32) {
if len(data) != 4 {
panic("data need len = 4")
func AvWriteImageLine2(src CVoidPointer, data []*uint8, linesize []int,
desc *AVPixFmtDescriptor, x, y, c, w, srcElementSize int32) {
if len(data) < 4 {
panic("data len < 4")
}
if len(linesize) != 4 {
panic("linesize need len = 4")
if len(linesize) < 4 {
panic("linesize len < 4")
}
C.av_write_image_line2(src,
C.av_write_image_line2(VoidPointer(src),
(**C.uint8_t)(unsafe.Pointer(&data[0])),
(*C.int)(unsafe.Pointer(&linesize[0])),
(*C.struct_AVPixFmtDescriptor)(desc),
@@ -198,12 +364,12 @@ func AvWriteImageLine2(src unsafe.Pointer, data []*uint8, linesize []int,
// AvWriteImageLine writes the values from src to the pixel format component c of an image line.
func AvWriteImageLine(src *uint16, data []*uint8, linesize []int,
desc *AvPixFmtDescriptor, x, y, c, w int32) {
if len(data) != 4 {
panic("data need len = 4")
desc *AVPixFmtDescriptor, x, y, c, w int32) {
if len(data) < 4 {
panic("data len < 4")
}
if len(linesize) != 4 {
panic("linesize need len = 4")
if len(linesize) < 4 {
panic("linesize len < 4")
}
C.av_write_image_line((*C.uint16_t)(src),
(**C.uint8_t)(unsafe.Pointer(&data[0])),
@@ -213,8 +379,8 @@ func AvWriteImageLine(src *uint16, data []*uint8, linesize []int,
}
// AvPixFmtSwapEndianness
func AvPixFmtSwapEndianness(pixFmt AvPixelFormat) AvPixelFormat {
return (AvPixelFormat)(C.av_pix_fmt_swap_endianness((C.enum_AVPixelFormat)(pixFmt)))
func AvPixFmtSwapEndianness(pixFmt AVPixelFormat) AVPixelFormat {
return (AVPixelFormat)(C.av_pix_fmt_swap_endianness((C.enum_AVPixelFormat)(pixFmt)))
}
const (
@@ -228,16 +394,16 @@ const (
// AvGetPixFmtLoss computes what kind of losses will occur when converting from one specific
// pixel format to another.
func AvGetPixFmtLoss(dstPixFmt, srcPixFmt AvPixelFormat, hasAlpha int32) int32 {
func AvGetPixFmtLoss(dstPixFmt, srcPixFmt AVPixelFormat, hasAlpha int32) int32 {
return (int32)(C.av_get_pix_fmt_loss((C.enum_AVPixelFormat)(dstPixFmt),
(C.enum_AVPixelFormat)(srcPixFmt), (C.int)(hasAlpha)))
}
// AvFindBestPixFmtOf2 compute what kind of losses will occur when converting from one specific
// pixel format to another.
func AvFindBestPixFmtOf2(dstPixFmt1, dstPixFmt2, srcPixFmt AvPixelFormat,
hasAlpha int32, lossPtr *int32) AvPixelFormat {
return (AvPixelFormat)(C.av_find_best_pix_fmt_of_2((C.enum_AVPixelFormat)(dstPixFmt1),
func AvFindBestPixFmtOf2(dstPixFmt1, dstPixFmt2, srcPixFmt AVPixelFormat,
hasAlpha int32, lossPtr *int32) AVPixelFormat {
return (AVPixelFormat)(C.av_find_best_pix_fmt_of_2((C.enum_AVPixelFormat)(dstPixFmt1),
(C.enum_AVPixelFormat)(dstPixFmt2),
(C.enum_AVPixelFormat)(srcPixFmt),
(C.int)(hasAlpha), (*C.int)(lossPtr)))

9
avutil_pixelutils.go
View File

@@ -5,13 +5,12 @@ package ffmpeg
*/
import "C"
import "unsafe"
type AvPixelutilsSadFn C.av_pixelutils_sad_fn
type AVPixelutilsSadFn C.av_pixelutils_sad_fn
// AvPixelutilsGetSadFn gets a potentially optimized pointer to a Sum-of-absolute-differences
// function (see the av_pixelutils_sad_fn prototype).
func AvPixelutilsGetSadFn(wBits, hBits, aligned int32, logCtx unsafe.Pointer) AvPixelutilsSadFn {
return (AvPixelutilsSadFn)(C.av_pixelutils_get_sad_fn((C.int)(wBits), (C.int)(hBits),
(C.int)(aligned), logCtx))
func AvPixelutilsGetSadFn(wBits, hBits, aligned int32, logCtx CVoidPointer) AVPixelutilsSadFn {
return (AVPixelutilsSadFn)(C.av_pixelutils_get_sad_fn((C.int)(wBits), (C.int)(hBits),
(C.int)(aligned), VoidPointer(logCtx)))
}

706
avutil_pixfmt.go
View File

@@ -6,437 +6,437 @@ package ffmpeg
import "C"
// Pixel format.
type AvPixelFormat = C.enum_AVPixelFormat
type AVPixelFormat = C.enum_AVPixelFormat
const (
AV_PIX_FMT_NONE = AvPixelFormat(C.AV_PIX_FMT_NONE)
AV_PIX_FMT_YUV420P = AvPixelFormat(C.AV_PIX_FMT_YUV420P)
AV_PIX_FMT_YUYV422 = AvPixelFormat(C.AV_PIX_FMT_YUYV422)
AV_PIX_FMT_RGB24 = AvPixelFormat(C.AV_PIX_FMT_RGB24)
AV_PIX_FMT_BGR24 = AvPixelFormat(C.AV_PIX_FMT_BGR24)
AV_PIX_FMT_YUV422P = AvPixelFormat(C.AV_PIX_FMT_YUV422P)
AV_PIX_FMT_YUV444P = AvPixelFormat(C.AV_PIX_FMT_YUV444P)
AV_PIX_FMT_YUV410P = AvPixelFormat(C.AV_PIX_FMT_YUV410P)
AV_PIX_FMT_YUV411P = AvPixelFormat(C.AV_PIX_FMT_YUV411P)
AV_PIX_FMT_GRAY8 = AvPixelFormat(C.AV_PIX_FMT_GRAY8)
AV_PIX_FMT_MONOWHITE = AvPixelFormat(C.AV_PIX_FMT_MONOWHITE)
AV_PIX_FMT_MONOBLACK = AvPixelFormat(C.AV_PIX_FMT_MONOBLACK)
AV_PIX_FMT_PAL8 = AvPixelFormat(C.AV_PIX_FMT_PAL8)
AV_PIX_FMT_YUVJ420P = AvPixelFormat(C.AV_PIX_FMT_YUVJ420P)
AV_PIX_FMT_YUVJ422P = AvPixelFormat(C.AV_PIX_FMT_YUVJ422P)
AV_PIX_FMT_YUVJ444P = AvPixelFormat(C.AV_PIX_FMT_YUVJ444P)
AV_PIX_FMT_UYVY422 = AvPixelFormat(C.AV_PIX_FMT_UYVY422)
AV_PIX_FMT_UYYVYY411 = AvPixelFormat(C.AV_PIX_FMT_UYYVYY411)
AV_PIX_FMT_BGR8 = AvPixelFormat(C.AV_PIX_FMT_BGR8)
AV_PIX_FMT_BGR4 = AvPixelFormat(C.AV_PIX_FMT_BGR4)
AV_PIX_FMT_BGR4_BYTE = AvPixelFormat(C.AV_PIX_FMT_BGR4_BYTE)
AV_PIX_FMT_RGB8 = AvPixelFormat(C.AV_PIX_FMT_RGB8)
AV_PIX_FMT_RGB4 = AvPixelFormat(C.AV_PIX_FMT_RGB4)
AV_PIX_FMT_RGB4_BYTE = AvPixelFormat(C.AV_PIX_FMT_RGB4_BYTE)
AV_PIX_FMT_NV12 = AvPixelFormat(C.AV_PIX_FMT_NV12)
AV_PIX_FMT_NV21 = AvPixelFormat(C.AV_PIX_FMT_NV21)
AV_PIX_FMT_NONE = AVPixelFormat(C.AV_PIX_FMT_NONE)
AV_PIX_FMT_YUV420P = AVPixelFormat(C.AV_PIX_FMT_YUV420P)
AV_PIX_FMT_YUYV422 = AVPixelFormat(C.AV_PIX_FMT_YUYV422)
AV_PIX_FMT_RGB24 = AVPixelFormat(C.AV_PIX_FMT_RGB24)
AV_PIX_FMT_BGR24 = AVPixelFormat(C.AV_PIX_FMT_BGR24)
AV_PIX_FMT_YUV422P = AVPixelFormat(C.AV_PIX_FMT_YUV422P)
AV_PIX_FMT_YUV444P = AVPixelFormat(C.AV_PIX_FMT_YUV444P)
AV_PIX_FMT_YUV410P = AVPixelFormat(C.AV_PIX_FMT_YUV410P)
AV_PIX_FMT_YUV411P = AVPixelFormat(C.AV_PIX_FMT_YUV411P)
AV_PIX_FMT_GRAY8 = AVPixelFormat(C.AV_PIX_FMT_GRAY8)
AV_PIX_FMT_MONOWHITE = AVPixelFormat(C.AV_PIX_FMT_MONOWHITE)
AV_PIX_FMT_MONOBLACK = AVPixelFormat(C.AV_PIX_FMT_MONOBLACK)
AV_PIX_FMT_PAL8 = AVPixelFormat(C.AV_PIX_FMT_PAL8)
AV_PIX_FMT_YUVJ420P = AVPixelFormat(C.AV_PIX_FMT_YUVJ420P)
AV_PIX_FMT_YUVJ422P = AVPixelFormat(C.AV_PIX_FMT_YUVJ422P)
AV_PIX_FMT_YUVJ444P = AVPixelFormat(C.AV_PIX_FMT_YUVJ444P)
AV_PIX_FMT_UYVY422 = AVPixelFormat(C.AV_PIX_FMT_UYVY422)
AV_PIX_FMT_UYYVYY411 = AVPixelFormat(C.AV_PIX_FMT_UYYVYY411)
AV_PIX_FMT_BGR8 = AVPixelFormat(C.AV_PIX_FMT_BGR8)
AV_PIX_FMT_BGR4 = AVPixelFormat(C.AV_PIX_FMT_BGR4)
AV_PIX_FMT_BGR4_BYTE = AVPixelFormat(C.AV_PIX_FMT_BGR4_BYTE)
AV_PIX_FMT_RGB8 = AVPixelFormat(C.AV_PIX_FMT_RGB8)
AV_PIX_FMT_RGB4 = AVPixelFormat(C.AV_PIX_FMT_RGB4)
AV_PIX_FMT_RGB4_BYTE = AVPixelFormat(C.AV_PIX_FMT_RGB4_BYTE)
AV_PIX_FMT_NV12 = AVPixelFormat(C.AV_PIX_FMT_NV12)
AV_PIX_FMT_NV21 = AVPixelFormat(C.AV_PIX_FMT_NV21)
AV_PIX_FMT_ARGB = AvPixelFormat(C.AV_PIX_FMT_ARGB)
AV_PIX_FMT_RGBA = AvPixelFormat(C.AV_PIX_FMT_RGBA)
AV_PIX_FMT_ABGR = AvPixelFormat(C.AV_PIX_FMT_ABGR)
AV_PIX_FMT_BGRA = AvPixelFormat(C.AV_PIX_FMT_BGRA)
AV_PIX_FMT_ARGB = AVPixelFormat(C.AV_PIX_FMT_ARGB)
AV_PIX_FMT_RGBA = AVPixelFormat(C.AV_PIX_FMT_RGBA)
AV_PIX_FMT_ABGR = AVPixelFormat(C.AV_PIX_FMT_ABGR)
AV_PIX_FMT_BGRA = AVPixelFormat(C.AV_PIX_FMT_BGRA)
AV_PIX_FMT_GRAY16BE = AvPixelFormat(C.AV_PIX_FMT_GRAY16BE)
AV_PIX_FMT_GRAY16LE = AvPixelFormat(C.AV_PIX_FMT_GRAY16LE)
AV_PIX_FMT_YUV440P = AvPixelFormat(C.AV_PIX_FMT_YUV440P)
AV_PIX_FMT_YUVJ440P = AvPixelFormat(C.AV_PIX_FMT_YUVJ440P)
AV_PIX_FMT_YUVA420P = AvPixelFormat(C.AV_PIX_FMT_YUVA420P)
AV_PIX_FMT_RGB48BE = AvPixelFormat(C.AV_PIX_FMT_RGB48BE)
AV_PIX_FMT_RGB48LE = AvPixelFormat(C.AV_PIX_FMT_RGB48LE)
AV_PIX_FMT_GRAY16BE = AVPixelFormat(C.AV_PIX_FMT_GRAY16BE)
AV_PIX_FMT_GRAY16LE = AVPixelFormat(C.AV_PIX_FMT_GRAY16LE)
AV_PIX_FMT_YUV440P = AVPixelFormat(C.AV_PIX_FMT_YUV440P)
AV_PIX_FMT_YUVJ440P = AVPixelFormat(C.AV_PIX_FMT_YUVJ440P)
AV_PIX_FMT_YUVA420P = AVPixelFormat(C.AV_PIX_FMT_YUVA420P)
AV_PIX_FMT_RGB48BE = AVPixelFormat(C.AV_PIX_FMT_RGB48BE)
AV_PIX_FMT_RGB48LE = AVPixelFormat(C.AV_PIX_FMT_RGB48LE)
AV_PIX_FMT_RGB565BE = AvPixelFormat(C.AV_PIX_FMT_RGB565BE)
AV_PIX_FMT_RGB565LE = AvPixelFormat(C.AV_PIX_FMT_RGB565LE)
AV_PIX_FMT_RGB555BE = AvPixelFormat(C.AV_PIX_FMT_RGB555BE)
AV_PIX_FMT_RGB555LE = AvPixelFormat(C.AV_PIX_FMT_RGB555LE)
AV_PIX_FMT_RGB565BE = AVPixelFormat(C.AV_PIX_FMT_RGB565BE)
AV_PIX_FMT_RGB565LE = AVPixelFormat(C.AV_PIX_FMT_RGB565LE)
AV_PIX_FMT_RGB555BE = AVPixelFormat(C.AV_PIX_FMT_RGB555BE)
AV_PIX_FMT_RGB555LE = AVPixelFormat(C.AV_PIX_FMT_RGB555LE)
AV_PIX_FMT_BGR565BE = AvPixelFormat(C.AV_PIX_FMT_BGR565BE)
AV_PIX_FMT_BGR565LE = AvPixelFormat(C.AV_PIX_FMT_BGR565LE)
AV_PIX_FMT_BGR555BE = AvPixelFormat(C.AV_PIX_FMT_BGR555BE)
AV_PIX_FMT_BGR555LE = AvPixelFormat(C.AV_PIX_FMT_BGR555LE)
AV_PIX_FMT_BGR565BE = AVPixelFormat(C.AV_PIX_FMT_BGR565BE)
AV_PIX_FMT_BGR565LE = AVPixelFormat(C.AV_PIX_FMT_BGR565LE)
AV_PIX_FMT_BGR555BE = AVPixelFormat(C.AV_PIX_FMT_BGR555BE)
AV_PIX_FMT_BGR555LE = AVPixelFormat(C.AV_PIX_FMT_BGR555LE)
AV_PIX_FMT_VAAPI_MOCO = AvPixelFormat(C.AV_PIX_FMT_VAAPI_MOCO)
AV_PIX_FMT_VAAPI_IDCT = AvPixelFormat(C.AV_PIX_FMT_VAAPI_IDCT)
AV_PIX_FMT_VAAPI_VLD = AvPixelFormat(C.AV_PIX_FMT_VAAPI_VLD)
AV_PIX_FMT_VAAPI = AvPixelFormat(C.AV_PIX_FMT_VAAPI)
AV_PIX_FMT_VAAPI_MOCO = AVPixelFormat(C.AV_PIX_FMT_VAAPI_MOCO)
AV_PIX_FMT_VAAPI_IDCT = AVPixelFormat(C.AV_PIX_FMT_VAAPI_IDCT)
AV_PIX_FMT_VAAPI_VLD = AVPixelFormat(C.AV_PIX_FMT_VAAPI_VLD)
AV_PIX_FMT_VAAPI = AVPixelFormat(C.AV_PIX_FMT_VAAPI)
AV_PIX_FMT_YUV420P16LE = AvPixelFormat(C.AV_PIX_FMT_YUV420P16LE)
AV_PIX_FMT_YUV420P16BE = AvPixelFormat(C.AV_PIX_FMT_YUV420P16BE)
AV_PIX_FMT_YUV422P16LE = AvPixelFormat(C.AV_PIX_FMT_YUV422P16LE)
AV_PIX_FMT_YUV422P16BE = AvPixelFormat(C.AV_PIX_FMT_YUV422P16BE)
AV_PIX_FMT_YUV444P16LE = AvPixelFormat(C.AV_PIX_FMT_YUV444P16LE)
AV_PIX_FMT_YUV444P16BE = AvPixelFormat(C.AV_PIX_FMT_YUV444P16BE)
AV_PIX_FMT_DXVA2_VLD = AvPixelFormat(C.AV_PIX_FMT_DXVA2_VLD)
AV_PIX_FMT_YUV420P16LE = AVPixelFormat(C.AV_PIX_FMT_YUV420P16LE)
AV_PIX_FMT_YUV420P16BE = AVPixelFormat(C.AV_PIX_FMT_YUV420P16BE)
AV_PIX_FMT_YUV422P16LE = AVPixelFormat(C.AV_PIX_FMT_YUV422P16LE)
AV_PIX_FMT_YUV422P16BE = AVPixelFormat(C.AV_PIX_FMT_YUV422P16BE)
AV_PIX_FMT_YUV444P16LE = AVPixelFormat(C.AV_PIX_FMT_YUV444P16LE)
AV_PIX_FMT_YUV444P16BE = AVPixelFormat(C.AV_PIX_FMT_YUV444P16BE)
AV_PIX_FMT_DXVA2_VLD = AVPixelFormat(C.AV_PIX_FMT_DXVA2_VLD)
AV_PIX_FMT_RGB444LE = AvPixelFormat(C.AV_PIX_FMT_RGB444LE)
AV_PIX_FMT_RGB444BE = AvPixelFormat(C.AV_PIX_FMT_RGB444BE)
AV_PIX_FMT_BGR444LE = AvPixelFormat(C.AV_PIX_FMT_BGR444LE)
AV_PIX_FMT_BGR444BE = AvPixelFormat(C.AV_PIX_FMT_BGR444BE)
AV_PIX_FMT_YA8 = AvPixelFormat(C.AV_PIX_FMT_YA8)
AV_PIX_FMT_RGB444LE = AVPixelFormat(C.AV_PIX_FMT_RGB444LE)
AV_PIX_FMT_RGB444BE = AVPixelFormat(C.AV_PIX_FMT_RGB444BE)
AV_PIX_FMT_BGR444LE = AVPixelFormat(C.AV_PIX_FMT_BGR444LE)
AV_PIX_FMT_BGR444BE = AVPixelFormat(C.AV_PIX_FMT_BGR444BE)
AV_PIX_FMT_YA8 = AVPixelFormat(C.AV_PIX_FMT_YA8)
AV_PIX_FMT_Y400A = AvPixelFormat(C.AV_PIX_FMT_Y400A)
AV_PIX_FMT_GRAY8A = AvPixelFormat(C.AV_PIX_FMT_GRAY8A)
AV_PIX_FMT_Y400A = AVPixelFormat(C.AV_PIX_FMT_Y400A)
AV_PIX_FMT_GRAY8A = AVPixelFormat(C.AV_PIX_FMT_GRAY8A)
AV_PIX_FMT_BGR48BE = AvPixelFormat(C.AV_PIX_FMT_BGR48BE)
AV_PIX_FMT_BGR48LE = AvPixelFormat(C.AV_PIX_FMT_BGR48LE)
AV_PIX_FMT_BGR48BE = AVPixelFormat(C.AV_PIX_FMT_BGR48BE)
AV_PIX_FMT_BGR48LE = AVPixelFormat(C.AV_PIX_FMT_BGR48LE)
AV_PIX_FMT_YUV420P9BE = AvPixelFormat(C.AV_PIX_FMT_YUV420P9BE)
AV_PIX_FMT_YUV420P9LE = AvPixelFormat(C.AV_PIX_FMT_YUV420P9LE)
AV_PIX_FMT_YUV420P10BE = AvPixelFormat(C.AV_PIX_FMT_YUV420P10BE)
AV_PIX_FMT_YUV420P10LE = AvPixelFormat(C.AV_PIX_FMT_YUV420P10LE)
AV_PIX_FMT_YUV422P10BE = AvPixelFormat(C.AV_PIX_FMT_YUV422P10BE)
AV_PIX_FMT_YUV422P10LE = AvPixelFormat(C.AV_PIX_FMT_YUV422P10LE)
AV_PIX_FMT_YUV444P9BE = AvPixelFormat(C.AV_PIX_FMT_YUV444P9BE)
AV_PIX_FMT_YUV444P9LE = AvPixelFormat(C.AV_PIX_FMT_YUV444P9LE)
AV_PIX_FMT_YUV444P10BE = AvPixelFormat(C.AV_PIX_FMT_YUV444P10BE)
AV_PIX_FMT_YUV444P10LE = AvPixelFormat(C.AV_PIX_FMT_YUV444P10LE)
AV_PIX_FMT_YUV422P9BE = AvPixelFormat(C.AV_PIX_FMT_YUV422P9BE)
AV_PIX_FMT_YUV422P9LE = AvPixelFormat(C.AV_PIX_FMT_YUV422P9LE)
AV_PIX_FMT_GBRP = AvPixelFormat(C.AV_PIX_FMT_GBRP)
AV_PIX_FMT_GBR24P = AvPixelFormat(C.AV_PIX_FMT_GBR24P)
AV_PIX_FMT_GBRP9BE = AvPixelFormat(C.AV_PIX_FMT_GBRP9BE)
AV_PIX_FMT_GBRP9LE = AvPixelFormat(C.AV_PIX_FMT_GBRP9LE)
AV_PIX_FMT_GBRP10BE = AvPixelFormat(C.AV_PIX_FMT_GBRP10BE)
AV_PIX_FMT_GBRP10LE = AvPixelFormat(C.AV_PIX_FMT_GBRP10LE)
AV_PIX_FMT_GBRP16BE = AvPixelFormat(C.AV_PIX_FMT_GBRP16BE)
AV_PIX_FMT_GBRP16LE = AvPixelFormat(C.AV_PIX_FMT_GBRP16LE)
AV_PIX_FMT_YUVA422P = AvPixelFormat(C.AV_PIX_FMT_YUVA422P)
AV_PIX_FMT_YUVA444P = AvPixelFormat(C.AV_PIX_FMT_YUVA444P)
AV_PIX_FMT_YUVA420P9BE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P9BE)
AV_PIX_FMT_YUVA420P9LE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P9LE)
AV_PIX_FMT_YUVA422P9BE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P9BE)
AV_PIX_FMT_YUVA422P9LE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P9LE)
AV_PIX_FMT_YUVA444P9BE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P9BE)
AV_PIX_FMT_YUVA444P9LE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P9LE)
AV_PIX_FMT_YUVA420P10BE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P10BE)
AV_PIX_FMT_YUVA420P10LE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P10LE)
AV_PIX_FMT_YUVA422P10BE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P10BE)
AV_PIX_FMT_YUVA422P10LE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P10LE)
AV_PIX_FMT_YUVA444P10BE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P10BE)
AV_PIX_FMT_YUVA444P10LE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P10LE)
AV_PIX_FMT_YUVA420P16BE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P16BE)
AV_PIX_FMT_YUVA420P16LE = AvPixelFormat(C.AV_PIX_FMT_YUVA420P16LE)
AV_PIX_FMT_YUVA422P16BE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P16BE)
AV_PIX_FMT_YUVA422P16LE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P16LE)
AV_PIX_FMT_YUVA444P16BE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P16BE)
AV_PIX_FMT_YUVA444P16LE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P16LE)
AV_PIX_FMT_YUV420P9BE = AVPixelFormat(C.AV_PIX_FMT_YUV420P9BE)
AV_PIX_FMT_YUV420P9LE = AVPixelFormat(C.AV_PIX_FMT_YUV420P9LE)
AV_PIX_FMT_YUV420P10BE = AVPixelFormat(C.AV_PIX_FMT_YUV420P10BE)
AV_PIX_FMT_YUV420P10LE = AVPixelFormat(C.AV_PIX_FMT_YUV420P10LE)
AV_PIX_FMT_YUV422P10BE = AVPixelFormat(C.AV_PIX_FMT_YUV422P10BE)
AV_PIX_FMT_YUV422P10LE = AVPixelFormat(C.AV_PIX_FMT_YUV422P10LE)
AV_PIX_FMT_YUV444P9BE = AVPixelFormat(C.AV_PIX_FMT_YUV444P9BE)
AV_PIX_FMT_YUV444P9LE = AVPixelFormat(C.AV_PIX_FMT_YUV444P9LE)
AV_PIX_FMT_YUV444P10BE = AVPixelFormat(C.AV_PIX_FMT_YUV444P10BE)
AV_PIX_FMT_YUV444P10LE = AVPixelFormat(C.AV_PIX_FMT_YUV444P10LE)
AV_PIX_FMT_YUV422P9BE = AVPixelFormat(C.AV_PIX_FMT_YUV422P9BE)
AV_PIX_FMT_YUV422P9LE = AVPixelFormat(C.AV_PIX_FMT_YUV422P9LE)
AV_PIX_FMT_GBRP = AVPixelFormat(C.AV_PIX_FMT_GBRP)
AV_PIX_FMT_GBR24P = AVPixelFormat(C.AV_PIX_FMT_GBR24P)
AV_PIX_FMT_GBRP9BE = AVPixelFormat(C.AV_PIX_FMT_GBRP9BE)
AV_PIX_FMT_GBRP9LE = AVPixelFormat(C.AV_PIX_FMT_GBRP9LE)
AV_PIX_FMT_GBRP10BE = AVPixelFormat(C.AV_PIX_FMT_GBRP10BE)
AV_PIX_FMT_GBRP10LE = AVPixelFormat(C.AV_PIX_FMT_GBRP10LE)
AV_PIX_FMT_GBRP16BE = AVPixelFormat(C.AV_PIX_FMT_GBRP16BE)
AV_PIX_FMT_GBRP16LE = AVPixelFormat(C.AV_PIX_FMT_GBRP16LE)
AV_PIX_FMT_YUVA422P = AVPixelFormat(C.AV_PIX_FMT_YUVA422P)
AV_PIX_FMT_YUVA444P = AVPixelFormat(C.AV_PIX_FMT_YUVA444P)
AV_PIX_FMT_YUVA420P9BE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P9BE)
AV_PIX_FMT_YUVA420P9LE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P9LE)
AV_PIX_FMT_YUVA422P9BE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P9BE)
AV_PIX_FMT_YUVA422P9LE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P9LE)
AV_PIX_FMT_YUVA444P9BE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P9BE)
AV_PIX_FMT_YUVA444P9LE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P9LE)
AV_PIX_FMT_YUVA420P10BE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P10BE)
AV_PIX_FMT_YUVA420P10LE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P10LE)
AV_PIX_FMT_YUVA422P10BE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P10BE)
AV_PIX_FMT_YUVA422P10LE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P10LE)
AV_PIX_FMT_YUVA444P10BE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P10BE)
AV_PIX_FMT_YUVA444P10LE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P10LE)
AV_PIX_FMT_YUVA420P16BE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P16BE)
AV_PIX_FMT_YUVA420P16LE = AVPixelFormat(C.AV_PIX_FMT_YUVA420P16LE)
AV_PIX_FMT_YUVA422P16BE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P16BE)
AV_PIX_FMT_YUVA422P16LE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P16LE)
AV_PIX_FMT_YUVA444P16BE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P16BE)
AV_PIX_FMT_YUVA444P16LE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P16LE)
AV_PIX_FMT_VDPAU = AvPixelFormat(C.AV_PIX_FMT_VDPAU)
AV_PIX_FMT_VDPAU = AVPixelFormat(C.AV_PIX_FMT_VDPAU)
AV_PIX_FMT_XYZ12LE = AvPixelFormat(C.AV_PIX_FMT_XYZ12LE)
AV_PIX_FMT_XYZ12BE = AvPixelFormat(C.AV_PIX_FMT_XYZ12BE)
AV_PIX_FMT_NV16 = AvPixelFormat(C.AV_PIX_FMT_NV16)
AV_PIX_FMT_NV20LE = AvPixelFormat(C.AV_PIX_FMT_NV20LE)
AV_PIX_FMT_NV20BE = AvPixelFormat(C.AV_PIX_FMT_NV20BE)
AV_PIX_FMT_RGBA64BE = AvPixelFormat(C.AV_PIX_FMT_RGBA64BE)
AV_PIX_FMT_RGBA64LE = AvPixelFormat(C.AV_PIX_FMT_RGBA64LE)
AV_PIX_FMT_BGRA64BE = AvPixelFormat(C.AV_PIX_FMT_BGRA64BE)
AV_PIX_FMT_BGRA64LE = AvPixelFormat(C.AV_PIX_FMT_BGRA64LE)
AV_PIX_FMT_XYZ12LE = AVPixelFormat(C.AV_PIX_FMT_XYZ12LE)
AV_PIX_FMT_XYZ12BE = AVPixelFormat(C.AV_PIX_FMT_XYZ12BE)
AV_PIX_FMT_NV16 = AVPixelFormat(C.AV_PIX_FMT_NV16)
AV_PIX_FMT_NV20LE = AVPixelFormat(C.AV_PIX_FMT_NV20LE)
AV_PIX_FMT_NV20BE = AVPixelFormat(C.AV_PIX_FMT_NV20BE)
AV_PIX_FMT_RGBA64BE = AVPixelFormat(C.AV_PIX_FMT_RGBA64BE)
AV_PIX_FMT_RGBA64LE = AVPixelFormat(C.AV_PIX_FMT_RGBA64LE)
AV_PIX_FMT_BGRA64BE = AVPixelFormat(C.AV_PIX_FMT_BGRA64BE)
AV_PIX_FMT_BGRA64LE = AVPixelFormat(C.AV_PIX_FMT_BGRA64LE)
AV_PIX_FMT_YVYU422 = AvPixelFormat(C.AV_PIX_FMT_YVYU422)
AV_PIX_FMT_YVYU422 = AVPixelFormat(C.AV_PIX_FMT_YVYU422)
AV_PIX_FMT_YA16BE = AvPixelFormat(C.AV_PIX_FMT_YA16BE)
AV_PIX_FMT_YA16LE = AvPixelFormat(C.AV_PIX_FMT_YA16LE)
AV_PIX_FMT_YA16BE = AVPixelFormat(C.AV_PIX_FMT_YA16BE)
AV_PIX_FMT_YA16LE = AVPixelFormat(C.AV_PIX_FMT_YA16LE)
AV_PIX_FMT_GBRAP = AvPixelFormat(C.AV_PIX_FMT_GBRAP)
AV_PIX_FMT_GBRAP16BE = AvPixelFormat(C.AV_PIX_FMT_GBRAP16BE)
AV_PIX_FMT_GBRAP16LE = AvPixelFormat(C.AV_PIX_FMT_GBRAP16LE)
AV_PIX_FMT_GBRAP = AVPixelFormat(C.AV_PIX_FMT_GBRAP)
AV_PIX_FMT_GBRAP16BE = AVPixelFormat(C.AV_PIX_FMT_GBRAP16BE)
AV_PIX_FMT_GBRAP16LE = AVPixelFormat(C.AV_PIX_FMT_GBRAP16LE)
AV_PIX_FMT_QSV = AvPixelFormat(C.AV_PIX_FMT_QSV)
AV_PIX_FMT_QSV = AVPixelFormat(C.AV_PIX_FMT_QSV)
AV_PIX_FMT_MMAL = AvPixelFormat(C.AV_PIX_FMT_MMAL)
AV_PIX_FMT_MMAL = AVPixelFormat(C.AV_PIX_FMT_MMAL)
AV_PIX_FMT_D3D11VA_VLD = AvPixelFormat(C.AV_PIX_FMT_D3D11VA_VLD)
AV_PIX_FMT_D3D11VA_VLD = AVPixelFormat(C.AV_PIX_FMT_D3D11VA_VLD)
AV_PIX_FMT_CUDA = AvPixelFormat(C.AV_PIX_FMT_CUDA)
AV_PIX_FMT_CUDA = AVPixelFormat(C.AV_PIX_FMT_CUDA)
AV_PIX_FMT_0RGB = AvPixelFormat(C.AV_PIX_FMT_0RGB)
AV_PIX_FMT_RGB0 = AvPixelFormat(C.AV_PIX_FMT_RGB0)
AV_PIX_FMT_0BGR = AvPixelFormat(C.AV_PIX_FMT_0BGR)
AV_PIX_FMT_BGR0 = AvPixelFormat(C.AV_PIX_FMT_BGR0)
AV_PIX_FMT_0RGB = AVPixelFormat(C.AV_PIX_FMT_0RGB)
AV_PIX_FMT_RGB0 = AVPixelFormat(C.AV_PIX_FMT_RGB0)
AV_PIX_FMT_0BGR = AVPixelFormat(C.AV_PIX_FMT_0BGR)
AV_PIX_FMT_BGR0 = AVPixelFormat(C.AV_PIX_FMT_BGR0)
AV_PIX_FMT_YUV420P12BE = AvPixelFormat(C.AV_PIX_FMT_YUV420P12BE)
AV_PIX_FMT_YUV420P12LE = AvPixelFormat(C.AV_PIX_FMT_YUV420P12LE)
AV_PIX_FMT_YUV420P14BE = AvPixelFormat(C.AV_PIX_FMT_YUV420P14BE)
AV_PIX_FMT_YUV420P14LE = AvPixelFormat(C.AV_PIX_FMT_YUV420P14LE)
AV_PIX_FMT_YUV422P12BE = AvPixelFormat(C.AV_PIX_FMT_YUV422P12BE)
AV_PIX_FMT_YUV422P12LE = AvPixelFormat(C.AV_PIX_FMT_YUV422P12LE)
AV_PIX_FMT_YUV422P14BE = AvPixelFormat(C.AV_PIX_FMT_YUV422P14BE)
AV_PIX_FMT_YUV422P14LE = AvPixelFormat(C.AV_PIX_FMT_YUV422P14LE)
AV_PIX_FMT_YUV444P12BE = AvPixelFormat(C.AV_PIX_FMT_YUV444P12BE)
AV_PIX_FMT_YUV444P12LE = AvPixelFormat(C.AV_PIX_FMT_YUV444P12LE)
AV_PIX_FMT_YUV444P14BE = AvPixelFormat(C.AV_PIX_FMT_YUV444P14BE)
AV_PIX_FMT_YUV444P14LE = AvPixelFormat(C.AV_PIX_FMT_YUV444P14LE)
AV_PIX_FMT_GBRP12BE = AvPixelFormat(C.AV_PIX_FMT_GBRP12BE)
AV_PIX_FMT_GBRP12LE = AvPixelFormat(C.AV_PIX_FMT_GBRP12LE)
AV_PIX_FMT_GBRP14BE = AvPixelFormat(C.AV_PIX_FMT_GBRP14BE)
AV_PIX_FMT_GBRP14LE = AvPixelFormat(C.AV_PIX_FMT_GBRP14LE)
AV_PIX_FMT_YUVJ411P = AvPixelFormat(C.AV_PIX_FMT_YUVJ411P)
AV_PIX_FMT_YUV420P12BE = AVPixelFormat(C.AV_PIX_FMT_YUV420P12BE)
AV_PIX_FMT_YUV420P12LE = AVPixelFormat(C.AV_PIX_FMT_YUV420P12LE)
AV_PIX_FMT_YUV420P14BE = AVPixelFormat(C.AV_PIX_FMT_YUV420P14BE)
AV_PIX_FMT_YUV420P14LE = AVPixelFormat(C.AV_PIX_FMT_YUV420P14LE)
AV_PIX_FMT_YUV422P12BE = AVPixelFormat(C.AV_PIX_FMT_YUV422P12BE)
AV_PIX_FMT_YUV422P12LE = AVPixelFormat(C.AV_PIX_FMT_YUV422P12LE)
AV_PIX_FMT_YUV422P14BE = AVPixelFormat(C.AV_PIX_FMT_YUV422P14BE)
AV_PIX_FMT_YUV422P14LE = AVPixelFormat(C.AV_PIX_FMT_YUV422P14LE)
AV_PIX_FMT_YUV444P12BE = AVPixelFormat(C.AV_PIX_FMT_YUV444P12BE)
AV_PIX_FMT_YUV444P12LE = AVPixelFormat(C.AV_PIX_FMT_YUV444P12LE)
AV_PIX_FMT_YUV444P14BE = AVPixelFormat(C.AV_PIX_FMT_YUV444P14BE)
AV_PIX_FMT_YUV444P14LE = AVPixelFormat(C.AV_PIX_FMT_YUV444P14LE)
AV_PIX_FMT_GBRP12BE = AVPixelFormat(C.AV_PIX_FMT_GBRP12BE)
AV_PIX_FMT_GBRP12LE = AVPixelFormat(C.AV_PIX_FMT_GBRP12LE)
AV_PIX_FMT_GBRP14BE = AVPixelFormat(C.AV_PIX_FMT_GBRP14BE)
AV_PIX_FMT_GBRP14LE = AVPixelFormat(C.AV_PIX_FMT_GBRP14LE)
AV_PIX_FMT_YUVJ411P = AVPixelFormat(C.AV_PIX_FMT_YUVJ411P)
AV_PIX_FMT_BAYER_BGGR8 = AvPixelFormat(C.AV_PIX_FMT_BAYER_BGGR8)
AV_PIX_FMT_BAYER_RGGB8 = AvPixelFormat(C.AV_PIX_FMT_BAYER_RGGB8)
AV_PIX_FMT_BAYER_GBRG8 = AvPixelFormat(C.AV_PIX_FMT_BAYER_GBRG8)
AV_PIX_FMT_BAYER_GRBG8 = AvPixelFormat(C.AV_PIX_FMT_BAYER_GRBG8)
AV_PIX_FMT_BAYER_BGGR16LE = AvPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16LE)
AV_PIX_FMT_BAYER_BGGR16BE = AvPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16BE)
AV_PIX_FMT_BAYER_RGGB16LE = AvPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16LE)
AV_PIX_FMT_BAYER_RGGB16BE = AvPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16BE)
AV_PIX_FMT_BAYER_GBRG16LE = AvPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16LE)
AV_PIX_FMT_BAYER_GBRG16BE = AvPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16BE)
AV_PIX_FMT_BAYER_GRBG16LE = AvPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16LE)
AV_PIX_FMT_BAYER_GRBG16BE = AvPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16BE)
AV_PIX_FMT_BAYER_BGGR8 = AVPixelFormat(C.AV_PIX_FMT_BAYER_BGGR8)
AV_PIX_FMT_BAYER_RGGB8 = AVPixelFormat(C.AV_PIX_FMT_BAYER_RGGB8)
AV_PIX_FMT_BAYER_GBRG8 = AVPixelFormat(C.AV_PIX_FMT_BAYER_GBRG8)
AV_PIX_FMT_BAYER_GRBG8 = AVPixelFormat(C.AV_PIX_FMT_BAYER_GRBG8)
AV_PIX_FMT_BAYER_BGGR16LE = AVPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16LE)
AV_PIX_FMT_BAYER_BGGR16BE = AVPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16BE)
AV_PIX_FMT_BAYER_RGGB16LE = AVPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16LE)
AV_PIX_FMT_BAYER_RGGB16BE = AVPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16BE)
AV_PIX_FMT_BAYER_GBRG16LE = AVPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16LE)
AV_PIX_FMT_BAYER_GBRG16BE = AVPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16BE)
AV_PIX_FMT_BAYER_GRBG16LE = AVPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16LE)
AV_PIX_FMT_BAYER_GRBG16BE = AVPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16BE)
AV_PIX_FMT_XVMC = AvPixelFormat(C.AV_PIX_FMT_XVMC)
AV_PIX_FMT_XVMC = AVPixelFormat(C.AV_PIX_FMT_XVMC)
AV_PIX_FMT_YUV440P10LE = AvPixelFormat(C.AV_PIX_FMT_YUV440P10LE)
AV_PIX_FMT_YUV440P10BE = AvPixelFormat(C.AV_PIX_FMT_YUV440P10BE)
AV_PIX_FMT_YUV440P12LE = AvPixelFormat(C.AV_PIX_FMT_YUV440P12LE)
AV_PIX_FMT_YUV440P12BE = AvPixelFormat(C.AV_PIX_FMT_YUV440P12BE)
AV_PIX_FMT_AYUV64LE = AvPixelFormat(C.AV_PIX_FMT_AYUV64LE)
AV_PIX_FMT_AYUV64BE = AvPixelFormat(C.AV_PIX_FMT_AYUV64BE)
AV_PIX_FMT_YUV440P10LE = AVPixelFormat(C.AV_PIX_FMT_YUV440P10LE)
AV_PIX_FMT_YUV440P10BE = AVPixelFormat(C.AV_PIX_FMT_YUV440P10BE)
AV_PIX_FMT_YUV440P12LE = AVPixelFormat(C.AV_PIX_FMT_YUV440P12LE)
AV_PIX_FMT_YUV440P12BE = AVPixelFormat(C.AV_PIX_FMT_YUV440P12BE)
AV_PIX_FMT_AYUV64LE = AVPixelFormat(C.AV_PIX_FMT_AYUV64LE)
AV_PIX_FMT_AYUV64BE = AVPixelFormat(C.AV_PIX_FMT_AYUV64BE)
AV_PIX_FMT_VIDEOTOOLBOX = AvPixelFormat(C.AV_PIX_FMT_VIDEOTOOLBOX)
AV_PIX_FMT_VIDEOTOOLBOX = AVPixelFormat(C.AV_PIX_FMT_VIDEOTOOLBOX)
AV_PIX_FMT_P010LE = AvPixelFormat(C.AV_PIX_FMT_P010LE)
AV_PIX_FMT_P010BE = AvPixelFormat(C.AV_PIX_FMT_P010BE)
AV_PIX_FMT_P010LE = AVPixelFormat(C.AV_PIX_FMT_P010LE)
AV_PIX_FMT_P010BE = AVPixelFormat(C.AV_PIX_FMT_P010BE)
AV_PIX_FMT_GBRAP12BE = AvPixelFormat(C.AV_PIX_FMT_GBRAP12BE)
AV_PIX_FMT_GBRAP12LE = AvPixelFormat(C.AV_PIX_FMT_GBRAP12LE)
AV_PIX_FMT_GBRAP12BE = AVPixelFormat(C.AV_PIX_FMT_GBRAP12BE)
AV_PIX_FMT_GBRAP12LE = AVPixelFormat(C.AV_PIX_FMT_GBRAP12LE)
AV_PIX_FMT_GBRAP10BE = AvPixelFormat(C.AV_PIX_FMT_GBRAP10BE)
AV_PIX_FMT_GBRAP10LE = AvPixelFormat(C.AV_PIX_FMT_GBRAP10LE)
AV_PIX_FMT_GBRAP10BE = AVPixelFormat(C.AV_PIX_FMT_GBRAP10BE)
AV_PIX_FMT_GBRAP10LE = AVPixelFormat(C.AV_PIX_FMT_GBRAP10LE)
AV_PIX_FMT_MEDIACODEC = AvPixelFormat(C.AV_PIX_FMT_MEDIACODEC)
AV_PIX_FMT_MEDIACODEC = AVPixelFormat(C.AV_PIX_FMT_MEDIACODEC)
AV_PIX_FMT_GRAY12BE = AvPixelFormat(C.AV_PIX_FMT_GRAY12BE)
AV_PIX_FMT_GRAY12LE = AvPixelFormat(C.AV_PIX_FMT_GRAY12LE)
AV_PIX_FMT_GRAY10BE = AvPixelFormat(C.AV_PIX_FMT_GRAY10BE)
AV_PIX_FMT_GRAY10LE = AvPixelFormat(C.AV_PIX_FMT_GRAY10LE)
AV_PIX_FMT_GRAY12BE = AVPixelFormat(C.AV_PIX_FMT_GRAY12BE)
AV_PIX_FMT_GRAY12LE = AVPixelFormat(C.AV_PIX_FMT_GRAY12LE)
AV_PIX_FMT_GRAY10BE = AVPixelFormat(C.AV_PIX_FMT_GRAY10BE)
AV_PIX_FMT_GRAY10LE = AVPixelFormat(C.AV_PIX_FMT_GRAY10LE)
AV_PIX_FMT_P016LE = AvPixelFormat(C.AV_PIX_FMT_P016LE)
AV_PIX_FMT_P016BE = AvPixelFormat(C.AV_PIX_FMT_P016BE)
AV_PIX_FMT_P016LE = AVPixelFormat(C.AV_PIX_FMT_P016LE)
AV_PIX_FMT_P016BE = AVPixelFormat(C.AV_PIX_FMT_P016BE)
AV_PIX_FMT_D3D11 = AvPixelFormat(C.AV_PIX_FMT_D3D11)
AV_PIX_FMT_D3D11 = AVPixelFormat(C.AV_PIX_FMT_D3D11)
AV_PIX_FMT_GRAY9BE = AvPixelFormat(C.AV_PIX_FMT_GRAY9BE)
AV_PIX_FMT_GRAY9LE = AvPixelFormat(C.AV_PIX_FMT_GRAY9LE)
AV_PIX_FMT_GRAY9BE = AVPixelFormat(C.AV_PIX_FMT_GRAY9BE)
AV_PIX_FMT_GRAY9LE = AVPixelFormat(C.AV_PIX_FMT_GRAY9LE)
AV_PIX_FMT_GBRPF32BE = AvPixelFormat(C.AV_PIX_FMT_GBRPF32BE)
AV_PIX_FMT_GBRPF32LE = AvPixelFormat(C.AV_PIX_FMT_GBRPF32LE)
AV_PIX_FMT_GBRAPF32BE = AvPixelFormat(C.AV_PIX_FMT_GBRAPF32BE)
AV_PIX_FMT_GBRAPF32LE = AvPixelFormat(C.AV_PIX_FMT_GBRAPF32LE)
AV_PIX_FMT_GBRPF32BE = AVPixelFormat(C.AV_PIX_FMT_GBRPF32BE)
AV_PIX_FMT_GBRPF32LE = AVPixelFormat(C.AV_PIX_FMT_GBRPF32LE)
AV_PIX_FMT_GBRAPF32BE = AVPixelFormat(C.AV_PIX_FMT_GBRAPF32BE)
AV_PIX_FMT_GBRAPF32LE = AVPixelFormat(C.AV_PIX_FMT_GBRAPF32LE)
AV_PIX_FMT_DRM_PRIME = AvPixelFormat(C.AV_PIX_FMT_DRM_PRIME)
AV_PIX_FMT_DRM_PRIME = AVPixelFormat(C.AV_PIX_FMT_DRM_PRIME)
AV_PIX_FMT_OPENCL = AvPixelFormat(C.AV_PIX_FMT_OPENCL)
AV_PIX_FMT_OPENCL = AVPixelFormat(C.AV_PIX_FMT_OPENCL)
AV_PIX_FMT_GRAY14BE = AvPixelFormat(C.AV_PIX_FMT_GRAY14BE)
AV_PIX_FMT_GRAY14LE = AvPixelFormat(C.AV_PIX_FMT_GRAY14LE)
AV_PIX_FMT_GRAY14BE = AVPixelFormat(C.AV_PIX_FMT_GRAY14BE)
AV_PIX_FMT_GRAY14LE = AVPixelFormat(C.AV_PIX_FMT_GRAY14LE)
AV_PIX_FMT_GRAYF32BE = AvPixelFormat(C.AV_PIX_FMT_GRAYF32BE)
AV_PIX_FMT_GRAYF32LE = AvPixelFormat(C.AV_PIX_FMT_GRAYF32LE)
AV_PIX_FMT_GRAYF32BE = AVPixelFormat(C.AV_PIX_FMT_GRAYF32BE)
AV_PIX_FMT_GRAYF32LE = AVPixelFormat(C.AV_PIX_FMT_GRAYF32LE)
AV_PIX_FMT_YUVA422P12BE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P12BE)
AV_PIX_FMT_YUVA422P12LE = AvPixelFormat(C.AV_PIX_FMT_YUVA422P12LE)
AV_PIX_FMT_YUVA444P12BE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P12BE)
AV_PIX_FMT_YUVA444P12LE = AvPixelFormat(C.AV_PIX_FMT_YUVA444P12LE)
AV_PIX_FMT_YUVA422P12BE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P12BE)
AV_PIX_FMT_YUVA422P12LE = AVPixelFormat(C.AV_PIX_FMT_YUVA422P12LE)
AV_PIX_FMT_YUVA444P12BE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P12BE)
AV_PIX_FMT_YUVA444P12LE = AVPixelFormat(C.AV_PIX_FMT_YUVA444P12LE)
AV_PIX_FMT_NV24 = AvPixelFormat(C.AV_PIX_FMT_NV24)
AV_PIX_FMT_NV42 = AvPixelFormat(C.AV_PIX_FMT_NV42)
AV_PIX_FMT_NV24 = AVPixelFormat(C.AV_PIX_FMT_NV24)
AV_PIX_FMT_NV42 = AVPixelFormat(C.AV_PIX_FMT_NV42)
AV_PIX_FMT_VULKAN = AvPixelFormat(C.AV_PIX_FMT_VULKAN)
AV_PIX_FMT_VULKAN = AVPixelFormat(C.AV_PIX_FMT_VULKAN)
AV_PIX_FMT_Y210BE = AvPixelFormat(C.AV_PIX_FMT_Y210BE)
AV_PIX_FMT_Y210LE = AvPixelFormat(C.AV_PIX_FMT_Y210LE)
AV_PIX_FMT_Y210BE = AVPixelFormat(C.AV_PIX_FMT_Y210BE)
AV_PIX_FMT_Y210LE = AVPixelFormat(C.AV_PIX_FMT_Y210LE)
AV_PIX_FMT_X2RGB10LE = AvPixelFormat(C.AV_PIX_FMT_X2RGB10LE)
AV_PIX_FMT_X2RGB10BE = AvPixelFormat(C.AV_PIX_FMT_X2RGB10BE)
AV_PIX_FMT_NB = AvPixelFormat(C.AV_PIX_FMT_NB)
AV_PIX_FMT_X2RGB10LE = AVPixelFormat(C.AV_PIX_FMT_X2RGB10LE)
AV_PIX_FMT_X2RGB10BE = AVPixelFormat(C.AV_PIX_FMT_X2RGB10BE)
AV_PIX_FMT_NB = AVPixelFormat(C.AV_PIX_FMT_NB)
)
const (
AV_PIX_FMT_RGB32 = AvPixelFormat(C.AV_PIX_FMT_RGB32)
AV_PIX_FMT_RGB32_1 = AvPixelFormat(C.AV_PIX_FMT_RGB32_1)
AV_PIX_FMT_BGR32 = AvPixelFormat(C.AV_PIX_FMT_BGR32)
AV_PIX_FMT_BGR32_1 = AvPixelFormat(C.AV_PIX_FMT_BGR32_1)
AV_PIX_FMT_0RGB32 = AvPixelFormat(C.AV_PIX_FMT_0RGB32)
AV_PIX_FMT_0BGR32 = AvPixelFormat(C.AV_PIX_FMT_0BGR32)
AV_PIX_FMT_RGB32 = AVPixelFormat(C.AV_PIX_FMT_RGB32)
AV_PIX_FMT_RGB32_1 = AVPixelFormat(C.AV_PIX_FMT_RGB32_1)
AV_PIX_FMT_BGR32 = AVPixelFormat(C.AV_PIX_FMT_BGR32)
AV_PIX_FMT_BGR32_1 = AVPixelFormat(C.AV_PIX_FMT_BGR32_1)
AV_PIX_FMT_0RGB32 = AVPixelFormat(C.AV_PIX_FMT_0RGB32)
AV_PIX_FMT_0BGR32 = AVPixelFormat(C.AV_PIX_FMT_0BGR32)
AV_PIX_FMT_GRAY9 = AvPixelFormat(C.AV_PIX_FMT_GRAY9)
AV_PIX_FMT_GRAY10 = AvPixelFormat(C.AV_PIX_FMT_GRAY10)
AV_PIX_FMT_GRAY12 = AvPixelFormat(C.AV_PIX_FMT_GRAY12)
AV_PIX_FMT_GRAY14 = AvPixelFormat(C.AV_PIX_FMT_GRAY14)
AV_PIX_FMT_GRAY16 = AvPixelFormat(C.AV_PIX_FMT_GRAY16)
AV_PIX_FMT_YA16 = AvPixelFormat(C.AV_PIX_FMT_YA16)
AV_PIX_FMT_RGB48 = AvPixelFormat(C.AV_PIX_FMT_RGB48)
AV_PIX_FMT_RGB565 = AvPixelFormat(C.AV_PIX_FMT_RGB565)
AV_PIX_FMT_RGB555 = AvPixelFormat(C.AV_PIX_FMT_RGB555)
AV_PIX_FMT_RGB444 = AvPixelFormat(C.AV_PIX_FMT_RGB444)
AV_PIX_FMT_RGBA64 = AvPixelFormat(C.AV_PIX_FMT_RGBA64)
AV_PIX_FMT_BGR48 = AvPixelFormat(C.AV_PIX_FMT_BGR48)
AV_PIX_FMT_BGR565 = AvPixelFormat(C.AV_PIX_FMT_BGR565)
AV_PIX_FMT_BGR555 = AvPixelFormat(C.AV_PIX_FMT_BGR555)
AV_PIX_FMT_BGR444 = AvPixelFormat(C.AV_PIX_FMT_BGR444)
AV_PIX_FMT_BGRA64 = AvPixelFormat(C.AV_PIX_FMT_BGRA64)
AV_PIX_FMT_GRAY9 = AVPixelFormat(C.AV_PIX_FMT_GRAY9)
AV_PIX_FMT_GRAY10 = AVPixelFormat(C.AV_PIX_FMT_GRAY10)
AV_PIX_FMT_GRAY12 = AVPixelFormat(C.AV_PIX_FMT_GRAY12)
AV_PIX_FMT_GRAY14 = AVPixelFormat(C.AV_PIX_FMT_GRAY14)
AV_PIX_FMT_GRAY16 = AVPixelFormat(C.AV_PIX_FMT_GRAY16)
AV_PIX_FMT_YA16 = AVPixelFormat(C.AV_PIX_FMT_YA16)
AV_PIX_FMT_RGB48 = AVPixelFormat(C.AV_PIX_FMT_RGB48)
AV_PIX_FMT_RGB565 = AVPixelFormat(C.AV_PIX_FMT_RGB565)
AV_PIX_FMT_RGB555 = AVPixelFormat(C.AV_PIX_FMT_RGB555)
AV_PIX_FMT_RGB444 = AVPixelFormat(C.AV_PIX_FMT_RGB444)
AV_PIX_FMT_RGBA64 = AVPixelFormat(C.AV_PIX_FMT_RGBA64)
AV_PIX_FMT_BGR48 = AVPixelFormat(C.AV_PIX_FMT_BGR48)
AV_PIX_FMT_BGR565 = AVPixelFormat(C.AV_PIX_FMT_BGR565)
AV_PIX_FMT_BGR555 = AVPixelFormat(C.AV_PIX_FMT_BGR555)
AV_PIX_FMT_BGR444 = AVPixelFormat(C.AV_PIX_FMT_BGR444)
AV_PIX_FMT_BGRA64 = AVPixelFormat(C.AV_PIX_FMT_BGRA64)
AV_PIX_FMT_YUV420P9 = AvPixelFormat(C.AV_PIX_FMT_YUV420P9)
AV_PIX_FMT_YUV422P9 = AvPixelFormat(C.AV_PIX_FMT_YUV422P9)
AV_PIX_FMT_YUV444P9 = AvPixelFormat(C.AV_PIX_FMT_YUV444P9)
AV_PIX_FMT_YUV420P10 = AvPixelFormat(C.AV_PIX_FMT_YUV420P10)
AV_PIX_FMT_YUV422P10 = AvPixelFormat(C.AV_PIX_FMT_YUV422P10)
AV_PIX_FMT_YUV440P10 = AvPixelFormat(C.AV_PIX_FMT_YUV440P10)
AV_PIX_FMT_YUV444P10 = AvPixelFormat(C.AV_PIX_FMT_YUV444P10)
AV_PIX_FMT_YUV420P12 = AvPixelFormat(C.AV_PIX_FMT_YUV420P12)
AV_PIX_FMT_YUV422P12 = AvPixelFormat(C.AV_PIX_FMT_YUV422P12)
AV_PIX_FMT_YUV440P12 = AvPixelFormat(C.AV_PIX_FMT_YUV440P12)
AV_PIX_FMT_YUV444P12 = AvPixelFormat(C.AV_PIX_FMT_YUV444P12)
AV_PIX_FMT_YUV420P14 = AvPixelFormat(C.AV_PIX_FMT_YUV420P14)
AV_PIX_FMT_YUV422P14 = AvPixelFormat(C.AV_PIX_FMT_YUV422P14)
AV_PIX_FMT_YUV444P14 = AvPixelFormat(C.AV_PIX_FMT_YUV444P14)
AV_PIX_FMT_YUV420P16 = AvPixelFormat(C.AV_PIX_FMT_YUV420P16)
AV_PIX_FMT_YUV422P16 = AvPixelFormat(C.AV_PIX_FMT_YUV422P16)
AV_PIX_FMT_YUV444P16 = AvPixelFormat(C.AV_PIX_FMT_YUV444P16)
AV_PIX_FMT_YUV420P9 = AVPixelFormat(C.AV_PIX_FMT_YUV420P9)
AV_PIX_FMT_YUV422P9 = AVPixelFormat(C.AV_PIX_FMT_YUV422P9)
AV_PIX_FMT_YUV444P9 = AVPixelFormat(C.AV_PIX_FMT_YUV444P9)
AV_PIX_FMT_YUV420P10 = AVPixelFormat(C.AV_PIX_FMT_YUV420P10)
AV_PIX_FMT_YUV422P10 = AVPixelFormat(C.AV_PIX_FMT_YUV422P10)
AV_PIX_FMT_YUV440P10 = AVPixelFormat(C.AV_PIX_FMT_YUV440P10)
AV_PIX_FMT_YUV444P10 = AVPixelFormat(C.AV_PIX_FMT_YUV444P10)
AV_PIX_FMT_YUV420P12 = AVPixelFormat(C.AV_PIX_FMT_YUV420P12)
AV_PIX_FMT_YUV422P12 = AVPixelFormat(C.AV_PIX_FMT_YUV422P12)
AV_PIX_FMT_YUV440P12 = AVPixelFormat(C.AV_PIX_FMT_YUV440P12)
AV_PIX_FMT_YUV444P12 = AVPixelFormat(C.AV_PIX_FMT_YUV444P12)
AV_PIX_FMT_YUV420P14 = AVPixelFormat(C.AV_PIX_FMT_YUV420P14)
AV_PIX_FMT_YUV422P14 = AVPixelFormat(C.AV_PIX_FMT_YUV422P14)
AV_PIX_FMT_YUV444P14 = AVPixelFormat(C.AV_PIX_FMT_YUV444P14)
AV_PIX_FMT_YUV420P16 = AVPixelFormat(C.AV_PIX_FMT_YUV420P16)
AV_PIX_FMT_YUV422P16 = AVPixelFormat(C.AV_PIX_FMT_YUV422P16)
AV_PIX_FMT_YUV444P16 = AVPixelFormat(C.AV_PIX_FMT_YUV444P16)
AV_PIX_FMT_GBRP9 = AvPixelFormat(C.AV_PIX_FMT_GBRP9)
AV_PIX_FMT_GBRP10 = AvPixelFormat(C.AV_PIX_FMT_GBRP10)
AV_PIX_FMT_GBRP12 = AvPixelFormat(C.AV_PIX_FMT_GBRP12)
AV_PIX_FMT_GBRP14 = AvPixelFormat(C.AV_PIX_FMT_GBRP14)
AV_PIX_FMT_GBRP16 = AvPixelFormat(C.AV_PIX_FMT_GBRP16)
AV_PIX_FMT_GBRAP10 = AvPixelFormat(C.AV_PIX_FMT_GBRAP10)
AV_PIX_FMT_GBRAP12 = AvPixelFormat(C.AV_PIX_FMT_GBRAP12)
AV_PIX_FMT_GBRAP16 = AvPixelFormat(C.AV_PIX_FMT_GBRAP16)
AV_PIX_FMT_GBRP9 = AVPixelFormat(C.AV_PIX_FMT_GBRP9)
AV_PIX_FMT_GBRP10 = AVPixelFormat(C.AV_PIX_FMT_GBRP10)
AV_PIX_FMT_GBRP12 = AVPixelFormat(C.AV_PIX_FMT_GBRP12)
AV_PIX_FMT_GBRP14 = AVPixelFormat(C.AV_PIX_FMT_GBRP14)
AV_PIX_FMT_GBRP16 = AVPixelFormat(C.AV_PIX_FMT_GBRP16)
AV_PIX_FMT_GBRAP10 = AVPixelFormat(C.AV_PIX_FMT_GBRAP10)
AV_PIX_FMT_GBRAP12 = AVPixelFormat(C.AV_PIX_FMT_GBRAP12)
AV_PIX_FMT_GBRAP16 = AVPixelFormat(C.AV_PIX_FMT_GBRAP16)
AV_PIX_FMT_BAYER_BGGR16 = AvPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16)
AV_PIX_FMT_BAYER_RGGB16 = AvPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16)
AV_PIX_FMT_BAYER_GBRG16 = AvPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16)
AV_PIX_FMT_BAYER_GRBG16 = AvPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16)
AV_PIX_FMT_BAYER_BGGR16 = AVPixelFormat(C.AV_PIX_FMT_BAYER_BGGR16)
AV_PIX_FMT_BAYER_RGGB16 = AVPixelFormat(C.AV_PIX_FMT_BAYER_RGGB16)
AV_PIX_FMT_BAYER_GBRG16 = AVPixelFormat(C.AV_PIX_FMT_BAYER_GBRG16)
AV_PIX_FMT_BAYER_GRBG16 = AVPixelFormat(C.AV_PIX_FMT_BAYER_GRBG16)
AV_PIX_FMT_GBRPF32 = AvPixelFormat(C.AV_PIX_FMT_GBRPF32)
AV_PIX_FMT_GBRAPF32 = AvPixelFormat(C.AV_PIX_FMT_GBRAPF32)
AV_PIX_FMT_GBRPF32 = AVPixelFormat(C.AV_PIX_FMT_GBRPF32)
AV_PIX_FMT_GBRAPF32 = AVPixelFormat(C.AV_PIX_FMT_GBRAPF32)
AV_PIX_FMT_GRAYF32 = AvPixelFormat(C.AV_PIX_FMT_GRAYF32)
AV_PIX_FMT_GRAYF32 = AVPixelFormat(C.AV_PIX_FMT_GRAYF32)
AV_PIX_FMT_YUVA420P9 = AvPixelFormat(C.AV_PIX_FMT_YUVA420P9)
AV_PIX_FMT_YUVA422P9 = AvPixelFormat(C.AV_PIX_FMT_YUVA422P9)
AV_PIX_FMT_YUVA444P9 = AvPixelFormat(C.AV_PIX_FMT_YUVA444P9)
AV_PIX_FMT_YUVA420P10 = AvPixelFormat(C.AV_PIX_FMT_YUVA420P10)
AV_PIX_FMT_YUVA422P10 = AvPixelFormat(C.AV_PIX_FMT_YUVA422P10)
AV_PIX_FMT_YUVA444P10 = AvPixelFormat(C.AV_PIX_FMT_YUVA444P10)
AV_PIX_FMT_YUVA422P12 = AvPixelFormat(C.AV_PIX_FMT_YUVA422P12)
AV_PIX_FMT_YUVA444P12 = AvPixelFormat(C.AV_PIX_FMT_YUVA444P12)
AV_PIX_FMT_YUVA420P16 = AvPixelFormat(C.AV_PIX_FMT_YUVA420P16)
AV_PIX_FMT_YUVA422P16 = AvPixelFormat(C.AV_PIX_FMT_YUVA422P16)
AV_PIX_FMT_YUVA444P16 = AvPixelFormat(C.AV_PIX_FMT_YUVA444P16)
AV_PIX_FMT_YUVA420P9 = AVPixelFormat(C.AV_PIX_FMT_YUVA420P9)
AV_PIX_FMT_YUVA422P9 = AVPixelFormat(C.AV_PIX_FMT_YUVA422P9)
AV_PIX_FMT_YUVA444P9 = AVPixelFormat(C.AV_PIX_FMT_YUVA444P9)
AV_PIX_FMT_YUVA420P10 = AVPixelFormat(C.AV_PIX_FMT_YUVA420P10)
AV_PIX_FMT_YUVA422P10 = AVPixelFormat(C.AV_PIX_FMT_YUVA422P10)
AV_PIX_FMT_YUVA444P10 = AVPixelFormat(C.AV_PIX_FMT_YUVA444P10)
AV_PIX_FMT_YUVA422P12 = AVPixelFormat(C.AV_PIX_FMT_YUVA422P12)
AV_PIX_FMT_YUVA444P12 = AVPixelFormat(C.AV_PIX_FMT_YUVA444P12)
AV_PIX_FMT_YUVA420P16 = AVPixelFormat(C.AV_PIX_FMT_YUVA420P16)
AV_PIX_FMT_YUVA422P16 = AVPixelFormat(C.AV_PIX_FMT_YUVA422P16)
AV_PIX_FMT_YUVA444P16 = AVPixelFormat(C.AV_PIX_FMT_YUVA444P16)
AV_PIX_FMT_XYZ12 = AvPixelFormat(C.AV_PIX_FMT_XYZ12)
AV_PIX_FMT_NV20 = AvPixelFormat(C.AV_PIX_FMT_NV20)
AV_PIX_FMT_AYUV64 = AvPixelFormat(C.AV_PIX_FMT_AYUV64)
AV_PIX_FMT_P010 = AvPixelFormat(C.AV_PIX_FMT_P010)
AV_PIX_FMT_P016 = AvPixelFormat(C.AV_PIX_FMT_P016)
AV_PIX_FMT_XYZ12 = AVPixelFormat(C.AV_PIX_FMT_XYZ12)
AV_PIX_FMT_NV20 = AVPixelFormat(C.AV_PIX_FMT_NV20)
AV_PIX_FMT_AYUV64 = AVPixelFormat(C.AV_PIX_FMT_AYUV64)
AV_PIX_FMT_P010 = AVPixelFormat(C.AV_PIX_FMT_P010)
AV_PIX_FMT_P016 = AVPixelFormat(C.AV_PIX_FMT_P016)
AV_PIX_FMT_Y210 = AvPixelFormat(C.AV_PIX_FMT_Y210)
AV_PIX_FMT_X2RGB10 = AvPixelFormat(C.AV_PIX_FMT_X2RGB10)
AV_PIX_FMT_Y210 = AVPixelFormat(C.AV_PIX_FMT_Y210)
AV_PIX_FMT_X2RGB10 = AVPixelFormat(C.AV_PIX_FMT_X2RGB10)
)
// Chromaticity coordinates of the source primaries.
type AvColorPrimaries = C.enum_AVColorPrimaries
type AVColorPrimaries = C.enum_AVColorPrimaries
const (
AVCOL_PRI_RESERVED0 = AvColorPrimaries(C.AVCOL_PRI_RESERVED0)
AVCOL_PRI_BT709 = AvColorPrimaries(C.AVCOL_PRI_BT709)
AVCOL_PRI_UNSPECIFIED = AvColorPrimaries(C.AVCOL_PRI_UNSPECIFIED)
AVCOL_PRI_RESERVED = AvColorPrimaries(C.AVCOL_PRI_RESERVED)
AVCOL_PRI_BT470M = AvColorPrimaries(C.AVCOL_PRI_BT470M)
AVCOL_PRI_RESERVED0 = AVColorPrimaries(C.AVCOL_PRI_RESERVED0)
AVCOL_PRI_BT709 = AVColorPrimaries(C.AVCOL_PRI_BT709)
AVCOL_PRI_UNSPECIFIED = AVColorPrimaries(C.AVCOL_PRI_UNSPECIFIED)
AVCOL_PRI_RESERVED = AVColorPrimaries(C.AVCOL_PRI_RESERVED)
AVCOL_PRI_BT470M = AVColorPrimaries(C.AVCOL_PRI_BT470M)
AVCOL_PRI_BT470BG = AvColorPrimaries(C.AVCOL_PRI_BT470BG)
AVCOL_PRI_SMPTE170M = AvColorPrimaries(C.AVCOL_PRI_SMPTE170M)
AVCOL_PRI_SMPTE240M = AvColorPrimaries(C.AVCOL_PRI_SMPTE240M)
AVCOL_PRI_FILM = AvColorPrimaries(C.AVCOL_PRI_FILM)
AVCOL_PRI_BT2020 = AvColorPrimaries(C.AVCOL_PRI_BT2020)
AVCOL_PRI_SMPTE428 = AvColorPrimaries(C.AVCOL_PRI_SMPTE428)
AVCOL_PRI_SMPTEST428_1 = AvColorPrimaries(C.AVCOL_PRI_SMPTEST428_1)
AVCOL_PRI_SMPTE431 = AvColorPrimaries(C.AVCOL_PRI_SMPTE431)
AVCOL_PRI_SMPTE432 = AvColorPrimaries(C.AVCOL_PRI_SMPTE432)
AVCOL_PRI_EBU3213 = AvColorPrimaries(C.AVCOL_PRI_EBU3213)
AVCOL_PRI_JEDEC_P22 = AvColorPrimaries(C.AVCOL_PRI_JEDEC_P22)
AVCOL_PRI_NB = AvColorPrimaries(C.AVCOL_PRI_NB)
AVCOL_PRI_BT470BG = AVColorPrimaries(C.AVCOL_PRI_BT470BG)
AVCOL_PRI_SMPTE170M = AVColorPrimaries(C.AVCOL_PRI_SMPTE170M)
AVCOL_PRI_SMPTE240M = AVColorPrimaries(C.AVCOL_PRI_SMPTE240M)
AVCOL_PRI_FILM = AVColorPrimaries(C.AVCOL_PRI_FILM)
AVCOL_PRI_BT2020 = AVColorPrimaries(C.AVCOL_PRI_BT2020)
AVCOL_PRI_SMPTE428 = AVColorPrimaries(C.AVCOL_PRI_SMPTE428)
AVCOL_PRI_SMPTEST428_1 = AVColorPrimaries(C.AVCOL_PRI_SMPTEST428_1)
AVCOL_PRI_SMPTE431 = AVColorPrimaries(C.AVCOL_PRI_SMPTE431)
AVCOL_PRI_SMPTE432 = AVColorPrimaries(C.AVCOL_PRI_SMPTE432)
AVCOL_PRI_EBU3213 = AVColorPrimaries(C.AVCOL_PRI_EBU3213)
AVCOL_PRI_JEDEC_P22 = AVColorPrimaries(C.AVCOL_PRI_JEDEC_P22)
AVCOL_PRI_NB = AVColorPrimaries(C.AVCOL_PRI_NB)
)
// Color Transfer Characteristic.
type AvColorTransferCharacteristic = C.enum_AVColorTransferCharacteristic
type AVColorTransferCharacteristic = C.enum_AVColorTransferCharacteristic
const (
AVCOL_TRC_RESERVED0 = AvColorTransferCharacteristic(C.AVCOL_TRC_RESERVED0)
AVCOL_TRC_BT709 = AvColorTransferCharacteristic(C.AVCOL_TRC_BT709)
AVCOL_TRC_UNSPECIFIED = AvColorTransferCharacteristic(C.AVCOL_TRC_UNSPECIFIED)
AVCOL_TRC_RESERVED = AvColorTransferCharacteristic(C.AVCOL_TRC_RESERVED)
AVCOL_TRC_GAMMA22 = AvColorTransferCharacteristic(C.AVCOL_TRC_GAMMA22)
AVCOL_TRC_GAMMA28 = AvColorTransferCharacteristic(C.AVCOL_TRC_GAMMA28)
AVCOL_TRC_SMPTE170M = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTE170M)
AVCOL_TRC_SMPTE240M = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTE240M)
AVCOL_TRC_LINEAR = AvColorTransferCharacteristic(C.AVCOL_TRC_LINEAR)
AVCOL_TRC_LOG = AvColorTransferCharacteristic(C.AVCOL_TRC_LOG)
AVCOL_TRC_LOG_SQRT = AvColorTransferCharacteristic(C.AVCOL_TRC_LOG_SQRT)
AVCOL_TRC_IEC61966_2_4 = AvColorTransferCharacteristic(C.AVCOL_TRC_IEC61966_2_4)
AVCOL_TRC_BT1361_ECG = AvColorTransferCharacteristic(C.AVCOL_TRC_BT1361_ECG)
AVCOL_TRC_IEC61966_2_1 = AvColorTransferCharacteristic(C.AVCOL_TRC_IEC61966_2_1)
AVCOL_TRC_BT2020_10 = AvColorTransferCharacteristic(C.AVCOL_TRC_BT2020_10)
AVCOL_TRC_BT2020_12 = AvColorTransferCharacteristic(C.AVCOL_TRC_BT2020_12)
AVCOL_TRC_SMPTE2084 = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTE2084)
AVCOL_TRC_SMPTEST2084 = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTEST2084)
AVCOL_TRC_SMPTE428 = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTE428)
AVCOL_TRC_SMPTEST428_1 = AvColorTransferCharacteristic(C.AVCOL_TRC_SMPTEST428_1)
AVCOL_TRC_ARIB_STD_B67 = AvColorTransferCharacteristic(C.AVCOL_TRC_ARIB_STD_B67)
AVCOL_TRC_NB = AvColorTransferCharacteristic(C.AVCOL_TRC_NB)
AVCOL_TRC_RESERVED0 = AVColorTransferCharacteristic(C.AVCOL_TRC_RESERVED0)
AVCOL_TRC_BT709 = AVColorTransferCharacteristic(C.AVCOL_TRC_BT709)
AVCOL_TRC_UNSPECIFIED = AVColorTransferCharacteristic(C.AVCOL_TRC_UNSPECIFIED)
AVCOL_TRC_RESERVED = AVColorTransferCharacteristic(C.AVCOL_TRC_RESERVED)
AVCOL_TRC_GAMMA22 = AVColorTransferCharacteristic(C.AVCOL_TRC_GAMMA22)
AVCOL_TRC_GAMMA28 = AVColorTransferCharacteristic(C.AVCOL_TRC_GAMMA28)
AVCOL_TRC_SMPTE170M = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTE170M)
AVCOL_TRC_SMPTE240M = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTE240M)
AVCOL_TRC_LINEAR = AVColorTransferCharacteristic(C.AVCOL_TRC_LINEAR)
AVCOL_TRC_LOG = AVColorTransferCharacteristic(C.AVCOL_TRC_LOG)
AVCOL_TRC_LOG_SQRT = AVColorTransferCharacteristic(C.AVCOL_TRC_LOG_SQRT)
AVCOL_TRC_IEC61966_2_4 = AVColorTransferCharacteristic(C.AVCOL_TRC_IEC61966_2_4)
AVCOL_TRC_BT1361_ECG = AVColorTransferCharacteristic(C.AVCOL_TRC_BT1361_ECG)
AVCOL_TRC_IEC61966_2_1 = AVColorTransferCharacteristic(C.AVCOL_TRC_IEC61966_2_1)
AVCOL_TRC_BT2020_10 = AVColorTransferCharacteristic(C.AVCOL_TRC_BT2020_10)
AVCOL_TRC_BT2020_12 = AVColorTransferCharacteristic(C.AVCOL_TRC_BT2020_12)
AVCOL_TRC_SMPTE2084 = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTE2084)
AVCOL_TRC_SMPTEST2084 = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTEST2084)
AVCOL_TRC_SMPTE428 = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTE428)
AVCOL_TRC_SMPTEST428_1 = AVColorTransferCharacteristic(C.AVCOL_TRC_SMPTEST428_1)
AVCOL_TRC_ARIB_STD_B67 = AVColorTransferCharacteristic(C.AVCOL_TRC_ARIB_STD_B67)
AVCOL_TRC_NB = AVColorTransferCharacteristic(C.AVCOL_TRC_NB)
)
// AvColorSpace
type AvColorSpace = C.enum_AVColorSpace
// AVColorSpace
type AVColorSpace = C.enum_AVColorSpace
const (
AVCOL_SPC_RGB = AvColorSpace(C.AVCOL_SPC_RGB)
AVCOL_SPC_BT709 = AvColorSpace(C.AVCOL_SPC_BT709)
AVCOL_SPC_UNSPECIFIED = AvColorSpace(C.AVCOL_SPC_UNSPECIFIED)
AVCOL_SPC_RESERVED = AvColorSpace(C.AVCOL_SPC_RESERVED)
AVCOL_SPC_FCC = AvColorSpace(C.AVCOL_SPC_FCC)
AVCOL_SPC_BT470BG = AvColorSpace(C.AVCOL_SPC_BT470BG)
AVCOL_SPC_SMPTE170M = AvColorSpace(C.AVCOL_SPC_SMPTE170M)
AVCOL_SPC_SMPTE240M = AvColorSpace(C.AVCOL_SPC_SMPTE240M)
AVCOL_SPC_YCGCO = AvColorSpace(C.AVCOL_SPC_YCGCO)
AVCOL_SPC_YCOCG = AvColorSpace(C.AVCOL_SPC_YCOCG)
AVCOL_SPC_BT2020_NCL = AvColorSpace(C.AVCOL_SPC_BT2020_NCL)
AVCOL_SPC_BT2020_CL = AvColorSpace(C.AVCOL_SPC_BT2020_CL)
AVCOL_SPC_SMPTE2085 = AvColorSpace(C.AVCOL_SPC_SMPTE2085)
AVCOL_SPC_CHROMA_DERIVED_NCL = AvColorSpace(C.AVCOL_SPC_CHROMA_DERIVED_NCL)
AVCOL_SPC_CHROMA_DERIVED_CL = AvColorSpace(C.AVCOL_SPC_CHROMA_DERIVED_CL)
AVCOL_SPC_ICTCP = AvColorSpace(C.AVCOL_SPC_ICTCP)
AVCOL_SPC_NB = AvColorSpace(C.AVCOL_SPC_NB)
AVCOL_SPC_RGB = AVColorSpace(C.AVCOL_SPC_RGB)
AVCOL_SPC_BT709 = AVColorSpace(C.AVCOL_SPC_BT709)
AVCOL_SPC_UNSPECIFIED = AVColorSpace(C.AVCOL_SPC_UNSPECIFIED)
AVCOL_SPC_RESERVED = AVColorSpace(C.AVCOL_SPC_RESERVED)
AVCOL_SPC_FCC = AVColorSpace(C.AVCOL_SPC_FCC)
AVCOL_SPC_BT470BG = AVColorSpace(C.AVCOL_SPC_BT470BG)
AVCOL_SPC_SMPTE170M = AVColorSpace(C.AVCOL_SPC_SMPTE170M)
AVCOL_SPC_SMPTE240M = AVColorSpace(C.AVCOL_SPC_SMPTE240M)
AVCOL_SPC_YCGCO = AVColorSpace(C.AVCOL_SPC_YCGCO)
AVCOL_SPC_YCOCG = AVColorSpace(C.AVCOL_SPC_YCOCG)
AVCOL_SPC_BT2020_NCL = AVColorSpace(C.AVCOL_SPC_BT2020_NCL)
AVCOL_SPC_BT2020_CL = AVColorSpace(C.AVCOL_SPC_BT2020_CL)
AVCOL_SPC_SMPTE2085 = AVColorSpace(C.AVCOL_SPC_SMPTE2085)
AVCOL_SPC_CHROMA_DERIVED_NCL = AVColorSpace(C.AVCOL_SPC_CHROMA_DERIVED_NCL)
AVCOL_SPC_CHROMA_DERIVED_CL = AVColorSpace(C.AVCOL_SPC_CHROMA_DERIVED_CL)
AVCOL_SPC_ICTCP = AVColorSpace(C.AVCOL_SPC_ICTCP)
AVCOL_SPC_NB = AVColorSpace(C.AVCOL_SPC_NB)
)
// AvColorRange
type AvColorRange = C.enum_AVColorRange
// AVColorRange
type AVColorRange = C.enum_AVColorRange
const (
AVCOL_RANGE_UNSPECIFIED = AvColorRange(C.AVCOL_RANGE_UNSPECIFIED)
AVCOL_RANGE_MPEG = AvColorRange(C.AVCOL_RANGE_MPEG)
AVCOL_RANGE_JPEG = AvColorRange(C.AVCOL_RANGE_JPEG)
AVCOL_RANGE_NB = AvColorRange(C.AVCOL_RANGE_NB)
AVCOL_RANGE_UNSPECIFIED = AVColorRange(C.AVCOL_RANGE_UNSPECIFIED)
AVCOL_RANGE_MPEG = AVColorRange(C.AVCOL_RANGE_MPEG)
AVCOL_RANGE_JPEG = AVColorRange(C.AVCOL_RANGE_JPEG)
AVCOL_RANGE_NB = AVColorRange(C.AVCOL_RANGE_NB)
)
// AvChromaLocation
type AvChromaLocation = C.enum_AVChromaLocation
// AVChromaLocation
type AVChromaLocation = C.enum_AVChromaLocation
const (
AVCHROMA_LOC_UNSPECIFIED = AvChromaLocation(C.AVCHROMA_LOC_UNSPECIFIED)
AVCHROMA_LOC_LEFT = AvChromaLocation(C.AVCHROMA_LOC_LEFT)
AVCHROMA_LOC_CENTER = AvChromaLocation(C.AVCHROMA_LOC_CENTER)
AVCHROMA_LOC_TOPLEFT = AvChromaLocation(C.AVCHROMA_LOC_TOPLEFT)
AVCHROMA_LOC_TOP = AvChromaLocation(C.AVCHROMA_LOC_TOP)
AVCHROMA_LOC_BOTTOMLEFT = AvChromaLocation(C.AVCHROMA_LOC_BOTTOMLEFT)
AVCHROMA_LOC_BOTTOM = AvChromaLocation(C.AVCHROMA_LOC_BOTTOM)
AVCHROMA_LOC_NB = AvChromaLocation(C.AVCHROMA_LOC_NB)
AVCHROMA_LOC_UNSPECIFIED = AVChromaLocation(C.AVCHROMA_LOC_UNSPECIFIED)
AVCHROMA_LOC_LEFT = AVChromaLocation(C.AVCHROMA_LOC_LEFT)
AVCHROMA_LOC_CENTER = AVChromaLocation(C.AVCHROMA_LOC_CENTER)
AVCHROMA_LOC_TOPLEFT = AVChromaLocation(C.AVCHROMA_LOC_TOPLEFT)
AVCHROMA_LOC_TOP = AVChromaLocation(C.AVCHROMA_LOC_TOP)
AVCHROMA_LOC_BOTTOMLEFT = AVChromaLocation(C.AVCHROMA_LOC_BOTTOMLEFT)
AVCHROMA_LOC_BOTTOM = AVChromaLocation(C.AVCHROMA_LOC_BOTTOM)
AVCHROMA_LOC_NB = AVChromaLocation(C.AVCHROMA_LOC_NB)
)

50
avutil_rational.go
View File

@@ -5,22 +5,22 @@ package ffmpeg
*/
import "C"
// AvRational
type AvRational C.struct_AVRational
// AVRational
type AVRational C.struct_AVRational
// Custom: GetNum gets `AVRational.num` value.
func (q *AvRational) GetNum() int32 {
func (q *AVRational) GetNum() int32 {
return (int32)(q.num)
}
// Custom: GetDen gets `AVRational.den` value.
func (q *AvRational) GetDen() int32 {
func (q *AVRational) GetDen() int32 {
return (int32)(q.den)
}
// AvMakeQ creates an AVRational with numerator and denominator.
func AvMakeQ(num, den int32) AvRational {
return (AvRational)(C.av_make_q((C.int)(num), (C.int)(den)))
func AvMakeQ(num, den int32) AVRational {
return (AVRational)(C.av_make_q((C.int)(num), (C.int)(den)))
}
const (
@@ -33,12 +33,12 @@ const (
// 1 if `a > b`
// -1 if `a < b`
// `INT_MIN` if one of the values is of the form `0 / 0`
func AvCmpQ(a, b AvRational) int32 {
func AvCmpQ(a, b AVRational) int32 {
return (int32)(C.av_cmp_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
}
// AvQ2d converts an AVRational to a `float64`.
func AvQ2d(a AvRational) float64 {
func AvQ2d(a AVRational) float64 {
return (float64)(C.av_q2d((C.struct_AVRational)(a)))
}
@@ -49,34 +49,34 @@ func AvReduce(dstNum, dstDen *int32, num, den, max int64) int32 {
}
// AvMulQ multiplies two rationals.
func AvMulQ(a, b AvRational) AvRational {
return (AvRational)(C.av_mul_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
func AvMulQ(a, b AVRational) AVRational {
return (AVRational)(C.av_mul_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
}
// AvDivQ divides one rational by another.
func AvDivQ(a, b AvRational) AvRational {
return (AvRational)(C.av_div_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
func AvDivQ(a, b AVRational) AVRational {
return (AVRational)(C.av_div_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
}
// AvAddQ adds two rationals.
func AvAddQ(a, b AvRational) AvRational {
return (AvRational)(C.av_add_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
func AvAddQ(a, b AVRational) AVRational {
return (AVRational)(C.av_add_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
}
// AvSubQ subtracts one rational from another.
func AvSubQ(a, b AvRational) AvRational {
return (AvRational)(C.av_sub_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
func AvSubQ(a, b AVRational) AVRational {
return (AVRational)(C.av_sub_q((C.struct_AVRational)(a), (C.struct_AVRational)(b)))
}
// AvInvQ invert a rational.
// return 1 / q
func AvInvQ(q AvRational) AvRational {
return (AvRational)(C.av_inv_q((C.struct_AVRational)(q)))
func AvInvQ(q AVRational) AVRational {
return (AVRational)(C.av_inv_q((C.struct_AVRational)(q)))
}
// AvD2Q converts a double precision floating point number to a rational.
func AvD2Q(d float64, max int32) AvRational {
return (AvRational)(C.av_d2q((C.double)(d), (C.int)(max)))
func AvD2Q(d float64, max int32) AVRational {
return (AVRational)(C.av_d2q((C.double)(d), (C.int)(max)))
}
// AvNearerQ finds which of the two rationals is closer to another rational.
@@ -84,24 +84,24 @@ func AvD2Q(d float64, max int32) AvRational {
// 1 if `q1` is nearer to `q` than `q2`
// -1 if `q2` is nearer to `q` than `q1`
// 0 if they have the same distance
func AvNearerQ(q, q1, q2 AvRational) int32 {
func AvNearerQ(q, q1, q2 AVRational) int32 {
return (int32)(C.av_nearer_q((C.struct_AVRational)(q),
(C.struct_AVRational)(q1), (C.struct_AVRational)(q2)))
}
// AvFindNearestQIdx finds the value in a list of rationals nearest a given reference rational.
func AvFindNearestQIdx(q AvRational, qList *AvRational) int32 {
func AvFindNearestQIdx(q AVRational, qList *AVRational) int32 {
return (int32)(C.av_find_nearest_q_idx((C.struct_AVRational)(q), (*C.struct_AVRational)(qList)))
}
// AvQ2intfloat Convert an AVRational to a IEEE 32-bit `float` expressed in fixed-point format.
func AvQ2intfloat(q AvRational) uint32 {
func AvQ2intfloat(q AVRational) uint32 {
return (uint32)(C.av_q2intfloat((C.struct_AVRational)(q)))
}
// AvGcdQ returns the best rational so that a and b are multiple of it.
// If the resulting denominator is larger than max_den, return def.
func AvGcdQ(a, b AvRational, maxDen int32, def AvRational) AvRational {
return (AvRational)(C.av_gcd_q((C.struct_AVRational)(a), (C.struct_AVRational)(b),
func AvGcdQ(a, b AVRational, maxDen int32, def AVRational) AVRational {
return (AVRational)(C.av_gcd_q((C.struct_AVRational)(a), (C.struct_AVRational)(b),
(C.int)(maxDen), (C.struct_AVRational)(def)))
}

70
avutil_samplefmt.go
View File

@@ -6,78 +6,78 @@ package ffmpeg
import "C"
import "unsafe"
// AvSampleFormat
type AvSampleFormat = C.enum_AVSampleFormat
// AVSampleFormat
type AVSampleFormat = C.enum_AVSampleFormat
const (
AV_SAMPLE_FMT_NONE = AvSampleFormat(C.AV_SAMPLE_FMT_NONE)
AV_SAMPLE_FMT_U8 = AvSampleFormat(C.AV_SAMPLE_FMT_U8)
AV_SAMPLE_FMT_S16 = AvSampleFormat(C.AV_SAMPLE_FMT_S16)
AV_SAMPLE_FMT_S32 = AvSampleFormat(C.AV_SAMPLE_FMT_S32)
AV_SAMPLE_FMT_FLT = AvSampleFormat(C.AV_SAMPLE_FMT_FLT)
AV_SAMPLE_FMT_DBL = AvSampleFormat(C.AV_SAMPLE_FMT_DBL)
AV_SAMPLE_FMT_U8P = AvSampleFormat(C.AV_SAMPLE_FMT_U8P)
AV_SAMPLE_FMT_S16P = AvSampleFormat(C.AV_SAMPLE_FMT_S16P)
AV_SAMPLE_FMT_S32P = AvSampleFormat(C.AV_SAMPLE_FMT_S32P)
AV_SAMPLE_FMT_FLTP = AvSampleFormat(C.AV_SAMPLE_FMT_FLTP)
AV_SAMPLE_FMT_DBLP = AvSampleFormat(C.AV_SAMPLE_FMT_DBLP)
AV_SAMPLE_FMT_S64 = AvSampleFormat(C.AV_SAMPLE_FMT_S64)
AV_SAMPLE_FMT_S64P = AvSampleFormat(C.AV_SAMPLE_FMT_S64P)
AV_SAMPLE_FMT_NB = AvSampleFormat(C.AV_SAMPLE_FMT_NB)
AV_SAMPLE_FMT_NONE = AVSampleFormat(C.AV_SAMPLE_FMT_NONE)
AV_SAMPLE_FMT_U8 = AVSampleFormat(C.AV_SAMPLE_FMT_U8)
AV_SAMPLE_FMT_S16 = AVSampleFormat(C.AV_SAMPLE_FMT_S16)
AV_SAMPLE_FMT_S32 = AVSampleFormat(C.AV_SAMPLE_FMT_S32)
AV_SAMPLE_FMT_FLT = AVSampleFormat(C.AV_SAMPLE_FMT_FLT)
AV_SAMPLE_FMT_DBL = AVSampleFormat(C.AV_SAMPLE_FMT_DBL)
AV_SAMPLE_FMT_U8P = AVSampleFormat(C.AV_SAMPLE_FMT_U8P)
AV_SAMPLE_FMT_S16P = AVSampleFormat(C.AV_SAMPLE_FMT_S16P)
AV_SAMPLE_FMT_S32P = AVSampleFormat(C.AV_SAMPLE_FMT_S32P)
AV_SAMPLE_FMT_FLTP = AVSampleFormat(C.AV_SAMPLE_FMT_FLTP)
AV_SAMPLE_FMT_DBLP = AVSampleFormat(C.AV_SAMPLE_FMT_DBLP)
AV_SAMPLE_FMT_S64 = AVSampleFormat(C.AV_SAMPLE_FMT_S64)
AV_SAMPLE_FMT_S64P = AVSampleFormat(C.AV_SAMPLE_FMT_S64P)
AV_SAMPLE_FMT_NB = AVSampleFormat(C.AV_SAMPLE_FMT_NB)
)
// AvGetSampleFmtName returns the name of sample_fmt, or NULL if sample_fmt is not
// recognized.
func AvGetSampleFmtName(sampleFmt AvSampleFormat) string {
func AvGetSampleFmtName(sampleFmt AVSampleFormat) string {
return C.GoString(C.av_get_sample_fmt_name((C.enum_AVSampleFormat)(sampleFmt)))
}
// AvGetSampleFmt returns a sample format corresponding to name, or AV_SAMPLE_FMT_NONE
// on error.
func AvGetSampleFmt(name string) AvSampleFormat {
func AvGetSampleFmt(name string) AVSampleFormat {
namePtr, nameFunc := StringCasting(name)
defer nameFunc()
return (AvSampleFormat)(C.av_get_sample_fmt((*C.char)(namePtr)))
return (AVSampleFormat)(C.av_get_sample_fmt((*C.char)(namePtr)))
}
// AvGetAltSampleFmt returns the planar<->packed alternative form of the given sample format, or
// AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the
// Av_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the
// requested planar/packed format, the format returned is the same as the
// input.
func AvGetAltSampleFmt(sampleFmt AvSampleFormat, planar int32) AvSampleFormat {
return (AvSampleFormat)(C.av_get_alt_sample_fmt((C.enum_AVSampleFormat)(sampleFmt), C.int(planar)))
func AvGetAltSampleFmt(sampleFmt AVSampleFormat, planar int32) AVSampleFormat {
return (AVSampleFormat)(C.av_get_alt_sample_fmt((C.enum_AVSampleFormat)(sampleFmt), C.int(planar)))
}
// AvGetPackedSampleFmt gets the packed alternative form of the given sample format.
func AvGetPackedSampleFmt(sampleFmt AvSampleFormat) AvSampleFormat {
return (AvSampleFormat)(C.av_get_packed_sample_fmt((C.enum_AVSampleFormat)(sampleFmt)))
func AvGetPackedSampleFmt(sampleFmt AVSampleFormat) AVSampleFormat {
return (AVSampleFormat)(C.av_get_packed_sample_fmt((C.enum_AVSampleFormat)(sampleFmt)))
}
// AvGetPlanarSampleFmt gets the planar alternative form of the given sample format.
func AvGetPlanarSampleFmt(sampleFmt AvSampleFormat) AvSampleFormat {
return (AvSampleFormat)(C.av_get_planar_sample_fmt((C.enum_AVSampleFormat)(sampleFmt)))
func AvGetPlanarSampleFmt(sampleFmt AVSampleFormat) AVSampleFormat {
return (AVSampleFormat)(C.av_get_planar_sample_fmt((C.enum_AVSampleFormat)(sampleFmt)))
}
// AvGetSampleFmtString generates a string corresponding to the sample format with
// sample_fmt, or a header if sample_fmt is negative.
func AvGetSampleFmtString(buf *int8, bufSize int32, sampleFmt AvSampleFormat) string {
func AvGetSampleFmtString(buf *int8, bufSize int32, sampleFmt AVSampleFormat) string {
return C.GoString(C.av_get_sample_fmt_string((*C.char)(buf), (C.int)(bufSize),
(C.enum_AVSampleFormat)(sampleFmt)))
}
// AvGetBytesPerSample returns number of bytes per sample.
func AvGetBytesPerSample(sampleFmt AvSampleFormat) int32 {
func AvGetBytesPerSample(sampleFmt AVSampleFormat) int32 {
return (int32)(C.av_get_bytes_per_sample((C.enum_AVSampleFormat)(sampleFmt)))
}
// AvSampleFmtIsPlanar checks if the sample format is planar.
func AvSampleFmtIsPlanar(sampleFmt AvSampleFormat) int32 {
func AvSampleFmtIsPlanar(sampleFmt AVSampleFormat) int32 {
return (int32)(C.av_sample_fmt_is_planar((C.enum_AVSampleFormat)(sampleFmt)))
}
// AvSamplesGetBufferSize gets the required buffer size for the given audio parameters.
func AvSamplesGetBufferSize(linesize *int32, nbChannels, nbSamples int32,
sampleFmt AvSampleFormat, align int32) int32 {
sampleFmt AVSampleFormat, align int32) int32 {
return (int32)(C.av_samples_get_buffer_size((*C.int)(linesize), (C.int)(nbChannels),
(C.int)(nbSamples), (C.enum_AVSampleFormat)(sampleFmt), (C.int)(align)))
}
@@ -86,7 +86,7 @@ func AvSamplesGetBufferSize(linesize *int32, nbChannels, nbSamples int32,
// format sample_fmt.
func AvSamplesFillArrays(audioData **uint8, linesize *int32,
buf *uint8, nbChannels, nbSamples int32,
sampleFmt AvSampleFormat, align int32) int32 {
sampleFmt AVSampleFormat, align int32) int32 {
return (int32)(C.av_samples_fill_arrays((**C.uint8_t)(unsafe.Pointer(audioData)),
(*C.int)(linesize), (*C.uint8_t)(buf),
(C.int)(nbChannels), (C.int)(nbSamples),
@@ -97,7 +97,7 @@ func AvSamplesFillArrays(audioData **uint8, linesize *int32,
// linesize accordingly.
func AvSamplesAlloc(audioData **uint8, linesize *int32,
nbChannels, nbSamples int32,
sampleFmt AvSampleFormat, align int32) int32 {
sampleFmt AVSampleFormat, align int32) int32 {
return (int32)(C.av_samples_alloc((**C.uint8_t)(unsafe.Pointer(audioData)),
(*C.int)(linesize),
(C.int)(nbChannels), (C.int)(nbSamples),
@@ -107,7 +107,7 @@ func AvSamplesAlloc(audioData **uint8, linesize *int32,
// AvSamplesAllocArrayAndSamples allocates a data pointers array, samples buffer for nb_samples
// samples, and fill data pointers and linesize accordingly.
func AvSamplesAllocArrayAndSamples(audioData ***uint8, linesize *int32, nbChannels, nbSamples int32,
sampleFmt AvSampleFormat, align int32) int32 {
sampleFmt AVSampleFormat, align int32) int32 {
return (int32)(C.av_samples_alloc_array_and_samples((***C.uint8_t)(unsafe.Pointer(audioData)),
(*C.int)(linesize), (C.int)(nbChannels), (C.int)(nbSamples),
(C.enum_AVSampleFormat)(sampleFmt), (C.int)(align)))
@@ -115,7 +115,7 @@ func AvSamplesAllocArrayAndSamples(audioData ***uint8, linesize *int32, nbChanne
// AvSamplesCopy copies samples from src to dst.
func AvSamplesCopy(dst, src **uint8, dstOffset, srcOffset int32,
nbSamples, nbChannels int32, sampleFmt AvSampleFormat) int32 {
nbSamples, nbChannels int32, sampleFmt AVSampleFormat) int32 {
return (int32)(C.av_samples_copy((**C.uint8_t)(unsafe.Pointer(dst)),
(**C.uint8_t)(unsafe.Pointer(src)),
(C.int)(dstOffset), (C.int)(srcOffset),
@@ -125,7 +125,7 @@ func AvSamplesCopy(dst, src **uint8, dstOffset, srcOffset int32,
// AvSamplesSetSilence fills an audio buffer with silence.
func AvSamplesSetSilence(audioData **uint8, offset int32,
nbSamples, nbChannels int32, sampleFmt AvSampleFormat) int32 {
nbSamples, nbChannels int32, sampleFmt AVSampleFormat) int32 {
return (int32)(C.av_samples_set_silence((**C.uint8_t)(unsafe.Pointer(audioData)), (C.int)(offset),
(C.int)(nbSamples), (C.int)(nbChannels), (C.enum_AVSampleFormat)(sampleFmt)))
}

12
examples/decode-audio/main.go
View File

@@ -13,9 +13,9 @@ const (
AUDIO_REFILL_THRESH = 4096
)
func getFormatFromSampleFmt(sampleFmt ffmpeg.AvSampleFormat) (string, int32) {
func getFormatFromSampleFmt(sampleFmt ffmpeg.AVSampleFormat) (string, int32) {
sampleFmtEntry := []struct {
sampleFmt ffmpeg.AvSampleFormat
sampleFmt ffmpeg.AVSampleFormat
fmtBe string
fmtLe string
}{
@@ -37,7 +37,7 @@ func getFormatFromSampleFmt(sampleFmt ffmpeg.AvSampleFormat) (string, int32) {
return "", -1
}
func decode(decCtx *ffmpeg.AvCodecContext, pkt *ffmpeg.AvPacket, frame *ffmpeg.AvFrame, outfile *os.File) {
func decode(decCtx *ffmpeg.AVCodecContext, pkt *ffmpeg.AVPacket, frame *ffmpeg.AVFrame, outfile *os.File) {
// send the packet with the compressed data to the decoder
ret := ffmpeg.AvCodecSendPacket(decCtx, pkt)
if ret < 0 {
@@ -48,7 +48,7 @@ func decode(decCtx *ffmpeg.AvCodecContext, pkt *ffmpeg.AvPacket, frame *ffmpeg.A
// read all the output frames (in general there may be any number of them
for ret >= 0 {
ret = ffmpeg.AvCodecReceiveFrame(decCtx, frame)
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) || ret == ffmpeg.AVERROR_EOF {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) || ret == ffmpeg.AVERROR_EOF {
return
} else if ret < 0 {
fmt.Fprintf(os.Stderr, "Error during decoding\n")
@@ -62,7 +62,7 @@ func decode(decCtx *ffmpeg.AvCodecContext, pkt *ffmpeg.AvPacket, frame *ffmpeg.A
}
for i := int32(0); i < frame.GetNbSamples(); i++ {
for ch := 0; ch < int(decCtx.GetChannels()); ch++ {
outfile.Write(ffmpeg.SliceWithOffset(frame.GetDataIdx(ch), dataSize*i, dataSize))
outfile.Write(ffmpeg.ByteSliceWithOffset(frame.GetDataIdx(ch), dataSize*i, dataSize))
}
}
}
@@ -114,7 +114,7 @@ func main() {
}
// decode until eof
var decodedFrame *ffmpeg.AvFrame
var decodedFrame *ffmpeg.AVFrame
inbuf := make([]byte, AUDIO_INBUF_SIZE+ffmpeg.AV_INPUT_BUFFER_PADDING_SIZE)
dataOffset := 0
dataSize, err := f.Read(inbuf[:AUDIO_INBUF_SIZE])

6
examples/decode-video/main.go
View File

@@ -17,12 +17,12 @@ func pgmSave(buf *uint8, wrap, xsize, ysize int32, filename string) {
f, _ := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
fmt.Fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255)
for i := int32(0); i < ysize; i++ {
f.Write(ffmpeg.SliceWithOffset(buf, i+wrap, xsize))
f.Write(ffmpeg.ByteSliceWithOffset(buf, i+wrap, xsize))
}
f.Close()
}
func decode(decCtx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.AvPacket, filename string) {
func decode(decCtx *ffmpeg.AVCodecContext, frame *ffmpeg.AVFrame, pkt *ffmpeg.AVPacket, filename string) {
ret := ffmpeg.AvCodecSendPacket(decCtx, pkt)
if ret < 0 {
fmt.Fprintf(os.Stderr, "Error sending a packet for decoding\n")
@@ -31,7 +31,7 @@ func decode(decCtx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.Av
for ret >= 0 {
ret = ffmpeg.AvCodecReceiveFrame(decCtx, frame)
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) || ret == ffmpeg.AVERROR_EOF {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) || ret == ffmpeg.AVERROR_EOF {
return
} else if ret < 0 {
fmt.Fprintf(os.Stderr, "Error during decoding\n")

12
examples/encode-audio/main.go
View File

@@ -11,7 +11,7 @@ import (
)
// check that a given sample format is supported by the encoder
func checkSampleFmt(codec *ffmpeg.AvCodec, sampleFmt ffmpeg.AvSampleFormat) int32 {
func checkSampleFmt(codec *ffmpeg.AVCodec, sampleFmt ffmpeg.AVSampleFormat) int32 {
for _, f := range codec.GetSampleFmts() {
if f == sampleFmt {
return 1
@@ -20,7 +20,7 @@ func checkSampleFmt(codec *ffmpeg.AvCodec, sampleFmt ffmpeg.AvSampleFormat) int3
return 0
}
func selectSampleRate(codec *ffmpeg.AvCodec) int32 {
func selectSampleRate(codec *ffmpeg.AVCodec) int32 {
var bestSamplerate int32
ss := codec.GetSupportedSamplerates()
if len(ss) == 0 {
@@ -35,7 +35,7 @@ func selectSampleRate(codec *ffmpeg.AvCodec) int32 {
}
// select layout with the highest channel count
func selectChannelLayout(codec *ffmpeg.AvCodec) uint64 {
func selectChannelLayout(codec *ffmpeg.AVCodec) uint64 {
var bestChLayout uint64
var bestNbChannels int32
ls := codec.GetChannelLayouts()
@@ -55,7 +55,7 @@ func selectChannelLayout(codec *ffmpeg.AvCodec) uint64 {
return bestChLayout
}
func encode(ctx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.AvPacket, output *os.File) {
func encode(ctx *ffmpeg.AVCodecContext, frame *ffmpeg.AVFrame, pkt *ffmpeg.AVPacket, output *os.File) {
// send the frame for encoding
ret := ffmpeg.AvCodecSendFrame(ctx, frame)
if ret < 0 {
@@ -66,14 +66,14 @@ func encode(ctx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.AvPac
// read all the available output packets (in general there may be any number of them
for ret >= 0 {
ret = ffmpeg.AvCodecReceivePacket(ctx, pkt)
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) || ret == ffmpeg.AVERROR_EOF {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) || ret == ffmpeg.AVERROR_EOF {
return
} else if ret < 0 {
fmt.Fprintf(os.Stderr, "Error encoding audio frame\n")
os.Exit(1)
}
output.Write(ffmpeg.Slice(pkt.GetData(), pkt.GetSize()))
output.Write(ffmpeg.ByteSlice(pkt.GetData(), pkt.GetSize()))
ffmpeg.AvPacketUnref(pkt)
}

4
examples/encode-video/main.go
View File

@@ -9,7 +9,7 @@ import (
ffmpeg "github.com/qrtc/ffmpeg-dev-go"
)
func encode(encCtx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.AvPacket, outfile *os.File) {
func encode(encCtx *ffmpeg.AVCodecContext, frame *ffmpeg.AVFrame, pkt *ffmpeg.AVPacket, outfile *os.File) {
if frame != nil {
fmt.Fprintf(os.Stdout, "Send frame %3d\n", frame.GetPts())
}
@@ -22,7 +22,7 @@ func encode(encCtx *ffmpeg.AvCodecContext, frame *ffmpeg.AvFrame, pkt *ffmpeg.Av
for ret >= 0 {
ret = ffmpeg.AvCodecReceivePacket(encCtx, pkt)
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) || ret == ffmpeg.AVERROR_EOF {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) || ret == ffmpeg.AVERROR_EOF {
return
} else if ret < 0 {
fmt.Fprintf(os.Stderr, "Error during encoding\n")

62
examples/filter-audio/main.go
View File

@@ -19,22 +19,22 @@ const (
FRAME_SIZE = 1024
)
func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext, sink *ffmpeg.AvFilterContext, ret int32) {
var filterGraph *ffmpeg.AvFilterGraph
var abufferCtx *ffmpeg.AvFilterContext
var abuffer *ffmpeg.AvFilter
var volumeCtx *ffmpeg.AvFilterContext
var volume *ffmpeg.AvFilter
var aformatCtx *ffmpeg.AvFilterContext
var aformat *ffmpeg.AvFilter
var abuffersinkCtx *ffmpeg.AvFilterContext
var abuffersink *ffmpeg.AvFilter
var optionsDict *ffmpeg.AvDictionary
func initFilterGraph() (graph *ffmpeg.AVFilterGraph, src *ffmpeg.AVFilterContext, sink *ffmpeg.AVFilterContext, ret int32) {
var filterGraph *ffmpeg.AVFilterGraph
var abufferCtx *ffmpeg.AVFilterContext
var abuffer *ffmpeg.AVFilter
var volumeCtx *ffmpeg.AVFilterContext
var volume *ffmpeg.AVFilter
var aformatCtx *ffmpeg.AVFilterContext
var aformat *ffmpeg.AVFilter
var abuffersinkCtx *ffmpeg.AVFilterContext
var abuffersink *ffmpeg.AVFilter
var optionsDict *ffmpeg.AVDictionary
// Create a new filtergraph, which will contain all the filters.
if filterGraph = ffmpeg.AvFilterGraphAlloc(); filterGraph == nil {
fmt.Fprintf(os.Stderr, "Unable to create filter graph.\n")
return nil, nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// Create the abuffer filter;
@@ -46,16 +46,16 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
if abufferCtx = ffmpeg.AvFilterGraphAllocFilter(filterGraph, abuffer, "src"); abufferCtx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate the abuffer instance.\n")
return nil, nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
ffmpeg.AvOptSet(unsafe.Pointer(abufferCtx), "channel_layout",
ffmpeg.AvOptSet(abufferCtx, "channel_layout",
ffmpeg.AvGetChannelLayoutString(0, INPUT_CHANNEL_LAYOUT), ffmpeg.AV_OPT_SEARCH_CHILDREN)
ffmpeg.AvOptSet(unsafe.Pointer(abufferCtx), "sample_fmt",
ffmpeg.AvOptSet(abufferCtx, "sample_fmt",
ffmpeg.AvGetSampleFmtName(INPUT_FORMAT), ffmpeg.AV_OPT_SEARCH_CHILDREN)
ffmpeg.AvOptSetQ(unsafe.Pointer(abufferCtx), "time_base",
ffmpeg.AvOptSetQ(abufferCtx, "time_base",
ffmpeg.AvMakeQ(1, INPUT_SAMPLERATE), ffmpeg.AV_OPT_SEARCH_CHILDREN)
ffmpeg.AvOptSetInt(unsafe.Pointer(abufferCtx), "sample_rate",
ffmpeg.AvOptSetInt(abufferCtx, "sample_rate",
INPUT_SAMPLERATE, ffmpeg.AV_OPT_SEARCH_CHILDREN)
// Now initialize the filter; we pass NULL options, since we have already set all the options above.
@@ -72,7 +72,7 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
if volumeCtx = ffmpeg.AvFilterGraphAllocFilter(filterGraph, volume, "volume"); volumeCtx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate the volume instance.\n")
return nil, nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// A different way of passing the options is as key/value pairs in a
@@ -94,7 +94,7 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
if aformatCtx = ffmpeg.AvFilterGraphAllocFilter(filterGraph, aformat, "aformat"); aformatCtx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate the aformat instance.\n")
return nil, nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// A third way of passing the options is in a string of the form
@@ -115,7 +115,7 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
if abuffersinkCtx = ffmpeg.AvFilterGraphAllocFilter(filterGraph, abuffersink, "sink"); abuffersinkCtx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate the abuffersink instance.\n")
return nil, nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// This filter takes no options.
@@ -126,12 +126,12 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
// Connect the filters;
// in this simple case the filters just form a linear chain.
ret = ffmpeg.AvFilterLink2(abufferCtx, 0, volumeCtx, 0)
ret = ffmpeg.AvFilterLink(abufferCtx, 0, volumeCtx, 0)
if ret >= 0 {
ret = ffmpeg.AvFilterLink2(volumeCtx, 0, aformatCtx, 0)
ret = ffmpeg.AvFilterLink(volumeCtx, 0, aformatCtx, 0)
}
if ret >= 0 {
ret = ffmpeg.AvFilterLink2(aformatCtx, 0, abuffersinkCtx, 0)
ret = ffmpeg.AvFilterLink(aformatCtx, 0, abuffersinkCtx, 0)
}
if ret < 0 {
fmt.Fprintf(os.Stderr, "Error connecting filters\n")
@@ -149,7 +149,7 @@ func initFilterGraph() (graph *ffmpeg.AvFilterGraph, src *ffmpeg.AvFilterContext
// Do something useful with the filtered data: this simple
// example just prints the MD5 checksum of each plane to stdout.
func processOutput(md5 *ffmpeg.AvMD5, frame *ffmpeg.AvFrame) int32 {
func processOutput(md5 *ffmpeg.AVMD5, frame *ffmpeg.AVFrame) int32 {
planar := ffmpeg.AvSampleFmtIsPlanar(frame.GetFormat())
channels := ffmpeg.AvGetChannelLayoutNbChannels(frame.GetChannelLayout())
planes := channels
@@ -181,7 +181,7 @@ func processOutput(md5 *ffmpeg.AvMD5, frame *ffmpeg.AvFrame) int32 {
// Construct a frame of audio data to be filtered;
// this simple example just synthesizes a sine wave.
func getInput(frame *ffmpeg.AvFrame, frameNum int32) int32 {
func getInput(frame *ffmpeg.AVFrame, frameNum int32) int32 {
// Set up the frame properties and allocate the buffer for the data.
frame.SetSampleRate(INPUT_SAMPLERATE)
frame.SetFormat(INPUT_FORMAT)
@@ -208,10 +208,10 @@ func getInput(frame *ffmpeg.AvFrame, frameNum int32) int32 {
}
func main() {
var md5 *ffmpeg.AvMD5
var graph *ffmpeg.AvFilterGraph
var src, sink *ffmpeg.AvFilterContext
var frame *ffmpeg.AvFrame
var md5 *ffmpeg.AVMD5
var graph *ffmpeg.AVFilterGraph
var src, sink *ffmpeg.AVFilterContext
var frame *ffmpeg.AVFrame
var ret int32
if len(os.Args) < 2 {
@@ -272,7 +272,7 @@ func main() {
ffmpeg.AvFrameUnref(frame)
}
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) {
// Need to feed more frames in.
continue
} else if ret == ffmpeg.AVERROR_EOF {
@@ -287,7 +287,7 @@ func main() {
ffmpeg.AvFilterGraphFree(&graph)
ffmpeg.AvFrameFree(&frame)
ffmpeg.AvFreep(unsafe.Pointer(&md5))
ffmpeg.AvFreep(&md5)
return
fail:

240
examples/hw-decode/main.go
View File

@@ -1,5 +1,243 @@
package main
func main() {
/*
#include <stdlib.h>
#include <stdio.h>
static int hw_pix_fmt;
static inline int get_hw_pix_fmt()
{
return hw_pix_fmt;
}
static inline void set_hw_pix_fmt(int fmt)
{
hw_pix_fmt = fmt;
}
struct AVCodecContext;
int get_hw_format(struct AVCodecContext *ctx, const int *pix_fmts)
{
const int *p;
fprintf(stderr, "get_hw_format called.\n");
for (p = pix_fmts; *p != -1; p++) {
if (*p == hw_pix_fmt)
return *p;
}
fprintf(stderr, "Failed to get HW surface format.\n");
return -1;
}
*/
import "C"
import (
"fmt"
"os"
"syscall"
"unsafe"
"github.com/qrtc/ffmpeg-dev-go"
)
var (
hwDeviceCtx *ffmpeg.AVBufferRef
outputFile *os.File
)
func hwDecoderInit(ctx *ffmpeg.AVCodecContext, hwType ffmpeg.AVHWDeviceType) (ret int32) {
if ret := ffmpeg.AvHWDeviceCtxCreate(&hwDeviceCtx, hwType, "", nil, 0); ret < 0 {
fmt.Fprintf(os.Stderr, "Failed to create specified HW device.\n")
return ret
}
ctx.SetHwDeviceCtx(ffmpeg.AvBufferRef(hwDeviceCtx))
return ret
}
func decodeWrite(avctx *ffmpeg.AVCodecContext, packet *ffmpeg.AVPacket) (ret int32) {
var frame, swFrame, tmpFrame *ffmpeg.AVFrame
var buffer *uint8
var size int32
if ret = ffmpeg.AvCodecSendPacket(avctx, packet); ret < 0 {
fmt.Fprintf(os.Stderr, "Error during decoding\n")
return ret
}
for {
if frame = ffmpeg.AvFrameAlloc(); frame == nil {
fmt.Fprintf(os.Stderr, "Can not alloc frame\n")
goto fail
}
if swFrame = ffmpeg.AvFrameAlloc(); swFrame == nil {
fmt.Fprintf(os.Stderr, "Can not alloc sw frame\n")
goto fail
}
ret = ffmpeg.AvCodecReceiveFrame(avctx, frame)
if ret == ffmpeg.AVERROR(syscall.EAGAIN) || ret == ffmpeg.AVERROR_EOF {
ffmpeg.AvFrameFree(&frame)
ffmpeg.AvFrameFree(&swFrame)
return 0
} else if ret < 0 {
fmt.Fprintf(os.Stderr, "Error while decoding\n")
goto fail
}
if frame.GetFormat() == (int32)(C.get_hw_pix_fmt()) {
// retrieve data from GPU to CPU
if ret = ffmpeg.AvHWFrameTransferData(swFrame, frame, 0); ret < 0 {
fmt.Fprintf(os.Stderr, "Error transferring the data to system memory\n")
goto fail
}
tmpFrame = swFrame
} else {
tmpFrame = frame
}
size = ffmpeg.AvImageGetBufferSize(tmpFrame.GetFormat(), tmpFrame.GetWidth(),
tmpFrame.GetHeight(), 1)
buffer = (*uint8)(ffmpeg.AvMalloc(size))
if buffer == nil {
fmt.Fprintf(os.Stderr, "Can not alloc buffer\n")
ret = ffmpeg.AVERROR(syscall.ENOMEM)
goto fail
}
ret = ffmpeg.AvImageCopyToBuffer(buffer, size, tmpFrame.GetData(),
tmpFrame.GetLinesize(), tmpFrame.GetFormat(),
tmpFrame.GetWidth(), tmpFrame.GetHeight(), 1)
if ret < 0 {
fmt.Fprintf(os.Stderr, "Can not copy image to buffer\n")
goto fail
}
if _, err := outputFile.Write(unsafe.Slice(buffer, size)); err != nil {
fmt.Fprintf(os.Stderr, "Failed to dump raw data.\n")
goto fail
}
fail:
ffmpeg.AvFrameFree(&frame)
ffmpeg.AvFrameFree(&swFrame)
ffmpeg.AvFreep(&buffer)
if ret < 0 {
return ret
}
}
}
func main() {
var inputCtx *ffmpeg.AVFormatContext
var videoStream, ret int32
var video *ffmpeg.AVStream
var decoderCtx *ffmpeg.AVCodecContext
var decoder *ffmpeg.AVCodec
var packet ffmpeg.AVPacket
var hwType ffmpeg.AVHWDeviceType
if len(os.Args) < 4 {
fmt.Fprintf(os.Stderr, "Usage: %s <device type> <input file> <output file>\n", os.Args[0])
os.Exit(1)
}
hwType = ffmpeg.AvHWDeviceFindTypeByName(os.Args[1])
if hwType == ffmpeg.AV_HWDEVICE_TYPE_NONE {
fmt.Fprintf(os.Stderr, "Device type %s is not supported.\n", os.Args[0])
fmt.Fprintf(os.Stderr, "Available device types:")
for hwType = ffmpeg.AvHWDeviceIterateTypes(hwType); hwType != ffmpeg.AV_HWDEVICE_TYPE_NONE; {
fmt.Fprintf(os.Stderr, " %s", ffmpeg.AvHWDeviceGetTypeName(hwType))
hwType = ffmpeg.AvHWDeviceIterateTypes(hwType)
}
fmt.Fprintf(os.Stderr, "\n")
os.Exit(1)
}
// open the input file
if ret = ffmpeg.AvFormatOpenInput(&inputCtx, os.Args[2], nil, nil); ret != 0 {
fmt.Fprintf(os.Stderr, "Cannot open input file '%s'\n", os.Args[2])
os.Exit(1)
}
if ret = ffmpeg.AvFormatFindStreamInfo(inputCtx, nil); ret < 0 {
fmt.Fprintf(os.Stderr, "Cannot find input stream information.\n")
os.Exit(1)
}
// find the video stream information
ret = ffmpeg.AvFindBestStream(inputCtx, ffmpeg.AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0)
if ret < 0 {
fmt.Fprintf(os.Stderr, "Cannot find a video stream in the input file\n")
os.Exit(1)
}
videoStream = ret
for i := 0; ; i++ {
config := ffmpeg.AvCodecGetHwConfig(decoder, i)
if config == nil {
fmt.Fprintf(os.Stderr, "Decoder %s does not support device type %s.\n",
decoder.GetName(), ffmpeg.AvHWDeviceGetTypeName(hwType))
os.Exit(1)
}
if (config.GetMethods()&ffmpeg.AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) != 0 &&
config.GetDeviceType() == hwType {
fmt.Fprintf(os.Stdout, "Support set_hw_pix_fmt. \n")
C.set_hw_pix_fmt((C.int)(config.GetPixFmt()))
break
}
}
if decoderCtx = ffmpeg.AvCodecAllocContext3(decoder); decoderCtx == nil {
os.Exit(int(ffmpeg.AVERROR(syscall.ENOMEM)))
}
video = inputCtx.GetStreamsIdx(int(videoStream))
if ret = ffmpeg.AvCodecParametersToContext(decoderCtx, video.GetCodecpar()); ret < 0 {
os.Exit(1)
}
decoderCtx.SetGetFormat((ffmpeg.AVCodecContextGetFormatFunc)(C.get_hw_format))
if ret = hwDecoderInit(decoderCtx, hwType); ret < 0 {
os.Exit(1)
}
if ret = ffmpeg.AvCodecOpen2(decoderCtx, decoder, nil); ret < 0 {
fmt.Fprintf(os.Stderr, "Failed to open codec for stream #%d\n", videoStream)
os.Exit(1)
}
// open the file to dump raw data
outputFile, _ = os.OpenFile(os.Args[3], os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
// actual decoding and dump the raw data
for ret >= 0 {
if ret = ffmpeg.AvReadFrame(inputCtx, &packet); ret < 0 {
break
}
if videoStream == packet.GetStreamIndex() {
ret = decodeWrite(decoderCtx, &packet)
}
ffmpeg.AvPacketUnref(&packet)
}
// flush the decoder
packet.SetData(nil)
packet.SetSize(0)
ret = decodeWrite(decoderCtx, &packet)
ffmpeg.AvPacketUnref(&packet)
if outputFile != nil {
outputFile.Close()
}
ffmpeg.AvCodecFreeContext(&decoderCtx)
ffmpeg.AvFormatCloseInput(&inputCtx)
ffmpeg.AvBufferUnref(&hwDeviceCtx)
if ret != 0 {
fmt.Fprintf(os.Stderr, "(error '%s')\n", ffmpeg.AvErr2str(ret))
}
os.Exit(int(ret))
}

6
examples/scaling-video/main.go
View File

@@ -72,7 +72,7 @@ func main() {
"fmt:%s s:%dx%d -> fmt:%s s:%dx%d\n",
ffmpeg.AvGetPixFmtName(srcPixFmt), srcW, srcH,
ffmpeg.AvGetPixFmtName(dstPixFmt), dstW, dstH)
ret = ffmpeg.AVERROR(int32(syscall.EINVAL))
ret = ffmpeg.AVERROR(syscall.EINVAL)
goto end
}
@@ -106,8 +106,8 @@ func main() {
end:
dstFile.Close()
ffmpeg.AvFreep(unsafe.Pointer(&srcData[0]))
ffmpeg.AvFreep(unsafe.Pointer(&dstData[0]))
ffmpeg.AvFreep(&srcData[0])
ffmpeg.AvFreep(&dstData[0])
ffmpeg.SwsFreeContext(swsCtx)
if ret < 0 {
os.Exit(1)

120
examples/transcode-aac/main.go
View File

@@ -15,8 +15,8 @@ const (
)
// Open an input file and the required decoder.
func openInputFile(fileName string) (inputFormatContext *ffmpeg.AvFormatContext,
inputCodecContext *ffmpeg.AvCodecContext, ret int32) {
func openInputFile(fileName string) (inputFormatContext *ffmpeg.AVFormatContext,
inputCodecContext *ffmpeg.AVCodecContext, ret int32) {
// Open the input file to read from it.
if ret = ffmpeg.AvFormatOpenInput(&inputFormatContext, fileName, nil, nil); ret < 0 {
@@ -51,7 +51,7 @@ func openInputFile(fileName string) (inputFormatContext *ffmpeg.AvFormatContext,
if avctx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate a decoding context\n")
ffmpeg.AvFormatCloseInput(&inputFormatContext)
return nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// Initialize the stream parameters with demuxer information.
@@ -76,13 +76,13 @@ func openInputFile(fileName string) (inputFormatContext *ffmpeg.AvFormatContext,
}
// Open an output file and the required encoder.
func openOutputFile(filename string, inputCodecContext *ffmpeg.AvCodecContext) (outputFormatContext *ffmpeg.AvFormatContext,
outputCodecContext *ffmpeg.AvCodecContext, ret int32) {
func openOutputFile(filename string, inputCodecContext *ffmpeg.AVCodecContext) (outputFormatContext *ffmpeg.AVFormatContext,
outputCodecContext *ffmpeg.AVCodecContext, ret int32) {
var outputIOContext *ffmpeg.AvIOContext
var outputCodec *ffmpeg.AvCodec
var stream *ffmpeg.AvStream
var avctx *ffmpeg.AvCodecContext
var outputIOContext *ffmpeg.AVIOContext
var outputCodec *ffmpeg.AVCodec
var stream *ffmpeg.AVStream
var avctx *ffmpeg.AVCodecContext
// Open the output file to write to it.
if ret = ffmpeg.AvIOOpen(&outputIOContext, filename, ffmpeg.AVIO_FLAG_WRITE); ret < 0 {
@@ -93,7 +93,7 @@ func openOutputFile(filename string, inputCodecContext *ffmpeg.AvCodecContext) (
// Create a new format context for the output container format.
if outputFormatContext = ffmpeg.AvFormatAllocContext(); outputFormatContext == nil {
fmt.Fprintf(os.Stderr, "Could not allocate output format context\n")
return nil, nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// Associate the output file (pointer) with the container format context.
@@ -109,7 +109,7 @@ func openOutputFile(filename string, inputCodecContext *ffmpeg.AvCodecContext) (
outputFormatContext.SetUrl(filename)
if len(outputFormatContext.GetUrl()) == 0 {
fmt.Fprintf(os.Stderr, "Could not allocate url.\n")
ret = ffmpeg.AVERROR(int32(syscall.ENOMEM))
ret = ffmpeg.AVERROR(syscall.ENOMEM)
goto cleanup
}
@@ -122,13 +122,13 @@ func openOutputFile(filename string, inputCodecContext *ffmpeg.AvCodecContext) (
// Create a new audio stream in the output file container.
if stream = ffmpeg.AvFormatNewStream(outputFormatContext, nil); stream == nil {
fmt.Fprintf(os.Stderr, "Could not create new stream\n")
ret = ffmpeg.AVERROR(int32(syscall.ENOMEM))
ret = ffmpeg.AVERROR(syscall.ENOMEM)
goto cleanup
}
if avctx = ffmpeg.AvCodecAllocContext3(outputCodec); avctx == nil {
fmt.Fprintf(os.Stderr, "Could not allocate an encoding context\n")
ret = ffmpeg.AVERROR(int32(syscall.ENOMEM))
ret = ffmpeg.AVERROR(syscall.ENOMEM)
goto cleanup
}
@@ -179,19 +179,19 @@ cleanup:
}
// Initialize one data packet for reading or writing.
func initPacket() (packet *ffmpeg.AvPacket, ret int32) {
func initPacket() (packet *ffmpeg.AVPacket, ret int32) {
if packet = ffmpeg.AvPacketAlloc(); packet == nil {
fmt.Fprintf(os.Stderr, "Could not allocate packet\n")
return nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
return packet, 0
}
// Initialize one audio frame for reading from the input file.
func initInputFrame() (frame *ffmpeg.AvFrame, ret int32) {
func initInputFrame() (frame *ffmpeg.AVFrame, ret int32) {
if frame = ffmpeg.AvFrameAlloc(); frame == nil {
fmt.Fprintf(os.Stderr, "Could not allocate input frame\n")
return nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
return frame, 0
}
@@ -199,7 +199,7 @@ func initInputFrame() (frame *ffmpeg.AvFrame, ret int32) {
// Initialize the audio resampler based on the input and output codec settings.
// If the input and output sample formats differ, a conversion is required
// libswresample takes care of this, but requires initialization.
func initResampler(inputCodecContext, outputCodecContext *ffmpeg.AvCodecContext) (
func initResampler(inputCodecContext, outputCodecContext *ffmpeg.AVCodecContext) (
resampleContext *ffmpeg.SwrContext, ret int32) {
// Create a resampler context for the conversion.
@@ -216,7 +216,7 @@ func initResampler(inputCodecContext, outputCodecContext *ffmpeg.AvCodecContext)
inputCodecContext.GetSampleRate(),
0, nil); resampleContext == nil {
fmt.Fprintf(os.Stderr, "Could not allocate resample context\n")
return nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
if outputCodecContext.GetSampleRate() != inputCodecContext.GetSampleRate() {
@@ -233,18 +233,18 @@ func initResampler(inputCodecContext, outputCodecContext *ffmpeg.AvCodecContext)
}
// Initialize a FIFO buffer for the audio samples to be encoded.
func initFifo(outputCodecContext *ffmpeg.AvCodecContext) (fifo *ffmpeg.AvAudioFifo, ret int32) {
func initFifo(outputCodecContext *ffmpeg.AVCodecContext) (fifo *ffmpeg.AVAudioFifo, ret int32) {
// Create the FIFO buffer based on the specified output sample format
if fifo = ffmpeg.AvAudioFifoAlloc(outputCodecContext.GetSampleFmt(),
outputCodecContext.GetChannels(), 1); fifo == nil {
fmt.Fprintf(os.Stderr, "Could not allocate FIFO\n")
return nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
return fifo, 0
}
// Write the header of the output file container.
func writeOutputFileHeader(outputFormatContext *ffmpeg.AvFormatContext) int32 {
func writeOutputFileHeader(outputFormatContext *ffmpeg.AVFormatContext) int32 {
if ret := ffmpeg.AvFormatWriteHeader(outputFormatContext, nil); ret < 0 {
fmt.Fprintf(os.Stderr, "Could not write output file header (error '%s')\n", ffmpeg.AvErr2str(ret))
return ret
@@ -253,9 +253,9 @@ func writeOutputFileHeader(outputFormatContext *ffmpeg.AvFormatContext) int32 {
}
// Decode one audio frame from the input file.
func decodeAudioFrame(frame *ffmpeg.AvFrame,
inputFormatContext *ffmpeg.AvFormatContext,
inputCodecContext *ffmpeg.AvCodecContext) (dataPresent, finished, ret int32) {
func decodeAudioFrame(frame *ffmpeg.AVFrame,
inputFormatContext *ffmpeg.AVFormatContext,
inputCodecContext *ffmpeg.AVCodecContext) (dataPresent, finished, ret int32) {
// Packet used for temporary storage.
inputPacket, ret := initPacket()
if ret < 0 {
@@ -285,7 +285,7 @@ func decodeAudioFrame(frame *ffmpeg.AvFrame,
switch {
// If the decoder asks for more data to be able to decode a frame,
// return indicating that no data is present.
case ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)):
case ret == ffmpeg.AVERROR(syscall.EAGAIN):
ret = 0
goto cleanup
// If the end of the input file is reached, stop decoding.
@@ -310,16 +310,16 @@ cleanup:
// Initialize a temporary storage for the specified number of audio samples.
// The conversion requires temporary storage due to the different format.
// The number of audio samples to be allocated is specified in frame_size.
func initConvertedSamples(outputCodecContext *ffmpeg.AvCodecContext,
func initConvertedSamples(outputCodecContext *ffmpeg.AVCodecContext,
frameSize int32) (convertedInputSamples **uint8, ret int32) {
// Allocate as many pointers as there are audio channels.
// Each pointer will later point to the audio samples of the corresponding
// channels (although it may be NULL for interleaved formats).
if convertedInputSamples = (**uint8)(ffmpeg.AvCalloc(uint(outputCodecContext.GetChannels()),
uint(unsafe.Sizeof(*convertedInputSamples)))); convertedInputSamples == nil {
if convertedInputSamples = (**uint8)(ffmpeg.AvCalloc(outputCodecContext.GetChannels(),
unsafe.Sizeof(*convertedInputSamples))); convertedInputSamples == nil {
fmt.Fprintf(os.Stderr, "Could not allocate converted input sample pointers\n")
return nil, ffmpeg.AVERROR(int32(syscall.ENOMEM))
return nil, ffmpeg.AVERROR(syscall.ENOMEM)
}
// Allocate memory for the samples of all channels in one consecutive
@@ -329,7 +329,7 @@ func initConvertedSamples(outputCodecContext *ffmpeg.AvCodecContext,
frameSize,
outputCodecContext.GetSampleFmt(), 0); ret < 0 {
fmt.Fprintf(os.Stderr, "Could not allocate converted input samples (error '%s')\n", ffmpeg.AvErr2str(ret))
ffmpeg.AvFreep(unsafe.Pointer(&convertedInputSamples))
ffmpeg.AvFreep(&convertedInputSamples)
return nil, ret
}
return convertedInputSamples, 0
@@ -340,9 +340,7 @@ func initConvertedSamples(outputCodecContext *ffmpeg.AvCodecContext,
// specified by frame_size.
func convertSamples(inputData, convertedData **uint8,
frameSize int32, resampleContext *ffmpeg.SwrContext) (ret int32) {
if ret = ffmpeg.SwrConvert(resampleContext,
convertedData, frameSize,
inputData, frameSize); ret < 0 {
if ret = ffmpeg.SwrConvert(resampleContext, convertedData, frameSize, inputData, frameSize); ret < 0 {
fmt.Fprintf(os.Stderr, "Could not convert input samples (error '%s')\n", ffmpeg.AvErr2str(ret))
return ret
}
@@ -350,7 +348,7 @@ func convertSamples(inputData, convertedData **uint8,
}
// Add converted input audio samples to the FIFO buffer for later processing.
func addSamplesToFifo(fifo *ffmpeg.AvAudioFifo, convertedInputSamples **uint8, frameSize int32) int32 {
func addSamplesToFifo(fifo *ffmpeg.AVAudioFifo, convertedInputSamples **uint8, frameSize int32) int32 {
// Make the FIFO as large as it needs to be to hold both,
// the old and the new samples.
if ret := ffmpeg.AvAudioFifoRealloc(fifo, ffmpeg.AvAudioFifoSize(fifo)+frameSize); ret < 0 {
@@ -359,8 +357,7 @@ func addSamplesToFifo(fifo *ffmpeg.AvAudioFifo, convertedInputSamples **uint8, f
}
// Store the new samples in the FIFO buffer.
if ret := ffmpeg.AvAudioFifoWrite(fifo, (*unsafe.Pointer)(unsafe.Pointer(convertedInputSamples)),
frameSize); ret < frameSize {
if ret := ffmpeg.AvAudioFifoWrite(fifo, convertedInputSamples, frameSize); ret < frameSize {
fmt.Fprintf(os.Stderr, "Could not write data to FIFO\n")
return ffmpeg.AVERROR_EXIT
}
@@ -368,14 +365,14 @@ func addSamplesToFifo(fifo *ffmpeg.AvAudioFifo, convertedInputSamples **uint8, f
}
// Read one audio frame from the input file, decode, convert and store it in the FIFO buffer.
func readDecodeConvertAndStore(fifo *ffmpeg.AvAudioFifo,
inputFormatContext *ffmpeg.AvFormatContext,
inputCodecContext *ffmpeg.AvCodecContext,
outputCodecContext *ffmpeg.AvCodecContext,
func readDecodeConvertAndStore(fifo *ffmpeg.AVAudioFifo,
inputFormatContext *ffmpeg.AVFormatContext,
inputCodecContext *ffmpeg.AVCodecContext,
outputCodecContext *ffmpeg.AVCodecContext,
resamplerContext *ffmpeg.SwrContext) (finished, ret int32) {
// Temporary storage of the input samples of the frame read from the file.
var inputFrame *ffmpeg.AvFrame
var inputFrame *ffmpeg.AVFrame
// Temporary storage for the converted input samples.
var convertedInputSamples **uint8
var dataPresent int32
@@ -423,7 +420,7 @@ func readDecodeConvertAndStore(fifo *ffmpeg.AvAudioFifo,
cleanup:
if convertedInputSamples != nil {
ffmpeg.AvFreep(unsafe.Pointer(&convertedInputSamples))
ffmpeg.AvFreep(&convertedInputSamples)
}
ffmpeg.AvFrameFree(&inputFrame)
@@ -431,8 +428,8 @@ cleanup:
}
// Initialize one input frame for writing to the output file.
func initOutputFrame(outputcodecContext *ffmpeg.AvCodecContext,
frameSize int32) (frame *ffmpeg.AvFrame, ret int32) {
func initOutputFrame(outputcodecContext *ffmpeg.AVCodecContext,
frameSize int32) (frame *ffmpeg.AVFrame, ret int32) {
// Create a new frame to store the audio samples.
if frame = ffmpeg.AvFrameAlloc(); frame == nil {
@@ -465,11 +462,11 @@ func initOutputFrame(outputcodecContext *ffmpeg.AvCodecContext,
var pts int64
// Encode one frame worth of audio to the output file.
func encodeAudioFrame(frame *ffmpeg.AvFrame,
outputFormatContext *ffmpeg.AvFormatContext,
outputCodecContext *ffmpeg.AvCodecContext) (dataPresent, ret int32) {
func encodeAudioFrame(frame *ffmpeg.AVFrame,
outputFormatContext *ffmpeg.AVFormatContext,
outputCodecContext *ffmpeg.AVCodecContext) (dataPresent, ret int32) {
// Packet used for temporary storage.
var outputPacket *ffmpeg.AvPacket
var outputPacket *ffmpeg.AVPacket
if outputPacket, ret = initPacket(); ret < 0 {
return dataPresent, ret
@@ -496,7 +493,7 @@ func encodeAudioFrame(frame *ffmpeg.AvFrame,
ret = ffmpeg.AvCodecReceivePacket(outputCodecContext, outputPacket)
// If the encoder asks for more data to be able to provide an
// encoded frame, return indicating that no data is present.
if ret == ffmpeg.AVERROR(int32(syscall.EAGAIN)) {
if ret == ffmpeg.AVERROR(syscall.EAGAIN) {
ret = 0
goto cleanup
} else if ret == ffmpeg.AVERROR_EOF {
@@ -525,11 +522,11 @@ cleanup:
}
// Load one audio frame from the FIFO buffer, encode and write it to the output file.
func loadEncodeAndWrite(fifo *ffmpeg.AvAudioFifo,
outputFormatContext *ffmpeg.AvFormatContext,
outputCodecContext *ffmpeg.AvCodecContext) (ret int32) {
func loadEncodeAndWrite(fifo *ffmpeg.AVAudioFifo,
outputFormatContext *ffmpeg.AVFormatContext,
outputCodecContext *ffmpeg.AVCodecContext) (ret int32) {
// Temporary storage of the output samples of the frame written to the file.
var outputFrame *ffmpeg.AvFrame
var outputFrame *ffmpeg.AVFrame
// Use the maximum number of possible samples per frame.
// If there is less than the maximum possible frame size in the FIFO
// buffer use this number. Otherwise, use the maximum possible frame size.
@@ -542,8 +539,7 @@ func loadEncodeAndWrite(fifo *ffmpeg.AvAudioFifo,
// Read as many samples from the FIFO buffer as required to fill the frame.
// The samples are stored in the frame temporarily.
if ret = ffmpeg.AvAudioFifoRead(fifo,
(*unsafe.Pointer)(unsafe.Pointer(outputFrame.GetData())), frameSize); ret < frameSize {
if ret = ffmpeg.AvAudioFifoRead(fifo, outputFrame.GetData(), frameSize); ret < frameSize {
fmt.Fprintf(os.Stderr, "Could not read data from FIFO\n")
ffmpeg.AvFrameFree(&outputFrame)
return ffmpeg.AVERROR_EXIT
@@ -560,7 +556,7 @@ func loadEncodeAndWrite(fifo *ffmpeg.AvAudioFifo,
}
// Write the trailer of the output file container.
func writeOutputFileTrailer(outputFormatContext *ffmpeg.AvFormatContext) int32 {
func writeOutputFileTrailer(outputFormatContext *ffmpeg.AVFormatContext) int32 {
if ret := ffmpeg.AvWriteTrailer(outputFormatContext); ret < 0 {
fmt.Fprintf(os.Stderr, "Could not write output file trailer (error '%s')\n", ffmpeg.AvErr2str(ret))
return ret
@@ -570,12 +566,12 @@ func writeOutputFileTrailer(outputFormatContext *ffmpeg.AvFormatContext) int32 {
func main() {
var ret int32 = ffmpeg.AVERROR_EXIT
var inputFormatContext *ffmpeg.AvFormatContext
var inputCodecContext *ffmpeg.AvCodecContext
var outputFormatContext *ffmpeg.AvFormatContext
var outputCodecContext *ffmpeg.AvCodecContext
var inputFormatContext *ffmpeg.AVFormatContext
var inputCodecContext *ffmpeg.AVCodecContext
var outputFormatContext *ffmpeg.AVFormatContext
var outputCodecContext *ffmpeg.AVCodecContext
var resampleContext *ffmpeg.SwrContext
var fifo *ffmpeg.AvAudioFifo
var fifo *ffmpeg.AVAudioFifo
if len(os.Args) != 3 {
fmt.Fprintf(os.Stdout, "Usage: %s <input file> <output file>\n", os.Args[0])

70
ffmpeg_helper.go
View File

@@ -5,6 +5,7 @@ package ffmpeg
*/
import "C"
import (
"reflect"
"unsafe"
)
@@ -31,12 +32,69 @@ func StringCasting(str string) (allocPtr *C.char, freeFunc func()) {
return allocPtr, freeFunc
}
// SliceWithOffset returns a []byte slice from a porinter with size.
func Slice[T HelperInteger](data *uint8, size T) []byte {
return unsafe.Slice(data, size)
// SliceWithOffset returns a []byte slice from a porinter with offset and size.
func ByteSliceWithOffset[X any, Y, Z HelperInteger](data *X, offset Y, size Z) []byte {
return unsafe.Slice((*byte)(unsafe.Add(unsafe.Pointer(uintptr(unsafe.Pointer(data))), offset)), size)
}
// SliceWithOffset returns a []byte slice from a porinter with offset and size.
func SliceWithOffset[U, V HelperInteger](data *uint8, offset U, size V) []byte {
return unsafe.Slice((*uint8)(unsafe.Add(unsafe.Pointer(uintptr(unsafe.Pointer(data))), offset)), size)
// Slice returns a []byte slice from a porinter with size.
func ByteSlice[U any, V HelperInteger](data *U, size V) []byte {
return ByteSliceWithOffset(data, 0, size)
}
// PointerOffset offset the pointer point.
func PointerOffset[U any, V HelperInteger](ptr *U, offset V) *U {
if ptr == nil {
return nil
}
return (*U)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))*(uintptr(offset))))
}
// TruncSlice return a slice from a sign-terminated array.
func TruncSlice[T any](ptr *T, fn func(T) bool) []T {
if ptr == nil {
return nil
}
for i := 0; ; i++ {
if fn(*(*T)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))*uintptr(i)))) {
return unsafe.Slice(ptr, i)
}
}
}
// TruncStringSlice returns a string slice from a NULL-terminated *C.char array.
func TruncStringSlice(ptr **C.char) (v []string) {
if ptr == nil {
return nil
}
for *ptr != nil && **ptr != C.char(0x00) {
v = append(v, C.GoString(*ptr))
ptr = (**C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) +
uintptr(unsafe.Sizeof(*ptr))))
}
return v
}
// CVoidPointer represents a (void*) type pointer in the C world.
type CVoidPointer any
// VoidPointer returns a unsafe.Pointer from CVoidPointer.
func VoidPointer(a CVoidPointer) unsafe.Pointer {
if a == nil {
return nil
}
return unsafe.Pointer(reflect.ValueOf(a).Pointer())
}
// CVoidPointer represents a (void**) type pointer in the C world.
type CVoidPointerPointer any
// VoidPointerPointer returns a *unsafe.Pointer from CVoidPointerPointer.
func VoidPointerPointer(a CVoidPointerPointer) *unsafe.Pointer {
if a == nil {
return nil
}
return (*unsafe.Pointer)(unsafe.Pointer(reflect.ValueOf(a).Pointer()))
}

42
ffmpeg_pointer.go
View File

@@ -1,42 +0,0 @@
package ffmpeg
/*
#include <stdlib.h>
*/
import "C"
import (
"sync"
"unsafe"
)
var (
pointerSyncMap sync.Map
)
func PointerStore(v interface{}) unsafe.Pointer {
if v == nil {
return nil
}
ptr := C.malloc(C.size_t(1))
if ptr == nil {
panic("allocate memory failed")
}
pointerSyncMap.Store(ptr, v)
return ptr
}
func PointerLoad(ptr unsafe.Pointer) (v interface{}) {
if ptr == nil {
return nil
}
v, _ = pointerSyncMap.Load(ptr)
return v
}
func PointerDelete(ptr unsafe.Pointer) {
if ptr == nil {
return
}
pointerSyncMap.Delete(ptr)
C.free(ptr)
}

8
postproc.go
View File

@@ -35,11 +35,11 @@ func PpPostprocess(src []*uint8, srcStride []int32,
horizontalSize, verticalSize int32,
QPStore *int8, QPStride int32,
ppMode *PpMode, ppContext *PpContext, pictType int32) {
if len(src) != 3 {
panic("src need len = 3")
if len(src) < 3 {
panic("src len < 3")
}
if len(dst) != 3 {
panic("dst need len = 3")
if len(dst) < 3 {
panic("dst len < 3")
}
C.pp_postprocess((**C.uint8_t)(unsafe.Pointer(&src[0])), (*C.int)(&srcStride[0]),
(**C.uint8_t)(unsafe.Pointer(&dst[0])), (*C.int)(&dstStride[0]),

22
swresample.go
View File

@@ -51,9 +51,9 @@ const (
type SwrContext C.struct_SwrContext
// SwrGetClass gets the AVClass for SwrContext. It can be used in combination with
// AV_OPT_SEARCH_FAKE_OBJ for examining options.
func SwrGetClass() *AvClass {
return (*AvClass)(C.swr_get_class())
// Av_OPT_SEARCH_FAKE_OBJ for examining options.
func SwrGetClass() *AVClass {
return (*AVClass)(C.swr_get_class())
}
// SwrAlloc allocates SwrContext.
@@ -73,13 +73,13 @@ func SwrIsInitialized(s *SwrContext) int32 {
// SwrAllocSetOpts allocates SwrContext if needed and set/reset common parameters.
func SwrAllocSetOpts(s *SwrContext,
outChLayout int64, outSampleFmt AvSampleFormat, outSampleRate int32,
inChLayout int64, inSampleFmt AvSampleFormat, inSampleRate int32,
logOffset int32, logCtx unsafe.Pointer) *SwrContext {
outChLayout int64, outSampleFmt AVSampleFormat, outSampleRate int32,
inChLayout int64, inSampleFmt AVSampleFormat, inSampleRate int32,
logOffset int32, logCtx CVoidPointer) *SwrContext {
return (*SwrContext)(C.swr_alloc_set_opts((*C.struct_SwrContext)(s),
(C.int64_t)(outChLayout), (C.enum_AVSampleFormat)(outSampleFmt), (C.int)(outSampleRate),
(C.int64_t)(inChLayout), (C.enum_AVSampleFormat)(inSampleFmt), (C.int)(inSampleRate),
(C.int)(logOffset), logCtx))
(C.int)(logOffset), VoidPointer(logCtx)))
}
// SwrFree frees the given SwrContext and set the pointer to NULL.
@@ -121,11 +121,11 @@ func SwrSetChannelMapping(s *SwrContext, channelMap *int32) int32 {
func SwrBuildMatrix(inLayout, outLayout uint64,
centerMixLevel, surroundMixLevel, lfeMixLevel float64,
rematrixMaxval, rematrixVolume float64,
matrix *float64, stride int32, matrixEncoding AvMatrixEncoding, logCtx unsafe.Pointer) int32 {
matrix *float64, stride int32, matrixEncoding AVMatrixEncoding, logCtx CVoidPointer) int32 {
return (int32)(C.swr_build_matrix((C.uint64_t)(inLayout), (C.uint64_t)(outLayout),
(C.double)(centerMixLevel), (C.double)(surroundMixLevel), (C.double)(lfeMixLevel),
(C.double)(rematrixMaxval), (C.double)(rematrixVolume),
(*C.double)(matrix), (C.int)(stride), (C.enum_AVMatrixEncoding)(matrixEncoding), logCtx))
(*C.double)(matrix), (C.int)(stride), (C.enum_AVMatrixEncoding)(matrixEncoding), VoidPointer(logCtx)))
}
// SwrSetMatrix sets a customized remix matrix.
@@ -170,13 +170,13 @@ func SwResampleLicense() string {
}
// SwrConvertFrame converts the samples in the input AVFrame and write them to the output AVFrame.
func SwrConvertFrame(s *SwrContext, output, input *AvFrame) int32 {
func SwrConvertFrame(s *SwrContext, output, input *AVFrame) int32 {
return (int32)(C.swr_convert_frame((*C.struct_SwrContext)(s),
(*C.struct_AVFrame)(output), (*C.struct_AVFrame)(input)))
}
// SwrConfigFrame configures or reconfigure the SwrContext using the information provided by the AVFrames.
func SwrConfigFrame(s *SwrContext, out, in *AvFrame) int32 {
func SwrConfigFrame(s *SwrContext, out, in *AVFrame) int32 {
return (int32)(C.swr_config_frame((*C.struct_SwrContext)(s),
(*C.struct_AVFrame)(out), (*C.struct_AVFrame)(in)))
}

126
swscale.go
View File

@@ -75,25 +75,115 @@ func SwsGetCoefficients(colorspace int32) *int32 {
// SwsVector
type SwsVector C.struct_SwsVector
// Custom: GetCoeff gets `SwsVector.coeff` value.
func (sv *SwsVector) GetCoeff() *float64 {
return (*float64)(sv.coeff)
}
// Custom: SetCoeff sets `SwsVector.coeff` value.
func (sv *SwsVector) SetCoeff(v *float64) {
sv.coeff = (*C.double)(v)
}
// Custom: GetCoeffAddr gets `SwsVector.coeff` address.
func (sv *SwsVector) GetCoeffAddr() **float64 {
return (**float64)(unsafe.Pointer(&sv.coeff))
}
// Custom: GetLength gets `SwsVector.length` value.
func (sv *SwsVector) GetLength() int32 {
return (int32)(sv.length)
}
// Custom: SetLength sets `SwsVector.length` value.
func (sv *SwsVector) SetLength(v int32) {
sv.length = (C.int)(v)
}
// Custom: GetLengthAddr gets `SwsVector.length` address.
func (sv *SwsVector) GetLengthAddr() *int32 {
return (*int32)(&sv.length)
}
// SwsFilter
type SwsFilter C.struct_SwsFilter
// Custom: GetLumH gets `SwsFilter.lumH` value.
func (sf *SwsFilter) GetLumH() *SwsVector {
return (*SwsVector)(sf.lumH)
}
// Custom: SetLumH sets `SwsFilter.lumH` value.
func (sf *SwsFilter) SetLumH(v *SwsVector) {
sf.lumH = (*C.struct_SwsVector)(v)
}
// Custom: GetLumHAddr gets `SwsFilter.lumH` address.
func (sf *SwsFilter) GetLumHAddr() **SwsVector {
return (**SwsVector)(unsafe.Pointer(&sf.lumH))
}
// Custom: GetLumV gets `SwsFilter.lumV` value.
func (sf *SwsFilter) GetLumV() *SwsVector {
return (*SwsVector)(sf.lumV)
}
// Custom: SetLumV sets `SwsFilter.lumV` value.
func (sf *SwsFilter) SetLumV(v *SwsVector) {
sf.lumV = (*C.struct_SwsVector)(v)
}
// Custom: GetLumVAddr gets `SwsFilter.lumV` address.
func (sf *SwsFilter) GetLumVAddr() **SwsVector {
return (**SwsVector)(unsafe.Pointer(&sf.lumV))
}
// Custom: GetChrH gets `SwsFilter.chrH` value.
func (sf *SwsFilter) GetChrH() *SwsVector {
return (*SwsVector)(sf.chrH)
}
// Custom: SetChrH sets `SwsFilter.chrH` value.
func (sf *SwsFilter) SetChrH(v *SwsVector) {
sf.chrH = (*C.struct_SwsVector)(v)
}
// Custom: GetChrHAddr gets `SwsFilter.chrH` address.
func (sf *SwsFilter) GetChrHAddr() **SwsVector {
return (**SwsVector)(unsafe.Pointer(&sf.chrH))
}
// Custom: GetChrV gets `SwsFilter.chrV` value.
func (sf *SwsFilter) GetChrV() *SwsVector {
return (*SwsVector)(sf.chrV)
}
// Custom: SetChrV sets `SwsFilter.chrV` value.
func (sf *SwsFilter) SetChrV(v *SwsVector) {
sf.chrV = (*C.struct_SwsVector)(v)
}
// Custom: GetChrVAddr gets `SwsFilter.chrV` address.
func (sf *SwsFilter) GetChrVAddr() **SwsVector {
return (**SwsVector)(unsafe.Pointer(&sf.chrV))
}
// SwsContext
type SwsContext C.struct_SwsContext
// SwsIsSupportedInput returns a positive value if pix_fmt is a supported input format.
func SwsIsSupportedInput(pixFmt AvPixelFormat) int32 {
func SwsIsSupportedInput(pixFmt AVPixelFormat) int32 {
return (int32)(C.sws_isSupportedInput((C.enum_AVPixelFormat)(pixFmt)))
}
// SwsIsSupportedOutput returns a positive value if pix_fmt is a supported output format.
func SwsIsSupportedOutput(pixFmt AvPixelFormat) int32 {
func SwsIsSupportedOutput(pixFmt AVPixelFormat) int32 {
return (int32)(C.sws_isSupportedOutput((C.enum_AVPixelFormat)(pixFmt)))
}
// SwsIsSupportedEndiannessConversion returns a positive value
// if pix_fmt is a supported endianness conversion format.
func SwsIsSupportedEndiannessConversion(pixFmt AvPixelFormat) int32 {
func SwsIsSupportedEndiannessConversion(pixFmt AVPixelFormat) int32 {
return (int32)(C.sws_isSupportedEndiannessConversion((C.enum_AVPixelFormat)(pixFmt)))
}
@@ -114,8 +204,8 @@ func SwsFreeContext(sctx *SwsContext) {
}
// SwsGetcontext allocates and returns an SwsContext.
func SwsGetContext(srcW, srcH int32, srcFormat AvPixelFormat,
dstW, dstH int32, dstFormat AvPixelFormat,
func SwsGetContext(srcW, srcH int32, srcFormat AVPixelFormat,
dstW, dstH int32, dstFormat AVPixelFormat,
flags int32, srcFilter, dstFilter *SwsFilter, param *float64) *SwsContext {
return (*SwsContext)(C.sws_getContext((C.int)(srcW), (C.int)(srcH), (C.enum_AVPixelFormat)(srcFormat),
(C.int)(dstW), (C.int)(dstH), (C.enum_AVPixelFormat)(dstFormat),
@@ -137,11 +227,11 @@ func SwsScale(sctx *SwsContext, srcSlice []*uint8, srcStride []int32,
// SwsSetColorspaceDetails
func SwsSetColorSpaceDetails(sctx *SwsContext, invTable []int32, srcRange int32,
table []int32, dstRange int32, brightness, contrast, saturation int32) int32 {
if len(invTable) != 4 {
panic("invTable need len = 4")
if len(invTable) < 4 {
panic("invTable len < 4")
}
if len(table) != 4 {
panic("table need len = 4")
if len(table) < 4 {
panic("table len < 4")
}
return (int32)(C.sws_setColorspaceDetails((*C.struct_SwsContext)(sctx),
(*C.int)(unsafe.Pointer(&invTable[0])), (C.int)(srcRange),
@@ -152,11 +242,11 @@ func SwsSetColorSpaceDetails(sctx *SwsContext, invTable []int32, srcRange int32,
// SwsGetColorSpaceDetails
func SwsGetColorSpaceDetails(sctx *SwsContext, invTable []int32, srcRange *int32,
table []int32, dstRange *int32, brightness, contrast, saturation *int32) int32 {
if len(invTable) != 4 {
panic("invTable need len = 4")
if len(invTable) < 4 {
panic("invTable len < 4")
}
if len(table) != 4 {
panic("table need len = 4")
if len(table) < 4 {
panic("table len = 4")
}
invTablePtr := unsafe.Pointer(&invTable[0])
tablePtr := unsafe.Pointer(&table[0])
@@ -222,7 +312,7 @@ func SwsCloneVec(a *SwsVector) *SwsVector {
}
// Deprecated: No use
func SwsPrintVec2(a *SwsVector, logCtx *AvClass, logLevel int32) {
func SwsPrintVec2(a *SwsVector, logCtx *AVClass, logLevel int32) {
C.sws_printVec2((*C.struct_SwsVector)(a),
(*C.struct_AVClass)(logCtx), (C.int)(logLevel))
}
@@ -248,8 +338,8 @@ func SwsFreeFilter(filter *SwsFilter) {
// SwsGetCachedContext check if context can be reused, otherwise reallocate a new one.
func SwsGetCachedContext(context *SwsContext,
srcW, srcH int32, srcFormat AvPixelFormat,
dstW, dstH int32, dstFormat AvPixelFormat,
srcW, srcH int32, srcFormat AVPixelFormat,
dstW, dstH int32, dstFormat AVPixelFormat,
flags int32, srcFilter, dstFilter *SwsFilter, param *float64) *SwsContext {
return (*SwsContext)(C.sws_getCachedContext((*C.struct_SwsContext)(context),
(C.int)(srcW), (C.int)(srcH), (C.enum_AVPixelFormat)(srcFormat),
@@ -271,6 +361,6 @@ func SwsConvertPalette8ToPacked24(src, dst *uint8, numPixels int32, palette *uin
}
// SwsGetClass gets the AVClass for swsContext.
func SwsGetClass() *AvClass {
return (*AvClass)(C.sws_get_class())
func SwsGetClass() *AVClass {
return (*AVClass)(C.sws_get_class())
}