| /* | |
| * Copyright (c) 2022, Alliance for Open Media. All rights reserved | |
| * | |
| * This source code is subject to the terms of the BSD 2 Clause License and | |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License | |
| * was not distributed with this source code in the LICENSE file, you can | |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open | |
| * Media Patent License 1.0 was not distributed with this source code in the | |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. | |
| */ | |
| #include <array> | |
| #include <algorithm> | |
| #include <cerrno> | |
| #include <cstring> | |
| #include <fstream> | |
| #include <memory> | |
| #include <numeric> | |
| #include <string> | |
| #include <vector> | |
| #include "av1/encoder/encoder.h" | |
| #include "av1/qmode_rc/ducky_encode.h" | |
| #include "av1/qmode_rc/ratectrl_qmode.h" | |
| #include "av1/qmode_rc/ratectrl_qmode_interface.h" | |
| #include "test/video_source.h" | |
| #include "third_party/googletest/src/googlemock/include/gmock/gmock.h" | |
| #include "third_party/googletest/src/googletest/include/gtest/gtest.h" | |
| namespace aom { | |
| constexpr int kMaxRefFrames = 7; | |
| TEST(DuckyEncodeTest, ComputeFirstPassStats) { | |
| aom_rational_t frame_rate = { 30, 1 }; | |
| VideoInfo video_info = { 352, 288, | |
| frame_rate, AOM_IMG_FMT_I420, | |
| 1, "bus_352x288_420_f20_b8.yuv" }; | |
| video_info.file_path = | |
| libaom_test::GetDataPath() + "/" + video_info.file_path; | |
| DuckyEncode ducky_encode(video_info, BLOCK_64X64, kMaxRefFrames, 3, 128); | |
| std::vector<FIRSTPASS_STATS> frame_stats = | |
| ducky_encode.ComputeFirstPassStats(); | |
| EXPECT_EQ(frame_stats.size(), static_cast<size_t>(video_info.frame_count)); | |
| for (size_t i = 0; i < frame_stats.size(); ++i) { | |
| // FIRSTPASS_STATS's first element is frame | |
| EXPECT_EQ(frame_stats[i].frame, i); | |
| } | |
| } | |
| TEST(DuckyEncodeTest, EncodeFrame) { | |
| aom_rational_t frame_rate = { 30, 1 }; | |
| VideoInfo video_info = { 352, 288, | |
| frame_rate, AOM_IMG_FMT_I420, | |
| 17, "bus_352x288_420_f20_b8.yuv" }; | |
| video_info.file_path = | |
| libaom_test::GetDataPath() + "/" + video_info.file_path; | |
| DuckyEncode ducky_encode(video_info, BLOCK_64X64, kMaxRefFrames, 3, 128); | |
| std::vector<FIRSTPASS_STATS> frame_stats = | |
| ducky_encode.ComputeFirstPassStats(); | |
| ducky_encode.StartEncode(frame_stats); | |
| // We set coding_frame_count to a arbitrary number that smaller than | |
| // 17 here. | |
| // TODO(angiebird): Set coding_frame_count properly, once the DuckyEncode can | |
| // provide proper information. | |
| int coding_frame_count = 5; | |
| EncodeFrameDecision decision = { aom::EncodeFrameMode::kNone, | |
| aom::EncodeGopMode::kNone, | |
| {} }; | |
| for (int i = 0; i < coding_frame_count; ++i) { | |
| ducky_encode.AllocateBitstreamBuffer(video_info); | |
| EncodeFrameResult encode_frame_result = ducky_encode.EncodeFrame(decision); | |
| } | |
| ducky_encode.EndEncode(); | |
| } | |
| TEST(DuckyEncodeTest, EncodeFrameWithQindex) { | |
| aom_rational_t frame_rate = { 30, 1 }; | |
| VideoInfo video_info = { 352, 288, | |
| frame_rate, AOM_IMG_FMT_I420, | |
| 17, "bus_352x288_420_f20_b8.yuv" }; | |
| video_info.file_path = | |
| libaom_test::GetDataPath() + "/" + video_info.file_path; | |
| DuckyEncode ducky_encode(video_info, BLOCK_64X64, kMaxRefFrames, 3, 128); | |
| std::vector<FIRSTPASS_STATS> frame_stats = | |
| ducky_encode.ComputeFirstPassStats(); | |
| ducky_encode.StartEncode(frame_stats); | |
| // We set coding_frame_count to a arbitrary number that smaller than | |
| // 17 here. | |
| // TODO(angiebird): Set coding_frame_count properly, once the DuckyEncode can | |
| // provide proper information. | |
| int coding_frame_count = 5; | |
| int q_index = 0; | |
| EncodeFrameDecision decision = { aom::EncodeFrameMode::kQindex, | |
| aom::EncodeGopMode::kNone, | |
| { q_index, -1, {}, {} } }; | |
| for (int i = 0; i < coding_frame_count; ++i) { | |
| ducky_encode.AllocateBitstreamBuffer(video_info); | |
| EncodeFrameResult encode_frame_result = ducky_encode.EncodeFrame(decision); | |
| EXPECT_EQ(encode_frame_result.dist, 0); | |
| } | |
| ducky_encode.EndEncode(); | |
| } | |
| TEST(DuckyEncodeRCTest, EncodeVideoWithRC) { | |
| aom_rational_t frame_rate = { 30, 1 }; | |
| const int frame_number = 35; | |
| const int frame_width = 352; | |
| const int frame_height = 288; | |
| VideoInfo video_info = { frame_width, frame_height, | |
| frame_rate, AOM_IMG_FMT_I420, | |
| frame_number, "bus_352x288_420_f20_b8.yuv" }; | |
| video_info.file_path = | |
| libaom_test::GetDataPath() + "/" + video_info.file_path; | |
| DuckyEncode ducky_encode(video_info, BLOCK_64X64, kMaxRefFrames, 3, 128); | |
| AV1RateControlQMode qmode_rc; | |
| RateControlParam rc_param = {}; | |
| rc_param.max_gop_show_frame_count = 16; | |
| rc_param.min_gop_show_frame_count = 4; | |
| rc_param.ref_frame_table_size = 5; | |
| rc_param.max_ref_frames = 3; | |
| rc_param.base_q_index = 45; | |
| rc_param.max_distinct_q_indices_per_frame = 8; | |
| rc_param.max_distinct_lambda_scales_per_frame = 1; | |
| rc_param.frame_width = frame_width; | |
| rc_param.frame_height = frame_height; | |
| rc_param.tpl_pass_count = TplPassCount::kOneTplPass; | |
| rc_param.tpl_pass_index = 0; | |
| const Status status = qmode_rc.SetRcParam(rc_param); | |
| ASSERT_TRUE(status.ok()); | |
| FirstpassInfo firstpass_info; | |
| firstpass_info.stats_list = ducky_encode.ComputeFirstPassStats(); | |
| constexpr int kBlockSize = 16; | |
| firstpass_info.num_mbs_16x16 = ((frame_width + kBlockSize - 1) / kBlockSize) * | |
| ((frame_height + kBlockSize - 1) / kBlockSize); | |
| const auto gop_info = qmode_rc.DetermineGopInfo(firstpass_info); | |
| ASSERT_TRUE(gop_info.status().ok()); | |
| const GopStructList &gop_list = gop_info.value(); | |
| std::vector<aom::GopEncodeInfo> tpl_pass_gop_encode_info_list; | |
| std::vector<aom::TplGopStats> tpl_gop_stats_list; | |
| for (const auto &gop_struct : gop_list) { | |
| const auto gop_encode_info = | |
| qmode_rc.GetTplPassGopEncodeInfo(gop_struct, firstpass_info); | |
| ASSERT_TRUE(gop_encode_info.status().ok()); | |
| tpl_pass_gop_encode_info_list.push_back(std::move(*gop_encode_info)); | |
| } | |
| tpl_gop_stats_list = ducky_encode.ComputeTplStats( | |
| firstpass_info.stats_list, gop_list, tpl_pass_gop_encode_info_list); | |
| std::vector<aom::GopEncodeInfo> final_pass_gop_encode_info_list; | |
| aom::RefFrameTable ref_frame_table; | |
| for (size_t i = 0; i < gop_list.size(); ++i) { | |
| const aom::GopStruct &gop_struct = gop_list[i]; | |
| const aom::TplGopStats &tpl_gop_stats = tpl_gop_stats_list[i]; | |
| std::vector<aom::LookaheadStats> lookahead_stats = {}; | |
| for (size_t lookahead_index = 1; | |
| lookahead_index <= 1 && i + lookahead_index < gop_list.size(); | |
| ++lookahead_index) { | |
| lookahead_stats.push_back({ &gop_list[i + lookahead_index], | |
| &tpl_gop_stats_list[i + lookahead_index] }); | |
| } | |
| const auto gop_encode_info = | |
| qmode_rc.GetGopEncodeInfo(gop_struct, tpl_gop_stats, lookahead_stats, | |
| firstpass_info, ref_frame_table); | |
| ASSERT_TRUE(gop_encode_info.status().ok()); | |
| ref_frame_table = gop_encode_info.value().final_snapshot; | |
| final_pass_gop_encode_info_list.push_back(std::move(*gop_encode_info)); | |
| } | |
| ducky_encode.StartEncode(firstpass_info.stats_list); | |
| std::vector<aom::EncodeFrameResult> encoded_frames_list = | |
| ducky_encode.EncodeVideo(gop_list, final_pass_gop_encode_info_list); | |
| ducky_encode.EndEncode(); | |
| EXPECT_THAT(encoded_frames_list, | |
| testing::Each(testing::Field( | |
| "psnr", &aom::EncodeFrameResult::psnr, testing::Gt(37)))); | |
| } | |
| TEST(DuckyEncodeTest, EncodeFrameMode) { | |
| EXPECT_EQ(DUCKY_ENCODE_FRAME_MODE_NONE, | |
| static_cast<DUCKY_ENCODE_FRAME_MODE>(EncodeFrameMode::kNone)); | |
| EXPECT_EQ(DUCKY_ENCODE_FRAME_MODE_QINDEX, | |
| static_cast<DUCKY_ENCODE_FRAME_MODE>(EncodeFrameMode::kQindex)); | |
| EXPECT_EQ( | |
| DUCKY_ENCODE_FRAME_MODE_QINDEX_RDMULT, | |
| static_cast<DUCKY_ENCODE_FRAME_MODE>(EncodeFrameMode::kQindexRdmult)); | |
| } | |
| } // namespace aom |