admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove dependency of video_replay on TestADM.

Browse Source 
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}
This commit is contained in:
Artem Titov 2023-04-21 17:35:49 +02:00 committed by WebRTC LUCI CQ
parent 47701c8c9b
commit 01716663a9
40 changed files with 784 additions and 497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
audio/BUILD.gn
View File

@ -139,6 +139,7 @@ if (rtc_include_tests) {
"../system_wrappers", "../system_wrappers",
"../test:test_common", "../test:test_common",
"../test:test_support", "../test:test_support",
"../test:video_test_constants",
] ]
} }
@ -216,6 +217,7 @@ if (rtc_include_tests) {
"../test:scoped_key_value_config", "../test:scoped_key_value_config",
"../test:test_common", "../test:test_common",
"../test:test_support", "../test:test_support",
"../test:video_test_constants",
"../test/time_controller:time_controller", "../test/time_controller:time_controller",
"utility:utility_tests", "utility:utility_tests",
"//testing/gtest", "//testing/gtest",
@ -277,6 +279,7 @@ if (rtc_include_tests) {
"../test:test_common", "../test:test_common",
"../test:test_main", "../test:test_main",
"../test:test_support", "../test:test_support",
"../test:video_test_constants",
"../test/pc/e2e:network_quality_metrics_reporter", "../test/pc/e2e:network_quality_metrics_reporter",
"//testing/gtest", "//testing/gtest",
] ]

3
audio/audio_send_stream_tests.cc
View File

@ -19,6 +19,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace test { namespace test {
@ -31,7 +32,7 @@ enum : int { // The first valid value is 1.
class AudioSendTest : public SendTest { class AudioSendTest : public SendTest {
public: public:
AudioSendTest() : SendTest(CallTest::kDefaultTimeout) {} AudioSendTest() : SendTest(VideoTestConstants::kDefaultTimeout) {}
size_t GetNumVideoStreams() const override { return 0; } size_t GetNumVideoStreams() const override { return 0; }
size_t GetNumAudioStreams() const override { return 1; } size_t GetNumAudioStreams() const override { return 1; }

5
audio/test/audio_end_to_end_test.cc
View File

@ -19,6 +19,7 @@
#include "modules/audio_device/include/test_audio_device.h" #include "modules/audio_device/include/test_audio_device.h"
#include "system_wrappers/include/sleep.h" #include "system_wrappers/include/sleep.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace test { namespace test {
@ -29,7 +30,7 @@ constexpr int kSampleRate = 48000;
} // namespace } // namespace
AudioEndToEndTest::AudioEndToEndTest() AudioEndToEndTest::AudioEndToEndTest()
: EndToEndTest(CallTest::kDefaultTimeout) {} : EndToEndTest(VideoTestConstants::kDefaultTimeout) {}
size_t AudioEndToEndTest::GetNumVideoStreams() const { size_t AudioEndToEndTest::GetNumVideoStreams() const {
return 0; return 0;
@ -66,7 +67,7 @@ void AudioEndToEndTest::ModifyAudioConfigs(
const webrtc::SdpAudioFormat kDefaultFormat("opus", 48000, 2, const webrtc::SdpAudioFormat kDefaultFormat("opus", 48000, 2,
{{"stereo", "1"}}); {{"stereo", "1"}});
send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec( send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
test::CallTest::kAudioSendPayloadType, kDefaultFormat); test::VideoTestConstants::kAudioSendPayloadType, kDefaultFormat);
send_config->min_bitrate_bps = 32000; send_config->min_bitrate_bps = 32000;
send_config->max_bitrate_bps = 32000; send_config->max_bitrate_bps = 32000;
} }

3
audio/test/low_bandwidth_audio_test.cc
View File

@ -14,6 +14,7 @@
#include "audio/test/audio_end_to_end_test.h" #include "audio/test/audio_end_to_end_test.h"
#include "system_wrappers/include/sleep.h" #include "system_wrappers/include/sleep.h"
#include "test/testsupport/file_utils.h" #include "test/testsupport/file_utils.h"
#include "test/video_test_constants.h"
ABSL_DECLARE_FLAG(int, sample_rate_hz); ABSL_DECLARE_FLAG(int, sample_rate_hz);
ABSL_DECLARE_FLAG(bool, quick); ABSL_DECLARE_FLAG(bool, quick);
@ -78,7 +79,7 @@ class Mobile2GNetworkTest : public AudioQualityTest {
std::vector<AudioReceiveStreamInterface::Config>* std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override { receive_configs) override {
send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec( send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
test::CallTest::kAudioSendPayloadType, test::VideoTestConstants::kAudioSendPayloadType,
{"OPUS", {"OPUS",
48000, 48000,
2, 2,

2
call/BUILD.gn
View File

@ -532,6 +532,7 @@ if (rtc_include_tests) {
"../test:scoped_key_value_config", "../test:scoped_key_value_config",
"../test:test_common", "../test:test_common",
"../test:test_support", "../test:test_support",
"../test:video_test_constants",
"../test/scenario", "../test/scenario",
"../test/time_controller:time_controller", "../test/time_controller:time_controller",
"../video", "../video",
@ -606,6 +607,7 @@ if (rtc_include_tests) {
"../test:test_common", "../test:test_common",
"../test:test_support", "../test:test_support",
"../test:video_test_common", "../test:video_test_common",
"../test:video_test_constants",
"../video", "../video",
"../video/config:encoder_config", "../video/config:encoder_config",
"//testing/gtest", "//testing/gtest",

23
call/bitrate_estimator_tests.cc
View File

@ -29,6 +29,7 @@
#include "test/fake_encoder.h" #include "test/fake_encoder.h"
#include "test/frame_generator_capturer.h" #include "test/frame_generator_capturer.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -80,7 +81,9 @@ class LogObserver {
} }
} }
bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeout); } bool Wait() {
return done_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
void PushExpectedLogLine(absl::string_view expected_log_line) { void PushExpectedLogLine(absl::string_view expected_log_line) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
@ -122,13 +125,15 @@ class BitrateEstimatorTest : public test::CallTest {
/*observer=*/nullptr); /*observer=*/nullptr);
VideoSendStream::Config video_send_config(send_transport_.get()); 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 = video_send_config.encoder_settings.encoder_factory =
&fake_encoder_factory_; &fake_encoder_factory_;
video_send_config.encoder_settings.bitrate_allocator_factory = video_send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get(); bitrate_allocator_factory_.get();
video_send_config.rtp.payload_name = "FAKE"; 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); SetVideoSendConfig(video_send_config);
VideoEncoderConfig video_encoder_config; VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config); test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
@ -138,7 +143,8 @@ class BitrateEstimatorTest : public test::CallTest {
VideoReceiveStreamInterface::Config(receive_transport_.get()); VideoReceiveStreamInterface::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately. // receive_config_.decoders will be set by every stream separately.
receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0]; 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 @@ class BitrateEstimatorTest : public test::CallTest {
frame_generator_capturer_ = frame_generator_capturer_ =
std::make_unique<test::FrameGeneratorCapturer>( std::make_unique<test::FrameGeneratorCapturer>(
test->clock_, test->clock_,
test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight, test::CreateSquareFrameGenerator(
absl::nullopt, absl::nullopt), test::VideoTestConstants::kDefaultWidth,
kDefaultFramerate, *test->task_queue_factory_); test::VideoTestConstants::kDefaultHeight, absl::nullopt,
absl::nullopt),
test::VideoTestConstants::kDefaultFramerate,
*test->task_queue_factory_);
frame_generator_capturer_->Init(); frame_generator_capturer_->Init();
send_stream_->SetSource(frame_generator_capturer_.get(), send_stream_->SetSource(frame_generator_capturer_.get(),
DegradationPreference::MAINTAIN_FRAMERATE); DegradationPreference::MAINTAIN_FRAMERATE);

63
call/call_perf_tests.cc
View File

@ -54,6 +54,7 @@
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/testsupport/file_utils.h" #include "test/testsupport/file_utils.h"
#include "test/video_encoder_proxy_factory.h" #include "test/video_encoder_proxy_factory.h"
#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h" #include "video/config/video_encoder_config.h"
#include "video/transport_adapter.h" #include "video/transport_adapter.h"
@ -116,7 +117,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue, explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue,
Clock* clock, Clock* clock,
absl::string_view test_label) absl::string_view test_label)
: test::RtpRtcpObserver(CallPerfTest::kLongTimeout), : test::RtpRtcpObserver(test::VideoTestConstants::kLongTimeout),
clock_(clock), clock_(clock),
test_label_(test_label), test_label_(test_label),
creation_time_ms_(clock_->TimeInMilliseconds()), creation_time_ms_(clock_->TimeInMilliseconds()),
@ -274,31 +275,37 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
audio_send_config.rtp.ssrc = kAudioSendSsrc; audio_send_config.rtp.ssrc = kAudioSendSsrc;
// TODO(bugs.webrtc.org/14683): Let the tests fail with invalid config. // TODO(bugs.webrtc.org/14683): Let the tests fail with invalid config.
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( 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.min_bitrate_bps = 6000;
audio_send_config.max_bitrate_bps = 510000; audio_send_config.max_bitrate_bps = 510000;
audio_send_config.encoder_factory = CreateBuiltinAudioEncoderFactory(); audio_send_config.encoder_factory = CreateBuiltinAudioEncoderFactory();
audio_send_stream = sender_call_->CreateAudioSendStream(audio_send_config); 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) { if (fec == FecMode::kOn) {
GetVideoSendConfig()->rtp.ulpfec.red_payload_type = kRedPayloadType; GetVideoSendConfig()->rtp.ulpfec.red_payload_type =
GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; test::VideoTestConstants::kRedPayloadType;
video_receive_configs_[0].rtp.red_payload_type = kRedPayloadType; GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type =
video_receive_configs_[0].rtp.ulpfec_payload_type = kUlpfecPayloadType; 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].rtp.nack.rtp_history_ms = 1000;
video_receive_configs_[0].renderer = observer.get(); video_receive_configs_[0].renderer = observer.get();
video_receive_configs_[0].sync_group = kSyncGroup; video_receive_configs_[0].sync_group = kSyncGroup;
AudioReceiveStreamInterface::Config audio_recv_config; 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.rtp.local_ssrc = kAudioRecvSsrc;
audio_recv_config.rtcp_send_transport = receive_transport.get(); audio_recv_config.rtcp_send_transport = receive_transport.get();
audio_recv_config.sync_group = kSyncGroup; audio_recv_config.sync_group = kSyncGroup;
audio_recv_config.decoder_factory = audio_decoder_factory_; audio_recv_config.decoder_factory = audio_decoder_factory_;
audio_recv_config.decoder_map = { audio_recv_config.decoder_map = {
{kAudioSendPayloadType, {"OPUS", 48000, 2}}}; {test::VideoTestConstants::kAudioSendPayloadType, {"OPUS", 48000, 2}}};
if (create_first == CreateOrder::kAudioFirst) { if (create_first == CreateOrder::kAudioFirst) {
audio_receive_stream = audio_receive_stream =
@ -312,9 +319,11 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
EXPECT_EQ(1u, video_receive_streams_.size()); EXPECT_EQ(1u, video_receive_streams_.size());
observer->set_receive_stream(video_receive_streams_[0]); observer->set_receive_stream(video_receive_streams_[0]);
drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed); drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed);
CreateFrameGeneratorCapturerWithDrift(drifting_clock.get(), video_rtp_speed, CreateFrameGeneratorCapturerWithDrift(
kDefaultFramerate, kDefaultWidth, drifting_clock.get(), video_rtp_speed,
kDefaultHeight); test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
@ -405,7 +414,7 @@ void CallPerfTest::TestCaptureNtpTime(
int threshold_ms, int threshold_ms,
int start_time_ms, int start_time_ms,
int run_time_ms) int run_time_ms)
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
net_config_(net_config), net_config_(net_config),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
threshold_ms_(threshold_ms), threshold_ms_(threshold_ms),
@ -558,7 +567,9 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
class LoadObserver : public test::SendTest, class LoadObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver { public test::FrameGeneratorCapturer::SinkWantsObserver {
public: public:
LoadObserver() : SendTest(kLongTimeout), test_phase_(TestPhase::kInit) {} LoadObserver()
: SendTest(test::VideoTestConstants::kLongTimeout),
test_phase_(TestPhase::kInit) {}
void OnFrameGeneratorCapturerCreated( void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override { test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -667,7 +678,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
public: public:
explicit BitrateObserver(bool using_min_transmit_bitrate, explicit BitrateObserver(bool using_min_transmit_bitrate,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
send_stream_(nullptr), send_stream_(nullptr),
converged_(false), converged_(false),
pad_to_min_bitrate_(using_min_transmit_bitrate), pad_to_min_bitrate_(using_min_transmit_bitrate),
@ -794,7 +805,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder { class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
public: public:
explicit BitrateObserver(TaskQueueBase* task_queue) explicit BitrateObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
encoder_inits_(0), encoder_inits_(0),
last_set_bitrate_kbps_(0), last_set_bitrate_kbps_(0),
@ -818,11 +829,11 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
: kInitialBitrateKbps - kInitialBitrateOverheadKpbs; : kInitialBitrateKbps - kInitialBitrateOverheadKpbs;
EXPECT_EQ(expected_bitrate, config->startBitrate) EXPECT_EQ(expected_bitrate, config->startBitrate)
<< "Encoder not initialized at expected bitrate."; << "Encoder not initialized at expected bitrate.";
EXPECT_EQ(kDefaultWidth, config->width); EXPECT_EQ(test::VideoTestConstants::kDefaultWidth, config->width);
EXPECT_EQ(kDefaultHeight, config->height); EXPECT_EQ(test::VideoTestConstants::kDefaultHeight, config->height);
} else if (encoder_inits_ == 2) { } else if (encoder_inits_ == 2) {
EXPECT_EQ(2 * kDefaultWidth, config->width); EXPECT_EQ(2 * test::VideoTestConstants::kDefaultWidth, config->width);
EXPECT_EQ(2 * kDefaultHeight, config->height); EXPECT_EQ(2 * test::VideoTestConstants::kDefaultHeight, config->height);
EXPECT_GE(last_set_bitrate_kbps_, kReconfigureThresholdKbps); EXPECT_GE(last_set_bitrate_kbps_, kReconfigureThresholdKbps);
EXPECT_GT(config->startBitrate, kReconfigureThresholdKbps) EXPECT_GT(config->startBitrate, kReconfigureThresholdKbps)
<< "Encoder reconfigured with bitrate too far away from last set."; << "Encoder reconfigured with bitrate too far away from last set.";
@ -871,9 +882,12 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
} }
void PerformTest() override { 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."; << "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_, [&]() { SendTask(task_queue_, [&]() {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
@ -1057,7 +1071,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
absl::string_view payload_name, absl::string_view payload_name,
const std::vector<int>& max_framerates, const std::vector<int>& max_framerates,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(payload_name), payload_name_(payload_name),
@ -1096,7 +1110,8 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = encoder_factory_; send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_; 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->video_format.name = payload_name_;
encoder_config->codec_type = PayloadStringToCodecType(payload_name_); encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->max_bitrate_bps = kMaxBitrate.bps(); encoder_config->max_bitrate_bps = kMaxBitrate.bps();

31
call/rampup_tests.cc
View File

@ -30,6 +30,7 @@
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
#include "test/encoder_settings.h" #include "test/encoder_settings.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
ABSL_FLAG(std::string, ABSL_FLAG(std::string,
ramp_dump_name, ramp_dump_name,
@ -69,7 +70,7 @@ RampUpTester::RampUpTester(size_t num_video_streams,
bool red, bool red,
bool report_perf_stats, bool report_perf_stats,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
num_video_streams_(num_video_streams), num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),
@ -163,8 +164,8 @@ void RampUpTester::ModifyVideoConfigs(
send_config->rtp.payload_name = "VP8"; send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8; encoder_config->codec_type = kVideoCodecVP8;
std::vector<VideoStream> streams = test::CreateVideoStreams( std::vector<VideoStream> streams = test::CreateVideoStreams(
test::CallTest::kDefaultWidth, test::CallTest::kDefaultHeight, test::VideoTestConstants::kDefaultWidth,
*encoder_config); test::VideoTestConstants::kDefaultHeight, *encoder_config);
// For multi stream rampup until all streams are being sent. That means // 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 // enough bitrate to send all the target streams plus the min bitrate of
// the last one. // the last one.
@ -174,19 +175,22 @@ void RampUpTester::ModifyVideoConfigs(
} }
} }
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_; send_config->rtp.ssrcs = video_ssrcs_;
if (rtx_) { 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_; send_config->rtp.rtx.ssrcs = video_rtx_ssrcs_;
} }
if (red_) { if (red_) {
send_config->rtp.ulpfec.ulpfec_payload_type = send_config->rtp.ulpfec.ulpfec_payload_type =
test::CallTest::kUlpfecPayloadType; test::VideoTestConstants::kUlpfecPayloadType;
send_config->rtp.ulpfec.red_payload_type = test::CallTest::kRedPayloadType; send_config->rtp.ulpfec.red_payload_type =
test::VideoTestConstants::kRedPayloadType;
if (rtx_) { if (rtx_) {
send_config->rtp.ulpfec.red_rtx_payload_type = send_config->rtp.ulpfec.red_rtx_payload_type =
test::CallTest::kRtxRedPayloadType; test::VideoTestConstants::kRtxRedPayloadType;
} }
} }
@ -223,8 +227,9 @@ void RampUpTester::ModifyVideoConfigs(
RTC_DCHECK_LE(num_flexfec_streams_, 1); RTC_DCHECK_LE(num_flexfec_streams_, 1);
if (num_flexfec_streams_ == 1) { if (num_flexfec_streams_ == 1) {
send_config->rtp.flexfec.payload_type = test::CallTest::kFlexfecPayloadType; send_config->rtp.flexfec.payload_type =
send_config->rtp.flexfec.ssrc = test::CallTest::kFlexfecSendSsrc; test::VideoTestConstants::kFlexfecPayloadType;
send_config->rtp.flexfec.ssrc = test::VideoTestConstants::kFlexfecSendSsrc;
send_config->rtp.flexfec.protected_media_ssrcs = {video_ssrcs_[0]}; send_config->rtp.flexfec.protected_media_ssrcs = {video_ssrcs_[0]};
} }
} }
@ -249,8 +254,10 @@ void RampUpTester::ModifyFlexfecConfigs(
if (num_flexfec_streams_ == 0) if (num_flexfec_streams_ == 0)
return; return;
RTC_DCHECK_EQ(1, num_flexfec_streams_); RTC_DCHECK_EQ(1, num_flexfec_streams_);
(*receive_configs)[0].payload_type = test::CallTest::kFlexfecPayloadType; (*receive_configs)[0].payload_type =
(*receive_configs)[0].rtp.remote_ssrc = test::CallTest::kFlexfecSendSsrc; test::VideoTestConstants::kFlexfecPayloadType;
(*receive_configs)[0].rtp.remote_ssrc =
test::VideoTestConstants::kFlexfecSendSsrc;
(*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]}; (*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]};
(*receive_configs)[0].rtp.local_ssrc = video_ssrcs_[0]; (*receive_configs)[0].rtp.local_ssrc = video_ssrcs_[0];
} }

2
rtc_tools/BUILD.gn
View File

@ -282,11 +282,11 @@ if (!is_component_build) {
"../test:run_loop", "../test:run_loop",
"../test:run_test", "../test:run_test",
"../test:run_test_interface", "../test:run_test_interface",
"../test:test_common",
"../test:test_renderer", "../test:test_renderer",
"../test:test_support", "../test:test_support",
"../test:test_video_capturer", "../test:test_video_capturer",
"../test:video_test_common", "../test:video_test_common",
"../test:video_test_constants",
"../test:video_test_support", "../test:video_test_support",
"../test/time_controller:time_controller", "../test/time_controller:time_controller",
"//third_party/abseil-cpp/absl/flags:flag", "//third_party/abseil-cpp/absl/flags:flag",

20
rtc_tools/video_replay.cc
View File

@ -40,7 +40,6 @@
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
#include "system_wrappers/include/sleep.h" #include "system_wrappers/include/sleep.h"
#include "test/call_config_utils.h" #include "test/call_config_utils.h"
#include "test/call_test.h"
#include "test/encoder_settings.h" #include "test/encoder_settings.h"
#include "test/fake_decoder.h" #include "test/fake_decoder.h"
#include "test/gtest.h" #include "test/gtest.h"
@ -52,54 +51,55 @@
#include "test/testsupport/frame_writer.h" #include "test/testsupport/frame_writer.h"
#include "test/time_controller/simulated_time_controller.h" #include "test/time_controller/simulated_time_controller.h"
#include "test/video_renderer.h" #include "test/video_renderer.h"
#include "test/video_test_constants.h"
// Flag for payload type. // Flag for payload type.
ABSL_FLAG(int, ABSL_FLAG(int,
media_payload_type, media_payload_type,
webrtc::test::CallTest::kPayloadTypeVP8, webrtc::test::VideoTestConstants::kPayloadTypeVP8,
"Media payload type"); "Media payload type");
// Flag for RED payload type. // Flag for RED payload type.
ABSL_FLAG(int, ABSL_FLAG(int,
red_payload_type, red_payload_type,
webrtc::test::CallTest::kRedPayloadType, webrtc::test::VideoTestConstants::kRedPayloadType,
"RED payload type"); "RED payload type");
// Flag for ULPFEC payload type. // Flag for ULPFEC payload type.
ABSL_FLAG(int, ABSL_FLAG(int,
ulpfec_payload_type, ulpfec_payload_type,
webrtc::test::CallTest::kUlpfecPayloadType, webrtc::test::VideoTestConstants::kUlpfecPayloadType,
"ULPFEC payload type"); "ULPFEC payload type");
// Flag for FLEXFEC payload type. // Flag for FLEXFEC payload type.
ABSL_FLAG(int, ABSL_FLAG(int,
flexfec_payload_type, flexfec_payload_type,
webrtc::test::CallTest::kFlexfecPayloadType, webrtc::test::VideoTestConstants::kFlexfecPayloadType,
"FLEXFEC payload type"); "FLEXFEC payload type");
ABSL_FLAG(int, ABSL_FLAG(int,
media_payload_type_rtx, media_payload_type_rtx,
webrtc::test::CallTest::kSendRtxPayloadType, webrtc::test::VideoTestConstants::kSendRtxPayloadType,
"Media over RTX payload type"); "Media over RTX payload type");
ABSL_FLAG(int, ABSL_FLAG(int,
red_payload_type_rtx, red_payload_type_rtx,
webrtc::test::CallTest::kRtxRedPayloadType, webrtc::test::VideoTestConstants::kRtxRedPayloadType,
"RED over RTX payload type"); "RED over RTX payload type");
// Flag for SSRC and RTX SSRC. // Flag for SSRC and RTX SSRC.
ABSL_FLAG(uint32_t, ABSL_FLAG(uint32_t,
ssrc, ssrc,
webrtc::test::CallTest::kVideoSendSsrcs[0], webrtc::test::VideoTestConstants::kVideoSendSsrcs[0],
"Incoming SSRC"); "Incoming SSRC");
ABSL_FLAG(uint32_t, ABSL_FLAG(uint32_t,
ssrc_rtx, ssrc_rtx,
webrtc::test::CallTest::kSendRtxSsrcs[0], webrtc::test::VideoTestConstants::kSendRtxSsrcs[0],
"Incoming RTX SSRC"); "Incoming RTX SSRC");
ABSL_FLAG(uint32_t, ABSL_FLAG(uint32_t,
ssrc_flexfec, ssrc_flexfec,
webrtc::test::CallTest::kFlexfecSendSsrc, webrtc::test::VideoTestConstants::kFlexfecSendSsrc,
"Incoming FLEXFEC SSRC"); "Incoming FLEXFEC SSRC");
// Flag for abs-send-time id. // Flag for abs-send-time id.

7
test/BUILD.gn
View File

@ -1064,6 +1064,12 @@ rtc_library("run_loop") {
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ] 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") { rtc_library("test_common") {
testonly = true testonly = true
sources = [ sources = [
@ -1087,6 +1093,7 @@ rtc_library("test_common") {
":scoped_key_value_config", ":scoped_key_value_config",
":test_support", ":test_support",
":video_test_common", ":video_test_common",
":video_test_constants",
"../api:array_view", "../api:array_view",
"../api:create_frame_generator", "../api:create_frame_generator",
"../api:frame_generator_api", "../api:frame_generator_api",

97
test/call_test.cc
View File

@ -31,6 +31,7 @@
#include "test/fake_encoder.h" #include "test/fake_encoder.h"
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/testsupport/file_utils.h" #include "test/testsupport/file_utils.h"
#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h" #include "video/config/video_encoder_config.h"
namespace webrtc { namespace webrtc {
@ -176,9 +177,9 @@ void CallTest::RunBaseTest(BaseTest* test) {
} }
if (num_video_streams_ > 0) { if (num_video_streams_ > 0) {
int width = kDefaultWidth; int width = VideoTestConstants::kDefaultWidth;
int height = kDefaultHeight; int height = VideoTestConstants::kDefaultHeight;
int frame_rate = kDefaultFramerate; int frame_rate = VideoTestConstants::kDefaultFramerate;
test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate); test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
test->ModifyVideoDegradationPreference(&degradation_preference_); test->ModifyVideoDegradationPreference(&degradation_preference_);
CreateFrameGeneratorCapturer(frame_rate, width, height); CreateFrameGeneratorCapturer(frame_rate, width, height);
@ -248,13 +249,15 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
size_t num_video_streams, size_t num_video_streams,
size_t num_used_ssrcs, size_t num_used_ssrcs,
Transport* send_transport) { 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 = VideoSendStream::Config(send_transport);
video_config->encoder_settings.encoder_factory = &fake_encoder_factory_; video_config->encoder_settings.encoder_factory = &fake_encoder_factory_;
video_config->encoder_settings.bitrate_allocator_factory = video_config->encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get(); bitrate_allocator_factory_.get();
video_config->rtp.payload_name = "FAKE"; 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; video_config->rtp.extmap_allow_mixed = true;
AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri, AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri,
&video_config->rtp.extensions); &video_config->rtp.extensions);
@ -274,7 +277,8 @@ void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config,
&video_encoder_configs_.back()); &video_encoder_configs_.back());
} }
for (size_t i = 0; i < num_video_streams; ++i) 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, AddRtpExtensionByUri(RtpExtension::kVideoRotationUri,
&video_config->rtp.extensions); &video_config->rtp.extensions);
AddRtpExtensionByUri(RtpExtension::kColorSpaceUri, AddRtpExtensionByUri(RtpExtension::kColorSpaceUri,
@ -288,12 +292,13 @@ void CallTest::CreateAudioAndFecSendConfigs(size_t num_audio_streams,
RTC_DCHECK_LE(num_flexfec_streams, 1); RTC_DCHECK_LE(num_flexfec_streams, 1);
if (num_audio_streams > 0) { if (num_audio_streams > 0) {
AudioSendStream::Config audio_send_config(send_transport); AudioSendStream::Config audio_send_config(send_transport);
audio_send_config.rtp.ssrc = kAudioSendSsrc; audio_send_config.rtp.ssrc = VideoTestConstants::kAudioSendSsrc;
AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri, AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri,
&audio_send_config.rtp.extensions); &audio_send_config.rtp.extensions);
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( 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.min_bitrate_bps = 6000;
audio_send_config.max_bitrate_bps = 60000; audio_send_config.max_bitrate_bps = 60000;
audio_send_config.encoder_factory = audio_encoder_factory_; audio_send_config.encoder_factory = audio_encoder_factory_;
@ -302,7 +307,7 @@ void CallTest::CreateAudioAndFecSendConfigs(size_t num_audio_streams,
// TODO(brandtr): Update this when we support multistream protection. // TODO(brandtr): Update this when we support multistream protection.
if (num_flexfec_streams > 0) { if (num_flexfec_streams > 0) {
SetSendFecConfig({kVideoSendSsrcs[0]}); SetSendFecConfig({VideoTestConstants::kVideoSendSsrcs[0]});
} }
} }
@ -311,23 +316,29 @@ void CallTest::SetAudioConfig(const AudioSendStream::Config& config) {
} }
void CallTest::SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs) { void CallTest::SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs) {
GetVideoSendConfig()->rtp.flexfec.payload_type = kFlexfecPayloadType; GetVideoSendConfig()->rtp.flexfec.payload_type =
GetVideoSendConfig()->rtp.flexfec.ssrc = kFlexfecSendSsrc; VideoTestConstants::kFlexfecPayloadType;
GetVideoSendConfig()->rtp.flexfec.ssrc = VideoTestConstants::kFlexfecSendSsrc;
GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs = video_send_ssrcs; GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs = video_send_ssrcs;
} }
void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) { void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) {
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; send_config->rtp.ulpfec.red_payload_type =
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; VideoTestConstants::kRedPayloadType;
send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType; send_config->rtp.ulpfec.ulpfec_payload_type =
VideoTestConstants::kUlpfecPayloadType;
send_config->rtp.ulpfec.red_rtx_payload_type =
VideoTestConstants::kRtxRedPayloadType;
} }
void CallTest::SetReceiveUlpFecConfig( void CallTest::SetReceiveUlpFecConfig(
VideoReceiveStreamInterface::Config* receive_config) { VideoReceiveStreamInterface::Config* receive_config) {
receive_config->rtp.red_payload_type = kRedPayloadType; receive_config->rtp.red_payload_type = VideoTestConstants::kRedPayloadType;
receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType; receive_config->rtp.ulpfec_payload_type =
receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] = VideoTestConstants::kUlpfecPayloadType;
kRedPayloadType; receive_config->rtp
.rtx_associated_payload_types[VideoTestConstants::kRtxRedPayloadType] =
VideoTestConstants::kRedPayloadType;
} }
void CallTest::CreateSendConfig(size_t num_video_streams, void CallTest::CreateSendConfig(size_t num_video_streams,
@ -375,7 +386,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
int rtp_history_ms) { int rtp_history_ms) {
RTC_DCHECK(!video_send_config.rtp.ssrcs.empty()); RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
VideoReceiveStreamInterface::Config default_config(rtcp_send_transport); 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; default_config.rtp.nack.rtp_history_ms = rtp_history_ms;
// Enable RTT calculation so NTP time estimator will work. // Enable RTT calculation so NTP time estimator will work.
default_config.rtp.rtcp_xr.receiver_reference_time_report = default_config.rtp.rtcp_xr.receiver_reference_time_report =
@ -388,7 +399,8 @@ void CallTest::AddMatchingVideoReceiveConfigs(
video_recv_config.decoders.clear(); video_recv_config.decoders.clear();
if (!video_send_config.rtp.rtx.ssrcs.empty()) { 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_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_send_config.rtp.payload_type;
} }
video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i]; video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i];
@ -433,11 +445,12 @@ AudioReceiveStreamInterface::Config CallTest::CreateMatchingAudioConfig(
Transport* transport, Transport* transport,
std::string sync_group) { std::string sync_group) {
AudioReceiveStreamInterface::Config audio_config; 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.rtcp_send_transport = transport;
audio_config.rtp.remote_ssrc = send_config.rtp.ssrc; audio_config.rtp.remote_ssrc = send_config.rtp.ssrc;
audio_config.decoder_factory = audio_decoder_factory; 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; audio_config.sync_group = sync_group;
return audio_config; return audio_config;
} }
@ -449,7 +462,7 @@ void CallTest::CreateMatchingFecConfig(
config.payload_type = send_config.rtp.flexfec.payload_type; config.payload_type = send_config.rtp.flexfec.payload_type;
config.rtp.remote_ssrc = send_config.rtp.flexfec.ssrc; config.rtp.remote_ssrc = send_config.rtp.flexfec.ssrc;
config.protected_media_ssrcs = send_config.rtp.flexfec.protected_media_ssrcs; 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()) { if (!video_receive_configs_.empty()) {
video_receive_configs_[0].rtp.protected_by_flexfec = true; video_receive_configs_[0].rtp.protected_by_flexfec = true;
video_receive_configs_[0].rtp.packet_sink_ = this; video_receive_configs_[0].rtp.packet_sink_ = this;
@ -730,33 +743,19 @@ void CallTest::AddRtpExtensionByUri(
} }
} }
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_ = { const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
{CallTest::kVideoSendPayloadType, MediaType::VIDEO}, {VideoTestConstants::kVideoSendPayloadType, MediaType::VIDEO},
{CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO}, {VideoTestConstants::kFakeVideoSendPayloadType, MediaType::VIDEO},
{CallTest::kSendRtxPayloadType, MediaType::VIDEO}, {VideoTestConstants::kSendRtxPayloadType, MediaType::VIDEO},
{CallTest::kPayloadTypeVP8, MediaType::VIDEO}, {VideoTestConstants::kPayloadTypeVP8, MediaType::VIDEO},
{CallTest::kPayloadTypeVP9, MediaType::VIDEO}, {VideoTestConstants::kPayloadTypeVP9, MediaType::VIDEO},
{CallTest::kPayloadTypeH264, MediaType::VIDEO}, {VideoTestConstants::kPayloadTypeH264, MediaType::VIDEO},
{CallTest::kPayloadTypeGeneric, MediaType::VIDEO}, {VideoTestConstants::kPayloadTypeGeneric, MediaType::VIDEO},
{CallTest::kRedPayloadType, MediaType::VIDEO}, {VideoTestConstants::kRedPayloadType, MediaType::VIDEO},
{CallTest::kRtxRedPayloadType, MediaType::VIDEO}, {VideoTestConstants::kRtxRedPayloadType, MediaType::VIDEO},
{CallTest::kUlpfecPayloadType, MediaType::VIDEO}, {VideoTestConstants::kUlpfecPayloadType, MediaType::VIDEO},
{CallTest::kFlexfecPayloadType, MediaType::VIDEO}, {VideoTestConstants::kFlexfecPayloadType, MediaType::VIDEO},
{CallTest::kAudioSendPayloadType, MediaType::AUDIO}}; {VideoTestConstants::kAudioSendPayloadType, MediaType::AUDIO}};
BaseTest::BaseTest() {} BaseTest::BaseTest() {}

29
test/call_test.h
View File

@ -36,6 +36,7 @@
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/run_loop.h" #include "test/run_loop.h"
#include "test/scoped_key_value_config.h" #include "test/scoped_key_value_config.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace test { namespace test {
@ -47,34 +48,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
CallTest(); CallTest();
virtual ~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_; static const std::map<uint8_t, MediaType> payload_type_map_;
protected: protected:

1
test/scenario/BUILD.gn
View File

@ -71,6 +71,7 @@ if (rtc_include_tests && !build_with_chromium) {
":column_printer", ":column_printer",
"..:frame_generator_capturer", "..:frame_generator_capturer",
"..:test_video_capturer", "..:test_video_capturer",
"..:video_test_constants",
"../:fake_video_codecs", "../:fake_video_codecs",
"../:fileutils", "../:fileutils",
"../:test_common", "../:test_common",

6
test/scenario/audio_stream.cc
View File

@ -11,6 +11,7 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "test/call_test.h" #include "test/call_test.h"
#include "test/video_test_constants.h"
#if WEBRTC_ENABLE_PROTOBUF #if WEBRTC_ENABLE_PROTOBUF
RTC_PUSH_IGNORING_WUNDEF() RTC_PUSH_IGNORING_WUNDEF()
@ -103,7 +104,8 @@ SendAudioStream::SendAudioStream(
// stereo, but the actual channel count used is based on the "stereo" // stereo, but the actual channel count used is based on the "stereo"
// parameter. // parameter.
send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( 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); RTC_DCHECK_LE(config.source.channels, 2);
send_config.encoder_factory = encoder_factory; send_config.encoder_factory = encoder_factory;
@ -190,7 +192,7 @@ ReceiveAudioStream::ReceiveAudioStream(
receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO; receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
recv_config.decoder_factory = decoder_factory; recv_config.decoder_factory = decoder_factory;
recv_config.decoder_map = { recv_config.decoder_map = {
{CallTest::kAudioSendPayloadType, {"opus", 48000, 2}}}; {VideoTestConstants::kAudioSendPayloadType, {"opus", 48000, 2}}};
recv_config.sync_group = config.render.sync_group; recv_config.sync_group = config.render.sync_group;
receiver_->SendTask([&] { receiver_->SendTask([&] {
receive_stream_ = receiver_->call_->CreateAudioReceiveStream(recv_config); receive_stream_ = receiver_->call_->CreateAudioReceiveStream(recv_config);

41
test/scenario/video_stream.cc
View File

@ -27,6 +27,7 @@
#include "test/fake_encoder.h" #include "test/fake_encoder.h"
#include "test/scenario/hardware_codecs.h" #include "test/scenario/hardware_codecs.h"
#include "test/testsupport/file_utils.h" #include "test/testsupport/file_utils.h"
#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h" #include "video/config/encoder_stream_factory.h"
namespace webrtc { namespace webrtc {
@ -43,13 +44,13 @@ constexpr int kDefaultMaxQp = cricket::WebRtcVideoChannel::kDefaultQpMax;
uint8_t CodecTypeToPayloadType(VideoCodecType codec_type) { uint8_t CodecTypeToPayloadType(VideoCodecType codec_type) {
switch (codec_type) { switch (codec_type) {
case VideoCodecType::kVideoCodecGeneric: case VideoCodecType::kVideoCodecGeneric:
return CallTest::kFakeVideoSendPayloadType; return VideoTestConstants::kFakeVideoSendPayloadType;
case VideoCodecType::kVideoCodecVP8: case VideoCodecType::kVideoCodecVP8:
return CallTest::kPayloadTypeVP8; return VideoTestConstants::kPayloadTypeVP8;
case VideoCodecType::kVideoCodecVP9: case VideoCodecType::kVideoCodecVP9:
return CallTest::kPayloadTypeVP9; return VideoTestConstants::kPayloadTypeVP9;
case VideoCodecType::kVideoCodecH264: case VideoCodecType::kVideoCodecH264:
return CallTest::kPayloadTypeH264; return VideoTestConstants::kPayloadTypeH264;
default: default:
RTC_DCHECK_NOTREACHED(); RTC_DCHECK_NOTREACHED();
} }
@ -108,18 +109,22 @@ VideoSendStream::Config CreateVideoSendStreamConfig(
send_config.rtp.extensions = GetVideoRtpExtensions(config); send_config.rtp.extensions = GetVideoRtpExtensions(config);
if (config.stream.use_rtx) { 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; send_config.rtp.rtx.ssrcs = rtx_ssrcs;
} }
if (config.stream.use_flexfec) { if (config.stream.use_flexfec) {
send_config.rtp.flexfec.payload_type = CallTest::kFlexfecPayloadType; send_config.rtp.flexfec.payload_type =
send_config.rtp.flexfec.ssrc = CallTest::kFlexfecSendSsrc; VideoTestConstants::kFlexfecPayloadType;
send_config.rtp.flexfec.ssrc = VideoTestConstants::kFlexfecSendSsrc;
send_config.rtp.flexfec.protected_media_ssrcs = ssrcs; send_config.rtp.flexfec.protected_media_ssrcs = ssrcs;
} }
if (config.stream.use_ulpfec) { if (config.stream.use_ulpfec) {
send_config.rtp.ulpfec.red_payload_type = CallTest::kRedPayloadType; send_config.rtp.ulpfec.red_payload_type =
send_config.rtp.ulpfec.ulpfec_payload_type = CallTest::kUlpfecPayloadType; VideoTestConstants::kRedPayloadType;
send_config.rtp.ulpfec.red_rtx_payload_type = CallTest::kRtxRedPayloadType; send_config.rtp.ulpfec.ulpfec_payload_type =
VideoTestConstants::kUlpfecPayloadType;
send_config.rtp.ulpfec.red_rtx_payload_type =
VideoTestConstants::kRtxRedPayloadType;
} }
return send_config; return send_config;
} }
@ -323,14 +328,16 @@ VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
recv.renderer = renderer; recv.renderer = renderer;
if (config.stream.use_rtx) { if (config.stream.use_rtx) {
recv.rtp.rtx_ssrc = rtx_ssrc; 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); CodecTypeToPayloadType(config.encoder.codec);
} }
if (config.stream.use_ulpfec) { if (config.stream.use_ulpfec) {
recv.rtp.red_payload_type = CallTest::kRedPayloadType; recv.rtp.red_payload_type = VideoTestConstants::kRedPayloadType;
recv.rtp.ulpfec_payload_type = CallTest::kUlpfecPayloadType; recv.rtp.ulpfec_payload_type = VideoTestConstants::kUlpfecPayloadType;
recv.rtp.rtx_associated_payload_types[CallTest::kRtxRedPayloadType] = recv.rtp
CallTest::kRedPayloadType; .rtx_associated_payload_types[VideoTestConstants::kRtxRedPayloadType] =
VideoTestConstants::kRedPayloadType;
} }
recv.sync_group = config.render.sync_group; recv.sync_group = config.render.sync_group;
return recv; return recv;
@ -564,8 +571,8 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
if (config.stream.use_flexfec) { if (config.stream.use_flexfec) {
RTC_DCHECK(num_streams == 1); RTC_DCHECK(num_streams == 1);
FlexfecReceiveStream::Config flexfec(feedback_transport); FlexfecReceiveStream::Config flexfec(feedback_transport);
flexfec.payload_type = CallTest::kFlexfecPayloadType; flexfec.payload_type = VideoTestConstants::kFlexfecPayloadType;
flexfec.rtp.remote_ssrc = CallTest::kFlexfecSendSsrc; flexfec.rtp.remote_ssrc = VideoTestConstants::kFlexfecSendSsrc;
flexfec.protected_media_ssrcs = send_stream->rtx_ssrcs_; flexfec.protected_media_ssrcs = send_stream->rtx_ssrcs_;
flexfec.rtp.local_ssrc = recv_config.rtp.local_ssrc; flexfec.rtp.local_ssrc = recv_config.rtp.local_ssrc;
receiver_->ssrc_media_types_[flexfec.rtp.remote_ssrc] = MediaType::VIDEO; receiver_->ssrc_media_types_[flexfec.rtp.remote_ssrc] = MediaType::VIDEO;

60
test/video_test_constants.h Normal file
View File

@ -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_

2
video/BUILD.gn
View File

@ -539,6 +539,7 @@ if (rtc_include_tests) {
"../test:test_support", "../test:test_support",
"../test:test_support_test_artifacts", "../test:test_support_test_artifacts",
"../test:video_test_common", "../test:video_test_common",
"../test:video_test_constants",
"../test:video_test_support", "../test:video_test_support",
"config:streams_config", "config:streams_config",
] ]
@ -915,6 +916,7 @@ if (rtc_include_tests) {
"../test:test_common", "../test:test_common",
"../test:test_support", "../test:test_support",
"../test:video_test_common", "../test:video_test_common",
"../test:video_test_constants",
"../test/time_controller", "../test/time_controller",
"adaptation:video_adaptation", "adaptation:video_adaptation",
"config:encoder_config", "config:encoder_config",

5
video/cpu_scaling_tests.cc
View File

@ -23,6 +23,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/frame_generator_capturer.h" #include "test/frame_generator_capturer.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h" #include "video/config/video_encoder_config.h"
namespace webrtc { namespace webrtc {
@ -55,7 +56,9 @@ void CpuOveruseTest::RunTestAndCheckForAdaptation(
public: public:
OveruseObserver(const DegradationPreference& degradation_preference, OveruseObserver(const DegradationPreference& degradation_preference,
bool expect_adaptation) bool expect_adaptation)
: SendTest(expect_adaptation ? kLongTimeout : kDefaultTimeout), : SendTest(expect_adaptation
? test::VideoTestConstants::kLongTimeout
: test::VideoTestConstants::kDefaultTimeout),
degradation_preference_(degradation_preference), degradation_preference_(degradation_preference),
expect_adaptation_(expect_adaptation) {} expect_adaptation_(expect_adaptation) {}

19
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -29,6 +29,7 @@
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/video_encoder_proxy_factory.h" #include "test/video_encoder_proxy_factory.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -46,7 +47,7 @@ class BandwidthEndToEndTest : public test::CallTest {
TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) { TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class RembObserver : public test::EndToEndTest { class RembObserver : public test::EndToEndTest {
public: public:
RembObserver() : EndToEndTest(kDefaultTimeout) {} RembObserver() : EndToEndTest(test::VideoTestConstants::kDefaultTimeout) {}
void ModifyVideoConfigs( void ModifyVideoConfigs(
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
@ -62,10 +63,12 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
EXPECT_TRUE(parser.Parse(packet, length)); EXPECT_TRUE(parser.Parse(packet, length));
if (parser.remb()->num_packets() > 0) { 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_LT(0U, parser.remb()->bitrate_bps());
EXPECT_EQ(1U, parser.remb()->ssrcs().size()); 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(); observation_complete_.Set();
} }
@ -84,7 +87,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
class BandwidthStatsTest : public test::EndToEndTest { class BandwidthStatsTest : public test::EndToEndTest {
public: public:
BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue) BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
sender_call_(nullptr), sender_call_(nullptr),
receiver_call_(nullptr), receiver_call_(nullptr),
has_seen_pacer_delay_(false), has_seen_pacer_delay_(false),
@ -191,7 +194,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
class BweObserver : public test::EndToEndTest { class BweObserver : public test::EndToEndTest {
public: public:
explicit BweObserver(TaskQueueBase* task_queue) explicit BweObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
sender_call_(nullptr), sender_call_(nullptr),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
sender_ssrc_(0), sender_ssrc_(0),
@ -315,7 +318,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit EncoderRateStatsTest(TaskQueueBase* task_queue) explicit EncoderRateStatsTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
send_stream_(nullptr), send_stream_(nullptr),
@ -363,7 +366,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
} }
void WaitForEncoderTargetBitrateMatchStats() { 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(); VideoSendStream::Stats stats = send_stream_->GetStats();
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
@ -379,7 +382,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
} }
void WaitForStatsReportZeroTargetBitrate() { 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) { if (send_stream_->GetStats().target_media_bitrate_bps == 0) {
return; return;
} }

13
video/end_to_end_tests/call_operation_tests.cc
View File

@ -22,6 +22,7 @@
#include "test/frame_forwarder.h" #include "test/frame_forwarder.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/null_transport.h" #include "test/null_transport.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
@ -88,7 +89,9 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
event_.Set(); event_.Set();
} }
bool Wait() { return event_.Wait(kDefaultTimeout); } bool Wait() {
return event_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
rtc::Event event_; rtc::Event event_;
} renderer; } renderer;
@ -143,7 +146,9 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
public: public:
void OnFrame(const VideoFrame& video_frame) override { event_.Set(); } 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_; rtc::Event event_;
} renderer; } renderer;
@ -170,7 +175,9 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
Start(); Start();
frame_generator = test::CreateSquareFrameGenerator( frame_generator = test::CreateSquareFrameGenerator(
kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt); test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight, absl::nullopt,
absl::nullopt);
GetVideoSendStream()->SetSource( GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE); &frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data = test::FrameGeneratorInterface::VideoFrameData frame_data =

7
video/end_to_end_tests/codec_tests.cc
View File

@ -9,6 +9,7 @@
*/ */
#include <memory> #include <memory>
#include "absl/types/optional.h" #include "absl/types/optional.h"
#include "api/test/video/function_video_encoder_factory.h" #include "api/test/video/function_video_encoder_factory.h"
#include "api/video/color_space.h" #include "api/video/color_space.h"
@ -25,6 +26,7 @@
#include "test/encoder_settings.h" #include "test/encoder_settings.h"
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -53,7 +55,7 @@ class CodecObserver : public test::EndToEndTest,
const std::string& payload_name, const std::string& payload_name,
VideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
VideoDecoderFactory* decoder_factory) VideoDecoderFactory* decoder_factory)
: EndToEndTest(4 * CodecEndToEndTest::kDefaultTimeout), : EndToEndTest(4 * test::VideoTestConstants::kDefaultTimeout),
// TODO(hta): This timeout (120 seconds) is excessive. // TODO(hta): This timeout (120 seconds) is excessive.
// https://bugs.webrtc.org/6830 // https://bugs.webrtc.org/6830
no_frames_to_wait_for_(no_frames_to_wait_for), no_frames_to_wait_for_(no_frames_to_wait_for),
@ -76,7 +78,8 @@ class CodecObserver : public test::EndToEndTest,
encoder_config->codec_type = PayloadStringToCodecType(payload_name_); encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
send_config->encoder_settings.encoder_factory = encoder_factory_; send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_; 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].renderer = this;
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);

5
video/end_to_end_tests/extended_reports_tests.cc
View File

@ -39,6 +39,7 @@
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/video_test_constants.h"
#include "video/config/video_encoder_config.h" #include "video/config/video_encoder_config.h"
namespace webrtc { namespace webrtc {
@ -63,7 +64,7 @@ class RtcpXrObserver : public test::EndToEndTest {
bool expect_target_bitrate, bool expect_target_bitrate,
bool enable_zero_target_bitrate, bool enable_zero_target_bitrate,
VideoEncoderConfig::ContentType content_type) VideoEncoderConfig::ContentType content_type)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
enable_rrtr_(enable_rrtr), enable_rrtr_(enable_rrtr),
expect_target_bitrate_(expect_target_bitrate), expect_target_bitrate_(expect_target_bitrate),
enable_zero_target_bitrate_(enable_zero_target_bitrate), enable_zero_target_bitrate_(enable_zero_target_bitrate),
@ -104,7 +105,7 @@ class RtcpXrObserver : public test::EndToEndTest {
test::RtcpPacketParser parser; test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length)); 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_) { enable_zero_target_bitrate_) {
// Reduce bandwidth restriction to disable second stream after it was // Reduce bandwidth restriction to disable second stream after it was
// enabled for some time. // enabled for some time.

136
video/end_to_end_tests/fec_tests.cc
View File

@ -26,6 +26,7 @@
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
using ::testing::Contains; using ::testing::Contains;
using ::testing::Not; using ::testing::Not;
@ -53,7 +54,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
UlpfecRenderObserver() UlpfecRenderObserver()
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([]() { return VP8Encoder::Create(); }), encoder_factory_([]() { return VP8Encoder::Create(); }),
random_(0xcafef00d1), random_(0xcafef00d1),
num_packets_sent_(0) {} num_packets_sent_(0) {}
@ -64,31 +65,38 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
RtpPacket rtp_packet; RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
EXPECT_TRUE(rtp_packet.PayloadType() == kVideoSendPayloadType || EXPECT_TRUE(rtp_packet.PayloadType() ==
rtp_packet.PayloadType() == kRedPayloadType) test::VideoTestConstants::kVideoSendPayloadType ||
rtp_packet.PayloadType() ==
test::VideoTestConstants::kRedPayloadType)
<< "Unknown payload type received."; << "Unknown payload type received.";
EXPECT_EQ(kVideoSendSsrcs[0], rtp_packet.Ssrc()) EXPECT_EQ(test::VideoTestConstants::kVideoSendSsrcs[0], rtp_packet.Ssrc())
<< "Unknown SSRC received."; << "Unknown SSRC received.";
// Parse RED header. // Parse RED header.
int encapsulated_payload_type = -1; int encapsulated_payload_type = -1;
if (rtp_packet.PayloadType() == kRedPayloadType) { if (rtp_packet.PayloadType() ==
test::VideoTestConstants::kRedPayloadType) {
encapsulated_payload_type = rtp_packet.payload()[0]; encapsulated_payload_type = rtp_packet.payload()[0];
EXPECT_TRUE(encapsulated_payload_type == kVideoSendPayloadType || EXPECT_TRUE(encapsulated_payload_type ==
encapsulated_payload_type == kUlpfecPayloadType) test::VideoTestConstants::kVideoSendPayloadType ||
encapsulated_payload_type ==
test::VideoTestConstants::kUlpfecPayloadType)
<< "Unknown encapsulated payload type received."; << "Unknown encapsulated payload type received.";
} }
// To minimize test flakiness, always let ULPFEC packets through. // To minimize test flakiness, always let ULPFEC packets through.
if (encapsulated_payload_type == kUlpfecPayloadType) { if (encapsulated_payload_type ==
test::VideoTestConstants::kUlpfecPayloadType) {
return SEND_PACKET; return SEND_PACKET;
} }
// Simulate 5% video packet loss after rampup period. Record the // Simulate 5% video packet loss after rampup period. Record the
// corresponding timestamps that were dropped. // corresponding timestamps that were dropped.
if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) { 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_sequence_numbers_.insert(rtp_packet.SequenceNumber());
dropped_timestamps_.insert(rtp_packet.Timestamp()); dropped_timestamps_.insert(rtp_packet.Timestamp());
} }
@ -116,7 +124,8 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
// in the packetization headers. // in the packetization headers.
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; 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; encoder_config->codec_type = kVideoCodecVP8;
VideoReceiveStreamInterface::Decoder decoder = VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(*send_config); test::CreateMatchingDecoder(*send_config);
@ -125,10 +134,14 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
(*receive_configs)[0].decoders.push_back(decoder); (*receive_configs)[0].decoders.push_back(decoder);
// Enable ULPFEC over RED. // Enable ULPFEC over RED.
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; send_config->rtp.ulpfec.red_payload_type =
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; test::VideoTestConstants::kRedPayloadType;
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType; send_config->rtp.ulpfec.ulpfec_payload_type =
(*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType; 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; (*receive_configs)[0].renderer = this;
} }
@ -159,7 +172,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
static constexpr uint32_t kFlexfecLocalSsrc = 456; static constexpr uint32_t kFlexfecLocalSsrc = 456;
explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp) explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp)
: test::EndToEndTest(test::CallTest::kLongTimeout), : test::EndToEndTest(test::VideoTestConstants::kLongTimeout),
enable_nack_(enable_nack), enable_nack_(enable_nack),
expect_flexfec_rtcp_(expect_flexfec_rtcp), expect_flexfec_rtcp_(expect_flexfec_rtcp),
received_flexfec_rtcp_(false), received_flexfec_rtcp_(false),
@ -175,27 +188,32 @@ class FlexfecRenderObserver : public test::EndToEndTest,
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
EXPECT_TRUE( EXPECT_TRUE(
rtp_packet.PayloadType() == test::CallTest::kFakeVideoSendPayloadType || rtp_packet.PayloadType() ==
rtp_packet.PayloadType() == test::CallTest::kFlexfecPayloadType || test::VideoTestConstants::kFakeVideoSendPayloadType ||
(enable_nack_ && rtp_packet.PayloadType() ==
rtp_packet.PayloadType() == test::CallTest::kSendRtxPayloadType)) test::VideoTestConstants::kFlexfecPayloadType ||
(enable_nack_ && rtp_packet.PayloadType() ==
test::VideoTestConstants::kSendRtxPayloadType))
<< "Unknown payload type received."; << "Unknown payload type received.";
EXPECT_TRUE( EXPECT_TRUE(
rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[0] || rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0] ||
rtp_packet.Ssrc() == test::CallTest::kFlexfecSendSsrc || rtp_packet.Ssrc() == test::VideoTestConstants::kFlexfecSendSsrc ||
(enable_nack_ && rtp_packet.Ssrc() == test::CallTest::kSendRtxSsrcs[0])) (enable_nack_ &&
rtp_packet.Ssrc() == test::VideoTestConstants::kSendRtxSsrcs[0]))
<< "Unknown SSRC received."; << "Unknown SSRC received.";
// To reduce test flakiness, always let FlexFEC packets through. // To reduce test flakiness, always let FlexFEC packets through.
if (rtp_packet.PayloadType() == test::CallTest::kFlexfecPayloadType) { if (rtp_packet.PayloadType() ==
EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, rtp_packet.Ssrc()); test::VideoTestConstants::kFlexfecPayloadType) {
EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, rtp_packet.Ssrc());
return SEND_PACKET; return SEND_PACKET;
} }
// To reduce test flakiness, always let RTX packets through. // To reduce test flakiness, always let RTX packets through.
if (rtp_packet.PayloadType() == test::CallTest::kSendRtxPayloadType) { if (rtp_packet.PayloadType() ==
EXPECT_EQ(test::CallTest::kSendRtxSsrcs[0], rtp_packet.Ssrc()); test::VideoTestConstants::kSendRtxPayloadType) {
EXPECT_EQ(test::VideoTestConstants::kSendRtxSsrcs[0], rtp_packet.Ssrc());
if (rtp_packet.payload_size() == 0) { if (rtp_packet.payload_size() == 0) {
// Pure padding packet. // Pure padding packet.
@ -223,9 +241,10 @@ class FlexfecRenderObserver : public test::EndToEndTest,
// Simulate 5% video packet loss after rampup period. Record the // Simulate 5% video packet loss after rampup period. Record the
// corresponding timestamps that were dropped. // corresponding timestamps that were dropped.
if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) { if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) {
EXPECT_EQ(test::CallTest::kFakeVideoSendPayloadType, EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType()); 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_sequence_numbers_.insert(rtp_packet.SequenceNumber());
dropped_timestamps_.insert(rtp_packet.Timestamp()); dropped_timestamps_.insert(rtp_packet.Timestamp());
@ -246,7 +265,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
parser.receiver_report()->report_blocks(); parser.receiver_report()->report_blocks();
if (!report_blocks.empty()) { if (!report_blocks.empty()) {
EXPECT_EQ(1U, report_blocks.size()); EXPECT_EQ(1U, report_blocks.size());
EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc,
report_blocks[0].source_ssrc()); report_blocks[0].source_ssrc());
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
received_flexfec_rtcp_ = true; received_flexfec_rtcp_ = true;
@ -286,17 +305,20 @@ class FlexfecRenderObserver : public test::EndToEndTest,
(*receive_configs)[0].renderer = this; (*receive_configs)[0].renderer = this;
if (enable_nack_) { if (enable_nack_) {
send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
send_config->rtp.rtx.ssrcs.push_back(test::CallTest::kSendRtxSsrcs[0]); test::VideoTestConstants::kNackRtpHistoryMs;
send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType; 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 = (*receive_configs)[0].rtp.nack.rtp_history_ms =
test::CallTest::kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.rtx_ssrc = test::CallTest::kSendRtxSsrcs[0]; (*receive_configs)[0].rtp.rtx_ssrc =
(*receive_configs)[0] test::VideoTestConstants::kSendRtxSsrcs[0];
.rtp (*receive_configs)[0].rtp.rtx_associated_payload_types
.rtx_associated_payload_types[test::CallTest::kSendRtxPayloadType] = [test::VideoTestConstants::kSendRtxPayloadType] =
test::CallTest::kVideoSendPayloadType; test::VideoTestConstants::kVideoSendPayloadType;
} }
} }
@ -345,7 +367,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
class UlpfecNackObserver : public test::EndToEndTest { class UlpfecNackObserver : public test::EndToEndTest {
public: public:
UlpfecNackObserver() UlpfecNackObserver()
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
state_(kFirstPacket), state_(kFirstPacket),
ulpfec_sequence_number_(0), ulpfec_sequence_number_(0),
has_last_sequence_number_(false), has_last_sequence_number_(false),
@ -359,12 +381,16 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
int encapsulated_payload_type = -1; int encapsulated_payload_type = -1;
if (rtp_packet.PayloadType() == kRedPayloadType) { if (rtp_packet.PayloadType() ==
test::VideoTestConstants::kRedPayloadType) {
encapsulated_payload_type = rtp_packet.payload()[0]; encapsulated_payload_type = rtp_packet.payload()[0];
if (encapsulated_payload_type != kFakeVideoSendPayloadType) if (encapsulated_payload_type !=
EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type); test::VideoTestConstants::kFakeVideoSendPayloadType)
EXPECT_EQ(test::VideoTestConstants::kUlpfecPayloadType,
encapsulated_payload_type);
} else { } else {
EXPECT_EQ(kFakeVideoSendPayloadType, rtp_packet.PayloadType()); EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType());
} }
if (has_last_sequence_number_ && if (has_last_sequence_number_ &&
@ -376,7 +402,8 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
last_sequence_number_ = rtp_packet.SequenceNumber(); last_sequence_number_ = rtp_packet.SequenceNumber();
has_last_sequence_number_ = true; has_last_sequence_number_ = true;
bool ulpfec_packet = encapsulated_payload_type == kUlpfecPayloadType; bool ulpfec_packet = encapsulated_payload_type ==
test::VideoTestConstants::kUlpfecPayloadType;
switch (state_) { switch (state_) {
case kFirstPacket: case kFirstPacket:
state_ = kDropEveryOtherPacketUntilUlpfec; state_ = kDropEveryOtherPacketUntilUlpfec;
@ -454,18 +481,25 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
// Configure hybrid NACK/FEC. // Configure hybrid NACK/FEC.
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; test::VideoTestConstants::kNackRtpHistoryMs;
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;
// Set codec to VP8, otherwise NACK/FEC hybrid will be disabled. // Set codec to VP8, otherwise NACK/FEC hybrid will be disabled.
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; 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; encoder_config->codec_type = kVideoCodecVP8;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; (*receive_configs)[0].rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType; test::VideoTestConstants::kNackRtpHistoryMs;
(*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;
(*receive_configs)[0].decoders.resize(1); (*receive_configs)[0].decoders.resize(1);
(*receive_configs)[0].decoders[0].payload_type = (*receive_configs)[0].decoders[0].payload_type =

6
video/end_to_end_tests/frame_encryption_tests.cc
View File

@ -15,6 +15,7 @@
#include "modules/video_coding/codecs/vp8/include/vp8.h" #include "modules/video_coding/codecs/vp8/include/vp8.h"
#include "test/call_test.h" #include "test/call_test.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -29,7 +30,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
DecryptedFrameObserver() DecryptedFrameObserver()
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([] { return VP8Encoder::Create(); }) {} encoder_factory_([] { return VP8Encoder::Create(); }) {}
private: private:
@ -40,7 +41,8 @@ class DecryptedFrameObserver : public test::EndToEndTest,
// Use VP8 instead of FAKE. // Use VP8 instead of FAKE.
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; 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->frame_encryptor = new FakeFrameEncryptor();
send_config->crypto_options.sframe.require_frame_encryption = true; send_config->crypto_options.sframe.require_frame_encryption = true;
encoder_config->codec_type = kVideoCodecVP8; encoder_config->codec_type = kVideoCodecVP8;

74
video/end_to_end_tests/histogram_tests.cc
View File

@ -15,6 +15,7 @@
#include "system_wrappers/include/metrics.h" #include "system_wrappers/include/metrics.h"
#include "test/call_test.h" #include "test/call_test.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -44,7 +45,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
FrameObserver(bool use_rtx, bool use_fec, bool screenshare) FrameObserver(bool use_rtx, bool use_fec, bool screenshare)
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
use_rtx_(use_rtx), use_rtx_(use_rtx),
use_fec_(use_fec), use_fec_(use_fec),
screenshare_(screenshare), screenshare_(screenshare),
@ -92,33 +93,43 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
// NACK // NACK
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].renderer = this; (*receive_configs)[0].renderer = this;
// FEC // FEC
if (use_fec_) { if (use_fec_) {
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; send_config->rtp.ulpfec.ulpfec_payload_type =
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; test::VideoTestConstants::kUlpfecPayloadType;
send_config->rtp.ulpfec.red_payload_type =
test::VideoTestConstants::kRedPayloadType;
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP8"; send_config->rtp.payload_name = "VP8";
encoder_config->codec_type = kVideoCodecVP8; encoder_config->codec_type = kVideoCodecVP8;
(*receive_configs)[0].decoders[0].video_format = SdpVideoFormat("VP8"); (*receive_configs)[0].decoders[0].video_format = SdpVideoFormat("VP8");
(*receive_configs)[0].rtp.red_payload_type = kRedPayloadType; (*receive_configs)[0].rtp.red_payload_type =
(*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType; test::VideoTestConstants::kRedPayloadType;
(*receive_configs)[0].rtp.ulpfec_payload_type =
test::VideoTestConstants::kUlpfecPayloadType;
} }
// RTX // RTX
if (use_rtx_) { if (use_rtx_) {
send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); send_config->rtp.rtx.ssrcs.push_back(
send_config->rtp.rtx.payload_type = kSendRtxPayloadType; test::VideoTestConstants::kSendRtxSsrcs[0]);
(*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; send_config->rtp.rtx.payload_type =
(*receive_configs)[0] test::VideoTestConstants::kSendRtxPayloadType;
.rtp.rtx_associated_payload_types[kSendRtxPayloadType] = (*receive_configs)[0].rtp.rtx_ssrc =
kFakeVideoSendPayloadType; test::VideoTestConstants::kSendRtxSsrcs[0];
(*receive_configs)[0].rtp.rtx_associated_payload_types
[test::VideoTestConstants::kSendRtxPayloadType] =
test::VideoTestConstants::kFakeVideoSendPayloadType;
if (use_fec_) { if (use_fec_) {
send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType; send_config->rtp.ulpfec.red_rtx_payload_type =
(*receive_configs)[0] test::VideoTestConstants::kRtxRedPayloadType;
.rtp.rtx_associated_payload_types[kRtxRedPayloadType] = (*receive_configs)[0].rtp.rtx_associated_payload_types
kSendRtxPayloadType; [test::VideoTestConstants::kRtxRedPayloadType] =
test::VideoTestConstants::kSendRtxPayloadType;
} }
} }
// RTT needed for RemoteNtpTimeEstimator for the receive stream. // RTT needed for RemoteNtpTimeEstimator for the receive stream.
@ -201,19 +212,24 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
EXPECT_METRIC_EQ( EXPECT_METRIC_EQ(
1, metrics::NumSamples(video_prefix + "ReceivedHeightInPixels")); 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, EXPECT_METRIC_EQ(1,
metrics::NumEvents(video_prefix + "ReceivedHeightInPixels", metrics::NumEvents(video_prefix + "InputWidthInPixels",
kDefaultHeight)); 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, EXPECT_METRIC_EQ(1,
metrics::NumSamples(video_prefix + "InputFramesPerSecond")); metrics::NumSamples(video_prefix + "InputFramesPerSecond"));

12
video/end_to_end_tests/multi_codec_receive_tests.cc
View File

@ -24,6 +24,7 @@
#include "test/call_test.h" #include "test/call_test.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_test_constants.h"
using ::testing::Contains; using ::testing::Contains;
@ -36,11 +37,11 @@ constexpr int kFramesToObserve = 10;
uint8_t PayloadNameToPayloadType(const std::string& payload_name) { uint8_t PayloadNameToPayloadType(const std::string& payload_name) {
if (payload_name == "VP8") { if (payload_name == "VP8") {
return test::CallTest::kPayloadTypeVP8; return test::VideoTestConstants::kPayloadTypeVP8;
} else if (payload_name == "VP9") { } else if (payload_name == "VP9") {
return test::CallTest::kPayloadTypeVP9; return test::VideoTestConstants::kPayloadTypeVP9;
} else if (payload_name == "H264") { } else if (payload_name == "H264") {
return test::CallTest::kPayloadTypeH264; return test::VideoTestConstants::kPayloadTypeH264;
} else { } else {
RTC_DCHECK_NOTREACHED(); RTC_DCHECK_NOTREACHED();
return 0; return 0;
@ -63,7 +64,8 @@ int RemoveOlderOrEqual(uint32_t timestamp, std::vector<uint32_t>* timestamps) {
class FrameObserver : public test::RtpRtcpObserver, class FrameObserver : public test::RtpRtcpObserver,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
FrameObserver() : test::RtpRtcpObserver(test::CallTest::kDefaultTimeout) {} FrameObserver()
: test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout) {}
void Reset(uint8_t expected_payload_type) { void Reset(uint8_t expected_payload_type) {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
@ -79,7 +81,7 @@ class FrameObserver : public test::RtpRtcpObserver,
RtpPacket rtp_packet; RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length)); 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) if (rtp_packet.payload_size() == 0)
return SEND_PACKET; // Skip padding, may be sent after OnFrame is called. return SEND_PACKET; // Skip padding, may be sent after OnFrame is called.

4
video/end_to_end_tests/multi_stream_tester.cc
View File

@ -29,6 +29,7 @@
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
#include "test/call_test.h" #include "test/call_test.h"
#include "test/encoder_settings.h" #include "test/encoder_settings.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
@ -101,7 +102,8 @@ void MultiStreamTester::RunTest() {
VideoReceiveStreamInterface::Config receive_config( VideoReceiveStreamInterface::Config receive_config(
receiver_transport.get()); receiver_transport.get());
receive_config.rtp.remote_ssrc = ssrc; 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; receive_config.decoder_factory = &decoder_factory;
VideoReceiveStreamInterface::Decoder decoder = VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(send_config); test::CreateMatchingDecoder(send_config);

16
video/end_to_end_tests/network_state_tests.cc
View File

@ -104,8 +104,10 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
GetVideoSendConfig()->encoder_settings.encoder_factory = GetVideoSendConfig()->encoder_settings.encoder_factory =
&encoder_factory; &encoder_factory;
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(
kDefaultHeight); test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
}); });
@ -131,8 +133,9 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
CreateSendConfig(1, 0, 0); CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(transport); CreateMatchingReceiveConfigs(transport);
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
kDefaultHeight); test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
}); });
@ -158,7 +161,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder { class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
public: public:
explicit NetworkStateTest(TaskQueueBase* task_queue) explicit NetworkStateTest(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
e2e_test_task_queue_(task_queue), e2e_test_task_queue_(task_queue),
task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue( task_queue_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(
@ -225,7 +228,8 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
} }
void PerformTest() override { void PerformTest() override {
EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeout)) EXPECT_TRUE(
encoded_frames_.Wait(test::VideoTestConstants::kDefaultTimeout))
<< "No frames received by the encoder."; << "No frames received by the encoder.";
SendTask(task_queue_.get(), [this]() { SendTask(task_queue_.get(), [this]() {

6
video/end_to_end_tests/resolution_bitrate_limits_tests.cc
View File

@ -18,6 +18,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/video_encoder_proxy_factory.h" #include "test/video_encoder_proxy_factory.h"
#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h" #include "video/config/encoder_stream_factory.h"
namespace webrtc { namespace webrtc {
@ -119,7 +120,7 @@ class InitEncodeTest : public test::EndToEndTest,
InitEncodeTest(const std::string& payload_name, InitEncodeTest(const std::string& payload_name,
const std::vector<TestConfig>& configs, const std::vector<TestConfig>& configs,
const std::vector<Expectation>& expectations) const std::vector<Expectation>& expectations)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this), encoder_factory_(this),
payload_name_(payload_name), payload_name_(payload_name),
@ -147,7 +148,8 @@ class InitEncodeTest : public test::EndToEndTest,
webrtc::VideoEncoder::EncoderInfo encoder_info; webrtc::VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_; 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_); const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type; encoder_config->codec_type = codec_type;
encoder_config->video_stream_factory = encoder_config->video_stream_factory =

69
video/end_to_end_tests/retransmission_tests.cc
View File

@ -26,6 +26,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -53,7 +54,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
NackObserver() NackObserver()
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
sent_rtp_packets_(0), sent_rtp_packets_(0),
packets_left_to_drop_(0), packets_left_to_drop_(0),
nacks_left_(kNumberOfNacksToObserve) {} nacks_left_(kNumberOfNacksToObserve) {}
@ -108,8 +109,10 @@ TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
} }
void PerformTest() override { void PerformTest() override {
@ -133,7 +136,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
NackObserver() NackObserver()
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
local_ssrc_(0), local_ssrc_(0),
remote_ssrc_(0), remote_ssrc_(0),
receive_transport_(nullptr) {} receive_transport_(nullptr) {}
@ -172,7 +175,8 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
void ModifyAudioConfigs(AudioSendStream::Config* send_config, void ModifyAudioConfigs(AudioSendStream::Config* send_config,
std::vector<AudioReceiveStreamInterface::Config>* std::vector<AudioReceiveStreamInterface::Config>*
receive_configs) override { 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; local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc; remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
receive_transport_ = (*receive_configs)[0].rtcp_send_transport; receive_transport_ = (*receive_configs)[0].rtcp_send_transport;
@ -272,7 +276,7 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
explicit PliObserver(int rtp_history_ms) explicit PliObserver(int rtp_history_ms)
: EndToEndTest(kLongTimeout), : EndToEndTest(test::VideoTestConstants::kLongTimeout),
rtp_history_ms_(rtp_history_ms), rtp_history_ms_(rtp_history_ms),
nack_enabled_(rtp_history_ms > 0), nack_enabled_(rtp_history_ms > 0),
highest_dropped_timestamp_(0), highest_dropped_timestamp_(0),
@ -362,10 +366,11 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
RetransmissionObserver(bool enable_rtx, bool enable_red) RetransmissionObserver(bool enable_rtx, bool enable_red)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
payload_type_(GetPayloadType(false, enable_red)), payload_type_(GetPayloadType(false, enable_red)),
retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0] retransmission_ssrc_(
: kVideoSendSsrcs[0]), enable_rtx ? test::VideoTestConstants::kSendRtxSsrcs[0]
: test::VideoTestConstants::kVideoSendSsrcs[0]),
retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)), retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)),
encoder_factory_([]() { return VP8Encoder::Create(); }), encoder_factory_([]() { return VP8Encoder::Create(); }),
marker_bits_observed_(0), marker_bits_observed_(0),
@ -417,7 +422,8 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { 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. // Insert ourselves into the rendering pipeline.
RTC_DCHECK(!orig_renderer_); RTC_DCHECK(!orig_renderer_);
@ -427,27 +433,34 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
(*receive_configs)[0].enable_prerenderer_smoothing = false; (*receive_configs)[0].enable_prerenderer_smoothing = false;
(*receive_configs)[0].renderer = this; (*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) { if (payload_type_ == test::VideoTestConstants::kRedPayloadType) {
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; send_config->rtp.ulpfec.ulpfec_payload_type =
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; test::VideoTestConstants::kUlpfecPayloadType;
if (retransmission_ssrc_ == kSendRtxSsrcs[0]) send_config->rtp.ulpfec.red_payload_type =
send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType; 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 = (*receive_configs)[0].rtp.ulpfec_payload_type =
send_config->rtp.ulpfec.ulpfec_payload_type; send_config->rtp.ulpfec.ulpfec_payload_type;
(*receive_configs)[0].rtp.red_payload_type = (*receive_configs)[0].rtp.red_payload_type =
send_config->rtp.ulpfec.red_payload_type; send_config->rtp.ulpfec.red_payload_type;
} }
if (retransmission_ssrc_ == kSendRtxSsrcs[0]) { if (retransmission_ssrc_ == test::VideoTestConstants::kSendRtxSsrcs[0]) {
send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); send_config->rtp.rtx.ssrcs.push_back(
send_config->rtp.rtx.payload_type = kSendRtxPayloadType; test::VideoTestConstants::kSendRtxSsrcs[0]);
(*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; send_config->rtp.rtx.payload_type =
(*receive_configs)[0] test::VideoTestConstants::kSendRtxPayloadType;
.rtp.rtx_associated_payload_types[(payload_type_ == kRedPayloadType) (*receive_configs)[0].rtp.rtx_ssrc =
? kRtxRedPayloadType test::VideoTestConstants::kSendRtxSsrcs[0];
: kSendRtxPayloadType] = (*receive_configs)[0].rtp.rtx_associated_payload_types
[(payload_type_ == test::VideoTestConstants::kRedPayloadType)
? test::VideoTestConstants::kRtxRedPayloadType
: test::VideoTestConstants::kSendRtxPayloadType] =
payload_type_; payload_type_;
} }
// Configure encoding and decoding with VP8, since generic packetization // Configure encoding and decoding with VP8, since generic packetization
@ -472,12 +485,12 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
int GetPayloadType(bool use_rtx, bool use_fec) { int GetPayloadType(bool use_rtx, bool use_fec) {
if (use_fec) { if (use_fec) {
if (use_rtx) if (use_rtx)
return kRtxRedPayloadType; return test::VideoTestConstants::kRtxRedPayloadType;
return kRedPayloadType; return test::VideoTestConstants::kRedPayloadType;
} }
if (use_rtx) if (use_rtx)
return kSendRtxPayloadType; return test::VideoTestConstants::kSendRtxPayloadType;
return kFakeVideoSendPayloadType; return test::VideoTestConstants::kFakeVideoSendPayloadType;
} }
Mutex mutex_; Mutex mutex_;

73
video/end_to_end_tests/rtp_rtcp_tests.cc
View File

@ -22,6 +22,7 @@
#include "test/call_test.h" #include "test/call_test.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -41,7 +42,7 @@ void RtpRtcpEndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
class RtcpModeObserver : public test::EndToEndTest { class RtcpModeObserver : public test::EndToEndTest {
public: public:
explicit RtcpModeObserver(RtcpMode rtcp_mode) explicit RtcpModeObserver(RtcpMode rtcp_mode)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
rtcp_mode_(rtcp_mode), rtcp_mode_(rtcp_mode),
sent_rtp_(0), sent_rtp_(0),
sent_rtcp_(0) {} sent_rtcp_(0) {}
@ -94,8 +95,10 @@ void RtpRtcpEndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_; (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
} }
@ -168,12 +171,13 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
class RtpSequenceObserver : public test::RtpRtcpObserver { class RtpSequenceObserver : public test::RtpRtcpObserver {
public: public:
explicit RtpSequenceObserver(bool use_rtx) explicit RtpSequenceObserver(bool use_rtx)
: test::RtpRtcpObserver(kDefaultTimeout), : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) { ssrcs_to_observe_(test::VideoTestConstants::kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) { for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
ssrc_is_rtx_[kVideoSendSsrcs[i]] = false; ++i) {
ssrc_is_rtx_[test::VideoTestConstants::kVideoSendSsrcs[i]] = false;
if (use_rtx) if (use_rtx)
ssrc_is_rtx_[kSendRtxSsrcs[i]] = true; ssrc_is_rtx_[test::VideoTestConstants::kSendRtxSsrcs[i]] = true;
} }
} }
@ -188,7 +192,8 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
uint32_t timestamp, uint32_t timestamp,
bool only_padding) bool only_padding)
RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) { 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); auto timestamp_it = last_observed_timestamp_.find(ssrc);
if (timestamp_it == last_observed_timestamp_.end()) { if (timestamp_it == last_observed_timestamp_.end()) {
EXPECT_FALSE(only_padding); EXPECT_FALSE(only_padding);
@ -285,13 +290,16 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
CreateCalls(); CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer); CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer); CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer);
CreateSendConfig(kNumSimulcastStreams, 0, 0); CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0);
if (use_rtx) { if (use_rtx) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) { for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); ++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 = GetVideoEncoderConfig()->video_stream_factory =
@ -341,7 +349,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
GetVideoSendStream()->ReconfigureVideoEncoder( GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy()); GetVideoEncoderConfig()->Copy());
}); });
observer.ResetExpectedSsrcs(kNumSimulcastStreams); observer.ResetExpectedSsrcs(test::VideoTestConstants::kNumSimulcastStreams);
EXPECT_TRUE(observer.Wait()) EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets."; << "Timed out waiting for all SSRCs to send packets.";
@ -357,7 +365,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
GetVideoSendStream()->ReconfigureVideoEncoder( GetVideoSendStream()->ReconfigureVideoEncoder(
GetVideoEncoderConfig()->Copy()); GetVideoEncoderConfig()->Copy());
}); });
observer.ResetExpectedSsrcs(kNumSimulcastStreams); observer.ResetExpectedSsrcs(test::VideoTestConstants::kNumSimulcastStreams);
EXPECT_TRUE(observer.Wait()) EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets."; << "Timed out waiting for all SSRCs to send packets.";
} }
@ -387,7 +395,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
class RtpSequenceObserver : public test::RtpRtcpObserver { class RtpSequenceObserver : public test::RtpRtcpObserver {
public: public:
RtpSequenceObserver() RtpSequenceObserver()
: test::RtpRtcpObserver(kDefaultTimeout), : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
num_flexfec_packets_sent_(0) {} num_flexfec_packets_sent_(0) {}
void ResetPacketCount() { void ResetPacketCount() {
@ -405,10 +413,12 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
const uint32_t timestamp = rtp_packet.Timestamp(); const uint32_t timestamp = rtp_packet.Timestamp();
const uint32_t ssrc = rtp_packet.Ssrc(); 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; return SEND_PACKET;
} }
EXPECT_EQ(kFlexfecSendSsrc, ssrc) << "Unknown SSRC sent."; EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, ssrc)
<< "Unknown SSRC sent.";
++num_flexfec_packets_sent_; ++num_flexfec_packets_sent_;
@ -476,18 +486,24 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory; GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
GetVideoSendConfig()->rtp.payload_name = "VP8"; GetVideoSendConfig()->rtp.payload_name = "VP8";
GetVideoSendConfig()->rtp.payload_type = kVideoSendPayloadType; GetVideoSendConfig()->rtp.payload_type =
GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kVideoSendPayloadType;
GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); GetVideoSendConfig()->rtp.nack.rtp_history_ms =
GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType; 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; GetVideoEncoderConfig()->codec_type = kVideoCodecVP8;
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; video_receive_configs_[0].rtp.nack.rtp_history_ms =
video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0] video_receive_configs_[0].rtp.rtx_ssrc =
.rtp.rtx_associated_payload_types[kSendRtxPayloadType] = test::VideoTestConstants::kSendRtxSsrcs[0];
kVideoSendPayloadType; video_receive_configs_[0].rtp.rtx_associated_payload_types
[test::VideoTestConstants::kSendRtxPayloadType] =
test::VideoTestConstants::kVideoSendPayloadType;
// The matching FlexFEC receive config is not created by // The matching FlexFEC receive config is not created by
// CreateMatchingReceiveConfigs since this is not a test::BaseTest. // CreateMatchingReceiveConfigs since this is not a test::BaseTest.
@ -500,7 +516,8 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
GetVideoSendConfig()->rtp.flexfec.ssrc; GetVideoSendConfig()->rtp.flexfec.ssrc;
flexfec_receive_config.protected_media_ssrcs = flexfec_receive_config.protected_media_ssrcs =
GetVideoSendConfig()->rtp.flexfec.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); flexfec_receive_configs_.push_back(flexfec_receive_config);
CreateFlexfecStreams(); CreateFlexfecStreams();

