blob: 40b82114328b39b24ec4c7f9c07d42aa1ff2c6b2 [file] [log] [blame]
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/gpu/vaapi/vp9_vaapi_video_encoder_delegate.h"
#include <memory>
#include <numeric>
#include <tuple>
#include "base/callback.h"
#include "base/callback_helpers.h"
#include "base/cxx17_backports.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "media/filters/vp9_parser.h"
#include "media/gpu/vaapi/vaapi_common.h"
#include "media/gpu/vaapi/vaapi_wrapper.h"
#include "media/gpu/vaapi/vp9_rate_control.h"
#include "media/gpu/vaapi/vp9_svc_layers.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/libvpx/source/libvpx/vp9/common/vp9_blockd.h"
#include "third_party/libvpx/source/libvpx/vp9/ratectrl_rtc.h"
using ::testing::_;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Return;
namespace media {
namespace {
constexpr size_t kDefaultMaxNumRefFrames = kVp9NumRefsPerFrame;
constexpr double kSpatialLayersBitrateScaleFactors[][3] = {
{1.00, 0.00, 0.00}, // For one spatial layer.
{0.30, 0.70, 0.00}, // For two spatial layers.
{0.07, 0.23, 0.70}, // For three spatial layers.
};
constexpr int kSpatialLayersResolutionScaleDenom[][3] = {
{1, 0, 0}, // For one spatial layer.
{2, 1, 0}, // For two spatial layers.
{4, 2, 1}, // For three spatial layers.
};
constexpr double kTemporalLayersBitrateScaleFactors[][3] = {
{1.00, 0.00, 0.00}, // For one temporal layer.
{0.50, 0.50, 0.00}, // For two temporal layers.
{0.25, 0.25, 0.50}, // For three temporal layers.
};
constexpr uint8_t kTemporalLayerPattern[][4] = {
{0, 0, 0, 0},
{0, 1, 0, 1},
{0, 2, 1, 2},
};
VaapiVideoEncoderDelegate::Config kDefaultVaapiVideoEncoderDelegateConfig{
kDefaultMaxNumRefFrames,
VaapiVideoEncoderDelegate::BitrateControl::kConstantQuantizationParameter};
VideoEncodeAccelerator::Config kDefaultVideoEncodeAcceleratorConfig(
PIXEL_FORMAT_I420,
gfx::Size(1280, 720),
VP9PROFILE_PROFILE0,
Bitrate::ConstantBitrate(14000000)
/* = maximum bitrate in bits per second for level 3.1 */,
VideoEncodeAccelerator::kDefaultFramerate,
absl::nullopt /* gop_length */,
absl::nullopt /* h264 output level*/,
false /* is_constrained_h264 */,
VideoEncodeAccelerator::Config::StorageType::kShmem);
constexpr std::array<bool, kVp9NumRefsPerFrame> kRefFramesUsedForKeyFrame = {
false, false, false};
constexpr std::array<bool, kVp9NumRefsPerFrame> kRefFramesUsedForInterFrame = {
true, true, true};
constexpr std::array<bool, kVp9NumRefsPerFrame>
kRefFramesUsedForInterFrameInTemporalLayer = {true, false, false};
void GetTemporalLayer(bool keyframe,
int frame_num,
size_t num_spatial_layers,
size_t num_temporal_layers,
std::array<bool, kVp9NumRefsPerFrame>* ref_frames_used,
uint8_t* temporal_layer_id) {
switch (num_temporal_layers) {
case 1:
*temporal_layer_id = 0;
if (num_spatial_layers > 1) {
// K-SVC stream.
*ref_frames_used = keyframe
? kRefFramesUsedForKeyFrame
: kRefFramesUsedForInterFrameInTemporalLayer;
} else {
// Simple stream.
*ref_frames_used =
keyframe ? kRefFramesUsedForKeyFrame : kRefFramesUsedForInterFrame;
}
break;
case 2:
if (keyframe) {
*temporal_layer_id = 0;
*ref_frames_used = kRefFramesUsedForKeyFrame;
return;
}
{
*temporal_layer_id = kTemporalLayerPattern[1][frame_num % 4];
*ref_frames_used = kRefFramesUsedForInterFrameInTemporalLayer;
}
break;
case 3:
if (keyframe) {
*temporal_layer_id = 0u;
*ref_frames_used = kRefFramesUsedForKeyFrame;
return;
}
{
*temporal_layer_id = kTemporalLayerPattern[2][frame_num % 4];
*ref_frames_used = kRefFramesUsedForInterFrameInTemporalLayer;
}
break;
}
}
VideoBitrateAllocation GetDefaultVideoBitrateAllocation(
size_t num_spatial_layers,
size_t num_temporal_layers,
uint32_t bitrate) {
VideoBitrateAllocation bitrate_allocation;
DCHECK_LE(num_spatial_layers, 3u);
DCHECK_LE(num_temporal_layers, 3u);
if (num_spatial_layers == 1u && num_temporal_layers == 1u) {
bitrate_allocation.SetBitrate(0, 0, bitrate);
return bitrate_allocation;
}
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const double bitrate_factor =
kSpatialLayersBitrateScaleFactors[num_spatial_layers - 1][sid];
uint32_t sl_bitrate = bitrate * bitrate_factor;
for (size_t tl_idx = 0; tl_idx < num_temporal_layers; ++tl_idx) {
const double tl_factor =
kTemporalLayersBitrateScaleFactors[num_temporal_layers - 1][tl_idx];
bitrate_allocation.SetBitrate(
sid, tl_idx, base::checked_cast<int>(sl_bitrate * tl_factor));
}
}
return bitrate_allocation;
}
VideoBitrateAllocation CreateBitrateAllocationWithActiveLayers(
const VideoBitrateAllocation& bitrate_allocation,
const std::vector<size_t>& active_layers) {
VideoBitrateAllocation new_bitrate_allocation;
for (size_t si : active_layers) {
for (size_t ti = 0; ti < VideoBitrateAllocation::kMaxTemporalLayers; ++ti) {
const int bps = bitrate_allocation.GetBitrateBps(si, ti);
new_bitrate_allocation.SetBitrate(si, ti, bps);
}
}
return new_bitrate_allocation;
}
VideoBitrateAllocation AdaptBitrateAllocation(
const VideoBitrateAllocation& bitrate_allocation) {
VideoBitrateAllocation new_bitrate_allocation;
size_t new_si = 0;
for (size_t si = 0; si < VideoBitrateAllocation::kMaxSpatialLayers; ++si) {
int sum = 0;
for (size_t ti = 0; ti < VideoBitrateAllocation::kMaxTemporalLayers; ++ti)
sum += bitrate_allocation.GetBitrateBps(si, ti);
if (sum == 0) {
// The spatial layer is disabled.
continue;
}
for (size_t ti = 0; ti < VideoBitrateAllocation::kMaxTemporalLayers; ++ti) {
const int bps = bitrate_allocation.GetBitrateBps(si, ti);
new_bitrate_allocation.SetBitrate(new_si, ti, bps);
}
new_si++;
}
return new_bitrate_allocation;
}
std::vector<gfx::Size> GetDefaultSpatialLayerResolutions(
size_t num_spatial_layers) {
constexpr gfx::Size& kDefaultSize =
kDefaultVideoEncodeAcceleratorConfig.input_visible_size;
std::vector<gfx::Size> spatial_layer_resolutions(num_spatial_layers);
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const int denom =
kSpatialLayersResolutionScaleDenom[num_spatial_layers - 1][sid];
spatial_layer_resolutions[sid] =
gfx::Size(kDefaultSize.width() / denom, kDefaultSize.height() / denom);
}
return spatial_layer_resolutions;
}
MATCHER_P4(MatchRtcConfigWithRates,
bitrate_allocation,
framerate,
num_temporal_layers,
spatial_layer_resolutions,
"") {
if (arg.target_bandwidth != bitrate_allocation.GetSumBps() / 1000)
return false;
if (arg.framerate != static_cast<double>(framerate))
return false;
const size_t num_spatial_layers = spatial_layer_resolutions.size();
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
int bitrate_sum = 0;
for (size_t tid = 0; tid < num_temporal_layers; ++tid) {
size_t idx = sid * num_temporal_layers + tid;
bitrate_sum += bitrate_allocation.GetBitrateBps(sid, tid);
if (arg.layer_target_bitrate[idx] != bitrate_sum / 1000)
return false;
if (arg.ts_rate_decimator[tid] != (1 << (num_temporal_layers - tid - 1)))
return false;
}
if (arg.scaling_factor_num[sid] != 1 ||
arg.scaling_factor_den[sid] !=
kSpatialLayersResolutionScaleDenom[num_spatial_layers - 1][sid]) {
return false;
}
}
const gfx::Size& size = spatial_layer_resolutions.back();
return arg.width == size.width() && arg.height == size.height() &&
base::checked_cast<size_t>(arg.ss_number_layers) ==
num_spatial_layers &&
base::checked_cast<size_t>(arg.ts_number_layers) ==
num_temporal_layers;
}
MATCHER_P3(MatchFrameParam,
frame_type,
temporal_layer_id,
spatial_layer_id,
"") {
return arg.frame_type == frame_type &&
arg.temporal_layer_id == temporal_layer_id &&
arg.spatial_layer_id == spatial_layer_id;
}
class MockVaapiWrapper : public VaapiWrapper {
public:
MockVaapiWrapper() : VaapiWrapper(kEncodeConstantQuantizationParameter) {}
protected:
~MockVaapiWrapper() override = default;
};
class MockVP9RateControl : public VP9RateControl {
public:
MockVP9RateControl() = default;
~MockVP9RateControl() override = default;
MOCK_METHOD1(UpdateRateControl, void(const libvpx::VP9RateControlRtcConfig&));
MOCK_CONST_METHOD0(GetQP, int());
MOCK_CONST_METHOD0(GetLoopfilterLevel, int());
MOCK_METHOD1(ComputeQP, void(const libvpx::VP9FrameParamsQpRTC&));
MOCK_METHOD1(PostEncodeUpdate, void(uint64_t));
};
} // namespace
struct VP9VaapiVideoEncoderDelegateTestParam;
class VP9VaapiVideoEncoderDelegateTest
: public ::testing::TestWithParam<VP9VaapiVideoEncoderDelegateTestParam> {
public:
using BitrateControl = VaapiVideoEncoderDelegate::BitrateControl;
VP9VaapiVideoEncoderDelegateTest() = default;
~VP9VaapiVideoEncoderDelegateTest() override = default;
void SetUp() override;
MOCK_METHOD0(OnError, void());
protected:
void ResetEncoder();
void InitializeVP9VaapiVideoEncoderDelegate(size_t num_spatial_layers,
size_t num_temporal_layers);
void EncodeConstantQuantizationParameterSequence(
bool is_keyframe,
const gfx::Size& layer_size,
absl::optional<std::array<bool, kVp9NumRefsPerFrame>>
expected_ref_frames_used,
uint8_t expected_temporal_layer_id,
uint8_t expected_spatial_layer_id);
void UpdateRatesTest(size_t num_spatial_layers, size_t num_temporal_layers);
void UpdateRatesAndEncode(
const VideoBitrateAllocation& bitrate_allocation,
uint32_t framerate,
bool valid_rates_request,
bool is_key_pic,
const std::vector<gfx::Size>& expected_spatial_layer_resolutions,
size_t expected_temporal_layers,
size_t expected_temporal_layer_id);
private:
std::unique_ptr<VaapiVideoEncoderDelegate::EncodeJob> CreateEncodeJob(
bool keyframe,
const scoped_refptr<VASurface>& va_surface,
const scoped_refptr<VP9Picture>& picture);
std::unique_ptr<VP9VaapiVideoEncoderDelegate> encoder_;
scoped_refptr<MockVaapiWrapper> mock_vaapi_wrapper_;
MockVP9RateControl* mock_rate_ctrl_ = nullptr;
};
void VP9VaapiVideoEncoderDelegateTest::ResetEncoder() {
encoder_ = std::make_unique<VP9VaapiVideoEncoderDelegate>(
mock_vaapi_wrapper_,
base::BindRepeating(&VP9VaapiVideoEncoderDelegateTest::OnError,
base::Unretained(this)));
}
void VP9VaapiVideoEncoderDelegateTest::SetUp() {
mock_vaapi_wrapper_ = base::MakeRefCounted<MockVaapiWrapper>();
ASSERT_TRUE(mock_vaapi_wrapper_);
ResetEncoder();
EXPECT_CALL(*this, OnError()).Times(0);
}
std::unique_ptr<VaapiVideoEncoderDelegate::EncodeJob>
VP9VaapiVideoEncoderDelegateTest::CreateEncodeJob(
bool keyframe,
const scoped_refptr<VASurface>& va_surface,
const scoped_refptr<VP9Picture>& picture) {
auto input_frame = VideoFrame::CreateFrame(
kDefaultVideoEncodeAcceleratorConfig.input_format,
kDefaultVideoEncodeAcceleratorConfig.input_visible_size,
gfx::Rect(kDefaultVideoEncodeAcceleratorConfig.input_visible_size),
kDefaultVideoEncodeAcceleratorConfig.input_visible_size,
base::TimeDelta());
LOG_ASSERT(input_frame) << " Failed to create VideoFrame";
constexpr VABufferID kDummyVABufferID = 12;
auto scoped_va_buffer = ScopedVABuffer::CreateForTesting(
kDummyVABufferID, VAEncCodedBufferType,
kDefaultVideoEncodeAcceleratorConfig.input_visible_size.GetArea());
return std::make_unique<VaapiVideoEncoderDelegate::EncodeJob>(
input_frame, keyframe, base::DoNothing(), va_surface, picture,
std::move(scoped_va_buffer));
}
void VP9VaapiVideoEncoderDelegateTest::InitializeVP9VaapiVideoEncoderDelegate(
size_t num_spatial_layers,
size_t num_temporal_layers) {
auto config = kDefaultVideoEncodeAcceleratorConfig;
auto ave_config = kDefaultVaapiVideoEncoderDelegateConfig;
auto rate_ctrl = std::make_unique<MockVP9RateControl>();
mock_rate_ctrl_ = rate_ctrl.get();
encoder_->set_rate_ctrl_for_testing(std::move(rate_ctrl));
VideoBitrateAllocation initial_bitrate_allocation;
initial_bitrate_allocation.SetBitrate(
0, 0, kDefaultVideoEncodeAcceleratorConfig.bitrate.target());
std::vector<gfx::Size> svc_layer_size =
GetDefaultSpatialLayerResolutions(num_spatial_layers);
if (num_spatial_layers > 1u || num_temporal_layers > 1u) {
DCHECK_GT(num_spatial_layers, 0u);
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const double bitrate_factor =
kSpatialLayersBitrateScaleFactors[num_spatial_layers - 1][sid];
VideoEncodeAccelerator::Config::SpatialLayer spatial_layer;
spatial_layer.width = svc_layer_size[sid].width();
spatial_layer.height = svc_layer_size[sid].height();
spatial_layer.bitrate_bps = config.bitrate.target() * bitrate_factor;
spatial_layer.framerate = *config.initial_framerate;
spatial_layer.num_of_temporal_layers = num_temporal_layers;
spatial_layer.max_qp = 30u;
config.spatial_layers.push_back(spatial_layer);
}
}
EXPECT_CALL(
*mock_rate_ctrl_,
UpdateRateControl(MatchRtcConfigWithRates(
GetDefaultVideoBitrateAllocation(
num_spatial_layers, num_temporal_layers, config.bitrate.target()),
VideoEncodeAccelerator::kDefaultFramerate, num_temporal_layers,
svc_layer_size)))
.Times(1)
.WillOnce(Return());
EXPECT_TRUE(encoder_->Initialize(config, ave_config));
EXPECT_EQ(num_temporal_layers > 1u || num_spatial_layers > 1u,
!!encoder_->svc_layers_);
EXPECT_EQ(encoder_->GetSVCLayerResolutions(), svc_layer_size);
}
void VP9VaapiVideoEncoderDelegateTest::
EncodeConstantQuantizationParameterSequence(
bool is_keyframe,
const gfx::Size& layer_size,
absl::optional<std::array<bool, kVp9NumRefsPerFrame>>
expected_ref_frames_used,
uint8_t expected_temporal_layer_id,
uint8_t expected_spatial_layer_id) {
InSequence seq;
constexpr VASurfaceID kDummyVASurfaceID = 123;
auto va_surface = base::MakeRefCounted<VASurface>(
kDummyVASurfaceID, layer_size, VA_RT_FORMAT_YUV420, base::DoNothing());
scoped_refptr<VP9Picture> picture = new VaapiVP9Picture(va_surface);
auto encode_job = CreateEncodeJob(is_keyframe, va_surface, picture);
FRAME_TYPE libvpx_frame_type =
is_keyframe ? FRAME_TYPE::KEY_FRAME : FRAME_TYPE::INTER_FRAME;
EXPECT_CALL(
*mock_rate_ctrl_,
ComputeQP(MatchFrameParam(libvpx_frame_type, expected_temporal_layer_id,
expected_spatial_layer_id)))
.WillOnce(Return());
constexpr int kDefaultQP = 34;
constexpr int kDefaultLoopFilterLevel = 8;
EXPECT_CALL(*mock_rate_ctrl_, GetQP()).WillOnce(Return(kDefaultQP));
EXPECT_CALL(*mock_rate_ctrl_, GetLoopfilterLevel())
.WillOnce(Return(kDefaultLoopFilterLevel));
// TODO(mcasas): Consider setting expectations on MockVaapiWrapper calls.
EXPECT_TRUE(encoder_->PrepareEncodeJob(encode_job.get()));
// TODO(hiroh): Test for encoder_->reference_frames_.
constexpr size_t kDefaultEncodedFrameSize = 123456;
// For BitrateControlUpdate sequence.
EXPECT_CALL(*mock_rate_ctrl_, PostEncodeUpdate(kDefaultEncodedFrameSize))
.WillOnce(Return());
encoder_->BitrateControlUpdate(kDefaultEncodedFrameSize);
}
void VP9VaapiVideoEncoderDelegateTest::UpdateRatesAndEncode(
const VideoBitrateAllocation& bitrate_allocation,
uint32_t framerate,
bool valid_rates_request,
bool is_key_pic,
const std::vector<gfx::Size>& expected_spatial_layer_resolutions,
size_t expected_temporal_layers,
size_t expected_temporal_layer_id) {
ASSERT_TRUE(encoder_->current_params_.bitrate_allocation !=
bitrate_allocation ||
encoder_->current_params_.framerate != framerate);
// Since the request is pended, this is always successful and no call happens
// to VP9SVCLayers and RateControl.
EXPECT_TRUE(encoder_->UpdateRates(bitrate_allocation, framerate));
EXPECT_TRUE(encoder_->pending_update_rates_.has_value());
// The pending update rates request is applied in GetSVCLayerResolutions().
if (!valid_rates_request) {
EXPECT_TRUE(encoder_->GetSVCLayerResolutions().empty());
return;
}
// VideoBitrateAllocation is adapted if some spatial layers are deactivated.
const VideoBitrateAllocation adapted_bitrate_allocation =
AdaptBitrateAllocation(bitrate_allocation);
EXPECT_CALL(*mock_rate_ctrl_, UpdateRateControl(MatchRtcConfigWithRates(
adapted_bitrate_allocation, framerate,
expected_temporal_layers,
expected_spatial_layer_resolutions)))
.Times(1)
.WillOnce(Return());
EXPECT_EQ(encoder_->GetSVCLayerResolutions(),
expected_spatial_layer_resolutions);
EXPECT_FALSE(encoder_->pending_update_rates_.has_value());
EXPECT_EQ(encoder_->current_params_.bitrate_allocation,
adapted_bitrate_allocation);
EXPECT_EQ(encoder_->current_params_.framerate, framerate);
const size_t num_spatial_layers = expected_spatial_layer_resolutions.size();
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const gfx::Size& layer_size = expected_spatial_layer_resolutions[sid];
const bool is_keyframe = is_key_pic && sid == 0;
EncodeConstantQuantizationParameterSequence(
is_keyframe, layer_size,
/*expected_ref_frames_used=*/{}, expected_temporal_layer_id, sid);
}
}
void VP9VaapiVideoEncoderDelegateTest::UpdateRatesTest(
size_t num_spatial_layers,
size_t num_temporal_layers) {
ASSERT_TRUE(num_temporal_layers <= VP9SVCLayers::kMaxSupportedTemporalLayers);
ASSERT_TRUE(num_spatial_layers <= VP9SVCLayers::kMaxSupportedTemporalLayers);
const auto spatial_layer_resolutions =
GetDefaultSpatialLayerResolutions(num_spatial_layers);
auto update_rates_and_encode = [this, num_spatial_layers, num_temporal_layers,
&spatial_layer_resolutions](
bool is_key_pic,
uint8_t expected_temporal_layer_id,
uint32_t bitrate, uint32_t framerate) {
auto bitrate_allocation = GetDefaultVideoBitrateAllocation(
num_spatial_layers, num_temporal_layers, bitrate);
UpdateRatesAndEncode(bitrate_allocation, framerate,
/*valid_rates_request=*/true, is_key_pic,
spatial_layer_resolutions, num_temporal_layers,
expected_temporal_layer_id);
};
const uint32_t kBitrate =
kDefaultVideoEncodeAcceleratorConfig.bitrate.target();
const uint32_t kFramerate =
*kDefaultVideoEncodeAcceleratorConfig.initial_framerate;
const uint8_t* expected_temporal_ids =
kTemporalLayerPattern[num_temporal_layers - 1];
// Call UpdateRates before Encode.
update_rates_and_encode(true, expected_temporal_ids[0], kBitrate / 2,
kFramerate);
// Bitrate change only.
update_rates_and_encode(false, expected_temporal_ids[1], kBitrate,
kFramerate);
// Framerate change only.
update_rates_and_encode(false, expected_temporal_ids[2], kBitrate,
kFramerate + 2);
// Bitrate + Frame changes.
update_rates_and_encode(false, expected_temporal_ids[3], kBitrate * 3 / 4,
kFramerate - 5);
}
struct VP9VaapiVideoEncoderDelegateTestParam {
size_t num_spatial_layers;
size_t num_temporal_layers;
} kTestCasesForVP9VaapiVideoEncoderDelegateTest[] = {
{1u, 1u}, {1u, 2u}, {1u, 3u}, {2u, 1u}, {2u, 2u},
{2u, 3u}, {3u, 1u}, {3u, 2u}, {3u, 3u},
};
TEST_P(VP9VaapiVideoEncoderDelegateTest, Initialize) {
InitializeVP9VaapiVideoEncoderDelegate(GetParam().num_spatial_layers,
GetParam().num_temporal_layers);
}
TEST_P(VP9VaapiVideoEncoderDelegateTest, EncodeWithSoftwareBitrateControl) {
const size_t num_spatial_layers = GetParam().num_spatial_layers;
const size_t num_temporal_layers = GetParam().num_temporal_layers;
InitializeVP9VaapiVideoEncoderDelegate(num_spatial_layers,
num_temporal_layers);
const std::vector<gfx::Size> layer_sizes =
GetDefaultSpatialLayerResolutions(num_spatial_layers);
constexpr size_t kEncodeFrames = 20;
for (size_t frame_num = 0; frame_num < kEncodeFrames; ++frame_num) {
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const bool is_keyframe = (frame_num == 0 && sid == 0);
std::array<bool, kVp9NumRefsPerFrame> ref_frames_used;
uint8_t temporal_layer_id;
GetTemporalLayer(is_keyframe, frame_num, num_spatial_layers,
num_temporal_layers, &ref_frames_used,
&temporal_layer_id);
EncodeConstantQuantizationParameterSequence(is_keyframe, layer_sizes[sid],
ref_frames_used,
temporal_layer_id, sid);
}
}
}
TEST_P(VP9VaapiVideoEncoderDelegateTest,
ForceKeyFrameWithSoftwareBitrateControl) {
const size_t num_spatial_layers = GetParam().num_spatial_layers;
const size_t num_temporal_layers = GetParam().num_temporal_layers;
InitializeVP9VaapiVideoEncoderDelegate(num_spatial_layers,
num_temporal_layers);
constexpr size_t kNumKeyFrames = 3;
constexpr size_t kKeyFrameInterval = 20;
const std::vector<gfx::Size> layer_sizes =
GetDefaultSpatialLayerResolutions(num_spatial_layers);
for (size_t j = 0; j < kNumKeyFrames; ++j) {
for (size_t i = 0; i < kKeyFrameInterval; ++i) {
for (size_t sid = 0; sid < num_spatial_layers; ++sid) {
const bool keyframe = (i == 0 && sid == 0);
std::array<bool, kVp9NumRefsPerFrame> ref_frames_used;
uint8_t temporal_layer_id;
GetTemporalLayer(keyframe, i, num_spatial_layers, num_temporal_layers,
&ref_frames_used, &temporal_layer_id);
EncodeConstantQuantizationParameterSequence(keyframe, layer_sizes[sid],
ref_frames_used,
temporal_layer_id, sid);
}
}
}
}
TEST_P(VP9VaapiVideoEncoderDelegateTest, UpdateRates) {
const size_t num_spatial_layers = GetParam().num_spatial_layers;
const size_t num_temporal_layers = GetParam().num_temporal_layers;
InitializeVP9VaapiVideoEncoderDelegate(num_spatial_layers,
num_temporal_layers);
UpdateRatesTest(num_spatial_layers, num_temporal_layers);
}
TEST_P(VP9VaapiVideoEncoderDelegateTest, DeactivateActivateSpatialLayers) {
const size_t num_spatial_layers = GetParam().num_spatial_layers;
const size_t num_temporal_layers = GetParam().num_temporal_layers;
if (num_spatial_layers == 1)
GTEST_SKIP() << "Skip a single spatial layer";
InitializeVP9VaapiVideoEncoderDelegate(num_spatial_layers,
num_temporal_layers);
const std::vector<std::vector<size_t>> kActivateExercise[2] = {
{
// Two spatial layers.
{0}, // Deactivate the top layer.
{0, 1}, // Activate the top layer.
{1}, // Deactivate the bottom layer.
{0, 1}, // Activate the bottom layer.
},
{
// Three spatial layers.
{0, 1}, // Deactivate the top layer.
{1}, // Deactivate the bottom layer.
{0}, // Activate the bottom layer and deactivate the top two layers.
{1,
2}, // Activate the top two layers and deactivate the bottom layer.
{0, 1, 2}, // Activate the bottom layer.
{2}, // Deactivate the bottom two layers.
{0, 1, 2}, // Activate the bottom two layers.
},
};
const VideoBitrateAllocation kDefaultBitrateAllocation =
GetDefaultVideoBitrateAllocation(
num_spatial_layers, num_temporal_layers,
kDefaultVideoEncodeAcceleratorConfig.bitrate.target());
const std::vector<gfx::Size> kDefaultSpatialLayers =
GetDefaultSpatialLayerResolutions(num_spatial_layers);
const uint32_t kFramerate =
*kDefaultVideoEncodeAcceleratorConfig.initial_framerate;
for (auto& active_layers : kActivateExercise[num_spatial_layers - 2]) {
const VideoBitrateAllocation bitrate_allocation =
CreateBitrateAllocationWithActiveLayers(kDefaultBitrateAllocation,
active_layers);
std::vector<gfx::Size> spatial_layer_resolutions;
for (size_t active_sid : active_layers)
spatial_layer_resolutions.emplace_back(kDefaultSpatialLayers[active_sid]);
// Always is_key_pic=true and temporal_layer_id=0 because the active spatial
// layers are changed.
UpdateRatesAndEncode(bitrate_allocation, kFramerate,
/*valid_rates_request=*/true,
/*is_key_pic=*/true, spatial_layer_resolutions,
num_temporal_layers,
/*expected_temporal_layer_id=*/0u);
}
}
TEST_P(VP9VaapiVideoEncoderDelegateTest, FailsWithInvalidSpatialLayers) {
const size_t num_spatial_layers = GetParam().num_spatial_layers;
const size_t num_temporal_layers = GetParam().num_temporal_layers;
const VideoBitrateAllocation kDefaultBitrateAllocation =
GetDefaultVideoBitrateAllocation(
num_spatial_layers, num_temporal_layers,
kDefaultVideoEncodeAcceleratorConfig.bitrate.target());
std::vector<VideoBitrateAllocation> invalid_bitrate_allocations;
constexpr int kBitrate = 1234;
auto bitrate_allocation = kDefaultBitrateAllocation;
// Activate one more top spatial layer.
ASSERT_LE(num_spatial_layers + 1, VideoBitrateAllocation::kMaxSpatialLayers);
bitrate_allocation.SetBitrate(num_spatial_layers, /*temporal_index=*/0,
kBitrate);
invalid_bitrate_allocations.push_back(bitrate_allocation);
// Deactivate a middle spatial layer.
if (num_spatial_layers == 3) {
bitrate_allocation = kDefaultBitrateAllocation;
for (size_t ti = 0; ti < VideoBitrateAllocation::kMaxTemporalLayers; ++ti)
bitrate_allocation.SetBitrate(1, ti, 0u);
invalid_bitrate_allocations.push_back(bitrate_allocation);
}
// Increase the number of temporal layers.
bitrate_allocation = kDefaultBitrateAllocation;
ASSERT_LE(num_temporal_layers + 1,
VideoBitrateAllocation::kMaxTemporalLayers);
for (size_t si = 0; si < num_spatial_layers; ++si)
bitrate_allocation.SetBitrate(si, num_temporal_layers, kBitrate);
invalid_bitrate_allocations.push_back(bitrate_allocation);
// Decrease the number of temporal layers.
if (num_temporal_layers > 1) {
bitrate_allocation = kDefaultBitrateAllocation;
for (size_t si = 0; si < num_spatial_layers; ++si)
bitrate_allocation.SetBitrate(si, num_temporal_layers - 1, 0u);
invalid_bitrate_allocations.push_back(bitrate_allocation);
}
// Set 0 in the bottom temporal layer.
if (num_temporal_layers > 1) {
bitrate_allocation = kDefaultBitrateAllocation;
bitrate_allocation.SetBitrate(/*spatial_index=*/0, /*temporal_index=*/0,
0u);
invalid_bitrate_allocations.push_back(bitrate_allocation);
}
// Set 0 in the middle temporal layer
if (num_temporal_layers == 3) {
bitrate_allocation = kDefaultBitrateAllocation;
bitrate_allocation.SetBitrate(/*spatial_index=*/0, /*temporal_index=*/1,
0u);
invalid_bitrate_allocations.push_back(bitrate_allocation);
}
const uint32_t kFramerate =
*kDefaultVideoEncodeAcceleratorConfig.initial_framerate;
for (const auto& bitrate_allocation : invalid_bitrate_allocations) {
InitializeVP9VaapiVideoEncoderDelegate(num_spatial_layers,
num_temporal_layers);
// The values of expected_spatial_layer_resolutions, is_key_pic,
// expected_temporal_layers and expected_temporal_layer_id are meaningless
// because UpdateRatesAndEncode will returns before checking them due to the
// invalid VideoBitrateAllocation request.
UpdateRatesAndEncode(bitrate_allocation, kFramerate,
/*valid_rates_request=*/false,
/*is_key_pic=*/true,
/*expected_spatial_layer_resolutions=*/{},
/*expected_temporal_layers=*/0u,
/*expected_temporal_layer_id=*/0u);
ResetEncoder();
}
}
INSTANTIATE_TEST_SUITE_P(
,
VP9VaapiVideoEncoderDelegateTest,
::testing::ValuesIn(kTestCasesForVP9VaapiVideoEncoderDelegateTest));
} // namespace media