zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Video, Svc] Remove inactive spatial layers in codec initializer

Browse Source 
This is more logical way to remove inactive lower layers.
Current way is to notify the encoder that the layer is inactive,
then renumber layers at the packatization level.

This Cl will allow to simplify libvpx vp9 encoder, svcRateAllocator and
vp9 packetizer.

Bug: webrtc:11319
Change-Id: Idf0bb30b729f5ecc97e31454b32934546b681aa2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173182
Commit-Queue: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31058}
This commit is contained in:
Ilya Nikolaevskiy
2020-04-14 10:28:19 +02:00
committed by Commit Bot
parent 9f297b5960
commit 39fb817efd
7 changed files with 36 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
modules/video_coding/codecs/vp9/svc_config.cc
View File

@ -61,10 +61,10 @@ std::vector<SpatialLayer> ConfigureSvcScreenSharing(size_t input_width,
std::vector<SpatialLayer> ConfigureSvcNormalVideo(size_t input_width,
size_t input_height,
float max_framerate_fps,
size_t min_spatial_layers,
size_t first_active_layer,
size_t num_spatial_layers,
size_t num_temporal_layers) {
RTC_DCHECK_LE(min_spatial_layers, num_spatial_layers);
RTC_DCHECK_LT(first_active_layer, num_spatial_layers);
std::vector<SpatialLayer> spatial_layers;
// Limit number of layers for given resolution.
@ -76,9 +76,11 @@ std::vector<SpatialLayer> ConfigureSvcNormalVideo(size_t input_width,
kMinVp9SpatialLayerHeight))));
num_spatial_layers =
std::min({num_spatial_layers, num_layers_fit_horz, num_layers_fit_vert});
num_spatial_layers = std::max(num_spatial_layers, min_spatial_layers);
// First active layer must be configured.
num_spatial_layers = std::max(num_spatial_layers, first_active_layer + 1);
for (size_t sl_idx = 0; sl_idx < num_spatial_layers; ++sl_idx) {
for (size_t sl_idx = first_active_layer; sl_idx < num_spatial_layers;
++sl_idx) {
SpatialLayer spatial_layer = {0};
spatial_layer.width = input_width >> (num_spatial_layers - sl_idx - 1);
spatial_layer.height = input_height >> (num_spatial_layers - sl_idx - 1);
@ -112,7 +114,7 @@ std::vector<SpatialLayer> ConfigureSvcNormalVideo(size_t input_width,
std::vector<SpatialLayer> GetSvcConfig(size_t input_width,
size_t input_height,
float max_framerate_fps,
size_t min_spatial_layers,
size_t first_active_layer,
size_t num_spatial_layers,
size_t num_temporal_layers,
bool is_screen_sharing) {
@ -126,7 +128,7 @@ std::vector<SpatialLayer> GetSvcConfig(size_t input_width,
max_framerate_fps, num_spatial_layers);
} else {
return ConfigureSvcNormalVideo(input_width, input_height, max_framerate_fps,
min_spatial_layers, num_spatial_layers,
first_active_layer, num_spatial_layers,
num_temporal_layers);
}
}

2
modules/video_coding/codecs/vp9/svc_config.h
View File

@ -21,7 +21,7 @@ namespace webrtc {
std::vector<SpatialLayer> GetSvcConfig(size_t input_width,
size_t input_height,
float max_framerate_fps,
size_t min_spatial_layers,
size_t first_active_layer,
size_t num_spatial_layers,
size_t num_temporal_layers,
bool is_screen_sharing);

27
modules/video_coding/codecs/vp9/svc_config_unittest.cc
View File

@ -19,35 +19,48 @@
namespace webrtc {
TEST(SvcConfig, NumSpatialLayers) {
const size_t max_num_spatial_layers = 6;
const size_t min_spatial_layers = 1;
const size_t first_active_layer = 0;
const size_t num_spatial_layers = 2;
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(kMinVp9SpatialLayerWidth << (num_spatial_layers - 1),
kMinVp9SpatialLayerHeight << (num_spatial_layers - 1), 30,
min_spatial_layers, max_num_spatial_layers, 1, false);
first_active_layer, max_num_spatial_layers, 1, false);
EXPECT_EQ(spatial_layers.size(), num_spatial_layers);
}
TEST(SvcConfig, NumSpatialLayersRespectsMinNumberOfLayers) {
TEST(SvcConfig, AlwaysSendsAtLeastOneLayer) {
const size_t max_num_spatial_layers = 6;
const size_t min_spatial_layers = 2;
const size_t first_active_layer = 5;
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(kMinVp9SpatialLayerWidth, kMinVp9SpatialLayerHeight, 30,
min_spatial_layers, max_num_spatial_layers, 1, false);
first_active_layer, max_num_spatial_layers, 1, false);
EXPECT_EQ(spatial_layers.size(), 1u);
EXPECT_EQ(spatial_layers.back().width, kMinVp9SpatialLayerWidth);
}
TEST(SvcConfig, SkipsInactiveLayers) {
const size_t num_spatial_layers = 4;
const size_t first_active_layer = 2;
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(kMinVp9SpatialLayerWidth << (num_spatial_layers - 1),
kMinVp9SpatialLayerHeight << (num_spatial_layers - 1), 30,
first_active_layer, num_spatial_layers, 1, false);
EXPECT_EQ(spatial_layers.size(), 2u);
EXPECT_EQ(spatial_layers.back().width,
kMinVp9SpatialLayerWidth << (num_spatial_layers - 1));
}
TEST(SvcConfig, BitrateThresholds) {
const size_t min_spatial_layers = 1;
const size_t first_active_layer = 0;
const size_t num_spatial_layers = 3;
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(kMinVp9SpatialLayerWidth << (num_spatial_layers - 1),
kMinVp9SpatialLayerHeight << (num_spatial_layers - 1), 30,
min_spatial_layers, num_spatial_layers, 1, false);
first_active_layer, num_spatial_layers, 1, false);
EXPECT_EQ(spatial_layers.size(), num_spatial_layers);

2
modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
View File

@ -34,7 +34,7 @@ static VideoCodec Configure(size_t width,
: VideoCodecMode::kRealtimeVideo;
std::vector<SpatialLayer> spatial_layers =
GetSvcConfig(width, height, 30, /*min_spatial_layers=*/1,
GetSvcConfig(width, height, 30, /*first_active_layer=*/0,
num_spatial_layers, num_temporal_layers, is_screen_sharing);
RTC_CHECK_LE(spatial_layers.size(), kMaxSpatialLayers);

2
modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
View File

@ -114,7 +114,7 @@ class TestVp9Impl : public VideoCodecUnitTest {
std::vector<SpatialLayer> layers =
GetSvcConfig(codec_settings_.width, codec_settings_.height,
codec_settings_.maxFramerate, /*min_spatial_layers=*/1,
codec_settings_.maxFramerate, /*first_active_layer=*/0,
num_spatial_layers, num_temporal_layers, false);
for (size_t i = 0; i < layers.size(); ++i) {
codec_settings_.spatialLayers[i] = layers[i];