ref: d058d41e87f2bc80beeca08a83fa9c30f01e42ac
dir: /test/simple_encode_test.cc/
/*
* Copyright (c) 2019 The WebM 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 <math.h>
#include <memory>
#include <vector>
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "vp9/simple_encode.h"
namespace vp9 {
namespace {
// TODO(angirbid): Find a better way to construct encode info
const int w = 352;
const int h = 288;
const int frame_rate_num = 30;
const int frame_rate_den = 1;
const int target_bitrate = 1000;
const int num_frames = 17;
const char infile_path[] = "bus_352x288_420_f20_b8.yuv";
double GetBitrateInKbps(size_t bit_size, int num_frames, int frame_rate_num,
int frame_rate_den) {
return static_cast<double>(bit_size) / num_frames * frame_rate_num /
frame_rate_den / 1000.0;
}
// Returns the number of unit in size of 4.
// For example, if size is 7, return 2.
int GetNumUnit4x4(int size) { return (size + 3) >> 2; }
TEST(SimpleEncode, ComputeFirstPassStats) {
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
std::vector<std::vector<double>> frame_stats =
simple_encode.ObserveFirstPassStats();
EXPECT_EQ(frame_stats.size(), static_cast<size_t>(num_frames));
size_t data_num = frame_stats[0].size();
// Read ObserveFirstPassStats before changing FIRSTPASS_STATS.
EXPECT_EQ(data_num, static_cast<size_t>(25));
for (size_t i = 0; i < frame_stats.size(); ++i) {
EXPECT_EQ(frame_stats[i].size(), data_num);
// FIRSTPASS_STATS's first element is frame
EXPECT_EQ(frame_stats[i][0], i);
// FIRSTPASS_STATS's last element is count, and the count is 1 for single
// frame stats
EXPECT_EQ(frame_stats[i][data_num - 1], 1);
}
}
TEST(SimpleEncode, GetCodingFrameNum) {
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
int num_coding_frames = simple_encode.GetCodingFrameNum();
EXPECT_EQ(num_coding_frames, 19);
}
TEST(SimpleEncode, EncodeFrame) {
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
int num_coding_frames = simple_encode.GetCodingFrameNum();
EXPECT_GE(num_coding_frames, num_frames);
simple_encode.StartEncode();
size_t total_data_bit_size = 0;
int coded_show_frame_count = 0;
int frame_coding_index = 0;
while (coded_show_frame_count < num_frames) {
const GroupOfPicture group_of_picture =
simple_encode.ObserveGroupOfPicture();
const std::vector<EncodeFrameInfo> &encode_frame_list =
group_of_picture.encode_frame_list;
for (size_t group_index = 0; group_index < encode_frame_list.size();
++group_index) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
EXPECT_EQ(encode_frame_result.show_idx,
encode_frame_list[group_index].show_idx);
EXPECT_EQ(encode_frame_result.frame_type,
encode_frame_list[group_index].frame_type);
EXPECT_EQ(encode_frame_list[group_index].coding_index,
frame_coding_index);
EXPECT_GE(encode_frame_result.psnr, 34)
<< "The psnr is supposed to be greater than 34 given the "
"target_bitrate 1000 kbps";
EXPECT_EQ(encode_frame_result.ref_frame_info,
encode_frame_list[group_index].ref_frame_info);
total_data_bit_size += encode_frame_result.coding_data_bit_size;
++frame_coding_index;
}
coded_show_frame_count += group_of_picture.show_frame_count;
}
const double bitrate = GetBitrateInKbps(total_data_bit_size, num_frames,
frame_rate_num, frame_rate_den);
const double off_target_threshold = 150;
EXPECT_LE(fabs(target_bitrate - bitrate), off_target_threshold);
simple_encode.EndEncode();
}
TEST(SimpleEncode, EncodeFrameWithQuantizeIndex) {
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
int num_coding_frames = simple_encode.GetCodingFrameNum();
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
const int assigned_quantize_index = 100 + i;
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrameWithQuantizeIndex(&encode_frame_result,
assigned_quantize_index);
EXPECT_EQ(encode_frame_result.quantize_index, assigned_quantize_index);
}
simple_encode.EndEncode();
}
TEST(SimpleEncode, EncodeConsistencyTest) {
std::vector<int> quantize_index_list;
std::vector<uint64_t> ref_sse_list;
std::vector<double> ref_psnr_list;
std::vector<size_t> ref_bit_size_list;
{
// The first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
quantize_index_list.push_back(encode_frame_result.quantize_index);
ref_sse_list.push_back(encode_frame_result.sse);
ref_psnr_list.push_back(encode_frame_result.psnr);
ref_bit_size_list.push_back(encode_frame_result.coding_data_bit_size);
}
simple_encode.EndEncode();
}
{
// The second encode with quantize index got from the first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
EXPECT_EQ(static_cast<size_t>(num_coding_frames),
quantize_index_list.size());
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrameWithQuantizeIndex(&encode_frame_result,
quantize_index_list[i]);
EXPECT_EQ(encode_frame_result.quantize_index, quantize_index_list[i]);
EXPECT_EQ(encode_frame_result.sse, ref_sse_list[i]);
EXPECT_DOUBLE_EQ(encode_frame_result.psnr, ref_psnr_list[i]);
EXPECT_EQ(encode_frame_result.coding_data_bit_size, ref_bit_size_list[i]);
}
simple_encode.EndEncode();
}
}
// Test the information (partition info and motion vector info) stored in
// encoder is the same between two encode runs.
TEST(SimpleEncode, EncodeConsistencyTest2) {
const int num_rows_4x4 = GetNumUnit4x4(w);
const int num_cols_4x4 = GetNumUnit4x4(h);
const int num_units_4x4 = num_rows_4x4 * num_cols_4x4;
// The first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
std::vector<PartitionInfo> partition_info_list(num_units_4x4 *
num_coding_frames);
std::vector<MotionVectorInfo> motion_vector_info_list(num_units_4x4 *
num_coding_frames);
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
for (int j = 0; j < num_rows_4x4 * num_cols_4x4; ++j) {
partition_info_list[i * num_units_4x4 + j] =
encode_frame_result.partition_info[j];
motion_vector_info_list[i * num_units_4x4 + j] =
encode_frame_result.motion_vector_info[j];
}
}
simple_encode.EndEncode();
// The second encode.
SimpleEncode simple_encode_2(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode_2.ComputeFirstPassStats();
const int num_coding_frames_2 = simple_encode_2.GetCodingFrameNum();
simple_encode_2.StartEncode();
for (int i = 0; i < num_coding_frames_2; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode_2.EncodeFrame(&encode_frame_result);
for (int j = 0; j < num_rows_4x4 * num_cols_4x4; ++j) {
EXPECT_EQ(encode_frame_result.partition_info[j].row,
partition_info_list[i * num_units_4x4 + j].row);
EXPECT_EQ(encode_frame_result.partition_info[j].column,
partition_info_list[i * num_units_4x4 + j].column);
EXPECT_EQ(encode_frame_result.partition_info[j].row_start,
partition_info_list[i * num_units_4x4 + j].row_start);
EXPECT_EQ(encode_frame_result.partition_info[j].column_start,
partition_info_list[i * num_units_4x4 + j].column_start);
EXPECT_EQ(encode_frame_result.partition_info[j].width,
partition_info_list[i * num_units_4x4 + j].width);
EXPECT_EQ(encode_frame_result.partition_info[j].height,
partition_info_list[i * num_units_4x4 + j].height);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].mv_count,
motion_vector_info_list[i * num_units_4x4 + j].mv_count);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].ref_frame[0],
motion_vector_info_list[i * num_units_4x4 + j].ref_frame[0]);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].ref_frame[1],
motion_vector_info_list[i * num_units_4x4 + j].ref_frame[1]);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].mv_row[0],
motion_vector_info_list[i * num_units_4x4 + j].mv_row[0]);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].mv_column[0],
motion_vector_info_list[i * num_units_4x4 + j].mv_column[0]);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].mv_row[1],
motion_vector_info_list[i * num_units_4x4 + j].mv_row[1]);
EXPECT_EQ(encode_frame_result.motion_vector_info[j].mv_column[1],
motion_vector_info_list[i * num_units_4x4 + j].mv_column[1]);
}
}
simple_encode_2.EndEncode();
}
// Test the information stored in encoder is the same between two encode runs.
TEST(SimpleEncode, EncodeConsistencyTest3) {
std::vector<int> quantize_index_list;
const int num_rows_4x4 = GetNumUnit4x4(w);
const int num_cols_4x4 = GetNumUnit4x4(h);
const int num_units_4x4 = num_rows_4x4 * num_cols_4x4;
// The first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
std::vector<PartitionInfo> partition_info_list(num_units_4x4 *
num_coding_frames);
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
quantize_index_list.push_back(encode_frame_result.quantize_index);
for (int j = 0; j < num_rows_4x4 * num_cols_4x4; ++j) {
partition_info_list[i * num_units_4x4 + j] =
encode_frame_result.partition_info[j];
}
}
simple_encode.EndEncode();
// The second encode.
SimpleEncode simple_encode_2(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode_2.ComputeFirstPassStats();
const int num_coding_frames_2 = simple_encode_2.GetCodingFrameNum();
simple_encode_2.StartEncode();
for (int i = 0; i < num_coding_frames_2; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode_2.EncodeFrameWithQuantizeIndex(&encode_frame_result,
quantize_index_list[i]);
for (int j = 0; j < num_rows_4x4 * num_cols_4x4; ++j) {
EXPECT_EQ(encode_frame_result.partition_info[j].row,
partition_info_list[i * num_units_4x4 + j].row);
EXPECT_EQ(encode_frame_result.partition_info[j].column,
partition_info_list[i * num_units_4x4 + j].column);
EXPECT_EQ(encode_frame_result.partition_info[j].row_start,
partition_info_list[i * num_units_4x4 + j].row_start);
EXPECT_EQ(encode_frame_result.partition_info[j].column_start,
partition_info_list[i * num_units_4x4 + j].column_start);
EXPECT_EQ(encode_frame_result.partition_info[j].width,
partition_info_list[i * num_units_4x4 + j].width);
EXPECT_EQ(encode_frame_result.partition_info[j].height,
partition_info_list[i * num_units_4x4 + j].height);
}
}
simple_encode_2.EndEncode();
}
// Encode with default VP9 decision first.
// Get QPs and arf locations from the first encode.
// Set external arfs and QPs for the second encode.
// Expect to get matched results.
TEST(SimpleEncode, EncodeConsistencyTestUseExternalArfs) {
std::vector<int> quantize_index_list;
std::vector<uint64_t> ref_sse_list;
std::vector<double> ref_psnr_list;
std::vector<size_t> ref_bit_size_list;
std::vector<int> external_arf_indexes(num_frames, 0);
{
// The first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
quantize_index_list.push_back(encode_frame_result.quantize_index);
ref_sse_list.push_back(encode_frame_result.sse);
ref_psnr_list.push_back(encode_frame_result.psnr);
ref_bit_size_list.push_back(encode_frame_result.coding_data_bit_size);
if (encode_frame_result.frame_type == kFrameTypeKey) {
external_arf_indexes[encode_frame_result.show_idx] = 0;
} else if (encode_frame_result.frame_type == kFrameTypeAltRef) {
external_arf_indexes[encode_frame_result.show_idx] = 1;
} else {
// This has to be |= because we can't let overlay overwrites the
// arf type for the same frame.
external_arf_indexes[encode_frame_result.show_idx] |= 0;
}
}
simple_encode.EndEncode();
}
{
// The second encode with quantize index got from the first encode.
// The external arfs are the same as the first encode.
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
simple_encode.SetExternalGroupOfPicture(external_arf_indexes);
const int num_coding_frames = simple_encode.GetCodingFrameNum();
EXPECT_EQ(static_cast<size_t>(num_coding_frames),
quantize_index_list.size());
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrameWithQuantizeIndex(&encode_frame_result,
quantize_index_list[i]);
EXPECT_EQ(encode_frame_result.quantize_index, quantize_index_list[i]);
EXPECT_EQ(encode_frame_result.sse, ref_sse_list[i]);
EXPECT_DOUBLE_EQ(encode_frame_result.psnr, ref_psnr_list[i]);
EXPECT_EQ(encode_frame_result.coding_data_bit_size, ref_bit_size_list[i]);
}
simple_encode.EndEncode();
}
}
TEST(SimpleEncode, GetEncodeFrameInfo) {
// Makes sure that the encode_frame_info obtained from GetEncodeFrameInfo()
// matches the counterpart in encode_frame_result obtained from EncodeFrame()
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
simple_encode.ComputeFirstPassStats();
const int num_coding_frames = simple_encode.GetCodingFrameNum();
simple_encode.StartEncode();
for (int i = 0; i < num_coding_frames; ++i) {
EncodeFrameInfo encode_frame_info = simple_encode.GetNextEncodeFrameInfo();
EncodeFrameResult encode_frame_result;
simple_encode.EncodeFrame(&encode_frame_result);
EXPECT_EQ(encode_frame_info.show_idx, encode_frame_result.show_idx);
EXPECT_EQ(encode_frame_info.frame_type, encode_frame_result.frame_type);
}
simple_encode.EndEncode();
}
TEST(SimpleEncode, GetFramePixelCount) {
SimpleEncode simple_encode(w, h, frame_rate_num, frame_rate_den,
target_bitrate, num_frames, infile_path);
EXPECT_EQ(simple_encode.GetFramePixelCount(),
static_cast<uint64_t>(w * h * 3 / 2));
}
} // namespace
} // namespace vp9