Added encoder input rate slider.

src/headset/remote_headset.cpp

@@ -129,6 +129,8 @@ bool RemoteHeadset::on_interface()
         }
     }
 
+    ImGui::SliderInt("Input-Rate (Fps)", (int32_t*) &this->encoder_input_rate, 1, 90);
+
     if (ImGui::SliderInt("Key-Rate (Kps)", (int32_t*)&this->encoder_key_rate, 90, 900))
     {
         for (Encoder::Ptr encoder : this->encoders)
@@ -174,10 +176,10 @@ bool RemoteHeadset::on_interface()
         return false;
     }
 
-    if (ImGui::SliderFloat("Send-Rate Limit (Mbps)", &this->send_bit_rate_limit, 1.0, 20.0))
+    /*if (ImGui::SliderFloat("Send-Rate Limit (Mbps)", &this->send_bit_rate_limit, 1.0, 20.0))
     {
         this->transport->set_max_bitrate_send(this->send_bit_rate_limit);
-    }
+    }*/
 
     if (ImGui::SliderInt("Send-Queue Limit (KBytes)", (int32_t*)&this->send_queue_size_limit, 1, 1000))
     {
@@ -207,10 +209,18 @@ bool RemoteHeadset::on_update(lava::delta delta_time)
     }
 
     this->update_values();
-    this->update_bitrates(delta_time);
+    this->update_bitrates();
     this->update_stage(delta_time);
     
     this->frame_number++;
+    this->encoder_last_submit += delta_time;
+    this->encoder_enable_submit = false;
+
+    if (this->encoder_last_submit > (1.0 / (float)this->encoder_input_rate))
+    {
+        this->encoder_enable_submit = true;
+        this->encoder_last_submit = 0.0f;
+    }
 
     return true;
 }
@@ -224,6 +234,11 @@ void RemoteHeadset::submit_frame(VkCommandBuffer command_buffer, VkImageLayout f
         return;
     }
 
+    if (!this->encoder_enable_submit)
+    {
+        return;        
+    }
+
     lava::renderer& renderer = this->get_application()->get_renderer();
     lava::image::ptr framebuffer = this->framebuffers[frame_id];
 
@@ -357,7 +372,7 @@ bool RemoteHeadset::create_transport()
         this->on_transport_error();
     });
 
-    this->transport->set_max_bitrate_send(this->send_bit_rate_limit);
+    //this->transport->set_max_bitrate_send(this->send_bit_rate_limit);
     this->transport->set_max_send_queue_size(this->send_queue_size_limit * 1000);
 
     if (!this->transport->create(this->server_port))
@@ -463,7 +478,7 @@ void RemoteHeadset::update_values()
     this->controller_states = this->transport_controller_states;
 }
 
-void RemoteHeadset::update_bitrates(lava::delta delta_time)
+void RemoteHeadset::update_bitrates()
 {
     this->statistic_send_bitrate->add_sample(this->transport->get_bitrate_send());
     this->statistic_receive_bitrate->add_sample(this->transport->get_bitrate_received());

src/headset/remote_headset.hpp

@@ -5,6 +5,7 @@
 #include <vector>
 #include <array>
 #include <memory>
+#include <chrono>
 
 #include "headset.hpp"
 #include "strategy/stereo_strategy.hpp"
@@ -60,7 +61,7 @@ private:
     void destroy_encoders();
 
     void update_values();
-    void update_bitrates(lava::delta delta_time);
+    void update_bitrates();
     void update_stage(lava::delta delta_time);
 
     void on_setup(const glm::u32vec2& resolution);
@@ -109,13 +110,18 @@ private:
 
     lava::image::ptr framebuffer_array;
     std::vector<lava::image::ptr> framebuffers;
+
     std::vector<Encoder::Ptr> encoders;
     uint32_t encoder_mode = ENCODER_MODE_CONSTANT_QUALITY;
+    uint32_t encoder_input_rate = 90;
     uint32_t encoder_key_rate = 120;
     uint32_t encoder_frame_rate = 90;
     uint32_t encoder_quality = 51;
     float encoder_bit_rate = 6.0;               //NOTE: Bitrate in Mbit per seconds
-    float send_bit_rate_limit = 15.0;           //NOTE: Bitrate in Mbit per seconds
+    float encoder_last_submit = 0.0f;
+    bool encoder_enable_submit = true;
+
+    //float send_bit_rate_limit = 15.0;         //NOTE: Bitrate in Mbit per seconds
     uint32_t send_queue_size_limit = 100;       //NOTE: Size in KBytes
 
     Statistic::Ptr statistic_send_bitrate;

src/stream/transport.cpp

@@ -294,11 +294,11 @@ void Transport::set_on_transport_error(OnTransportError function)
     this->on_transport_error = std::move(function);
 }
 
-void Transport::set_max_bitrate_send(double bitrate)
+/*void Transport::set_max_bitrate_send(double bitrate)
 {
     std::unique_lock<std::mutex> lock(this->worker_mutex);
     this->max_bitrate_send = bitrate;
-}
+}*/
 
 void Transport::set_max_send_queue_size(uint32_t size)
 {
@@ -338,14 +338,14 @@ double Transport::get_bitrate_received()
     return value;
 }
 
-double Transport::get_max_bitrate_send()
+/*double Transport::get_max_bitrate_send()
 {
     std::unique_lock<std::mutex> lock(this->worker_mutex);
     double value = this->max_bitrate_send;
     lock.unlock();
 
     return value;
-}
+}*/
 
 uint32_t Transport::get_max_send_queue_size()
 {
@@ -607,10 +607,10 @@ void Transport::process_send_queue()
         this->send_queue.erase(this->send_queue.begin());
         this->datagram_pool.release_datagram(datagram);
 
-        if (this->bits_send < (this->max_bitrate_send * (TRANSPORT_STATE_CHECK_INTERVAL / 1000.0)) * (1000.0 * 1000.0))
-        {
+        //if (this->bits_send < (this->max_bitrate_send * (TRANSPORT_STATE_CHECK_INTERVAL / 1000.0)) * (1000.0 * 1000.0))
+        //{
             this->process_send_queue();
-        }
+        //}
         lock.unlock();
     });
 

src/stream/transport.hpp

@@ -62,7 +62,7 @@ public:
     void set_on_transport_error(OnTransportError function);
 
     //NOTE: The following functions should be thread safe
-    void set_max_bitrate_send(double bitrate);      //NOTE: The bitrate is given in MBits/s
+    //void set_max_bitrate_send(double bitrate);      //NOTE: The bitrate is given in MBits/s
     void set_max_send_queue_size(uint32_t size);    //NOTE: The size is given in Bytes
 
     //NOTE: The following function should be thread safe
@@ -70,7 +70,7 @@ public:
     TransportState get_state();
     double get_bitrate_send();              //NOTE: The bitrate is given in MBits/s
     double get_bitrate_received();          //NOTE: The bitrate is given in MBits/s
-    double get_max_bitrate_send();          //NOTE: The bitrate is given in MBits/s
+    //double get_max_bitrate_send();          //NOTE: The bitrate is given in MBits/s
     uint32_t get_max_send_queue_size();     //NOTE: The size is given in Bytes
 
     uint32_t get_send_queue_size();         //NOTE: In Bytes
@@ -117,7 +117,7 @@ private:
     uint32_t bits_received = 0;                           //NOTE: Owned by worker_thread
     double bitrate_send = 0.0;                            //NOTE: Protected by worker_mutex
     double bitrate_received = 0.0;                        //NOTE: Protected by worker_mutex
-    double max_bitrate_send = 1.0;                        //NOTE: Protected by worker_mutex
+    //double max_bitrate_send = 1.0;                        //NOTE: Protected by worker_mutex
     uint32_t max_send_queue_size = DATAGRAM_SIZE * 128;   //NOTE: Protected by worker_mutex
     bool send_active = false;                             //NOTE: Protected by worker_mutex
     double inactive_time = 0.0;                           //NOTE: Owned by worker_thread