Variable audio bitrate.

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 23 matching lines @@
                            const std::string& extension_type,
                            bool rtx,
                            bool red)
     : 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),
       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"),
-      sender_call_(nullptr) {
+                     "BitrateStatsPollingThread") {
   EXPECT_LE(num_audio_streams_, 1u);
   if (rtx_) {
     for (size_t i = 0; i < video_ssrcs_.size(); ++i)
       rtx_ssrc_map_[video_rtx_ssrcs_[i]] = video_ssrcs_[i];
   }
 }
 
 RampUpTester::~RampUpTester() {
   event_.Set();
 }
@@ skipping 113 matching lines @@
     std::vector<AudioReceiveStream::Config>* receive_configs) {
   if (num_audio_streams_ == 0)
     return;
 
   EXPECT_NE(RtpExtension::kTimestampOffsetUri, extension_type_)
       << "Audio BWE not supported with toffset.";
 
   send_config->rtp.ssrc = audio_ssrcs_[0];
   send_config->rtp.extensions.clear();
 
+  send_config->min_bitrate_kbps = 6;
+  send_config->max_bitrate_kbps = 60;
+
   bool transport_cc = false;
   if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
     transport_cc = false;
     send_config->rtp.extensions.push_back(
         RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
   } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
     transport_cc = true;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   }
@@ skipping 59 matching lines @@
   *padding_sent += stream.rtp_stats.transmitted.padding_bytes +
                    stream.rtp_stats.retransmitted.padding_bytes +
                    stream.rtp_stats.fec.padding_bytes;
   *media_sent += stream.rtp_stats.MediaPayloadBytes();
 }
 
 void RampUpTester::TriggerTestDone() {
   RTC_DCHECK_GE(test_start_ms_, 0);
 
   // TODO(holmer): Add audio send stats here too when those APIs are available.
+  if (!send_stream_)
+    return;
+
   VideoSendStream::Stats send_stats = send_stream_->GetStats();
 
   size_t total_packets_sent = 0;
   size_t total_sent = 0;
   size_t padding_sent = 0;
   size_t media_sent = 0;
   for (uint32_t ssrc : video_ssrcs_) {
     AccumulateStats(send_stats.substreams[ssrc], &total_packets_sent,
                     &total_sent, &padding_sent, &media_sent);
   }
@@ skipping 54 matching lines @@
 RampUpDownUpTester::~RampUpDownUpTester() {}
 
 bool RampUpDownUpTester::PollStats() {
   if (send_stream_) {
     webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
     int transmit_bitrate_bps = 0;
     for (auto it : stats.substreams) {
       transmit_bitrate_bps += it.second.total_bitrate_bps;
     }
     EvolveTestState(transmit_bitrate_bps, stats.suspended);
+  } else if (num_audio_streams_ > 0 && sender_call_ != nullptr) {
+    // An audio send stream doesn't have bitrate stats, so the call send BW is
+    // currently used instead.
+    int transmit_bitrate_bps = sender_call_->GetStats().send_bandwidth_bps;
+    EvolveTestState(transmit_bitrate_bps, false);
   }
 
   return !event_.Wait(kPollIntervalMs);
 }
 
 Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
   Call::Config config;
   config.bitrate_config.min_bitrate_bps = 10000;
   return config;
 }
@@ skipping 19 matching lines @@
   str += (rtx_ ? "" : "no");
   str += "rtx";
   return str;
 }
 
 void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
   int64_t now = clock_->TimeInMilliseconds();
   switch (test_state_) {
     case kFirstRampup: {
       EXPECT_FALSE(suspended);
-      if (bitrate_bps > kExpectedHighBitrateBps) {
+      if (bitrate_bps >= kExpectedHighBitrateBps) {
         // The first ramp-up has reached the target bitrate. Change the
         // channel limit, and move to the next test state.
         forward_transport_config_.link_capacity_kbps =
             kLowBandwidthLimitBps / 1000;
         send_transport_->SetConfig(forward_transport_config_);
         test_state_ = kLowRate;
         webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
                                   "first_rampup", now - state_start_ms_, "ms",
                                   false);
         state_start_ms_ = now;
         interval_start_ms_ = now;
         sent_bytes_ = 0;
       }
       break;
     }
     case kLowRate: {
-      if (bitrate_bps < kExpectedLowBitrateBps && suspended) {
+      // Audio streams are never suspended.
+      bool check_suspend_state = num_video_streams_ > 0;
+      if (bitrate_bps < kExpectedLowBitrateBps &&
+          suspended == check_suspend_state) {
         // The ramp-down was successful. Change the channel limit back to a
         // high value, and move to the next test state.
         forward_transport_config_.link_capacity_kbps =
             kHighBandwidthLimitBps / 1000;
         send_transport_->SetConfig(forward_transport_config_);
         test_state_ = kSecondRampup;
         webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
                                   "rampdown", now - state_start_ms_, "ms",
                                   false);
         state_start_ms_ = now;
         interval_start_ms_ = now;
         sent_bytes_ = 0;
       }
       break;
     }
     case kSecondRampup: {
-      if (bitrate_bps > kExpectedHighBitrateBps && !suspended) {
+      if (bitrate_bps >= kExpectedHighBitrateBps && !suspended) {
         webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
                                   "second_rampup", now - state_start_ms_, "ms",
                                   false);
         ReportResult("ramp-up-down-up-average-network-latency",
                      send_transport_->GetAverageDelayMs(), "milliseconds");
         observation_complete_.Set();
       }
       break;
     }
   }
@@ skipping 85 matching lines @@
 
 // TODO(holmer): Enable when audio bitrates are included in the bitrate
 //               allocation.
 TEST_F(RampUpTest, DISABLED_SendSideAudioVideoUpDownUpRtx) {
   RampUpDownUpTester test(3, 1, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
                           false);
   RunBaseTest(&test);
 }
 
+TEST_F(RampUpTest, SendSideAudioOnlyUpDownUpRtx) {
+  RampUpDownUpTester test(0, 1, kStartBitrateBps,
+                          RtpExtension::kTransportSequenceNumberUri, true,
+                          false);
+  RunBaseTest(&test);
+}
+
 TEST_F(RampUpTest, AbsSendTimeSingleStream) {
   RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTimeUri, false, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcast) {
   RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTimeUri, false, false);
   RunBaseTest(&test);
 }
 
@@ skipping 42 matching lines @@
                     true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
                     RtpExtension::kTransportSequenceNumberUri, false, false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc