From 9b09e3417f2ac0c51d3fa80a16b20879ad21561c Mon Sep 17 00:00:00 2001 From: aggresss Date: Sat, 18 Nov 2023 10:51:33 +0800 Subject: [PATCH] 2023-11-18 10:51:33 CST W46D6 --- avcodec.go | 51 ++++++-- avcodec_avfft.go | 18 +++ avcodec_codec.go | 17 +-- avcodec_codec_desc.go | 1 + avcodec_codec_id.go | 6 + avcodec_codec_par.go | 58 ++++++++-- avcodec_defs.go | 127 ++++++++++++++++++++ avcodec_packet.go | 39 +++++++ avdevice.go | 3 - avfilter.go | 10 +- avformat.go | 39 ++++--- avformat_avio.go | 164 +++++++++++++++++++++++--- avutil_channel_layout.go | 96 +++++++++------ avutil_executor.go | 141 ++++++++++++++++++++++ avutil_frame.go | 48 ++++++-- avutil_hdr_dynamic_metadata.go | 16 +++ avutil_hdr_dynamic_vivid_metadata.go | 146 +++++++++++++++++++++++ avutil_hwcontext_cuda.go | 1 + avutil_imgutils.go | 6 + avutil_mathematics.go | 5 + avutil_opt.go | 3 - avutil_pixfmt.go | 9 ++ avutil_random_seed.go | 5 + avutil_tx.go | 8 +- avutil_video_hint.go | 167 +++++++++++++++++++++++++++ 25 files changed, 1059 insertions(+), 125 deletions(-) create mode 100644 avutil_executor.go create mode 100644 avutil_video_hint.go diff --git a/avcodec.go b/avcodec.go index 54d3e83..2165320 100644 --- a/avcodec.go +++ b/avcodec.go @@ -64,7 +64,9 @@ const ( AV_CODEC_FLAG_4MV = C.AV_CODEC_FLAG_4MV AV_CODEC_FLAG_OUTPUT_CORRUPT = C.AV_CODEC_FLAG_OUTPUT_CORRUPT AV_CODEC_FLAG_QPEL = C.AV_CODEC_FLAG_QPEL - AV_CODEC_FLAG_DROPCHANGED = C.AV_CODEC_FLAG_DROPCHANGED + + // Deprecated: callers should implement this functionality in their own code. + AV_CODEC_FLAG_DROPCHANGED = C.AV_CODEC_FLAG_DROPCHANGED AV_CODEC_FLAG_RECON_FRAME = C.AV_CODEC_FLAG_RECON_FRAME AV_CODEC_FLAG_COPY_OPAQUE = C.AV_CODEC_FLAG_COPY_OPAQUE @@ -368,16 +370,28 @@ func (avctx *AVCodecContext) GetTimeBaseAddr() *AVRational { return (*AVRational)(&avctx.time_base) } +// Deprecated: +// - decoding: Use AVCodecDescriptor.props & AV_CODEC_PROP_FIELDS instead. +// - encoding: Set AVCodecContext.framerate instead. +// // GetTicksPerFrame gets `AVCodecContext.ticks_per_frame` value. func (avctx *AVCodecContext) GetTicksPerFrame() int32 { return (int32)(avctx.ticks_per_frame) } +// Deprecated: +// - decoding: Use AVCodecDescriptor.props & AV_CODEC_PROP_FIELDS instead. +// - encoding: Set AVCodecContext.framerate instead. +// // SetTicksPerFrame sets `AVCodecContext.ticks_per_frame` value. func (avctx *AVCodecContext) SetTicksPerFrame(v int32) { avctx.ticks_per_frame = (C.int)(v) } +// Deprecated: +// - decoding: Use AVCodecDescriptor.props & AV_CODEC_PROP_FIELDS instead. +// - encoding: Set AVCodecContext.framerate instead. +// // GetTicksPerFrameAddr gets `AVCodecContext.ticks_per_frame` address. func (avctx *AVCodecContext) GetTicksPerFrameAddr() *int32 { return (*int32)(&avctx.ticks_per_frame) @@ -2047,6 +2061,7 @@ func (avctx *AVCodecContext) GetProfileAddr() *int32 { return (*int32)(&avctx.profile) } +// Deprecated: Use AV_PROFILE_* instead. const ( FF_PROFILE_UNKNOWN = int32(C.FF_PROFILE_UNKNOWN) FF_PROFILE_RESERVED = int32(C.FF_PROFILE_RESERVED) @@ -2069,12 +2084,18 @@ const ( FF_PROFILE_DNXHR_HQX = int32(C.FF_PROFILE_DNXHR_HQX) FF_PROFILE_DNXHR_444 = int32(C.FF_PROFILE_DNXHR_444) - FF_PROFILE_DTS = int32(C.FF_PROFILE_DTS) - FF_PROFILE_DTS_ES = int32(C.FF_PROFILE_DTS_ES) - FF_PROFILE_DTS_96_24 = int32(C.FF_PROFILE_DTS_96_24) - FF_PROFILE_DTS_HD_HRA = int32(C.FF_PROFILE_DTS_HD_HRA) - FF_PROFILE_DTS_HD_MA = int32(C.FF_PROFILE_DTS_HD_MA) - FF_PROFILE_DTS_EXPRESS = int32(C.FF_PROFILE_DTS_EXPRESS) + FF_PROFILE_DTS = int32(C.FF_PROFILE_DTS) + FF_PROFILE_DTS_ES = int32(C.FF_PROFILE_DTS_ES) + FF_PROFILE_DTS_96_24 = int32(C.FF_PROFILE_DTS_96_24) + FF_PROFILE_DTS_HD_HRA = int32(C.FF_PROFILE_DTS_HD_HRA) + FF_PROFILE_DTS_HD_MA = int32(C.FF_PROFILE_DTS_HD_MA) + FF_PROFILE_DTS_EXPRESS = int32(C.FF_PROFILE_DTS_EXPRESS) + FF_PROFILE_DTS_HD_MA_X = int32(C.FF_PROFILE_DTS_HD_MA_X) + FF_PROFILE_DTS_HD_MA_X_IMAX = int32(C.FF_PROFILE_DTS_HD_MA_X_IMAX) + + FF_PROFILE_EAC3_DDP_ATMOS = int32(C.FF_PROFILE_EAC3_DDP_ATMOS) + + FF_PROFILE_TRUEHD_ATMOS = int32(C.FF_PROFILE_TRUEHD_ATMOS) FF_PROFILE_MPEG2_422 = int32(C.FF_PROFILE_MPEG2_422) FF_PROFILE_MPEG2_HIGH = int32(C.FF_PROFILE_MPEG2_HIGH) @@ -2139,6 +2160,7 @@ const ( FF_PROFILE_HEVC_MAIN_10 = int32(C.FF_PROFILE_HEVC_MAIN_10) FF_PROFILE_HEVC_MAIN_STILL_PICTURE = int32(C.FF_PROFILE_HEVC_MAIN_STILL_PICTURE) FF_PROFILE_HEVC_REXT = int32(C.FF_PROFILE_HEVC_REXT) + FF_PROFILE_HEVC_SCC = int32(C.FF_PROFILE_HEVC_SCC) FF_PROFILE_VVC_MAIN_10 = int32(C.FF_PROFILE_VVC_MAIN_10) FF_PROFILE_VVC_MAIN_10_444 = int32(C.FF_PROFILE_VVC_MAIN_10_444) @@ -2167,6 +2189,9 @@ const ( FF_PROFILE_KLVA_SYNC = int32(C.FF_PROFILE_KLVA_SYNC) FF_PROFILE_KLVA_ASYNC = int32(C.FF_PROFILE_KLVA_ASYNC) + + FF_PROFILE_EVC_BASELINE = int32(C.FF_PROFILE_EVC_BASELINE) + FF_PROFILE_EVC_MAIN = int32(C.FF_PROFILE_EVC_MAIN) ) // GetLevel gets `AVCodecContext.level` value. @@ -2184,6 +2209,11 @@ func (avctx *AVCodecContext) GetLevelAddr() *int32 { return (*int32)(&avctx.level) } +const ( + // Deprecated: use AV_LEVEL_UNKOWN instead. + FF_LEVEL_UNKNOWN = int32(C.FF_LEVEL_UNKNOWN) +) + // GetSkipLoopFilter gets `AVCodecContext.skip_loop_filter` value. func (avctx *AVCodecContext) GetSkipLoopFilter() AVDiscard { return (AVDiscard)(avctx.skip_loop_filter) @@ -2508,8 +2538,8 @@ const ( ) // GetCodedSideData gets `AVCodecContext.coded_side_data` value. -func (avctx *AVCodecContext) GetCodedSideData() *AVPacketSideData { - return (*AVPacketSideData)(avctx.coded_side_data) +func (avctx *AVCodecContext) GetCodedSideData() []AVPacketSideData { + return unsafe.Slice((*AVPacketSideData)(avctx.coded_side_data), avctx.nb_coded_side_data) } // SetCodedSideData sets `AVCodecContext.coded_side_data` value. @@ -3019,9 +3049,6 @@ func (sbt *AVSubtitle) GetNumRectsAddr() *uint32 { // GetRects gets `AVSubtitle.rects` value. func (sbt *AVSubtitle) GetRects() []*AVSubtitleRect { - if sbt.rects == nil { - return nil - } return unsafe.Slice((**AVSubtitleRect)(unsafe.Pointer(sbt.rects)), sbt.num_rects) } diff --git a/avcodec_avfft.go b/avcodec_avfft.go index 09edad0..edd361b 100644 --- a/avcodec_avfft.go +++ b/avcodec_avfft.go @@ -33,16 +33,22 @@ func AvFftInit(nbits, inverse int32) *FFTContext { return (*FFTContext)(C.av_fft_init((C.int)(nbits), (C.int)(inverse))) } +// Deprecated: No use. +// // AvFftPermute does the permutation needed BEFORE calling FfFftCalc(). func AvFftPermute(s *FFTContext, z *FFTComplex) { C.av_fft_permute((*C.struct_FFTContext)(s), (*C.struct_FFTComplex)(z)) } +// Deprecated: No use. +// // FfFftCalc does a complex FFT with the parameters defined in AvFftInit(). func FfFftCalc(s *FFTContext, z *FFTComplex) { C.av_fft_calc((*C.struct_FFTContext)(s), (*C.struct_FFTComplex)(z)) } +// Deprecated: No use. +// // AvFftEnd func AvFftEnd(s *FFTContext) { C.av_fft_end((*C.struct_FFTContext)(s)) @@ -61,17 +67,23 @@ const ( // RDFTContext type RDFTContext C.struct_RDFTContext +// Deprecated: No use. +// // AvRdftInit func AvRdftInit(nbits int32, trans RDFTransformType) *RDFTContext { return (*RDFTContext)(C.av_rdft_init((C.int)(nbits), (C.enum_RDFTransformType)(trans))) } +// Deprecated: No use. +// // AvRdftCalc func AvRdftCalc(r *RDFTContext, data *FFTSample) { C.av_rdft_calc((*C.struct_RDFTContext)(r), (*C.FFTSample)(data)) } +// Deprecated: No use. +// // AvRdftEnd func AvRdftEnd(r *RDFTContext) { C.av_rdft_end((*C.struct_RDFTContext)(r)) @@ -90,17 +102,23 @@ const ( DST_I = DCTTransformType(C.DST_I) ) +// Deprecated: No use. +// // AvDctInit func AvDctInit(nbits int32, _type RDFTransformType) *DCTContext { return (*DCTContext)(C.av_dct_init((C.int)(nbits), (C.enum_RDFTransformType)(_type))) } +// Deprecated: No use. +// // AvDctCalc func AvDctCalc(d *DCTContext, data *FFTSample) { C.av_dct_calc((*C.struct_DCTContext)(d), (*C.FFTSample)(data)) } +// Deprecated: No use. +// // AvDctEnd func AvDctEnd(d *DCTContext) { C.av_dct_end((*C.struct_DCTContext)(d)) diff --git a/avcodec_codec.go b/avcodec_codec.go index 7d4e7fb..89dc740 100644 --- a/avcodec_codec.go +++ b/avcodec_codec.go @@ -15,13 +15,16 @@ const ( AV_CODEC_CAP_DELAY = C.AV_CODEC_CAP_DELAY AV_CODEC_CAP_SMALL_LAST_FRAME = C.AV_CODEC_CAP_SMALL_LAST_FRAME - AV_CODEC_CAP_SUBFRAMES = C.AV_CODEC_CAP_SUBFRAMES - AV_CODEC_CAP_EXPERIMENTAL = C.AV_CODEC_CAP_EXPERIMENTAL - AV_CODEC_CAP_CHANNEL_CONF = C.AV_CODEC_CAP_CHANNEL_CONF - AV_CODEC_CAP_FRAME_THREADS = C.AV_CODEC_CAP_FRAME_THREADS - AV_CODEC_CAP_SLICE_THREADS = C.AV_CODEC_CAP_SLICE_THREADS - AV_CODEC_CAP_PARAM_CHANGE = C.AV_CODEC_CAP_PARAM_CHANGE - AV_CODEC_CAP_OTHER_THREADS = C.AV_CODEC_CAP_OTHER_THREADS + + // Deprecated: no use. + AV_CODEC_CAP_SUBFRAMES = C.AV_CODEC_CAP_SUBFRAMES + + AV_CODEC_CAP_EXPERIMENTAL = C.AV_CODEC_CAP_EXPERIMENTAL + AV_CODEC_CAP_CHANNEL_CONF = C.AV_CODEC_CAP_CHANNEL_CONF + AV_CODEC_CAP_FRAME_THREADS = C.AV_CODEC_CAP_FRAME_THREADS + AV_CODEC_CAP_SLICE_THREADS = C.AV_CODEC_CAP_SLICE_THREADS + AV_CODEC_CAP_PARAM_CHANGE = C.AV_CODEC_CAP_PARAM_CHANGE + AV_CODEC_CAP_OTHER_THREADS = C.AV_CODEC_CAP_OTHER_THREADS AV_CODEC_CAP_VARIABLE_FRAME_SIZE = C.AV_CODEC_CAP_VARIABLE_FRAME_SIZE AV_CODEC_CAP_AVOID_PROBING = C.AV_CODEC_CAP_AVOID_PROBING diff --git a/avcodec_codec_desc.go b/avcodec_codec_desc.go index db218d9..f903c66 100644 --- a/avcodec_codec_desc.go +++ b/avcodec_codec_desc.go @@ -54,6 +54,7 @@ const ( AV_CODEC_PROP_LOSSY = C.AV_CODEC_PROP_LOSSY AV_CODEC_PROP_LOSSLESS = C.AV_CODEC_PROP_LOSSLESS AV_CODEC_PROP_REORDER = C.AV_CODEC_PROP_REORDER + AV_CODEC_PROP_FIELDS = C.AV_CODEC_PROP_FIELDS AV_CODEC_PROP_BITMAP_SUB = C.AV_CODEC_PROP_BITMAP_SUB AV_CODEC_PROP_TEXT_SUB = C.AV_CODEC_PROP_TEXT_SUB ) diff --git a/avcodec_codec_id.go b/avcodec_codec_id.go index f1b0a93..2dce18b 100644 --- a/avcodec_codec_id.go +++ b/avcodec_codec_id.go @@ -284,6 +284,10 @@ const ( AV_CODEC_ID_WBMP = AVCodecID(C.AV_CODEC_ID_WBMP) AV_CODEC_ID_MEDIA100 = AVCodecID(C.AV_CODEC_ID_MEDIA100) AV_CODEC_ID_VQC = AVCodecID(C.AV_CODEC_ID_VQC) + AV_CODEC_ID_PDV = AVCodecID(C.AV_CODEC_ID_PDV) + AV_CODEC_ID_EVC = AVCodecID(C.AV_CODEC_ID_EVC) + AV_CODEC_ID_RTV1 = AVCodecID(C.AV_CODEC_ID_RTV1) + AV_CODEC_ID_VMIX = AVCodecID(C.AV_CODEC_ID_VMIX) // various PCM "codecs" AV_CODEC_ID_FIRST_AUDIO = AVCodecID(C.AV_CODEC_ID_FIRST_AUDIO) @@ -500,6 +504,8 @@ const ( AV_CODEC_ID_FTR = AVCodecID(C.AV_CODEC_ID_FTR) AV_CODEC_ID_WAVARC = AVCodecID(C.AV_CODEC_ID_WAVARC) AV_CODEC_ID_RKA = AVCodecID(C.AV_CODEC_ID_RKA) + AV_CODEC_ID_AC4 = AVCodecID(C.AV_CODEC_ID_AC4) + AV_CODEC_ID_OSQ = AVCodecID(C.AV_CODEC_ID_OSQ) // subtitle codecs AV_CODEC_ID_FIRST_SUBTITLE = AVCodecID(C.AV_CODEC_ID_FIRST_SUBTITLE) diff --git a/avcodec_codec_par.go b/avcodec_codec_par.go index a4c0acc..48041a0 100644 --- a/avcodec_codec_par.go +++ b/avcodec_codec_par.go @@ -10,18 +10,6 @@ package ffmpeg import "C" import "unsafe" -// 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) -) - // AVCodecParameters type AVCodecParameters C.struct_AVCodecParameters @@ -475,6 +463,52 @@ func (par *AVCodecParameters) GetChLayoutAddr() *AVChannelLayout { return (*AVChannelLayout)(&par.ch_layout) } +// GetFramerate gets `AVCodecParameters.framerate` value. +func (par *AVCodecParameters) GetFramerate() AVRational { + return (AVRational)(par.framerate) +} + +// SetFramerate sets `AVCodecParameters.framerate` value. +func (par *AVCodecParameters) SetFramerate(v AVRational) { + par.framerate = (C.struct_AVRational)(v) +} + +// GetFramerateAddr gets `AVCodecParameters.framerate` address. +func (par *AVCodecParameters) GetFramerateAddr() *AVRational { + return (*AVRational)(&par.framerate) +} + +// GetCodedSideData gets `AVCodecParameters.coded_side_data` value. +func (par *AVCodecParameters) GetCodedSideData() (v []AVPacketSideData) { + return unsafe.Slice((*AVPacketSideData)(unsafe.Pointer(par.coded_side_data)), + par.nb_coded_side_data) +} + +// SetCodedSideData sets `AVCodecParameters.coded_side_data` value. +func (par *AVCodecParameters) SetCodedSideData(v *AVPacketSideData) { + par.coded_side_data = (*C.struct_AVPacketSideData)(v) +} + +// GetCodedSideDataAddr gets `AVCodecParameters.coded_side_data` address. +func (par *AVCodecParameters) GetCodedSideDataAddr() **AVPacketSideData { + return (**AVPacketSideData)(unsafe.Pointer(&par.coded_side_data)) +} + +// GetNbCodedSideData gets `AVCodecParameters.nb_coded_side_data` value. +func (par *AVCodecParameters) GetNbCodedSideData() int32 { + return (int32)(par.nb_coded_side_data) +} + +// SetNbCodedSideData sets `AVCodecParameters.nb_coded_side_data` value. +func (par *AVCodecParameters) SetNbCodedSideData(v int32) { + par.nb_coded_side_data = (C.int)(v) +} + +// GetNbCodedSideDataAddr gets `AVCodecParameters.nb_coded_side_data` address. +func (par *AVCodecParameters) GetNbCodedSideDataAddr() *int32 { + return (*int32)(&par.nb_coded_side_data) +} + // 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 { diff --git a/avcodec_defs.go b/avcodec_defs.go index e8b4941..52d00e0 100644 --- a/avcodec_defs.go +++ b/avcodec_defs.go @@ -34,6 +34,133 @@ const ( FF_COMPLIANCE_EXPERIMENTAL = int32(C.FF_COMPLIANCE_EXPERIMENTAL) ) +const ( + AV_PROFILE_UNKNOWN = int32(C.AV_PROFILE_UNKNOWN) + AV_PROFILE_RESERVED = int32(C.AV_PROFILE_RESERVED) + AV_PROFILE_AAC_MAIN = int32(C.AV_PROFILE_AAC_MAIN) + AV_PROFILE_AAC_LOW = int32(C.AV_PROFILE_AAC_LOW) + AV_PROFILE_AAC_SSR = int32(C.AV_PROFILE_AAC_SSR) + AV_PROFILE_AAC_LTP = int32(C.AV_PROFILE_AAC_LTP) + AV_PROFILE_AAC_HE = int32(C.AV_PROFILE_AAC_HE) + AV_PROFILE_AAC_HE_V2 = int32(C.AV_PROFILE_AAC_HE_V2) + AV_PROFILE_AAC_LD = int32(C.AV_PROFILE_AAC_LD) + AV_PROFILE_AAC_ELD = int32(C.AV_PROFILE_AAC_ELD) + AV_PROFILE_MPEG2_AAC_LOW = int32(C.AV_PROFILE_MPEG2_AAC_LOW) + AV_PROFILE_MPEG2_AAC_HE = int32(C.AV_PROFILE_MPEG2_AAC_HE) + AV_PROFILE_DNXHD = int32(C.AV_PROFILE_DNXHD) + AV_PROFILE_DNXHR_LB = int32(C.AV_PROFILE_DNXHR_LB) + AV_PROFILE_DNXHR_SQ = int32(C.AV_PROFILE_DNXHR_SQ) + AV_PROFILE_DNXHR_HQ = int32(C.AV_PROFILE_DNXHR_HQ) + AV_PROFILE_DNXHR_HQX = int32(C.AV_PROFILE_DNXHR_HQX) + AV_PROFILE_DNXHR_444 = int32(C.AV_PROFILE_DNXHR_444) + AV_PROFILE_DTS = int32(C.AV_PROFILE_DTS) + AV_PROFILE_DTS_ES = int32(C.AV_PROFILE_DTS_ES) + AV_PROFILE_DTS_96_24 = int32(C.AV_PROFILE_DTS_96_24) + AV_PROFILE_DTS_HD_HRA = int32(C.AV_PROFILE_DTS_HD_HRA) + AV_PROFILE_DTS_HD_MA = int32(C.AV_PROFILE_DTS_HD_MA) + AV_PROFILE_DTS_EXPRESS = int32(C.AV_PROFILE_DTS_EXPRESS) + AV_PROFILE_DTS_HD_MA_X = int32(C.AV_PROFILE_DTS_HD_MA_X) + AV_PROFILE_DTS_HD_MA_X_IMAX = int32(C.AV_PROFILE_DTS_HD_MA_X_IMAX) + AV_PROFILE_EAC3_DDP_ATMOS = int32(C.AV_PROFILE_EAC3_DDP_ATMOS) + AV_PROFILE_TRUEHD_ATMOS = int32(C.AV_PROFILE_TRUEHD_ATMOS) + AV_PROFILE_MPEG2_422 = int32(C.AV_PROFILE_MPEG2_422) + AV_PROFILE_MPEG2_HIGH = int32(C.AV_PROFILE_MPEG2_HIGH) + AV_PROFILE_MPEG2_SS = int32(C.AV_PROFILE_MPEG2_SS) + AV_PROFILE_MPEG2_SNR_SCALABLE = int32(C.AV_PROFILE_MPEG2_SNR_SCALABLE) + AV_PROFILE_MPEG2_MAIN = int32(C.AV_PROFILE_MPEG2_MAIN) + AV_PROFILE_MPEG2_SIMPLE = int32(C.AV_PROFILE_MPEG2_SIMPLE) + AV_PROFILE_H264_CONSTRAINED = int32(C.AV_PROFILE_H264_CONSTRAINED) + AV_PROFILE_H264_INTRA = int32(C.AV_PROFILE_H264_INTRA) + AV_PROFILE_H264_BASELINE = int32(C.AV_PROFILE_H264_BASELINE) + AV_PROFILE_H264_CONSTRAINED_BASELINE = int32(C.AV_PROFILE_H264_CONSTRAINED_BASELINE) + AV_PROFILE_H264_MAIN = int32(C.AV_PROFILE_H264_MAIN) + AV_PROFILE_H264_EXTENDED = int32(C.AV_PROFILE_H264_EXTENDED) + AV_PROFILE_H264_HIGH = int32(C.AV_PROFILE_H264_HIGH) + AV_PROFILE_H264_HIGH_10 = int32(C.AV_PROFILE_H264_HIGH_10) + AV_PROFILE_H264_HIGH_10_INTRA = int32(C.AV_PROFILE_H264_HIGH_10_INTRA) + AV_PROFILE_H264_MULTIVIEW_HIGH = int32(C.AV_PROFILE_H264_MULTIVIEW_HIGH) + AV_PROFILE_H264_HIGH_422 = int32(C.AV_PROFILE_H264_HIGH_422) + AV_PROFILE_H264_HIGH_422_INTRA = int32(C.AV_PROFILE_H264_HIGH_422_INTRA) + AV_PROFILE_H264_STEREO_HIGH = int32(C.AV_PROFILE_H264_STEREO_HIGH) + AV_PROFILE_H264_HIGH_444 = int32(C.AV_PROFILE_H264_HIGH_444) + AV_PROFILE_H264_HIGH_444_PREDICTIVE = int32(C.AV_PROFILE_H264_HIGH_444_PREDICTIVE) + AV_PROFILE_H264_HIGH_444_INTRA = int32(C.AV_PROFILE_H264_HIGH_444_INTRA) + AV_PROFILE_H264_CAVLC_444 = int32(C.AV_PROFILE_H264_CAVLC_444) + AV_PROFILE_VC1_SIMPLE = int32(C.AV_PROFILE_VC1_SIMPLE) + AV_PROFILE_VC1_MAIN = int32(C.AV_PROFILE_VC1_MAIN) + AV_PROFILE_VC1_COMPLEX = int32(C.AV_PROFILE_VC1_COMPLEX) + AV_PROFILE_VC1_ADVANCED = int32(C.AV_PROFILE_VC1_ADVANCED) + AV_PROFILE_MPEG4_SIMPLE = int32(C.AV_PROFILE_MPEG4_SIMPLE) + AV_PROFILE_MPEG4_SIMPLE_SCALABLE = int32(C.AV_PROFILE_MPEG4_SIMPLE_SCALABLE) + AV_PROFILE_MPEG4_CORE = int32(C.AV_PROFILE_MPEG4_CORE) + AV_PROFILE_MPEG4_MAIN = int32(C.AV_PROFILE_MPEG4_MAIN) + AV_PROFILE_MPEG4_N_BIT = int32(C.AV_PROFILE_MPEG4_N_BIT) + AV_PROFILE_MPEG4_SCALABLE_TEXTURE = int32(C.AV_PROFILE_MPEG4_SCALABLE_TEXTURE) + AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION = int32(C.AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION) + AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE = int32(C.AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE) + AV_PROFILE_MPEG4_HYBRID = int32(C.AV_PROFILE_MPEG4_HYBRID) + AV_PROFILE_MPEG4_ADVANCED_REAL_TIME = int32(C.AV_PROFILE_MPEG4_ADVANCED_REAL_TIME) + AV_PROFILE_MPEG4_CORE_SCALABLE = int32(C.AV_PROFILE_MPEG4_CORE_SCALABLE) + AV_PROFILE_MPEG4_ADVANCED_CODING = int32(C.AV_PROFILE_MPEG4_ADVANCED_CODING) + AV_PROFILE_MPEG4_ADVANCED_CORE = int32(C.AV_PROFILE_MPEG4_ADVANCED_CORE) + AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE = int32(C.AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE) + AV_PROFILE_MPEG4_SIMPLE_STUDIO = int32(C.AV_PROFILE_MPEG4_SIMPLE_STUDIO) + AV_PROFILE_MPEG4_ADVANCED_SIMPLE = int32(C.AV_PROFILE_MPEG4_ADVANCED_SIMPLE) + AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 = int32(C.AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0) + AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 = int32(C.AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1) + AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION = int32(C.AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION) + AV_PROFILE_JPEG2000_DCINEMA_2K = int32(C.AV_PROFILE_JPEG2000_DCINEMA_2K) + AV_PROFILE_JPEG2000_DCINEMA_4K = int32(C.AV_PROFILE_JPEG2000_DCINEMA_4K) + AV_PROFILE_VP9_0 = int32(C.AV_PROFILE_VP9_0) + AV_PROFILE_VP9_1 = int32(C.AV_PROFILE_VP9_1) + AV_PROFILE_VP9_2 = int32(C.AV_PROFILE_VP9_2) + AV_PROFILE_VP9_3 = int32(C.AV_PROFILE_VP9_3) + AV_PROFILE_HEVC_MAIN = int32(C.AV_PROFILE_HEVC_MAIN) + AV_PROFILE_HEVC_MAIN_10 = int32(C.AV_PROFILE_HEVC_MAIN_10) + AV_PROFILE_HEVC_MAIN_STILL_PICTURE = int32(C.AV_PROFILE_HEVC_MAIN_STILL_PICTURE) + AV_PROFILE_HEVC_REXT = int32(C.AV_PROFILE_HEVC_REXT) + AV_PROFILE_HEVC_SCC = int32(C.AV_PROFILE_HEVC_SCC) + AV_PROFILE_VVC_MAIN_10 = int32(C.AV_PROFILE_VVC_MAIN_10) + AV_PROFILE_VVC_MAIN_10_444 = int32(C.AV_PROFILE_VVC_MAIN_10_444) + AV_PROFILE_AV1_MAIN = int32(C.AV_PROFILE_AV1_MAIN) + AV_PROFILE_AV1_HIGH = int32(C.AV_PROFILE_AV1_HIGH) + AV_PROFILE_AV1_PROFESSIONAL = int32(C.AV_PROFILE_AV1_PROFESSIONAL) + AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT = int32(C.AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT) + AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT = int32(C.AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT) + AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT = int32(C.AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT) + AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS = int32(C.AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS) + AV_PROFILE_MJPEG_JPEG_LS = int32(C.AV_PROFILE_MJPEG_JPEG_LS) + AV_PROFILE_SBC_MSBC = int32(C.AV_PROFILE_SBC_MSBC) + AV_PROFILE_PRORES_PROXY = int32(C.AV_PROFILE_PRORES_PROXY) + AV_PROFILE_PRORES_LT = int32(C.AV_PROFILE_PRORES_LT) + AV_PROFILE_PRORES_STANDARD = int32(C.AV_PROFILE_PRORES_STANDARD) + AV_PROFILE_PRORES_HQ = int32(C.AV_PROFILE_PRORES_HQ) + AV_PROFILE_PRORES_4444 = int32(C.AV_PROFILE_PRORES_4444) + AV_PROFILE_PRORES_XQ = int32(C.AV_PROFILE_PRORES_XQ) + AV_PROFILE_ARIB_PROFILE_A = int32(C.AV_PROFILE_ARIB_PROFILE_A) + AV_PROFILE_ARIB_PROFILE_C = int32(C.AV_PROFILE_ARIB_PROFILE_C) + AV_PROFILE_KLVA_SYNC = int32(C.AV_PROFILE_KLVA_SYNC) + AV_PROFILE_KLVA_ASYNC = int32(C.AV_PROFILE_KLVA_ASYNC) + AV_PROFILE_EVC_BASELINE = int32(C.AV_PROFILE_EVC_BASELINE) + AV_PROFILE_EVC_MAIN = int32(C.AV_PROFILE_EVC_MAIN) +) + +const ( + AV_LEVEL_UNKNOWN = int32(C.AV_LEVEL_UNKNOWN) +) + +// 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) +) + // AVDiscard type AVDiscard = C.enum_AVDiscard diff --git a/avcodec_packet.go b/avcodec_packet.go index b1f0a92..4fe107c 100644 --- a/avcodec_packet.go +++ b/avcodec_packet.go @@ -102,6 +102,45 @@ func (psd *AVPacketSideData) GetTypeAddr() *AVPacketSideDataType { return (*AVPacketSideDataType)(&psd._type) } +// AvPacketSideDataNew allocates a new packet side data. +func AvPacketSideDataNew(psd **AVPacketSideData, pnbSd *int32, _type AVPacketSideDataType, + size uintptr, flags int32) *AVPacketSideData { + return (*AVPacketSideData)(C.av_packet_side_data_new((**C.struct_AVPacketSideData)(unsafe.Pointer(psd)), + (*C.int)(pnbSd), (C.enum_AVPacketSideDataType)(_type), + (C.size_t)(size), (C.int)(flags))) +} + +// AvPacketSideDataAdd wraps existing data as packet side data. +func AvPacketSideDataAdd(sd **AVPacketSideData, nbSd *int32, _type AVPacketSideDataType, + data CVoidPointer, size uintptr, flags int32) *AVPacketSideData { + return (*AVPacketSideData)(C.av_packet_side_data_add((**C.struct_AVPacketSideData)(unsafe.Pointer(sd)), + (*C.int)(nbSd), (C.enum_AVPacketSideDataType)(_type), + VoidPointer(data), (C.size_t)(size), (C.int)(flags))) +} + +// AvPacketSideDataGet gets side information from a side data array. +func AvPacketSideDataGet(sd *AVPacketSideData, nbSd int32, _type AVPacketSideDataType) *AVPacketSideData { + return (*AVPacketSideData)(C.av_packet_side_data_get((*C.struct_AVPacketSideData)(sd), + (C.int)(nbSd), (C.enum_AVPacketSideDataType)(_type))) +} + +// AvPacketSideDataRemove removes side data of the given type from a side data array. +func AvPacketSideDataRemove(sd *AVPacketSideData, nbSd *int32, _type AVPacketSideDataType) { + C.av_packet_side_data_remove((*C.struct_AVPacketSideData)(sd), + (*C.int)(nbSd), (C.enum_AVPacketSideDataType)(_type)) +} + +// AvPacketSideDataFree convenience function to free all the side data stored in an array, and +// the array itself. +func AvPacketSideDataFree(sd **AVPacketSideData, nbSd *int32) { + C.av_packet_side_data_free((**C.struct_AVPacketSideData)(unsafe.Pointer(sd)), (*C.int)(nbSd)) +} + +// AvPacketSideDataName +func AvPacketSideDataName(_type AVPacketSideDataType) string { + return C.GoString(C.av_packet_side_data_name((C.enum_AVPacketSideDataType)(_type))) +} + // AVPacket type AVPacket C.struct_AVPacket diff --git a/avdevice.go b/avdevice.go index 2e9c954..471c01d 100644 --- a/avdevice.go +++ b/avdevice.go @@ -185,9 +185,6 @@ type AVDeviceInfoList C.struct_AVDeviceInfoList // 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) } diff --git a/avfilter.go b/avfilter.go index d8fcacd..6aafebe 100644 --- a/avfilter.go +++ b/avfilter.go @@ -49,6 +49,7 @@ const ( AVFILTER_FLAG_DYNAMIC_OUTPUTS = C.AVFILTER_FLAG_DYNAMIC_OUTPUTS AVFILTER_FLAG_SLICE_THREADS = C.AVFILTER_FLAG_SLICE_THREADS AVFILTER_FLAG_METADATA_ONLY = C.AVFILTER_FLAG_METADATA_ONLY + AVFILTER_FLAG_HWDEVICE = C.AVFILTER_FLAG_HWDEVICE AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC = C.AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL = C.AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL AVFILTER_FLAG_SUPPORT_TIMELINE = C.AVFILTER_FLAG_SUPPORT_TIMELINE @@ -201,9 +202,6 @@ func (fltc *AVFilterContext) GetInputPadsAddr() **AVFilterPad { // GetInputs gets `AVFilterContext.inputs` value. func (fltc *AVFilterContext) GetInputs() []*AVFilterLink { - if fltc.inputs == nil { - return nil - } return unsafe.Slice((**AVFilterLink)(unsafe.Pointer(fltc.inputs)), fltc.nb_inputs) } @@ -249,9 +247,6 @@ func (fltc *AVFilterContext) GetOutputPadsAddr() **AVFilterPad { // GetOutputs gets `AVFilterContext.outputs` value. func (fltc *AVFilterContext) GetOutputs() []*AVFilterLink { - if fltc.outputs == nil { - return nil - } return unsafe.Slice((**AVFilterLink)(unsafe.Pointer(fltc.outputs)), fltc.nb_outputs) } @@ -831,9 +826,6 @@ func (fltg *AVFilterGraph) GetAvClassAddr() **AVClass { // GetFilters gets `AVFilterGraph.filters` value. func (fltg *AVFilterGraph) GetFilters() []*AVFilterContext { - if fltg.filters == nil { - return nil - } return unsafe.Slice((**AVFilterContext)(unsafe.Pointer(fltg.filters)), fltg.nb_filters) } diff --git a/avformat.go b/avformat.go index 25387d2..5d5587f 100644 --- a/avformat.go +++ b/avformat.go @@ -601,31 +601,43 @@ func (stm *AVStream) GetAttachedPicAddr() *AVPacket { return (*AVPacket)(&stm.attached_pic) } +// Deprecated: Use AVStream's AVCodecParameters.coded_side_data "codecpar side data" instead. +// // GetSideData gets `AVStream.side_data` value. -func (stm *AVStream) GetSideData() *AVPacketSideData { - return (*AVPacketSideData)(stm.side_data) +func (stm *AVStream) GetSideData() []AVPacketSideData { + return unsafe.Slice((*AVPacketSideData)(stm.side_data), stm.nb_side_data) } +// Deprecated: Use AVStream's AVCodecParameters.coded_side_data "codecpar side data" instead. +// // SetSideData sets `AVStream.side_data` value. func (stm *AVStream) SetSideData(v *AVPacketSideData) { stm.side_data = (*C.struct_AVPacketSideData)(v) } +// Deprecated: Use AVStream's AVCodecParameters.coded_side_data "codecpar side data" instead. +// // GetSideDataAddr gets `AVStream.side_data` address. func (stm *AVStream) GetSideDataAddr() **AVPacketSideData { return (**AVPacketSideData)(unsafe.Pointer(&stm.side_data)) } +// Deprecated: Use AVStream's AVCodecParameters.nb_coded_side_data "codecpar side data" instead. +// // GetNbSideData gets `AVStream.nb_side_data` value. func (stm *AVStream) GetNbSideData() int32 { return (int32)(stm.nb_side_data) } +// Deprecated: Use AVStream's AVCodecParameters.nb_coded_side_data "codecpar side data" instead. +// // SetNbSideData sets `AVStream.nb_side_data` value. func (stm *AVStream) SetNbSideData(v int32) { stm.nb_side_data = (C.int)(v) } +// Deprecated: Use AVStream's AVCodecParameters.nb_coded_side_data "codecpar side data" instead. +// // GetNbSideDataAddr gets `AVStream.nb_side_data` address. func (stm *AVStream) GetNbSideDataAddr() *int32 { return (*int32)(&stm.nb_side_data) @@ -763,9 +775,6 @@ func (pgm *AVProgram) GetDiscardAddr() *AVDiscard { // GetStreamIndex gets `AVProgram.stream_index` value. func (pgm *AVProgram) GetStreamIndex() (v []uint32) { - if pgm.stream_index == nil { - return v - } return unsafe.Slice((*uint32)(unsafe.Pointer(pgm.stream_index)), pgm.nb_stream_indexes) } @@ -1083,9 +1092,6 @@ func (s *AVFormatContext) GetNbStreamsAddr() *uint32 { // GetStreams gets `AVFormatContext.streams` value. func (s *AVFormatContext) GetStreams() (v []*AVStream) { - if s.streams == nil { - return v - } return unsafe.Slice((**AVStream)(unsafe.Pointer(s.streams)), s.nb_streams) } @@ -1280,9 +1286,6 @@ func (s *AVFormatContext) GetNbProgramsAddr() *uint32 { // GetPrograms gets `AVFormatContext.programs` value. func (s *AVFormatContext) GetPrograms() (v []*AVProgram) { - if s.programs == nil { - return v - } return unsafe.Slice((**AVProgram)(unsafe.Pointer(s.programs)), s.nb_programs) } @@ -1388,9 +1391,6 @@ func (s *AVFormatContext) GetNbChaptersAddr() *uint32 { // GetChapters gets `AVFormatContext.chapters` value. func (s *AVFormatContext) GetChapters() (v []*AVChapter) { - if s.chapters == nil { - return v - } return unsafe.Slice((**AVChapter)(unsafe.Pointer(s.chapters)), s.nb_chapters) } @@ -2056,8 +2056,9 @@ const ( AVFMT_FLAG_SORT_DTS = C.AVFMT_FLAG_SORT_DTS AVFMT_FLAG_FAST_SEEK = C.AVFMT_FLAG_FAST_SEEK - AVFMT_FLAG_SHORTEST = C.AVFMT_FLAG_SHORTEST - AVFMT_FLAG_AUTO_BSF = C.AVFMT_FLAG_AUTO_BSF + + AVFMT_FLAG_SHORTEST = C.AVFMT_FLAG_SHORTEST + AVFMT_FLAG_AUTO_BSF = C.AVFMT_FLAG_AUTO_BSF ) const ( @@ -2138,18 +2139,24 @@ func AvFormatNewStream(s *AVFormatContext, c *AVCodec) *AVStream { return (*AVStream)(C.avformat_new_stream((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))) } +// Deprecated: No use. +// // AvStreamAddSideData wraps an existing array as stream side data. func AvStreamAddSideData(st *AVStream, _type AVPacketSideDataType, data *uint8, size uintptr) int32 { return (int32)(C.av_stream_add_side_data((*C.struct_AVStream)(st), (C.enum_AVPacketSideDataType)(_type), (*C.uint8_t)(data), (C.size_t)(size))) } +// Deprecated: No use. +// // AvStreamNewSideData allocates new information from stream. func AvStreamNewSideData(st *AVStream, _type AVPacketSideDataType, size uintptr) *uint8 { return (*uint8)(C.av_stream_new_side_data((*C.struct_AVStream)(st), (C.enum_AVPacketSideDataType)(_type), (C.size_t)(size))) } +// Deprecated: No use. +// // AvStreamGetSideData gets side information from stream. func AvStreamGetSideData(st *AVStream, _type AVPacketSideDataType, size *uintptr) *uint8 { return (*uint8)(C.av_stream_get_side_data((*C.struct_AVStream)(st), diff --git a/avformat_avio.go b/avformat_avio.go index c328d4b..d3a65e8 100644 --- a/avformat_avio.go +++ b/avformat_avio.go @@ -8,9 +8,17 @@ package ffmpeg #include typedef int (*avio_interrupt_callback_func)(void* opaque); + typedef int (*avio_context_read_packet_func)(void *opaque, uint8_t *buf, int buf_size); typedef int (*avio_context_write_packet_func)(void *opaque, uint8_t *buf, int buf_size); typedef int64_t (*avio_context_seek_func)(void *opaque, int64_t offset, int whence); +typedef unsigned long (*avio_context_update_checksum)(unsigned long checksum, + const uint8_t *buf, unsigned int size); +typedef int (*avio_context_read_pause)(void *opaque, int pause); +typedef int64_t (*avio_context_read_seek)(void *opaque, int stream_index, + int64_t timestamp, int flags); +typedef int (*avio_context_write_data_type)(void *opaque, uint8_t *buf, int buf_size, + enum AVIODataMarkerType type, int64_t time); int avio_printf_wrap(AVIOContext *s, const char *fmt) { return avio_printf(s, fmt, NULL); @@ -265,6 +273,30 @@ const ( // AVIOContext type AVIOContext C.struct_AVIOContext +// typedef int (*avio_context_read_packet_func)(void *opaque, uint8_t *buf, int buf_size); +type AVIOContextReadPacketFunc = C.avio_context_read_packet_func + +// typedef int (*avio_context_write_packet_func)(void *opaque, uint8_t *buf, int buf_size); +type AVIOContextWritePacketFunc = C.avio_context_write_packet_func + +// typedef int64_t (*avio_context_seek_func)(void *opaque, int64_t offset, int whence); +type AVIOContextSeekFunc = C.avio_context_seek_func + +// typedef unsigned long (*avio_context_update_checksum)(unsigned long checksum, +// const uint8_t *buf, unsigned int size); +type AVIOContextUpdateChecksum = C.avio_context_update_checksum + +// typedef int (*avio_context_read_pause)(void *opaque, int pause); +type AVIOContextReadPause = C.avio_context_read_pause + +// typedef int64_t (*avio_context_read_seek)(void *opaque, int stream_index, +// int64_t timestamp, int flags); +type AVIOContextReadSeek = C.avio_context_read_seek + +// typedef int (*avio_context_write_data_type)(void *opaque, uint8_t *buf, int buf_size, +// enum AVIODataMarkerType type, int64_t time); +type AVIOContextWriteDataType = C.avio_context_write_data_type + // GetAvClass gets `AVIOContext.av_class` value. func (ctx *AVIOContext) GetAvClass() *AVClass { return (*AVClass)(ctx.av_class) @@ -355,6 +387,51 @@ func (ctx *AVIOContext) GetOpaqueAddr() *unsafe.Pointer { return (*unsafe.Pointer)(&ctx.opaque) } +// GetReadPacket gets `AVIOContext.read_packet` value. +func (ctx *AVIOContext) GetReadPacket() AVIOContextReadPacketFunc { + return (AVIOContextReadPacketFunc)(ctx.read_packet) +} + +// SetReadPacket sets `AVIOContext.read_packet` value. +func (ctx *AVIOContext) SetReadPacket(v AVIOContextReadPacketFunc) { + ctx.read_packet = (C.avio_context_read_packet_func)(v) +} + +// GetReadPacketAddr gets `AVIOContext.read_packet` address. +func (ctx *AVIOContext) GetReadPacketAddr() *AVIOContextReadPacketFunc { + return (*AVIOContextReadPacketFunc)(&ctx.read_packet) +} + +// GetWritePacket gets `AVIOContext.write_packet` value. +func (ctx *AVIOContext) GetWritePacket() AVIOContextWritePacketFunc { + return (AVIOContextWritePacketFunc)(ctx.write_packet) +} + +// SetWritePacket sets `AVIOContext.write_packet` value. +func (ctx *AVIOContext) SetWritePacket(v AVIOContextWritePacketFunc) { + ctx.write_packet = (C.avio_context_write_packet_func)(v) +} + +// GetWritePacketAddr gets `AVIOContext.write_packet` address. +func (ctx *AVIOContext) GetWritePacketAddr() *AVIOContextWritePacketFunc { + return (*AVIOContextWritePacketFunc)(&ctx.write_packet) +} + +// GetSeek gets `AVIOContext.seek` value. +func (ctx *AVIOContext) GetSeek() AVIOContextSeekFunc { + return (AVIOContextSeekFunc)(ctx.seek) +} + +// SetSeek sets `AVIOContext.seek` value. +func (ctx *AVIOContext) SetSeek(v AVIOContextSeekFunc) { + ctx.seek = (C.avio_context_seek_func)(v) +} + +// GetSeekAddr gets `AVIOContext.seek` address. +func (ctx *AVIOContext) GetSeekAddr() *AVIOContextSeekFunc { + return (*AVIOContextSeekFunc)(&ctx.seek) +} + // GetPos gets `AVIOContext.pos` value. func (ctx *AVIOContext) GetPos() int64 { return (int64)(ctx.pos) @@ -385,6 +462,21 @@ func (ctx *AVIOContext) GetEofReachedAddr() *int32 { return (*int32)(&ctx.eof_reached) } +// GetError gets `AVIOContext.error` value. +func (ctx *AVIOContext) GetError() int32 { + return (int32)(ctx.error) +} + +// SetError sets `AVIOContext.error` value. +func (ctx *AVIOContext) SetError(v int32) { + ctx.error = (C.int)(v) +} + +// GetErrorAddr gets `AVIOContext.error` address. +func (ctx *AVIOContext) GetErrorAddr() *int32 { + return (*int32)(&ctx.error) +} + // GetWriteFlag gets `AVIOContext.write_flag` value. func (ctx *AVIOContext) GetWriteFlag() int32 { return (int32)(ctx.write_flag) @@ -445,19 +537,49 @@ func (ctx *AVIOContext) GetChecksumPtrAddr() **uint8 { return (**uint8)(unsafe.Pointer(&ctx.checksum_ptr)) } -// GetError gets `AVIOContext.error` value. -func (ctx *AVIOContext) GetError() int32 { - return (int32)(ctx.error) +// GetUpdateChecksum gets `AVIOContext.update_checksum` value. +func (ctx *AVIOContext) GetUpdateChecksum() AVIOContextUpdateChecksum { + return (AVIOContextUpdateChecksum)(ctx.update_checksum) } -// SetError sets `AVIOContext.error` value. -func (ctx *AVIOContext) SetError(v int32) { - ctx.error = (C.int)(v) +// SetUpdateChecksum sets `AVIOContext.update_checksum` value. +func (ctx *AVIOContext) SetUpdateChecksum(v AVIOContextUpdateChecksum) { + ctx.update_checksum = (C.avio_context_update_checksum)(v) } -// GetErrorAddr gets `AVIOContext.error` address. -func (ctx *AVIOContext) GetErrorAddr() *int32 { - return (*int32)(&ctx.error) +// GetUpdateChecksumAddr gets `AVIOContext.update_checksum` address. +func (ctx *AVIOContext) GetUpdateChecksumAddr() *AVIOContextUpdateChecksum { + return (*AVIOContextUpdateChecksum)(&ctx.update_checksum) +} + +// GetReadPause gets `AVIOContext.read_pause` value. +func (ctx *AVIOContext) GetReadPause() AVIOContextReadPause { + return (AVIOContextReadPause)(ctx.read_pause) +} + +// SetReadPause sets `AVIOContext.read_pause` value. +func (ctx *AVIOContext) SetReadPause(v AVIOContextReadPause) { + ctx.read_pause = (C.avio_context_read_pause)(v) +} + +// GetReadPauseAddr gets `AVIOContext.read_pause` address. +func (ctx *AVIOContext) GetReadPauseAddr() *AVIOContextReadPause { + return (*AVIOContextReadPause)(&ctx.read_pause) +} + +// GetReadSeek gets `AVIOContext.read_seek` value. +func (ctx *AVIOContext) GetReadSeek() AVIOContextReadSeek { + return (AVIOContextReadSeek)(ctx.read_seek) +} + +// SetReadSeek sets `AVIOContext.read_seek` value. +func (ctx *AVIOContext) SetReadSeek(v AVIOContextReadSeek) { + ctx.read_seek = (C.avio_context_read_seek)(v) +} + +// GetReadSeekAddr gets `AVIOContext.read_seek` address. +func (ctx *AVIOContext) GetReadSeekAddr() *AVIOContextReadSeek { + return (*AVIOContextReadSeek)(&ctx.read_seek) } // GetSeekable gets `AVIOContext.seekable` value. @@ -530,6 +652,21 @@ func (ctx *AVIOContext) GetProtocolBlacklist() string { return C.GoString(ctx.protocol_blacklist) } +// GetWriteDataType gets `AVIOContext.write_data_type` value. +func (ctx *AVIOContext) GetWriteDataType() AVIOContextWriteDataType { + return (AVIOContextWriteDataType)(ctx.write_data_type) +} + +// SetWriteDataType sets `AVIOContext.write_data_type` value. +func (ctx *AVIOContext) SetWriteDataType(v AVIOContextWriteDataType) { + ctx.write_data_type = (C.avio_context_write_data_type)(v) +} + +// GetWriteDataTypeAddr gets `AVIOContext.write_data_type` address. +func (ctx *AVIOContext) GetWriteDataTypeAddr() *AVIOContextWriteDataType { + return (*AVIOContextWriteDataType)(&ctx.write_data_type) +} + // GetIgnoreBoundaryPoint gets `AVIOContext.ignore_boundary_point` value. func (ctx *AVIOContext) GetIgnoreBoundaryPoint() int32 { return (int32)(ctx.ignore_boundary_point) @@ -616,15 +753,6 @@ func AvIOFreeDirectoryEntry(entry **AVIODirEntry) { C.avio_free_directory_entry((**C.struct_AVIODirEntry)(unsafe.Pointer(entry))) } -// typedef int (*avio_context_read_packet_func)(void *opaque, uint8_t *buf, int buf_size); -type AVIOContextReadPacketFunc = C.avio_context_read_packet_func - -// typedef int (*avio_context_write_packet_func)(void *opaque, uint8_t *buf, int buf_size); -type AVIOContextWritePacketFunc = C.avio_context_write_packet_func - -// typedef int64_t (*avio_context_seek_func)(void *opaque, int64_t offset, int whence); -type AVIOContextSeekFunc = C.avio_context_seek_func - // AvIOAllocContext sllocates and initialize an AVIOContext for buffered I/O. It must be later // freed with AVIOContextFree(). func AvIOAllocContext(buffer *uint8, bufferSize, writeFlag int32, diff --git a/avutil_channel_layout.go b/avutil_channel_layout.go index d96c3fb..0d394bb 100644 --- a/avutil_channel_layout.go +++ b/avutil_channel_layout.go @@ -47,6 +47,7 @@ const struct AVChannelLayout av_channel_layout_5point0_back = AV_CHANNE const struct AVChannelLayout av_channel_layout_5point1_back = AV_CHANNEL_LAYOUT_5POINT1_BACK; const struct AVChannelLayout av_channel_layout_6point0 = AV_CHANNEL_LAYOUT_6POINT0; const struct AVChannelLayout av_channel_layout_6point0_front = AV_CHANNEL_LAYOUT_6POINT0_FRONT; +const struct AVChannelLayout av_channel_layout_3point1point2 = AV_CHANNEL_LAYOUT_3POINT1POINT2; const struct AVChannelLayout av_channel_layout_hexagonal = AV_CHANNEL_LAYOUT_HEXAGONAL; const struct AVChannelLayout av_channel_layout_6point1 = AV_CHANNEL_LAYOUT_6POINT1; const struct AVChannelLayout av_channel_layout_6point1_back = AV_CHANNEL_LAYOUT_6POINT1_BACK; @@ -56,14 +57,19 @@ const struct AVChannelLayout av_channel_layout_7point0_front = AV_CHANNE const struct AVChannelLayout av_channel_layout_7point1 = AV_CHANNEL_LAYOUT_7POINT1; const struct AVChannelLayout av_channel_layout_7point1_wide = AV_CHANNEL_LAYOUT_7POINT1_WIDE; const struct AVChannelLayout av_channel_layout_7point1_wide_back = AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK; -const struct AVChannelLayout av_channel_layout_7point1_top_back = AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK; +const struct AVChannelLayout av_channel_layout_5point1point2_back = AV_CHANNEL_LAYOUT_5POINT1POINT2_BACK; const struct AVChannelLayout av_channel_layout_octagonal = AV_CHANNEL_LAYOUT_OCTAGONAL; const struct AVChannelLayout av_channel_layout_cube = AV_CHANNEL_LAYOUT_CUBE; +const struct AVChannelLayout av_channel_layout_5point1point4_back = AV_CHANNEL_LAYOUT_5POINT1POINT4_BACK; +const struct AVChannelLayout av_channel_layout_7point1point2 = AV_CHANNEL_LAYOUT_7POINT1POINT2; +const struct AVChannelLayout av_channel_layout_7point1point4_back = AV_CHANNEL_LAYOUT_7POINT1POINT4_BACK; const struct AVChannelLayout av_channel_layout_hexadecagonal = AV_CHANNEL_LAYOUT_HEXADECAGONAL; const struct AVChannelLayout av_channel_layout_stereo_downmix = AV_CHANNEL_LAYOUT_STEREO_DOWNMIX; const struct AVChannelLayout av_channel_layout_22point2 = AV_CHANNEL_LAYOUT_22POINT2; const struct AVChannelLayout av_channel_layout_ambisonic_first_order = AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER; +const struct AVChannelLayout av_channel_layout_7point1_top_back = AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK; + */ import "C" import "unsafe" @@ -159,37 +165,43 @@ const ( ) const ( - AV_CH_LAYOUT_MONO = uint64(C.AV_CH_LAYOUT_MONO) - AV_CH_LAYOUT_STEREO = uint64(C.AV_CH_LAYOUT_STEREO) - AV_CH_LAYOUT_2POINT1 = uint64(C.AV_CH_LAYOUT_2POINT1) - AV_CH_LAYOUT_2_1 = uint64(C.AV_CH_LAYOUT_2_1) - AV_CH_LAYOUT_SURROUND = uint64(C.AV_CH_LAYOUT_SURROUND) - AV_CH_LAYOUT_3POINT1 = uint64(C.AV_CH_LAYOUT_3POINT1) - AV_CH_LAYOUT_4POINT0 = uint64(C.AV_CH_LAYOUT_4POINT0) - AV_CH_LAYOUT_4POINT1 = uint64(C.AV_CH_LAYOUT_4POINT1) - AV_CH_LAYOUT_2_2 = uint64(C.AV_CH_LAYOUT_2_2) - AV_CH_LAYOUT_QUAD = uint64(C.AV_CH_LAYOUT_QUAD) - AV_CH_LAYOUT_5POINT0 = uint64(C.AV_CH_LAYOUT_5POINT0) - AV_CH_LAYOUT_5POINT1 = uint64(C.AV_CH_LAYOUT_5POINT1) - AV_CH_LAYOUT_5POINT0_BACK = uint64(C.AV_CH_LAYOUT_5POINT0_BACK) - AV_CH_LAYOUT_5POINT1_BACK = uint64(C.AV_CH_LAYOUT_5POINT1_BACK) - AV_CH_LAYOUT_6POINT0 = uint64(C.AV_CH_LAYOUT_6POINT0) - AV_CH_LAYOUT_6POINT0_FRONT = uint64(C.AV_CH_LAYOUT_6POINT0_FRONT) - AV_CH_LAYOUT_HEXAGONAL = uint64(C.AV_CH_LAYOUT_HEXAGONAL) - AV_CH_LAYOUT_6POINT1 = uint64(C.AV_CH_LAYOUT_6POINT1) - AV_CH_LAYOUT_6POINT1_BACK = uint64(C.AV_CH_LAYOUT_6POINT1_BACK) - AV_CH_LAYOUT_6POINT1_FRONT = uint64(C.AV_CH_LAYOUT_6POINT1_FRONT) - AV_CH_LAYOUT_7POINT0 = uint64(C.AV_CH_LAYOUT_7POINT0) - AV_CH_LAYOUT_7POINT0_FRONT = uint64(C.AV_CH_LAYOUT_7POINT0_FRONT) - AV_CH_LAYOUT_7POINT1 = uint64(C.AV_CH_LAYOUT_7POINT1) - AV_CH_LAYOUT_7POINT1_WIDE = uint64(C.AV_CH_LAYOUT_7POINT1_WIDE) - AV_CH_LAYOUT_7POINT1_WIDE_BACK = uint64(C.AV_CH_LAYOUT_7POINT1_WIDE_BACK) - AV_CH_LAYOUT_7POINT1_TOP_BACK = uint64(C.AV_CH_LAYOUT_7POINT1_TOP_BACK) - AV_CH_LAYOUT_OCTAGONAL = uint64(C.AV_CH_LAYOUT_OCTAGONAL) - AV_CH_LAYOUT_CUBE = uint64(C.AV_CH_LAYOUT_CUBE) - AV_CH_LAYOUT_HEXADECAGONAL = uint64(C.AV_CH_LAYOUT_HEXADECAGONAL) - AV_CH_LAYOUT_STEREO_DOWNMIX = uint64(C.AV_CH_LAYOUT_STEREO_DOWNMIX) - AV_CH_LAYOUT_22POINT2 = uint64(C.AV_CH_LAYOUT_22POINT2) + AV_CH_LAYOUT_MONO = uint64(C.AV_CH_LAYOUT_MONO) + AV_CH_LAYOUT_STEREO = uint64(C.AV_CH_LAYOUT_STEREO) + AV_CH_LAYOUT_2POINT1 = uint64(C.AV_CH_LAYOUT_2POINT1) + AV_CH_LAYOUT_2_1 = uint64(C.AV_CH_LAYOUT_2_1) + AV_CH_LAYOUT_SURROUND = uint64(C.AV_CH_LAYOUT_SURROUND) + AV_CH_LAYOUT_3POINT1 = uint64(C.AV_CH_LAYOUT_3POINT1) + AV_CH_LAYOUT_4POINT0 = uint64(C.AV_CH_LAYOUT_4POINT0) + AV_CH_LAYOUT_4POINT1 = uint64(C.AV_CH_LAYOUT_4POINT1) + AV_CH_LAYOUT_2_2 = uint64(C.AV_CH_LAYOUT_2_2) + AV_CH_LAYOUT_QUAD = uint64(C.AV_CH_LAYOUT_QUAD) + AV_CH_LAYOUT_5POINT0 = uint64(C.AV_CH_LAYOUT_5POINT0) + AV_CH_LAYOUT_5POINT1 = uint64(C.AV_CH_LAYOUT_5POINT1) + AV_CH_LAYOUT_5POINT0_BACK = uint64(C.AV_CH_LAYOUT_5POINT0_BACK) + AV_CH_LAYOUT_5POINT1_BACK = uint64(C.AV_CH_LAYOUT_5POINT1_BACK) + AV_CH_LAYOUT_6POINT0 = uint64(C.AV_CH_LAYOUT_6POINT0) + AV_CH_LAYOUT_6POINT0_FRONT = uint64(C.AV_CH_LAYOUT_6POINT0_FRONT) + AV_CH_LAYOUT_HEXAGONAL = uint64(C.AV_CH_LAYOUT_HEXAGONAL) + AV_CH_LAYOUT_3POINT1POINT2 = uint64(C.AV_CH_LAYOUT_3POINT1POINT2) + AV_CH_LAYOUT_6POINT1 = uint64(C.AV_CH_LAYOUT_6POINT1) + AV_CH_LAYOUT_6POINT1_BACK = uint64(C.AV_CH_LAYOUT_6POINT1_BACK) + AV_CH_LAYOUT_6POINT1_FRONT = uint64(C.AV_CH_LAYOUT_6POINT1_FRONT) + AV_CH_LAYOUT_7POINT0 = uint64(C.AV_CH_LAYOUT_7POINT0) + AV_CH_LAYOUT_7POINT0_FRONT = uint64(C.AV_CH_LAYOUT_7POINT0_FRONT) + AV_CH_LAYOUT_7POINT1 = uint64(C.AV_CH_LAYOUT_7POINT1) + AV_CH_LAYOUT_7POINT1_WIDE = uint64(C.AV_CH_LAYOUT_7POINT1_WIDE) + AV_CH_LAYOUT_7POINT1_WIDE_BACK = uint64(C.AV_CH_LAYOUT_7POINT1_WIDE_BACK) + AV_CH_LAYOUT_5POINT1POINT2_BACK = uint64(C.AV_CH_LAYOUT_5POINT1POINT2_BACK) + AV_CH_LAYOUT_OCTAGONAL = uint64(C.AV_CH_LAYOUT_OCTAGONAL) + AV_CH_LAYOUT_CUBE = uint64(C.AV_CH_LAYOUT_CUBE) + AV_CH_LAYOUT_5POINT1POINT4_BACK = uint64(C.AV_CH_LAYOUT_5POINT1POINT4_BACK) + AV_CH_LAYOUT_7POINT1POINT2 = uint64(C.AV_CH_LAYOUT_7POINT1POINT2) + AV_CH_LAYOUT_7POINT1POINT4_BACK = uint64(C.AV_CH_LAYOUT_7POINT1POINT4_BACK) + AV_CH_LAYOUT_HEXADECAGONAL = uint64(C.AV_CH_LAYOUT_HEXADECAGONAL) + AV_CH_LAYOUT_STEREO_DOWNMIX = uint64(C.AV_CH_LAYOUT_STEREO_DOWNMIX) + AV_CH_LAYOUT_22POINT2 = uint64(C.AV_CH_LAYOUT_22POINT2) + + AV_CH_LAYOUT_7POINT1_TOP_BACK = uint64(C.AV_CH_LAYOUT_7POINT1_TOP_BACK) ) // AVMatrixEncoding @@ -373,6 +385,9 @@ func AV_CHANNEL_LAYOUT_6POINT0() *AVChannelLayout { func AV_CHANNEL_LAYOUT_6POINT0_FRONT() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_6point0_front) } +func AV_CHANNEL_LAYOUT_3POINT1POINT2() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_3point1point2) +} func AV_CHANNEL_LAYOUT_HEXAGONAL() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_hexagonal) } @@ -400,8 +415,8 @@ func AV_CHANNEL_LAYOUT_7POINT1_WIDE() *AVChannelLayout { func AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_7point1_wide_back) } -func AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK() *AVChannelLayout { - return (*AVChannelLayout)(&C.av_channel_layout_7point1_top_back) +func AV_CHANNEL_LAYOUT_5POINT1POINT2_BACK() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_5point1point2_back) } func AV_CHANNEL_LAYOUT_OCTAGONAL() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_octagonal) @@ -409,6 +424,15 @@ func AV_CHANNEL_LAYOUT_OCTAGONAL() *AVChannelLayout { func AV_CHANNEL_LAYOUT_CUBE() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_cube) } +func AV_CHANNEL_LAYOUT_5POINT1POINT4_BACK() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_5point1point4_back) +} +func AV_CHANNEL_LAYOUT_7POINT1POINT2() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_7point1point2) +} +func AV_CHANNEL_LAYOUT_7POINT1POINT4_BACK() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_7point1point4_back) +} func AV_CHANNEL_LAYOUT_HEXADECAGONAL() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_hexadecagonal) } @@ -422,6 +446,10 @@ func AV_CHANNEL_LAYOUT_AMBISONIC_FIRST_ORDER() *AVChannelLayout { return (*AVChannelLayout)(&C.av_channel_layout_ambisonic_first_order) } +func AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK() *AVChannelLayout { + return (*AVChannelLayout)(&C.av_channel_layout_7point1_top_back) +} + // Deprecated: Use AvChannelLayoutFromString() instead. // // AvGetChannelLayout returns a channel layout id that matches name, or 0 if no match is found. diff --git a/avutil_executor.go b/avutil_executor.go new file mode 100644 index 0000000..d399071 --- /dev/null +++ b/avutil_executor.go @@ -0,0 +1,141 @@ +// Copyright (c) 2023 QRTC. All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +package ffmpeg + +/* +#include + +typedef int (*av_executor_priority_higher_func)(const AVTask *a, const AVTask *b); + +typedef int (*av_executor_ready_func)(const AVTask *t, void *user_data); + +typedef int (*av_executor_run_func)(AVTask *t, void *local_context, void *user_data); + +*/ +import "C" +import "unsafe" + +// AVExecutor +type AVExecutor C.struct_AVExecutor + +// AVTask +type AVTask C.struct_AVTask + +// GetNext gets `AVTask.next` value. +func (t *AVTask) GetNext() *AVTask { + return (*AVTask)(t.next) +} + +// SetNext sets `AVTask.next` value. +func (t *AVTask) SetNext(v *AVTask) { + t.next = (*C.struct_AVTask)(v) +} + +// GetNextAddr gets `AVTask.next` address. +func (t *AVTask) GetNextAddr() **AVTask { + return (**AVTask)(unsafe.Pointer(&t.next)) +} + +// AVTaskCallbacks +type AVTaskCallbacks C.struct_AVTaskCallbacks + +// typedef int (*av_executor_priority_higher_func)(const AVTask *a, const AVTask *b); +type AvExecutorPriorityHigherFunc = C.av_executor_priority_higher_func + +// typedef int (*av_executor_ready_func)(const AVTask *t, void *user_data); +type AvExecutorReadyFunc = C.av_executor_ready_func + +// typedef int (*av_executor_run_func)(AVTask *t, void *local_context, void *user_data); +type AvExecutorRunFunc = C.av_executor_run_func + +// GetUserData gets `AVTaskCallbacks.user_data` value. +func (cbs *AVTaskCallbacks) GetUserData() unsafe.Pointer { + return cbs.user_data +} + +// SetUserData sets `AVTaskCallbacks.user_data` value. +func (cbs *AVTaskCallbacks) SetUserData(v CVoidPointer) { + cbs.user_data = VoidPointer(v) +} + +// GetUserDataAddr gets `AVTaskCallbacks.user_data` address. +func (cbs *AVTaskCallbacks) GetUserDataAddr() *unsafe.Pointer { + return (*unsafe.Pointer)(&cbs.user_data) +} + +// GetLocalContextSize gets `AVTaskCallbacks.local_context_size` value. +func (cbs *AVTaskCallbacks) GetLocalContextSize() int32 { + return (int32)(cbs.local_context_size) +} + +// SetLocalContextSize sets `AVTaskCallbacks.local_context_size` value. +func (cbs *AVTaskCallbacks) SetLocalContextSize(v int32) { + cbs.local_context_size = (C.int)(v) +} + +// GetLocalContextSizeAddr gets `AVTaskCallbacks.local_context_size` address. +func (cbs *AVTaskCallbacks) GetLocalContextSizeAddr() *int32 { + return (*int32)(&cbs.local_context_size) +} + +// GetPriorityHigher gets `AVTaskCallbacks.priority_higher` value. +func (cbs *AVTaskCallbacks) GetPriorityHigher() AvExecutorPriorityHigherFunc { + return (AvExecutorPriorityHigherFunc)(cbs.priority_higher) +} + +// SetPriorityHigher sets `AVTaskCallbacks.priority_higher` value. +func (cbs *AVTaskCallbacks) SetPriorityHigher(v AvExecutorPriorityHigherFunc) { + cbs.priority_higher = (C.av_executor_priority_higher_func)(v) +} + +// GetPriorityHigherAddr gets `AVTaskCallbacks.priority_higher` address. +func (cbs *AVTaskCallbacks) GetPriorityHigherAddr() *AvExecutorPriorityHigherFunc { + return (*AvExecutorPriorityHigherFunc)(&cbs.priority_higher) +} + +// GetReady gets `AVTaskCallbacks.ready` value. +func (cbs *AVTaskCallbacks) GetReady() AvExecutorReadyFunc { + return (AvExecutorReadyFunc)(cbs.ready) +} + +// SetReady sets `AVTaskCallbacks.ready` value. +func (cbs *AVTaskCallbacks) SetReady(v AvExecutorReadyFunc) { + cbs.ready = (C.av_executor_ready_func)(v) +} + +// GetReadyAddr gets `AVTaskCallbacks.ready` address. +func (cbs *AVTaskCallbacks) GetReadyAddr() *AvExecutorReadyFunc { + return (*AvExecutorReadyFunc)(&cbs.ready) +} + +// GetRun gets `AVTaskCallbacks.run` value. +func (cbs *AVTaskCallbacks) GetRun() AvExecutorRunFunc { + return (AvExecutorRunFunc)(cbs.run) +} + +// SetRun sets `AVTaskCallbacks.run` value. +func (cbs *AVTaskCallbacks) SetRun(v AvExecutorRunFunc) { + cbs.run = (C.av_executor_run_func)(v) +} + +// GetRunAddr gets `AVTaskCallbacks.run` address. +func (cbs *AVTaskCallbacks) GetRunAddr() *AvExecutorRunFunc { + return (*AvExecutorRunFunc)(&cbs.run) +} + +// AvExecutorAlloc allocates executor. +func AvExecutorAlloc(callbacks *AVTaskCallbacks, threadCount int32) *AVExecutor { + return (*AVExecutor)(C.av_executor_alloc((*C.struct_AVTaskCallbacks)(callbacks), (C.int)(threadCount))) +} + +// AvExecutorFree frees executor. +func AvExecutorFree(e **AVExecutor) { + C.av_executor_free((**C.struct_AVExecutor)(unsafe.Pointer(e))) +} + +// AvExecutorExecute adds task to executor. +func AvExecutorExecute(e *AVExecutor, t *AVTask) { + C.av_executor_execute((*C.struct_AVExecutor)(e), (*C.struct_AVTask)(t)) +} diff --git a/avutil_frame.go b/avutil_frame.go index 76e2ef1..1ecdede 100644 --- a/avutil_frame.go +++ b/avutil_frame.go @@ -345,16 +345,22 @@ func (frame *AVFrame) GetFormatAddr() *int32 { return (*int32)(&frame.format) } +// Deprecated: Use AV_FRAME_FLAG_KEY instead. +// // GetKeyFrame gets `AVFrame.key_frame` value. func (frame *AVFrame) GetKeyFrame() int32 { return (int32)(frame.key_frame) } +// Deprecated: Use AV_FRAME_FLAG_KEY instead. +// // SetKeyFrame sets `AVFrame.key_frame` value. func (frame *AVFrame) SetKeyFrame(v int32) { frame.key_frame = (C.int)(v) } +// Deprecated: Use AV_FRAME_FLAG_KEY instead. +// // GetKeyFrameAddr gets `AVFrame.key_frame` address. func (frame *AVFrame) GetKeyFrameAddr() *int32 { return (*int32)(&frame.key_frame) @@ -507,61 +513,85 @@ func (frame *AVFrame) GetRepeatPictAddr() *int32 { return (*int32)(&frame.repeat_pict) } +// Deprecated: Use AV_FRAME_FLAG_INTERLACED instead. +// // GetInterlacedFrame gets `AVFrame.interlaced_frame` value. func (frame *AVFrame) GetInterlacedFrame() int32 { return (int32)(frame.interlaced_frame) } +// Deprecated: Use AV_FRAME_FLAG_INTERLACED instead. +// // SetInterlacedFrame sets `AVFrame.interlaced_frame` value. func (frame *AVFrame) SetInterlacedFrame(v int32) { frame.interlaced_frame = (C.int)(v) } +// Deprecated: Use AV_FRAME_FLAG_INTERLACED instead. +// // GetInterlacedFrameAddr gets `AVFrame.interlaced_frame` address. func (frame *AVFrame) GetInterlacedFrameAddr() *int32 { return (*int32)(&frame.interlaced_frame) } +// Deprecated: Use AV_FRAME_FLAG_TOP_FIELD_FIRST instead. +// // GetTopFieldFirst gets `AVFrame.top_field_first` value. func (frame *AVFrame) GetTopFieldFirst() int32 { return (int32)(frame.top_field_first) } +// Deprecated: Use AV_FRAME_FLAG_TOP_FIELD_FIRST instead. +// // SetTopFieldFirst sets `AVFrame.top_field_first` value. func (frame *AVFrame) SetTopFieldFirst(v int32) { frame.top_field_first = (C.int)(v) } +// Deprecated: Use AV_FRAME_FLAG_TOP_FIELD_FIRST instead. +// // GetTopFieldFirstAddr gets `AVFrame.top_field_first` address. func (frame *AVFrame) GetTopFieldFirstAddr() *int32 { return (*int32)(&frame.top_field_first) } +// Deprecated: no use. +// // GetPaletteHasChanged gets `AVFrame.palette_has_changed` value. func (frame *AVFrame) GetPaletteHasChanged() int32 { return (int32)(frame.palette_has_changed) } +// Deprecated: no use. +// // SetPaletteHasChanged sets `AVFrame.palette_has_changed` value. func (frame *AVFrame) SetPaletteHasChanged(v int32) { frame.palette_has_changed = (C.int)(v) } +// Deprecated: no use. +// // GetPaletteHasChangedAddr gets `AVFrame.palette_has_changed` address. func (frame *AVFrame) GetPaletteHasChangedAddr() *int32 { return (*int32)(&frame.palette_has_changed) } +// Deprecated: Use AV_CODEC_FLAG_COPY_OPAQUE instead. +// // GetReorderedOpaque gets `AVFrame.reordered_opaque` value. func (frame *AVFrame) GetReorderedOpaque() int64 { return (int64)(frame.reordered_opaque) } +// Deprecated: Use AV_CODEC_FLAG_COPY_OPAQUE instead. +// // SetReorderedOpaque sets `AVFrame.reordered_opaque` value. func (frame *AVFrame) SetReorderedOpaque(v int64) { frame.reordered_opaque = (C.int64_t)(v) } +// Deprecated: Use AV_CODEC_FLAG_COPY_OPAQUE instead. +// // GetReorderedOpaqueAddr gets `AVFrame.reordered_opaque` address. func (frame *AVFrame) GetReorderedOpaqueAddr() *int64 { return (*int64)(&frame.reordered_opaque) @@ -622,9 +652,6 @@ func (frame *AVFrame) GetBufAddr() ***AVBufferRef { // GetExtendedBuf gets `AVFrame.extended_buf` value. func (frame *AVFrame) GetExtendedBuf() []*AVBufferRef { - if frame.extended_buf == nil { - return nil - } return unsafe.Slice((**AVBufferRef)(unsafe.Pointer(frame.extended_buf)), frame.nb_extended_buf) } @@ -656,9 +683,6 @@ func (frame *AVFrame) GetNbExtendedBufAddr() *int32 { // GetSideData gets `AVFrame.side_data` value. func (frame *AVFrame) GetSideData() []*AVFrameSideData { - if frame.side_data == nil { - return nil - } return unsafe.Slice((**AVFrameSideData)(unsafe.Pointer(frame.side_data)), frame.nb_side_data) } @@ -688,8 +712,11 @@ func (frame *AVFrame) GetNbSideDataAddr() *int32 { } const ( - AV_FRAME_FLAG_CORRUPT = int32(C.AV_FRAME_FLAG_CORRUPT) - AV_FRAME_FLAG_DISCARD = int32(C.AV_FRAME_FLAG_DISCARD) + AV_FRAME_FLAG_CORRUPT = int32(C.AV_FRAME_FLAG_CORRUPT) + AV_FRAME_FLAG_KEY = int32(C.AV_FRAME_FLAG_KEY) + AV_FRAME_FLAG_DISCARD = int32(C.AV_FRAME_FLAG_DISCARD) + AV_FRAME_FLAG_INTERLACED = int32(C.AV_FRAME_FLAG_INTERLACED) + AV_FRAME_FLAG_TOP_FIELD_FIRST = int32(C.AV_FRAME_FLAG_TOP_FIELD_FIRST) ) // GetFlags gets `AVFrame.flags` value. @@ -1059,6 +1086,11 @@ func AvFrameRef(dst, src *AVFrame) int32 { return (int32)(C.av_frame_ref((*C.struct_AVFrame)(dst), (*C.struct_AVFrame)(src))) } +// AvFrameReplace ensures the destination frame refers to the same data described by the source frame. +func AvFrameReplace(dst, src *AVFrame) int32 { + return (int32)(C.av_frame_replace((*C.struct_AVFrame)(dst), (*C.struct_AVFrame)(src))) +} + // AvFrameClone creates a new frame that references the same data as src. func AvFrameClone(frame *AVFrame) *AVFrame { return (*AVFrame)(C.av_frame_clone((*C.struct_AVFrame)(frame))) diff --git a/avutil_hdr_dynamic_metadata.go b/avutil_hdr_dynamic_metadata.go index 8d46a04..8025937 100644 --- a/avutil_hdr_dynamic_metadata.go +++ b/avutil_hdr_dynamic_metadata.go @@ -631,3 +631,19 @@ func AvDynamicHdrPlusAlloc(size *uintptr) *AVDynamicHDRPlus { func AvDynamicHdrPlusCreateSideData(frame *AVFrame) *AVDynamicHDRPlus { return (*AVDynamicHDRPlus)(C.av_dynamic_hdr_plus_create_side_data((*C.struct_AVFrame)(frame))) } + +// AvDynamicHdrPlusFromT35 parses the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus). +func AvDynamicHdrPlusFromT35(s *AVDynamicHDRPlus, data *uint8, size uintptr) int32 { + return (int32)(C.av_dynamic_hdr_plus_from_t35((*C.struct_AVDynamicHDRPlus)(s), + (*C.uint8_t)(data), (C.size_t)(size))) +} + +const ( + AV_HDR_PLUS_MAX_PAYLOAD_SIZE = C.AV_HDR_PLUS_MAX_PAYLOAD_SIZE +) + +// AvDynamicHdrPlusToT35 serializes dynamic HDR10+ metadata to a user data registered ITU-T T.35 buffer. +func AvDynamicHdrPlusToT35(s *AVDynamicHDRPlus, data **uint8, size *uintptr) int32 { + return (int32)(C.av_dynamic_hdr_plus_to_t35((*C.struct_AVDynamicHDRPlus)(s), + (**C.uint8_t)(unsafe.Pointer(data)), (*C.size_t)(unsafe.Pointer(size)))) +} diff --git a/avutil_hdr_dynamic_vivid_metadata.go b/avutil_hdr_dynamic_vivid_metadata.go index 7dcc78d..4741710 100644 --- a/avutil_hdr_dynamic_vivid_metadata.go +++ b/avutil_hdr_dynamic_vivid_metadata.go @@ -10,6 +10,99 @@ package ffmpeg import "C" import "unsafe" +// AVHDRVivid3SplineParams +type AVHDRVivid3SplineParams C.struct_AVHDRVivid3SplineParams + +// GetThMode gets `AVHDRVivid3SplineParams.th_mode` value. +func (d3sp *AVHDRVivid3SplineParams) GetThMode() int32 { + return (int32)(d3sp.th_mode) +} + +// SetThMode sets `AVHDRVivid3SplineParams.th_mode` value. +func (d3sp *AVHDRVivid3SplineParams) SetThMode(v int32) { + d3sp.th_mode = (C.int)(v) +} + +// GetThModeAddr gets `AVHDRVivid3SplineParams.th_mode` address. +func (d3sp *AVHDRVivid3SplineParams) GetThModeAddr() *int32 { + return (*int32)(&d3sp.th_mode) +} + +// GetThEnableMb gets `AVHDRVivid3SplineParams.th_enable_mb` value. +func (d3sp *AVHDRVivid3SplineParams) GetThEnableMb() AVRational { + return (AVRational)(d3sp.th_enable_mb) +} + +// SetThEnableMb sets `AVHDRVivid3SplineParams.th_enable_mb` value. +func (d3sp *AVHDRVivid3SplineParams) SetThEnableMb(v AVRational) { + d3sp.th_enable_mb = (C.struct_AVRational)(v) +} + +// GetThEnableMbAddr gets `AVHDRVivid3SplineParams.th_enable_mb` address. +func (d3sp *AVHDRVivid3SplineParams) GetThEnableMbAddr() *AVRational { + return (*AVRational)(&d3sp.th_enable_mb) +} + +// GetThEnable gets `AVHDRVivid3SplineParams.th_enable` value. +func (d3sp *AVHDRVivid3SplineParams) GetThEnable() AVRational { + return (AVRational)(d3sp.th_enable) +} + +// SetThEnable sets `AVHDRVivid3SplineParams.th_enable` value. +func (d3sp *AVHDRVivid3SplineParams) SetThEnable(v AVRational) { + d3sp.th_enable = (C.struct_AVRational)(v) +} + +// GetThEnableAddr gets `AVHDRVivid3SplineParams.th_enable` address. +func (d3sp *AVHDRVivid3SplineParams) GetThEnableAddr() *AVRational { + return (*AVRational)(&d3sp.th_enable) +} + +// GetThDelta1 gets `AVHDRVivid3SplineParams.th_delta1` value. +func (d3sp *AVHDRVivid3SplineParams) GetThDelta1() AVRational { + return (AVRational)(d3sp.th_delta1) +} + +// SetThDelta1 sets `AVHDRVivid3SplineParams.th_delta1` value. +func (d3sp *AVHDRVivid3SplineParams) SetThDelta1(v AVRational) { + d3sp.th_delta1 = (C.struct_AVRational)(v) +} + +// GetThDelta1Addr gets `AVHDRVivid3SplineParams.th_delta1` address. +func (d3sp *AVHDRVivid3SplineParams) GetThDelta1Addr() *AVRational { + return (*AVRational)(&d3sp.th_delta1) +} + +// GetThDelta2 gets `AVHDRVivid3SplineParams.th_delta2` value. +func (d3sp *AVHDRVivid3SplineParams) GetThDelta2() AVRational { + return (AVRational)(d3sp.th_delta2) +} + +// SetThDelta2 sets `AVHDRVivid3SplineParams.th_delta2` value. +func (d3sp *AVHDRVivid3SplineParams) SetThDelta2(v AVRational) { + d3sp.th_delta2 = (C.struct_AVRational)(v) +} + +// GetThDelta2Addr gets `AVHDRVivid3SplineParams.th_delta2` address. +func (d3sp *AVHDRVivid3SplineParams) GetThDelta2Addr() *AVRational { + return (*AVRational)(&d3sp.th_delta2) +} + +// GetEnableStrength gets `AVHDRVivid3SplineParams.enable_strength` value. +func (d3sp *AVHDRVivid3SplineParams) GetEnableStrength() AVRational { + return (AVRational)(d3sp.enable_strength) +} + +// SetEnableStrength sets `AVHDRVivid3SplineParams.enable_strength` value. +func (d3sp *AVHDRVivid3SplineParams) SetEnableStrength(v AVRational) { + d3sp.enable_strength = (C.struct_AVRational)(v) +} + +// GetEnableStrengthAddr gets `AVHDRVivid3SplineParams.enable_strength` address. +func (d3sp *AVHDRVivid3SplineParams) GetEnableStrengthAddr() *AVRational { + return (*AVRational)(&d3sp.enable_strength) +} + // AVHDRVividColorToneMappingParams type AVHDRVividColorToneMappingParams C.struct_AVHDRVividColorToneMappingParams @@ -223,96 +316,149 @@ func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineNumAddr() *int32 { return (*int32)(&ctmp.three_Spline_num) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThMode gets `AVHDRVividColorToneMappingParams.three_Spline_TH_mode` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThMode() int32 { return (int32)(ctmp.three_Spline_TH_mode) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineThMode sets `AVHDRVividColorToneMappingParams.three_Spline_TH_mode` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThMode(v int32) { ctmp.three_Spline_TH_mode = (C.int)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThModeAddr gets `AVHDRVividColorToneMappingParams.three_Spline_TH_mode` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThModeAddr() *int32 { return (*int32)(&ctmp.three_Spline_TH_mode) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThEnableMb gets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable_MB` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableMb() AVRational { return (AVRational)(ctmp.three_Spline_TH_enable_MB) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineThEnableMb sets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable_MB` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThEnableMb(v AVRational) { ctmp.three_Spline_TH_enable_MB = (C.struct_AVRational)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThEnableMbAddr gets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable_MB` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableMbAddr() *AVRational { return (*AVRational)(&ctmp.three_Spline_TH_enable_MB) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThEnable gets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnable() AVRational { return (AVRational)(ctmp.three_Spline_TH_enable) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineThEnable sets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThEnable(v AVRational) { ctmp.three_Spline_TH_enable = (C.struct_AVRational)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThEnableAddr gets `AVHDRVividColorToneMappingParams.three_Spline_TH_enable` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThEnableAddr() *AVRational { return (*AVRational)(&ctmp.three_Spline_TH_enable) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThDelta1 gets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta1` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta1() AVRational { return (AVRational)(ctmp.three_Spline_TH_Delta1) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineThDelta1 sets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta1` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThDelta1(v AVRational) { ctmp.three_Spline_TH_Delta1 = (C.struct_AVRational)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThDelta1Addr gets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta1` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta1Addr() *AVRational { return (*AVRational)(&ctmp.three_Spline_TH_Delta1) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThDelta2 gets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta2` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta2() AVRational { return (AVRational)(ctmp.three_Spline_TH_Delta2) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineThDelta2 sets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta2` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineThDelta2(v AVRational) { ctmp.three_Spline_TH_Delta2 = (C.struct_AVRational)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineThDelta2Addr gets `AVHDRVividColorToneMappingParams.three_Spline_TH_Delta2` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineThDelta2Addr() *AVRational { return (*AVRational)(&ctmp.three_Spline_TH_Delta2) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineEnableStrength gets `AVHDRVividColorToneMappingParams.three_Spline_enable_Strength` value. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableStrength() AVRational { return (AVRational)(ctmp.three_Spline_enable_Strength) } +// Deprecated: Use three_spline instead. +// // SetThreeSplineEnableStrength sets `AVHDRVividColorToneMappingParams.three_Spline_enable_Strength` value. func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSplineEnableStrength(v AVRational) { ctmp.three_Spline_enable_Strength = (C.struct_AVRational)(v) } +// Deprecated: Use three_spline instead. +// // GetThreeSplineEnableStrengthAddr gets `AVHDRVividColorToneMappingParams.three_Spline_enable_Strength` address. func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineEnableStrengthAddr() *AVRational { return (*AVRational)(&ctmp.three_Spline_enable_Strength) } +// GetThreeSpline gets `AVHDRVividColorToneMappingParams.three_spline` value. +func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSpline() []AVHDRVivid3SplineParams { + return unsafe.Slice((*AVHDRVivid3SplineParams)(&ctmp.three_spline[0]), 2) +} + +// SetThreeSpline sets `AVHDRVividColorToneMappingParams.three_spline` value. +func (ctmp *AVHDRVividColorToneMappingParams) SetThreeSpline(v []AVHDRVivid3SplineParams) { + for i := 0; i < FFMIN(len(v), 2); i++ { + ctmp.three_spline[i] = (C.struct_AVHDRVivid3SplineParams)(v[i]) + } +} + +// GetThreeSplineAddr gets `AVHDRVividColorToneMappingParams.three_spline` address. +func (ctmp *AVHDRVividColorToneMappingParams) GetThreeSplineAddr() **AVHDRVivid3SplineParams { + return (**AVHDRVivid3SplineParams)(unsafe.Pointer(&ctmp.three_spline)) +} + // AVHDRVividColorTransformParams type AVHDRVividColorTransformParams C.struct_AVHDRVividColorTransformParams diff --git a/avutil_hwcontext_cuda.go b/avutil_hwcontext_cuda.go index f957055..bb74125 100644 --- a/avutil_hwcontext_cuda.go +++ b/avutil_hwcontext_cuda.go @@ -16,4 +16,5 @@ type AVCUDADeviceContextInternal C.struct_AVCUDADeviceContextInternal const ( AV_CUDA_USE_PRIMARY_CONTEXT = C.AV_CUDA_USE_PRIMARY_CONTEXT + AV_CUDA_USE_CURRENT_CONTEXT = C.AV_CUDA_USE_CURRENT_CONTEXT ) diff --git a/avutil_imgutils.go b/avutil_imgutils.go index cd1f409..309c132 100644 --- a/avutil_imgutils.go +++ b/avutil_imgutils.go @@ -121,6 +121,12 @@ func AvImageCopy(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLi (C.enum_AVPixelFormat)(pixFmt), (C.int)(width), (C.int)(height)) } +// AvImageCopy2 is wrapper around AvImageCopy() +func AvImageCopy2(dstData []*uint8, dstLinesizes []int32, srcData []*uint8, srcLinesizes []int32, + pixFmt AVPixelFormat, width, height int32) { + AvImageCopy(dstData, dstLinesizes, srcData, srcLinesizes, pixFmt, width, height) +} + // 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) { diff --git a/avutil_mathematics.go b/avutil_mathematics.go index 04dfa3f..b03abde 100644 --- a/avutil_mathematics.go +++ b/avutil_mathematics.go @@ -75,3 +75,8 @@ 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))) } + +// AvBesselI0 is 0th order modified bessel function of the first kind. +func AvBesselI0(x float64) float64 { + return (float64)(C.av_bessel_i0((C.double)(x))) +} diff --git a/avutil_opt.go b/avutil_opt.go index adf0f4e..970d14e 100644 --- a/avutil_opt.go +++ b/avutil_opt.go @@ -347,9 +347,6 @@ type AVOptionRanges C.struct_AVOptionRanges // 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) } diff --git a/avutil_pixfmt.go b/avutil_pixfmt.go index a3a573a..6448d0a 100644 --- a/avutil_pixfmt.go +++ b/avutil_pixfmt.go @@ -296,6 +296,15 @@ const ( AV_PIX_FMT_RGBAF32BE = AVPixelFormat(C.AV_PIX_FMT_RGBAF32BE) AV_PIX_FMT_RGBAF32LE = AVPixelFormat(C.AV_PIX_FMT_RGBAF32LE) + AV_PIX_FMT_P212BE = AVPixelFormat(C.AV_PIX_FMT_P212BE) + AV_PIX_FMT_P212LE = AVPixelFormat(C.AV_PIX_FMT_P212LE) + + AV_PIX_FMT_P412BE = AVPixelFormat(C.AV_PIX_FMT_P412BE) + AV_PIX_FMT_P412LE = AVPixelFormat(C.AV_PIX_FMT_P412LE) + + AV_PIX_FMT_GBRAP14BE = AVPixelFormat(C.AV_PIX_FMT_GBRAP14BE) + AV_PIX_FMT_GBRAP14LE = AVPixelFormat(C.AV_PIX_FMT_GBRAP14LE) + AV_PIX_FMT_NB = AVPixelFormat(C.AV_PIX_FMT_NB) ) diff --git a/avutil_random_seed.go b/avutil_random_seed.go index 7a3d6f0..bf11e72 100644 --- a/avutil_random_seed.go +++ b/avutil_random_seed.go @@ -13,3 +13,8 @@ import "C" func AvGetRandomSeed() uint32 { return (uint32)(C.av_get_random_seed()) } + +// AvRandomBytes gets a seed to use in conjunction with random functions. +func AvRandomBytes[T Integer](buf *uint8, len T) int32 { + return (int32)(C.av_random_bytes((*C.uint8_t)(buf), (C.size_t)(len))) +} diff --git a/avutil_tx.go b/avutil_tx.go index 54a40da..6b7be41 100644 --- a/avutil_tx.go +++ b/avutil_tx.go @@ -162,9 +162,11 @@ type AvTxFn = C.av_tx_fn type AVTXFlags = C.enum_AVTXFlags const ( - AV_TX_INPLACE = AVTXFlags(C.AV_TX_INPLACE) - AV_TX_UNALIGNED = AVTXFlags(C.AV_TX_UNALIGNED) - AV_TX_FULL_IMDCT = AVTXFlags(C.AV_TX_FULL_IMDCT) + AV_TX_INPLACE = AVTXFlags(C.AV_TX_INPLACE) + AV_TX_UNALIGNED = AVTXFlags(C.AV_TX_UNALIGNED) + AV_TX_FULL_IMDCT = AVTXFlags(C.AV_TX_FULL_IMDCT) + AV_TX_REAL_TO_REAL = AVTXFlags(C.AV_TX_REAL_TO_REAL) + AV_TX_REAL_TO_IMAGINARY = AVTXFlags(C.AV_TX_REAL_TO_IMAGINARY) ) // AvTxInit initializes a transform context with the given configuration diff --git a/avutil_video_hint.go b/avutil_video_hint.go new file mode 100644 index 0000000..a9cded1 --- /dev/null +++ b/avutil_video_hint.go @@ -0,0 +1,167 @@ +// Copyright (c) 2023 QRTC. All rights reserved. +// Use of this source code is governed by a MIT +// license that can be found in the LICENSE file. + +package ffmpeg + +/* +#include +*/ +import "C" +import "unsafe" + +// AVVideoRect +type AVVideoRect C.struct_AVVideoRect + +// GetX gets `AVVideoRect.x` value. +func (rect *AVVideoRect) GetX() uint32 { + return (uint32)(rect.x) +} + +// SetX sets `AVVideoRect.x` value. +func (rect *AVVideoRect) SetX(v uint32) { + rect.x = (C.uint32_t)(v) +} + +// GetXAddr gets `AVVideoRect.x` address. +func (rect *AVVideoRect) GetXAddr() *uint32 { + return (*uint32)(&rect.x) +} + +// GetY gets `AVVideoRect.y` value. +func (rect *AVVideoRect) GetY() uint32 { + return (uint32)(rect.y) +} + +// SetY sets `AVVideoRect.y` value. +func (rect *AVVideoRect) SetY(v uint32) { + rect.y = (C.uint32_t)(v) +} + +// GetYAddr gets `AVVideoRect.y` address. +func (rect *AVVideoRect) GetYAddr() *uint32 { + return (*uint32)(&rect.y) +} + +// GetWidth gets `AVVideoRect.width` value. +func (rect *AVVideoRect) GetWidth() uint32 { + return (uint32)(rect.width) +} + +// SetWidth sets `AVVideoRect.width` value. +func (rect *AVVideoRect) SetWidth(v uint32) { + rect.width = (C.uint32_t)(v) +} + +// GetWidthAddr gets `AVVideoRect.width` address. +func (rect *AVVideoRect) GetWidthAddr() *uint32 { + return (*uint32)(&rect.width) +} + +// GetHeight gets `AVVideoRect.height` value. +func (rect *AVVideoRect) GetHeight() uint32 { + return (uint32)(rect.height) +} + +// SetHeight sets `AVVideoRect.height` value. +func (rect *AVVideoRect) SetHeight(v uint32) { + rect.height = (C.uint32_t)(v) +} + +// GetHeightAddr gets `AVVideoRect.height` address. +func (rect *AVVideoRect) GetHeightAddr() *uint32 { + return (*uint32)(&rect.height) +} + +// AVVideoHintType +type AVVideoHintType = C.AVVideoHintType // C.enum_AVVideoHintType + +const ( + AV_VIDEO_HINT_TYPE_CONSTANT = AVVideoHintType(C.AV_VIDEO_HINT_TYPE_CONSTANT) + AV_VIDEO_HINT_TYPE_CHANGED = AVVideoHintType(C.AV_VIDEO_HINT_TYPE_CHANGED) +) + +// AVVideoHint +type AVVideoHint C.struct_AVVideoHint + +// GetNbRects gets `AVVideoHint.nb_rects` value. +func (hint *AVVideoHint) GetNbRects() uintptr { + return (uintptr)(hint.nb_rects) +} + +// SetNbRects sets `AVVideoHint.nb_rects` value. +func (hint *AVVideoHint) SetNbRects(v uintptr) { + hint.nb_rects = (C.size_t)(v) +} + +// GetNbRectsAddr gets `AVVideoHint.nb_rects` address. +func (hint *AVVideoHint) GetNbRectsAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&hint.nb_rects)) +} + +// GetRectOffset gets `AVVideoHint.rect_offset` value. +func (hint *AVVideoHint) GetRectOffset() uintptr { + return (uintptr)(hint.rect_offset) +} + +// SetRectOffset sets `AVVideoHint.rect_offset` value. +func (hint *AVVideoHint) SetRectOffset(v uintptr) { + hint.rect_offset = (C.size_t)(v) +} + +// GetRectOffsetAddr gets `AVVideoHint.rect_offset` address. +func (hint *AVVideoHint) GetRectOffsetAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&hint.rect_offset)) +} + +// GetRectSize gets `AVVideoHint.rect_size` value. +func (hint *AVVideoHint) GetRectSize() uintptr { + return (uintptr)(hint.rect_size) +} + +// SetRectSize sets `AVVideoHint.rect_size` value. +func (hint *AVVideoHint) SetRectSize(v uintptr) { + hint.rect_size = (C.size_t)(v) +} + +// GetRectSizeAddr gets `AVVideoHint.rect_size` address. +func (hint *AVVideoHint) GetRectSizeAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&hint.rect_size)) +} + +// GetType gets `AVVideoHint.type` value. +func (hint *AVVideoHint) GetType() AVVideoHintType { + return (AVVideoHintType)(hint._type) +} + +// SetType sets `AVVideoHint.type` value. +func (hint *AVVideoHint) SetType(v AVVideoHintType) { + hint._type = (C.AVVideoHintType)(v) +} + +// GetTypeAddr gets `AVVideoHint.type` address. +func (hint *AVVideoHint) GetTypeAddr() *AVVideoHintType { + return (*AVVideoHintType)(&hint._type) +} + +// AvVideoHintRects +func AvVideoHintRects(hints *AVVideoHint) *AVVideoRect { + return (*AVVideoRect)(C.av_video_hint_rects((*C.struct_AVVideoHint)(hints))) +} + +// AvVideoHintGetRect +func AvVideoHintGetRect(hints *AVVideoHint, idx uintptr) *AVVideoRect { + return (*AVVideoRect)(C.av_video_hint_get_rect((*C.struct_AVVideoHint)(hints), (C.size_t)(idx))) +} + +// AvVideoHintAlloc allocates memory for the AVVideoHint struct along with an nb_rects-sized +// arrays of AVVideoRect. +func AvVideoHintAlloc(nbRects uintptr, outSize *uintptr) *AVVideoHint { + return (*AVVideoHint)(C.av_video_hint_alloc((C.size_t)(nbRects), (*C.size_t)(unsafe.Pointer(outSize)))) +} + +// AvVideoHintCreateSideData same as AvVideoHintAlloc(), except newly-allocated AVVideoHint is attached +// as side data of type AV_FRAME_DATA_VIDEO_HINT_INFO to frame. +func AvVideoHintCreateSideData(frame *AVFrame, nbRects uintptr) *AVVideoHint { + return (*AVVideoHint)(C.av_video_hint_create_side_data((*C.struct_AVFrame)(frame), (C.size_t)(nbRects))) +}