Frames queue implemented

Author: XITRIX

app/src/streaming/AVFrameHolder.cpp

@@ -0,0 +1,59 @@
+//
+//  DiscoverManager.cpp
+//  Moonlight
+//
+// Created by XITRIX on 31.03.2025.
+//
+
+#include "AVFrameHolder.hpp"
+
+AVFrameQueue::AVFrameQueue(size_t limit): limit(limit) {}
+
+AVFrameQueue::~AVFrameQueue() {
+    for (; !queue.empty(); queue.pop()) {
+        AVFrame* frame = queue.front();
+        av_frame_free(&frame);
+    }
+
+    for (; !freeQueue.empty(); freeQueue.pop()) {
+        AVFrame* frame = freeQueue.front();
+        av_frame_free(&frame);
+    }
+}
+
+void AVFrameQueue::push(AVFrame* item) {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    queue.push(item);
+
+    if (queue.size() > limit)
+        queue.pop();
+}
+
+AVFrame* AVFrameQueue::pop() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+
+    if (!queue.empty()) {
+        AVFrame* item = queue.front();
+        queue.pop();
+        bufferFrame = item;
+    } else {
+        fakeFrameUsedStat ++;
+    }
+
+    return bufferFrame;
+}
+
+size_t AVFrameQueue::size() const {
+    return queue.size();
+}
+
+size_t AVFrameQueue::getFakeFrameUsage() const {
+    return fakeFrameUsedStat;
+}
+
+void AVFrameQueue::cleanup() {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    fakeFrameUsedStat = 0;
+    bufferFrame = nullptr;
+    queue = {};
+}

app/src/streaming/AVFrameHolder.hpp

@@ -1,36 +1,64 @@
+#pragma once
+
 #include "Singleton.hpp"
 #include <mutex>
 #include <functional>
+#include <queue>
 
 extern "C" {
 #include <libavcodec/avcodec.h>
 }
 
-#pragma once
+#define m_frames_count 4
+
+class AVFrameQueue {
+public:
+    explicit AVFrameQueue(size_t limit = m_frames_count - 1);
+    ~AVFrameQueue();
+
+    void push(AVFrame* item);
+    AVFrame* pop();
+
+    [[nodiscard]] size_t size() const;
+    [[nodiscard]] size_t getFakeFrameUsage() const;
+
+    void cleanup();
+
+private:
+    size_t limit;
+    std::queue<AVFrame*> queue;
+    std::queue<AVFrame*> freeQueue;
+    AVFrame* bufferFrame = nullptr;
+    std::mutex m_mutex;
+    size_t fakeFrameUsedStat = 0;
+};
 
 class AVFrameHolder : public Singleton<AVFrameHolder> {
   public:
     void push(AVFrame* frame) {
-        std::lock_guard<std::mutex> lock(m_mutex);
-
-        m_frame = frame;
+        m_frame_queue.push(frame);
+        stat ++;
     }
 
-    void get(const std::function<void(AVFrame*)> fn) {
-        std::lock_guard<std::mutex> lock(m_mutex);
+    void get(const std::function<void(AVFrame*)>& fn) {
+        auto frame = m_frame_queue.pop();
 
-        if (m_frame) {
-            fn(m_frame);
+        if (frame) {
+            fn(frame);
+            stat --;
         }
     }
 
     void cleanup() {
-        std::lock_guard<std::mutex> lock(m_mutex);
-
-        m_frame = nullptr;
+        m_frame_queue.cleanup();
+        stat = 0;
     }
 
+    [[nodiscard]] int getStat() const { return stat; }
+    [[nodiscard]] size_t getFakeFrameStat() const { return m_frame_queue.getFakeFrameUsage(); }
+    [[nodiscard]] size_t getFrameQueueSize() const { return m_frame_queue.size(); }
+
   private:
-    std::mutex m_mutex;
-    AVFrame* m_frame = nullptr;
+    AVFrameQueue m_frame_queue;
+    int stat = 0;
 };

app/src/streaming/ffmpeg/FFmpegVideoDecoder.hpp

@@ -1,7 +1,6 @@
-#include "IFFmpegVideoDecoder.hpp"
 #pragma once
-
-#define m_frames_count 2
+#include "IFFmpegVideoDecoder.hpp"
+#include "AVFrameHolder.hpp"
 
 class FFmpegVideoDecoder : public IFFmpegVideoDecoder {
   public:

app/src/streaming_view.cpp

@@ -10,6 +10,7 @@
 #endif
 
 #include "streaming_view.hpp"
+#include "AVFrameHolder.hpp"
 #include "InputManager.hpp"
 #include "click_gesture_recognizer.hpp"
 #include "helper.hpp"
@@ -331,13 +332,19 @@ void StreamingView::draw(NVGcontext* vg, float x, float y, float width,
         statistics += fmt::format("Frames dropped by your network connection: {}\n"
                                   "Average receive time: {:.{}f} | {:.{}f} ms\n"
                                   "Average decoding time: {:.{}f} | {:.{}f} ms\n"
-                                  "Average rendering time: {:.{}f} ms\n",
+                                  "Average rendering time: {:.{}f} ms\n"
+                                  "Frame holder push/get rate: {}\n"
+                                  "Fake frames produced: {}\n"
+                                  "Frames queue: {}",
                                   stats->video_decode_stats.network_dropped_frames,
                                   stats->video_decode_stats.current_receive_time, 2,
                                   stats->video_decode_stats.session_receive_time, 2,
                                   stats->video_decode_stats.current_decoding_time, 2,
                                   stats->video_decode_stats.session_decoding_time, 2,
-                                  stats->video_render_stats.rendering_time, 2);
+                                  stats->video_render_stats.rendering_time, 2,
+                                  AVFrameHolder::instance().getStat(),
+                                  AVFrameHolder::instance().getFakeFrameStat(),
+                                  AVFrameHolder::instance().getFrameQueueSize());
 
         nvgFontFaceId(vg, Application::getFont(FONT_REGULAR));
         nvgFontSize(vg, 20);