1 files changed, 8 insertions, 117 deletions

diff --git a/modules/rtp_rtcp/source/absolute_capture_time_receiver.cc b/modules/rtp_rtcp/source/absolute_capture_time_receiver.cc
index 529ed7eef6..efb75506d0 100644
--- a/modules/rtp_rtcp/source/absolute_capture_time_receiver.cc
+++ b/modules/rtp_rtcp/source/absolute_capture_time_receiver.cc
@@ -10,38 +10,14 @@
 
 #include "modules/rtp_rtcp/source/absolute_capture_time_receiver.h"
 
-#include <limits>
-
-#include "rtc_base/checks.h"
-
 namespace webrtc {
-namespace {
-
-constexpr Timestamp kInvalidLastReceiveTime = Timestamp::MinusInfinity();
-}  // namespace
-
-constexpr TimeDelta AbsoluteCaptureTimeReceiver::kInterpolationMaxInterval;
 
 AbsoluteCaptureTimeReceiver::AbsoluteCaptureTimeReceiver(Clock* clock)
-    : clock_(clock),
-      remote_to_local_clock_offset_(absl::nullopt),
-      last_receive_time_(kInvalidLastReceiveTime) {}
-
-uint32_t AbsoluteCaptureTimeReceiver::GetSource(
-    uint32_t ssrc,
-    rtc::ArrayView<const uint32_t> csrcs) {
-  if (csrcs.empty()) {
-    return ssrc;
-  }
-
-  return csrcs[0];
-}
+    : AbsoluteCaptureTimeInterpolator(clock) {}
 
 void AbsoluteCaptureTimeReceiver::SetRemoteToLocalClockOffset(
     absl::optional<int64_t> value_q32x32) {
-  MutexLock lock(&mutex_);
-
-  remote_to_local_clock_offset_ = value_q32x32;
+  capture_clock_offset_updater_.SetRemoteToLocalClockOffset(value_q32x32);
 }
 
 absl::optional<AbsoluteCaptureTime>
@@ -50,101 +26,16 @@ AbsoluteCaptureTimeReceiver::OnReceivePacket(
     uint32_t rtp_timestamp,
     uint32_t rtp_clock_frequency,
     const absl::optional<AbsoluteCaptureTime>& received_extension) {
-  const Timestamp receive_time = clock_->CurrentTime();
-
-  MutexLock lock(&mutex_);
+  auto extension = AbsoluteCaptureTimeInterpolator::OnReceivePacket(
+      source, rtp_timestamp, rtp_clock_frequency, received_extension);
 
-  AbsoluteCaptureTime extension;
-  if (received_extension == absl::nullopt) {
-    if (!ShouldInterpolateExtension(receive_time, source, rtp_timestamp,
-                                    rtp_clock_frequency)) {
-      last_receive_time_ = kInvalidLastReceiveTime;
-      return absl::nullopt;
-    }
-
-    extension.absolute_capture_timestamp = InterpolateAbsoluteCaptureTimestamp(
-        rtp_timestamp, rtp_clock_frequency, last_rtp_timestamp_,
-        last_absolute_capture_timestamp_);
-    extension.estimated_capture_clock_offset =
-        last_estimated_capture_clock_offset_;
-  } else {
-    last_source_ = source;
-    last_rtp_timestamp_ = rtp_timestamp;
-    last_rtp_clock_frequency_ = rtp_clock_frequency;
-    last_absolute_capture_timestamp_ =
-        received_extension->absolute_capture_timestamp;
-    last_estimated_capture_clock_offset_ =
-        received_extension->estimated_capture_clock_offset;
-
-    last_receive_time_ = receive_time;
-
-    extension = *received_extension;
+  if (extension.has_value()) {
+    extension->estimated_capture_clock_offset =
+        capture_clock_offset_updater_.AdjustEstimatedCaptureClockOffset(
+            extension->estimated_capture_clock_offset);
   }
 
-  extension.estimated_capture_clock_offset = AdjustEstimatedCaptureClockOffset(
-      extension.estimated_capture_clock_offset);
-
   return extension;
 }
 
-uint64_t AbsoluteCaptureTimeReceiver::InterpolateAbsoluteCaptureTimestamp(
-    uint32_t rtp_timestamp,
-    uint32_t rtp_clock_frequency,
-    uint32_t last_rtp_timestamp,
-    uint64_t last_absolute_capture_timestamp) {
-  RTC_DCHECK_GT(rtp_clock_frequency, 0);
-
-  return last_absolute_capture_timestamp +
-         static_cast<int64_t>(
-             rtc::dchecked_cast<uint64_t>(rtp_timestamp - last_rtp_timestamp)
-             << 32) /
-             rtp_clock_frequency;
-}
-
-bool AbsoluteCaptureTimeReceiver::ShouldInterpolateExtension(
-    Timestamp receive_time,
-    uint32_t source,
-    uint32_t rtp_timestamp,
-    uint32_t rtp_clock_frequency) const {
-  // Shouldn't if we don't have a previously received extension stored.
-  if (last_receive_time_ == kInvalidLastReceiveTime) {
-    return false;
-  }
-
-  // Shouldn't if the last received extension is too old.
-  if ((receive_time - last_receive_time_) > kInterpolationMaxInterval) {
-    return false;
-  }
-
-  // Shouldn't if the source has changed.
-  if (last_source_ != source) {
-    return false;
-  }
-
-  // Shouldn't if the RTP clock frequency has changed.
-  if (last_rtp_clock_frequency_ != rtp_clock_frequency) {
-    return false;
-  }
-
-  // Shouldn't if the RTP clock frequency is invalid.
-  if (rtp_clock_frequency <= 0) {
-    return false;
-  }
-
-  return true;
-}
-
-absl::optional<int64_t>
-AbsoluteCaptureTimeReceiver::AdjustEstimatedCaptureClockOffset(
-    absl::optional<int64_t> received_value) const {
-  if (received_value == absl::nullopt ||
-      remote_to_local_clock_offset_ == absl::nullopt) {
-    return absl::nullopt;
-  }
-
-  // Do calculations as "unsigned" to make overflows deterministic.
-  return static_cast<uint64_t>(*received_value) +
-         static_cast<uint64_t>(*remote_to_local_clock_offset_);
-}
-
 }  // namespace webrtc