Refactor VideoOverlaySession to use ListenerSet and fix hang on stats.

Author: Mysticial

SerialPrograms/Source/CommonFramework/VideoPipeline/VideoOverlaySession.cpp

@@ -15,13 +15,10 @@ namespace PokemonAutomation{
 
 
 void VideoOverlaySession::add_listener(ContentListener& listener){
-    WriteSpinLock lg(m_lock);
-    m_content_listeners.insert(&listener);
+    m_listeners.add(listener);
 }
 void VideoOverlaySession::remove_listener(ContentListener& listener){
-    WriteSpinLock lg(m_lock);
-//    listener.on_overlay_update_stats(nullptr);
-    m_content_listeners.erase(&listener);
+    m_listeners.remove(listener);
 }
 
 
@@ -53,7 +50,6 @@ void VideoOverlaySession::get(VideoOverlayOption& option){
     option.stats.store(stats, std::memory_order_relaxed);
 }
 void VideoOverlaySession::set(const VideoOverlayOption& option){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_boxes()");
     bool boxes = option.boxes.load(std::memory_order_relaxed);
     bool text = option.text.load(std::memory_order_relaxed);
     bool images = option.images.load(std::memory_order_relaxed);
@@ -64,13 +60,11 @@ void VideoOverlaySession::set(const VideoOverlayOption& option){
     m_option.images.store(images, std::memory_order_relaxed);
     m_option.log.store(log, std::memory_order_relaxed);
     m_option.stats.store(stats, std::memory_order_relaxed);
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_boxes(boxes);
-        listener->on_overlay_enabled_text(text);
-        listener->on_overlay_enabled_images(images);
-        listener->on_overlay_enabled_log(log);
-        listener->on_overlay_enabled_stats(stats);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_boxes, boxes);
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_text, text);
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_images, images);
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_log, log);
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_stats, stats);
 }
 
 
@@ -95,38 +89,23 @@ void VideoOverlaySession::stats_thread(){
 
 void VideoOverlaySession::set_enabled_boxes(bool enabled){
     m_option.boxes.store(enabled, std::memory_order_relaxed);
-    ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_boxes()");
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_boxes(enabled);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_boxes, enabled);
 }
 void VideoOverlaySession::set_enabled_text(bool enabled){
     m_option.text.store(enabled, std::memory_order_relaxed);
-    ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_text()");
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_text(enabled);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_text, enabled);
 }
 void VideoOverlaySession::set_enabled_images(bool enabled){
     m_option.images.store(enabled, std::memory_order_relaxed);
-    ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_images()");
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_images(enabled);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_images, enabled);
 }
 void VideoOverlaySession::set_enabled_log(bool enabled){
     m_option.log.store(enabled, std::memory_order_relaxed);
-    ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_log()");
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_log(enabled);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_log, enabled);
 }
 void VideoOverlaySession::set_enabled_stats(bool enabled){
     m_option.stats.store(enabled, std::memory_order_relaxed);
-    ReadSpinLock lg(m_lock, "VideoOverlaySession::set_enabled_stats()");
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_enabled_stats(enabled);
-    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_enabled_stats, enabled);
 }
 
 
@@ -135,30 +114,32 @@ void VideoOverlaySession::set_enabled_stats(bool enabled){
 //
 
 void VideoOverlaySession::add_box(const OverlayBox& box){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::add_box()");
-    m_boxes.insert(&box);
-    push_box_update();
-}
-void VideoOverlaySession::remove_box(const OverlayBox& box){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_box()");
-    m_boxes.erase(&box);
-    push_box_update();
-}
+    std::shared_ptr<std::vector<OverlayBox>> ptr = std::make_shared<std::vector<OverlayBox>>();
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::add_box()");
+        m_boxes.insert(&box);
 
-void VideoOverlaySession::push_box_update(){
-    if (m_content_listeners.empty()){
-        return;
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_boxes` asynchronously.
+        for (const auto& item : m_boxes){
+            ptr->emplace_back(*item);
+        }
     }
-    
-    //  We create a newly allocated Box vector to avoid listener accessing
-    //  `m_boxes` asynchronously.
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_boxes, ptr);
+}
+void VideoOverlaySession::remove_box(const OverlayBox& box){
     std::shared_ptr<std::vector<OverlayBox>> ptr = std::make_shared<std::vector<OverlayBox>>();
-    for (const auto& item : m_boxes){
-        ptr->emplace_back(*item);
-    }
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_boxes(ptr);
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_box()");
+        m_boxes.erase(&box);
+
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_boxes` asynchronously.
+        for (const auto& item : m_boxes){
+            ptr->emplace_back(*item);
+        }
     }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_boxes, ptr);
 }
 std::vector<OverlayBox> VideoOverlaySession::boxes() const{
     ReadSpinLock lg(m_lock);
@@ -175,30 +156,32 @@ std::vector<OverlayBox> VideoOverlaySession::boxes() const{
 //
 
 void VideoOverlaySession::add_text(const OverlayText& text){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::add_text()");
-    m_texts.insert(&text);
-    push_text_update();
-}
-void VideoOverlaySession::remove_text(const OverlayText& text){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_text()");
-    m_texts.erase(&text);
-    push_text_update();
-}
+    std::shared_ptr<std::vector<OverlayText>> ptr = std::make_shared<std::vector<OverlayText>>();
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::add_text()");
+        m_texts.insert(&text);
 
-void VideoOverlaySession::push_text_update(){
-    if (m_content_listeners.empty()){
-        return;
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_texts` asynchronously.
+        for (const auto& item : m_texts){
+            ptr->emplace_back(*item);
+        }
     }
-
-    //  We create a newly allocated Box vector to avoid listener accessing
-    //  `m_texts` asynchronously.
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_text, ptr);
+}
+void VideoOverlaySession::remove_text(const OverlayText& text){
     std::shared_ptr<std::vector<OverlayText>> ptr = std::make_shared<std::vector<OverlayText>>();
-    for (const auto& item : m_texts){
-        ptr->emplace_back(*item);
-    }
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_text(ptr);
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_text()");
+        m_texts.erase(&text);
+
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_texts` asynchronously.
+        for (const auto& item : m_texts){
+            ptr->emplace_back(*item);
+        }
     }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_text, ptr);
 }
 std::vector<OverlayText> VideoOverlaySession::texts() const{
     ReadSpinLock lg(m_lock);
@@ -215,30 +198,32 @@ std::vector<OverlayText> VideoOverlaySession::texts() const{
 //
 
 void VideoOverlaySession::add_image(const OverlayImage& image){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::add_image()");
-    m_images.insert(&image);
-    push_image_update();
-}
-void VideoOverlaySession::remove_image(const OverlayImage& image){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_image()");
-    m_images.erase(&image);
-    push_image_update();
-}
+    std::shared_ptr<std::vector<OverlayImage>> ptr = std::make_shared<std::vector<OverlayImage>>();
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::add_image()");
+        m_images.insert(&image);
 
-void VideoOverlaySession::push_image_update(){
-    if (m_content_listeners.empty()){
-        return;
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_images` asynchronously.
+        for (const auto& item : m_images){
+            ptr->emplace_back(*item);
+        }
     }
-
-    //  We create a newly allocated Box vector to avoid listener accessing
-    //  `m_images` asynchronously.
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_images, ptr);
+}
+void VideoOverlaySession::remove_image(const OverlayImage& image){
     std::shared_ptr<std::vector<OverlayImage>> ptr = std::make_shared<std::vector<OverlayImage>>();
-    for (const auto& item : m_images){
-        ptr->emplace_back(*item);
-    }
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_images(ptr);
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::remove_image()");
+        m_images.erase(&image);
+
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_images` asynchronously.
+        for (const auto& item : m_images){
+            ptr->emplace_back(*item);
+        }
     }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_images, ptr);
 }
 std::vector<OverlayImage> VideoOverlaySession::images() const{
     ReadSpinLock lg(m_lock);
@@ -255,35 +240,36 @@ std::vector<OverlayImage> VideoOverlaySession::images() const{
 //
 
 void VideoOverlaySession::add_log(std::string message, Color color){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::add_log_text()");
-    m_log_texts.emplace_front(color, std::move(message));
+    std::shared_ptr<std::vector<OverlayLogLine>> ptr = std::make_shared<std::vector<OverlayLogLine>>();
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::add_log_text()");
+        m_log_texts.emplace_front(color, std::move(message));
 
-    if (m_log_texts.size() > LOG_MAX_LINES){
-        m_log_texts.pop_back();
-    }
+        if (m_log_texts.size() > LOG_MAX_LINES){
+            m_log_texts.pop_back();
+        }
 
-    push_log_text_update();
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_log_texts` asynchronously.
+        for(const auto& item : m_log_texts){
+            ptr->emplace_back(item);
+        }
+    }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_log, ptr);
 }
 void VideoOverlaySession::clear_log(){
-    WriteSpinLock lg(m_lock, "VideoOverlaySession::clear_log_texts()");
-    m_log_texts.clear();
-    push_log_text_update();
-}
-
-void VideoOverlaySession::push_log_text_update(){
-    if (m_content_listeners.empty()){
-        return;
-    }
-    
-    //  We create a newly allocated Box vector to avoid listener accessing
-    //  `m_log_texts` asynchronously.
     std::shared_ptr<std::vector<OverlayLogLine>> ptr = std::make_shared<std::vector<OverlayLogLine>>();
-    for(const auto& item : m_log_texts){
-        ptr->emplace_back(item);
-    }
-    for (ContentListener* listener : m_content_listeners){
-        listener->on_overlay_update_log(ptr);
+    {
+        WriteSpinLock lg(m_lock, "VideoOverlaySession::clear_log_texts()");
+        m_log_texts.clear();
+
+        //  We create a newly allocated Box vector to avoid listener accessing
+        //  `m_log_texts` asynchronously.
+        for(const auto& item : m_log_texts){
+            ptr->emplace_back(item);
+        }
     }
+    m_listeners.run_method_unique(&ContentListener::on_overlay_update_log, ptr);
 }
 std::vector<OverlayLogLine> VideoOverlaySession::log_texts() const{
     ReadSpinLock lg(m_lock);

SerialPrograms/Source/CommonFramework/VideoPipeline/VideoOverlaySession.h

@@ -24,6 +24,7 @@
 #include <thread>
 #include "Common/Cpp/AbstractLogger.h"
 #include "Common/Cpp/Color.h"
+#include "Common/Cpp/ListenerSet.h"
 #include "Common/Cpp/Concurrency/SpinLock.h"
 #include "VideoOverlay.h"
 #include "VideoOverlayOption.h"
@@ -132,11 +133,6 @@ class VideoOverlaySession : public VideoOverlay{
 private:
     void stats_thread();
 
-    //  Push updates to the various listeners.
-    void push_box_update();
-    void push_text_update();
-    void push_image_update();
-    void push_log_text_update();
 
 private:
     Logger& m_logger;
@@ -152,7 +148,7 @@ class VideoOverlaySession : public VideoOverlay{
     std::list<OverlayStat*> m_stats_order;
     std::map<OverlayStat*, std::list<OverlayStat*>::iterator> m_stats;
 
-    std::set<ContentListener*> m_content_listeners;
+    ListenerSet<ContentListener> m_listeners;
 
     bool m_stopping = false;
     std::vector<OverlayStatSnapshot> m_stat_lines;