Refactor out the logic for holding the last frame.

Author: Mysticial

SerialPrograms/CMakeLists.txt

@@ -463,6 +463,7 @@ file(GLOB MAIN_SOURCES
     Source/CommonFramework/VideoPipeline/Backends/CameraWidgetQt6.h
     Source/CommonFramework/VideoPipeline/Backends/MediaServicesQt6.cpp
     Source/CommonFramework/VideoPipeline/Backends/MediaServicesQt6.h
+    Source/CommonFramework/VideoPipeline/Backends/QVideoFrameCache.h
     Source/CommonFramework/VideoPipeline/Backends/VideoFrameQt.h
     Source/CommonFramework/VideoPipeline/CameraInfo.h
     Source/CommonFramework/VideoPipeline/Stats/CpuUtilizationStats.h

SerialPrograms/Source/CommonFramework/VideoPipeline/Backends/CameraWidgetQt6.5.cpp

@@ -95,7 +95,6 @@ CameraVideoSource::CameraVideoSource(
     , m_logger(logger)
     , m_last_image_timestamp(WallClock::min())
     , m_stats_conversion("ConvertFrame", "ms", 1000, std::chrono::seconds(10))
-    , m_last_frame_seqnum(0)
 {
     if (!info){
         return;
@@ -182,19 +181,8 @@ void CameraVideoSource::set_video_output(QGraphicsVideoItem& item){
             //  return immediately to unblock the main thread.
 
             WallClock now = current_time();
-            {
-                WriteSpinLock lg(m_frame_lock);
-
-                //  Skip duplicate frames.
-                if (frame.startTime() != -1 && frame.startTime() <= m_last_frame.startTime()){
-                    return;
-                }
-
-                m_last_frame = frame;
-                m_last_frame_timestamp = now;
-                uint64_t seqnum = m_last_frame_seqnum.load(std::memory_order_relaxed);
-                seqnum++;
-                m_last_frame_seqnum.store(seqnum, std::memory_order_relaxed);
+            if (!m_last_frame.push_frame(frame, now)){
+                return;
             }
             report_source_frame(std::make_shared<VideoFrame>(now, frame));
         },
@@ -214,20 +202,15 @@ VideoSnapshot CameraVideoSource::snapshot(){
     std::lock_guard<std::mutex> lg(m_cache_lock);
 
     //  Check the cached image frame. If it's not stale, return it immediately.
-    uint64_t frame_seqnum = m_last_frame_seqnum.load(std::memory_order_relaxed);
+    uint64_t frame_seqnum = m_last_frame.seqnum();
     if (!m_last_image.isNull() && m_last_image_seqnum == frame_seqnum){
         return VideoSnapshot(m_last_image, m_last_image_timestamp);
     }
 
     //  Cached image is stale. Grab the latest frame.
     QVideoFrame frame;
     WallClock frame_timestamp;
-    {
-        ReadSpinLock lg0(m_frame_lock);
-        frame_seqnum = m_last_frame_seqnum.load(std::memory_order_relaxed);
-        frame = m_last_frame;
-        frame_timestamp = m_last_frame_timestamp;
-    }
+    frame_seqnum = m_last_frame.get_latest(frame, frame_timestamp);
 
     if (!frame.isValid()){
         m_logger.log("QVideoFrame is null.", COLOR_RED);

SerialPrograms/Source/CommonFramework/VideoPipeline/Backends/CameraWidgetQt6.5.h

@@ -10,7 +10,7 @@
 #include <QtGlobal>
 #if QT_VERSION_MAJOR == 6
 
-#include <set>
+//#include <set>
 #include <mutex>
 #include <QCameraDevice>
 #include <QMediaCaptureSession>
@@ -24,8 +24,13 @@
 #include "CommonFramework/Tools/StatAccumulator.h"
 #include "CommonFramework/VideoPipeline/VideoSource.h"
 #include "CommonFramework/VideoPipeline/CameraInfo.h"
+#include "QVideoFrameCache.h"
 #include "CameraImplementations.h"
 
+//  REMOVE
+#include "Common/Cpp/Concurrency/AsyncDispatcher.h"
+//#include "Common/Cpp/Containers/CircularBuffer.h"
+
 //#include <iostream>
 //using std::cout;
 //using std::endl;
@@ -87,6 +92,8 @@ class StaticQGraphicsView : public QGraphicsView{
 };
 
 
+
+
 class CameraVideoSource : public QObject, public VideoSource{
 public:
     virtual ~CameraVideoSource();
@@ -135,16 +142,7 @@ class CameraVideoSource : public QObject, public VideoSource{
     PeriodicStatsReporterI32 m_stats_conversion;
 
 private:
-    //  Last Frame: All accesses must be under this lock.
-    //  These will be updated very rapidly by the main thread.
-    //  Holding the frame lock will block the main thread.
-    //  So accessors should minimize the time they hold the frame lock.
-
-    mutable SpinLock m_frame_lock;
-
-    QVideoFrame m_last_frame;
-    WallClock m_last_frame_timestamp;
-    std::atomic<uint64_t> m_last_frame_seqnum;
+    QVideoFrameCache m_last_frame;
 
 };
 

SerialPrograms/Source/CommonFramework/VideoPipeline/Backends/CameraWidgetQt6.cpp

@@ -88,7 +88,6 @@ CameraVideoSource::CameraVideoSource(
     , m_logger(logger)
     , m_last_image_timestamp(WallClock::min())
     , m_stats_conversion("ConvertFrame", "ms", 1000, std::chrono::seconds(10))
-    , m_last_frame_seqnum(0)
 {
     if (!info){
         return;
@@ -160,14 +159,8 @@ CameraVideoSource::CameraVideoSource(
             //  return immediately to unblock the main thread.
 
             WallClock now = current_time();
-            {
-                WriteSpinLock lg(m_frame_lock);
-//                cout << now << endl;
-                m_last_frame = frame;
-                m_last_frame_timestamp = now;
-                uint64_t seqnum = m_last_frame_seqnum.load(std::memory_order_relaxed);
-                seqnum++;
-                m_last_frame_seqnum.store(seqnum, std::memory_order_relaxed);
+            if (!m_last_frame.push_frame(frame, now)){
+                return;
             }
             report_source_frame(std::make_shared<VideoFrame>(now, frame));
         }
@@ -184,19 +177,16 @@ VideoSnapshot CameraVideoSource::snapshot(){
         return VideoSnapshot();
     }
 
-    //  Frame is already cached and is not stale.
+    //  Check the cached image frame. If it's not stale, return it immediately.
+    uint64_t frame_seqnum = m_last_frame.seqnum();
+    if (!m_last_image.isNull() && m_last_image_seqnum == frame_seqnum){
+        return VideoSnapshot(m_last_image, m_last_image_timestamp);
+    }
+
+    //  Cached image is stale. Grab the latest frame.
     QVideoFrame frame;
     WallClock frame_timestamp;
-    uint64_t frame_seqnum;
-    {
-        SpinLockGuard lg0(m_frame_lock);
-        frame_seqnum = m_last_frame_seqnum;
-        if (!m_last_image.isNull() && m_last_image_seqnum == frame_seqnum){
-            return VideoSnapshot(m_last_image, m_last_image_timestamp);
-        }
-        frame = m_last_frame;
-        frame_timestamp = m_last_frame_timestamp;
-    }
+    frame_seqnum = m_last_frame.get_latest(frame, frame_timestamp);
 
     if (!frame.isValid()){
         global_logger_tagged().log("QVideoFrame is null.", COLOR_RED);

SerialPrograms/Source/CommonFramework/VideoPipeline/Backends/CameraWidgetQt6.h

@@ -19,6 +19,7 @@
 #include "CommonFramework/Tools/StatAccumulator.h"
 #include "CommonFramework/VideoPipeline/VideoSource.h"
 #include "CommonFramework/VideoPipeline/CameraInfo.h"
+#include "QVideoFrameCache.h"
 #include "CameraImplementations.h"
 
 class QCamera;
@@ -96,16 +97,7 @@ class CameraVideoSource : public QObject, public VideoSource{
 
 
 private:
-    //  Last Frame: All accesses must be under this lock.
-    //  These will be updated very rapidly by the main thread.
-    //  Holding the frame lock will block the main thread.
-    //  So accessors should minimize the time they hold the frame lock.
-
-    mutable SpinLock m_frame_lock;
-
-    QVideoFrame m_last_frame;
-    WallClock m_last_frame_timestamp;
-    std::atomic<uint64_t> m_last_frame_seqnum;
+    QVideoFrameCache m_last_frame;
 
 };
 

SerialPrograms/Source/CommonFramework/VideoPipeline/Backends/QVideoFrameCache.h

@@ -0,0 +1,64 @@
+/*  Camera Widget (Qt6.5)
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_VideoPipeline_QVideoFrameCache_H
+#define PokemonAutomation_VideoPipeline_QVideoFrameCache_H
+
+#include <QVideoFrame>
+#include "Common/Cpp/Time.h"
+#include "Common/Cpp/Concurrency/SpinLock.h"
+
+namespace PokemonAutomation{
+
+
+
+class QVideoFrameCache{
+public:
+    QVideoFrameCache()
+        : m_last_frame_timestamp(WallClock::min())
+        , m_last_frame_seqnum(0)
+    {}
+
+    uint64_t seqnum() const{
+        return m_last_frame_seqnum.load(std::memory_order_relaxed);
+    }
+    uint64_t get_latest(QVideoFrame& frame, WallClock& timestamp) const{
+        WriteSpinLock lg(m_frame_lock);
+        frame = m_last_frame;
+        timestamp = m_last_frame_timestamp;
+        return seqnum();
+    }
+
+    bool push_frame(QVideoFrame frame, WallClock timestamp){
+        WriteSpinLock lg(m_frame_lock);
+
+        //  Skip duplicate frames.
+        if (frame.startTime() != -1 && frame.startTime() <= m_last_frame.startTime()){
+            return false;
+        }
+
+        m_last_frame = frame;
+        m_last_frame_timestamp = timestamp;
+        uint64_t seqnum = m_last_frame_seqnum.load(std::memory_order_relaxed);
+        seqnum++;
+        m_last_frame_seqnum.store(seqnum, std::memory_order_relaxed);
+
+        return true;
+    }
+
+
+private:
+    mutable SpinLock m_frame_lock;
+
+    QVideoFrame m_last_frame;
+    WallClock m_last_frame_timestamp;
+    std::atomic<uint64_t> m_last_frame_seqnum;
+};
+
+
+
+}
+#endif