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

VideoProcessorIntegrationTest: Group member variables into two structs containing target/actual rates.

Browse Source 
- Group member variables into two structs: target rates/actual rates.
- Split verify and print of rate control metrics into separate functions.
- Rename member variables.

BUG=webrtc:6634

Review-Url: https://codereview.webrtc.org/3009423002
Cr-Commit-Position: refs/heads/master@{#19925}
This commit is contained in:
asapersson
2017-09-22 03:45:15 -07:00
committed by Commit Bot
parent 22d3da9235
commit 55c7eded94
2 changed files with 233 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

332
modules/video_coding/codecs/test/videoprocessor_integrationtest.cc
View File

@ -10,6 +10,7 @@
#include "modules/video_coding/codecs/test/videoprocessor_integrationtest.h"
#include <algorithm>
#include <utility>
#if defined(WEBRTC_ANDROID)
@ -41,7 +42,7 @@ namespace test {
namespace {
const int kPercTargetvsActualMismatch = 20;
const int kMaxBitrateMismatchPercent = 20;
const int kBaseKeyFrameInterval = 3000;
// Parameters from VP8 wrapper, which control target size of key frames.
@ -58,6 +59,13 @@ void VerifyQuality(const QualityMetricsResult& psnr_result,
EXPECT_GT(ssim_result.min, quality_thresholds.min_min_ssim);
}
void PrintQualityMetrics(const QualityMetricsResult& psnr_result,
const QualityMetricsResult& ssim_result) {
printf("PSNR avg: %f, min: %f\n", psnr_result.average, psnr_result.min);
printf("SSIM avg: %f, min: %f\n", ssim_result.average, ssim_result.min);
printf("\n");
}
int NumberOfTemporalLayers(const VideoCodec& codec_settings) {
if (codec_settings.codecType == kVideoCodecVP8) {
return codec_settings.VP8().numberOfTemporalLayers;
@ -140,10 +148,10 @@ void VideoProcessorIntegrationTest::SetRateProfile(
void VideoProcessorIntegrationTest::AddRateControlThresholds(
int max_num_dropped_frames,
int max_key_frame_size_mismatch,
int max_delta_frame_size_mismatch,
int max_encoding_rate_mismatch,
int max_time_hit_target,
int max_key_framesize_mismatch_percent,
int max_delta_framesize_mismatch_percent,
int max_bitrate_mismatch_percent,
int max_num_frames_to_hit_target,
int num_spatial_resizes,
int num_key_frames,
std::vector<RateControlThresholds>* rc_thresholds) {
@ -152,10 +160,12 @@ void VideoProcessorIntegrationTest::AddRateControlThresholds(
rc_thresholds->emplace_back();
RateControlThresholds* rc_threshold = &rc_thresholds->back();
rc_threshold->max_num_dropped_frames = max_num_dropped_frames;
rc_threshold->max_key_frame_size_mismatch = max_key_frame_size_mismatch;
rc_threshold->max_delta_frame_size_mismatch = max_delta_frame_size_mismatch;
rc_threshold->max_encoding_rate_mismatch = max_encoding_rate_mismatch;
rc_threshold->max_time_hit_target = max_time_hit_target;
rc_threshold->max_key_framesize_mismatch_percent =
max_key_framesize_mismatch_percent;
rc_threshold->max_delta_framesize_mismatch_percent =
max_delta_framesize_mismatch_percent;
rc_threshold->max_bitrate_mismatch_percent = max_bitrate_mismatch_percent;
rc_threshold->max_num_frames_to_hit_target = max_num_frames_to_hit_target;
rc_threshold->num_spatial_resizes = num_spatial_resizes;
rc_threshold->num_key_frames = num_key_frames;
}
@ -218,19 +228,20 @@ void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
ReleaseAndCloseObjects(&task_queue);
// Calculate and print rate control statistics.
rate_update_index = 0;
frame_number = 0;
ResetRateControlMetrics(rate_update_index, rate_profile);
std::vector<int> num_dropped_frames;
std::vector<int> num_resize_actions;
std::vector<int> num_spatial_resizes;
sync_event.Reset();
task_queue.PostTask(
[this, &num_dropped_frames, &num_resize_actions, &sync_event]() {
[this, &num_dropped_frames, &num_spatial_resizes, &sync_event]() {
num_dropped_frames = processor_->NumberDroppedFramesPerRateUpdate();
num_resize_actions = processor_->NumberSpatialResizesPerRateUpdate();
num_spatial_resizes = processor_->NumberSpatialResizesPerRateUpdate();
sync_event.Set();
});
sync_event.Wait(rtc::Event::kForever);
rate_update_index = 0;
frame_number = 0;
ResetRateControlMetrics(rate_update_index, rate_profile);
while (frame_number < num_frames) {
UpdateRateControlMetrics(frame_number);
@ -238,15 +249,19 @@ void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
if (frame_number ==
rate_profile.frame_index_rate_update[rate_update_index + 1]) {
PrintAndMaybeVerifyRateControlMetrics(rate_update_index, rc_thresholds,
num_dropped_frames,
num_resize_actions);
PrintRateControlMetrics(rate_update_index, num_dropped_frames,
num_spatial_resizes);
VerifyRateControlMetrics(rate_update_index, rc_thresholds,
num_dropped_frames, num_spatial_resizes);
++rate_update_index;
ResetRateControlMetrics(rate_update_index, rate_profile);
}
}
PrintAndMaybeVerifyRateControlMetrics(rate_update_index, rc_thresholds,
num_dropped_frames, num_resize_actions);
PrintRateControlMetrics(rate_update_index, num_dropped_frames,
num_spatial_resizes);
VerifyRateControlMetrics(rate_update_index, rc_thresholds, num_dropped_frames,
num_spatial_resizes);
// Calculate and print other statistics.
EXPECT_EQ(num_frames, static_cast<int>(stats_.size()));
@ -263,9 +278,7 @@ void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
if (quality_thresholds) {
VerifyQuality(psnr_result, ssim_result, *quality_thresholds);
}
printf("PSNR avg: %f, min: %f\nSSIM avg: %f, min: %f\n", psnr_result.average,
psnr_result.min, ssim_result.average, ssim_result.min);
printf("\n");
PrintQualityMetrics(psnr_result, ssim_result);
// Remove analysis file.
if (remove(config_.output_filename.c_str()) < 0) {
@ -438,134 +451,120 @@ void VideoProcessorIntegrationTest::UpdateRateControlMetrics(int frame_number) {
RTC_CHECK_GE(frame_number, 0);
const int tl_idx = TemporalLayerIndexForFrame(frame_number);
++num_frames_per_update_[tl_idx];
++num_frames_total_;
++actual_.num_frames_layer[tl_idx];
++actual_.num_frames;
const FrameStatistic* frame_stat = stats_.GetFrame(frame_number);
FrameType frame_type = frame_stat->frame_type;
float encoded_size_kbits =
frame_stat->encoded_frame_size_bytes * 8.0f / 1000.0f;
float framesize_kbits = frame_stat->encoded_frame_size_bytes * 8.0f / 1000.0f;
// Update layer data.
// Update rate mismatch relative to per-frame bandwidth for delta frames.
// Update rate mismatch relative to per-frame bandwidth.
if (frame_type == kVideoFrameDelta) {
// TODO(marpan): Should we count dropped (zero size) frames in mismatch?
sum_frame_size_mismatch_[tl_idx] +=
fabs(encoded_size_kbits - per_frame_bandwidth_[tl_idx]) /
per_frame_bandwidth_[tl_idx];
actual_.sum_delta_framesize_mismatch_layer[tl_idx] +=
fabs(framesize_kbits - target_.framesize_kbits_layer[tl_idx]) /
target_.framesize_kbits_layer[tl_idx];
} else {
float target_size = (frame_number == 0) ? target_size_key_frame_initial_
: target_size_key_frame_;
sum_key_frame_size_mismatch_ +=
fabs(encoded_size_kbits - target_size) / target_size;
num_key_frames_ += 1;
float key_framesize_kbits = (frame_number == 0)
? target_.key_framesize_kbits_initial
: target_.key_framesize_kbits;
actual_.sum_key_framesize_mismatch +=
fabs(framesize_kbits - key_framesize_kbits) / key_framesize_kbits;
++actual_.num_key_frames;
}
sum_encoded_frame_size_[tl_idx] += encoded_size_kbits;
// Encoding bit rate per temporal layer: from the start of the update/run
// to the current frame.
encoding_bitrate_[tl_idx] = sum_encoded_frame_size_[tl_idx] *
framerate_layer_[tl_idx] /
num_frames_per_update_[tl_idx];
// Total encoding rate: from the start of the update/run to current frame.
sum_encoded_frame_size_total_ += encoded_size_kbits;
encoding_bitrate_total_ =
sum_encoded_frame_size_total_ * framerate_ / num_frames_total_;
perc_encoding_rate_mismatch_ =
100 * fabs(encoding_bitrate_total_ - bitrate_kbps_) / bitrate_kbps_;
if (perc_encoding_rate_mismatch_ < kPercTargetvsActualMismatch &&
!encoding_rate_within_target_) {
num_frames_to_hit_target_ = num_frames_total_;
encoding_rate_within_target_ = true;
actual_.sum_framesize_kbits += framesize_kbits;
actual_.sum_framesize_kbits_layer[tl_idx] += framesize_kbits;
// Encoded bitrate: from the start of the update/run to current frame.
actual_.kbps = actual_.sum_framesize_kbits * target_.fps / actual_.num_frames;
actual_.kbps_layer[tl_idx] = actual_.sum_framesize_kbits_layer[tl_idx] *
target_.fps_layer[tl_idx] /
actual_.num_frames_layer[tl_idx];
// Number of frames to hit target bitrate.
if (actual_.BitrateMismatchPercent(target_.kbps) <
kMaxBitrateMismatchPercent) {
actual_.num_frames_to_hit_target =
std::min(actual_.num_frames, actual_.num_frames_to_hit_target);
}
}
// Verify expected behavior of rate control and print out data.
void VideoProcessorIntegrationTest::PrintAndMaybeVerifyRateControlMetrics(
// Verify expected behavior of rate control.
void VideoProcessorIntegrationTest::VerifyRateControlMetrics(
int rate_update_index,
const std::vector<RateControlThresholds>* rc_thresholds,
const std::vector<int>& num_dropped_frames,
const std::vector<int>& num_resize_actions) {
printf(
"Rate update #%d:\n"
" Target bitrate : %d\n"
" Encoded bitrate : %f\n"
" Frame rate : %d\n",
rate_update_index, bitrate_kbps_, encoding_bitrate_total_, framerate_);
printf(
" # processed frames : %d\n"
" # frames to convergence: %d\n"
" # dropped frames : %d\n"
" # spatial resizes : %d\n",
num_frames_total_, num_frames_to_hit_target_,
num_dropped_frames[rate_update_index],
num_resize_actions[rate_update_index]);
const std::vector<int>& num_spatial_resizes) const {
if (!rc_thresholds)
return;
const RateControlThresholds* rc_threshold = nullptr;
if (rc_thresholds) {
rc_threshold = &(*rc_thresholds)[rate_update_index];
const RateControlThresholds& rc_threshold =
(*rc_thresholds)[rate_update_index];
EXPECT_LE(perc_encoding_rate_mismatch_,
rc_threshold->max_encoding_rate_mismatch);
}
if (num_key_frames_ > 0) {
int perc_key_frame_size_mismatch =
100 * sum_key_frame_size_mismatch_ / num_key_frames_;
printf(
" # key frames : %d\n"
" Key frame rate mismatch: %d\n",
num_key_frames_, perc_key_frame_size_mismatch);
if (rc_threshold) {
EXPECT_LE(perc_key_frame_size_mismatch,
rc_threshold->max_key_frame_size_mismatch);
}
}
EXPECT_LE(num_dropped_frames[rate_update_index],
rc_threshold.max_num_dropped_frames);
EXPECT_EQ(rc_threshold.num_spatial_resizes,
num_spatial_resizes[rate_update_index]);
EXPECT_LE(actual_.num_frames_to_hit_target,
rc_threshold.max_num_frames_to_hit_target);
EXPECT_EQ(rc_threshold.num_key_frames, actual_.num_key_frames);
EXPECT_LE(actual_.KeyFrameSizeMismatchPercent(),
rc_threshold.max_key_framesize_mismatch_percent);
EXPECT_LE(actual_.BitrateMismatchPercent(target_.kbps),
rc_threshold.max_bitrate_mismatch_percent);
const int num_temporal_layers =
NumberOfTemporalLayers(config_.codec_settings);
for (int i = 0; i < num_temporal_layers; i++) {
int perc_frame_size_mismatch =
100 * sum_frame_size_mismatch_[i] / num_frames_per_update_[i];
int perc_encoding_rate_mismatch =
100 * fabs(encoding_bitrate_[i] - bitrate_layer_[i]) /
bitrate_layer_[i];
printf(
" Temporal layer #%d:\n"
" Target layer bitrate : %f\n"
" Layer frame rate : %f\n"
" Layer per frame bandwidth : %f\n"
" Layer encoding bitrate : %f\n"
" Layer percent frame size mismatch : %d\n"
" Layer percent encoding rate mismatch: %d\n"
" # frames processed per layer : %d\n",
i, bitrate_layer_[i], framerate_layer_[i], per_frame_bandwidth_[i],
encoding_bitrate_[i], perc_frame_size_mismatch,
perc_encoding_rate_mismatch, num_frames_per_update_[i]);
if (rc_threshold) {
EXPECT_LE(perc_frame_size_mismatch,
rc_threshold->max_delta_frame_size_mismatch);
EXPECT_LE(perc_encoding_rate_mismatch,
rc_threshold->max_encoding_rate_mismatch);
}
for (int i = 0; i < num_temporal_layers; ++i) {
EXPECT_LE(actual_.DeltaFrameSizeMismatchPercent(i),
rc_threshold.max_delta_framesize_mismatch_percent);
EXPECT_LE(actual_.BitrateMismatchPercent(i, target_.kbps_layer[i]),
rc_threshold.max_bitrate_mismatch_percent);
}
}
void VideoProcessorIntegrationTest::PrintRateControlMetrics(
int rate_update_index,
const std::vector<int>& num_dropped_frames,
const std::vector<int>& num_spatial_resizes) const {
printf("Rate update #%d:\n", rate_update_index);
printf(" Target bitrate : %d\n", target_.kbps);
printf(" Encoded bitrate : %f\n", actual_.kbps);
printf(" Frame rate : %d\n", target_.fps);
printf(" # processed frames : %d\n", actual_.num_frames);
printf(" # frames to convergence: %d\n", actual_.num_frames_to_hit_target);
printf(" # dropped frames : %d\n",
num_dropped_frames[rate_update_index]);
printf(" # spatial resizes : %d\n",
num_spatial_resizes[rate_update_index]);
printf(" # key frames : %d\n", actual_.num_key_frames);
printf(" Key frame rate mismatch: %d\n",
actual_.KeyFrameSizeMismatchPercent());
const int num_temporal_layers =
NumberOfTemporalLayers(config_.codec_settings);
for (int i = 0; i < num_temporal_layers; ++i) {
printf(" Temporal layer #%d:\n", i);
printf(" Layer target bitrate : %f\n", target_.kbps_layer[i]);
printf(" Layer frame rate : %f\n", target_.fps_layer[i]);
printf(" Layer per frame bandwidth : %f\n",
target_.framesize_kbits_layer[i]);
printf(" Layer encoded bitrate : %f\n", actual_.kbps_layer[i]);
printf(" Layer frame size %% mismatch : %d\n",
actual_.DeltaFrameSizeMismatchPercent(i));
printf(" Layer bitrate %% mismatch : %d\n",
actual_.BitrateMismatchPercent(i, target_.kbps_layer[i]));
printf(" # processed frames per layer: %d\n", actual_.num_frames_layer[i]);
}
printf("\n");
if (rc_threshold) {
EXPECT_LE(num_frames_to_hit_target_, rc_threshold->max_time_hit_target);
EXPECT_LE(num_dropped_frames[rate_update_index],
rc_threshold->max_num_dropped_frames);
EXPECT_EQ(rc_threshold->num_spatial_resizes,
num_resize_actions[rate_update_index]);
EXPECT_EQ(rc_threshold->num_key_frames, num_key_frames_);
}
}
// Temporal layer index corresponding to frame number, for up to 3 layers.
int VideoProcessorIntegrationTest::TemporalLayerIndexForFrame(
int frame_number) const {
const int num_temporal_layers =
NumberOfTemporalLayers(config_.codec_settings);
int tl_idx = -1;
switch (num_temporal_layers) {
switch (NumberOfTemporalLayers(config_.codec_settings)) {
case 1:
tl_idx = 0;
break;
@ -598,59 +597,58 @@ void VideoProcessorIntegrationTest::ResetRateControlMetrics(
int rate_update_index,
const RateProfile& rate_profile) {
// Set new rates.
bitrate_kbps_ = rate_profile.target_bit_rate[rate_update_index];
framerate_ = rate_profile.input_frame_rate[rate_update_index];
const int num_temporal_layers =
NumberOfTemporalLayers(config_.codec_settings);
RTC_DCHECK_LE(num_temporal_layers, kMaxNumTemporalLayers);
for (int i = 0; i < num_temporal_layers; i++) {
float bit_rate_ratio = kVp8LayerRateAlloction[num_temporal_layers - 1][i];
if (i > 0) {
float bit_rate_delta_ratio =
kVp8LayerRateAlloction[num_temporal_layers - 1][i] -
kVp8LayerRateAlloction[num_temporal_layers - 1][i - 1];
bitrate_layer_[i] = bitrate_kbps_ * bit_rate_delta_ratio;
} else {
bitrate_layer_[i] = bitrate_kbps_ * bit_rate_ratio;
}
framerate_layer_[i] =
framerate_ / static_cast<float>(1 << (num_temporal_layers - 1));
}
if (num_temporal_layers == 3) {
framerate_layer_[2] = framerate_ / 2.0f;
}
target_.kbps = rate_profile.target_bit_rate[rate_update_index];
target_.fps = rate_profile.input_frame_rate[rate_update_index];
SetRatesPerTemporalLayer();
// Set key frame target sizes.
if (rate_update_index == 0) {
target_size_key_frame_initial_ =
0.5 * kInitialBufferSize * bitrate_layer_[0];
target_.key_framesize_kbits_initial =
0.5 * kInitialBufferSize * target_.kbps_layer[0];
}
// Reset rate control metrics.
for (int i = 0; i < num_temporal_layers; i++) {
num_frames_per_update_[i] = 0;
sum_frame_size_mismatch_[i] = 0.0f;
sum_encoded_frame_size_[i] = 0.0f;
encoding_bitrate_[i] = 0.0f;
// Update layer per-frame-bandwidth.
per_frame_bandwidth_[i] = static_cast<float>(bitrate_layer_[i]) /
static_cast<float>(framerate_layer_[i]);
}
// Set maximum size of key frames, following setting in the VP8 wrapper.
float max_key_size = kScaleKeyFrameSize * kOptimalBufferSize * framerate_;
float max_key_size = kScaleKeyFrameSize * kOptimalBufferSize * target_.fps;
// We don't know exact target size of the key frames (except for first one),
// but the minimum in libvpx is ~|3 * per_frame_bandwidth| and maximum is
// set by |max_key_size_ * per_frame_bandwidth|. Take middle point/average
// as reference for mismatch. Note key frames always correspond to base
// layer frame in this test.
target_size_key_frame_ = 0.5 * (3 + max_key_size) * per_frame_bandwidth_[0];
num_frames_total_ = 0;
sum_encoded_frame_size_total_ = 0.0f;
encoding_bitrate_total_ = 0.0f;
perc_encoding_rate_mismatch_ = 0.0f;
num_frames_to_hit_target_ =
target_.key_framesize_kbits =
0.5 * (3 + max_key_size) * target_.framesize_kbits_layer[0];
// Reset rate control metrics.
actual_ = TestResults();
actual_.num_frames_to_hit_target = // Set to max number of frames.
rate_profile.frame_index_rate_update[rate_update_index + 1];
encoding_rate_within_target_ = false;
sum_key_frame_size_mismatch_ = 0.0;
num_key_frames_ = 0;
}
void VideoProcessorIntegrationTest::SetRatesPerTemporalLayer() {
const int num_temporal_layers =
NumberOfTemporalLayers(config_.codec_settings);
RTC_DCHECK_LE(num_temporal_layers, kMaxNumTemporalLayers);
for (int i = 0; i < num_temporal_layers; ++i) {
float bitrate_ratio;
if (i > 0) {
bitrate_ratio = kVp8LayerRateAlloction[num_temporal_layers - 1][i] -
kVp8LayerRateAlloction[num_temporal_layers - 1][i - 1];
} else {
bitrate_ratio = kVp8LayerRateAlloction[num_temporal_layers - 1][i];
}
target_.kbps_layer[i] = target_.kbps * bitrate_ratio;
target_.fps_layer[i] =
target_.fps / static_cast<float>(1 << (num_temporal_layers - 1));
}
if (num_temporal_layers == 3) {
target_.fps_layer[2] = target_.fps / 2.0f;
}
// Update layer per-frame-bandwidth.
for (int i = 0; i < num_temporal_layers; ++i) {
target_.framesize_kbits_layer[i] =
target_.kbps_layer[i] / target_.fps_layer[i];
}
}
} // namespace test

108
modules/video_coding/codecs/test/videoprocessor_integrationtest.h
View File

@ -31,8 +31,7 @@ namespace webrtc {
namespace test {
// The sequence of bit rate and frame rate changes for the encoder, the frame
// number where the changes are made, and the total number of frames for the
// test.
// number where the changes are made, and the total number of frames to process.
struct RateProfile {
static const int kMaxNumRateUpdates = 3;
@ -42,17 +41,16 @@ struct RateProfile {
int num_frames;
};
// Thresholds for the rate control metrics. The rate mismatch thresholds are
// defined as percentages. |max_time_hit_target| is defined as number of frames,
// after a rate update is made to the encoder, for the encoder to reach within
// |kPercTargetvsActualMismatch| of new target rate. The thresholds are defined
// for each rate update sequence.
// Thresholds for the rate control metrics. The thresholds are defined for each
// rate update sequence. |max_num_frames_to_hit_target| is defined as number of
// frames, after a rate update is made to the encoder, for the encoder to reach
// |kMaxBitrateMismatchPercent| of new target rate.
struct RateControlThresholds {
int max_num_dropped_frames;
int max_key_frame_size_mismatch;
int max_delta_frame_size_mismatch;
int max_encoding_rate_mismatch;
int max_time_hit_target;
int max_key_framesize_mismatch_percent;
int max_delta_framesize_mismatch_percent;
int max_bitrate_mismatch_percent;
int max_num_frames_to_hit_target;
int num_spatial_resizes;
int num_key_frames;
};
@ -112,10 +110,10 @@ class VideoProcessorIntegrationTest : public testing::Test {
static void AddRateControlThresholds(
int max_num_dropped_frames,
int max_key_frame_size_mismatch,
int max_delta_frame_size_mismatch,
int max_encoding_rate_mismatch,
int max_time_hit_target,
int max_key_framesize_mismatch_percent,
int max_delta_framesize_mismatch_percent,
int max_bitrate_mismatch_percent,
int max_num_frames_to_hit_target,
int num_spatial_resizes,
int num_key_frames,
std::vector<RateControlThresholds>* rc_thresholds);
@ -132,6 +130,44 @@ class VideoProcessorIntegrationTest : public testing::Test {
private:
static const int kMaxNumTemporalLayers = 3;
struct TestResults {
int KeyFrameSizeMismatchPercent() const {
if (num_key_frames == 0) {
return -1;
}
return 100 * sum_key_framesize_mismatch / num_key_frames;
}
int DeltaFrameSizeMismatchPercent(int i) const {
return 100 * sum_delta_framesize_mismatch_layer[i] / num_frames_layer[i];
}
int BitrateMismatchPercent(float target_kbps) const {
return 100 * fabs(kbps - target_kbps) / target_kbps;
}
int BitrateMismatchPercent(int i, float target_kbps_layer) const {
return 100 * fabs(kbps_layer[i] - target_kbps_layer) / target_kbps_layer;
}
int num_frames = 0;
int num_frames_layer[kMaxNumTemporalLayers] = {0};
int num_key_frames = 0;
int num_frames_to_hit_target = 0;
float sum_framesize_kbits = 0.0f;
float sum_framesize_kbits_layer[kMaxNumTemporalLayers] = {0};
float kbps = 0.0f;
float kbps_layer[kMaxNumTemporalLayers] = {0};
float sum_key_framesize_mismatch = 0.0f;
float sum_delta_framesize_mismatch_layer[kMaxNumTemporalLayers] = {0};
};
struct TargetRates {
int kbps;
int fps;
float kbps_layer[kMaxNumTemporalLayers];
float fps_layer[kMaxNumTemporalLayers];
float framesize_kbits_layer[kMaxNumTemporalLayers];
float key_framesize_kbits_initial;
float key_framesize_kbits;
};
void CreateEncoderAndDecoder();
void DestroyEncoderAndDecoder();
void SetUpAndInitObjects(rtc::TaskQueue* task_queue,
@ -139,15 +175,22 @@ class VideoProcessorIntegrationTest : public testing::Test {
const int initial_framerate_fps,
const VisualizationParams* visualization_params);
void ReleaseAndCloseObjects(rtc::TaskQueue* task_queue);
int TemporalLayerIndexForFrame(int frame_number) const;
// Rate control metrics.
void ResetRateControlMetrics(int rate_update_index,
const RateProfile& rate_profile);
void SetRatesPerTemporalLayer();
void UpdateRateControlMetrics(int frame_number);
void PrintAndMaybeVerifyRateControlMetrics(
void PrintRateControlMetrics(
int rate_update_index,
const std::vector<int>& num_dropped_frames,
const std::vector<int>& num_spatial_resizes) const;
void VerifyRateControlMetrics(
int rate_update_index,
const std::vector<RateControlThresholds>* rc_thresholds,
const std::vector<int>& num_dropped_frames,
const std::vector<int>& num_resize_actions);
int TemporalLayerIndexForFrame(int frame_number) const;
void ResetRateControlMetrics(int rate_update_index,
const RateProfile& rate_profile);
const std::vector<int>& num_spatial_resizes) const;
// Codecs.
std::unique_ptr<VideoEncoder> encoder_;
@ -164,26 +207,11 @@ class VideoProcessorIntegrationTest : public testing::Test {
Stats stats_;
std::unique_ptr<VideoProcessor> processor_;
// Quantities defined/updated for every encoder rate update.
int num_frames_per_update_[kMaxNumTemporalLayers];
float sum_frame_size_mismatch_[kMaxNumTemporalLayers];
float sum_encoded_frame_size_[kMaxNumTemporalLayers];
float encoding_bitrate_[kMaxNumTemporalLayers];
float per_frame_bandwidth_[kMaxNumTemporalLayers];
float bitrate_layer_[kMaxNumTemporalLayers];
float framerate_layer_[kMaxNumTemporalLayers];
int num_frames_total_;
float sum_encoded_frame_size_total_;
float encoding_bitrate_total_;
float perc_encoding_rate_mismatch_;
int num_frames_to_hit_target_;
bool encoding_rate_within_target_;
int bitrate_kbps_;
int framerate_;
float target_size_key_frame_initial_;
float target_size_key_frame_;
float sum_key_frame_size_mismatch_;
int num_key_frames_;
// Quantities updated for every encoded frame.
TestResults actual_;
// Rates set for every encoder rate update.
TargetRates target_;
};
} // namespace test