Fix mutex lock issues (OCR and FR)

modules/ANSOCR/ANSRTOCR/PaddleOCRV5RTEngine.cpp

@@ -12,6 +12,7 @@ bool PaddleOCRV5RTEngine::Initialize(const std::string& detModelPath,
                                       int gpuId,
                                       const std::string& engineCacheDir) {
     std::lock_guard<std::recursive_mutex> lock(_mutex);
+    ModelLoadingGuard mlg(_modelLoading);
 
     gpuId_ = gpuId;
     if (!engineCacheDir.empty()) {
@@ -57,10 +58,15 @@ bool PaddleOCRV5RTEngine::Initialize(const std::string& detModelPath,
 }
 
 std::vector<OCRPredictResult> PaddleOCRV5RTEngine::ocr(const cv::Mat& image) {
-    std::lock_guard<std::recursive_mutex> lock(_mutex);
-    std::vector<OCRPredictResult> results;
+    if (_modelLoading.load()) return {};
 
-    if (!detector_ || !recognizer_ || image.empty()) return results;
+    std::vector<OCRPredictResult> results;
+    {
+        auto lk = TryLockWithTimeout("PaddleOCRV5RTEngine::ocr");
+        if (!lk.owns_lock()) return results;
+        if (!detector_ || !recognizer_ || image.empty()) return results;
+    }
+    // _mutex released — heavy pipeline runs lock-free
 
     try {
         // 1. Detection: find text boxes
@@ -148,8 +154,12 @@ std::vector<OCRPredictResult> PaddleOCRV5RTEngine::ocr(const cv::Mat& image) {
 }
 
 TextLine PaddleOCRV5RTEngine::recognizeOnly(const cv::Mat& croppedImage) {
-    std::lock_guard<std::recursive_mutex> lock(_mutex);
-    if (!recognizer_ || croppedImage.empty()) return { "", 0.0f };
+    if (_modelLoading.load()) return { "", 0.0f };
+    {
+        auto lk = TryLockWithTimeout("PaddleOCRV5RTEngine::recognizeOnly");
+        if (!lk.owns_lock()) return { "", 0.0f };
+        if (!recognizer_ || croppedImage.empty()) return { "", 0.0f };
+    }
     return recognizer_->Recognize(croppedImage);
 }
 

modules/ANSOCR/ANSRTOCR/PaddleOCRV5RTEngine.h

@@ -6,6 +6,9 @@
 #include "RTOCRRecognizer.h"
 #include <memory>
 #include <mutex>
+#include <atomic>
+#include <chrono>
+#include <thread>
 #include <string>
 #include <vector>
 #include "ANSLicense.h"
@@ -64,6 +67,34 @@ private:
     std::string engineCacheDir_;
 
     std::recursive_mutex _mutex;
+    std::atomic<bool>    _modelLoading{ false };
+
+    struct ModelLoadingGuard {
+        std::atomic<bool>& flag;
+        explicit ModelLoadingGuard(std::atomic<bool>& f) : flag(f) { flag.store(true); }
+        ~ModelLoadingGuard() { flag.store(false); }
+        ModelLoadingGuard(const ModelLoadingGuard&) = delete;
+        ModelLoadingGuard& operator=(const ModelLoadingGuard&) = delete;
+    };
+
+    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) {
+                std::cerr << "[" << caller << "] Mutex acquisition timed out after "
+                          << timeoutMs << " ms"
+                          << (_modelLoading.load() ? " (model loading in progress)" : "")
+                          << std::endl;
+                return lk;
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        return lk;
+    }
 };
 
 } // namespace rtocr