Change TWCC send interval to reduce overhead on low BW situations.

webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc

 /*
  *  Copyright (c) 2015 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/remote_bitrate_estimator/remote_estimator_proxy.h"
 
 #include <limits>
+#include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 
 namespace webrtc {
 
 // TODO(sprang): Tune these!
-const int RemoteEstimatorProxy::kDefaultProcessIntervalMs = 50;
 const int RemoteEstimatorProxy::kBackWindowMs = 500;
+const int RemoteEstimatorProxy::kMinSendIntervalMs = 50;
+const int RemoteEstimatorProxy::kMaxSendIntervalMs = 250;
+const int RemoteEstimatorProxy::kDefaultSendIntervalMs = 100;
 
 // The maximum allowed value for a timestamp in milliseconds. This is lower
 // than the numerical limit since we often convert to microseconds.
 static constexpr int64_t kMaxTimeMs =
     std::numeric_limits<int64_t>::max() / 1000;
 
 RemoteEstimatorProxy::RemoteEstimatorProxy(Clock* clock,
                                            PacketRouter* packet_router)
     : clock_(clock),
       packet_router_(packet_router),
@@ skipping 24 matching lines @@
 
   OnPacketArrival(header.extension.transportSequenceNumber, arrival_time_ms);
 }
 
 bool RemoteEstimatorProxy::LatestEstimate(std::vector<unsigned int>* ssrcs,
                                           unsigned int* bitrate_bps) const {
   return false;
 }
 
 int64_t RemoteEstimatorProxy::TimeUntilNextProcess() {
-  int64_t now = clock_->TimeInMilliseconds();
   int64_t time_until_next = 0;
-  if (last_process_time_ms_ != -1 &&
-      now - last_process_time_ms_ < kDefaultProcessIntervalMs) {
-    time_until_next = (last_process_time_ms_ + kDefaultProcessIntervalMs - now);
+  if (last_process_time_ms_ != -1) {
+    int send_interval_ms = kDefaultSendIntervalMs;
+    if (bitrate_bps_) {
+      // TwccReportSize = Ipv4(20B) + UDP(8B) + SRTP(10B) +
+      // AverageTwccReport(30B)
+      // TwccReport size at 50ms interval is 24 byte.
+      // TwccReport size at 250ms interval is 36 byte.
+      // AverageTwccReport = (TwccReport(50ms) + TwccReport(250ms)) / 2
+      constexpr int kTwccReportSize = 20 + 8 + 10 + 30;
+      send_interval_ms = static_cast<int>(
+          kTwccReportSize * 8.0 * 1000.0 / (0.05 * *bitrate_bps_) + 0.5);
+      send_interval_ms = std::min(
+          std::max(send_interval_ms, kMinSendIntervalMs), kMaxSendIntervalMs);
+    }
+    int64_t now = clock_->TimeInMilliseconds();
+    if (now - last_process_time_ms_ < send_interval_ms)
+      time_until_next = (last_process_time_ms_ + send_interval_ms - now);
   }
   return time_until_next;
 }
 
 void RemoteEstimatorProxy::Process() {
   last_process_time_ms_ = clock_->TimeInMilliseconds();
 
   bool more_to_build = true;
   while (more_to_build) {
     rtcp::TransportFeedback feedback_packet;
     if (BuildFeedbackPacket(&feedback_packet)) {
       RTC_DCHECK(packet_router_ != nullptr);
       packet_router_->SendFeedback(&feedback_packet);
     } else {
       more_to_build = false;
     }
   }
 }
 
+void RemoteEstimatorProxy::OnBitrateChanged(int bitrate_bps) {
+  bitrate_bps_ = rtc::Optional<int>(bitrate_bps);

[stefan-webrtc, 2016/11/02 13:10:24]

Is this accessed on the same thread as TimeUntilNextProcess? In that case we may
want to use a SequenceChecker to verify. Otherwise you'll need to lock.

[michaelt, 2016/11/02 14:28:02]

Done.

+}
+
 void RemoteEstimatorProxy::OnPacketArrival(uint16_t sequence_number,
                                            int64_t arrival_time) {
   if (arrival_time < 0 || arrival_time > kMaxTimeMs) {
     LOG(LS_WARNING) << "Arrival time out of bounds: " << arrival_time;
     return;
   }
 
   // TODO(holmer): We should handle a backwards wrap here if the first
   // sequence number was small and the new sequence number is large. The
   // SequenceNumberUnwrapper doesn't do this, so we should replace this with
@@ skipping 69 matching lines @@
     // Note: Don't erase items from packet_arrival_times_ after sending, in case
     // they need to be re-sent after a reordering. Removal will be handled
     // by OnPacketArrival once packets are too old.
     window_start_seq_ = it->first + 1;
   }
 
   return true;
 }
 
 }  // namespace webrtc