Fix mutex lock issues (OCR and FR)

modules/ANSFR/ANSFaceRecognizer.cpp

@@ -44,6 +44,11 @@ namespace ANSCENTER {
 		const std::string& modelZipPassword,
 		std::string& labelMap)
 	{
+		struct LoadGuard {
+			std::atomic<bool>& f;
+			explicit LoadGuard(std::atomic<bool>& fl) : f(fl) { f.store(true); }
+			~LoadGuard() { f.store(false); }
+		} mlg(_modelLoading);
 		ANS_DBG("FaceRecognizer", "Initialize: modelZip=%s", modelZipFilePath.c_str());
 		bool result = ANSFRBase::Initialize(licenseKey, modelConfig, modelZipFilePath, modelZipPassword, labelMap);
 		if (!result) {
@@ -276,7 +281,9 @@ namespace ANSCENTER {
 			return embeddingResult;
 		}
 
-		std::lock_guard<std::recursive_mutex> lock(_mutex);
+		if (_modelLoading.load()) return embeddingResult;
+		auto lock = TryLockWithTimeout("ANSFaceRecognizer::Feature");
+		if (!lock.owns_lock()) return embeddingResult;
 
 		try {
 			if (engineType == EngineType::NVIDIA_GPU) {
@@ -338,7 +345,9 @@ namespace ANSCENTER {
 			return resultObjects;
 		}
 
-		std::lock_guard<std::recursive_mutex> lock(_mutex);
+		if (_modelLoading.load()) return resultObjects;
+		auto lock = TryLockWithTimeout("ANSFaceRecognizer::Match");
+		if (!lock.owns_lock()) return resultObjects;
 
 		if (!_isInitialized) {
 			_logger.LogError("ANSFaceRecognizer::Match",

modules/ANSFR/ANSFaceRecognizer.h

@@ -11,6 +11,9 @@
 #include <faiss/gpu/GpuIndexFlat.h>
 #include <faiss/gpu/StandardGpuResources.h>
 #include <unordered_map>
+#include <atomic>
+#include <chrono>
+#include <thread>
 #include "engine.h"
 #include "engine/EnginePoolManager.h"
 #include "ONNXEngine.h"
@@ -99,6 +102,28 @@ namespace ANSCENTER {
         const bool NORMALIZE = true;
 
         std::recursive_mutex _mutex;
+        std::atomic<bool>    _modelLoading{ false };
+
+        std::unique_lock<std::recursive_mutex> TryLockWithTimeout(
+                const char* caller, unsigned int timeoutMs = 5000)
+        {
+            const auto deadline = std::chrono::steady_clock::now()
+                                + std::chrono::milliseconds(timeoutMs);
+            std::unique_lock<std::recursive_mutex> lk(_mutex, std::defer_lock);
+            while (!lk.try_lock()) {
+                if (std::chrono::steady_clock::now() >= deadline) {
+                    _logger.LogWarn(caller,
+                        "Mutex acquisition timed out after "
+                        + std::to_string(timeoutMs) + " ms"
+                        + (_modelLoading.load() ? " (model loading in progress)" : ""),
+                        __FILE__, __LINE__);
+                    return lk;
+                }
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+            return lk;
+        }
+
         float m_knownPersonThresh = 0.35f;
         EngineType engineType;