1 files changed, 42 insertions, 23 deletions

diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
index 577912eb..08422d28 100644
--- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
@@ -59,10 +59,27 @@ class RemoteBitrateEstimatorSingleStream : public RemoteBitrateEstimator {
       ReceiveBandwidthEstimatorStats* output) const OVERRIDE;
 
  private:
-  typedef std::map<unsigned int, OveruseDetector> SsrcOveruseDetectorMap;
+  // Map from SSRC to over-use detector and last incoming packet time in
+  // milliseconds, taken from clock_.
+  typedef std::map<unsigned int, std::pair<OveruseDetector, int64_t> >
+      SsrcOveruseDetectorMap;
+
+  static OveruseDetector* GetDetector(
+      const SsrcOveruseDetectorMap::iterator it) {
+    return &it->second.first;
+  }
+
+  static int64_t GetPacketTimeMs(const SsrcOveruseDetectorMap::iterator it) {
+    return it->second.second;
+  }
+
+  static void SetPacketTimeMs(SsrcOveruseDetectorMap::iterator it,
+                              int64_t time_ms) {
+    it->second.second = time_ms;
+  }
 
   // Triggers a new estimate calculation.
-  void UpdateEstimate(int64_t time_now);
+  void UpdateEstimate(int64_t now_ms);
 
   void GetSsrcs(std::vector<unsigned int>* ssrcs) const;
 
@@ -95,6 +112,7 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket(
   uint32_t ssrc = header.ssrc;
   uint32_t rtp_timestamp = header.timestamp +
       header.extension.transmissionTimeOffset;
+  int64_t now_ms = clock_->TimeInMilliseconds();
   CriticalSectionScoped cs(crit_sect_.get());
   SsrcOveruseDetectorMap::iterator it = overuse_detectors_.find(ssrc);
   if (it == overuse_detectors_.end()) {
@@ -105,22 +123,23 @@ void RemoteBitrateEstimatorSingleStream::IncomingPacket(
     // automatically cleaned up when we have one RemoteBitrateEstimator per REMB
     // group.
     std::pair<SsrcOveruseDetectorMap::iterator, bool> insert_result =
-        overuse_detectors_.insert(std::make_pair(ssrc, OveruseDetector(
-            OverUseDetectorOptions())));
+        overuse_detectors_.insert(std::make_pair(ssrc,
+            std::make_pair(OveruseDetector(OverUseDetectorOptions()), now_ms)));
     it = insert_result.first;
   }
-  OveruseDetector* overuse_detector = &it->second;
-  incoming_bitrate_.Update(payload_size, arrival_time_ms);
+  SetPacketTimeMs(it, now_ms);
+  OveruseDetector* overuse_detector = GetDetector(it);
+  incoming_bitrate_.Update(payload_size, now_ms);
   const BandwidthUsage prior_state = overuse_detector->State();
   overuse_detector->Update(payload_size, -1, rtp_timestamp, arrival_time_ms);
   if (overuse_detector->State() == kBwOverusing) {
-    unsigned int incoming_bitrate = incoming_bitrate_.Rate(arrival_time_ms);
+    unsigned int incoming_bitrate = incoming_bitrate_.Rate(now_ms);
     if (prior_state != kBwOverusing ||
-        remote_rate_.TimeToReduceFurther(arrival_time_ms, incoming_bitrate)) {
+        remote_rate_.TimeToReduceFurther(now_ms, incoming_bitrate)) {
       // 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.
-      UpdateEstimate(arrival_time_ms);
+      UpdateEstimate(now_ms);
     }
   }
 }
@@ -129,8 +148,9 @@ int32_t RemoteBitrateEstimatorSingleStream::Process() {
   if (TimeUntilNextProcess() > 0) {
     return 0;
   }
-  UpdateEstimate(clock_->TimeInMilliseconds());
-  last_process_time_ = clock_->TimeInMilliseconds();
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  UpdateEstimate(now_ms);
+  last_process_time_ = now_ms;
   return 0;
 }
 
@@ -141,25 +161,24 @@ int32_t RemoteBitrateEstimatorSingleStream::TimeUntilNextProcess() {
   return last_process_time_ + kProcessIntervalMs - clock_->TimeInMilliseconds();
 }
 
-void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t time_now) {
+void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t now_ms) {
   CriticalSectionScoped cs(crit_sect_.get());
   BandwidthUsage bw_state = kBwNormal;
   double sum_noise_var = 0.0;
   SsrcOveruseDetectorMap::iterator it = overuse_detectors_.begin();
   while (it != overuse_detectors_.end()) {
-    const int64_t time_of_last_received_packet =
-         it->second.time_of_last_received_packet();
-    if (time_of_last_received_packet >= 0 &&
-        time_now - time_of_last_received_packet > kStreamTimeOutMs) {
+    if (GetPacketTimeMs(it) >= 0 &&
+        now_ms - GetPacketTimeMs(it) > kStreamTimeOutMs) {
       // This over-use detector hasn't received packets for |kStreamTimeOutMs|
       // milliseconds and is considered stale.
       overuse_detectors_.erase(it++);
     } else {
-      sum_noise_var += it->second.NoiseVar();
+      OveruseDetector* overuse_detector = GetDetector(it);
+      sum_noise_var += overuse_detector->NoiseVar();
       // Make sure that we trigger an over-use if any of the over-use detectors
       // is detecting over-use.
-      if (it->second.State() > bw_state) {
-        bw_state = it->second.State();
+      if (overuse_detector->State() > bw_state) {
+        bw_state = overuse_detector->State();
       }
       ++it;
     }
@@ -172,17 +191,17 @@ void RemoteBitrateEstimatorSingleStream::UpdateEstimate(int64_t time_now) {
   double mean_noise_var = sum_noise_var /
       static_cast<double>(overuse_detectors_.size());
   const RateControlInput input(bw_state,
-                               incoming_bitrate_.Rate(time_now),
+                               incoming_bitrate_.Rate(now_ms),
                                mean_noise_var);
-  const RateControlRegion region = remote_rate_.Update(&input, time_now);
-  unsigned int target_bitrate = remote_rate_.UpdateBandwidthEstimate(time_now);
+  const RateControlRegion region = remote_rate_.Update(&input, now_ms);
+  unsigned int target_bitrate = remote_rate_.UpdateBandwidthEstimate(now_ms);
   if (remote_rate_.ValidEstimate()) {
     std::vector<unsigned int> ssrcs;
     GetSsrcs(&ssrcs);
     observer_->OnReceiveBitrateChanged(ssrcs, target_bitrate);
   }
   for (it = overuse_detectors_.begin(); it != overuse_detectors_.end(); ++it) {
-    it->second.SetRateControlRegion(region);
+    GetDetector(it)->SetRateControlRegion(region);
   }
 }