542 lines
22 KiB
C++
542 lines
22 KiB
C++
/*
|
|
* Copyright (c) 2018, 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 <tuple>
|
|
#include <vector>
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "config/aom_config.h"
|
|
#include "config/aom_dsp_rtcd.h"
|
|
|
|
#include "aom_mem/aom_mem.h"
|
|
#include "aom_ports/aom_timer.h"
|
|
#include "aom_ports/sanitizer.h"
|
|
#include "av1/common/blockd.h"
|
|
#include "av1/common/pred_common.h"
|
|
#include "av1/common/reconintra.h"
|
|
#include "test/acm_random.h"
|
|
#include "test/register_state_check.h"
|
|
#include "test/util.h"
|
|
|
|
namespace {
|
|
|
|
const int kNumIntraNeighbourPixels = MAX_TX_SIZE * 2 + 32;
|
|
const int kIntraPredInputPadding = 16;
|
|
|
|
const int kZ1Start = 0;
|
|
const int kZ2Start = 90;
|
|
const int kZ3Start = 180;
|
|
|
|
const TX_SIZE kTxSize[] = { TX_4X4, TX_8X8, TX_16X16, TX_32X32, TX_64X64,
|
|
TX_4X8, TX_8X4, TX_8X16, TX_16X8, TX_16X32,
|
|
TX_32X16, TX_32X64, TX_64X32, TX_4X16, TX_16X4,
|
|
TX_8X32, TX_32X8, TX_16X64, TX_64X16 };
|
|
|
|
const char *const kTxSizeStrings[] = {
|
|
"TX_4X4", "TX_8X8", "TX_16X16", "TX_32X32", "TX_64X64",
|
|
"TX_4X8", "TX_8X4", "TX_8X16", "TX_16X8", "TX_16X32",
|
|
"TX_32X16", "TX_32X64", "TX_64X32", "TX_4X16", "TX_16X4",
|
|
"TX_8X32", "TX_32X8", "TX_16X64", "TX_64X16"
|
|
};
|
|
|
|
using libaom_test::ACMRandom;
|
|
|
|
typedef void (*DrPred_Hbd)(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int upsample_left, int dx,
|
|
int dy, int bd);
|
|
|
|
typedef void (*DrPred)(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy,
|
|
int bd);
|
|
|
|
typedef void (*Z1_Lbd)(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left,
|
|
int upsample_above, int dx, int dy);
|
|
template <Z1_Lbd fn>
|
|
void z1_wrapper(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left, int upsample_above,
|
|
int upsample_left, int dx, int dy, int bd) {
|
|
(void)bd;
|
|
(void)upsample_left;
|
|
fn(dst, stride, bw, bh, above, left, upsample_above, dx, dy);
|
|
}
|
|
|
|
typedef void (*Z2_Lbd)(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy);
|
|
template <Z2_Lbd fn>
|
|
void z2_wrapper(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left, int upsample_above,
|
|
int upsample_left, int dx, int dy, int bd) {
|
|
(void)bd;
|
|
(void)upsample_left;
|
|
fn(dst, stride, bw, bh, above, left, upsample_above, upsample_left, dx, dy);
|
|
}
|
|
|
|
typedef void (*Z3_Lbd)(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left,
|
|
int upsample_left, int dx, int dy);
|
|
template <Z3_Lbd fn>
|
|
void z3_wrapper(uint8_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint8_t *above, const uint8_t *left, int upsample_above,
|
|
int upsample_left, int dx, int dy, int bd) {
|
|
(void)bd;
|
|
(void)upsample_above;
|
|
fn(dst, stride, bw, bh, above, left, upsample_left, dx, dy);
|
|
}
|
|
|
|
typedef void (*Z1_Hbd)(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int dx, int dy, int bd);
|
|
template <Z1_Hbd fn>
|
|
void z1_wrapper_hbd(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy,
|
|
int bd) {
|
|
(void)bd;
|
|
(void)upsample_left;
|
|
fn(dst, stride, bw, bh, above, left, upsample_above, dx, dy, bd);
|
|
}
|
|
|
|
typedef void (*Z2_Hbd)(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy,
|
|
int bd);
|
|
template <Z2_Hbd fn>
|
|
void z2_wrapper_hbd(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy,
|
|
int bd) {
|
|
(void)bd;
|
|
fn(dst, stride, bw, bh, above, left, upsample_above, upsample_left, dx, dy,
|
|
bd);
|
|
}
|
|
|
|
typedef void (*Z3_Hbd)(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_left, int dx, int dy, int bd);
|
|
template <Z3_Hbd fn>
|
|
void z3_wrapper_hbd(uint16_t *dst, ptrdiff_t stride, int bw, int bh,
|
|
const uint16_t *above, const uint16_t *left,
|
|
int upsample_above, int upsample_left, int dx, int dy,
|
|
int bd) {
|
|
(void)bd;
|
|
(void)upsample_above;
|
|
fn(dst, stride, bw, bh, above, left, upsample_left, dx, dy, bd);
|
|
}
|
|
|
|
template <typename FuncType>
|
|
struct DrPredFunc {
|
|
DrPredFunc(FuncType pred = nullptr, FuncType tst = nullptr,
|
|
int bit_depth_value = 0, int start_angle_value = 0)
|
|
: ref_fn(pred), tst_fn(tst), bit_depth(bit_depth_value),
|
|
start_angle(start_angle_value) {}
|
|
|
|
FuncType ref_fn;
|
|
FuncType tst_fn;
|
|
int bit_depth;
|
|
int start_angle;
|
|
};
|
|
|
|
template <typename Pixel, typename FuncType>
|
|
class DrPredTest : public ::testing::TestWithParam<DrPredFunc<FuncType> > {
|
|
protected:
|
|
static const int kMaxNumTests = 10000;
|
|
static const int kIterations = 10;
|
|
|
|
DrPredTest()
|
|
: enable_upsample_(0), upsample_above_(0), upsample_left_(0), bw_(0),
|
|
bh_(0), dx_(1), dy_(1), bd_(8), txsize_(TX_4X4) {
|
|
params_ = this->GetParam();
|
|
start_angle_ = params_.start_angle;
|
|
stop_angle_ = start_angle_ + 90;
|
|
}
|
|
|
|
~DrPredTest() override = default;
|
|
|
|
void Predict(bool speedtest, int tx, const Pixel *above, const Pixel *left,
|
|
Pixel *dst_ref, Pixel *dst_tst, int dst_stride) {
|
|
const int kNumTests = speedtest ? kMaxNumTests : 1;
|
|
aom_usec_timer timer;
|
|
int tst_time = 0;
|
|
|
|
bd_ = params_.bit_depth;
|
|
|
|
aom_usec_timer_start(&timer);
|
|
for (int k = 0; k < kNumTests; ++k) {
|
|
params_.ref_fn(dst_ref, dst_stride, bw_, bh_, above, left,
|
|
upsample_above_, upsample_left_, dx_, dy_, bd_);
|
|
}
|
|
aom_usec_timer_mark(&timer);
|
|
const int ref_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
|
|
|
|
if (params_.tst_fn) {
|
|
aom_usec_timer_start(&timer);
|
|
for (int k = 0; k < kNumTests; ++k) {
|
|
API_REGISTER_STATE_CHECK(params_.tst_fn(dst_tst, dst_stride, bw_, bh_,
|
|
above, left, upsample_above_,
|
|
upsample_left_, dx_, dy_, bd_));
|
|
}
|
|
aom_usec_timer_mark(&timer);
|
|
tst_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
|
|
} else {
|
|
for (int r = 0; r < bh_; ++r) {
|
|
for (int c = 0; c < bw_; ++c) {
|
|
dst_tst[r * dst_stride + c] = dst_ref[r * dst_stride + c];
|
|
}
|
|
}
|
|
}
|
|
|
|
OutputTimes(kNumTests, ref_time, tst_time, tx);
|
|
}
|
|
|
|
void RunTest(bool speedtest, bool needsaturation, int p_angle) {
|
|
bd_ = params_.bit_depth;
|
|
|
|
for (int tx = 0; tx < TX_SIZES_ALL; ++tx) {
|
|
bw_ = tx_size_wide[kTxSize[tx]];
|
|
bh_ = tx_size_high[kTxSize[tx]];
|
|
|
|
if (enable_upsample_) {
|
|
upsample_above_ =
|
|
av1_use_intra_edge_upsample(bw_, bh_, p_angle - 90, 0);
|
|
upsample_left_ =
|
|
av1_use_intra_edge_upsample(bw_, bh_, p_angle - 180, 0);
|
|
} else {
|
|
upsample_above_ = upsample_left_ = 0;
|
|
}
|
|
|
|
// Declare input buffers as local arrays to allow checking for
|
|
// over-reads.
|
|
DECLARE_ALIGNED(16, Pixel, left_data[kNumIntraNeighbourPixels]);
|
|
DECLARE_ALIGNED(16, Pixel, above_data[kNumIntraNeighbourPixels]);
|
|
|
|
// We need to allow reading some previous bytes from the input pointers.
|
|
const Pixel *above = &above_data[kIntraPredInputPadding];
|
|
const Pixel *left = &left_data[kIntraPredInputPadding];
|
|
|
|
if (needsaturation) {
|
|
const Pixel sat = (1 << bd_) - 1;
|
|
for (int i = 0; i < kNumIntraNeighbourPixels; ++i) {
|
|
left_data[i] = sat;
|
|
above_data[i] = sat;
|
|
}
|
|
} else {
|
|
for (int i = 0; i < kNumIntraNeighbourPixels; ++i) {
|
|
left_data[i] = rng_.Rand8();
|
|
above_data[i] = rng_.Rand8();
|
|
}
|
|
}
|
|
|
|
// Add additional padding to allow detection of over reads/writes when
|
|
// the transform width is equal to MAX_TX_SIZE.
|
|
const int dst_stride = MAX_TX_SIZE + 16;
|
|
std::vector<Pixel> dst_ref(dst_stride * bh_);
|
|
std::vector<Pixel> dst_tst(dst_stride * bh_);
|
|
|
|
for (int r = 0; r < bh_; ++r) {
|
|
ASAN_POISON_MEMORY_REGION(&dst_ref[r * dst_stride + bw_],
|
|
(dst_stride - bw_) * sizeof(Pixel));
|
|
ASAN_POISON_MEMORY_REGION(&dst_tst[r * dst_stride + bw_],
|
|
(dst_stride - bw_) * sizeof(Pixel));
|
|
}
|
|
|
|
Predict(speedtest, tx, above, left, dst_ref.data(), dst_tst.data(),
|
|
dst_stride);
|
|
|
|
for (int r = 0; r < bh_; ++r) {
|
|
ASAN_UNPOISON_MEMORY_REGION(&dst_ref[r * dst_stride + bw_],
|
|
(dst_stride - bw_) * sizeof(Pixel));
|
|
ASAN_UNPOISON_MEMORY_REGION(&dst_tst[r * dst_stride + bw_],
|
|
(dst_stride - bw_) * sizeof(Pixel));
|
|
}
|
|
|
|
for (int r = 0; r < bh_; ++r) {
|
|
for (int c = 0; c < bw_; ++c) {
|
|
ASSERT_EQ(dst_ref[r * dst_stride + c], dst_tst[r * dst_stride + c])
|
|
<< bw_ << "x" << bh_ << " r: " << r << " c: " << c
|
|
<< " dx: " << dx_ << " dy: " << dy_
|
|
<< " upsample_above: " << upsample_above_
|
|
<< " upsample_left: " << upsample_left_;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OutputTimes(int num_tests, int ref_time, int tst_time, int tx) {
|
|
if (num_tests > 1) {
|
|
if (params_.tst_fn) {
|
|
const float x = static_cast<float>(ref_time) / tst_time;
|
|
printf("\t[%8s] :: ref time %6d, tst time %6d %3.2f\n",
|
|
kTxSizeStrings[tx], ref_time, tst_time, x);
|
|
} else {
|
|
printf("\t[%8s] :: ref time %6d\n", kTxSizeStrings[tx], ref_time);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RundrPredTest(const int speed) {
|
|
if (params_.tst_fn == nullptr) return;
|
|
const int angles[] = { 3, 45, 87 };
|
|
const int start_angle = speed ? 0 : start_angle_;
|
|
const int stop_angle = speed ? 3 : stop_angle_;
|
|
for (enable_upsample_ = 0; enable_upsample_ < 2; ++enable_upsample_) {
|
|
for (int i = start_angle; i < stop_angle; ++i) {
|
|
const int angle = speed ? angles[i] + start_angle_ : i;
|
|
dx_ = av1_get_dx(angle);
|
|
dy_ = av1_get_dy(angle);
|
|
if (speed) {
|
|
printf("enable_upsample: %d angle: %d ~~~~~~~~~~~~~~~\n",
|
|
enable_upsample_, angle);
|
|
}
|
|
if (dx_ && dy_) RunTest(speed, false, angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
int enable_upsample_;
|
|
int upsample_above_;
|
|
int upsample_left_;
|
|
int bw_;
|
|
int bh_;
|
|
int dx_;
|
|
int dy_;
|
|
int bd_;
|
|
TX_SIZE txsize_;
|
|
|
|
int start_angle_;
|
|
int stop_angle_;
|
|
|
|
ACMRandom rng_;
|
|
|
|
DrPredFunc<FuncType> params_;
|
|
};
|
|
|
|
class LowbdDrPredTest : public DrPredTest<uint8_t, DrPred> {};
|
|
|
|
TEST_P(LowbdDrPredTest, SaturatedValues) {
|
|
for (enable_upsample_ = 0; enable_upsample_ < 2; ++enable_upsample_) {
|
|
for (int angle = start_angle_; angle < stop_angle_; ++angle) {
|
|
dx_ = av1_get_dx(angle);
|
|
dy_ = av1_get_dy(angle);
|
|
if (dx_ && dy_) RunTest(false, true, angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
using std::make_tuple;
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
C, LowbdDrPredTest,
|
|
::testing::Values(DrPredFunc<DrPred>(&z1_wrapper<av1_dr_prediction_z1_c>,
|
|
nullptr, AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred>(&z2_wrapper<av1_dr_prediction_z2_c>,
|
|
nullptr, AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred>(&z3_wrapper<av1_dr_prediction_z3_c>,
|
|
nullptr, AOM_BITS_8, kZ3Start)));
|
|
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
class HighbdDrPredTest : public DrPredTest<uint16_t, DrPred_Hbd> {};
|
|
|
|
TEST_P(HighbdDrPredTest, SaturatedValues) {
|
|
for (enable_upsample_ = 0; enable_upsample_ < 2; ++enable_upsample_) {
|
|
for (int angle = start_angle_; angle < stop_angle_; ++angle) {
|
|
dx_ = av1_get_dx(angle);
|
|
dy_ = av1_get_dy(angle);
|
|
if (dx_ && dy_) RunTest(false, true, angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
C, HighbdDrPredTest,
|
|
::testing::Values(
|
|
DrPredFunc<DrPred_Hbd>(&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
nullptr, AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
nullptr, AOM_BITS_10, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
nullptr, AOM_BITS_12, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
nullptr, AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
nullptr, AOM_BITS_10, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
nullptr, AOM_BITS_12, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
nullptr, AOM_BITS_8, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
nullptr, AOM_BITS_10, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
nullptr, AOM_BITS_12, kZ3Start)));
|
|
#endif // CONFIG_AV1_HIGHBITDEPTH
|
|
|
|
TEST_P(LowbdDrPredTest, OperationCheck) { RundrPredTest(0); }
|
|
|
|
TEST_P(LowbdDrPredTest, DISABLED_Speed) { RundrPredTest(1); }
|
|
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
TEST_P(HighbdDrPredTest, OperationCheck) {
|
|
if (params_.tst_fn == nullptr) return;
|
|
for (enable_upsample_ = 0; enable_upsample_ < 2; ++enable_upsample_) {
|
|
for (int angle = start_angle_; angle < stop_angle_; angle++) {
|
|
dx_ = av1_get_dx(angle);
|
|
dy_ = av1_get_dy(angle);
|
|
if (dx_ && dy_) RunTest(false, false, angle);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_P(HighbdDrPredTest, DISABLED_Speed) {
|
|
const int angles[] = { 3, 45, 87 };
|
|
for (enable_upsample_ = 0; enable_upsample_ < 2; ++enable_upsample_) {
|
|
for (int i = 0; i < 3; ++i) {
|
|
int angle = angles[i] + start_angle_;
|
|
dx_ = av1_get_dx(angle);
|
|
dy_ = av1_get_dy(angle);
|
|
printf("enable_upsample: %d angle: %d ~~~~~~~~~~~~~~~\n",
|
|
enable_upsample_, angle);
|
|
if (dx_ && dy_) RunTest(true, false, angle);
|
|
}
|
|
}
|
|
}
|
|
#endif // CONFIG_AV1_HIGHBITDEPTH
|
|
|
|
#if HAVE_SSE4_1
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SSE4_1, LowbdDrPredTest,
|
|
::testing::Values(
|
|
DrPredFunc<DrPred>(&z1_wrapper<av1_dr_prediction_z1_c>,
|
|
&z1_wrapper<av1_dr_prediction_z1_sse4_1>, AOM_BITS_8,
|
|
kZ1Start),
|
|
DrPredFunc<DrPred>(&z2_wrapper<av1_dr_prediction_z2_c>,
|
|
&z2_wrapper<av1_dr_prediction_z2_sse4_1>, AOM_BITS_8,
|
|
kZ2Start),
|
|
DrPredFunc<DrPred>(&z3_wrapper<av1_dr_prediction_z3_c>,
|
|
&z3_wrapper<av1_dr_prediction_z3_sse4_1>, AOM_BITS_8,
|
|
kZ3Start)));
|
|
#endif // HAVE_SSE4_1
|
|
|
|
#if HAVE_AVX2
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
AVX2, LowbdDrPredTest,
|
|
::testing::Values(DrPredFunc<DrPred>(&z1_wrapper<av1_dr_prediction_z1_c>,
|
|
&z1_wrapper<av1_dr_prediction_z1_avx2>,
|
|
AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred>(&z2_wrapper<av1_dr_prediction_z2_c>,
|
|
&z2_wrapper<av1_dr_prediction_z2_avx2>,
|
|
AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred>(&z3_wrapper<av1_dr_prediction_z3_c>,
|
|
&z3_wrapper<av1_dr_prediction_z3_avx2>,
|
|
AOM_BITS_8, kZ3Start)));
|
|
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
AVX2, HighbdDrPredTest,
|
|
::testing::Values(DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_avx2>,
|
|
AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_avx2>,
|
|
AOM_BITS_10, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_avx2>,
|
|
AOM_BITS_12, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_avx2>,
|
|
AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_avx2>,
|
|
AOM_BITS_10, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_avx2>,
|
|
AOM_BITS_12, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_avx2>,
|
|
AOM_BITS_8, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_avx2>,
|
|
AOM_BITS_10, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_avx2>,
|
|
AOM_BITS_12, kZ3Start)));
|
|
#endif // CONFIG_AV1_HIGHBITDEPTH
|
|
#endif // HAVE_AVX2
|
|
|
|
#if HAVE_NEON
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
NEON, LowbdDrPredTest,
|
|
::testing::Values(DrPredFunc<DrPred>(&z1_wrapper<av1_dr_prediction_z1_c>,
|
|
&z1_wrapper<av1_dr_prediction_z1_neon>,
|
|
AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred>(&z2_wrapper<av1_dr_prediction_z2_c>,
|
|
&z2_wrapper<av1_dr_prediction_z2_neon>,
|
|
AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred>(&z3_wrapper<av1_dr_prediction_z3_c>,
|
|
&z3_wrapper<av1_dr_prediction_z3_neon>,
|
|
AOM_BITS_8, kZ3Start)));
|
|
|
|
#if CONFIG_AV1_HIGHBITDEPTH
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
NEON, HighbdDrPredTest,
|
|
::testing::Values(DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_neon>,
|
|
AOM_BITS_8, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_neon>,
|
|
AOM_BITS_10, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_c>,
|
|
&z1_wrapper_hbd<av1_highbd_dr_prediction_z1_neon>,
|
|
AOM_BITS_12, kZ1Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_neon>,
|
|
AOM_BITS_8, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_neon>,
|
|
AOM_BITS_10, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_c>,
|
|
&z2_wrapper_hbd<av1_highbd_dr_prediction_z2_neon>,
|
|
AOM_BITS_12, kZ2Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_neon>,
|
|
AOM_BITS_8, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_neon>,
|
|
AOM_BITS_10, kZ3Start),
|
|
DrPredFunc<DrPred_Hbd>(
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_c>,
|
|
&z3_wrapper_hbd<av1_highbd_dr_prediction_z3_neon>,
|
|
AOM_BITS_12, kZ3Start)));
|
|
#endif // CONFIG_AV1_HIGHBITDEPTH
|
|
|
|
#endif // HAVE_NEON
|
|
|
|
} // namespace
|