Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright 2021 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/adaptation/bitrate_constraint.h"
#include <utility>
#include <vector>
#include "api/video_codecs/scalability_mode.h"
#include "api/video_codecs/video_encoder.h"
#include "call/adaptation/encoder_settings.h"
#include "call/adaptation/test/fake_frame_rate_provider.h"
#include "call/adaptation/video_source_restrictions.h"
#include "call/adaptation/video_stream_input_state_provider.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
const VideoSourceRestrictions k180p{/*max_pixels_per_frame=*/320 * 180,
/*target_pixels_per_frame=*/320 * 180,
/*max_frame_rate=*/30};
const VideoSourceRestrictions k360p{/*max_pixels_per_frame=*/640 * 360,
/*target_pixels_per_frame=*/640 * 360,
/*max_frame_rate=*/30};
const VideoSourceRestrictions k720p{/*max_pixels_per_frame=*/1280 * 720,
/*target_pixels_per_frame=*/1280 * 720,
/*max_frame_rate=*/30};
struct TestParams {
bool active;
absl::optional<ScalabilityMode> scalability_mode;
};
void FillCodecConfig(VideoCodec* video_codec,
VideoEncoderConfig* encoder_config,
int width_px,
int height_px,
const std::vector<TestParams>& params,
bool svc) {
size_t num_layers = params.size();
video_codec->codecType = kVideoCodecVP8;
video_codec->numberOfSimulcastStreams = svc ? 1 : num_layers;
encoder_config->number_of_streams = svc ? 1 : num_layers;
encoder_config->simulcast_layers.resize(num_layers);
for (size_t layer_idx = 0; layer_idx < num_layers; ++layer_idx) {
int layer_width_px = width_px >> (num_layers - 1 - layer_idx);
int layer_height_px = height_px >> (num_layers - 1 - layer_idx);
if (params[layer_idx].scalability_mode)
video_codec->SetScalabilityMode(*params[layer_idx].scalability_mode);
video_codec->simulcastStream[layer_idx].active = params[layer_idx].active;
video_codec->simulcastStream[layer_idx].width = layer_width_px;
video_codec->simulcastStream[layer_idx].height = layer_height_px;
encoder_config->simulcast_layers[layer_idx].scalability_mode =
params[layer_idx].scalability_mode;
encoder_config->simulcast_layers[layer_idx].active =
params[layer_idx].active;
encoder_config->simulcast_layers[layer_idx].width = layer_width_px;
encoder_config->simulcast_layers[layer_idx].height = layer_height_px;
}
}
constexpr int kStartBitrateBps360p = 500000;
constexpr int kStartBitrateBps720p = 1000000;
VideoEncoder::EncoderInfo MakeEncoderInfo() {
VideoEncoder::EncoderInfo encoder_info;
encoder_info.resolution_bitrate_limits = {
{640 * 360, kStartBitrateBps360p, 0, 5000000},
{1280 * 720, kStartBitrateBps720p, 0, 5000000},
{1920 * 1080, 2000000, 0, 5000000}};
return encoder_info;
}
} // namespace
class BitrateConstraintTest : public ::testing::Test {
public:
BitrateConstraintTest()
: frame_rate_provider_(), input_state_provider_(&frame_rate_provider_) {}
protected:
void OnEncoderSettingsUpdated(int width_px,
int height_px,
const std::vector<TestParams>& params,
bool svc = false) {
VideoCodec video_codec;
VideoEncoderConfig encoder_config;
FillCodecConfig(&video_codec, &encoder_config, width_px, height_px, params,
svc);
EncoderSettings encoder_settings(MakeEncoderInfo(),
std::move(encoder_config), video_codec);
bitrate_constraint_.OnEncoderSettingsUpdated(encoder_settings);
input_state_provider_.OnEncoderSettingsChanged(encoder_settings);
}
FakeFrameRateProvider frame_rate_provider_;
VideoStreamInputStateProvider input_state_provider_;
BitrateConstraint bitrate_constraint_;
};
TEST_F(BitrateConstraintTest, AdaptUpAllowedAtSinglecastIfBitrateIsEnough) {
OnEncoderSettingsUpdated(/*width_px=*/640, /*height_px=*/360,
{{.active = true}});
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpDisallowedAtSinglecastIfBitrateIsNotEnough) {
OnEncoderSettingsUpdated(/*width_px=*/640, /*height_px=*/360,
{{.active = true}});
// 1 bps less than needed for 720p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p - 1);
EXPECT_FALSE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedAtSinglecastIfBitrateIsEnoughForOneSpatialLayer) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL1T1}});
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpDisallowedAtSinglecastIfBitrateIsNotEnoughForOneSpatialLayer) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL1T1}});
// 1 bps less than needed for 720p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p - 1);
EXPECT_FALSE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedAtSinglecastIfBitrateIsNotEnoughForMultipleSpatialLayers) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL2T1}});
// 1 bps less than needed for 720p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p - 1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedAtSinglecastUpperLayerActiveIfBitrateIsEnough) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = false, .scalability_mode = ScalabilityMode::kL2T1},
{.active = true}});
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpDisallowedAtSinglecastUpperLayerActiveIfBitrateIsNotEnough) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = false, .scalability_mode = ScalabilityMode::kL2T1},
{.active = true}});
// 1 bps less than needed for 720p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p - 1);
EXPECT_FALSE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest, AdaptUpAllowedLowestActiveIfBitrateIsNotEnough) {
OnEncoderSettingsUpdated(/*width_px=*/640, /*height_px=*/360,
{{.active = true}, {.active = false}});
// 1 bps less than needed for 360p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps360p - 1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k180p,
/*restrictions_after=*/k360p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedLowestActiveIfBitrateIsNotEnoughForOneSpatialLayer) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL1T2},
{.active = false}});
// 1 bps less than needed for 360p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps360p - 1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k180p,
/*restrictions_after=*/k360p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedLowestActiveIfBitrateIsEnoughForOneSpatialLayerSvc) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL1T1},
{.active = false}},
/*svc=*/true);
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps360p);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k180p,
/*restrictions_after=*/k360p));
}
TEST_F(BitrateConstraintTest,
AdaptUpDisallowedLowestActiveIfBitrateIsNotEnoughForOneSpatialLayerSvc) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL1T1},
{.active = false}},
/*svc=*/true);
// 1 bps less than needed for 360p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps360p - 1);
EXPECT_FALSE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k180p,
/*restrictions_after=*/k360p));
}
TEST_F(BitrateConstraintTest,
AdaptUpAllowedLowestActiveIfBitrateIsNotEnoughForTwoSpatialLayersSvc) {
OnEncoderSettingsUpdated(
/*width_px=*/640, /*height_px=*/360,
{{.active = true, .scalability_mode = ScalabilityMode::kL2T1},
{.active = false}},
/*svc=*/true);
// 1 bps less than needed for 360p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps360p - 1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k180p,
/*restrictions_after=*/k360p));
}
TEST_F(BitrateConstraintTest, AdaptUpAllowedAtSimulcastIfBitrateIsNotEnough) {
OnEncoderSettingsUpdated(/*width_px=*/640, /*height_px=*/360,
{{.active = true}, {.active = true}});
// 1 bps less than needed for 720p.
bitrate_constraint_.OnEncoderTargetBitrateUpdated(kStartBitrateBps720p - 1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k720p));
}
TEST_F(BitrateConstraintTest,
AdaptUpInFpsAllowedAtNoResolutionIncreaseIfBitrateIsNotEnough) {
OnEncoderSettingsUpdated(/*width_px=*/640, /*height_px=*/360,
{{.active = true}});
bitrate_constraint_.OnEncoderTargetBitrateUpdated(1);
EXPECT_TRUE(bitrate_constraint_.IsAdaptationUpAllowed(
input_state_provider_.InputState(),
/*restrictions_before=*/k360p,
/*restrictions_after=*/k360p));
}
} // namespace webrtc