Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 525 insertions, 0 deletions

diff --git a/third_party/libwebrtc/video/config/simulcast_unittest.cc b/third_party/libwebrtc/video/config/simulcast_unittest.cc
new file mode 100644
index 0000000000..152a0f9525
--- /dev/null
+++ b/third_party/libwebrtc/video/config/simulcast_unittest.cc
@@ -0,0 +1,525 @@
+/*
+ *  Copyright 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 "video/config/simulcast.h"
+
+#include "api/transport/field_trial_based_config.h"
+#include "media/base/media_constants.h"
+#include "test/field_trial.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace {
+constexpr int kQpMax = 55;
+constexpr double kBitratePriority = 2.0;
+constexpr bool kScreenshare = true;
+constexpr int kDefaultTemporalLayers = 3;  // Value from simulcast.cc.
+
+// Values from kSimulcastConfigs in simulcast.cc.
+const std::vector<VideoStream> GetSimulcastBitrates720p() {
+  std::vector<VideoStream> streams(3);
+  streams[0].min_bitrate_bps = 30000;
+  streams[0].target_bitrate_bps = 150000;
+  streams[0].max_bitrate_bps = 200000;
+  streams[1].min_bitrate_bps = 150000;
+  streams[1].target_bitrate_bps = 500000;
+  streams[1].max_bitrate_bps = 700000;
+  streams[2].min_bitrate_bps = 600000;
+  streams[2].target_bitrate_bps = 2500000;
+  streams[2].max_bitrate_bps = 2500000;
+  return streams;
+}
+}  // namespace
+
+TEST(SimulcastTest, TotalMaxBitrateIsZeroForNoStreams) {
+  std::vector<VideoStream> streams;
+  EXPECT_EQ(0, cricket::GetTotalMaxBitrate(streams).bps());
+}
+
+TEST(SimulcastTest, GetTotalMaxBitrateForSingleStream) {
+  std::vector<VideoStream> streams(1);
+  streams[0].max_bitrate_bps = 100000;
+  EXPECT_EQ(100000, cricket::GetTotalMaxBitrate(streams).bps());
+}
+
+TEST(SimulcastTest, GetTotalMaxBitrateForMultipleStreams) {
+  std::vector<VideoStream> streams(3);
+  streams[0].target_bitrate_bps = 100000;
+  streams[1].target_bitrate_bps = 200000;
+  streams[2].max_bitrate_bps = 400000;
+  EXPECT_EQ(700000, cricket::GetTotalMaxBitrate(streams).bps());
+}
+
+TEST(SimulcastTest, BandwidthAboveTotalMaxBitrateGivenToHighestStream) {
+  std::vector<VideoStream> streams(3);
+  streams[0].target_bitrate_bps = 100000;
+  streams[1].target_bitrate_bps = 200000;
+  streams[2].max_bitrate_bps = 400000;
+
+  const webrtc::DataRate one_bps = webrtc::DataRate::BitsPerSec(1);
+
+  // No bitrate above the total max to give to the highest stream.
+  const webrtc::DataRate max_total_bitrate =
+      cricket::GetTotalMaxBitrate(streams);
+  cricket::BoostMaxSimulcastLayer(max_total_bitrate, &streams);
+  EXPECT_EQ(400000, streams[2].max_bitrate_bps);
+  EXPECT_EQ(max_total_bitrate, cricket::GetTotalMaxBitrate(streams));
+
+  // The bitrate above the total max should be given to the highest stream.
+  cricket::BoostMaxSimulcastLayer(max_total_bitrate + one_bps, &streams);
+  EXPECT_EQ(400000 + 1, streams[2].max_bitrate_bps);
+  EXPECT_EQ(max_total_bitrate + one_bps, cricket::GetTotalMaxBitrate(streams));
+}
+
+TEST(SimulcastTest, GetConfig) {
+  const std::vector<VideoStream> kExpected = GetSimulcastBitrates720p();
+  const FieldTrialBasedConfig trials;
+
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 1280, 720, kBitratePriority, kQpMax,
+      !kScreenshare, true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(320u, streams[0].width);
+  EXPECT_EQ(180u, streams[0].height);
+  EXPECT_EQ(640u, streams[1].width);
+  EXPECT_EQ(360u, streams[1].height);
+  EXPECT_EQ(1280u, streams[2].width);
+  EXPECT_EQ(720u, streams[2].height);
+
+  for (size_t i = 0; i < streams.size(); ++i) {
+    EXPECT_EQ(size_t{kDefaultTemporalLayers}, streams[i].num_temporal_layers);
+    EXPECT_EQ(cricket::kDefaultVideoMaxFramerate, streams[i].max_framerate);
+    EXPECT_EQ(kQpMax, streams[i].max_qp);
+    EXPECT_EQ(kExpected[i].min_bitrate_bps, streams[i].min_bitrate_bps);
+    EXPECT_EQ(kExpected[i].target_bitrate_bps, streams[i].target_bitrate_bps);
+    EXPECT_EQ(kExpected[i].max_bitrate_bps, streams[i].max_bitrate_bps);
+    EXPECT_TRUE(streams[i].active);
+  }
+  // Currently set on lowest stream.
+  EXPECT_EQ(kBitratePriority, streams[0].bitrate_priority);
+  EXPECT_FALSE(streams[1].bitrate_priority);
+  EXPECT_FALSE(streams[2].bitrate_priority);
+}
+
+TEST(SimulcastTest, GetConfigWithBaseHeavyVP8TL3RateAllocation) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-UseBaseHeavyVP8TL3RateAllocation/Enabled/");
+  FieldTrialBasedConfig trials;
+
+  const std::vector<VideoStream> kExpected = GetSimulcastBitrates720p();
+
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 1280, 720, kBitratePriority, kQpMax,
+      !kScreenshare, true, trials);
+
+  EXPECT_EQ(kExpected[0].min_bitrate_bps, streams[0].min_bitrate_bps);
+  EXPECT_EQ(static_cast<int>(0.4 * kExpected[0].target_bitrate_bps / 0.6),
+            streams[0].target_bitrate_bps);
+  EXPECT_EQ(static_cast<int>(0.4 * kExpected[0].max_bitrate_bps / 0.6),
+            streams[0].max_bitrate_bps);
+  for (size_t i = 1; i < streams.size(); ++i) {
+    EXPECT_EQ(kExpected[i].min_bitrate_bps, streams[i].min_bitrate_bps);
+    EXPECT_EQ(kExpected[i].target_bitrate_bps, streams[i].target_bitrate_bps);
+    EXPECT_EQ(kExpected[i].max_bitrate_bps, streams[i].max_bitrate_bps);
+  }
+}
+
+TEST(SimulcastTest, GetConfigWithLimitedMaxLayers) {
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 2;
+  FieldTrialBasedConfig trials;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 1280, 720, kBitratePriority, kQpMax,
+      !kScreenshare, true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(640u, streams[0].width);
+  EXPECT_EQ(360u, streams[0].height);
+  EXPECT_EQ(1280u, streams[1].width);
+  EXPECT_EQ(720u, streams[1].height);
+}
+
+TEST(SimulcastTest, GetConfigWithLimitedMaxLayersForResolution) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LegacySimulcastLayerLimit/Enabled/");
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 800, 600, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+
+  EXPECT_EQ(2u, streams.size());
+  EXPECT_EQ(400u, streams[0].width);
+  EXPECT_EQ(300u, streams[0].height);
+  EXPECT_EQ(800u, streams[1].width);
+  EXPECT_EQ(600u, streams[1].height);
+}
+
+TEST(SimulcastTest, GetConfigWithLowResolutionScreenshare) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LegacySimulcastLayerLimit/Enabled/");
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 100, 100, kBitratePriority, kQpMax, kScreenshare,
+      true, trials);
+
+  // Simulcast streams number is never decreased for screenshare,
+  // even for very low resolution.
+  EXPECT_GT(streams.size(), 1u);
+}
+
+TEST(SimulcastTest, GetConfigWithNotLimitedMaxLayersForResolution) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LegacySimulcastLayerLimit/Disabled/");
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 800, 600, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(200u, streams[0].width);
+  EXPECT_EQ(150u, streams[0].height);
+  EXPECT_EQ(400u, streams[1].width);
+  EXPECT_EQ(300u, streams[1].height);
+  EXPECT_EQ(800u, streams[2].width);
+  EXPECT_EQ(600u, streams[2].height);
+}
+
+TEST(SimulcastTest, GetConfigWithNormalizedResolution) {
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 2;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 640 + 1, 360 + 1, kBitratePriority, kQpMax,
+      !kScreenshare, true, trials);
+
+  // Must be divisible by |2 ^ (num_layers - 1)|.
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(320u, streams[0].width);
+  EXPECT_EQ(180u, streams[0].height);
+  EXPECT_EQ(640u, streams[1].width);
+  EXPECT_EQ(360u, streams[1].height);
+}
+
+TEST(SimulcastTest, GetConfigWithNormalizedResolutionDivisibleBy4) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-2/");
+  FieldTrialBasedConfig trials;
+
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 2;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 709, 501, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+
+  // Must be divisible by |2 ^ 2|.
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(354u, streams[0].width);
+  EXPECT_EQ(250u, streams[0].height);
+  EXPECT_EQ(708u, streams[1].width);
+  EXPECT_EQ(500u, streams[1].height);
+}
+
+TEST(SimulcastTest, GetConfigWithNormalizedResolutionDivisibleBy8) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-NormalizeSimulcastResolution/Enabled-3/");
+  FieldTrialBasedConfig trials;
+
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 2;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 709, 501, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+
+  // Must be divisible by |2 ^ 3|.
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(352u, streams[0].width);
+  EXPECT_EQ(248u, streams[0].height);
+  EXPECT_EQ(704u, streams[1].width);
+  EXPECT_EQ(496u, streams[1].height);
+}
+
+TEST(SimulcastTest, GetConfigForLegacyLayerLimit) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LegacySimulcastLayerLimit/Enabled/");
+  FieldTrialBasedConfig trials;
+
+  const size_t kMinLayers = 1;
+  const int kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 320, 180, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+  EXPECT_EQ(1u, streams.size());
+
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 640, 360,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 1920, 1080,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+}
+
+TEST(SimulcastTest, GetConfigForLegacyLayerLimitWithRequiredHD) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LegacySimulcastLayerLimit/Enabled/");
+  FieldTrialBasedConfig trials;
+
+  const size_t kMinLayers = 3;  // "HD" layer must be present!
+  const int kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 320, 180, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+  EXPECT_EQ(3u, streams.size());
+
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 640, 360,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 1920, 1080,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+}
+
+TEST(SimulcastTest, GetConfigForScreenshareSimulcast) {
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 1400, 800, kBitratePriority, kQpMax, kScreenshare,
+      true, trials);
+
+  EXPECT_GT(streams.size(), 1u);
+  for (size_t i = 0; i < streams.size(); ++i) {
+    EXPECT_EQ(1400u, streams[i].width) << "Screen content never scaled.";
+    EXPECT_EQ(800u, streams[i].height) << "Screen content never scaled.";
+    EXPECT_EQ(kQpMax, streams[i].max_qp);
+    EXPECT_TRUE(streams[i].active);
+    EXPECT_GT(streams[i].num_temporal_layers, size_t{1});
+    EXPECT_GT(streams[i].max_framerate, 0);
+    EXPECT_GT(streams[i].min_bitrate_bps, 0);
+    EXPECT_GT(streams[i].target_bitrate_bps, streams[i].min_bitrate_bps);
+    EXPECT_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
+  }
+}
+
+TEST(SimulcastTest, GetConfigForScreenshareSimulcastWithLimitedMaxLayers) {
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 1;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 1400, 800, kBitratePriority, kQpMax, kScreenshare,
+      true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+}
+
+TEST(SimulcastTest, AveragesBitratesForNonStandardResolution) {
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, 900, 800, kBitratePriority, kQpMax, !kScreenshare,
+      true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(900u, streams[2].width);
+  EXPECT_EQ(800u, streams[2].height);
+  EXPECT_EQ(1850000, streams[2].max_bitrate_bps);
+  EXPECT_EQ(1850000, streams[2].target_bitrate_bps);
+  EXPECT_EQ(475000, streams[2].min_bitrate_bps);
+}
+
+TEST(SimulcastTest, BitratesForCloseToStandardResolution) {
+  const size_t kMinLayers = 1;
+  const size_t kMaxLayers = 3;
+  // Resolution very close to 720p in number of pixels
+  const size_t kWidth = 1280;
+  const size_t kHeight = 716;
+  const std::vector<VideoStream> kExpectedNear = GetSimulcastBitrates720p();
+  FieldTrialBasedConfig trials;
+
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMinLayers, kMaxLayers, kWidth, kHeight, kBitratePriority, kQpMax,
+      !kScreenshare, true, trials);
+
+  EXPECT_EQ(kMaxLayers, streams.size());
+  EXPECT_EQ(kWidth, streams[2].width);
+  EXPECT_EQ(kHeight, streams[2].height);
+  for (size_t i = 0; i < streams.size(); ++i) {
+    EXPECT_NEAR(kExpectedNear[i].max_bitrate_bps, streams[i].max_bitrate_bps,
+                20000);
+    EXPECT_NEAR(kExpectedNear[i].target_bitrate_bps,
+                streams[i].target_bitrate_bps, 20000);
+    EXPECT_NEAR(kExpectedNear[i].min_bitrate_bps, streams[i].min_bitrate_bps,
+                20000);
+  }
+}
+
+TEST(SimulcastTest, MaxLayersWithRoundUpDisabled) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-SimulcastLayerLimitRoundUp/max_ratio:0.0/");
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const int kMaxLayers = 3;
+
+  std::vector<VideoStream> streams;
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 960, 540,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+  // <960x540: 2 layers
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 960, 539,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 270,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  // <480x270: 1 layer
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 269,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(1u, streams.size());
+}
+
+TEST(SimulcastTest, MaxLayersWithDefaultRoundUpRatio) {
+  // Default: "WebRTC-SimulcastLayerLimitRoundUp/max_ratio:0.1/"
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const int kMaxLayers = 3;
+
+  std::vector<VideoStream> streams;
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 960, 540,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+  // Lowest cropped height where max layers from higher resolution is used.
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 960, 512,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(3u, streams.size());
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 960, 508,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 270,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  // Lowest cropped height where max layers from higher resolution is used.
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 256,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 254,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(1u, streams.size());
+}
+
+TEST(SimulcastTest, MaxLayersWithRoundUpRatio) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-SimulcastLayerLimitRoundUp/max_ratio:0.13/");
+  FieldTrialBasedConfig trials;
+  const size_t kMinLayers = 1;
+  const int kMaxLayers = 3;
+
+  std::vector<VideoStream> streams;
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 270,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  // Lowest cropped height where max layers from higher resolution is used.
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 252,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(2u, streams.size());
+  streams = cricket::GetSimulcastConfig(kMinLayers, kMaxLayers, 480, 250,
+                                        kBitratePriority, kQpMax, !kScreenshare,
+                                        true, trials);
+  EXPECT_EQ(1u, streams.size());
+}
+
+TEST(SimulcastTest, BitratesInterpolatedForResBelow180p) {
+  // TODO(webrtc:12415): Remove when feature launches.
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LowresSimulcastBitrateInterpolation/Enabled/");
+
+  const size_t kMaxLayers = 3;
+  FieldTrialBasedConfig trials;
+
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      /* min_layers = */ 1, kMaxLayers, /* width = */ 960, /* height = */ 540,
+      kBitratePriority, kQpMax, !kScreenshare, true, trials);
+
+  ASSERT_EQ(streams.size(), kMaxLayers);
+  EXPECT_EQ(240u, streams[0].width);
+  EXPECT_EQ(135u, streams[0].height);
+  EXPECT_EQ(streams[0].max_bitrate_bps, 112500);
+  EXPECT_EQ(streams[0].target_bitrate_bps, 84375);
+  EXPECT_EQ(streams[0].min_bitrate_bps, 30000);
+}
+
+TEST(SimulcastTest, BitratesConsistentForVerySmallRes) {
+  // TODO(webrtc:12415): Remove when feature launches.
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LowresSimulcastBitrateInterpolation/Enabled/");
+
+  FieldTrialBasedConfig trials;
+
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      /* min_layers = */ 1, /* max_layers = */ 3, /* width = */ 1,
+      /* height = */ 1, kBitratePriority, kQpMax, !kScreenshare, true, trials);
+
+  ASSERT_TRUE(!streams.empty());
+  EXPECT_EQ(1u, streams[0].width);
+  EXPECT_EQ(1u, streams[0].height);
+  EXPECT_EQ(streams[0].max_bitrate_bps, 30000);
+  EXPECT_EQ(streams[0].target_bitrate_bps, 30000);
+  EXPECT_EQ(streams[0].min_bitrate_bps, 30000);
+}
+
+TEST(SimulcastTest,
+     BitratesNotInterpolatedForResBelow180pWhenDisabledTrialSet) {
+  test::ScopedFieldTrials field_trials(
+      "WebRTC-LowresSimulcastBitrateInterpolation/Disabled/");
+
+  const size_t kMaxLayers = 3;
+  FieldTrialBasedConfig trials;
+
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      /* min_layers = */ 1, kMaxLayers, /* width = */ 960, /* height = */ 540,
+      kBitratePriority, kQpMax, !kScreenshare, true, trials);
+
+  ASSERT_EQ(streams.size(), kMaxLayers);
+  EXPECT_EQ(240u, streams[0].width);
+  EXPECT_EQ(135u, streams[0].height);
+  EXPECT_EQ(streams[0].max_bitrate_bps, 200000);
+  EXPECT_EQ(streams[0].target_bitrate_bps, 150000);
+  EXPECT_EQ(streams[0].min_bitrate_bps, 30000);
+}
+
+}  // namespace webrtc