Fix AMD ALPR_OCR and custom model
This commit is contained in:
+29
-12
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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
@@ -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
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
Reference in New Issue
Block a user