Set the start bitrate to the delay-based BWE.

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.
  */
 
@@ skipping 18 matching lines @@
   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,
                            size_t num_audio_streams,
                            unsigned int start_bitrate_bps,
+                           int64_t min_run_time_ms,
                            const std::string& extension_type,
                            bool rtx,
-                           bool red)
+                           bool red,
+                           bool report_perf_stats)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
       event_(false, false),
       clock_(Clock::GetRealTimeClock()),
       num_video_streams_(num_video_streams),
       num_audio_streams_(num_audio_streams),
       rtx_(rtx),
       red_(red),
       sender_call_(nullptr),
       send_stream_(nullptr),
       start_bitrate_bps_(start_bitrate_bps),
-      start_bitrate_verified_(false),
+      min_run_time_ms_(min_run_time_ms),
+      report_perf_stats_(report_perf_stats),
       expected_bitrate_bps_(0),
       test_start_ms_(-1),
       ramp_up_finished_ms_(-1),
       extension_type_(extension_type),
       video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
       video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
       audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
       poller_thread_(&BitrateStatsPollingThread,
                      this,
                      "BitrateStatsPollingThread") {
@@ skipping 183 matching lines @@
 }
 
 bool RampUpTester::BitrateStatsPollingThread(void* obj) {
   return static_cast<RampUpTester*>(obj)->PollStats();
 }
 
 bool RampUpTester::PollStats() {
   if (sender_call_) {
     Call::Stats stats = sender_call_->GetStats();
 
-    RTC_DCHECK_GT(expected_bitrate_bps_, 0);
-    if (!start_bitrate_verified_ && start_bitrate_bps_ != 0) {
-      // For tests with an explicitly set start bitrate, verify the first
-      // bitrate estimate is close to the start bitrate and lower than the
-      // test target bitrate. This is to verify a call respects the configured
-      // start bitrate, but due to the BWE implementation we can't guarantee the
-      // first estimate really is as high as the start bitrate.
-      EXPECT_GT(stats.send_bandwidth_bps, 0.9 * start_bitrate_bps_);
-      start_bitrate_verified_ = true;
-    }
-    if (stats.send_bandwidth_bps >= expected_bitrate_bps_) {
+    EXPECT_GE(stats.send_bandwidth_bps, start_bitrate_bps_);
+    EXPECT_GE(expected_bitrate_bps_, 0);
+    if (stats.send_bandwidth_bps >= expected_bitrate_bps_ &&
+        (min_run_time_ms_ == -1 ||

[terelius, 2017/01/24 16:05:52]

Is min_run_time__= -1 used to signal that there is no minimum run time, and the
test should report the time as soon as it reaches the bitrate? If so, what's the
difference compared to using min_run_time_ = 0 for this.

[stefan-webrtc, 2017/01/24 16:29:43]

Right, I can change it to zero.

+         clock_->TimeInMilliseconds() - test_start_ms_ >= min_run_time_ms_)) {
       ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
       observation_complete_.Set();
     }
   }
 
   return !event_.Wait(kPollIntervalMs);
 }
 
 void RampUpTester::ReportResult(const std::string& measurement,
                                 size_t value,
@@ skipping 41 matching lines @@
 
   size_t rtx_total_packets_sent = 0;
   size_t rtx_total_sent = 0;
   size_t rtx_padding_sent = 0;
   size_t rtx_media_sent = 0;
   for (uint32_t rtx_ssrc : video_rtx_ssrcs_) {
     AccumulateStats(send_stats.substreams[rtx_ssrc], &rtx_total_packets_sent,
                     &rtx_total_sent, &rtx_padding_sent, &rtx_media_sent);
   }
 
-  ReportResult("ramp-up-total-packets-sent", total_packets_sent, "packets");
-  ReportResult("ramp-up-total-sent", total_sent, "bytes");
-  ReportResult("ramp-up-media-sent", media_sent, "bytes");
-  ReportResult("ramp-up-padding-sent", padding_sent, "bytes");
-  ReportResult("ramp-up-rtx-total-packets-sent", rtx_total_packets_sent,
-               "packets");
-  ReportResult("ramp-up-rtx-total-sent", rtx_total_sent, "bytes");
-  ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, "bytes");
-  ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, "bytes");
-  if (ramp_up_finished_ms_ >= 0) {
-    ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_,
-                 "milliseconds");
+  if (report_perf_stats_) {
+    ReportResult("ramp-up-total-packets-sent", total_packets_sent, "packets");
+    ReportResult("ramp-up-total-sent", total_sent, "bytes");
+    ReportResult("ramp-up-media-sent", media_sent, "bytes");
+    ReportResult("ramp-up-padding-sent", padding_sent, "bytes");
+    ReportResult("ramp-up-rtx-total-packets-sent", rtx_total_packets_sent,
+                 "packets");
+    ReportResult("ramp-up-rtx-total-sent", rtx_total_sent, "bytes");
+    ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, "bytes");
+    ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, "bytes");
+    if (ramp_up_finished_ms_ >= 0) {
+      ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_,
+                   "milliseconds");
+    }
+    ReportResult("ramp-up-average-network-latency",
+                 send_transport_->GetAverageDelayMs(), "milliseconds");
   }
