diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index bbe8480..0496aa8 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -33,6 +33,8 @@
 #include "api/scoped_refptr.h"
 #include "api/sequence_checker.h"
 #include "api/transport/rtp/rtp_source.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "audio/audio_send_stream.h"
 #include "audio/audio_state.h"
 #include "audio/channel_receive.h"
@@ -45,6 +47,7 @@
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/time_utils.h"
+#include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 
@@ -410,25 +413,23 @@
   return channel_receive_->GetSyncInfo();
 }
 
-bool AudioReceiveStreamImpl::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                                                    int64_t* time_ms) const {
+std::optional<Syncable::PlayoutInfo>
+AudioReceiveStreamImpl::GetPlayoutRtpTimestamp() const {
   // Called on video capture thread.
-  return channel_receive_->GetPlayoutRtpTimestamp(rtp_timestamp, time_ms);
+  return channel_receive_->GetPlayoutRtpTimestamp();
 }
 
-void AudioReceiveStreamImpl::SetEstimatedPlayoutNtpTimestampMs(
-    int64_t ntp_timestamp_ms,
-    int64_t time_ms) {
+void AudioReceiveStreamImpl::SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                                             Timestamp time) {
   // Called on video capture thread.
-  channel_receive_->SetEstimatedPlayoutNtpTimestampMs(ntp_timestamp_ms,
-                                                      time_ms);
+  channel_receive_->SetEstimatedPlayoutNtpTimestamp(ntp_time, time);
 }
 
-bool AudioReceiveStreamImpl::SetMinimumPlayoutDelay(int delay_ms) {
+bool AudioReceiveStreamImpl::SetMinimumPlayoutDelay(TimeDelta delay) {
   // TODO(bugs.webrtc.org/11993): This is called via RtpStreamsSynchronizer,
   // expect to be called on the network thread.
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  return channel_receive_->SetMinimumPlayoutDelay(delay_ms);
+  return channel_receive_->SetMinimumPlayoutDelay(delay);
 }
 
 void AudioReceiveStreamImpl::DeliverRtcp(ArrayView<const uint8_t> packet) {
diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h
index 0d78482..4b6c57b 100644
--- a/audio/audio_receive_stream.h
+++ b/audio/audio_receive_stream.h
@@ -32,12 +32,15 @@
 #include "api/scoped_refptr.h"
 #include "api/sequence_checker.h"
 #include "api/transport/rtp/rtp_source.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "audio/audio_state.h"
 #include "call/audio_receive_stream.h"
 #include "call/audio_state.h"
 #include "call/syncable.h"
 #include "rtc_base/system/no_unique_address.h"
 #include "rtc_base/thread_annotations.h"
+#include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 class PacketRouter;
@@ -118,11 +121,10 @@
   // Syncable
   uint32_t id() const override;
   std::optional<Syncable::Info> GetInfo() const override;
-  bool GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                              int64_t* time_ms) const override;
-  void SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                         int64_t time_ms) override;
-  bool SetMinimumPlayoutDelay(int delay_ms) override;
+  std::optional<Syncable::PlayoutInfo> GetPlayoutRtpTimestamp() const override;
+  void SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                       Timestamp time) override;
+  bool SetMinimumPlayoutDelay(TimeDelta delay) override;
 
   void DeliverRtcp(ArrayView<const uint8_t> packet);
 
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index 658266e..b98ac8e 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -72,7 +72,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
-#include "rtc_base/numerics/safe_minmax.h"
 #include "rtc_base/numerics/sequence_number_unwrapper.h"
 #include "rtc_base/race_checker.h"
 #include "rtc_base/strings/string_builder.h"
@@ -92,8 +91,8 @@
 constexpr double kAudioSampleDurationSeconds = 0.01;
 
 // Video Sync.
-constexpr int kVoiceEngineMinMinPlayoutDelayMs = 0;
-constexpr int kVoiceEngineMaxMinPlayoutDelayMs = 10000;
+constexpr TimeDelta kVoiceEngineMinMinPlayoutDelay = TimeDelta::Zero();
+constexpr TimeDelta kVoiceEngineMaxMinPlayoutDelay = TimeDelta::Seconds(10);
 
 std::unique_ptr<NetEq> CreateNetEq(
     NetEqFactory* neteq_factory,
@@ -169,11 +168,10 @@
 
   // Audio+Video Sync.
   uint32_t GetDelayEstimate() const override;
-  bool SetMinimumPlayoutDelay(int delay_ms) override;
-  bool GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                              int64_t* time_ms) const override;
-  void SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                         int64_t time_ms) override;
+  bool SetMinimumPlayoutDelay(TimeDelta delay) override;
+  std::optional<Syncable::PlayoutInfo> GetPlayoutRtpTimestamp() const override;
+  void SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                       Timestamp time) override;
   std::optional<int64_t> GetCurrentEstimatedPlayoutNtpTimestampMs(
       int64_t now_ms) const override;
 
