Merge pull request #3208 from Carbenium/analysis-thread-cleanup

Analysis and decoder thread to auto ptr

src/zm_analysis_thread.cpp

@@ -4,10 +4,8 @@
 #include "zm_signal.h"
 #include "zm_utils.h"
 
-//AnalysisThread::AnalysisThread(std::shared_ptr<Monitor> monitor) :
-AnalysisThread::AnalysisThread(Monitor* monitor) :
+AnalysisThread::AnalysisThread(Monitor *monitor) :
     monitor_(monitor), terminate_(false) {
-    //monitor_(std::move(monitor)), terminate_(false) {
   thread_ = std::thread(&AnalysisThread::Run, this);
 }
 
@@ -43,7 +41,7 @@ void AnalysisThread::Run() {
 
     Debug(2, "Analyzing");
     if (!monitor_->Analyse()) {
-      if ( !(terminate_ or zm_terminate) ) {
+      if (!(terminate_ or zm_terminate)) {
         Microseconds sleep_for = monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
         Debug(2, "Sleeping for %" PRId64 "us", int64(sleep_for.count()));
         std::this_thread::sleep_for(sleep_for);

src/zm_analysis_thread.h

@@ -1,15 +1,15 @@
 #ifndef ZM_ANALYSIS_THREAD_H
 #define ZM_ANALYSIS_THREAD_H
 
-class Monitor;
 #include <atomic>
 #include <memory>
 #include <thread>
 
+class Monitor;
+
 class AnalysisThread {
  public:
-  explicit AnalysisThread(Monitor* monitor);
-  //explicit AnalysisThread(std::shared_ptr<Monitor> monitor);
+  explicit AnalysisThread(Monitor *monitor);
   ~AnalysisThread();
   AnalysisThread(AnalysisThread &rhs) = delete;
   AnalysisThread(AnalysisThread &&rhs) = delete;
@@ -19,8 +19,7 @@ class AnalysisThread {
  private:
   void Run();
 
-  Monitor* monitor_;
-  //std::shared_ptr<Monitor> monitor_;
+  Monitor *monitor_;
   std::atomic<bool> terminate_;
   std::thread thread_;
 };

src/zm_decoder_thread.cpp

@@ -3,10 +3,8 @@
 #include "zm_monitor.h"
 #include "zm_signal.h"
 
-//DecoderThread::DecoderThread(std::shared_ptr<Monitor> monitor) :
-DecoderThread::DecoderThread(Monitor * monitor) :
+DecoderThread::DecoderThread(Monitor *monitor) :
     monitor_(monitor), terminate_(false) {
-    //monitor_(std::move(monitor)), terminate_(false) {
   thread_ = std::thread(&DecoderThread::Run, this);
 }
 
@@ -19,35 +17,7 @@ DecoderThread::~DecoderThread() {
 void DecoderThread::Run() {
   Debug(2, "DecoderThread::Run() for %d", monitor_->Id());
 
-  //Microseconds decoder_rate = Microseconds(monitor_->GetDecoderRate());
-  //Seconds decoder_update_delay = Seconds(monitor_->GetDecoderUpdateDelay());
-  //Debug(2, "DecoderThread::Run() have update delay %d", decoder_update_delay);
-
-  //TimePoint last_decoder_update_time = std::chrono::steady_clock::now();
-  //TimePoint cur_time;
-
   while (!(terminate_ or zm_terminate)) {
-    // Some periodic updates are required for variable capturing framerate
-    //if (decoder_update_delay != Seconds::zero()) {
-      //cur_time = std::chrono::steady_clock::now();
-      //Debug(2, "Updating adaptive skip");
-      //if ((cur_time - last_decoder_update_time) > decoder_update_delay) {
-        //decoder_rate = Microseconds(monitor_->GetDecoderRate());
-        //last_decoder_update_time = cur_time;
-      //}
-    //}
-
-    if (!monitor_->Decode()) {
-      //if ( !(terminate_ or zm_terminate) ) {
-        //Microseconds sleep_for = monitor_->Active() ? Microseconds(ZM_SAMPLE_RATE) : Microseconds(ZM_SUSPENDED_RATE);
-        //Debug(2, "Sleeping for %" PRId64 "us", int64(sleep_for.count()));
-        //std::this_thread::sleep_for(sleep_for);
-      //}
-    //} else if (decoder_rate != Microseconds::zero()) {
-      //Debug(2, "Sleeping for %" PRId64 " us", int64(decoder_rate.count()));
-      //std::this_thread::sleep_for(decoder_rate);
-    //} else {
-      //Debug(2, "Not sleeping");
-    }
+    monitor_->Decode();
   }
 }

src/zm_decoder_thread.h

@@ -9,8 +9,7 @@ class Monitor;
 
 class DecoderThread {
  public:
-  explicit DecoderThread(Monitor* monitor);
-  //explicit DecoderThread(std::shared_ptr<Monitor> monitor);
+  explicit DecoderThread(Monitor *monitor);
   ~DecoderThread();
   DecoderThread(DecoderThread &rhs) = delete;
   DecoderThread(DecoderThread &&rhs) = delete;
@@ -20,8 +19,7 @@ class DecoderThread {
  private:
   void Run();
 
-  Monitor* monitor_;
-  //std::shared_ptr<Monitor> monitor_;
+  Monitor *monitor_;
   std::atomic<bool> terminate_;
   std::thread thread_;
 };

src/zm_monitor.cpp

@@ -3210,13 +3210,13 @@ int Monitor::PrimeCapture() {
 
     if (decoding_enabled) {
       if (!decoder_it) decoder_it = packetqueue.get_video_it(false);
-      if (!decoder) decoder = new DecoderThread(this);
+      if (!decoder) decoder = ZM::make_unique<DecoderThread>(this);
     }
 
     if (!analysis_it) analysis_it = packetqueue.get_video_it(false);
     if (!analysis_thread) {
       Debug(1, "Starting an analysis thread for monitor (%d)", id);
-      analysis_thread = new AnalysisThread(this);
+      analysis_thread = ZM::make_unique<AnalysisThread>(this);
     }
 
   } else {
@@ -3229,17 +3229,14 @@ int Monitor::PreCapture() const { return camera->PreCapture(); }
 int Monitor::PostCapture() const { return camera->PostCapture(); }
 int Monitor::Close() {
   // Because the stream indexes may change we have to clear out the packetqueue
-  if (decoder) decoder->Stop();
-  if (analysis_thread) analysis_thread->Stop();
-  packetqueue.clear();
   if (decoder) {
-    delete decoder;
-    decoder = nullptr;
+    decoder->Stop();
   }
   if (analysis_thread) {
-    delete analysis_thread;
-    analysis_thread = nullptr;
+    analysis_thread->Stop();
   }
+  packetqueue.clear();
+
   std::lock_guard<std::mutex> lck(event_mutex);
   if (event) {
     Info("%s: image_count:%d - Closing event %" PRIu64 ", shutting down", name, image_count, event->Id());

src/zm_monitor.h

@@ -376,9 +376,9 @@ protected:
   VideoStore          *videoStore;
   PacketQueue      packetqueue;
   packetqueue_iterator  *analysis_it;
-  AnalysisThread        *analysis_thread;
+  std::unique_ptr<AnalysisThread> analysis_thread;
   packetqueue_iterator  *decoder_it;
-  DecoderThread         *decoder;
+  std::unique_ptr<DecoderThread> decoder;
   AVFrame *dest_frame;                    // Used by decoding thread doing colorspace conversions
   SwsContext   *convert_context;
   std::thread  close_event_thread;