-  ReportResult("ramp-up-average-network-latency",
-               send_transport_->GetAverageDelayMs(), "milliseconds");
 }
 
 void RampUpTester::PerformTest() {
   test_start_ms_ = clock_->TimeInMilliseconds();
   poller_thread_.Start();
   EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
   TriggerTestDone();
   poller_thread_.Stop();
 }
 
 RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
                                        size_t num_audio_streams,
                                        unsigned int start_bitrate_bps,
                                        const std::string& extension_type,
                                        bool rtx,
                                        bool red)
     : RampUpTester(num_video_streams,
                    num_audio_streams,
                    start_bitrate_bps,
+                   -1,
                    extension_type,
                    rtx,
-                   red),
+                   red,
+                   true),
       test_state_(kFirstRampup),
       state_start_ms_(clock_->TimeInMilliseconds()),
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0) {
   forward_transport_config_.link_capacity_kbps = GetHighLinkCapacity();
 }
 
 RampUpDownUpTester::~RampUpDownUpTester() {}
 
 bool RampUpDownUpTester::PollStats() {
@@ skipping 143 matching lines @@
 }
 
 TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) {
   RampUpDownUpTester test(0, 1, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
                           false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TOffsetSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, RtpExtension::kTimestampOffsetUri, true, true);
+  RampUpTester test(3, 0, 0, -1, RtpExtension::kTimestampOffsetUri, true, true,
+                    true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTime) {
-  RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTimeUri, false, false);
+  RampUpTester test(1, 0, 0, -1, RtpExtension::kAbsSendTimeUri, false, false,
+                    true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTimeUri, true, true);
+  RampUpTester test(3, 0, 0, -1, RtpExtension::kAbsSendTimeUri, true, true,
+                    true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumber) {
-  RampUpTester test(1, 0, 0, RtpExtension::kTransportSequenceNumberUri, false,
-                    false);
+  RampUpTester test(1, 0, 0, -1, RtpExtension::kTransportSequenceNumberUri,
+                    false, false, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumberUri, false,
-                    false);
+  RampUpTester test(3, 0, 0, -1, RtpExtension::kTransportSequenceNumberUri,
+                    false, false, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumberUri, true,
-                    true);
+  RampUpTester test(3, 0, 0, -1, RtpExtension::kTransportSequenceNumberUri,
+                    true, true, true);
+  RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, AudioTransportSequenceNumber) {
+  RampUpTester test(0, 1, 300000, 10000,
+                    RtpExtension::kTransportSequenceNumberUri, false, false,
+                    false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc