Update to latest.

Author: Mysticial

SerialPrograms/Source/CommonFramework/Environment/SystemSleep.cpp

@@ -24,6 +24,65 @@ namespace PokemonAutomation{
 
 
 
+SystemSleepController::SystemSleepController()
+    : m_state(SleepSuppress::NONE)
+{}
+
+void SystemSleepController::add_listener(Listener& listener){
+    std::lock_guard<std::mutex> lg(m_lock);
+    m_listeners.insert(&listener);
+}
+void SystemSleepController::remove_listener(Listener& listener){
+    std::lock_guard<std::mutex> lg(m_lock);
+    m_listeners.erase(&listener);
+}
+void SystemSleepController::notify_listeners(SleepSuppress state){
+    for (Listener* listener : m_listeners){
+        listener->sleep_suppress_state_changed(state);
+    }
+}
+
+SleepSuppress SystemSleepController::current_state() const{
+    return m_state.load(std::memory_order_relaxed);
+}
+
+
+
+
+
+
+
+void SleepSuppressScope::clear(){
+    switch (m_mode){
+    case SleepSuppress::NONE:
+        break;
+    case SleepSuppress::NO_SLEEP:
+        SystemSleepController::instance().pop_no_sleep();
+        break;
+    case SleepSuppress::SCREEN_ON:
+        SystemSleepController::instance().pop_screen_on();
+        break;
+    }
+        m_mode = SleepSuppress::NONE;
+}
+void SleepSuppressScope::operator=(SleepSuppress mode){
+    clear();
+    set(mode);
+}
+void SleepSuppressScope::set(SleepSuppress mode){
+    switch (mode){
+    case SleepSuppress::NONE:
+        break;
+    case SleepSuppress::NO_SLEEP:
+        SystemSleepController::instance().push_no_sleep();
+        break;
+    case SleepSuppress::SCREEN_ON:
+        SystemSleepController::instance().push_screen_on();
+        break;
+    }
+    m_mode = mode;
+}
+
 
 
 

SerialPrograms/Source/CommonFramework/Environment/SystemSleep.h

@@ -8,7 +8,10 @@
 #define PokemonAutomation_SystemSleep_H
 
 #include <memory>
-
+#include <set>
+#include <atomic>
+#include <mutex>
+#include "Common/Compiler.h"
 
 #if _WIN32
 #define PA_ENABLE_SLEEP_SUPPRESS
@@ -22,17 +25,39 @@
 namespace PokemonAutomation{
 
 
+
+enum class SleepSuppress{
+    NONE,
+    NO_SLEEP,
+    SCREEN_ON,
+};
+
+
 //  Call OS API to prevent screen saver from running and OS from going to sleep.
 //  Useful for running some programs like PokemonSV_VideoFastCodeEntry that require
 //  the screen to be constantly on.
 class SystemSleepController{
+public:
+    struct Listener{
+        virtual void sleep_suppress_state_changed(SleepSuppress new_state) = 0;
+    };
+    void add_listener(Listener& listener);
+    void remove_listener(Listener& listener);
+
+
 protected:
     virtual ~SystemSleepController() = default;
-    SystemSleepController() = default;
+    SystemSleepController();
+
+    //  Must be called under lock.
+    void notify_listeners(SleepSuppress state);
+
 
 public:
     static SystemSleepController& instance();
 
+    SleepSuppress current_state() const;
+
     //  Push: Add a request for this type of sleep-disable.
     //  Pop: Remove a request for this type of sleep-disable.
     //  The sleep-disable will be active as long as there is at least one
@@ -45,18 +70,19 @@ class SystemSleepController{
     //  Allow the screen to turn off, but don't sleep.
     virtual void push_no_sleep(){}
     virtual void pop_no_sleep(){}
-};
-
 
 
+protected:
+    std::atomic<SleepSuppress> m_state;
 
-enum class SleepSuppress{
-    NONE,
-    NO_SLEEP,
-    SCREEN_ON,
+    std::mutex m_lock;
+    std::set<Listener*> m_listeners;
 };
 
 
+
+
+
 class SleepSuppressScope{
 public:
     SleepSuppressScope(SleepSuppress mode){
@@ -68,38 +94,11 @@ class SleepSuppressScope{
     SleepSuppressScope(const SleepSuppressScope&) = delete;
     void operator=(const SleepSuppressScope&) = delete;
 
-    void clear(){
-        switch (m_mode){
-        case SleepSuppress::NONE:
-            break;
-        case SleepSuppress::NO_SLEEP:
-            SystemSleepController::instance().pop_no_sleep();
-            break;
-        case SleepSuppress::SCREEN_ON:
-            SystemSleepController::instance().pop_screen_on();
-            break;
-        }
-            m_mode = SleepSuppress::NONE;
-    }
-    void operator=(SleepSuppress mode){
-        clear();
-        set(mode);
-    }
+    void clear();
+    void operator=(SleepSuppress mode);
 
 private:
-    void set(SleepSuppress mode){
-        switch (mode){
-        case SleepSuppress::NONE:
-            break;
-        case SleepSuppress::NO_SLEEP:
-            SystemSleepController::instance().push_no_sleep();
-            break;
-        case SleepSuppress::SCREEN_ON:
-            SystemSleepController::instance().push_screen_on();
-            break;
-        }
-        m_mode = mode;
-    }
+    void set(SleepSuppress mode);
 
 private:
     SleepSuppress m_mode;

SerialPrograms/Source/CommonFramework/Environment/SystemSleep_Apple.tpp

@@ -56,7 +56,6 @@ private:
     IOReturn m_prevention_succeeded = kIOReturnError;
     IOPMAssertionID m_session_id = 0;
 
-    std::mutex m_lock;
     size_t m_screen_on_requests = 0;
     size_t m_no_sleep_requests = 0;
 };
@@ -113,8 +112,22 @@ bool AppleSleepController::enable_sleep(){
 void AppleSleepController::update_state(){
     //  Must call under lock.
 
+    SleepSuppress before_state = m_state.load(std::memory_order_relaxed);
+    SleepSuppress after_state = SleepSuppress::NONE;
+
     //  TODO: Distiguish these two.
-    prevent_sleep(m_screen_on_requests > 0 || m_no_sleep_requests > 0);
+    bool enabled = m_screen_on_requests > 0 || m_no_sleep_requests > 0;
+    prevent_sleep(enabled);
+
+    after_state = enabled
+        ? SleepSuppress::SCREEN_ON
+        : SleepSuppress::NONE,
+
+    m_state.store(after_state, std::memory_order_release);
+
+    if (before_state != after_state){
+        notify_listeners(after_state);
+    }
 }
 
 

SerialPrograms/Source/CommonFramework/Environment/SystemSleep_Windows.tpp

@@ -5,6 +5,7 @@
  */
 
 #include <mutex>
+#include <condition_variable>
 #include <Windows.h>
 #include "Common/Qt/Redispatch.h"
 #include "CommonFramework/Logging/Logger.h"
@@ -16,64 +17,100 @@ namespace PokemonAutomation{
 class WindowsSleepController : public SystemSleepController{
 public:
     virtual ~WindowsSleepController(){
-        std::lock_guard<std::mutex> lg(m_lock);
-        m_screen_on_requests = 0;
-        m_no_sleep_requests = 0;
-        update_state();
+        {
+            std::lock_guard<std::mutex> lg(m_lock);
+            m_stopping = true;
+            m_cv.notify_all();
+        }
+        m_thread.join();
+        if (m_state.load(std::memory_order_relaxed) != SleepSuppress::NONE){
+            global_logger_tagged().log("Destroying WindowsSleepController with active requests...", COLOR_RED);
+        }
     }
+    WindowsSleepController()
+        : m_screen_on_requests(0)
+        , m_no_sleep_requests(0)
+        , m_stopping(false)
+        , m_thread(&WindowsSleepController::thread_loop, this)
+    {}
+
     virtual void push_screen_on() override{
         std::lock_guard<std::mutex> lg(m_lock);
         m_screen_on_requests++;
-        update_state();
+        m_cv.notify_all();
     }
     virtual void pop_screen_on() override{
         std::lock_guard<std::mutex> lg(m_lock);
         m_screen_on_requests--;
-        update_state();
+        m_cv.notify_all();
     }
     virtual void push_no_sleep() override{
         std::lock_guard<std::mutex> lg(m_lock);
         m_no_sleep_requests++;
-        update_state();
+        m_cv.notify_all();
     }
     virtual void pop_no_sleep() override{
         std::lock_guard<std::mutex> lg(m_lock);
         m_no_sleep_requests--;
-        update_state();
+        m_cv.notify_all();
     }
 
 private:
-    void update_state(){
+    void thread_loop(){
         //  SetThreadExecutionState(ES_CONTINUOUS) only lasts as long as the
-        //  thread is alive. So we redispatch to the main thread.
-        queue_on_main_thread([
-            screen_on_requests = m_screen_on_requests,
-            no_sleep_requests = m_no_sleep_requests
-        ]{
-            EXECUTION_STATE flags = ES_CONTINUOUS;
-            if (screen_on_requests > 0){
-                flags |= ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED;
+        //  thread is alive. So we use our own thread.
+        while (true){
+            std::unique_lock<std::mutex> lg(m_lock);
+            if (m_stopping){
+                return;
             }
-            if (no_sleep_requests > 0){
+
+            SleepSuppress before_state = m_state.load(std::memory_order_relaxed);
+            SleepSuppress after_state = SleepSuppress::NONE;
+
+            EXECUTION_STATE flags = ES_CONTINUOUS;
+            if (m_no_sleep_requests > 0){
                 flags |= ES_SYSTEM_REQUIRED | ES_AWAYMODE_REQUIRED;
+                after_state = SleepSuppress::NO_SLEEP;
+            }
+            if (m_screen_on_requests > 0){
+                flags |= ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED;
+                after_state = SleepSuppress::SCREEN_ON;
             }
             EXECUTION_STATE ret = SetThreadExecutionState(flags);
             if (ret == 0){
                 global_logger_tagged().log("Unable to set system sleep state.", COLOR_RED);
-            }else if (screen_on_requests > 0){
-                global_logger_tagged().log("Setting sleep state to: Screen On", COLOR_BLUE);
-            }else if (no_sleep_requests > 0){
-                global_logger_tagged().log("Setting sleep state to: No Sleep", COLOR_BLUE);
             }else{
-                global_logger_tagged().log("Setting sleep state to: None", COLOR_BLUE);
+                switch (after_state){
+                case SleepSuppress::NONE:
+                    global_logger_tagged().log("Setting sleep state to: None", COLOR_BLUE);
+                    break;
+                case SleepSuppress::NO_SLEEP:
+                    global_logger_tagged().log("Setting sleep state to: No Sleep", COLOR_BLUE);
+                    break;
+                case SleepSuppress::SCREEN_ON:
+                    global_logger_tagged().log("Setting sleep state to: Screen On", COLOR_BLUE);
+                    break;
+                }
+
+                m_state.store(after_state, std::memory_order_release);
+
+                if (before_state != after_state){
+                    notify_listeners(after_state);
+                }
             }
-        });
+
+            m_cv.wait(lg);
+        }
     }
 
 private:
-    std::mutex m_lock;
     size_t m_screen_on_requests = 0;
     size_t m_no_sleep_requests = 0;
+
+    bool m_stopping;
+    std::condition_variable m_cv;
+    std::thread m_thread;
 };
 
 

SerialPrograms/Source/CommonFramework/ErrorReports/ErrorReports.cpp

@@ -122,7 +122,9 @@ SendableErrorReport::SendableErrorReport(
         std::cout << "Compiling Error Report..." << std::endl;
     }
     m_program_id = info.program_id;
-    m_program_runtime_millis = std::chrono::duration_cast<Milliseconds>(current_time() - info.start_time).count();
+    if (info.start_time != WallClock::min()){
+        m_program_runtime_millis = std::chrono::duration_cast<Milliseconds>(current_time() - info.start_time).count();
+    }
     m_title = std::move(title);
     m_messages = std::move(messages);
     m_image = image;

SerialPrograms/Source/CommonFramework/ErrorReports/ErrorReports.h

@@ -87,7 +87,7 @@ class SendableErrorReport{
     std::string m_processor;
     std::string m_program;
     std::string m_program_id;
-    uint64_t m_program_runtime_millis;
+    uint64_t m_program_runtime_millis = 0;
     std::string m_title;
     std::vector<std::pair<std::string, std::string>> m_messages;
     ImageRGB32 m_image_owner;

SerialPrograms/Source/CommonFramework/Globals.cpp

@@ -25,7 +25,7 @@ namespace PokemonAutomation{
 const bool IS_BETA_VERSION = false;
 const int PROGRAM_VERSION_MAJOR = 0;
 const int PROGRAM_VERSION_MINOR = 50;
-const int PROGRAM_VERSION_PATCH = 15;
+const int PROGRAM_VERSION_PATCH = 16;
 
 const std::string PROGRAM_VERSION_BASE =
     "v" + std::to_string(PROGRAM_VERSION_MAJOR) +

SerialPrograms/Source/CommonFramework/Inference/FrozenImageDetector.cpp

@@ -42,7 +42,10 @@ bool FrozenImageDetector::process_frame(const VideoSnapshot& frame){
         return false;
     }
 
-    double rmsd = ImageMatch::pixel_RMSD(m_previous, frame);
+    double rmsd = ImageMatch::pixel_RMSD(
+        extract_box_reference(m_previous, m_box),
+        extract_box_reference(frame, m_box)
+    );
 //    cout << "rmsd = " << rmsd << endl;
     if (rmsd > m_rmsd_threshold){
         m_previous = frame;