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

Revert "Updated analysis in videoprocessor."

Browse Source 
This reverts commit 1880c7162bd3637c433f9421c798808cd6eacaf7.

Reason for revert: breaks internal tests

Original change's description:
> Updated analysis in videoprocessor.
> 
> - Run analysis after all frames are processed. Before part of it was
> done at bitrate change points;
> - Analysis is done for whole stream as well as for each rate update
> interval;
> - Changed units from number of frames to time units for some metrics
> and thresholds. E.g. 'num frames to hit tagret bitrate' is changed to
> 'time to reach target bitrate, sec';
> - Changed data type of FrameStatistic::max_nalu_length (renamed to
> max_nalu_size_bytes) from rtc::Optional to size_t. There it no need to
> use such advanced data type in such low level data structure.
> 
> Bug: webrtc:8524
> Change-Id: Ic9f6eab5b15ee12a80324b1f9c101de1bf3c702f
> Reviewed-on: https://webrtc-review.googlesource.com/31901
> Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
> Reviewed-by: Stefan Holmer <stefan@webrtc.org>
> Reviewed-by: Åsa Persson <asapersson@webrtc.org>
> Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#21653}

TBR=brandtr@webrtc.org,asapersson@webrtc.org,sprang@webrtc.org,stefan@webrtc.org,ssilkin@webrtc.org

Change-Id: Id0b7d387bbba02e71637b229aeed6f6cf012af46
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:8524
Reviewed-on: https://webrtc-review.googlesource.com/40220
Reviewed-by: Sergey Silkin <ssilkin@webrtc.org>
Commit-Queue: Sergey Silkin <ssilkin@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21656}
This commit is contained in:
Sergey Silkin
2018-01-17 13:15:57 +00:00
committed by Commit Bot
parent 53d877c0f8
commit 18bc3e19c4
20 changed files with 916 additions and 741 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -36,24 +36,35 @@ namespace test {
// Rates for the encoder and the frame number when to change profile.
struct RateProfile {
size_t target_kbps;
size_t input_fps;
size_t frame_index_rate_update;
int target_kbps;
int input_fps;
int frame_index_rate_update;
};
// 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 {
double max_avg_bitrate_mismatch_percent;
double max_time_to_reach_target_bitrate_sec;
// TODO(ssilkin): Use absolute threshold for framerate.
double max_avg_framerate_mismatch_percent;
double max_avg_buffer_level_sec;
double max_max_key_frame_delay_sec;
double max_max_delta_frame_delay_sec;
size_t max_num_spatial_resizes;
size_t max_num_key_frames;
int max_num_dropped_frames;
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;
};
// Thresholds for the quality metrics.
struct QualityThresholds {
QualityThresholds(double min_avg_psnr,
double min_min_psnr,
double min_avg_ssim,
double min_min_ssim)
: min_avg_psnr(min_avg_psnr),
min_min_psnr(min_min_psnr),
min_avg_ssim(min_avg_ssim),
min_min_ssim(min_min_ssim) {}
double min_avg_psnr;
double min_min_psnr;
double min_avg_ssim;
@ -61,7 +72,9 @@ struct QualityThresholds {
};
struct BitstreamThresholds {
size_t max_max_nalu_size_bytes;
explicit BitstreamThresholds(size_t max_nalu_length)
: max_nalu_length(max_nalu_length) {}
size_t max_nalu_length;
};
// Should video files be saved persistently to disk for post-run visualization?
@ -70,10 +83,15 @@ struct VisualizationParams {
bool save_decoded_y4m;
};
// Integration test for video processor. It does rate control and frame quality
// analysis using frame statistics collected by video processor and logs the
// results. If thresholds are specified it checks that corresponding metrics
// are in desirable range.
// Integration test for video processor. Encodes+decodes a clip and
// writes it to the output directory. After completion, quality metrics
// (PSNR and SSIM) and rate control metrics are computed and compared to given
// thresholds, to verify that the quality and encoder response is acceptable.
// The rate control tests allow us to verify the behavior for changing bit rate,
// changing frame rate, frame dropping/spatial resize, and temporal layers.
// The thresholds for the rate control metrics are set to be fairly
// conservative, so failure should only happen when some significant regression
// or breakdown occurs.
class VideoProcessorIntegrationTest : public testing::Test {
protected:
// Verifies that all H.264 keyframes contain SPS/PPS/IDR NALUs.
@ -89,7 +107,7 @@ class VideoProcessorIntegrationTest : public testing::Test {
void ProcessFramesAndMaybeVerify(
const std::vector<RateProfile>& rate_profiles,
const std::vector<RateControlThresholds>* rc_thresholds,
const std::vector<QualityThresholds>* quality_thresholds,
const QualityThresholds* quality_thresholds,
const BitstreamThresholds* bs_thresholds,
const VisualizationParams* visualization_params);
@ -101,6 +119,54 @@ class VideoProcessorIntegrationTest : public testing::Test {
private:
class CpuProcessTime;
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 * std::fabs(kbps - target_kbps) / target_kbps;
}
int BitrateMismatchPercent(int i, float target_kbps_layer) const {
return 100 * std::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;
};
struct QualityMetrics {
int num_decoded_frames = 0;
double total_psnr = 0.0;
double total_ssim = 0.0;
double min_psnr = std::numeric_limits<double>::max();
double min_ssim = std::numeric_limits<double>::max();
};
void CreateEncoderAndDecoder();
void DestroyEncoderAndDecoder();
@ -110,29 +176,26 @@ class VideoProcessorIntegrationTest : public testing::Test {
const VisualizationParams* visualization_params);
void ReleaseAndCloseObjects(rtc::TaskQueue* task_queue);
void ProcessAllFrames(rtc::TaskQueue* task_queue,
const std::vector<RateProfile>& rate_profiles);
void AnalyzeAllFrames(
const std::vector<RateProfile>& rate_profiles,
// Rate control metrics.
void ResetRateControlMetrics(int rate_update_index,
const std::vector<RateProfile>& rate_profiles);
void SetRatesPerTemporalLayer();
void UpdateRateControlMetrics(int frame_number);
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<QualityThresholds>* quality_thresholds,
const BitstreamThresholds* bs_thresholds);
const std::vector<int>& num_dropped_frames,
const std::vector<int>& num_spatial_resizes) const;
std::vector<FrameStatistic> ExtractLayerStats(
size_t target_spatial_layer_number,
size_t target_temporal_layer_number,
size_t first_frame_number,
size_t last_frame_number,
bool combine_layers);
void VerifyBitstream(int frame_number,
const BitstreamThresholds& bs_thresholds);
void AnalyzeAndPrintStats(const std::vector<FrameStatistic>& stats,
float target_bitrate_kbps,
float target_framerate_fps,
float input_duration_sec,
const RateControlThresholds* rc_thresholds,
const QualityThresholds* quality_thresholds,
const BitstreamThresholds* bs_thresholds);
void PrintFrameLevelStats(const std::vector<FrameStatistic>& stats) const;
void UpdateQualityMetrics(int frame_number);
void VerifyQualityMetrics(const QualityThresholds& quality_thresholds);
void PrintSettings() const;
@ -150,6 +213,14 @@ class VideoProcessorIntegrationTest : public testing::Test {
Stats stats_;
std::unique_ptr<VideoProcessor> processor_;
std::unique_ptr<CpuProcessTime> cpu_process_time_;
// Quantities updated for every encoded frame.
TestResults actual_;
// Rates set for every encoder rate update.
TargetRates target_;
QualityMetrics quality_;
};
} // namespace test