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

QualityScaler: Add option to try fast adapt down at start up based on initial bw estimates.

Browse Source 
optional<int> initial_bitrate_interval_ms: time interval since start of call
where fast adapt down is allowed.
optional<double> initial_bitrate_factor: try fast adapt down if bw estimate is
below initial bitrate * factor.

Bug: none
Change-Id: I63e1fdaac6556d8e9a961a42e11c925f9ecb9771
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/147725
Reviewed-by: Sergey Silkin <ssilkin@webrtc.org>
Commit-Queue: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28753}
This commit is contained in:
Åsa Persson
2019-08-02 09:29:58 +02:00
committed by Commit Bot
parent fedd625e0c
commit 139f4dc7ac
7 changed files with 125 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
rtc_base/experiments/quality_scaler_settings.cc
View File

@ -23,9 +23,12 @@ QualityScalerSettings::QualityScalerSettings(
const WebRtcKeyValueConfig* const key_value_config)
: min_frames_("min_frames"),
initial_scale_factor_("initial_scale_factor"),
scale_factor_("scale_factor") {
scale_factor_("scale_factor"),
initial_bitrate_interval_ms_("initial_bitrate_interval_ms"),
initial_bitrate_factor_("initial_bitrate_factor") {
ParseFieldTrial(
{&min_frames_, &initial_scale_factor_, &scale_factor_},
{&min_frames_, &initial_scale_factor_, &scale_factor_,
&initial_bitrate_interval_ms_, &initial_bitrate_factor_},
key_value_config->Lookup("WebRTC-Video-QualityScalerSettings"));
}
@ -59,4 +62,22 @@ absl::optional<double> QualityScalerSettings::ScaleFactor() const {
return scale_factor_.GetOptional();
}
absl::optional<int> QualityScalerSettings::InitialBitrateIntervalMs() const {
if (initial_bitrate_interval_ms_ &&
initial_bitrate_interval_ms_.Value() < 0) {
RTC_LOG(LS_WARNING) << "Unsupported bitrate_interval value, ignored.";
return absl::nullopt;
}
return initial_bitrate_interval_ms_.GetOptional();
}
absl::optional<double> QualityScalerSettings::InitialBitrateFactor() const {
if (initial_bitrate_factor_ &&
initial_bitrate_factor_.Value() < kMinScaleFactor) {
RTC_LOG(LS_WARNING) << "Unsupported initial_bitrate_factor value, ignored.";
return absl::nullopt;
}
return initial_bitrate_factor_.GetOptional();
}
} // namespace webrtc

4
rtc_base/experiments/quality_scaler_settings.h
View File

