blob: 0b9926e18c89b09d0002be1763fb0a1c26561d19 [file] [log] [blame]
/*
* Copyright (c) 2019 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/encoder_overshoot_detector.h"
#include <algorithm>
namespace webrtc {
namespace {
// The buffer level for media-rate utilization is allowed to go below zero,
// down to
// -(|kMaxMediaUnderrunFrames| / |target_framerate_fps_|) * |target_bitrate_|.
static constexpr double kMaxMediaUnderrunFrames = 5.0;
} // namespace
EncoderOvershootDetector::EncoderOvershootDetector(int64_t window_size_ms)
: window_size_ms_(window_size_ms),
time_last_update_ms_(-1),
sum_network_utilization_factors_(0.0),
sum_media_utilization_factors_(0.0),
target_bitrate_(DataRate::Zero()),
target_framerate_fps_(0),
network_buffer_level_bits_(0),
media_buffer_level_bits_(0) {}
EncoderOvershootDetector::~EncoderOvershootDetector() = default;
void EncoderOvershootDetector::SetTargetRate(DataRate target_bitrate,
double target_framerate_fps,
int64_t time_ms) {
// First leak bits according to the previous target rate.
if (target_bitrate_ != DataRate::Zero()) {
LeakBits(time_ms);
} else if (target_bitrate != DataRate::Zero()) {
// Stream was just enabled, reset state.
time_last_update_ms_ = time_ms;
utilization_factors_.clear();
sum_network_utilization_factors_ = 0.0;
sum_media_utilization_factors_ = 0.0;
network_buffer_level_bits_ = 0;
media_buffer_level_bits_ = 0;
}
target_bitrate_ = target_bitrate;
target_framerate_fps_ = target_framerate_fps;
}
void EncoderOvershootDetector::OnEncodedFrame(size_t bytes, int64_t time_ms) {
// Leak bits from the virtual pacer buffer, according to the current target
// bitrate.
LeakBits(time_ms);
// Ideal size of a frame given the current rates.
const int64_t ideal_frame_size_bits = IdealFrameSizeBits();
if (ideal_frame_size_bits == 0) {
// Frame without updated bitrate and/or framerate, ignore it.
return;
}
const double network_utilization_factor = HandleEncodedFrame(
bytes * 8, ideal_frame_size_bits, time_ms, &network_buffer_level_bits_);
const double media_utilization_factor = HandleEncodedFrame(
bytes * 8, ideal_frame_size_bits, time_ms, &media_buffer_level_bits_);
sum_network_utilization_factors_ += network_utilization_factor;
sum_media_utilization_factors_ += media_utilization_factor;
utilization_factors_.emplace_back(network_utilization_factor,
media_utilization_factor, time_ms);
}
double EncoderOvershootDetector::HandleEncodedFrame(
size_t frame_size_bits,
int64_t ideal_frame_size_bits,
int64_t time_ms,
int64_t* buffer_level_bits) const {
// Add new frame to the buffer level. If doing so exceeds the ideal buffer
// size, penalize this frame but cap overshoot to current buffer level rather
// than size of this frame. This is done so that a single large frame is not
// penalized if the encoder afterwards compensates by dropping frames and/or
// reducing frame size. If however a large frame is followed by more data,
// we cannot pace that next frame out within one frame space.
const int64_t bitsum = frame_size_bits + *buffer_level_bits;
int64_t overshoot_bits = 0;
if (bitsum > ideal_frame_size_bits) {
overshoot_bits =
std::min(*buffer_level_bits, bitsum - ideal_frame_size_bits);
}
// Add entry for the (over) utilization for this frame. Factor is capped
// at 1.0 so that we don't risk overshooting on sudden changes.
double utilization_factor;
if (utilization_factors_.empty()) {
// First frame, cannot estimate overshoot based on previous one so
// for this particular frame, just like as size vs optimal size.
utilization_factor = std::max(
1.0, static_cast<double>(frame_size_bits) / ideal_frame_size_bits);
} else {
utilization_factor =
1.0 + (static_cast<double>(overshoot_bits) / ideal_frame_size_bits);
}
// Remove the overshot bits from the virtual buffer so we don't penalize
// those bits multiple times.
*buffer_level_bits -= overshoot_bits;
*buffer_level_bits += frame_size_bits;
return utilization_factor;
}
absl::optional<double>
EncoderOvershootDetector::GetNetworkRateUtilizationFactor(int64_t time_ms) {
CullOldUpdates(time_ms);
// No data points within window, return.
if (utilization_factors_.empty()) {
return absl::nullopt;
}
// TODO(sprang): Consider changing from arithmetic mean to some other
// function such as 90th percentile.
return sum_network_utilization_factors_ / utilization_factors_.size();
}
absl::optional<double> EncoderOvershootDetector::GetMediaRateUtilizationFactor(
int64_t time_ms) {
CullOldUpdates(time_ms);
// No data points within window, return.
if (utilization_factors_.empty()) {
return absl::nullopt;
}
return sum_media_utilization_factors_ / utilization_factors_.size();
}
void EncoderOvershootDetector::Reset() {
time_last_update_ms_ = -1;
utilization_factors_.clear();
target_bitrate_ = DataRate::Zero();
sum_network_utilization_factors_ = 0.0;
sum_media_utilization_factors_ = 0.0;
target_framerate_fps_ = 0.0;
network_buffer_level_bits_ = 0;
media_buffer_level_bits_ = 0;
}
int64_t EncoderOvershootDetector::IdealFrameSizeBits() const {
if (target_framerate_fps_ <= 0 || target_bitrate_ == DataRate::Zero()) {
return 0;
}
// Current ideal frame size, based on the current target bitrate.
return static_cast<int64_t>(
(target_bitrate_.bps() + target_framerate_fps_ / 2) /
target_framerate_fps_);
}
void EncoderOvershootDetector::LeakBits(int64_t time_ms) {
if (time_last_update_ms_ != -1 && target_bitrate_ > DataRate::Zero()) {
int64_t time_delta_ms = time_ms - time_last_update_ms_;
// Leak bits according to the current target bitrate.
const int64_t leaked_bits = (target_bitrate_.bps() * time_delta_ms) / 1000;
// Network buffer may not go below zero.
network_buffer_level_bits_ =
std::max<int64_t>(0, network_buffer_level_bits_ - leaked_bits);
// Media buffer my go down to minus |kMaxMediaUnderrunFrames| frames worth
// of data.
const double max_underrun_seconds =
std::min(kMaxMediaUnderrunFrames, target_framerate_fps_) /
target_framerate_fps_;
media_buffer_level_bits_ = std::max<int64_t>(
-max_underrun_seconds * target_bitrate_.bps<int64_t>(),
media_buffer_level_bits_ - leaked_bits);
}
time_last_update_ms_ = time_ms;
}
void EncoderOvershootDetector::CullOldUpdates(int64_t time_ms) {
// Cull old data points.
const int64_t cutoff_time_ms = time_ms - window_size_ms_;
while (!utilization_factors_.empty() &&
utilization_factors_.front().update_time_ms < cutoff_time_ms) {
// Make sure sum is never allowed to become negative due rounding errors.
sum_network_utilization_factors_ = std::max(
0.0, sum_network_utilization_factors_ -
utilization_factors_.front().network_utilization_factor);
sum_media_utilization_factors_ = std::max(
0.0, sum_media_utilization_factors_ -
utilization_factors_.front().media_utilization_factor);
utilization_factors_.pop_front();
}
}
} // namespace webrtc