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