1 files changed, 300 insertions, 0 deletions
diff --git a/third_party/libwebrtc/modules/video_coding/codecs/vp9/svc_config_unittest.cc b/third_party/libwebrtc/modules/video_coding/codecs/vp9/svc_config_unittest.cc
new file mode 100644
index 0000000000..1b1abe0f6d
--- /dev/null
+++ b/third_party/libwebrtc/modules/video_coding/codecs/vp9/svc_config_unittest.cc
@@ -0,0 +1,300 @@
+/*
+ *  Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/video_coding/codecs/vp9/svc_config.h"
+
+#include <cstddef>
+#include <vector>
+
+#include "modules/video_coding/codecs/vp9/include/vp9_globals.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+using ::testing::ElementsAre;
+using ::testing::Field;
+
+namespace webrtc {
+TEST(SvcConfig, NumSpatialLayers) {
+  const size_t max_num_spatial_layers = 6;
+  const size_t first_active_layer = 0;
+  const size_t num_spatial_layers = 2;
+
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerLongSideLength << (num_spatial_layers - 1),
+      kMinVp9SpatialLayerShortSideLength << (num_spatial_layers - 1), 30,
+      first_active_layer, max_num_spatial_layers, 1, false);
+
+  EXPECT_EQ(spatial_layers.size(), num_spatial_layers);
+}
+
+TEST(SvcConfig, NumSpatialLayersPortrait) {
+  const size_t max_num_spatial_layers = 6;
+  const size_t first_active_layer = 0;
+  const size_t num_spatial_layers = 2;
+
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerShortSideLength << (num_spatial_layers - 1),
+      kMinVp9SpatialLayerLongSideLength << (num_spatial_layers - 1), 30,
+      first_active_layer, max_num_spatial_layers, 1, false);
+
+  EXPECT_EQ(spatial_layers.size(), num_spatial_layers);
+}
+
+TEST(SvcConfig, NumSpatialLayersWithScalabilityMode) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 960;
+  codec.height = 540;
+  codec.SetScalabilityMode(ScalabilityMode::kL3T3_KEY);
+
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::height, 135),
+                                          Field(&SpatialLayer::height, 270),
+                                          Field(&SpatialLayer::height, 540)));
+  EXPECT_THAT(spatial_layers,
+              ElementsAre(Field(&SpatialLayer::numberOfTemporalLayers, 3),
+                          Field(&SpatialLayer::numberOfTemporalLayers, 3),
+                          Field(&SpatialLayer::numberOfTemporalLayers, 3)));
+  EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL3T3_KEY);
+}
+
+TEST(SvcConfig, NumSpatialLayersLimitedWithScalabilityMode) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 480;
+  codec.height = 270;
+  codec.SetScalabilityMode(ScalabilityMode::kL3T3_KEY);
+
+  // Scalability mode updated.
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::height, 135),
+                                          Field(&SpatialLayer::height, 270)));
+  EXPECT_THAT(spatial_layers,
+              ElementsAre(Field(&SpatialLayer::numberOfTemporalLayers, 3),
+                          Field(&SpatialLayer::numberOfTemporalLayers, 3)));
+  EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL2T3_KEY);
+}
+
+TEST(SvcConfig, NumSpatialLayersLimitedWithScalabilityModePortrait) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 270;
+  codec.height = 480;
+  codec.SetScalabilityMode(ScalabilityMode::kL3T1);
+
+  // Scalability mode updated.
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::width, 135),
+                                          Field(&SpatialLayer::width, 270)));
+  EXPECT_THAT(spatial_layers,
+              ElementsAre(Field(&SpatialLayer::numberOfTemporalLayers, 1),
+                          Field(&SpatialLayer::numberOfTemporalLayers, 1)));
+  EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL2T1);
+}
+
+TEST(SvcConfig, NumSpatialLayersWithScalabilityModeResolutionRatio1_5) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 270;
+  codec.height = 480;
+  codec.SetScalabilityMode(ScalabilityMode::kL2T1h);  // 1.5:1
+
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::width, 180),
+                                          Field(&SpatialLayer::width, 270)));
+  EXPECT_THAT(spatial_layers,
+              ElementsAre(Field(&SpatialLayer::numberOfTemporalLayers, 1),
+                          Field(&SpatialLayer::numberOfTemporalLayers, 1)));
+  EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL2T1h);
+}
+
+TEST(SvcConfig, NumSpatialLayersLimitedWithScalabilityModeResolutionRatio1_5) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 320;
+  codec.height = 180;
+  codec.SetScalabilityMode(ScalabilityMode::kL3T1h);  // 1.5:1
+
+  // Scalability mode updated.
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::width, 320)));
+  EXPECT_THAT(spatial_layers,
+              ElementsAre(Field(&SpatialLayer::numberOfTemporalLayers, 1)));
+  EXPECT_EQ(codec.GetScalabilityMode(), ScalabilityMode::kL1T1);
+}
+
+TEST(SvcConfig, AlwaysSendsAtLeastOneLayer) {
+  const size_t max_num_spatial_layers = 6;
+  const size_t first_active_layer = 5;
+
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerLongSideLength, kMinVp9SpatialLayerShortSideLength, 30,
+      first_active_layer, max_num_spatial_layers, 1, false);
+  EXPECT_EQ(spatial_layers.size(), 1u);
+  EXPECT_EQ(spatial_layers.back().width, kMinVp9SpatialLayerLongSideLength);
+}
+
+TEST(SvcConfig, AlwaysSendsAtLeastOneLayerPortrait) {
+  const size_t max_num_spatial_layers = 6;
+  const size_t first_active_layer = 5;
+
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerShortSideLength, kMinVp9SpatialLayerLongSideLength, 30,
+      first_active_layer, max_num_spatial_layers, 1, false);
+  EXPECT_EQ(spatial_layers.size(), 1u);
+  EXPECT_EQ(spatial_layers.back().width, kMinVp9SpatialLayerShortSideLength);
+}
+
+TEST(SvcConfig, EnforcesMinimalRequiredParity) {
+  const size_t max_num_spatial_layers = 3;
+  const size_t kOddSize = 1023;
+
+  std::vector<SpatialLayer> spatial_layers =
+      GetSvcConfig(kOddSize, kOddSize, 30,
+                   /*first_active_layer=*/1, max_num_spatial_layers, 1, false);
+  // Since there are 2 layers total (1, 2), divisiblity by 2 is required.
+  EXPECT_EQ(spatial_layers.back().width, kOddSize - 1);
+  EXPECT_EQ(spatial_layers.back().width, kOddSize - 1);
+
+  spatial_layers =
+      GetSvcConfig(kOddSize, kOddSize, 30,
+                   /*first_active_layer=*/0, max_num_spatial_layers, 1, false);
+  // Since there are 3 layers total (0, 1, 2), divisiblity by 4 is required.
+  EXPECT_EQ(spatial_layers.back().width, kOddSize - 3);
+  EXPECT_EQ(spatial_layers.back().width, kOddSize - 3);
+
+  spatial_layers =
+      GetSvcConfig(kOddSize, kOddSize, 30,
+                   /*first_active_layer=*/2, max_num_spatial_layers, 1, false);
+  // Since there is only 1 layer active (2), divisiblity by 1 is required.
+  EXPECT_EQ(spatial_layers.back().width, kOddSize);
+  EXPECT_EQ(spatial_layers.back().width, kOddSize);
+}
+
+TEST(SvcConfig, EnforcesMinimalRequiredParityWithScalabilityMode) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 1023;
+  codec.height = 1023;
+  codec.SetScalabilityMode(ScalabilityMode::kL3T1);
+
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers,  // Divisiblity by 4 required.
+              ElementsAre(Field(&SpatialLayer::width, 255),
+                          Field(&SpatialLayer::width, 510),
+                          Field(&SpatialLayer::width, 1020)));
+
+  codec.SetScalabilityMode(ScalabilityMode::kL2T1);
+  spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers,  // Divisiblity by 2 required.
+              ElementsAre(Field(&SpatialLayer::width, 511),
+                          Field(&SpatialLayer::width, 1022)));
+
+  codec.SetScalabilityMode(ScalabilityMode::kL1T1);
+  spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers,  // Divisiblity by 1 required.
+              ElementsAre(Field(&SpatialLayer::width, 1023)));
+}
+
+TEST(SvcConfig, EnforcesMinimalRequiredParityWithScalabilityModeResRatio1_5) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 1280;
+  codec.height = 1280;
+  codec.SetScalabilityMode(ScalabilityMode::kL2T1h);  // 1.5:1
+
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers,  // Divisiblity by 3 required.
+              ElementsAre(Field(&SpatialLayer::width, 852),
+                          Field(&SpatialLayer::width, 1278)));
+}
+
+TEST(SvcConfig, SkipsInactiveLayers) {
+  const size_t num_spatial_layers = 4;
+  const size_t first_active_layer = 2;
+
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerLongSideLength << (num_spatial_layers - 1),
+      kMinVp9SpatialLayerShortSideLength << (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,
+            kMinVp9SpatialLayerLongSideLength << (num_spatial_layers - 1));
+}
+
+TEST(SvcConfig, BitrateThresholds) {
+  const size_t first_active_layer = 0;
+  const size_t num_spatial_layers = 3;
+  std::vector<SpatialLayer> spatial_layers = GetSvcConfig(
+      kMinVp9SpatialLayerLongSideLength << (num_spatial_layers - 1),
+      kMinVp9SpatialLayerShortSideLength << (num_spatial_layers - 1), 30,
+      first_active_layer, num_spatial_layers, 1, false);
+
+  EXPECT_EQ(spatial_layers.size(), num_spatial_layers);
+
+  for (const SpatialLayer& layer : spatial_layers) {
+    EXPECT_LE(layer.minBitrate, layer.maxBitrate);
+    EXPECT_LE(layer.minBitrate, layer.targetBitrate);
+    EXPECT_LE(layer.targetBitrate, layer.maxBitrate);
+  }
+}
+
+TEST(SvcConfig, BitrateThresholdsWithScalabilityMode) {
+  VideoCodec codec;
+  codec.codecType = kVideoCodecVP9;
+  codec.width = 960;
+  codec.height = 540;
+  codec.SetScalabilityMode(ScalabilityMode::kS3T3);
+
+  std::vector<SpatialLayer> spatial_layers = GetVp9SvcConfig(codec);
+  EXPECT_THAT(spatial_layers, ElementsAre(Field(&SpatialLayer::height, 135),
+                                          Field(&SpatialLayer::height, 270),
+                                          Field(&SpatialLayer::height, 540)));
+
+  for (const SpatialLayer& layer : spatial_layers) {
+    EXPECT_LE(layer.minBitrate, layer.maxBitrate);
+    EXPECT_LE(layer.minBitrate, layer.targetBitrate);
+    EXPECT_LE(layer.targetBitrate, layer.maxBitrate);
+  }
+}
+
+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);
+
+  EXPECT_EQ(spatial_layers.size(), 3UL);
+
+  for (size_t i = 0; i < 3; ++i) {
+    const SpatialLayer& layer = spatial_layers[i];
+    EXPECT_EQ(layer.width, 1920);
+    EXPECT_EQ(layer.height, 1080);
+    EXPECT_EQ(layer.maxFramerate, (i < 1) ? 5 : (i < 2 ? 10 : 30));
+    EXPECT_EQ(layer.numberOfTemporalLayers, 1);
+    EXPECT_LE(layer.minBitrate, layer.maxBitrate);
+    EXPECT_LE(layer.minBitrate, layer.targetBitrate);
+    EXPECT_LE(layer.targetBitrate, layer.maxBitrate);
+  }
+}
+}  // namespace webrtc