Let alr dectector use a budged to detect underuse.

webrtc/modules/pacing/paced_sender.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.
  */
 
 #include "webrtc/modules/pacing/paced_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <queue>
 #include <set>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/pacing/bitrate_prober.h"
+#include "webrtc/modules/pacing/interval_budget.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace {
 // Time limit in milliseconds between packet bursts.
 const int64_t kMinPacketLimitMs = 5;
 
 // Upper cap on process interval, in case process has not been called in a long
 // time.
 const int64_t kMaxIntervalTimeMs = 30;
 
 }  // namespace
 
-// TODO(sprang): Move at least PacketQueue and MediaBudget out to separate
+// TODO(sprang): Move at least PacketQueue out to separate
 // files, so that we can more easily test them.
 
 namespace webrtc {
 namespace paced_sender {
 struct Packet {
   Packet(RtpPacketSender::Priority priority,
          uint32_t ssrc,
          uint16_t seq_number,
          int64_t capture_time_ms,
          int64_t enqueue_time_ms,
@@ skipping 145 matching lines @@
   // Total number of bytes in the queue.
   uint64_t bytes_;
   // Map<ssrc, std::set<seq_no> >, for checking duplicates.
   typedef std::map<uint32_t, std::set<uint16_t> > SsrcSeqNoMap;
   SsrcSeqNoMap dupe_map_;
   const Clock* const clock_;
   int64_t queue_time_sum_;
   int64_t time_last_updated_;
 };
 
-class IntervalBudget {
- public:
-  explicit IntervalBudget(int initial_target_rate_kbps)
-      : target_rate_kbps_(initial_target_rate_kbps),
-        bytes_remaining_(0) {}
-
-  void set_target_rate_kbps(int target_rate_kbps) {
-    target_rate_kbps_ = target_rate_kbps;
-    bytes_remaining_ =
-        std::max(-kWindowMs * target_rate_kbps_ / 8, bytes_remaining_);
-  }
-
-  void IncreaseBudget(int64_t delta_time_ms) {
-    int64_t bytes = target_rate_kbps_ * delta_time_ms / 8;
-    if (bytes_remaining_ < 0) {
-      // We overused last interval, compensate this interval.
-      bytes_remaining_ = bytes_remaining_ + bytes;
-    } else {
-      // If we underused last interval we can't use it this interval.
-      bytes_remaining_ = bytes;
-    }
-  }
-
-  void UseBudget(size_t bytes) {
-    bytes_remaining_ = std::max(bytes_remaining_ - static_cast<int>(bytes),
-                                -kWindowMs * target_rate_kbps_ / 8);
-  }
-
-  size_t bytes_remaining() const {
-    return static_cast<size_t>(std::max(0, bytes_remaining_));
-  }
-
-  int target_rate_kbps() const { return target_rate_kbps_; }
-
- private:
-  static const int kWindowMs = 500;
-
-  int target_rate_kbps_;
-  int bytes_remaining_;
-};
 }  // namespace paced_sender
 
 const int64_t PacedSender::kMaxQueueLengthMs = 2000;
 const float PacedSender::kDefaultPaceMultiplier = 2.5f;
 
 PacedSender::PacedSender(const Clock* clock,
                          PacketSender* packet_sender,
                          RtcEventLog* event_log)
     : clock_(clock),
       packet_sender_(packet_sender),
       alr_detector_(new AlrDetector()),
       paused_(false),
-      media_budget_(new paced_sender::IntervalBudget(0)),
-      padding_budget_(new paced_sender::IntervalBudget(0)),
+      media_budget_(new IntervalBudget(0)),
+      padding_budget_(new IntervalBudget(0)),
       prober_(new BitrateProber(event_log)),
       probing_send_failure_(false),
       estimated_bitrate_bps_(0),
       min_send_bitrate_kbps_(0u),
       max_padding_bitrate_kbps_(0u),
       pacing_bitrate_kbps_(0),
       time_last_update_us_(clock->TimeInMicroseconds()),
       first_sent_packet_ms_(-1),
       packets_(new paced_sender::PacketQueue(clock)),
       packet_counter_(0),
@@ skipping 205 matching lines @@
 
       if (padding_needed > 0)
         bytes_sent += SendPadding(padding_needed, pacing_info);
     }
   }
   if (is_probing) {
     probing_send_failure_ = bytes_sent == 0;
     if (!probing_send_failure_)
       prober_->ProbeSent(clock_->TimeInMilliseconds(), bytes_sent);
   }
-  alr_detector_->OnBytesSent(bytes_sent, now_us / 1000);
+  alr_detector_->OnBytesSent(bytes_sent, elapsed_time_ms);
 }
 
 void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {
   LOG(LS_INFO) << "ProcessThreadAttached 0x" << std::hex << process_thread;
   process_thread_ = process_thread;
 }
 
 bool PacedSender::SendPacket(const paced_sender::Packet& packet,
                              const PacedPacketInfo& pacing_info) {
   if (paused_)
@@ skipping 48 matching lines @@
   rtc::CritScope cs(&critsect_);
   pacing_factor_ = pacing_factor;
 }
 
 void PacedSender::SetQueueTimeLimit(int limit_ms) {
   rtc::CritScope cs(&critsect_);
   queue_time_limit = limit_ms;
 }
 
 }  // namespace webrtc