@@ -221,7 +219,7 @@
                      const RTPHeader& header,
                      Timestamp receive_time) RTC_RUN_ON(worker_thread_checker_);
   int ResendPackets(const uint16_t* sequence_numbers, int length);
-  void UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms)
+  void UpdatePlayoutTimestamp(bool rtcp, Timestamp now)
       RTC_RUN_ON(worker_thread_checker_);
 
   int GetRtpTimestampRateHz() const;
@@ -266,7 +264,7 @@
 
   std::optional<uint32_t> last_received_rtp_timestamp_
       RTC_GUARDED_BY(&worker_thread_checker_);
-  std::optional<int64_t> last_received_rtp_system_time_ms_
+  std::optional<Timestamp> last_received_rtp_system_time_
       RTC_GUARDED_BY(&worker_thread_checker_);
 
   const std::unique_ptr<NetEq> neteq_;  // NetEq is thread-safe; no lock needed.
@@ -281,13 +279,12 @@
   // Timestamp of the audio pulled from NetEq.
   std::optional<uint32_t> jitter_buffer_playout_timestamp_;
 
-  uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(worker_thread_checker_);
-  std::optional<int64_t> playout_timestamp_rtp_time_ms_
+  std::optional<Syncable::PlayoutInfo> playout_timestamp_
       RTC_GUARDED_BY(worker_thread_checker_);
   uint32_t playout_delay_ms_ RTC_GUARDED_BY(worker_thread_checker_);
-  std::optional<int64_t> playout_timestamp_ntp_
+  std::optional<NtpTime> playout_timestamp_ntp_
       RTC_GUARDED_BY(worker_thread_checker_);
-  std::optional<int64_t> playout_timestamp_ntp_time_ms_
+  std::optional<Timestamp> playout_timestamp_ntp_time_
       RTC_GUARDED_BY(worker_thread_checker_);
 
   mutable Mutex ts_stats_lock_;
@@ -579,7 +576,6 @@
                          decoder_factory)),
       _outputAudioLevel(),
       ntp_estimator_(&env_.clock()),
-      playout_timestamp_rtp_(0),
       playout_delay_ms_(0),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
@@ -662,13 +658,13 @@
 
 void ChannelReceive::OnRtpPacket(const RtpPacketReceived& packet) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  int64_t now_ms = TimeMillis();
+  Timestamp now = Timestamp::Millis(TimeMillis());
 
   last_received_rtp_timestamp_ = packet.Timestamp();
-  last_received_rtp_system_time_ms_ = now_ms;
+  last_received_rtp_system_time_ = now;
 
   // Store playout timestamp for the received RTP packet
-  UpdatePlayoutTimestamp(false, now_ms);
+  UpdatePlayoutTimestamp(false, now);
 
   const auto& it = payload_type_frequencies_.find(packet.PayloadType());
   if (it == payload_type_frequencies_.end())
@@ -759,7 +755,7 @@
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
 
   // Store playout timestamp for the received RTCP packet
-  UpdatePlayoutTimestamp(true, TimeMillis());
+  UpdatePlayoutTimestamp(true, Timestamp::Millis(TimeMillis()));
 
   // Deliver RTCP packet to RTP/RTCP module for parsing
   rtp_rtcp_->IncomingRtcpPacket(MakeArrayView(data, length));
@@ -1046,46 +1042,41 @@
   return neteq_->FilteredCurrentDelayMs() + playout_delay_ms_;
 }
 
