summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/call/rampup_tests.cc
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libwebrtc/call/rampup_tests.cc')
-rw-r--r--third_party/libwebrtc/call/rampup_tests.cc711
1 files changed, 711 insertions, 0 deletions
diff --git a/third_party/libwebrtc/call/rampup_tests.cc b/third_party/libwebrtc/call/rampup_tests.cc
new file mode 100644
index 0000000000..232fe0b3fe
--- /dev/null
+++ b/third_party/libwebrtc/call/rampup_tests.cc
@@ -0,0 +1,711 @@
+/*
+ * 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 "call/rampup_tests.h"
+
+#include <memory>
+
+#include "absl/flags/flag.h"
+#include "absl/strings/string_view.h"
+#include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/rtc_event_log_output_file.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/task_queue/task_queue_factory.h"
+#include "api/test/metrics/global_metrics_logger_and_exporter.h"
+#include "api/test/metrics/metric.h"
+#include "call/fake_network_pipe.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+#include "rtc_base/platform_thread.h"
+#include "rtc_base/string_encode.h"
+#include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/time_utils.h"
+#include "test/encoder_settings.h"
+#include "test/gtest.h"
+#include "test/video_test_constants.h"
+
+ABSL_FLAG(std::string,
+ ramp_dump_name,
+ "",
+ "Filename for dumped received RTP stream.");
+
+namespace webrtc {
+namespace {
+
+using ::webrtc::test::GetGlobalMetricsLogger;
+using ::webrtc::test::ImprovementDirection;
+using ::webrtc::test::Unit;
+
+constexpr TimeDelta kPollInterval = TimeDelta::Millis(20);
+static const int kExpectedHighVideoBitrateBps = 80000;
+static const int kExpectedHighAudioBitrateBps = 30000;
+static const int kLowBandwidthLimitBps = 20000;
+// Set target detected bitrate to slightly larger than the target bitrate to
+// avoid flakiness.
+static const int kLowBitrateMarginBps = 2000;
+
+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_video_streams,
+ size_t num_audio_streams,
+ size_t num_flexfec_streams,
+ unsigned int start_bitrate_bps,
+ int64_t min_run_time_ms,
+ bool rtx,
+ bool red,
+ bool report_perf_stats,
+ TaskQueueBase* task_queue)
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
+ clock_(Clock::GetRealTimeClock()),
+ num_video_streams_(num_video_streams),
+ num_audio_streams_(num_audio_streams),
+ num_flexfec_streams_(num_flexfec_streams),
+ rtx_(rtx),
+ red_(red),
+ report_perf_stats_(report_perf_stats),
+ sender_call_(nullptr),
+ send_stream_(nullptr),
+ send_transport_(nullptr),
+ send_simulated_network_(nullptr),
+ start_bitrate_bps_(start_bitrate_bps),
+ min_run_time_ms_(min_run_time_ms),
+ expected_bitrate_bps_(0),
+ test_start_ms_(-1),
+ ramp_up_finished_ms_(-1),
+ video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
+ video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
+ audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
+ task_queue_(task_queue) {
+ if (red_)
+ EXPECT_EQ(0u, num_flexfec_streams_);
+ EXPECT_LE(num_audio_streams_, 1u);
+}
+
+RampUpTester::~RampUpTester() = default;
+
+void RampUpTester::ModifySenderBitrateConfig(
+ BitrateConstraints* bitrate_config) {
+ if (start_bitrate_bps_ != 0) {
+ bitrate_config->start_bitrate_bps = start_bitrate_bps_;
+ }
+ bitrate_config->min_bitrate_bps = 10000;
+}
+
+void RampUpTester::OnVideoStreamsCreated(
+ VideoSendStream* send_stream,
+ const std::vector<VideoReceiveStreamInterface*>& receive_streams) {
+ send_stream_ = send_stream;
+}
+
+BuiltInNetworkBehaviorConfig RampUpTester::GetSendTransportConfig() const {
+ return forward_transport_config_;
+}
+
+size_t RampUpTester::GetNumVideoStreams() const {
+ return num_video_streams_;
+}
+
+size_t RampUpTester::GetNumAudioStreams() const {
+ return num_audio_streams_;
+}
+
+size_t RampUpTester::GetNumFlexfecStreams() const {
+ return num_flexfec_streams_;
+}
+
+class RampUpTester::VideoStreamFactory
+ : public VideoEncoderConfig::VideoStreamFactoryInterface {
+ public:
+ VideoStreamFactory() {}
+
+ private:
+ std::vector<VideoStream> CreateEncoderStreams(
+ int frame_width,
+ int frame_height,
+ const VideoEncoderConfig& encoder_config) override {
+ std::vector<VideoStream> streams =
+ test::CreateVideoStreams(frame_width, frame_height, encoder_config);
+ if (encoder_config.number_of_streams == 1) {
+ streams[0].target_bitrate_bps = streams[0].max_bitrate_bps = 2000000;
+ }
+ return streams;
+ }
+};
+
+void RampUpTester::ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) {
+ send_config->suspend_below_min_bitrate = true;
+ encoder_config->number_of_streams = num_video_streams_;
+ encoder_config->max_bitrate_bps = 2000000;
+ encoder_config->video_stream_factory =
+ rtc::make_ref_counted<RampUpTester::VideoStreamFactory>();
+ if (num_video_streams_ == 1) {
+ // For single stream rampup until 1mbps
+ expected_bitrate_bps_ = kSingleStreamTargetBps;
+ } else {
+ // To ensure simulcast rate allocation.
+ send_config->rtp.payload_name = "VP8";
+ encoder_config->codec_type = kVideoCodecVP8;
+ std::vector<VideoStream> streams = test::CreateVideoStreams(
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight, *encoder_config);
+ // For multi stream rampup until all streams are being sent. That means
+ // enough bitrate to send all the target streams plus the min bitrate of
+ // the last one.
+ expected_bitrate_bps_ = streams.back().min_bitrate_bps;
+ for (size_t i = 0; i < streams.size() - 1; ++i) {
+ expected_bitrate_bps_ += streams[i].target_bitrate_bps;
+ }
+ }
+
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ send_config->rtp.ssrcs = video_ssrcs_;
+ if (rtx_) {
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
+ send_config->rtp.rtx.ssrcs = video_rtx_ssrcs_;
+ }
+ if (red_) {
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ if (rtx_) {
+ send_config->rtp.ulpfec.red_rtx_payload_type =
+ test::VideoTestConstants::kRtxRedPayloadType;
+ }
+ }
+
+ size_t i = 0;
+ for (VideoReceiveStreamInterface::Config& recv_config : *receive_configs) {
+ recv_config.decoders.reserve(1);
+ recv_config.decoders[0].payload_type = send_config->rtp.payload_type;
+ recv_config.decoders[0].video_format =
+ SdpVideoFormat(send_config->rtp.payload_name);
+
+ 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.red_payload_type =
+ send_config->rtp.ulpfec.red_payload_type;
+ recv_config.rtp.ulpfec_payload_type =
+ send_config->rtp.ulpfec.ulpfec_payload_type;
+ if (rtx_) {
+ recv_config.rtp.rtx_associated_payload_types
+ [send_config->rtp.ulpfec.red_rtx_payload_type] =
+ send_config->rtp.ulpfec.red_payload_type;
+ }
+ }
+
+ if (rtx_) {
+ recv_config.rtp.rtx_ssrc = video_rtx_ssrcs_[i];
+ recv_config.rtp
+ .rtx_associated_payload_types[send_config->rtp.rtx.payload_type] =
+ send_config->rtp.payload_type;
+ }
+ ++i;
+ }
+
+ RTC_DCHECK_LE(num_flexfec_streams_, 1);
+ if (num_flexfec_streams_ == 1) {
+ send_config->rtp.flexfec.payload_type =
+ test::VideoTestConstants::kFlexfecPayloadType;
+ send_config->rtp.flexfec.ssrc = test::VideoTestConstants::kFlexfecSendSsrc;
+ send_config->rtp.flexfec.protected_media_ssrcs = {video_ssrcs_[0]};
+ }
+}
+
+void RampUpTester::ModifyAudioConfigs(
+ AudioSendStream::Config* send_config,
+ std::vector<AudioReceiveStreamInterface::Config>* receive_configs) {
+ if (num_audio_streams_ == 0)
+ return;
+
+ send_config->rtp.ssrc = audio_ssrcs_[0];
+ send_config->min_bitrate_bps = 6000;
+ send_config->max_bitrate_bps = 60000;
+
+ for (AudioReceiveStreamInterface::Config& recv_config : *receive_configs) {
+ recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
+ }
+}
+
+void RampUpTester::ModifyFlexfecConfigs(
+ std::vector<FlexfecReceiveStream::Config>* receive_configs) {
+ if (num_flexfec_streams_ == 0)
+ return;
+ RTC_DCHECK_EQ(1, num_flexfec_streams_);
+ (*receive_configs)[0].payload_type =
+ test::VideoTestConstants::kFlexfecPayloadType;
+ (*receive_configs)[0].rtp.remote_ssrc =
+ test::VideoTestConstants::kFlexfecSendSsrc;
+ (*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]};
+ (*receive_configs)[0].rtp.local_ssrc = video_ssrcs_[0];
+}
+
+void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
+ RTC_DCHECK(sender_call);
+ sender_call_ = sender_call;
+ pending_task_ = RepeatingTaskHandle::Start(task_queue_, [this] {
+ PollStats();
+ return kPollInterval;
+ });
+}
+
+void RampUpTester::OnTransportCreated(
+ test::PacketTransport* to_receiver,
+ SimulatedNetworkInterface* sender_network,
+ test::PacketTransport* to_sender,
+ SimulatedNetworkInterface* receiver_network) {
+ RTC_DCHECK_RUN_ON(task_queue_);
+
+ send_transport_ = to_receiver;
+ send_simulated_network_ = sender_network;
+}
+
+void RampUpTester::PollStats() {
+ RTC_DCHECK_RUN_ON(task_queue_);
+
+ Call::Stats stats = sender_call_->GetStats();
+ EXPECT_GE(expected_bitrate_bps_, 0);
+
+ if (stats.send_bandwidth_bps >= expected_bitrate_bps_ &&
+ (min_run_time_ms_ == -1 ||
+ clock_->TimeInMilliseconds() - test_start_ms_ >= min_run_time_ms_)) {
+ ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
+ observation_complete_.Set();
+ pending_task_.Stop();
+ }
+}
+
+void RampUpTester::ReportResult(
+ absl::string_view measurement,
+ size_t value,
+ Unit unit,
+ ImprovementDirection improvement_direction) const {
+ GetGlobalMetricsLogger()->LogSingleValueMetric(
+ measurement,
+ ::testing::UnitTest::GetInstance()->current_test_info()->name(), value,
+ unit, improvement_direction);
+}
+
+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);
+
+ // Stop polling stats.
+ // Corner case for webrtc_quick_perf_test
+ SendTask(task_queue_, [this] { pending_task_.Stop(); });
+
+ // TODO(holmer): Add audio send stats here too when those APIs are available.
+ if (!send_stream_)
+ return;
+
+ VideoSendStream::Stats send_stats;
+ SendTask(task_queue_, [&] { send_stats = send_stream_->GetStats(); });
+
+ send_stream_ = nullptr; // To avoid dereferencing a bad pointer.
+
+ 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);
+ }
+
+ 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);
+ }
+
+ if (report_perf_stats_) {
+ ReportResult("ramp-up-media-sent", media_sent, Unit::kBytes,
+ ImprovementDirection::kBiggerIsBetter);
+ ReportResult("ramp-up-padding-sent", padding_sent, Unit::kBytes,
+ ImprovementDirection::kSmallerIsBetter);
+ ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, Unit::kBytes,
+ ImprovementDirection::kBiggerIsBetter);
+ ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, Unit::kBytes,
+ ImprovementDirection::kSmallerIsBetter);
+ if (ramp_up_finished_ms_ >= 0) {
+ ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_,
+ Unit::kMilliseconds, ImprovementDirection::kSmallerIsBetter);
+ }
+ ReportResult("ramp-up-average-network-latency",
+ send_transport_->GetAverageDelayMs(), Unit::kMilliseconds,
+ ImprovementDirection::kSmallerIsBetter);
+ }
+}
+
+void RampUpTester::PerformTest() {
+ test_start_ms_ = clock_->TimeInMilliseconds();
+ EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
+ TriggerTestDone();
+}
+
+RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
+ size_t num_audio_streams,
+ size_t num_flexfec_streams,
+ unsigned int start_bitrate_bps,
+ bool rtx,
+ bool red,
+ const std::vector<int>& loss_rates,
+ bool report_perf_stats,
+ TaskQueueBase* task_queue)
+ : RampUpTester(num_video_streams,
+ num_audio_streams,
+ num_flexfec_streams,
+ start_bitrate_bps,
+ 0,
+ rtx,
+ red,
+ report_perf_stats,
+ task_queue),
+ link_rates_({4 * GetExpectedHighBitrate() / (3 * 1000),
+ kLowBandwidthLimitBps / 1000,
+ 4 * GetExpectedHighBitrate() / (3 * 1000), 0}),
+ test_state_(kFirstRampup),
+ next_state_(kTransitionToNextState),
+ state_start_ms_(clock_->TimeInMilliseconds()),
+ interval_start_ms_(clock_->TimeInMilliseconds()),
+ sent_bytes_(0),
+ loss_rates_(loss_rates) {
+ forward_transport_config_.link_capacity_kbps = link_rates_[test_state_];
+ forward_transport_config_.queue_delay_ms = 100;
+ forward_transport_config_.loss_percent = loss_rates_[test_state_];
+}
+
+RampUpDownUpTester::~RampUpDownUpTester() {}
+
+void RampUpDownUpTester::PollStats() {
+ if (test_state_ == kTestEnd) {
+ pending_task_.Stop();
+ }
+
+ int transmit_bitrate_bps = 0;
+ bool suspended = false;
+ if (num_video_streams_ > 0 && send_stream_) {
+ webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
+ for (const auto& it : stats.substreams) {
+ transmit_bitrate_bps += it.second.total_bitrate_bps;
+ }
+ suspended = stats.suspended;
+ }
+ if (num_audio_streams_ > 0 && sender_call_) {
+ // An audio send stream doesn't have bitrate stats, so the call send BW is
+ // currently used instead.
+ transmit_bitrate_bps = sender_call_->GetStats().send_bandwidth_bps;
+ }
+
+ EvolveTestState(transmit_bitrate_bps, suspended);
+}
+
+void RampUpDownUpTester::ModifyReceiverBitrateConfig(
+ BitrateConstraints* bitrate_config) {
+ bitrate_config->min_bitrate_bps = 10000;
+}
+
+std::string RampUpDownUpTester::GetModifierString() const {
+ std::string str("_");
+ if (num_video_streams_ > 0) {
+ str += rtc::ToString(num_video_streams_);
+ str += "stream";
+ str += (num_video_streams_ > 1 ? "s" : "");
+ str += "_";
+ }
+ if (num_audio_streams_ > 0) {
+ str += rtc::ToString(num_audio_streams_);
+ str += "stream";
+ str += (num_audio_streams_ > 1 ? "s" : "");
+ str += "_";
+ }
+ str += (rtx_ ? "" : "no");
+ str += "rtx_";
+ str += (red_ ? "" : "no");
+ str += "red";
+ return str;
+}
+
+int RampUpDownUpTester::GetExpectedHighBitrate() const {
+ int expected_bitrate_bps = 0;
+ if (num_audio_streams_ > 0)
+ expected_bitrate_bps += kExpectedHighAudioBitrateBps;
+ if (num_video_streams_ > 0)
+ expected_bitrate_bps += kExpectedHighVideoBitrateBps;
+ return expected_bitrate_bps;
+}
+
+size_t RampUpDownUpTester::GetFecBytes() const {
+ size_t flex_fec_bytes = 0;
+ if (num_flexfec_streams_ > 0) {
+ webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
+ for (const auto& kv : stats.substreams)
+ flex_fec_bytes += kv.second.rtp_stats.fec.TotalBytes();
+ }
+ return flex_fec_bytes;
+}
+
+bool RampUpDownUpTester::ExpectingFec() const {
+ return num_flexfec_streams_ > 0 && forward_transport_config_.loss_percent > 0;
+}
+
+void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
+ int64_t now = clock_->TimeInMilliseconds();
+ switch (test_state_) {
+ case kFirstRampup:
+ EXPECT_FALSE(suspended);
+ if (bitrate_bps >= GetExpectedHighBitrate()) {
+ if (report_perf_stats_) {
+ GetGlobalMetricsLogger()->LogSingleValueMetric(
+ "ramp_up_down_up" + GetModifierString(), "first_rampup",
+ now - state_start_ms_, Unit::kMilliseconds,
+ ImprovementDirection::kSmallerIsBetter);
+ }
+ // Apply loss during the transition between states if FEC is enabled.
+ forward_transport_config_.loss_percent = loss_rates_[test_state_];
+ test_state_ = kTransitionToNextState;
+ next_state_ = kLowRate;
+ }
+ break;
+ case kLowRate: {
+ // Audio streams are never suspended.
+ bool check_suspend_state = num_video_streams_ > 0;
+ if (bitrate_bps < kLowBandwidthLimitBps + kLowBitrateMarginBps &&
+ suspended == check_suspend_state) {
+ if (report_perf_stats_) {
+ GetGlobalMetricsLogger()->LogSingleValueMetric(
+ "ramp_up_down_up" + GetModifierString(), "rampdown",
+ now - state_start_ms_, Unit::kMilliseconds,
+ ImprovementDirection::kSmallerIsBetter);
+ }
+ // Apply loss during the transition between states if FEC is enabled.
+ forward_transport_config_.loss_percent = loss_rates_[test_state_];
+ test_state_ = kTransitionToNextState;
+ next_state_ = kSecondRampup;
+ }
+ break;
+ }
+ case kSecondRampup:
+ if (bitrate_bps >= GetExpectedHighBitrate() && !suspended) {
+ if (report_perf_stats_) {
+ GetGlobalMetricsLogger()->LogSingleValueMetric(
+ "ramp_up_down_up" + GetModifierString(), "second_rampup",
+ now - state_start_ms_, Unit::kMilliseconds,
+ ImprovementDirection::kSmallerIsBetter);
+ ReportResult("ramp-up-down-up-average-network-latency",
+ send_transport_->GetAverageDelayMs(),
+ Unit::kMilliseconds,
+ ImprovementDirection::kSmallerIsBetter);
+ }
+ // Apply loss during the transition between states if FEC is enabled.
+ forward_transport_config_.loss_percent = loss_rates_[test_state_];
+ test_state_ = kTransitionToNextState;
+ next_state_ = kTestEnd;
+ }
+ break;
+ case kTestEnd:
+ observation_complete_.Set();
+ break;
+ case kTransitionToNextState:
+ if (!ExpectingFec() || GetFecBytes() > 0) {
+ test_state_ = next_state_;
+ forward_transport_config_.link_capacity_kbps = link_rates_[test_state_];
+ // No loss while ramping up and down as it may affect the BWE
+ // negatively, making the test flaky.
+ forward_transport_config_.loss_percent = 0;
+ state_start_ms_ = now;
+ interval_start_ms_ = now;
+ sent_bytes_ = 0;
+ send_simulated_network_->SetConfig(forward_transport_config_);
+ }
+ break;
+ }
+}
+
+class RampUpTest : public test::CallTest {
+ public:
+ RampUpTest()
+ : task_queue_factory_(CreateDefaultTaskQueueFactory()),
+ rtc_event_log_factory_(task_queue_factory_.get()) {
+ std::string dump_name(absl::GetFlag(FLAGS_ramp_dump_name));
+ if (!dump_name.empty()) {
+ send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+ RtcEventLog::EncodingType::Legacy);
+ recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+ RtcEventLog::EncodingType::Legacy);
+ bool event_log_started =
+ send_event_log_->StartLogging(
+ std::make_unique<RtcEventLogOutputFile>(
+ dump_name + ".send.rtc.dat", RtcEventLog::kUnlimitedOutput),
+ RtcEventLog::kImmediateOutput) &&
+ recv_event_log_->StartLogging(
+ std::make_unique<RtcEventLogOutputFile>(
+ dump_name + ".recv.rtc.dat", RtcEventLog::kUnlimitedOutput),
+ RtcEventLog::kImmediateOutput);
+ RTC_DCHECK(event_log_started);
+ }
+ }
+
+ private:
+ const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
+ RtcEventLogFactory rtc_event_log_factory_;
+};
+
+static const uint32_t kStartBitrateBps = 60000;
+
+TEST_F(RampUpTest, UpDownUpAbsSendTimeSimulcastRedRtx) {
+ std::vector<int> loss_rates = {0, 0, 0, 0};
+ RegisterRtpExtension(
+ RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
+ RampUpDownUpTester test(3, 0, 0, kStartBitrateBps, true, true, loss_rates,
+ true, task_queue());
+ RunBaseTest(&test);
+}
+
+// TODO(bugs.webrtc.org/8878)
+#if defined(WEBRTC_MAC)
+#define MAYBE_UpDownUpTransportSequenceNumberRtx \
+ DISABLED_UpDownUpTransportSequenceNumberRtx
+#else
+#define MAYBE_UpDownUpTransportSequenceNumberRtx \
+ UpDownUpTransportSequenceNumberRtx
+#endif
+TEST_F(RampUpTest, MAYBE_UpDownUpTransportSequenceNumberRtx) {
+ std::vector<int> loss_rates = {0, 0, 0, 0};
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpDownUpTester test(3, 0, 0, kStartBitrateBps, true, false, loss_rates,
+ true, task_queue());
+ RunBaseTest(&test);
+}
+
+// TODO(holmer): Tests which don't report perf stats should be moved to a
+// different executable since they per definition are not perf tests.
+// This test is disabled because it crashes on Linux, and is flaky on other
+// platforms. See: crbug.com/webrtc/7919
+TEST_F(RampUpTest, DISABLED_UpDownUpTransportSequenceNumberPacketLoss) {
+ std::vector<int> loss_rates = {20, 0, 0, 0};
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpDownUpTester test(1, 0, 1, kStartBitrateBps, true, false, loss_rates,
+ false, task_queue());
+ RunBaseTest(&test);
+}
+
+// TODO(bugs.webrtc.org/8878)
+#if defined(WEBRTC_MAC)
+#define MAYBE_UpDownUpAudioVideoTransportSequenceNumberRtx \
+ DISABLED_UpDownUpAudioVideoTransportSequenceNumberRtx
+#else
+#define MAYBE_UpDownUpAudioVideoTransportSequenceNumberRtx \
+ UpDownUpAudioVideoTransportSequenceNumberRtx
+#endif
+TEST_F(RampUpTest, MAYBE_UpDownUpAudioVideoTransportSequenceNumberRtx) {
+ std::vector<int> loss_rates = {0, 0, 0, 0};
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpDownUpTester test(3, 1, 0, kStartBitrateBps, true, false, loss_rates,
+ false, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) {
+ std::vector<int> loss_rates = {0, 0, 0, 0};
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpDownUpTester test(0, 1, 0, kStartBitrateBps, true, false, loss_rates,
+ false, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, TOffsetSimulcastRedRtx) {
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTimestampOffsetUri,
+ kTransmissionTimeOffsetExtensionId));
+ RampUpTester test(3, 0, 0, 0, 0, true, true, true, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, AbsSendTime) {
+ RegisterRtpExtension(
+ RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
+ RampUpTester test(1, 0, 0, 0, 0, false, false, false, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, AbsSendTimeSimulcastRedRtx) {
+ RegisterRtpExtension(
+ RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
+ RampUpTester test(3, 0, 0, 0, 0, true, true, true, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumber) {
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpTester test(1, 0, 0, 0, 0, false, false, false, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpTester test(3, 0, 0, 0, 0, false, false, false, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSimulcastRedRtx) {
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpTester test(3, 0, 0, 0, 0, true, true, true, task_queue());
+ RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, AudioTransportSequenceNumber) {
+ RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
+ RampUpTester test(0, 1, 0, 300000, 10000, false, false, false, task_queue());
+ RunBaseTest(&test);
+}
+
+} // namespace webrtc