Fix vpVideoWriterStorageWorker to be able to use a vector of vpConcurrentQueue.

Author: s-trinh

example/device/framegrabber/grabV4l2MultiCpp11Thread.cpp

@@ -491,7 +491,12 @@ int main(int argc, char *argv[])
       ss << "/%06d.png";
       std::string filename = ss.str();
 
-      storages.emplace_back(std::ref(save_queues[deviceId]), std::cref(filename));
+      std::vector< std::reference_wrapper<vpConcurrentQueue<vpImage<vpRGBa>>> > save_queue_single;
+      save_queue_single.emplace_back(std::ref(save_queues[deviceId]));
+
+      std::vector<std::string> filenames;
+      filenames.emplace_back(filename);
+      storages.emplace_back(save_queue_single, filenames);
     }
   }
 

modules/core/include/visp3/core/vpConcurrentQueue.h

@@ -50,12 +50,14 @@ template <class T, class Container = std::deque<T>> class VISP_EXPORT vpConcurre
   { };
 
   vpConcurrentQueue()
-    : m_cancelled(false), m_cond(), /*m_data(),*/ m_maxQueueSize(1024), m_mutex(), m_queue()
+    : m_cancelled(false), m_cond(), m_data(), m_maxQueueSize(1024), m_mutex(), m_queue()
   { }
 
   void cancel()
   {
-
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_cancelled = true;
+    m_cond.notify_all();
   }
 
   // Push the data into the queue (FIFO)
@@ -73,8 +75,7 @@ template <class T, class Container = std::deque<T>> class VISP_EXPORT vpConcurre
     m_cond.notify_one();
   }
 
-  // Pop the image to save from the queue (FIFO)
-  T &pop()
+  T pop()
   {
     std::unique_lock<std::mutex> lock(m_mutex);
 
@@ -90,16 +91,10 @@ template <class T, class Container = std::deque<T>> class VISP_EXPORT vpConcurre
       }
     }
 
-    // TODO:
-    // m_data = m_queue.front();
-    // m_queue.pop();
-
-    // return m_data;
-
-    T &data = m_queue.front();
+    m_data = m_queue.front();
     m_queue.pop();
 
-    return data;
+    return m_data;
   }
 
   void setMaxQueueSize(size_t max_queue_size)
@@ -110,7 +105,7 @@ template <class T, class Container = std::deque<T>> class VISP_EXPORT vpConcurre
 private:
   bool m_cancelled;
   std::condition_variable m_cond;
-  // T m_data;
+  T m_data;
   size_t m_maxQueueSize;
   std::mutex m_mutex;
   std::queue<T> m_queue;

modules/io/include/visp3/io/vpVideoWriterStorageWorker.h

@@ -47,8 +47,9 @@
 template <class T, class Container = std::deque<vpImage<T>>> class VISP_EXPORT vpVideoWriterStorageWorker
 {
 public:
-  vpVideoWriterStorageWorker(vpConcurrentQueue<vpImage<T>, Container> &queue, const std::string &filename)
-    : m_filename(filename), m_queue(queue), m_writer()
+  vpVideoWriterStorageWorker(const std::vector<std::reference_wrapper<vpConcurrentQueue<vpImage<T>, Container>>> &queues,
+    const std::vector< std::string > &filenames)
+    : m_filenames(filenames), m_images(), m_queues(queues), m_writers()
   {
     assert(!m_queues.empty());
     assert(m_queues.size() == m_filenames.size());
@@ -57,29 +58,38 @@ template <class T, class Container = std::deque<vpImage<T>>> class VISP_EXPORT v
   // Thread main loop
   void run()
   {
-    m_writer.setFileName(m_filename);
+    m_images.resize(m_queues.size());
+    m_writers.resize(m_queues.size());
+
+    std::vector<bool> is_opened_vec;
+    for (size_t i = 0; i < m_filenames.size(); i++) {
+      m_writers[i].setFileName(m_filenames[i]);
+      is_opened_vec.push_back(false);
+    }
 
     try {
-      bool is_opened = false;
       for (;;) {
-        vpImage<T> &image = m_queue.pop();
+        for (size_t i = 0; i < m_queues.size(); i++) {
+          m_images[i] = m_queues[i].get().pop();
 
-        if (!is_opened) {
-          m_writer.open(image);
-          is_opened = true;
-        }
+          if (!is_opened_vec[i]) {
+            m_writers[i].open(m_images[i]);
+            is_opened_vec[i] = true;
+          }
 
-        m_writer.saveFrame(image);
+          m_writers[i].saveFrame(m_images[i]);
+        }
       }
     }
     catch (typename vpConcurrentQueue<vpImage<T>, Container>::vpCancelled_t &) {
     }
   }
 
 private:
-  std::string m_filename;
-  vpConcurrentQueue<vpImage<T>, Container> &m_queue;
-  vpVideoWriter m_writer;
+  std::vector<std::string> m_filenames;
+  std::vector<vpImage<T>> m_images;
+  std::vector< std::reference_wrapper<vpConcurrentQueue<vpImage<T>, Container>> > m_queues;
+  std::vector<vpVideoWriter> m_writers;
 };
 
 #endif