void RTCPSender::PrepareReport(const std::set<RTCPPacketType>& packetTypes,

                               const FeedbackState& feedback_state){

  // Add all flags as volatile. Non volatile entries will not be overwritten

  // and all new volatile flags added will be consumed by the end of this call.

  SetFlags(packetTypes, true);



  if (packet_type_counter_.first_packet_time_ms== -1)

    packet_type_counter_.first_packet_time_ms= clock_->TimeInMilliseconds();



  bool generate_report;

  if (IsFlagPresent(kRtcpSr)|| IsFlagPresent(kRtcpRr)){

    // Report type already explicitly set, don't automatically populate.

    generate_report = true;

    RTC_DCHECK(ConsumeFlag(kRtcpReport)== false);

  } else {

    generate_report =

        (ConsumeFlag(kRtcpReport)&& method_ == RtcpMode::kReducedSize)||

        method_ == RtcpMode::kCompound;

    if (generate_report)

      SetFlag(sending_? kRtcpSr : kRtcpRr, true);

  }



  if (IsFlagPresent(kRtcpSr)|| (IsFlagPresent(kRtcpRr)&& !cname_.empty()))

    SetFlag(kRtcpSdes, true);



  if (generate_report) {

    if (!sending_ && xr_send_receiver_reference_time_enabled_)

      SetFlag(kRtcpXrReceiverReferenceTime, true);

    if (feedback_state.has_last_xr_rr)

      SetFlag(kRtcpXrDlrrReportBlock, true);



    // generate next time to send an RTCP report

    uint32_t minIntervalMs = RTCP_INTERVAL_AUDIO_MS;



    if (!audio_) {

      if (sending_) {

        // Calculate bandwidth for video; 360 / send bandwidth in kbit/s.

        uint32_t send_bitrate_kbit = feedback_state.send_bitrate/ 1000;

        if (send_bitrate_kbit !=0)

          minIntervalMs =360000 / send_bitrate_kbit;

      }

      if (minIntervalMs > RTCP_INTERVAL_VIDEO_MS)

        minIntervalMs = RTCP_INTERVAL_VIDEO_MS;

    }

    // The interval between RTCP packets is varied randomly over the

    // range [1/2,3/2] times the calculated interval.

    uint32_t timeToNext =

        random_.Rand(minIntervalMs* 1 / 2, minIntervalMs * 3/ 2);

    next_time_to_send_rtcp_ = clock_->TimeInMilliseconds()+ timeToNext;



    StatisticianMap statisticians =

        receive_statistics_->GetActiveStatisticians();

    RTC_DCHECK(report_blocks_.empty());

    for (auto& it: statisticians){

      AddReportBlock(feedback_state, it.first, it.second);

    }

  }

}

// src/modules/pacing/paced_sender.h
    class PacketSender {
     public:
      virtual bool TimeToSendPacket(uint32_t ssrc,
                                    uint16_t sequence_number,
                                    int64_t capture_time_ms,
                                    bool retransmission,
                                    const PacedPacketInfo& cluster_info) = 0;
      virtual size_t TimeToSendPadding(size_t bytes,
                                       const PacedPacketInfo& cluster_info) = 0;
     protected:
      virtual ~PacketSender() {}
    };

// src/modules/pacing/packet_router.h
    class PacketRouter : public PacedSender::PacketSender,
                         public TransportSequenceNumberAllocator,
                         public RemoteBitrateObserver,
                         public TransportFeedbackSenderInterface {};
    // src/modules/pacing/packet_router.cc
    bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
                                        uint16_t sequence_number,
                                        int64_t capture_timestamp,
                                        bool retransmission,
                                        const PacedPacketInfo& pacing_info) {
      return rtp_module->TimeToSendPacket(ssrc, sequence_number,
                                          capture_timestamp, retransmission,
                                          pacing_info);
    }

// src/modules/rtp_rtcp/include/rtp_rtcp.h
    class RtpRtcp : public Module, public RtcpFeedbackSenderInterface {
      virtual bool TimeToSendPacket(uint32_t ssrc,
                                    uint16_t sequence_number,
                                    int64_t capture_time_ms,
                                    bool retransmission,
                                    const PacedPacketInfo& pacing_info) = 0;
    };