-bool ChannelReceive::SetMinimumPlayoutDelay(int delay_ms) {
+bool ChannelReceive::SetMinimumPlayoutDelay(TimeDelta delay) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   // Limit to range accepted by both VoE and ACM, so we're at least getting as
   // close as possible, instead of failing.
-  delay_ms = SafeClamp(delay_ms, kVoiceEngineMinMinPlayoutDelayMs,
-                       kVoiceEngineMaxMinPlayoutDelayMs);
-  if (!neteq_->SetMinimumDelay(delay_ms)) {
+  delay = std::clamp(delay, kVoiceEngineMinMinPlayoutDelay,
+                     kVoiceEngineMaxMinPlayoutDelay);
+  if (!neteq_->SetMinimumDelay(delay.ms())) {
     RTC_DLOG(LS_ERROR)
-        << "SetMinimumPlayoutDelay() failed to set min playout delay "
-        << delay_ms;
+        << "SetMinimumPlayoutDelay() failed to set min playout delay " << delay;
     return false;
   }
   return true;
 }
 
-bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                                            int64_t* time_ms) const {
+std::optional<Syncable::PlayoutInfo> ChannelReceive::GetPlayoutRtpTimestamp()
+    const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  if (!playout_timestamp_rtp_time_ms_)
-    return false;
-  *rtp_timestamp = playout_timestamp_rtp_;
-  *time_ms = playout_timestamp_rtp_time_ms_.value();
-  return true;
+  return playout_timestamp_;
 }
 
-void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                                       int64_t time_ms) {
+void ChannelReceive::SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                                     Timestamp time) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  playout_timestamp_ntp_ = ntp_timestamp_ms;
-  playout_timestamp_ntp_time_ms_ = time_ms;
+  playout_timestamp_ntp_ = ntp_time;
+  playout_timestamp_ntp_time_ = time;
 }
 
 std::optional<int64_t> ChannelReceive::GetCurrentEstimatedPlayoutNtpTimestampMs(
     int64_t now_ms) const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  if (!playout_timestamp_ntp_ || !playout_timestamp_ntp_time_ms_)
+  if (!playout_timestamp_ntp_ || !playout_timestamp_ntp_time_)
     return std::nullopt;
 
-  int64_t elapsed_ms = now_ms - *playout_timestamp_ntp_time_ms_;
-  return *playout_timestamp_ntp_ + elapsed_ms;
+  int64_t elapsed_ms = now_ms - playout_timestamp_ntp_time_->ms();
+  return playout_timestamp_ntp_->ToMs() + elapsed_ms;
 }
 
 bool ChannelReceive::SetBaseMinimumPlayoutDelayMs(int delay_ms) {
@@ -1106,23 +1097,23 @@
   if (!last_sr.has_value()) {
     return std::nullopt;
   }
-  info.capture_time_ntp_secs = last_sr->last_remote_ntp_timestamp.seconds();
-  info.capture_time_ntp_frac = last_sr->last_remote_ntp_timestamp.fractions();
-  info.capture_time_source_clock = last_sr->last_remote_rtp_timestamp;
+  info.capture_time_ntp = last_sr->last_remote_ntp_timestamp;
+  info.capture_time_rtp = last_sr->last_remote_rtp_timestamp;
 
-  if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
+  if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_) {
     return std::nullopt;
   }
-  info.latest_received_capture_timestamp = *last_received_rtp_timestamp_;
-  info.latest_receive_time_ms = *last_received_rtp_system_time_ms_;
+  info.latest_received_capture_rtp_timestamp = *last_received_rtp_timestamp_;
+  info.latest_receive_time = *last_received_rtp_system_time_;
 
   int jitter_buffer_delay = neteq_->FilteredCurrentDelayMs();
-  info.current_delay_ms = jitter_buffer_delay + playout_delay_ms_;
+  info.current_delay =
+      TimeDelta::Millis(jitter_buffer_delay + playout_delay_ms_);
 
   return info;
 }
 
-void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
+void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, Timestamp now) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
 
   jitter_buffer_playout_timestamp_ = neteq_->GetPlayoutTimestamp();
@@ -1147,9 +1138,9 @@
   // Remove the playout delay.
   playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
 
-  if (!rtcp && playout_timestamp != playout_timestamp_rtp_) {
-    playout_timestamp_rtp_ = playout_timestamp;
-    playout_timestamp_rtp_time_ms_ = now_ms;
+  if (!rtcp && (!playout_timestamp_.has_value() ||
+                playout_timestamp_->rtp_timestamp != playout_timestamp)) {
+    playout_timestamp_ = {{.time = now, .rtp_timestamp = playout_timestamp}};
   }
   playout_delay_ms_ = delay_ms;
 }
