Fix AMD ALPR_OCR and custom model

This commit is contained in:
2026-05-01 07:53:18 +10:00
parent e1f37ec767
commit 91efbb9a8f
25 changed files with 2841 additions and 429 deletions
+29 -12
View File
@@ -1,6 +1,7 @@
#include "ANSFLV.h"
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include "ANSCVVendorGate.h" // anscv_vendor_gate::IsNvidiaGpuAvailable()
#include "ANSLicense.h" // ANS_DBG macro
#include <memory>
@@ -785,17 +786,25 @@ extern "C" __declspec(dllexport) int GetFLVCVImage(ANSCENTER::ANSFLVClient** Han
// Thread-safe Mat pointer swap (anscv_mat_replace has its own internal lock)
anscv_mat_replace(image, std::move(img));
// NV12 GPU fast path (optional — disabled by default for stability)
// NV12 GPU fast path (optional — disabled by default for stability).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
if ((*Handle)->IsNV12FastPath()) {
int gpuIdx = (*Handle)->GetHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = (*Handle)->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSFLV V1 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->GetNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSFLV V1 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
}
@@ -1032,16 +1041,24 @@ extern "C" __declspec(dllexport) int GetFLVCVImage_V2(uint64_t handleVal, int& w
}
anscv_mat_replace(image, std::move(img));
// Attach NV12 frame for GPU fast-path inference (side-table registry)
// Attach NV12 frame for GPU fast-path inference (side-table registry).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
int gpuIdx = h->GetHWDecodingGpuIndex();
AVFrame* cudaHW = h->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ h->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = h->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ h->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSFLV V2 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = h->GetNV12Frame();
ansmedia::AvFramePtr nv12{ h->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSFLV V2 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
+29 -11
View File
@@ -1,6 +1,7 @@
#include "ANSFilePlayer.h"
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include <memory>
#include <cstdint>
#include <libswscale/swscale.h>
@@ -382,15 +383,24 @@ extern "C" __declspec(dllexport) int GetFilePlayerCVImage(ANSCENTER::ANSFILEPLAY
// Attach NV12/CUDA frames to registry for inference zero-copy (same as ANSRTSP/ANSVideoPlayer).
// CFilePlayer inherits getNV12Frame()/getCudaHWFrame() from CVideoPlayer.
// AvFramePtr wraps each clone so it auto-frees on any return path before
// the .release() handoff to gpu_frame_attach[_cuda] — leak-by-omission
// becomes impossible if an exception or early return slips in later.
int gpuIdx = (*Handle)->_playerClient->getHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->_playerClient->getCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->_playerClient->getCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = (*Handle)->_playerClient->getNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->_playerClient->getNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSFilePlayer V1 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp, cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->_playerClient->getNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->_playerClient->getNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSFilePlayer V1 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
} else {
// CPU-only fallback: attach full-res BGR clone for ANSRTYOLO
cv::Mat infImg = (*Handle)->GetInferenceImage();
@@ -639,16 +649,24 @@ extern "C" __declspec(dllexport) int GetFilePlayerCVImage_V2(uint64_t handleVal,
}
anscv_mat_replace(image, std::move(img));
// NV12/CUDA registry attach (same as V1)
// NV12/CUDA registry attach (same as V1).
// AvFramePtr ensures any clone we obtain is freed automatically if we
// don't reach the .release() handoff (e.g. exception, future early return).
int gpuIdx = h->_playerClient->getHWDecodingGpuIndex();
AVFrame* cudaHW = h->_playerClient->getCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ h->_playerClient->getCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = h->_playerClient->getNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ h->_playerClient->getNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSFilePlayer V2 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp, cpuNV12.release());
} else {
AVFrame* nv12 = h->_playerClient->getNV12Frame();
ansmedia::AvFramePtr nv12{ h->_playerClient->getNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSFilePlayer V2 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
} else {
cv::Mat infImg = h->GetInferenceImage();
if (!infImg.empty() && infImg.data != (*image)->data) {
+29 -12
View File
@@ -1,6 +1,7 @@
#include "ANSMJPEG.h"
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include "ANSCVVendorGate.h" // anscv_vendor_gate::IsNvidiaGpuAvailable()
#include "ANSLicense.h" // ANS_DBG macro
#include <memory>
@@ -784,17 +785,25 @@ extern "C" __declspec(dllexport) int GetMJPEGCVImage(ANSCENTER::ANSMJPEGClient**
// Thread-safe Mat pointer swap (anscv_mat_replace has its own internal lock)
anscv_mat_replace(image, std::move(img));
// NV12 GPU fast path (optional — disabled by default for stability)
// NV12 GPU fast path (optional — disabled by default for stability).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
if ((*Handle)->IsNV12FastPath()) {
int gpuIdx = (*Handle)->GetHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = (*Handle)->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSMJPEG V1 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->GetNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSMJPEG V1 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
}
@@ -1030,16 +1039,24 @@ extern "C" __declspec(dllexport) int GetMJPEGCVImage_V2(uint64_t handleVal, int&
}
anscv_mat_replace(image, std::move(img));
// Attach NV12 frame for GPU fast-path inference (side-table registry)
// Attach NV12 frame for GPU fast-path inference (side-table registry).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
int gpuIdx = h->GetHWDecodingGpuIndex();
AVFrame* cudaHW = h->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ h->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = h->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ h->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSMJPEG V2 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = h->GetNV12Frame();
ansmedia::AvFramePtr nv12{ h->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSMJPEG V2 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
+29 -12
View File
@@ -1,6 +1,7 @@
#include "ANSRTMP.h"
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include "ANSCVVendorGate.h" // anscv_vendor_gate::IsNvidiaGpuAvailable()
#include "ANSLicense.h" // ANS_DBG macro
#include <memory>
@@ -808,17 +809,25 @@ extern "C" __declspec(dllexport) int GetRTMPCVImage(ANSCENTER::ANSRTMPClient** H
// Thread-safe Mat pointer swap (anscv_mat_replace has its own internal lock)
anscv_mat_replace(image, std::move(img));
// NV12 GPU fast path (optional — disabled by default for stability)
// NV12 GPU fast path (optional — disabled by default for stability).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
if ((*Handle)->IsNV12FastPath()) {
int gpuIdx = (*Handle)->GetHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = (*Handle)->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSRTMP V1 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->GetNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSRTMP V1 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
}
@@ -1053,16 +1062,24 @@ extern "C" __declspec(dllexport) int GetRTMPCVImage_V2(uint64_t handleVal, int&
}
anscv_mat_replace(image, std::move(img));
// Attach NV12 frame for GPU fast-path inference (side-table registry)
// Attach NV12 frame for GPU fast-path inference (side-table registry).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
int gpuIdx = h->GetHWDecodingGpuIndex();
AVFrame* cudaHW = h->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ h->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = h->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ h->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSRTMP V2 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = h->GetNV12Frame();
ansmedia::AvFramePtr nv12{ h->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSRTMP V2 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
+18 -5
View File
@@ -2,6 +2,7 @@
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "GpuNV12SlotPool.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include "ANSLicense.h" // ANS_DBG macro
#include "ANSCVVendorGate.h" // anscv_vendor_gate::IsNvidiaGpuAvailable()
#include <memory>
@@ -1175,7 +1176,12 @@ extern "C" __declspec(dllexport) int GetRTSPCVImage(
(void*)*image, gpuIdx, (int)inFlightGuardHeld);
if (inFlightGuardHeld) {
AVFrame* cudaHW = (*Handle)->GetCudaHWFrame();
// AvFramePtr wraps each clone obtained from the player so it
// auto-frees on every return path before the .release() handoff
// to gpu_frame_attach[_cuda]. This closes the leak window if
// any future early-return / exception slips between the clone
// call and the attach call.
ansmedia::AvFramePtr cudaHW{ (*Handle)->GetCudaHWFrame() };
if (cudaHW) {
RTSP_DBG("[GetRTSPCVImage] cudaHW: %dx%d data[0]=%p data[1]=%p",
cudaHW->width, cudaHW->height,
@@ -1186,13 +1192,20 @@ extern "C" __declspec(dllexport) int GetRTSPCVImage(
gpuIdx, cudaHW->width, cudaHW->height);
// Only fetch CPU NV12 if pool slot unavailable (cross-GPU fallback).
AVFrame* cpuNV12 = slot ? nullptr : (*Handle)->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12, slot);
ansmedia::AvFramePtr cpuNV12{ slot ? nullptr : (*Handle)->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSRTSP attach_cuda cudaHW=%p cpuNV12=%p slot=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), (void*)slot, gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release(), slot);
} else {
// HW decode not active — try CPU NV12
AVFrame* nv12 = (*Handle)->GetNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSRTSP attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
+29 -12
View File
@@ -1,6 +1,7 @@
#include "ANSSRT.h"
#include "ANSMatRegistry.h"
#include "ANSGpuFrameOps.h"
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include "ANSCVVendorGate.h" // anscv_vendor_gate::IsNvidiaGpuAvailable()
#include "ANSLicense.h" // ANS_DBG macro
#include <memory>
@@ -826,17 +827,25 @@ extern "C" __declspec(dllexport) int GetSRTCVImage(ANSCENTER::ANSSRTClient** Han
// Thread-safe Mat pointer swap (anscv_mat_replace has its own internal lock)
anscv_mat_replace(image, std::move(img));
// NV12 GPU fast path (optional — disabled by default for stability)
// NV12 GPU fast path (optional — disabled by default for stability).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
if ((*Handle)->IsNV12FastPath()) {
int gpuIdx = (*Handle)->GetHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = (*Handle)->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSSRT V1 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->GetNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSSRT V1 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
}
@@ -1077,16 +1086,24 @@ extern "C" __declspec(dllexport) int GetSRTCVImage_V2(uint64_t handleVal, int& w
anscv_mat_replace(image, std::move(img));
// Attach NV12 frame for GPU fast-path inference (side-table registry)
// Attach NV12 frame for GPU fast-path inference (side-table registry).
// AvFramePtr auto-frees clones if we don't reach the .release() handoff.
int gpuIdx = h->GetHWDecodingGpuIndex();
AVFrame* cudaHW = h->GetCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ h->GetCudaHWFrame() };
if (cudaHW) {
AVFrame* cpuNV12 = h->GetNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ h->GetNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSSRT V2 attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp,
cpuNV12.release());
} else {
AVFrame* nv12 = h->GetNV12Frame();
ansmedia::AvFramePtr nv12{ h->GetNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSSRT V2 attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
+16 -5
View File
@@ -5,6 +5,7 @@
#include "ANSMatRegistry.h"
#include "ANSGpuFrameRegistry.h"
#include "ANSGpuFrameOps.h" // gpu_frame_attach, gpu_frame_attach_cuda
#include "av_frame_ptr.h" // ansmedia::AvFramePtr — RAII for AVFrame*
#include <memory>
#include <libswscale/swscale.h>
#include <libavutil/imgutils.h>
@@ -1010,17 +1011,27 @@ extern "C" __declspec(dllexport) int GetVideoPlayerCVImage(
// When using cv::VideoCapture fallback, attach BGR clone (pixFmt=1000).
if ((*Handle)->_hwDecodeActive && (*Handle)->_hwPlayer) {
// --- HW decode: NV12/CUDA attachment (same pattern as ANSRTSP.cpp:847-862) ---
// AvFramePtr wraps each clone so it auto-frees on any return path
// before the .release() handoff to gpu_frame_attach[_cuda]. This
// makes leak-by-omission impossible if an exception or early return
// is added between the clone and the attach call.
int gpuIdx = (*Handle)->_hwPlayer->getHWDecodingGpuIndex();
AVFrame* cudaHW = (*Handle)->_hwPlayer->getCudaHWFrame();
ansmedia::AvFramePtr cudaHW{ (*Handle)->_hwPlayer->getCudaHWFrame() };
if (cudaHW) {
// CUDA zero-copy: frame data[0]/data[1] are CUDA device pointers.
// Also attach CPU NV12 as fallback for cross-GPU inference.
AVFrame* cpuNV12 = (*Handle)->_hwPlayer->getNV12Frame();
gpu_frame_attach_cuda(*image, cudaHW, gpuIdx, timeStamp, cpuNV12);
ansmedia::AvFramePtr cpuNV12{ (*Handle)->_hwPlayer->getNV12Frame() };
ANS_DBG("MEDIA_AvPtr",
"ANSVideoPlayer attach_cuda cudaHW=%p cpuNV12=%p gpuIdx=%d",
(void*)cudaHW.get(), (void*)cpuNV12.get(), gpuIdx);
gpu_frame_attach_cuda(*image, cudaHW.release(), gpuIdx, timeStamp, cpuNV12.release());
} else {
AVFrame* nv12 = (*Handle)->_hwPlayer->getNV12Frame();
ansmedia::AvFramePtr nv12{ (*Handle)->_hwPlayer->getNV12Frame() };
if (nv12) {
gpu_frame_attach(*image, nv12, gpuIdx, timeStamp);
ANS_DBG("MEDIA_AvPtr",
"ANSVideoPlayer attach nv12=%p gpuIdx=%d",
(void*)nv12.get(), gpuIdx);
gpu_frame_attach(*image, nv12.release(), gpuIdx, timeStamp);
}
}
} else {