Revert of Make overuse estimator one dimensional.

webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc

 /*
  *  Copyright (c) 2012 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 10 matching lines @@
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 enum { kTimestampGroupLengthMs = 5 };
 static const double kTimestampToMs = 1.0 / 90.0;
 
 struct RemoteBitrateEstimatorSingleStream::Detector {
-  explicit Detector(int64_t last_packet_time_ms, bool enable_burst_grouping)
-      : last_packet_time_ms(last_packet_time_ms),
-        inter_arrival(90 * kTimestampGroupLengthMs,
-                      kTimestampToMs,
-                      enable_burst_grouping),
-        estimator(),
-        detector() {}
+    explicit Detector(int64_t last_packet_time_ms,
+                      const OverUseDetectorOptions& options,
+                      bool enable_burst_grouping)
+        : last_packet_time_ms(last_packet_time_ms),
+          inter_arrival(90 * kTimestampGroupLengthMs, kTimestampToMs,
+                        enable_burst_grouping),
+          estimator(options),
+          detector(options) {}
     int64_t last_packet_time_ms;
     InterArrival inter_arrival;
     OveruseEstimator estimator;
     OveruseDetector detector;
   };
 
   RemoteBitrateEstimatorSingleStream::RemoteBitrateEstimatorSingleStream(
       RemoteBitrateObserver* observer,
       Clock* clock)
       : clock_(clock),
@@ skipping 26 matching lines @@
   CriticalSectionScoped cs(crit_sect_.get());
   SsrcOveruseEstimatorMap::iterator it = overuse_detectors_.find(ssrc);
   if (it == overuse_detectors_.end()) {
     // This is a new SSRC. Adding to map.
     // TODO(holmer): If the channel changes SSRC the old SSRC will still be
     // around in this map until the channel is deleted. This is OK since the
     // callback will no longer be called for the old SSRC. This will be
     // automatically cleaned up when we have one RemoteBitrateEstimator per REMB
     // group.
     std::pair<SsrcOveruseEstimatorMap::iterator, bool> insert_result =
-        overuse_detectors_.insert(
-            std::make_pair(ssrc, new Detector(now_ms, true)));
+        overuse_detectors_.insert(std::make_pair(
+            ssrc, new Detector(now_ms, OverUseDetectorOptions(), true)));
     it = insert_result.first;
   }
   Detector* estimator = it->second;
   estimator->last_packet_time_ms = now_ms;
   incoming_bitrate_.Update(payload_size, now_ms);
   const BandwidthUsage prior_state = estimator->detector.State();
   uint32_t timestamp_delta = 0;
   int64_t time_delta = 0;
+  int size_delta = 0;
   if (estimator->inter_arrival.ComputeDeltas(rtp_timestamp, arrival_time_ms,
-                                             &timestamp_delta, &time_delta)) {
+                                             payload_size, &timestamp_delta,
+                                             &time_delta, &size_delta)) {
     double timestamp_delta_ms = timestamp_delta * kTimestampToMs;
-    estimator->estimator.Update(time_delta, timestamp_delta_ms,
+    estimator->estimator.Update(time_delta, timestamp_delta_ms, size_delta,
                                 estimator->detector.State());
     estimator->detector.Detect(estimator->estimator.offset(),
                                timestamp_delta_ms,
                                estimator->estimator.num_of_deltas(), now_ms);
   }
   if (estimator->detector.State() == kBwOverusing) {
     uint32_t incoming_bitrate_bps = incoming_bitrate_.Rate(now_ms);
     if (prior_state != kBwOverusing ||
         remote_rate_->TimeToReduceFurther(now_ms, incoming_bitrate_bps)) {
       // The first overuse should immediately trigger a new estimate.
@@ skipping 117 matching lines @@
     (*ssrcs)[i] = it->first;
   }
 }
 
 void RemoteBitrateEstimatorSingleStream::SetMinBitrate(int min_bitrate_bps) {
   CriticalSectionScoped cs(crit_sect_.get());
   remote_rate_->SetMinBitrate(min_bitrate_bps);
 }
 
 }  // namespace webrtc