admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup unused field trial WebRTC-Video-BandwidthQualityScalerSettings

Browse Source 
Bug: webrtc:42221607, webrtc:42223115
Change-Id: I6eda70ce7c3e914f57fe1a70f33891a5742d985b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/349482
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42220}
This commit is contained in:
Danil Chapovalov 2024-05-03 10:55:23 +02:00 committed by WebRTC LUCI CQ
parent 5b643294af
commit 111d957ada
9 changed files with 58 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
experiments/field_trials.py
View File

@ -829,9 +829,6 @@ POLICY_EXEMPT_FIELD_TRIALS: FrozenSet[FieldTrial] = frozenset([
FieldTrial('WebRTC-Video-BalancedDegradationSettings',
NO_BUG,
INDEFINITE),
FieldTrial('WebRTC-Video-BandwidthQualityScalerSettings',
42223115,
INDEFINITE),
FieldTrial('WebRTC-Video-DisableAutomaticResize',
42221931,
date(2024, 4, 1)),
@ -893,7 +890,7 @@ POLICY_EXEMPT_FIELD_TRIALS: FrozenSet[FieldTrial] = frozenset([
]) # yapf: disable
POLICY_EXEMPT_FIELD_TRIALS_DIGEST: str = \
'263c7a29291a7c4472ff60c7c3b2520f6dd5cea8'
'f74a8c7f29f03ef83154393d0a7ea0b7258d7441'
REGISTERED_FIELD_TRIALS: FrozenSet[FieldTrial] = ACTIVE_FIELD_TRIALS.union(
POLICY_EXEMPT_FIELD_TRIALS)

1
modules/video_coding/BUILD.gn
View File

@ -443,7 +443,6 @@ rtc_library("video_coding_utility") {
"../../rtc_base:stringutils",
"../../rtc_base:timeutils",
"../../rtc_base:weak_ptr",
"../../rtc_base/experiments:bandwidth_quality_scaler_settings",
"../../rtc_base/experiments:encoder_info_settings",
"../../rtc_base/experiments:quality_scaler_settings",
"../../rtc_base/experiments:quality_scaling_experiment",

8
modules/video_coding/utility/bandwidth_quality_scaler.cc
View File

@ -18,7 +18,6 @@
#include "api/video/video_adaptation_reason.h"
#include "api/video_codecs/video_encoder.h"
#include "rtc_base/checks.h"
#include "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/exp_filter.h"
#include "rtc_base/time_utils.h"
@ -31,16 +30,11 @@ namespace {
constexpr int kDefaultMaxWindowSizeMs = 5000;
constexpr float kHigherMaxBitrateTolerationFactor = 0.95;
constexpr float kLowerMinBitrateTolerationFactor = 0.8;
constexpr int kDefaultBitrateStateUpdateIntervalSeconds = 5;
} // namespace
BandwidthQualityScaler::BandwidthQualityScaler(
BandwidthQualityScalerUsageHandlerInterface* handler)
: kBitrateStateUpdateInterval(TimeDelta::Seconds(
BandwidthQualityScalerSettings::ParseFromFieldTrials()
.BitrateStateUpdateInterval()
.value_or(kDefaultBitrateStateUpdateIntervalSeconds))),
handler_(handler),
: handler_(handler),
encoded_bitrate_(kDefaultMaxWindowSizeMs, RateStatistics::kBpsScale),
weak_ptr_factory_(this) {
RTC_DCHECK_RUN_ON(&task_checker_);

5
modules/video_coding/utility/bandwidth_quality_scaler.h
View File

@ -46,6 +46,9 @@ class BandwidthQualityScalerUsageHandlerInterface {
// stream down or up).
class BandwidthQualityScaler {
public:
static constexpr TimeDelta kBitrateStateUpdateInterval =
TimeDelta::Seconds(5);
explicit BandwidthQualityScaler(
BandwidthQualityScalerUsageHandlerInterface* handler);
virtual ~BandwidthQualityScaler();
@ -62,8 +65,6 @@ class BandwidthQualityScaler {
const std::vector<VideoEncoder::ResolutionBitrateLimits>&
resolution_bitrate_limits);
const TimeDelta kBitrateStateUpdateInterval;
private:
enum class CheckBitrateResult {
kInsufficientSamples,

125
modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
View File

@ -19,15 +19,15 @@
#include "rtc_base/experiments/encoder_info_settings.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/time_utils.h"
#include "test/field_trial.h"
#include "test/gtest.h"
#include "test/time_controller/simulated_time_controller.h"
namespace webrtc {
namespace {
constexpr int kFramerateFps = 30;
constexpr TimeDelta kDefaultBitrateStateUpdateInterval = TimeDelta::Seconds(5);
constexpr TimeDelta kDefaultEncodeTime = TimeDelta::Seconds(1) / kFramerateFps;
constexpr TimeDelta kWaitTime = TimeDelta::Millis(200);
} // namespace
@ -50,20 +50,7 @@ class FakeBandwidthQualityScalerHandler
int adapt_down_event_count_ = 0;
};
class BandwidthQualityScalerUnderTest : public BandwidthQualityScaler {
public:
explicit BandwidthQualityScalerUnderTest(
BandwidthQualityScalerUsageHandlerInterface* handler)
: BandwidthQualityScaler(handler) {}
int GetBitrateStateUpdateIntervalMs() {
return this->kBitrateStateUpdateInterval.ms() + 200;
}
};
class BandwidthQualityScalerTest
: public ::testing::Test,
public ::testing::WithParamInterface<std::string> {
class BandwidthQualityScalerTest : public ::testing::Test {
protected:
enum ScaleDirection {
kKeepScaleNormalBandwidth,
@ -94,13 +81,13 @@ class BandwidthQualityScalerTest
};
BandwidthQualityScalerTest()
: scoped_field_trial_(GetParam()),
task_queue_("BandwidthQualityScalerTestQueue"),
: task_queue_(time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
"BandwidthQualityScalerTestQueue",
TaskQueueFactory::Priority::NORMAL)),
handler_(std::make_unique<FakeBandwidthQualityScalerHandler>()) {
task_queue_.SendTask([this] {
bandwidth_quality_scaler_ =
std::unique_ptr<BandwidthQualityScalerUnderTest>(
new BandwidthQualityScalerUnderTest(handler_.get()));
std::make_unique<BandwidthQualityScaler>(handler_.get());
bandwidth_quality_scaler_->SetResolutionBitrateLimits(
EncoderInfoSettings::
GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
@ -149,52 +136,51 @@ class BandwidthQualityScalerTest
void TriggerBandwidthQualityScalerTest(
const std::vector<FrameConfig>& frame_configs) {
task_queue_.SendTask([frame_configs, this] {
RTC_CHECK(!frame_configs.empty());
RTC_CHECK(!frame_configs.empty());
int total_frame_nums = 0;
for (const FrameConfig& frame_config : frame_configs) {
total_frame_nums += frame_config.frame_num;
int total_frame_nums = 0;
for (const FrameConfig& frame_config : frame_configs) {
total_frame_nums += frame_config.frame_num;
}
EXPECT_EQ(kFramerateFps *
BandwidthQualityScaler::kBitrateStateUpdateInterval.seconds(),
total_frame_nums);
TimeDelta delay = TimeDelta::Zero();
int num_delayed_tasks = 0;
for (const FrameConfig& config : frame_configs) {
absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate =
GetDefaultSuitableBitrateLimit(config.actual_width *
config.actual_height);
EXPECT_TRUE(suitable_bitrate);
for (int j = 0; j <= config.frame_num; ++j) {
delay += kDefaultEncodeTime;
int frame_size_bytes = GetFrameSizeBytes(config, *suitable_bitrate);
RTC_CHECK_GT(frame_size_bytes, 0);
++num_delayed_tasks;
task_queue_.PostDelayedTask(
[frame_size_bytes, config, &num_delayed_tasks, this] {
bandwidth_quality_scaler_->ReportEncodeInfo(
frame_size_bytes,
time_controller_.GetClock()->CurrentTime().ms(),
config.actual_width, config.actual_height);
--num_delayed_tasks;
},
delay);
}
EXPECT_EQ(kFramerateFps * kDefaultBitrateStateUpdateInterval.seconds(),
total_frame_nums);
uint32_t time_send_to_scaler_ms_ = rtc::TimeMillis();
for (size_t i = 0; i < frame_configs.size(); ++i) {
const FrameConfig& config = frame_configs[i];
absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate =
GetDefaultSuitableBitrateLimit(config.actual_width *
config.actual_height);
EXPECT_TRUE(suitable_bitrate);
for (int j = 0; j <= config.frame_num; ++j) {
time_send_to_scaler_ms_ += kDefaultEncodeTime.ms();
int frame_size_bytes =
GetFrameSizeBytes(config, suitable_bitrate.value());
RTC_CHECK(frame_size_bytes > 0);
bandwidth_quality_scaler_->ReportEncodeInfo(
frame_size_bytes, time_send_to_scaler_ms_, config.actual_width,
config.actual_height);
}
}
});
}
time_controller_.AdvanceTime(delay);
ASSERT_TRUE(time_controller_.Wait([&] { return num_delayed_tasks == 0; }));
}
test::ScopedFieldTrials scoped_field_trial_;
GlobalSimulatedTimeController time_controller_{Timestamp::Seconds(1234)};
TaskQueueForTest task_queue_;
std::unique_ptr<BandwidthQualityScalerUnderTest> bandwidth_quality_scaler_;
std::unique_ptr<BandwidthQualityScaler> bandwidth_quality_scaler_;
std::unique_ptr<FakeBandwidthQualityScalerHandler> handler_;
};
INSTANTIATE_TEST_SUITE_P(
FieldTrials,
BandwidthQualityScalerTest,
::testing::Values("WebRTC-Video-BandwidthQualityScalerSettings/"
"bitrate_state_update_interval_s_:1/",
"WebRTC-Video-BandwidthQualityScalerSettings/"
"bitrate_state_update_interval_s_:2/"));
TEST_P(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
TEST_F(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
const std::vector<FrameConfig> frame_configs{
FrameConfig(150, FrameType::kNormalFrame, 640, 360)};
TriggerBandwidthQualityScalerTest(frame_configs);
@ -202,13 +188,12 @@ TEST_P(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 654253, so it falls in the range
// without any operation(up/down).
EXPECT_FALSE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_FALSE(handler_->event_.Wait(kWaitTime));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(0, handler_->adapt_up_event_count_);
}
TEST_P(BandwidthQualityScalerTest, AllNoramlFrame_AboveMaxBandwidth_640x360) {
TEST_F(BandwidthQualityScalerTest, AllNormalFrame_AboveMaxBandwidth_640x360) {
const std::vector<FrameConfig> frame_configs{
FrameConfig(150, FrameType::kNormalFrame_Overuse, 640, 360)};
TriggerBandwidthQualityScalerTest(frame_configs);
@ -216,13 +201,12 @@ TEST_P(BandwidthQualityScalerTest, AllNoramlFrame_AboveMaxBandwidth_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1208000 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}
TEST_P(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
TEST_F(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
const std::vector<FrameConfig> frame_configs{
FrameConfig(150, FrameType::kNormalFrame_Underuse, 640, 360)};
TriggerBandwidthQualityScalerTest(frame_configs);
@ -230,13 +214,12 @@ TEST_P(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 377379 < 500000 * 0.8, so it
// triggers adapt_down_event_count_.
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
EXPECT_EQ(1, handler_->adapt_down_event_count_);
EXPECT_EQ(0, handler_->adapt_up_event_count_);
}
TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
TEST_F(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
const std::vector<FrameConfig> frame_configs{
FrameConfig(5, FrameType::kNormalFrame_Underuse, 640, 360),
FrameConfig(110, FrameType::kNormalFrame, 640, 360),
@ -248,13 +231,12 @@ TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}
TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
TEST_F(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
const std::vector<FrameConfig> frame_configs{
FrameConfig(10, FrameType::kNormalFrame_Underuse, 640, 360),
FrameConfig(50, FrameType::kNormalFrame, 640, 360),
@ -266,8 +248,7 @@ TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
// When resolution is 640*360, experimental working bitrate range is
// [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
// triggers adapt_up_event_count_.
EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
EXPECT_EQ(0, handler_->adapt_down_event_count_);
EXPECT_EQ(1, handler_->adapt_up_event_count_);
}

17
rtc_base/experiments/BUILD.gn
View File

@ -78,21 +78,6 @@ rtc_library("quality_scaler_settings") {
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
rtc_library("bandwidth_quality_scaler_settings") {
sources = [
"bandwidth_quality_scaler_settings.cc",
"bandwidth_quality_scaler_settings.h",
]
deps = [
":field_trial_parser",
"..:logging",
"../../api:field_trials_view",
"../../api/transport:field_trial_based_config",
"../../system_wrappers:field_trial",
]
absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
}
rtc_library("quality_scaling_experiment") {
sources = [
"quality_scaling_experiment.cc",
@ -224,7 +209,6 @@ if (rtc_include_tests && !build_with_chromium) {
sources = [
"balanced_degradation_settings_unittest.cc",
"bandwidth_quality_scaler_settings_unittest.cc",
"encoder_info_settings_unittest.cc",
"field_trial_list_unittest.cc",
"field_trial_parser_unittest.cc",
@ -241,7 +225,6 @@ if (rtc_include_tests && !build_with_chromium) {
]
deps = [
":balanced_degradation_settings",
":bandwidth_quality_scaler_settings",
":encoder_info_settings",
":field_trial_parser",
":keyframe_interval_settings_experiment",

43
rtc_base/experiments/bandwidth_quality_scaler_settings.cc
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 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 "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
#include "api/transport/field_trial_based_config.h"
#include "rtc_base/logging.h"
namespace webrtc {
BandwidthQualityScalerSettings::BandwidthQualityScalerSettings(
const FieldTrialsView* const key_value_config)
: bitrate_state_update_interval_s_("bitrate_state_update_interval_s_") {
ParseFieldTrial(
{&bitrate_state_update_interval_s_},
key_value_config->Lookup("WebRTC-Video-BandwidthQualityScalerSettings"));
}
BandwidthQualityScalerSettings
BandwidthQualityScalerSettings::ParseFromFieldTrials() {
FieldTrialBasedConfig field_trial_config;
return BandwidthQualityScalerSettings(&field_trial_config);
}
absl::optional<uint32_t>
BandwidthQualityScalerSettings::BitrateStateUpdateInterval() const {
if (bitrate_state_update_interval_s_ &&
bitrate_state_update_interval_s_.Value() <= 0) {
RTC_LOG(LS_WARNING)
<< "Unsupported bitrate_state_update_interval_s_ value, ignored.";
return absl::nullopt;
}
return bitrate_state_update_interval_s_.GetOptional();
}
} // namespace webrtc

35
rtc_base/experiments/bandwidth_quality_scaler_settings.h
View File

@ -1,35 +0,0 @@
/*
* Copyright (c) 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.
*/
#ifndef RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_
#define RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_
#include "absl/types/optional.h"
#include "api/field_trials_view.h"
#include "rtc_base/experiments/field_trial_parser.h"
namespace webrtc {
class BandwidthQualityScalerSettings final {
public:
static BandwidthQualityScalerSettings ParseFromFieldTrials();
absl::optional<uint32_t> BitrateStateUpdateInterval() const;
private:
explicit BandwidthQualityScalerSettings(
const FieldTrialsView* const key_value_config);
FieldTrialOptional<uint32_t> bitrate_state_update_interval_s_;
};
} // namespace webrtc
#endif // RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_

49
rtc_base/experiments/bandwidth_quality_scaler_settings_unittest.cc
View File

@ -1,49 +0,0 @@
/*
* 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 "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
#include "test/field_trial.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
TEST(BandwidthQualityScalerSettingsTest, ValuesNotSetByDefault) {
const auto settings = BandwidthQualityScalerSettings::ParseFromFieldTrials();
EXPECT_FALSE(settings.BitrateStateUpdateInterval());
}
TEST(BandwidthQualityScalerSettingsTest, ParseBitrateStateUpdateInterval) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-BandwidthQualityScalerSettings/"
"bitrate_state_update_interval_s_:100/");
EXPECT_EQ(100u, BandwidthQualityScalerSettings::ParseFromFieldTrials()
.BitrateStateUpdateInterval());
}
TEST(BandwidthQualityScalerSettingsTest, ParseAll) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-BandwidthQualityScalerSettings/"
"bitrate_state_update_interval_s_:100/");
EXPECT_EQ(100u, BandwidthQualityScalerSettings::ParseFromFieldTrials()
.BitrateStateUpdateInterval());
}
TEST(BandwidthQualityScalerSettingsTest, DoesNotParseIncorrectValue) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-BandwidthQualityScalerSettings/"
"bitrate_state_update_interval_s_:??/");
const auto settings = BandwidthQualityScalerSettings::ParseFromFieldTrials();
EXPECT_FALSE(settings.BitrateStateUpdateInterval());
}
} // namespace
} // namespace webrtc