Fix NV12 crash issue when recreate camera object

(new structure) does not work

include/GpuNV12SlotPool.h

@@ -0,0 +1,161 @@
+#pragma once
+// GpuNV12SlotPool.h — Process-wide GPU NV12 buffer pool.
+//
+// Provides pre-allocated CUDA buffer slots (Y + UV planes) that are shared
+// across all RTSP camera instances.  Slots are acquired per-frame by
+// GetRTSPCVImage and released back to the pool when the GpuFrameData's
+// refcount drops to 0 in freeOwnedBuffers_locked().
+//
+// KEY DESIGN: Slots are NEVER freed when a camera is destroyed — they are
+// recycled.  This decouples GPU buffer lifetime from camera lifetime, so
+// inference engines can safely read NV12 data even after the camera object
+// that produced it has been deleted and recreated (the LabVIEW reconnect
+// pattern: ReleaseHandle → Destroy → delete → CreateHandle).
+//
+// TIME-DELAYED RELEASE: When a GpuFrameData's refcount drops to 0, the
+// slot is NOT immediately available.  It enters a "cooling" state for
+// SLOT_COOLDOWN_MS (50ms) to guarantee that any in-flight GPU kernels
+// (launched asynchronously by inference engines) have completed reading
+// from the buffer.  CUDA kernels typically complete in <10ms, so 50ms
+// provides a 5x safety margin.  The cooldown is kept short to minimize
+// the number of slots in COOLING, which prevents POOL FULL events.
+// POOL FULL triggers per-frame cudaMalloc/cudaFree, which holds the
+// nvcuda64 SRW lock and causes cascading stalls on other cameras'
+// cudaMemcpy2D operations.
+//
+// Thread-safe: acquire() locks internally, deferRelease() is lock-free.
+//
+// Cross-DLL: uses the same resolveProcessWide() singleton pattern as
+// ANSGpuFrameRegistry.  ANSCV.dll owns the canonical instance; other DLLs
+// find it via GetProcAddress("GpuNV12SlotPool_GetInstance").
+
+#include <vector>
+#include <memory>
+#include <mutex>
+#include <atomic>
+#include <cstdint>
+#include <cstdio>
+#include <chrono>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+// Safety constants
+static constexpr int GPU_NV12_POOL_MAX_SLOTS   = 64;
+static constexpr int SLOT_COOLDOWN_MS          = 50;   // Time after CPU release before slot reuse
+                                                        // GPU kernels complete in <10ms; 50ms = 5× margin
+
+// Debug logging for pool operations.
+// Define ANSCORE_GPU_DEBUG=1 to enable verbose per-frame GPU logging.
+// In production, these are silent to avoid OutputDebugString/fprintf
+// lock contention (measured: 500-2000 calls/sec causes process stalls).
+#ifndef NV12POOL_DBG
+#if defined(ANSCORE_GPU_DEBUG) && ANSCORE_GPU_DEBUG
+#ifdef _WIN32
+#define NV12POOL_DBG(fmt, ...) do { \
+    char _p_buf[512]; \
+    snprintf(_p_buf, sizeof(_p_buf), "[NV12Pool] " fmt "\n", ##__VA_ARGS__); \
+    OutputDebugStringA(_p_buf); \
+    fprintf(stderr, "%s", _p_buf); \
+} while(0)
+#else
+#define NV12POOL_DBG(fmt, ...) fprintf(stderr, "[NV12Pool] " fmt "\n", ##__VA_ARGS__)
+#endif
+#else
+#define NV12POOL_DBG(fmt, ...) ((void)0)
+#endif
+#endif
+
+struct GpuNV12Slot {
+    void*  bufY    = nullptr;   // cudaMallocPitch'd Y plane
+    void*  bufUV   = nullptr;   // cudaMallocPitch'd UV plane
+    size_t pitchY  = 0;
+    size_t pitchUV = 0;
+    int    width   = 0;         // Resolution this slot was allocated for
+    int    height  = 0;
+    int    gpuIdx  = -1;        // GPU device index
+
+    // Slot lifecycle state:
+    //   FREE      (0) = available for acquire()
+    //   ACTIVE    (1) = owned by a GpuFrameData (D2D copy + inference reading)
+    //   COOLING   (2) = CPU released but GPU kernel may still be reading;
+    //                    becomes FREE after SLOT_COOLDOWN_MS elapses.
+    static constexpr int STATE_FREE    = 0;
+    static constexpr int STATE_ACTIVE  = 1;
+    static constexpr int STATE_COOLING = 2;
+    std::atomic<int> state{STATE_FREE};
+
+    // Timestamp when the slot entered COOLING state.
+    // Only meaningful when state == STATE_COOLING.
+    std::chrono::steady_clock::time_point cooldownStart;
+
+    // Per-slot CUDA stream for D2D copy (non-blocking).
+    // CRITICAL: cudaMemcpy2D (no stream arg) uses the NULL stream, which on
+    // WDDM implicitly synchronizes with ALL other streams before executing.
+    // This means the D2D copy must wait for all inference kernels to finish
+    // first — causing 1-2 second stalls.  Using a dedicated non-blocking
+    // stream avoids this implicit sync entirely.
+    // Stored as void* to avoid cuda_runtime.h in the header.
+    void* copyStream = nullptr;  // cudaStream_t
+};
+
+class GpuNV12SlotPool {
+public:
+    // Process-wide singleton (same pattern as ANSGpuFrameRegistry).
+    static GpuNV12SlotPool& instance() {
+#ifdef _WIN32
+        static GpuNV12SlotPool* s_inst = resolveProcessWide();
+        return *s_inst;
+#else
+        static GpuNV12SlotPool pool;
+        return pool;
+#endif
+    }
+
+    // Acquire a free slot matching (gpuIdx, w, h).
+    // Drains cooled-down slots first, then looks for a FREE match.
+    // If none, allocates a new one (up to GPU_NV12_POOL_MAX_SLOTS).
+    // Returns nullptr if pool full — caller falls back to CPU path.
+    GpuNV12Slot* acquire(int gpuIdx, int w, int h);
+
+    // Deferred release: moves slot from ACTIVE → COOLING.
+    // Called from freeOwnedBuffers_locked() when GpuFrameData refcount → 0.
+    // The slot becomes FREE after SLOT_COOLDOWN_MS elapses (checked in acquire).
+    static void deferRelease(GpuNV12Slot* slot) {
+        if (slot) {
+            slot->cooldownStart = std::chrono::steady_clock::now();
+            slot->state.store(GpuNV12Slot::STATE_COOLING, std::memory_order_release);
+        }
+    }
+
+    // Number of allocated slots (for diagnostics).
+    size_t slotCount() const {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_slots.size();
+    }
+
+    // Number of in-use slots (for diagnostics).
+    size_t activeCount() const {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        size_t count = 0;
+        for (auto& s : m_slots) {
+            if (s->state.load(std::memory_order_relaxed) != GpuNV12Slot::STATE_FREE) ++count;
+        }
+        return count;
+    }
+
+private:
+    GpuNV12SlotPool() = default;
+
+#ifdef _WIN32
+    static GpuNV12SlotPool* resolveProcessWide();
+#endif
+
+    // Transition all COOLING slots that have exceeded SLOT_COOLDOWN_MS to FREE.
+    // Called at the start of acquire() under the lock.
+    void drainCooledSlots_locked();
+
+    mutable std::mutex m_mutex;
+    std::vector<std::unique_ptr<GpuNV12Slot>> m_slots;
+};