mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-14 06:10:40 +01:00
73cf80a932
At the point where an EncodedImage is reported to the EncoderBitrateAdjuster (in order to estimate utilization), the image data has been cleared so the size is 0 - meaning the esimtated utilization is 0 so pushback is in effect only applied at the beginning before an estimate is available. This CL fixes that by explicitly using spatial/temporal id and size in bytes, rather than passing along the EncodedImage proxy. It is unclear when this broke, but the regression seems rather old. This CL will affect the encoded bitrate (and thus indirectly BWE ramp-up rate), but should avoid exessive delay at low bitrates. Perf bots will likely trigger alerts, this is expected. In case there are undesired side-effects, we can entirely disable the adjuster using existing field-trials. Bug: webrtc:12606 Change-Id: I936c2045f554696d8b4bb518eee6871ffc12c47d Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/212900 Commit-Queue: Erik Språng <sprang@webrtc.org> Reviewed-by: Philip Eliasson <philipel@webrtc.org> Cr-Commit-Position: refs/heads/master@{#33550}
525 lines
22 KiB
C++
525 lines
22 KiB
C++
/*
|
|
* 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_bitrate_adjuster.h"
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "api/units/data_rate.h"
|
|
#include "rtc_base/fake_clock.h"
|
|
#include "rtc_base/numerics/safe_conversions.h"
|
|
#include "test/field_trial.h"
|
|
#include "test/gtest.h"
|
|
|
|
namespace webrtc {
|
|
namespace test {
|
|
|
|
class EncoderBitrateAdjusterTest : public ::testing::Test {
|
|
public:
|
|
static constexpr int64_t kWindowSizeMs = 3000;
|
|
static constexpr int kDefaultBitrateBps = 300000;
|
|
static constexpr int kDefaultFrameRateFps = 30;
|
|
// For network utilization higher than media utilization, loop over a
|
|
// sequence where the first half undershoots and the second half overshoots
|
|
// by the same amount.
|
|
static constexpr int kSequenceLength = 4;
|
|
static_assert(kSequenceLength % 2 == 0, "Sequence length must be even.");
|
|
|
|
EncoderBitrateAdjusterTest()
|
|
: target_bitrate_(DataRate::BitsPerSec(kDefaultBitrateBps)),
|
|
target_framerate_fps_(kDefaultFrameRateFps),
|
|
tl_pattern_idx_{},
|
|
sequence_idx_{} {}
|
|
|
|
protected:
|
|
void SetUpAdjuster(size_t num_spatial_layers,
|
|
size_t num_temporal_layers,
|
|
bool vp9_svc) {
|
|
// Initialize some default VideoCodec instance with the given number of
|
|
// layers.
|
|
if (vp9_svc) {
|
|
codec_.codecType = VideoCodecType::kVideoCodecVP9;
|
|
codec_.numberOfSimulcastStreams = 1;
|
|
codec_.VP9()->numberOfSpatialLayers = num_spatial_layers;
|
|
codec_.VP9()->numberOfTemporalLayers = num_temporal_layers;
|
|
for (size_t si = 0; si < num_spatial_layers; ++si) {
|
|
codec_.spatialLayers[si].minBitrate = 100 * (1 << si);
|
|
codec_.spatialLayers[si].targetBitrate = 200 * (1 << si);
|
|
codec_.spatialLayers[si].maxBitrate = 300 * (1 << si);
|
|
codec_.spatialLayers[si].active = true;
|
|
codec_.spatialLayers[si].numberOfTemporalLayers = num_temporal_layers;
|
|
}
|
|
} else {
|
|
codec_.codecType = VideoCodecType::kVideoCodecVP8;
|
|
codec_.numberOfSimulcastStreams = num_spatial_layers;
|
|
codec_.VP8()->numberOfTemporalLayers = num_temporal_layers;
|
|
for (size_t si = 0; si < num_spatial_layers; ++si) {
|
|
codec_.simulcastStream[si].minBitrate = 100 * (1 << si);
|
|
codec_.simulcastStream[si].targetBitrate = 200 * (1 << si);
|
|
codec_.simulcastStream[si].maxBitrate = 300 * (1 << si);
|
|
codec_.simulcastStream[si].active = true;
|
|
codec_.simulcastStream[si].numberOfTemporalLayers = num_temporal_layers;
|
|
}
|
|
}
|
|
|
|
for (size_t si = 0; si < num_spatial_layers; ++si) {
|
|
encoder_info_.fps_allocation[si].resize(num_temporal_layers);
|
|
double fraction = 1.0;
|
|
for (int ti = num_temporal_layers - 1; ti >= 0; --ti) {
|
|
encoder_info_.fps_allocation[si][ti] = static_cast<uint8_t>(
|
|
VideoEncoder::EncoderInfo::kMaxFramerateFraction * fraction + 0.5);
|
|
fraction /= 2.0;
|
|
}
|
|
}
|
|
|
|
adjuster_ = std::make_unique<EncoderBitrateAdjuster>(codec_);
|
|
adjuster_->OnEncoderInfo(encoder_info_);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
}
|
|
|
|
void InsertFrames(std::vector<std::vector<double>> media_utilization_factors,
|
|
int64_t duration_ms) {
|
|
InsertFrames(media_utilization_factors, media_utilization_factors,
|
|
duration_ms);
|
|
}
|
|
|
|
void InsertFrames(
|
|
std::vector<std::vector<double>> media_utilization_factors,
|
|
std::vector<std::vector<double>> network_utilization_factors,
|
|
int64_t duration_ms) {
|
|
RTC_DCHECK_EQ(media_utilization_factors.size(),
|
|
network_utilization_factors.size());
|
|
|
|
const int64_t start_us = rtc::TimeMicros();
|
|
while (rtc::TimeMicros() <
|
|
start_us + (duration_ms * rtc::kNumMicrosecsPerMillisec)) {
|
|
clock_.AdvanceTime(TimeDelta::Seconds(1) / target_framerate_fps_);
|
|
for (size_t si = 0; si < NumSpatialLayers(); ++si) {
|
|
const std::vector<int>& tl_pattern =
|
|
kTlPatterns[NumTemporalLayers(si) - 1];
|
|
const size_t ti =
|
|
tl_pattern[(tl_pattern_idx_[si]++) % tl_pattern.size()];
|
|
|
|
uint32_t layer_bitrate_bps =
|
|
current_adjusted_allocation_.GetBitrate(si, ti);
|
|
double layer_framerate_fps = target_framerate_fps_;
|
|
if (encoder_info_.fps_allocation[si].size() > ti) {
|
|
uint8_t layer_fps_fraction = encoder_info_.fps_allocation[si][ti];
|
|
if (ti > 0) {
|
|
// We're interested in the frame rate for this layer only, not
|
|
// cumulative frame rate.
|
|
layer_fps_fraction -= encoder_info_.fps_allocation[si][ti - 1];
|
|
}
|
|
layer_framerate_fps =
|
|
(target_framerate_fps_ * layer_fps_fraction) /
|
|
VideoEncoder::EncoderInfo::kMaxFramerateFraction;
|
|
}
|
|
double media_utilization_factor = 1.0;
|
|
double network_utilization_factor = 1.0;
|
|
if (media_utilization_factors.size() > si) {
|
|
RTC_DCHECK_EQ(media_utilization_factors[si].size(),
|
|
network_utilization_factors[si].size());
|
|
if (media_utilization_factors[si].size() > ti) {
|
|
media_utilization_factor = media_utilization_factors[si][ti];
|
|
network_utilization_factor = network_utilization_factors[si][ti];
|
|
}
|
|
}
|
|
RTC_DCHECK_GE(network_utilization_factor, media_utilization_factor);
|
|
|
|
// Frame size based on constant (media) overshoot.
|
|
const size_t media_frame_size = media_utilization_factor *
|
|
(layer_bitrate_bps / 8.0) /
|
|
layer_framerate_fps;
|
|
|
|
constexpr int kFramesWithPenalty = (kSequenceLength / 2) - 1;
|
|
RTC_DCHECK_GT(kFramesWithPenalty, 0);
|
|
|
|
// The positive/negative size diff needed to achieve network rate but
|
|
// not media rate penalty is the difference between the utilization
|
|
// factors times the media rate frame size, then scaled by the fraction
|
|
// between total frames and penalized frames in the sequence.
|
|
// Cap to media frame size to avoid negative size undershoot.
|
|
const size_t network_frame_size_diff_bytes = std::min(
|
|
media_frame_size,
|
|
static_cast<size_t>(
|
|
(((network_utilization_factor - media_utilization_factor) *
|
|
media_frame_size) *
|
|
kSequenceLength) /
|
|
kFramesWithPenalty +
|
|
0.5));
|
|
|
|
int sequence_idx = sequence_idx_[si][ti];
|
|
sequence_idx_[si][ti] = (sequence_idx_[si][ti] + 1) % kSequenceLength;
|
|
const DataSize frame_size = DataSize::Bytes(
|
|
(sequence_idx < kSequenceLength / 2)
|
|
? media_frame_size - network_frame_size_diff_bytes
|
|
: media_frame_size + network_frame_size_diff_bytes);
|
|
|
|
adjuster_->OnEncodedFrame(frame_size, si, ti);
|
|
sequence_idx = ++sequence_idx % kSequenceLength;
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t NumSpatialLayers() const {
|
|
if (codec_.codecType == VideoCodecType::kVideoCodecVP9) {
|
|
return codec_.VP9().numberOfSpatialLayers;
|
|
}
|
|
return codec_.numberOfSimulcastStreams;
|
|
}
|
|
|
|
size_t NumTemporalLayers(int spatial_index) {
|
|
if (codec_.codecType == VideoCodecType::kVideoCodecVP9) {
|
|
return codec_.spatialLayers[spatial_index].numberOfTemporalLayers;
|
|
}
|
|
return codec_.simulcastStream[spatial_index].numberOfTemporalLayers;
|
|
}
|
|
|
|
void ExpectNear(const VideoBitrateAllocation& expected_allocation,
|
|
const VideoBitrateAllocation& actual_allocation,
|
|
double allowed_error_fraction) {
|
|
for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
|
|
for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
|
|
if (expected_allocation.HasBitrate(si, ti)) {
|
|
EXPECT_TRUE(actual_allocation.HasBitrate(si, ti));
|
|
uint32_t expected_layer_bitrate_bps =
|
|
expected_allocation.GetBitrate(si, ti);
|
|
EXPECT_NEAR(expected_layer_bitrate_bps,
|
|
actual_allocation.GetBitrate(si, ti),
|
|
static_cast<uint32_t>(expected_layer_bitrate_bps *
|
|
allowed_error_fraction));
|
|
} else {
|
|
EXPECT_FALSE(actual_allocation.HasBitrate(si, ti));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VideoBitrateAllocation MultiplyAllocation(
|
|
const VideoBitrateAllocation& allocation,
|
|
double factor) {
|
|
VideoBitrateAllocation multiplied_allocation;
|
|
for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
|
|
for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
|
|
if (allocation.HasBitrate(si, ti)) {
|
|
multiplied_allocation.SetBitrate(
|
|
si, ti,
|
|
static_cast<uint32_t>(factor * allocation.GetBitrate(si, ti) +
|
|
0.5));
|
|
}
|
|
}
|
|
}
|
|
return multiplied_allocation;
|
|
}
|
|
|
|
VideoCodec codec_;
|
|
VideoEncoder::EncoderInfo encoder_info_;
|
|
std::unique_ptr<EncoderBitrateAdjuster> adjuster_;
|
|
VideoBitrateAllocation current_input_allocation_;
|
|
VideoBitrateAllocation current_adjusted_allocation_;
|
|
rtc::ScopedFakeClock clock_;
|
|
DataRate target_bitrate_;
|
|
double target_framerate_fps_;
|
|
int tl_pattern_idx_[kMaxSpatialLayers];
|
|
int sequence_idx_[kMaxSpatialLayers][kMaxTemporalStreams];
|
|
|
|
const std::vector<int> kTlPatterns[kMaxTemporalStreams] = {
|
|
{0},
|
|
{0, 1},
|
|
{0, 2, 1, 2},
|
|
{0, 3, 2, 3, 1, 3, 2, 3}};
|
|
};
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, SingleLayerOptimal) {
|
|
// Single layer, well behaved encoder.
|
|
current_input_allocation_.SetBitrate(0, 0, 300000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 1, false);
|
|
InsertFrames({{1.0}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Adjusted allocation near input. Allow 1% error margin due to rounding
|
|
// errors etc.
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, SingleLayerOveruse) {
|
|
// Single layer, well behaved encoder.
|
|
current_input_allocation_.SetBitrate(0, 0, 300000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 1, false);
|
|
InsertFrames({{1.2}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Adjusted allocation lowered by 20%.
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.2),
|
|
current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, SingleLayerUnderuse) {
|
|
// Single layer, well behaved encoder.
|
|
current_input_allocation_.SetBitrate(0, 0, 300000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 1, false);
|
|
InsertFrames({{0.5}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Undershoot, adjusted should exactly match input.
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.00);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, ThreeTemporalLayersOptimalSize) {
|
|
// Three temporal layers, 60%/20%/20% bps distro, well behaved encoder.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 3, false);
|
|
InsertFrames({{1.0, 1.0, 1.0}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, ThreeTemporalLayersOvershoot) {
|
|
// Three temporal layers, 60%/20%/20% bps distro.
|
|
// 10% overshoot on all layers.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 3, false);
|
|
InsertFrames({{1.1, 1.1, 1.1}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Adjusted allocation lowered by 10%.
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.1),
|
|
current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, ThreeTemporalLayersUndershoot) {
|
|
// Three temporal layers, 60%/20%/20% bps distro, undershoot all layers.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 3, false);
|
|
InsertFrames({{0.8, 0.8, 0.8}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Adjusted allocation identical since we don't boost bitrates.
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.0);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, ThreeTemporalLayersSkewedOvershoot) {
|
|
// Three temporal layers, 60%/20%/20% bps distro.
|
|
// 10% overshoot on base layer, 20% on higher layers.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 3, false);
|
|
InsertFrames({{1.1, 1.2, 1.2}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Expected overshoot is weighted by bitrate:
|
|
// (0.6 * 1.1 + 0.2 * 1.2 + 0.2 * 1.2) = 1.14
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.14),
|
|
current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, FourTemporalLayersSkewedOvershoot) {
|
|
// Three temporal layers, 40%/30%/15%/15% bps distro.
|
|
// 10% overshoot on base layer, 20% on higher layers.
|
|
current_input_allocation_.SetBitrate(0, 0, 120000);
|
|
current_input_allocation_.SetBitrate(0, 1, 90000);
|
|
current_input_allocation_.SetBitrate(0, 2, 45000);
|
|
current_input_allocation_.SetBitrate(0, 3, 45000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 4, false);
|
|
InsertFrames({{1.1, 1.2, 1.2, 1.2}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Expected overshoot is weighted by bitrate:
|
|
// (0.4 * 1.1 + 0.3 * 1.2 + 0.15 * 1.2 + 0.15 * 1.2) = 1.16
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.16),
|
|
current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, ThreeTemporalLayersNonLayeredEncoder) {
|
|
// Three temporal layers, 60%/20%/20% bps allocation, 10% overshoot,
|
|
// encoder does not actually support temporal layers.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 1, false);
|
|
InsertFrames({{1.1}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// Expect the actual 10% overuse to be detected and the allocation to
|
|
// only contain the one entry.
|
|
VideoBitrateAllocation expected_allocation;
|
|
expected_allocation.SetBitrate(
|
|
0, 0,
|
|
static_cast<uint32_t>(current_input_allocation_.get_sum_bps() / 1.10));
|
|
ExpectNear(expected_allocation, current_adjusted_allocation_, 0.01);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, IgnoredStream) {
|
|
// Encoder with three temporal layers, but in a mode that does not support
|
|
// deterministic frame rate. Those are ignored, even if bitrate overshoots.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
target_framerate_fps_ = 30;
|
|
SetUpAdjuster(1, 1, false);
|
|
encoder_info_.fps_allocation[0].clear();
|
|
adjuster_->OnEncoderInfo(encoder_info_);
|
|
|
|
InsertFrames({{1.1}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
|
|
// Values passed through.
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.00);
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, DifferentSpatialOvershoots) {
|
|
// Two streams, both with three temporal layers.
|
|
// S0 has 5% overshoot, S1 has 25% overshoot.
|
|
current_input_allocation_.SetBitrate(0, 0, 180000);
|
|
current_input_allocation_.SetBitrate(0, 1, 60000);
|
|
current_input_allocation_.SetBitrate(0, 2, 60000);
|
|
current_input_allocation_.SetBitrate(1, 0, 400000);
|
|
current_input_allocation_.SetBitrate(1, 1, 150000);
|
|
current_input_allocation_.SetBitrate(1, 2, 150000);
|
|
target_framerate_fps_ = 30;
|
|
// Run twice, once configured as simulcast and once as VP9 SVC.
|
|
for (int i = 0; i < 2; ++i) {
|
|
SetUpAdjuster(2, 3, i == 0);
|
|
InsertFrames({{1.05, 1.05, 1.05}, {1.25, 1.25, 1.25}}, kWindowSizeMs);
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
VideoBitrateAllocation expected_allocation;
|
|
for (size_t ti = 0; ti < 3; ++ti) {
|
|
expected_allocation.SetBitrate(
|
|
0, ti,
|
|
static_cast<uint32_t>(current_input_allocation_.GetBitrate(0, ti) /
|
|
1.05));
|
|
expected_allocation.SetBitrate(
|
|
1, ti,
|
|
static_cast<uint32_t>(current_input_allocation_.GetBitrate(1, ti) /
|
|
1.25));
|
|
}
|
|
ExpectNear(expected_allocation, current_adjusted_allocation_, 0.01);
|
|
}
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, HeadroomAllowsOvershootToMediaRate) {
|
|
// Two streams, both with three temporal layers.
|
|
// Media rate is 1.0, but network rate is higher.
|
|
ScopedFieldTrials field_trial(
|
|
"WebRTC-VideoRateControl/adjuster_use_headroom:true/");
|
|
|
|
const uint32_t kS0Bitrate = 300000;
|
|
const uint32_t kS1Bitrate = 900000;
|
|
current_input_allocation_.SetBitrate(0, 0, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(0, 1, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(0, 2, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 0, kS1Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 1, kS1Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 2, kS1Bitrate / 3);
|
|
|
|
target_framerate_fps_ = 30;
|
|
|
|
// Run twice, once configured as simulcast and once as VP9 SVC.
|
|
for (int i = 0; i < 2; ++i) {
|
|
SetUpAdjuster(2, 3, i == 0);
|
|
// Network rate has 10% overshoot, but media rate is correct at 1.0.
|
|
InsertFrames({{1.0, 1.0, 1.0}, {1.0, 1.0, 1.0}},
|
|
{{1.1, 1.1, 1.1}, {1.1, 1.1, 1.1}},
|
|
kWindowSizeMs * kSequenceLength);
|
|
|
|
// Push back by 10%.
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.1),
|
|
current_adjusted_allocation_, 0.01);
|
|
|
|
// Add 10% link headroom, overshoot is now allowed.
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_,
|
|
DataRate::BitsPerSec(current_input_allocation_.get_sum_bps() *
|
|
1.1)));
|
|
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.01);
|
|
}
|
|
}
|
|
|
|
TEST_F(EncoderBitrateAdjusterTest, DontExceedMediaRateEvenWithHeadroom) {
|
|
// Two streams, both with three temporal layers.
|
|
// Media rate is 1.1, but network rate is higher.
|
|
ScopedFieldTrials field_trial(
|
|
"WebRTC-VideoRateControl/adjuster_use_headroom:true/");
|
|
|
|
const uint32_t kS0Bitrate = 300000;
|
|
const uint32_t kS1Bitrate = 900000;
|
|
current_input_allocation_.SetBitrate(0, 0, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(0, 1, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(0, 2, kS0Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 0, kS1Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 1, kS1Bitrate / 3);
|
|
current_input_allocation_.SetBitrate(1, 2, kS1Bitrate / 3);
|
|
|
|
target_framerate_fps_ = 30;
|
|
|
|
// Run twice, once configured as simulcast and once as VP9 SVC.
|
|
for (int i = 0; i < 2; ++i) {
|
|
SetUpAdjuster(2, 3, i == 0);
|
|
// Network rate has 30% overshoot, media rate has 10% overshoot.
|
|
InsertFrames({{1.1, 1.1, 1.1}, {1.1, 1.1, 1.1}},
|
|
{{1.3, 1.3, 1.3}, {1.3, 1.3, 1.3}},
|
|
kWindowSizeMs * kSequenceLength);
|
|
|
|
// Push back by 30%.
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_));
|
|
// The up-down causes a bit more noise, allow slightly more error margin.
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.3),
|
|
current_adjusted_allocation_, 0.015);
|
|
|
|
// Add 100% link headroom, overshoot from network to media rate is allowed.
|
|
current_adjusted_allocation_ =
|
|
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
|
|
current_input_allocation_, target_framerate_fps_,
|
|
DataRate::BitsPerSec(current_input_allocation_.get_sum_bps() * 2)));
|
|
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.1),
|
|
current_adjusted_allocation_, 0.015);
|
|
}
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace webrtc
|