Remove dependency of video_replay on TestADM.
This should remove requirement to build TestADM in chromium build.
Bug: b/272350185, webrtc:15081
Change-Id: Iceb8862aa81099c22bd378ae692229f01ab3314c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/302380
Reviewed-by: Henrik Andreassson <henrika@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39934}
diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index 1a06502..0f0e792 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -139,6 +139,7 @@
"../system_wrappers",
"../test:test_common",
"../test:test_support",
+ "../test:video_test_constants",
]
}
@@ -216,6 +217,7 @@
"../test:scoped_key_value_config",
"../test:test_common",
"../test:test_support",
+ "../test:video_test_constants",
"../test/time_controller:time_controller",
"utility:utility_tests",
"//testing/gtest",
@@ -277,6 +279,7 @@
"../test:test_common",
"../test:test_main",
"../test:test_support",
+ "../test:video_test_constants",
"../test/pc/e2e:network_quality_metrics_reporter",
"//testing/gtest",
]
diff --git a/audio/audio_send_stream_tests.cc b/audio/audio_send_stream_tests.cc
index 2ec7229..1337a01 100644
--- a/audio/audio_send_stream_tests.cc
+++ b/audio/audio_send_stream_tests.cc
@@ -19,6 +19,7 @@
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace test {
@@ -31,7 +32,7 @@
class AudioSendTest : public SendTest {
public:
- AudioSendTest() : SendTest(CallTest::kDefaultTimeout) {}
+ AudioSendTest() : SendTest(VideoTestConstants::kDefaultTimeout) {}
size_t GetNumVideoStreams() const override { return 0; }
size_t GetNumAudioStreams() const override { return 1; }
diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc
index 97acf93..b1e2712 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -19,6 +19,7 @@
#include "modules/audio_device/include/test_audio_device.h"
#include "system_wrappers/include/sleep.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace test {
@@ -29,7 +30,7 @@
} // namespace
AudioEndToEndTest::AudioEndToEndTest()
- : EndToEndTest(CallTest::kDefaultTimeout) {}
+ : EndToEndTest(VideoTestConstants::kDefaultTimeout) {}
size_t AudioEndToEndTest::GetNumVideoStreams() const {
return 0;
@@ -66,7 +67,7 @@
const webrtc::SdpAudioFormat kDefaultFormat("opus", 48000, 2,
{{"stereo", "1"}});
send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- test::CallTest::kAudioSendPayloadType, kDefaultFormat);
+ test::VideoTestConstants::kAudioSendPayloadType, kDefaultFormat);
send_config->min_bitrate_bps = 32000;
send_config->max_bitrate_bps = 32000;
}
diff --git a/audio/test/low_bandwidth_audio_test.cc b/audio/test/low_bandwidth_audio_test.cc
index 3cc90f7..903f482 100644
--- a/audio/test/low_bandwidth_audio_test.cc
+++ b/audio/test/low_bandwidth_audio_test.cc
@@ -14,6 +14,7 @@
#include "audio/test/audio_end_to_end_test.h"
#include "system_wrappers/include/sleep.h"
#include "test/testsupport/file_utils.h"
+#include "test/video_test_constants.h"
ABSL_DECLARE_FLAG(int, sample_rate_hz);
ABSL_DECLARE_FLAG(bool, quick);
@@ -78,7 +79,7 @@
std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override {
send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- test::CallTest::kAudioSendPayloadType,
+ test::VideoTestConstants::kAudioSendPayloadType,
{"OPUS",
48000,
2,
diff --git a/call/BUILD.gn b/call/BUILD.gn
index bf22820..c40cfcf 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -532,6 +532,7 @@
"../test:scoped_key_value_config",
"../test:test_common",
"../test:test_support",
+ "../test:video_test_constants",
"../test/scenario",
"../test/time_controller:time_controller",
"../video",
@@ -606,6 +607,7 @@
"../test:test_common",
"../test:test_support",
"../test:video_test_common",
+ "../test:video_test_constants",
"../video",
"../video/config:encoder_config",
"//testing/gtest",
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 58605b9..f44cdfd 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -29,6 +29,7 @@
#include "test/fake_encoder.h"
#include "test/frame_generator_capturer.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -80,7 +81,9 @@
}
}
- bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeout); }
+ bool Wait() {
+ return done_.Wait(test::VideoTestConstants::kDefaultTimeout);
+ }
void PushExpectedLogLine(absl::string_view expected_log_line) {
MutexLock lock(&mutex_);
@@ -122,13 +125,15 @@
/*observer=*/nullptr);
VideoSendStream::Config video_send_config(send_transport_.get());
- video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
+ video_send_config.rtp.ssrcs.push_back(
+ test::VideoTestConstants::kVideoSendSsrcs[0]);
video_send_config.encoder_settings.encoder_factory =
&fake_encoder_factory_;
video_send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_send_config.rtp.payload_name = "FAKE";
- video_send_config.rtp.payload_type = kFakeVideoSendPayloadType;
+ video_send_config.rtp.payload_type =
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
SetVideoSendConfig(video_send_config);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
@@ -138,7 +143,8 @@
VideoReceiveStreamInterface::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately.
receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0];
- receive_config_.rtp.local_ssrc = kReceiverLocalVideoSsrc;
+ receive_config_.rtp.local_ssrc =
+ test::VideoTestConstants::kReceiverLocalVideoSsrc;
});
}
@@ -173,9 +179,12 @@
frame_generator_capturer_ =
std::make_unique<test::FrameGeneratorCapturer>(
test->clock_,
- test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight,
- absl::nullopt, absl::nullopt),
- kDefaultFramerate, *test->task_queue_factory_);
+ test::CreateSquareFrameGenerator(
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight, absl::nullopt,
+ absl::nullopt),
+ test::VideoTestConstants::kDefaultFramerate,
+ *test->task_queue_factory_);
frame_generator_capturer_->Init();
send_stream_->SetSource(frame_generator_capturer_.get(),
DegradationPreference::MAINTAIN_FRAMERATE);
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index cc58772..c07eed7 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -54,6 +54,7 @@
#include "test/rtp_rtcp_observer.h"
#include "test/testsupport/file_utils.h"
#include "test/video_encoder_proxy_factory.h"
+#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h"
#include "video/transport_adapter.h"
@@ -116,7 +117,7 @@
explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue,
Clock* clock,
absl::string_view test_label)
- : test::RtpRtcpObserver(CallPerfTest::kLongTimeout),
+ : test::RtpRtcpObserver(test::VideoTestConstants::kLongTimeout),
clock_(clock),
test_label_(test_label),
creation_time_ms_(clock_->TimeInMilliseconds()),
@@ -274,31 +275,37 @@
audio_send_config.rtp.ssrc = kAudioSendSsrc;
// TODO(bugs.webrtc.org/14683): Let the tests fail with invalid config.
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- kAudioSendPayloadType, {"OPUS", 48000, 2});
+ test::VideoTestConstants::kAudioSendPayloadType, {"OPUS", 48000, 2});
audio_send_config.min_bitrate_bps = 6000;
audio_send_config.max_bitrate_bps = 510000;
audio_send_config.encoder_factory = CreateBuiltinAudioEncoderFactory();
audio_send_stream = sender_call_->CreateAudioSendStream(audio_send_config);
- GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ GetVideoSendConfig()->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
if (fec == FecMode::kOn) {
- GetVideoSendConfig()->rtp.ulpfec.red_payload_type = kRedPayloadType;
- GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
- video_receive_configs_[0].rtp.red_payload_type = kRedPayloadType;
- video_receive_configs_[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
+ GetVideoSendConfig()->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
+ video_receive_configs_[0].rtp.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ video_receive_configs_[0].rtp.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
}
video_receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
video_receive_configs_[0].renderer = observer.get();
video_receive_configs_[0].sync_group = kSyncGroup;
AudioReceiveStreamInterface::Config audio_recv_config;
- audio_recv_config.rtp.remote_ssrc = kAudioSendSsrc;
+ audio_recv_config.rtp.remote_ssrc =
+ test::VideoTestConstants::kAudioSendSsrc;
audio_recv_config.rtp.local_ssrc = kAudioRecvSsrc;
audio_recv_config.rtcp_send_transport = receive_transport.get();
audio_recv_config.sync_group = kSyncGroup;
audio_recv_config.decoder_factory = audio_decoder_factory_;
audio_recv_config.decoder_map = {
- {kAudioSendPayloadType, {"OPUS", 48000, 2}}};
+ {test::VideoTestConstants::kAudioSendPayloadType, {"OPUS", 48000, 2}}};
if (create_first == CreateOrder::kAudioFirst) {
audio_receive_stream =
@@ -312,9 +319,11 @@
EXPECT_EQ(1u, video_receive_streams_.size());
observer->set_receive_stream(video_receive_streams_[0]);
drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed);
- CreateFrameGeneratorCapturerWithDrift(drifting_clock.get(), video_rtp_speed,
- kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturerWithDrift(
+ drifting_clock.get(), video_rtp_speed,
+ test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
Start();
@@ -405,7 +414,7 @@
int threshold_ms,
int start_time_ms,
int run_time_ms)
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
net_config_(net_config),
clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms),
@@ -558,7 +567,9 @@
class LoadObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
public:
- LoadObserver() : SendTest(kLongTimeout), test_phase_(TestPhase::kInit) {}
+ LoadObserver()
+ : SendTest(test::VideoTestConstants::kLongTimeout),
+ test_phase_(TestPhase::kInit) {}
void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override {
@@ -667,7 +678,7 @@
public:
explicit BitrateObserver(bool using_min_transmit_bitrate,
TaskQueueBase* task_queue)
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
send_stream_(nullptr),
converged_(false),
pad_to_min_bitrate_(using_min_transmit_bitrate),
@@ -794,7 +805,7 @@
class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
public:
explicit BitrateObserver(TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
encoder_inits_(0),
last_set_bitrate_kbps_(0),
@@ -818,11 +829,11 @@
: kInitialBitrateKbps - kInitialBitrateOverheadKpbs;
EXPECT_EQ(expected_bitrate, config->startBitrate)
<< "Encoder not initialized at expected bitrate.";
- EXPECT_EQ(kDefaultWidth, config->width);
- EXPECT_EQ(kDefaultHeight, config->height);
+ EXPECT_EQ(test::VideoTestConstants::kDefaultWidth, config->width);
+ EXPECT_EQ(test::VideoTestConstants::kDefaultHeight, config->height);
} else if (encoder_inits_ == 2) {
- EXPECT_EQ(2 * kDefaultWidth, config->width);
- EXPECT_EQ(2 * kDefaultHeight, config->height);
+ EXPECT_EQ(2 * test::VideoTestConstants::kDefaultWidth, config->width);
+ EXPECT_EQ(2 * test::VideoTestConstants::kDefaultHeight, config->height);
EXPECT_GE(last_set_bitrate_kbps_, kReconfigureThresholdKbps);
EXPECT_GT(config->startBitrate, kReconfigureThresholdKbps)
<< "Encoder reconfigured with bitrate too far away from last set.";
@@ -871,9 +882,12 @@
}
void PerformTest() override {
- ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeout))
+ ASSERT_TRUE(
+ time_to_reconfigure_.Wait(test::VideoTestConstants::kDefaultTimeout))
<< "Timed out before receiving an initial high bitrate.";
- frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
+ frame_generator_->ChangeResolution(
+ test::VideoTestConstants::kDefaultWidth * 2,
+ test::VideoTestConstants::kDefaultHeight * 2);
SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
@@ -1057,7 +1071,7 @@
absl::string_view payload_name,
const std::vector<int>& max_framerates,
TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
encoder_factory_(encoder_factory),
payload_name_(payload_name),
@@ -1096,7 +1110,8 @@
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
encoder_config->video_format.name = payload_name_;
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->max_bitrate_bps = kMaxBitrate.bps();
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index 3c89670..8ddce83 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -30,6 +30,7 @@
#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,
@@ -69,7 +70,7 @@
bool red,
bool report_perf_stats,
TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
@@ -163,8 +164,8 @@
send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8;
std::vector<VideoStream> streams = test::CreateVideoStreams(
- test::CallTest::kDefaultWidth, test::CallTest::kDefaultHeight,
- *encoder_config);
+ 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.
@@ -174,19 +175,22 @@
}
}
- send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
+ 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::CallTest::kSendRtxPayloadType;
+ 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::CallTest::kUlpfecPayloadType;
- send_config->rtp.ulpfec.red_payload_type = test::CallTest::kRedPayloadType;
+ test::VideoTestConstants::kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
if (rtx_) {
send_config->rtp.ulpfec.red_rtx_payload_type =
- test::CallTest::kRtxRedPayloadType;
+ test::VideoTestConstants::kRtxRedPayloadType;
}
}
@@ -223,8 +227,9 @@
RTC_DCHECK_LE(num_flexfec_streams_, 1);
if (num_flexfec_streams_ == 1) {
- send_config->rtp.flexfec.payload_type = test::CallTest::kFlexfecPayloadType;
- send_config->rtp.flexfec.ssrc = test::CallTest::kFlexfecSendSsrc;
+ 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]};
}
}
@@ -249,8 +254,10 @@
if (num_flexfec_streams_ == 0)
return;
RTC_DCHECK_EQ(1, num_flexfec_streams_);
- (*receive_configs)[0].payload_type = test::CallTest::kFlexfecPayloadType;
- (*receive_configs)[0].rtp.remote_ssrc = test::CallTest::kFlexfecSendSsrc;
+ (*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];
}
diff --git a/rtc_tools/BUILD.gn b/rtc_tools/BUILD.gn
index d9b7379..1e5fb05 100644
--- a/rtc_tools/BUILD.gn
+++ b/rtc_tools/BUILD.gn
@@ -282,11 +282,11 @@
"../test:run_loop",
"../test:run_test",
"../test:run_test_interface",
- "../test:test_common",
"../test:test_renderer",
"../test:test_support",
"../test:test_video_capturer",
"../test:video_test_common",
+ "../test:video_test_constants",
"../test:video_test_support",
"../test/time_controller:time_controller",
"//third_party/abseil-cpp/absl/flags:flag",
diff --git a/rtc_tools/video_replay.cc b/rtc_tools/video_replay.cc
index 405948d..2600598 100644
--- a/rtc_tools/video_replay.cc
+++ b/rtc_tools/video_replay.cc
@@ -40,7 +40,6 @@
#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/sleep.h"
#include "test/call_config_utils.h"
-#include "test/call_test.h"
#include "test/encoder_settings.h"
#include "test/fake_decoder.h"
#include "test/gtest.h"
@@ -52,54 +51,55 @@
#include "test/testsupport/frame_writer.h"
#include "test/time_controller/simulated_time_controller.h"
#include "test/video_renderer.h"
+#include "test/video_test_constants.h"
// Flag for payload type.
ABSL_FLAG(int,
media_payload_type,
- webrtc::test::CallTest::kPayloadTypeVP8,
+ webrtc::test::VideoTestConstants::kPayloadTypeVP8,
"Media payload type");
// Flag for RED payload type.
ABSL_FLAG(int,
red_payload_type,
- webrtc::test::CallTest::kRedPayloadType,
+ webrtc::test::VideoTestConstants::kRedPayloadType,
"RED payload type");
// Flag for ULPFEC payload type.
ABSL_FLAG(int,
ulpfec_payload_type,
- webrtc::test::CallTest::kUlpfecPayloadType,
+ webrtc::test::VideoTestConstants::kUlpfecPayloadType,
"ULPFEC payload type");
// Flag for FLEXFEC payload type.
ABSL_FLAG(int,
flexfec_payload_type,
- webrtc::test::CallTest::kFlexfecPayloadType,
+ webrtc::test::VideoTestConstants::kFlexfecPayloadType,
"FLEXFEC payload type");
ABSL_FLAG(int,
media_payload_type_rtx,
- webrtc::test::CallTest::kSendRtxPayloadType,
+ webrtc::test::VideoTestConstants::kSendRtxPayloadType,
"Media over RTX payload type");
ABSL_FLAG(int,
red_payload_type_rtx,
- webrtc::test::CallTest::kRtxRedPayloadType,
+ webrtc::test::VideoTestConstants::kRtxRedPayloadType,
"RED over RTX payload type");
// Flag for SSRC and RTX SSRC.
ABSL_FLAG(uint32_t,
ssrc,
- webrtc::test::CallTest::kVideoSendSsrcs[0],
+ webrtc::test::VideoTestConstants::kVideoSendSsrcs[0],
"Incoming SSRC");
ABSL_FLAG(uint32_t,
ssrc_rtx,
- webrtc::test::CallTest::kSendRtxSsrcs[0],
+ webrtc::test::VideoTestConstants::kSendRtxSsrcs[0],
"Incoming RTX SSRC");
ABSL_FLAG(uint32_t,
ssrc_flexfec,
- webrtc::test::CallTest::kFlexfecSendSsrc,
+ webrtc::test::VideoTestConstants::kFlexfecSendSsrc,
"Incoming FLEXFEC SSRC");
// Flag for abs-send-time id.
diff --git a/test/BUILD.gn b/test/BUILD.gn
index bd0ba3c..bda1228 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -1064,6 +1064,12 @@
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ]
}
+rtc_library("video_test_constants") {
+ testonly = true
+ sources = [ "video_test_constants.h" ]
+ deps = [ "../api/units:time_delta" ]
+}
+
rtc_library("test_common") {
testonly = true
sources = [
@@ -1087,6 +1093,7 @@
":scoped_key_value_config",
":test_support",
":video_test_common",
+ ":video_test_constants",
"../api:array_view",
"../api:create_frame_generator",
"../api:frame_generator_api",
diff --git a/test/call_test.cc b/test/call_test.cc
index b6b633f..7a1bbd2 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -31,6 +31,7 @@
#include "test/fake_encoder.h"
#include "test/rtp_rtcp_observer.h"
#include "test/testsupport/file_utils.h"
+#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h"
namespace webrtc {
@@ -176,9 +177,9 @@
}
if (num_video_streams_ > 0) {
- int width = kDefaultWidth;
- int height = kDefaultHeight;
- int frame_rate = kDefaultFramerate;
+ int width = VideoTestConstants::kDefaultWidth;
+ int height = VideoTestConstants::kDefaultHeight;
+ int frame_rate = VideoTestConstants::kDefaultFramerate;
test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
test->ModifyVideoDegradationPreference(°radation_preference_);
CreateFrameGeneratorCapturer(frame_rate, width, height);
@@ -248,13 +249,15 @@
size_t num_video_streams,
size_t num_used_ssrcs,
Transport* send_transport) {
- RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs);
+ RTC_DCHECK_LE(num_video_streams + num_used_ssrcs,
+ VideoTestConstants::kNumSsrcs);
*video_config = VideoSendStream::Config(send_transport);
video_config->encoder_settings.encoder_factory = &fake_encoder_factory_;
video_config->encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_config->rtp.payload_name = "FAKE";
- video_config->rtp.payload_type = kFakeVideoSendPayloadType;
+ video_config->rtp.payload_type =
+ VideoTestConstants::kFakeVideoSendPayloadType;
video_config->rtp.extmap_allow_mixed = true;
AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri,
&video_config->rtp.extensions);
@@ -274,7 +277,8 @@
&video_encoder_configs_.back());
}
for (size_t i = 0; i < num_video_streams; ++i)
- video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]);
+ video_config->rtp.ssrcs.push_back(
+ VideoTestConstants::kVideoSendSsrcs[num_used_ssrcs + i]);
AddRtpExtensionByUri(RtpExtension::kVideoRotationUri,
&video_config->rtp.extensions);
AddRtpExtensionByUri(RtpExtension::kColorSpaceUri,
@@ -288,12 +292,13 @@
RTC_DCHECK_LE(num_flexfec_streams, 1);
if (num_audio_streams > 0) {
AudioSendStream::Config audio_send_config(send_transport);
- audio_send_config.rtp.ssrc = kAudioSendSsrc;
+ audio_send_config.rtp.ssrc = VideoTestConstants::kAudioSendSsrc;
AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri,
&audio_send_config.rtp.extensions);
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- kAudioSendPayloadType, {"opus", 48000, 2, {{"stereo", "1"}}});
+ VideoTestConstants::kAudioSendPayloadType,
+ {"opus", 48000, 2, {{"stereo", "1"}}});
audio_send_config.min_bitrate_bps = 6000;
audio_send_config.max_bitrate_bps = 60000;
audio_send_config.encoder_factory = audio_encoder_factory_;
@@ -302,7 +307,7 @@
// TODO(brandtr): Update this when we support multistream protection.
if (num_flexfec_streams > 0) {
- SetSendFecConfig({kVideoSendSsrcs[0]});
+ SetSendFecConfig({VideoTestConstants::kVideoSendSsrcs[0]});
}
}
@@ -311,23 +316,29 @@
}
void CallTest::SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs) {
- GetVideoSendConfig()->rtp.flexfec.payload_type = kFlexfecPayloadType;
- GetVideoSendConfig()->rtp.flexfec.ssrc = kFlexfecSendSsrc;
+ GetVideoSendConfig()->rtp.flexfec.payload_type =
+ VideoTestConstants::kFlexfecPayloadType;
+ GetVideoSendConfig()->rtp.flexfec.ssrc = VideoTestConstants::kFlexfecSendSsrc;
GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs = video_send_ssrcs;
}
void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) {
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
- send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ VideoTestConstants::kRedPayloadType;
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ VideoTestConstants::kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_rtx_payload_type =
+ VideoTestConstants::kRtxRedPayloadType;
}
void CallTest::SetReceiveUlpFecConfig(
VideoReceiveStreamInterface::Config* receive_config) {
- receive_config->rtp.red_payload_type = kRedPayloadType;
- receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType;
- receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] =
- kRedPayloadType;
+ receive_config->rtp.red_payload_type = VideoTestConstants::kRedPayloadType;
+ receive_config->rtp.ulpfec_payload_type =
+ VideoTestConstants::kUlpfecPayloadType;
+ receive_config->rtp
+ .rtx_associated_payload_types[VideoTestConstants::kRtxRedPayloadType] =
+ VideoTestConstants::kRedPayloadType;
}
void CallTest::CreateSendConfig(size_t num_video_streams,
@@ -375,7 +386,7 @@
int rtp_history_ms) {
RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
- default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
+ default_config.rtp.local_ssrc = VideoTestConstants::kReceiverLocalVideoSsrc;
default_config.rtp.nack.rtp_history_ms = rtp_history_ms;
// Enable RTT calculation so NTP time estimator will work.
default_config.rtp.rtcp_xr.receiver_reference_time_report =
@@ -388,7 +399,8 @@
video_recv_config.decoders.clear();
if (!video_send_config.rtp.rtx.ssrcs.empty()) {
video_recv_config.rtp.rtx_ssrc = video_send_config.rtp.rtx.ssrcs[i];
- video_recv_config.rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
+ video_recv_config.rtp.rtx_associated_payload_types
+ [VideoTestConstants::kSendRtxPayloadType] =
video_send_config.rtp.payload_type;
}
video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i];
@@ -433,11 +445,12 @@
Transport* transport,
std::string sync_group) {
AudioReceiveStreamInterface::Config audio_config;
- audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
+ audio_config.rtp.local_ssrc = VideoTestConstants::kReceiverLocalAudioSsrc;
audio_config.rtcp_send_transport = transport;
audio_config.rtp.remote_ssrc = send_config.rtp.ssrc;
audio_config.decoder_factory = audio_decoder_factory;
- audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};
+ audio_config.decoder_map = {
+ {VideoTestConstants::kAudioSendPayloadType, {"opus", 48000, 2}}};
audio_config.sync_group = sync_group;
return audio_config;
}
@@ -449,7 +462,7 @@
config.payload_type = send_config.rtp.flexfec.payload_type;
config.rtp.remote_ssrc = send_config.rtp.flexfec.ssrc;
config.protected_media_ssrcs = send_config.rtp.flexfec.protected_media_ssrcs;
- config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
+ config.rtp.local_ssrc = VideoTestConstants::kReceiverLocalVideoSsrc;
if (!video_receive_configs_.empty()) {
video_receive_configs_[0].rtp.protected_by_flexfec = true;
video_receive_configs_[0].rtp.packet_sink_ = this;
@@ -730,33 +743,19 @@
}
}
-constexpr size_t CallTest::kNumSsrcs;
-const int CallTest::kDefaultWidth;
-const int CallTest::kDefaultHeight;
-const int CallTest::kDefaultFramerate;
-const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {
- 0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02};
-const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {
- 0xC0FFED, 0xC0FFEE, 0xC0FFEF, 0xC0FFF0, 0xC0FFF1, 0xC0FFF2};
-const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF;
-const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF;
-const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
-const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
-const int CallTest::kNackRtpHistoryMs = 1000;
-
const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
- {CallTest::kVideoSendPayloadType, MediaType::VIDEO},
- {CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO},
- {CallTest::kSendRtxPayloadType, MediaType::VIDEO},
- {CallTest::kPayloadTypeVP8, MediaType::VIDEO},
- {CallTest::kPayloadTypeVP9, MediaType::VIDEO},
- {CallTest::kPayloadTypeH264, MediaType::VIDEO},
- {CallTest::kPayloadTypeGeneric, MediaType::VIDEO},
- {CallTest::kRedPayloadType, MediaType::VIDEO},
- {CallTest::kRtxRedPayloadType, MediaType::VIDEO},
- {CallTest::kUlpfecPayloadType, MediaType::VIDEO},
- {CallTest::kFlexfecPayloadType, MediaType::VIDEO},
- {CallTest::kAudioSendPayloadType, MediaType::AUDIO}};
+ {VideoTestConstants::kVideoSendPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kFakeVideoSendPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kSendRtxPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kPayloadTypeVP8, MediaType::VIDEO},
+ {VideoTestConstants::kPayloadTypeVP9, MediaType::VIDEO},
+ {VideoTestConstants::kPayloadTypeH264, MediaType::VIDEO},
+ {VideoTestConstants::kPayloadTypeGeneric, MediaType::VIDEO},
+ {VideoTestConstants::kRedPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kRtxRedPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kUlpfecPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kFlexfecPayloadType, MediaType::VIDEO},
+ {VideoTestConstants::kAudioSendPayloadType, MediaType::AUDIO}};
BaseTest::BaseTest() {}
diff --git a/test/call_test.h b/test/call_test.h
index d6acfef..d01bac4 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -36,6 +36,7 @@
#include "test/rtp_rtcp_observer.h"
#include "test/run_loop.h"
#include "test/scoped_key_value_config.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace test {
@@ -47,34 +48,6 @@
CallTest();
virtual ~CallTest();
- static constexpr size_t kNumSsrcs = 6;
- static const int kNumSimulcastStreams = 3;
- static const int kDefaultWidth = 320;
- static const int kDefaultHeight = 180;
- static const int kDefaultFramerate = 30;
- static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(30);
- static constexpr TimeDelta kLongTimeout = TimeDelta::Seconds(120);
- enum classPayloadTypes : uint8_t {
- kSendRtxPayloadType = 98,
- kRtxRedPayloadType = 99,
- kVideoSendPayloadType = 100,
- kAudioSendPayloadType = 103,
- kRedPayloadType = 118,
- kUlpfecPayloadType = 119,
- kFlexfecPayloadType = 120,
- kPayloadTypeH264 = 122,
- kPayloadTypeVP8 = 123,
- kPayloadTypeVP9 = 124,
- kPayloadTypeGeneric = 125,
- kFakeVideoSendPayloadType = 126,
- };
- static const uint32_t kSendRtxSsrcs[kNumSsrcs];
- static const uint32_t kVideoSendSsrcs[kNumSsrcs];
- static const uint32_t kAudioSendSsrc;
- static const uint32_t kFlexfecSendSsrc;
- static const uint32_t kReceiverLocalVideoSsrc;
- static const uint32_t kReceiverLocalAudioSsrc;
- static const int kNackRtpHistoryMs;
static const std::map<uint8_t, MediaType> payload_type_map_;
protected:
diff --git a/test/scenario/BUILD.gn b/test/scenario/BUILD.gn
index d63d591..c3b8847 100644
--- a/test/scenario/BUILD.gn
+++ b/test/scenario/BUILD.gn
@@ -71,6 +71,7 @@
":column_printer",
"..:frame_generator_capturer",
"..:test_video_capturer",
+ "..:video_test_constants",
"../:fake_video_codecs",
"../:fileutils",
"../:test_common",
diff --git a/test/scenario/audio_stream.cc b/test/scenario/audio_stream.cc
index e134e4b..7715555 100644
--- a/test/scenario/audio_stream.cc
+++ b/test/scenario/audio_stream.cc
@@ -11,6 +11,7 @@
#include "absl/memory/memory.h"
#include "test/call_test.h"
+#include "test/video_test_constants.h"
#if WEBRTC_ENABLE_PROTOBUF
RTC_PUSH_IGNORING_WUNDEF()
@@ -103,7 +104,8 @@
// stereo, but the actual channel count used is based on the "stereo"
// parameter.
send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- CallTest::kAudioSendPayloadType, {"opus", 48000, 2, sdp_params});
+ VideoTestConstants::kAudioSendPayloadType,
+ {"opus", 48000, 2, sdp_params});
RTC_DCHECK_LE(config.source.channels, 2);
send_config.encoder_factory = encoder_factory;
@@ -190,7 +192,7 @@
receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
recv_config.decoder_factory = decoder_factory;
recv_config.decoder_map = {
- {CallTest::kAudioSendPayloadType, {"opus", 48000, 2}}};
+ {VideoTestConstants::kAudioSendPayloadType, {"opus", 48000, 2}}};
recv_config.sync_group = config.render.sync_group;
receiver_->SendTask([&] {
receive_stream_ = receiver_->call_->CreateAudioReceiveStream(recv_config);
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index 3879ec8..937ad4f 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -27,6 +27,7 @@
#include "test/fake_encoder.h"
#include "test/scenario/hardware_codecs.h"
#include "test/testsupport/file_utils.h"
+#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h"
namespace webrtc {
@@ -43,13 +44,13 @@
uint8_t CodecTypeToPayloadType(VideoCodecType codec_type) {
switch (codec_type) {
case VideoCodecType::kVideoCodecGeneric:
- return CallTest::kFakeVideoSendPayloadType;
+ return VideoTestConstants::kFakeVideoSendPayloadType;
case VideoCodecType::kVideoCodecVP8:
- return CallTest::kPayloadTypeVP8;
+ return VideoTestConstants::kPayloadTypeVP8;
case VideoCodecType::kVideoCodecVP9:
- return CallTest::kPayloadTypeVP9;
+ return VideoTestConstants::kPayloadTypeVP9;
case VideoCodecType::kVideoCodecH264:
- return CallTest::kPayloadTypeH264;
+ return VideoTestConstants::kPayloadTypeH264;
default:
RTC_DCHECK_NOTREACHED();
}
@@ -108,18 +109,22 @@
send_config.rtp.extensions = GetVideoRtpExtensions(config);
if (config.stream.use_rtx) {
- send_config.rtp.rtx.payload_type = CallTest::kSendRtxPayloadType;
+ send_config.rtp.rtx.payload_type = VideoTestConstants::kSendRtxPayloadType;
send_config.rtp.rtx.ssrcs = rtx_ssrcs;
}
if (config.stream.use_flexfec) {
- send_config.rtp.flexfec.payload_type = CallTest::kFlexfecPayloadType;
- send_config.rtp.flexfec.ssrc = CallTest::kFlexfecSendSsrc;
+ send_config.rtp.flexfec.payload_type =
+ VideoTestConstants::kFlexfecPayloadType;
+ send_config.rtp.flexfec.ssrc = VideoTestConstants::kFlexfecSendSsrc;
send_config.rtp.flexfec.protected_media_ssrcs = ssrcs;
}
if (config.stream.use_ulpfec) {
- send_config.rtp.ulpfec.red_payload_type = CallTest::kRedPayloadType;
- send_config.rtp.ulpfec.ulpfec_payload_type = CallTest::kUlpfecPayloadType;
- send_config.rtp.ulpfec.red_rtx_payload_type = CallTest::kRtxRedPayloadType;
+ send_config.rtp.ulpfec.red_payload_type =
+ VideoTestConstants::kRedPayloadType;
+ send_config.rtp.ulpfec.ulpfec_payload_type =
+ VideoTestConstants::kUlpfecPayloadType;
+ send_config.rtp.ulpfec.red_rtx_payload_type =
+ VideoTestConstants::kRtxRedPayloadType;
}
return send_config;
}
@@ -323,14 +328,16 @@
recv.renderer = renderer;
if (config.stream.use_rtx) {
recv.rtp.rtx_ssrc = rtx_ssrc;
- recv.rtp.rtx_associated_payload_types[CallTest::kSendRtxPayloadType] =
+ recv.rtp
+ .rtx_associated_payload_types[VideoTestConstants::kSendRtxPayloadType] =
CodecTypeToPayloadType(config.encoder.codec);
}
if (config.stream.use_ulpfec) {
- recv.rtp.red_payload_type = CallTest::kRedPayloadType;
- recv.rtp.ulpfec_payload_type = CallTest::kUlpfecPayloadType;
- recv.rtp.rtx_associated_payload_types[CallTest::kRtxRedPayloadType] =
- CallTest::kRedPayloadType;
+ recv.rtp.red_payload_type = VideoTestConstants::kRedPayloadType;
+ recv.rtp.ulpfec_payload_type = VideoTestConstants::kUlpfecPayloadType;
+ recv.rtp
+ .rtx_associated_payload_types[VideoTestConstants::kRtxRedPayloadType] =
+ VideoTestConstants::kRedPayloadType;
}
recv.sync_group = config.render.sync_group;
return recv;
@@ -564,8 +571,8 @@
if (config.stream.use_flexfec) {
RTC_DCHECK(num_streams == 1);
FlexfecReceiveStream::Config flexfec(feedback_transport);
- flexfec.payload_type = CallTest::kFlexfecPayloadType;
- flexfec.rtp.remote_ssrc = CallTest::kFlexfecSendSsrc;
+ flexfec.payload_type = VideoTestConstants::kFlexfecPayloadType;
+ flexfec.rtp.remote_ssrc = VideoTestConstants::kFlexfecSendSsrc;
flexfec.protected_media_ssrcs = send_stream->rtx_ssrcs_;
flexfec.rtp.local_ssrc = recv_config.rtp.local_ssrc;
receiver_->ssrc_media_types_[flexfec.rtp.remote_ssrc] = MediaType::VIDEO;
diff --git a/test/video_test_constants.h b/test/video_test_constants.h
new file mode 100644
index 0000000..732d4f0
--- /dev/null
+++ b/test/video_test_constants.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2023 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.
+ */
+#ifndef TEST_VIDEO_TEST_CONSTANTS_H_
+#define TEST_VIDEO_TEST_CONSTANTS_H_
+
+#include <cstdint>
+
+#include "api/units/time_delta.h"
+
+namespace webrtc {
+namespace test {
+
+class VideoTestConstants {
+ public:
+ static constexpr size_t kNumSsrcs = 6;
+ static constexpr int kNumSimulcastStreams = 3;
+ static constexpr int kDefaultWidth = 320;
+ static constexpr int kDefaultHeight = 180;
+ static constexpr int kDefaultFramerate = 30;
+ static constexpr TimeDelta kDefaultTimeout = TimeDelta::Seconds(30);
+ static constexpr TimeDelta kLongTimeout = TimeDelta::Seconds(120);
+ enum classPayloadTypes : uint8_t {
+ kSendRtxPayloadType = 98,
+ kRtxRedPayloadType = 99,
+ kVideoSendPayloadType = 100,
+ kAudioSendPayloadType = 103,
+ kRedPayloadType = 118,
+ kUlpfecPayloadType = 119,
+ kFlexfecPayloadType = 120,
+ kPayloadTypeH264 = 122,
+ kPayloadTypeVP8 = 123,
+ kPayloadTypeVP9 = 124,
+ kPayloadTypeGeneric = 125,
+ kFakeVideoSendPayloadType = 126,
+ };
+ static constexpr uint32_t kSendRtxSsrcs[kNumSsrcs] = {
+ 0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02};
+ static constexpr uint32_t kVideoSendSsrcs[kNumSsrcs] = {
+ 0xC0FFED, 0xC0FFEE, 0xC0FFEF, 0xC0FFF0, 0xC0FFF1, 0xC0FFF2};
+ static constexpr uint32_t kAudioSendSsrc = 0xDEADBEEF;
+ static constexpr uint32_t kFlexfecSendSsrc = 0xBADBEEF;
+ static constexpr uint32_t kReceiverLocalVideoSsrc = 0x123456;
+ static constexpr uint32_t kReceiverLocalAudioSsrc = 0x1234567;
+ static constexpr int kNackRtpHistoryMs = 1000;
+
+ private:
+ VideoTestConstants() = default;
+};
+
+} // namespace test
+} // namespace webrtc
+
+#endif // TEST_VIDEO_TEST_CONSTANTS_H_
diff --git a/video/BUILD.gn b/video/BUILD.gn
index 78b6e78..e4d3c51 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -539,6 +539,7 @@
"../test:test_support",
"../test:test_support_test_artifacts",
"../test:video_test_common",
+ "../test:video_test_constants",
"../test:video_test_support",
"config:streams_config",
]
@@ -915,6 +916,7 @@
"../test:test_common",
"../test:test_support",
"../test:video_test_common",
+ "../test:video_test_constants",
"../test/time_controller",
"adaptation:video_adaptation",
"config:encoder_config",
diff --git a/video/cpu_scaling_tests.cc b/video/cpu_scaling_tests.cc
index b9f3a45..7947372 100644
--- a/video/cpu_scaling_tests.cc
+++ b/video/cpu_scaling_tests.cc
@@ -23,6 +23,7 @@
#include "test/field_trial.h"
#include "test/frame_generator_capturer.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h"
namespace webrtc {
@@ -55,7 +56,9 @@
public:
OveruseObserver(const DegradationPreference& degradation_preference,
bool expect_adaptation)
- : SendTest(expect_adaptation ? kLongTimeout : kDefaultTimeout),
+ : SendTest(expect_adaptation
+ ? test::VideoTestConstants::kLongTimeout
+ : test::VideoTestConstants::kDefaultTimeout),
degradation_preference_(degradation_preference),
expect_adaptation_(expect_adaptation) {}
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index d6610a8..1e36f2f 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -29,6 +29,7 @@
#include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h"
#include "test/video_encoder_proxy_factory.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -46,7 +47,7 @@
TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class RembObserver : public test::EndToEndTest {
public:
- RembObserver() : EndToEndTest(kDefaultTimeout) {}
+ RembObserver() : EndToEndTest(test::VideoTestConstants::kDefaultTimeout) {}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
@@ -62,10 +63,12 @@
EXPECT_TRUE(parser.Parse(packet, length));
if (parser.remb()->num_packets() > 0) {
- EXPECT_EQ(kReceiverLocalVideoSsrc, parser.remb()->sender_ssrc());
+ EXPECT_EQ(test::VideoTestConstants::kReceiverLocalVideoSsrc,
+ parser.remb()->sender_ssrc());
EXPECT_LT(0U, parser.remb()->bitrate_bps());
EXPECT_EQ(1U, parser.remb()->ssrcs().size());
- EXPECT_EQ(kVideoSendSsrcs[0], parser.remb()->ssrcs()[0]);
+ EXPECT_EQ(test::VideoTestConstants::kVideoSendSsrcs[0],
+ parser.remb()->ssrcs()[0]);
observation_complete_.Set();
}
@@ -84,7 +87,7 @@
class BandwidthStatsTest : public test::EndToEndTest {
public:
BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
sender_call_(nullptr),
receiver_call_(nullptr),
has_seen_pacer_delay_(false),
@@ -191,7 +194,7 @@
class BweObserver : public test::EndToEndTest {
public:
explicit BweObserver(TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0),
@@ -315,7 +318,7 @@
public test::FakeEncoder {
public:
explicit EncoderRateStatsTest(TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
send_stream_(nullptr),
@@ -363,7 +366,7 @@
}
void WaitForEncoderTargetBitrateMatchStats() {
- for (int i = 0; i < kDefaultTimeout.ms(); ++i) {
+ for (int i = 0; i < test::VideoTestConstants::kDefaultTimeout.ms(); ++i) {
VideoSendStream::Stats stats = send_stream_->GetStats();
{
MutexLock lock(&mutex_);
@@ -379,7 +382,7 @@
}
void WaitForStatsReportZeroTargetBitrate() {
- for (int i = 0; i < kDefaultTimeout.ms(); ++i) {
+ for (int i = 0; i < test::VideoTestConstants::kDefaultTimeout.ms(); ++i) {
if (send_stream_->GetStats().target_media_bitrate_bps == 0) {
return;
}
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index f5b3238..7a026c3 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -22,6 +22,7 @@
#include "test/frame_forwarder.h"
#include "test/gtest.h"
#include "test/null_transport.h"
+#include "test/video_test_constants.h"
namespace webrtc {
@@ -88,7 +89,9 @@
event_.Set();
}
- bool Wait() { return event_.Wait(kDefaultTimeout); }
+ bool Wait() {
+ return event_.Wait(test::VideoTestConstants::kDefaultTimeout);
+ }
rtc::Event event_;
} renderer;
@@ -143,7 +146,9 @@
public:
void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
- bool Wait() { return event_.Wait(kDefaultTimeout); }
+ bool Wait() {
+ return event_.Wait(test::VideoTestConstants::kDefaultTimeout);
+ }
rtc::Event event_;
} renderer;
@@ -170,7 +175,9 @@
Start();
frame_generator = test::CreateSquareFrameGenerator(
- kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt);
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight, absl::nullopt,
+ absl::nullopt);
GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data =
diff --git a/video/end_to_end_tests/codec_tests.cc b/video/end_to_end_tests/codec_tests.cc
index 53ec9f5..c56e7c5 100644
--- a/video/end_to_end_tests/codec_tests.cc
+++ b/video/end_to_end_tests/codec_tests.cc
@@ -9,6 +9,7 @@
*/
#include <memory>
+
#include "absl/types/optional.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/video/color_space.h"
@@ -25,6 +26,7 @@
#include "test/encoder_settings.h"
#include "test/field_trial.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -53,7 +55,7 @@
const std::string& payload_name,
VideoEncoderFactory* encoder_factory,
VideoDecoderFactory* decoder_factory)
- : EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeout),
+ : EndToEndTest(4 * test::VideoTestConstants::kDefaultTimeout),
// TODO(hta): This timeout (120 seconds) is excessive.
// https://bugs.webrtc.org/6830
no_frames_to_wait_for_(no_frames_to_wait_for),
@@ -76,7 +78,8 @@
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
(*receive_configs)[0].renderer = this;
(*receive_configs)[0].decoders.resize(1);
diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc
index 2897212..ac16a8e 100644
--- a/video/end_to_end_tests/extended_reports_tests.cc
+++ b/video/end_to_end_tests/extended_reports_tests.cc
@@ -39,6 +39,7 @@
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h"
+#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h"
namespace webrtc {
@@ -63,7 +64,7 @@
bool expect_target_bitrate,
bool enable_zero_target_bitrate,
VideoEncoderConfig::ContentType content_type)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
enable_rrtr_(enable_rrtr),
expect_target_bitrate_(expect_target_bitrate),
enable_zero_target_bitrate_(enable_zero_target_bitrate),
@@ -104,7 +105,7 @@
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
- if (parser.sender_ssrc() == test::CallTest::kVideoSendSsrcs[1] &&
+ if (parser.sender_ssrc() == test::VideoTestConstants::kVideoSendSsrcs[1] &&
enable_zero_target_bitrate_) {
// Reduce bandwidth restriction to disable second stream after it was
// enabled for some time.
diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc
index bf3ad0b..f2ab161 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -26,6 +26,7 @@
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
using ::testing::Contains;
using ::testing::Not;
@@ -53,7 +54,7 @@
public rtc::VideoSinkInterface<VideoFrame> {
public:
UlpfecRenderObserver()
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([]() { return VP8Encoder::Create(); }),
random_(0xcafef00d1),
num_packets_sent_(0) {}
@@ -64,31 +65,38 @@
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
- EXPECT_TRUE(rtp_packet.PayloadType() == kVideoSendPayloadType ||
- rtp_packet.PayloadType() == kRedPayloadType)
+ EXPECT_TRUE(rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kVideoSendPayloadType ||
+ rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kRedPayloadType)
<< "Unknown payload type received.";
- EXPECT_EQ(kVideoSendSsrcs[0], rtp_packet.Ssrc())
+ EXPECT_EQ(test::VideoTestConstants::kVideoSendSsrcs[0], rtp_packet.Ssrc())
<< "Unknown SSRC received.";
// Parse RED header.
int encapsulated_payload_type = -1;
- if (rtp_packet.PayloadType() == kRedPayloadType) {
+ if (rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kRedPayloadType) {
encapsulated_payload_type = rtp_packet.payload()[0];
- EXPECT_TRUE(encapsulated_payload_type == kVideoSendPayloadType ||
- encapsulated_payload_type == kUlpfecPayloadType)
+ EXPECT_TRUE(encapsulated_payload_type ==
+ test::VideoTestConstants::kVideoSendPayloadType ||
+ encapsulated_payload_type ==
+ test::VideoTestConstants::kUlpfecPayloadType)
<< "Unknown encapsulated payload type received.";
}
// To minimize test flakiness, always let ULPFEC packets through.
- if (encapsulated_payload_type == kUlpfecPayloadType) {
+ if (encapsulated_payload_type ==
+ test::VideoTestConstants::kUlpfecPayloadType) {
return SEND_PACKET;
}
// Simulate 5% video packet loss after rampup period. Record the
// corresponding timestamps that were dropped.
if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) {
- if (encapsulated_payload_type == kVideoSendPayloadType) {
+ if (encapsulated_payload_type ==
+ test::VideoTestConstants::kVideoSendPayloadType) {
dropped_sequence_numbers_.insert(rtp_packet.SequenceNumber());
dropped_timestamps_.insert(rtp_packet.Timestamp());
}
@@ -116,7 +124,8 @@
// in the packetization headers.
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8";
- send_config->rtp.payload_type = kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
encoder_config->codec_type = kVideoCodecVP8;
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(*send_config);
@@ -125,10 +134,14 @@
(*receive_configs)[0].decoders.push_back(decoder);
// Enable ULPFEC over RED.
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
- (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
- (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
+ (*receive_configs)[0].rtp.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ (*receive_configs)[0].rtp.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
(*receive_configs)[0].renderer = this;
}
@@ -159,7 +172,7 @@
static constexpr uint32_t kFlexfecLocalSsrc = 456;
explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp)
- : test::EndToEndTest(test::CallTest::kLongTimeout),
+ : test::EndToEndTest(test::VideoTestConstants::kLongTimeout),
enable_nack_(enable_nack),
expect_flexfec_rtcp_(expect_flexfec_rtcp),
received_flexfec_rtcp_(false),
@@ -175,27 +188,32 @@
EXPECT_TRUE(rtp_packet.Parse(packet, length));
EXPECT_TRUE(
- rtp_packet.PayloadType() == test::CallTest::kFakeVideoSendPayloadType ||
- rtp_packet.PayloadType() == test::CallTest::kFlexfecPayloadType ||
- (enable_nack_ &&
- rtp_packet.PayloadType() == test::CallTest::kSendRtxPayloadType))
+ rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kFakeVideoSendPayloadType ||
+ rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kFlexfecPayloadType ||
+ (enable_nack_ && rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kSendRtxPayloadType))
<< "Unknown payload type received.";
EXPECT_TRUE(
- rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[0] ||
- rtp_packet.Ssrc() == test::CallTest::kFlexfecSendSsrc ||
- (enable_nack_ && rtp_packet.Ssrc() == test::CallTest::kSendRtxSsrcs[0]))
+ rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0] ||
+ rtp_packet.Ssrc() == test::VideoTestConstants::kFlexfecSendSsrc ||
+ (enable_nack_ &&
+ rtp_packet.Ssrc() == test::VideoTestConstants::kSendRtxSsrcs[0]))
<< "Unknown SSRC received.";
// To reduce test flakiness, always let FlexFEC packets through.
- if (rtp_packet.PayloadType() == test::CallTest::kFlexfecPayloadType) {
- EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, rtp_packet.Ssrc());
+ if (rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kFlexfecPayloadType) {
+ EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, rtp_packet.Ssrc());
return SEND_PACKET;
}
// To reduce test flakiness, always let RTX packets through.
- if (rtp_packet.PayloadType() == test::CallTest::kSendRtxPayloadType) {
- EXPECT_EQ(test::CallTest::kSendRtxSsrcs[0], rtp_packet.Ssrc());
+ if (rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kSendRtxPayloadType) {
+ EXPECT_EQ(test::VideoTestConstants::kSendRtxSsrcs[0], rtp_packet.Ssrc());
if (rtp_packet.payload_size() == 0) {
// Pure padding packet.
@@ -223,9 +241,10 @@
// Simulate 5% video packet loss after rampup period. Record the
// corresponding timestamps that were dropped.
if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) {
- EXPECT_EQ(test::CallTest::kFakeVideoSendPayloadType,
+ EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType());
- EXPECT_EQ(test::CallTest::kVideoSendSsrcs[0], rtp_packet.Ssrc());
+ EXPECT_EQ(test::VideoTestConstants::kVideoSendSsrcs[0],
+ rtp_packet.Ssrc());
dropped_sequence_numbers_.insert(rtp_packet.SequenceNumber());
dropped_timestamps_.insert(rtp_packet.Timestamp());
@@ -246,7 +265,7 @@
parser.receiver_report()->report_blocks();
if (!report_blocks.empty()) {
EXPECT_EQ(1U, report_blocks.size());
- EXPECT_EQ(test::CallTest::kFlexfecSendSsrc,
+ EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc,
report_blocks[0].source_ssrc());
MutexLock lock(&mutex_);
received_flexfec_rtcp_ = true;
@@ -286,17 +305,20 @@
(*receive_configs)[0].renderer = this;
if (enable_nack_) {
- send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
- send_config->rtp.rtx.ssrcs.push_back(test::CallTest::kSendRtxSsrcs[0]);
- send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[0]);
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
(*receive_configs)[0].rtp.nack.rtp_history_ms =
- test::CallTest::kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.rtx_ssrc = test::CallTest::kSendRtxSsrcs[0];
- (*receive_configs)[0]
- .rtp
- .rtx_associated_payload_types[test::CallTest::kSendRtxPayloadType] =
- test::CallTest::kVideoSendPayloadType;
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.rtx_ssrc =
+ test::VideoTestConstants::kSendRtxSsrcs[0];
+ (*receive_configs)[0].rtp.rtx_associated_payload_types
+ [test::VideoTestConstants::kSendRtxPayloadType] =
+ test::VideoTestConstants::kVideoSendPayloadType;
}
}
@@ -345,7 +367,7 @@
class UlpfecNackObserver : public test::EndToEndTest {
public:
UlpfecNackObserver()
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
state_(kFirstPacket),
ulpfec_sequence_number_(0),
has_last_sequence_number_(false),
@@ -359,12 +381,16 @@
EXPECT_TRUE(rtp_packet.Parse(packet, length));
int encapsulated_payload_type = -1;
- if (rtp_packet.PayloadType() == kRedPayloadType) {
+ if (rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kRedPayloadType) {
encapsulated_payload_type = rtp_packet.payload()[0];
- if (encapsulated_payload_type != kFakeVideoSendPayloadType)
- EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
+ if (encapsulated_payload_type !=
+ test::VideoTestConstants::kFakeVideoSendPayloadType)
+ EXPECT_EQ(test::VideoTestConstants::kUlpfecPayloadType,
+ encapsulated_payload_type);
} else {
- EXPECT_EQ(kFakeVideoSendPayloadType, rtp_packet.PayloadType());
+ EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
+ rtp_packet.PayloadType());
}
if (has_last_sequence_number_ &&
@@ -376,7 +402,8 @@
last_sequence_number_ = rtp_packet.SequenceNumber();
has_last_sequence_number_ = true;
- bool ulpfec_packet = encapsulated_payload_type == kUlpfecPayloadType;
+ bool ulpfec_packet = encapsulated_payload_type ==
+ test::VideoTestConstants::kUlpfecPayloadType;
switch (state_) {
case kFirstPacket:
state_ = kDropEveryOtherPacketUntilUlpfec;
@@ -454,18 +481,25 @@
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Configure hybrid NACK/FEC.
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
// Set codec to VP8, otherwise NACK/FEC hybrid will be disabled.
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8";
- send_config->rtp.payload_type = kFakeVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
encoder_config->codec_type = kVideoCodecVP8;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
- (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ (*receive_configs)[0].rtp.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
(*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type =
diff --git a/video/end_to_end_tests/frame_encryption_tests.cc b/video/end_to_end_tests/frame_encryption_tests.cc
index 6a1b169..01f3db6 100644
--- a/video/end_to_end_tests/frame_encryption_tests.cc
+++ b/video/end_to_end_tests/frame_encryption_tests.cc
@@ -15,6 +15,7 @@
#include "modules/video_coding/codecs/vp8/include/vp8.h"
#include "test/call_test.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -29,7 +30,7 @@
public rtc::VideoSinkInterface<VideoFrame> {
public:
DecryptedFrameObserver()
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([] { return VP8Encoder::Create(); }) {}
private:
@@ -40,7 +41,8 @@
// Use VP8 instead of FAKE.
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8";
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
send_config->frame_encryptor = new FakeFrameEncryptor();
send_config->crypto_options.sframe.require_frame_encryption = true;
encoder_config->codec_type = kVideoCodecVP8;
diff --git a/video/end_to_end_tests/histogram_tests.cc b/video/end_to_end_tests/histogram_tests.cc
index 03e32ff..fd35b0f 100644
--- a/video/end_to_end_tests/histogram_tests.cc
+++ b/video/end_to_end_tests/histogram_tests.cc
@@ -15,6 +15,7 @@
#include "system_wrappers/include/metrics.h"
#include "test/call_test.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -44,7 +45,7 @@
public rtc::VideoSinkInterface<VideoFrame> {
public:
FrameObserver(bool use_rtx, bool use_fec, bool screenshare)
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
use_rtx_(use_rtx),
use_fec_(use_fec),
screenshare_(screenshare),
@@ -92,33 +93,43 @@
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// NACK
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].renderer = this;
// FEC
if (use_fec_) {
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8;
(*receive_configs)[0].decoders[0].video_format = SdpVideoFormat("VP8");
- (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
- (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
+ (*receive_configs)[0].rtp.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ (*receive_configs)[0].rtp.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
}
// RTX
if (use_rtx_) {
- send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
- send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
- (*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
- (*receive_configs)[0]
- .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
- kFakeVideoSendPayloadType;
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[0]);
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
+ (*receive_configs)[0].rtp.rtx_ssrc =
+ test::VideoTestConstants::kSendRtxSsrcs[0];
+ (*receive_configs)[0].rtp.rtx_associated_payload_types
+ [test::VideoTestConstants::kSendRtxPayloadType] =
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
if (use_fec_) {
- send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
- (*receive_configs)[0]
- .rtp.rtx_associated_payload_types[kRtxRedPayloadType] =
- kSendRtxPayloadType;
+ send_config->rtp.ulpfec.red_rtx_payload_type =
+ test::VideoTestConstants::kRtxRedPayloadType;
+ (*receive_configs)[0].rtp.rtx_associated_payload_types
+ [test::VideoTestConstants::kRtxRedPayloadType] =
+ test::VideoTestConstants::kSendRtxPayloadType;
}
}
// RTT needed for RemoteNtpTimeEstimator for the receive stream.
@@ -201,19 +212,24 @@
EXPECT_METRIC_EQ(
1, metrics::NumSamples(video_prefix + "ReceivedHeightInPixels"));
- EXPECT_METRIC_EQ(1, metrics::NumEvents(video_prefix + "InputWidthInPixels",
- kDefaultWidth));
- EXPECT_METRIC_EQ(1, metrics::NumEvents(video_prefix + "InputHeightInPixels",
- kDefaultHeight));
- EXPECT_METRIC_EQ(
- 1, metrics::NumEvents(video_prefix + "SentWidthInPixels", kDefaultWidth));
- EXPECT_METRIC_EQ(1, metrics::NumEvents(video_prefix + "SentHeightInPixels",
- kDefaultHeight));
- EXPECT_METRIC_EQ(1, metrics::NumEvents(video_prefix + "ReceivedWidthInPixels",
- kDefaultWidth));
EXPECT_METRIC_EQ(1,
- metrics::NumEvents(video_prefix + "ReceivedHeightInPixels",
- kDefaultHeight));
+ metrics::NumEvents(video_prefix + "InputWidthInPixels",
+ test::VideoTestConstants::kDefaultWidth));
+ EXPECT_METRIC_EQ(
+ 1, metrics::NumEvents(video_prefix + "InputHeightInPixels",
+ test::VideoTestConstants::kDefaultHeight));
+ EXPECT_METRIC_EQ(1,
+ metrics::NumEvents(video_prefix + "SentWidthInPixels",
+ test::VideoTestConstants::kDefaultWidth));
+ EXPECT_METRIC_EQ(
+ 1, metrics::NumEvents(video_prefix + "SentHeightInPixels",
+ test::VideoTestConstants::kDefaultHeight));
+ EXPECT_METRIC_EQ(1,
+ metrics::NumEvents(video_prefix + "ReceivedWidthInPixels",
+ test::VideoTestConstants::kDefaultWidth));
+ EXPECT_METRIC_EQ(
+ 1, metrics::NumEvents(video_prefix + "ReceivedHeightInPixels",
+ test::VideoTestConstants::kDefaultHeight));
EXPECT_METRIC_EQ(1,
metrics::NumSamples(video_prefix + "InputFramesPerSecond"));
diff --git a/video/end_to_end_tests/multi_codec_receive_tests.cc b/video/end_to_end_tests/multi_codec_receive_tests.cc
index d8ac606..e850a11 100644
--- a/video/end_to_end_tests/multi_codec_receive_tests.cc
+++ b/video/end_to_end_tests/multi_codec_receive_tests.cc
@@ -24,6 +24,7 @@
#include "test/call_test.h"
#include "test/gmock.h"
#include "test/gtest.h"
+#include "test/video_test_constants.h"
using ::testing::Contains;
@@ -36,11 +37,11 @@
uint8_t PayloadNameToPayloadType(const std::string& payload_name) {
if (payload_name == "VP8") {
- return test::CallTest::kPayloadTypeVP8;
+ return test::VideoTestConstants::kPayloadTypeVP8;
} else if (payload_name == "VP9") {
- return test::CallTest::kPayloadTypeVP9;
+ return test::VideoTestConstants::kPayloadTypeVP9;
} else if (payload_name == "H264") {
- return test::CallTest::kPayloadTypeH264;
+ return test::VideoTestConstants::kPayloadTypeH264;
} else {
RTC_DCHECK_NOTREACHED();
return 0;
@@ -63,7 +64,8 @@
class FrameObserver : public test::RtpRtcpObserver,
public rtc::VideoSinkInterface<VideoFrame> {
public:
- FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout) {}
+ FrameObserver()
+ : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout) {}
void Reset(uint8_t expected_payload_type) {
MutexLock lock(&mutex_);
@@ -79,7 +81,7 @@
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
- EXPECT_EQ(rtp_packet.Ssrc(), test::CallTest::kVideoSendSsrcs[0]);
+ EXPECT_EQ(rtp_packet.Ssrc(), test::VideoTestConstants::kVideoSendSsrcs[0]);
if (rtp_packet.payload_size() == 0)
return SEND_PACKET; // Skip padding, may be sent after OnFrame is called.
diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc
index 82e9eb9..8d99329 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/video/end_to_end_tests/multi_stream_tester.cc
@@ -29,6 +29,7 @@
#include "rtc_base/task_queue_for_test.h"
#include "test/call_test.h"
#include "test/encoder_settings.h"
+#include "test/video_test_constants.h"
namespace webrtc {
@@ -101,7 +102,8 @@
VideoReceiveStreamInterface::Config receive_config(
receiver_transport.get());
receive_config.rtp.remote_ssrc = ssrc;
- receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
+ receive_config.rtp.local_ssrc =
+ test::VideoTestConstants::kReceiverLocalVideoSsrc;
receive_config.decoder_factory = &decoder_factory;
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(send_config);
diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc
index a39f9fe..a523465 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/video/end_to_end_tests/network_state_tests.cc
@@ -104,8 +104,10 @@
GetVideoSendConfig()->encoder_settings.encoder_factory =
&encoder_factory;
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(
+ test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
Start();
});
@@ -131,8 +133,9 @@
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(transport);
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
Start();
});
@@ -158,7 +161,7 @@
class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
public:
explicit NetworkStateTest(TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
e2e_test_task_queue_(task_queue),
task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(
@@ -225,7 +228,8 @@
}
void PerformTest() override {
- EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeout))
+ EXPECT_TRUE(
+ encoded_frames_.Wait(test::VideoTestConstants::kDefaultTimeout))
<< "No frames received by the encoder.";
SendTask(task_queue_.get(), [this]() {
diff --git a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
index 86167ac..e110fb7 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -18,6 +18,7 @@
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/video_encoder_proxy_factory.h"
+#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h"
namespace webrtc {
@@ -119,7 +120,7 @@
InitEncodeTest(const std::string& payload_name,
const std::vector<TestConfig>& configs,
const std::vector<Expectation>& expectations)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this),
payload_name_(payload_name),
@@ -147,7 +148,8 @@
webrtc::VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type;
encoder_config->video_stream_factory =
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index 45a9dae..08b1bc8 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -26,6 +26,7 @@
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -53,7 +54,7 @@
class NackObserver : public test::EndToEndTest {
public:
NackObserver()
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
sent_rtp_packets_(0),
packets_left_to_drop_(0),
nacks_left_(kNumberOfNacksToObserve) {}
@@ -108,8 +109,10 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
}
void PerformTest() override {
@@ -133,7 +136,7 @@
class NackObserver : public test::EndToEndTest {
public:
NackObserver()
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
local_ssrc_(0),
remote_ssrc_(0),
receive_transport_(nullptr) {}
@@ -172,7 +175,8 @@
void ModifyAudioConfigs(AudioSendStream::Config* send_config,
std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override {
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
receive_transport_ = (*receive_configs)[0].rtcp_send_transport;
@@ -272,7 +276,7 @@
public rtc::VideoSinkInterface<VideoFrame> {
public:
explicit PliObserver(int rtp_history_ms)
- : EndToEndTest(kLongTimeout),
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
rtp_history_ms_(rtp_history_ms),
nack_enabled_(rtp_history_ms > 0),
highest_dropped_timestamp_(0),
@@ -362,10 +366,11 @@
public rtc::VideoSinkInterface<VideoFrame> {
public:
RetransmissionObserver(bool enable_rtx, bool enable_red)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
payload_type_(GetPayloadType(false, enable_red)),
- retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0]
- : kVideoSendSsrcs[0]),
+ retransmission_ssrc_(
+ enable_rtx ? test::VideoTestConstants::kSendRtxSsrcs[0]
+ : test::VideoTestConstants::kVideoSendSsrcs[0]),
retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)),
encoder_factory_([]() { return VP8Encoder::Create(); }),
marker_bits_observed_(0),
@@ -417,7 +422,8 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
// Insert ourselves into the rendering pipeline.
RTC_DCHECK(!orig_renderer_);
@@ -427,27 +433,34 @@
(*receive_configs)[0].enable_prerenderer_smoothing = false;
(*receive_configs)[0].renderer = this;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
- if (payload_type_ == kRedPayloadType) {
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
- if (retransmission_ssrc_ == kSendRtxSsrcs[0])
- send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
+ if (payload_type_ == test::VideoTestConstants::kRedPayloadType) {
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ if (retransmission_ssrc_ == test::VideoTestConstants::kSendRtxSsrcs[0])
+ send_config->rtp.ulpfec.red_rtx_payload_type =
+ test::VideoTestConstants::kRtxRedPayloadType;
(*receive_configs)[0].rtp.ulpfec_payload_type =
send_config->rtp.ulpfec.ulpfec_payload_type;
(*receive_configs)[0].rtp.red_payload_type =
send_config->rtp.ulpfec.red_payload_type;
}
- if (retransmission_ssrc_ == kSendRtxSsrcs[0]) {
- send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
- send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
- (*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
- (*receive_configs)[0]
- .rtp.rtx_associated_payload_types[(payload_type_ == kRedPayloadType)
- ? kRtxRedPayloadType
- : kSendRtxPayloadType] =
+ if (retransmission_ssrc_ == test::VideoTestConstants::kSendRtxSsrcs[0]) {
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[0]);
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
+ (*receive_configs)[0].rtp.rtx_ssrc =
+ test::VideoTestConstants::kSendRtxSsrcs[0];
+ (*receive_configs)[0].rtp.rtx_associated_payload_types
+ [(payload_type_ == test::VideoTestConstants::kRedPayloadType)
+ ? test::VideoTestConstants::kRtxRedPayloadType
+ : test::VideoTestConstants::kSendRtxPayloadType] =
payload_type_;
}
// Configure encoding and decoding with VP8, since generic packetization
@@ -472,12 +485,12 @@
int GetPayloadType(bool use_rtx, bool use_fec) {
if (use_fec) {
if (use_rtx)
- return kRtxRedPayloadType;
- return kRedPayloadType;
+ return test::VideoTestConstants::kRtxRedPayloadType;
+ return test::VideoTestConstants::kRedPayloadType;
}
if (use_rtx)
- return kSendRtxPayloadType;
- return kFakeVideoSendPayloadType;
+ return test::VideoTestConstants::kSendRtxPayloadType;
+ return test::VideoTestConstants::kFakeVideoSendPayloadType;
}
Mutex mutex_;
diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc
index 10d2748..009a387 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -22,6 +22,7 @@
#include "test/call_test.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -41,7 +42,7 @@
class RtcpModeObserver : public test::EndToEndTest {
public:
explicit RtcpModeObserver(RtcpMode rtcp_mode)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
rtcp_mode_(rtcp_mode),
sent_rtp_(0),
sent_rtcp_(0) {}
@@ -94,8 +95,10 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
}
@@ -168,12 +171,13 @@
class RtpSequenceObserver : public test::RtpRtcpObserver {
public:
explicit RtpSequenceObserver(bool use_rtx)
- : test::RtpRtcpObserver(kDefaultTimeout),
- ssrcs_to_observe_(kNumSimulcastStreams) {
- for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
- ssrc_is_rtx_[kVideoSendSsrcs[i]] = false;
+ : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
+ ssrcs_to_observe_(test::VideoTestConstants::kNumSimulcastStreams) {
+ for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
+ ++i) {
+ ssrc_is_rtx_[test::VideoTestConstants::kVideoSendSsrcs[i]] = false;
if (use_rtx)
- ssrc_is_rtx_[kSendRtxSsrcs[i]] = true;
+ ssrc_is_rtx_[test::VideoTestConstants::kSendRtxSsrcs[i]] = true;
}
}
@@ -188,7 +192,8 @@
uint32_t timestamp,
bool only_padding)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
- static const int32_t kMaxTimestampGap = kDefaultTimeout.ms() * 90;
+ static const int32_t kMaxTimestampGap =
+ test::VideoTestConstants::kDefaultTimeout.ms() * 90;
auto timestamp_it = last_observed_timestamp_.find(ssrc);
if (timestamp_it == last_observed_timestamp_.end()) {
EXPECT_FALSE(only_padding);
@@ -285,13 +290,16 @@
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
- CreateSendConfig(kNumSimulcastStreams, 0, 0);
+ CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0);
if (use_rtx) {
- for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
- GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+ for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
+ ++i) {
+ GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[i]);
}
- GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
+ GetVideoSendConfig()->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
}
GetVideoEncoderConfig()->video_stream_factory =
@@ -341,7 +349,7 @@
GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy());
});
- observer.ResetExpectedSsrcs(kNumSimulcastStreams);
+ observer.ResetExpectedSsrcs(test::VideoTestConstants::kNumSimulcastStreams);
EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
@@ -357,7 +365,7 @@
GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy());
});
- observer.ResetExpectedSsrcs(kNumSimulcastStreams);
+ observer.ResetExpectedSsrcs(test::VideoTestConstants::kNumSimulcastStreams);
EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
}
@@ -387,7 +395,7 @@
class RtpSequenceObserver : public test::RtpRtcpObserver {
public:
RtpSequenceObserver()
- : test::RtpRtcpObserver(kDefaultTimeout),
+ : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
num_flexfec_packets_sent_(0) {}
void ResetPacketCount() {
@@ -405,10 +413,12 @@
const uint32_t timestamp = rtp_packet.Timestamp();
const uint32_t ssrc = rtp_packet.Ssrc();
- if (ssrc == kVideoSendSsrcs[0] || ssrc == kSendRtxSsrcs[0]) {
+ if (ssrc == test::VideoTestConstants::kVideoSendSsrcs[0] ||
+ ssrc == test::VideoTestConstants::kSendRtxSsrcs[0]) {
return SEND_PACKET;
}
- EXPECT_EQ(kFlexfecSendSsrc, ssrc) << "Unknown SSRC sent.";
+ EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, ssrc)
+ << "Unknown SSRC sent.";
++num_flexfec_packets_sent_;
@@ -476,18 +486,24 @@
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
GetVideoSendConfig()->rtp.payload_name = "VP8";
- GetVideoSendConfig()->rtp.payload_type = kVideoSendPayloadType;
- GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
- GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType;
+ GetVideoSendConfig()->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
+ GetVideoSendConfig()->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[0]);
+ GetVideoSendConfig()->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
GetVideoEncoderConfig()->codec_type = kVideoCodecVP8;
CreateMatchingReceiveConfigs();
- video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
- video_receive_configs_[0]
- .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
- kVideoSendPayloadType;
+ video_receive_configs_[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ video_receive_configs_[0].rtp.rtx_ssrc =
+ test::VideoTestConstants::kSendRtxSsrcs[0];
+ video_receive_configs_[0].rtp.rtx_associated_payload_types
+ [test::VideoTestConstants::kSendRtxPayloadType] =
+ test::VideoTestConstants::kVideoSendPayloadType;
// The matching FlexFEC receive config is not created by
// CreateMatchingReceiveConfigs since this is not a test::BaseTest.
@@ -500,7 +516,8 @@
GetVideoSendConfig()->rtp.flexfec.ssrc;
flexfec_receive_config.protected_media_ssrcs =
GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs;
- flexfec_receive_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
+ flexfec_receive_config.rtp.local_ssrc =
+ test::VideoTestConstants::kReceiverLocalVideoSsrc;
flexfec_receive_configs_.push_back(flexfec_receive_config);
CreateFlexfecStreams();
diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc
index edacde1..296e7c3 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -21,6 +21,7 @@
#include "test/call_test.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
namespace webrtc {
class SsrcEndToEndTest : public test::CallTest {
@@ -37,12 +38,14 @@
TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
class SyncRtcpObserver : public test::EndToEndTest {
public:
- SyncRtcpObserver() : EndToEndTest(kDefaultTimeout) {}
+ SyncRtcpObserver()
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length));
- EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc());
+ EXPECT_EQ(test::VideoTestConstants::kReceiverLocalVideoSsrc,
+ parser.sender_ssrc());
observation_complete_.Set();
return SEND_PACKET;
@@ -64,7 +67,8 @@
: receiver_(receiver) {}
bool Wait() {
- return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout);
+ return undemuxable_packet_handler_triggered_.Wait(
+ test::VideoTestConstants::kDefaultTimeout);
}
private:
@@ -119,8 +123,10 @@
CreateMatchingReceiveConfigs(receive_transport.get());
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(
+ test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
Start();
receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
@@ -147,7 +153,7 @@
size_t num_ssrcs,
bool send_single_ssrc_first,
TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
num_ssrcs_(num_ssrcs),
send_single_ssrc_first_(send_single_ssrc_first),
ssrcs_to_observe_(num_ssrcs),
@@ -236,7 +242,8 @@
VideoSendStream* send_stream_;
VideoEncoderConfig video_encoder_config_all_streams_;
TaskQueueBase* task_queue_;
- } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first, task_queue());
+ } test(test::VideoTestConstants::kVideoSendSsrcs, num_ssrcs,
+ send_single_ssrc_first, task_queue());
RunBaseTest(&test);
}
@@ -246,21 +253,22 @@
}
TEST_F(SsrcEndToEndTest, SendsSetSimulcastSsrcs) {
- TestSendsSetSsrcs(kNumSimulcastStreams, false);
+ TestSendsSetSsrcs(test::VideoTestConstants::kNumSimulcastStreams, false);
}
TEST_F(SsrcEndToEndTest, CanSwitchToUseAllSsrcs) {
- TestSendsSetSsrcs(kNumSimulcastStreams, true);
+ TestSendsSetSsrcs(test::VideoTestConstants::kNumSimulcastStreams, true);
}
TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
class ObserveRedundantPayloads : public test::EndToEndTest {
public:
ObserveRedundantPayloads()
- : EndToEndTest(kDefaultTimeout),
- ssrcs_to_observe_(kNumSimulcastStreams) {
- for (size_t i = 0; i < kNumSimulcastStreams; ++i) {
- registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true;
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
+ ssrcs_to_observe_(test::VideoTestConstants::kNumSimulcastStreams) {
+ for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
+ ++i) {
+ registered_rtx_ssrc_[test::VideoTestConstants::kSendRtxSsrcs[i]] = true;
}
}
@@ -286,7 +294,9 @@
return SEND_PACKET;
}
- size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; }
+ size_t GetNumVideoStreams() const override {
+ return test::VideoTestConstants::kNumSimulcastStreams;
+ }
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
@@ -299,10 +309,13 @@
layer.target_bitrate_bps = 15000;
layer.max_bitrate_bps = 20000;
}
- send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
- for (size_t i = 0; i < kNumSimulcastStreams; ++i)
- send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+ for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
+ ++i)
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[i]);
// Significantly higher than max bitrates for all video streams -> forcing
// padding to trigger redundant padding on all RTX SSRCs.
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index 147227d..4a1c093 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -28,6 +28,7 @@
#include "test/fake_encoder.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -51,7 +52,8 @@
class StatsObserver : public test::EndToEndTest {
public:
StatsObserver()
- : EndToEndTest(kLongTimeout), encoder_factory_([]() {
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
+ encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), 10);
}) {}
@@ -135,9 +137,11 @@
stats.rtcp_packet_type_counts.unique_nack_requests != 0;
RTC_DCHECK(stats.current_payload_type == -1 ||
- stats.current_payload_type == kFakeVideoSendPayloadType);
+ stats.current_payload_type ==
+ test::VideoTestConstants::kFakeVideoSendPayloadType);
receive_stats_filled_["IncomingPayloadType"] |=
- stats.current_payload_type == kFakeVideoSendPayloadType;
+ stats.current_payload_type ==
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
}
return AllStatsFilled(receive_stats_filled_);
@@ -150,7 +154,8 @@
SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
size_t expected_num_streams =
- kNumSimulcastStreams + expected_send_ssrcs_.size();
+ test::VideoTestConstants::kNumSimulcastStreams +
+ expected_send_ssrcs_.size();
send_stats_filled_["NumStreams"] |=
stats.substreams.size() == expected_num_streams;
@@ -252,8 +257,10 @@
}
send_config->rtp.c_name = "SomeCName";
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs;
for (size_t i = 0; i < ssrcs.size(); ++i) {
@@ -261,23 +268,29 @@
expected_receive_ssrcs_.push_back(
(*receive_configs)[i].rtp.remote_ssrc);
(*receive_configs)[i].render_delay_ms = kExpectedRenderDelayMs;
- (*receive_configs)[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ (*receive_configs)[i].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
- (*receive_configs)[i].rtp.rtx_ssrc = kSendRtxSsrcs[i];
- (*receive_configs)[i]
- .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
- kFakeVideoSendPayloadType;
+ (*receive_configs)[i].rtp.rtx_ssrc =
+ test::VideoTestConstants::kSendRtxSsrcs[i];
+ (*receive_configs)[i].rtp.rtx_associated_payload_types
+ [test::VideoTestConstants::kSendRtxPayloadType] =
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
}
- for (size_t i = 0; i < kNumSimulcastStreams; ++i)
- send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+ for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
+ ++i)
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[i]);
// Use a delayed encoder to make sure we see CpuOveruseMetrics stats that
// are non-zero.
send_config->encoder_settings.encoder_factory = &encoder_factory_;
}
- size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; }
+ size_t GetNumVideoStreams() const override {
+ return test::VideoTestConstants::kNumSimulcastStreams;
+ }
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
@@ -290,7 +303,8 @@
void PerformTest() override {
Clock* clock = Clock::GetRealTimeClock();
int64_t now_ms = clock->TimeInMilliseconds();
- int64_t stop_time_ms = now_ms + test::CallTest::kLongTimeout.ms();
+ int64_t stop_time_ms =
+ now_ms + test::VideoTestConstants::kLongTimeout.ms();
bool receive_ok = false;
bool send_ok = false;
@@ -347,7 +361,7 @@
class StatsObserver : public test::EndToEndTest {
public:
- StatsObserver() : EndToEndTest(kLongTimeout) {}
+ StatsObserver() : EndToEndTest(test::VideoTestConstants::kLongTimeout) {}
private:
void ModifyVideoConfigs(
@@ -395,7 +409,8 @@
class ReceivedRtpStatsObserver : public test::EndToEndTest {
public:
explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue)
- : EndToEndTest(kDefaultTimeout), task_queue_(task_queue) {}
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
+ task_queue_(task_queue) {}
private:
void OnVideoStreamsCreated(VideoSendStream* send_stream,
@@ -447,7 +462,9 @@
class StatsObserver : public test::BaseTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
- StatsObserver() : BaseTest(kLongTimeout), num_frames_received_(0) {}
+ StatsObserver()
+ : BaseTest(test::VideoTestConstants::kLongTimeout),
+ num_frames_received_(0) {}
bool ShouldCreateReceivers() const override { return true; }
@@ -512,8 +529,10 @@
CreateMatchingReceiveConfigs();
// Modify send and receive configs.
- GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ GetVideoSendConfig()->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ video_receive_configs_[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].renderer = &test;
// RTT needed for RemoteNtpTimeEstimator for the receive stream.
video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report =
@@ -527,8 +546,10 @@
VideoEncoderConfig::ContentType::kScreen;
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(
+ test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
Start();
});
@@ -572,7 +593,8 @@
class NackObserver : public test::EndToEndTest {
public:
explicit NackObserver(TaskQueueBase* task_queue)
- : EndToEndTest(kLongTimeout), task_queue_(task_queue) {}
+ : EndToEndTest(test::VideoTestConstants::kLongTimeout),
+ task_queue_(task_queue) {}
private:
Action OnSendRtp(const uint8_t* packet, size_t length) override {
@@ -638,8 +660,10 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ (*receive_configs)[0].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
}
void OnVideoStreamsCreated(VideoSendStream* send_stream,
@@ -695,8 +719,9 @@
CreateMatchingReceiveConfigs();
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
Start();
});
@@ -706,7 +731,7 @@
Call::Stats stats;
SendTask(task_queue(),
[this, &stats]() { stats = sender_call_->GetStats(); });
- ASSERT_GE(start_time_ms + kDefaultTimeout.ms(),
+ ASSERT_GE(start_time_ms + test::VideoTestConstants::kDefaultTimeout.ms(),
clock_->TimeInMilliseconds())
<< "No RTT stats before timeout!";
if (stats.rtt_ms != -1) {
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 0703f29..33cddce 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -26,6 +26,7 @@
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
#include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc {
@@ -251,7 +252,7 @@
class TransportFeedbackTester : public test::EndToEndTest {
public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
- : EndToEndTest(::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
receiver_call_(nullptr) {
@@ -279,7 +280,8 @@
}
void PerformTest() override {
- EXPECT_TRUE(observation_complete_.Wait(test::CallTest::kDefaultTimeout));
+ EXPECT_TRUE(
+ observation_complete_.Wait(test::VideoTestConstants::kDefaultTimeout));
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@@ -326,8 +328,7 @@
class TransportFeedbackTester : public test::EndToEndTest {
public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
- : EndToEndTest(
- ::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams),
media_sent_(0),
@@ -415,7 +416,7 @@
class TransportSequenceNumberTest : public test::EndToEndTest {
public:
TransportSequenceNumberTest()
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
video_observed_(false),
audio_observed_(false) {
extensions_.Register<TransportSequenceNumber>(
@@ -444,9 +445,9 @@
int64_t packet_id = unwrapper_.Unwrap(transport_sequence_number);
EXPECT_TRUE(received_packet_ids_.insert(packet_id).second);
- if (rtp_packet.Ssrc() == kVideoSendSsrcs[0])
+ if (rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0])
video_observed_ = true;
- if (rtp_packet.Ssrc() == kAudioSendSsrc)
+ if (rtp_packet.Ssrc() == test::VideoTestConstants::kAudioSendSsrc)
audio_observed_ = true;
if (audio_observed_ && video_observed_ &&
received_packet_ids_.size() >= kMinPacketsToWaitFor) {
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 06491b9..60d3f52 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -25,6 +25,7 @@
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/call_test.h"
+#include "test/video_test_constants.h"
namespace webrtc {
namespace {
@@ -43,7 +44,7 @@
class PictureIdObserver : public test::RtpRtcpObserver {
public:
explicit PictureIdObserver(VideoCodecType codec_type)
- : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout),
+ : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
depacketizer_(CreateVideoRtpDepacketizer(codec_type)),
max_expected_picture_id_gap_(0),
max_expected_tl0_idx_gap_(0),
@@ -84,9 +85,10 @@
ParsedPacket* parsed) const {
RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length));
- EXPECT_TRUE(rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[0] ||
- rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[1] ||
- rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[2])
+ EXPECT_TRUE(
+ rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0] ||
+ rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[1] ||
+ rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[2])
<< "Unknown SSRC sent.";
if (rtp_packet.payload_size() == 0) {
@@ -257,7 +259,8 @@
task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
- CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get());
+ CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0,
+ send_transport_.get());
GetVideoSendConfig()->encoder_settings.encoder_factory =
encoder_factory;
GetVideoSendConfig()->rtp.payload_name = payload_name;
diff --git a/video/quality_scaling_tests.cc b/video/quality_scaling_tests.cc
index 80b6616..b6f1575 100644
--- a/video/quality_scaling_tests.cc
+++ b/video/quality_scaling_tests.cc
@@ -19,6 +19,7 @@
#include "test/call_test.h"
#include "test/field_trial.h"
#include "test/frame_generator_capturer.h"
+#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h"
namespace webrtc {
@@ -126,7 +127,8 @@
VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
encoder_config->video_format.name = payload_name_;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type;
diff --git a/video/video_analyzer.cc b/video/video_analyzer.cc
index 6d70762..24bcfc9 100644
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@@ -34,6 +34,7 @@
#include "test/testsupport/file_utils.h"
#include "test/testsupport/frame_writer.h"
#include "test/testsupport/test_artifacts.h"
+#include "test/video_test_constants.h"
ABSL_FLAG(bool,
save_worst_frame,
@@ -59,7 +60,7 @@
kKeepAliveInterval.ms() / kProbingInterval.ms();
bool IsFlexfec(int payload_type) {
- return payload_type == test::CallTest::kFlexfecPayloadType;
+ return payload_type == test::VideoTestConstants::kFlexfecPayloadType;
}
} // namespace
@@ -437,7 +438,7 @@
bool VideoAnalyzer::IsInSelectedSpatialAndTemporalLayer(
const RtpPacket& rtp_packet) {
- if (rtp_packet.PayloadType() == test::CallTest::kPayloadTypeVP8) {
+ if (rtp_packet.PayloadType() == test::VideoTestConstants::kPayloadTypeVP8) {
auto parsed_payload = vp8_depacketizer_->Parse(rtp_packet.PayloadBuffer());
RTC_DCHECK(parsed_payload);
const auto& vp8_header = absl::get<RTPVideoHeaderVP8>(
@@ -447,7 +448,7 @@
temporal_idx <= selected_tl_;
}
- if (rtp_packet.PayloadType() == test::CallTest::kPayloadTypeVP9) {
+ if (rtp_packet.PayloadType() == test::VideoTestConstants::kPayloadTypeVP9) {
auto parsed_payload = vp9_depacketizer_->Parse(rtp_packet.PayloadBuffer());
RTC_DCHECK(parsed_payload);
const auto& vp9_header = absl::get<RTPVideoHeaderVP9>(
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 1e71774..2dd80ea 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -54,6 +54,7 @@
#ifdef WEBRTC_WIN
#include "modules/audio_device/include/audio_device_factory.h"
#endif
+#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h"
namespace webrtc {
@@ -714,26 +715,26 @@
RTC_CHECK_GT(num_video_substreams, 0);
for (size_t i = 0; i < num_video_substreams; ++i)
video_send_configs_[video_idx].rtp.ssrcs.push_back(
- kVideoSendSsrcs[total_streams_used + i]);
+ test::VideoTestConstants::kVideoSendSsrcs[total_streams_used + i]);
int payload_type;
if (params_.video[video_idx].codec == "H264") {
- payload_type = kPayloadTypeH264;
+ payload_type = test::VideoTestConstants::kPayloadTypeH264;
} else if (params_.video[video_idx].codec == "VP8") {
- payload_type = kPayloadTypeVP8;
+ payload_type = test::VideoTestConstants::kPayloadTypeVP8;
} else if (params_.video[video_idx].codec == "VP9") {
- payload_type = kPayloadTypeVP9;
+ payload_type = test::VideoTestConstants::kPayloadTypeVP9;
} else if (params_.video[video_idx].codec == "multiplex") {
- payload_type = kPayloadTypeVP9;
+ payload_type = test::VideoTestConstants::kPayloadTypeVP9;
} else if (params_.video[video_idx].codec == "FakeCodec") {
- payload_type = kFakeVideoSendPayloadType;
+ payload_type = test::VideoTestConstants::kFakeVideoSendPayloadType;
} else {
RTC_CHECK(generic_codec_name.empty() ||
generic_codec_name == params_.video[video_idx].codec)
<< "Supplying multiple generic codecs is unsupported.";
RTC_LOG(LS_INFO) << "Treating codec " << params_.video[video_idx].codec
<< " as generic.";
- payload_type = kPayloadTypeGeneric;
+ payload_type = test::VideoTestConstants::kPayloadTypeGeneric;
generic_codec_name = params_.video[video_idx].codec;
}
video_send_configs_[video_idx].encoder_settings.encoder_factory =
@@ -745,11 +746,13 @@
video_send_configs_[video_idx].rtp.payload_name =
params_.video[video_idx].codec;
video_send_configs_[video_idx].rtp.payload_type = payload_type;
- video_send_configs_[video_idx].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType;
+ video_send_configs_[video_idx].rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ video_send_configs_[video_idx].rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
for (size_t i = 0; i < num_video_substreams; ++i) {
video_send_configs_[video_idx].rtp.rtx.ssrcs.push_back(
- kSendRtxSsrcs[i + total_streams_used]);
+ test::VideoTestConstants::kSendRtxSsrcs[i + total_streams_used]);
}
video_send_configs_[video_idx].rtp.extensions.clear();
if (params_.call.send_side_bwe) {
@@ -824,7 +827,7 @@
decode_sub_stream = params_.ss[video_idx].selected_stream;
CreateMatchingVideoReceiveConfigs(
video_send_configs_[video_idx], recv_transport, &video_decoder_factory_,
- decode_sub_stream, true, kNackRtpHistoryMs);
+ decode_sub_stream, true, test::VideoTestConstants::kNackRtpHistoryMs);
if (params_.screenshare[video_idx].enabled) {
// Fill out codec settings.
@@ -925,7 +928,9 @@
if (decode_all_receive_streams) {
SetSendFecConfig(GetVideoSendConfig()->rtp.ssrcs);
} else {
- SetSendFecConfig({kVideoSendSsrcs[params_.ss[0].selected_stream]});
+ SetSendFecConfig(
+ {test::VideoTestConstants::kVideoSendSsrcs[params_.ss[0]
+ .selected_stream]});
}
CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
@@ -956,9 +961,12 @@
thumbnail_send_config.encoder_settings.bitrate_allocator_factory =
video_bitrate_allocator_factory_.get();
thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
- thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
- thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType;
+ thumbnail_send_config.rtp.payload_type =
+ test::VideoTestConstants::kPayloadTypeVP8;
+ thumbnail_send_config.rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
+ thumbnail_send_config.rtp.rtx.payload_type =
+ test::VideoTestConstants::kSendRtxPayloadType;
thumbnail_send_config.rtp.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
thumbnail_send_config.rtp.extensions.clear();
if (params_.call.send_side_bwe) {
@@ -988,7 +996,8 @@
AddMatchingVideoReceiveConfigs(
&thumbnail_receive_configs_, thumbnail_send_config, send_transport,
- &video_decoder_factory_, absl::nullopt, false, kNackRtpHistoryMs);
+ &video_decoder_factory_, absl::nullopt, false,
+ test::VideoTestConstants::kNackRtpHistoryMs);
}
for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(
@@ -1169,11 +1178,12 @@
return std::make_unique<test::LayerFilteringTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
- sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
- params_.video[0].selected_tl, params_.ss[0].selected_sl,
- payload_type_map_, kVideoSendSsrcs[0],
- static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() -
- 1),
+ sender_call_.get(), test::VideoTestConstants::kPayloadTypeVP8,
+ test::VideoTestConstants::kPayloadTypeVP9, params_.video[0].selected_tl,
+ params_.ss[0].selected_sl, payload_type_map_,
+ test::VideoTestConstants::kVideoSendSsrcs[0],
+ static_cast<uint32_t>(test::VideoTestConstants::kVideoSendSsrcs[0] +
+ params_.ss[0].streams.size() - 1),
GetRegisteredExtensions(), GetRegisteredExtensions());
}
@@ -1263,8 +1273,8 @@
? TimeDelta::Millis(1)
: TimeDelta::Seconds(params_.analyzer.test_durations_secs),
graph_data_output_file, graph_title,
- kVideoSendSsrcs[params_.ss[0].selected_stream],
- kSendRtxSsrcs[params_.ss[0].selected_stream],
+ test::VideoTestConstants::kVideoSendSsrcs[params_.ss[0].selected_stream],
+ test::VideoTestConstants::kSendRtxSsrcs[params_.ss[0].selected_stream],
static_cast<size_t>(params_.ss[0].selected_stream),
params.ss[0].selected_sl, params_.video[0].selected_tl,
is_quick_test_enabled, clock_, params_.logging.rtp_dump_name,
@@ -1393,13 +1403,13 @@
void VideoQualityTest::SetupAudio(Transport* transport) {
AudioSendStream::Config audio_send_config(transport);
- audio_send_config.rtp.ssrc = kAudioSendSsrc;
+ audio_send_config.rtp.ssrc = test::VideoTestConstants::kAudioSendSsrc;
// Add extension to enable audio send side BWE, and allow audio bit rate
// adaptation.
audio_send_config.rtp.extensions.clear();
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
- kAudioSendPayloadType,
+ test::VideoTestConstants::kAudioSendPayloadType,
{"OPUS",
48000,
2,
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 4e1fefe..cb24993 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -71,6 +71,7 @@
#include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h"
#include "test/video_encoder_proxy_factory.h"
+#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h"
#include "video/send_statistics_proxy.h"
#include "video/transport_adapter.h"
@@ -186,7 +187,7 @@
static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
class CNameObserver : public test::SendTest {
public:
- CNameObserver() : SendTest(kDefaultTimeout) {}
+ CNameObserver() : SendTest(test::VideoTestConstants::kDefaultTimeout) {}
private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override {
@@ -220,7 +221,8 @@
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
class AbsoluteSendTimeObserver : public test::SendTest {
public:
- AbsoluteSendTimeObserver() : SendTest(kDefaultTimeout) {
+ AbsoluteSendTimeObserver()
+ : SendTest(test::VideoTestConstants::kDefaultTimeout) {
extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId);
}
@@ -271,7 +273,8 @@
class TransmissionTimeOffsetObserver : public test::SendTest {
public:
TransmissionTimeOffsetObserver()
- : SendTest(kDefaultTimeout), encoder_factory_([]() {
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
+ encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), kEncodeDelayMs);
}) {
@@ -318,7 +321,8 @@
class TransportWideSequenceNumberObserver : public test::SendTest {
public:
TransportWideSequenceNumberObserver()
- : SendTest(kDefaultTimeout), encoder_factory_([]() {
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
+ encoder_factory_([]() {
return std::make_unique<test::FakeEncoder>(
Clock::GetRealTimeClock());
}) {
@@ -360,7 +364,8 @@
TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
class VideoRotationObserver : public test::SendTest {
public:
- VideoRotationObserver() : SendTest(kDefaultTimeout) {
+ VideoRotationObserver()
+ : SendTest(test::VideoTestConstants::kDefaultTimeout) {
extensions_.Register<VideoOrientation>(kVideoRotationExtensionId);
}
@@ -404,7 +409,8 @@
class VideoContentTypeObserver : public test::SendTest {
public:
VideoContentTypeObserver()
- : SendTest(kDefaultTimeout), first_frame_sent_(false) {
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
+ first_frame_sent_(false) {
extensions_.Register<VideoContentTypeExtension>(
kVideoContentTypeExtensionId);
}
@@ -450,7 +456,8 @@
class VideoTimingObserver : public test::SendTest {
public:
VideoTimingObserver()
- : SendTest(kDefaultTimeout), first_frame_sent_(false) {
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
+ first_frame_sent_(false) {
extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId);
}
@@ -522,7 +529,7 @@
bool expect_ulpfec,
const std::string& codec,
VideoEncoderFactory* encoder_factory)
- : EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeout
+ : EndToEndTest(expect_ulpfec ? test::VideoTestConstants::kDefaultTimeout
: kReducedTimeout),
encoder_factory_(encoder_factory),
payload_name_(codec),
@@ -543,16 +550,16 @@
EXPECT_TRUE(rtp_packet.Parse(packet, length));
int encapsulated_payload_type = -1;
- if (rtp_packet.PayloadType() == VideoSendStreamTest::kRedPayloadType) {
+ if (rtp_packet.PayloadType() == test::VideoTestConstants::kRedPayloadType) {
EXPECT_TRUE(expect_red_);
encapsulated_payload_type = rtp_packet.payload()[0];
if (encapsulated_payload_type !=
- VideoSendStreamTest::kFakeVideoSendPayloadType) {
- EXPECT_EQ(VideoSendStreamTest::kUlpfecPayloadType,
+ test::VideoTestConstants::kFakeVideoSendPayloadType) {
+ EXPECT_EQ(test::VideoTestConstants::kUlpfecPayloadType,
encapsulated_payload_type);
}
} else {
- EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType,
+ EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType());
if (rtp_packet.payload_size() > 0) {
// Not padding-only, media received outside of RED.
@@ -587,7 +594,7 @@
if (encapsulated_payload_type != -1) {
if (encapsulated_payload_type ==
- VideoSendStreamTest::kUlpfecPayloadType) {
+ test::VideoTestConstants::kUlpfecPayloadType) {
EXPECT_TRUE(expect_ulpfec_);
sent_ulpfec_ = true;
} else {
@@ -619,14 +626,14 @@
if (use_nack_) {
send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms =
- VideoSendStreamTest::kNackRtpHistoryMs;
+ test::VideoTestConstants::kNackRtpHistoryMs;
}
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
send_config->rtp.ulpfec.red_payload_type =
- VideoSendStreamTest::kRedPayloadType;
+ test::VideoTestConstants::kRedPayloadType;
send_config->rtp.ulpfec.ulpfec_payload_type =
- VideoSendStreamTest::kUlpfecPayloadType;
+ test::VideoTestConstants::kUlpfecPayloadType;
if (!header_extensions_enabled_) {
send_config->rtp.extensions.clear();
} else {
@@ -746,7 +753,7 @@
const std::string& codec,
VideoEncoderFactory* encoder_factory,
size_t num_video_streams)
- : EndToEndTest(VideoSendStreamTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_(encoder_factory),
payload_name_(codec),
use_nack_(use_nack),
@@ -768,15 +775,17 @@
RtpPacket rtp_packet(&extensions_);
EXPECT_TRUE(rtp_packet.Parse(packet, length));
- if (rtp_packet.PayloadType() == VideoSendStreamTest::kFlexfecPayloadType) {
- EXPECT_EQ(VideoSendStreamTest::kFlexfecSendSsrc, rtp_packet.Ssrc());
+ if (rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kFlexfecPayloadType) {
+ EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, rtp_packet.Ssrc());
sent_flexfec_ = true;
} else {
- EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType,
+ EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType());
- EXPECT_THAT(::testing::make_tuple(VideoSendStreamTest::kVideoSendSsrcs,
- num_video_streams_),
- ::testing::Contains(rtp_packet.Ssrc()));
+ EXPECT_THAT(
+ ::testing::make_tuple(test::VideoTestConstants::kVideoSendSsrcs,
+ num_video_streams_),
+ ::testing::Contains(rtp_packet.Ssrc()));
sent_media_ = true;
}
@@ -819,7 +828,7 @@
if (use_nack_) {
send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms =
- VideoSendStreamTest::kNackRtpHistoryMs;
+ test::VideoTestConstants::kNackRtpHistoryMs;
}
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
@@ -928,7 +937,7 @@
public:
explicit NackObserver(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type)
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
send_count_(0),
retransmit_count_(0),
retransmit_ssrc_(retransmit_ssrc),
@@ -956,11 +965,12 @@
config.clock = Clock::GetRealTimeClock();
config.outgoing_transport = transport_adapter_.get();
config.rtcp_report_interval = TimeDelta::Millis(kRtcpIntervalMs);
- config.local_media_ssrc = kReceiverLocalVideoSsrc;
+ config.local_media_ssrc =
+ test::VideoTestConstants::kReceiverLocalVideoSsrc;
RTCPSender rtcp_sender(config);
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
- rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
+ rtcp_sender.SetRemoteSSRC(test::VideoTestConstants::kVideoSendSsrcs[0]);
RTCPSender::FeedbackState feedback_state;
uint16_t nack_sequence_numbers[kNackedPacketsAtOnceCount];
@@ -980,7 +990,7 @@
uint16_t sequence_number = rtp_packet.SequenceNumber();
if (rtp_packet.Ssrc() == retransmit_ssrc_ &&
- retransmit_ssrc_ != kVideoSendSsrcs[0]) {
+ retransmit_ssrc_ != test::VideoTestConstants::kVideoSendSsrcs[0]) {
// Not kVideoSendSsrcs[0], assume correct RTX packet. Extract sequence
// number.
const uint8_t* rtx_header = rtp_packet.payload().data();
@@ -991,7 +1001,7 @@
if (it == sequence_numbers_pending_retransmission_.end()) {
// Not currently pending retransmission. Add it to retransmission queue
// if media and limit not reached.
- if (rtp_packet.Ssrc() == kVideoSendSsrcs[0] &&
+ if (rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0] &&
rtp_packet.payload_size() > 0 &&
retransmit_count_ +
sequence_numbers_pending_retransmission_.size() <
@@ -1019,9 +1029,10 @@
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
- send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ send_config->rtp.nack.rtp_history_ms =
+ test::VideoTestConstants::kNackRtpHistoryMs;
send_config->rtp.rtx.payload_type = retransmit_payload_type_;
- if (retransmit_ssrc_ != kVideoSendSsrcs[0])
+ if (retransmit_ssrc_ != test::VideoTestConstants::kVideoSendSsrcs[0])
send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_);
}
@@ -1042,12 +1053,14 @@
TEST_F(VideoSendStreamTest, RetransmitsNack) {
// Normal NACKs should use the send SSRC.
- TestNackRetransmission(kVideoSendSsrcs[0], kFakeVideoSendPayloadType);
+ TestNackRetransmission(test::VideoTestConstants::kVideoSendSsrcs[0],
+ test::VideoTestConstants::kFakeVideoSendPayloadType);
}
TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
// NACKs over RTX should use a separate SSRC.
- TestNackRetransmission(kSendRtxSsrcs[0], kSendRtxPayloadType);
+ TestNackRetransmission(test::VideoTestConstants::kSendRtxSsrcs[0],
+ test::VideoTestConstants::kSendRtxPayloadType);
}
void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
@@ -1068,7 +1081,7 @@
size_t stop_size,
bool test_generic_packetization,
bool use_fec)
- : SendTest(kLongTimeout),
+ : SendTest(test::VideoTestConstants::kLongTimeout),
encoder_(stop),
encoder_factory_(&encoder_),
max_packet_size_(max_packet_size),
@@ -1101,8 +1114,10 @@
if (use_fec_ && rtp_packet.payload_size() > 0) {
uint8_t payload_type = rtp_packet.payload()[0];
- bool is_fec = rtp_packet.PayloadType() == kRedPayloadType &&
- payload_type == kUlpfecPayloadType;
+ bool is_fec =
+ rtp_packet.PayloadType() ==
+ test::VideoTestConstants::kRedPayloadType &&
+ payload_type == test::VideoTestConstants::kUlpfecPayloadType;
if (is_fec) {
fec_packet_received_ = true;
return SEND_PACKET;
@@ -1181,7 +1196,8 @@
uint8_t loss_ratio =
static_cast<uint8_t>(loss_delta * 255 / packets_delta);
FakeReceiveStatistics lossy_receive_stats(
- kVideoSendSsrcs[0], rtp_packet.SequenceNumber(),
+ test::VideoTestConstants::kVideoSendSsrcs[0],
+ rtp_packet.SequenceNumber(),
packets_lost_, // Cumulative lost.
loss_ratio); // Loss percent.
RTCPSender::Configuration config;
@@ -1189,11 +1205,11 @@
config.receive_statistics = &lossy_receive_stats;
config.outgoing_transport = transport_adapter_.get();
config.rtcp_report_interval = TimeDelta::Millis(kRtcpIntervalMs);
- config.local_media_ssrc = kVideoSendSsrcs[0];
+ config.local_media_ssrc = test::VideoTestConstants::kVideoSendSsrcs[0];
RTCPSender rtcp_sender(config);
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
- rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);
+ rtcp_sender.SetRemoteSSRC(test::VideoTestConstants::kVideoSendSsrcs[0]);
RTCPSender::FeedbackState feedback_state;
@@ -1224,8 +1240,10 @@
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
if (use_fec_) {
- send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
- send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
+ send_config->rtp.ulpfec.red_payload_type =
+ test::VideoTestConstants::kRedPayloadType;
+ send_config->rtp.ulpfec.ulpfec_payload_type =
+ test::VideoTestConstants::kUlpfecPayloadType;
}
if (!test_generic_packetization_)
@@ -1302,7 +1320,7 @@
class NoPaddingWhenVideoIsMuted : public test::SendTest {
public:
NoPaddingWhenVideoIsMuted()
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
capturer_(nullptr) {}
@@ -1391,7 +1409,7 @@
class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
public:
PaddingIsPrimarilyRetransmissions()
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()),
padding_length_(0),
total_length_(0),
@@ -1426,8 +1444,10 @@
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Turn on RTX.
- send_config->rtp.rtx.payload_type = kFakeVideoSendPayloadType;
- send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
+ send_config->rtp.rtx.payload_type =
+ test::VideoTestConstants::kFakeVideoSendPayloadType;
+ send_config->rtp.rtx.ssrcs.push_back(
+ test::VideoTestConstants::kSendRtxSsrcs[0]);
}
void PerformTest() override {
@@ -1467,7 +1487,7 @@
class BitrateObserver : public test::SendTest {
public:
explicit BitrateObserver(TaskQueueBase* task_queue)
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue),
retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000),
stream_(nullptr),
@@ -1560,7 +1580,7 @@
class ChangingNetworkRouteTest : public test::EndToEndTest {
public:
explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr) {
module_process_thread_.Detach();
@@ -1680,7 +1700,7 @@
class RelayToDirectRouteTest : public test::EndToEndTest {
public:
explicit RelayToDirectRouteTest(TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr),
packets_sent_(0),
@@ -1775,7 +1795,7 @@
class ChangingTransportOverheadTest : public test::EndToEndTest {
public:
explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue),
call_(nullptr),
packets_sent_(0),
@@ -1851,7 +1871,7 @@
MaxPaddingSetTest(bool test_switch_content_type,
T* stream_reset_fun,
TaskQueueBase* task_queue)
- : SendTest(test::CallTest::kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
running_without_padding_(test_switch_content_type),
stream_resetter_(stream_reset_fun),
task_queue_(task_queue) {
@@ -2009,7 +2029,7 @@
}
}
EXPECT_TRUE(
- init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeout));
+ init_encode_called_.Wait(test::VideoTestConstants::kDefaultTimeout));
{
MutexLock lock(&mutex_);
EXPECT_EQ(width, last_initialized_frame_width_);
@@ -2049,19 +2069,23 @@
CreateSendConfig(1, 0, 0, &transport);
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
CreateVideoStreams();
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
frame_generator_capturer_->Start();
});
- encoder.WaitForResolution(kDefaultWidth, kDefaultHeight);
+ encoder.WaitForResolution(test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
SendTask(task_queue(), [this]() {
- frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2,
- kDefaultHeight * 2);
+ frame_generator_capturer_->ChangeResolution(
+ test::VideoTestConstants::kDefaultWidth * 2,
+ test::VideoTestConstants::kDefaultHeight * 2);
});
- encoder.WaitForResolution(kDefaultWidth * 2, kDefaultHeight * 2);
+ encoder.WaitForResolution(test::VideoTestConstants::kDefaultWidth * 2,
+ test::VideoTestConstants::kDefaultHeight * 2);
SendTask(task_queue(), [this]() {
DestroyStreams();
@@ -2095,7 +2119,8 @@
}
bool WaitForStartBitrate() {
- return start_bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout);
+ return start_bitrate_changed_.Wait(
+ test::VideoTestConstants::kDefaultTimeout);
}
private:
@@ -2122,8 +2147,9 @@
CreateVideoStreams();
// Start capturing and encoding frames to force encoder reconfiguration.
- CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
- kDefaultHeight);
+ CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+ test::VideoTestConstants::kDefaultWidth,
+ test::VideoTestConstants::kDefaultHeight);
frame_generator_capturer_->Start();
// TODO(crbug/1255737): Added manual current thread message processing because
// the test code context is interpreted as the worker thread and we assume
@@ -2173,7 +2199,7 @@
}
bool WaitForEncoderInit() {
- return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeout);
+ return encoder_init_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
bool WaitBitrateChanged(WaitUntil until) {
@@ -2190,7 +2216,7 @@
(until == WaitUntil::kZero && *bitrate_kbps == 0)) {
return true;
}
- } while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout));
+ } while (bitrate_changed_.Wait(test::VideoTestConstants::kDefaultTimeout));
return false;
}
@@ -2205,7 +2231,7 @@
class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public:
explicit EncoderStateObserver(TaskQueueBase* task_queue)
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue),
stream_(nullptr),
initialized_(false),
@@ -2338,7 +2364,7 @@
public:
VideoCodecConfigObserver(VideoCodecType video_codec_type,
TaskQueueBase* task_queue)
- : SendTest(VideoSendStreamTest::kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type),
stream_(nullptr),
@@ -2384,7 +2410,8 @@
GetEncoderSpecificSettings() const;
void PerformTest() override {
- EXPECT_TRUE(init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout));
+ EXPECT_TRUE(
+ init_encode_event_.Wait(test::VideoTestConstants::kDefaultTimeout));
ASSERT_EQ(1, FakeEncoder::GetNumInitializations())
<< "VideoEncoder not initialized.";
@@ -2394,7 +2421,8 @@
SendTask(task_queue_, [&]() {
stream_->ReconfigureVideoEncoder(std::move(encoder_config_));
});
- ASSERT_TRUE(init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout));
+ ASSERT_TRUE(
+ init_encode_event_.Wait(test::VideoTestConstants::kDefaultTimeout));
EXPECT_EQ(2, FakeEncoder::GetNumInitializations())
<< "ReconfigureVideoEncoder did not reinitialize the encoder with "
"new encoder settings.";
@@ -2539,7 +2567,7 @@
class RtcpSenderReportTest : public test::SendTest {
public:
RtcpSenderReportTest()
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
rtp_packets_sent_(0),
media_bytes_sent_(0) {}
@@ -2614,7 +2642,7 @@
public test::FakeEncoder {
public:
ScreencastTargetBitrateTest()
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this) {}
@@ -2672,7 +2700,7 @@
public test::FakeEncoder {
public:
explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue)
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
target_bitrate_(0),
@@ -2760,7 +2788,7 @@
}
} while (bitrate_changed_event_.Wait(
std::max(TimeDelta::Millis(1),
- VideoSendStreamTest::kDefaultTimeout -
+ test::VideoTestConstants::kDefaultTimeout -
TimeDelta::Millis(rtc::TimeMillis() - start_time))));
MutexLock lock(&mutex_);
EXPECT_NEAR(target_bitrate_, expected_bitrate, abs_error)
@@ -2801,9 +2829,10 @@
void PerformTest() override {
ASSERT_TRUE(create_rate_allocator_event_.Wait(
- VideoSendStreamTest::kDefaultTimeout))
+ test::VideoTestConstants::kDefaultTimeout))
<< "Timed out while waiting for rate allocator to be created.";
- ASSERT_TRUE(init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeout))
+ ASSERT_TRUE(
+ init_encode_event_.Wait(test::VideoTestConstants::kDefaultTimeout))
<< "Timed out while waiting for encoder to be configured.";
WaitForSetRates(kStartBitrateKbps, 80);
BitrateConstraints bitrate_config;
@@ -2820,7 +2849,7 @@
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
ASSERT_TRUE(create_rate_allocator_event_.Wait(
- VideoSendStreamTest::kDefaultTimeout));
+ test::VideoTestConstants::kDefaultTimeout));
EXPECT_EQ(2, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated.";
@@ -2832,7 +2861,7 @@
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
});
ASSERT_TRUE(create_rate_allocator_event_.Wait(
- VideoSendStreamTest::kDefaultTimeout));
+ test::VideoTestConstants::kDefaultTimeout));
EXPECT_EQ(3, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated.";
@@ -2872,7 +2901,7 @@
public test::FakeEncoder {
public:
explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue)
- : SendTest(kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()),
send_stream_(nullptr),
encoder_factory_(this),
@@ -2928,12 +2957,14 @@
SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
for (size_t i = 0; i < kNumStreams; ++i) {
- ASSERT_TRUE(stats.substreams.find(kVideoSendSsrcs[i]) !=
+ ASSERT_TRUE(stats.substreams.find(
+ test::VideoTestConstants::kVideoSendSsrcs[i]) !=
stats.substreams.end())
- << "No stats for SSRC: " << kVideoSendSsrcs[i]
+ << "No stats for SSRC: "
+ << test::VideoTestConstants::kVideoSendSsrcs[i]
<< ", stats should exist as soon as frames have been encoded.";
VideoSendStream::StreamStats ssrc_stats =
- stats.substreams[kVideoSendSsrcs[i]];
+ stats.substreams[test::VideoTestConstants::kVideoSendSsrcs[i]];
EXPECT_EQ(kEncodedResolution[i].width, ssrc_stats.width);
EXPECT_EQ(kEncodedResolution[i].height, ssrc_stats.height);
}
@@ -2957,7 +2988,7 @@
class Vp9HeaderObserver : public test::SendTest {
public:
explicit Vp9HeaderObserver(const Vp9TestParams& params)
- : SendTest(VideoSendStreamTest::kLongTimeout),
+ : SendTest(test::VideoTestConstants::kLongTimeout),
encoder_factory_([]() { return VP9Encoder::Create(); }),
params_(params),
vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {}
@@ -2970,7 +3001,7 @@
virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
private:
- const int kVp9PayloadType = test::CallTest::kVideoSendPayloadType;
+ const int kVp9PayloadType = test::VideoTestConstants::kVideoSendPayloadType;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
@@ -3642,7 +3673,7 @@
class FpsObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver {
public:
- FpsObserver() : SendTest(kDefaultTimeout) {}
+ FpsObserver() : SendTest(test::VideoTestConstants::kDefaultTimeout) {}
void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override {
@@ -3678,7 +3709,7 @@
public test::FakeEncoder {
public:
explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue)
- : EndToEndTest(test::CallTest::kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue),
encoder_factory_(this),
@@ -3733,8 +3764,8 @@
// At a bitrate of 60kbps with a packet size of 1200B video and an
// overhead of 40B per packet video produces 2240bps overhead.
// So the encoder BW should be set to 57760bps.
- EXPECT_TRUE(
- bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeout));
+ EXPECT_TRUE(bitrate_changed_event_.Wait(
+ test::VideoTestConstants::kDefaultTimeout));
{
MutexLock lock(&mutex_);
EXPECT_LE(max_bitrate_bps_, 57760u);
@@ -3757,7 +3788,7 @@
public:
PacingFactorObserver(bool configure_send_side,
absl::optional<float> expected_pacing_factor)
- : test::SendTest(VideoSendStreamTest::kDefaultTimeout),
+ : test::SendTest(test::VideoTestConstants::kDefaultTimeout),
configure_send_side_(configure_send_side),
expected_pacing_factor_(expected_pacing_factor) {}
@@ -3854,7 +3885,7 @@
static const uint32_t kMinPacketsToSend = 50;
explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue)
- : SendTest(test::CallTest::kDefaultTimeout),
+ : SendTest(test::VideoTestConstants::kDefaultTimeout),
call_(nullptr),
state_(StreamState::kBeforeSwitch),
send_stream_(nullptr),
@@ -3950,7 +3981,8 @@
void PerformTest() override {
while (GetStreamState() != StreamState::kAfterSwitchBack) {
- ASSERT_TRUE(content_switch_event_.Wait(test::CallTest::kDefaultTimeout));
+ ASSERT_TRUE(content_switch_event_.Wait(
+ test::VideoTestConstants::kDefaultTimeout));
(*stream_resetter_)(send_stream_config_, encoder_config_, this);
}
@@ -4014,7 +4046,7 @@
const std::string& payload_name,
const std::vector<int>& num_temporal_layers,
const std::vector<ScalabilityMode>& scalability_mode)
- : EndToEndTest(kDefaultTimeout),
+ : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_(encoder_factory),
payload_name_(payload_name),
num_temporal_layers_(num_temporal_layers),
@@ -4051,7 +4083,8 @@
webrtc::VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
- send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+ send_config->rtp.payload_type =
+ test::VideoTestConstants::kVideoSendPayloadType;
encoder_config->video_format.name = payload_name_;
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->video_stream_factory =
