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

Reland of Make QualityScaler more responsive to downgrades. (patchset #1 id:1 of https://codereview.webrtc.org/1880103002/ )

Browse Source 
Reason for revert:
Regressed behavior is actually desirable (go down to 360p instead of producing super-bad 720p).

Original issue's description:
> Revert of Make QualityScaler more responsive to downgrades. (patchset #3 id:40001 of https://codereview.webrtc.org/1830593003/ )
>
> Reason for revert:
> Speculative revert: want to see if this causes the regression in https://crbug.com/602621
>
> Original issue's description:
> > Make QualityScaler more responsive to downgrades.
> >
> > Permits going from HD to QVGA in 6 seconds instead of 10. Also adds
> > windows for going up quickly in the beginning of a call (before any
> > downscaling happens due to bad quality).
> >
> > BUG=webrtc:5678
> > R=glaznev@webrtc.org, stefan@webrtc.org
> >
> > Committed: https://crrev.com/85829fd90cc4e7a91c9857921b19e8fc126aeb60
> > Cr-Commit-Position: refs/heads/master@{#12219}
>
> TBR=glaznev@webrtc.org,stefan@webrtc.org,pbos@webrtc.org
> # Not skipping CQ checks because original CL landed more than 1 days ago.
> BUG=webrtc:5678
> NOTRY=true
>
> Committed: https://crrev.com/19b4fecf08e3fe215e431a260fb673553c15e569
> Cr-Commit-Position: refs/heads/master@{#12331}

TBR=glaznev@webrtc.org,stefan@webrtc.org,phoglund@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=chromium:602621, webrtc:5678

Review URL: https://codereview.webrtc.org/1887493003

Cr-Commit-Position: refs/heads/master@{#12341}
This commit is contained in:
pbos
2016-04-13 02:51:02 -07:00
committed by Commit bot
parent afaae0d151
commit cbac40d321
5 changed files with 146 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
webrtc/modules/video_coding/utility/quality_scaler.cc
View File

@ -11,8 +11,11 @@
namespace webrtc {
static const int kMinFps = 10;
static const int kMeasureSeconds = 5;
static const int kMinFps = 5;
static const int kMeasureSecondsDownscale = 3;
// Threshold constant used until first downscale (to permit fast rampup).
static const int kMeasureSecondsFastUpscale = 2;
static const int kMeasureSecondsUpscale = 5;
static const int kFramedropPercentThreshold = 60;
static const int kHdResolutionThreshold = 700 * 500;
static const int kHdBitrateThresholdKbps = 500;
@ -23,9 +26,7 @@ const int QualityScaler::kDefaultLowQpDenominator = 3;
const int QualityScaler::kDefaultMinDownscaleDimension = 90;
QualityScaler::QualityScaler()
: num_samples_(0),
low_qp_threshold_(-1),
downscale_shift_(0),
: low_qp_threshold_(-1),
framerate_down_(false),
min_width_(kDefaultMinDownscaleDimension),
min_height_(kDefaultMinDownscaleDimension) {}
@ -35,12 +36,17 @@ void QualityScaler::Init(int low_qp_threshold,
bool use_framerate_reduction,
int initial_bitrate_kbps,
int width,
int height) {
int height,
int fps) {
ClearSamples();
low_qp_threshold_ = low_qp_threshold;
high_qp_threshold_ = high_qp_threshold;
use_framerate_reduction_ = use_framerate_reduction;
downscale_shift_ = 0;
// Use a faster window for upscaling initially (but be more graceful later).
// This enables faster initial rampups without risking strong up-down
// behavior later.
measure_seconds_upscale_ = kMeasureSecondsFastUpscale;
const int init_width = width;
const int init_height = height;
// TODO(glaznev): Investigate using thresholds for other resolutions
@ -55,6 +61,7 @@ void QualityScaler::Init(int low_qp_threshold,
}
}
UpdateTargetResolution(init_width, init_height);
ReportFramerate(fps);
target_framerate_ = -1;
}
@ -65,14 +72,14 @@ void QualityScaler::SetMinResolution(int min_width, int min_height) {
// Report framerate(fps) to estimate # of samples.
void QualityScaler::ReportFramerate(int framerate) {
num_samples_ = static_cast<size_t>(
kMeasureSeconds * (framerate < kMinFps ? kMinFps : framerate));
framerate_ = framerate;
UpdateSampleCounts();
}
void QualityScaler::ReportQP(int qp) {
framedrop_percent_.AddSample(0);
average_qp_.AddSample(qp);
average_qp_downscale_.AddSample(qp);
average_qp_upscale_.AddSample(qp);
}
void QualityScaler::ReportDroppedFrame() {
@ -82,7 +89,8 @@ void QualityScaler::ReportDroppedFrame() {
void QualityScaler::OnEncodeFrame(const VideoFrame& frame) {
// Should be set through InitEncode -> Should be set by now.
assert(low_qp_threshold_ >= 0);
assert(num_samples_ > 0);
assert(num_samples_upscale_ > 0);
assert(num_samples_downscale_ > 0);
// Update scale factor.
int avg_drop = 0;
@ -90,9 +98,9 @@ void QualityScaler::OnEncodeFrame(const VideoFrame& frame) {
// When encoder consistently overshoots, framerate reduction and spatial
// resizing will be triggered to get a smoother video.
if ((framedrop_percent_.GetAverage(num_samples_, &avg_drop) &&
if ((framedrop_percent_.GetAverage(num_samples_downscale_, &avg_drop) &&
avg_drop >= kFramedropPercentThreshold) ||
(average_qp_.GetAverage(num_samples_, &avg_qp) &&
(average_qp_downscale_.GetAverage(num_samples_downscale_, &avg_qp) &&
avg_qp > high_qp_threshold_)) {
// Reducing frame rate before spatial resolution change.
// Reduce frame rate only when it is above a certain number.
@ -107,7 +115,7 @@ void QualityScaler::OnEncodeFrame(const VideoFrame& frame) {
} else {
AdjustScale(false);
}
} else if (average_qp_.GetAverage(num_samples_, &avg_qp) &&
} else if (average_qp_upscale_.GetAverage(num_samples_upscale_, &avg_qp) &&
avg_qp <= low_qp_threshold_) {
if (use_framerate_reduction_ && framerate_down_) {
target_framerate_ = -1;
@ -160,13 +168,26 @@ void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
void QualityScaler::ClearSamples() {
framedrop_percent_.Reset();
average_qp_.Reset();
average_qp_downscale_.Reset();
average_qp_upscale_.Reset();
}
void QualityScaler::UpdateSampleCounts() {
num_samples_downscale_ = static_cast<size_t>(
kMeasureSecondsDownscale * (framerate_ < kMinFps ? kMinFps : framerate_));
num_samples_upscale_ = static_cast<size_t>(
measure_seconds_upscale_ * (framerate_ < kMinFps ? kMinFps : framerate_));
}
void QualityScaler::AdjustScale(bool up) {
downscale_shift_ += up ? -1 : 1;
if (downscale_shift_ < 0)
downscale_shift_ = 0;
if (!up) {
// Hit first downscale, start using a slower threshold for going up.
measure_seconds_upscale_ = kMeasureSecondsUpscale;
UpdateSampleCounts();
}
ClearSamples();
}