[feat] use the io statistics module to collect network information

src/statistics/io_statistics.cpp

@@ -3,9 +3,7 @@
 #include "log.h"
 
 IOStatistics::IOStatistics(
-    std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
-                       uint32_t, uint32_t, uint32_t)>
-        io_report_callback)
+    std::function<void(const NetTrafficStats&)> io_report_callback)
     : io_report_callback_(io_report_callback) {
   interval_ = 1000;
 }
@@ -36,11 +34,95 @@ void IOStatistics::Process() {
     data_inbound_bytes_ = 0;
     data_outbound_bytes_ = 0;
 
+    // packet loss rate
+    {
+      video_rtp_pkt_loss_cnt_ =
+          expected_video_inbound_rtp_pkt_cnt_ - video_inbound_rtp_pkt_cnt_tmp_;
+      audio_rtp_pkt_loss_cnt_ =
+          expected_audio_inbound_rtp_pkt_cnt_ - audio_inbound_rtp_pkt_cnt_tmp_;
+      data_rtp_pkt_loss_cnt_ =
+          expected_data_inbound_rtp_pkt_cnt_ - data_inbound_rtp_pkt_cnt_tmp_;
+
+      if (expected_video_inbound_rtp_pkt_cnt_ > 0 &&
+          video_rtp_pkt_loss_cnt_ >= 0) {
+        video_rtp_pkt_loss_rate_ = video_rtp_pkt_loss_cnt_ /
+                                   (float)expected_video_inbound_rtp_pkt_cnt_;
+      } else {
+        video_rtp_pkt_loss_rate_ = 0;
+      }
+
+      if (expected_audio_inbound_rtp_pkt_cnt_ > 0 &&
+          audio_inbound_rtp_pkt_cnt_tmp_ > 0) {
+        audio_rtp_pkt_loss_rate_ =
+            audio_rtp_pkt_loss_cnt_ / (float)audio_inbound_rtp_pkt_cnt_;
+      } else {
+        audio_rtp_pkt_loss_rate_ = 0;
+      }
+
+      if (expected_data_inbound_rtp_pkt_cnt_ > 0 &&
+          data_inbound_rtp_pkt_cnt_ > 0) {
+        data_rtp_pkt_loss_rate_ =
+            data_rtp_pkt_loss_cnt_ / (float)data_inbound_rtp_pkt_cnt_;
+      } else {
+        data_rtp_pkt_loss_rate_ = 0;
+      }
+
+      expected_video_inbound_rtp_pkt_cnt_ = 0;
+      expected_audio_inbound_rtp_pkt_cnt_ = 0;
+      expected_data_inbound_rtp_pkt_cnt_ = 0;
+      video_inbound_rtp_pkt_cnt_tmp_ = 0;
+      audio_inbound_rtp_pkt_cnt_tmp_ = 0;
+      data_inbound_rtp_pkt_cnt_tmp_ = 0;
+      video_rtp_pkt_loss_cnt_ = 0;
+      audio_rtp_pkt_loss_cnt_ = 0;
+      data_rtp_pkt_loss_cnt_ = 0;
+    }
+
     if (io_report_callback_) {
-      io_report_callback_(video_inbound_bitrate_, video_outbound_bitrate_,
-                          audio_inbound_bitrate_, audio_outbound_bitrate_,
-                          data_inbound_bitrate_, data_outbound_bitrate_,
-                          total_inbound_bitrate_, total_outbound_bitrate_);
+      NetTrafficStats net_traffic_stats;
+      net_traffic_stats.video_inbound_stats.bitrate = video_inbound_bitrate_;
+      net_traffic_stats.video_inbound_stats.rtp_packet_count =
+          video_inbound_rtp_pkt_cnt_;
+      net_traffic_stats.video_inbound_stats.loss_rate =
+          video_rtp_pkt_loss_rate_;
+
+      net_traffic_stats.video_outbound_stats.bitrate = video_outbound_bitrate_;
+      net_traffic_stats.video_outbound_stats.rtp_packet_count =
+          video_outbound_rtp_pkt_cnt_;
+
+      net_traffic_stats.audio_inbound_stats.bitrate = audio_inbound_bitrate_;
+      net_traffic_stats.audio_inbound_stats.rtp_packet_count =
+          audio_inbound_rtp_pkt_cnt_;
+      net_traffic_stats.audio_inbound_stats.loss_rate =
+          audio_rtp_pkt_loss_rate_;
+
+      net_traffic_stats.audio_outbound_stats.bitrate = audio_outbound_bitrate_;
+      net_traffic_stats.audio_outbound_stats.rtp_packet_count =
+          audio_outbound_rtp_pkt_cnt_;
+
+      net_traffic_stats.data_inbound_stats.bitrate = data_inbound_bitrate_;
+      net_traffic_stats.data_inbound_stats.rtp_packet_count =
+          data_inbound_rtp_pkt_cnt_;
+      net_traffic_stats.data_inbound_stats.loss_rate = data_rtp_pkt_loss_rate_;
+
+      net_traffic_stats.data_outbound_stats.bitrate = data_outbound_bitrate_;
+      net_traffic_stats.data_outbound_stats.rtp_packet_count =
+          data_outbound_rtp_pkt_cnt_;
+
+      net_traffic_stats.total_inbound_stats.bitrate = total_inbound_bitrate_;
+      net_traffic_stats.total_inbound_stats.loss_rate =
+          video_rtp_pkt_loss_rate_ + audio_rtp_pkt_loss_rate_ +
+          data_rtp_pkt_loss_rate_;
+      net_traffic_stats.total_inbound_stats.rtp_packet_count =
+          video_inbound_rtp_pkt_cnt_ + audio_inbound_rtp_pkt_cnt_ +
+          data_inbound_rtp_pkt_cnt_;
+
+      net_traffic_stats.total_outbound_stats.bitrate = total_outbound_bitrate_;
+      net_traffic_stats.total_outbound_stats.rtp_packet_count =
+          video_outbound_rtp_pkt_cnt_ + audio_outbound_rtp_pkt_cnt_ +
+          data_outbound_rtp_pkt_cnt_;
+
+      io_report_callback_(net_traffic_stats);
     }
   }
 }
@@ -68,6 +150,24 @@ void IOStatistics::UpdateVideoOutboundBytes(uint32_t bytes) {
   video_outbound_bytes_ += bytes;
 }
 
+void IOStatistics::UpdateVideoPacketLossCount(uint16_t seq_num) {
+  if (last_received_video_rtp_pkt_seq_ != 0) {
+    if (last_received_video_rtp_pkt_seq_ < seq_num) {
+      if (seq_num - last_received_video_rtp_pkt_seq_ > 0x8000) {
+        expected_video_inbound_rtp_pkt_cnt_ +=
+            0xffff - last_received_video_rtp_pkt_seq_ + seq_num + 1;
+      } else {
+        expected_video_inbound_rtp_pkt_cnt_ +=
+            seq_num - last_received_video_rtp_pkt_seq_ - 1;
+      }
+    } else if (last_received_video_rtp_pkt_seq_ > seq_num) {
+      expected_video_inbound_rtp_pkt_cnt_ +=
+          0xffff - last_received_video_rtp_pkt_seq_ + seq_num + 1;
+    }
+  }
+  last_received_video_rtp_pkt_seq_ = seq_num;
+}
+
 void IOStatistics::UpdateAudioInboundBytes(uint32_t bytes) {
   audio_inbound_bytes_ += bytes;
 }
@@ -76,10 +176,73 @@ void IOStatistics::UpdateAudioOutboundBytes(uint32_t bytes) {
   audio_outbound_bytes_ += bytes;
 }
 
+void IOStatistics::UpdateAudioPacketLossCount(uint16_t seq_num) {
+  if (last_received_audio_rtp_pkt_seq_ != 0) {
+    if (last_received_audio_rtp_pkt_seq_ < seq_num) {
+      if (seq_num - last_received_audio_rtp_pkt_seq_ > 0x8000) {
+        expected_audio_inbound_rtp_pkt_cnt_ +=
+            0xffff - last_received_audio_rtp_pkt_seq_ + seq_num + 1;
+      } else {
+        expected_audio_inbound_rtp_pkt_cnt_ +=
+            seq_num - last_received_audio_rtp_pkt_seq_ - 1;
+      }
+    } else if (last_received_audio_rtp_pkt_seq_ > seq_num) {
+      expected_audio_inbound_rtp_pkt_cnt_ +=
+          0xffff - last_received_audio_rtp_pkt_seq_ + seq_num + 1;
+    }
+  }
+  last_received_audio_rtp_pkt_seq_ = seq_num;
+}
+
 void IOStatistics::UpdateDataInboundBytes(uint32_t bytes) {
   data_inbound_bytes_ += bytes;
 }
 
 void IOStatistics::UpdateDataOutboundBytes(uint32_t bytes) {
   data_outbound_bytes_ += bytes;
+}
+
+void IOStatistics::UpdateDataPacketLossCount(uint16_t seq_num) {
+  if (last_received_data_rtp_pkt_seq_ != 0) {
+    if (last_received_data_rtp_pkt_seq_ < seq_num) {
+      if (seq_num - last_received_data_rtp_pkt_seq_ > 0x8000) {
+        expected_data_inbound_rtp_pkt_cnt_ +=
+            0xffff - last_received_data_rtp_pkt_seq_ + seq_num + 1;
+      } else {
+        expected_data_inbound_rtp_pkt_cnt_ +=
+            seq_num - last_received_data_rtp_pkt_seq_ - 1;
+      }
+    } else if (last_received_data_rtp_pkt_seq_ > seq_num) {
+      expected_data_inbound_rtp_pkt_cnt_ +=
+          0xffff - last_received_data_rtp_pkt_seq_ + seq_num + 1;
+    }
+  }
+  last_received_data_rtp_pkt_seq_ = seq_num;
+}
+
+void IOStatistics::IncrementVideoInboundRtpPacketCount() {
+  video_inbound_rtp_pkt_cnt_++;
+  video_inbound_rtp_pkt_cnt_tmp_++;
+}
+
+void IOStatistics::IncrementVideoOutboundRtpPacketCount() {
+  video_outbound_rtp_pkt_cnt_++;
+}
+
+void IOStatistics::IncrementAudioInboundRtpPacketCount() {
+  audio_inbound_rtp_pkt_cnt_++;
+  audio_inbound_rtp_pkt_cnt_tmp_++;
+}
+
+void IOStatistics::IncrementAudioOutboundRtpPacketCount() {
+  audio_outbound_rtp_pkt_cnt_++;
+}
+
+void IOStatistics::IncrementDataInboundRtpPacketCount() {
+  data_inbound_rtp_pkt_cnt_++;
+  data_inbound_rtp_pkt_cnt_tmp_++;
+}
+
+void IOStatistics::IncrementDataOutboundRtpPacketCount() {
+  data_outbound_rtp_pkt_cnt_++;
 }

src/statistics/io_statistics.h

@@ -15,9 +15,30 @@
 
 class IOStatistics {
  public:
-  IOStatistics(std::function<void(uint32_t, uint32_t, uint32_t, uint32_t,
-                                  uint32_t, uint32_t, uint32_t, uint32_t)>
-                   io_report_callback);
+  typedef struct {
+    uint32_t bitrate;
+    uint32_t rtp_packet_count;
+    float loss_rate;
+  } InboundStats;
+
+  typedef struct {
+    uint32_t bitrate;
+    uint32_t rtp_packet_count;
+  } OutboundStats;
+
+  typedef struct {
+    InboundStats video_inbound_stats;
+    OutboundStats video_outbound_stats;
+    InboundStats audio_inbound_stats;
+    OutboundStats audio_outbound_stats;
+    InboundStats data_inbound_stats;
+    OutboundStats data_outbound_stats;
+    InboundStats total_inbound_stats;
+    OutboundStats total_outbound_stats;
+  } NetTrafficStats;
+
+ public:
+  IOStatistics(std::function<void(const NetTrafficStats&)> io_report_callback);
   ~IOStatistics();
 
  public:
@@ -26,20 +47,30 @@ class IOStatistics {
 
   void UpdateVideoInboundBytes(uint32_t bytes);
   void UpdateVideoOutboundBytes(uint32_t bytes);
+  void UpdateVideoPacketLossCount(uint16_t seq_num);
 
   void UpdateAudioInboundBytes(uint32_t bytes);
   void UpdateAudioOutboundBytes(uint32_t bytes);
+  void UpdateAudioPacketLossCount(uint16_t seq_num);
 
   void UpdateDataInboundBytes(uint32_t bytes);
   void UpdateDataOutboundBytes(uint32_t bytes);
+  void UpdateDataPacketLossCount(uint16_t seq_num);
+
+  void IncrementVideoInboundRtpPacketCount();
+  void IncrementVideoOutboundRtpPacketCount();
+
+  void IncrementAudioInboundRtpPacketCount();
+  void IncrementAudioOutboundRtpPacketCount();
+
+  void IncrementDataInboundRtpPacketCount();
+  void IncrementDataOutboundRtpPacketCount();
 
  private:
   void Process();
 
  private:
-  std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
-                     uint32_t, uint32_t)>
-      io_report_callback_ = nullptr;
+  std::function<void(const NetTrafficStats&)> io_report_callback_ = nullptr;
   std::thread statistics_thread_;
   std::mutex mtx_;
   uint32_t interval_ = 1000;
@@ -48,13 +79,35 @@ class IOStatistics {
 
   std::atomic<uint32_t> video_inbound_bytes_ = 0;
   std::atomic<uint32_t> video_outbound_bytes_ = 0;
+  std::atomic<uint16_t> last_received_video_rtp_pkt_seq_ = 0;
   std::atomic<uint32_t> audio_inbound_bytes_ = 0;
   std::atomic<uint32_t> audio_outbound_bytes_ = 0;
+  std::atomic<uint16_t> last_received_audio_rtp_pkt_seq_ = 0;
   std::atomic<uint32_t> data_inbound_bytes_ = 0;
   std::atomic<uint32_t> data_outbound_bytes_ = 0;
+  std::atomic<uint16_t> last_received_data_rtp_pkt_seq_ = 0;
   std::atomic<uint32_t> total_inbound_bytes_ = 0;
   std::atomic<uint32_t> total_outbound_bytes_ = 0;
 
+  std::atomic<uint32_t> video_inbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> audio_inbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> data_inbound_rtp_pkt_cnt_ = 0;
+
+  std::atomic<uint32_t> video_inbound_rtp_pkt_cnt_tmp_ = 0;
+  std::atomic<uint32_t> audio_inbound_rtp_pkt_cnt_tmp_ = 0;
+  std::atomic<uint32_t> data_inbound_rtp_pkt_cnt_tmp_ = 0;
+
+  std::atomic<uint32_t> data_outbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> video_outbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> audio_outbound_rtp_pkt_cnt_ = 0;
+
+  std::atomic<uint32_t> expected_video_inbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> expected_audio_inbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> expected_data_inbound_rtp_pkt_cnt_ = 0;
+  std::atomic<uint32_t> video_rtp_pkt_loss_cnt_ = 0;
+  std::atomic<uint32_t> audio_rtp_pkt_loss_cnt_ = 0;
+  std::atomic<uint32_t> data_rtp_pkt_loss_cnt_ = 0;
+
   std::atomic<uint32_t> video_inbound_bitrate_ = 0;
   std::atomic<uint32_t> video_outbound_bitrate_ = 0;
   std::atomic<uint32_t> audio_inbound_bitrate_ = 0;
@@ -63,6 +116,10 @@ class IOStatistics {
   std::atomic<uint32_t> data_outbound_bitrate_ = 0;
   std::atomic<uint32_t> total_inbound_bitrate_ = 0;
   std::atomic<uint32_t> total_outbound_bitrate_ = 0;
+
+  float video_rtp_pkt_loss_rate_ = 0;
+  float audio_rtp_pkt_loss_rate_ = 0;
+  float data_rtp_pkt_loss_rate_ = 0;
 };
 
 #endif