1 files changed, 32 insertions, 35 deletions

diff --git a/modules/rtp_rtcp/source/absolute_capture_time_sender.cc b/modules/rtp_rtcp/source/absolute_capture_time_sender.cc
index 28266769ff..09f61a0ace 100644
--- a/modules/rtp_rtcp/source/absolute_capture_time_sender.cc
+++ b/modules/rtp_rtcp/source/absolute_capture_time_sender.cc
@@ -16,14 +16,6 @@
 #include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
-namespace {
-
-constexpr Timestamp kInvalidLastSendTime = Timestamp::MinusInfinity();
-
-}  // namespace
-
-constexpr TimeDelta AbsoluteCaptureTimeSender::kInterpolationMaxInterval;
-constexpr TimeDelta AbsoluteCaptureTimeSender::kInterpolationMaxError;
 
 static_assert(
     AbsoluteCaptureTimeInterpolator::kInterpolationMaxInterval >=
@@ -31,7 +23,7 @@ static_assert(
     "Receivers should be as willing to interpolate timestamps as senders.");
 
 AbsoluteCaptureTimeSender::AbsoluteCaptureTimeSender(Clock* clock)
-    : clock_(clock), last_send_time_(kInvalidLastSendTime) {}
+    : clock_(clock) {}
 
 uint32_t AbsoluteCaptureTimeSender::GetSource(
     uint32_t ssrc,
@@ -45,44 +37,48 @@ absl::optional<AbsoluteCaptureTime> AbsoluteCaptureTimeSender::OnSendPacket(
     uint32_t rtp_clock_frequency,
     uint64_t absolute_capture_timestamp,
     absl::optional<int64_t> estimated_capture_clock_offset) {
-  const Timestamp send_time = clock_->CurrentTime();
-
-  MutexLock lock(&mutex_);
+  return OnSendPacket(source, rtp_timestamp, rtp_clock_frequency,
+                      NtpTime(absolute_capture_timestamp),
+                      estimated_capture_clock_offset, /*force=*/false);
+}
 
-  if (!ShouldSendExtension(send_time, source, rtp_timestamp,
-                           rtp_clock_frequency, absolute_capture_timestamp,
-                           estimated_capture_clock_offset)) {
+absl::optional<AbsoluteCaptureTime> AbsoluteCaptureTimeSender::OnSendPacket(
+    uint32_t source,
+    uint32_t rtp_timestamp,
+    int rtp_clock_frequency_hz,
+    NtpTime absolute_capture_time,
+    absl::optional<int64_t> estimated_capture_clock_offset,
+    bool force) {
+  Timestamp send_time = clock_->CurrentTime();
+  if (!(force || ShouldSendExtension(
+                     send_time, source, rtp_timestamp, rtp_clock_frequency_hz,
+                     absolute_capture_time, estimated_capture_clock_offset))) {
     return absl::nullopt;
   }
 
   last_source_ = source;
   last_rtp_timestamp_ = rtp_timestamp;
-  last_rtp_clock_frequency_ = rtp_clock_frequency;
-  last_absolute_capture_timestamp_ = absolute_capture_timestamp;
+  last_rtp_clock_frequency_hz_ = rtp_clock_frequency_hz;
+  last_absolute_capture_time_ = absolute_capture_time;
   last_estimated_capture_clock_offset_ = estimated_capture_clock_offset;
-
   last_send_time_ = send_time;
 
-  AbsoluteCaptureTime extension;
-  extension.absolute_capture_timestamp = absolute_capture_timestamp;
-  extension.estimated_capture_clock_offset = estimated_capture_clock_offset;
-  return extension;
+  return AbsoluteCaptureTime{
+      .absolute_capture_timestamp = uint64_t{absolute_capture_time},
+      .estimated_capture_clock_offset = estimated_capture_clock_offset,
+  };
 }
 
 bool AbsoluteCaptureTimeSender::ShouldSendExtension(
     Timestamp send_time,
     uint32_t source,
     uint32_t rtp_timestamp,
-    uint32_t rtp_clock_frequency,
-    uint64_t absolute_capture_timestamp,
+    int rtp_clock_frequency_hz,
+    NtpTime absolute_capture_time,
     absl::optional<int64_t> estimated_capture_clock_offset) const {
-  // Should if we've never sent anything before.
-  if (last_send_time_ == kInvalidLastSendTime) {
-    return true;
-  }
-
-  // Should if the last sent extension is too old.
-  if ((send_time - last_send_time_) > kInterpolationMaxInterval) {
+  // Should if the last sent extension is too old, in particular if we've never
+  // sent anything before.
+  if (send_time - last_send_time_ > kInterpolationMaxInterval) {
     return true;
   }
 
@@ -92,12 +88,12 @@ bool AbsoluteCaptureTimeSender::ShouldSendExtension(
   }
 
   // Should if the RTP clock frequency has changed.
-  if (last_rtp_clock_frequency_ != rtp_clock_frequency) {
+  if (last_rtp_clock_frequency_hz_ != rtp_clock_frequency_hz) {
     return true;
   }
 
   // Should if the RTP clock frequency is invalid.
-  if (rtp_clock_frequency <= 0) {
+  if (rtp_clock_frequency_hz <= 0) {
     return true;
   }
 
@@ -109,8 +105,9 @@ bool AbsoluteCaptureTimeSender::ShouldSendExtension(
   // Should if interpolation would introduce too much error.
   const uint64_t interpolated_absolute_capture_timestamp =
       AbsoluteCaptureTimeInterpolator::InterpolateAbsoluteCaptureTimestamp(
-          rtp_timestamp, rtp_clock_frequency, last_rtp_timestamp_,
-          last_absolute_capture_timestamp_);
+          rtp_timestamp, rtp_clock_frequency_hz, last_rtp_timestamp_,
+          uint64_t{last_absolute_capture_time_});
+  const uint64_t absolute_capture_timestamp = uint64_t{absolute_capture_time};
   const int64_t interpolation_error_ms = UQ32x32ToInt64Ms(std::min(
       interpolated_absolute_capture_timestamp - absolute_capture_timestamp,
       absolute_capture_timestamp - interpolated_absolute_capture_timestamp));