[fix] use ntp timestamp ms as video rtp timestamp

src/channel/audio_channel_send.cpp

@@ -48,7 +48,7 @@ void AudioChannelSend::Destroy() {
 int AudioChannelSend::SendAudio(char *data, size_t size) {
   if (rtp_audio_sender_ && rtp_packetizer_) {
     std::vector<std::shared_ptr<RtpPacket>> rtp_packets =
-        rtp_packetizer_->Build((uint8_t *)data, (uint32_t)size, true);
+        rtp_packetizer_->Build((uint8_t *)data, (uint32_t)size, 0, true);
     rtp_audio_sender_->Enqueue(rtp_packets);
   }
 

src/channel/data_channel_send.cpp

@@ -48,7 +48,7 @@ void DataChannelSend::Destroy() {
 int DataChannelSend::SendData(const char *data, size_t size) {
   if (rtp_data_sender_ && rtp_packetizer_) {
     std::vector<std::shared_ptr<RtpPacket>> rtp_packets =
-        rtp_packetizer_->Build((uint8_t *)data, (uint32_t)size, true);
+        rtp_packetizer_->Build((uint8_t *)data, (uint32_t)size, 0, true);
     rtp_data_sender_->Enqueue(rtp_packets);
   }
 

src/channel/rtp_channel/rtp_video_sender.cpp

@@ -45,7 +45,7 @@ RtpVideoSender::~RtpVideoSender() {
 
 void RtpVideoSender::Enqueue(
     std::vector<std::shared_ptr<RtpPacket>>& rtp_packets,
-    int64_t capture_timestamp) {
+    int64_t capture_timestamp_ms) {
   if (!rtp_statistics_) {
     rtp_statistics_ = std::make_unique<RtpStatistics>();
     rtp_statistics_->Start();
@@ -55,7 +55,7 @@ void RtpVideoSender::Enqueue(
     std::shared_ptr<webrtc::RtpPacketToSend> rtp_packet_to_send =
         std::dynamic_pointer_cast<webrtc::RtpPacketToSend>(rtp_packet);
     rtp_packet_to_send->set_capture_time(
-        webrtc::Timestamp::Millis(capture_timestamp));
+        webrtc::Timestamp::Millis(capture_timestamp_ms));
     rtp_packet_to_send->set_transport_sequence_number(transport_seq_++);
     rtp_packet_to_send->set_packet_type(webrtc::RtpPacketMediaType::kVideo);
     rtp_packet_queue_.push(std::move(rtp_packet_to_send));
@@ -93,7 +93,7 @@ int RtpVideoSender::SendRtpPacket(
 
 #ifdef SAVE_RTP_SENT_STREAM
   fwrite((unsigned char*)rtp_packet_to_send->Payload(), 1,
-         rtp_packet_to_send->PayloadSize(), file_rtp_sent_);
+         x rtp_packet_to_send->PayloadSize(), file_rtp_sent_);
 #endif
 
   last_send_bytes_ += (uint32_t)rtp_packet_to_send->Size();

src/channel/rtp_channel/rtp_video_sender.h

@@ -23,7 +23,7 @@ class RtpVideoSender : public ThreadBase {
 
  public:
   void Enqueue(std::vector<std::shared_ptr<RtpPacket>> &rtp_packets,
-               int64_t capture_timestamp);
+               int64_t capture_timestamp_ms);
   void SetSendDataFunc(std::function<int(const char *, size_t)> data_send_func);
   void SetOnSentPacketFunc(
       std::function<void(const webrtc::RtpPacketToSend &)> on_sent_packet_func);

src/channel/video_channel_send.cpp

@@ -62,7 +62,8 @@ int VideoChannelSend::SendVideo(
   if (rtp_video_sender_ && rtp_packetizer_) {
     std::vector<std::shared_ptr<RtpPacket>> rtp_packets =
         rtp_packetizer_->Build((uint8_t*)encoded_frame->Buffer(),
-                               (uint32_t)encoded_frame->Size(), true);
+                               (uint32_t)encoded_frame->Size(),
+                               encoded_frame->CaptureTimestamp(), true);
     rtp_video_sender_->Enqueue(rtp_packets, encoded_frame->CaptureTimestamp());
   }
 

src/common/clock/system_clock.cpp

@@ -78,6 +78,17 @@ int64_t SystemClock::CurrentNtpTime() {
   return ConvertToNtpTime(CurrentTimeNs());
 }
 
+int64_t SystemClock::CurrentNtpTimeMs() {
+  int64_t ntp_ts = ConvertToNtpTime(CurrentTimeNs());
+  uint32_t seconds = static_cast<uint32_t>(ntp_ts / 1000000000);
+  uint32_t fractions = static_cast<uint32_t>(ntp_ts % 1000000000);
+
+  static constexpr double kNtpFracPerMs = 4.294967296E6;  // 2^32 / 1000.
+  const double frac_ms = static_cast<double>(fractions) / kNtpFracPerMs;
+  return 1000 * static_cast<int64_t>(seconds) +
+         static_cast<int64_t>(frac_ms + 0.5);
+}
+
 int64_t SystemClock::CurrentUtcTimeNs() {
 #if defined(__POSIX__)
   struct timeval time;

src/common/clock/system_clock.h

@@ -23,6 +23,7 @@ class SystemClock {
   int64_t CurrentTimeNs();
 
   int64_t CurrentNtpTime();
+  int64_t CurrentNtpTimeMs();
 
   int64_t CurrentUtcTime();
   int64_t CurrentUtcTimeMs();

src/frame/video_frame_wrapper.h

@@ -23,10 +23,10 @@ class VideoFrameWrapper : public VideoFrame {
   VideoFrameWrapper() = delete;
   ~VideoFrameWrapper() = default;
 
-  int64_t CaptureTimestamp() { return capture_timestamp_; }
+  int64_t CaptureTimestamp() { return capture_timestamp_ms_; }
 
-  void SetCaptureTimestamp(int64_t capture_timestamp) {
+  void SetCaptureTimestamp(int64_t capture_timestamp_ms) {
-    capture_timestamp_ = capture_timestamp;
+    capture_timestamp_ms_ = capture_timestamp_ms;
   }
 
   VideoFrameType FrameType() { return frame_type_; }
@@ -46,7 +46,7 @@ class VideoFrameWrapper : public VideoFrame {
   }
 
  private:
-  int64_t capture_timestamp_ = 0;
+  int64_t capture_timestamp_ms_ = 0;
   VideoFrameType frame_type_ = VideoFrameType::kVideoFrameDelta;
   uint32_t encoded_width_ = 0;
   uint32_t encoded_height_ = 0;

src/interface/x.h

@@ -134,7 +134,7 @@ DLLAPI int SendAudioFrame(PeerPtr* peer_ptr, const char* data, size_t size);
 
 DLLAPI int SendDataFrame(PeerPtr* peer_ptr, const char* data, size_t size);
 
-DLLAPI int64_t GetNowTime(PeerPtr* peer_ptr);
+DLLAPI int64_t CurrentNtpTimeMs(PeerPtr* peer_ptr);
 
 #ifdef __cplusplus
 }

src/pc/peer_connection.cpp

@@ -390,9 +390,9 @@ int PeerConnection::SendDataFrame(const char *data, size_t size) {
   return 0;
 }
 
-int64_t PeerConnection::CurrentTime() {
+int64_t PeerConnection::CurrentNtpTimeMs() {
   if (clock_) {
-    return clock_->CurrentTimeMs();
+    return clock_->CurrentNtpTimeMs();
   }
   return 0;
 }

src/pc/peer_connection.h

@@ -108,7 +108,7 @@ class PeerConnection {
   int SendAudioFrame(const char *data, size_t size);
   int SendDataFrame(const char *data, size_t size);
 
-  int64_t CurrentTime();
+  int64_t CurrentNtpTimeMs();
 
  private:
   int Login();

src/rtc/x_inner.cpp

@@ -149,10 +149,10 @@ int SendDataFrame(PeerPtr *peer_ptr, const char *data, size_t size) {
   return 0;
 }
 
-int64_t GetNowTime(PeerPtr *peer_ptr) {
+int64_t CurrentNtpTimeMs(PeerPtr *peer_ptr) {
   if (!peer_ptr || !peer_ptr->peer_connection) {
     LOG_ERROR("Peer connection not created");
     return -1;
   }
-  return peer_ptr->peer_connection->CurrentTime();
+  return peer_ptr->peer_connection->CurrentNtpTimeMs();
 }

src/rtp/rtp_packetizer/rtp_packetizer.h

@@ -22,7 +22,8 @@ class RtpPacketizer {
   virtual ~RtpPacketizer() = default;
 
   virtual std::vector<std::shared_ptr<RtpPacket>> Build(
-      uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) = 0;
+      uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+      bool use_rtp_packet_to_send) = 0;
 };
 
 #endif

src/rtp/rtp_packetizer/rtp_packetizer_av1.cpp

@@ -5,7 +5,8 @@ RtpPacketizerAv1::RtpPacketizerAv1(uint32_t ssrc) {}
 RtpPacketizerAv1::~RtpPacketizerAv1() {}
 
 std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerAv1::Build(
-    uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
+    uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+    bool use_rtp_packet_to_send) {
   std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
 
   return rtp_packets;

src/rtp/rtp_packetizer/rtp_packetizer_av1.h

@@ -16,7 +16,7 @@ class RtpPacketizerAv1 : public RtpPacketizer {
   virtual ~RtpPacketizerAv1();
 
   std::vector<std::shared_ptr<RtpPacket>> Build(
-      uint8_t* payload, uint32_t payload_size,
+      uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
       bool use_rtp_packet_to_send) override;
 
  private:

src/rtp/rtp_packetizer/rtp_packetizer_generic.cpp

@@ -47,7 +47,8 @@ void RtpPacketizerGeneric::AddAbsSendTimeExtension(
 }
 
 std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerGeneric::Build(
-    uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
+    uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+    bool use_rtp_packet_to_send) {
   uint32_t last_packet_size = payload_size % MAX_NALU_LEN;
   uint32_t packet_num =
       payload_size / MAX_NALU_LEN + (last_packet_size ? 1 : 0);

src/rtp/rtp_packetizer/rtp_packetizer_generic.h

@@ -16,7 +16,7 @@ class RtpPacketizerGeneric : public RtpPacketizer {
   virtual ~RtpPacketizerGeneric();
 
   std::vector<std::shared_ptr<RtpPacket>> Build(
-      uint8_t* payload, uint32_t payload_size,
+      uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
       bool use_rtp_packet_to_send) override;
 
  private:

src/rtp/rtp_packetizer/rtp_packetizer_h264.cpp

@@ -1,5 +1,7 @@
 #include "rtp_packetizer_h264.h"
 
+static int kMsToRtpTimestamp = 90;
+
 RtpPacketizerH264::RtpPacketizerH264(uint32_t ssrc)
     : version_(kRtpVersion),
       has_padding_(false),
@@ -59,16 +61,20 @@ void RtpPacketizerH264::AddAbsSendTimeExtension(
 }
 
 std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::Build(
-    uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
+    uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+    bool use_rtp_packet_to_send) {
   if (payload_size <= MAX_NALU_LEN) {
-    return BuildNalu(payload, payload_size, use_rtp_packet_to_send);
+    return BuildNalu(payload, payload_size, capture_timestamp_ms,
+                     use_rtp_packet_to_send);
   } else {
-    return BuildFua(payload, payload_size, use_rtp_packet_to_send);
+    return BuildFua(payload, payload_size, capture_timestamp_ms,
+                    use_rtp_packet_to_send);
   }
 }
 
 std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
-    uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
+    uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+    bool use_rtp_packet_to_send) {
   std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
 
   version_ = kRtpVersion;
@@ -78,9 +84,7 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
   marker_ = 1;
   payload_type_ = rtp::PAYLOAD_TYPE(payload_type_);
   sequence_number_++;
-  timestamp_ = std::chrono::duration_cast<std::chrono::microseconds>(
+  timestamp_ = kMsToRtpTimestamp * static_cast<uint32_t>(capture_timestamp_ms);
-                   std::chrono::system_clock::now().time_since_epoch())
-                   .count();
 
   if (!csrc_count_) {
   }
@@ -138,7 +142,8 @@ std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildNalu(
 }
 
 std::vector<std::shared_ptr<RtpPacket>> RtpPacketizerH264::BuildFua(
-    uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send) {
+    uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+    bool use_rtp_packet_to_send) {
   std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
 
   uint32_t last_packet_size = payload_size % MAX_NALU_LEN;

src/rtp/rtp_packetizer/rtp_packetizer_h264.h

@@ -16,14 +16,16 @@ class RtpPacketizerH264 : public RtpPacketizer {
   virtual ~RtpPacketizerH264();
 
   std::vector<std::shared_ptr<RtpPacket>> Build(
-      uint8_t* payload, uint32_t payload_size,
+      uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
       bool use_rtp_packet_to_send) override;
 
   std::vector<std::shared_ptr<RtpPacket>> BuildNalu(
-      uint8_t* payload, uint32_t payload_size, bool use_rtp_packet_to_send);
+      uint8_t* payload, uint32_t payload_size, int64_t capture_timestamp_ms,
+      bool use_rtp_packet_to_send);
 
   std::vector<std::shared_ptr<RtpPacket>> BuildFua(uint8_t* payload,
                                                    uint32_t payload_size,
+                                                   int64_t capture_timestamp_ms,
                                                    bool use_rtp_packet_to_send);
 
  private: