Moving src/webrtc into src/.
In order to eliminate the WebRTC Subtree mirror in Chromium, WebRTC is moving the content of the src/webrtc directory up to the src/ directory. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true TBR=tommi@webrtc.org Bug: chromium:611808 Change-Id: Iac59c5b51b950f174119565bac87955a7994bc38 Reviewed-on: https://webrtc-review.googlesource.com/1560 Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Henrik Kjellander <kjellander@webrtc.org> Cr-Commit-Position: refs/heads/master@{#19845}
This commit is contained in:
Mirko Bonadei
committed by
Commit Bot
Commit Bot
parent
6674846b4a
commit
bb547203bf
@ -0,0 +1,657 @@
|
||||
/*
|
||||
* Copyright (c) 2017 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 "webrtc/modules/video_coding/codecs/test/videoprocessor_integrationtest.h"
|
||||
|
||||
#include <utility>
|
||||
|
||||
#if defined(WEBRTC_ANDROID)
|
||||
#include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h"
|
||||
#include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h"
|
||||
#include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
|
||||
#elif defined(WEBRTC_IOS)
|
||||
#include "webrtc/modules/video_coding/codecs/test/objc_codec_h264_test.h"
|
||||
#endif
|
||||
|
||||
#include "webrtc/media/engine/internaldecoderfactory.h"
|
||||
#include "webrtc/media/engine/internalencoderfactory.h"
|
||||
#include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h"
|
||||
#include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
|
||||
#include "webrtc/modules/video_coding/include/video_codec_interface.h"
|
||||
#include "webrtc/modules/video_coding/include/video_coding.h"
|
||||
#include "webrtc/rtc_base/checks.h"
|
||||
#include "webrtc/rtc_base/event.h"
|
||||
#include "webrtc/rtc_base/file.h"
|
||||
#include "webrtc/rtc_base/logging.h"
|
||||
#include "webrtc/rtc_base/ptr_util.h"
|
||||
#include "webrtc/system_wrappers/include/sleep.h"
|
||||
#include "webrtc/test/testsupport/fileutils.h"
|
||||
#include "webrtc/test/testsupport/metrics/video_metrics.h"
|
||||
#include "webrtc/test/video_codec_settings.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace test {
|
||||
|
||||
namespace {
|
||||
|
||||
const int kPercTargetvsActualMismatch = 20;
|
||||
const int kBaseKeyFrameInterval = 3000;
|
||||
|
||||
// Parameters from VP8 wrapper, which control target size of key frames.
|
||||
const float kInitialBufferSize = 0.5f;
|
||||
const float kOptimalBufferSize = 0.6f;
|
||||
const float kScaleKeyFrameSize = 0.5f;
|
||||
|
||||
void VerifyQuality(const QualityMetricsResult& psnr_result,
|
||||
const QualityMetricsResult& ssim_result,
|
||||
const QualityThresholds& quality_thresholds) {
|
||||
EXPECT_GT(psnr_result.average, quality_thresholds.min_avg_psnr);
|
||||
EXPECT_GT(psnr_result.min, quality_thresholds.min_min_psnr);
|
||||
EXPECT_GT(ssim_result.average, quality_thresholds.min_avg_ssim);
|
||||
EXPECT_GT(ssim_result.min, quality_thresholds.min_min_ssim);
|
||||
}
|
||||
|
||||
int NumberOfTemporalLayers(const VideoCodec& codec_settings) {
|
||||
if (codec_settings.codecType == kVideoCodecVP8) {
|
||||
return codec_settings.VP8().numberOfTemporalLayers;
|
||||
} else if (codec_settings.codecType == kVideoCodecVP9) {
|
||||
return codec_settings.VP9().numberOfTemporalLayers;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
VideoProcessorIntegrationTest::VideoProcessorIntegrationTest() {
|
||||
#if defined(WEBRTC_ANDROID)
|
||||
InitializeAndroidObjects();
|
||||
#endif
|
||||
}
|
||||
|
||||
VideoProcessorIntegrationTest::~VideoProcessorIntegrationTest() = default;
|
||||
|
||||
void VideoProcessorIntegrationTest::SetCodecSettings(TestConfig* config,
|
||||
VideoCodecType codec_type,
|
||||
int num_temporal_layers,
|
||||
bool error_concealment_on,
|
||||
bool denoising_on,
|
||||
bool frame_dropper_on,
|
||||
bool spatial_resize_on,
|
||||
bool resilience_on,
|
||||
int width,
|
||||
int height) {
|
||||
webrtc::test::CodecSettings(codec_type, &config->codec_settings);
|
||||
|
||||
// TODO(brandtr): Move the setting of |width| and |height| to the tests, and
|
||||
// DCHECK that they are set before initializing the codec instead.
|
||||
config->codec_settings.width = width;
|
||||
config->codec_settings.height = height;
|
||||
|
||||
switch (config->codec_settings.codecType) {
|
||||
case kVideoCodecVP8:
|
||||
config->codec_settings.VP8()->resilience =
|
||||
resilience_on ? kResilientStream : kResilienceOff;
|
||||
config->codec_settings.VP8()->numberOfTemporalLayers =
|
||||
num_temporal_layers;
|
||||
config->codec_settings.VP8()->denoisingOn = denoising_on;
|
||||
config->codec_settings.VP8()->errorConcealmentOn = error_concealment_on;
|
||||
config->codec_settings.VP8()->automaticResizeOn = spatial_resize_on;
|
||||
config->codec_settings.VP8()->frameDroppingOn = frame_dropper_on;
|
||||
config->codec_settings.VP8()->keyFrameInterval = kBaseKeyFrameInterval;
|
||||
break;
|
||||
case kVideoCodecVP9:
|
||||
config->codec_settings.VP9()->resilienceOn = resilience_on;
|
||||
config->codec_settings.VP9()->numberOfTemporalLayers =
|
||||
num_temporal_layers;
|
||||
config->codec_settings.VP9()->denoisingOn = denoising_on;
|
||||
config->codec_settings.VP9()->frameDroppingOn = frame_dropper_on;
|
||||
config->codec_settings.VP9()->keyFrameInterval = kBaseKeyFrameInterval;
|
||||
config->codec_settings.VP9()->automaticResizeOn = spatial_resize_on;
|
||||
break;
|
||||
case kVideoCodecH264:
|
||||
config->codec_settings.H264()->frameDroppingOn = frame_dropper_on;
|
||||
config->codec_settings.H264()->keyFrameInterval = kBaseKeyFrameInterval;
|
||||
break;
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void VideoProcessorIntegrationTest::SetRateProfile(
|
||||
RateProfile* rate_profile,
|
||||
int rate_update_index,
|
||||
int bitrate_kbps,
|
||||
int framerate_fps,
|
||||
int frame_index_rate_update) {
|
||||
rate_profile->target_bit_rate[rate_update_index] = bitrate_kbps;
|
||||
rate_profile->input_frame_rate[rate_update_index] = framerate_fps;
|
||||
rate_profile->frame_index_rate_update[rate_update_index] =
|
||||
frame_index_rate_update;
|
||||
}
|
||||
|
||||
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 num_spatial_resizes,
|
||||
int num_key_frames,
|
||||
std::vector<RateControlThresholds>* rc_thresholds) {
|
||||
RTC_DCHECK(rc_thresholds);
|
||||
|
||||
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->num_spatial_resizes = num_spatial_resizes;
|
||||
rc_threshold->num_key_frames = num_key_frames;
|
||||
}
|
||||
|
||||
// Processes all frames in the clip and verifies the result.
|
||||
void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
|
||||
const RateProfile& rate_profile,
|
||||
const std::vector<RateControlThresholds>* rc_thresholds,
|
||||
const QualityThresholds* quality_thresholds,
|
||||
const VisualizationParams* visualization_params) {
|
||||
// The Android HW codec needs to be run on a task queue, so we simply always
|
||||
// run the test on a task queue.
|
||||
rtc::TaskQueue task_queue("VidProc TQ");
|
||||
rtc::Event sync_event(false, false);
|
||||
|
||||
SetUpAndInitObjects(&task_queue, rate_profile.target_bit_rate[0],
|
||||
rate_profile.input_frame_rate[0], visualization_params);
|
||||
|
||||
// Set initial rates.
|
||||
int rate_update_index = 0;
|
||||
task_queue.PostTask([this, &rate_profile, rate_update_index] {
|
||||
processor_->SetRates(rate_profile.target_bit_rate[rate_update_index],
|
||||
rate_profile.input_frame_rate[rate_update_index]);
|
||||
});
|
||||
|
||||
// Process all frames.
|
||||
int frame_number = 0;
|
||||
const int num_frames = rate_profile.num_frames;
|
||||
RTC_DCHECK_GE(num_frames, 1);
|
||||
while (frame_number < num_frames) {
|
||||
// In order to not overwhelm the OpenMAX buffers in the Android
|
||||
// MediaCodec API, we roughly pace the frames here. The downside
|
||||
// of this is that the encode run will be done in real-time.
|
||||
#if defined(WEBRTC_ANDROID)
|
||||
if (config_.hw_encoder || config_.hw_decoder) {
|
||||
SleepMs(rtc::kNumMillisecsPerSec /
|
||||
rate_profile.input_frame_rate[rate_update_index]);
|
||||
}
|
||||
#endif
|
||||
|
||||
task_queue.PostTask([this] { processor_->ProcessFrame(); });
|
||||
++frame_number;
|
||||
|
||||
if (frame_number ==
|
||||
rate_profile.frame_index_rate_update[rate_update_index + 1]) {
|
||||
++rate_update_index;
|
||||
|
||||
task_queue.PostTask([this, &rate_profile, rate_update_index] {
|
||||
processor_->SetRates(rate_profile.target_bit_rate[rate_update_index],
|
||||
rate_profile.input_frame_rate[rate_update_index]);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Give the VideoProcessor pipeline some time to process the last frame,
|
||||
// and then release the codecs.
|
||||
if (config_.hw_encoder || config_.hw_decoder) {
|
||||
SleepMs(1 * rtc::kNumMillisecsPerSec);
|
||||
}
|
||||
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;
|
||||
sync_event.Reset();
|
||||
task_queue.PostTask(
|
||||
[this, &num_dropped_frames, &num_resize_actions, &sync_event]() {
|
||||
num_dropped_frames = processor_->NumberDroppedFramesPerRateUpdate();
|
||||
num_resize_actions = processor_->NumberSpatialResizesPerRateUpdate();
|
||||
sync_event.Set();
|
||||
});
|
||||
sync_event.Wait(rtc::Event::kForever);
|
||||
while (frame_number < num_frames) {
|
||||
UpdateRateControlMetrics(frame_number);
|
||||
|
||||
++frame_number;
|
||||
|
||||
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);
|
||||
++rate_update_index;
|
||||
ResetRateControlMetrics(rate_update_index, rate_profile);
|
||||
}
|
||||
}
|
||||
PrintAndMaybeVerifyRateControlMetrics(rate_update_index, rc_thresholds,
|
||||
num_dropped_frames, num_resize_actions);
|
||||
|
||||
// Calculate and print other statistics.
|
||||
EXPECT_EQ(num_frames, static_cast<int>(stats_.size()));
|
||||
stats_.PrintSummary();
|
||||
|
||||
// Calculate and print image quality statistics.
|
||||
// TODO(marpan): Should compute these quality metrics per SetRates update.
|
||||
QualityMetricsResult psnr_result, ssim_result;
|
||||
EXPECT_EQ(0, I420MetricsFromFiles(config_.input_filename.c_str(),
|
||||
config_.output_filename.c_str(),
|
||||
config_.codec_settings.width,
|
||||
config_.codec_settings.height, &psnr_result,
|
||||
&ssim_result));
|
||||
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");
|
||||
|
||||
// Remove analysis file.
|
||||
if (remove(config_.output_filename.c_str()) < 0) {
|
||||
fprintf(stderr, "Failed to remove temporary file!\n");
|
||||
}
|
||||
}
|
||||
|
||||
void VideoProcessorIntegrationTest::CreateEncoderAndDecoder() {
|
||||
std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
|
||||
if (config_.hw_encoder) {
|
||||
#if defined(WEBRTC_ANDROID)
|
||||
encoder_factory.reset(new jni::MediaCodecVideoEncoderFactory());
|
||||
#elif defined(WEBRTC_IOS)
|
||||
EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
|
||||
<< "iOS HW codecs only support H264.";
|
||||
encoder_factory = CreateObjCEncoderFactory();
|
||||
#else
|
||||
RTC_NOTREACHED() << "Only support HW encoder on Android and iOS.";
|
||||
#endif
|
||||
} else {
|
||||
encoder_factory.reset(new cricket::InternalEncoderFactory());
|
||||
}
|
||||
|
||||
if (config_.hw_decoder) {
|
||||
#if defined(WEBRTC_ANDROID)
|
||||
decoder_factory_.reset(new jni::MediaCodecVideoDecoderFactory());
|
||||
#elif defined(WEBRTC_IOS)
|
||||
EXPECT_EQ(kVideoCodecH264, config_.codec_settings.codecType)
|
||||
<< "iOS HW codecs only support H264.";
|
||||
decoder_factory_ = CreateObjCDecoderFactory();
|
||||
#else
|
||||
RTC_NOTREACHED() << "Only support HW decoder on Android and iOS.";
|
||||
#endif
|
||||
} else {
|
||||
decoder_factory_.reset(new cricket::InternalDecoderFactory());
|
||||
}
|
||||
|
||||
cricket::VideoCodec codec;
|
||||
cricket::VideoDecoderParams decoder_params; // Empty.
|
||||
switch (config_.codec_settings.codecType) {
|
||||
case kVideoCodecVP8:
|
||||
codec = cricket::VideoCodec(cricket::kVp8CodecName);
|
||||
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
|
||||
decoder_ =
|
||||
decoder_factory_->CreateVideoDecoderWithParams(codec, decoder_params);
|
||||
break;
|
||||
case kVideoCodecVP9:
|
||||
codec = cricket::VideoCodec(cricket::kVp9CodecName);
|
||||
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
|
||||
decoder_ =
|
||||
decoder_factory_->CreateVideoDecoderWithParams(codec, decoder_params);
|
||||
break;
|
||||
case kVideoCodecH264:
|
||||
// TODO(brandtr): Generalize so that we support multiple profiles here.
|
||||
codec = cricket::VideoCodec(cricket::kH264CodecName);
|
||||
encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
|
||||
decoder_ =
|
||||
decoder_factory_->CreateVideoDecoderWithParams(codec, decoder_params);
|
||||
break;
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
break;
|
||||
}
|
||||
|
||||
if (config_.sw_fallback_encoder) {
|
||||
encoder_ = rtc::MakeUnique<VideoEncoderSoftwareFallbackWrapper>(
|
||||
codec, std::move(encoder_));
|
||||
}
|
||||
|
||||
EXPECT_TRUE(encoder_) << "Encoder not successfully created.";
|
||||
EXPECT_TRUE(decoder_) << "Decoder not successfully created.";
|
||||
}
|
||||
|
||||
void VideoProcessorIntegrationTest::DestroyEncoderAndDecoder() {
|
||||
encoder_.reset();
|
||||
decoder_factory_->DestroyVideoDecoder(decoder_);
|
||||
}
|
||||
|
||||
void VideoProcessorIntegrationTest::SetUpAndInitObjects(
|
||||
rtc::TaskQueue* task_queue,
|
||||
const int initial_bitrate_kbps,
|
||||
const int initial_framerate_fps,
|
||||
const VisualizationParams* visualization_params) {
|
||||
CreateEncoderAndDecoder();
|
||||
|
||||
// Create file objects for quality analysis.
|
||||
analysis_frame_reader_.reset(new YuvFrameReaderImpl(
|
||||
config_.input_filename, config_.codec_settings.width,
|
||||
config_.codec_settings.height));
|
||||
analysis_frame_writer_.reset(new YuvFrameWriterImpl(
|
||||
config_.output_filename, config_.codec_settings.width,
|
||||
config_.codec_settings.height));
|
||||
EXPECT_TRUE(analysis_frame_reader_->Init());
|
||||
EXPECT_TRUE(analysis_frame_writer_->Init());
|
||||
|
||||
if (visualization_params) {
|
||||
const std::string codec_name =
|
||||
CodecTypeToPayloadString(config_.codec_settings.codecType);
|
||||
const std::string implementation_type = config_.hw_encoder ? "hw" : "sw";
|
||||
// clang-format off
|
||||
const std::string output_filename_base =
|
||||
OutputPath() + config_.filename + "-" +
|
||||
codec_name + "-" + implementation_type + "-" +
|
||||
std::to_string(initial_bitrate_kbps);
|
||||
// clang-format on
|
||||
if (visualization_params->save_encoded_ivf) {
|
||||
rtc::File post_encode_file =
|
||||
rtc::File::Create(output_filename_base + ".ivf");
|
||||
encoded_frame_writer_ =
|
||||
IvfFileWriter::Wrap(std::move(post_encode_file), 0);
|
||||
}
|
||||
if (visualization_params->save_decoded_y4m) {
|
||||
decoded_frame_writer_.reset(new Y4mFrameWriterImpl(
|
||||
output_filename_base + ".y4m", config_.codec_settings.width,
|
||||
config_.codec_settings.height, initial_framerate_fps));
|
||||
EXPECT_TRUE(decoded_frame_writer_->Init());
|
||||
}
|
||||
}
|
||||
|
||||
packet_manipulator_.reset(new PacketManipulatorImpl(
|
||||
&packet_reader_, config_.networking_config, config_.verbose));
|
||||
|
||||
config_.codec_settings.minBitrate = 0;
|
||||
config_.codec_settings.startBitrate = initial_bitrate_kbps;
|
||||
config_.codec_settings.maxFramerate = initial_framerate_fps;
|
||||
|
||||
rtc::Event sync_event(false, false);
|
||||
task_queue->PostTask([this, &sync_event]() {
|
||||
// TODO(brandtr): std::move |encoder_| and |decoder_| into the
|
||||
// VideoProcessor when we are able to store |decoder_| in a
|
||||
// std::unique_ptr. That is, when https://codereview.webrtc.org/3009973002
|
||||
// has been relanded.
|
||||
processor_ = rtc::MakeUnique<VideoProcessor>(
|
||||
encoder_.get(), decoder_, analysis_frame_reader_.get(),
|
||||
analysis_frame_writer_.get(), packet_manipulator_.get(), config_,
|
||||
&stats_, encoded_frame_writer_.get(), decoded_frame_writer_.get());
|
||||
processor_->Init();
|
||||
sync_event.Set();
|
||||
});
|
||||
sync_event.Wait(rtc::Event::kForever);
|
||||
}
|
||||
|
||||
void VideoProcessorIntegrationTest::ReleaseAndCloseObjects(
|
||||
rtc::TaskQueue* task_queue) {
|
||||
rtc::Event sync_event(false, false);
|
||||
task_queue->PostTask([this, &sync_event]() {
|
||||
processor_->Release();
|
||||
sync_event.Set();
|
||||
});
|
||||
sync_event.Wait(rtc::Event::kForever);
|
||||
|
||||
// The VideoProcessor must be ::Release()'d before we destroy the codecs.
|
||||
DestroyEncoderAndDecoder();
|
||||
|
||||
// Close the analysis files before we use them for SSIM/PSNR calculations.
|
||||
analysis_frame_reader_->Close();
|
||||
analysis_frame_writer_->Close();
|
||||
|
||||
// Close visualization files.
|
||||
if (encoded_frame_writer_) {
|
||||
EXPECT_TRUE(encoded_frame_writer_->Close());
|
||||
}
|
||||
if (decoded_frame_writer_) {
|
||||
decoded_frame_writer_->Close();
|
||||
}
|
||||
}
|
||||
|
||||
// For every encoded frame, update the rate control metrics.
|
||||
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_;
|
||||
|
||||
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;
|
||||
|
||||
// Update layer data.
|
||||
// Update rate mismatch relative to per-frame bandwidth for delta frames.
|
||||
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];
|
||||
} 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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
// Verify expected behavior of rate control and print out data.
|
||||
void VideoProcessorIntegrationTest::PrintAndMaybeVerifyRateControlMetrics(
|
||||
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 RateControlThresholds* rc_threshold = nullptr;
|
||||
if (rc_thresholds) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
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) {
|
||||
case 1:
|
||||
tl_idx = 0;
|
||||
break;
|
||||
case 2:
|
||||
// temporal layer 0: 0 2 4 ...
|
||||
// temporal layer 1: 1 3
|
||||
tl_idx = (frame_number % 2 == 0) ? 0 : 1;
|
||||
break;
|
||||
case 3:
|
||||
// temporal layer 0: 0 4 8 ...
|
||||
// temporal layer 1: 2 6
|
||||
// temporal layer 2: 1 3 5 7
|
||||
if (frame_number % 4 == 0) {
|
||||
tl_idx = 0;
|
||||
} else if ((frame_number + 2) % 4 == 0) {
|
||||
tl_idx = 1;
|
||||
} else if ((frame_number + 1) % 2 == 0) {
|
||||
tl_idx = 2;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
RTC_NOTREACHED();
|
||||
break;
|
||||
}
|
||||
return tl_idx;
|
||||
}
|
||||
|
||||
// Reset quantities before each encoder rate update.
|
||||
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;
|
||||
}
|
||||
if (rate_update_index == 0) {
|
||||
target_size_key_frame_initial_ =
|
||||
0.5 * kInitialBufferSize * bitrate_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_;
|
||||
// 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_ =
|
||||
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;
|
||||
}
|
||||
|
||||
} // namespace test
|
||||
} // namespace webrtc
|
||||
Reference in New Issue
Block a user