WebRTC RtpTransport 详解：架构设计与代码实现深度分析

摘要

RtpTransport是WebRTC传输层架构中的核心组件，负责RTP/RTCP数据包的发送、接收和路由。本文将深入分析RtpTransport的设计理念、架构层次、核心实现以及在WebRTC整体架构中的作用，通过源码解析和流程图解，为开发者提供全面的技术指南。

目录

1. RtpTransport概述
2. 架构设计与继承体系
3. 核心接口与方法分析
4. 数据包传输流程
5. RTP解复用机制
6. SRTP加密传输
7. DTLS-SRTP集成
8. 性能优化与最佳实践

1. RtpTransport概述

1.1 基本概念

RtpTransport是WebRTC中负责RTP（Real-time Transport Protocol）数据传输的核心组件。它位于WebRTC传输层架构的中间层，连接上层的媒体处理模块和下层的网络传输模块。

1.2 主要职责

• 数据包发送：将RTP/RTCP数据包发送到网络
• 数据包接收：从网络接收RTP/RTCP数据包
• 包解复用：根据SSRC、MID、RSID等标识符将数据包路由到正确的接收器
• 传输状态管理：管理传输通道的可写状态和就绪状态
• 头扩展处理：处理RTP头扩展映射

1.3 在WebRTC架构中的位置

// WebRTC传输层架构
应用层：PeerConnection、MediaStream
    ↓
传输控制层：JsepTransportController、JsepTransport
    ↓
RTP传输层：RtpTransport、SrtpTransport、DtlsSrtpTransport  ← 本文重点
    ↓
安全传输层：DtlsTransport
    ↓
网络传输层：IceTransport、P2PTransportChannel
    ↓
物理网络层：UDP/TCP Socket

2. 架构设计与继承体系

2.1 类继承关系

// 继承体系图
RtpTransportInternal (抽象接口)
    ↓
RtpTransport (基础实现)
    ↓
SrtpTransport (SRTP加密)
    ↓
DtlsSrtpTransport (DTLS-SRTP)

2.2 RtpTransportInternal接口定义

// pc/rtp_transport_internal.h
class RtpTransportInternal : public sigslot::has_slots<> {
 public:
  virtual ~RtpTransportInternal() = default;

  // 核心传输方法
  virtual bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
                             const rtc::PacketOptions& options,
                             int flags) = 0;
  virtual bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options,
                              int flags) = 0;

  // 状态管理
  virtual bool IsReadyToSend() const = 0;
  virtual bool IsWritable(bool rtcp) const = 0;
  virtual bool IsSrtpActive() const = 0;

  // 解复用管理
  virtual bool RegisterRtpDemuxerSink(const RtpDemuxerCriteria& criteria,
                                      RtpPacketSinkInterface* sink) = 0;
  virtual bool UnregisterRtpDemuxerSink(RtpPacketSinkInterface* sink) = 0;

  // 回调订阅机制
  void SubscribeReadyToSend(const void* tag,
                            absl::AnyInvocable<void(bool)> callback);
  void SubscribeRtcpPacketReceived(
      const void* tag,
      absl::AnyInvocable<void(rtc::CopyOnWriteBuffer*, int64_t)> callback);
  void SubscribeNetworkRouteChanged(
      const void* tag,
      absl::AnyInvocable<void(std::optional<rtc::NetworkRoute>)> callback);
};

2.3 RtpTransport基础实现

// pc/rtp_transport.h
class RtpTransport : public RtpTransportInternal {
 public:
  RtpTransport(bool rtcp_mux_enabled, const FieldTrialsView& field_trials)
      : set_ready_to_send_false_if_send_fail_(
            field_trials.IsEnabled("WebRTC-SetReadyToSendFalseIfSendFail")),
        rtcp_mux_enabled_(rtcp_mux_enabled) {}

  // 传输通道管理
  void SetRtpPacketTransport(rtc::PacketTransportInternal* rtp);
  void SetRtcpPacketTransport(rtc::PacketTransportInternal* rtcp);