47
video/end_to_end_tests/ssrc_tests.cc
View File

@ -21,6 +21,7 @@
#include "test/call_test.h" #include "test/call_test.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
class SsrcEndToEndTest : public test::CallTest { class SsrcEndToEndTest : public test::CallTest {
@ -37,12 +38,14 @@ class SsrcEndToEndTest : public test::CallTest {
TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) { TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) {
class SyncRtcpObserver : public test::EndToEndTest { class SyncRtcpObserver : public test::EndToEndTest {
public: public:
SyncRtcpObserver() : EndToEndTest(kDefaultTimeout) {} SyncRtcpObserver()
: EndToEndTest(test::VideoTestConstants::kDefaultTimeout) {}
Action OnReceiveRtcp(const uint8_t* packet, size_t length) override { Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
test::RtcpPacketParser parser; test::RtcpPacketParser parser;
EXPECT_TRUE(parser.Parse(packet, length)); EXPECT_TRUE(parser.Parse(packet, length));
EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc()); EXPECT_EQ(test::VideoTestConstants::kReceiverLocalVideoSsrc,
parser.sender_ssrc());
observation_complete_.Set(); observation_complete_.Set();
return SEND_PACKET; return SEND_PACKET;
@ -64,7 +67,8 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
: receiver_(receiver) {} : receiver_(receiver) {}
bool Wait() { bool Wait() {
return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout); return undemuxable_packet_handler_triggered_.Wait(
test::VideoTestConstants::kDefaultTimeout);
} }
private: private:
@ -119,8 +123,10 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
CreateMatchingReceiveConfigs(receive_transport.get()); CreateMatchingReceiveConfigs(receive_transport.get());
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(
kDefaultHeight); test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
@ -147,7 +153,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
size_t num_ssrcs, size_t num_ssrcs,
bool send_single_ssrc_first, bool send_single_ssrc_first,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
num_ssrcs_(num_ssrcs), num_ssrcs_(num_ssrcs),
send_single_ssrc_first_(send_single_ssrc_first), send_single_ssrc_first_(send_single_ssrc_first),
ssrcs_to_observe_(num_ssrcs), ssrcs_to_observe_(num_ssrcs),
@ -236,7 +242,8 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
VideoSendStream* send_stream_; VideoSendStream* send_stream_;
VideoEncoderConfig video_encoder_config_all_streams_; VideoEncoderConfig video_encoder_config_all_streams_;
TaskQueueBase* task_queue_; 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); RunBaseTest(&test);
} }
@ -246,21 +253,22 @@ TEST_F(SsrcEndToEndTest, SendsSetSsrc) {
} }
TEST_F(SsrcEndToEndTest, SendsSetSimulcastSsrcs) { TEST_F(SsrcEndToEndTest, SendsSetSimulcastSsrcs) {
TestSendsSetSsrcs(kNumSimulcastStreams, false); TestSendsSetSsrcs(test::VideoTestConstants::kNumSimulcastStreams, false);
} }
TEST_F(SsrcEndToEndTest, CanSwitchToUseAllSsrcs) { TEST_F(SsrcEndToEndTest, CanSwitchToUseAllSsrcs) {
TestSendsSetSsrcs(kNumSimulcastStreams, true); TestSendsSetSsrcs(test::VideoTestConstants::kNumSimulcastStreams, true);
} }
TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
class ObserveRedundantPayloads : public test::EndToEndTest { class ObserveRedundantPayloads : public test::EndToEndTest {
public: public:
ObserveRedundantPayloads() ObserveRedundantPayloads()
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
ssrcs_to_observe_(kNumSimulcastStreams) { ssrcs_to_observe_(test::VideoTestConstants::kNumSimulcastStreams) {
for (size_t i = 0; i < kNumSimulcastStreams; ++i) { for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true; ++i) {
registered_rtx_ssrc_[test::VideoTestConstants::kSendRtxSsrcs[i]] = true;
} }
} }
@ -286,7 +294,9 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
return SEND_PACKET; return SEND_PACKET;
} }
size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; } size_t GetNumVideoStreams() const override {
return test::VideoTestConstants::kNumSimulcastStreams;
}
void ModifyVideoConfigs( void ModifyVideoConfigs(
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
@ -299,10 +309,13 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
layer.target_bitrate_bps = 15000; layer.target_bitrate_bps = 15000;
layer.max_bitrate_bps = 20000; 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) for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); ++i)
send_config->rtp.rtx.ssrcs.push_back(
test::VideoTestConstants::kSendRtxSsrcs[i]);
// Significantly higher than max bitrates for all video streams -> forcing // Significantly higher than max bitrates for all video streams -> forcing
// padding to trigger redundant padding on all RTX SSRCs. // padding to trigger redundant padding on all RTX SSRCs.

