Reset InterArrival if arrival time clock makes a jump.

webrtc/modules/congestion_controller/delay_based_bwe.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 50 matching lines @@
 
 namespace webrtc {
 
 void DelayBasedBwe::AddCluster(std::list<Cluster>* clusters, Cluster* cluster) {
   cluster->send_mean_ms /= static_cast<float>(cluster->count);
   cluster->recv_mean_ms /= static_cast<float>(cluster->count);
   cluster->mean_size /= cluster->count;
   clusters->push_back(*cluster);
 }
 
-DelayBasedBwe::DelayBasedBwe(RemoteBitrateObserver* observer)
-    : observer_(observer),
+DelayBasedBwe::DelayBasedBwe(RemoteBitrateObserver* observer, Clock* clock)
+    : clock_(clock),
+      observer_(observer),
       inter_arrival_(),
       estimator_(),
       detector_(OverUseDetectorOptions()),
       incoming_bitrate_(kBitrateWindowMs, 8000),
       total_probes_received_(0),
       first_packet_time_ms_(-1),
       last_update_ms_(-1),
       ssrcs_() {
   RTC_DCHECK(observer_);
   // NOTE! The BitrateEstimatorTest relies on this EXACT log line.
@@ skipping 113 matching lines @@
     const std::vector<PacketInfo>& packet_feedback_vector) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
   for (const auto& packet_info : packet_feedback_vector) {
     IncomingPacketInfo(packet_info.arrival_time_ms,
                        ConvertMsTo24Bits(packet_info.send_time_ms),
                        packet_info.payload_size, 0,
                        packet_info.probe_cluster_id);
   }
 }
 
-void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
-                                   size_t payload_size,
-                                   const RTPHeader& header) {
-  RTC_DCHECK(network_thread_.CalledOnValidThread());
-  if (!header.extension.hasAbsoluteSendTime) {
-    // NOTE! The BitrateEstimatorTest relies on this EXACT log line.
-    LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTime: Incoming packet "
-                       "is missing absolute send time extension!";
-    return;
-  }
-  IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
-                     payload_size, header.ssrc, PacketInfo::kNotAProbe);
-}
-
-void DelayBasedBwe::IncomingPacket(int64_t arrival_time_ms,
-                                   size_t payload_size,
-                                   const RTPHeader& header,
-                                   int probe_cluster_id) {
-  RTC_DCHECK(network_thread_.CalledOnValidThread());
-  if (!header.extension.hasAbsoluteSendTime) {
-    // NOTE! The BitrateEstimatorTest relies on this EXACT log line.
-    LOG(LS_WARNING) << "RemoteBitrateEstimatorAbsSendTime: Incoming packet "
-                       "is missing absolute send time extension!";
-    return;
-  }
-  IncomingPacketInfo(arrival_time_ms, header.extension.absoluteSendTime,
-                     payload_size, header.ssrc, probe_cluster_id);
-}
-
 void DelayBasedBwe::IncomingPacketInfo(int64_t arrival_time_ms,
                                        uint32_t send_time_24bits,
                                        size_t payload_size,
                                        uint32_t ssrc,
                                        int probe_cluster_id) {
   assert(send_time_24bits < (1ul << 24));
   // Shift up send time to use the full 32 bits that inter_arrival works with,
   // so wrapping works properly.
   uint32_t timestamp = send_time_24bits << kAbsSendTimeInterArrivalUpshift;
   int64_t send_time_ms = static_cast<int64_t>(timestamp) * kTimestampToMs;
 
-  int64_t now_ms = arrival_time_ms;
+  int64_t now_ms = clock_->TimeInMilliseconds();
   // TODO(holmer): SSRCs are only needed for REMB, should be broken out from
   // here.
-  incoming_bitrate_.Update(payload_size, now_ms);
+  incoming_bitrate_.Update(payload_size, arrival_time_ms);
 
   if (first_packet_time_ms_ == -1)
-    first_packet_time_ms_ = arrival_time_ms;
+    first_packet_time_ms_ = now_ms;
 
   uint32_t ts_delta = 0;
   int64_t t_delta = 0;
   int size_delta = 0;
 
   bool update_estimate = false;
   uint32_t target_bitrate_bps = 0;
   std::vector<uint32_t> ssrcs;
   {
     rtc::CritScope lock(&crit_);
@@ skipping 24 matching lines @@
                      << " ms, recv delta=" << recv_delta_ms << " ms.";
       }
       probes_.push_back(
           Probe(send_time_ms, arrival_time_ms, payload_size, probe_cluster_id));
       ++total_probes_received_;
       // Make sure that a probe which updated the bitrate immediately has an
       // effect by calling the OnReceiveBitrateChanged callback.
       if (ProcessClusters(now_ms) == ProbeResult::kBitrateUpdated)
         update_estimate = true;
     }
-    if (inter_arrival_->ComputeDeltas(timestamp, arrival_time_ms, payload_size,
-                                      &ts_delta, &t_delta, &size_delta)) {
+    if (inter_arrival_->ComputeDeltas(timestamp, arrival_time_ms, now_ms,
+                                      payload_size, &ts_delta, &t_delta,
+                                      &size_delta)) {
       double ts_delta_ms = (1000.0 * ts_delta) / (1 << kInterArrivalShift);
       estimator_->Update(t_delta, ts_delta_ms, size_delta, detector_.State());
       detector_.Detect(estimator_->offset(), ts_delta_ms,
                        estimator_->num_of_deltas(), arrival_time_ms);
     }
 
     if (!update_estimate) {
       // Check if it's time for a periodic update or if we should update because
       // of an over-use.
       if (last_update_ms_ == -1 ||
           now_ms - last_update_ms_ > remote_rate_.GetFeedbackInterval()) {
         update_estimate = true;
       } else if (detector_.State() == kBwOverusing) {
-        rtc::Optional<uint32_t> incoming_rate = incoming_bitrate_.Rate(now_ms);
+        rtc::Optional<uint32_t> incoming_rate =
+            incoming_bitrate_.Rate(arrival_time_ms);
         if (incoming_rate &&
             remote_rate_.TimeToReduceFurther(now_ms, *incoming_rate)) {
           update_estimate = true;
         }
       }
     }
 
     if (update_estimate) {
       // The first overuse should immediately trigger a new estimate.
       // We also have to update the estimate immediately if we are overusing
       // and the target bitrate is too high compared to what we are receiving.
       const RateControlInput input(detector_.State(),
-                                   incoming_bitrate_.Rate(now_ms),
+                                   incoming_bitrate_.Rate(arrival_time_ms),
                                    estimator_->var_noise());
       remote_rate_.Update(&input, now_ms);
       target_bitrate_bps = remote_rate_.UpdateBandwidthEstimate(now_ms);
       update_estimate = remote_rate_.ValidEstimate();
       ssrcs = Keys(ssrcs_);
     }
   }
   if (update_estimate) {
     last_update_ms_ = now_ms;
     observer_->OnReceiveBitrateChanged(ssrcs, target_bitrate_bps);
@@ skipping 57 matching lines @@
   return true;
 }
 
 void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) {
   // Called from both the configuration thread and the network thread. Shouldn't
   // be called from the network thread in the future.
   rtc::CritScope lock(&crit_);
   remote_rate_.SetMinBitrate(min_bitrate_bps);
 }
 }  // namespace webrtc