mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move setting single spatial layer bitrates to GetVp9SvcConfig

Browse source 
Before this change bitrate limits for VP9 single spatial layer case were set in VideoCodecInitializer. Move this logic to GetVp9SvcConfig. This simplifies replication of WebRTC behaviour in codec level tests. The similar AV1 logic sits in SetAv1SvcConfig, not VideoCodecInitializer.

Bug: webrtc:14852
Change-Id: Ie7202ec880d0e4b903e7265721eeef9b3920f21a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/324286
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40992}
This commit is contained in:
Sergey Silkin 2023-10-22 19:42:42 +02:00 committed by WebRTC LUCI CQ
parent 75a131f39c
commit 50e2054c5b
4 changed files with 29 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
modules/video_coding/codecs/av1/av1_svc_config.cc
View file

@ -85,7 +85,7 @@ bool SetAv1SvcConfig(VideoCodec& video_codec,
}
}
bool configured_for_single_spatial_layer =
bool requested_single_spatial_layer =
ScalabilityModeToNumSpatialLayers(*scalability_mode) == 1;
if (ScalabilityMode reduced = LimitNumSpatialLayers(
@ -121,7 +121,7 @@ bool SetAv1SvcConfig(VideoCodec& video_codec,
spatial_layer.active = true;
}
if (configured_for_single_spatial_layer) {
if (requested_single_spatial_layer) {
SpatialLayer& spatial_layer = video_codec.spatialLayers[0];
spatial_layer.minBitrate = video_codec.minBitrate;
spatial_layer.maxBitrate = video_codec.maxBitrate;

11
modules/video_coding/codecs/vp9/svc_config.cc
View file

@ -172,6 +172,9 @@ std::vector<SpatialLayer> GetVp9SvcConfig(VideoCodec& codec) {
absl::optional<ScalabilityMode> scalability_mode = codec.GetScalabilityMode();
RTC_DCHECK(scalability_mode.has_value());
bool requested_single_spatial_layer =
ScalabilityModeToNumSpatialLayers(*scalability_mode) == 1;
// Limit number of spatial layers for given resolution.
int limited_num_spatial_layers =
GetLimitedNumSpatialLayers(codec.width, codec.height);
@ -205,6 +208,14 @@ std::vector<SpatialLayer> GetVp9SvcConfig(VideoCodec& codec) {
spatial_layers[0].minBitrate = kMinVp9SvcBitrateKbps;
// Use codec bitrate limits if spatial layering is not requested.
if (requested_single_spatial_layer) {
SpatialLayer& spatial_layer = spatial_layers[0];
spatial_layer.minBitrate = codec.minBitrate;
spatial_layer.maxBitrate = codec.maxBitrate;
spatial_layer.targetBitrate = codec.maxBitrate;
}
return spatial_layers;
}

15
modules/video_coding/codecs/vp9/svc_config_unittest.cc
View file

@ -265,6 +265,21 @@ TEST(SvcConfig, BitrateThresholdsWithScalabilityMode) {
}
}
TEST(SvcConfig, CopiesMinMaxBitrateForSingleSpatialLayer) {
VideoCodec codec;
codec.codecType = kVideoCodecVP9;
codec.SetScalabilityMode(ScalabilityMode::kL1T3);
codec.width = 1280;
codec.height = 720;
codec.minBitrate = 100;
codec.maxBitrate = 500;
std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
EXPECT_EQ(spatial_layers[0].minBitrate, 100u);
EXPECT_EQ(spatial_layers[0].maxBitrate, 500u);
EXPECT_LE(spatial_layers[0].targetBitrate, 500u);
}
TEST(SvcConfig, ScreenSharing) {
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(1920, 1080, 30, 1, 3, 3, true);

11
modules/video_coding/video_codec_initializer.cc
View file

@ -236,18 +236,9 @@ VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
if (!config.spatial_layers.empty()) {
// Layering is set explicitly.
spatial_layers = config.spatial_layers;
} else if (scalability_mode.has_value()) {
} else if (video_codec.GetScalabilityMode().has_value()) {
// Layering is set via scalability mode.
spatial_layers = GetVp9SvcConfig(video_codec);
if (spatial_layers.empty())
break;
// Use codec bitrate limits if spatial layering is not requested.
if (video_codec.numberOfSimulcastStreams <= 1 &&
ScalabilityModeToNumSpatialLayers(*scalability_mode) == 1) {
spatial_layers.back().minBitrate = video_codec.minBitrate;
spatial_layers.back().targetBitrate = video_codec.maxBitrate;
spatial_layers.back().maxBitrate = video_codec.maxBitrate;
}
} else {
size_t first_active_layer = 0;
for (size_t spatial_idx = 0;