text: /*
   *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
   *
   *  Use of this source code is governed by a BSD-style license
   *  that can be found in the LICENSE file in the root of the source
   *  tree. An additional intellectual property rights grant can be found
   *  in the file PATENTS.  All contributing project authors may
   *  be found in the AUTHORS file in the root of the source tree.
   */
  
  #include "modules/remote_bitrate_estimator/remote_estimator_proxy.h"
  
  #include <algorithm>
  #include <limits>
  
  #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
  #include "rtc_base/checks.h"
  #include "rtc_base/logging.h"
  #include "rtc_base/numerics/safe_minmax.h"
  #include "system_wrappers/include/clock.h"
  
  namespace webrtc {
  
  // TODO(sprang): Tune these!
  const int RemoteEstimatorProxy::kBackWindowMs = 500;
  const int RemoteEstimatorProxy::kMinSendIntervalMs = 50;
  const int RemoteEstimatorProxy::kMaxSendIntervalMs = 250;
  const int RemoteEstimatorProxy::kDefaultSendIntervalMs = 100;
  
  // The maximum allowed value for a timestamp in milliseconds. This is lower
  // than the numerical limit since we often convert to microseconds.
  static constexpr int64_t kMaxTimeMs =
      std::numeric_limits<int64_t>::max() / 1000;
  
  RemoteEstimatorProxy::RemoteEstimatorProxy(
      Clock* clock,
      TransportFeedbackSenderInterface* feedback_sender)
      : clock_(clock),
        feedback_sender_(feedback_sender),
        last_process_time_ms_(-1),
        media_ssrc_(0),
        feedback_sequence_(0),
        window_start_seq_(-1),
        send_interval_ms_(kDefaultSendIntervalMs),
        send_feedback_on_request_only_(false) {}
  
  RemoteEstimatorProxy::~RemoteEstimatorProxy() {}
  
  void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms,
                                            size_t payload_size,
                                            const RTPHeader& header) {
    if (!header.extension.hasTransportSequenceNumber) {
      RTC_LOG(LS_WARNING)
          << "RemoteEstimatorProxy: Incoming packet "
             "is missing the transport sequence number extension!";
      return;
    }
    rtc::CritScope cs(&lock_);
    media_ssrc_ = header.ssrc;
  
    OnPacketArrival(header.extension.transportSequenceNumber, arrival_time_ms);
  }
  
  bool RemoteEstimatorProxy::LatestEstimate(std::vector<unsigned int>* ssrcs,
                                            unsigned int* bitrate_bps) const {
    return false;
  }
  
  int64_t RemoteEstimatorProxy::TimeUntilNextProcess() {
    int64_t time_until_next = 0;
    if (last_process_time_ms_ != -1) {
      rtc::CritScope cs(&lock_);
      int64_t now = clock_->TimeInMilliseconds();
      if (now - last_process_time_ms_ < send_interval_ms_)
        time_until_next = (last_process_time_ms_ + send_interval_ms_ - now);
    }
    return time_until_next;
  }
  
  void RemoteEstimatorProxy::Process() {
    last_process_time_ms_ = clock_->TimeInMilliseconds();
  
    bool more_to_build = true;
    while (more_to_build) {
      rtcp::TransportFeedback feedback_packet;
      if (BuildFeedbackPacket(&feedback_packet)) {
        RTC_DCHECK(feedback_sender_ != nullptr);
        feedback_sender_->SendTransportFeedback(&feedback_packet);
      } else {
        more_to_build = false;
      }
    }
  }
  
  void RemoteEstimatorProxy::OnBitrateChanged(int bitrate_bps) {
    // TwccReportSize = Ipv4(20B) + UDP(8B) + SRTP(10B) +
    // AverageTwccReport(30B)
    // TwccReport size at 50ms interval is 24 byte.
    // TwccReport size at 250ms interval is 36 byte.
    // AverageTwccReport = (TwccReport(50ms) + TwccReport(250ms)) / 2
    constexpr int kTwccReportSize = 20 + 8 + 10 + 30;
    constexpr double kMinTwccRate =
        kTwccReportSize * 8.0 * 1000.0 / kMaxSendIntervalMs;
    constexpr double kMaxTwccRate =
        kTwccReportSize * 8.0 * 1000.0 / kMinSendIntervalMs;
  
    // Let TWCC reports occupy 5% of total bandwidth.
    rtc::CritScope cs(&lock_);
    send_interval_ms_ = static_cast<int>(
        0.5 + kTwccReportSize * 8.0 * 1000.0 /
                  rtc::SafeClamp(0.05 * bitrate_bps, kMinTwccRate, kMaxTwccRate));
  }
  
  void RemoteEstimatorProxy::SetSendFeedbackOnRequestOnly(
      bool send_feedback_on_request_only) {
    rtc::CritScope cs(&lock_);
    send_feedback_on_request_only_ = send_feedback_on_request_only;
  }
  
  void RemoteEstimatorProxy::OnPacketArrival(uint16_t sequence_number,
                                             int64_t arrival_time) {
    if (arrival_time < 0 || arrival_time > kMaxTimeMs) {
      RTC_LOG(LS_WARNING) << "Arrival time out of bounds: " << arrival_time;
      return;
    }
  
    // TODO(holmer): We should handle a backwards wrap here if the first
    // sequence number was small and the new sequence number is large. The
    // SequenceNumberUnwrapper doesn't do this, so we should replace this with
    // calls to IsNewerSequenceNumber instead.
    int64_t seq = unwrapper_.Unwrap(sequence_number);
    if (window_start_seq_ != -1 && seq > window_start_seq_ + 0xFFFF / 2) {
      RTC_LOG(LS_WARNING) << "Skipping this sequence number (" << sequence_number
                          << ") since it likely is reordered, but the unwrapper"
                             "failed to handle it. Feedback window starts at "
                          << window_start_seq_ << ".";
      return;
    }
  
    if (packet_arrival_times_.lower_bound(window_start_seq_) ==
        packet_arrival_times_.end()) {
      // Start new feedback packet, cull old packets.
      for (auto it = packet_arrival_times_.begin();
           it != packet_arrival_times_.end() && it->first < seq &&
           arrival_time - it->second >= kBackWindowMs;) {
        auto delete_it = it;
        ++it;
        packet_arrival_times_.erase(delete_it);
      }
    }
  
    if (window_start_seq_ == -1) {
      window_start_seq_ = sequence_number;
    } else if (seq < window_start_seq_) {
      window_start_seq_ = seq;
    }
  
    // We are only interested in the first time a packet is received.
    if (packet_arrival_times_.find(seq) != packet_arrival_times_.end())
      return;
  
    packet_arrival_times_[seq] = arrival_time;
  }
  
  bool RemoteEstimatorProxy::BuildFeedbackPacket(
      rtcp::TransportFeedback* feedback_packet) {
    // window_start_seq_ is the first sequence number to include in the current
    // feedback packet. Some older may still be in the map, in case a reordering
    // happens and we need to retransmit them.
    rtc::CritScope cs(&lock_);
    auto it = packet_arrival_times_.lower_bound(window_start_seq_);
    if (it == packet_arrival_times_.end()) {
      // Feedback for all packets already sent.
      return false;
    }
  
    // TODO(sprang): Measure receive times in microseconds and remove the
    // conversions below.
    const int64_t first_sequence = it->first;
    feedback_packet->SetMediaSsrc(media_ssrc_);
    // Base sequence is the expected next (window_start_seq_). This is known, but
    // we might not have actually received it, so the base time shall be the time
    // of the first received packet in the feedback.
    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)) {
        // If we can't even add the first seq to the feedback packet, we won't be
        // able to build it at all.
        RTC_CHECK_NE(first_sequence, it->first);
  
        // Could not add timestamp, feedback packet might be full. Return and
        // try again with a fresh packet.
        break;
      }
  
      // Note: Don't erase items from packet_arrival_times_ after sending, in case
      // they need to be re-sent after a reordering. Removal will be handled
      // by OnPacketArrival once packets are too old.
      window_start_seq_ = it->first + 1;
    }
  
    return true;
  }
  
  }  // namespace webrtc
  