[cleanup] Fix redundant webrtc name specifier
This CL was uploaded by git cl split.
R=hta@webrtc.org
No-Iwyu: LSC
Bug: webrtc:42232595
Change-Id: Ibcffecf0d1e04b73850501f0f2cb88f39384a79e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/390620
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44584}
diff --git a/common_video/bitrate_adjuster_unittest.cc b/common_video/bitrate_adjuster_unittest.cc
index 1ff911c..8660533 100644
--- a/common_video/bitrate_adjuster_unittest.cc
+++ b/common_video/bitrate_adjuster_unittest.cc
@@ -34,7 +34,7 @@
const size_t frame_size_bytes =
(bitrate_bps * frame_interval_ms) / (8 * 1000);
for (size_t i = 0; i < update_frame_interval; ++i) {
- clock_.AdvanceTime(webrtc::TimeDelta::Millis(frame_interval_ms));
+ clock_.AdvanceTime(TimeDelta::Millis(frame_interval_ms));
adjuster_.Update(frame_size_bytes);
}
}
diff --git a/common_video/libyuv/libyuv_unittest.cc b/common_video/libyuv/libyuv_unittest.cc
index fbaf67c..b0e9794 100644
--- a/common_video/libyuv/libyuv_unittest.cc
+++ b/common_video/libyuv/libyuv_unittest.cc
@@ -97,8 +97,7 @@
frame_length_(CalcBufferSize(VideoType::kI420, 352, 288)) {}
void TestLibYuv::SetUp() {
- const std::string input_file_name =
- webrtc::test::ResourcePath("foreman_cif", "yuv");
+ const std::string input_file_name = test::ResourcePath("foreman_cif", "yuv");
source_file_ = fopen(input_file_name.c_str(), "rb");
ASSERT_TRUE(source_file_ != NULL)
<< "Cannot read file: " << input_file_name << "\n";
@@ -106,12 +105,11 @@
scoped_refptr<I420BufferInterface> buffer(
test::ReadI420Buffer(width_, height_, source_file_));
- orig_frame_ =
- std::make_unique<VideoFrame>(VideoFrame::Builder()
- .set_video_frame_buffer(buffer)
- .set_rotation(webrtc::kVideoRotation_0)
- .set_timestamp_us(0)
- .build());
+ orig_frame_ = std::make_unique<VideoFrame>(VideoFrame::Builder()
+ .set_video_frame_buffer(buffer)
+ .set_rotation(kVideoRotation_0)
+ .set_timestamp_us(0)
+ .build());
}
void TestLibYuv::TearDown() {
@@ -125,7 +123,7 @@
// Reading YUV frame - testing on the first frame of the foreman sequence
int j = 0;
std::string output_file_name =
- webrtc::test::OutputPath() + "LibYuvTest_conversion.yuv";
+ test::OutputPath() + "LibYuvTest_conversion.yuv";
FILE* output_file = fopen(output_file_name.c_str(), "wb");
ASSERT_TRUE(output_file != NULL);
@@ -291,7 +289,7 @@
TEST_F(TestLibYuv, ConvertAlignedFrame) {
// Reading YUV frame - testing on the first frame of the foreman sequence
std::string output_file_name =
- webrtc::test::OutputPath() + "LibYuvTest_conversion.yuv";
+ test::OutputPath() + "LibYuvTest_conversion.yuv";
FILE* output_file = fopen(output_file_name.c_str(), "wb");
ASSERT_TRUE(output_file != NULL);
diff --git a/common_video/video_frame_unittest.cc b/common_video/video_frame_unittest.cc
index c2611aa..21ddf8d 100644
--- a/common_video/video_frame_unittest.cc
+++ b/common_video/video_frame_unittest.cc
@@ -146,7 +146,7 @@
template <class T>
void CheckRotate(int width,
int height,
- webrtc::VideoRotation rotation,
+ VideoRotation rotation,
const T& rotated) {
int rotated_width = width;
int rotated_height = height;
@@ -204,7 +204,7 @@
VideoFrame frame =
VideoFrame::Builder()
.set_video_frame_buffer(I420Buffer::Create(10, 10, 10, 14, 90))
- .set_rotation(webrtc::kVideoRotation_0)
+ .set_rotation(kVideoRotation_0)
.set_timestamp_ms(789)
.build();
const int valid_value = 10;
@@ -251,10 +251,8 @@
VideoFrame frame2(frame1);
EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
- const webrtc::I420BufferInterface* yuv1 =
- frame1.video_frame_buffer()->GetI420();
- const webrtc::I420BufferInterface* yuv2 =
- frame2.video_frame_buffer()->GetI420();
+ const I420BufferInterface* yuv1 = frame1.video_frame_buffer()->GetI420();
+ const I420BufferInterface* yuv2 = frame2.video_frame_buffer()->GetI420();
EXPECT_EQ(yuv1->DataY(), yuv2->DataY());
EXPECT_EQ(yuv1->DataU(), yuv2->DataU());
EXPECT_EQ(yuv1->DataV(), yuv2->DataV());
@@ -276,8 +274,8 @@
}
TEST(TestVideoFrame, TextureInitialValues) {
- VideoFrame frame = test::FakeNativeBuffer::CreateFrame(
- 640, 480, 100, 10, webrtc::kVideoRotation_0);
+ VideoFrame frame =
+ test::FakeNativeBuffer::CreateFrame(640, 480, 100, 10, kVideoRotation_0);
EXPECT_EQ(640, frame.width());
EXPECT_EQ(480, frame.height());
EXPECT_EQ(100u, frame.rtp_timestamp());
@@ -425,7 +423,7 @@
TYPED_TEST_SUITE_P(TestPlanarYuvBufferRotate);
TYPED_TEST_P(TestPlanarYuvBufferRotate, Rotates) {
- for (const webrtc::VideoRotation& rotation : this->RotationParams) {
+ for (const VideoRotation& rotation : this->RotationParams) {
scoped_refptr<TypeParam> buffer = CreateGradient<TypeParam>(640, 480);
scoped_refptr<TypeParam> rotated_buffer =
TypeParam::Rotate(*buffer, rotation);
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
index d6fce46..38bf7cf 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
@@ -170,19 +170,19 @@
}
rtclog2::DtlsTransportStateEvent::DtlsTransportState ConvertToProtoFormat(
- webrtc::DtlsTransportState state) {
+ DtlsTransportState state) {
switch (state) {
- case webrtc::DtlsTransportState::kNew:
+ case DtlsTransportState::kNew:
return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_NEW;
- case webrtc::DtlsTransportState::kConnecting:
+ case DtlsTransportState::kConnecting:
return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTING;
- case webrtc::DtlsTransportState::kConnected:
+ case DtlsTransportState::kConnected:
return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTED;
- case webrtc::DtlsTransportState::kClosed:
+ case DtlsTransportState::kClosed:
return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CLOSED;
- case webrtc::DtlsTransportState::kFailed:
+ case DtlsTransportState::kFailed:
return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_FAILED;
- case webrtc::DtlsTransportState::kNumValues:
+ case DtlsTransportState::kNumValues:
RTC_DCHECK_NOTREACHED();
}
RTC_DCHECK_NOTREACHED();
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index aff0181..61ab4f5 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -1123,8 +1123,7 @@
// is not stored in the event log.
// TODO(ivoc): Remove this once this mapping is stored in the event log for
// audio streams. Tracking bug: webrtc:6399
-webrtc::RtpHeaderExtensionMap
-ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
+RtpHeaderExtensionMap ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
// Values from before the default RTP header extension IDs were removed.
constexpr int kAudioLevelDefaultId = 1;
constexpr int kTimestampOffsetDefaultId = 2;
@@ -1136,7 +1135,7 @@
constexpr int kVideoTimingDefaultId = 8;
constexpr int kDependencyDescriptorDefaultId = 9;
- webrtc::RtpHeaderExtensionMap default_map(/*extmap_allow_mixed=*/true);
+ RtpHeaderExtensionMap default_map(/*extmap_allow_mixed=*/true);
default_map.Register<AudioLevelExtension>(kAudioLevelDefaultId);
default_map.Register<TransmissionOffset>(kTimestampOffsetDefaultId);
default_map.Register<AbsoluteSendTime>(kAbsSendTimeDefaultId);
diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc
index 29ec8ae..03fc2eb 100644
--- a/video/buffered_frame_decryptor.cc
+++ b/video/buffered_frame_decryptor.cc
@@ -73,7 +73,7 @@
}
// Retrieve the maximum possible size of the decrypted payload.
const size_t max_plaintext_byte_size =
- frame_decryptor_->GetMaxPlaintextByteSize(webrtc::MediaType::VIDEO,
+ frame_decryptor_->GetMaxPlaintextByteSize(MediaType::VIDEO,
frame->size());
RTC_CHECK_LE(max_plaintext_byte_size, frame->size());
// Place the decrypted frame inline into the existing frame.
@@ -88,9 +88,8 @@
// Attempt to decrypt the video frame.
const FrameDecryptorInterface::Result decrypt_result =
- frame_decryptor_->Decrypt(webrtc::MediaType::VIDEO, /*csrcs=*/{},
- additional_data, *frame,
- inline_decrypted_bitstream);
+ frame_decryptor_->Decrypt(MediaType::VIDEO, /*csrcs=*/{}, additional_data,
+ *frame, inline_decrypted_bitstream);
// Optionally call the callback if there was a change in status
if (decrypt_result.status != last_status_) {
last_status_ = decrypt_result.status;
diff --git a/video/config/encoder_stream_factory.cc b/video/config/encoder_stream_factory.cc
index 601c750..8820c98 100644
--- a/video/config/encoder_stream_factory.cc
+++ b/video/config/encoder_stream_factory.cc
@@ -42,7 +42,6 @@
namespace webrtc {
namespace {
-using ::webrtc::FieldTrialsView;
const int kMinLayerSize = 16;
@@ -73,10 +72,10 @@
}
bool IsTemporalLayersSupported(VideoCodecType codec_type) {
- return codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
- codec_type == webrtc::VideoCodecType::kVideoCodecVP9 ||
- codec_type == webrtc::VideoCodecType::kVideoCodecAV1 ||
- codec_type == webrtc::VideoCodecType::kVideoCodecH265;
+ return codec_type == VideoCodecType::kVideoCodecVP8 ||
+ codec_type == VideoCodecType::kVideoCodecVP9 ||
+ codec_type == VideoCodecType::kVideoCodecAV1 ||
+ codec_type == VideoCodecType::kVideoCodecH265;
}
size_t FindRequiredActiveLayers(const VideoEncoderConfig& encoder_config) {
@@ -111,14 +110,14 @@
int GetDefaultMaxQp(VideoCodecType codec_type) {
switch (codec_type) {
- case webrtc::kVideoCodecH264:
- case webrtc::kVideoCodecH265:
+ case kVideoCodecH264:
+ case kVideoCodecH265:
return kDefaultVideoMaxQpH26x;
- case webrtc::kVideoCodecVP8:
- case webrtc::kVideoCodecVP9:
- case webrtc::kVideoCodecGeneric:
+ case kVideoCodecVP8:
+ case kVideoCodecVP9:
+ case kVideoCodecGeneric:
return kDefaultVideoMaxQpVpx;
- case webrtc::kVideoCodecAV1:
+ case kVideoCodecAV1:
return kDefaultVideoMaxQpAv1;
}
}
@@ -131,7 +130,7 @@
size_t simulcast_layers) {
int base2_exponent = static_cast<int>(simulcast_layers) - 1;
const std::optional<int> experimental_base2_exponent =
- webrtc::NormalizeSimulcastSizeExperiment::GetBase2Exponent(field_trials);
+ NormalizeSimulcastSizeExperiment::GetBase2Exponent(field_trials);
if (experimental_base2_exponent &&
(size > (1 << *experimental_base2_exponent))) {
base2_exponent = *experimental_base2_exponent;
@@ -149,10 +148,10 @@
// Allow an experiment to override the minimum bitrate for the lowest
// spatial layer. The experiment's configuration has the lowest priority.
- layers[0].min_bitrate_bps = experimental_min_bitrate
- .value_or(webrtc::DataRate::BitsPerSec(
- webrtc::kDefaultMinVideoBitrateBps))
- .bps<int>();
+ layers[0].min_bitrate_bps =
+ experimental_min_bitrate
+ .value_or(DataRate::BitsPerSec(kDefaultMinVideoBitrateBps))
+ .bps<int>();
const bool temporal_layers_supported =
IsTemporalLayersSupported(encoder_config.codec_type);
@@ -220,14 +219,14 @@
bool is_highest_layer_max_bitrate_configured =
encoder_config.simulcast_layers[layers.size() - 1].max_bitrate_bps > 0;
- bool is_screencast = encoder_config.content_type ==
- webrtc::VideoEncoderConfig::ContentType::kScreen;
+ bool is_screencast =
+ encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen;
if (!is_screencast && !is_highest_layer_max_bitrate_configured &&
encoder_config.max_bitrate_bps > 0) {
// No application-configured maximum for the largest layer.
// If there is bitrate leftover, give it to the largest layer.
- webrtc::BoostMaxSimulcastLayer(
- webrtc::DataRate::BitsPerSec(encoder_config.max_bitrate_bps), &layers);
+ BoostMaxSimulcastLayer(DataRate::BitsPerSec(encoder_config.max_bitrate_bps),
+ &layers);
}
// Sort the layers by max_bitrate_bps, they might not always be from
@@ -259,7 +258,7 @@
} // namespace
EncoderStreamFactory::EncoderStreamFactory(
- const webrtc::VideoEncoder::EncoderInfo& encoder_info,
+ const VideoEncoder::EncoderInfo& encoder_info,
std::optional<VideoSourceRestrictions> restrictions)
: encoder_info_requested_resolution_alignment_(
encoder_info.requested_resolution_alignment),
@@ -296,7 +295,7 @@
std::vector<VideoStream> streams;
if (is_simulcast ||
- webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
+ SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
streams = CreateSimulcastOrConferenceModeScreenshareStreams(
trials, frame_width, frame_height, encoder_config,
experimental_min_bitrate);
@@ -318,8 +317,8 @@
int height,
const VideoEncoderConfig& encoder_config,
const std::optional<DataRate>& experimental_min_bitrate) const {
- bool is_screencast = encoder_config.content_type ==
- webrtc::VideoEncoderConfig::ContentType::kScreen;
+ bool is_screencast =
+ encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen;
// The max bitrate specified by the API.
// - `encoder_config.simulcast_layers[0].max_bitrate_bps` comes from the first
@@ -346,8 +345,8 @@
int min_bitrate_bps =
experimental_min_bitrate
- ? webrtc::saturated_cast<int>(experimental_min_bitrate->bps())
- : webrtc::kDefaultMinVideoBitrateBps;
+ ? saturated_cast<int>(experimental_min_bitrate->bps())
+ : kDefaultMinVideoBitrateBps;
if (encoder_config.simulcast_layers[0].min_bitrate_bps > 0) {
// Use set min bitrate.
min_bitrate_bps = encoder_config.simulcast_layers[0].min_bitrate_bps;
@@ -388,7 +387,7 @@
kMinLayerSize);
}
- if (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP9) {
+ if (encoder_config.codec_type == VideoCodecType::kVideoCodecVP9) {
RTC_DCHECK(encoder_config.encoder_specific_settings);
// Use VP9 SVC layering from codec settings which might be initialized
// though field trial in ConfigureVideoEncoderSettings.
@@ -407,12 +406,12 @@
(layer.num_temporal_layers > 1u || num_spatial_layers > 1)) {
// In SVC mode, the VP9 max bitrate is determined by SvcConfig, instead of
// GetMaxDefaultVideoBitrateKbps().
- std::vector<webrtc::SpatialLayer> svc_layers =
- webrtc::GetSvcConfig(width, height, max_framerate,
- /*first_active_layer=*/0, num_spatial_layers,
- *layer.num_temporal_layers, is_screencast);
+ std::vector<SpatialLayer> svc_layers =
+ GetSvcConfig(width, height, max_framerate,
+ /*first_active_layer=*/0, num_spatial_layers,
+ *layer.num_temporal_layers, is_screencast);
int sum_max_bitrates_kbps = 0;
- for (const webrtc::SpatialLayer& spatial_layer : svc_layers) {
+ for (const SpatialLayer& spatial_layer : svc_layers) {
sum_max_bitrates_kbps += spatial_layer.maxBitrate;
}
RTC_DCHECK_GE(sum_max_bitrates_kbps, 0);
@@ -468,9 +467,9 @@
// Use legacy simulcast screenshare if conference mode is explicitly enabled
// or use the regular simulcast configuration path which is generic.
- std::vector<VideoStream> layers = webrtc::GetSimulcastConfig(
+ std::vector<VideoStream> layers = GetSimulcastConfig(
resolutions,
- webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
+ SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
IsTemporalLayersSupported(encoder_config.codec_type), trials,
encoder_config.codec_type);
@@ -509,8 +508,8 @@
VideoSinkWants wants;
wants.is_active = true;
wants.target_pixel_count = restrictions_->target_pixels_per_frame();
- wants.max_pixel_count = webrtc::dchecked_cast<int>(
- restrictions_->max_pixels_per_frame().value_or(
+ wants.max_pixel_count =
+ dchecked_cast<int>(restrictions_->max_pixels_per_frame().value_or(
std::numeric_limits<int>::max()));
wants.aggregates.emplace(VideoSinkWants::Aggregates());
wants.resolution_alignment = encoder_info_requested_resolution_alignment_;
@@ -532,7 +531,7 @@
int height,
const VideoEncoderConfig& encoder_config) const {
std::vector<Resolution> resolutions;
- if (webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
+ if (SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
resolutions.push_back({.width = width, .height = height});
}
@@ -540,7 +539,7 @@
size_t min_num_layers = FindRequiredActiveLayers(encoder_config);
size_t max_num_layers =
!encoder_config.HasScaleResolutionDownTo()
- ? webrtc::LimitSimulcastLayerCount(
+ ? LimitSimulcastLayerCount(
min_num_layers, encoder_config.number_of_streams, width,
height, trials, encoder_config.codec_type)
: encoder_config.number_of_streams;
@@ -556,8 +555,8 @@
if (encoder_config.HasScaleResolutionDownTo() &&
restrictions_.has_value() &&
restrictions_->max_pixels_per_frame().has_value()) {
- int max_pixels = webrtc::dchecked_cast<int>(
- restrictions_->max_pixels_per_frame().value());
+ int max_pixels =
+ dchecked_cast<int>(restrictions_->max_pixels_per_frame().value());
int prev_pixel_count =
encoder_config.simulcast_layers[0]
.scale_resolution_down_to.value_or(Resolution())
@@ -592,8 +591,7 @@
}
const bool norm_size_configured =
- webrtc::NormalizeSimulcastSizeExperiment::GetBase2Exponent(trials)
- .has_value();
+ NormalizeSimulcastSizeExperiment::GetBase2Exponent(trials).has_value();
const int normalized_width =
(default_scale_factors_used || norm_size_configured) &&
(width >= kMinLayerSize)
diff --git a/video/config/encoder_stream_factory_unittest.cc b/video/config/encoder_stream_factory_unittest.cc
index a36efaa..5c93527 100644
--- a/video/config/encoder_stream_factory_unittest.cc
+++ b/video/config/encoder_stream_factory_unittest.cc
@@ -42,7 +42,6 @@
using ::testing::SizeIs;
using ::testing::TestWithParam;
using ::testing::Values;
-using ::webrtc::EncoderStreamFactory;
struct CreateVideoStreamParams {
int width = 0;
@@ -482,7 +481,7 @@
.scalability_mode = ScalabilityMode::kL1T2})}}),
Values(
#ifdef RTC_ENABLE_H265
- webrtc::kVideoCodecH265,
+ kVideoCodecH265,
#endif
VideoCodecType::kVideoCodecAV1,
VideoCodecType::kVideoCodecVP9)));
diff --git a/video/config/simulcast.cc b/video/config/simulcast.cc
index 66e9005..acc2e15 100644
--- a/video/config/simulcast.cc
+++ b/video/config/simulcast.cc
@@ -37,7 +37,6 @@
namespace {
-using ::webrtc::FieldTrialsView;
constexpr char kUseLegacySimulcastLayerLimitFieldTrial[] =
"WebRTC-LegacySimulcastLayerLimit";
@@ -47,16 +46,16 @@
// Limits for legacy conference screensharing mode. Currently used for the
// lower of the two simulcast streams.
constexpr DataRate kScreenshareDefaultTl0Bitrate =
- webrtc::DataRate::KilobitsPerSec(200);
+ DataRate::KilobitsPerSec(200);
constexpr DataRate kScreenshareDefaultTl1Bitrate =
- webrtc::DataRate::KilobitsPerSec(1000);
+ DataRate::KilobitsPerSec(1000);
// Min/max bitrate for the higher one of the two simulcast stream used for
// screen content.
constexpr DataRate kScreenshareHighStreamMinBitrate =
- webrtc::DataRate::KilobitsPerSec(600);
+ DataRate::KilobitsPerSec(600);
constexpr DataRate kScreenshareHighStreamMaxBitrate =
- webrtc::DataRate::KilobitsPerSec(1250);
+ DataRate::KilobitsPerSec(1250);
constexpr int kDefaultNumTemporalLayers = 3;
constexpr int kScreenshareMaxSimulcastLayers = 2;
@@ -83,62 +82,47 @@
// simulcast layers at what bitrates (maximum, target, and minimum).
// Important!! Keep this table from high resolution to low resolution.
constexpr const SimulcastFormat kSimulcastFormatsVP8[] = {
- {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(5000),
- webrtc::DataRate::KilobitsPerSec(4000),
- webrtc::DataRate::KilobitsPerSec(800)},
- {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(2500),
- webrtc::DataRate::KilobitsPerSec(2500),
- webrtc::DataRate::KilobitsPerSec(600)},
- {960, 540, 3, webrtc::DataRate::KilobitsPerSec(1200),
- webrtc::DataRate::KilobitsPerSec(1200),
- webrtc::DataRate::KilobitsPerSec(350)},
- {640, 360, 2, webrtc::DataRate::KilobitsPerSec(700),
- webrtc::DataRate::KilobitsPerSec(500),
- webrtc::DataRate::KilobitsPerSec(150)},
- {480, 270, 2, webrtc::DataRate::KilobitsPerSec(450),
- webrtc::DataRate::KilobitsPerSec(350),
- webrtc::DataRate::KilobitsPerSec(150)},
- {320, 180, 1, webrtc::DataRate::KilobitsPerSec(200),
- webrtc::DataRate::KilobitsPerSec(150),
- webrtc::DataRate::KilobitsPerSec(30)},
+ {1920, 1080, 3, DataRate::KilobitsPerSec(5000),
+ DataRate::KilobitsPerSec(4000), DataRate::KilobitsPerSec(800)},
+ {1280, 720, 3, DataRate::KilobitsPerSec(2500),
+ DataRate::KilobitsPerSec(2500), DataRate::KilobitsPerSec(600)},
+ {960, 540, 3, DataRate::KilobitsPerSec(1200),
+ DataRate::KilobitsPerSec(1200), DataRate::KilobitsPerSec(350)},
+ {640, 360, 2, DataRate::KilobitsPerSec(700), DataRate::KilobitsPerSec(500),
+ DataRate::KilobitsPerSec(150)},
+ {480, 270, 2, DataRate::KilobitsPerSec(450), DataRate::KilobitsPerSec(350),
+ DataRate::KilobitsPerSec(150)},
+ {320, 180, 1, DataRate::KilobitsPerSec(200), DataRate::KilobitsPerSec(150),
+ DataRate::KilobitsPerSec(30)},
// As the resolution goes down, interpolate the target and max bitrates down
// towards zero. The min bitrate is still limited at 30 kbps and the target
// and the max will be capped from below accordingly.
- {0, 0, 1, webrtc::DataRate::KilobitsPerSec(0),
- webrtc::DataRate::KilobitsPerSec(0),
- webrtc::DataRate::KilobitsPerSec(30)}};
+ {0, 0, 1, DataRate::KilobitsPerSec(0), DataRate::KilobitsPerSec(0),
+ DataRate::KilobitsPerSec(30)}};
// These tables describe from which resolution we can use how many
// simulcast layers at what bitrates (maximum, target, and minimum).
// Important!! Keep this table from high resolution to low resolution.
constexpr const SimulcastFormat kSimulcastFormatsVP9[] = {
- {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(3367),
- webrtc::DataRate::KilobitsPerSec(3367),
- webrtc::DataRate::KilobitsPerSec(769)},
- {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(1524),
- webrtc::DataRate::KilobitsPerSec(1524),
- webrtc::DataRate::KilobitsPerSec(481)},
- {960, 540, 3, webrtc::DataRate::KilobitsPerSec(879),
- webrtc::DataRate::KilobitsPerSec(879),
- webrtc::DataRate::KilobitsPerSec(337)},
- {640, 360, 2, webrtc::DataRate::KilobitsPerSec(420),
- webrtc::DataRate::KilobitsPerSec(420),
- webrtc::DataRate::KilobitsPerSec(193)},
- {480, 270, 2, webrtc::DataRate::KilobitsPerSec(257),
- webrtc::DataRate::KilobitsPerSec(257),
- webrtc::DataRate::KilobitsPerSec(121)},
- {320, 180, 1, webrtc::DataRate::KilobitsPerSec(142),
- webrtc::DataRate::KilobitsPerSec(142),
- webrtc::DataRate::KilobitsPerSec(30)},
- {240, 135, 1, webrtc::DataRate::KilobitsPerSec(101),
- webrtc::DataRate::KilobitsPerSec(101),
- webrtc::DataRate::KilobitsPerSec(30)},
+ {1920, 1080, 3, DataRate::KilobitsPerSec(3367),
+ DataRate::KilobitsPerSec(3367), DataRate::KilobitsPerSec(769)},
+ {1280, 720, 3, DataRate::KilobitsPerSec(1524),
+ DataRate::KilobitsPerSec(1524), DataRate::KilobitsPerSec(481)},
+ {960, 540, 3, DataRate::KilobitsPerSec(879), DataRate::KilobitsPerSec(879),
+ DataRate::KilobitsPerSec(337)},
+ {640, 360, 2, DataRate::KilobitsPerSec(420), DataRate::KilobitsPerSec(420),
+ DataRate::KilobitsPerSec(193)},
+ {480, 270, 2, DataRate::KilobitsPerSec(257), DataRate::KilobitsPerSec(257),
+ DataRate::KilobitsPerSec(121)},
+ {320, 180, 1, DataRate::KilobitsPerSec(142), DataRate::KilobitsPerSec(142),
+ DataRate::KilobitsPerSec(30)},
+ {240, 135, 1, DataRate::KilobitsPerSec(101), DataRate::KilobitsPerSec(101),
+ DataRate::KilobitsPerSec(30)},
// As the resolution goes down, interpolate the target and max bitrates down
// towards zero. The min bitrate is still limited at 30 kbps and the target
// and the max will be capped from below accordingly.
- {0, 0, 1, webrtc::DataRate::KilobitsPerSec(0),
- webrtc::DataRate::KilobitsPerSec(0),
- webrtc::DataRate::KilobitsPerSec(30)}};
+ {0, 0, 1, DataRate::KilobitsPerSec(0), DataRate::KilobitsPerSec(0),
+ DataRate::KilobitsPerSec(30)}};
constexpr DataRate Interpolate(const DataRate& a,
const DataRate& b,
@@ -154,16 +138,16 @@
int GetDefaultSimulcastTemporalLayers(VideoCodecType codec) {
switch (codec) {
- case webrtc::kVideoCodecVP8:
- case webrtc::kVideoCodecVP9:
- case webrtc::kVideoCodecAV1:
- case webrtc::kVideoCodecH264:
- case webrtc::kVideoCodecGeneric:
+ case kVideoCodecVP8:
+ case kVideoCodecVP9:
+ case kVideoCodecAV1:
+ case kVideoCodecH264:
+ case kVideoCodecGeneric:
return kDefaultNumTemporalLayers;
// For codec type that has no software fallback, defaults to L1T1 for
// initial simulcast setup, as this is the only scalability mode secure to
// be supported.
- case webrtc::kVideoCodecH265:
+ case kVideoCodecH265:
return 1;
}
RTC_DCHECK_NOTREACHED() << "Unsupported codec.";
@@ -175,15 +159,15 @@
VideoCodecType codec) {
std::vector<SimulcastFormat> formats;
switch (codec) {
- case webrtc::kVideoCodecGeneric:
- case webrtc::kVideoCodecVP8:
- case webrtc::kVideoCodecH264:
+ case kVideoCodecGeneric:
+ case kVideoCodecVP8:
+ case kVideoCodecH264:
formats.insert(formats.begin(), std::begin(kSimulcastFormatsVP8),
std::end(kSimulcastFormatsVP8));
break;
- case webrtc::kVideoCodecVP9:
- case webrtc::kVideoCodecAV1:
- case webrtc::kVideoCodecH265:
+ case kVideoCodecVP9:
+ case kVideoCodecAV1:
+ case kVideoCodecH265:
formats.insert(formats.begin(), std::begin(kSimulcastFormatsVP9),
std::end(kSimulcastFormatsVP9));
break;
@@ -323,7 +307,7 @@
layers[0].width = width;
layers[0].height = height;
layers[0].max_framerate = 5;
- layers[0].min_bitrate_bps = webrtc::kDefaultMinVideoBitrateBps;
+ layers[0].min_bitrate_bps = kDefaultMinVideoBitrateBps;
layers[0].target_bitrate_bps = kScreenshareDefaultTl0Bitrate.bps();
layers[0].max_bitrate_bps = kScreenshareDefaultTl1Bitrate.bps();
layers[0].num_temporal_layers = temporal_layers_supported ? 2 : 1;
@@ -340,7 +324,7 @@
// layers were enabled.
max_bitrate_bps = static_cast<int>(
kScreenshareHighStreamMaxBitrate.bps() *
- webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
+ SimulcastRateAllocator::GetTemporalRateAllocation(
kScreenshareTemporalLayers, 0, base_heavy_tl3_rate_alloc));
} else {
// Experimental temporal layer mode used, use increased max bitrate.
@@ -378,8 +362,8 @@
// than configured `max_ratio`. pixels_down is the selected index in
// kSimulcastFormats based on pixels.
FieldTrialOptional<double> max_ratio("max_ratio");
- webrtc::ParseFieldTrial({&max_ratio},
- trials.Lookup("WebRTC-SimulcastLayerLimitRoundUp"));
+ ParseFieldTrial({&max_ratio},
+ trials.Lookup("WebRTC-SimulcastLayerLimitRoundUp"));
size_t reduced_num_layers =
std::max(min_num_layers,
@@ -413,14 +397,14 @@
DataRate GetTotalMaxBitrate(const std::vector<VideoStream>& layers) {
if (layers.empty())
- return webrtc::DataRate::Zero();
+ return DataRate::Zero();
int total_max_bitrate_bps = 0;
for (size_t s = 0; s < layers.size() - 1; ++s) {
total_max_bitrate_bps += layers[s].target_bitrate_bps;
}
total_max_bitrate_bps += layers.back().max_bitrate_bps;
- return webrtc::DataRate::BitsPerSec(total_max_bitrate_bps);
+ return DataRate::BitsPerSec(total_max_bitrate_bps);
}
std::vector<VideoStream> GetSimulcastConfig(
diff --git a/video/config/simulcast_unittest.cc b/video/config/simulcast_unittest.cc
index 94b48fe..628e4ea 100644
--- a/video/config/simulcast_unittest.cc
+++ b/video/config/simulcast_unittest.cc
@@ -73,7 +73,7 @@
std::vector<Resolution> CreateResolutions(int max_width,
int max_height,
int num_streams) {
- std::vector<webrtc::Resolution> resolutions(num_streams);
+ std::vector<Resolution> resolutions(num_streams);
for (int i = 0; i < num_streams; ++i) {
resolutions[i].width = max_width >> (num_streams - i - 1);
resolutions[i].height = max_height >> (num_streams - i - 1);
@@ -107,10 +107,10 @@
streams[1].target_bitrate_bps = 200000;
streams[2].max_bitrate_bps = 400000;
- const webrtc::DataRate one_bps = webrtc::DataRate::BitsPerSec(1);
+ const DataRate one_bps = DataRate::BitsPerSec(1);
// No bitrate above the total max to give to the highest stream.
- const webrtc::DataRate max_total_bitrate = GetTotalMaxBitrate(streams);
+ const DataRate max_total_bitrate = GetTotalMaxBitrate(streams);
BoostMaxSimulcastLayer(max_total_bitrate, &streams);
EXPECT_EQ(400000, streams[2].max_bitrate_bps);
EXPECT_EQ(max_total_bitrate, GetTotalMaxBitrate(streams));
@@ -129,7 +129,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(320u, streams[0].width);
@@ -157,7 +157,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecH265);
+ !kScreenshare, true, trials, kVideoCodecH265);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(320u, streams[0].width);
@@ -188,7 +188,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(kExpected[0].min_bitrate_bps, streams[0].min_bitrate_bps);
@@ -209,7 +209,7 @@
const size_t kMaxLayers = 2;
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(640u, streams[0].width);
@@ -224,7 +224,7 @@
std::vector<Resolution>{{.width = 1400, .height = 800},
{.width = 1400, .height = 800},
{.width = 1400, .height = 800}},
- kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ kScreenshare, true, trials, kVideoCodecVP8);
EXPECT_THAT(streams, SizeIs(2));
for (size_t i = 0; i < streams.size(); ++i) {
@@ -244,7 +244,7 @@
ExplicitKeyValueConfig trials("");
std::vector<VideoStream> streams = GetSimulcastConfig(
std::vector<Resolution>{{.width = 1400, .height = 800}}, kScreenshare,
- true, trials, webrtc::kVideoCodecVP8);
+ true, trials, kVideoCodecVP8);
EXPECT_THAT(streams, SizeIs(1));
}
@@ -252,7 +252,7 @@
ExplicitKeyValueConfig trials("");
std::vector<VideoStream> streams =
GetSimulcastConfig(std::vector<Resolution>{{.width = 900, .height = 800}},
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(1));
EXPECT_EQ(900u, streams[0].width);
@@ -273,7 +273,7 @@
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(kWidth, kHeight, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(kWidth, streams[2].width);
@@ -296,18 +296,18 @@
const int kMaxLayers = 3;
size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 540,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 3u);
// <960x540: 2 layers
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 539,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
// <480x270: 1 layer
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 269,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 1u);
}
@@ -318,24 +318,24 @@
const int kMaxLayers = 3;
size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 540,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 3u);
// Lowest cropped height where max layers from higher resolution is used.
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 512,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 3u);
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 508,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
// Lowest cropped height where max layers from higher resolution is used.
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 256,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 254,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 1u);
}
@@ -347,14 +347,14 @@
const int kMaxLayers = 3;
size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
// Lowest cropped height where max layers from higher resolution is used.
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 252,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 2u);
num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 250,
- trials, webrtc::kVideoCodecVP8);
+ trials, kVideoCodecVP8);
EXPECT_EQ(num_layers, 1u);
}
@@ -366,7 +366,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams = GetSimulcastConfig(
CreateResolutions(/*max_width=*/960, /*max_height=*/540, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(240u, streams[0].width);
@@ -383,7 +383,7 @@
std::vector<VideoStream> streams =
GetSimulcastConfig(std::vector<Resolution>{{.width = 1, .height = 1}},
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(1));
EXPECT_EQ(1u, streams[0].width);
@@ -401,7 +401,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams = GetSimulcastConfig(
CreateResolutions(/*max_width=*/960, /*max_height=*/540, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+ !kScreenshare, true, trials, kVideoCodecVP8);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
EXPECT_EQ(240u, streams[0].width);
@@ -419,10 +419,10 @@
};
using BitrateLimitsTest =
- TestWithParam<std::tuple<webrtc::VideoCodecType, BitrateLimitsTestParams>>;
+ TestWithParam<std::tuple<VideoCodecType, BitrateLimitsTestParams>>;
TEST_P(BitrateLimitsTest, VerifyBitrateLimits) {
- const auto codec_type = std::get<webrtc::VideoCodecType>(GetParam());
+ const auto codec_type = std::get<VideoCodecType>(GetParam());
const auto test_params = std::get<BitrateLimitsTestParams>(GetParam());
ExplicitKeyValueConfig trials("");
std::vector<VideoStream> streams = GetSimulcastConfig(
@@ -442,7 +442,7 @@
INSTANTIATE_TEST_SUITE_P(
Vp8H264,
BitrateLimitsTest,
- Combine(Values(webrtc::kVideoCodecVP8, webrtc::kVideoCodecH264),
+ Combine(Values(kVideoCodecVP8, kVideoCodecH264),
Values(BitrateLimitsTestParams{.width = 1920,
.height = 1080,
.expected_min_bitrate_kbps{150, 350,
@@ -460,8 +460,7 @@
.expected_min_bitrate_kbps{30, 150, 350},
.expected_max_bitrate_kbps{200, 450, 1200}})),
[](const TestParamInfo<BitrateLimitsTest::ParamType>& info) {
- return CodecTypeToPayloadString(
- std::get<webrtc::VideoCodecType>(info.param)) +
+ return CodecTypeToPayloadString(std::get<VideoCodecType>(info.param)) +
std::to_string(
std::get<BitrateLimitsTestParams>(info.param).height);
});
@@ -472,10 +471,10 @@
Combine(
Values(
#ifdef RTC_ENABLE_H265
- webrtc::kVideoCodecH265,
+ kVideoCodecH265,
#endif
- webrtc::kVideoCodecAV1,
- webrtc::kVideoCodecVP9),
+ kVideoCodecAV1,
+ kVideoCodecVP9),
Values(
BitrateLimitsTestParams{.width = 1920,
.height = 1080,
@@ -491,8 +490,7 @@
.expected_min_bitrate_kbps{30, 121, 337},
.expected_max_bitrate_kbps{101, 257, 879}})),
[](const TestParamInfo<BitrateLimitsTest::ParamType>& info) {
- return CodecTypeToPayloadString(
- std::get<webrtc::VideoCodecType>(info.param)) +
+ return CodecTypeToPayloadString(std::get<VideoCodecType>(info.param)) +
std::to_string(
std::get<BitrateLimitsTestParams>(info.param).height);
});
@@ -506,7 +504,7 @@
const size_t kMaxLayers = 3;
std::vector<VideoStream> streams =
GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
- !kScreenshare, true, trials, webrtc::kVideoCodecH265);
+ !kScreenshare, true, trials, kVideoCodecH265);
ASSERT_THAT(streams, SizeIs(kMaxLayers));
for (size_t i = 0; i < streams.size(); ++i) {
diff --git a/video/corruption_detection/frame_instrumentation_generator_unittest.cc b/video/corruption_detection/frame_instrumentation_generator_unittest.cc
index d4362c0..fff4cb4 100644
--- a/video/corruption_detection/frame_instrumentation_generator_unittest.cc
+++ b/video/corruption_detection/frame_instrumentation_generator_unittest.cc
@@ -685,7 +685,7 @@
VideoCodecType::kVideoCodecVP8);
bool frames_destroyed[4] = {};
- class TestBuffer : public webrtc::I420Buffer {
+ class TestBuffer : public I420Buffer {
public:
TestBuffer(int width, int height, bool* frame_destroyed_indicator)
: I420Buffer(width, height),
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index d327a76..2f6ec09 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -327,7 +327,7 @@
TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
// If these fields trial are on, we get lower bitrates than expected by this
// test, due to the packetization overhead and encoder pushback.
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
std::string(field_trial::GetFieldTrialString()) +
"WebRTC-VideoRateControl/bitrate_adjuster:false/");
class EncoderRateStatsTest : public test::EndToEndTest,
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 a8503d9..786535a 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -228,7 +228,7 @@
};
TEST_P(ResolutionBitrateLimitsTest, LimitsApplied) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:921600,"
"min_start_bitrate_bps:0,"
@@ -272,7 +272,7 @@
}
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
OneStreamLimitsAppliedForOneSpatialLayer) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:921600,"
"min_start_bitrate_bps:0,"
@@ -291,7 +291,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
OneStreamLimitsNotAppliedForMultipleSpatialLayers) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -324,7 +324,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, IntersectionApplied) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:921600,"
"min_start_bitrate_bps:0,"
@@ -343,7 +343,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedMiddleActive) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -360,7 +360,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, EncodingMinMaxBitrateAppliedMiddleActive) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -383,7 +383,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, MinBitrateNotAboveEncodingMax) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -404,7 +404,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, MaxBitrateNotBelowEncodingMin) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -464,7 +464,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedHighestActive) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -481,7 +481,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, EncodingMinMaxBitrateAppliedHighestActive) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -506,7 +506,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, LimitsNotAppliedLowestActive) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -527,7 +527,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
LimitsAppliedForVp9OneSpatialLayer) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -547,7 +547,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
LimitsNotAppliedForVp9MultipleSpatialLayers) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -570,7 +570,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
OneStreamLimitsAppliedForAv1OneSpatialLayer) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:921600,"
"min_start_bitrate_bps:0,"
@@ -589,7 +589,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
LimitsAppliedForAv1SingleSpatialLayer) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -609,7 +609,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
EncodingMinMaxBitrateAppliedForAv1SingleSpatialLayer) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:921600,"
"min_start_bitrate_bps:0,"
@@ -631,7 +631,7 @@
TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
LimitsNotAppliedForAv1MultipleSpatialLayers) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
@@ -653,7 +653,7 @@
}
TEST_P(ResolutionBitrateLimitsTest, LimitsNotAppliedSimulcast) {
- webrtc::test::ScopedFieldTrials field_trials(
+ test::ScopedFieldTrials field_trials(
"WebRTC-GetEncoderInfoOverride/"
"frame_size_pixels:230400|921600,"
"min_start_bitrate_bps:0|0,"
diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc
index 712d4a8..1e0f1d7 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -362,7 +362,7 @@
// to wait for a second for periodic Sender Report.
rtcp::RapidResyncRequest force_send_sr_back_request;
Buffer packet = force_send_sr_back_request.Build();
- static_cast<webrtc::Transport*>(receive_transport_.get())
+ static_cast<Transport*>(receive_transport_.get())
->SendRtcp(packet, /*packet_options=*/{});
}
CreateFrameGeneratorCapturer(30, 1280, 720);
diff --git a/video/frame_cadence_adapter_unittest.cc b/video/frame_cadence_adapter_unittest.cc
index b40171e..285b917 100644
--- a/video/frame_cadence_adapter_unittest.cc
+++ b/video/frame_cadence_adapter_unittest.cc
@@ -1295,7 +1295,7 @@
TEST_F(ZeroHertzQueueOverloadTest,
QueueOverloadIsDisabledForZeroHerzWhenKillSwitchIsEnabled) {
- webrtc::test::ScopedKeyValueConfig field_trials(
+ test::ScopedKeyValueConfig field_trials(
field_trials_, "WebRTC-ZeroHertzQueueOverload/Disabled/");
adapter_.reset();
adapter_ = CreateAdapter(field_trials, time_controller_.GetClock());
diff --git a/video/frame_decode_timing.cc b/video/frame_decode_timing.cc
index 04b8e22..9871ba9 100644
--- a/video/frame_decode_timing.cc
+++ b/video/frame_decode_timing.cc
@@ -22,8 +22,7 @@
namespace webrtc {
-FrameDecodeTiming::FrameDecodeTiming(Clock* clock,
- webrtc::VCMTiming const* timing)
+FrameDecodeTiming::FrameDecodeTiming(Clock* clock, VCMTiming const* timing)
: clock_(clock), timing_(timing) {
RTC_DCHECK(clock_);
RTC_DCHECK(timing_);
diff --git a/video/frame_decode_timing_unittest.cc b/video/frame_decode_timing_unittest.cc
index e4359b5..da7a098 100644
--- a/video/frame_decode_timing_unittest.cc
+++ b/video/frame_decode_timing_unittest.cc
@@ -35,10 +35,10 @@
namespace {
-class FakeVCMTiming : public webrtc::VCMTiming {
+class FakeVCMTiming : public VCMTiming {
public:
explicit FakeVCMTiming(Clock* clock, const FieldTrialsView& field_trials)
- : webrtc::VCMTiming(clock, field_trials) {}
+ : VCMTiming(clock, field_trials) {}
Timestamp RenderTime(uint32_t frame_timestamp, Timestamp now) const override {
RTC_DCHECK(render_time_map_.contains(frame_timestamp));
diff --git a/video/frame_encode_metadata_writer_unittest.cc b/video/frame_encode_metadata_writer_unittest.cc
index bb584b8..4580caa 100644
--- a/video/frame_encode_metadata_writer_unittest.cc
+++ b/video/frame_encode_metadata_writer_unittest.cc
@@ -386,8 +386,7 @@
bitrate_allocation.SetBitrate(0, 0, 500000);
encode_timer.OnSetRates(bitrate_allocation, 30);
- webrtc::ColorSpace color_space =
- CreateTestColorSpace(/*with_hdr_metadata=*/true);
+ ColorSpace color_space = CreateTestColorSpace(/*with_hdr_metadata=*/true);
image.SetRtpTimestamp(static_cast<uint32_t>(kTimestampMs * 90));
VideoFrame frame = VideoFrame::Builder()
.set_timestamp_ms(kTimestampMs)
diff --git a/video/full_stack_tests.cc b/video/full_stack_tests.cc
index 8245e6f..f8c809c 100644
--- a/video/full_stack_tests.cc
+++ b/video/full_stack_tests.cc
@@ -978,7 +978,7 @@
#if !defined(WEBRTC_MAC)
TEST(FullStackTest, Vp9ksvc_3sl_High) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
auto fixture = CreateVideoQualityTestFixture();
ParamsWithLogging simulcast;
@@ -993,7 +993,7 @@
}
TEST(FullStackTest, Vp9ksvc_3sl_Low) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
auto fixture = CreateVideoQualityTestFixture();
ParamsWithLogging simulcast;
@@ -1008,7 +1008,7 @@
}
TEST(FullStackTest, Vp9ksvc_3sl_Low_Bw_Limited) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
auto fixture = CreateVideoQualityTestFixture();
ParamsWithLogging simulcast;
@@ -1024,7 +1024,7 @@
}
TEST(FullStackTest, Vp9ksvc_3sl_Medium_Network_Restricted) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
auto fixture = CreateVideoQualityTestFixture();
ParamsWithLogging simulcast;
@@ -1042,7 +1042,7 @@
// TODO(webrtc:9722): Remove when experiment is cleaned up.
TEST(FullStackTest, Vp9ksvc_3sl_Medium_Network_Restricted_Trusted_Rate) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
auto fixture = CreateVideoQualityTestFixture();
ParamsWithLogging simulcast;
@@ -1087,7 +1087,7 @@
simulcast.ss[0] = {
streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(),
true};
- webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(
+ test::ScopedFieldTrials override_trials(AppendFieldTrials(
"WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/"));
fixture->RunWithAnalyzer(simulcast);
}
diff --git a/video/pc_full_stack_tests.cc b/video/pc_full_stack_tests.cc
index 841f961..f0c4c0e 100644
--- a/video/pc_full_stack_tests.cc
+++ b/video/pc_full_stack_tests.cc
@@ -39,14 +39,14 @@
namespace webrtc {
-using ::webrtc::webrtc_pc_e2e::AudioConfig;
-using ::webrtc::webrtc_pc_e2e::EmulatedSFUConfig;
-using ::webrtc::webrtc_pc_e2e::PeerConfigurer;
-using ::webrtc::webrtc_pc_e2e::RunParams;
-using ::webrtc::webrtc_pc_e2e::ScreenShareConfig;
-using ::webrtc::webrtc_pc_e2e::VideoCodecConfig;
-using ::webrtc::webrtc_pc_e2e::VideoConfig;
-using ::webrtc::webrtc_pc_e2e::VideoSimulcastConfig;
+using webrtc_pc_e2e::AudioConfig;
+using webrtc_pc_e2e::EmulatedSFUConfig;
+using webrtc_pc_e2e::PeerConfigurer;
+using webrtc_pc_e2e::RunParams;
+using webrtc_pc_e2e::ScreenShareConfig;
+using webrtc_pc_e2e::VideoCodecConfig;
+using webrtc_pc_e2e::VideoConfig;
+using webrtc_pc_e2e::VideoSimulcastConfig;
namespace {
@@ -1235,7 +1235,7 @@
#if defined(RTC_ENABLE_VP9)
TEST(PCFullStackTest, Pc_Screenshare_Slides_Vp9_3sl_High_Fps) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
"Enabled,inter_layer_pred_mode:on/"));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1269,7 +1269,7 @@
}
TEST(PCFullStackTest, Pc_Vp9svc_3sl_High) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
"Enabled,inter_layer_pred_mode:on/"));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1302,7 +1302,7 @@
}
TEST(PCFullStackTest, Pc_Vp9svc_3sl_Low) {
- webrtc::test::ScopedFieldTrials override_trials(
+ test::ScopedFieldTrials override_trials(
AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
"Enabled,inter_layer_pred_mode:on/"));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1434,7 +1434,7 @@
#define MAYBE_Pc_Simulcast_HD_High Pc_Simulcast_HD_High
#endif
TEST(PCFullStackTest, MAYBE_Pc_Simulcast_HD_High) {
- webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(
+ test::ScopedFieldTrials override_trials(AppendFieldTrials(
"WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/"));
std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
CreateNetworkEmulationManager();
diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc
index 22d46e4..b89ae42 100644
--- a/video/receive_statistics_proxy.cc
+++ b/video/receive_statistics_proxy.cc
@@ -614,7 +614,7 @@
VideoContentType content_type,
VideoFrameType frame_type) {
TimeDelta processing_delay = TimeDelta::Zero();
- webrtc::Timestamp current_time = clock_->CurrentTime();
+ Timestamp current_time = clock_->CurrentTime();
// TODO(bugs.webrtc.org/13984): some tests do not fill packet_infos().
TimeDelta assembly_time = TimeDelta::Zero();
if (frame.packet_infos().size() > 0) {
diff --git a/video/receive_statistics_proxy_unittest.cc b/video/receive_statistics_proxy_unittest.cc
index a198cd6..5e06231 100644
--- a/video/receive_statistics_proxy_unittest.cc
+++ b/video/receive_statistics_proxy_unittest.cc
@@ -128,7 +128,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesFramesDecoded) {
EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (uint32_t i = 1; i <= 3; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -141,7 +141,7 @@
const Frequency kFps = Frequency::Hertz(20);
const int kRequiredSamples =
TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -159,7 +159,7 @@
const Frequency kFps = Frequency::Hertz(20);
const int kRequiredSamples =
TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kRequiredSamples - 1; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -174,7 +174,7 @@
TEST_F(ReceiveStatisticsProxyTest,
OnDecodedFrameWithQpDoesNotResetFramesDecodedOrTotalDecodeTime) {
EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
TimeDelta expected_total_decode_time = TimeDelta::Zero();
unsigned int expected_frames_decoded = 0;
for (uint32_t i = 1; i <= 3; ++i) {
@@ -204,7 +204,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesProcessingDelay) {
const TimeDelta kProcessingDelay = TimeDelta::Millis(10);
EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
TimeDelta expected_total_processing_delay = TimeDelta::Zero();
unsigned int expected_frames_decoded = 0;
// We set receive time fixed and increase the clock by 10ms
@@ -242,7 +242,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesAssemblyTime) {
const TimeDelta kAssemblyTime = TimeDelta::Millis(7);
EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
TimeDelta expected_total_assembly_time = TimeDelta::Zero();
unsigned int expected_frames_decoded = 0;
unsigned int expected_frames_assembled_from_multiple_packets = 0;
@@ -316,7 +316,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesQpSum) {
EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -329,7 +329,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesTotalDecodeTime) {
EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Millis(4),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -343,7 +343,7 @@
TEST_F(ReceiveStatisticsProxyTest, ReportsContentType) {
const std::string kRealtimeString("realtime");
const std::string kScreenshareString("screen");
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
EXPECT_EQ(kRealtimeString, videocontenttypehelpers::ToString(
statistics_proxy_->GetStats().content_type));
statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
@@ -359,7 +359,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, ReportsMaxInterframeDelay) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
const TimeDelta kInterframeDelay1 = TimeDelta::Millis(100);
const TimeDelta kInterframeDelay2 = TimeDelta::Millis(200);
const TimeDelta kInterframeDelay3 = TimeDelta::Millis(100);
@@ -390,7 +390,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, ReportInterframeDelayInWindow) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
const TimeDelta kInterframeDelay1 = TimeDelta::Millis(900);
const TimeDelta kInterframeDelay2 = TimeDelta::Millis(750);
const TimeDelta kInterframeDelay3 = TimeDelta::Millis(700);
@@ -428,7 +428,7 @@
EXPECT_EQ(0u, stats.freeze_count);
EXPECT_FALSE(stats.total_freezes_duration_ms);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (size_t i = 0; i < VideoQualityObserver::kMinFrameSamplesToDetectFreeze;
++i) {
time_controller_.AdvanceTime(TimeDelta::Millis(30));
@@ -449,7 +449,7 @@
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnRenderedFrame(MetaData(frame));
// Pause.
@@ -467,7 +467,7 @@
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
// Pause -> Frame -> Pause
time_controller_.AdvanceTime(TimeDelta::Seconds(5));
@@ -489,7 +489,7 @@
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0.0, stats.total_inter_frame_delay);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
// Emulate delay before first frame is rendered. This is needed to ensure
// that frame duration only covers time since first frame is rendered and
@@ -508,7 +508,7 @@
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0.0, stats.total_squared_inter_frame_delay);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i <= 10; ++i) {
time_controller_.AdvanceTime(TimeDelta::Millis(30));
statistics_proxy_->OnRenderedFrame(MetaData(frame));
@@ -522,7 +522,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpQpSumWontExist) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -531,7 +531,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpResetsQpSum) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -545,7 +545,7 @@
TEST_F(ReceiveStatisticsProxyTest, OnRenderedFrameIncreasesFramesRendered) {
EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_rendered);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (uint32_t i = 1; i <= 3; ++i) {
statistics_proxy_->OnRenderedFrame(MetaData(frame));
EXPECT_EQ(i, statistics_proxy_->GetStats().frames_rendered);
@@ -695,7 +695,7 @@
TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
const int kKeyFrames = 3;
const int kDeltaFrames = 22;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kKeyFrames; i++) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
@@ -774,7 +774,7 @@
time_controller_.AdvanceTime(kLifetime);
// Need at least one decoded frame to report stream lifetime.
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnCompleteFrame(true, 1000, VideoContentType::UNSPECIFIED);
statistics_proxy_->OnDecodedFrame(
frame, std::nullopt, TimeDelta::Millis(1000),
@@ -920,7 +920,7 @@
KeyFrameHistogramNotUpdatedForTooFewSamples) {
const bool kIsKeyFrame = false;
const int kFrameSizeBytes = 1000;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples - 1; ++i) {
statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
@@ -945,7 +945,7 @@
KeyFrameHistogramUpdatedForMinRequiredSamples) {
const bool kIsKeyFrame = false;
const int kFrameSizeBytes = 1000;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
@@ -970,7 +970,7 @@
TEST_F(ReceiveStatisticsProxyTest, KeyFrameHistogramIsUpdated) {
const int kFrameSizeBytes = 1000;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
@@ -1058,7 +1058,7 @@
TEST_F(ReceiveStatisticsProxyTest, DoesNotReportStaleFramerates) {
const Frequency kDefaultFps = Frequency::Hertz(30);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kDefaultFps.hertz(); ++i) {
// Since OnRenderedFrame is never called the fps in each sample will be 0,
@@ -1137,7 +1137,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, ZeroDelayReportedIfFrameNotDelayed) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -1160,7 +1160,7 @@
TEST_F(ReceiveStatisticsProxyTest,
DelayedFrameHistogramsAreNotUpdatedIfMinRuntimeHasNotPassed) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -1182,7 +1182,7 @@
TEST_F(ReceiveStatisticsProxyTest,
DelayedFramesHistogramsAreNotUpdatedIfNoRenderedFrames) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -1199,7 +1199,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, DelayReportedIfFrameIsDelayed) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -1224,7 +1224,7 @@
}
TEST_F(ReceiveStatisticsProxyTest, AverageDelayOfDelayedFramesIsReported) {
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
VideoContentType::UNSPECIFIED,
VideoFrameType::kVideoFrameKey);
@@ -1342,7 +1342,7 @@
TEST_P(ReceiveStatisticsProxyTestWithFreezeDuration, FreezeDetection) {
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(0u, stats.freeze_count);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
// Add a very long frame. This is need to verify that average frame
// duration, which is supposed to be calculated as mean of durations of
@@ -1364,9 +1364,9 @@
class ReceiveStatisticsProxyTestWithContent
: public ReceiveStatisticsProxyTest,
- public ::testing::WithParamInterface<webrtc::VideoContentType> {
+ public ::testing::WithParamInterface<VideoContentType> {
protected:
- const webrtc::VideoContentType content_type_{GetParam()};
+ const VideoContentType content_type_{GetParam()};
};
INSTANTIATE_TEST_SUITE_P(ContentTypes,
@@ -1376,7 +1376,7 @@
TEST_P(ReceiveStatisticsProxyTestWithContent, InterFrameDelaysAreReported) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1413,7 +1413,7 @@
InterFrameDelaysPercentilesAreReported) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
const int kLastFivePercentsSamples = kMinRequiredSamples * 5 / 100;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i <= kMinRequiredSamples - kLastFivePercentsSamples; ++i) {
time_controller_.AdvanceTime(kInterFrameDelay);
@@ -1451,7 +1451,7 @@
TEST_P(ReceiveStatisticsProxyTestWithContent,
MaxInterFrameDelayOnlyWithValidAverage) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1475,7 +1475,7 @@
TEST_P(ReceiveStatisticsProxyTestWithContent, MaxInterFrameDelayOnlyWithPause) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i <= kMinRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1563,7 +1563,7 @@
const TimeDelta kFreezeDelay = TimeDelta::Millis(200);
const TimeDelta kCallDuration =
kMinRequiredSamples * kInterFrameDelay + kFreezeDelay;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
VideoFrameMetaData meta = MetaData(frame);
@@ -1612,7 +1612,7 @@
const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
const TimeDelta kCallDuration =
kMinRequiredSamples * kFrameDuration + kFreezeDuration + kPauseDuration;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
time_controller_.AdvanceTime(kFrameDuration);
@@ -1661,7 +1661,7 @@
TEST_P(ReceiveStatisticsProxyTestWithContent, PausesAreIgnored) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i <= kMinRequiredSamples; ++i) {
VideoFrameMetaData meta = MetaData(frame);
@@ -1706,7 +1706,7 @@
TEST_P(ReceiveStatisticsProxyTestWithContent, ManyPausesAtTheBeginning) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i <= kMinRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1736,8 +1736,8 @@
TEST_P(ReceiveStatisticsProxyTestWithContent, TimeInHdReported) {
const TimeDelta kInterFrameDelay = TimeDelta::Millis(20);
- webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
- webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
+ VideoFrame frame_hd = CreateFrame(1280, 720);
+ VideoFrame frame_sd = CreateFrame(640, 360);
// HD frames.
for (int i = 0; i < kMinRequiredSamples; ++i) {
@@ -1777,7 +1777,7 @@
const TimeDelta kInterFrameDelay = TimeDelta::Millis(20);
const int kHighQp = 80;
const int kLowQp = 30;
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
// High quality frames.
for (int i = 0; i < kMinRequiredSamples; ++i) {
@@ -1821,9 +1821,9 @@
// To ensure long enough call duration.
const TimeDelta kInterFrameDelay = TimeDelta::Seconds(2);
- webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
- webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
- webrtc::VideoFrame frame_ld = CreateFrame(320, 180);
+ VideoFrame frame_hd = CreateFrame(1280, 720);
+ VideoFrame frame_sd = CreateFrame(640, 360);
+ VideoFrame frame_ld = CreateFrame(320, 180);
// Call once to pass content type.
statistics_proxy_->OnDecodedFrame(frame_hd, std::nullopt, TimeDelta::Zero(),
@@ -1854,7 +1854,7 @@
const int kLowQp = 30;
const TimeDelta kDecodeTime = TimeDelta::Millis(7);
- webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+ VideoFrame frame = CreateFrame(kWidth, kHeight);
for (int i = 0; i < kMinRequiredSamples; ++i) {
statistics_proxy_->OnDecodedFrame(frame, kLowQp, kDecodeTime, content_type_,
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index bdd2cc2..3e41758 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -393,7 +393,7 @@
void RtpVideoStreamReceiver2::AddReceiveCodec(
uint8_t payload_type,
VideoCodecType video_codec,
- const webrtc::CodecParameterMap& codec_params,
+ const CodecParameterMap& codec_params,
bool raw_payload) {
RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
if (codec_params.count(kH264FmtpSpsPpsIdrInKeyframe) > 0 ||
diff --git a/video/rtp_video_stream_receiver2_unittest.cc b/video/rtp_video_stream_receiver2_unittest.cc
index 6a8f963..3440601 100644
--- a/video/rtp_video_stream_receiver2_unittest.cc
+++ b/video/rtp_video_stream_receiver2_unittest.cc
@@ -348,7 +348,7 @@
received_packet_generator.SetColorSpace(kColorSpace);
// Prepare the receiver for VP9.
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
codec_params,
/*raw_payload=*/false);
@@ -476,7 +476,7 @@
const std::vector<uint8_t> kDeltaFramePayload = {5, 6, 7, 8, 9};
// Prepare the receiver for VP9.
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
codec_params,
/*raw_payload=*/false);
@@ -553,7 +553,7 @@
const std::vector<uint8_t> kDeltaFramePayload = {5, 6, 7, 8, 9};
// Prepare the receiver for VP9.
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
codec_params,
/*raw_payload=*/false);
@@ -799,7 +799,7 @@
TEST_P(RtpVideoStreamReceiver2TestH264, InBandSpsPps) {
constexpr int kH264PayloadType = 98;
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kH264PayloadType, kVideoCodecH264,
codec_params,
/*raw_payload=*/false);
@@ -856,7 +856,7 @@
TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) {
constexpr int kH264PayloadType = 99;
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
// Example parameter sets from https://tools.ietf.org/html/rfc3984#section-8.2
// .
codec_params.insert({kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="});
@@ -903,7 +903,7 @@
}
TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
// Forcing can be done either with field trial or codec_params.
if (!env_.field_trials().IsEnabled("WebRTC-SpsPpsIdrIsH264Keyframe")) {
codec_params.insert({kH264FmtpSpsPpsIdrInKeyframe, ""});
@@ -1063,7 +1063,7 @@
rtp_packet_slice.Parse(raw_rtp_slice.data(), raw_rtp_slice.size());
// Prepare the receiver for H264.
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kH264PayloadType, kVideoCodecH264,
codec_params, false);
rtp_video_stream_receiver_->StartReceive();
@@ -1770,7 +1770,7 @@
TEST_F(RtpVideoStreamReceiver2TestH265, H265Bitstream) {
constexpr int kH265PayloadType = 98;
- webrtc::CodecParameterMap codec_params;
+ CodecParameterMap codec_params;
rtp_video_stream_receiver_->AddReceiveCodec(kH265PayloadType, kVideoCodecH265,
codec_params,
/*raw_payload=*/false);
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 38873b4f..e6858df 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -147,7 +147,7 @@
}
std::optional<int> GetFallbackMaxPixelsIfFieldTrialEnabled(
- const webrtc::FieldTrialsView& field_trials) {
+ const FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Enabled"))
? GetFallbackMaxPixels(group.substr(7))
@@ -155,7 +155,7 @@
}
std::optional<int> GetFallbackMaxPixelsIfFieldTrialDisabled(
- const webrtc::FieldTrialsView& field_trials) {
+ const FieldTrialsView& field_trials) {
std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
return (absl::StartsWith(group, "Disabled"))
? GetFallbackMaxPixels(group.substr(8))
diff --git a/video/video_analyzer.cc b/video/video_analyzer.cc
index 94f06ee..159bd8c 100644
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@@ -78,10 +78,10 @@
namespace webrtc {
namespace {
-using ::webrtc::test::GetGlobalMetricsLogger;
-using ::webrtc::test::ImprovementDirection;
-using ::webrtc::test::Metric;
-using ::webrtc::test::Unit;
+using test::GetGlobalMetricsLogger;
+using test::ImprovementDirection;
+using test::Metric;
+using test::Unit;
constexpr TimeDelta kSendStatsPollingInterval = TimeDelta::Seconds(1);
constexpr size_t kMaxComparisons = 10;
diff --git a/video/video_loopback.cc b/video/video_loopback.cc
index b8659d1..f2ab825 100644
--- a/video/video_loopback.cc
+++ b/video/video_loopback.cc
@@ -442,9 +442,9 @@
// InitFieldTrialsFromString stores the char*, so the char array must outlive
// the application.
const std::string field_trials = absl::GetFlag(FLAGS_force_fieldtrials);
- webrtc::field_trial::InitFieldTrialsFromString(field_trials.c_str());
+ field_trial::InitFieldTrialsFromString(field_trials.c_str());
- webrtc::test::RunTest(webrtc::Loopback);
+ test::RunTest(Loopback);
return 0;
}
} // namespace webrtc
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 66a8a25..d4e1754 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -340,7 +340,7 @@
const SdpVideoFormat& format) {
std::unique_ptr<VideoDecoder> decoder;
if (format.name == "FakeCodec") {
- decoder = webrtc::FakeVideoDecoderFactory::CreateVideoDecoder();
+ decoder = FakeVideoDecoderFactory::CreateVideoDecoder();
} else {
decoder = decoder_factory_->Create(env, format);
}
@@ -644,14 +644,14 @@
const std::vector<std::string>& sl_descriptors) {
if (params->ss[video_idx].streams.empty() &&
params->ss[video_idx].infer_streams) {
- webrtc::VideoEncoder::EncoderInfo encoder_info;
- webrtc::VideoEncoderConfig encoder_config;
+ VideoEncoder::EncoderInfo encoder_info;
+ VideoEncoderConfig encoder_config;
encoder_config.codec_type =
PayloadStringToCodecType(params->video[video_idx].codec);
encoder_config.content_type =
params->screenshare[video_idx].enabled
- ? webrtc::VideoEncoderConfig::ContentType::kScreen
- : webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
+ ? VideoEncoderConfig::ContentType::kScreen
+ : VideoEncoderConfig::ContentType::kRealtimeVideo;
encoder_config.max_bitrate_bps = params->video[video_idx].max_bitrate_bps;
encoder_config.min_transmit_bitrate_bps =
params->video[video_idx].min_transmit_bps;
@@ -737,7 +737,7 @@
RTC_CHECK(num_video_streams_ > 0);
video_encoder_configs_.resize(num_video_streams_);
std::string generic_codec_name;
- webrtc::VideoEncoder::EncoderInfo encoder_info;
+ VideoEncoder::EncoderInfo encoder_info;
for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
VideoSendStream::Config config(send_transport);
config.rtp.extmap_allow_mixed = true;
@@ -1423,7 +1423,7 @@
// The real ADM requires extra initialization: setting default devices,
// setting up number of channels etc. Helper class also calls
// AudioDeviceModule::Init().
- webrtc::adm_helpers::Init(audio_device.get());
+ adm_helpers::Init(audio_device.get());
} else {
audio_device->Init();
}
@@ -1448,8 +1448,8 @@
if (params_.call.send_side_bwe) {
audio_send_config.rtp.extensions.push_back(
- webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
- kTransportSequenceNumberExtensionId));
+ RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+ kTransportSequenceNumberExtensionId));
audio_send_config.min_bitrate_bps = kOpusMinBitrateBps;
audio_send_config.max_bitrate_bps = kOpusBitrateFbBps;
// Only allow ANA when send-side BWE is enabled.
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index 3aced70..c7c1c30 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -132,11 +132,11 @@
return buffer_;
}
- std::optional<webrtc::ColorSpace> color_space() const override {
+ std::optional<ColorSpace> color_space() const override {
return color_space_;
}
- std::optional<webrtc::VideoRotation> video_rotation() const override {
+ std::optional<VideoRotation> video_rotation() const override {
return video_rotation_;
}
@@ -156,8 +156,8 @@
VideoCodecType codec_;
bool is_key_frame_;
EncodedResolution resolution_;
- std::optional<webrtc::ColorSpace> color_space_;
- std::optional<webrtc::VideoRotation> video_rotation_;
+ std::optional<ColorSpace> color_space_;
+ std::optional<VideoRotation> video_rotation_;
};
RenderResolution InitialDecoderResolution(const FieldTrialsView& field_trials) {
@@ -174,21 +174,21 @@
// Video decoder class to be used for unknown codecs. Doesn't support decoding
// but logs messages to LS_ERROR.
-class NullVideoDecoder : public webrtc::VideoDecoder {
+class NullVideoDecoder : public VideoDecoder {
public:
bool Configure(const Settings& settings) override {
RTC_LOG(LS_ERROR) << "Can't initialize NullVideoDecoder.";
return true;
}
- int32_t Decode(const webrtc::EncodedImage& input_image,
+ int32_t Decode(const EncodedImage& input_image,
int64_t render_time_ms) override {
RTC_LOG(LS_ERROR) << "The NullVideoDecoder doesn't support decoding.";
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t RegisterDecodeCompleteCallback(
- webrtc::DecodedImageCallback* callback) override {
+ DecodedImageCallback* callback) override {
RTC_LOG(LS_ERROR)
<< "Can't register decode complete callback on NullVideoDecoder.";
return WEBRTC_VIDEO_CODEC_OK;
@@ -710,7 +710,7 @@
frame_meta.decode_timestamp);
}));
- webrtc::MutexLock lock(&pending_resolution_mutex_);
+ MutexLock lock(&pending_resolution_mutex_);
if (pending_resolution_.has_value()) {
if (!pending_resolution_->empty() &&
(video_frame.width() != static_cast<int>(pending_resolution_->width) ||
@@ -729,7 +729,7 @@
}
void VideoReceiveStream2::SetFrameDecryptor(
- scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+ scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
rtp_video_stream_receiver_.SetFrameDecryptor(std::move(frame_decryptor));
}
@@ -973,7 +973,7 @@
RTC_LOG(LS_ERROR) << "About to halt recordable encoded frame output due "
"to too many buffered frames.";
- webrtc::MutexLock lock(&pending_resolution_mutex_);
+ MutexLock lock(&pending_resolution_mutex_);
if (IsKeyFrameAndUnspecifiedResolution(*frame_ptr) &&
!pending_resolution_.has_value())
pending_resolution_.emplace();
@@ -1001,7 +1001,7 @@
{
// Fish out `pending_resolution_` to avoid taking the mutex on every lap
// or dispatching under the mutex in the flush loop.
- webrtc::MutexLock lock(&pending_resolution_mutex_);
+ MutexLock lock(&pending_resolution_mutex_);
if (pending_resolution_.has_value())
pending_resolution = *pending_resolution_;
}
@@ -1134,7 +1134,7 @@
}
}
-std::vector<webrtc::RtpSource> VideoReceiveStream2::GetSources() const {
+std::vector<RtpSource> VideoReceiveStream2::GetSources() const {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
return source_tracker_.GetSources();
}
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index 61e1872..b19e001 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -257,12 +257,10 @@
video_receive_stream_ = nullptr;
}
timing_ = new VCMTiming(&env_.clock(), env_.field_trials());
- video_receive_stream_ =
- std::make_unique<webrtc::internal::VideoReceiveStream2>(
- env_, &fake_call_, kDefaultNumCpuCores, &packet_router_,
- config_.Copy(), &call_stats_, absl::WrapUnique(timing_),
- &nack_periodic_processor_,
- UseMetronome() ? &decode_sync_ : nullptr);
+ video_receive_stream_ = std::make_unique<internal::VideoReceiveStream2>(
+ env_, &fake_call_, kDefaultNumCpuCores, &packet_router_, config_.Copy(),
+ &call_stats_, absl::WrapUnique(timing_), &nack_periodic_processor_,
+ UseMetronome() ? &decode_sync_ : nullptr);
video_receive_stream_->RegisterWithTransport(
&rtp_stream_receiver_controller_);
if (state)
@@ -283,7 +281,7 @@
test::RtcpPacketParser rtcp_packet_parser_;
PacketRouter packet_router_;
RtpStreamReceiverController rtp_stream_receiver_controller_;
- std::unique_ptr<webrtc::internal::VideoReceiveStream2> video_receive_stream_;
+ std::unique_ptr<internal::VideoReceiveStream2> video_receive_stream_;
VCMTiming* timing_;
test::FakeMetronome fake_metronome_;
DecodeSynchronizer decode_sync_;
@@ -595,7 +593,7 @@
}
TEST_P(VideoReceiveStream2Test, PassesRotation) {
- const webrtc::VideoRotation kRotation = webrtc::kVideoRotation_180;
+ const VideoRotation kRotation = kVideoRotation_180;
std::unique_ptr<test::FakeEncodedFrame> test_frame =
test::FakeFrameBuilder()
.Id(0)
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 9f093f5..c0c8dff 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -228,10 +228,9 @@
const FieldTrialsView& field_trials) {
int priority_bitrate = 0;
if (PayloadStringToCodecType(codec_name) == VideoCodecType::kVideoCodecAV1) {
- webrtc::FieldTrialParameter<int> av1_priority_bitrate("bitrate", 0);
- webrtc::ParseFieldTrial(
- {&av1_priority_bitrate},
- field_trials.Lookup("WebRTC-AV1-OverridePriorityBitrate"));
+ FieldTrialParameter<int> av1_priority_bitrate("bitrate", 0);
+ ParseFieldTrial({&av1_priority_bitrate},
+ field_trials.Lookup("WebRTC-AV1-OverridePriorityBitrate"));
priority_bitrate = av1_priority_bitrate;
}
return priority_bitrate;
@@ -299,9 +298,8 @@
VideoStreamEncoder::BitrateAllocationCallbackType
GetBitrateAllocationCallbackType(const VideoSendStream::Config& config,
const FieldTrialsView& field_trials) {
- if (webrtc::RtpExtension::FindHeaderExtensionByUri(
- config.rtp.extensions,
- webrtc::RtpExtension::kVideoLayersAllocationUri,
+ if (RtpExtension::FindHeaderExtensionByUri(
+ config.rtp.extensions, RtpExtension::kVideoLayersAllocationUri,
config.crypto_options.srtp.enable_encrypted_rtp_header_extensions
? RtpExtension::Filter::kPreferEncryptedExtension
: RtpExtension::Filter::kDiscardEncryptedExtension)) {
@@ -349,7 +347,7 @@
VideoStreamEncoder::BitrateAllocationCallbackType
bitrate_allocation_callback_type,
Metronome* metronome,
- webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) {
+ VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) {
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue =
env.task_queue_factory().CreateTaskQueue(
"EncoderQueue", TaskQueueFactory::Priority::NORMAL);
@@ -542,7 +540,7 @@
}
void VideoSendStreamImpl::SetSource(
- VideoSourceInterface<webrtc::VideoFrame>* source,
+ VideoSourceInterface<VideoFrame>* source,
const DegradationPreference& degradation_preference) {
RTC_DCHECK_RUN_ON(&thread_checker_);
video_stream_encoder_->SetSource(source, degradation_preference);
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 7a11b78..f0023f1 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -126,8 +126,7 @@
MOCK_METHOD(void, SetEncodingData, (size_t, size_t, size_t), (override));
MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
GetSentRtpPacketInfos,
- (uint32_t ssrc,
- webrtc::ArrayView<const uint16_t> sequence_numbers),
+ (uint32_t ssrc, ArrayView<const uint16_t> sequence_numbers),
(const, override));
MOCK_METHOD(void, SetFecAllowed, (bool fec_allowed), (override));
@@ -217,7 +216,7 @@
protected:
GlobalSimulatedTimeController time_controller_;
- webrtc::test::ScopedKeyValueConfig field_trials_;
+ test::ScopedKeyValueConfig field_trials_;
NiceMock<MockTransport> transport_;
NiceMock<MockRtpTransportControllerSend> transport_controller_;
NiceMock<MockBitrateAllocator> bitrate_allocator_;
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 69e0c8e..d73601e 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -126,7 +126,7 @@
namespace test {
class VideoSendStreamPeer {
public:
- explicit VideoSendStreamPeer(webrtc::VideoSendStream* base_class_stream)
+ explicit VideoSendStreamPeer(VideoSendStream* base_class_stream)
: internal_stream_(
static_cast<internal::VideoSendStreamImpl*>(base_class_stream)) {}
std::optional<float> GetPacingFactorOverride() const {
@@ -1754,8 +1754,8 @@
}
private:
- webrtc::SequenceChecker module_process_thread_;
- webrtc::SequenceChecker task_queue_thread_;
+ SequenceChecker module_process_thread_;
+ SequenceChecker task_queue_thread_;
TaskQueueBase* const task_queue_;
RtpHeaderExtensionMap extensions_;
Call* call_ RTC_GUARDED_BY(task_queue_thread_);
@@ -1771,7 +1771,7 @@
static const int kStartBitrateBps = 300000;
static const int kRelayBandwidthCapBps = 800000;
static const int kMinPacketsToSend = 100;
- webrtc::test::ScopedKeyValueConfig field_trials(
+ test::ScopedKeyValueConfig field_trials(
field_trials_, "WebRTC-Bwe-NetworkRouteConstraints/relay_cap:" +
std::to_string(kRelayBandwidthCapBps) + "bps/");
@@ -1858,8 +1858,8 @@
}
private:
- webrtc::SequenceChecker module_process_thread_;
- webrtc::SequenceChecker task_queue_thread_;
+ SequenceChecker module_process_thread_;
+ SequenceChecker task_queue_thread_;
TaskQueueBase* const task_queue_;
Call* call_ RTC_GUARDED_BY(task_queue_thread_);
int packets_sent_ RTC_GUARDED_BY(task_queue_thread_);
@@ -2049,11 +2049,11 @@
}
private:
- webrtc::SequenceChecker task_queue_thread_;
+ SequenceChecker task_queue_thread_;
Call* call_ RTC_GUARDED_BY(task_queue_thread_) = nullptr;
VideoSendStream::Config send_stream_config_{nullptr};
VideoEncoderConfig encoder_config_;
- webrtc::SequenceChecker module_process_thread_;
+ SequenceChecker module_process_thread_;
uint32_t packets_sent_ RTC_GUARDED_BY(task_queue_thread_) = 0;
bool running_without_padding_ RTC_GUARDED_BY(task_queue_thread_);
T* const stream_resetter_;
@@ -2729,7 +2729,7 @@
// TODO(bugs.webrtc.org/12058): If these fields trial are on, we get lower
// bitrates than expected by this test, due to encoder pushback and subtracted
// overhead.
- webrtc::test::ScopedKeyValueConfig field_trials(
+ test::ScopedKeyValueConfig field_trials(
field_trials_, "WebRTC-VideoRateControl/bitrate_adjuster:false/");
class EncoderBitrateThresholdObserver : public test::SendTest,
@@ -2919,11 +2919,11 @@
int num_rate_allocator_creations_;
int num_encoder_initializations_;
- webrtc::Call* call_;
- webrtc::VideoSendStream* send_stream_;
+ Call* call_;
+ VideoSendStream* send_stream_;
test::VideoEncoderProxyFactory encoder_factory_;
std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
- webrtc::VideoEncoderConfig encoder_config_;
+ VideoEncoderConfig encoder_config_;
} test(env(), task_queue());
RunBaseTest(&test);
@@ -3380,7 +3380,7 @@
test::FunctionVideoEncoderFactory encoder_factory_;
const Vp9TestParams params_;
VideoCodecVP9 vp9_settings_;
- webrtc::VideoEncoderConfig encoder_config_;
+ VideoEncoderConfig encoder_config_;
bool last_packet_marker_ = false;
std::optional<uint16_t> last_packet_sequence_number_;
std::optional<uint32_t> last_packet_timestamp_;
@@ -3979,7 +3979,7 @@
internal_send_peer.GetPacingFactorOverride().value_or(0.0f);
float expected_pacing_factor = 1.1; // Strict pacing factor.
VideoSendStream::Stats stats = send_stream_->GetStats();
- if (stats.content_type == webrtc::VideoContentType::SCREENSHARE) {
+ if (stats.content_type == VideoContentType::SCREENSHARE) {
expected_pacing_factor = 1.0f; // Currently used pacing factor in ALR.
}
@@ -4123,7 +4123,7 @@
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
- webrtc::VideoEncoder::EncoderInfo encoder_info;
+ VideoEncoder::EncoderInfo encoder_info;
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;
send_config->rtp.payload_type =
diff --git a/video/video_source_sink_controller_unittest.cc b/video/video_source_sink_controller_unittest.cc
index bc4d263..603c726 100644
--- a/video/video_source_sink_controller_unittest.cc
+++ b/video/video_source_sink_controller_unittest.cc
@@ -43,13 +43,9 @@
MOCK_METHOD(void,
AddOrUpdateSink,
- (webrtc::VideoSinkInterface<VideoFrame>*,
- const webrtc::VideoSinkWants&),
+ (VideoSinkInterface<VideoFrame>*, const VideoSinkWants&),
(override));
- MOCK_METHOD(void,
- RemoveSink,
- (webrtc::VideoSinkInterface<VideoFrame>*),
- (override));
+ MOCK_METHOD(void, RemoveSink, (VideoSinkInterface<VideoFrame>*), (override));
MOCK_METHOD(void, RequestRefreshFrame, (), (override));
};
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 8623944..212108e 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -346,9 +346,9 @@
encoder_config.VP9().interLayerPred == InterLayerPredMode::kOn;
layers_allocation.resolution_and_frame_rate_is_valid = true;
- std::vector<DataRate> aggregated_spatial_bitrate(
- webrtc::kMaxTemporalStreams, DataRate::Zero());
- for (int si = 0; si < webrtc::kMaxSpatialLayers; ++si) {
+ std::vector<DataRate> aggregated_spatial_bitrate(kMaxTemporalStreams,
+ DataRate::Zero());
+ for (int si = 0; si < kMaxSpatialLayers; ++si) {
layers_allocation.resolution_and_frame_rate_is_valid = true;
if (!target_bitrate.IsSpatialLayerUsed(si) ||
target_bitrate.GetSpatialLayerSum(si) == 0) {
@@ -692,10 +692,9 @@
const VideoStreamEncoderSettings& settings,
std::unique_ptr<OveruseFrameDetector> overuse_detector,
std::unique_ptr<FrameCadenceAdapterInterface> frame_cadence_adapter,
- std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>
- encoder_queue,
+ std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue,
BitrateAllocationCallbackType allocation_cb_type,
- webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector)
+ VideoEncoderFactory::EncoderSelectorInterface* encoder_selector)
: env_(env),
worker_queue_(TaskQueueBase::Current()),
number_of_cores_(number_of_cores),
@@ -1012,7 +1011,7 @@
ReconfigureEncoder();
} else {
- webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
+ InvokeSetParametersCallback(callback, RTCError::OK());
}
});
}
@@ -1485,7 +1484,7 @@
stream_resource_manager_.ConfigureQualityScaler(info);
stream_resource_manager_.ConfigureBandwidthQualityScaler(info);
- webrtc::RTCError encoder_configuration_result = webrtc::RTCError::OK();
+ RTCError encoder_configuration_result = RTCError::OK();
if (!encoder_initialized_) {
RTC_LOG(LS_WARNING) << "Failed to initialize "
@@ -1497,14 +1496,13 @@
RequestEncoderSwitch();
} else {
encoder_configuration_result =
- webrtc::RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
+ RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
}
}
if (!encoder_configuration_callbacks_.empty()) {
for (auto& callback : encoder_configuration_callbacks_) {
- webrtc::InvokeSetParametersCallback(callback,
- encoder_configuration_result);
+ InvokeSetParametersCallback(callback, encoder_configuration_result);
}
encoder_configuration_callbacks_.clear();
}