// src/modules/rtp_rtcp/source/rtp_rtcp_impl.h
    class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {};
    // src/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
    bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
                                             uint16_t sequence_number,
                                             int64_t capture_time_ms,
                                             bool retransmission,
                                             const PacedPacketInfo& pacing_info) {
      return rtp_sender_->TimeToSendPacket(ssrc, sequence_number, capture_time_ms,
                                           retransmission, pacing_info);
    }

// src/modules/rtp_rtcp/source/rtp_sender.cc
    bool RTPSender::TimeToSendPacket(uint32_t ssrc,
                                     uint16_t sequence_number,
                                     bool retransmission,
                                     const PacedPacketInfo& pacing_info) {
      // ...
      // 从发送缓存队列获取要发送的包，若为 FEC 则另从 FEC 缓存队列获取
      // ...
      return PrepareAndSendPacket(
          std::move(packet),
          retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
          pacing_info);
    }
    bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
                                         bÂool send_over_rtx,
                                         bool is_retransmit,
                                         const PacedPacketInfo& pacing_info) {
      // ...
      // 给 packet 添加头部扩展（包括序列号）
      // 如果不是重传包则更新发送延迟
      // ...
      AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
                                   pacing_info);
      UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
                         packet->Ssrc());
      SendPacketToNetwork(*packet_to_send, options, pacing_info);
    }
    void RTPSender::AddPacketToTransportFeedback(
        uint16_t packet_id,
        const RtpPacketToSend& packet,
        const PacedPacketInfo& pacing_info) {
      transport_feedback_observer_->AddPacket(SSRC(), packet_id, packet_size,
                                              pacing_info);
    }
    void RTPSender::UpdateOnSendPacket(int packet_id,
                                       int64_t capture_time_ms,
                                       uint32_t ssrc) {
      send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
    }
    bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
                                        const PacketOptions& options,
                                        const PacedPacketInfo& pacing_info) {
      // ...
      // 更新 rtp 头部开销
      // ...
      bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
                       ? static_cast<int>(packet.size())
                       : -1;
    }

// src/modules/rtp_rtcp/include/rtp_rtcp_defines.h
    class TransportFeedbackObserver {
     public:
      TransportFeedbackObserver() {}
      virtual ~TransportFeedbackObserver() {}
      virtual void AddPacket(uint32_t ssrc,
                             uint16_t sequence_number,
                             size_t length,
                             const PacedPacketInfo& pacing_info) = 0;
      virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
    };

// src/modules/congestion_controller/include/send_side_congestion_controller_interface.h
    class SendSideCongestionControllerInterface : public CallStatsObserver,
                                                  public Module,
                                                  public TransportFeedbackObserver{};

// src/modules/congestion_controller/include/send_side_congestion_controller.h
    class SendSideCongestionController
        : public SendSideCongestionControllerInterface {};
    // src/modules/congestion_controller/send_side_congestion_controller.cc
    void SendSideCongestionController::AddPacket(
        uint32_t ssrc,
        uint16_t sequence_number,
        size_t length,
        const PacedPacketInfo& pacing_info) {
      transport_feedback_adapter_.AddPacket(ssrc, sequence_number, length,
                                            pacing_info);
    }

// src/modules/congestion_controller/transport_feedback_adapter.cc
    void TransportFeedbackAdapter::AddPacket(uint32_t ssrc,
                                             uint16_t sequence_number,
                                             size_t length,
                                             const PacedPacketInfo& pacing_info) {
      send_time_history_.AddAndRemoveOld(
          PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_,
                         remote_net_id_, pacing_info));
      observer->OnPacketAdded(ssrc, sequence_number);
    }

// src/common_types.h
    class SendPacketObserver {
     public:
      virtual ~SendPacketObserver() {}
      virtual void OnSendPacket(uint16_t packet_id,
                                int64_t capture_time_ms,
                                uint32_t ssrc) = 0;
    };

// src/video/send_delay_stats.h
    class SendDelayStats : public SendPacketObserver {};
    // src/video/send_delay_stats.cc
    void SendDelayStats::OnSendPacket(uint16_t packet_id,
                                      int64_t capture_time_ms,
                                      uint32_t ssrc) {};

