Revert of Refactor NACK bitrate allocation

webrtc/modules/rtp_rtcp/source/receive_statistics_impl.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/modules/rtp_rtcp/source/receive_statistics_impl.h"
 
 #include <math.h>
 
 #include <cstdlib>
 
-#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
+#include "webrtc/modules/rtp_rtcp/source/bitrate.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 
 namespace webrtc {
 
 const int64_t kStatisticsTimeoutMs = 8000;
 const int64_t kStatisticsProcessIntervalMs = 1000;
 
 StreamStatistician::~StreamStatistician() {}
 
 StreamStatisticianImpl::StreamStatisticianImpl(
     Clock* clock,
     RtcpStatisticsCallback* rtcp_callback,
     StreamDataCountersCallback* rtp_callback)
     : clock_(clock),
-      incoming_bitrate_(kStatisticsProcessIntervalMs,
-                        RateStatistics::kBpsScale),
+      incoming_bitrate_(clock, NULL),
       ssrc_(0),
       max_reordering_threshold_(kDefaultMaxReorderingThreshold),
       jitter_q4_(0),
       cumulative_loss_(0),
       jitter_q4_transmission_time_offset_(0),
       last_receive_time_ms_(0),
       last_received_timestamp_(0),
       last_received_transmission_time_offset_(0),
       received_seq_first_(0),
       received_seq_max_(0),
@@ skipping 11 matching lines @@
   UpdateCounters(header, packet_length, retransmitted);
   NotifyRtpCallback();
 }
 
 void StreamStatisticianImpl::UpdateCounters(const RTPHeader& header,
                                             size_t packet_length,
                                             bool retransmitted) {
   rtc::CritScope cs(&stream_lock_);
   bool in_order = InOrderPacketInternal(header.sequenceNumber);
   ssrc_ = header.ssrc;
-  incoming_bitrate_.Update(packet_length, clock_->TimeInMilliseconds());
+  incoming_bitrate_.Update(packet_length);
   receive_counters_.transmitted.AddPacket(packet_length, header);
   if (!in_order && retransmitted) {
     receive_counters_.retransmitted.AddPacket(packet_length, header);
   }
 
   if (receive_counters_.transmitted.packets == 1) {
     received_seq_first_ = header.sequenceNumber;
     receive_counters_.first_packet_time_ms = clock_->TimeInMilliseconds();
   }
 
@@ skipping 218 matching lines @@
 }
 
 void StreamStatisticianImpl::GetReceiveStreamDataCounters(
     StreamDataCounters* data_counters) const {
   rtc::CritScope cs(&stream_lock_);
   *data_counters = receive_counters_;
 }
 
 uint32_t StreamStatisticianImpl::BitrateReceived() const {
   rtc::CritScope cs(&stream_lock_);
-  return incoming_bitrate_.Rate(clock_->TimeInMilliseconds()).value_or(0);
+  return incoming_bitrate_.BitrateNow();
+}
+
+void StreamStatisticianImpl::ProcessBitrate() {
+  rtc::CritScope cs(&stream_lock_);
+  incoming_bitrate_.Process();
 }
 
 void StreamStatisticianImpl::LastReceiveTimeNtp(uint32_t* secs,
                                                 uint32_t* frac) const {
   rtc::CritScope cs(&stream_lock_);
   *secs = last_receive_time_ntp_.seconds();
   *frac = last_receive_time_ntp_.fractions();
 }
 
 bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
@@ skipping 50 matching lines @@
                                   max_reordering_threshold_);
   }
 }
 
 ReceiveStatistics* ReceiveStatistics::Create(Clock* clock) {
   return new ReceiveStatisticsImpl(clock);
 }
 
 ReceiveStatisticsImpl::ReceiveStatisticsImpl(Clock* clock)
     : clock_(clock),
+      last_rate_update_ms_(0),
       rtcp_stats_callback_(NULL),
       rtp_stats_callback_(NULL) {}
 
 ReceiveStatisticsImpl::~ReceiveStatisticsImpl() {
   while (!statisticians_.empty()) {
     delete statisticians_.begin()->second;
     statisticians_.erase(statisticians_.begin());
   }
 }
 
@@ skipping 55 matching lines @@
 
 void ReceiveStatisticsImpl::SetMaxReorderingThreshold(
     int max_reordering_threshold) {
   rtc::CritScope cs(&receive_statistics_lock_);
   for (StatisticianImplMap::iterator it = statisticians_.begin();
        it != statisticians_.end(); ++it) {
     it->second->SetMaxReorderingThreshold(max_reordering_threshold);
   }
 }
 
+void ReceiveStatisticsImpl::Process() {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  for (StatisticianImplMap::iterator it = statisticians_.begin();
+       it != statisticians_.end(); ++it) {
+    it->second->ProcessBitrate();
+  }
+  last_rate_update_ms_ = clock_->TimeInMilliseconds();
+}
+
+int64_t ReceiveStatisticsImpl::TimeUntilNextProcess() {
+  rtc::CritScope cs(&receive_statistics_lock_);
+  int64_t time_since_last_update = clock_->TimeInMilliseconds() -
+      last_rate_update_ms_;
+  return std::max<int64_t>(
+      kStatisticsProcessIntervalMs - time_since_last_update, 0);
+}
+
 void ReceiveStatisticsImpl::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   rtc::CritScope cs(&receive_statistics_lock_);
   if (callback != NULL)
     assert(rtcp_stats_callback_ == NULL);
   rtcp_stats_callback_ = callback;
 }
 
 void ReceiveStatisticsImpl::StatisticsUpdated(const RtcpStatistics& statistics,
                                               uint32_t ssrc) {
@@ skipping 36 matching lines @@
 }
 
 StreamStatistician* NullReceiveStatistics::GetStatistician(
     uint32_t ssrc) const {
   return NULL;
 }
 
 void NullReceiveStatistics::SetMaxReorderingThreshold(
     int max_reordering_threshold) {}
 
+int64_t NullReceiveStatistics::TimeUntilNextProcess() { return 0; }
+
+void NullReceiveStatistics::Process() {}
+
 void NullReceiveStatistics::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {}
 
 void NullReceiveStatistics::RegisterRtpStatisticsCallback(
     StreamDataCountersCallback* callback) {}
 
 }  // namespace webrtc