Enable the bayesian bitrate estimator by default.

webrtc/call/rampup_tests.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/call/rampup_tests.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/perf_test.h"
 
 namespace webrtc {
 namespace {
 
 static const int64_t kPollIntervalMs = 20;
 static const int kExpectedHighVideoBitrateBps = 80000;
 static const int kExpectedHighAudioBitrateBps = 30000;
 static const int kLowBandwidthLimitBps = 20000;
 static const int kExpectedLowBitrateBps = 20000;
+static const int kUnlimitedCapacityBps = 10000000;
 
 std::vector<uint32_t> GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) {
   std::vector<uint32_t> ssrcs;
   for (size_t i = 0; i != num_streams; ++i)
     ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
   return ssrcs;
 }
 }  // namespace
 
 RampUpTester::RampUpTester(size_t num_video_streams,
@@ skipping 351 matching lines @@
                                        bool report_perf_stats)
     : RampUpTester(num_video_streams,
                    num_audio_streams,
                    num_flexfec_streams,
                    start_bitrate_bps,
                    0,
                    extension_type,
                    rtx,
                    red,
                    report_perf_stats),
-      link_rates_({GetHighLinkCapacity(), kLowBandwidthLimitBps / 1000,
-                   GetHighLinkCapacity(), 0}),
+      link_rates_({GetExpectedHighBitrate() / 1000,
+                   kLowBandwidthLimitBps / 1000, kUnlimitedCapacityBps / 1000,

[stefan-webrtc, 2017/03/14 16:05:23]

This change is to reduce flakiness in these tests. It can happen that they
toggle a few times close to the high link capacity before we get over the high
bitrate. I think the test is basically as valuable with an unlimited capacity in
the second ramp-up phase.

+                   0}),
       test_state_(kFirstRampup),
       next_state_(kTransitionToNextState),
       state_start_ms_(clock_->TimeInMilliseconds()),
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0),
       loss_rates_(loss_rates) {
   forward_transport_config_.link_capacity_kbps = link_rates_[test_state_];
   forward_transport_config_.queue_delay_ms = 100;
   forward_transport_config_.loss_percent = loss_rates_[test_state_];
 }
@@ skipping 49 matching lines @@
 
 int RampUpDownUpTester::GetExpectedHighBitrate() const {
   int expected_bitrate_bps = 0;
   if (num_audio_streams_ > 0)
     expected_bitrate_bps += kExpectedHighAudioBitrateBps;
   if (num_video_streams_ > 0)
     expected_bitrate_bps += kExpectedHighVideoBitrateBps;
   return expected_bitrate_bps;
 }
 
-int RampUpDownUpTester::GetHighLinkCapacity() const {
-  return 4 * GetExpectedHighBitrate() / (3 * 1000);
-}
-
 size_t RampUpDownUpTester::GetFecBytes() const {
   size_t flex_fec_bytes = 0;
   if (num_flexfec_streams_ > 0) {
     webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
     for (const auto& kv : stats.substreams)
       flex_fec_bytes += kv.second.rtp_stats.fec.TotalBytes();
   }
   return flex_fec_bytes;
 }
 
@@ skipping 159 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AudioTransportSequenceNumber) {
   RampUpTester test(0, 1, 0, 300000, 10000,
                     RtpExtension::kTransportSequenceNumberUri, false, false,
                     false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc