Move frame buffer size from constant into config

Author: XITRIX

app/src/streaming/AVFrameHolder.cpp

@@ -7,7 +7,7 @@
 
 #include "AVFrameHolder.hpp"
 
-AVFrameQueue::AVFrameQueue(size_t limit): limit(limit) {}
+AVFrameQueue::AVFrameQueue() {}
 
 AVFrameQueue::~AVFrameQueue() {
     for (; !queue.empty(); queue.pop()) {
@@ -25,8 +25,10 @@ void AVFrameQueue::push(AVFrame* item) {
     std::lock_guard<std::mutex> lock(m_mutex);
     queue.push(item);
 
-    if (queue.size() > limit)
+    if (queue.size() > limit) {
         queue.pop();
+        framesDroppedStat ++;
+    }
 }
 
 AVFrame* AVFrameQueue::pop() {
@@ -51,9 +53,14 @@ size_t AVFrameQueue::getFakeFrameUsage() const {
     return fakeFrameUsedStat;
 }
 
+size_t AVFrameQueue::getFramesDropStat() const {
+    return framesDroppedStat;
+}
+
 void AVFrameQueue::cleanup() {
     std::lock_guard<std::mutex> lock(m_mutex);
     fakeFrameUsedStat = 0;
+    framesDroppedStat = 0;
     bufferFrame = nullptr;
     queue = {};
 }

app/src/streaming/AVFrameHolder.hpp

@@ -4,33 +4,35 @@
 #include <mutex>
 #include <functional>
 #include <queue>
+#include "Settings.hpp"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
 }
 
-#define m_frames_count 4
-
 class AVFrameQueue {
 public:
-    explicit AVFrameQueue(size_t limit = m_frames_count - 1);
+    explicit AVFrameQueue();
     ~AVFrameQueue();
 
     void push(AVFrame* item);
     AVFrame* pop();
 
     [[nodiscard]] size_t size() const;
     [[nodiscard]] size_t getFakeFrameUsage() const;
+    [[nodiscard]] size_t getFramesDropStat() const;
 
     void cleanup();
 
 private:
+    friend class AVFrameHolder;
     size_t limit;
     std::queue<AVFrame*> queue;
     std::queue<AVFrame*> freeQueue;
     AVFrame* bufferFrame = nullptr;
     std::mutex m_mutex;
     size_t fakeFrameUsedStat = 0;
+    size_t framesDroppedStat = 0;
 };
 
 class AVFrameHolder : public Singleton<AVFrameHolder> {
@@ -49,13 +51,18 @@ class AVFrameHolder : public Singleton<AVFrameHolder> {
         }
     }
 
+    void prepare() {
+        m_frame_queue.limit = Settings::instance().frames_queue_size();
+    }
+
     void cleanup() {
         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 getFrameDropStat() const { return m_frame_queue.getFramesDropStat(); }
     [[nodiscard]] size_t getFrameQueueSize() const { return m_frame_queue.size(); }
 
   private:

app/src/streaming/ffmpeg/FFmpegVideoDecoder.cpp

@@ -146,41 +146,48 @@ int FFmpegVideoDecoder::setup(int video_format, int width, int height,
         return err;
     }
 
+    AVFrameHolder::instance().prepare();
+
+    // One extra frame for decoding processing
+    m_frames_size = Settings::instance().frames_queue_size() + 1;
+    m_frames = new AVFrame*[m_frames_size];
+
     tmp_frame = av_frame_alloc();
-    for (auto & m_frame : m_frames) {
-        m_frame = av_frame_alloc();
-        if (m_frame == nullptr) {
+    for (int i = 0; i < m_frames_size; i++) {
+        auto& frame = m_frames[i];
+        frame = av_frame_alloc();
+        if (frame == nullptr) {
             brls::Logger::error("FFmpeg: Couldn't allocate frame");
             return -1;
         }
 
 #if defined(PLATFORM_SWITCH) && defined(BOREALIS_USE_DEKO3D)
-        m_frames[i]->format = AV_PIX_FMT_NVTEGRA;
+        frame->format = AV_PIX_FMT_NVTEGRA;
 #elif defined(PLATFORM_ANDROID)
-        m_frames[i]->format = AV_PIX_FMT_MEDIACODEC;
+        frame->format = AV_PIX_FMT_MEDIACODEC;
 #else
         if (video_format & VIDEO_FORMAT_MASK_10BIT)
-            m_frame->format = AV_PIX_FMT_P010;
+            frame->format = AV_PIX_FMT_P010;
         else
-            m_frame->format = AV_PIX_FMT_NV12;
+            frame->format = AV_PIX_FMT_NV12;
 #endif
-        m_frame->width  = width;
-        m_frame->height = height;
+        frame->width  = width;
+        frame->height = height;
 
 // Need to align Switch frame to 256, need to de reviewed
 #if defined(PLATFORM_SWITCH) && !defined(BOREALIS_USE_DEKO3D)
-        int err = av_frame_get_buffer(m_frame, 256);
+        int err = av_frame_get_buffer(frame, 256);
         if (err < 0) {
             char errs[64]; 
             brls::Logger::error("FFmpeg: Couldn't allocate frame buffer: {}", av_make_error_string(errs, 64, err));
             return -1;
         }
 
         for (int j = 0; j < 2; j++) {
-            uintptr_t ptr = (uintptr_t)m_frame->data[j];
+            uintptr_t ptr = (uintptr_t)frame->data[j];
             uintptr_t dst = (((ptr)+(256)-1)&~((256)-1));
             uintptr_t gap = dst - ptr;
-            m_frame->data[j] += gap;
+            frame->data[j] += gap;
         }
 #endif
     }
@@ -235,7 +242,7 @@ void FFmpegVideoDecoder::cleanup() {
     }
 
 //    if (m_frames) {
-       for (int i = 0; i < m_frames_count; i++) {
+       for (int i = 0; i < m_frames_size; i++) {
         //    if (m_extra_frames[i])
                av_frame_free(&m_frames[i]);
        }
@@ -254,6 +261,7 @@ void FFmpegVideoDecoder::cleanup() {
     }
 
     AVFrameHolder::instance().cleanup();
+    delete[] m_frames;
 
     brls::Logger::info("FFmpeg: Cleanup done!");
 }
@@ -445,7 +453,7 @@ AVFrame* FFmpegVideoDecoder::get_frame(bool native_frame) {
 
     if (err == 0) {
         m_current_frame = m_next_frame;
-        m_next_frame = (m_current_frame + 1) % m_frames_count;
+        m_next_frame = (m_current_frame + 1) % m_frames_size;
         if (/*ffmpeg_decoder == SOFTWARE ||*/ native_frame)
             return resultFrame;
     } else {

app/src/streaming/ffmpeg/FFmpegVideoDecoder.hpp

@@ -23,8 +23,8 @@ class FFmpegVideoDecoder : public IFFmpegVideoDecoder {
     const AVCodec* m_decoder = nullptr;
     AVCodecContext* m_decoder_context = nullptr;
     AVFrame *tmp_frame = nullptr;
-    // AVFrame* m_extra_frames[m_frames_count];
-    AVFrame* m_frames[m_frames_count];
+    AVFrame** m_frames;
+    int m_frames_size;
 
     int m_stream_fps = 0;
     int m_frames_in = 0;

app/src/streaming_view.cpp

@@ -334,7 +334,7 @@ void StreamingView::draw(NVGcontext* vg, float x, float y, float width,
                                   "Average decoding time: {:.{}f} | {:.{}f} ms\n"
                                   "Average rendering time: {:.{}f} ms\n"
                                   "Frame holder push/get rate: {}\n"
-                                  "Fake frames produced: {}\n"
+                                  "Frames queue reuses | drops: {} | {}\n"
                                   "Frames queue: {}",
                                   stats->video_decode_stats.network_dropped_frames,
                                   stats->video_decode_stats.current_receive_time, 2,
@@ -344,6 +344,7 @@ void StreamingView::draw(NVGcontext* vg, float x, float y, float width,
                                   stats->video_render_stats.rendering_time, 2,
                                   AVFrameHolder::instance().getStat(),
                                   AVFrameHolder::instance().getFakeFrameStat(),
+                                  AVFrameHolder::instance().getFrameDropStat(),
                                   AVFrameHolder::instance().getFrameQueueSize());
 
         nvgFontFaceId(vg, Application::getFont(FONT_REGULAR));

app/src/utils/Settings.cpp

@@ -266,6 +266,15 @@ void Settings::load() {
                 }
             }
 
+            if (json_t* frames_queue_size = json_object_get(settings, "frames_queue_size")) {
+                if (json_typeof(frames_queue_size) == JSON_INTEGER) {
+                    m_frames_queue_size = (int)json_integer_value(frames_queue_size);
+
+                    // SANITY CHECK, APP WILL CRASH OTHERWISE
+                    if (m_frames_queue_size < 1) m_frames_queue_size = 1;
+                }
+            }
+
             if (json_t* hw_decoding = json_object_get(settings, "use_hw_decoding")) {
                 m_use_hw_decoding = json_typeof(hw_decoding) == JSON_TRUE;
             }
@@ -488,6 +497,7 @@ void Settings::save() {
             json_object_set_new(settings, "audio_backend", json_integer(m_audio_backend));
             json_object_set_new(settings, "bitrate", json_integer(m_bitrate));
             json_object_set_new(settings, "decoder_threads", json_integer(m_decoder_threads));
+            json_object_set_new(settings, "frames_queue_size", json_integer(m_frames_queue_size));
             json_object_set_new(settings, "enable_hdr", m_enable_hdr ? json_true() : json_false());
             json_object_set_new(settings, "click_by_tap", m_click_by_tap ? json_true() : json_false());
             json_object_set_new(settings, "use_hw_decoding", m_use_hw_decoding ? json_true() : json_false());

app/src/utils/Settings.hpp

@@ -97,6 +97,9 @@ class Settings : public Singleton<Settings> {
     void set_decoder_threads(int decoder_threads) { m_decoder_threads = decoder_threads; }
     [[nodiscard]] int decoder_threads() const { return m_decoder_threads; }
 
+    void set_frames_queue_size(int frames_queue_size) { m_frames_queue_size = frames_queue_size; }
+    [[nodiscard]] int frames_queue_size() const { return m_frames_queue_size; }
+
     void set_sops(bool sops) { m_sops = sops; }
     [[nodiscard]] bool sops() const { return m_sops; }
 
@@ -190,6 +193,7 @@ class Settings : public Singleton<Settings> {
     bool m_enable_hdr = false;
     bool m_click_by_tap = false;
     int m_decoder_threads = 4;
+    int m_frames_queue_size = 3;
     bool m_sops = true;
     bool m_play_audio = false;
     bool m_write_log = false;