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

Fix max bitrate not being resptected with some HW codecs.

Browse Source 
This makes the max bitrate configured in RTP parameter to still be
respected, instead of being overridden by defaults in the case that an
encoder with untrusted QP is reconfigured (e.g. due to some adaptation).

Bug: webrtc:14914
Change-Id: I2d3ff645c069b80ec2e36887e6ce0ecd09a7ecbf
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/293944
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39357}
This commit is contained in:
Erik Språng 2023-02-17 15:12:22 +01:00 committed by WebRTC LUCI CQ
parent 262b2d8509
commit 573f546197
2 changed files with 66 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
video/video_stream_encoder.cc
View File

@ -1063,19 +1063,21 @@ void VideoStreamEncoder::ReconfigureEncoder() {
if (qp_untrusted_bitrate_limit) {
// bandwidth_quality_scaler is only used for singlecast.
if (streams.size() == 1 && encoder_config_.simulcast_layers.size() == 1) {
streams.back().min_bitrate_bps =
qp_untrusted_bitrate_limit->min_bitrate_bps;
streams.back().max_bitrate_bps =
qp_untrusted_bitrate_limit->max_bitrate_bps;
VideoStream& stream = streams.back();
stream.max_bitrate_bps =
std::min(stream.max_bitrate_bps,
qp_untrusted_bitrate_limit->max_bitrate_bps);
stream.min_bitrate_bps =
std::min(stream.max_bitrate_bps,
qp_untrusted_bitrate_limit->min_bitrate_bps);
// If it is screen share mode, the minimum value of max_bitrate should
// be greater than/equal to 1200kbps.
if (encoder_config_.content_type ==
VideoEncoderConfig::ContentType::kScreen) {
streams.back().max_bitrate_bps = std::max(
streams.back().max_bitrate_bps, kDefaultMinScreenSharebps);
stream.max_bitrate_bps =
std::max(stream.max_bitrate_bps, kDefaultMinScreenSharebps);
}
streams.back().target_bitrate_bps =
qp_untrusted_bitrate_limit->max_bitrate_bps;
stream.target_bitrate_bps = stream.max_bitrate_bps;
}
}
} else {

67
video/video_stream_encoder_unittest.cc
View File

@ -8384,7 +8384,7 @@ TEST_F(VideoStreamEncoderTest, EncoderProvideLimitsWhenQPIsNotTrusted) {
}
TEST_F(VideoStreamEncoderTest, EncoderDoesnotProvideLimitsWhenQPIsNotTrusted) {
// Set QP trusted in encoder info.
// Set QP not trusted in encoder info.
fake_encoder_.SetIsQpTrusted(false);
absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate_limit =
@ -8395,28 +8395,73 @@ TEST_F(VideoStreamEncoderTest, EncoderDoesnotProvideLimitsWhenQPIsNotTrusted) {
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
EXPECT_TRUE(suitable_bitrate_limit.has_value());
const int MaxEncBitrate = suitable_bitrate_limit->max_bitrate_bps;
const int MinEncBitrate = suitable_bitrate_limit->min_bitrate_bps;
const int TargetEncBitrate = MaxEncBitrate;
const int max_encoder_bitrate = suitable_bitrate_limit->max_bitrate_bps;
const int min_encoder_bitrate = suitable_bitrate_limit->min_bitrate_bps;
const int target_encoder_bitrate = max_encoder_bitrate;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
DataRate::BitsPerSec(TargetEncBitrate),
DataRate::BitsPerSec(TargetEncBitrate),
DataRate::BitsPerSec(TargetEncBitrate), 0, 0, 0);
DataRate::BitsPerSec(target_encoder_bitrate),
DataRate::BitsPerSec(target_encoder_bitrate),
DataRate::BitsPerSec(target_encoder_bitrate), 0, 0, 0);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecH264, 1, &video_encoder_config);
video_encoder_config.max_bitrate_bps = MaxEncBitrate;
video_encoder_config.simulcast_layers[0].min_bitrate_bps = MinEncBitrate;
video_encoder_config.max_bitrate_bps = max_encoder_bitrate;
video_encoder_config.simulcast_layers[0].min_bitrate_bps =
min_encoder_bitrate;
video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
kMaxPayloadLength);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
EXPECT_EQ(
MaxEncBitrate / 1000,
max_encoder_bitrate / 1000,
static_cast<int>(bitrate_allocator_factory_.codec_config().maxBitrate));
EXPECT_EQ(
MinEncBitrate / 1000,
min_encoder_bitrate / 1000,
static_cast<int>(bitrate_allocator_factory_.codec_config().minBitrate));
video_stream_encoder_->Stop();
}
TEST_F(VideoStreamEncoderTest,
RespectsLowerThanDefaultMinBitrateWhenQPIsNotTrusted) {
// Set QP not trusted in encoder info.
fake_encoder_.SetIsQpTrusted(false);
absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate_limit =
EncoderInfoSettings::
GetSinglecastBitrateLimitForResolutionWhenQpIsUntrusted(
codec_width_ * codec_height_,
EncoderInfoSettings::
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
EXPECT_TRUE(suitable_bitrate_limit.has_value());
const int max_encoder_bitrate = suitable_bitrate_limit->max_bitrate_bps;
const int min_encoder_bitrate = suitable_bitrate_limit->min_bitrate_bps;
const int target_encoder_bitrate = max_encoder_bitrate;
video_stream_encoder_->OnBitrateUpdatedAndWaitForManagedResources(
DataRate::BitsPerSec(target_encoder_bitrate),
DataRate::BitsPerSec(target_encoder_bitrate),
DataRate::BitsPerSec(target_encoder_bitrate), 0, 0, 0);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecH264, 1, &video_encoder_config);
// Set the max bitrate config to be lower than what the resolution bitrate
// limits would suggest for the current resolution.
video_encoder_config.max_bitrate_bps =
(max_encoder_bitrate + min_encoder_bitrate) / 2;
video_encoder_config.simulcast_layers[0].min_bitrate_bps =
min_encoder_bitrate;
video_stream_encoder_->ConfigureEncoder(video_encoder_config.Copy(),
kMaxPayloadLength);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
EXPECT_EQ(
video_encoder_config.max_bitrate_bps / 1000,
static_cast<int>(bitrate_allocator_factory_.codec_config().maxBitrate));
EXPECT_EQ(
min_encoder_bitrate / 1000,
static_cast<int>(bitrate_allocator_factory_.codec_config().minBitrate));
video_stream_encoder_->Stop();