improved logging

src/transport/webrtc_transport.cpp

@@ -21,8 +21,12 @@ rtc::Configuration* config;
 std::ofstream logFile;
 rtc::binary* msg_frame_buffer;
 unsigned long long maxMessageSize = 64000; //262144; //65536;
-std::map<TransformId, unsigned long long> left_frame_start_times, right_frame_start_times;
-std::map<TransformId, unsigned long long> left_frame_generation_times, right_frame_generation_times;
+
+TransformId transformsCount = 0;
+unsigned long long frameStarts[30000];
+TransformId transformMaps[30000];
+int LeftFrameGenerationTimes[30000];
+int RightFrameGenerationTimes[30000];
 
 bool WebRTCTransport::create(uint32_t port_number) {
     this->last_update_time = std::chrono::high_resolution_clock::now();
@@ -265,45 +269,45 @@ shared_ptr<rtc::PeerConnection> createPeerConnection(weak_ptr<rtc::WebSocket> ww
                             TransformId transform_id = (std::to_integer<long long>(msg[1]) | std::to_integer<long long>(msg[2]) << 8 | std::to_integer<long long>(msg[3]) << 16 | std::to_integer<long long>(msg[4]) << 24 | std::to_integer<long long>(msg[5]) << 32 | std::to_integer<long long>(msg[6]) << 40 | std::to_integer<long long>(msg[7]) << 48 | std::to_integer<long long>(msg[8]) << 56);
                             float htr[16];
                             //memcpy(&htr, &msg[9], 64);
+                            
+                            //texting only:
                             auto time = std::chrono::system_clock::now(); // get the current time
                             auto since_epoch = time.time_since_epoch(); // get the duration since epoch
                             auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(since_epoch);
                             auto now = millis.count(); // just like java (new Date()).getTime();
-                            left_frame_start_times.insert(std::pair<TransformId, unsigned long long>(transform_id, now));
-                            right_frame_start_times.insert(std::pair<TransformId, unsigned long long>(transform_id, now));
-                            int r = now % 1000;
-                            float angle = r / 1000.0 * 2 * 3.141592;
-                            float sine = std::sin(angle);
-                            float cosine = std::cos(angle);
+                            frameStarts[transformsCount] = now;
+                            transformMaps[transformsCount] = transform_id;
+                            //int r = now % 1000;
+                            //float angle = r / 1000.0 * 2 * 3.141592;
+                            //float sine = std::sin(angle);
+                            //float cosine = std::cos(angle);
                             //htr[0] = cosine;
                             //htr[10] = cosine;
                             //htr[2] = sine;
                             //htr[8] = -sine;
-                            tr->parse_head_transform(transform_id, htr);
+
+                            tr->parse_head_transform(transformsCount, htr);
+                            transformsCount++;
                         }
                         break;
                     case 'g': //logging message
                         if (tr->get_state() == TRANSPORT_STATE_CONNECTED) {
-                            float val_1, val_2, val_3, val_4, val_5;
+                            float val_1, val_2, val_3, val_4, val_5, val_6;
                             memcpy(&val_1, &msg[1], 4);
+                            memcpy(&val_6, &msg[13], 4);
                             memcpy(&val_2, &msg[5], 4);
                             memcpy(&val_3, &msg[9], 4);
-                            memcpy(&val_4, &msg[13], 4);
-                            memcpy(&val_5, &msg[17], 4);
-                            unsigned long long generation_time = 300;
+                            memcpy(&val_4, &msg[17], 4);
+                            memcpy(&val_5, &msg[21], 4);
+                            int generation_time = -1;
                             if ((int)val_1 % 2 == 0) {
-                                if(left_frame_start_times.contains((TransformId)val_4) && left_frame_generation_times.contains((TransformId)val_4)) {
-                                    generation_time = left_frame_generation_times[(TransformId)val_4] - left_frame_start_times[(TransformId)val_4];
-                                }
+                                generation_time = LeftFrameGenerationTimes[(FrameNumber) val_6];
                             } else {
-                               if(right_frame_start_times.contains((TransformId)val_4) && right_frame_generation_times.contains((TransformId)val_4)) {
-                                    generation_time = right_frame_generation_times[(TransformId)val_4] - right_frame_start_times[(TransformId)val_4];
+                                generation_time = RightFrameGenerationTimes[(FrameNumber) val_6];
                             }
-                            }
-                            //frame id, Generation time, RTT no decoding, RTT with decoding, packets sent, packets received bytes sent,
+                            //frame id, transform_id, Generation time, RTT no decoding, RTT with decoding, packets sent, packets received bytes sent,
                             logFile << std::to_string(val_1) + "; " + std::to_string(val_4) + "; " + std::to_string(generation_time) + "; " + std::to_string(val_3 - val_4) + "; " + std::to_string(val_2 - val_4) + "; " + std::to_string(tr->packets_send) + "; " + std::to_string(val_5) + "; " + std::to_string(tr->bytes_send_total) + "; \n";
                             //logFile << std::to_string(val_1) + "; " + std::to_string(val_2) + "; " + std::to_string(val_3) + "; " + std::to_string(val_4) + "; \n";
-                            tr->latency_counter += generation_time;
                             tr->frame_counter++;
                         }
                         break;
@@ -413,26 +417,13 @@ bool WebRTCTransport::send_frame_nal(FrameNumber frame_number, FrameId frame_id,
     auto since_epoch = time.time_since_epoch(); // get the duration since epoch
     auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(since_epoch);
     auto now = millis.count(); // just like java (new Date()).getTime();
+    
+    TransformId realTransformId = transformMaps[transform_id];
+
     if (frame_id == 0) {
-        std::erase_if(left_frame_start_times, [transform_id](const auto& item) {
-            auto const& [key, value] = item;
-            return key < transform_id - 300;
-        });
-        std::erase_if(left_frame_generation_times, [transform_id](const auto& item) {
-            auto const& [key, value] = item;
-            return key < transform_id - 300;
-        });
-        left_frame_generation_times.insert(std::pair<TransformId, unsigned long long>(transform_id, now));
+        LeftFrameGenerationTimes[frame_number] = now - frameStarts[transform_id];
     } else {
-        std::erase_if(right_frame_start_times, [transform_id](const auto& item) {
-            auto const& [key, value] = item;
-            return key < transform_id - 300;
-        });
-        std::erase_if(right_frame_generation_times, [transform_id](const auto& item) {
-            auto const& [key, value] = item;
-            return key < transform_id - 300;
-        });
-        right_frame_generation_times.insert(std::pair<TransformId, unsigned long long>(transform_id, now));
+        RightFrameGenerationTimes[frame_number] = now - frameStarts[transform_id];
     }
 
     if (msg_frame_buffer == nullptr) {
@@ -448,10 +439,10 @@ bool WebRTCTransport::send_frame_nal(FrameNumber frame_number, FrameId frame_id,
         } else {
             (*msg_frame_buffer)[1] = std::byte('r');
         }
-        (*msg_frame_buffer)[2] = std::byte(transform_id & 0x000000ff);
-        (*msg_frame_buffer)[3] = std::byte((transform_id & 0x0000ff00) >> 8);
-        (*msg_frame_buffer)[4] = std::byte((transform_id & 0x00ff0000) >> 16);
-        (*msg_frame_buffer)[5] = std::byte((transform_id & 0xff000000) >> 24);
+        (*msg_frame_buffer)[2] = std::byte(realTransformId & 0x000000ff);
+        (*msg_frame_buffer)[3] = std::byte((realTransformId & 0x0000ff00) >> 8);
+        (*msg_frame_buffer)[4] = std::byte((realTransformId & 0x00ff0000) >> 16);
+        (*msg_frame_buffer)[5] = std::byte((realTransformId & 0xff000000) >> 24);
 
         //time at start transmission
         //auto time = std::chrono::system_clock::now(); 
@@ -681,12 +672,6 @@ void WebRTCTransport::process_send_queue() {
         this->bitrate_receive = ((double) this->bits_received / (double) delta_time) / 1000.0;
         this->bits_send = 0;
         this->bits_received = 0;
-        if ((latency_counter / (double) frame_counter) > GOAL_LATENCY) {
-
-        } else {
-
-        }
-        this->latency_counter = 0;
         this->frame_counter = 0;
         this->last_update_time = cur_time;
     }

src/transport/webrtc_transport.hpp

@@ -24,7 +24,7 @@
 #include <unordered_map>
 
 
-#define WEBRTC_TRANSPORT_STATE_CHECK_INTERVAL   200   //NOTE: In milliseconds
+#define WEBRTC_TRANSPORT_STATE_CHECK_INTERVAL   20   //NOTE: In milliseconds
 #define TRANSPORT_CLIENT_CONNECT_TIMEOUT 60   //NOTE: In seconds
 #define WEBRTC_TRANSPORT_CLIENT_TIMEOUT         20   //NOTE: In seconds
 #define GOAL_LATENCY 50
@@ -93,7 +93,6 @@ public:
     uint32_t bits_received = 0; //NOTE: Owned by worker_thread
     double bytes_send_total = 0.0;
     double packets_send = 0.0;
-    double latency_counter = 0.0;
     uint32_t frame_counter = 0;
 
 private: