Add possible input frame limiter and fps log for each gof bitstream generation

Author: Louis Fréneau

src/app/cli.cpp

@@ -52,7 +52,7 @@ namespace {
 
 // NOLINTNEXTLINE(cert-err58-cpp)
 const std::string short_options = "i:g:l:n:o:s:t:b:d:";
-const std::array<struct option, 14> long_options{{{"input", required_argument, nullptr, 'i'},
+const std::array<struct option, 15> long_options{{{"input", required_argument, nullptr, 'i'},
                                                   {"output", required_argument, nullptr, 'o'},
                                                   {"frames", required_argument, nullptr, 'n'},
                                                   {"start-frame", required_argument, nullptr, 's'},
@@ -65,7 +65,8 @@ const std::array<struct option, 14> long_options{{{"input", required_argument, n
                                                   {"version", no_argument, nullptr, 0},
                                                   {"dst-address", required_argument, nullptr, 0},
                                                   {"dst-port", required_argument, nullptr, 0},
-                                                  {"sdp-outdir", required_argument, nullptr, 0}
+                                                  {"sdp-outdir", required_argument, nullptr, 0},
+                                                  {"input-frame-per-second-limiter", required_argument, nullptr, 0}
 }};
 
 /**
@@ -205,6 +206,10 @@ bool opts_parse(cli::opts_t& opts, const int& argc, const std::span<const char*
             }
         } else if (name == "sdp-outdir") {
             opts.sdpOutdir = optarg;
+        } else if (name == "input-frame-per-second-limiter") {
+            opts.inputFramePerSecondLimiter = std::stoi(optarg);
+        } else {
+            //TODO(lf): throw error ?
         }
     }
 

src/app/cli.hpp

@@ -73,6 +73,9 @@ struct opts_t {
     std::vector<uint16_t> dstPort{};
     /** \brief Output directory for SDP files */
     std::string sdpOutdir{};
+    /** \brief FPS limit for reading input frames */
+    size_t inputFramePerSecondLimiter = 0; // 0 means no input frame limiter (maxConcurrentFrames can still be a limiter)
+
 };
 
 bool opts_parse(cli::opts_t& opts, const int& argc, const std::span<const char* const>& args);

src/app/uvgVPCCencAppExample.cpp

@@ -197,6 +197,10 @@ void inputReadThread(const std::shared_ptr<input_handler_args>& args) {
     bool run = true;
     const size_t totalNbFrames = appParameters.nbFrames * appParameters.nbLoops;
     Retval returnValue = Retval::Running;
+    
+    // For input frame limiter
+    double lastFrameTimeStamp = 0;    
+    
     // Producer thread that reads input frames.
     while (run) {
         // Signal that all input frames has been load
@@ -230,6 +234,20 @@ void inputReadThread(const std::shared_ptr<input_handler_args>& args) {
             returnValue = Retval::Failure;
         }
 
+        if(appParameters.inputFramePerSecondLimiter != 0) {
+            const double targetDelayMs = 1000.0 / static_cast<double>(appParameters.inputFramePerSecondLimiter);
+            const double currentFrameStamp = uvgvpcc_enc::global_timer.elapsed(); //TODO(lf,gg): is it okay to access such library objects from the application?
+            const double delay = currentFrameStamp - lastFrameTimeStamp;
+            if(delay < targetDelayMs) {
+                const double waitMs = targetDelayMs - delay;
+                std::this_thread::sleep_for(std::chrono::milliseconds(static_cast<int>(waitMs)));
+                lastFrameTimeStamp = currentFrameStamp + waitMs;
+            } else {
+                lastFrameTimeStamp = currentFrameStamp;
+            }
+        }
+        
+
         // Signal that an item has been produced
         available_input_slot.acquire();
         args->frame_in = frame;

src/lib/bitstreamGeneration/bitstreamGeneration.cpp

@@ -40,6 +40,8 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <sstream>
+#include <iomanip>
 
 #include "atlas_context.hpp"
 #include "bitstream_common.hpp"
@@ -58,6 +60,11 @@ void BitstreamGeneration::createV3CGOFBitstream(const std::shared_ptr<uvgvpcc_en
                                                 uvgvpcc_enc::API::v3c_unit_stream* output) {
     uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::INFO>(
         "BITSTREAM GENERATION", "GOF " + std::to_string(gofUVG->gofId) + " : Create V3C GOF bitstream using uvgVPCC.\n");
+    
+
+
+
+
 
     v3c_gof gof(gofUVG->gofId);
     gof.set_n_frames(gofUVG->nbFrames);
@@ -142,4 +149,22 @@ void BitstreamGeneration::createV3CGOFBitstream(const std::shared_ptr<uvgvpcc_en
     }
 
     output->available_chunks.release();
+
+    if (paramUVG.displayBitstreamGenerationFps) {
+        static double lastStampJobCreateV3CGOFBitstream = 0.0;
+        const double currentStampJobCreateV3CGOFBitstream = global_timer.elapsed();
+        const double ms = currentStampJobCreateV3CGOFBitstream - lastStampJobCreateV3CGOFBitstream;
+        double fps = (static_cast<double>(gofUVG->nbFrames) * 1000.0) / ms;
+        std::ostringstream msStream;
+        msStream << std::fixed << std::setprecision(1) << ms;
+        std::string msStr = msStream.str();    
+        fps = std::round(fps * 10.0) / 10.0;
+        std::ostringstream fpsStream;
+        fpsStream << std::fixed << std::setprecision(1) << fps;
+        std::string fpsStr = fpsStream.str();
+        lastStampJobCreateV3CGOFBitstream = currentStampJobCreateV3CGOFBitstream;
+        uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::INFO>(
+            "BITSTREAM GENERATION", "GOF " + std::to_string(gofUVG->gofId) + " : Delay since last createV3CGOFBitstream: " + msStr + "ms, GOF with " + std::to_string(gofUVG->nbFrames) + " frames => " + fpsStr + "fps\n");
+    }
+
 }

src/lib/utils/parameters.cpp

@@ -246,6 +246,10 @@ void initializeParameterMap(Parameters& param) {
         {"attributeEncodingQp", {UINT, "", &param.attributeEncodingQp}},
         {"attributeEncodingPreset",
          {STRING, "ultrafast,superfast,veryfast,faster,fast,medium,slow,slower,veryslow", &param.attributeEncodingPreset}},
+
+        // ___ Bitstream generation ___ //
+        {"displayBitstreamGenerationFps", {BOOL, "", &param.displayBitstreamGenerationFps}},
+
     };
 }
 

src/lib/utils/parameters.hpp

@@ -161,6 +161,9 @@ struct Parameters {
     size_t attributeEncodingQp;
     std::string attributeEncodingPreset;
 
+    // ___ Bitstream generation ___ //
+    bool displayBitstreamGenerationFps = false;
+
     // ___ Miscellaneous ___ //
     // bool useEncoderCommand = false; // lf : All mention of this parameter has been commented. This might be usefull to support command line
     // 2D encoder in the futur.