@ -24,6 +24,8 @@ class QualityScalerSettings final {
absl::optional<int> MinFrames() const;
absl::optional<double> InitialScaleFactor() const;
absl::optional<double> ScaleFactor() const;
absl::optional<int> InitialBitrateIntervalMs() const;
absl::optional<double> InitialBitrateFactor() const;
private:
explicit QualityScalerSettings(
@ -32,6 +34,8 @@ class QualityScalerSettings final {
FieldTrialOptional<int> min_frames_;
FieldTrialOptional<double> initial_scale_factor_;
FieldTrialOptional<double> scale_factor_;
FieldTrialOptional<int> initial_bitrate_interval_ms_;
FieldTrialOptional<double> initial_bitrate_factor_;
};
} // namespace webrtc

41
rtc_base/experiments/quality_scaler_settings_unittest.cc
View File

@ -17,10 +17,12 @@ namespace webrtc {
namespace {
TEST(QualityScalerSettingsTest, ValuesNotSetByDefault) {
EXPECT_FALSE(QualityScalerSettings::ParseFromFieldTrials().MinFrames());
EXPECT_FALSE(
QualityScalerSettings::ParseFromFieldTrials().InitialScaleFactor());
EXPECT_FALSE(QualityScalerSettings::ParseFromFieldTrials().ScaleFactor());
const auto settings = QualityScalerSettings::ParseFromFieldTrials();
EXPECT_FALSE(settings.MinFrames());
EXPECT_FALSE(settings.InitialScaleFactor());
EXPECT_FALSE(settings.ScaleFactor());
EXPECT_FALSE(settings.InitialBitrateIntervalMs());
EXPECT_FALSE(settings.InitialBitrateFactor());
}
TEST(QualityScalerSettingsTest, ParseMinFrames) {
@ -42,34 +44,59 @@ TEST(QualityScalerSettingsTest, ParseScaleFactor) {
EXPECT_EQ(1.1, QualityScalerSettings::ParseFromFieldTrials().ScaleFactor());
}
TEST(QualityScalerSettingsTest, ParseInitialBitrateInterval) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/initial_bitrate_interval_ms:1000/");
EXPECT_EQ(
1000,
QualityScalerSettings::ParseFromFieldTrials().InitialBitrateIntervalMs());
}
TEST(QualityScalerSettingsTest, ParseInitialBitrateFactor) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/initial_bitrate_factor:0.75/");
EXPECT_EQ(
0.75,
QualityScalerSettings::ParseFromFieldTrials().InitialBitrateFactor());
}
TEST(QualityScalerSettingsTest, ParseAll) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/"
"min_frames:100,initial_scale_factor:1.5,scale_factor:0.9/");
"min_frames:100,initial_scale_factor:1.5,scale_factor:0.9,"
"initial_bitrate_interval_ms:5500,initial_bitrate_factor:0.7/");
const auto settings = QualityScalerSettings::ParseFromFieldTrials();
EXPECT_EQ(100, settings.MinFrames());
EXPECT_EQ(1.5, settings.InitialScaleFactor());
EXPECT_EQ(0.9, settings.ScaleFactor());
EXPECT_EQ(5500, settings.InitialBitrateIntervalMs());
EXPECT_EQ(0.7, settings.InitialBitrateFactor());
}
TEST(QualityScalerSettingsTest, DoesNotParseIncorrectValue) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/"
"min_frames:a,initial_scale_factor:b,scale_factor:c/");
"min_frames:a,initial_scale_factor:b,scale_factor:c,"
"initial_bitrate_interval_ms:d,initial_bitrate_factor:e/");
const auto settings = QualityScalerSettings::ParseFromFieldTrials();
EXPECT_FALSE(settings.MinFrames());
EXPECT_FALSE(settings.InitialScaleFactor());
EXPECT_FALSE(settings.ScaleFactor());
EXPECT_FALSE(settings.InitialBitrateIntervalMs());
EXPECT_FALSE(settings.InitialBitrateFactor());
}
TEST(QualityScalerSettingsTest, DoesNotReturnTooSmallValue) {
test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/"
"min_frames:0,initial_scale_factor:0.0,scale_factor:0.0/");
"min_frames:0,initial_scale_factor:0.0,scale_factor:0.0,"
"initial_bitrate_interval_ms:-1,initial_bitrate_factor:0.0/");
const auto settings = QualityScalerSettings::ParseFromFieldTrials();
EXPECT_FALSE(settings.MinFrames());
EXPECT_FALSE(settings.InitialScaleFactor());
EXPECT_FALSE(settings.ScaleFactor());
EXPECT_FALSE(settings.InitialBitrateIntervalMs());
EXPECT_FALSE(settings.InitialBitrateFactor());
}
} // namespace

1
video/BUILD.gn
View File

