From e1639186190a8f532481653ed376e039f27942d1 Mon Sep 17 00:00:00 2001 From: aggresss Date: Sun, 22 Oct 2023 11:46:19 +0800 Subject: [PATCH] 2023-10-22 11:46:19 CST W43D0 --- avcodec.go | 246 ++++++++---------- avcodec_ac3_parser.go | 2 +- avcodec_avdct.go | 155 +++++++++++ avcodec_avfft.go | 12 +- avcodec_d3d11va.go | 13 + avcodec_dirac.go | 434 +++++++++++++++++++++++++++++++ avcodec_dv_profile.go | 296 +++++++++++++++++++++ avcodec_dvxa2.go | 17 ++ avcodec_jni.go | 16 ++ avcodec_mediacodec.go | 45 ++++ avcodec_packet.go | 2 +- avcodec_qsv.go | 17 ++ avcodec_vaapi.go | 11 + avcodec_vdpau.go | 42 +++ avcodec_videotoolbox.go | 33 +++ avcodec_xvmc.go | 15 ++ avdevice.go | 12 +- avfilter.go | 24 -- avformat.go | 26 +- avformat_avio.go | 6 +- avutil_adler32.go | 13 + avutil_aes.go | 26 ++ avutil_aes_ctr.go | 60 +++++ avutil_assert.go | 19 ++ avutil_attributes.go | 6 + avutil_avstring.go | 86 ++++++ avutil_base64.go | 26 ++ avutil_blowfish.go | 87 +++++++ avutil_bprint.go | 82 ++++++ avutil_bswap.go | 21 ++ avutil_camellia.go | 26 ++ avutil_cast5.go | 33 +++ avutil_error.go | 4 +- avutil_file.go | 34 +++ avutil_frame.go | 148 ++++------- avutil_hwcontext_cuda.go | 15 ++ avutil_hwcontext_d3d11va.go | 17 ++ avutil_hwcontext_drm.go | 27 ++ avutil_hwcontext_dxva2.go | 14 + avutil_hwcontext_mediacodec.go | 11 + avutil_hwcontext_opencl.go | 17 ++ avutil_hwcontext_qsv.go | 14 + avutil_hwcontext_vaapi.go | 24 ++ avutil_hwcontext_vdpau.go | 11 + avutil_hwcontext_videotoolbox.go | 24 ++ avutil_hwcontext_vulkan.go | 28 ++ avutil_imgutils.go | 2 +- avutil_opt.go | 8 - avutil_pixdesc.go | 23 +- avutil_tea.go | 28 ++ examples/avio-list-dir/main.go | 110 +++++++- examples/avio-reading/main.go | 115 +++++++- examples/decode-audio/main.go | 4 +- examples/decode-video/main.go | 2 +- examples/encode-audio/main.go | 2 +- examples/encode-video/main.go | 12 +- examples/filter-audio/main.go | 4 + examples/hw-decode/main.go | 27 +- examples/metadata/main.go | 37 ++- examples/scaling-video/main.go | 2 +- examples/transcode-aac/main.go | 2 +- ffmpeg_helper.go | 6 +- 62 files changed, 2326 insertions(+), 355 deletions(-) create mode 100644 avcodec_dirac.go create mode 100644 avcodec_dv_profile.go create mode 100644 avcodec_dvxa2.go create mode 100644 avcodec_jni.go create mode 100644 avcodec_mediacodec.go create mode 100644 avcodec_qsv.go create mode 100644 avcodec_vaapi.go create mode 100644 avcodec_vdpau.go create mode 100644 avcodec_videotoolbox.go create mode 100644 avcodec_xvmc.go create mode 100644 avutil_adler32.go create mode 100644 avutil_aes.go create mode 100644 avutil_aes_ctr.go create mode 100644 avutil_assert.go create mode 100644 avutil_attributes.go create mode 100644 avutil_avstring.go create mode 100644 avutil_base64.go create mode 100644 avutil_blowfish.go create mode 100644 avutil_bprint.go create mode 100644 avutil_bswap.go create mode 100644 avutil_camellia.go create mode 100644 avutil_cast5.go create mode 100644 avutil_file.go create mode 100644 avutil_hwcontext_cuda.go create mode 100644 avutil_hwcontext_d3d11va.go create mode 100644 avutil_hwcontext_drm.go create mode 100644 avutil_hwcontext_dxva2.go create mode 100644 avutil_hwcontext_mediacodec.go create mode 100644 avutil_hwcontext_opencl.go create mode 100644 avutil_hwcontext_qsv.go create mode 100644 avutil_hwcontext_vaapi.go create mode 100644 avutil_hwcontext_vdpau.go create mode 100644 avutil_hwcontext_videotoolbox.go create mode 100644 avutil_hwcontext_vulkan.go create mode 100644 avutil_tea.go diff --git a/avcodec.go b/avcodec.go index 233e22e..83bfbcb 100644 --- a/avcodec.go +++ b/avcodec.go @@ -20,7 +20,9 @@ typedef int (*avcodec_context_get_encode_buffer_func)(struct AVCodecContext *s, typedef int (*av_lockmgr_cb)(void **mutex, enum AVLockOp op); */ import "C" -import "unsafe" +import ( + "unsafe" +) const ( // Required number of additionally allocated bytes at the end of the input bitstream for decoding. @@ -159,6 +161,18 @@ func (psn *AVPanScan) GetPosition() []int16 { return unsafe.Slice((*int16)(&psn.position[0][0]), 3*2) } +// Custom: SetPosition sets `AVPanScan.position` value. +func (psn *AVPanScan) SetPosition(v []int16) { + for i := 0; i < FFMIN(len(v), 3*2); i++ { + psn.position[i/2][i%2] = (C.int16_t)(v[i]) + } +} + +// Custom: GetPositionAddr gets `AVPanScan.position` address. +func (psn *AVPanScan) GetPositionAddr() **int16 { + return (**int16)(unsafe.Pointer(&psn.position)) +} + // Custom: GetPositionIdx gets `AVPanScan.position` index value. func (psn *AVPanScan) GetPositionIdx(x, y int) int16 { return (int16)(psn.position[x][y]) @@ -2395,19 +2409,16 @@ func (avctx *AVCodecContext) GetError() []uint64 { return unsafe.Slice((*uint64)(&avctx.error[0]), AV_NUM_DATA_POINTERS) } -// Custom: GetErrorIdx gets `AVCodecContext.error` value. -func (avctx *AVCodecContext) GetErrorIdx(idx int) uint64 { - return (uint64)(avctx.error[idx]) +// Custom: SetError sets `AVCodecContext.error` value. +func (avctx *AVCodecContext) SetError(v []uint64) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + avctx.error[i] = (C.uint64_t)(v[i]) + } } -// Custom: SetErrorIdx sets `AVCodecContext.error` value. -func (avctx *AVCodecContext) SetErrorIdx(idx int, v uint64) { - avctx.error[idx] = (C.uint64_t)(v) -} - -// Custom: GetErrorIdxAddr gets `AVCodecContext.error` address. -func (avctx *AVCodecContext) GetErrorIdxAddr(idx int) *uint64 { - return (*uint64)(&avctx.error[idx]) +// Custom: GetErrorAddr gets `AVCodecContext.error` address. +func (avctx *AVCodecContext) GetErrorAddr() **uint64 { + return (**uint64)(unsafe.Pointer(&avctx.error)) } // Custom: GetDctAlgo gets `AVCodecContext.dct_algo` value. @@ -3472,23 +3483,20 @@ const ( type AVPicture C.struct_AVPicture // Custom: GetData gets `AVPicture.data` value. -func (pct *AVPicture) GetData(idx int) []*uint8 { +func (pct *AVPicture) GetData() []*uint8 { return unsafe.Slice((**uint8)(unsafe.Pointer(&pct.data[0])), AV_NUM_DATA_POINTERS) } -// Custom: GetDataIdx gets `AVPicture.data` index value. -func (pct *AVPicture) GetDataIdx(idx int) *uint8 { - return (*uint8)(pct.data[idx]) +// Custom: SetData sets `AVPicture.data` value. +func (pct *AVPicture) SetData(v []*uint8) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + pct.data[i] = (*C.uint8_t)(v[i]) + } } -// Custom: SetDataIdx sets `AVPicture.data` index value. -func (pct *AVPicture) SetDataIdx(idx int, v *uint8) { - pct.data[idx] = (*C.uint8_t)(v) -} - -// Custom: GetDataIdxAddr gets `AVPicture.data` index address. -func (pct *AVPicture) GetDataIdxAddr(idx int) **uint8 { - return (**uint8)(unsafe.Pointer(&pct.data[idx])) +// Custom: GetDataAddr gets `AVPicture.data` address. +func (pct *AVPicture) GetDataAddr() ***uint8 { + return (***uint8)(unsafe.Pointer(&pct.data)) } // Custom: GetLinesize gets `AVPicture.linesize` value. @@ -3496,19 +3504,16 @@ func (pct *AVPicture) GetLinesize() []int32 { return unsafe.Slice((*int32)(&pct.linesize[0]), AV_NUM_DATA_POINTERS) } -// Custom: GetLinesizeIdx gets `AVPicture.linesize` index value. -func (pct *AVPicture) GetLinesizeIdx(idx int) int32 { - return (int32)(pct.linesize[idx]) +// Custom: SetLinesize sets `AVPicture.linesize` value. +func (pct *AVPicture) SetLinesize(v []int32) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + pct.linesize[i] = (C.int)(v[i]) + } } -// Custom: SetLinesizeIdx sets `AVPicture.linesize` index value. -func (pct *AVPicture) SetLinesizeIdx(idx int, v int32) { - pct.linesize[idx] = (C.int)(v) -} - -// Custom: GetLinesizeIdxAddr gets `AVPicture.linesize` index address. -func (pct *AVPicture) GetLinesizeIdxAddr(idx int) *int32 { - return (*int32)(&pct.linesize[idx]) +// Custom: GetLinesizeAddr gets `AVPicture.linesize` address. +func (pct *AVPicture) GetLinesizeAddr() **int32 { + return (**int32)(unsafe.Pointer(&pct.linesize)) } // AVSubtitleType @@ -3621,19 +3626,16 @@ func (sbtr *AVSubtitleRect) GetData() []*uint8 { return unsafe.Slice((**uint8)(unsafe.Pointer(&sbtr.data[0])), 4) } -// Custom: GetDataIdx gets `AVSubtitleRect.data` index value. -func (sbtr *AVSubtitleRect) GetDataIdx(idx int) *uint8 { - return (*uint8)(sbtr.data[idx]) +// Custom: SetData sets `AVSubtitleRect.data` value. +func (sbtr *AVSubtitleRect) SetData(v []*uint8) { + for i := 0; i < FFMIN(len(v), 4); i++ { + sbtr.data[i] = (*C.uint8_t)(v[i]) + } } -// Custom: SetDataIdx sets `AVSubtitleRect.data` index value. -func (sbtr *AVSubtitleRect) SetDataIdx(idx int, v *uint8) { - sbtr.data[idx] = (*C.uint8_t)(v) -} - -// Custom: GetDataIdxAddr gets `AVSubtitleRect.data` index address. -func (sbtr *AVSubtitleRect) GetDataIdxAddr(idx int) **uint8 { - return (**uint8)(unsafe.Pointer(&sbtr.data[idx])) +// Custom: GetDataAddr gets `AVSubtitleRect.data` address. +func (sbtr *AVSubtitleRect) GetDataAddr() ***uint8 { + return (***uint8)(unsafe.Pointer(&sbtr.data)) } // Custom: GetLinesize gets `AVSubtitleRect.linesize` value. @@ -3641,19 +3643,16 @@ func (sbtr *AVSubtitleRect) GetLinesize() []int32 { return unsafe.Slice((*int32)(&sbtr.linesize[0]), 4) } -// Custom: GetLinesizeIdx gets `AVSubtitleRect.linesize` index value. -func (sbtr *AVSubtitleRect) GetLinesizeIdx(idx int) int32 { - return (int32)(sbtr.linesize[idx]) +// Custom: SetLinesize sets `AVSubtitleRect.linesize` value. +func (sbtr *AVSubtitleRect) SetLinesize(v []int32) { + for i := 0; i < FFMIN(len(v), 4); i++ { + sbtr.linesize[i] = (C.int)(v[i]) + } } -// Custom: SetLinesizeIdx sets `AVSubtitleRect.linesize` index value. -func (sbtr *AVSubtitleRect) SetLinesizeIdx(idx int, v int32) { - sbtr.linesize[idx] = (C.int)(v) -} - -// Custom: GetLinesizeIdxAddr gets `AVSubtitleRect.linesize` index address. -func (sbtr *AVSubtitleRect) GetLinesizeIdxAddr(idx int) *int32 { - return (*int32)(&sbtr.linesize[idx]) +// Custom: GetLinesize gets `AVSubtitleRect.linesize` address. +func (sbtr *AVSubtitleRect) GetLinesizeAddr() **int32 { + return (**int32)(unsafe.Pointer(&sbtr.linesize)) } // Custom: GetType gets `AVSubtitleRect._type` value. @@ -3777,14 +3776,6 @@ func (sbt *AVSubtitle) GetRectsAddr() ***AVSubtitleRect { return (***AVSubtitleRect)(unsafe.Pointer(&sbt.rects)) } -// Custom: GetRectsIdx gets `AVSubtitle.rects` index value. -func (sbt *AVSubtitle) GetRectsIdx(idx int) *AVSubtitleRect { - if idx >= int(sbt.num_rects) { - return nil - } - return PointerOffset((*AVSubtitleRect)(*sbt.rects), idx) -} - // Custom: GetPts gets `AVSubtitle.pts` value. func (sbt *AVSubtitle) GetPts() int64 { return (int64)(sbt.pts) @@ -4189,23 +4180,20 @@ func (cpc *AVCodecParserContext) GetCurFrameStartIndexAddr() *int32 { } // Custom: GetCurFrameOffset gets `AVCodecParserContext.cur_frame_offset` value. -func (cpc *AVCodecParserContext) GetCurFrameOffset(idx int) []int64 { +func (cpc *AVCodecParserContext) GetCurFrameOffset() []int64 { return unsafe.Slice((*int64)(&cpc.cur_frame_offset[0]), AV_PARSER_PTS_NB) } -// Custom: GetCurFrameOffsetIdx gets `AVCodecParserContext.cur_frame_offset` index value. -func (cpc *AVCodecParserContext) GetCurFrameOffsetIdx(idx int) int64 { - return (int64)(cpc.cur_frame_offset[idx]) +// Custom: SetCurFrameOffset sets `AVCodecParserContext.cur_frame_offset` value. +func (cpc *AVCodecParserContext) SetCurFrameOffset(v []int64) { + for i := 0; i < FFMIN(len(v), AV_PARSER_PTS_NB); i++ { + cpc.cur_frame_offset[i] = (C.int64_t)(v[i]) + } } -// Custom: SetCurFrameOffsetIdx sets `AVCodecParserContext.cur_frame_offset` index value. -func (cpc *AVCodecParserContext) SetCurFrameOffsetIdx(idx int, v int64) { - cpc.cur_frame_offset[idx] = (C.int64_t)(v) -} - -// Custom: GetCurFrameOffsetIdxAddr gets `AVCodecParserContext.cur_frame_offset` index address. -func (cpc *AVCodecParserContext) GetCurFrameOffsetIdxAddr(idx int) *int64 { - return (*int64)(&cpc.cur_frame_offset[idx]) +// Custom: GetCurFrameOffsetAddr gets `AVCodecParserContext.cur_frame_offset` address. +func (cpc *AVCodecParserContext) GetCurFrameOffsetAddr() **int64 { + return (**int64)(unsafe.Pointer(&cpc.cur_frame_offset)) } // Custom: GetCurFramePts gets `AVCodecParserContext.cur_frame_pts` value. @@ -4213,19 +4201,16 @@ func (cpc *AVCodecParserContext) GetCurFramePts() []int64 { return unsafe.Slice((*int64)(&cpc.cur_frame_pts[0]), AV_PARSER_PTS_NB) } -// Custom: GetCurFramePtsIdx gets `AVCodecParserContext.cur_frame_pts` index value. -func (cpc *AVCodecParserContext) GetCurFramePtsIdx(idx int) int64 { - return (int64)(cpc.cur_frame_pts[idx]) +// Custom: SetCurFramePts sets `AVCodecParserContext.cur_frame_pts` value. +func (cpc *AVCodecParserContext) SetCurFramePts(v []int64) { + for i := 0; i < FFMIN(len(v), AV_PARSER_PTS_NB); i++ { + cpc.cur_frame_pts[i] = (C.int64_t)(v[i]) + } } -// Custom: SetCurFramePtsIdx sets `AVCodecParserContext.cur_frame_pts` index value. -func (cpc *AVCodecParserContext) SetCurFramePtsIdx(idx int, v int64) { - cpc.cur_frame_pts[idx] = (C.int64_t)(v) -} - -// Custom: GetCurFramePtsIdxAddr gets `AVCodecParserContext.cur_frame_pts` index address. -func (cpc *AVCodecParserContext) GetCurFramePtsIdxAddr(idx int) *int64 { - return (*int64)(&cpc.cur_frame_pts[idx]) +// Custom: GetCurFramePtsAddr gets `AVCodecParserContext.cur_frame_pts` address. +func (cpc *AVCodecParserContext) GetCurFramePtsAddr() **int64 { + return (**int64)(unsafe.Pointer(&cpc.cur_frame_pts)) } // Custom: GetCurFrameDts gets `AVCodecParserContext.cur_frame_dts` value. @@ -4233,19 +4218,16 @@ func (cpc *AVCodecParserContext) GetCurFrameDts() []int64 { return unsafe.Slice((*int64)(&cpc.cur_frame_dts[0]), AV_PARSER_PTS_NB) } -// Custom: GetCurFrameDtsIdx gets `AVCodecParserContext.cur_frame_dts` index value. -func (cpc *AVCodecParserContext) GetCurFrameDtsIdx(idx int) int64 { - return (int64)(cpc.cur_frame_dts[idx]) +// Custom: SetCurFrameDts sets `AVCodecParserContext.cur_frame_dts` value. +func (cpc *AVCodecParserContext) SetCurFrameDts(v []int64) { + for i := 0; i < FFMIN(len(v), AV_PARSER_PTS_NB); i++ { + cpc.cur_frame_dts[i] = (C.int64_t)(v[i]) + } } -// Custom: SetCurFrameDtsIdx sets `AVCodecParserContext.cur_frame_dts` index value. -func (cpc *AVCodecParserContext) SetCurFrameDtsIdx(idx int, v int64) { - cpc.cur_frame_dts[idx] = (C.int64_t)(v) -} - -// Custom: GetCurFrameDtsIdxAddr gets `AVCodecParserContext.cur_frame_dts` index address. -func (cpc *AVCodecParserContext) GetCurFrameDtsIdxAddr(idx int) *int64 { - return (*int64)(&cpc.cur_frame_dts[idx]) +// Custom: GetCurFrameDtsAddr gets `AVCodecParserContext.cur_frame_dts` address. +func (cpc *AVCodecParserContext) GetCurFrameDtsAddr() **int64 { + return (**int64)(unsafe.Pointer(&cpc.cur_frame_dts)) } // Custom: GetOffset gets `AVCodecParserContext.offset` value. @@ -4268,19 +4250,16 @@ func (cpc *AVCodecParserContext) GetCurFrameEnd() []int64 { return unsafe.Slice((*int64)(&cpc.cur_frame_end[0]), AV_PARSER_PTS_NB) } -// Custom: GetCurFrameEndIdx gets `AVCodecParserContext.cur_frame_end` index value. -func (cpc *AVCodecParserContext) GetCurFrameEndIdx(idx int) int64 { - return (int64)(cpc.cur_frame_end[idx]) +// Custom: SetCurFrameEnd sets `AVCodecParserContext.cur_frame_end` value. +func (cpc *AVCodecParserContext) SetCurFrameEnd(v []int64) { + for i := 0; i < FFMIN(len(v), AV_PARSER_PTS_NB); i++ { + cpc.cur_frame_end[i] = (C.int64_t)(v[i]) + } } -// Custom: SetCurFrameEndIdx sets `AVCodecParserContext.cur_frame_end` index value. -func (cpc *AVCodecParserContext) SetCurFrameEndIdx(idx int, v int64) { - cpc.cur_frame_end[idx] = (C.int64_t)(v) -} - -// Custom: GetCurFrameEndIdxAddr gets `AVCodecParserContext.cur_frame_end` index address. -func (cpc *AVCodecParserContext) GetCurFrameEndIdxAddr(idx int) *int64 { - return (*int64)(&cpc.cur_frame_end[idx]) +// Custom: GetCurFrameEndAddr gets `AVCodecParserContext.cur_frame_end` address. +func (cpc *AVCodecParserContext) GetCurFrameEndAddr() **int64 { + return (**int64)(unsafe.Pointer(&cpc.cur_frame_end)) } // Custom: GetKeyFrame gets `AVCodecParserContext.key_frame` value. @@ -4358,19 +4337,21 @@ func (cpc *AVCodecParserContext) GetPtsDtsDeltaAddr() *int32 { return (*int32)(&cpc.pts_dts_delta) } -// Custom: GetCurFramePosIdx gets `AVCodecParserContext.cur_frame_pos` value. -func (cpc *AVCodecParserContext) GetCurFramePosIdx(idx int) int64 { - return (int64)(cpc.cur_frame_pos[idx]) +// Custom: GetCurFramePos gets `AVCodecParserContext.cur_frame_pos` value. +func (cpc *AVCodecParserContext) GetCurFramePos() []int64 { + return unsafe.Slice((*int64)(&cpc.cur_frame_pos[0]), AV_PARSER_PTS_NB) } -// Custom: SetCurFramePosIdx sets `AVCodecParserContext.cur_frame_pos` value. -func (cpc *AVCodecParserContext) SetCurFramePosIdx(idx int, v int64) { - cpc.cur_frame_pos[idx] = (C.int64_t)(v) +// Custom: SetCurFramePos sets `AVCodecParserContext.cur_frame_pos` value. +func (cpc *AVCodecParserContext) SetCurFramePos(v []int64) { + for i := 0; i < FFMIN(len(v), AV_PARSER_PTS_NB); i++ { + cpc.cur_frame_pos[i] = (C.int64_t)(v[i]) + } } -// Custom: GetCurFramePosIdxAddr gets `AVCodecParserContext.cur_frame_pos` address. -func (cpc *AVCodecParserContext) GetCurFramePosIdxAddr(idx int) *int64 { - return (*int64)(&cpc.cur_frame_pos[idx]) +// Custom: GetCurFramePosAddr gets `AVCodecParserContext.cur_frame_pos` address. +func (cpc *AVCodecParserContext) GetCurFramePosAddr() **int64 { + return (**int64)(unsafe.Pointer(&cpc.cur_frame_pos)) } // Custom: GetPos gets `AVCodecParserContext.pos` value. @@ -4546,19 +4527,16 @@ func (cp *AVCodecParser) GetCodecIds() []int32 { return unsafe.Slice((*int32)(&cp.codec_ids[0]), 5) } -// Custom: GetCodecIdsIdx gets `AVCodecParser.codec_ids` index value. -func (cp *AVCodecParser) GetCodecIdsIdx(idx int) int32 { - return (int32)(cp.codec_ids[idx]) +// Custom: SetCodecIds sets `AVCodecParser.codec_ids` value. +func (cp *AVCodecParser) SetCodecIds(v []int32) { + for i := 0; i < FFMIN(len(v), 5); i++ { + cp.codec_ids[i] = (C.int)(v[i]) + } } -// Custom: SetCodecIdsIdx sets `AVCodecParser.codec_ids` index value. -func (cp *AVCodecParser) SetCodecIdsIdx(idx int, v int32) { - cp.codec_ids[idx] = (C.int)(v) -} - -// Custom: GetCodecIdsIdxAddr gets `AVCodecParser.codec_ids` index address. -func (cp *AVCodecParser) GetCodecIdsIdxAddr(idx int) *int32 { - return (*int32)(&cp.codec_ids[idx]) +// Custom: GetCodecIdsAddr gets `AVCodecParser.codec_ids` address. +func (cp *AVCodecParser) GetCodecIdsAddr() *int32 { + return (*int32)(unsafe.Pointer(&cp.codec_ids)) } // Custom: GetPrivDataSize gets `AVCodecParser.priv_data_size` value. @@ -4745,7 +4723,7 @@ func AvCodecDefaultGetFormat(avctx *AVCodecContext, fmt *AVPixelFormat) AVPixelF } // Deprecated: Use AvFourccMakeString() or AvFourcc2str() instead. -func AvGetCodecTagString(buf *int8, bufSize uint, codecTag uint32) int32 { +func AvGetCodecTagString(buf *int8, bufSize uintptr, codecTag uint32) int32 { return (int32)(C.av_get_codec_tag_string((*C.char)(buf), (C.size_t)(bufSize), (C.uint)(codecTag))) } @@ -4891,12 +4869,12 @@ func AvBsfNext(opaque CVoidPointerPointer) *AVBitStreamFilter { } // AvFastPaddedMalloc -func AvFastPaddedMalloc(ptr CVoidPointer, size *uint32, minSize uint) { +func AvFastPaddedMalloc(ptr CVoidPointer, size *uint32, minSize uintptr) { C.av_fast_padded_malloc(VoidPointer(ptr), (*C.uint)(size), (C.size_t)(minSize)) } // AvFastPaddedMallocz -func AvFastPaddedMallocz(ptr CVoidPointer, size *uint32, minSize uint) { +func AvFastPaddedMallocz(ptr CVoidPointer, size *uint32, minSize uintptr) { C.av_fast_padded_mallocz(VoidPointer(ptr), (*C.uint)(size), (C.size_t)(minSize)) } @@ -4941,6 +4919,6 @@ func AvCodecIsOpen(avctx *AVCodecContext) int32 { // AvCpbPropertiesAlloc allocates a CPB properties structure and initialize its fields to default // values. -func AvCpbPropertiesAlloc(size *uint) *AVCPBProperties { +func AvCpbPropertiesAlloc(size *uintptr) *AVCPBProperties { return (*AVCPBProperties)(C.av_cpb_properties_alloc((*C.size_t)(unsafe.Pointer(size)))) } diff --git a/avcodec_ac3_parser.go b/avcodec_ac3_parser.go index ae55bbf..11b47ab 100644 --- a/avcodec_ac3_parser.go +++ b/avcodec_ac3_parser.go @@ -6,7 +6,7 @@ package ffmpeg import "C" // AvAc3ParseHeader extracts the bitstream ID and the frame size from AC-3 data. -func AvAc3ParseHeader(buf *uint8, size uint, bitstreamID *uint8, frameSize *uint16) int32 { +func AvAc3ParseHeader(buf *uint8, size uintptr, bitstreamID *uint8, frameSize *uint16) int32 { return (int32)(C.av_ac3_parse_header((*C.uint8_t)(buf), (C.size_t)(size), (*C.uint8_t)(bitstreamID), (*C.uint16_t)(frameSize))) } diff --git a/avcodec_avdct.go b/avcodec_avdct.go index 540ccf5..52fe7a7 100644 --- a/avcodec_avdct.go +++ b/avcodec_avdct.go @@ -2,12 +2,167 @@ package ffmpeg /* #include + +typedef void (*avdct_idct_func)(int16_t *block); +typedef void (*avdct_fdct_func)(int16_t *block); +typedef void (*avdct_get_pixels_func)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size); +typedef void (*avdct_get_pixels_unaligned_func)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size); */ import "C" +import "unsafe" // AVDCT type AVDCT C.struct_AVDCT +// typedef void (*avdct_idct_func)(int16_t *block); +type AVDCTIdctFunc = C.avdct_idct_func + +// typedef void (*avdct_fdct_func)(int16_t *block); +type AVDCTFdctFunc = C.avdct_fdct_func + +// typedef void (*avdct_get_pixels_func)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size); +type AVDCTGetPixelsFunc = C.avdct_get_pixels_func + +// typedef void (*avdct_get_pixels_unaligned_func)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size); +type AVDCTGetPixelsUnalignedFunc = C.avdct_get_pixels_unaligned_func + +// Custom: GetAvClass gets `AVDCT.av_class` value. +func (dct *AVDCT) GetAvClass() *AVClass { + return (*AVClass)(dct.av_class) +} + +// Custom: SetAvClass sets `AVDCT.av_class` value. +func (dct *AVDCT) SetAvClass(v *AVClass) { + dct.av_class = (*C.struct_AVClass)(v) +} + +// Custom: GetAvClassAddr gets `AVDCT.av_class` address. +func (dct *AVDCT) GetAvClassAddr() **AVClass { + return (**AVClass)(unsafe.Pointer(&dct.av_class)) +} + +// Custom: GetIdct gets `AVDCT.idct` value. +func (dct *AVDCT) GetIdct() AVDCTIdctFunc { + return (AVDCTIdctFunc)(dct.idct) +} + +// Custom: SetIdct sets `AVDCT.idct` value. +func (dct *AVDCT) SetIdct(v AVDCTIdctFunc) { + dct.idct = (C.avdct_idct_func)(v) +} + +// Custom: GetIdctAddr gets `AVDCT.idct` address. +func (dct *AVDCT) GetIdctAddr() *AVDCTIdctFunc { + return (*AVDCTIdctFunc)(&dct.idct) +} + +// Custom: GetIdctPermutation gets `AVDCT.idct_permutation` value. +func (dct *AVDCT) GetIdctPermutation() []uint8 { + return unsafe.Slice((*uint8)(&dct.idct_permutation[0]), 64) +} + +// Custom: SetIdctPermutation sets `AVDCT.idct_permutation` value. +func (dct *AVDCT) SetIdctPermutation(v []uint8) { + for i := 0; i < FFMIN(len(v), 64); i++ { + dct.idct_permutation[i] = (C.uint8_t)(v[i]) + } +} + +// Custom: GetIdctPermutationAddr gets `AVDCT.idct_permutation` address. +func (dct *AVDCT) GetIdctPermutationAddr() **uint8 { + return (**uint8)(unsafe.Pointer(&dct.idct_permutation)) +} + +// Custom: GetFdct gets `AVDCT.fdct` value. +func (dct *AVDCT) GetFdct() AVDCTFdctFunc { + return (AVDCTFdctFunc)(dct.fdct) +} + +// Custom: SetFdct sets `AVDCT.fdct` value. +func (dct *AVDCT) SetFdct(v AVDCTFdctFunc) { + dct.fdct = (C.avdct_fdct_func)(v) +} + +// Custom: GetFdctAddr gets `AVDCT.fdct` address. +func (dct *AVDCT) GetFdctAddr() *AVDCTFdctFunc { + return (*AVDCTFdctFunc)(&dct.fdct) +} + +// Custom: GetDctAlgo gets `AVDCT.dct_algo` value. +func (dct *AVDCT) GetDctAlgo() int32 { + return (int32)(dct.dct_algo) +} + +// Custom: SetDctAlgo sets `AVDCT.dct_algo` value. +func (dct *AVDCT) SetDctAlgo(v int32) { + dct.dct_algo = (C.int)(v) +} + +// Custom: GetDctAlgoAddr gets `AVDCT.dct_algo` address. +func (dct *AVDCT) GetDctAlgoAddr() *int32 { + return (*int32)(&dct.dct_algo) +} + +// Custom: GetIdctAlgo gets `AVDCT.idct_algo` value. +func (dct *AVDCT) GetIdctAlgo() int32 { + return (int32)(dct.idct_algo) +} + +// Custom: SetIdctAlgo sets `AVDCT.idct_algo` value. +func (dct *AVDCT) SetIdctAlgo(v int32) { + dct.idct_algo = (C.int)(v) +} + +// Custom: GetIdctAlgoAddr gets `AVDCT.idct_algo` address. +func (dct *AVDCT) GetIdctAlgoAddr() *int32 { + return (*int32)(&dct.idct_algo) +} + +// Custom: GetGetPixels gets `AVDCT.get_pixels` value. +func (dct *AVDCT) GetGetPixels() AVDCTGetPixelsFunc { + return (AVDCTGetPixelsFunc)(dct.get_pixels) +} + +// Custom: SetGetPixels sets `AVDCT.get_pixels` value. +func (dct *AVDCT) SetGetPixels(v AVDCTGetPixelsFunc) { + dct.get_pixels = (C.avdct_get_pixels_func)(v) +} + +// Custom: GetGetPixelsAddr gets `AVDCT.get_pixels` address. +func (dct *AVDCT) GetGetPixelsAddr() *AVDCTGetPixelsFunc { + return (*AVDCTGetPixelsFunc)(&dct.get_pixels) +} + +// Custom: GetBitsPerSample gets `AVDCT.bits_per_sample` value. +func (dct *AVDCT) GetBitsPerSample() int32 { + return (int32)(dct.bits_per_sample) +} + +// Custom: SetBitsPerSample sets `AVDCT.bits_per_sample` value. +func (dct *AVDCT) SetBitsPerSample(v int32) { + dct.bits_per_sample = (C.int)(v) +} + +// Custom: GetBitsPerSampleAddr gets `AVDCT.bits_per_sample` address. +func (dct *AVDCT) GetBitsPerSampleAddr() *int32 { + return (*int32)(&dct.bits_per_sample) +} + +// Custom: GetGetPixelsUnaligned gets `AVDCT.get_pixels_unaligned` value. +func (dct *AVDCT) GetGetPixelsUnaligned() AVDCTGetPixelsUnalignedFunc { + return (AVDCTGetPixelsUnalignedFunc)(dct.get_pixels_unaligned) +} + +// Custom: SetGetPixelsUnaligned sets `AVDCT.get_pixels_unaligned` value. +func (dct *AVDCT) SetGetPixelsUnaligned(v AVDCTGetPixelsUnalignedFunc) { + dct.get_pixels_unaligned = (C.avdct_get_pixels_unaligned_func)(v) +} + +// Custom: GetGetPixelsUnalignedAddr gets `AVDCT.get_pixels_unaligned` address. +func (dct *AVDCT) GetGetPixelsUnalignedAddr() *AVDCTGetPixelsUnalignedFunc { + return (*AVDCTGetPixelsUnalignedFunc)(&dct.get_pixels_unaligned) +} + // AvCodecDctAlloc allocates a AVDCT context. func AvCodecDctAlloc() *AVDCT { return (*AVDCT)(C.avcodec_dct_alloc()) diff --git a/avcodec_avfft.go b/avcodec_avfft.go index 5ce5c62..9094bce 100644 --- a/avcodec_avfft.go +++ b/avcodec_avfft.go @@ -6,11 +6,21 @@ package ffmpeg import "C" // FFTSample -type FFTSample C.FFTSample +type FFTSample = C.FFTSample // FFTComplex type FFTComplex C.struct_FFTComplex +// Custom: GetRe gets `FFTComplex.re` value. +func (fc *FFTComplex) GetRe() FFTSample { + return (FFTSample)(fc.re) +} + +// Custom: GetIm gets `FFTComplex.im` value. +func (fc *FFTComplex) GetIm() FFTSample { + return (FFTSample)(fc.im) +} + // FFTContext type FFTContext C.struct_FFTContext diff --git a/avcodec_d3d11va.go b/avcodec_d3d11va.go index c818407..b9b6374 100644 --- a/avcodec_d3d11va.go +++ b/avcodec_d3d11va.go @@ -6,3 +6,16 @@ package ffmpeg #include */ import "C" + +const ( + FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG = C.FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG + FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO = C.FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO +) + +// AVD3D11VAContext +type AVD3D11VAContext C.struct_AVD3D11VAContext + +// AvD3d11vaAllocContext allocates an AVD3D11VAContext. +func AvD3d11vaAllocContext() *AVD3D11VAContext { + return (*AVD3D11VAContext)(C.av_d3d11va_alloc_context()) +} diff --git a/avcodec_dirac.go b/avcodec_dirac.go new file mode 100644 index 0000000..5f1f769 --- /dev/null +++ b/avcodec_dirac.go @@ -0,0 +1,434 @@ +package ffmpeg + +/* +#include +*/ +import "C" +import "unsafe" + +const ( + MAX_DWT_LEVELS = C.MAX_DWT_LEVELS +) + +type DiracParseCodes = C.enum_DiracParseCodes + +const ( + DIRAC_PCODE_SEQ_HEADER = DiracParseCodes(C.DIRAC_PCODE_SEQ_HEADER) + DIRAC_PCODE_END_SEQ = DiracParseCodes(C.DIRAC_PCODE_END_SEQ) + DIRAC_PCODE_AUX = DiracParseCodes(C.DIRAC_PCODE_AUX) + DIRAC_PCODE_PAD = DiracParseCodes(C.DIRAC_PCODE_PAD) + DIRAC_PCODE_PICTURE_CODED = DiracParseCodes(C.DIRAC_PCODE_PICTURE_CODED) + DIRAC_PCODE_PICTURE_RAW = DiracParseCodes(C.DIRAC_PCODE_PICTURE_RAW) + DIRAC_PCODE_PICTURE_LOW_DEL = DiracParseCodes(C.DIRAC_PCODE_PICTURE_LOW_DEL) + DIRAC_PCODE_PICTURE_HQ = DiracParseCodes(C.DIRAC_PCODE_PICTURE_HQ) + DIRAC_PCODE_INTER_NOREF_CO1 = DiracParseCodes(C.DIRAC_PCODE_INTER_NOREF_CO1) + DIRAC_PCODE_INTER_NOREF_CO2 = DiracParseCodes(C.DIRAC_PCODE_INTER_NOREF_CO2) + DIRAC_PCODE_INTER_REF_CO1 = DiracParseCodes(C.DIRAC_PCODE_INTER_REF_CO1) + DIRAC_PCODE_INTER_REF_CO2 = DiracParseCodes(C.DIRAC_PCODE_INTER_REF_CO2) + DIRAC_PCODE_INTRA_REF_CO = DiracParseCodes(C.DIRAC_PCODE_INTRA_REF_CO) + DIRAC_PCODE_INTRA_REF_RAW = DiracParseCodes(C.DIRAC_PCODE_INTRA_REF_RAW) + DIRAC_PCODE_INTRA_REF_PICT = DiracParseCodes(C.DIRAC_PCODE_INTRA_REF_PICT) + DIRAC_PCODE_MAGIC = DiracParseCodes(C.DIRAC_PCODE_MAGIC) +) + +// DiracVersionInfo +type DiracVersionInfo C.struct_DiracVersionInfo + +// Custom: GetMajor gets `DiracVersionInfo.major` value. +func (dvi *DiracVersionInfo) GetMajor() int32 { + return (int32)(dvi.major) +} + +// Custom: SetMajor sets `DiracVersionInfo.major` value. +func (dvi *DiracVersionInfo) SetMajor(v int32) { + dvi.major = (C.int)(v) +} + +// Custom: GetMajorAddr gets `DiracVersionInfo.major` address. +func (dvi *DiracVersionInfo) GetMajorAddr() *int32 { + return (*int32)(&dvi.major) +} + +// Custom: GetMinor gets `DiracVersionInfo.minor` value. +func (dvi *DiracVersionInfo) GetMinor() int32 { + return (int32)(dvi.minor) +} + +// Custom: SetMinor sets `DiracVersionInfo.minor` value. +func (dvi *DiracVersionInfo) SetMinor(v int32) { + dvi.minor = (C.int)(v) +} + +// Custom: GetMinorAddr gets `DiracVersionInfo.minor` address. +func (dvi *DiracVersionInfo) GetMinorAddr() *int32 { + return (*int32)(&dvi.minor) +} + +// AVDiracSeqHeader +type AVDiracSeqHeader C.struct_AVDiracSeqHeader + +// Custom: GetWidth gets `AVDiracSeqHeader.width` value. +func (dsh *AVDiracSeqHeader) GetWidth() uint32 { + return (uint32)(dsh.width) +} + +// Custom: SetWidth sets `AVDiracSeqHeader.width` value. +func (dsh *AVDiracSeqHeader) SetWidth(v uint32) { + dsh.width = (C.uint)(v) +} + +// Custom: GetWidthAddr gets `AVDiracSeqHeader.width` address. +func (dsh *AVDiracSeqHeader) GetWidthAddr() *uint32 { + return (*uint32)(&dsh.width) +} + +// Custom: GetHeight gets `AVDiracSeqHeader.height` value. +func (dsh *AVDiracSeqHeader) GetHeight() uint32 { + return (uint32)(dsh.height) +} + +// Custom: SetHeight sets `AVDiracSeqHeader.height` value. +func (dsh *AVDiracSeqHeader) SetHeight(v uint32) { + dsh.height = (C.uint)(v) +} + +// Custom: GetHeightAddr gets `AVDiracSeqHeader.height` address. +func (dsh *AVDiracSeqHeader) GetHeightAddr() *uint32 { + return (*uint32)(&dsh.height) +} + +// Custom: GetChromaFormat gets `AVDiracSeqHeader.chroma_format` value. +func (dsh *AVDiracSeqHeader) GetChromaFormat() uint8 { + return (uint8)(dsh.chroma_format) +} + +// Custom: SetChromaFormat sets `AVDiracSeqHeader.chroma_format` value. +func (dsh *AVDiracSeqHeader) SetChromaFormat(v uint8) { + dsh.chroma_format = (C.uint8_t)(v) +} + +// Custom: GetChromaFormatAddr gets `AVDiracSeqHeader.chroma_format` address. +func (dsh *AVDiracSeqHeader) GetChromaFormatAddr() *uint8 { + return (*uint8)(&dsh.chroma_format) +} + +// Custom: GetInterlaced gets `AVDiracSeqHeader.interlaced` value. +func (dsh *AVDiracSeqHeader) GetInterlaced() uint8 { + return (uint8)(dsh.interlaced) +} + +// Custom: SetInterlaced sets `AVDiracSeqHeader.interlaced` value. +func (dsh *AVDiracSeqHeader) SetInterlaced(v uint8) { + dsh.interlaced = (C.uint8_t)(v) +} + +// Custom: GetInterlacedAddr gets `AVDiracSeqHeader.interlaced` address. +func (dsh *AVDiracSeqHeader) GetInterlacedAddr() *uint8 { + return (*uint8)(&dsh.interlaced) +} + +// Custom: GetTopFieldFirst gets `AVDiracSeqHeader.top_field_first` value. +func (dsh *AVDiracSeqHeader) GetTopFieldFirst() uint8 { + return (uint8)(dsh.top_field_first) +} + +// Custom: SetTopFieldFirst sets `AVDiracSeqHeader.top_field_first` value. +func (dsh *AVDiracSeqHeader) SetTopFieldFirst(v uint8) { + dsh.top_field_first = (C.uint8_t)(v) +} + +// Custom: GetTopFieldFirstAddr gets `AVDiracSeqHeader.top_field_first` address. +func (dsh *AVDiracSeqHeader) GetTopFieldFirstAddr() *uint8 { + return (*uint8)(&dsh.top_field_first) +} + +// Custom: GetFrameRateIndex gets `AVDiracSeqHeader.frame_rate_index` value. +func (dsh *AVDiracSeqHeader) GetFrameRateIndex() uint8 { + return (uint8)(dsh.frame_rate_index) +} + +// Custom: SetFrameRateIndex sets `AVDiracSeqHeader.frame_rate_index` value. +func (dsh *AVDiracSeqHeader) SetFrameRateIndex(v uint8) { + dsh.frame_rate_index = (C.uint8_t)(v) +} + +// Custom: GetFrameRateIndexAddr gets `AVDiracSeqHeader.frame_rate_index` address. +func (dsh *AVDiracSeqHeader) GetFrameRateIndexAddr() *uint8 { + return (*uint8)(&dsh.frame_rate_index) +} + +// Custom: GetAspectRatioIndex gets `AVDiracSeqHeader.aspect_ratio_index` value. +func (dsh *AVDiracSeqHeader) GetAspectRatioIndex() uint8 { + return (uint8)(dsh.aspect_ratio_index) +} + +// Custom: SetAspectRatioIndex sets `AVDiracSeqHeader.aspect_ratio_index` value. +func (dsh *AVDiracSeqHeader) SetAspectRatioIndex(v uint8) { + dsh.aspect_ratio_index = (C.uint8_t)(v) +} + +// Custom: GetAspectRatioIndexAddr gets `AVDiracSeqHeader.aspect_ratio_index` address. +func (dsh *AVDiracSeqHeader) GetAspectRatioIndexAddr() *uint8 { + return (*uint8)(&dsh.aspect_ratio_index) +} + +// Custom: GetCleanWidth gets `AVDiracSeqHeader.clean_width` value. +func (dsh *AVDiracSeqHeader) GetCleanWidth() uint16 { + return (uint16)(dsh.clean_width) +} + +// Custom: SetCleanWidth sets `AVDiracSeqHeader.clean_width` value. +func (dsh *AVDiracSeqHeader) SetCleanWidth(v uint16) { + dsh.clean_width = (C.uint16_t)(v) +} + +// Custom: GetCleanWidthAddr gets `AVDiracSeqHeader.clean_width` address. +func (dsh *AVDiracSeqHeader) GetCleanWidthAddr() *uint16 { + return (*uint16)(&dsh.clean_width) +} + +// Custom: GetCleanHeight gets `AVDiracSeqHeader.clean_height` value. +func (dsh *AVDiracSeqHeader) GetCleanHeight() uint16 { + return (uint16)(dsh.clean_height) +} + +// Custom: SetCleanHeight sets `AVDiracSeqHeader.clean_height` value. +func (dsh *AVDiracSeqHeader) SetCleanHeight(v uint16) { + dsh.clean_height = (C.uint16_t)(v) +} + +// Custom: GetCleanHeightAddr gets `AVDiracSeqHeader.clean_height` address. +func (dsh *AVDiracSeqHeader) GetCleanHeightAddr() *uint16 { + return (*uint16)(&dsh.clean_height) +} + +// Custom: GetCleanLeftOffset gets `AVDiracSeqHeader.clean_left_offset` value. +func (dsh *AVDiracSeqHeader) GetCleanLeftOffset() uint16 { + return (uint16)(dsh.clean_left_offset) +} + +// Custom: SetCleanLeftOffset sets `AVDiracSeqHeader.clean_left_offset` value. +func (dsh *AVDiracSeqHeader) SetCleanLeftOffset(v uint16) { + dsh.clean_left_offset = (C.uint16_t)(v) +} + +// Custom: GetCleanLeftOffsetAddr gets `AVDiracSeqHeader.clean_left_offset` address. +func (dsh *AVDiracSeqHeader) GetCleanLeftOffsetAddr() *uint16 { + return (*uint16)(&dsh.clean_left_offset) +} + +// Custom: GetCleanRightOffset gets `AVDiracSeqHeader.clean_right_offset` value. +func (dsh *AVDiracSeqHeader) GetCleanRightOffset() uint16 { + return (uint16)(dsh.clean_right_offset) +} + +// Custom: SetCleanRightOffset sets `AVDiracSeqHeader.clean_right_offset` value. +func (dsh *AVDiracSeqHeader) SetCleanRightOffset(v uint16) { + dsh.clean_right_offset = (C.uint16_t)(v) +} + +// Custom: GetCleanRightOffsetAddr gets `AVDiracSeqHeader.clean_right_offset` address. +func (dsh *AVDiracSeqHeader) GetCleanRightOffsetAddr() *uint16 { + return (*uint16)(&dsh.clean_right_offset) +} + +// Custom: GetPixelRangeIndex gets `AVDiracSeqHeader.pixel_range_index` value. +func (dsh *AVDiracSeqHeader) GetPixelRangeIndex() uint8 { + return (uint8)(dsh.pixel_range_index) +} + +// Custom: SetPixelRangeIndex sets `AVDiracSeqHeader.pixel_range_index` value. +func (dsh *AVDiracSeqHeader) SetPixelRangeIndex(v uint8) { + dsh.pixel_range_index = (C.uint8_t)(v) +} + +// Custom: GetPixelRangeIndexAddr gets `AVDiracSeqHeader.pixel_range_index` address. +func (dsh *AVDiracSeqHeader) GetPixelRangeIndexAddr() *uint8 { + return (*uint8)(&dsh.pixel_range_index) +} + +// Custom: GetColorSpecIndex gets `AVDiracSeqHeader.color_spec_index` value. +func (dsh *AVDiracSeqHeader) GetColorSpecIndex() uint8 { + return (uint8)(dsh.color_spec_index) +} + +// Custom: SetColorSpecIndex sets `AVDiracSeqHeader.color_spec_index` value. +func (dsh *AVDiracSeqHeader) SetColorSpecIndex(v uint8) { + dsh.color_spec_index = (C.uint8_t)(v) +} + +// Custom: GetColorSpecIndexAddr gets `AVDiracSeqHeader.color_spec_index` address. +func (dsh *AVDiracSeqHeader) GetColorSpecIndexAddr() *uint8 { + return (*uint8)(&dsh.color_spec_index) +} + +// Custom: GetProfile gets `AVDiracSeqHeader.profile` value. +func (dsh *AVDiracSeqHeader) GetProfile() int32 { + return (int32)(dsh.profile) +} + +// Custom: SetProfile sets `AVDiracSeqHeader.profile` value. +func (dsh *AVDiracSeqHeader) SetProfile(v int32) { + dsh.profile = (C.int)(v) +} + +// Custom: GetProfileAddr gets `AVDiracSeqHeader.profile` address. +func (dsh *AVDiracSeqHeader) GetProfileAddr() *int32 { + return (*int32)(&dsh.profile) +} + +// Custom: GetLevel gets `AVDiracSeqHeader.level` value. +func (dsh *AVDiracSeqHeader) GetLevel() int32 { + return (int32)(dsh.level) +} + +// Custom: SetLevel sets `AVDiracSeqHeader.level` value. +func (dsh *AVDiracSeqHeader) SetLevel(v int32) { + dsh.level = (C.int)(v) +} + +// Custom: GetLevelAddr gets `AVDiracSeqHeader.level` address. +func (dsh *AVDiracSeqHeader) GetLevelAddr() *int32 { + return (*int32)(&dsh.level) +} + +// Custom: GetFramerate gets `AVDiracSeqHeader.framerate` value. +func (dsh *AVDiracSeqHeader) GetFramerate() AVRational { + return (AVRational)(dsh.framerate) +} + +// Custom: SetFramerate sets `AVDiracSeqHeader.framerate` value. +func (dsh *AVDiracSeqHeader) SetFramerate(v AVRational) { + dsh.framerate = (C.struct_AVRational)(v) +} + +// Custom: GetFramerateAddr gets `AVDiracSeqHeader.framerate` address. +func (dsh *AVDiracSeqHeader) GetFramerateAddr() *AVRational { + return (*AVRational)(&dsh.framerate) +} + +// Custom: GetSampleAspectRatio gets `AVDiracSeqHeader.sample_aspect_ratio` value. +func (dsh *AVDiracSeqHeader) GetSampleAspectRatio() AVRational { + return (AVRational)(dsh.sample_aspect_ratio) +} + +// Custom: SetSampleAspectRatio sets `AVDiracSeqHeader.sample_aspect_ratio` value. +func (dsh *AVDiracSeqHeader) SetSampleAspectRatio(v AVRational) { + dsh.sample_aspect_ratio = (C.struct_AVRational)(v) +} + +// Custom: GetSampleAspectRatioAddr gets `AVDiracSeqHeader.sample_aspect_ratio` address. +func (dsh *AVDiracSeqHeader) GetSampleAspectRatioAddr() *AVRational { + return (*AVRational)(&dsh.sample_aspect_ratio) +} + +// Custom: GetPixFmt gets `AVDiracSeqHeader.pix_fmt` value. +func (dsh *AVDiracSeqHeader) GetPixFmt() AVPixelFormat { + return (AVPixelFormat)(dsh.pix_fmt) +} + +// Custom: SetPixFmt sets `AVDiracSeqHeader.pix_fmt` value. +func (dsh *AVDiracSeqHeader) SetPixFmt(v AVPixelFormat) { + dsh.pix_fmt = (C.enum_AVPixelFormat)(v) +} + +// Custom: GetPixFmtAddr gets `AVDiracSeqHeader.pix_fmt` address. +func (dsh *AVDiracSeqHeader) GetPixFmtAddr() *AVPixelFormat { + return (*AVPixelFormat)(&dsh.pix_fmt) +} + +// Custom: GetColorRange gets `AVDiracSeqHeader.color_range` value. +func (dsh *AVDiracSeqHeader) GetColorRange() AVColorRange { + return (AVColorRange)(dsh.color_range) +} + +// Custom: SetColorRange sets `AVDiracSeqHeader.color_range` value. +func (dsh *AVDiracSeqHeader) SetColorRange(v AVColorRange) { + dsh.color_range = (C.enum_AVColorRange)(v) +} + +// Custom: GetColorRangeAddr gets `AVDiracSeqHeader.color_range` address. +func (dsh *AVDiracSeqHeader) GetColorRangeAddr() *AVColorRange { + return (*AVColorRange)(&dsh.color_range) +} + +// Custom: GetColorPrimaries gets `AVDiracSeqHeader.color_primaries` value. +func (dsh *AVDiracSeqHeader) GetColorPrimaries() AVColorPrimaries { + return (AVColorPrimaries)(dsh.color_primaries) +} + +// Custom: SetColorPrimaries sets `AVDiracSeqHeader.color_primaries` value. +func (dsh *AVDiracSeqHeader) SetColorPrimaries(v AVColorPrimaries) { + dsh.color_primaries = (C.enum_AVColorPrimaries)(v) +} + +// Custom: GetColorPrimariesAddr gets `AVDiracSeqHeader.color_primaries` address. +func (dsh *AVDiracSeqHeader) GetColorPrimariesAddr() *AVColorPrimaries { + return (*AVColorPrimaries)(&dsh.color_primaries) +} + +// Custom: GetColorTrc gets `AVDiracSeqHeader.color_trc` value. +func (dsh *AVDiracSeqHeader) GetColorTrc() AVColorTransferCharacteristic { + return (AVColorTransferCharacteristic)(dsh.color_trc) +} + +// Custom: SetColorTrc sets `AVDiracSeqHeader.color_trc` value. +func (dsh *AVDiracSeqHeader) SetColorTrc(v AVColorTransferCharacteristic) { + dsh.color_trc = (C.enum_AVColorTransferCharacteristic)(v) +} + +// Custom: GetColorTrcAddr gets `AVDiracSeqHeader.color_trc` address. +func (dsh *AVDiracSeqHeader) GetColorTrcAddr() *AVColorTransferCharacteristic { + return (*AVColorTransferCharacteristic)(&dsh.color_trc) +} + +// Custom: GetColorspace gets `AVDiracSeqHeader.colorspace` value. +func (dsh *AVDiracSeqHeader) GetColorspace() AVColorSpace { + return (AVColorSpace)(dsh.colorspace) +} + +// Custom: SetColorspace sets `AVDiracSeqHeader.colorspace` value. +func (dsh *AVDiracSeqHeader) SetColorspace(v AVColorSpace) { + dsh.colorspace = (C.enum_AVColorSpace)(v) +} + +// Custom: GetColorspaceAddr gets `AVDiracSeqHeader.colorspace` address. +func (dsh *AVDiracSeqHeader) GetColorspaceAddr() *AVColorSpace { + return (*AVColorSpace)(&dsh.colorspace) +} + +// Custom: GetVersion gets `AVDiracSeqHeader.version` value. +func (dsh *AVDiracSeqHeader) GetVersion() DiracVersionInfo { + return (DiracVersionInfo)(dsh.version) +} + +// Custom: SetVersion sets `AVDiracSeqHeader.version` value. +func (dsh *AVDiracSeqHeader) SetVersion(v DiracVersionInfo) { + dsh.version = (C.struct_DiracVersionInfo)(v) +} + +// Custom: GetVersionAddr gets `AVDiracSeqHeader.version` address. +func (dsh *AVDiracSeqHeader) GetVersionAddr() *DiracVersionInfo { + return (*DiracVersionInfo)(&dsh.version) +} + +// Custom: GetBitDepth gets `AVDiracSeqHeader.bit_depth` value. +func (dsh *AVDiracSeqHeader) GetBitDepth() int32 { + return (int32)(dsh.bit_depth) +} + +// Custom: SetBitDepth sets `AVDiracSeqHeader.bit_depth` value. +func (dsh *AVDiracSeqHeader) SetBitDepth(v int32) { + dsh.bit_depth = (C.int)(v) +} + +// Custom: GetBitDepthAddr gets `AVDiracSeqHeader.bit_depth` address. +func (dsh *AVDiracSeqHeader) GetBitDepthAddr() *int32 { + return (*int32)(&dsh.bit_depth) +} + +// AvDiracParseSequenceHeader parses a Dirac sequence header. +func AvDiracParseSequenceHeader(dsh **AVDiracSeqHeader, buf *uint8, bufSize uintptr, logCtx CVoidPointer) int32 { + return (int32)(C.av_dirac_parse_sequence_header((**C.struct_AVDiracSeqHeader)(unsafe.Pointer(dsh)), + (*C.uint8_t)(buf), (C.size_t)(bufSize), VoidPointer(logCtx))) +} diff --git a/avcodec_dv_profile.go b/avcodec_dv_profile.go new file mode 100644 index 0000000..3e82738 --- /dev/null +++ b/avcodec_dv_profile.go @@ -0,0 +1,296 @@ +package ffmpeg + +/* +#include +*/ +import "C" +import "unsafe" + +const ( + DV_PROFILE_BYTES = C.DV_PROFILE_BYTES +) + +// AVDVProfile +type AVDVProfile C.struct_AVDVProfile + +// Custom: GetDsf gets `AVDVProfile.dsf` value. +func (dvp *AVDVProfile) GetDsf() int32 { + return (int32)(dvp.dsf) +} + +// Custom: SetDsf sets `AVDVProfile.dsf` value. +func (dvp *AVDVProfile) SetDsf(v int32) { + dvp.dsf = (C.int)(v) +} + +// Custom: GetDsfAddr gets `AVDVProfile.dsf` address. +func (dvp *AVDVProfile) GetDsfAddr() *int32 { + return (*int32)(&dvp.dsf) +} + +// Custom: GetVideoStype gets `AVDVProfile.video_stype` value. +func (dvp *AVDVProfile) GetVideoStype() int32 { + return (int32)(dvp.video_stype) +} + +// Custom: SetVideoStype sets `AVDVProfile.video_stype` value. +func (dvp *AVDVProfile) SetVideoStype(v int32) { + dvp.video_stype = (C.int)(v) +} + +// Custom: GetVideoStypeAddr gets `AVDVProfile.video_stype` address. +func (dvp *AVDVProfile) GetVideoStypeAddr() *int32 { + return (*int32)(&dvp.video_stype) +} + +// Custom: GetFrameSize gets `AVDVProfile.frame_size` value. +func (dvp *AVDVProfile) GetFrameSize() int32 { + return (int32)(dvp.frame_size) +} + +// Custom: SetFrameSize sets `AVDVProfile.frame_size` value. +func (dvp *AVDVProfile) SetFrameSize(v int32) { + dvp.frame_size = (C.int)(v) +} + +// Custom: GetFrameSizeAddr gets `AVDVProfile.frame_size` address. +func (dvp *AVDVProfile) GetFrameSizeAddr() *int32 { + return (*int32)(&dvp.frame_size) +} + +// Custom: GetDifsegSize gets `AVDVProfile.difseg_size` value. +func (dvp *AVDVProfile) GetDifsegSize() int32 { + return (int32)(dvp.difseg_size) +} + +// Custom: SetDifsegSize sets `AVDVProfile.difseg_size` value. +func (dvp *AVDVProfile) SetDifsegSize(v int32) { + dvp.difseg_size = (C.int)(v) +} + +// Custom: GetDifsegSizeAddr gets `AVDVProfile.difseg_size` address. +func (dvp *AVDVProfile) GetDifsegSizeAddr() *int32 { + return (*int32)(&dvp.difseg_size) +} + +// Custom: GetNDifchan gets `AVDVProfile.n_difchan` value. +func (dvp *AVDVProfile) GetNDifchan() int32 { + return (int32)(dvp.n_difchan) +} + +// Custom: SetNDifchan sets `AVDVProfile.n_difchan` value. +func (dvp *AVDVProfile) SetNDifchan(v int32) { + dvp.n_difchan = (C.int)(v) +} + +// Custom: GetNDifchanAddr gets `AVDVProfile.n_difchan` address. +func (dvp *AVDVProfile) GetNDifchanAddr() *int32 { + return (*int32)(&dvp.n_difchan) +} + +// Custom: GetTimeBase gets `AVDVProfile.time_base` value. +func (dvp *AVDVProfile) GetTimeBase() AVRational { + return (AVRational)(dvp.time_base) +} + +// Custom: SetTimeBase sets `AVDVProfile.time_base` value. +func (dvp *AVDVProfile) SetTimeBase(v AVRational) { + dvp.time_base = (C.struct_AVRational)(v) +} + +// Custom: GetTimeBaseAddr gets `AVDVProfile.time_base` address. +func (dvp *AVDVProfile) GetTimeBaseAddr() *AVRational { + return (*AVRational)(&dvp.time_base) +} + +// Custom: GetLtcDivisor gets `AVDVProfile.ltc_divisor` value. +func (dvp *AVDVProfile) GetLtcDivisor() int32 { + return (int32)(dvp.ltc_divisor) +} + +// Custom: SetLtcDivisor sets `AVDVProfile.ltc_divisor` value. +func (dvp *AVDVProfile) SetLtcDivisor(v int32) { + dvp.ltc_divisor = (C.int)(v) +} + +// Custom: GetLtcDivisorAddr gets `AVDVProfile.ltc_divisor` address. +func (dvp *AVDVProfile) GetLtcDivisorAddr() *int32 { + return (*int32)(&dvp.ltc_divisor) +} + +// Custom: GetHeight gets `AVDVProfile.height` value. +func (dvp *AVDVProfile) GetHeight() int32 { + return (int32)(dvp.height) +} + +// Custom: SetHeight sets `AVDVProfile.height` value. +func (dvp *AVDVProfile) SetHeight(v int32) { + dvp.height = (C.int)(v) +} + +// Custom: GetHeightAddr gets `AVDVProfile.height` address. +func (dvp *AVDVProfile) GetHeightAddr() *int32 { + return (*int32)(&dvp.height) +} + +// Custom: GetWidth gets `AVDVProfile.width` value. +func (dvp *AVDVProfile) GetWidth() int32 { + return (int32)(dvp.width) +} + +// Custom: SetWidth sets `AVDVProfile.width` value. +func (dvp *AVDVProfile) SetWidth(v int32) { + dvp.width = (C.int)(v) +} + +// Custom: GetWidthAddr gets `AVDVProfile.width` address. +func (dvp *AVDVProfile) GetWidthAddr() *int32 { + return (*int32)(&dvp.width) +} + +// Custom: GetSar gets `AVDVProfile.sar` value. +func (dvp *AVDVProfile) GetSar() []AVRational { + return unsafe.Slice((*AVRational)(&dvp.sar[0]), 2) +} + +// Custom: SetSar sets `AVDVProfile.sar` value. +func (dvp *AVDVProfile) SetSar(v []AVRational) { + for i := 0; i < FFMIN(len(v), 2); i++ { + dvp.sar[i] = (C.struct_AVRational)(v[i]) + } +} + +// Custom: GetSarAddr gets `AVDVProfile.sar` address. +func (dvp *AVDVProfile) GetSarAddr() **AVRational { + return (**AVRational)(unsafe.Pointer(&dvp.sar)) +} + +// Custom: GetPixFmt gets `AVDVProfile.pix_fmt` value. +func (dvp *AVDVProfile) GetPixFmt() AVPixelFormat { + return (AVPixelFormat)(dvp.pix_fmt) +} + +// Custom: SetPixFmt sets `AVDVProfile.pix_fmt` value. +func (dvp *AVDVProfile) SetPixFmt(v AVPixelFormat) { + dvp.pix_fmt = (C.enum_AVPixelFormat)(v) +} + +// Custom: GetPixFmtAddr gets `AVDVProfile.pix_fmt` address. +func (dvp *AVDVProfile) GetPixFmtAddr() *AVPixelFormat { + return (*AVPixelFormat)(&dvp.pix_fmt) +} + +// Custom: GetBpm gets `AVDVProfile.bpm` value. +func (dvp *AVDVProfile) GetBpm() int32 { + return (int32)(dvp.bpm) +} + +// Custom: SetBpm sets `AVDVProfile.bpm` value. +func (dvp *AVDVProfile) SetBpm(v int32) { + dvp.bpm = (C.int)(v) +} + +// Custom: GetBpmAddr gets `AVDVProfile.bpm` address. +func (dvp *AVDVProfile) GetBpmAddr() *int32 { + return (*int32)(&dvp.bpm) +} + +// Custom: GetBlockSizes gets `AVDVProfile.block_sizes` value. +func (dvp *AVDVProfile) GetBlockSizes() *uint8 { + return (*uint8)(dvp.block_sizes) +} + +// Custom: SetBlockSizes sets `AVDVProfile.block_sizes` value. +func (dvp *AVDVProfile) SetBlockSizes(v *uint8) { + dvp.block_sizes = (*C.uint8_t)(v) +} + +// Custom: GetBlockSizesAddr gets `AVDVProfile.block_sizes` address. +func (dvp *AVDVProfile) GetBlockSizesAddr() **uint8 { + return (**uint8)(unsafe.Pointer(&dvp.block_sizes)) +} + +// Custom: GetAudioStride gets `AVDVProfile.audio_stride` value. +func (dvp *AVDVProfile) GetAudioStride() int32 { + return (int32)(dvp.audio_stride) +} + +// Custom: SetAudioStride sets `AVDVProfile.audio_stride` value. +func (dvp *AVDVProfile) SetAudioStride(v int32) { + dvp.audio_stride = (C.int)(v) +} + +// Custom: GetAudioStrideAddr gets `AVDVProfile.audio_stride` address. +func (dvp *AVDVProfile) GetAudioStrideAddr() *int32 { + return (*int32)(&dvp.audio_stride) +} + +// Custom: GetAudioMinSamples gets `AVDVProfile.audio_min_samples` value. +func (dvp *AVDVProfile) GetAudioMinSamples() []int32 { + return unsafe.Slice((*int32)(&dvp.audio_min_samples[0]), 3) +} + +// Custom: SetAudioMinSamples sets `AVDVProfile.audio_min_samples` value. +func (dvp *AVDVProfile) SetAudioMinSamples(v []int32) { + for i := 0; i < FFMIN(len(v), 3); i++ { + dvp.audio_min_samples[i] = (C.int)(v[i]) + } +} + +// Custom: GetAudioMinSamplesAddr gets `AVDVProfile.audio_min_samples` address. +func (dvp *AVDVProfile) GetAudioMinSamplesAddr() **int32 { + return (**int32)(unsafe.Pointer(&dvp.audio_min_samples)) +} + +// Custom: GetAudioSamplesDist gets `AVDVProfile.audio_samples_dist` value. +func (dvp *AVDVProfile) GetAudioSamplesDist() []int32 { + return unsafe.Slice((*int32)(&dvp.audio_samples_dist[0]), 5) +} + +// Custom: SetAudioSamplesDist sets `AVDVProfile.audio_samples_dist` value. +func (dvp *AVDVProfile) SetAudioSamplesDist(v []int32) { + for i := 0; i < FFMIN(len(v), 5); i++ { + dvp.audio_samples_dist[i] = (C.int)(v[i]) + } +} + +// Custom: GetAudioSamplesDistAddr gets `AVDVProfile.audio_samples_dist` address. +func (dvp *AVDVProfile) GetAudioSamplesDistAddr() **int32 { + return (**int32)(unsafe.Pointer(&dvp.audio_samples_dist)) +} + +// Custom: GetAudioShuffle gets `AVDVProfile.audio_shuffle` value. +func (dvp *AVDVProfile) GetAudioShuffle() []uint8 { + return unsafe.Slice((*uint8)(&dvp.audio_shuffle[0]), 9) +} + +// Custom: SetAudioShuffle sets `AVDVProfile.audio_shuffle` value. +func (dvp *AVDVProfile) SetAudioShuffle(v []uint8) { + for i := 0; i < FFMIN(len(v), 9); i++ { + dvp.audio_shuffle[i] = (C.uint8_t)(v[i]) + } +} + +// Custom: GetAudioShuffleAddr gets `AVDVProfile.audio_shuffle` address. +func (dvp *AVDVProfile) GetAudioShuffleAddr() **uint8 { + return (**uint8)(unsafe.Pointer(&dvp.audio_shuffle)) +} + +// AvDvFrameProfile gets a DV profile for the provided compressed frame. +func AvDvFrameProfile(sys *AVDVProfile, frame *uint8, bufSize uint32) *AVDVProfile { + return (*AVDVProfile)(C.av_dv_frame_profile((*C.struct_AVDVProfile)(sys), + (*C.uint8_t)(frame), (C.uint)(bufSize))) +} + +// AvDvCodecProfile gets a DV profile for the provided stream parameters. +func AvDvCodecProfile(width, height int32, pixFmt AVPixelFormat) *AVDVProfile { + return (*AVDVProfile)(C.av_dv_codec_profile((C.int)(width), (C.int)(height), + (C.enum_AVPixelFormat)(pixFmt))) +} + +// AvDvCodecProfile2 gets a DV profile for the provided stream parameters. +func AvDvCodecProfile2(width, height int32, pixFmt AVPixelFormat, + frameRate AVRational) *AVDVProfile { + return (*AVDVProfile)(C.av_dv_codec_profile2((C.int)(width), (C.int)(height), + (C.enum_AVPixelFormat)(pixFmt), (C.struct_AVRational)(frameRate))) +} diff --git a/avcodec_dvxa2.go b/avcodec_dvxa2.go new file mode 100644 index 0000000..b358ee4 --- /dev/null +++ b/avcodec_dvxa2.go @@ -0,0 +1,17 @@ +//go:build ffmpeg_hw_dvxa2 + +package ffmpeg + +/* +#include +*/ +import "C" + +const { + FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG = C.FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG + FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO = C.FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO +} + +// DxvaContext +type DxvaContext C.struct_dxva_context + diff --git a/avcodec_jni.go b/avcodec_jni.go new file mode 100644 index 0000000..74d612c --- /dev/null +++ b/avcodec_jni.go @@ -0,0 +1,16 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AvJniSetJavaVm sets a Java virtual machine which will be used to retrieve the JNI environment. +func AvJniSetJavaVm(vm, logCtx CVoidPointer) int32 { + return (int32)(C.av_jni_set_java_vm(VoidPointer(vm), VoidPointer(logCtx))) +} + +// AvJniGetJavaVm gets the Java virtual machine which has been set with AvJniSetJavaVm. +func AvJniGetJavaVm(logCtx CVoidPointer) { + C.av_jni_get_java_vm(VoidPointer(logCtx)) +} diff --git a/avcodec_mediacodec.go b/avcodec_mediacodec.go new file mode 100644 index 0000000..8fb1596 --- /dev/null +++ b/avcodec_mediacodec.go @@ -0,0 +1,45 @@ +//go:build ffmpeg_hw_mediacodec + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVMediaCodecContext +type AVMediaCodecContext C.struct_AVMediaCodecContext + +// AvMediacodecAllocContext allocates and initializes a MediaCodec context. +func AvMediacodecAllocContext() *AVMediaCodecContext { + return (*AVMediaCodecContext)(C.av_mediacodec_alloc_context()) +} + +// AvMediacodecDefaultInit sets up the MediaCodec context. +func AvMediacodecDefaultInit(avctx *AVCodecContext, ctx *AVMediaCodecContext, surface CVoidPointer) int32 { + return (int32)(C.av_mediacodec_default_init((*C.struct_AVCodecContext)(avctx), + (*C.struct_AVMediaCodecContext)(ctx), VoidPointer(surface))) +} + +// AvMediacodecDefaultFree frees the MediaCodec context +func AvMediacodecDefaultFree(avctx *AVCodecContext) { + C.av_mediacodec_default_free((*C.struct_AVCodecContext)(avctx)) +} + +// MediaCodecBuffer +type MediaCodecBuffer C.struct_MediaCodecBuffer + +// AVMediaCodecBuffer +type AVMediaCodecBuffer = MediaCodecBuffer + +// AvMediacodecReleaseBuffer releases a MediaCodec buffer and render it to the surface that is associated +// with the decoder. +func AvMediacodecReleaseBuffer(buffer *AVMediaCodecBuffer, render int32) int32 { + return (int32)(C.av_mediacodec_release_buffer((*C.struct_MediaCodecBuffer)(buffer), (C.int)(render))) +} + +// AvMediacodecRenderBufferAtTime release a MediaCodec buffer and render it at the given time to the surface +// that is associated with the decoder. +func AvMediacodecRenderBufferAtTime(buffer *AVMediaCodecBuffer, time int64) int32 { + return (int32)(C.av_mediacodec_render_buffer_at_time((*C.struct_MediaCodecBuffer)(buffer), (C.int64_t)(time))) +} diff --git a/avcodec_packet.go b/avcodec_packet.go index b430028..488289d 100644 --- a/avcodec_packet.go +++ b/avcodec_packet.go @@ -385,7 +385,7 @@ func AvPacketNewSideData(pkt *AVPacket, _type AVPacketSideDataType, size int32) } // 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 uintptr) 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))) } diff --git a/avcodec_qsv.go b/avcodec_qsv.go new file mode 100644 index 0000000..e52ed67 --- /dev/null +++ b/avcodec_qsv.go @@ -0,0 +1,17 @@ +//go:build ffmpeg_hw_qsv + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVQSVContext +type AVQSVContext = C.struct_AVQSVContext + +// AvQsvAllocContext allocates a new context. +// It must be freed by the caller with AvFree(). +func AvQsvAllocContext() *AVQSVContext { + return (*AVQSVContext)(C.av_qsv_alloc_context()) +} diff --git a/avcodec_vaapi.go b/avcodec_vaapi.go new file mode 100644 index 0000000..3f97952 --- /dev/null +++ b/avcodec_vaapi.go @@ -0,0 +1,11 @@ +//go:build ffmpeg_hw_vaapi + +package ffmpeg + +/* +#include +*/ +import "C" + +// Deprecated: No use +type VaapiContext C.struct_vaapi_context diff --git a/avcodec_vdpau.go b/avcodec_vdpau.go new file mode 100644 index 0000000..94669f3 --- /dev/null +++ b/avcodec_vdpau.go @@ -0,0 +1,42 @@ +//go:build ffmpeg_hw_vdpau + +package ffmpeg + +/* +#include +*/ +import "C" + +// typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *, +// const VdpPictureInfo *, uint32_t, +// const VdpBitstreamBuffer *); +type AVVDPAURenderFunc2 = C.AVVDPAU_Render2 + +// AVVDPAUContext +type AVVDPAUContext C.struct_AVVDPAUContext + +// AvAllocVdpaucontext allocates AVVDPAUContext. +func AvAllocVdpaucontext() *AVVDPAUContext { + return (*AVVDPAUContext)(C.av_alloc_vdpaucontext()) +} + +// AvVdpauHwaccelGetRender2 +func AvVdpauHwaccelGetRender2(ctx *AVVDPAUContext) AVVDPAURenderFunc2 { + return (AVVDPAURenderFunc2)(C.av_vdpau_hwaccel_get_render2((*C.struct_AVVDPAUContext)(ctx))) +} + +// AvVdpauHwaccelSetRender2 +func AvVdpauHwaccelSetRender2(ctx *AVVDPAUContext, f AVVDPAURenderFunc2) { + C.av_vdpau_hwaccel_set_render2((*C.struct_AVVDPAUContext)(ctx), (C.AVVDPAU_Render2)(f)) +} + +// NONEED: av_vdpau_get_surface_parameters + +// NONEED: av_vdpau_get_surface_parameters + +// AvVdpauAllocContext +func AvVdpauAllocContext() *AVVDPAUContext { + return (*AVVDPAUContext)(C.av_vdpau_alloc_context()) +} + +// NONEED: av_vdpau_get_profile diff --git a/avcodec_videotoolbox.go b/avcodec_videotoolbox.go new file mode 100644 index 0000000..8d736e7 --- /dev/null +++ b/avcodec_videotoolbox.go @@ -0,0 +1,33 @@ +//go:build ffmpeg_hw_videotoolbox + +package ffmpeg + +/* +#include +*/ +import "C" + +type AVVideotoolboxContext C.struct_AVVideotoolboxContext + +// AvVideotoolboxAllocContext allocates and initializes a Videotoolbox context. +func AvVideotoolboxAllocContext() *AVVideotoolboxContext { + return (*AVVideotoolboxContext)(C.av_videotoolbox_alloc_context()) +} + +// AvVideotoolboxDefaultInit creates and sets up the Videotoolbox context using +// an internal implementation. +func AvVideotoolboxDefaultInit(avctx *AVCodecContext) int32 { + return (int32)(C.av_videotoolbox_default_init((*C.struct_AVCodecContext)(avctx))) +} + +// AvVideotoolboxDefaultInit2 creates and sets up the Videotoolbox context using +// an internal implementation. +func AvVideotoolboxDefaultInit2(avctx *AVCodecContext, vtctx *AVVideotoolboxContext) int32 { + return (int32)(C.av_videotoolbox_default_init2((*C.struct_AVCodecContext)(avctx), + (*C.struct_AVVideotoolboxContext)(vtctx))) +} + +// AvVideotoolboxDefaultFree frees the Videotoolbox context. +func AvVideotoolboxDefaultFree(avctx *AVCodecContext) { + C.av_videotoolbox_default_free((*C.struct_AVCodecContext)(avctx)) +} diff --git a/avcodec_xvmc.go b/avcodec_xvmc.go new file mode 100644 index 0000000..e05be1b --- /dev/null +++ b/avcodec_xvmc.go @@ -0,0 +1,15 @@ +//go:build ffmpeg_hw_xvmc + +package ffmpeg + +/* +#include +*/ +import "C" + +const ( + AV_XVMC_ID = C.AV_XVMC_ID +) + +// Deprecated: No use +type XvmcPixFmt C.struct_xvmc_pix_fmt diff --git a/avdevice.go b/avdevice.go index f9e8914..f09c74a 100644 --- a/avdevice.go +++ b/avdevice.go @@ -146,14 +146,14 @@ const ( // AvDeviceAppToDevControlMessage sends control message from application to device. func AvDeviceAppToDevControlMessage(s *AVFormatContext, - _type AVAppToDevMessageType, data CVoidPointer, dataSize uint) int32 { + _type AVAppToDevMessageType, data CVoidPointer, dataSize uintptr) int32 { return (int32)(C.avdevice_app_to_dev_control_message((*C.struct_AVFormatContext)(s), (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 CVoidPointer, dataSize uint) int32 { + _type AVDevToAppMessageType, data CVoidPointer, dataSize uintptr) int32 { return (int32)(C.avdevice_dev_to_app_control_message((*C.struct_AVFormatContext)(s), (C.enum_AVDevToAppMessageType)(_type), VoidPointer(data), (C.size_t)(dataSize))) } @@ -393,14 +393,6 @@ func (dcl *AVDeviceInfoList) GetDevices() []*AVDeviceInfo { 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) diff --git a/avfilter.go b/avfilter.go index 8d64baf..e08106d 100644 --- a/avfilter.go +++ b/avfilter.go @@ -207,14 +207,6 @@ func (fltc *AVFilterContext) GetInputsAddr() ***AVFilterLink { return (***AVFilterLink)(unsafe.Pointer(&fltc.inputs)) } -// Custom: GetInputsIdx gets `AVFilterContext.inputs` index value. -func (fltc *AVFilterContext) GetInputsIdx(idx int) *AVFilterLink { - if idx >= int(fltc.nb_inputs) { - return nil - } - return PointerOffset((*AVFilterLink)(*fltc.inputs), idx) -} - // Custom: GetNbInputs gets `AVFilterContext.nb_inputs` value. func (fltc *AVFilterContext) GetNbInputs() uint32 { return (uint32)(fltc.nb_inputs) @@ -263,14 +255,6 @@ func (fltc *AVFilterContext) GetOutputsAddr() ***AVFilterLink { return (***AVFilterLink)(unsafe.Pointer(&fltc.outputs)) } -// Custom: GetOutputsIdx gets `AVFilterContext.outputs` index value. -func (fltc *AVFilterContext) GetOutputsIdx(idx int) *AVFilterLink { - if idx >= int(fltc.nb_outputs) { - return nil - } - return PointerOffset((*AVFilterLink)(*fltc.outputs), idx) -} - // Custom: GetNbOutputs gets `AVFilterContext.nb_outputs` value. func (fltc *AVFilterContext) GetNbOutputs() uint32 { return (uint32)(fltc.nb_outputs) @@ -857,14 +841,6 @@ func (fltg *AVFilterGraph) GetFiltersAddr() ***AVFilterContext { return (***AVFilterContext)(unsafe.Pointer(&fltg.filters)) } -// Custom: GetFiltersIdx gets `AVFilterGraph.filters` index value. -func (fltg *AVFilterGraph) GetFiltersIdx(idx int) *AVFilterContext { - if idx >= int(fltg.nb_filters) { - return nil - } - return PointerOffset((*AVFilterContext)(*fltg.filters), idx) -} - // Custom: GetNbFilters gets `AVFilterGraph.nb_filters` value. func (fltg *AVFilterGraph) GetNbFilters() uint32 { return (uint32)(fltg.nb_filters) diff --git a/avformat.go b/avformat.go index 8a0ced7..85d25cb 100644 --- a/avformat.go +++ b/avformat.go @@ -1089,14 +1089,6 @@ func (s *AVFormatContext) GetStreamsAddr() ***AVStream { return (***AVStream)(unsafe.Pointer(&s.streams)) } -// Custom: GetStreamsIdx gets `AVFormatContext.streams` index value. -func (s *AVFormatContext) GetStreamsIdx(idx int) *AVStream { - if idx >= int(s.nb_streams) { - return nil - } - return PointerOffset((*AVStream)(*s.streams), idx) -} - // Custom: GetFilename gets `AVFormatContext.filename` value. func (s *AVFormatContext) GetFilename() string { return C.GoString((*C.char)(&s.filename[0])) @@ -1299,14 +1291,6 @@ func (s *AVFormatContext) GetProgramsAddr() ***AVProgram { return (***AVProgram)(unsafe.Pointer(&s.programs)) } -// Custom: GetProgramsIdx gets `AVFormatContext.programs` index value. -func (s *AVFormatContext) GetProgramsIdx(idx int) *AVProgram { - if idx >= int(s.nb_programs) { - return nil - } - return PointerOffset((*AVProgram)(*s.programs), idx) -} - // Custom: GetVideoCodecId gets `AVFormatContext.video_codec_id` value. func (s *AVFormatContext) GetVideoCodecId() AVCodecID { return (AVCodecID)(s.video_codec_id) @@ -1415,14 +1399,6 @@ func (s *AVFormatContext) GetChaptersAddr() ***AVChapter { return (***AVChapter)(&s.chapters) } -// Custom: GetChaptersIdx gets `AVFormatContext.chapters` index value. -func (s *AVFormatContext) GetChaptersIdx(idx int) *AVChapter { - if idx >= int(s.nb_chapters) { - return nil - } - return PointerOffset((*AVChapter)(*s.chapters), idx) -} - // Custom: GetMetadata gets `AVFormatContext.metadata` value. func (s *AVFormatContext) GetMetadata() *AVDictionary { return (*AVDictionary)(s.metadata) @@ -2208,7 +2184,7 @@ func AvFormatNewStream(s *AVFormatContext, c *AVCodec) *AVStream { } // AvStreamAddSideData wraps an existing array as stream side data. -func AvStreamAddSideData(st *AVStream, _type AVPacketSideDataType, data *uint8, size uint) int32 { +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))) } diff --git a/avformat_avio.go b/avformat_avio.go index a774b2a..865ad95 100644 --- a/avformat_avio.go +++ b/avformat_avio.go @@ -60,7 +60,7 @@ func (icb *AVIOInterruptCB) GetOpaqueAddr() *unsafe.Pointer { } // AVIODirEntryType -type AVIODirEntryType = C.enum_AVIODirEntryType +type AVIODirEntryType = int32 // C.enum_AVIODirEntryType const ( AVIO_ENTRY_UNKNOWN = AVIODirEntryType(C.AVIO_ENTRY_UNKNOWN) @@ -1041,10 +1041,8 @@ func AvIOSeekTime(s *AVIOContext, streamIndex int32, timestamp int64, flags int3 (C.int)(streamIndex), (C.int64_t)(timestamp), (C.int)(flags))) } -type AVBPrint C.struct_AVBPrint - // AvIOReadToBprint reads contents of h into print buffer, up to max_size bytes, or up to EOF. -func AvIOReadToBprint(s *AVIOContext, pb *AVBPrint, maxSize uint) int32 { +func AvIOReadToBprint(s *AVIOContext, pb *AVBPrint, maxSize uintptr) int32 { return (int32)(C.avio_read_to_bprint((*C.struct_AVIOContext)(s), (*C.struct_AVBPrint)(pb), (C.size_t)(maxSize))) } diff --git a/avutil_adler32.go b/avutil_adler32.go new file mode 100644 index 0000000..135d069 --- /dev/null +++ b/avutil_adler32.go @@ -0,0 +1,13 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +type AVAdler = C.AVAdler + +// AvAdler32Update calculates the Adler32 checksum of a buffer. +func AvAdler32Update(adler AVAdler, buf *uint8, len uint32) AVAdler { + return (AVAdler)(C.av_adler32_update((C.AVAdler)(adler), (*C.uint8_t)(buf), (C.uint)(len))) +} diff --git a/avutil_aes.go b/avutil_aes.go new file mode 100644 index 0000000..cc637e1 --- /dev/null +++ b/avutil_aes.go @@ -0,0 +1,26 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AVAES +type AVAES C.struct_AVAES + +// AvAesAlloc allocates an AVAES context. +func AvAesAlloc() *AVAES { + return (*AVAES)(C.av_aes_alloc()) +} + +// AvAesInit initializes an AVAES context. +func AvAesInit(a *AVAES, key *uint8, keyBits, decrypt int32) int32 { + return (int32)(C.av_aes_init((*C.struct_AVAES)(a), (*C.uint8_t)(key), + (C.int)(keyBits), (C.int)(decrypt))) +} + +// AvAesCrypt encrypts or decrypts a buffer using a previously initialized context. +func AvAesCrypt(a *AVAES, dst, src *uint8, count int32, iv *uint8, decrypt int32) { + C.av_aes_crypt((*C.struct_AVAES)(a), (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (*C.uint8_t)(iv), (C.int)(decrypt)) +} diff --git a/avutil_aes_ctr.go b/avutil_aes_ctr.go new file mode 100644 index 0000000..1621678 --- /dev/null +++ b/avutil_aes_ctr.go @@ -0,0 +1,60 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +const ( + AES_CTR_KEY_SIZE = C.AES_CTR_KEY_SIZE + AES_CTR_IV_SIZE = C.AES_CTR_IV_SIZE +) + +// AVAESCTR +type AVAESCTR C.struct_AVAESCTR + +// AvAesCtrAlloc allocates an AVAESCTR context. +func AvAesCtrAlloc() *AVAESCTR { + return (*AVAESCTR)(C.av_aes_ctr_alloc()) +} + +// AvAesCtrInit initializes an AVAESCTR context. +func AvAesCtrInit(a *AVAESCTR, key *uint8) int32 { + return (int32)(C.av_aes_ctr_init((*C.struct_AVAESCTR)(a), (*C.uint8_t)(key))) +} + +// AvAesCtrFree releases an AVAESCTR context. +func AvAesCtrFree(a *AVAESCTR) { + C.av_aes_ctr_free((*C.struct_AVAESCTR)(a)) +} + +// AvAesCtrCrypt processes a buffer using a previously initialized context. +func AvAesCtrCrypt(a *AVAESCTR, dst, src *uint8, size int32) { + C.av_aes_ctr_crypt((*C.struct_AVAESCTR)(a), + (*C.uint8_t)(dst), (*C.uint8_t)(src), (C.int)(size)) +} + +// AvAesCtrGetIv gets the current iv. +func AvAesCtrGetIv(a *AVAESCTR) *uint8 { + return (*uint8)(C.av_aes_ctr_get_iv((*C.struct_AVAESCTR)(a))) +} + +// AvAesCtrSetRandomIv generates a random iv. +func AvAesCtrSetRandomIv(a *AVAESCTR) { + C.av_aes_ctr_set_random_iv((*C.struct_AVAESCTR)(a)) +} + +// AvAesCtrSetIv changes the 8-byte iv. +func AvAesCtrSetIv(a *AVAESCTR, iv *uint8) { + C.av_aes_ctr_set_iv((*C.struct_AVAESCTR)(a), (*C.uint8_t)(iv)) +} + +// AvAesCtrSetFullIv changes the "full" 16-byte iv, including the counter. +func AvAesCtrSetFullIv(a *AVAESCTR, iv *uint8) { + C.av_aes_ctr_set_full_iv((*C.struct_AVAESCTR)(a), (*C.uint8_t)(iv)) +} + +// AvAesCtrIncrementIv increments the top 64 bit of the iv. +func AvAesCtrIncrementIv(a *AVAESCTR) { + C.av_aes_ctr_increment_iv((*C.struct_AVAESCTR)(a)) +} diff --git a/avutil_assert.go b/avutil_assert.go new file mode 100644 index 0000000..31cf479 --- /dev/null +++ b/avutil_assert.go @@ -0,0 +1,19 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AvAssert0 +func AvAssert0(cond bool) { + if !cond { + AvLog(nil, AV_LOG_PANIC, "Assertion failed\n") + panic("AvAssert0 assert failed") + } +} + +// AvAssert0Fpu asserts that floating point operations can be executed. +func AvAssert0Fpu() { + C.av_assert0_fpu() +} diff --git a/avutil_attributes.go b/avutil_attributes.go new file mode 100644 index 0000000..dd4ed7d --- /dev/null +++ b/avutil_attributes.go @@ -0,0 +1,6 @@ +package ffmpeg + +/* +#include +*/ +import "C" diff --git a/avutil_avstring.go b/avutil_avstring.go new file mode 100644 index 0000000..d16dafb --- /dev/null +++ b/avutil_avstring.go @@ -0,0 +1,86 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// NONEED: av_strstart + +// NONEED: av_stristart + +// NONEED: av_stristr + +// NONEED: av_strnstr + +// NONEED: av_strlcpy + +// NONEED: av_strlcat + +// NONEED: av_strlcatf + +// NONEED: av_strnlen + +// NONEED: av_asprintf + +// NONEED: av_d2str + +// NONEED: av_get_token + +// NONEED: av_strtok + +// NONEED: av_isgraph + +// NONEED: av_isspace + +// NONEED: av_toupper + +// NONEED: av_tolower + +// NONEED: av_isxdigit + +// NONEED: av_strcasecmp + +// NONEED: av_strncasecmp + +// NONEED: av_strireplace + +// NONEED: av_basename + +// NONEED: av_dirname + +// NONEED: av_match_name + +// NONEED: av_append_path_component + +type AVEscapeMode C.enum_AVEscapeMode + +const ( + AV_ESCAPE_MODE_AUTO = C.AV_ESCAPE_MODE_AUTO + AV_ESCAPE_MODE_BACKSLASH = C.AV_ESCAPE_MODE_BACKSLASH + AV_ESCAPE_MODE_QUOTE = C.AV_ESCAPE_MODE_QUOTE + AV_ESCAPE_MODE_XML = C.AV_ESCAPE_MODE_XML +) + +const ( + AV_ESCAPE_FLAG_WHITESPACE = C.AV_ESCAPE_FLAG_WHITESPACE + AV_ESCAPE_FLAG_STRICT = C.AV_ESCAPE_FLAG_STRICT + AV_ESCAPE_FLAG_XML_SINGLE_QUOTES = C.AV_ESCAPE_FLAG_XML_SINGLE_QUOTES + AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES = C.AV_ESCAPE_FLAG_XML_DOUBLE_QUOTES +) + +// NONEED: av_escape + +const ( + AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES = C.AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES + AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS = C.AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS + AV_UTF8_FLAG_ACCEPT_SURROGATES = C.AV_UTF8_FLAG_ACCEPT_SURROGATES + AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES = C.AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES + AV_UTF8_FLAG_ACCEPT_ALL = C.AV_UTF8_FLAG_ACCEPT_ALL +) + +// NONEED: av_utf8_decode + +// NONEED: av_match_list + +// NONEED: av_sscanf diff --git a/avutil_base64.go b/avutil_base64.go new file mode 100644 index 0000000..cf8a6ea --- /dev/null +++ b/avutil_base64.go @@ -0,0 +1,26 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AvBase64Decode decodes a base64-encoded string. +func AvBase64Decode(out *uint8, in *int8, outSize int32) int32 { + return (int32)(C.av_base64_decode((*C.uint8_t)(out), (*C.char)(in), (C.int)(outSize))) +} + +// AV_BASE64_DECODE_SIZE +func AV_BASE64_DECODE_SIZE[T HelperInteger](x T) T { + return x * 3 / 4 +} + +// AvBase64Encode encodes data to base64 and null-terminate. +func AvBase64Encode(out *int8, outSize int32, in *uint8, inSize int32) *int8 { + return (*int8)(C.av_base64_encode((*C.char)(out), (C.int)(outSize), (*C.uint8_t)(in), (C.int)(inSize))) +} + +// AV_BASE64_SIZE +func AV_BASE64_SIZE[T HelperInteger](x T) T { + return (x+2)/3*4 + 1 +} diff --git a/avutil_blowfish.go b/avutil_blowfish.go new file mode 100644 index 0000000..7618c7c --- /dev/null +++ b/avutil_blowfish.go @@ -0,0 +1,87 @@ +package ffmpeg + +/* +#include +*/ +import "C" +import "unsafe" + +const ( + AV_BF_ROUNDS = C.AV_BF_ROUNDS +) + +type AVBlowfish C.struct_AVBlowfish + +// Custom: GetP gets `AVBlowfish.p` value. +func (bf *AVBlowfish) GetP() []uint32 { + return unsafe.Slice((*uint32)(&bf.p[0]), AV_BF_ROUNDS+2) +} + +// Custom: SetP sets `AVBlowfish.p` value. +func (bf *AVBlowfish) SetP(v []uint32) { + for i := 0; i < FFMIN(len(v), AV_BF_ROUNDS+2); i++ { + bf.p[i] = (C.uint32_t)(v[i]) + } +} + +// Custom: GetPAddr gets `AVBlowfish.p` address. +func (bf *AVBlowfish) GetPAddr() **uint32 { + return (**uint32)(unsafe.Pointer(&bf.p)) +} + +// Custom: GetS gets `AVBlowfish.s` value. +func (bf *AVBlowfish) GetS() []uint32 { + return unsafe.Slice((*uint32)(&bf.s[0][0]), 4*256) +} + +// Custom: SetS sets `AVBlowfish.s` value. +func (bf *AVBlowfish) SetS(v []uint32) { + for i := 0; i < FFMIN(len(v), 4*256); i++ { + bf.s[i/256][i%256] = (C.uint32_t)(v[i]) + } +} + +// Custom: GetSAddr gets `AVBlowfish.s` address. +func (bf *AVBlowfish) GetSAddr() **uint32 { + return (**uint32)(unsafe.Pointer(&bf.s)) +} + +// Custom: GetSIdx gets `AVBlowfish.s` index value. +func (bf *AVBlowfish) GetSIdx(x, y int) uint32 { + return (uint32)(bf.s[x][y]) +} + +// Custom: SetSIdx sets `AVBlowfish.s` index value. +func (bf *AVBlowfish) SetSIdx(x, y int, v uint32) { + bf.s[x][y] = (C.uint32_t)(v) +} + +// Custom: GetSIdxAddr gets `AVBlowfish.s` index address. +func (bf *AVBlowfish) GetSIdxAddr(x, y int) *uint32 { + return (*uint32)(&bf.s[x][y]) +} + +// AvBlowfishAlloc allocates an AVBlowfish context. +func AvBlowfishAlloc() *AVBlowfish { + return (*AVBlowfish)(C.av_blowfish_alloc()) +} + +// AvBlowfishInit initializes an AVBlowfish context. +func AvBlowfishInit(ctx *AVBlowfish, key *uint8, keyLen int32) { + C.av_blowfish_init((*C.struct_AVBlowfish)(ctx), + (*C.uint8_t)(key), (C.int)(keyLen)) +} + +// AvBlowfishCryptEcb encrypts or decrypts a buffer using a previously initialized context. +func AvBlowfishCryptEcb(ctx *AVBlowfish, xl, xr *uint32, decrypt int32) { + C.av_blowfish_crypt_ecb((*C.struct_AVBlowfish)(ctx), + (*C.uint32_t)(xl), (*C.uint32_t)(xr), (C.int)(decrypt)) +} + +// AvBlowfishCrypt encrypts or decrypts a buffer using a previously initialized context. +func AvBlowfishCrypt(ctx *AVBlowfish, dst, src *uint8, + count int32, iv *uint8, decrypt int32) { + C.av_blowfish_crypt((*C.struct_AVBlowfish)(ctx), + (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (*C.uint8_t)(iv), (C.int)(decrypt)) +} diff --git a/avutil_bprint.go b/avutil_bprint.go new file mode 100644 index 0000000..252e089 --- /dev/null +++ b/avutil_bprint.go @@ -0,0 +1,82 @@ +package ffmpeg + +/* +#include + +void av_bprintf_wrap(AVBPrint *buf, const char *fmt) { + av_bprintf(buf, fmt, NULL); +} +*/ +import "C" +import ( + "fmt" + "unsafe" +) + +type AVBPrint C.struct_AVBPrint + +const ( + AV_BPRINT_SIZE_UNLIMITED = C.AV_BPRINT_SIZE_UNLIMITED + AV_BPRINT_SIZE_AUTOMATIC = C.AV_BPRINT_SIZE_AUTOMATIC + AV_BPRINT_SIZE_COUNT_ONLY = C.AV_BPRINT_SIZE_COUNT_ONLY +) + +// AvBprintInit initializes a print buffer. +func AvBprintInit(buf *AVBPrint, sizeInit, sizeMax uint32) { + C.av_bprint_init((*C.struct_AVBPrint)(buf), (C.uint)(sizeInit), (C.uint)(sizeMax)) +} + +// AvBprintInitForBuffer initializes a print buffer using a pre-existing buffer. +func AvBprintInitForBuffer(buf *AVBPrint, buffer *int8, size uint32) { + C.av_bprint_init_for_buffer((*C.struct_AVBPrint)(buf), (*C.char)(buffer), (C.uint)(size)) +} + +// AvBprintf appends a formatted string to a print buffer. +func AvBprintf(buf *AVBPrint, _fmt string, va ...any) { + strPtr, strFunc := StringCasting(fmt.Sprintf(_fmt, va...)) + defer strFunc() + C.av_bprintf_wrap((*C.struct_AVBPrint)(buf), (*C.char)(strPtr)) +} + +// NONEED: av_vbprintf + +// AvBprintChars appends char c n times to a print buffer. +func AvBprintChars(buf *AVBPrint, c int8, n uint32) { + C.av_bprint_chars((*C.struct_AVBPrint)(buf), (C.char)(c), (C.uint)(n)) +} + +// AvBprintAppendData appends data to a print buffer. +func AvBprintAppendData(buf *AVBPrint, data *int8, size uint32) { + C.av_bprint_append_data((*C.struct_AVBPrint)(buf), (*C.char)(data), (C.uint)(size)) +} + +// NONEED: av_bprint_strftime + +// AvBprintGetBuffer allocates bytes in the buffer for external use. +func AvBprintGetBuffer(buf *AVBPrint, size uint32, mem **uint8, actualSize *uint32) { + C.av_bprint_get_buffer((*C.struct_AVBPrint)(buf), (C.uint)(size), + (**C.uint8_t)(unsafe.Pointer(mem)), (*C.uint)(actualSize)) +} + +// AvBprintClear resets the string to "" but keep internal allocated data. +func AvBprintClear(buf *AVBPrint) { + C.av_bprint_clear((*C.struct_AVBPrint)(buf)) +} + +// AvBprintIsComplete tests if the print buffer is complete (not truncated). +func AvBprintIsComplete(buf *AVBPrint) int32 { + return (int32)(C.av_bprint_is_complete((*C.struct_AVBPrint)(buf))) +} + +// AvBprintFinalize finalizes a print buffer. +func AvBprintFinalize(buf *AVBPrint, retStr **int8) int32 { + return (int32)(C.av_bprint_finalize((*C.struct_AVBPrint)(buf), + (**C.char)(unsafe.Pointer(retStr)))) +} + +// AvBprintEscape escapes the content in src and append it to dstbuf. +func AvBprintEscape(dstbuf *AVBPrint, src, specialChars *int8, mode AVEscapeMode, flags int32) { + C.av_bprint_escape((*C.struct_AVBPrint)(dstbuf), + (*C.char)(src), (*C.char)(specialChars), + (C.enum_AVEscapeMode)(mode), (C.int)(flags)) +} diff --git a/avutil_bswap.go b/avutil_bswap.go new file mode 100644 index 0000000..ab595a8 --- /dev/null +++ b/avutil_bswap.go @@ -0,0 +1,21 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AvBswap16 +func AvBswap16(x uint16) uint16 { + return (uint16)(C.av_bswap16((C.uint16_t)(x))) +} + +// AvBswap32 +func AvBswap32(x uint32) uint32 { + return (uint32)(C.av_bswap32((C.uint32_t)(x))) +} + +// AvBswap64 +func AvBswap64(x uint64) uint64 { + return (uint64)(C.av_bswap64((C.uint64_t)(x))) +} diff --git a/avutil_camellia.go b/avutil_camellia.go new file mode 100644 index 0000000..6565de6 --- /dev/null +++ b/avutil_camellia.go @@ -0,0 +1,26 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +type AVCAMELLIA C.struct_AVCAMELLIA + +// AvCamelliaAlloc allocates an AVCAMELLIA context. +func AvCamelliaAlloc() *AVCAMELLIA { + return (*AVCAMELLIA)(C.av_camellia_alloc()) +} + +// AvCamelliaInit initializes an AVCAMELLIA context. +func AvCamelliaInit(ctx *AVCAMELLIA, key *uint8, keyBits int32) int32 { + return (int32)(C.av_camellia_init((*C.struct_AVCAMELLIA)(ctx), + (*C.uint8_t)(key), (C.int)(keyBits))) +} + +// AvCamelliaCrypt encrypts or decrypts a buffer using a previously initialized context. +func AvCamelliaCrypt(ctx *AVCAMELLIA, dst, src *uint8, count int32, iv *uint8, decrypt int32) { + C.av_camellia_crypt((*C.struct_AVCAMELLIA)(ctx), + (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (*C.uint8_t)(iv), (C.int)(decrypt)) +} diff --git a/avutil_cast5.go b/avutil_cast5.go new file mode 100644 index 0000000..74f947f --- /dev/null +++ b/avutil_cast5.go @@ -0,0 +1,33 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +type AVCAST5 C.struct_AVCAST5 + +// AvCast5Alloc allocates an AVCAST5 context. +func AvCast5Alloc() *AVCAST5 { + return (*AVCAST5)(C.av_cast5_alloc()) +} + +// AvCast5Init initializes an AVCAST5 context. +func AvCast5Init(ctx *AVCAST5, key *uint8, keyBits int32) int32 { + return (int32)(C.av_cast5_init((*C.struct_AVCAST5)(ctx), + (*C.uint8_t)(key), (C.int)(keyBits))) +} + +// AvCast5Crypt encrypts or decrypts a buffer using a previously initialized context. +func AvCast5Crypt(ctx *AVCAST5, dst, src *uint8, count, decrypt int32) { + C.av_cast5_crypt((*C.struct_AVCAST5)(ctx), + (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (C.int)(decrypt)) +} + +// AvCast5Crypt2 encrypts or decrypts a buffer using a previously initialized context. +func AvCast5Crypt2(ctx *AVCAST5, dst, src *uint8, count int32, iv *uint8, decrypt int32) { + C.av_cast5_crypt2((*C.struct_AVCAST5)(ctx), + (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (*C.uint8_t)(iv), (C.int)(decrypt)) +} diff --git a/avutil_error.go b/avutil_error.go index 46bf838..121ca45 100644 --- a/avutil_error.go +++ b/avutil_error.go @@ -64,13 +64,13 @@ const ( // In case of failure the global variable errno is set to indicate the // error. Even in case of failure AvStrerror() will print a generic // error message indicating the errnum provided to errbuf. -func AvStrerror(errnum int32, errbuf *int8, errbufSize uint) int32 { +func AvStrerror(errnum int32, errbuf *int8, errbufSize uintptr) int32 { return (int32)(C.av_strerror((C.int)(errnum), (*C.char)(errbuf), (C.size_t)(errbufSize))) } // AvMakeErrorString fills the provided buffer with a string containing an error string // corresponding to the AVERROR code errnum. -func AvMakeErrorString(errbuf *int8, errbufSize uint, errnum int32) *int8 { +func AvMakeErrorString(errbuf *int8, errbufSize uintptr, errnum int32) *int8 { return (*int8)(C.av_make_error_string((*C.char)(errbuf), (C.size_t)(errbufSize), (C.int)(errnum))) } diff --git a/avutil_file.go b/avutil_file.go new file mode 100644 index 0000000..3d5ce51 --- /dev/null +++ b/avutil_file.go @@ -0,0 +1,34 @@ +package ffmpeg + +/* +#include +*/ +import "C" +import "unsafe" + +// AvFileMap reads the file with name filename, and put its content in a newly +// allocated buffer or map it with mmap() when available. +func AvFileMap(filename string, bufptr **uint8, size *uintptr, logOffset int32, logCtx CVoidPointer) int32 { + filenamePtr, filenameFunc := StringCasting(filename) + defer filenameFunc() + return (int32)(C.av_file_map((*C.char)(filenamePtr), (**C.uint8_t)(unsafe.Pointer(bufptr)), + (*C.size_t)(unsafe.Pointer(size)), (C.int)(logOffset), VoidPointer(logCtx))) +} + +// AvFileUnmap unmaps or frees the buffer bufptr created by AvFileMap(). +func AvFileUnmap(bufptr *uint8, size uintptr) { + C.av_file_unmap((*C.uint8_t)(bufptr), (C.size_t)(size)) +} + +// AvTempfile tries to create file in /tmp first, if possible. +func AvTempfile(prefix string, logOffset int32, logCtx CVoidPointer) (filename string, ret int32) { + prefixPtr, prefixFunc := StringCasting(prefix) + defer prefixFunc() + var filenamePtr *C.char + defer C.free(unsafe.Pointer(filenamePtr)) + ret = (int32)(C.av_tempfile((*C.char)(prefixPtr), + (**C.char)(unsafe.Pointer(&filenamePtr)), + (C.int)(logOffset), + VoidPointer(logCtx))) + return C.GoString(filenamePtr), ret +} diff --git a/avutil_frame.go b/avutil_frame.go index 14e8960..8ba6584 100644 --- a/avutil_frame.go +++ b/avutil_frame.go @@ -232,51 +232,35 @@ func (frame *AVFrame) GetData() []*uint8 { return unsafe.Slice((**uint8)(unsafe.Pointer(&frame.data[0])), AV_NUM_DATA_POINTERS) } +// Custom: SetData sets `AVFrame.data` value. +func (frame *AVFrame) SetData(v []*uint8) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + frame.data[i] = (*C.uint8_t)(v[i]) + } +} + // Custom: GetDataAddr gets `AVFrame.data` address. func (frame *AVFrame) GetDataAddr() ***uint8 { return (***uint8)(unsafe.Pointer(&frame.data)) } -// Custom: GetDataIdx gets `AVFrame.data` index value. -func (frame *AVFrame) GetDataIdx(idx int) *uint8 { - return (*uint8)(frame.data[idx]) -} - -// Custom: SetDataIdx sets `AVFrame.data` index value. -func (frame *AVFrame) SetDataIdx(idx int, v *uint8) { - frame.data[idx] = (*C.uint8_t)(v) -} - -// Custom: GetDataIdxAddr gets `AVFrame.data` index address. -func (frame *AVFrame) GetDataIdxAddr(idx int) **uint8 { - return (**uint8)(unsafe.Pointer(&frame.data[idx])) -} - // Custom: GetLinesize gets `AVFrame.linesize` value. func (frame *AVFrame) GetLinesize() []int32 { return unsafe.Slice((*int32)(&frame.linesize[0]), AV_NUM_DATA_POINTERS) } +// Custom: SetLinesize sets `AVFrame.linesize` value. +func (frame *AVFrame) SetLinesize(v []int32) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + frame.linesize[i] = (C.int)(v[i]) + } +} + // Custom: GetLinesizeAddr gets `AVFrame.linesize` address. func (frame *AVFrame) GetLinesizeAddr() **int32 { return (**int32)(unsafe.Pointer(&frame.linesize)) } -// Custom: GetLinesizeIdx gets `AVFrame.linesize` index value. -func (frame *AVFrame) GetLinesizeIdx(idx int) int32 { - return (int32)(frame.linesize[idx]) -} - -// Custom: SetLinesizeIdx sets `AVFrame.linesize` index value. -func (frame *AVFrame) SetLinesizeIdx(idx int, v int32) { - frame.linesize[idx] = (C.int)(v) -} - -// Custom: GetLinesizeIdxAddr gets `AVFrame.linesize` index address. -func (frame *AVFrame) GetLinesizeIdxAddr(idx int) *int32 { - return (*int32)(&frame.linesize[idx]) -} - // Custom: GetExtendedData gets `AVFrame.extended_data` value. func (frame *AVFrame) GetExtendedData() **uint8 { return (**uint8)(unsafe.Pointer(frame.extended_data)) @@ -297,7 +281,7 @@ func (frame *AVFrame) GetExtendedDataIdx(idx int) *uint8 { if frame.extended_data == nil { return nil } - return PointerOffset((*uint8)(*frame.extended_data), idx) + return (*uint8)(*PointerOffset(frame.extended_data, idx)) } // Custom: GetWidth gets `AVFrame.width` value. @@ -495,26 +479,18 @@ func (frame *AVFrame) GetQualityAddr() *int32 { return (*int32)(&frame.quality) } -// Custom: GetIdxError gets `AVFrame.error` index value. -func (frame *AVFrame) GetErrorIdx(idx int) uint64 { - return (uint64)(frame.error[idx]) -} - -// Custom: SetIdxError sets `AVFrame.error` index value. -func (frame *AVFrame) SetErrorIdx(idx int, v uint64) { - frame.error[idx] = (C.uint64_t)(v) -} - -// Custom: GetErrorIdxAddr gets `AVFrame.error` index address. -func (frame *AVFrame) GetErrorIdxAddr(idx int) *uint64 { - return (*uint64)(&frame.error[idx]) -} - // Custom: GetError gets `AVFrame.error` value. func (frame *AVFrame) GetError() []uint64 { return unsafe.Slice((*uint64)(&frame.error[0]), AV_NUM_DATA_POINTERS) } +// Custom: SetError sets `AVFrame.error` value. +func (frame *AVFrame) SetError(v []uint64) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + frame.error[i] = (C.uint64_t)(v[i]) + } +} + // Custom: GetErrorAddr gets `AVFrame.error` address. func (frame *AVFrame) GetErrorAddr() **uint64 { return (**uint64)(unsafe.Pointer(&frame.error)) @@ -625,30 +601,16 @@ func (frame *AVFrame) GetChannelLayoutAddr() *uint64 { return (*uint64)(&frame.channel_layout) } -// Custom: GetBufIdx gets `AVFrame.buf` value. +// Custom: GetBuf gets `AVFrame.buf` value. func (frame *AVFrame) GetBuf() []*AVBufferRef { return unsafe.Slice((**AVBufferRef)(unsafe.Pointer(&frame.buf[0])), AV_NUM_DATA_POINTERS) } -// Custom: GetBufIdx gets `AVFrame.buf` value. -func (frame *AVFrame) GetBufIdx(idx int) *AVBufferRef { - return (*AVBufferRef)(frame.buf[idx]) -} - -// Custom: SetBufIdx sets `AVFrame.buf` value. -func (frame *AVFrame) SetBufIdx(idx int, v *AVBufferRef) { - if idx > AV_NUM_DATA_POINTERS { - return +// Custom: SetBuf sets `AVFrame.buf` value. +func (frame *AVFrame) SetBuf(v []*AVBufferRef) { + for i := 0; i < FFMIN(len(v), AV_NUM_DATA_POINTERS); i++ { + frame.buf[i] = (*C.struct_AVBufferRef)(v[i]) } - frame.buf[idx] = (*C.struct_AVBufferRef)(v) -} - -// Custom: GetBufIdxAddr gets `AVFrame.buf` address. -func (frame *AVFrame) GetBufIdxAddr(idx int) **AVBufferRef { - if idx > AV_NUM_DATA_POINTERS { - return nil - } - return (**AVBufferRef)(unsafe.Pointer(&frame.buf[idx])) } // Custom: GetBufAddr gets `AVFrame.buf` address. @@ -675,14 +637,6 @@ func (frame *AVFrame) GetExtendedBufAddr() ***AVBufferRef { return (***AVBufferRef)(unsafe.Pointer(&frame.extended_buf)) } -// Custom: GetExtendedBufIdx gets `AVFrame.extended_buf` index value. -func (frame *AVFrame) GetExtendedBufIdx(idx int) *AVBufferRef { - if idx >= int(frame.nb_extended_buf) { - return nil - } - return PointerOffset((*AVBufferRef)(*frame.extended_buf), idx) -} - // Custom: GetNbExtendedBuf gets `AVFrame.nb_extended_buf` value. func (frame *AVFrame) GetNbExtendedBuf() int32 { return (int32)(frame.nb_extended_buf) @@ -716,14 +670,6 @@ func (frame *AVFrame) GetSideDataAddr() ***AVFrameSideData { return (***AVFrameSideData)(unsafe.Pointer(&frame.side_data)) } -// Custom: GetSideDataIdx gets `AVFrame.side_data` index value. -func (frame *AVFrame) GetSideDataIdx(idx int) *AVFrameSideData { - if idx >= int(frame.nb_side_data) { - return nil - } - return PointerOffset((*AVFrameSideData)(*frame.side_data), idx) -} - // Custom: GetNbSideData gets `AVFrame.nb_side_data` value. func (frame *AVFrame) GetNbSideData() int32 { return (int32)(frame.nb_side_data) @@ -1037,63 +983,63 @@ func (frame *AVFrame) GetOpaqueRefAddr() **AVBufferRef { } // Custom: GetCropTop gets `AVFrame.crop_top` value. -func (frame *AVFrame) GetCropTop() uint { - return (uint)(frame.crop_top) +func (frame *AVFrame) GetCropTop() uintptr { + return (uintptr)(frame.crop_top) } // Custom: SetCropTop sets `AVFrame.crop_top` value. -func (frame *AVFrame) SetCropTop(v uint) { +func (frame *AVFrame) SetCropTop(v uintptr) { frame.crop_top = (C.size_t)(v) } // Custom: GetCropTopAddr gets `AVFrame.crop_top` address. -func (frame *AVFrame) GetCropTopAddr() *uint { - return (*uint)(unsafe.Pointer(&frame.crop_top)) +func (frame *AVFrame) GetCropTopAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&frame.crop_top)) } // Custom: GetCropBottom gets `AVFrame.crop_bottom` value. -func (frame *AVFrame) GetCropBottom() uint { - return (uint)(frame.crop_bottom) +func (frame *AVFrame) GetCropBottom() uintptr { + return (uintptr)(frame.crop_bottom) } // Custom: SetCropBottom sets `AVFrame.crop_bottom` value. -func (frame *AVFrame) SetCropBottom(v uint) { +func (frame *AVFrame) SetCropBottom(v uintptr) { frame.crop_bottom = (C.size_t)(v) } // Custom: GetCropBottomAddr gets `AVFrame.crop_bottom` address. -func (frame *AVFrame) GetCropBottomAddr() *uint { - return (*uint)(unsafe.Pointer(&frame.crop_bottom)) +func (frame *AVFrame) GetCropBottomAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&frame.crop_bottom)) } // Custom: GetCropLeft gets `AVFrame.crop_left` value. -func (frame *AVFrame) GetCropLeft() uint { - return (uint)(frame.crop_left) +func (frame *AVFrame) GetCropLeft() uintptr { + return (uintptr)(frame.crop_left) } // Custom: SetCropLeft sets `AVFrame.crop_left` value. -func (frame *AVFrame) SetCropLeft(v uint) { +func (frame *AVFrame) SetCropLeft(v uintptr) { frame.crop_left = (C.size_t)(v) } // Custom: GetCropLeftAddr gets `AVFrame.crop_left` address. -func (frame *AVFrame) GetCropLeftAddr() *uint { - return (*uint)(unsafe.Pointer(&frame.crop_left)) +func (frame *AVFrame) GetCropLeftAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&frame.crop_left)) } // Custom: GetCropRight gets `AVFrame.crop_right` value. -func (frame *AVFrame) GetCropRight() uint { - return (uint)(frame.crop_right) +func (frame *AVFrame) GetCropRight() uintptr { + return (uintptr)(frame.crop_right) } // Custom: SetCropRight sets `AVFrame.crop_right` value. -func (frame *AVFrame) SetCropRight(v uint) { +func (frame *AVFrame) SetCropRight(v uintptr) { frame.crop_right = (C.size_t)(v) } // Custom: GetCropRightAddr gets `AVFrame.crop_right` address. -func (frame *AVFrame) GetCropRightAddr() *uint { - return (*uint)(unsafe.Pointer(&frame.crop_right)) +func (frame *AVFrame) GetCropRightAddr() *uintptr { + return (*uintptr)(unsafe.Pointer(&frame.crop_right)) } // Custom: GetPrivateRef gets `AVFrame.private_ref` value. diff --git a/avutil_hwcontext_cuda.go b/avutil_hwcontext_cuda.go new file mode 100644 index 0000000..d0d8837 --- /dev/null +++ b/avutil_hwcontext_cuda.go @@ -0,0 +1,15 @@ +//go:build ffmpeg_hw_cuda + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVCUDADeviceContextInternal +type AVCUDADeviceContextInternal C.struct_AVCUDADeviceContextInternal + +const ( + AV_CUDA_USE_PRIMARY_CONTEXT = C.AV_CUDA_USE_PRIMARY_CONTEXT +) diff --git a/avutil_hwcontext_d3d11va.go b/avutil_hwcontext_d3d11va.go new file mode 100644 index 0000000..8aac854 --- /dev/null +++ b/avutil_hwcontext_d3d11va.go @@ -0,0 +1,17 @@ +//go:build ffmpeg_hw_d3d11va + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVD3D11VADeviceContext +type AVD3D11VADeviceContext C.struct_AVD3D11VADeviceContext + +// AVD3D11FrameDescriptor +type AVD3D11FrameDescriptor C.struct_AVD3D11FrameDescriptor + +// AVD3D11VAFramesContext +type AVD3D11VAFramesContext C.struct_AVD3D11VAFramesContext diff --git a/avutil_hwcontext_drm.go b/avutil_hwcontext_drm.go new file mode 100644 index 0000000..f060674 --- /dev/null +++ b/avutil_hwcontext_drm.go @@ -0,0 +1,27 @@ +//go:build ffmpeg_hw_drm + +package ffmpeg + +/* +#include +*/ +import "C" + +const ( + AV_DRM_MAX_PLANES = C.AV_DRM_MAX_PLANES +) + +// AVDRMObjectDescriptor +type AVDRMObjectDescriptor C.struct_AVDRMObjectDescriptor + +// AVDRMPlaneDescriptor +type AVDRMPlaneDescriptor C.struct_AVDRMPlaneDescriptor + +// AVDRMLayerDescriptor +type AVDRMLayerDescriptor C.struct_AVDRMLayerDescriptor + +// AVDRMFrameDescriptor +type AVDRMFrameDescriptor C.struct_AVDRMFrameDescriptor + +// AVDRMDeviceContext +type AVDRMDeviceContext C.struct_AVDRMDeviceContext diff --git a/avutil_hwcontext_dxva2.go b/avutil_hwcontext_dxva2.go new file mode 100644 index 0000000..2237ee7 --- /dev/null +++ b/avutil_hwcontext_dxva2.go @@ -0,0 +1,14 @@ +//go:build ffmpeg_hw_dxva2 + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVDXVA2DeviceContext +type AVDXVA2DeviceContext C.struct_AVDXVA2DeviceContext + +// AVDXVA2FramesContext +type AVDXVA2FramesContext C.struct_AVDXVA2FramesContext diff --git a/avutil_hwcontext_mediacodec.go b/avutil_hwcontext_mediacodec.go new file mode 100644 index 0000000..ffcf44d --- /dev/null +++ b/avutil_hwcontext_mediacodec.go @@ -0,0 +1,11 @@ +//go:build ffmpeg_hw_mediacodec + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVMediaCodecDeviceContext +type AVMediaCodecDeviceContext C.struct_AVMediaCodecDeviceContext diff --git a/avutil_hwcontext_opencl.go b/avutil_hwcontext_opencl.go new file mode 100644 index 0000000..25fae00 --- /dev/null +++ b/avutil_hwcontext_opencl.go @@ -0,0 +1,17 @@ +//go:build ffmpeg_hw_opencl + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVOpenCLFrameDescriptor +type AVOpenCLFrameDescriptor C.struct_AVOpenCLFrameDescriptor + +// AVOpenCLDeviceContext +type AVOpenCLDeviceContext C.struct_AVOpenCLDeviceContext + +// AVOpenCLFramesContext +type AVOpenCLFramesContext C.struct_AVOpenCLFramesContext diff --git a/avutil_hwcontext_qsv.go b/avutil_hwcontext_qsv.go new file mode 100644 index 0000000..808c606 --- /dev/null +++ b/avutil_hwcontext_qsv.go @@ -0,0 +1,14 @@ +//go:build ffmpeg_hw_qsv + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVQSVDeviceContext +type AVQSVDeviceContext C.struct_AVQSVDeviceContext + +// AVQSVFramesContext +type AVQSVFramesContext C.struct_AVQSVFramesContext diff --git a/avutil_hwcontext_vaapi.go b/avutil_hwcontext_vaapi.go new file mode 100644 index 0000000..e2f1d95 --- /dev/null +++ b/avutil_hwcontext_vaapi.go @@ -0,0 +1,24 @@ +//go:build ffmpeg_hw_vaapi + +package ffmpeg + +/* +#include +*/ +import "C" + +const ( + AV_VAAPI_DRIVER_QUIRK_USER_SET = C.AV_VAAPI_DRIVER_QUIRK_USER_SET + AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS = C.AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS + AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE = C.AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE + AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES = C.AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES +) + +// AVVAAPIDeviceContext +type AVVAAPIDeviceContext C.struct_AVVAAPIDeviceContext + +// AVVAAPIFramesContext +type AVVAAPIFramesContext C.struct_AVVAAPIFramesContext + +// AVVAAPIHWConfig +type AVVAAPIHWConfig C.struct_AVVAAPIHWConfig diff --git a/avutil_hwcontext_vdpau.go b/avutil_hwcontext_vdpau.go new file mode 100644 index 0000000..fe82005 --- /dev/null +++ b/avutil_hwcontext_vdpau.go @@ -0,0 +1,11 @@ +//go:build ffmpeg_hw_vdpau + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVVDPAUDeviceContext +type AVVDPAUDeviceContext C.struct_AVVDPAUDeviceContext diff --git a/avutil_hwcontext_videotoolbox.go b/avutil_hwcontext_videotoolbox.go new file mode 100644 index 0000000..5e2e5ba --- /dev/null +++ b/avutil_hwcontext_videotoolbox.go @@ -0,0 +1,24 @@ +//go:build ffmpeg_hw_videotoolbox + +package ffmpeg + +/* +#include +*/ +import "C" + +// AvMapVideotoolboxFormatToPixfmt converts a VideoToolbox (actually CoreVideo) format to AVPixelFormat. +func AvMapVideotoolboxFormatToPixfmt(cvFmt uint32) AVPixelFormat { + return (AVPixelFormat)(C.av_map_videotoolbox_format_to_pixfmt((C.uint32_t)(cvFmt))) +} + +// AvMapVideotoolboxFormatFromPixfmt converts an AVPixelFormat to a VideoToolbox (actually CoreVideo) format. +func AvMapVideotoolboxFormatFromPixfmt(pixFmt AVPixelFormat) uint32 { + return (uint32)(C.av_map_videotoolbox_format_from_pixfmt((C.enum_AVPixelFormat)(pixFmt))) +} + +// AvMapVideotoolboxFormatFromPixfmt2 same as av_map_videotoolbox_format_from_pixfmt function, but can map and +// return full range pixel formats via a flag. +func AvMapVideotoolboxFormatFromPixfmt2(pixFmt AVPixelFormat, fullRange bool) uint32 { + return (uint32)(C.av_map_videotoolbox_format_from_pixfmt2((C.enum_AVPixelFormat)(pixFmt), C.bool(fullRange))) +} diff --git a/avutil_hwcontext_vulkan.go b/avutil_hwcontext_vulkan.go new file mode 100644 index 0000000..f977688 --- /dev/null +++ b/avutil_hwcontext_vulkan.go @@ -0,0 +1,28 @@ +//go:build ffmpeg_hw_vulkan + +package ffmpeg + +/* +#include +*/ +import "C" + +// AVVulkanDeviceContext +type AVVulkanDeviceContext C.struct_AVVulkanDeviceContext + +// AVVulkanFramesContext +type AVVulkanFramesContext C.struct_AVVulkanFramesContext + +// AVVkFrame +type AVVkFrame C.struct_AVVkFrame + +// AvVkFrameAlloc allocates a single AVVkFrame and initializes everything as 0. +func AvVkFrameAlloc() *AVVkFrame { + return (*AVVkFrame)(C.av_vk_frame_alloc()) +} + +// AvVkfmtFromPixfmt returns the format of each image up to the number of planes for a given sw_format. +// Returns NULL on unsupported formats. +func AvVkfmtFromPixfmt(p AVPixelFormat) *AVVkFrame { + return (*AVVkFrame)(C.av_vkfmt_from_pixfmt((C.enum_AVPixelFormat)(p))) +} diff --git a/avutil_imgutils.go b/avutil_imgutils.go index a198471..5620d71 100644 --- a/avutil_imgutils.go +++ b/avutil_imgutils.go @@ -38,7 +38,7 @@ func AvImageFillLinesizes(linesizes []int32, pixFmt AVPixelFormat, width int32) } // 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 { +func AvImageFillPlaneSizes(size []uintptr, pixFmt AVPixelFormat, height int32, linesizes []int) int32 { if len(size) < 4 { panic("size len < 4") } diff --git a/avutil_opt.go b/avutil_opt.go index 299330a..6a22e40 100644 --- a/avutil_opt.go +++ b/avutil_opt.go @@ -281,14 +281,6 @@ func (optrs *AVOptionRanges) GetRange() []*AVOptionRange { 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) diff --git a/avutil_pixdesc.go b/avutil_pixdesc.go index 1857c17..69a0791 100644 --- a/avutil_pixdesc.go +++ b/avutil_pixdesc.go @@ -152,23 +152,20 @@ func (pfd *AVPixFmtDescriptor) GetFlagsAddr() *uint64 { } // Custom: GetComp gets `AVPixFmtDescriptor.comp` value. -func (pfd *AVPixFmtDescriptor) GetComp(idx int) []AVComponentDescriptor { - return unsafe.Slice((*AVComponentDescriptor)(&pfd.comp[0]), idx) +func (pfd *AVPixFmtDescriptor) GetComp() []AVComponentDescriptor { + return unsafe.Slice((*AVComponentDescriptor)(&pfd.comp[0]), 4) } -// Custom: GetCompIdx gets `AVPixFmtDescriptor.comp` index value. -func (pfd *AVPixFmtDescriptor) GetCompIdx(idx int) AVComponentDescriptor { - return (AVComponentDescriptor)(pfd.comp[idx]) +// Custom: SetComp sets `AVPixFmtDescriptor.comp` value. +func (pfd *AVPixFmtDescriptor) SetComp(v []AVComponentDescriptor) { + for i := 0; i < FFMIN(len(v), 4); i++ { + pfd.comp[i] = (C.struct_AVComponentDescriptor)(v[i]) + } } -// 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: GetCompAddr gets `AVPixFmtDescriptor.comp` address. +func (pfd *AVPixFmtDescriptor) GetCompAddr() **AVComponentDescriptor { + return (**AVComponentDescriptor)(unsafe.Pointer(&pfd.comp)) } // Custom: GetAlias gets `AVPixFmtDescriptor.alias` value. diff --git a/avutil_tea.go b/avutil_tea.go new file mode 100644 index 0000000..f91bf63 --- /dev/null +++ b/avutil_tea.go @@ -0,0 +1,28 @@ +package ffmpeg + +/* +#include +*/ +import "C" + +// AVTEA +type AVTEA C.struct_AVTEA + +// AvTeaAlloc allocates an AVTEA context. +func AvTeaAlloc() *AVTEA { + return (*AVTEA)(C.av_tea_alloc()) +} + +// AvTeaInit initializes an AVTEA context. +func AvTeaInit(ctx *AVTEA, key []uint8, rounds int32) { + if len(key) < 16 { + panic("key len < 16") + } + C.av_tea_init((*C.struct_AVTEA)(ctx), (*C.uint8_t)(&key[0]), (C.int)(rounds)) +} + +// AvTeaCrypt encrypts or decrypts a buffer using a previously initialized context. +func AvTeaCrypt(ctx *AVTEA, dst, src *uint8, count int32, iv *uint8, decrypt int32) { + C.av_tea_crypt((*C.struct_AVTEA)(ctx), (*C.uint8_t)(dst), (*C.uint8_t)(src), + (C.int)(count), (*C.uint8_t)(iv), (C.int)(decrypt)) +} diff --git a/examples/avio-list-dir/main.go b/examples/avio-list-dir/main.go index 7905807..7978019 100644 --- a/examples/avio-list-dir/main.go +++ b/examples/avio-list-dir/main.go @@ -1,5 +1,113 @@ package main -func main() { +import ( + "fmt" + "os" + ffmpeg "github.com/qrtc/ffmpeg-dev-go" +) + +func typeString(_type int32) string { + switch _type { + case ffmpeg.AVIO_ENTRY_DIRECTORY: + return "" + case ffmpeg.AVIO_ENTRY_FILE: + return "" + case ffmpeg.AVIO_ENTRY_BLOCK_DEVICE: + return "" + case ffmpeg.AVIO_ENTRY_CHARACTER_DEVICE: + return "" + case ffmpeg.AVIO_ENTRY_NAMED_PIPE: + return "" + case ffmpeg.AVIO_ENTRY_SYMBOLIC_LINK: + return "" + case ffmpeg.AVIO_ENTRY_SOCKET: + return "" + case ffmpeg.AVIO_ENTRY_SERVER: + return "" + case ffmpeg.AVIO_ENTRY_SHARE: + return "" + case ffmpeg.AVIO_ENTRY_WORKGROUP: + return "" + case ffmpeg.AVIO_ENTRY_UNKNOWN: + default: + break + } + return "" +} + +func listOp(inputDir string) int32 { + var entry *ffmpeg.AVIODirEntry + var ctx *ffmpeg.AVIODirContext + var cnt, ret int32 + var filemode, uidAndGid string + + if ret = ffmpeg.AvIOOpenDir(&ctx, inputDir, nil); ret < 0 { + ffmpeg.AvLog(nil, ffmpeg.AV_LOG_ERROR, "Cannot open directory: %s.\n", ffmpeg.AvErr2str(ret)) + goto fail + } + + for { + if ret = ffmpeg.AvIOReadDir(ctx, &entry); ret < 0 { + ffmpeg.AvLog(nil, ffmpeg.AV_LOG_ERROR, "Cannot list directory: %s.\n", ffmpeg.AvErr2str(ret)) + goto fail + } + if entry == nil { + break + } + if entry.GetFilemode() == -1 { + filemode = "???" + } else { + filemode = fmt.Sprintf("%3d", entry.GetFilemode()) + } + uidAndGid = fmt.Sprintf("%d(%d)", entry.GetUserId(), entry.GetGroupId()) + if cnt == 0 { + ffmpeg.AvLog(nil, ffmpeg.AV_LOG_INFO, "%-9s %12s %30s %10s %s %16s %16s %16s\n", + "TYPE", "SIZE", "NAME", "UID(GID)", "UGO", "MODIFIED", + "ACCESSED", "STATUS_CHANGED") + } + ffmpeg.AvLog(nil, ffmpeg.AV_LOG_INFO, "%-9s %12d %30s %10s %s %d %d %d\n", + typeString(entry.GetType()), + entry.GetSize(), + entry.GetName(), + uidAndGid, + filemode, + entry.GetModificationTimestamp(), + entry.GetAccessTimestamp(), + entry.GetStatusChangeTimestamp()) + ffmpeg.AvIOFreeDirectoryEntry(&entry) + cnt++ + } + +fail: + ffmpeg.AvIOCloseDir(&ctx) + return ret +} + +func usage(programName string) { + fmt.Fprintf(os.Stderr, "usage: %s input_dir\n"+ + "API example program to show how to list files in directory "+ + "accessed through AVIOContext.\n", programName) + os.Exit(1) +} + +func main() { + var ret int32 + + ffmpeg.AvLogSetLevel(ffmpeg.AV_LOG_DEBUG) + + if len(os.Args) < 2 { + usage(os.Args[0]) + os.Exit(1) + } + + ffmpeg.AvFormatNetworkInit() + + ret = listOp(os.Args[1]) + + ffmpeg.AvFormatNetworkDeinit() + + if ret < 0 { + os.Exit(1) + } } diff --git a/examples/avio-reading/main.go b/examples/avio-reading/main.go index 7905807..453592b 100644 --- a/examples/avio-reading/main.go +++ b/examples/avio-reading/main.go @@ -1,5 +1,118 @@ package main -func main() { +/* +#include +int readPacket(void* opaque, uint8_t *buf, int bufSize); + +*/ +import "C" +import ( + "fmt" + "os" + "runtime/cgo" + "syscall" + "unsafe" + + ffmpeg "github.com/qrtc/ffmpeg-dev-go" +) + +type bufferData struct { + ptr *uint8 + size uintptr +} + +//export readPacket +func readPacket(opaque unsafe.Pointer, buf *uint8, bufSize int32) int32 { + bd := (*(*cgo.Handle)(opaque)).Value().(*bufferData) + bufSize = ffmpeg.FFMIN(bufSize, int32(bd.size)) + + if bufSize == 0 { + return ffmpeg.AVERROR_EOF + } + fmt.Fprintf(os.Stdout, "ptr:%p size:%d\n", bd.ptr, bd.size) + + // copy internal buffer data to buf + bd.ptr = ffmpeg.PointerOffset(bd.ptr, bufSize) + bd.size -= uintptr(bufSize) + + return bufSize +} + +func main() { + var fmtCtx *ffmpeg.AVFormatContext + var avioCtx *ffmpeg.AVIOContext + var buffer, avioCtxBuffer *uint8 + var bufferSize uintptr + var avioCtxBufferSize uint = 4096 + var ret int32 + var bd bufferData + var opaqueHandle cgo.Handle + + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "usage: %s input_file\n"+ + "API example program to show how to read from a custom buffer "+ + "accessed through AVIOContext.\n", os.Args[0]) + os.Exit(1) + } + inputFilename := os.Args[1] + + // slurp file content into buffer + if ret = ffmpeg.AvFileMap(inputFilename, &buffer, &bufferSize, 0, nil); ret < 0 { + goto end + } + + // fill opaque structure used by the AVIOContext read callback + bd.ptr = buffer + bd.size = bufferSize + + if fmtCtx = ffmpeg.AvFormatAllocContext(); fmtCtx == nil { + ret = ffmpeg.AVERROR(syscall.ENOMEM) + goto end + } + + if avioCtxBuffer = (*uint8)(ffmpeg.AvMalloc(avioCtxBufferSize)); avioCtxBuffer == nil { + ret = ffmpeg.AVERROR(syscall.ENOMEM) + goto end + } + + opaqueHandle = cgo.NewHandle(&bd) + if avioCtx = ffmpeg.AvIOAllocContext(avioCtxBuffer, int32(avioCtxBufferSize), 0, + &opaqueHandle, (ffmpeg.AVIOContextReadPacketFunc)(C.readPacket), nil, nil); avioCtx == nil { + ret = ffmpeg.AVERROR(syscall.ENOMEM) + goto end + } + fmtCtx.SetPb(avioCtx) + + if ret = ffmpeg.AvFormatOpenInput(&fmtCtx, ffmpeg.NIL, nil, nil); ret < 0 { + fmt.Fprintf(os.Stderr, "Could not open input\n") + goto end + } + + if ret = ffmpeg.AvFormatFindStreamInfo(fmtCtx, nil); ret < 0 { + fmt.Fprintf(os.Stderr, "Could not find stream information\n") + goto end + } + + ffmpeg.AvDumpFormat(fmtCtx, 0, inputFilename, 0) + +end: + ffmpeg.AvFormatCloseInput(&fmtCtx) + + if opaqueHandle != 0 { + opaqueHandle.Delete() + } + + // note: the internal buffer could have changed, and be != avio_ctx_buffer + if avioCtx != nil { + ffmpeg.AvFreep(avioCtx.GetBufferAddr()) + } + ffmpeg.AvIOContextFree(&avioCtx) + + ffmpeg.AvFileUnmap(buffer, bufferSize) + + if ret < 0 { + fmt.Fprintf(os.Stderr, "Error occurred: %s\n", ffmpeg.AvErr2str(ret)) + os.Exit(1) + } } diff --git a/examples/decode-audio/main.go b/examples/decode-audio/main.go index 4338e02..8aa23bc 100644 --- a/examples/decode-audio/main.go +++ b/examples/decode-audio/main.go @@ -34,7 +34,7 @@ func getFormatFromSampleFmt(sampleFmt ffmpeg.AVSampleFormat) (string, int32) { fmt.Fprintf(os.Stderr, "sample format %s is not supported as output format\n", ffmpeg.AvGetSampleFmtName(sampleFmt)) - return "", -1 + return ffmpeg.NIL, -1 } func decode(decCtx *ffmpeg.AVCodecContext, pkt *ffmpeg.AVPacket, frame *ffmpeg.AVFrame, outfile *os.File) { @@ -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.ByteSliceWithOffset(frame.GetDataIdx(ch), dataSize*i, dataSize)) + outfile.Write(ffmpeg.ByteSliceWithOffset(frame.GetData()[ch], dataSize*i, dataSize)) } } } diff --git a/examples/decode-video/main.go b/examples/decode-video/main.go index c646d9b..f99375e 100644 --- a/examples/decode-video/main.go +++ b/examples/decode-video/main.go @@ -42,7 +42,7 @@ func decode(decCtx *ffmpeg.AVCodecContext, frame *ffmpeg.AVFrame, pkt *ffmpeg.AV // the picture is allocated by the decoder. no need to free it fname := fmt.Sprintf("%s-%d", filename, decCtx.GetFrameNumber()) - pgmSave(frame.GetDataIdx(0), frame.GetLinesizeIdx(0), frame.GetWidth(), frame.GetHeight(), fname) + pgmSave(frame.GetData()[0], frame.GetLinesize()[0], frame.GetWidth(), frame.GetHeight(), fname) } } diff --git a/examples/encode-audio/main.go b/examples/encode-audio/main.go index e3affde..9212ee1 100644 --- a/examples/encode-audio/main.go +++ b/examples/encode-audio/main.go @@ -159,7 +159,7 @@ func main() { if ret := ffmpeg.AvFrameMakeWritable(frame); ret < 0 { os.Exit(1) } - samples := unsafe.Slice((*uint16)(unsafe.Pointer(frame.GetDataIdx(0))), 2*avctx.GetFrameSize()+avctx.GetChannels()) + samples := unsafe.Slice((*uint16)(unsafe.Pointer(frame.GetData()[0])), avctx.GetFrameSize()*avctx.GetChannels()) for j := 0; j < int(avctx.GetFrameSize()); j++ { samples[2*j] = (uint16)(math.Sin(t) * 10000) diff --git a/examples/encode-video/main.go b/examples/encode-video/main.go index 5ab90da..9e741ab 100644 --- a/examples/encode-video/main.go +++ b/examples/encode-video/main.go @@ -120,20 +120,20 @@ func main() { } // prepare a dummy image - data0 := unsafe.Slice(frame.GetDataIdx(0), avctx.GetHeight()*frame.GetLinesizeIdx(0)+avctx.GetWidth()) - data1 := unsafe.Slice(frame.GetDataIdx(1), (avctx.GetHeight()/2)*frame.GetLinesizeIdx(1)+(avctx.GetWidth()/2)) - data2 := unsafe.Slice(frame.GetDataIdx(2), (avctx.GetHeight()/2)*frame.GetLinesizeIdx(2)+(avctx.GetWidth()/2)) + data0 := unsafe.Slice(frame.GetData()[0], avctx.GetHeight()*frame.GetLinesize()[0]) + data1 := unsafe.Slice(frame.GetData()[1], (avctx.GetHeight()/2)*frame.GetLinesize()[1]) + data2 := unsafe.Slice(frame.GetData()[2], (avctx.GetHeight()/2)*frame.GetLinesize()[2]) // Y for y := 0; y < int(avctx.GetHeight()); y++ { for x := 0; x < int(avctx.GetWidth()); x++ { - data0[y*int(frame.GetLinesizeIdx(0))+x] = uint8(x + y + i*3) + data0[y*int(frame.GetLinesize()[0])+x] = uint8(x + y + i*3) } } // Cb and Cr for y := 0; y < int(avctx.GetHeight()/2); y++ { for x := 0; x < int(avctx.GetWidth()/2); x++ { - data1[y*int(frame.GetLinesizeIdx(1))+x] = uint8(128 + y + i*2) - data2[y*int(frame.GetLinesizeIdx(2))+x] = uint8(64 + x + i*5) + data1[y*int(frame.GetLinesize()[1])+x] = uint8(128 + y + i*2) + data2[y*int(frame.GetLinesize()[2])+x] = uint8(64 + x + i*5) } } diff --git a/examples/filter-audio/main.go b/examples/filter-audio/main.go index d711f15..21ffd62 100644 --- a/examples/filter-audio/main.go +++ b/examples/filter-audio/main.go @@ -1,5 +1,9 @@ package main +// filter-audio 0.05 +// plane 0: 0x3A1E227C0C1A0DA59EAA91C35653125C +// plane 0: 0xA7922B09261B407E49C545A68B671572 + import ( "fmt" "math" diff --git a/examples/hw-decode/main.go b/examples/hw-decode/main.go index f22246e..5e0bd0e 100644 --- a/examples/hw-decode/main.go +++ b/examples/hw-decode/main.go @@ -22,7 +22,7 @@ int get_hw_format(struct AVCodecContext *ctx, const int *pix_fmts) { const int *p; - fprintf(stderr, "get_hw_format called.\n"); + fprintf(stderr, "get_hw_format ballback has been invoked.\n"); for (p = pix_fmts; *p != -1; p++) { if (*p == hw_pix_fmt) return *p; @@ -44,20 +44,20 @@ import ( ) var ( - hwDeviceCtx *ffmpeg.AVBufferRef - outputFile *os.File +// Note: Gobal variable as argument pass to C world may be cause panic. +// `runtime error: cgo argument has Go pointer to unpinned Go pointer` ) -func hwDecoderInit(ctx *ffmpeg.AVCodecContext, hwType ffmpeg.AVHWDeviceType) (ret int32) { - if ret := ffmpeg.AvHWDeviceCtxCreate(&hwDeviceCtx, hwType, "", nil, 0); ret < 0 { +func hwDecoderInit(ctx *ffmpeg.AVCodecContext, hwType ffmpeg.AVHWDeviceType) (hwDeviceCtx *ffmpeg.AVBufferRef, ret int32) { + if ret := ffmpeg.AvHWDeviceCtxCreate(&hwDeviceCtx, hwType, ffmpeg.NIL, nil, 0); ret < 0 { fmt.Fprintf(os.Stderr, "Failed to create specified HW device.\n") - return ret + return nil, ret } ctx.SetHwDeviceCtx(ffmpeg.AvBufferRef(hwDeviceCtx)) - return ret + return hwDeviceCtx, ret } -func decodeWrite(avctx *ffmpeg.AVCodecContext, packet *ffmpeg.AVPacket) (ret int32) { +func decodeWrite(avctx *ffmpeg.AVCodecContext, packet *ffmpeg.AVPacket, outputFile *os.File) (ret int32) { var frame, swFrame, tmpFrame *ffmpeg.AVFrame var buffer *uint8 var size int32 @@ -129,6 +129,8 @@ func decodeWrite(avctx *ffmpeg.AVCodecContext, packet *ffmpeg.AVPacket) (ret int } func main() { + var outputFile *os.File + var hwDeviceCtx *ffmpeg.AVBufferRef var inputCtx *ffmpeg.AVFormatContext var videoStream, ret int32 var video *ffmpeg.AVStream @@ -182,7 +184,6 @@ func main() { } 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 } @@ -192,14 +193,14 @@ func main() { os.Exit(int(ffmpeg.AVERROR(syscall.ENOMEM))) } - video = inputCtx.GetStreamsIdx(int(videoStream)) + video = inputCtx.GetStreams()[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 { + if hwDeviceCtx, ret = hwDecoderInit(decoderCtx, hwType); ret < 0 { os.Exit(1) } @@ -217,7 +218,7 @@ func main() { break } if videoStream == packet.GetStreamIndex() { - ret = decodeWrite(decoderCtx, &packet) + ret = decodeWrite(decoderCtx, &packet, outputFile) } ffmpeg.AvPacketUnref(&packet) @@ -226,7 +227,7 @@ func main() { // flush the decoder packet.SetData(nil) packet.SetSize(0) - ret = decodeWrite(decoderCtx, &packet) + ret = decodeWrite(decoderCtx, &packet, outputFile) ffmpeg.AvPacketUnref(&packet) if outputFile != nil { diff --git a/examples/metadata/main.go b/examples/metadata/main.go index 7905807..ca736ff 100644 --- a/examples/metadata/main.go +++ b/examples/metadata/main.go @@ -1,5 +1,40 @@ package main -func main() { +import ( + "fmt" + "os" + ffmpeg "github.com/qrtc/ffmpeg-dev-go" +) + +func main() { + var fmtCtx *ffmpeg.AVFormatContext + var tag *ffmpeg.AVDictionaryEntry + var ret int32 + + if len(os.Args) != 2 { + fmt.Fprintf(os.Stderr, "usage: %s \n"+ + "example program to demonstrate the use of the libavformat metadata API.\n"+ + "\n", os.Args[0]) + os.Exit(1) + } + + if ret = ffmpeg.AvFormatOpenInput(&fmtCtx, os.Args[1], nil, nil); ret != 0 { + os.Exit(int(ret)) + } + + if ret = ffmpeg.AvFormatFindStreamInfo(fmtCtx, nil); ret < 0 { + ffmpeg.AvLog(nil, ffmpeg.AV_LOG_ERROR, "Cannot find stream information\n") + os.Exit(int(ret)) + } + + for { + if tag = ffmpeg.AvDictGet(fmtCtx.GetMetadata(), "", tag, ffmpeg.AV_DICT_IGNORE_SUFFIX); tag == nil { + break + } + fmt.Fprintf(os.Stdout, "%s=%s\n", tag.GetKey(), tag.GetValue()) + } + + ffmpeg.AvFormatCloseInput(&fmtCtx) + os.Exit(0) } diff --git a/examples/scaling-video/main.go b/examples/scaling-video/main.go index 1b6c6c1..7f5c756 100644 --- a/examples/scaling-video/main.go +++ b/examples/scaling-video/main.go @@ -11,7 +11,7 @@ import ( func fillYuvImage(data [4]*uint8, linesize [4]int32, width, height, frameIndex int32) { // Y - data0 := unsafe.Slice(data[0], height*linesize[0]+width) + data0 := unsafe.Slice(data[0], height*linesize[0]) for y := int32(0); y < height; y++ { for x := int32(0); x < width; x++ { data0[y*linesize[0]+x] = (uint8)(x + y + frameIndex*3) diff --git a/examples/transcode-aac/main.go b/examples/transcode-aac/main.go index 0def024..27aeae3 100644 --- a/examples/transcode-aac/main.go +++ b/examples/transcode-aac/main.go @@ -100,7 +100,7 @@ func openOutputFile(filename string, inputCodecContext *ffmpeg.AVCodecContext) ( outputFormatContext.SetPb(outputIOContext) // Guess the desired container format based on the file extension. - outputFormatContext.SetOformat(ffmpeg.AvGuessFormat("", filename, "")) + outputFormatContext.SetOformat(ffmpeg.AvGuessFormat(ffmpeg.NIL, filename, ffmpeg.NIL)) if outputFormatContext.GetOformat() == nil { fmt.Fprintf(os.Stderr, "Could not find output file format\n") goto cleanup diff --git a/ffmpeg_helper.go b/ffmpeg_helper.go index e8dad11..9373be5 100644 --- a/ffmpeg_helper.go +++ b/ffmpeg_helper.go @@ -21,10 +21,12 @@ type HelperUnsingedInteger interface { ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr } +const NIL = "\\'nil'\\" + // StringCasting casts go string to c world char* with free function -// Note: if input is a empty string will return a nil pointer. +// Note: if input is a NIL string will return a nil pointer. func StringCasting(str string) (allocPtr *C.char, freeFunc func()) { - if len(str) == 0 { + if str == NIL { return nil, func() {} } allocPtr = C.CString(str)