// src/api/call/transport.h
    class Transport {
     public:
      virtual bool SendRtp(const uint8_t* packet,
                           size_t length,
                           const PacketOptions& options) = 0;
      virtual bool SendRtcp(const uint8_t* packet, size_t length) = 0;
     protected:
      virtual ~Transport() {}
    };

// src/audio/audio_send_stream.cc
    class AudioSendStream::TimedTransport : public Transport {};
    // src/video/transport_adapter.h
    class TransportAdapter : public Transport {};

// src/pc/channel.cc
void BaseChannel::OnRtpPacket(const webrtc::RtpPacketReceived& parsed_packet) {
  // 重构了 parsed_packet 里的 PacketTime
  OnPacketReceived(/*rtcp=*/false, parsed_packet.Buffer(), packet_time);
}
void BaseChannel::OnPacketReceived(bool rtcp,
                                   const rtc::CopyOnWriteBuffer& packet,
                                   const rtc::PacketTime& packet_time) {
  // 如果是第一个 RTP 包则进行额外处理
  invoker_.AsyncInvoke<void>(
      RTC_FROM_HERE, worker_thread_,
      Bind(&BaseChannel::ProcessPacket, this, rtcp, packet, packet_time));
}
void BaseChannel::ProcessPacket(bool rtcp,
                                const rtc::CopyOnWriteBuffer& packet,
                                const rtc::PacketTime& packet_time) {
  media_channel_->OnPacketReceived(&data, packet_time);
}

// src/media/engine/webrtcvideoengine.cc
void WebRtcVideoChannel::OnPacketReceived(rtc::CopyOnWriteBuffer* packet,
                                          const rtc::PacketTime& packet_time) {
  const webrtc::PacketReceiver::DeliveryStatus delivery_result =
      call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, *packet,
                                       webrtc_packet_time);
}

// src/call/call.cc
PacketReceiver::DeliveryStatus Call::DeliverPacket(
    MediaType media_type,
    rtc::CopyOnWriteBuffer packet,
    const PacketTime& packet_time) {
  // 如果是 RTCP 包则调用 DeliverRtcp 处理
  return DeliverRtp(media_type, std::move(packet), packet_time);
}
PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
                                                rtc::CopyOnWriteBuffer packet,
                                                const PacketTime& packet_time) {
  NotifyBweOfReceivedPacket(parsed_packet, media_type);
  video_receiver_controller_.OnRtpPacket(parsed_packet);
}

// src/call/rtp_stream_receiver_controller.cc
bool RtpStreamReceiverController::OnRtpPacket(const RtpPacketReceived& packet) {
  rtc::CritScope cs(&lock_);
  return demuxer_.OnRtpPacket(packet);
}

// src/call/rtp_demuxer.cc
bool RtpDemuxer::OnRtpPacket(const RtpPacketReceived& packet) {
  RtpPacketSinkInterface* sink = ResolveSink(packet);
  if (sink != nullptr) {
    sink->OnRtpPacket(packet);
    return true;
  }
  return false;
}

// src/video/rtp_video_stream_receiver.cc
void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
  packet.GetHeader(&header);
  ReceivePacket(packet.data(), packet.size(), header);
  rtp_receive_statistics_->IncomingPacket(header, packet.size(),
                                          IsPacketRetransmitted(header));
  secondary_sink->OnRtpPacket(packet);
}
void RtpVideoStreamReceiver::ReceivePacket(const uint8_t* packet,
                                           size_t packet_length,
                                           const RTPHeader& header) {
  if (header.payloadType == config_.rtp.red_payload_type) {
    ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
    return;
  }
  const uint8_t* payload = packet + header.headerLength;
  assert(packet_length >= header.headerLength);
  size_t payload_length = packet_length - header.headerLength;
  const auto pl =
      rtp_payload_registry_.PayloadTypeToPayload(header.payloadType);
  if (pl) {
    rtp_receiver_->IncomingRtpPacket(header, payload, payload_length,
                                     pl->typeSpecific);
  }
}

