Make requested_resolution_alignment of webrtc::EncoderInfo as uint32_t.
At the same time, proper names of some parameters are refactored in SimulcastEncoderAdapter.
Bug: None
Change-Id: Ia036e3f362d1394e90aa26b79953c1ffe75e2fe0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/284961
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Chunbo Hua <chunbo.hua@intel.com>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38870}
diff --git a/api/video_codecs/video_encoder.h b/api/video_codecs/video_encoder.h
index 30ec58e..395a87e 100644
--- a/api/video_codecs/video_encoder.h
+++ b/api/video_codecs/video_encoder.h
@@ -174,7 +174,7 @@
// For example: With I420, this value would be a multiple of 2.
// Note that this field is unrelated to any horizontal or vertical stride
// requirements the encoder has on the incoming video frame buffers.
- int requested_resolution_alignment;
+ uint32_t requested_resolution_alignment;
// Same as above but if true, each simulcast layer should also be divisible
// by `requested_resolution_alignment`.
diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index f1535e3..3a73a4a 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -86,22 +86,24 @@
return active_streams_count;
}
-int VerifyCodec(const webrtc::VideoCodec* inst) {
- if (inst == nullptr) {
+int VerifyCodec(const webrtc::VideoCodec* codec_settings) {
+ if (codec_settings == nullptr) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
- if (inst->maxFramerate < 1) {
+ if (codec_settings->maxFramerate < 1) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
// allow zero to represent an unspecified maxBitRate
- if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) {
+ if (codec_settings->maxBitrate > 0 &&
+ codec_settings->startBitrate > codec_settings->maxBitrate) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
- if (inst->width <= 1 || inst->height <= 1) {
+ if (codec_settings->width <= 1 || codec_settings->height <= 1) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
- if (inst->codecType == webrtc::kVideoCodecVP8 &&
- inst->VP8().automaticResizeOn && CountActiveStreams(*inst) > 1) {
+ if (codec_settings->codecType == webrtc::kVideoCodecVP8 &&
+ codec_settings->VP8().automaticResizeOn &&
+ CountActiveStreams(*codec_settings) > 1) {
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
return WEBRTC_VIDEO_CODEC_OK;
@@ -299,7 +301,7 @@
}
int SimulcastEncoderAdapter::InitEncode(
- const VideoCodec* inst,
+ const VideoCodec* codec_settings,
const VideoEncoder::Settings& settings) {
RTC_DCHECK_RUN_ON(&encoder_queue_);
@@ -307,15 +309,15 @@
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
- int ret = VerifyCodec(inst);
+ int ret = VerifyCodec(codec_settings);
if (ret < 0) {
return ret;
}
Release();
- codec_ = *inst;
- total_streams_count_ = CountAllStreams(*inst);
+ codec_ = *codec_settings;
+ total_streams_count_ = CountAllStreams(*codec_settings);
// TODO(ronghuawu): Remove once this is handled in LibvpxVp8Encoder.
if (codec_.qpMax < kDefaultMinQp) {
@@ -349,7 +351,7 @@
// (active_streams_count >= 1). SEA creates N=active_streams_count encoders
// and configures each to produce a single stream.
- int active_streams_count = CountActiveStreams(*inst);
+ int active_streams_count = CountActiveStreams(*codec_settings);
// If we only have a single active layer it is better to create an encoder
// with only one configured layer than creating it with all-but-one disabled
// layers because that way we control scaling.
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index 76ab152..15a8aeb 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -176,7 +176,7 @@
}
void set_init_encode_return_value(int32_t value);
void set_requested_resolution_alignments(
- std::vector<int> requested_resolution_alignments) {
+ std::vector<uint32_t> requested_resolution_alignments) {
requested_resolution_alignments_ = requested_resolution_alignments;
}
void set_supports_simulcast(bool supports_simulcast) {
@@ -195,7 +195,7 @@
std::vector<MockVideoEncoder*> encoders_;
std::vector<const char*> encoder_names_;
// Keep number of entries in sync with `kMaxSimulcastStreams`.
- std::vector<int> requested_resolution_alignments_ = {1, 1, 1};
+ std::vector<uint32_t> requested_resolution_alignments_ = {1, 1, 1};
bool supports_simulcast_ = false;
std::vector<VideoEncoder::ResolutionBitrateLimits> resolution_bitrate_limits_;
};
@@ -284,7 +284,8 @@
scaling_settings_ = settings;
}
- void set_requested_resolution_alignment(int requested_resolution_alignment) {
+ void set_requested_resolution_alignment(
+ uint32_t requested_resolution_alignment) {
requested_resolution_alignment_ = requested_resolution_alignment;
}
@@ -332,7 +333,7 @@
bool supports_native_handle_ = false;
std::string implementation_name_ = "unknown";
VideoEncoder::ScalingSettings scaling_settings_;
- int requested_resolution_alignment_ = 1;
+ uint32_t requested_resolution_alignment_ = 1;
bool apply_alignment_to_all_simulcast_layers_ = false;
bool has_trusted_rate_controller_ = false;
bool is_hardware_accelerated_ = false;
@@ -1396,7 +1397,7 @@
helper_->factory()->set_requested_resolution_alignments({2, 4, 7});
EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
- EXPECT_EQ(adapter_->GetEncoderInfo().requested_resolution_alignment, 28);
+ EXPECT_EQ(adapter_->GetEncoderInfo().requested_resolution_alignment, 28u);
}
TEST_F(TestSimulcastEncoderAdapterFake,
@@ -1467,7 +1468,7 @@
EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
ASSERT_EQ(3u, helper_->factory()->encoders().size());
- EXPECT_EQ(8, adapter_->GetEncoderInfo().requested_resolution_alignment);
+ EXPECT_EQ(8u, adapter_->GetEncoderInfo().requested_resolution_alignment);
EXPECT_TRUE(
adapter_->GetEncoderInfo().apply_alignment_to_all_simulcast_layers);
EXPECT_TRUE(adapter_->GetEncoderInfo().resolution_bitrate_limits.empty());
@@ -1490,7 +1491,7 @@
EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
ASSERT_EQ(1u, helper_->factory()->encoders().size());
- EXPECT_EQ(9, adapter_->GetEncoderInfo().requested_resolution_alignment);
+ EXPECT_EQ(9u, adapter_->GetEncoderInfo().requested_resolution_alignment);
EXPECT_FALSE(
adapter_->GetEncoderInfo().apply_alignment_to_all_simulcast_layers);
EXPECT_THAT(
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index 8cf7617..c5a8b65 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -640,7 +640,7 @@
EXPECT_FALSE(info.is_hardware_accelerated);
EXPECT_TRUE(info.supports_simulcast);
EXPECT_EQ(info.implementation_name, "libvpx");
- EXPECT_EQ(info.requested_resolution_alignment, 1);
+ EXPECT_EQ(info.requested_resolution_alignment, 1u);
EXPECT_THAT(info.preferred_pixel_formats,
testing::UnorderedElementsAre(VideoFrameBuffer::Type::kNV12,
VideoFrameBuffer::Type::kI420));
@@ -655,7 +655,7 @@
LibvpxVp8Encoder encoder((std::unique_ptr<LibvpxInterface>(vpx)),
VP8Encoder::Settings());
- EXPECT_EQ(encoder.GetEncoderInfo().requested_resolution_alignment, 10);
+ EXPECT_EQ(encoder.GetEncoderInfo().requested_resolution_alignment, 10u);
EXPECT_FALSE(
encoder.GetEncoderInfo().apply_alignment_to_all_simulcast_layers);
EXPECT_TRUE(encoder.GetEncoderInfo().resolution_bitrate_limits.empty());
diff --git a/rtc_base/experiments/encoder_info_settings.cc b/rtc_base/experiments/encoder_info_settings.cc
index 8af52d6..5f0bf2d 100644
--- a/rtc_base/experiments/encoder_info_settings.cc
+++ b/rtc_base/experiments/encoder_info_settings.cc
@@ -188,7 +188,7 @@
resolution_bitrate_limits_ = ToResolutionBitrateLimits(bitrate_limits.Get());
}
-absl::optional<int> EncoderInfoSettings::requested_resolution_alignment()
+absl::optional<uint32_t> EncoderInfoSettings::requested_resolution_alignment()
const {
if (requested_resolution_alignment_ &&
requested_resolution_alignment_.Value() < 1) {
diff --git a/rtc_base/experiments/encoder_info_settings.h b/rtc_base/experiments/encoder_info_settings.h
index d450697..f4227ed 100644
--- a/rtc_base/experiments/encoder_info_settings.h
+++ b/rtc_base/experiments/encoder_info_settings.h
@@ -33,7 +33,7 @@
int max_bitrate_bps = 0; // The maximum bitrate.
};
- absl::optional<int> requested_resolution_alignment() const;
+ absl::optional<uint32_t> requested_resolution_alignment() const;
bool apply_alignment_to_all_simulcast_layers() const {
return apply_alignment_to_all_simulcast_layers_.Get();
}
@@ -62,7 +62,7 @@
explicit EncoderInfoSettings(absl::string_view name);
private:
- FieldTrialOptional<int> requested_resolution_alignment_;
+ FieldTrialOptional<uint32_t> requested_resolution_alignment_;
FieldTrialFlag apply_alignment_to_all_simulcast_layers_;
std::vector<VideoEncoder::ResolutionBitrateLimits> resolution_bitrate_limits_;
};
diff --git a/rtc_base/experiments/encoder_info_settings_unittest.cc b/rtc_base/experiments/encoder_info_settings_unittest.cc
index aabb687..929c777 100644
--- a/rtc_base/experiments/encoder_info_settings_unittest.cc
+++ b/rtc_base/experiments/encoder_info_settings_unittest.cc
@@ -38,7 +38,7 @@
"requested_resolution_alignment:2/");
SimulcastEncoderAdapterEncoderInfoSettings settings;
- EXPECT_EQ(2, settings.requested_resolution_alignment());
+ EXPECT_EQ(2u, settings.requested_resolution_alignment());
EXPECT_FALSE(settings.apply_alignment_to_all_simulcast_layers());
EXPECT_TRUE(settings.resolution_bitrate_limits().empty());
}
@@ -50,7 +50,7 @@
"apply_alignment_to_all_simulcast_layers/");
SimulcastEncoderAdapterEncoderInfoSettings settings;
- EXPECT_EQ(3, settings.requested_resolution_alignment());
+ EXPECT_EQ(3u, settings.requested_resolution_alignment());
EXPECT_TRUE(settings.apply_alignment_to_all_simulcast_layers());
EXPECT_TRUE(settings.resolution_bitrate_limits().empty());
}
@@ -94,9 +94,9 @@
"WebRTC-GetEncoderInfoOverride/requested_resolution_alignment:3/");
LibvpxVp8EncoderInfoSettings vp8_settings;
- EXPECT_EQ(2, vp8_settings.requested_resolution_alignment());
+ EXPECT_EQ(2u, vp8_settings.requested_resolution_alignment());
LibvpxVp9EncoderInfoSettings vp9_settings;
- EXPECT_EQ(3, vp9_settings.requested_resolution_alignment());
+ EXPECT_EQ(3u, vp9_settings.requested_resolution_alignment());
}
} // namespace webrtc
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index e45b2ef..1f328cc 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -1097,7 +1097,8 @@
quality_scaling_ = b;
}
- void SetRequestedResolutionAlignment(int requested_resolution_alignment) {
+ void SetRequestedResolutionAlignment(
+ uint32_t requested_resolution_alignment) {
MutexLock lock(&local_mutex_);
requested_resolution_alignment_ = requested_resolution_alignment;
}
@@ -1331,7 +1332,7 @@
int last_input_width_ RTC_GUARDED_BY(local_mutex_) = 0;
int last_input_height_ RTC_GUARDED_BY(local_mutex_) = 0;
bool quality_scaling_ RTC_GUARDED_BY(local_mutex_) = true;
- int requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1;
+ uint32_t requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1;
bool apply_alignment_to_all_simulcast_layers_ RTC_GUARDED_BY(local_mutex_) =
false;
bool is_hardware_accelerated_ RTC_GUARDED_BY(local_mutex_) = false;
@@ -2472,7 +2473,7 @@
scale_factors_(::testing::get<1>(GetParam())) {}
protected:
- const int requested_alignment_;
+ const uint32_t requested_alignment_;
const std::vector<double> scale_factors_;
};
@@ -2538,8 +2539,8 @@
EXPECT_EQ(codec.numberOfSimulcastStreams, num_streams);
// Frame size should be a multiple of the requested alignment.
for (int i = 0; i < codec.numberOfSimulcastStreams; ++i) {
- EXPECT_EQ(codec.simulcastStream[i].width % requested_alignment_, 0);
- EXPECT_EQ(codec.simulcastStream[i].height % requested_alignment_, 0);
+ EXPECT_EQ(codec.simulcastStream[i].width % requested_alignment_, 0u);
+ EXPECT_EQ(codec.simulcastStream[i].height % requested_alignment_, 0u);
// Aspect ratio should match.
EXPECT_EQ(codec.width * codec.simulcastStream[i].height,
codec.height * codec.simulcastStream[i].width);
