tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

rtp_rtcp_impl2.cc (29591B)

      1 /*
      2 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
      3 *
      4 *  Use of this source code is governed by a BSD-style license
      5 *  that can be found in the LICENSE file in the root of the source
      6 *  tree. An additional intellectual property rights grant can be found
      7 *  in the file PATENTS.  All contributing project authors may
      8 *  be found in the AUTHORS file in the root of the source tree.
      9 */
     10 
     11 #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
     12 
     13 #include <cstdint>
     14 #include <cstring>
     15 #include <memory>
     16 #include <optional>
     17 #include <utility>
     18 #include <vector>
     19 
     20 #include "absl/functional/any_invocable.h"
     21 #include "absl/strings/string_view.h"
     22 #include "api/array_view.h"
     23 #include "api/environment/environment.h"
     24 #include "api/rtp_headers.h"
     25 #include "api/sequence_checker.h"
     26 #include "api/task_queue/pending_task_safety_flag.h"
     27 #include "api/task_queue/task_queue_base.h"
     28 #include "api/units/time_delta.h"
     29 #include "api/units/timestamp.h"
     30 #include "api/video/video_bitrate_allocation.h"
     31 #include "modules/include/module_fec_types.h"
     32 #include "modules/rtp_rtcp/include/report_block_data.h"
     33 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
     34 #include "modules/rtp_rtcp/source/ntp_time_util.h"
     35 #include "modules/rtp_rtcp/source/rtcp_packet.h"
     36 #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
     37 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
     38 #include "modules/rtp_rtcp/source/rtcp_sender.h"
     39 #include "modules/rtp_rtcp/source/rtp_packet_history.h"
     40 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
     41 #include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
     42 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
     43 #include "modules/rtp_rtcp/source/rtp_sender.h"
     44 #include "modules/rtp_rtcp/source/rtp_sequence_number_map.h"
     45 #include "rtc_base/checks.h"
     46 #include "rtc_base/logging.h"
     47 #include "rtc_base/synchronization/mutex.h"
     48 #include "rtc_base/task_utils/repeating_task.h"
     49 #include "system_wrappers/include/ntp_time.h"
     50 
     51 #ifdef _WIN32
     52 // Disable warning C4355: 'this' : used in base member initializer list.
     53 #pragma warning(disable : 4355)
     54 #endif
     55 
     56 namespace webrtc {
     57 namespace {
     58 constexpr TimeDelta kDefaultExpectedRetransmissionTime = TimeDelta::Millis(125);
     59 constexpr TimeDelta kRttUpdateInterval = TimeDelta::Millis(1000);
     60 }  // namespace
     61 
     62 ModuleRtpRtcpImpl2::RtpSenderContext::RtpSenderContext(
     63    const Environment& env,
     64    TaskQueueBase& worker_queue,
     65    const RtpRtcpInterface::Configuration& config)
     66    : packet_history(env, RtpPacketHistory::PaddingMode::kRecentLargePacket),
     67      sequencer(config.local_media_ssrc,
     68                config.rtx_send_ssrc,
     69                /*require_marker_before_media_padding=*/!config.audio,
     70                &env.clock()),
     71      packet_sender(env, config, &packet_history),
     72      non_paced_sender(worker_queue, &packet_sender, &sequencer),
     73      packet_generator(
     74          env,
     75          config,
     76          &packet_history,
     77          config.paced_sender ? config.paced_sender : &non_paced_sender) {}
     78 
     79 ModuleRtpRtcpImpl2::ModuleRtpRtcpImpl2(const Environment& env,
     80                                       const Configuration& configuration)
     81    : env_(env),
     82      worker_queue_(TaskQueueBase::Current()),
     83      rtcp_sender_(
     84          env_,
     85          {.audio = configuration.audio,
     86           .local_media_ssrc = configuration.local_media_ssrc,
     87           .outgoing_transport = configuration.outgoing_transport,
     88           .non_sender_rtt_measurement =
     89               configuration.non_sender_rtt_measurement,
     90           .schedule_next_rtcp_send_evaluation =
     91               [this](TimeDelta duration) {
     92                 ScheduleRtcpSendEvaluation(duration);
     93               },
     94           .rtcp_report_interval =
     95               configuration.rtcp_report_interval_ms > 0
     96                   ? TimeDelta::Millis(configuration.rtcp_report_interval_ms)
     97                   : (configuration.audio ? TimeDelta::Seconds(5)
     98                                          : TimeDelta::Seconds(1)),
     99           .receive_statistics = configuration.receive_statistics,
    100           .rtcp_packet_type_counter_observer =
    101               configuration.rtcp_packet_type_counter_observer}),
    102      rtcp_receiver_(env_, configuration, this),
    103      packet_overhead_(28),  // IPV4 UDP.
    104      nack_last_time_sent_full_ms_(0),
    105      nack_last_seq_number_sent_(0),
    106      rtt_stats_(configuration.rtt_stats),
    107      rtt_ms_(0) {
    108  RTC_DCHECK(worker_queue_);
    109  rtcp_thread_checker_.Detach();
    110  if (!configuration.receiver_only) {
    111    rtp_sender_ =
    112        std::make_unique<RtpSenderContext>(env_, *worker_queue_, configuration);
    113    rtp_sender_->sequencing_checker.Detach();
    114    // Make sure rtcp sender use same timestamp offset as rtp sender.
    115    rtcp_sender_.SetTimestampOffset(
    116        rtp_sender_->packet_generator.TimestampOffset());
    117    rtp_sender_->packet_sender.SetTimestampOffset(
    118        rtp_sender_->packet_generator.TimestampOffset());
    119  }
    120 
    121  // Set default packet size limit.
    122  // TODO(nisse): Kind-of duplicates
    123  // VideoSendStream::Config::Rtp::kDefaultMaxPacketSize.
    124  const size_t kTcpOverIpv4HeaderSize = 40;
    125  SetMaxRtpPacketSize(IP_PACKET_SIZE - kTcpOverIpv4HeaderSize);
    126  rtt_update_task_ = RepeatingTaskHandle::DelayedStart(
    127      worker_queue_, kRttUpdateInterval, [this]() {
    128        PeriodicUpdate();
    129        return kRttUpdateInterval;
    130      });
    131 }
    132 
    133 ModuleRtpRtcpImpl2::~ModuleRtpRtcpImpl2() {
    134  RTC_DCHECK_RUN_ON(worker_queue_);
    135  rtt_update_task_.Stop();
    136 }
    137 
    138 void ModuleRtpRtcpImpl2::SetRtxSendStatus(int mode) {
    139  rtp_sender_->packet_generator.SetRtxStatus(mode);
    140 }
    141 
    142 int ModuleRtpRtcpImpl2::RtxSendStatus() const {
    143  return rtp_sender_ ? rtp_sender_->packet_generator.RtxStatus() : kRtxOff;
    144 }
    145 
    146 void ModuleRtpRtcpImpl2::SetRtxSendPayloadType(int payload_type,
    147                                               int associated_payload_type) {
    148  rtp_sender_->packet_generator.SetRtxPayloadType(payload_type,
    149                                                  associated_payload_type);
    150 }
    151 
    152 std::optional<uint32_t> ModuleRtpRtcpImpl2::RtxSsrc() const {
    153  return rtp_sender_ ? rtp_sender_->packet_generator.RtxSsrc() : std::nullopt;
    154 }
    155 
    156 std::optional<uint32_t> ModuleRtpRtcpImpl2::FlexfecSsrc() const {
    157  if (rtp_sender_) {
    158    return rtp_sender_->packet_generator.FlexfecSsrc();
    159  }
    160  return std::nullopt;
    161 }
    162 
    163 void ModuleRtpRtcpImpl2::IncomingRtcpPacket(
    164    ArrayView<const uint8_t> rtcp_packet) {
    165  RTC_DCHECK_RUN_ON(&rtcp_thread_checker_);
    166  rtcp_receiver_.IncomingPacket(rtcp_packet);
    167 }
    168 
    169 void ModuleRtpRtcpImpl2::RegisterSendPayloadFrequency(int payload_type,
    170                                                      int payload_frequency) {
    171  rtcp_sender_.SetRtpClockRate(payload_type, payload_frequency);
    172 }
    173 
    174 int32_t ModuleRtpRtcpImpl2::DeRegisterSendPayload(
    175    const int8_t /* payload_type */) {
    176  return 0;
    177 }
    178 
    179 uint32_t ModuleRtpRtcpImpl2::StartTimestamp() const {
    180  return rtp_sender_->packet_generator.TimestampOffset();
    181 }
    182 
    183 // Configure start timestamp, default is a random number.
    184 void ModuleRtpRtcpImpl2::SetStartTimestamp(const uint32_t timestamp) {
    185  rtcp_sender_.SetTimestampOffset(timestamp);
    186  rtp_sender_->packet_generator.SetTimestampOffset(timestamp);
    187  rtp_sender_->packet_sender.SetTimestampOffset(timestamp);
    188 }
    189 
    190 uint16_t ModuleRtpRtcpImpl2::SequenceNumber() const {
    191  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    192  return rtp_sender_->sequencer.media_sequence_number();
    193 }
    194 
    195 // Set SequenceNumber, default is a random number.
    196 void ModuleRtpRtcpImpl2::SetSequenceNumber(const uint16_t seq_num) {
    197  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    198  if (rtp_sender_->sequencer.media_sequence_number() != seq_num) {
    199    rtp_sender_->sequencer.set_media_sequence_number(seq_num);
    200    rtp_sender_->packet_history.Clear();
    201  }
    202 }
    203 
    204 void ModuleRtpRtcpImpl2::SetRtpState(const RtpState& rtp_state) {
    205  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    206  rtp_sender_->packet_generator.SetRtpState(rtp_state);
    207  rtp_sender_->sequencer.SetRtpState(rtp_state);
    208  rtcp_sender_.SetTimestampOffset(rtp_state.start_timestamp);
    209  rtp_sender_->packet_sender.SetTimestampOffset(rtp_state.start_timestamp);
    210 }
    211 
    212 void ModuleRtpRtcpImpl2::SetRtxState(const RtpState& rtp_state) {
    213  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    214  rtp_sender_->packet_generator.SetRtxRtpState(rtp_state);
    215  rtp_sender_->sequencer.set_rtx_sequence_number(rtp_state.sequence_number);
    216 }
    217 
    218 RtpState ModuleRtpRtcpImpl2::GetRtpState() const {
    219  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    220  RtpState state = rtp_sender_->packet_generator.GetRtpState();
    221  rtp_sender_->sequencer.PopulateRtpState(state);
    222  return state;
    223 }
    224 
    225 RtpState ModuleRtpRtcpImpl2::GetRtxState() const {
    226  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    227  RtpState state = rtp_sender_->packet_generator.GetRtxRtpState();
    228  state.sequence_number = rtp_sender_->sequencer.rtx_sequence_number();
    229  return state;
    230 }
    231 
    232 void ModuleRtpRtcpImpl2::SetNonSenderRttMeasurement(bool enabled) {
    233  rtcp_sender_.SetNonSenderRttMeasurement(enabled);
    234  rtcp_receiver_.SetNonSenderRttMeasurement(enabled);
    235 }
    236 
    237 uint32_t ModuleRtpRtcpImpl2::local_media_ssrc() const {
    238  RTC_DCHECK_RUN_ON(&rtcp_thread_checker_);
    239  RTC_DCHECK_EQ(rtcp_receiver_.local_media_ssrc(), rtcp_sender_.SSRC());
    240  return rtcp_receiver_.local_media_ssrc();
    241 }
    242 
    243 void ModuleRtpRtcpImpl2::SetMid(absl::string_view mid) {
    244  if (rtp_sender_) {
    245    rtp_sender_->packet_generator.SetMid(mid);
    246  }
    247  // TODO(bugs.webrtc.org/4050): If we end up supporting the MID SDES item for
    248  // RTCP, this will need to be passed down to the RTCPSender also.
    249 }
    250 
    251 // TODO(pbos): Handle media and RTX streams separately (separate RTCP
    252 // feedbacks).
    253 RTCPSender::FeedbackState ModuleRtpRtcpImpl2::GetFeedbackState() {
    254  // TODO(bugs.webrtc.org/11581): Called by potentially multiple threads.
    255  // Mostly "Send*" methods. Make sure it's only called on the
    256  // construction thread.
    257 
    258  RTCPSender::FeedbackState state;
    259  // This is called also when receiver_only is true. Hence below
    260  // checks that rtp_sender_ exists.
    261  if (rtp_sender_) {
    262    StreamDataCounters rtp_stats;
    263    StreamDataCounters rtx_stats;
    264    rtp_sender_->packet_sender.GetDataCounters(&rtp_stats, &rtx_stats);
    265    state.packets_sent =
    266        rtp_stats.transmitted.packets + rtx_stats.transmitted.packets;
    267    state.media_bytes_sent = rtp_stats.transmitted.payload_bytes +
    268                             rtx_stats.transmitted.payload_bytes;
    269    state.send_bitrate =
    270        rtp_sender_->packet_sender.GetSendRates(env_.clock().CurrentTime())
    271            .Sum();
    272  }
    273  state.receiver = &rtcp_receiver_;
    274 
    275  if (std::optional<RtpRtcpInterface::SenderReportStats> last_sr =
    276          rtcp_receiver_.GetSenderReportStats();
    277      last_sr.has_value()) {
    278    state.remote_sr = CompactNtp(last_sr->last_remote_ntp_timestamp);
    279    state.last_rr = last_sr->last_arrival_ntp_timestamp;
    280  }
    281 
    282  state.last_xr_rtis = rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo();
    283 
    284  return state;
    285 }
    286 
    287 int32_t ModuleRtpRtcpImpl2::SetSendingStatus(const bool sending) {
    288  if (rtcp_sender_.Sending() != sending) {
    289    // Sends RTCP BYE when going from true to false
    290    rtcp_sender_.SetSendingStatus(GetFeedbackState(), sending);
    291  }
    292  return 0;
    293 }
    294 
    295 bool ModuleRtpRtcpImpl2::Sending() const {
    296  return rtcp_sender_.Sending();
    297 }
    298 
    299 void ModuleRtpRtcpImpl2::SetSendingMediaStatus(const bool sending) {
    300  rtp_sender_->packet_generator.SetSendingMediaStatus(sending);
    301 }
    302 
    303 bool ModuleRtpRtcpImpl2::SendingMedia() const {
    304  return rtp_sender_ ? rtp_sender_->packet_generator.SendingMedia() : false;
    305 }
    306 
    307 bool ModuleRtpRtcpImpl2::IsAudioConfigured() const {
    308  return rtp_sender_ ? rtp_sender_->packet_generator.IsAudioConfigured()
    309                     : false;
    310 }
    311 
    312 void ModuleRtpRtcpImpl2::SetAsPartOfAllocation(bool part_of_allocation) {
    313  RTC_CHECK(rtp_sender_);
    314  rtp_sender_->packet_sender.ForceIncludeSendPacketsInAllocation(
    315      part_of_allocation);
    316 }
    317 
    318 bool ModuleRtpRtcpImpl2::OnSendingRtpFrame(uint32_t timestamp,
    319                                           int64_t capture_time_ms,
    320                                           int payload_type,
    321                                           bool force_sender_report) {
    322  if (!Sending()) {
    323    return false;
    324  }
    325  // TODO(bugs.webrtc.org/12873): Migrate this method and it's users to use
    326  // optional Timestamps.
    327  std::optional<Timestamp> capture_time;
    328  if (capture_time_ms > 0) {
    329    capture_time = Timestamp::Millis(capture_time_ms);
    330  }
    331  std::optional<int> payload_type_optional;
    332  if (payload_type >= 0)
    333    payload_type_optional = payload_type;
    334 
    335  auto closure = [this, timestamp, capture_time, payload_type_optional,
    336                  force_sender_report] {
    337    RTC_DCHECK_RUN_ON(worker_queue_);
    338    rtcp_sender_.SetLastRtpTime(timestamp, capture_time, payload_type_optional);
    339    // Make sure an RTCP report isn't queued behind a key frame.
    340    if (rtcp_sender_.TimeToSendRTCPReport(force_sender_report))
    341      rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
    342  };
    343  if (worker_queue_->IsCurrent()) {
    344    closure();
    345  } else {
    346    worker_queue_->PostTask(SafeTask(task_safety_.flag(), std::move(closure)));
    347  }
    348  return true;
    349 }
    350 
    351 bool ModuleRtpRtcpImpl2::CanSendPacket(const RtpPacketToSend& packet) const {
    352  RTC_DCHECK(rtp_sender_);
    353  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    354  if (!rtp_sender_->packet_generator.SendingMedia()) {
    355    return false;
    356  }
    357  if (packet.packet_type() == RtpPacketMediaType::kPadding &&
    358      packet.Ssrc() == rtp_sender_->packet_generator.SSRC() &&
    359      !rtp_sender_->sequencer.CanSendPaddingOnMediaSsrc()) {
    360    // New media packet preempted this generated padding packet, discard it.
    361    return false;
    362  }
    363  return true;
    364 }
    365 
    366 void ModuleRtpRtcpImpl2::AssignSequenceNumber(RtpPacketToSend& packet) {
    367  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    368  bool is_flexfec =
    369      packet.packet_type() == RtpPacketMediaType::kForwardErrorCorrection &&
    370      packet.Ssrc() == rtp_sender_->packet_generator.FlexfecSsrc();
    371  if (!is_flexfec) {
    372    rtp_sender_->sequencer.Sequence(packet);
    373  }
    374 }
    375 
    376 void ModuleRtpRtcpImpl2::SendPacket(std::unique_ptr<RtpPacketToSend> packet,
    377                                    const PacedPacketInfo& pacing_info) {
    378  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    379  RTC_DCHECK(CanSendPacket(*packet));
    380  rtp_sender_->packet_sender.SendPacket(std::move(packet), pacing_info);
    381 }
    382 
    383 bool ModuleRtpRtcpImpl2::TrySendPacket(std::unique_ptr<RtpPacketToSend> packet,
    384                                       const PacedPacketInfo& pacing_info) {
    385  if (!packet || !CanSendPacket(*packet)) {
    386    return false;
    387  }
    388  AssignSequenceNumber(*packet);
    389  SendPacket(std::move(packet), pacing_info);
    390  return true;
    391 }
    392 
    393 void ModuleRtpRtcpImpl2::OnBatchComplete() {
    394  RTC_DCHECK(rtp_sender_);
    395  rtp_sender_->packet_sender.OnBatchComplete();
    396 }
    397 
    398 void ModuleRtpRtcpImpl2::SetFecProtectionParams(
    399    const FecProtectionParams& delta_params,
    400    const FecProtectionParams& key_params) {
    401  RTC_DCHECK(rtp_sender_);
    402  rtp_sender_->packet_sender.SetFecProtectionParameters(delta_params,
    403                                                        key_params);
    404 }
    405 
    406 std::vector<std::unique_ptr<RtpPacketToSend>>
    407 ModuleRtpRtcpImpl2::FetchFecPackets() {
    408  RTC_DCHECK(rtp_sender_);
    409  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    410  return rtp_sender_->packet_sender.FetchFecPackets();
    411 }
    412 
    413 void ModuleRtpRtcpImpl2::OnAbortedRetransmissions(
    414    ArrayView<const uint16_t> sequence_numbers) {
    415  RTC_DCHECK(rtp_sender_);
    416  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    417  rtp_sender_->packet_sender.OnAbortedRetransmissions(sequence_numbers);
    418 }
    419 
    420 void ModuleRtpRtcpImpl2::OnPacketsAcknowledged(
    421    ArrayView<const uint16_t> sequence_numbers) {
    422  RTC_DCHECK(rtp_sender_);
    423  rtp_sender_->packet_history.CullAcknowledgedPackets(sequence_numbers);
    424 }
    425 
    426 bool ModuleRtpRtcpImpl2::SupportsPadding() const {
    427  RTC_DCHECK(rtp_sender_);
    428  return rtp_sender_->packet_generator.SupportsPadding();
    429 }
    430 
    431 bool ModuleRtpRtcpImpl2::SupportsRtxPayloadPadding() const {
    432  RTC_DCHECK(rtp_sender_);
    433  return rtp_sender_->packet_generator.SupportsRtxPayloadPadding();
    434 }
    435 
    436 std::vector<std::unique_ptr<RtpPacketToSend>>
    437 ModuleRtpRtcpImpl2::GeneratePadding(size_t target_size_bytes) {
    438  RTC_DCHECK(rtp_sender_);
    439  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    440 
    441  return rtp_sender_->packet_generator.GeneratePadding(
    442      target_size_bytes, rtp_sender_->packet_sender.MediaHasBeenSent(),
    443      rtp_sender_->sequencer.CanSendPaddingOnMediaSsrc());
    444 }
    445 
    446 std::vector<RtpSequenceNumberMap::Info>
    447 ModuleRtpRtcpImpl2::GetSentRtpPacketInfos(
    448    ArrayView<const uint16_t> sequence_numbers) const {
    449  RTC_DCHECK(rtp_sender_);
    450  return rtp_sender_->packet_sender.GetSentRtpPacketInfos(sequence_numbers);
    451 }
    452 
    453 size_t ModuleRtpRtcpImpl2::ExpectedPerPacketOverhead() const {
    454  if (!rtp_sender_) {
    455    return 0;
    456  }
    457  return rtp_sender_->packet_generator.ExpectedPerPacketOverhead();
    458 }
    459 
    460 void ModuleRtpRtcpImpl2::OnPacketSendingThreadSwitched() {
    461  // Ownership of sequencing is being transferred to another thread.
    462  rtp_sender_->sequencing_checker.Detach();
    463 }
    464 
    465 size_t ModuleRtpRtcpImpl2::MaxRtpPacketSize() const {
    466  RTC_DCHECK(rtp_sender_);
    467  return rtp_sender_->packet_generator.MaxRtpPacketSize();
    468 }
    469 
    470 void ModuleRtpRtcpImpl2::SetMaxRtpPacketSize(size_t rtp_packet_size) {
    471  RTC_DCHECK_LE(rtp_packet_size, IP_PACKET_SIZE)
    472      << "rtp packet size too large: " << rtp_packet_size;
    473  RTC_DCHECK_GT(rtp_packet_size, packet_overhead_)
    474      << "rtp packet size too small: " << rtp_packet_size;
    475 
    476  rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
    477  if (rtp_sender_) {
    478    rtp_sender_->packet_generator.SetMaxRtpPacketSize(rtp_packet_size);
    479  }
    480 }
    481 
    482 RtcpMode ModuleRtpRtcpImpl2::RTCP() const {
    483  return rtcp_sender_.Status();
    484 }
    485 
    486 // Configure RTCP status i.e on/off.
    487 void ModuleRtpRtcpImpl2::SetRTCPStatus(const RtcpMode method) {
    488  rtcp_sender_.SetRTCPStatus(method);
    489 }
    490 
    491 int32_t ModuleRtpRtcpImpl2::SetCNAME(absl::string_view c_name) {
    492  return rtcp_sender_.SetCNAME(c_name);
    493 }
    494 
    495 std::optional<TimeDelta> ModuleRtpRtcpImpl2::LastRtt() const {
    496  std::optional<TimeDelta> rtt = rtcp_receiver_.LastRtt();
    497  if (!rtt.has_value()) {
    498    MutexLock lock(&mutex_rtt_);
    499    if (rtt_ms_ > 0) {
    500      rtt = TimeDelta::Millis(rtt_ms_);
    501    }
    502  }
    503  return rtt;
    504 }
    505 
    506 TimeDelta ModuleRtpRtcpImpl2::ExpectedRetransmissionTime() const {
    507  int64_t expected_retransmission_time_ms = rtt_ms();
    508  if (expected_retransmission_time_ms > 0) {
    509    return TimeDelta::Millis(expected_retransmission_time_ms);
    510  }
    511  // No rtt available (`kRttUpdateInterval` not yet passed?), so try to
    512  // poll avg_rtt_ms directly from rtcp receiver.
    513  if (std::optional<TimeDelta> rtt = rtcp_receiver_.AverageRtt()) {
    514    return *rtt;
    515  }
    516  return kDefaultExpectedRetransmissionTime;
    517 }
    518 
    519 // Force a send of an RTCP packet.
    520 // Normal SR and RR are triggered via the process function.
    521 int32_t ModuleRtpRtcpImpl2::SendRTCP(RTCPPacketType packet_type) {
    522  return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
    523 }
    524 
    525 void ModuleRtpRtcpImpl2::GetSendStreamDataCounters(
    526    StreamDataCounters* rtp_counters,
    527    StreamDataCounters* rtx_counters) const {
    528  rtp_sender_->packet_sender.GetDataCounters(rtp_counters, rtx_counters);
    529 }
    530 
    531 // Received RTCP report.
    532 void ModuleRtpRtcpImpl2::RemoteRTCPSenderInfo(
    533    uint32_t* packet_count, uint32_t* octet_count, int64_t* ntp_timestamp_ms,
    534    int64_t* remote_ntp_timestamp_ms) const {
    535  return rtcp_receiver_.RemoteRTCPSenderInfo(
    536      packet_count, octet_count, ntp_timestamp_ms, remote_ntp_timestamp_ms);
    537 }
    538 
    539 std::vector<ReportBlockData> ModuleRtpRtcpImpl2::GetLatestReportBlockData()
    540    const {
    541  return rtcp_receiver_.GetLatestReportBlockData();
    542 }
    543 
    544 std::optional<RtpRtcpInterface::SenderReportStats>
    545 ModuleRtpRtcpImpl2::GetSenderReportStats() const {
    546  return rtcp_receiver_.GetSenderReportStats();
    547 }
    548 
    549 std::optional<RtpRtcpInterface::NonSenderRttStats>
    550 ModuleRtpRtcpImpl2::GetNonSenderRttStats() const {
    551  RTCPReceiver::NonSenderRttStats non_sender_rtt_stats =
    552      rtcp_receiver_.GetNonSenderRTT();
    553  return {{
    554      .round_trip_time = non_sender_rtt_stats.round_trip_time(),
    555      .total_round_trip_time = non_sender_rtt_stats.total_round_trip_time(),
    556      .round_trip_time_measurements =
    557          non_sender_rtt_stats.round_trip_time_measurements(),
    558  }};
    559 }
    560 
    561 // (REMB) Receiver Estimated Max Bitrate.
    562 void ModuleRtpRtcpImpl2::SetRemb(int64_t bitrate_bps,
    563                                 std::vector<uint32_t> ssrcs) {
    564  rtcp_sender_.SetRemb(bitrate_bps, std::move(ssrcs));
    565 }
    566 
    567 void ModuleRtpRtcpImpl2::UnsetRemb() {
    568  rtcp_sender_.UnsetRemb();
    569 }
    570 
    571 void ModuleRtpRtcpImpl2::SetExtmapAllowMixed(bool extmap_allow_mixed) {
    572  rtp_sender_->packet_generator.SetExtmapAllowMixed(extmap_allow_mixed);
    573 }
    574 
    575 void ModuleRtpRtcpImpl2::RegisterRtpHeaderExtension(absl::string_view uri,
    576                                                    int id) {
    577  bool registered =
    578      rtp_sender_->packet_generator.RegisterRtpHeaderExtension(uri, id);
    579  RTC_CHECK(registered);
    580 }
    581 
    582 void ModuleRtpRtcpImpl2::DeregisterSendRtpHeaderExtension(
    583    absl::string_view uri) {
    584  rtp_sender_->packet_generator.DeregisterRtpHeaderExtension(uri);
    585 }
    586 
    587 void ModuleRtpRtcpImpl2::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
    588  rtcp_sender_.SetTmmbn(std::move(bounding_set));
    589 }
    590 
    591 // Send a Negative acknowledgment packet.
    592 int32_t ModuleRtpRtcpImpl2::SendNACK(const uint16_t* nack_list,
    593                                     const uint16_t size) {
    594  uint16_t nack_length = size;
    595  uint16_t start_id = 0;
    596  int64_t now_ms = env_.clock().TimeInMilliseconds();
    597  if (TimeToSendFullNackList(now_ms)) {
    598    nack_last_time_sent_full_ms_ = now_ms;
    599  } else {
    600    // Only send extended list.
    601    if (nack_last_seq_number_sent_ == nack_list[size - 1]) {
    602      // Last sequence number is the same, do not send list.
    603      return 0;
    604    }
    605    // Send new sequence numbers.
    606    for (int i = 0; i < size; ++i) {
    607      if (nack_last_seq_number_sent_ == nack_list[i]) {
    608        start_id = i + 1;
    609        break;
    610      }
    611    }
    612    nack_length = size - start_id;
    613  }
    614 
    615  // Our RTCP NACK implementation is limited to kRtcpMaxNackFields sequence
    616  // numbers per RTCP packet.
    617  if (nack_length > kRtcpMaxNackFields) {
    618    nack_length = kRtcpMaxNackFields;
    619  }
    620  nack_last_seq_number_sent_ = nack_list[start_id + nack_length - 1];
    621 
    622  return rtcp_sender_.SendRTCP(
    623      GetFeedbackState(), kRtcpNack,
    624      MakeArrayView(&nack_list[start_id], nack_length));
    625 }
    626 
    627 void ModuleRtpRtcpImpl2::SendNack(
    628    const std::vector<uint16_t>& sequence_numbers) {
    629  rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, sequence_numbers);
    630 }
    631 
    632 bool ModuleRtpRtcpImpl2::TimeToSendFullNackList(int64_t now) const {
    633  // Use RTT from RtcpRttStats class if provided.
    634  int64_t rtt = rtt_ms();
    635  if (rtt == 0) {
    636    if (std::optional<TimeDelta> average_rtt = rtcp_receiver_.AverageRtt()) {
    637      rtt = average_rtt->ms();
    638    }
    639  }
    640 
    641  const int64_t kStartUpRttMs = 100;
    642  int64_t wait_time = 5 + ((rtt * 3) >> 1);  // 5 + RTT * 1.5.
    643  if (rtt == 0) {
    644    wait_time = kStartUpRttMs;
    645  }
    646 
    647  // Send a full NACK list once within every `wait_time`.
    648  return now - nack_last_time_sent_full_ms_ > wait_time;
    649 }
    650 
    651 // Store the sent packets, needed to answer to Negative acknowledgment requests.
    652 void ModuleRtpRtcpImpl2::SetStorePacketsStatus(const bool enable,
    653                                               const uint16_t number_to_store) {
    654  rtp_sender_->packet_history.SetStorePacketsStatus(
    655      enable ? RtpPacketHistory::StorageMode::kStoreAndCull
    656             : RtpPacketHistory::StorageMode::kDisabled,
    657      number_to_store);
    658 }
    659 
    660 bool ModuleRtpRtcpImpl2::StorePackets() const {
    661  return rtp_sender_->packet_history.GetStorageMode() !=
    662         RtpPacketHistory::StorageMode::kDisabled;
    663 }
    664 
    665 void ModuleRtpRtcpImpl2::SendCombinedRtcpPacket(
    666    std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) {
    667  rtcp_sender_.SendCombinedRtcpPacket(std::move(rtcp_packets));
    668 }
    669 
    670 int32_t ModuleRtpRtcpImpl2::SendLossNotification(uint16_t last_decoded_seq_num,
    671                                                 uint16_t last_received_seq_num,
    672                                                 bool decodability_flag,
    673                                                 bool buffering_allowed) {
    674  return rtcp_sender_.SendLossNotification(
    675      GetFeedbackState(), last_decoded_seq_num, last_received_seq_num,
    676      decodability_flag, buffering_allowed);
    677 }
    678 
    679 void ModuleRtpRtcpImpl2::SetRemoteSSRC(const uint32_t ssrc) {
    680  // Inform about the incoming SSRC.
    681  rtcp_sender_.SetRemoteSSRC(ssrc);
    682  rtcp_receiver_.SetRemoteSSRC(ssrc);
    683 }
    684 
    685 void ModuleRtpRtcpImpl2::SetLocalSsrc(uint32_t local_ssrc) {
    686  RTC_DCHECK_RUN_ON(&rtcp_thread_checker_);
    687  rtcp_receiver_.set_local_media_ssrc(local_ssrc);
    688  rtcp_sender_.SetSsrc(local_ssrc);
    689 }
    690 
    691 RtpSendRates ModuleRtpRtcpImpl2::GetSendRates() const {
    692  RTC_DCHECK_RUN_ON(&rtp_sender_->sequencing_checker);
    693  return rtp_sender_->packet_sender.GetSendRates(env_.clock().CurrentTime());
    694 }
    695 
    696 void ModuleRtpRtcpImpl2::OnRequestSendReport() {
    697  SendRTCP(kRtcpSr);
    698 }
    699 
    700 void ModuleRtpRtcpImpl2::OnReceivedNack(
    701    const std::vector<uint16_t>& nack_sequence_numbers) {
    702  if (!rtp_sender_)
    703    return;
    704 
    705  if (!StorePackets() || nack_sequence_numbers.empty()) {
    706    return;
    707  }
    708  // Use RTT from RtcpRttStats class if provided.
    709  int64_t rtt = rtt_ms();
    710  if (rtt == 0) {
    711    if (std::optional<TimeDelta> average_rtt = rtcp_receiver_.AverageRtt()) {
    712      rtt = average_rtt->ms();
    713    }
    714  }
    715  rtp_sender_->packet_generator.OnReceivedNack(nack_sequence_numbers, rtt);
    716 }
    717 
    718 void ModuleRtpRtcpImpl2::OnReceivedRtcpReportBlocks(
    719    ArrayView<const ReportBlockData> report_blocks) {
    720  if (rtp_sender_) {
    721    uint32_t ssrc = SSRC();
    722    std::optional<uint32_t> rtx_ssrc;
    723    if (rtp_sender_->packet_generator.RtxStatus() != kRtxOff) {
    724      rtx_ssrc = rtp_sender_->packet_generator.RtxSsrc();
    725    }
    726 
    727    for (const ReportBlockData& report_block : report_blocks) {
    728      if (ssrc == report_block.source_ssrc()) {
    729        rtp_sender_->packet_generator.OnReceivedAckOnSsrc(
    730            report_block.extended_highest_sequence_number());
    731      } else if (rtx_ssrc == report_block.source_ssrc()) {
    732        rtp_sender_->packet_generator.OnReceivedAckOnRtxSsrc(
    733            report_block.extended_highest_sequence_number());
    734      }
    735    }
    736  }
    737 }
    738 
    739 void ModuleRtpRtcpImpl2::set_rtt_ms(int64_t rtt_ms) {
    740  RTC_DCHECK_RUN_ON(worker_queue_);
    741  {
    742    MutexLock lock(&mutex_rtt_);
    743    rtt_ms_ = rtt_ms;
    744  }
    745  if (rtp_sender_) {
    746    rtp_sender_->packet_history.SetRtt(TimeDelta::Millis(rtt_ms));
    747  }
    748 }
    749 
    750 int64_t ModuleRtpRtcpImpl2::rtt_ms() const {
    751  MutexLock lock(&mutex_rtt_);
    752  return rtt_ms_;
    753 }
    754 
    755 void ModuleRtpRtcpImpl2::SetVideoBitrateAllocation(
    756    const VideoBitrateAllocation& bitrate) {
    757  rtcp_sender_.SetVideoBitrateAllocation(bitrate);
    758 }
    759 
    760 RTPSender* ModuleRtpRtcpImpl2::RtpSender() {
    761  return rtp_sender_ ? &rtp_sender_->packet_generator : nullptr;
    762 }
    763 
    764 const RTPSender* ModuleRtpRtcpImpl2::RtpSender() const {
    765  return rtp_sender_ ? &rtp_sender_->packet_generator : nullptr;
    766 }
    767 
    768 void ModuleRtpRtcpImpl2::PeriodicUpdate() {
    769  RTC_DCHECK_RUN_ON(worker_queue_);
    770 
    771  Timestamp check_since = env_.clock().CurrentTime() - kRttUpdateInterval;
    772  std::optional<TimeDelta> rtt =
    773      rtcp_receiver_.OnPeriodicRttUpdate(check_since, rtcp_sender_.Sending());
    774  if (rtt) {
    775    if (rtt_stats_) {
    776      rtt_stats_->OnRttUpdate(rtt->ms());
    777    }
    778    set_rtt_ms(rtt->ms());
    779  }
    780 }
    781 
    782 void ModuleRtpRtcpImpl2::MaybeSendRtcp() {
    783  RTC_DCHECK_RUN_ON(worker_queue_);
    784  if (rtcp_sender_.TimeToSendRTCPReport())
    785    rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
    786 }
    787 
    788 // TODO(bugs.webrtc.org/12889): Consider removing this function when the issue
    789 // is resolved.
    790 void ModuleRtpRtcpImpl2::MaybeSendRtcpAtOrAfterTimestamp(
    791    Timestamp execution_time) {
    792  RTC_DCHECK_RUN_ON(worker_queue_);
    793  Timestamp now = env_.clock().CurrentTime();
    794  if (now >= execution_time) {
    795    MaybeSendRtcp();
    796    return;
    797  }
    798 
    799  TimeDelta delta = execution_time - now;
    800  // TaskQueue may run task 1ms earlier, so don't print warning if in this case.
    801  if (delta > TimeDelta::Millis(1)) {
    802    RTC_DLOG(LS_WARNING) << "BUGBUG: Task queue scheduled delayed call "
    803                         << delta << " too early.";
    804  }
    805 
    806  ScheduleMaybeSendRtcpAtOrAfterTimestamp(execution_time, delta);
    807 }
    808 
    809 void ModuleRtpRtcpImpl2::ScheduleRtcpSendEvaluation(TimeDelta duration) {
    810  // We end up here under various sequences including the worker queue, and
    811  // the RTCPSender lock is held.
    812  // We're assuming that the fact that RTCPSender executes under other sequences
    813  // than the worker queue on which it's created on implies that external
    814  // synchronization is present and removes this activity before destruction.
    815  if (duration.IsZero()) {
    816    worker_queue_->PostTask(SafeTask(task_safety_.flag(), [this] {
    817      RTC_DCHECK_RUN_ON(worker_queue_);
    818      MaybeSendRtcp();
    819    }));
    820  } else {
    821    Timestamp execution_time = env_.clock().CurrentTime() + duration;
    822    ScheduleMaybeSendRtcpAtOrAfterTimestamp(execution_time, duration);
    823  }
    824 }
    825 
    826 void ModuleRtpRtcpImpl2::ScheduleMaybeSendRtcpAtOrAfterTimestamp(
    827    Timestamp execution_time,
    828    TimeDelta duration) {
    829  // We end up here under various sequences including the worker queue, and
    830  // the RTCPSender lock is held.
    831  // See note in ScheduleRtcpSendEvaluation about why `worker_queue_` can be
    832  // accessed.
    833  worker_queue_->PostDelayedTask(
    834      SafeTask(task_safety_.flag(),
    835               [this, execution_time] {
    836                 RTC_DCHECK_RUN_ON(worker_queue_);
    837                 MaybeSendRtcpAtOrAfterTimestamp(execution_time);
    838               }),
    839      duration.RoundUpTo(TimeDelta::Millis(1)));
    840 }
    841 
    842 }  // namespace webrtc