81
video/end_to_end_tests/stats_tests.cc
View File

@ -28,6 +28,7 @@
#include "test/fake_encoder.h" #include "test/fake_encoder.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -51,7 +52,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
class StatsObserver : public test::EndToEndTest { class StatsObserver : public test::EndToEndTest {
public: public:
StatsObserver() StatsObserver()
: EndToEndTest(kLongTimeout), encoder_factory_([]() { : EndToEndTest(test::VideoTestConstants::kLongTimeout),
encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>( return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), 10); Clock::GetRealTimeClock(), 10);
}) {} }) {}
@ -135,9 +137,11 @@ TEST_F(StatsEndToEndTest, GetStats) {
stats.rtcp_packet_type_counts.unique_nack_requests != 0; stats.rtcp_packet_type_counts.unique_nack_requests != 0;
RTC_DCHECK(stats.current_payload_type == -1 || RTC_DCHECK(stats.current_payload_type == -1 ||
stats.current_payload_type == kFakeVideoSendPayloadType); stats.current_payload_type ==
test::VideoTestConstants::kFakeVideoSendPayloadType);
receive_stats_filled_["IncomingPayloadType"] |= receive_stats_filled_["IncomingPayloadType"] |=
stats.current_payload_type == kFakeVideoSendPayloadType; stats.current_payload_type ==
test::VideoTestConstants::kFakeVideoSendPayloadType;
} }
return AllStatsFilled(receive_stats_filled_); return AllStatsFilled(receive_stats_filled_);
@ -150,7 +154,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); }); SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
size_t expected_num_streams = size_t expected_num_streams =
kNumSimulcastStreams + expected_send_ssrcs_.size(); test::VideoTestConstants::kNumSimulcastStreams +
expected_send_ssrcs_.size();
send_stats_filled_["NumStreams"] |= send_stats_filled_["NumStreams"] |=
stats.substreams.size() == expected_num_streams; stats.substreams.size() == expected_num_streams;
@ -252,8 +257,10 @@ TEST_F(StatsEndToEndTest, GetStats) {
} }
send_config->rtp.c_name = "SomeCName"; send_config->rtp.c_name = "SomeCName";
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
send_config->rtp.rtx.payload_type = kSendRtxPayloadType; test::VideoTestConstants::kNackRtpHistoryMs;
send_config->rtp.rtx.payload_type =
test::VideoTestConstants::kSendRtxPayloadType;
const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs; const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs;
for (size_t i = 0; i < ssrcs.size(); ++i) { for (size_t i = 0; i < ssrcs.size(); ++i) {
@ -261,23 +268,29 @@ TEST_F(StatsEndToEndTest, GetStats) {
expected_receive_ssrcs_.push_back( expected_receive_ssrcs_.push_back(
(*receive_configs)[i].rtp.remote_ssrc); (*receive_configs)[i].rtp.remote_ssrc);
(*receive_configs)[i].render_delay_ms = kExpectedRenderDelayMs; (*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_ssrc =
(*receive_configs)[i] test::VideoTestConstants::kSendRtxSsrcs[i];
.rtp.rtx_associated_payload_types[kSendRtxPayloadType] = (*receive_configs)[i].rtp.rtx_associated_payload_types
kFakeVideoSendPayloadType; [test::VideoTestConstants::kSendRtxPayloadType] =
test::VideoTestConstants::kFakeVideoSendPayloadType;
} }
for (size_t i = 0; i < kNumSimulcastStreams; ++i) for (size_t i = 0; i < test::VideoTestConstants::kNumSimulcastStreams;
send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); ++i)
send_config->rtp.rtx.ssrcs.push_back(
test::VideoTestConstants::kSendRtxSsrcs[i]);
// Use a delayed encoder to make sure we see CpuOveruseMetrics stats that // Use a delayed encoder to make sure we see CpuOveruseMetrics stats that
// are non-zero. // are non-zero.
send_config->encoder_settings.encoder_factory = &encoder_factory_; 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, void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>& const std::vector<VideoReceiveStreamInterface*>&
@ -290,7 +303,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
void PerformTest() override { void PerformTest() override {
Clock* clock = Clock::GetRealTimeClock(); Clock* clock = Clock::GetRealTimeClock();
int64_t now_ms = clock->TimeInMilliseconds(); 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 receive_ok = false;
bool send_ok = false; bool send_ok = false;
@ -347,7 +361,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
class StatsObserver : public test::EndToEndTest { class StatsObserver : public test::EndToEndTest {
public: public:
StatsObserver() : EndToEndTest(kLongTimeout) {} StatsObserver() : EndToEndTest(test::VideoTestConstants::kLongTimeout) {}
private: private:
void ModifyVideoConfigs( void ModifyVideoConfigs(
@ -395,7 +409,8 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
class ReceivedRtpStatsObserver : public test::EndToEndTest { class ReceivedRtpStatsObserver : public test::EndToEndTest {
public: public:
explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue) explicit ReceivedRtpStatsObserver(TaskQueueBase* task_queue)
: EndToEndTest(kDefaultTimeout), task_queue_(task_queue) {} : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue) {}
private: private:
void OnVideoStreamsCreated(VideoSendStream* send_stream, void OnVideoStreamsCreated(VideoSendStream* send_stream,
@ -447,7 +462,9 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
class StatsObserver : public test::BaseTest, class StatsObserver : public test::BaseTest,
public rtc::VideoSinkInterface<VideoFrame> { public rtc::VideoSinkInterface<VideoFrame> {
public: public:
StatsObserver() : BaseTest(kLongTimeout), num_frames_received_(0) {} StatsObserver()
: BaseTest(test::VideoTestConstants::kLongTimeout),
num_frames_received_(0) {}
bool ShouldCreateReceivers() const override { return true; } bool ShouldCreateReceivers() const override { return true; }
@ -512,8 +529,10 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
// Modify send and receive configs. // Modify send and receive configs.
GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; GetVideoSendConfig()->rtp.nack.rtp_history_ms =
video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].renderer = &test; video_receive_configs_[0].renderer = &test;
// RTT needed for RemoteNtpTimeEstimator for the receive stream. // RTT needed for RemoteNtpTimeEstimator for the receive stream.
video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report =
@ -527,8 +546,10 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
VideoEncoderConfig::ContentType::kScreen; VideoEncoderConfig::ContentType::kScreen;
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(
kDefaultHeight); test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
}); });
@ -572,7 +593,8 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
class NackObserver : public test::EndToEndTest { class NackObserver : public test::EndToEndTest {
public: public:
explicit NackObserver(TaskQueueBase* task_queue) explicit NackObserver(TaskQueueBase* task_queue)
: EndToEndTest(kLongTimeout), task_queue_(task_queue) {} : EndToEndTest(test::VideoTestConstants::kLongTimeout),
task_queue_(task_queue) {}
private: private:
Action OnSendRtp(const uint8_t* packet, size_t length) override { Action OnSendRtp(const uint8_t* packet, size_t length) override {
@ -638,8 +660,10 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
} }
void OnVideoStreamsCreated(VideoSendStream* send_stream, void OnVideoStreamsCreated(VideoSendStream* send_stream,
@ -695,8 +719,9 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
kDefaultHeight); test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
Start(); Start();
}); });
@ -706,7 +731,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
Call::Stats stats; Call::Stats stats;
SendTask(task_queue(), SendTask(task_queue(),
[this, &stats]() { stats = sender_call_->GetStats(); }); [this, &stats]() { stats = sender_call_->GetStats(); });
ASSERT_GE(start_time_ms + kDefaultTimeout.ms(), ASSERT_GE(start_time_ms + test::VideoTestConstants::kDefaultTimeout.ms(),
clock_->TimeInMilliseconds()) clock_->TimeInMilliseconds())
<< "No RTT stats before timeout!"; << "No RTT stats before timeout!";
if (stats.rtt_ms != -1) { if (stats.rtt_ms != -1) {

15
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -26,6 +26,7 @@
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/video_test_constants.h"
#include "video/end_to_end_tests/multi_stream_tester.h" #include "video/end_to_end_tests/multi_stream_tester.h"
namespace webrtc { namespace webrtc {
@ -251,7 +252,7 @@ class TransportFeedbackEndToEndTest : public test::CallTest {
class TransportFeedbackTester : public test::EndToEndTest { class TransportFeedbackTester : public test::EndToEndTest {
public: public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams) 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_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),
receiver_call_(nullptr) { receiver_call_(nullptr) {
@ -279,7 +280,8 @@ class TransportFeedbackTester : public test::EndToEndTest {
} }
void PerformTest() override { 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 { void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
@ -326,8 +328,7 @@ TEST_F(TransportFeedbackEndToEndTest,
class TransportFeedbackTester : public test::EndToEndTest { class TransportFeedbackTester : public test::EndToEndTest {
public: public:
TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams) TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
: EndToEndTest( : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
::webrtc::TransportFeedbackEndToEndTest::kDefaultTimeout),
num_video_streams_(num_video_streams), num_video_streams_(num_video_streams),
num_audio_streams_(num_audio_streams), num_audio_streams_(num_audio_streams),
media_sent_(0), media_sent_(0),
@ -415,7 +416,7 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
class TransportSequenceNumberTest : public test::EndToEndTest { class TransportSequenceNumberTest : public test::EndToEndTest {
public: public:
TransportSequenceNumberTest() TransportSequenceNumberTest()
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
video_observed_(false), video_observed_(false),
audio_observed_(false) { audio_observed_(false) {
extensions_.Register<TransportSequenceNumber>( extensions_.Register<TransportSequenceNumber>(
@ -444,9 +445,9 @@ TEST_F(TransportFeedbackEndToEndTest, TransportSeqNumOnAudioAndVideo) {
int64_t packet_id = unwrapper_.Unwrap(transport_sequence_number); int64_t packet_id = unwrapper_.Unwrap(transport_sequence_number);
EXPECT_TRUE(received_packet_ids_.insert(packet_id).second); 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; video_observed_ = true;
if (rtp_packet.Ssrc() == kAudioSendSsrc) if (rtp_packet.Ssrc() == test::VideoTestConstants::kAudioSendSsrc)
audio_observed_ = true; audio_observed_ = true;
if (audio_observed_ && video_observed_ && if (audio_observed_ && video_observed_ &&
received_packet_ids_.size() >= kMinPacketsToWaitFor) { received_packet_ids_.size() >= kMinPacketsToWaitFor) {

13
video/picture_id_tests.cc
View File

@ -25,6 +25,7 @@
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h" #include "rtc_base/task_queue_for_test.h"
#include "test/call_test.h" #include "test/call_test.h"
#include "test/video_test_constants.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -43,7 +44,7 @@ const size_t kNumTemporalLayers[] = {1, 2, 3};
class PictureIdObserver : public test::RtpRtcpObserver { class PictureIdObserver : public test::RtpRtcpObserver {
public: public:
explicit PictureIdObserver(VideoCodecType codec_type) explicit PictureIdObserver(VideoCodecType codec_type)
: test::RtpRtcpObserver(test::CallTest::kDefaultTimeout), : test::RtpRtcpObserver(test::VideoTestConstants::kDefaultTimeout),
depacketizer_(CreateVideoRtpDepacketizer(codec_type)), depacketizer_(CreateVideoRtpDepacketizer(codec_type)),
max_expected_picture_id_gap_(0), max_expected_picture_id_gap_(0),
max_expected_tl0_idx_gap_(0), max_expected_tl0_idx_gap_(0),
@ -84,9 +85,10 @@ class PictureIdObserver : public test::RtpRtcpObserver {
ParsedPacket* parsed) const { ParsedPacket* parsed) const {
RtpPacket rtp_packet; RtpPacket rtp_packet;
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
EXPECT_TRUE(rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[0] || EXPECT_TRUE(
rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[1] || rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[0] ||
rtp_packet.Ssrc() == test::CallTest::kVideoSendSsrcs[2]) rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[1] ||
rtp_packet.Ssrc() == test::VideoTestConstants::kVideoSendSsrcs[2])
<< "Unknown SSRC sent."; << "Unknown SSRC sent.";
if (rtp_packet.payload_size() == 0) { if (rtp_packet.payload_size() == 0) {
@ -257,7 +259,8 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
task_queue(), [this, encoder_factory, payload_name]() { task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls(); CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get()); 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 = GetVideoSendConfig()->encoder_settings.encoder_factory =
encoder_factory; encoder_factory;
GetVideoSendConfig()->rtp.payload_name = payload_name; GetVideoSendConfig()->rtp.payload_name = payload_name;

4
video/quality_scaling_tests.cc
View File

@ -19,6 +19,7 @@
#include "test/call_test.h" #include "test/call_test.h"
#include "test/field_trial.h" #include "test/field_trial.h"
#include "test/frame_generator_capturer.h" #include "test/frame_generator_capturer.h"
#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h" #include "video/config/encoder_stream_factory.h"
namespace webrtc { namespace webrtc {
@ -126,7 +127,8 @@ class ScalingObserver : public test::SendTest {
VideoEncoder::EncoderInfo encoder_info; VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = &encoder_factory_; send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_; 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->video_format.name = payload_name_;
const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_); const VideoCodecType codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->codec_type = codec_type; encoder_config->codec_type = codec_type;

7
video/video_analyzer.cc
View File

@ -34,6 +34,7 @@
#include "test/testsupport/file_utils.h" #include "test/testsupport/file_utils.h"
#include "test/testsupport/frame_writer.h" #include "test/testsupport/frame_writer.h"
#include "test/testsupport/test_artifacts.h" #include "test/testsupport/test_artifacts.h"
#include "test/video_test_constants.h"
ABSL_FLAG(bool, ABSL_FLAG(bool,
save_worst_frame, save_worst_frame,
@ -59,7 +60,7 @@ constexpr int kKeepAliveIntervalIterations =
kKeepAliveInterval.ms() / kProbingInterval.ms(); kKeepAliveInterval.ms() / kProbingInterval.ms();
bool IsFlexfec(int payload_type) { bool IsFlexfec(int payload_type) {
return payload_type == test::CallTest::kFlexfecPayloadType; return payload_type == test::VideoTestConstants::kFlexfecPayloadType;
} }
} // namespace } // namespace
@ -437,7 +438,7 @@ double VideoAnalyzer::GetCpuUsagePercent() {
bool VideoAnalyzer::IsInSelectedSpatialAndTemporalLayer( bool VideoAnalyzer::IsInSelectedSpatialAndTemporalLayer(
const RtpPacket& rtp_packet) { 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()); auto parsed_payload = vp8_depacketizer_->Parse(rtp_packet.PayloadBuffer());
RTC_DCHECK(parsed_payload); RTC_DCHECK(parsed_payload);
const auto& vp8_header = absl::get<RTPVideoHeaderVP8>( const auto& vp8_header = absl::get<RTPVideoHeaderVP8>(
@ -447,7 +448,7 @@ bool VideoAnalyzer::IsInSelectedSpatialAndTemporalLayer(
temporal_idx <= selected_tl_; 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()); auto parsed_payload = vp9_depacketizer_->Parse(rtp_packet.PayloadBuffer());
RTC_DCHECK(parsed_payload); RTC_DCHECK(parsed_payload);
const auto& vp9_header = absl::get<RTPVideoHeaderVP9>( const auto& vp9_header = absl::get<RTPVideoHeaderVP9>(

60
video/video_quality_test.cc
View File

@ -54,6 +54,7 @@
#ifdef WEBRTC_WIN #ifdef WEBRTC_WIN
#include "modules/audio_device/include/audio_device_factory.h" #include "modules/audio_device/include/audio_device_factory.h"
#endif #endif
#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h" #include "video/config/encoder_stream_factory.h"
namespace webrtc { namespace webrtc {
@ -714,26 +715,26 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
RTC_CHECK_GT(num_video_substreams, 0); RTC_CHECK_GT(num_video_substreams, 0);
for (size_t i = 0; i < num_video_substreams; ++i) for (size_t i = 0; i < num_video_substreams; ++i)
video_send_configs_[video_idx].rtp.ssrcs.push_back( video_send_configs_[video_idx].rtp.ssrcs.push_back(
kVideoSendSsrcs[total_streams_used + i]); test::VideoTestConstants::kVideoSendSsrcs[total_streams_used + i]);
int payload_type; int payload_type;
if (params_.video[video_idx].codec == "H264") { if (params_.video[video_idx].codec == "H264") {
payload_type = kPayloadTypeH264; payload_type = test::VideoTestConstants::kPayloadTypeH264;
} else if (params_.video[video_idx].codec == "VP8") { } else if (params_.video[video_idx].codec == "VP8") {
payload_type = kPayloadTypeVP8; payload_type = test::VideoTestConstants::kPayloadTypeVP8;
} else if (params_.video[video_idx].codec == "VP9") { } else if (params_.video[video_idx].codec == "VP9") {
payload_type = kPayloadTypeVP9; payload_type = test::VideoTestConstants::kPayloadTypeVP9;
} else if (params_.video[video_idx].codec == "multiplex") { } else if (params_.video[video_idx].codec == "multiplex") {
payload_type = kPayloadTypeVP9; payload_type = test::VideoTestConstants::kPayloadTypeVP9;
} else if (params_.video[video_idx].codec == "FakeCodec") { } else if (params_.video[video_idx].codec == "FakeCodec") {
payload_type = kFakeVideoSendPayloadType; payload_type = test::VideoTestConstants::kFakeVideoSendPayloadType;
} else { } else {
RTC_CHECK(generic_codec_name.empty() || RTC_CHECK(generic_codec_name.empty() ||
generic_codec_name == params_.video[video_idx].codec) generic_codec_name == params_.video[video_idx].codec)
<< "Supplying multiple generic codecs is unsupported."; << "Supplying multiple generic codecs is unsupported.";
RTC_LOG(LS_INFO) << "Treating codec " << params_.video[video_idx].codec RTC_LOG(LS_INFO) << "Treating codec " << params_.video[video_idx].codec
<< " as generic."; << " as generic.";
payload_type = kPayloadTypeGeneric; payload_type = test::VideoTestConstants::kPayloadTypeGeneric;
generic_codec_name = params_.video[video_idx].codec; generic_codec_name = params_.video[video_idx].codec;
} }
video_send_configs_[video_idx].encoder_settings.encoder_factory = video_send_configs_[video_idx].encoder_settings.encoder_factory =
@ -745,11 +746,13 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
video_send_configs_[video_idx].rtp.payload_name = video_send_configs_[video_idx].rtp.payload_name =
params_.video[video_idx].codec; params_.video[video_idx].codec;
video_send_configs_[video_idx].rtp.payload_type = payload_type; 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.nack.rtp_history_ms =
video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType; 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) { for (size_t i = 0; i < num_video_substreams; ++i) {
video_send_configs_[video_idx].rtp.rtx.ssrcs.push_back( 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(); video_send_configs_[video_idx].rtp.extensions.clear();
if (params_.call.send_side_bwe) { if (params_.call.send_side_bwe) {
@ -824,7 +827,7 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
decode_sub_stream = params_.ss[video_idx].selected_stream; decode_sub_stream = params_.ss[video_idx].selected_stream;
CreateMatchingVideoReceiveConfigs( CreateMatchingVideoReceiveConfigs(
video_send_configs_[video_idx], recv_transport, &video_decoder_factory_, 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) { if (params_.screenshare[video_idx].enabled) {
// Fill out codec settings. // Fill out codec settings.
@ -925,7 +928,9 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
if (decode_all_receive_streams) { if (decode_all_receive_streams) {
SetSendFecConfig(GetVideoSendConfig()->rtp.ssrcs); SetSendFecConfig(GetVideoSendConfig()->rtp.ssrcs);
} else { } else {
SetSendFecConfig({kVideoSendSsrcs[params_.ss[0].selected_stream]}); SetSendFecConfig(
{test::VideoTestConstants::kVideoSendSsrcs[params_.ss[0]
.selected_stream]});
} }
CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig()); CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
@ -956,9 +961,12 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
thumbnail_send_config.encoder_settings.bitrate_allocator_factory = thumbnail_send_config.encoder_settings.bitrate_allocator_factory =
video_bitrate_allocator_factory_.get(); video_bitrate_allocator_factory_.get();
thumbnail_send_config.rtp.payload_name = params_.video[0].codec; thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8; thumbnail_send_config.rtp.payload_type =
thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; test::VideoTestConstants::kPayloadTypeVP8;
thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType; 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.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
thumbnail_send_config.rtp.extensions.clear(); thumbnail_send_config.rtp.extensions.clear();
if (params_.call.send_side_bwe) { if (params_.call.send_side_bwe) {
@ -988,7 +996,8 @@ void VideoQualityTest::SetupThumbnails(Transport* send_transport,
AddMatchingVideoReceiveConfigs( AddMatchingVideoReceiveConfigs(
&thumbnail_receive_configs_, thumbnail_send_config, send_transport, &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) { for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream( thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(
@ -1169,11 +1178,12 @@ VideoQualityTest::CreateSendTransport() {
return std::make_unique<test::LayerFilteringTransport>( return std::make_unique<test::LayerFilteringTransport>(
task_queue(), task_queue(),
std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)), std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9, sender_call_.get(), test::VideoTestConstants::kPayloadTypeVP8,
params_.video[0].selected_tl, params_.ss[0].selected_sl, test::VideoTestConstants::kPayloadTypeVP9, params_.video[0].selected_tl,
payload_type_map_, kVideoSendSsrcs[0], params_.ss[0].selected_sl, payload_type_map_,
static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() - test::VideoTestConstants::kVideoSendSsrcs[0],
1), static_cast<uint32_t>(test::VideoTestConstants::kVideoSendSsrcs[0] +
params_.ss[0].streams.size() - 1),
GetRegisteredExtensions(), GetRegisteredExtensions()); GetRegisteredExtensions(), GetRegisteredExtensions());
} }
@ -1263,8 +1273,8 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
? TimeDelta::Millis(1) ? TimeDelta::Millis(1)
: TimeDelta::Seconds(params_.analyzer.test_durations_secs), : TimeDelta::Seconds(params_.analyzer.test_durations_secs),
graph_data_output_file, graph_title, graph_data_output_file, graph_title,
kVideoSendSsrcs[params_.ss[0].selected_stream], test::VideoTestConstants::kVideoSendSsrcs[params_.ss[0].selected_stream],
kSendRtxSsrcs[params_.ss[0].selected_stream], test::VideoTestConstants::kSendRtxSsrcs[params_.ss[0].selected_stream],
static_cast<size_t>(params_.ss[0].selected_stream), static_cast<size_t>(params_.ss[0].selected_stream),
params.ss[0].selected_sl, params_.video[0].selected_tl, params.ss[0].selected_sl, params_.video[0].selected_tl,
is_quick_test_enabled, clock_, params_.logging.rtp_dump_name, is_quick_test_enabled, clock_, params_.logging.rtp_dump_name,
@ -1393,13 +1403,13 @@ void VideoQualityTest::InitializeAudioDevice(Call::Config* send_call_config,
void VideoQualityTest::SetupAudio(Transport* transport) { void VideoQualityTest::SetupAudio(Transport* transport) {
AudioSendStream::Config audio_send_config(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 // Add extension to enable audio send side BWE, and allow audio bit rate
// adaptation. // adaptation.
audio_send_config.rtp.extensions.clear(); audio_send_config.rtp.extensions.clear();
audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
kAudioSendPayloadType, test::VideoTestConstants::kAudioSendPayloadType,
{"OPUS", {"OPUS",
48000, 48000,
2, 2,

211
video/video_send_stream_tests.cc
View File

@ -71,6 +71,7 @@
#include "test/rtcp_packet_parser.h" #include "test/rtcp_packet_parser.h"
#include "test/rtp_rtcp_observer.h" #include "test/rtp_rtcp_observer.h"
#include "test/video_encoder_proxy_factory.h" #include "test/video_encoder_proxy_factory.h"
#include "test/video_test_constants.h"
#include "video/config/encoder_stream_factory.h" #include "video/config/encoder_stream_factory.h"
#include "video/send_statistics_proxy.h" #include "video/send_statistics_proxy.h"
#include "video/transport_adapter.h" #include "video/transport_adapter.h"
@ -186,7 +187,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo="; static std::string kCName = "PjQatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
class CNameObserver : public test::SendTest { class CNameObserver : public test::SendTest {
public: public:
CNameObserver() : SendTest(kDefaultTimeout) {} CNameObserver() : SendTest(test::VideoTestConstants::kDefaultTimeout) {}
private: private:
Action OnSendRtcp(const uint8_t* packet, size_t length) override { Action OnSendRtcp(const uint8_t* packet, size_t length) override {
@ -220,7 +221,8 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
class AbsoluteSendTimeObserver : public test::SendTest { class AbsoluteSendTimeObserver : public test::SendTest {
public: public:
AbsoluteSendTimeObserver() : SendTest(kDefaultTimeout) { AbsoluteSendTimeObserver()
: SendTest(test::VideoTestConstants::kDefaultTimeout) {
extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId); extensions_.Register<AbsoluteSendTime>(kAbsSendTimeExtensionId);
} }
@ -271,7 +273,8 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
class TransmissionTimeOffsetObserver : public test::SendTest { class TransmissionTimeOffsetObserver : public test::SendTest {
public: public:
TransmissionTimeOffsetObserver() TransmissionTimeOffsetObserver()
: SendTest(kDefaultTimeout), encoder_factory_([]() { : SendTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([]() {
return std::make_unique<test::DelayedEncoder>( return std::make_unique<test::DelayedEncoder>(
Clock::GetRealTimeClock(), kEncodeDelayMs); Clock::GetRealTimeClock(), kEncodeDelayMs);
}) { }) {
@ -318,7 +321,8 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
class TransportWideSequenceNumberObserver : public test::SendTest { class TransportWideSequenceNumberObserver : public test::SendTest {
public: public:
TransportWideSequenceNumberObserver() TransportWideSequenceNumberObserver()
: SendTest(kDefaultTimeout), encoder_factory_([]() { : SendTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_([]() {
return std::make_unique<test::FakeEncoder>( return std::make_unique<test::FakeEncoder>(
Clock::GetRealTimeClock()); Clock::GetRealTimeClock());
}) { }) {
@ -360,7 +364,8 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
TEST_F(VideoSendStreamTest, SupportsVideoRotation) { TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
class VideoRotationObserver : public test::SendTest { class VideoRotationObserver : public test::SendTest {
public: public:
VideoRotationObserver() : SendTest(kDefaultTimeout) { VideoRotationObserver()
: SendTest(test::VideoTestConstants::kDefaultTimeout) {
extensions_.Register<VideoOrientation>(kVideoRotationExtensionId); extensions_.Register<VideoOrientation>(kVideoRotationExtensionId);
} }
@ -404,7 +409,8 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
class VideoContentTypeObserver : public test::SendTest { class VideoContentTypeObserver : public test::SendTest {
public: public:
VideoContentTypeObserver() VideoContentTypeObserver()
: SendTest(kDefaultTimeout), first_frame_sent_(false) { : SendTest(test::VideoTestConstants::kDefaultTimeout),
first_frame_sent_(false) {
extensions_.Register<VideoContentTypeExtension>( extensions_.Register<VideoContentTypeExtension>(
kVideoContentTypeExtensionId); kVideoContentTypeExtensionId);
} }
@ -450,7 +456,8 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
class VideoTimingObserver : public test::SendTest { class VideoTimingObserver : public test::SendTest {
public: public:
VideoTimingObserver() VideoTimingObserver()
: SendTest(kDefaultTimeout), first_frame_sent_(false) { : SendTest(test::VideoTestConstants::kDefaultTimeout),
first_frame_sent_(false) {
extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId); extensions_.Register<VideoTimingExtension>(kVideoTimingExtensionId);
} }
@ -522,7 +529,7 @@ class UlpfecObserver : public test::EndToEndTest {
bool expect_ulpfec, bool expect_ulpfec,
const std::string& codec, const std::string& codec,
VideoEncoderFactory* encoder_factory) VideoEncoderFactory* encoder_factory)
: EndToEndTest(expect_ulpfec ? VideoSendStreamTest::kDefaultTimeout : EndToEndTest(expect_ulpfec ? test::VideoTestConstants::kDefaultTimeout
: kReducedTimeout), : kReducedTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(codec), payload_name_(codec),
@ -543,16 +550,16 @@ class UlpfecObserver : public test::EndToEndTest {
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
int encapsulated_payload_type = -1; int encapsulated_payload_type = -1;
if (rtp_packet.PayloadType() == VideoSendStreamTest::kRedPayloadType) { if (rtp_packet.PayloadType() == test::VideoTestConstants::kRedPayloadType) {
EXPECT_TRUE(expect_red_); EXPECT_TRUE(expect_red_);
encapsulated_payload_type = rtp_packet.payload()[0]; encapsulated_payload_type = rtp_packet.payload()[0];
if (encapsulated_payload_type != if (encapsulated_payload_type !=
VideoSendStreamTest::kFakeVideoSendPayloadType) { test::VideoTestConstants::kFakeVideoSendPayloadType) {
EXPECT_EQ(VideoSendStreamTest::kUlpfecPayloadType, EXPECT_EQ(test::VideoTestConstants::kUlpfecPayloadType,
encapsulated_payload_type); encapsulated_payload_type);
} }
} else { } else {
EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType, EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType()); rtp_packet.PayloadType());
if (rtp_packet.payload_size() > 0) { if (rtp_packet.payload_size() > 0) {
// Not padding-only, media received outside of RED. // Not padding-only, media received outside of RED.
@ -587,7 +594,7 @@ class UlpfecObserver : public test::EndToEndTest {
if (encapsulated_payload_type != -1) { if (encapsulated_payload_type != -1) {
if (encapsulated_payload_type == if (encapsulated_payload_type ==
VideoSendStreamTest::kUlpfecPayloadType) { test::VideoTestConstants::kUlpfecPayloadType) {
EXPECT_TRUE(expect_ulpfec_); EXPECT_TRUE(expect_ulpfec_);
sent_ulpfec_ = true; sent_ulpfec_ = true;
} else { } else {
@ -619,14 +626,14 @@ class UlpfecObserver : public test::EndToEndTest {
if (use_nack_) { if (use_nack_) {
send_config->rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].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->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_; send_config->rtp.payload_name = payload_name_;
send_config->rtp.ulpfec.red_payload_type = send_config->rtp.ulpfec.red_payload_type =
VideoSendStreamTest::kRedPayloadType; test::VideoTestConstants::kRedPayloadType;
send_config->rtp.ulpfec.ulpfec_payload_type = send_config->rtp.ulpfec.ulpfec_payload_type =
VideoSendStreamTest::kUlpfecPayloadType; test::VideoTestConstants::kUlpfecPayloadType;
if (!header_extensions_enabled_) { if (!header_extensions_enabled_) {
send_config->rtp.extensions.clear(); send_config->rtp.extensions.clear();
} else { } else {
@ -746,7 +753,7 @@ class FlexfecObserver : public test::EndToEndTest {
const std::string& codec, const std::string& codec,
VideoEncoderFactory* encoder_factory, VideoEncoderFactory* encoder_factory,
size_t num_video_streams) size_t num_video_streams)
: EndToEndTest(VideoSendStreamTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(codec), payload_name_(codec),
use_nack_(use_nack), use_nack_(use_nack),
@ -768,15 +775,17 @@ class FlexfecObserver : public test::EndToEndTest {
RtpPacket rtp_packet(&extensions_); RtpPacket rtp_packet(&extensions_);
EXPECT_TRUE(rtp_packet.Parse(packet, length)); EXPECT_TRUE(rtp_packet.Parse(packet, length));
if (rtp_packet.PayloadType() == VideoSendStreamTest::kFlexfecPayloadType) { if (rtp_packet.PayloadType() ==
EXPECT_EQ(VideoSendStreamTest::kFlexfecSendSsrc, rtp_packet.Ssrc()); test::VideoTestConstants::kFlexfecPayloadType) {
EXPECT_EQ(test::VideoTestConstants::kFlexfecSendSsrc, rtp_packet.Ssrc());
sent_flexfec_ = true; sent_flexfec_ = true;
} else { } else {
EXPECT_EQ(VideoSendStreamTest::kFakeVideoSendPayloadType, EXPECT_EQ(test::VideoTestConstants::kFakeVideoSendPayloadType,
rtp_packet.PayloadType()); rtp_packet.PayloadType());
EXPECT_THAT(::testing::make_tuple(VideoSendStreamTest::kVideoSendSsrcs, EXPECT_THAT(
num_video_streams_), ::testing::make_tuple(test::VideoTestConstants::kVideoSendSsrcs,
::testing::Contains(rtp_packet.Ssrc())); num_video_streams_),
::testing::Contains(rtp_packet.Ssrc()));
sent_media_ = true; sent_media_ = true;
} }
@ -819,7 +828,7 @@ class FlexfecObserver : public test::EndToEndTest {
if (use_nack_) { if (use_nack_) {
send_config->rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].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->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_; send_config->rtp.payload_name = payload_name_;
@ -928,7 +937,7 @@ void VideoSendStreamTest::TestNackRetransmission(
public: public:
explicit NackObserver(uint32_t retransmit_ssrc, explicit NackObserver(uint32_t retransmit_ssrc,
uint8_t retransmit_payload_type) uint8_t retransmit_payload_type)
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
send_count_(0), send_count_(0),
retransmit_count_(0), retransmit_count_(0),
retransmit_ssrc_(retransmit_ssrc), retransmit_ssrc_(retransmit_ssrc),
@ -956,11 +965,12 @@ void VideoSendStreamTest::TestNackRetransmission(
config.clock = Clock::GetRealTimeClock(); config.clock = Clock::GetRealTimeClock();
config.outgoing_transport = transport_adapter_.get(); config.outgoing_transport = transport_adapter_.get();
config.rtcp_report_interval = TimeDelta::Millis(kRtcpIntervalMs); config.rtcp_report_interval = TimeDelta::Millis(kRtcpIntervalMs);
config.local_media_ssrc = kReceiverLocalVideoSsrc; config.local_media_ssrc =
test::VideoTestConstants::kReceiverLocalVideoSsrc;
RTCPSender rtcp_sender(config); RTCPSender rtcp_sender(config);
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); rtcp_sender.SetRemoteSSRC(test::VideoTestConstants::kVideoSendSsrcs[0]);
RTCPSender::FeedbackState feedback_state; RTCPSender::FeedbackState feedback_state;
uint16_t nack_sequence_numbers[kNackedPacketsAtOnceCount]; uint16_t nack_sequence_numbers[kNackedPacketsAtOnceCount];
@ -980,7 +990,7 @@ void VideoSendStreamTest::TestNackRetransmission(
uint16_t sequence_number = rtp_packet.SequenceNumber(); uint16_t sequence_number = rtp_packet.SequenceNumber();
if (rtp_packet.Ssrc() == retransmit_ssrc_ && 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 // Not kVideoSendSsrcs[0], assume correct RTX packet. Extract sequence
// number. // number.
const uint8_t* rtx_header = rtp_packet.payload().data(); const uint8_t* rtx_header = rtp_packet.payload().data();
@ -991,7 +1001,7 @@ void VideoSendStreamTest::TestNackRetransmission(
if (it == sequence_numbers_pending_retransmission_.end()) { if (it == sequence_numbers_pending_retransmission_.end()) {
// Not currently pending retransmission. Add it to retransmission queue // Not currently pending retransmission. Add it to retransmission queue
// if media and limit not reached. // 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 && rtp_packet.payload_size() > 0 &&
retransmit_count_ + retransmit_count_ +
sequence_numbers_pending_retransmission_.size() < sequence_numbers_pending_retransmission_.size() <
@ -1019,9 +1029,10 @@ void VideoSendStreamTest::TestNackRetransmission(
transport_adapter_.reset( transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport)); new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable(); 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_; 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_); send_config->rtp.rtx.ssrcs.push_back(retransmit_ssrc_);
} }
@ -1042,12 +1053,14 @@ void VideoSendStreamTest::TestNackRetransmission(
TEST_F(VideoSendStreamTest, RetransmitsNack) { TEST_F(VideoSendStreamTest, RetransmitsNack) {
// Normal NACKs should use the send SSRC. // Normal NACKs should use the send SSRC.
TestNackRetransmission(kVideoSendSsrcs[0], kFakeVideoSendPayloadType); TestNackRetransmission(test::VideoTestConstants::kVideoSendSsrcs[0],
test::VideoTestConstants::kFakeVideoSendPayloadType);
} }
TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) { TEST_F(VideoSendStreamTest, RetransmitsNackOverRtx) {
// NACKs over RTX should use a separate SSRC. // 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, void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
@ -1068,7 +1081,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
size_t stop_size, size_t stop_size,
bool test_generic_packetization, bool test_generic_packetization,
bool use_fec) bool use_fec)
: SendTest(kLongTimeout), : SendTest(test::VideoTestConstants::kLongTimeout),
encoder_(stop), encoder_(stop),
encoder_factory_(&encoder_), encoder_factory_(&encoder_),
max_packet_size_(max_packet_size), max_packet_size_(max_packet_size),
@ -1101,8 +1114,10 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
if (use_fec_ && rtp_packet.payload_size() > 0) { if (use_fec_ && rtp_packet.payload_size() > 0) {
uint8_t payload_type = rtp_packet.payload()[0]; uint8_t payload_type = rtp_packet.payload()[0];
bool is_fec = rtp_packet.PayloadType() == kRedPayloadType && bool is_fec =
payload_type == kUlpfecPayloadType; rtp_packet.PayloadType() ==
test::VideoTestConstants::kRedPayloadType &&
payload_type == test::VideoTestConstants::kUlpfecPayloadType;
if (is_fec) { if (is_fec) {
fec_packet_received_ = true; fec_packet_received_ = true;
return SEND_PACKET; return SEND_PACKET;
@ -1181,7 +1196,8 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
uint8_t loss_ratio = uint8_t loss_ratio =
static_cast<uint8_t>(loss_delta * 255 / packets_delta); static_cast<uint8_t>(loss_delta * 255 / packets_delta);
FakeReceiveStatistics lossy_receive_stats( FakeReceiveStatistics lossy_receive_stats(
kVideoSendSsrcs[0], rtp_packet.SequenceNumber(), test::VideoTestConstants::kVideoSendSsrcs[0],
rtp_packet.SequenceNumber(),
packets_lost_, // Cumulative lost. packets_lost_, // Cumulative lost.
loss_ratio); // Loss percent. loss_ratio); // Loss percent.
RTCPSender::Configuration config; RTCPSender::Configuration config;
@ -1189,11 +1205,11 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
config.receive_statistics = &lossy_receive_stats; config.receive_statistics = &lossy_receive_stats;
config.outgoing_transport = transport_adapter_.get(); config.outgoing_transport = transport_adapter_.get();
config.rtcp_report_interval = TimeDelta::Millis(kRtcpIntervalMs); 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); RTCPSender rtcp_sender(config);
rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); rtcp_sender.SetRemoteSSRC(test::VideoTestConstants::kVideoSendSsrcs[0]);
RTCPSender::FeedbackState feedback_state; RTCPSender::FeedbackState feedback_state;
@ -1224,8 +1240,10 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
new internal::TransportAdapter(send_config->send_transport)); new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable(); transport_adapter_->Enable();
if (use_fec_) { if (use_fec_) {
send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; send_config->rtp.ulpfec.red_payload_type =
send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; test::VideoTestConstants::kRedPayloadType;
send_config->rtp.ulpfec.ulpfec_payload_type =
test::VideoTestConstants::kUlpfecPayloadType;
} }
if (!test_generic_packetization_) if (!test_generic_packetization_)
@ -1302,7 +1320,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
class NoPaddingWhenVideoIsMuted : public test::SendTest { class NoPaddingWhenVideoIsMuted : public test::SendTest {
public: public:
NoPaddingWhenVideoIsMuted() NoPaddingWhenVideoIsMuted()
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
capturer_(nullptr) {} capturer_(nullptr) {}
@ -1391,7 +1409,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest { class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
public: public:
PaddingIsPrimarilyRetransmissions() PaddingIsPrimarilyRetransmissions()
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
clock_(Clock::GetRealTimeClock()), clock_(Clock::GetRealTimeClock()),
padding_length_(0), padding_length_(0),
total_length_(0), total_length_(0),
@ -1426,8 +1444,10 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
std::vector<VideoReceiveStreamInterface::Config>* receive_configs, std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override { VideoEncoderConfig* encoder_config) override {
// Turn on RTX. // Turn on RTX.
send_config->rtp.rtx.payload_type = kFakeVideoSendPayloadType; send_config->rtp.rtx.payload_type =
send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]); test::VideoTestConstants::kFakeVideoSendPayloadType;
send_config->rtp.rtx.ssrcs.push_back(
test::VideoTestConstants::kSendRtxSsrcs[0]);
} }
void PerformTest() override { void PerformTest() override {
@ -1467,7 +1487,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
class BitrateObserver : public test::SendTest { class BitrateObserver : public test::SendTest {
public: public:
explicit BitrateObserver(TaskQueueBase* task_queue) explicit BitrateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000), retranmission_rate_limiter_(Clock::GetRealTimeClock(), 1000),
stream_(nullptr), stream_(nullptr),
@ -1560,7 +1580,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
class ChangingNetworkRouteTest : public test::EndToEndTest { class ChangingNetworkRouteTest : public test::EndToEndTest {
public: public:
explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue) explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr) { call_(nullptr) {
module_process_thread_.Detach(); module_process_thread_.Detach();
@ -1680,7 +1700,7 @@ TEST_F(VideoSendStreamTest, DISABLED_RelayToDirectRoute) {
class RelayToDirectRouteTest : public test::EndToEndTest { class RelayToDirectRouteTest : public test::EndToEndTest {
public: public:
explicit RelayToDirectRouteTest(TaskQueueBase* task_queue) explicit RelayToDirectRouteTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr), call_(nullptr),
packets_sent_(0), packets_sent_(0),
@ -1775,7 +1795,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
class ChangingTransportOverheadTest : public test::EndToEndTest { class ChangingTransportOverheadTest : public test::EndToEndTest {
public: public:
explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue) explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
call_(nullptr), call_(nullptr),
packets_sent_(0), packets_sent_(0),
@ -1851,7 +1871,7 @@ class MaxPaddingSetTest : public test::SendTest {
MaxPaddingSetTest(bool test_switch_content_type, MaxPaddingSetTest(bool test_switch_content_type,
T* stream_reset_fun, T* stream_reset_fun,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
running_without_padding_(test_switch_content_type), running_without_padding_(test_switch_content_type),
stream_resetter_(stream_reset_fun), stream_resetter_(stream_reset_fun),
task_queue_(task_queue) { task_queue_(task_queue) {
@ -2009,7 +2029,7 @@ TEST_F(VideoSendStreamTest,
} }
} }
EXPECT_TRUE( EXPECT_TRUE(
init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeout)); init_encode_called_.Wait(test::VideoTestConstants::kDefaultTimeout));
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_EQ(width, last_initialized_frame_width_); EXPECT_EQ(width, last_initialized_frame_width_);
@ -2049,19 +2069,23 @@ TEST_F(VideoSendStreamTest,
CreateSendConfig(1, 0, 0, &transport); CreateSendConfig(1, 0, 0, &transport);
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory; GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
kDefaultHeight); test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
frame_generator_capturer_->Start(); frame_generator_capturer_->Start();
}); });
encoder.WaitForResolution(kDefaultWidth, kDefaultHeight); encoder.WaitForResolution(test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
SendTask(task_queue(), [this]() { SendTask(task_queue(), [this]() {
frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2, frame_generator_capturer_->ChangeResolution(
kDefaultHeight * 2); 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]() { SendTask(task_queue(), [this]() {
DestroyStreams(); DestroyStreams();
@ -2095,7 +2119,8 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
} }
bool WaitForStartBitrate() { bool WaitForStartBitrate() {
return start_bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout); return start_bitrate_changed_.Wait(
test::VideoTestConstants::kDefaultTimeout);
} }
private: private:
@ -2122,8 +2147,9 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
CreateVideoStreams(); CreateVideoStreams();
// Start capturing and encoding frames to force encoder reconfiguration. // Start capturing and encoding frames to force encoder reconfiguration.
CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
kDefaultHeight); test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
frame_generator_capturer_->Start(); frame_generator_capturer_->Start();
// TODO(crbug/1255737): Added manual current thread message processing because // TODO(crbug/1255737): Added manual current thread message processing because
// the test code context is interpreted as the worker thread and we assume // the test code context is interpreted as the worker thread and we assume
@ -2173,7 +2199,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
} }
bool WaitForEncoderInit() { bool WaitForEncoderInit() {
return encoder_init_.Wait(VideoSendStreamTest::kDefaultTimeout); return encoder_init_.Wait(test::VideoTestConstants::kDefaultTimeout);
} }
bool WaitBitrateChanged(WaitUntil until) { bool WaitBitrateChanged(WaitUntil until) {
@ -2190,7 +2216,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
(until == WaitUntil::kZero && *bitrate_kbps == 0)) { (until == WaitUntil::kZero && *bitrate_kbps == 0)) {
return true; return true;
} }
} while (bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeout)); } while (bitrate_changed_.Wait(test::VideoTestConstants::kDefaultTimeout));
return false; return false;
} }
@ -2205,7 +2231,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
class EncoderStateObserver : public test::SendTest, public VideoEncoder { class EncoderStateObserver : public test::SendTest, public VideoEncoder {
public: public:
explicit EncoderStateObserver(TaskQueueBase* task_queue) explicit EncoderStateObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
task_queue_(task_queue), task_queue_(task_queue),
stream_(nullptr), stream_(nullptr),
initialized_(false), initialized_(false),
@ -2338,7 +2364,7 @@ class VideoCodecConfigObserver : public test::SendTest,
public: public:
VideoCodecConfigObserver(VideoCodecType video_codec_type, VideoCodecConfigObserver(VideoCodecType video_codec_type,
TaskQueueBase* task_queue) TaskQueueBase* task_queue)
: SendTest(VideoSendStreamTest::kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
video_codec_type_(video_codec_type), video_codec_type_(video_codec_type),
stream_(nullptr), stream_(nullptr),
@ -2384,7 +2410,8 @@ class VideoCodecConfigObserver : public test::SendTest,
GetEncoderSpecificSettings() const; GetEncoderSpecificSettings() const;
void PerformTest() override { 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()) ASSERT_EQ(1, FakeEncoder::GetNumInitializations())
<< "VideoEncoder not initialized."; << "VideoEncoder not initialized.";
@ -2394,7 +2421,8 @@ class VideoCodecConfigObserver : public test::SendTest,
SendTask(task_queue_, [&]() { SendTask(task_queue_, [&]() {
stream_->ReconfigureVideoEncoder(std::move(encoder_config_)); 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()) EXPECT_EQ(2, FakeEncoder::GetNumInitializations())
<< "ReconfigureVideoEncoder did not reinitialize the encoder with " << "ReconfigureVideoEncoder did not reinitialize the encoder with "
"new encoder settings."; "new encoder settings.";
@ -2539,7 +2567,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
class RtcpSenderReportTest : public test::SendTest { class RtcpSenderReportTest : public test::SendTest {
public: public:
RtcpSenderReportTest() RtcpSenderReportTest()
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
rtp_packets_sent_(0), rtp_packets_sent_(0),
media_bytes_sent_(0) {} media_bytes_sent_(0) {}
@ -2614,7 +2642,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
ScreencastTargetBitrateTest() ScreencastTargetBitrateTest()
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()), test::FakeEncoder(Clock::GetRealTimeClock()),
encoder_factory_(this) {} encoder_factory_(this) {}
@ -2672,7 +2700,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue) explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
target_bitrate_(0), target_bitrate_(0),
@ -2760,7 +2788,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
} }
} while (bitrate_changed_event_.Wait( } while (bitrate_changed_event_.Wait(
std::max(TimeDelta::Millis(1), std::max(TimeDelta::Millis(1),
VideoSendStreamTest::kDefaultTimeout - test::VideoTestConstants::kDefaultTimeout -
TimeDelta::Millis(rtc::TimeMillis() - start_time)))); TimeDelta::Millis(rtc::TimeMillis() - start_time))));
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_NEAR(target_bitrate_, expected_bitrate, abs_error) EXPECT_NEAR(target_bitrate_, expected_bitrate, abs_error)
@ -2801,9 +2829,10 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
void PerformTest() override { void PerformTest() override {
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeout)) test::VideoTestConstants::kDefaultTimeout))
<< "Timed out while waiting for rate allocator to be created."; << "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."; << "Timed out while waiting for encoder to be configured.";
WaitForSetRates(kStartBitrateKbps, 80); WaitForSetRates(kStartBitrateKbps, 80);
BitrateConstraints bitrate_config; BitrateConstraints bitrate_config;
@ -2820,7 +2849,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeout)); test::VideoTestConstants::kDefaultTimeout));
EXPECT_EQ(2, num_rate_allocator_creations_) EXPECT_EQ(2, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated."; << "Rate allocator should have been recreated.";
@ -2832,7 +2861,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy()); send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
}); });
ASSERT_TRUE(create_rate_allocator_event_.Wait( ASSERT_TRUE(create_rate_allocator_event_.Wait(
VideoSendStreamTest::kDefaultTimeout)); test::VideoTestConstants::kDefaultTimeout));
EXPECT_EQ(3, num_rate_allocator_creations_) EXPECT_EQ(3, num_rate_allocator_creations_)
<< "Rate allocator should have been recreated."; << "Rate allocator should have been recreated.";
@ -2872,7 +2901,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue) explicit ScreencastTargetBitrateTest(TaskQueueBase* task_queue)
: SendTest(kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
test::FakeEncoder(Clock::GetRealTimeClock()), test::FakeEncoder(Clock::GetRealTimeClock()),
send_stream_(nullptr), send_stream_(nullptr),
encoder_factory_(this), encoder_factory_(this),
@ -2928,12 +2957,14 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); }); SendTask(task_queue_, [&]() { stats = send_stream_->GetStats(); });
for (size_t i = 0; i < kNumStreams; ++i) { 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()) 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."; << ", stats should exist as soon as frames have been encoded.";
VideoSendStream::StreamStats ssrc_stats = 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].width, ssrc_stats.width);
EXPECT_EQ(kEncodedResolution[i].height, ssrc_stats.height); EXPECT_EQ(kEncodedResolution[i].height, ssrc_stats.height);
} }
@ -2957,7 +2988,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
class Vp9HeaderObserver : public test::SendTest { class Vp9HeaderObserver : public test::SendTest {
public: public:
explicit Vp9HeaderObserver(const Vp9TestParams& params) explicit Vp9HeaderObserver(const Vp9TestParams& params)
: SendTest(VideoSendStreamTest::kLongTimeout), : SendTest(test::VideoTestConstants::kLongTimeout),
encoder_factory_([]() { return VP9Encoder::Create(); }), encoder_factory_([]() { return VP9Encoder::Create(); }),
params_(params), params_(params),
vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {} vp9_settings_(VideoEncoder::GetDefaultVp9Settings()) {}
@ -2970,7 +3001,7 @@ class Vp9HeaderObserver : public test::SendTest {
virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0; virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
private: private:
const int kVp9PayloadType = test::CallTest::kVideoSendPayloadType; const int kVp9PayloadType = test::VideoTestConstants::kVideoSendPayloadType;
void ModifyVideoConfigs( void ModifyVideoConfigs(
VideoSendStream::Config* send_config, VideoSendStream::Config* send_config,
@ -3642,7 +3673,7 @@ TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
class FpsObserver : public test::SendTest, class FpsObserver : public test::SendTest,
public test::FrameGeneratorCapturer::SinkWantsObserver { public test::FrameGeneratorCapturer::SinkWantsObserver {
public: public:
FpsObserver() : SendTest(kDefaultTimeout) {} FpsObserver() : SendTest(test::VideoTestConstants::kDefaultTimeout) {}
void OnFrameGeneratorCapturerCreated( void OnFrameGeneratorCapturerCreated(
test::FrameGeneratorCapturer* frame_generator_capturer) override { test::FrameGeneratorCapturer* frame_generator_capturer) override {
@ -3678,7 +3709,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
public test::FakeEncoder { public test::FakeEncoder {
public: public:
explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue) explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue)
: EndToEndTest(test::CallTest::kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
FakeEncoder(Clock::GetRealTimeClock()), FakeEncoder(Clock::GetRealTimeClock()),
task_queue_(task_queue), task_queue_(task_queue),
encoder_factory_(this), encoder_factory_(this),
@ -3733,8 +3764,8 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
// At a bitrate of 60kbps with a packet size of 1200B video and an // At a bitrate of 60kbps with a packet size of 1200B video and an
// overhead of 40B per packet video produces 2240bps overhead. // overhead of 40B per packet video produces 2240bps overhead.
// So the encoder BW should be set to 57760bps. // So the encoder BW should be set to 57760bps.
EXPECT_TRUE( EXPECT_TRUE(bitrate_changed_event_.Wait(
bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeout)); test::VideoTestConstants::kDefaultTimeout));
{ {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
EXPECT_LE(max_bitrate_bps_, 57760u); EXPECT_LE(max_bitrate_bps_, 57760u);
@ -3757,7 +3788,7 @@ class PacingFactorObserver : public test::SendTest {
public: public:
PacingFactorObserver(bool configure_send_side, PacingFactorObserver(bool configure_send_side,
absl::optional<float> expected_pacing_factor) absl::optional<float> expected_pacing_factor)
: test::SendTest(VideoSendStreamTest::kDefaultTimeout), : test::SendTest(test::VideoTestConstants::kDefaultTimeout),
configure_send_side_(configure_send_side), configure_send_side_(configure_send_side),
expected_pacing_factor_(expected_pacing_factor) {} expected_pacing_factor_(expected_pacing_factor) {}
@ -3854,7 +3885,7 @@ class ContentSwitchTest : public test::SendTest {
static const uint32_t kMinPacketsToSend = 50; static const uint32_t kMinPacketsToSend = 50;
explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue) explicit ContentSwitchTest(T* stream_reset_fun, TaskQueueBase* task_queue)
: SendTest(test::CallTest::kDefaultTimeout), : SendTest(test::VideoTestConstants::kDefaultTimeout),
call_(nullptr), call_(nullptr),
state_(StreamState::kBeforeSwitch), state_(StreamState::kBeforeSwitch),
send_stream_(nullptr), send_stream_(nullptr),
@ -3950,7 +3981,8 @@ class ContentSwitchTest : public test::SendTest {
void PerformTest() override { void PerformTest() override {
while (GetStreamState() != StreamState::kAfterSwitchBack) { 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); (*stream_resetter_)(send_stream_config_, encoder_config_, this);
} }
@ -4014,7 +4046,7 @@ void VideoSendStreamTest::TestTemporalLayers(
const std::string& payload_name, const std::string& payload_name,
const std::vector<int>& num_temporal_layers, const std::vector<int>& num_temporal_layers,
const std::vector<ScalabilityMode>& scalability_mode) const std::vector<ScalabilityMode>& scalability_mode)
: EndToEndTest(kDefaultTimeout), : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
encoder_factory_(encoder_factory), encoder_factory_(encoder_factory),
payload_name_(payload_name), payload_name_(payload_name),
num_temporal_layers_(num_temporal_layers), num_temporal_layers_(num_temporal_layers),
@ -4051,7 +4083,8 @@ void VideoSendStreamTest::TestTemporalLayers(
webrtc::VideoEncoder::EncoderInfo encoder_info; webrtc::VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = encoder_factory_; send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_; 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->video_format.name = payload_name_;
encoder_config->codec_type = PayloadStringToCodecType(payload_name_); encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
encoder_config->video_stream_factory = encoder_config->video_stream_factory =