diff --git a/audio/channel_receive.h b/audio/channel_receive.h
index 0783363..7eb8639 100644
--- a/audio/channel_receive.h
+++ b/audio/channel_receive.h
@@ -39,6 +39,7 @@
 #include "call/rtp_packet_sink_interface.h"
 #include "call/syncable.h"
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
+#include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 
@@ -123,11 +124,11 @@
 
   // Audio+Video Sync.
   virtual uint32_t GetDelayEstimate() const = 0;
-  virtual bool SetMinimumPlayoutDelay(int delay_ms) = 0;
-  virtual bool GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                                      int64_t* time_ms) const = 0;
-  virtual void SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                                 int64_t time_ms) = 0;
+  virtual bool SetMinimumPlayoutDelay(TimeDelta delay) = 0;
+  virtual std::optional<Syncable::PlayoutInfo> GetPlayoutRtpTimestamp()
+      const = 0;
+  virtual void SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                               Timestamp time) = 0;
   virtual std::optional<int64_t> GetCurrentEstimatedPlayoutNtpTimestampMs(
       int64_t now_ms) const = 0;
 
diff --git a/audio/mock_voe_channel_proxy.h b/audio/mock_voe_channel_proxy.h
index cd2927d..7818a36 100644
--- a/audio/mock_voe_channel_proxy.h
+++ b/audio/mock_voe_channel_proxy.h
@@ -35,6 +35,8 @@
 #include "api/scoped_refptr.h"
 #include "api/transport/rtp/rtp_source.h"
 #include "api/units/data_rate.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "audio/channel_receive.h"
 #include "audio/channel_send.h"
 #include "call/syncable.h"
@@ -42,6 +44,7 @@
 #include "modules/rtp_rtcp/include/report_block_data.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
+#include "system_wrappers/include/ntp_time.h"
 #include "test/gmock.h"
 
 namespace webrtc {
@@ -83,13 +86,13 @@
               (override));
   MOCK_METHOD(int, PreferredSampleRate, (), (const, override));
   MOCK_METHOD(std::vector<RtpSource>, GetSources, (), (const, override));
-  MOCK_METHOD(bool,
+  MOCK_METHOD(std::optional<Syncable::PlayoutInfo>,
               GetPlayoutRtpTimestamp,
-              (uint32_t*, int64_t*),
+              (),
               (const, override));
   MOCK_METHOD(void,
-              SetEstimatedPlayoutNtpTimestampMs,
-              (int64_t ntp_timestamp_ms, int64_t time_ms),
+              SetEstimatedPlayoutNtpTimestamp,
+              (NtpTime ntp_time, Timestamp time),
               (override));
   MOCK_METHOD(std::optional<int64_t>,
               GetCurrentEstimatedPlayoutNtpTimestampMs,
@@ -99,7 +102,7 @@
               GetSyncInfo,
               (),
               (const, override));
-  MOCK_METHOD(bool, SetMinimumPlayoutDelay, (int delay_ms), (override));
+  MOCK_METHOD(bool, SetMinimumPlayoutDelay, (TimeDelta delay), (override));
   MOCK_METHOD(bool, SetBaseMinimumPlayoutDelayMs, (int delay_ms), (override));
   MOCK_METHOD(int, GetBaseMinimumPlayoutDelayMs, (), (const, override));
   MOCK_METHOD((std::optional<std::pair<int, SdpAudioFormat>>),
diff --git a/call/BUILD.gn b/call/BUILD.gn
index 3f5c615..d3504a3 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -77,6 +77,7 @@
     "../rtc_base:copy_on_write_buffer",
     "../rtc_base:stringutils",
     "../rtc_base/network:sent_packet",
+    "../system_wrappers",
     "../video/config:encoder_config",
     "//third_party/abseil-cpp/absl/functional:any_invocable",
     "//third_party/abseil-cpp/absl/strings",
diff --git a/call/syncable.h b/call/syncable.h
index 09c0f22..b6cff19 100644
--- a/call/syncable.h
+++ b/call/syncable.h
@@ -14,32 +14,45 @@
 #ifndef CALL_SYNCABLE_H_
 #define CALL_SYNCABLE_H_
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <optional>
 
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
+#include "system_wrappers/include/ntp_time.h"
+
 namespace webrtc {
 
 class Syncable {
  public:
   struct Info {
-    int64_t latest_receive_time_ms = 0;
-    uint32_t latest_received_capture_timestamp = 0;
-    uint32_t capture_time_ntp_secs = 0;
-    uint32_t capture_time_ntp_frac = 0;
-    uint32_t capture_time_source_clock = 0;
-    int current_delay_ms = 0;
+    // Local time when the the last RTP packet was received.
+    Timestamp latest_receive_time = Timestamp::Zero();
+    // RTP timestamp of the last RTP packet received.
+    uint32_t latest_received_capture_rtp_timestamp = 0;
+
+    // NTP and RTP timestamp from the last RTCP sender report received.
+    uint32_t capture_time_rtp = 0;
+    NtpTime capture_time_ntp;
+
+    // Current playout delay for the given `Syncable`.
+    TimeDelta current_delay;
+  };
+
+  // Mapping between capture/render time in RTP timestamps and local clock.
+  struct PlayoutInfo {
+    Timestamp time;
+    uint32_t rtp_timestamp;
   };
 
   virtual ~Syncable();
 
   virtual uint32_t id() const = 0;
   virtual std::optional<Info> GetInfo() const = 0;
-  virtual bool GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                                      int64_t* time_ms) const = 0;
-  virtual bool SetMinimumPlayoutDelay(int delay_ms) = 0;
-  virtual void SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                                 int64_t time_ms) = 0;
+  virtual std::optional<PlayoutInfo> GetPlayoutRtpTimestamp() const = 0;
+  virtual bool SetMinimumPlayoutDelay(TimeDelta delay) = 0;
+  virtual void SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                               Timestamp time) = 0;
 };
 }  // namespace webrtc
 
