Implementation for rtcp receiver report

src/rtp/rtp_video_receiver.cpp

@@ -3,6 +3,7 @@
 #include "log.h"
 
 #define NV12_BUFFER_SIZE (1280 * 720 * 3 / 2)
+#define RTCP_RR_INTERVAL 1000
 
 RtpVideoReceiver::RtpVideoReceiver() {}
 
@@ -19,6 +20,34 @@ void RtpVideoReceiver::InsertRtpPacket(RtpPacket& rtp_packet) {
     rtp_video_receive_statistics_->UpdateReceiveBytes(rtp_packet.Size());
   }
 
+  if (CheckIsTimeSendRR()) {
+    RtcpReceiverReport rtcp_rr;
+    RtcpReportBlock report;
+
+    auto duration = std::chrono::system_clock::now().time_since_epoch();
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+    uint32_t seconds_u32 = static_cast<uint32_t>(
+        std::chrono::duration_cast<std::chrono::seconds>(duration).count());
+
+    uint32_t fraction_u32 = static_cast<uint32_t>(
+        std::chrono::duration_cast<std::chrono::nanoseconds>(duration - seconds)
+            .count());
+
+    report.source_ssrc = 0x00;
+    report.fraction_lost = 0;
+    report.cumulative_lost = 0;
+    report.extended_high_seq_num = 0;
+    report.jitter = 0;
+    report.lsr = 0;
+    report.dlsr = 0;
+
+    rtcp_rr.SetReportBlock(report);
+
+    rtcp_rr.Encode();
+
+    SendRtcpRR(rtcp_rr);
+  }
+
   if (RtpPacket::NAL_UNIT_TYPE::NALU == rtp_packet.NalUnitType()) {
     compelete_video_frame_queue_.push(
         VideoFrame(rtp_packet.Payload(), rtp_packet.Size()));
@@ -116,4 +145,39 @@ bool RtpVideoReceiver::Process() {
 
   std::this_thread::sleep_for(std::chrono::milliseconds(13));
   return true;
+}
+
+void RtpVideoReceiver::SetUdpSender(
+    std::function<int(const char*, size_t)> udp_sender) {
+  udp_sender_ = udp_sender;
+}
+
+int RtpVideoReceiver::SendRtcpRR(RtcpReceiverReport& rtcp_rr) {
+  if (!udp_sender_) {
+    LOG_ERROR("udp_sender_ is nullptr");
+    return -1;
+  }
+
+  if (udp_sender_((const char*)rtcp_rr.Buffer(), rtcp_rr.Size())) {
+    LOG_ERROR("Send RR failed");
+    return -1;
+  }
+
+  LOG_ERROR("Send RR");
+
+  return 0;
+}
+
+bool RtpVideoReceiver::CheckIsTimeSendRR() {
+  uint32_t now_ts = static_cast<uint32_t>(
+      std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::high_resolution_clock::now().time_since_epoch())
+          .count());
+
+  if (now_ts - last_send_rtcp_rr_packet_ts_ >= RTCP_RR_INTERVAL) {
+    last_send_rtcp_rr_packet_ts_ = now_ts;
+    return true;
+  } else {
+    return false;
+  }
 }

src/rtp/rtp_video_receiver.h

@@ -7,6 +7,7 @@
 
 #include "frame.h"
 #include "ringbuffer.h"
+#include "rtcp_receiver_report.h"
 #include "rtp_codec.h"
 #include "rtp_video_receive_statistics.h"
 #include "thread_base.h"
@@ -19,6 +20,9 @@ class RtpVideoReceiver : public ThreadBase {
  public:
   void InsertRtpPacket(RtpPacket& rtp_packet);
 
+  void SetUdpSender(
+      std::function<int(const char*, size_t)> rtp_packet_send_func);
+
   void SetOnReceiveCompleteFrame(
       std::function<void(VideoFrame&)> on_receive_complete_frame) {
     on_receive_complete_frame_ = on_receive_complete_frame;
@@ -26,7 +30,8 @@ class RtpVideoReceiver : public ThreadBase {
 
  private:
   bool CheckIsFrameCompleted(RtpPacket& rtp_packet);
-  //   void OnReceiveFrame(uint8_t* payload) {}
+  bool CheckIsTimeSendRR();
+  int SendRtcpRR(RtcpReceiverReport& rtcp_rr);
 
  private:
   bool Process() override;
@@ -41,6 +46,8 @@ class RtpVideoReceiver : public ThreadBase {
  private:
   std::unique_ptr<RtpVideoReceiveStatistics> rtp_video_receive_statistics_ =
       nullptr;
+  uint32_t last_send_rtcp_rr_packet_ts_ = 0;
+  std::function<int(const char*, size_t)> udp_sender_ = nullptr;
 };
 
 #endif

src/rtp/rtp_video_sender.cpp

@@ -4,7 +4,7 @@
 
 #include "log.h"
 
-#define RTCP_INTERVAL 1000
+#define RTCP_SR_INTERVAL 1000
 
 RtpVideoSender::RtpVideoSender() {}
 
@@ -45,7 +45,8 @@ int RtpVideoSender::SendRtpPacket(RtpPacket& rtp_packet) {
 
   if (CheckIsTimeSendSR()) {
     RtcpSenderReport rtcp_sr;
-    RtcpSenderReport::SENDER_INFO sender_info;
+    SenderInfo sender_info;
+    RtcpReportBlock report;
 
     auto duration = std::chrono::system_clock::now().time_since_epoch();
     auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
@@ -57,7 +58,8 @@ int RtpVideoSender::SendRtpPacket(RtpPacket& rtp_packet) {
             .count());
 
     sender_info.sender_ssrc = 0x00;
-    sender_info.ntp_ts = (uint64_t)seconds_u32 << 32 | (uint64_t)fraction_u32;
+    sender_info.ntp_ts_msw = (uint32_t)seconds_u32;
+    sender_info.ntp_ts_lsw = (uint32_t)fraction_u32;
     sender_info.rtp_ts =
         std::chrono::high_resolution_clock::now().time_since_epoch().count() *
         1000000;
@@ -66,6 +68,16 @@ int RtpVideoSender::SendRtpPacket(RtpPacket& rtp_packet) {
 
     rtcp_sr.SetSenderInfo(sender_info);
 
+    report.source_ssrc = 0x00;
+    report.fraction_lost = 0;
+    report.cumulative_lost = 0;
+    report.extended_high_seq_num = 0;
+    report.jitter = 0;
+    report.lsr = 0;
+    report.dlsr = 0;
+
+    rtcp_sr.SetReportBlock(report);
+
     rtcp_sr.Encode();
 
     SendRtcpSR(rtcp_sr);
@@ -96,8 +108,8 @@ bool RtpVideoSender::CheckIsTimeSendSR() {
           std::chrono::high_resolution_clock::now().time_since_epoch())
           .count());
 
-  if (now_ts - last_send_rtcp_packet_ts_ >= RTCP_INTERVAL) {
-    last_send_rtcp_packet_ts_ = now_ts;
+  if (now_ts - last_send_rtcp_sr_packet_ts_ >= RTCP_SR_INTERVAL) {
+    last_send_rtcp_sr_packet_ts_ = now_ts;
     return true;
   } else {
     return false;

src/rtp/rtp_video_sender.h

@@ -4,7 +4,6 @@
 #include <functional>
 
 #include "ringbuffer.h"
-#include "rtcp_packet.h"
 #include "rtcp_sender_report.h"
 #include "rtp_packet.h"
 #include "rtp_video_send_statistics.h"
@@ -38,7 +37,7 @@ class RtpVideoSender : public ThreadBase {
  private:
   std::unique_ptr<RtpVideoSendStatistics> rtp_video_send_statistics_ = nullptr;
   uint32_t last_send_bytes_ = 0;
-  uint32_t last_send_rtcp_packet_ts_ = 0;
+  uint32_t last_send_rtcp_sr_packet_ts_ = 0;
   uint32_t total_rtp_packets_sent_ = 0;
   uint32_t total_rtp_payload_sent_ = 0;
 };