@ -213,6 +213,7 @@ rtc_source_set("video_stream_encoder_impl") {
"../rtc_base/experiments:alr_experiment",
"../rtc_base/experiments:balanced_degradation_settings",
"../rtc_base/experiments:field_trial_parser",
"../rtc_base/experiments:quality_scaler_settings",
"../rtc_base/experiments:quality_scaling_experiment",
"../rtc_base/experiments:rate_control_settings",
"../rtc_base/synchronization:sequence_checker",

22
video/video_stream_encoder.cc
View File

@ -479,6 +479,7 @@ VideoStreamEncoder::VideoStreamEncoder(
sink_(nullptr),
settings_(settings),
rate_control_settings_(RateControlSettings::ParseFromFieldTrials()),
quality_scaler_settings_(QualityScalerSettings::ParseFromFieldTrials()),
overuse_detector_(std::move(overuse_detector)),
encoder_stats_observer_(encoder_stats_observer),
encoder_initialized_(false),
@ -488,6 +489,9 @@ VideoStreamEncoder::VideoStreamEncoder(
crop_width_(0),
crop_height_(0),
encoder_start_bitrate_bps_(0),
set_start_bitrate_bps_(0),
set_start_bitrate_time_ms_(0),
has_seen_first_bwe_drop_(false),
max_data_payload_length_(0),
encoder_paused_and_dropped_frame_(false),
was_encode_called_since_last_initialization_(false),
@ -612,6 +616,8 @@ void VideoStreamEncoder::SetStartBitrate(int start_bitrate_bps) {
encoder_queue_.PostTask([this, start_bitrate_bps] {
RTC_DCHECK_RUN_ON(&encoder_queue_);
encoder_start_bitrate_bps_ = start_bitrate_bps;
set_start_bitrate_bps_ = start_bitrate_bps;
set_start_bitrate_time_ms_ = clock_->TimeInMilliseconds();
});
}
@ -1688,6 +1694,7 @@ void VideoStreamEncoder::OnBitrateUpdated(DataRate target_bitrate,
<< " link allocation bitrate = " << link_allocation.bps()
<< " packet loss " << static_cast<int>(fraction_lost)
<< " rtt " << round_trip_time_ms;
// On significant changes to BWE at the start of the call,
// enable frame drops to quickly react to jumps in available bandwidth.
if (encoder_start_bitrate_bps_ != 0 &&
@ -1701,6 +1708,21 @@ void VideoStreamEncoder::OnBitrateUpdated(DataRate target_bitrate,
initial_framedrop_ = 0;
has_seen_first_significant_bwe_change_ = true;
}
if (set_start_bitrate_bps_ > 0 && !has_seen_first_bwe_drop_ &&
quality_scaler_ && quality_scaler_settings_.InitialBitrateIntervalMs() &&
quality_scaler_settings_.InitialBitrateFactor()) {
int64_t diff_ms = clock_->TimeInMilliseconds() - set_start_bitrate_time_ms_;
if (diff_ms < quality_scaler_settings_.InitialBitrateIntervalMs().value() &&
(target_bitrate.bps() <
(set_start_bitrate_bps_ *
quality_scaler_settings_.InitialBitrateFactor().value()))) {
RTC_LOG(LS_INFO) << "Reset initial_framedrop_. Start bitrate: "
<< set_start_bitrate_bps_
<< ", target bitrate: " << target_bitrate.bps();
initial_framedrop_ = 0;
has_seen_first_bwe_drop_ = true;
}
}
if (encoder_) {
encoder_->OnPacketLossRateUpdate(static_cast<float>(fraction_lost) / 256.f);

5
video/video_stream_encoder.h
View File

@ -31,6 +31,7 @@
#include "rtc_base/critical_section.h"
#include "rtc_base/event.h"
#include "rtc_base/experiments/balanced_degradation_settings.h"
#include "rtc_base/experiments/quality_scaler_settings.h"
#include "rtc_base/experiments/rate_control_settings.h"
#include "rtc_base/race_checker.h"
#include "rtc_base/rate_statistics.h"
@ -238,6 +239,7 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
EncoderSink* sink_;
const VideoStreamEncoderSettings settings_;
const RateControlSettings rate_control_settings_;
const QualityScalerSettings quality_scaler_settings_;
const std::unique_ptr<OveruseFrameDetector> overuse_detector_
RTC_PT_GUARDED_BY(&encoder_queue_);
@ -271,6 +273,9 @@ class VideoStreamEncoder : public VideoStreamEncoderInterface,
int crop_width_ RTC_GUARDED_BY(&encoder_queue_);
int crop_height_ RTC_GUARDED_BY(&encoder_queue_);
uint32_t encoder_start_bitrate_bps_ RTC_GUARDED_BY(&encoder_queue_);
int set_start_bitrate_bps_ RTC_GUARDED_BY(&encoder_queue_);
int64_t set_start_bitrate_time_ms_ RTC_GUARDED_BY(&encoder_queue_);
bool has_seen_first_bwe_drop_ RTC_GUARDED_BY(&encoder_queue_);
size_t max_data_payload_length_ RTC_GUARDED_BY(&encoder_queue_);
absl::optional<EncoderRateSettings> last_encoder_rate_settings_
RTC_GUARDED_BY(&encoder_queue_);

36
video/video_stream_encoder_unittest.cc
View File

@ -3093,6 +3093,42 @@ TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenBWEstimateReady) {
video_stream_encoder_->Stop();
}
TEST_F(VideoStreamEncoderTest, InitialFrameDropActivatesWhenBweDrops) {
webrtc::test::ScopedFieldTrials field_trials(
"WebRTC-Video-QualityScalerSettings/"
"initial_bitrate_interval_ms:1000,initial_bitrate_factor:0.2/");
// Reset encoder for field trials to take effect.
ConfigureEncoder(video_encoder_config_.Copy());
const int kNotTooLowBitrateForFrameSizeBps = kTargetBitrateBps * 0.2;
const int kTooLowBitrateForFrameSizeBps = kTargetBitrateBps * 0.19;
const int kWidth = 640;
const int kHeight = 360;
video_stream_encoder_->OnBitrateUpdated(
DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps), 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
// Frame should not be dropped.
WaitForEncodedFrame(1);
video_stream_encoder_->OnBitrateUpdated(
DataRate::bps(kNotTooLowBitrateForFrameSizeBps),
DataRate::bps(kNotTooLowBitrateForFrameSizeBps), 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
// Frame should not be dropped.
WaitForEncodedFrame(2);
video_stream_encoder_->OnBitrateUpdated(
DataRate::bps(kTooLowBitrateForFrameSizeBps),
DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
// Expect to drop this frame, the wait should time out.
ExpectDroppedFrame();
// Expect the sink_wants to specify a scaled frame.
EXPECT_LT(video_source_.sink_wants().max_pixel_count, kWidth * kHeight);
video_stream_encoder_->Stop();
}
TEST_F(VideoStreamEncoderTest,
ResolutionNotAdaptedForTooSmallFrame_MaintainFramerateMode) {
const int kTooSmallWidth = 10;