webrtc/video/rampup_tests.cc - Issue 1537273003: Step 1 to prepare call_test.* for combined audio/video tests.

Unified Diff: webrtc/video/rampup_tests.cc

Issue 1537273003: Step 1 to prepare call_test.* for combined audio/video tests. (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Cleanups Created 5 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webrtc/video/rampup_tests.cc

diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc

deleted file mode 100644

index bc5daf522599ed1ee32bb5d6fa306b26c306e9d2..0000000000000000000000000000000000000000

--- a/webrtc/video/rampup_tests.cc

+++ /dev/null

@@ -1,511 +0,0 @@

-/*

- *

- * 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);