bool RtpReceiverImpl::IncomingRtpPacket(const RTPHeader& rtp_header,
                                        const uint8_t* payload,
                                        size_t payload_length,
                                        PayloadUnion payload_specific) {
  int32_t ret_val = rtp_media_receiver_->ParseRtpPacket(
      &webrtc_rtp_header, payload_specific, payload, payload_length,
      clock_->TimeInMilliseconds());
}

int32_t RTPReceiverVideo::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                                         const PayloadUnion& specific_payload,
                                         const uint8_t* payload,
                                         size_t payload_length,
                                         int64_t timestamp_ms) {}

// /modules/remote_bitrate_estimator/remote_estimator_proxy.cc
// 接收端发送RTCP
void RemoteEstimatorProxy::Process() {
  BuildFeedbackPacket(&feedback_packet)
  feedback_sender_->SendTransportFeedback(&feedback_packet);
}
// 构造Feedback Packet
bool RemoteEstimatorProxy::BuildFeedbackPacket(
    rtcp::TransportFeedback* feedback_packet) {
    const int64_t first_sequence = it->first;
    feedback_packet->SetMediaSsrc(media_ssrc_);
    feedback_packet->SetBase(static_cast<uint16_t>(window_start_seq_ & 0xFFFF),
                             it->second * 1000);
    feedback_packet->SetFeedbackSequenceNumber(feedback_sequence_++);
    for (; it != packet_arrival_times_.end(); ++it) {
        if (!feedback_packet->AddReceivedPacket(
            static_cast<uint16_t>(it->first & 0xFFFF), it->second * 1000)) {
            break;
        }
        window_start_seq_ = it->first + 1;
    }
    return true;
}

// src/modules/pacing/packet_router.cc
// 发送TransportFeedback包
bool PacketRouter::SendTransportFeedback(rtcp::TransportFeedback* packet) {
  rtp_module->SendFeedbackPacket(*packet);
}

// src/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
bool ModuleRtpRtcpImpl::SendFeedbackPacket(
    const rtcp::TransportFeedback& packet) {
  return rtcp_sender_.SendFeedbackPacket(packet);
}

// src/modules/rtp_rtcp/source/rtcp_sender.cc
// 发送TransportFeedback包
bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) {
  transport_->SendRtcp(packet.data(), packet.size());
    return packet.BuildExternalBuffer(buffer, max_packet_size, &sender) &&
         !sender.send_failure_;
}

// src/media/engine/webrtcvideoengine.cc
bool WebRtcVideoChannel::SendRtcp(const uint8_t* data, size_t len) {
  rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen);
  return MediaChannel::SendRtcp(&packet, rtc::PacketOptions());
}

// src/media/base/mediachannel.h
bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
              const rtc::PacketOptions& options) {
  return DoSendPacket(packet, true, options);
}
bool DoSendPacket(rtc::CopyOnWriteBuffer* packet,
                  bool rtcp,
                  const rtc::PacketOptions& options) {
  rtc::CritScope cs(&network_interface_crit_);
  if (!network_interface_)
    return false;
  return (!rtcp) ? network_interface_->SendPacket(packet, options)
                 : network_interface_->SendRtcp(packet, options);
}

// src/pc/channel.cc
bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
                           const rtc::PacketOptions& options) {
  return SendPacket(true, packet, options);
}
bool BaseChannel::SendPacket(bool rtcp,
                             rtc::CopyOnWriteBuffer* packet,
                             const rtc::PacketOptions& options) {
  // ...
  // Bon voyage.
  return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
              : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
}
//src/pc/rtptransportinternal.h

// /call/call.cc
PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
                                                 const uint8_t* packet,
                                                 size_t length) {
  // media_type == MediaType::VIDEO
  video_receive_stream_->DeliverRtcp(packet, length);
  // media)type == MediaType::AUDIO
  audio_receive_stream->DeliverRtcp(packet, length);
}

// /video/video_receive_stream.cc
bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
  return rtp_video_stream_receiver_.DeliverRtcp(packet, length);
}

// /video/rtp_video_stream_receiver.cc
bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet,
                                         size_t rtcp_packet_length) {
  rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
}

// /modules/rtp_rtcp/source/rtp_rtcp_impl.cc
void ModuleRtpRtcpImpl::IncomingRtcpPacket(const uint8_t* rtcp_packet,
                                           const size_t length) {
  rtcp_receiver_.IncomingPacket(rtcp_packet, length);
}

// /modules/rtp_rtcp/souce/rtcp_receiver.cc
void RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
  PacketInformation packet_information;
  if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
    return;
  TriggerCallbacksFromRtcpPacket(packet_information);
}

bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
                                       const uint8_t* packet_end,
                                       PacketInformation* packet_information) {
    switch (rtcp_block.type()) {
      case rtcp::SenderReport::kPacketType:
        HandleSenderReport(rtcp_block, packet_information);
        break;
      case rtcp::ReceiverReport::kPacketType:
        HandleReceiverReport(rtcp_block, packet_information);
        break;
      case rtcp::Sdes::kPacketType:
        HandleSdes(rtcp_block, packet_information);
        break;
      case rtcp::ExtendedReports::kPacketType:
        HandleXr(rtcp_block, packet_information);
        break;
      case rtcp::Bye::kPacketType:
        HandleBye(rtcp_block);
        break;
      case rtcp::Rtpfb::kPacketType:
        switch (rtcp_block.fmt()) {
          case rtcp::Nack::kFeedbackMessageType:
            HandleNack(rtcp_block, packet_information);
            break;
          case rtcp::Tmmbr::kFeedbackMessageType:
            HandleTmmbr(rtcp_block, packet_information);
            break;
          case rtcp::Tmmbn::kFeedbackMessageType:
            HandleTmmbn(rtcp_block, packet_information);
            break;
          case rtcp::RapidResyncRequest::kFeedbackMessageType:
            HandleSrReq(rtcp_block, packet_information);
            break;
          case rtcp::TransportFeedback::kFeedbackMessageType:
            HandleTransportFeedback(rtcp_block, packet_information);
            break;
          default:
            ++num_skipped_packets_;
            break;
        }
        break;
      case rtcp::Psfb::kPacketType:
        switch (rtcp_block.fmt()) {
          case rtcp::Pli::kFeedbackMessageType:
            HandlePli(rtcp_block, packet_information);
            break;
          case rtcp::Fir::kFeedbackMessageType:
            HandleFir(rtcp_block, packet_information);
            break;
          case rtcp::Remb::kFeedbackMessageType:
            HandlePsfbApp(rtcp_block, packet_information);
            break;
          default:
            ++num_skipped_packets_;
            break;
        }
        break;
      case rtcp::App::kPacketType:
          switch (rtcp_block.fmt()) {
          case rtcp::App::kNtpSyncResponseType:
              HandleSyncNtp(rtcp_block, packet_information);
              break;
          default:
              ++num_skipped_packets_;
              break;
          }
          break;
      default:
        ++num_skipped_packets_;
        break;
    }
}

// /modules/rtp_rtcp/source/rtcp_receiver.cc
void RTCPReceiver::HandleTransportFeedback(
    const CommonHeader& rtcp_block,
    PacketInformation* packet_information) {
    transport_feedback->Parse(rtcp_block);
}
// /modules/rtp_rtcp/souce/rtcp_packet/transport_feedback.cc
bool TransportFeedback::Parse(const CommonHeader& packet) {
  const uint8_t* const payload = packet.payload();
  ParseCommonFeedback(payload);
  base_seq_no_ = ByteReader<uint16_t>::ReadBigEndian(&payload[8]);
  uint16_t status_count = ByteReader<uint16_t>::ReadBigEndian(&payload[10]);
  base_time_ticks_ = ByteReader<int32_t, 3>::ReadBigEndian(&payload[12]);
  feedback_seq_ = payload[15];
  Clear();
  size_t index = 16;
  const size_t end_index = packet.payload_size_bytes();
  // ...
}

// /modules/rtp_rtcp/source/rtcp_receiver.cc
void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
    const PacketInformation& packet_information) {
  if (transport_feedback_observer_ &&
      (packet_information.packet_type_flags & kRtcpTransportFeedback)) {
    uint32_t media_source_ssrc =
        packet_information.transport_feedback->media_ssrc();
    if (media_source_ssrc == local_ssrc ||
        registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
      transport_feedback_observer_->OnTransportFeedback(
          *packet_information.transport_feedback);