Fix mutex lock issues (OCR and FR)

modules/ANSOCR/ANSONNXOCR/PaddleOCRV5Engine.cpp

@@ -13,6 +13,7 @@ bool PaddleOCRV5Engine::Initialize(const std::string& detModelPath,
                                     const std::string& recModelPath,
                                     const std::string& dictPath) {
     std::lock_guard<std::recursive_mutex> lock(_mutex);
+    ModelLoadingGuard mlg(_modelLoading);
 
     try {
         // Initialize detector (also triggers EPLoader init in BasicOrtHandler)
@@ -59,13 +60,16 @@ bool PaddleOCRV5Engine::Initialize(const std::string& detModelPath,
 }
 
 std::vector<OCRPredictResult> PaddleOCRV5Engine::ocr(const cv::Mat& img) {
-    std::lock_guard<std::recursive_mutex> lock(_mutex);
+    if (_modelLoading.load()) return {};
 
     std::vector<OCRPredictResult> results;
 
-    if (!_initialized || img.empty()) {
-        return results;
+    {
+        auto lk = TryLockWithTimeout("PaddleOCRV5Engine::ocr");
+        if (!lk.owns_lock()) return results;
+        if (!_initialized || img.empty()) return results;
     }
+    // _mutex released — heavy pipeline runs lock-free
 
     // Step 1: Text Detection
     auto boxes = detector_->Detect(img, _maxSideLen, _detDbThresh, _detBoxThresh, _detUnclipRatio, _useDilation);
@@ -127,8 +131,12 @@ std::vector<OCRPredictResult> PaddleOCRV5Engine::ocr(const cv::Mat& img) {
 }
 
 TextLine PaddleOCRV5Engine::recognizeOnly(const cv::Mat& croppedImage) {
-    std::lock_guard<std::recursive_mutex> lock(_mutex);
-    if (!_initialized || !recognizer_ || croppedImage.empty()) return { "", 0.0f };
+    if (_modelLoading.load()) return { "", 0.0f };
+    {
+        auto lk = TryLockWithTimeout("PaddleOCRV5Engine::recognizeOnly");
+        if (!lk.owns_lock()) return { "", 0.0f };
+        if (!_initialized || !recognizer_ || croppedImage.empty()) return { "", 0.0f };
+    }
     return recognizer_->Recognize(croppedImage);
 }
 

modules/ANSOCR/ANSONNXOCR/PaddleOCRV5Engine.h

@@ -7,6 +7,9 @@
 
 #include <memory>
 #include <mutex>
+#include <atomic>
+#include <chrono>
+#include <thread>
 #include <string>
 #include <vector>
 
@@ -48,6 +51,37 @@ private:
     std::unique_ptr<ONNXOCRRecognizer>  recognizer_;
 
     std::recursive_mutex _mutex;
+    std::atomic<bool>    _modelLoading{ false };
+
+    // RAII helper: sets _modelLoading=true on construction, false on destruction.
+    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;
+    };
+
+    // Try to lock _mutex with a timeout.  Returns a unique_lock that
+    // evaluates to true on success.
+    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; // unlocked
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        return lk; // locked
+    }
 
     // Detection parameters
     int   _maxSideLen    = kDetMaxSideLen;