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

webrtc/video/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 "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> 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,
-                           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),
-      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)),
-      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];
-  }
-}
-
-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(
-    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(
-    VideoSendStream::Config* send_config,
-    std::vector<VideoReceiveStream::Config>* receive_configs,
-    VideoEncoderConfig* encoder_config) {
-  send_config->suspend_below_min_bitrate = true;
-
-  if (num_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) {
-      expected_bitrate_bps_ += encoder_config->streams[i].target_bitrate_bps;
-    }
-  }
-
-  send_config->rtp.extensions.clear();
-
-  bool remb;
-  bool transport_cc;
-  if (extension_type_ == RtpExtension::kAbsSendTime) {
-    remb = true;
-    transport_cc = false;
-    send_config->rtp.extensions.push_back(
-        RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
-  } else if (extension_type_ == RtpExtension::kTransportSequenceNumber) {
-    remb = false;
-    transport_cc = true;
-    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_;
-  if (rtx_) {
-    send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
-    send_config->rtp.rtx.ssrcs = 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.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];
-      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;
-}
-
-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_) {
-      ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
-      observation_complete_.Set();
-    }
-  }
-
-  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);
-}
-
-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_) {
-    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_) {
-    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");
-  }
-}
-
-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_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),
-      test_state_(kFirstRampup),
-      state_start_ms_(clock_->TimeInMilliseconds()),
-      interval_start_ms_(clock_->TimeInMilliseconds()),
-      sent_bytes_(0) {
-  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 += "_";
-  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",
-                                  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",
-                                  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",
-                                  false);
-        observation_complete_.Set();
-      }
-      break;
-    }
-  }
-}
-
-class RampUpTest : public test::CallTest {
- public:
-  RampUpTest() {}
-
-  virtual ~RampUpTest() {
-    EXPECT_EQ(nullptr, send_stream_);
-    EXPECT_TRUE(receive_streams_.empty());
-  }
-};
-
-TEST_F(RampUpTest, SingleStream) {
-  RampUpTester test(1, 0, RtpExtension::kTOffset, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, Simulcast) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, SimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, true, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, SimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTOffset, true, true);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 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) {
-  RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, UpDownUpOneStreamRtx) {
-  RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) {
-  RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) {
-  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);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, AbsSendTimeSimulcast) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
-                    false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
-  RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
-  RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
-  RampUpTester test(1, 0.9 * kSingleStreamTargetBps,
-                    RtpExtension::kTransportSequenceNumber, false, false);
-  RunBaseTest(&test, FakeNetworkPipe::Config());
-}
-}  // namespace webrtc