[采集端] --RTP Packet(ts_rtp)--> [网络传输] --> [接收端]
                                      |
                                      v
                              [RTCP SR: NTP + RTP_ts]
                                      |
                                      v
                              [接收端解算映射关系]
                                      |
                                      v
                              [播放端渲染调度]

NTP_i  <-->  RTP_ts_i

NTP = (RTP_ts - RTP_ts_i) / clock_rate + NTP_i

NTP_est = k * RTP_ts + b

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|V=2|P|    RC   |   PT=SR=200   |             length            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         SSRC of sender                        |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|              NTP timestamp, most significant word             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|              NTP timestamp, least significant word            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         RTP timestamp                         |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                     sender's packet count                     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                      sender's octet count                     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

struct RtcpSrParser {
  bool Parse(const uint8_t* data, size_t len, SenderReport& sr) {
    if (len < kSrHeaderSize) return false;
    const uint8_t* ptr = data;
    // 版本/类型/长度校验
    if ((ptr[0] & 0xC0) != 0x80 || (ptr[1] & 0xFE) != 0xC8) return false;
    uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(ptr + 4);
    // NTP 时间戳（高32位秒 + 低32位小数）
    uint64_t ntp_sec  = ByteReader<uint32_t>::ReadBigEndian(ptr + 8);
    uint64_t ntp_frac = ByteReader<uint32_t>::ReadBigEndian(ptr + 12);
    uint32_t rtp_ts   = ByteReader<uint32_t>::ReadBigEndian(ptr + 16);
    uint32_t pkt_cnt  = ByteReader<uint32_t>::ReadBigEndian(ptr + 20);
    uint32_t oct_cnt  = ByteReader<uint32_t>::ReadBigEndian(ptr + 24);

    sr.ssrc = ssrc;
    sr.ntp_time = (ntp_sec << 32) | ntp_frac;
    sr.rtp_timestamp = rtp_ts;
    sr.packet_count = pkt_cnt;
    sr.octet_count = oct_cnt;
    return true;
  }
};

// NTP 64bit -> 双精度秒
double NtpToSeconds(uint64_t ntp) {
  const double kNtpFracPerSec = 4294967296.0; // 2^32
  uint32_t sec  = ntp >> 32;
  uint32_t frac = ntp & 0xFFFFFFFF;
  return sec + frac / kNtpFracPerSec;
}

// RTP timestamp -> 秒（以视频 90kHz 为例）
double RtpToSeconds(uint32_t rtp_ts, int clock_rate) {
  return static_cast<double>(rtp_ts) / clock_rate;
}

class AvSyncContext {
public:
  void OnRtcpSrReceived(uint32_t media_ssrc, const SenderReport& sr) {
    // 1. 存入样本池
    samples_[media_ssrc].push_back({NtpToSeconds(sr.ntp_time),
                                    RtpToSeconds(sr.rtp_timestamp, GetClockRate(media_ssrc))});
    // 2. 维护窗口大小
    if (samples_[media_ssrc].size() > kMaxSamples) samples_[media_ssrc].pop_front();
    // 3. 触发拟合更新
    UpdateMapping(media_ssrc);
  }

  // 查询某 RTP 时间戳对应的 NTP 墙钟时间
  absl::optional<double> GetNtpTime(uint32_t media_ssrc, uint32_t rtp_ts) const {
    auto it = mappings_.find(media_ssrc);
    if (it == mappings_.end()) return absl::nullopt;
    return it->second.k * rtp_ts + it->second.b;
  }
private:
  struct Mapping { double k, b; };
  std::map<uint32_t, std::deque<std::pair<double,double>>> samples_;
  std::map<uint32_t, Mapping> mappings_;
  void UpdateMapping(uint32_t ssrc) { /* 最小二乘法拟合 */ }
};

void VideoRenderer::OnFrame(const VideoFrame& frame) {
  // 1. 获取该帧 RTP 时间戳
  uint32_t rtp_ts = frame.timestamp();
  // 2. 查询映射得到目标 NTP 时间
  auto ntp_time = sync_ctx_.GetNtpTime(video_ssrc_, rtp_ts);
  if (!ntp_time) return; // 映射未建立，丢帧或缓存

  // 3. 换算为本地渲染时钟（如 std::chrono::steady_clock）
  auto render_time = ntp_clock_.ConvertNtpToLocal(*ntp_time);
  // 4. 投递定时任务或推入渲染队列
  scheduler_.ScheduleAt(render_time, [this, frame] { Render(frame); });
}

class HybridNtpClock {
public:
  int64_t NowNtp() const {
    // 1. 优先读取单调时钟（Steady Clock），无阶跃、高精度、低开销
    int64_t steady_ms = steady_clock_.NowInMs();
    // 2. 通过校准偏移量换算为 NTP 墙钟时间
    return steady_ms + ntp_offset_ms_.load(std::memory_order_relaxed);
  }

  // 后台线程低频（如 10s/次）同步系统墙钟，修正偏移量
  void PeriodicCalibrate() {
    int64_t sys_ntp_ms = SystemClock::NowNtpMs(); // 真实墙钟
    int64_t steady_ms  = steady_clock_.NowInMs();
    int64_t new_offset = sys_ntp_ms - steady_ms;
    // 平滑更新，防止单次抖动导致映射突变
    ntp_offset_ms_.store(
        (ntp_offset_ms_.load() * 7 + new_offset) / 8,
        std::memory_order_relaxed);
  }
private:
  SteadyClock steady_clock_;
  std::atomic<int64_t> ntp_offset_ms_{0};
};

// 视频轨：按帧率累加
void VideoSender::OnFrameCaptured(const VideoFrame& frame) {
  // 优先使用采集层硬件时间戳（如 V4L2 TIMESTAMP_MONOTONIC）
  if (frame.has_ntp_time_ms()) {
    rtp_timestamp_ = NtpToRtp(frame.ntp_time_ms(), kVideoClockRate);
  } else {
    rtp_timestamp_ += kFrameDurationTicks; // 90000 / fps
  }
  encoder_.Encode(frame, rtp_timestamp_);
}

// 音频轨：严格按采样点数累加（48kHz -> 480 ticks/10ms）
void AudioSender::OnData(const int16_t* data, size_t samples) {
  rtp_timestamp_ += samples; // 单位：采样点
  encoder_.Encode(data, samples, rtp_timestamp_);
}

class MultiStreamSyncManager {
  // 所有流（音频/视频/屏幕共享）共享同一 NTP 域
  struct StreamSyncCtx {
    uint32_t ssrc;
    MediaType type; // AUDIO / VIDEO / SCREEN
    AvSyncContext sync_ctx; // 复用上篇单流映射逻辑
    bool is_master_clock = false; // 仅主音频流为 true
  };

  void OnRtcpSr(uint32_t ssrc, const SenderReport& sr) {
    auto& ctx = streams_[ssrc];
    ctx.sync_ctx.OnRtcpSrReceived(ssrc, sr);
    
    // 关键：若为主音频流，同步更新“全局 NTP 基准”
    if (ctx.is_master_clock) {
      global_ntp_base_ = ctx.sync_ctx.GetLatestNtp();
    }
  }

  // 统一查询接口：任意流 RTP TS -> 全局 NTP
  absl::optional<int64_t> GetGlobalNtp(uint32_t ssrc, uint32_t rtp_ts) {
    auto it = streams_.find(ssrc);
    if (it == streams_.end()) return absl::nullopt;
    auto local_ntp = it->second.sync_ctx.GetNtpTime(ssrc, rtp_ts);
    if (!local_ntp) return absl::nullopt;
    // 校正：消除该流相对主音频流的固定偏移（首帧建立）
    return *local_ntp - it->second.fixed_offset_ms_;
  }
};

void OnFirstFrameRendered(uint32_t ssrc, int64_t render_ntp_ms) {
  auto& ctx = streams_[ssrc];
  if (!ctx.offset_calibrated) {
    // 主音频流当前渲染 NTP
    int64_t master_render_ntp = GetMasterAudioRenderNtp();
    // 计算该流相对主音频的固有管线延迟差
    ctx.fixed_offset_ms_ = render_ntp_ms - master_render_ntp;
    ctx.offset_calibrated = true;
    LOG(INFO) << "Stream " << ssrc << " fixed offset: " << ctx.fixed_offset_ms_ << "ms";
  }
}

class IPlayoutScheduler {
public:
  // 安排任务在 target_ntp_ms（NTP 毫秒）执行
  virtual TaskId ScheduleAt(int64_t target_ntp_ms, TaskCallback cb) = 0;
  virtual void Cancel(TaskId id) = 0;
  // 获取当前渲染管线“实际”时间（用于闭环校准）
  virtual int64_t GetCurrentRenderNtpMs() const = 0;
};

class Clock {
public:
  virtual ~Clock() = default;
  virtual int64_t NowNtpMs() = 0;
  virtual int64_t NowSteadyMs() = 0;
  virtual void SleepMs(int64_t ms) = 0;
};

// 生产环境实现
class RealClock : public Clock { ... };

// 测试环境实现：完全可控
class SimulatedClock : public Clock {
public:
  void AdvanceTimeMs(int64_t ms) { now_ms_ += ms; }
  int64_t NowNtpMs() override { return ntp_offset_ms_ + now_ms_; }
  int64_t NowSteadyMs() override { return now_ms_; }
  void SleepMs(int64_t ms) override { AdvanceTimeMs(ms); } // 瞬间推进
private:
  int64_t now_ms_ = 0;
  int64_t ntp_offset_ms_ = 0;
};

TEST(AvSyncTest, VideoFollowsAudioAfterSeek) {
  SimulatedClock clock;
  AvSyncContext sync(&clock);
  FakeNetworkSender sender(&clock);
  FakeRenderer renderer(&clock);

  // 1. 建立映射：发送 3 个 SR
  sender.SendSr(1000, 90000); // NTP=1s, RTP=90k
  sender.SendSr(2000, 180000);
  sender.SendSr(3000, 270000);
  clock.AdvanceTimeMs(3000);
  EXPECT_TRUE(sync.MappingReady());

  // 2. 模拟 Seek：音频跳到 5s，视频跳到 5.1s（故意错 100ms）
  sender.SendSr(5000, 450000); // Audio
  sender.SendSr(5100, 459000); // Video (fast 100ms)
  clock.AdvanceTimeMs(5100);

  // 3. 送入视频帧 RTP=468000 (对应 5.2s)
  renderer.PushVideoFrame(468000);
  
  // 4. 推进时钟至 5.2s，验证视频是否“等待”音频对齐
  clock.AdvanceTimeMs(5200);
  EXPECT_EQ(renderer.GetLastRenderedVideoNtp(), 5200); // 精准对齐
  
  // 5. 验证视频未早渲染（5.1s 时不应渲染 5.2s 帧）
  clock.AdvanceTimeMs(5150);
  EXPECT_EQ(renderer.GetRenderedCount(), 0);
}

// RTCRtpScriptTransform 中拦截帧，注入 NTP 映射信息
const transformer = new TransformStream({
  transform(controller, frame) {
    if (frame.type === 'video') {
      // 利用 RTCP SR 映射计算目标渲染 NTP
      const targetNtp = syncController.mapRtpToNtp(frame.timestamp);
      // 附加到 frame.metadata 传给 WebCodecs Decoder
      controller.enqueue(new VideoFrame(frame.data, {
        ...frame,
        metadata: { targetRenderNtp: targetNtp }
      }));
    }
  }
});
peerConnection.addTransceiver('video', { sender: { transform: transformer } });

# 拉取最近 10 分钟某房间同步指标
rtc-diag sync --room=12345 --duration=600s --output=json | jq '.p99_offset_ms'