  // 数据包发送
  bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
                     const rtc::PacketOptions& options,
                     int flags) override;
  bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
                      const rtc::PacketOptions& options,
                      int flags) override;

 protected:
  // 数据包解复用
  void DemuxPacket(rtc::CopyOnWriteBuffer packet,
                   Timestamp arrival_time,
                   rtc::EcnMarking ecn);

 private:
  // 底层传输通道
  rtc::PacketTransportInternal* rtp_packet_transport_ = nullptr;
  rtc::PacketTransportInternal* rtcp_packet_transport_ = nullptr;

  // 状态管理
  bool ready_to_send_ = false;
  bool rtp_ready_to_send_ = false;
  bool rtcp_ready_to_send_ = false;

  // RTP解复用器
  RtpDemuxer rtp_demuxer_;
  // 头扩展映射
  RtpHeaderExtensionMap header_extension_map_;
};

3. 核心接口与方法分析

3.1 传输通道设置

// 设置RTP传输通道
void RtpTransport::SetRtpPacketTransport(
    rtc::PacketTransportInternal* new_packet_transport) {
  if (new_packet_transport == rtp_packet_transport_) {
    return;
  }
  
  // 断开旧连接
  if (rtp_packet_transport_) {
    rtp_packet_transport_->SignalReadyToSend.disconnect(this);
    rtp_packet_transport_->DeregisterReceivedPacketCallback(this);
    rtp_packet_transport_->SignalNetworkRouteChanged.disconnect(this);
    rtp_packet_transport_->SignalWritableState.disconnect(this);
    rtp_packet_transport_->SignalSentPacket.disconnect(this);
  }
  
  // 建立新连接
  if (new_packet_transport) {
    new_packet_transport->SignalReadyToSend.connect(
        this, &RtpTransport::OnReadyToSend);
    new_packet_transport->RegisterReceivedPacketCallback(
        this, [&](rtc::PacketTransportInternal* transport,
                  const rtc::ReceivedPacket& packet) {
          OnReadPacket(transport, packet);
        });
    new_packet_transport->SignalNetworkRouteChanged.connect(
        this, &RtpTransport::OnNetworkRouteChanged);
    new_packet_transport->SignalWritableState.connect(
        this, &RtpTransport::OnWritableState);
    new_packet_transport->SignalSentPacket.connect(this,
                                                   &RtpTransport::OnSentPacket);
  }

  rtp_packet_transport_ = new_packet_transport;
  SetReadyToSend(false,
                 rtp_packet_transport_ && rtp_packet_transport_->writable());
}

3.2 数据包发送机制

// RTP数据包发送
bool RtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
                                 const rtc::PacketOptions& options,
                                 int flags) {
  return SendPacket(false, packet, options, flags);
}

// RTCP数据包发送
bool RtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
                                  const rtc::PacketOptions& options,
                                  int flags) {
  return SendPacket(true, packet, options, flags);
}

// 通用发送方法
bool RtpTransport::SendPacket(bool rtcp,
                              rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options,
                              int flags) {
  // 选择传输通道（RTCP复用或独立通道）
  rtc::PacketTransportInternal* transport = rtcp && !rtcp_mux_enabled_
                                                ? rtcp_packet_transport_
                                                : rtp_packet_transport_;
  
  // 发送数据包
  int ret = transport->SendPacket(packet->cdata<char>(), packet->size(),
                                  options, flags);
  
  // 错误处理
  if (ret != static_cast<int>(packet->size())) {
    if (set_ready_to_send_false_if_send_fail_) {
      if (transport->GetError() == ENOTCONN) {
        RTC_LOG(LS_WARNING) << "Got ENOTCONN from transport.";
        SetReadyToSend(rtcp, false);
      }
    }
    return false;
  }
  return true;
}

3.3 数据包接收处理

// 数据包接收入口
void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
                                const rtc::ReceivedPacket& received_packet) {
  TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket");

  // 判断包类型（RTP或RTCP）
  cricket::RtpPacketType packet_type =
      cricket::InferRtpPacketType(received_packet.payload());
  
  // 过滤无效包
  if (packet_type == cricket::RtpPacketType::kUnknown) {
    return;
  }

  // 验证包大小
  if (!cricket::IsValidRtpPacketSize(packet_type,
                                     received_packet.payload().size())) {
    RTC_LOG(LS_ERROR) << "Dropping incoming "
                      << cricket::RtpPacketTypeToString(packet_type)
                      << " packet: wrong size="
                      << received_packet.payload().size();
    return;
  }

  // 分发到对应处理器
  if (packet_type == cricket::RtpPacketType::kRtcp) {
    OnRtcpPacketReceived(received_packet);
  } else {
    OnRtpPacketReceived(received_packet);
  }
}

// RTP包处理
void RtpTransport::OnRtpPacketReceived(
    const rtc::ReceivedPacket& received_packet) {
  rtc::CopyOnWriteBuffer payload(received_packet.payload());
  DemuxPacket(
      payload,
      received_packet.arrival_time().value_or(Timestamp::MinusInfinity()),
      received_packet.ecn());
}

4. 数据包传输流程

4.1 发送流程图

4.2 接收流程图

4.3 状态管理流程

// 状态更新机制
void RtpTransport::SetReadyToSend(bool rtcp, bool ready) {
  if (rtcp) {
    rtcp_ready_to_send_ = ready;
  } else {
    rtp_ready_to_send_ = ready;
  }
  MaybeSignalReadyToSend();
}

void RtpTransport::MaybeSignalReadyToSend() {
  // 只有当RTP就绪且（RTCP就绪或启用RTCP复用）时才认为传输就绪
  bool ready_to_send =
      rtp_ready_to_send_ && (rtcp_ready_to_send_ || rtcp_mux_enabled_);
  
  if (ready_to_send != ready_to_send_) {
    if (processing_ready_to_send_) {
      // 延迟处理避免递归
      TaskQueueBase::Current()->PostTask(
          SafeTask(safety_.flag(), [this] { MaybeSignalReadyToSend(); }));
      return;
    }
    ready_to_send_ = ready_to_send;
    processing_ready_to_send_ = true;
    SendReadyToSend(ready_to_send);
    processing_ready_to_send_ = false;
  }
}

5. RTP解复用机制

5.1 解复用算法概述

RtpTransport使用RtpDemuxer来实现数据包的解复用，根据BUNDLE规范的算法将接收到的RTP包路由到正确的接收器。

5.2 解复用标准

// call/rtp_demuxer.h - 解复用标准定义
class RtpDemuxerCriteria {
 public:
  // MID (Media ID) - BUNDLE协商中的媒体标识
  std::string mid;
  
  // RSID (RTP Stream ID) - RTP流标识
  std::string rsid;
  
  // SSRC - 同步源标识符
  std::set<uint32_t> ssrcs;
  
  // Payload Types - 负载类型
  std::set<uint8_t> payload_types;
};

5.3 解复用流程

// RTP包解复用实现
void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet,
                               webrtc::Timestamp arrival_time,
                               rtc::EcnMarking ecn) {
  // 解析RTP包
  RtpPacketReceived parsed_packet(&header_extension_map_);
  parsed_packet.set_arrival_time(arrival_time);
  parsed_packet.set_ecn(ecn);

  if (!parsed_packet.Parse(std::move(packet))) {
    RTC_LOG(LS_ERROR)
        << "Failed to parse the incoming RTP packet before demuxing. Drop it.";
    return;
  }

  // 执行解复用
  if (!rtp_demuxer_.OnRtpPacket(parsed_packet)) {
    RTC_LOG(LS_VERBOSE) << "Failed to demux RTP packet: "
                        << RtpDemuxer::DescribePacket(parsed_packet);
    NotifyUnDemuxableRtpPacketReceived(parsed_packet);
  }
}

5.4 解复用算法详解

// call/rtp_demuxer.cc - 解复用算法核心
RtpPacketSinkInterface* RtpDemuxer::ResolveSink(
    const RtpPacketReceived& packet) {
  // 提取包信息
  std::string packet_mid, packet_rsid;
  bool has_mid = use_mid_ && packet.GetExtension<RtpMid>(&packet_mid);
  bool has_rsid = packet.GetExtension<RepairedRtpStreamId>(&packet_rsid);
  if (!has_rsid) {
    has_rsid = packet.GetExtension<RtpStreamId>(&packet_rsid);
  }
  uint32_t ssrc = packet.Ssrc();

  // 1. 优先使用MID进行路由
  if (has_mid && known_mids_.find(packet_mid) != known_mids_.end()) {
    mid_by_ssrc_[ssrc] = packet_mid;
    RtpPacketSinkInterface* sink_by_mid = ResolveSinkByMid(packet_mid, ssrc);
    if (sink_by_mid != nullptr) {
      return sink_by_mid;
    }
    
    // 2. MID + RSID组合路由
    if (has_rsid) {
      rsid_by_ssrc_[ssrc] = packet_rsid;
      RtpPacketSinkInterface* sink_by_mid_rsid =
          ResolveSinkByMidRsid(packet_mid, packet_rsid, ssrc);
      if (sink_by_mid_rsid != nullptr) {
        return sink_by_mid_rsid;
      }
    }
    return nullptr; // MID已知但无匹配sink，丢弃包
  }

  // 3. 使用RSID路由
  if (has_rsid) {
    rsid_by_ssrc_[ssrc] = packet_rsid;
    RtpPacketSinkInterface* sink_by_rsid = ResolveSinkByRsid(packet_rsid, ssrc);
    if (sink_by_rsid != nullptr) {
      return sink_by_rsid;
    }
  }

  // 4. 使用SSRC路由
  const auto ssrc_sink_it = sink_by_ssrc_.find(ssrc);
  if (ssrc_sink_it != sink_by_ssrc_.end()) {
    return ssrc_sink_it->second;
  }

  // 5. 使用Payload Type路由（最后选择）
  return ResolveSinkByPayloadType(packet.PayloadType(), ssrc);
}

6. SRTP加密传输

6.1 SrtpTransport架构

// pc/srtp_transport.h
class SrtpTransport : public RtpTransport {
 public:
  SrtpTransport(bool rtcp_mux_enabled, const FieldTrialsView& field_trials);

  // 重写发送方法以添加加密
  bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
                     const rtc::PacketOptions& options,
                     int flags) override;
  bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
                      const rtc::PacketOptions& options,
                      int flags) override;

  // SRTP参数设置
  bool SetRtpParams(int send_crypto_suite,
                    const rtc::ZeroOnFreeBuffer<uint8_t>& send_key,
                    const std::vector<int>& send_extension_ids,
                    int recv_crypto_suite,
                    const rtc::ZeroOnFreeBuffer<uint8_t>& recv_key,
                    const std::vector<int>& recv_extension_ids);

  bool IsSrtpActive() const override;

 private:
  // SRTP会话管理
  std::unique_ptr<cricket::SrtpSession> send_session_;
  std::unique_ptr<cricket::SrtpSession> recv_session_;
  std::unique_ptr<cricket::SrtpSession> send_rtcp_session_;
  std::unique_ptr<cricket::SrtpSession> recv_rtcp_session_;

  // 加密/解密方法
  bool ProtectRtp(void* data, int in_len, int max_len, int* out_len);
  bool ProtectRtcp(void* data, int in_len, int max_len, int* out_len);
  bool UnprotectRtp(void* data, int in_len, int* out_len);
  bool UnprotectRtcp(void* data, int in_len, int* out_len);
};

6.2 SRTP发送流程

// SRTP包发送实现
bool SrtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
                                  const rtc::PacketOptions& options,
                                  int flags) {
  if (!IsSrtpActive()) {
    RTC_LOG(LS_ERROR)
        << "Failed to send the packet because SRTP transport is inactive.";
    return false;
  }
  
  rtc::PacketOptions updated_options = options;
  TRACE_EVENT0("webrtc", "SRTP Encode");
  
  // 加密RTP包
  uint8_t* data = packet->MutableData();
  int len = rtc::checked_cast<int>(packet->size());
  bool res = ProtectRtp(data, len, static_cast<int>(packet->capacity()), &len);
  
  if (!res) {
    uint16_t seq_num = ParseRtpSequenceNumber(*packet);
    uint32_t ssrc = ParseRtpSsrc(*packet);
    RTC_LOG(LS_ERROR) << "Failed to protect RTP packet: size=" << len
                      << ", seqnum=" << seq_num << ", SSRC=" << ssrc;
    return false;
  }

  // 更新包长度（添加了认证标签）
  packet->SetSize(len);
  return SendPacket(/*rtcp=*/false, packet, updated_options, flags);
}

6.3 SRTP接收流程

// SRTP包接收处理
void SrtpTransport::OnRtpPacketReceived(const rtc::ReceivedPacket& packet) {
  TRACE_EVENT0("webrtc", "SrtpTransport::OnRtpPacketReceived");
  if (!IsSrtpActive()) {
    RTC_LOG(LS_WARNING)
        << "Inactive SRTP transport received an RTP packet. Drop it.";
    return;
  }

  rtc::CopyOnWriteBuffer payload(packet.payload());
  char* data = payload.MutableData<char>();
  int len = rtc::checked_cast<int>(payload.size());
  
  // 解密RTP包
  if (!UnprotectRtp(data, len, &len)) {
    // 限制错误日志避免过多输出
    const int kFailureLogThrottleCount = 100;
    if (decryption_failure_count_ % kFailureLogThrottleCount == 0) {
      RTC_LOG(LS_ERROR) << "Failed to unprotect RTP packet: size=" << len
                        << ", seqnum=" << ParseRtpSequenceNumber(payload)
                        << ", SSRC=" << ParseRtpSsrc(payload)
                        << ", previous failure count: "
                        << decryption_failure_count_;
    }
    ++decryption_failure_count_;
    return;
  }
  
  payload.SetSize(len);
  DemuxPacket(std::move(payload),
              packet.arrival_time().value_or(Timestamp::MinusInfinity()),
              packet.ecn());
}

7. DTLS-SRTP集成

7.1 DtlsSrtpTransport架构

// pc/dtls_srtp_transport.h
class DtlsSrtpTransport : public SrtpTransport {
 public:
  DtlsSrtpTransport(bool rtcp_mux_enabled, const FieldTrialsView& field_trials);

  // 设置DTLS传输层
  void SetDtlsTransports(cricket::DtlsTransportInternal* rtp_dtls_transport,
                         cricket::DtlsTransportInternal* rtcp_dtls_transport);

  // 加密头扩展配置
  void UpdateSendEncryptedHeaderExtensionIds(
      const std::vector<int>& send_extension_ids);
  void UpdateRecvEncryptedHeaderExtensionIds(
      const std::vector<int>& recv_extension_ids);

 private:
  // DTLS状态管理
  bool IsDtlsActive();
  bool IsDtlsConnected();
  bool DtlsHandshakeCompleted();
  
  // DTLS-SRTP设置
  void MaybeSetupDtlsSrtp();
  void SetupRtpDtlsSrtp();
  void SetupRtcpDtlsSrtp();
  
  // 密钥提取
  bool ExtractParams(cricket::DtlsTransportInternal* dtls_transport,
                     int* selected_crypto_suite,
                     rtc::ZeroOnFreeBuffer<uint8_t>* send_key,
                     rtc::ZeroOnFreeBuffer<uint8_t>* recv_key);

  // DTLS传输层引用
  cricket::DtlsTransportInternal* rtp_dtls_transport_ = nullptr;
  cricket::DtlsTransportInternal* rtcp_dtls_transport_ = nullptr;
};

7.2 DTLS握手完成后的密钥提取

// DTLS-SRTP密钥提取实现
bool DtlsSrtpTransport::ExtractParams(
    cricket::DtlsTransportInternal* dtls_transport,
    int* selected_crypto_suite,
    rtc::ZeroOnFreeBuffer<uint8_t>* send_key,
    rtc::ZeroOnFreeBuffer<uint8_t>* recv_key) {
  
  // 获取协商的加密套件
  int crypto_suite;
  if (!dtls_transport->GetSrtpCryptoSuite(&crypto_suite)) {
    RTC_LOG(LS_ERROR) << "Failed to get SRTP crypto suite from DTLS transport";
    return false;
  }

  // 计算密钥长度
  int key_len;
  int salt_len;
  if (!rtc::GetSrtpKeyAndSaltLengths(crypto_suite, &key_len, &salt_len)) {
    RTC_LOG(LS_ERROR) << "Failed to get SRTP key and salt lengths";
    return false;
  }

  // 提取密钥材料
  const size_t total_key_len = (key_len + salt_len) * 2;
  rtc::ZeroOnFreeBuffer<uint8_t> key_material(total_key_len);
  if (!dtls_transport->ExportKeyingMaterial(
          kDtlsSrtpExporterLabel, nullptr, 0, false,
          key_material.data(), key_material.size())) {
    RTC_LOG(LS_ERROR) << "Failed to export DTLS-SRTP keying material";
    return false;
  }

  // 分离客户端和服务器密钥
  rtc::ZeroOnFreeBuffer<uint8_t> client_write_key(key_len + salt_len);
  rtc::ZeroOnFreeBuffer<uint8_t> server_write_key(key_len + salt_len);
  
  // 客户端写密钥 = 客户端密钥 + 客户端盐值
  memcpy(client_write_key.data(), key_material.data(), key_len);
  memcpy(client_write_key.data() + key_len, 
         key_material.data() + key_len * 2, salt_len);
  
  // 服务器写密钥 = 服务器密钥 + 服务器盐值  
  memcpy(server_write_key.data(), key_material.data() + key_len, key_len);
  memcpy(server_write_key.data() + key_len,
         key_material.data() + key_len * 2 + salt_len, salt_len);

  // 根据DTLS角色分配发送/接收密钥
  rtc::SSLRole role;
  if (!dtls_transport->GetDtlsRole(&role)) {
    RTC_LOG(LS_WARNING) << "Failed to get the DTLS role.";
    return false;
  }

  if (role == rtc::SSL_SERVER) {
    *send_key = std::move(server_write_key);
    *recv_key = std::move(client_write_key);
  } else {
    *send_key = std::move(client_write_key);
    *recv_key = std::move(server_write_key);
  }
  
  *selected_crypto_suite = crypto_suite;
  return true;
}

7.3 DTLS状态变化处理

// DTLS状态变化回调
void DtlsSrtpTransport::OnDtlsState(cricket::DtlsTransportInternal* transport,
                                    DtlsTransportState state) {
  RTC_DCHECK(transport == rtp_dtls_transport_ ||
             transport == rtcp_dtls_transport_);

  if (on_dtls_state_change_) {
    on_dtls_state_change_();
  }

  if (state != DtlsTransportState::kConnected) {
    ResetParams();  // 连接断开时重置SRTP参数
    return;
  }

  MaybeSetupDtlsSrtp();  // 连接建立时设置DTLS-SRTP
}

// DTLS-SRTP设置
void DtlsSrtpTransport::MaybeSetupDtlsSrtp() {
  if (!IsDtlsConnected() || IsSrtpActive()) {
    return;
  }

  SetupRtpDtlsSrtp();
  
  if (!rtcp_mux_enabled() && rtcp_dtls_transport_) {
    SetupRtcpDtlsSrtp();
  }
}

8. 性能优化与最佳实践

8.1 内存管理优化

// 使用CopyOnWriteBuffer减少内存拷贝
class RtpTransport {
  // 避免不必要的数据拷贝
  bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,  // 传指针而非值
                     const rtc::PacketOptions& options,
                     int flags) override;
  
  // 接收时直接构造CopyOnWriteBuffer
  void OnRtpPacketReceived(const rtc::ReceivedPacket& received_packet) {
    rtc::CopyOnWriteBuffer payload(received_packet.payload());
    DemuxPacket(std::move(payload), ...);  // 使用move语义
  }
};

8.2 异步处理优化

// 避免递归调用的异步处理
void RtpTransport::MaybeSignalReadyToSend() {
  if (processing_ready_to_send_) {
    // 使用TaskQueue延迟处理避免递归
    TaskQueueBase::Current()->PostTask(
        SafeTask(safety_.flag(), [this] { MaybeSignalReadyToSend(); }));
    return;
  }
  // ... 正常处理逻辑
}

8.3 错误处理最佳实践

// 限制错误日志频率
void SrtpTransport::OnRtpPacketReceived(const rtc::ReceivedPacket& packet) {
  if (!UnprotectRtp(data, len, &len)) {
    const int kFailureLogThrottleCount = 100;
    if (decryption_failure_count_ % kFailureLogThrottleCount == 0) {
      RTC_LOG(LS_ERROR) << "Failed to unprotect RTP packet...";
    }
    ++decryption_failure_count_;
    return;
  }
}

8.4 状态管理最佳实践

// 使用回调列表管理多个订阅者
class RtpTransportInternal {
 private:
  CallbackList<bool> callback_list_ready_to_send_;
  CallbackList<rtc::CopyOnWriteBuffer*, int64_t> callback_list_rtcp_packet_received_;
  
 protected:
  void SendReadyToSend(bool arg) { 
    callback_list_ready_to_send_.Send(arg); 
  }
};

总结

RtpTransport是WebRTC传输层的核心组件，通过分层设计实现了：

1. 基础传输功能：RtpTransport提供基本的RTP/RTCP包发送接收
2. 安全传输：SrtpTransport添加SRTP加密保护
3. 密钥协商：DtlsSrtpTransport集成DTLS密钥协商
4. 智能路由：通过RtpDemuxer实现基于MID/RSID/SSRC的包路由
5. 状态管理：完善的传输状态和错误处理机制

这种设计既保证了功能的完整性，又维持了良好的可扩展性和性能表现，是WebRTC架构设计的典型体现。