Step 1 to prepare call_test.* for combined audio/video tests.

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 "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
-#include "webrtc/base/common.h"
-#include "webrtc/base/event.h"
 #include "webrtc/base/platform_thread.h"
-#include "webrtc/modules/pacing/packet_router.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
-#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/test/testsupport/perf_test.h"
-#include "webrtc/video/rampup_tests.h"
 
 namespace webrtc {
 namespace {
 
 static const int64_t kPollIntervalMs = 20;
 
-std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
-                                    uint32_t ssrc_offset) {
+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_streams,
+RampUpTester::RampUpTester(size_t num_video_streams,
+                           size_t num_audio_streams,
                            unsigned int start_bitrate_bps,
                            const std::string& extension_type,
                            bool rtx,
                            bool red)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
       event_(false, false),
       clock_(Clock::GetRealTimeClock()),
-      num_streams_(num_streams),
+      num_video_streams_(num_video_streams),
+      num_audio_streams_(num_audio_streams),
       rtx_(rtx),
       red_(red),
       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),
-      ssrcs_(GenerateSsrcs(num_streams, 100)),
-      rtx_ssrcs_(GenerateSsrcs(num_streams, 200)),
+      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) {
   if (rtx_) {
-    for (size_t i = 0; i < ssrcs_.size(); ++i)
-      rtx_ssrc_map_[rtx_ssrcs_[i]] = ssrcs_[i];
+    for (size_t i = 0; i < video_ssrcs_.size(); ++i)
+      rtx_ssrc_map_[video_rtx_ssrcs_[i]] = video_ssrcs_[i];
   }
 }
 
 RampUpTester::~RampUpTester() {
   event_.Set();
 }
 
 Call::Config RampUpTester::GetSenderCallConfig() {
   Call::Config call_config;
   if (start_bitrate_bps_ != 0) {
     call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
   }
   call_config.bitrate_config.min_bitrate_bps = 10000;
   return call_config;
 }
 
-void RampUpTester::OnStreamsCreated(
+void RampUpTester::OnVideoStreamsCreated(
     VideoSendStream* send_stream,
     const std::vector<VideoReceiveStream*>& receive_streams) {
   send_stream_ = send_stream;
 }
 
 void RampUpTester::OnTransportsCreated(
     test::PacketTransport* send_transport,
     test::PacketTransport* receive_transport) {
   send_transport_ = send_transport;
   send_transport_->SetConfig(forward_transport_config_);
 }
 
-size_t RampUpTester::GetNumStreams() const {
-  return num_streams_;
-}
-
-void RampUpTester::ModifyConfigs(
+void RampUpTester::ModifyVideoConfigs(
     VideoSendStream::Config* send_config,
     std::vector<VideoReceiveStream::Config>* receive_configs,
     VideoEncoderConfig* encoder_config) {
   send_config->suspend_below_min_bitrate = true;
 
-  if (num_streams_ == 1) {
+  if (num_video_streams_ == 1) {
     encoder_config->streams[0].target_bitrate_bps =
         encoder_config->streams[0].max_bitrate_bps = 2000000;
     // For single stream rampup until 1mbps
     expected_bitrate_bps_ = kSingleStreamTargetBps;
   } else {
     // For multi stream rampup until all streams are being sent. That means
     // enough birate to send all the target streams plus the min bitrate of
     // the last one.
     expected_bitrate_bps_ = encoder_config->streams.back().min_bitrate_bps;
     for (size_t i = 0; i < encoder_config->streams.size() - 1; ++i) {
@@ skipping 16 matching lines @@
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   } else {
     remb = true;
     transport_cc = false;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransmissionTimeOffsetExtensionId));
   }
 
   send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
-  send_config->rtp.ssrcs = ssrcs_;
+  send_config->rtp.ssrcs = video_ssrcs_;
   if (rtx_) {
     send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
-    send_config->rtp.rtx.ssrcs = rtx_ssrcs_;
+    send_config->rtp.rtx.ssrcs = video_rtx_ssrcs_;
   }
   if (red_) {
     send_config->rtp.fec.ulpfec_payload_type =
         test::CallTest::kUlpfecPayloadType;
     send_config->rtp.fec.red_payload_type = test::CallTest::kRedPayloadType;
   }
 
   size_t i = 0;
   for (VideoReceiveStream::Config& recv_config : *receive_configs) {
     recv_config.rtp.remb = remb;
     recv_config.rtp.transport_cc = transport_cc;
     recv_config.rtp.extensions = send_config->rtp.extensions;
 
-    recv_config.rtp.remote_ssrc = ssrcs_[i];
+    recv_config.rtp.remote_ssrc = video_ssrcs_[i];
     recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms;
 
     if (red_) {
       recv_config.rtp.fec.red_payload_type =
           send_config->rtp.fec.red_payload_type;
       recv_config.rtp.fec.ulpfec_payload_type =
           send_config->rtp.fec.ulpfec_payload_type;
     }
 
     if (rtx_) {
       recv_config.rtp.rtx[send_config->encoder_settings.payload_type].ssrc =
-          rtx_ssrcs_[i];
+          video_rtx_ssrcs_[i];
       recv_config.rtp.rtx[send_config->encoder_settings.payload_type]
           .payload_type = send_config->rtp.rtx.payload_type;
     }
     ++i;
   }
 }
 
 void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
   sender_call_ = sender_call;
 }
@@ skipping 23 matching lines @@
   }
 
   return !event_.Wait(kPollIntervalMs);
 }
 
 void RampUpTester::ReportResult(const std::string& measurement,
                                 size_t value,
                                 const std::string& units) const {
   webrtc::test::PrintResult(
       measurement, "",
-      ::testing::UnitTest::GetInstance()->current_test_info()->name(),
-      value, units, false);
+      ::testing::UnitTest::GetInstance()->current_test_info()->name(), value,
+      units, false);
 }
 
 void RampUpTester::AccumulateStats(const VideoSendStream::StreamStats& stream,
                                    size_t* total_packets_sent,
                                    size_t* total_sent,
                                    size_t* padding_sent,
                                    size_t* media_sent) const {
   *total_packets_sent += stream.rtp_stats.transmitted.packets +
                          stream.rtp_stats.retransmitted.packets +
                          stream.rtp_stats.fec.packets;
   *total_sent += stream.rtp_stats.transmitted.TotalBytes() +
                  stream.rtp_stats.retransmitted.TotalBytes() +
                  stream.rtp_stats.fec.TotalBytes();
   *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);
 
   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 : ssrcs_) {
+  for (uint32_t ssrc : video_ssrcs_) {
     AccumulateStats(send_stats.substreams[ssrc], &total_packets_sent,
                     &total_sent, &padding_sent, &media_sent);
   }
 
   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 : rtx_ssrcs_) {
+  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");
@@ skipping 12 matching lines @@
   EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
   TriggerTestDone();
   poller_thread_.Stop();
 }
 
 RampUpDownUpTester::RampUpDownUpTester(size_t num_streams,
                                        unsigned int start_bitrate_bps,
                                        const std::string& extension_type,
                                        bool rtx,
                                        bool red)
-    : RampUpTester(num_streams, start_bitrate_bps, extension_type, rtx, red),
+    : RampUpTester(num_streams, 0, start_bitrate_bps, extension_type, rtx, red),
       test_state_(kFirstRampup),
       state_start_ms_(clock_->TimeInMilliseconds()),
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0) {
-  forward_transport_config_.link_capacity_kbps =
-      kHighBandwidthLimitBps / 1000;
+  forward_transport_config_.link_capacity_kbps = kHighBandwidthLimitBps / 1000;
 }
 
 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);
   }
 
   return !event_.Wait(kPollIntervalMs);
 }
 
 Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
   Call::Config config;
   config.bitrate_config.min_bitrate_bps = 10000;
   return config;
 }
 
 std::string RampUpDownUpTester::GetModifierString() const {
   std::string str("_");
-  std::ostringstream s;
-  s << num_streams_;
-  str += s.str();
-  str += "stream";
-  str += (num_streams_ > 1 ? "s" : "");
-  str += "_";
+  if (num_video_streams_ > 0) {
+    std::ostringstream s;
+    s << num_video_streams_;
+    str += s.str();
+    str += "stream";
+    str += (num_video_streams_ > 1 ? "s" : "");
+    str += "_";
+  }
+  if (num_audio_streams_ > 0) {
+    std::ostringstream s;
+    s << num_audio_streams_;
+    str += s.str();
+    str += "stream";
+    str += (num_audio_streams_ > 1 ? "s" : "");
+    str += "_";
+  }
   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) {
         // 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",
+        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) {
         // 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",
+        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) {
-        webrtc::test::PrintResult("ramp_up_down_up",
-                                  GetModifierString(),
-                                  "second_rampup",
-                                  now - state_start_ms_,
-                                  "ms",
+        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+                                  "second_rampup", now - state_start_ms_, "ms",
                                   false);
         observation_complete_.Set();
       }
       break;
     }
   }
 }
 
 class RampUpTest : public test::CallTest {
  public:
   RampUpTest() {}
 
   virtual ~RampUpTest() {
-    EXPECT_EQ(nullptr, send_stream_);
-    EXPECT_TRUE(receive_streams_.empty());
+    EXPECT_EQ(nullptr, video_send_stream_);
+    EXPECT_TRUE(video_receive_streams_.empty());
   }
 };
 
 TEST_F(RampUpTest, SingleStream) {
-  RampUpTester test(1, 0, RtpExtension::kTOffset, false, false);
+  RampUpTester test(1, 0, 0, RtpExtension::kTOffset, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, Simulcast) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, false, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kTOffset, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, true, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kTOffset, true, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, true, true);
+  RampUpTester test(3, 0, 0, RtpExtension::kTOffset, true, true);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
+  RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
                     false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpOneStream) {
   RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreams) {
@@ skipping 15 matching lines @@
   RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, true);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) {
   RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, true);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStream) {
-  RampUpTester test(1, 0, RtpExtension::kAbsSendTime, false, false);
+  RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcast) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, true, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true);
+  RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, true, true);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
-                    false, false);
+  RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
+                    RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
-  RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
+  RampUpTester test(1, 0, 0, RtpExtension::kTransportSequenceNumber, false,
+                    false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, false,
+                    false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
+  RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
+                    false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
+  RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
+                    true);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 0.9 * kSingleStreamTargetBps,
+  RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
                     RtpExtension::kTransportSequenceNumber, false, false);
   RunBaseTest(&test, FakeNetworkPipe::Config());
 }
 }  // namespace webrtc