diff --git a/video/rtp_streams_synchronizer2.cc b/video/rtp_streams_synchronizer2.cc
index f3c3875..2019ec3 100644
--- a/video/rtp_streams_synchronizer2.cc
+++ b/video/rtp_streams_synchronizer2.cc
@@ -16,6 +16,7 @@
 #include "api/sequence_checker.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "call/syncable.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
@@ -35,11 +36,10 @@
 
 bool UpdateMeasurements(StreamSynchronization::Measurements* stream,
                         const Syncable::Info& info) {
-  stream->latest_timestamp = info.latest_received_capture_timestamp;
-  stream->latest_receive_time_ms = info.latest_receive_time_ms;
-  return stream->rtp_to_ntp.UpdateMeasurements(
-             NtpTime(info.capture_time_ntp_secs, info.capture_time_ntp_frac),
-             info.capture_time_source_clock) !=
+  stream->latest_timestamp = info.latest_received_capture_rtp_timestamp;
+  stream->latest_receive_time_ms = info.latest_receive_time.ms();
+  return stream->rtp_to_ntp.UpdateMeasurements(info.capture_time_ntp,
+                                               info.capture_time_rtp) !=
          RtpToNtpEstimator::kInvalidMeasurement;
 }
 
@@ -133,23 +133,23 @@
   if (log_stats) {
     RTC_LOG(LS_INFO) << "Sync info stats: " << now_ms
                      << ", {ssrc: " << sync_->audio_stream_id() << ", "
-                     << "cur_delay_ms: " << audio_info->current_delay_ms
+                     << "cur_delay: " << audio_info->current_delay
                      << "} {ssrc: " << sync_->video_stream_id() << ", "
-                     << "cur_delay_ms: " << video_info->current_delay_ms
+                     << "cur_delay: " << video_info->current_delay
                      << "} {relative_delay_ms: " << relative_delay_ms << "} ";
   }
 
   TRACE_COUNTER1("webrtc", "SyncCurrentVideoDelay",
-                 video_info->current_delay_ms);
+                 video_info->current_delay.ms());
   TRACE_COUNTER1("webrtc", "SyncCurrentAudioDelay",
-                 audio_info->current_delay_ms);
+                 audio_info->current_delay.ms());
   TRACE_COUNTER1("webrtc", "SyncRelativeDelay", relative_delay_ms);
 
   int target_audio_delay_ms = 0;
-  int target_video_delay_ms = video_info->current_delay_ms;
+  int target_video_delay_ms = video_info->current_delay.ms();
   // Calculate the necessary extra audio delay and desired total video
   // delay to get the streams in sync.
-  if (!sync_->ComputeDelays(relative_delay_ms, audio_info->current_delay_ms,
+  if (!sync_->ComputeDelays(relative_delay_ms, audio_info->current_delay.ms(),
                             &target_audio_delay_ms, &target_video_delay_ms)) {
     return;
   }
@@ -162,10 +162,12 @@
                      << "target_delay_ms: " << target_video_delay_ms << "} ";
   }
 
-  if (!syncable_audio_->SetMinimumPlayoutDelay(target_audio_delay_ms)) {
+  if (!syncable_audio_->SetMinimumPlayoutDelay(
+          TimeDelta::Millis(target_audio_delay_ms))) {
     sync_->ReduceAudioDelay();
   }
-  if (!syncable_video_->SetMinimumPlayoutDelay(target_video_delay_ms)) {
+  if (!syncable_video_->SetMinimumPlayoutDelay(
+          TimeDelta::Millis(target_video_delay_ms))) {
     sync_->ReduceVideoDelay();
   }
 }
@@ -184,22 +186,21 @@
   if (!syncable_audio_)
     return false;
 
-  uint32_t audio_rtp_timestamp;
-  int64_t time_ms;
-  if (!syncable_audio_->GetPlayoutRtpTimestamp(&audio_rtp_timestamp,
-                                               &time_ms)) {
+  std::optional<Syncable::PlayoutInfo> audio =
+      syncable_audio_->GetPlayoutRtpTimestamp();
+  if (!audio.has_value()) {
     return false;
   }
 
   NtpTime latest_audio_ntp =
-      audio_measurement_.rtp_to_ntp.Estimate(audio_rtp_timestamp);
+      audio_measurement_.rtp_to_ntp.Estimate(audio->rtp_timestamp);
   if (!latest_audio_ntp.Valid()) {
     return false;
   }
   int64_t latest_audio_ntp_ms = latest_audio_ntp.ToMs();
 
-  syncable_audio_->SetEstimatedPlayoutNtpTimestampMs(latest_audio_ntp_ms,
-                                                     time_ms);
+  syncable_audio_->SetEstimatedPlayoutNtpTimestamp(latest_audio_ntp,
+                                                   audio->time);
 
   NtpTime latest_video_ntp =
       video_measurement_.rtp_to_ntp.Estimate(rtp_timestamp);
@@ -209,13 +210,14 @@
   int64_t latest_video_ntp_ms = latest_video_ntp.ToMs();
 
   // Current audio ntp.
-  int64_t now_ms = TimeMillis();
-  latest_audio_ntp_ms += (now_ms - time_ms);
+  Timestamp now = Timestamp::Millis(TimeMillis());
+  latest_audio_ntp_ms += (now - audio->time).ms();
 
   // Remove video playout delay.
-  int64_t time_to_render_ms = render_time_ms - now_ms;
-  if (time_to_render_ms > 0)
+  int64_t time_to_render_ms = render_time_ms - now.ms();
+  if (time_to_render_ms > 0) {
     latest_video_ntp_ms -= time_to_render_ms;
+  }
 
   *video_playout_ntp_ms = latest_video_ntp_ms;
   *stream_offset_ms = latest_audio_ntp_ms - latest_video_ntp_ms;
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index 804fff8..ef79a69 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -426,15 +426,14 @@
   if (!last_sr.has_value()) {
     return std::nullopt;
   }
-  info.capture_time_ntp_secs = last_sr->last_remote_ntp_timestamp.seconds();
-  info.capture_time_ntp_frac = last_sr->last_remote_ntp_timestamp.fractions();
-  info.capture_time_source_clock = last_sr->last_remote_rtp_timestamp;
+  info.capture_time_ntp = last_sr->last_remote_ntp_timestamp;
+  info.capture_time_rtp = last_sr->last_remote_rtp_timestamp;
 
   if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_) {
     return std::nullopt;
   }
-  info.latest_received_capture_timestamp = *last_received_rtp_timestamp_;
-  info.latest_receive_time_ms = last_received_rtp_system_time_->ms();
+  info.latest_received_capture_rtp_timestamp = *last_received_rtp_timestamp_;
+  info.latest_receive_time = *last_received_rtp_system_time_;
 
   // Leaves info.current_delay_ms uninitialized.
   return info;
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index 6c3ebfa..5df80d0 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -84,6 +84,7 @@
 #include "rtc_base/time_utils.h"
 #include "rtc_base/trace_event.h"
 #include "system_wrappers/include/clock.h"
+#include "system_wrappers/include/ntp_time.h"
 #include "video/call_stats2.h"
 #include "video/corruption_detection/frame_instrumentation_evaluation.h"
 #include "video/decode_synchronizer.h"
@@ -790,25 +791,24 @@
   if (!info)
     return std::nullopt;
 
-  info->current_delay_ms = timing_->TargetVideoDelay().ms();
+  info->current_delay = timing_->TargetVideoDelay();
   return info;
 }
 
-bool VideoReceiveStream2::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                                                 int64_t* time_ms) const {
+std::optional<Syncable::PlayoutInfo>
+VideoReceiveStream2::GetPlayoutRtpTimestamp() const {
   RTC_DCHECK_NOTREACHED();
-  return false;
+  return std::nullopt;
 }
 
-void VideoReceiveStream2::SetEstimatedPlayoutNtpTimestampMs(
-    int64_t ntp_timestamp_ms,
-    int64_t time_ms) {
+void VideoReceiveStream2::SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                                          Timestamp time) {
   RTC_DCHECK_NOTREACHED();
 }
 
-bool VideoReceiveStream2::SetMinimumPlayoutDelay(int delay_ms) {
+bool VideoReceiveStream2::SetMinimumPlayoutDelay(TimeDelta delay) {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-  syncable_minimum_playout_delay_ = TimeDelta::Millis(delay_ms);
+  syncable_minimum_playout_delay_ = delay;
   UpdatePlayoutDelays();
   return true;
 }
diff --git a/video/video_receive_stream2.h b/video/video_receive_stream2.h
index 9ac106f..a00d8cb 100644
--- a/video/video_receive_stream2.h
+++ b/video/video_receive_stream2.h
@@ -50,6 +50,7 @@
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/system/no_unique_address.h"
 #include "rtc_base/thread_annotations.h"
+#include "system_wrappers/include/ntp_time.h"
 #include "video/corruption_detection/frame_instrumentation_evaluation.h"
 #include "video/decode_synchronizer.h"
 #include "video/receive_statistics_proxy.h"
@@ -195,13 +196,12 @@
   // Implements Syncable.
   uint32_t id() const override;
   std::optional<Syncable::Info> GetInfo() const override;
-  bool GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
-                              int64_t* time_ms) const override;
-  void SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
-                                         int64_t time_ms) override;
+  std::optional<Syncable::PlayoutInfo> GetPlayoutRtpTimestamp() const override;
+  void SetEstimatedPlayoutNtpTimestamp(NtpTime ntp_time,
+                                       Timestamp time) override;
 
   // SetMinimumPlayoutDelay is only called by A/V sync.
-  bool SetMinimumPlayoutDelay(int delay_ms) override;
+  bool SetMinimumPlayoutDelay(TimeDelta delay) override;
 
   std::vector<webrtc::RtpSource> GetSources() const override;
 
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index ec7f76e..ca8772b 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -327,7 +327,7 @@
   EXPECT_EQ(kPlayoutDelay.max(), timings.max_playout_delay);
 
   // Check that the biggest minimum delay is chosen.
-  video_receive_stream_->SetMinimumPlayoutDelay(400);
+  video_receive_stream_->SetMinimumPlayoutDelay(TimeDelta::Millis(400));
   timings = timing_->GetTimings();
   EXPECT_EQ(400, timings.min_playout_delay.ms());
 
@@ -344,7 +344,7 @@
   timings = timing_->GetTimings();
   EXPECT_EQ(400, timings.min_playout_delay.ms());
 
-  video_receive_stream_->SetMinimumPlayoutDelay(0);
+  video_receive_stream_->SetMinimumPlayoutDelay(TimeDelta::Zero());
   timings = timing_->GetTimings();
   EXPECT_EQ(123, timings.min_playout_delay.ms());
 }
@@ -360,7 +360,7 @@
   EXPECT_EQ(timing_->GetTimings().min_playout_delay, kPlayoutDelay.min());
 
   // Check that the biggest minimum delay is limited by the max playout delay.
-  video_receive_stream_->SetMinimumPlayoutDelay(400);
+  video_receive_stream_->SetMinimumPlayoutDelay(TimeDelta::Millis(400));
   EXPECT_EQ(timing_->GetTimings().min_playout_delay, kPlayoutDelay.max());
 }