summaryrefslogtreecommitdiffstats
path: root/third_party/aom/test
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/aom/test')
-rw-r--r--third_party/aom/test/altref_test.cc2
-rw-r--r--third_party/aom/test/aq_segment_test.cc4
-rw-r--r--third_party/aom/test/av1_convolve_optimz_test.cc2
-rw-r--r--third_party/aom/test/av1_convolve_test.cc2
-rw-r--r--third_party/aom/test/av1_fht32x32_test.cc (renamed from third_party/aom/test/fht32x32_test.cc)2
-rw-r--r--third_party/aom/test/av1_fht64x64_test.cc108
-rw-r--r--third_party/aom/test/av1_fwd_txfm1d_test.cc4
-rw-r--r--third_party/aom/test/av1_fwd_txfm2d_test.cc8
-rw-r--r--third_party/aom/test/av1_inv_txfm2d_test.cc2
-rw-r--r--third_party/aom/test/av1_quantize_test.cc22
-rw-r--r--third_party/aom/test/av1_txfm_test.h4
-rw-r--r--third_party/aom/test/avg_test.cc97
-rw-r--r--third_party/aom/test/binary_codes_test.cc9
-rw-r--r--third_party/aom/test/boolcoder_test.cc11
-rw-r--r--third_party/aom/test/borders_test.cc4
-rw-r--r--third_party/aom/test/convolve_test.cc13
-rw-r--r--third_party/aom/test/corner_match_test.cc100
-rw-r--r--third_party/aom/test/cpu_speed_test.cc4
-rw-r--r--third_party/aom/test/datarate_test.cc2
-rw-r--r--third_party/aom/test/decode_test_driver.cc2
-rw-r--r--third_party/aom/test/error_resilience_test.cc9
-rw-r--r--third_party/aom/test/frame_size_tests.cc22
-rw-r--r--third_party/aom/test/hiprec_convolve_test.cc42
-rw-r--r--third_party/aom/test/hiprec_convolve_test_util.cc188
-rw-r--r--third_party/aom/test/hiprec_convolve_test_util.h89
-rw-r--r--third_party/aom/test/intrapred_test.cc174
-rw-r--r--third_party/aom/test/masked_sad_test.cc63
-rw-r--r--third_party/aom/test/masked_variance_test.cc594
-rw-r--r--third_party/aom/test/motion_vector_test.cc17
-rw-r--r--third_party/aom/test/partial_idct_test.cc30
-rw-r--r--third_party/aom/test/quantize_func_test.cc236
-rw-r--r--third_party/aom/test/sad_test.cc7
-rw-r--r--third_party/aom/test/simd_avx2_test.cc15
-rw-r--r--third_party/aom/test/simd_cmp_avx2.cc15
-rw-r--r--third_party/aom/test/simd_cmp_impl.h522
-rw-r--r--third_party/aom/test/simd_impl.h330
-rw-r--r--third_party/aom/test/superframe_test.cc11
-rw-r--r--third_party/aom/test/test-data.mk30
-rw-r--r--third_party/aom/test/test.cmake137
-rw-r--r--third_party/aom/test/test.mk73
-rw-r--r--third_party/aom/test/test_data_download_worker.cmake40
-rw-r--r--third_party/aom/test/test_data_util.cmake21
-rw-r--r--third_party/aom/test/test_intra_pred_speed.cc142
-rw-r--r--third_party/aom/test/test_runner.cmake20
-rw-r--r--third_party/aom/test/test_worker.cmake49
-rw-r--r--third_party/aom/test/variance_test.cc22
-rw-r--r--third_party/aom/test/warp_filter_test.cc13
-rw-r--r--third_party/aom/test/warp_filter_test_util.cc54
-rw-r--r--third_party/aom/test/warp_filter_test_util.h20
49 files changed, 2419 insertions, 968 deletions
diff --git a/third_party/aom/test/altref_test.cc b/third_party/aom/test/altref_test.cc
index 6dd8b5186..28b400121 100644
--- a/third_party/aom/test/altref_test.cc
+++ b/third_party/aom/test/altref_test.cc
@@ -92,6 +92,6 @@ TEST_P(AltRefForcedKeyTestLarge, ForcedFrameIsKey) {
AV1_INSTANTIATE_TEST_CASE(AltRefForcedKeyTestLarge,
::testing::Values(::libaom_test::kOnePassGood),
- ::testing::Range(0, 9));
+ ::testing::Values(2, 5));
} // namespace
diff --git a/third_party/aom/test/aq_segment_test.cc b/third_party/aom/test/aq_segment_test.cc
index 5dc93ec79..b01f140a0 100644
--- a/third_party/aom/test/aq_segment_test.cc
+++ b/third_party/aom/test/aq_segment_test.cc
@@ -98,7 +98,7 @@ TEST_P(AqSegmentTest, TestNoMisMatchAQ4) {
aq_mode_ = 4;
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- 30, 1, 0, 100);
+ 30, 1, 0, 15);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
@@ -112,7 +112,7 @@ TEST_P(AqSegmentTest, TestNoMisMatchExtDeltaQ) {
aq_mode_ = 0;
deltaq_mode_ = 2;
::libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- 30, 1, 0, 100);
+ 30, 1, 0, 15);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
diff --git a/third_party/aom/test/av1_convolve_optimz_test.cc b/third_party/aom/test/av1_convolve_optimz_test.cc
index fd0f6dbce..c32f4cb95 100644
--- a/third_party/aom/test/av1_convolve_optimz_test.cc
+++ b/third_party/aom/test/av1_convolve_optimz_test.cc
@@ -218,7 +218,7 @@ const BlockDimension kBlockDim[] = {
};
// 10/12-tap filters
-const InterpFilter kFilter[] = { FILTER_REGULAR_UV, BILINEAR, MULTITAP_SHARP };
+const InterpFilter kFilter[] = { EIGHTTAP_REGULAR, BILINEAR, MULTITAP_SHARP };
const int kSubpelQ4[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
diff --git a/third_party/aom/test/av1_convolve_test.cc b/third_party/aom/test/av1_convolve_test.cc
index 02ac8e7bb..9ea662381 100644
--- a/third_party/aom/test/av1_convolve_test.cc
+++ b/third_party/aom/test/av1_convolve_test.cc
@@ -262,6 +262,7 @@ INSTANTIATE_TEST_CASE_P(
::testing::ValuesIn(filter_ls)));
#if CONFIG_HIGHBITDEPTH
+#ifndef __clang_analyzer__
TEST(AV1ConvolveTest, av1_highbd_convolve) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
#if CONFIG_DUAL_FILTER
@@ -322,6 +323,7 @@ TEST(AV1ConvolveTest, av1_highbd_convolve) {
}
}
}
+#endif
TEST(AV1ConvolveTest, av1_highbd_convolve_avg) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
diff --git a/third_party/aom/test/fht32x32_test.cc b/third_party/aom/test/av1_fht32x32_test.cc
index 56ac597c0..cdd915337 100644
--- a/third_party/aom/test/fht32x32_test.cc
+++ b/third_party/aom/test/av1_fht32x32_test.cc
@@ -49,7 +49,7 @@ void highbd_fht32x32_ref(const int16_t *in, int32_t *out, int stride,
}
#endif // CONFIG_HIGHBITDEPTH
-#if HAVE_AVX2
+#if HAVE_SSE2 || HAVE_AVX2
void dummy_inv_txfm(const tran_low_t *in, uint8_t *out, int stride,
int tx_type) {
(void)in;
diff --git a/third_party/aom/test/av1_fht64x64_test.cc b/third_party/aom/test/av1_fht64x64_test.cc
new file mode 100644
index 000000000..cde1d0ca3
--- /dev/null
+++ b/third_party/aom/test/av1_fht64x64_test.cc
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2017, 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 "third_party/googletest/src/googletest/include/gtest/gtest.h"
+
+#include "./av1_rtcd.h"
+
+#include "aom_ports/mem.h"
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/transform_test_base.h"
+#include "test/util.h"
+
+#if CONFIG_TX64X64
+
+using libaom_test::ACMRandom;
+
+namespace {
+typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
+ int tx_type);
+using std::tr1::tuple;
+using libaom_test::FhtFunc;
+typedef tuple<FhtFunc, IhtFunc, int, aom_bit_depth_t, int> Ht64x64Param;
+
+void fht64x64_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
+ av1_fht64x64_c(in, out, stride, tx_type);
+}
+
+void iht64x64_ref(const tran_low_t *in, uint8_t *dest, int stride,
+ int tx_type) {
+ av1_iht64x64_4096_add_c(in, dest, stride, tx_type);
+}
+
+class AV1Trans64x64HT : public libaom_test::TransformTestBase,
+ public ::testing::TestWithParam<Ht64x64Param> {
+ public:
+ virtual ~AV1Trans64x64HT() {}
+
+ virtual void SetUp() {
+ fwd_txfm_ = GET_PARAM(0);
+ inv_txfm_ = GET_PARAM(1);
+ tx_type_ = GET_PARAM(2);
+ pitch_ = 64;
+ height_ = 64;
+ fwd_txfm_ref = fht64x64_ref;
+ inv_txfm_ref = iht64x64_ref;
+ bit_depth_ = GET_PARAM(3);
+ mask_ = (1 << bit_depth_) - 1;
+ num_coeffs_ = GET_PARAM(4);
+ }
+ virtual void TearDown() { libaom_test::ClearSystemState(); }
+
+ protected:
+ void RunFwdTxfm(const int16_t *in, tran_low_t *out, int stride) {
+ fwd_txfm_(in, out, stride, tx_type_);
+ }
+
+ void RunInvTxfm(const tran_low_t *out, uint8_t *dst, int stride) {
+ inv_txfm_(out, dst, stride, tx_type_);
+ }
+
+ FhtFunc fwd_txfm_;
+ IhtFunc inv_txfm_;
+};
+
+TEST_P(AV1Trans64x64HT, AccuracyCheck) { RunAccuracyCheck(4, 0.2); }
+TEST_P(AV1Trans64x64HT, CoeffCheck) { RunCoeffCheck(); }
+TEST_P(AV1Trans64x64HT, MemCheck) { RunMemCheck(); }
+TEST_P(AV1Trans64x64HT, InvCoeffCheck) { RunInvCoeffCheck(); }
+TEST_P(AV1Trans64x64HT, InvAccuracyCheck) { RunInvAccuracyCheck(4); }
+
+using std::tr1::make_tuple;
+
+const Ht64x64Param kArrayHt64x64Param_c[] = {
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 0, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 1, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 2, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 3, AOM_BITS_8, 4096),
+#if CONFIG_EXT_TX
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 4, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 5, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 6, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 7, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 8, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 9, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 10, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 11, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 12, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 13, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 14, AOM_BITS_8, 4096),
+ make_tuple(&av1_fht64x64_c, &av1_iht64x64_4096_add_c, 15, AOM_BITS_8, 4096)
+#endif // CONFIG_EXT_TX
+};
+INSTANTIATE_TEST_CASE_P(C, AV1Trans64x64HT,
+ ::testing::ValuesIn(kArrayHt64x64Param_c));
+
+} // namespace
+
+#endif // CONFIG_TX64X64
diff --git a/third_party/aom/test/av1_fwd_txfm1d_test.cc b/third_party/aom/test/av1_fwd_txfm1d_test.cc
index a9b3f8e40..511e057fa 100644
--- a/third_party/aom/test/av1_fwd_txfm1d_test.cc
+++ b/third_party/aom/test/av1_fwd_txfm1d_test.cc
@@ -56,10 +56,10 @@ TEST(av1_fwd_txfm1d, get_max_bit) {
EXPECT_EQ(max_bit, 3);
}
-TEST(av1_fwd_txfm1d, cospi_arr) {
+TEST(av1_fwd_txfm1d, cospi_arr_data) {
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 64; j++) {
- EXPECT_EQ(cospi_arr[i][j],
+ EXPECT_EQ(cospi_arr_data[i][j],
(int32_t)round(cos(M_PI * j / 128) * (1 << (cos_bit_min + i))));
}
}
diff --git a/third_party/aom/test/av1_fwd_txfm2d_test.cc b/third_party/aom/test/av1_fwd_txfm2d_test.cc
index 25cf5ad53..af3c8ff44 100644
--- a/third_party/aom/test/av1_fwd_txfm2d_test.cc
+++ b/third_party/aom/test/av1_fwd_txfm2d_test.cc
@@ -41,9 +41,11 @@ class AV1FwdTxfm2d : public ::testing::TestWithParam<AV1FwdTxfm2dParam> {
count_ = 500;
TXFM_2D_FLIP_CFG fwd_txfm_flip_cfg =
av1_get_fwd_txfm_cfg(tx_type_, tx_size_);
- const TXFM_2D_CFG *fwd_txfm_cfg = fwd_txfm_flip_cfg.cfg;
- int amplify_bit = fwd_txfm_cfg->shift[0] + fwd_txfm_cfg->shift[1] +
- fwd_txfm_cfg->shift[2];
+ // TODO(sarahparker) this test will need to be updated when these
+ // functions are extended to support rectangular transforms
+ int amplify_bit = fwd_txfm_flip_cfg.row_cfg->shift[0] +
+ fwd_txfm_flip_cfg.row_cfg->shift[1] +
+ fwd_txfm_flip_cfg.row_cfg->shift[2];
ud_flip_ = fwd_txfm_flip_cfg.ud_flip;
lr_flip_ = fwd_txfm_flip_cfg.lr_flip;
amplify_factor_ =
diff --git a/third_party/aom/test/av1_inv_txfm2d_test.cc b/third_party/aom/test/av1_inv_txfm2d_test.cc
index bb2743af1..89ae34b01 100644
--- a/third_party/aom/test/av1_inv_txfm2d_test.cc
+++ b/third_party/aom/test/av1_inv_txfm2d_test.cc
@@ -17,7 +17,7 @@
#include "test/acm_random.h"
#include "test/util.h"
#include "test/av1_txfm_test.h"
-#include "av1/common/av1_inv_txfm2d_cfg.h"
+#include "av1/common/av1_inv_txfm1d_cfg.h"
using libaom_test::ACMRandom;
using libaom_test::input_base;
diff --git a/third_party/aom/test/av1_quantize_test.cc b/third_party/aom/test/av1_quantize_test.cc
index b5d1531f5..239b041b2 100644
--- a/third_party/aom/test/av1_quantize_test.cc
+++ b/third_party/aom/test/av1_quantize_test.cc
@@ -196,16 +196,18 @@ TEST_P(AV1QuantizeTest, EobVerify) { RunEobTest(); }
#if HAVE_SSE4_1
#if !CONFIG_AOM_QM
-INSTANTIATE_TEST_CASE_P(
- SSE4_1, AV1QuantizeTest,
- ::testing::Values(QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
- &av1_highbd_quantize_fp_c, 16),
- QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
- &av1_highbd_quantize_fp_c, 64),
- QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
- &av1_highbd_quantize_fp_c, 256),
- QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1,
- &av1_highbd_quantize_fp_c, 1024)));
+const QuantizeFuncParams qfps[4] = {
+ QuantizeFuncParams(av1_highbd_quantize_fp_sse4_1, &av1_highbd_quantize_fp_c,
+ 16),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1, &av1_highbd_quantize_fp_c,
+ 64),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1, &av1_highbd_quantize_fp_c,
+ 256),
+ QuantizeFuncParams(&av1_highbd_quantize_fp_sse4_1, &av1_highbd_quantize_fp_c,
+ 1024),
+};
+
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1QuantizeTest, ::testing::ValuesIn(qfps));
#endif // !CONFIG_AOM_QM
#endif // HAVE_SSE4_1
} // namespace
diff --git a/third_party/aom/test/av1_txfm_test.h b/third_party/aom/test/av1_txfm_test.h
index 70f971d09..d46f0bba7 100644
--- a/third_party/aom/test/av1_txfm_test.h
+++ b/third_party/aom/test/av1_txfm_test.h
@@ -79,7 +79,7 @@ static const int input_base = (1 << bd);
#if CONFIG_HIGHBITDEPTH
#if CONFIG_AV1_ENCODER
static const Fwd_Txfm2d_Func fwd_txfm_func_ls[TX_SIZES] = {
-#if CONFIG_CB4X4
+#if CONFIG_CHROMA_2X2
NULL,
#endif
av1_fwd_txfm2d_4x4_c, av1_fwd_txfm2d_8x8_c, av1_fwd_txfm2d_16x16_c,
@@ -88,7 +88,7 @@ static const Fwd_Txfm2d_Func fwd_txfm_func_ls[TX_SIZES] = {
#endif
static const Inv_Txfm2d_Func inv_txfm_func_ls[TX_SIZES] = {
-#if CONFIG_CB4X4
+#if CONFIG_CHROMA_2X2
NULL,
#endif
av1_inv_txfm2d_add_4x4_c, av1_inv_txfm2d_add_8x8_c,
diff --git a/third_party/aom/test/avg_test.cc b/third_party/aom/test/avg_test.cc
index b040f6a34..e83a75c1c 100644
--- a/third_party/aom/test/avg_test.cc
+++ b/third_party/aom/test/avg_test.cc
@@ -53,21 +53,6 @@ class AverageTestBase : public ::testing::Test {
rnd_.Reset(ACMRandom::DeterministicSeed());
}
- // Sum Pixels
- static unsigned int ReferenceAverage8x8(const uint8_t *source, int pitch) {
- unsigned int average = 0;
- for (int h = 0; h < 8; ++h)
- for (int w = 0; w < 8; ++w) average += source[h * pitch + w];
- return ((average + 32) >> 6);
- }
-
- static unsigned int ReferenceAverage4x4(const uint8_t *source, int pitch) {
- unsigned int average = 0;
- for (int h = 0; h < 4; ++h)
- for (int w = 0; w < 4; ++w) average += source[h * pitch + w];
- return ((average + 8) >> 4);
- }
-
void FillConstant(uint8_t fill_constant) {
for (int i = 0; i < width_ * height_; ++i) {
source_data_[i] = fill_constant;
@@ -86,35 +71,6 @@ class AverageTestBase : public ::testing::Test {
ACMRandom rnd_;
};
-typedef unsigned int (*AverageFunction)(const uint8_t *s, int pitch);
-
-typedef std::tr1::tuple<int, int, int, int, AverageFunction> AvgFunc;
-
-class AverageTest : public AverageTestBase,
- public ::testing::WithParamInterface<AvgFunc> {
- public:
- AverageTest() : AverageTestBase(GET_PARAM(0), GET_PARAM(1)) {}
-
- protected:
- void CheckAverages() {
- const int block_size = GET_PARAM(3);
- unsigned int expected = 0;
- if (block_size == 8) {
- expected =
- ReferenceAverage8x8(source_data_ + GET_PARAM(2), source_stride_);
- } else if (block_size == 4) {
- expected =
- ReferenceAverage4x4(source_data_ + GET_PARAM(2), source_stride_);
- }
-
- ASM_REGISTER_STATE_CHECK(
- GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_));
- unsigned int actual =
- GET_PARAM(4)(source_data_ + GET_PARAM(2), source_stride_);
-
- EXPECT_EQ(expected, actual);
- }
-};
typedef void (*IntProRowFunc)(int16_t hbuf[16], uint8_t const *ref,
const int ref_stride, const int height);
@@ -229,25 +185,6 @@ class SatdTest : public ::testing::Test,
uint8_t *AverageTestBase::source_data_ = NULL;
-TEST_P(AverageTest, MinValue) {
- FillConstant(0);
- CheckAverages();
-}
-
-TEST_P(AverageTest, MaxValue) {
- FillConstant(255);
- CheckAverages();
-}
-
-TEST_P(AverageTest, Random) {
- // The reference frame, but not the source frame, may be unaligned for
- // certain types of searches.
- for (int i = 0; i < 1000; i++) {
- FillRandom();
- CheckAverages();
- }
-}
-
TEST_P(IntProRowTest, MinValue) {
FillConstant(0);
RunComparison();
@@ -309,11 +246,6 @@ TEST_P(SatdTest, Random) {
using std::tr1::make_tuple;
-INSTANTIATE_TEST_CASE_P(
- C, AverageTest,
- ::testing::Values(make_tuple(16, 16, 1, 8, &aom_avg_8x8_c),
- make_tuple(16, 16, 1, 4, &aom_avg_4x4_c)));
-
INSTANTIATE_TEST_CASE_P(C, SatdTest,
::testing::Values(make_tuple(16, &aom_satd_c),
make_tuple(64, &aom_satd_c),
@@ -322,15 +254,6 @@ INSTANTIATE_TEST_CASE_P(C, SatdTest,
#if HAVE_SSE2
INSTANTIATE_TEST_CASE_P(
- SSE2, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_sse2),
- make_tuple(16, 16, 5, 8, &aom_avg_8x8_sse2),
- make_tuple(32, 32, 15, 8, &aom_avg_8x8_sse2),
- make_tuple(16, 16, 0, 4, &aom_avg_4x4_sse2),
- make_tuple(16, 16, 5, 4, &aom_avg_4x4_sse2),
- make_tuple(32, 32, 15, 4, &aom_avg_4x4_sse2)));
-
-INSTANTIATE_TEST_CASE_P(
SSE2, IntProRowTest,
::testing::Values(make_tuple(16, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
make_tuple(32, &aom_int_pro_row_sse2, &aom_int_pro_row_c),
@@ -353,15 +276,6 @@ INSTANTIATE_TEST_CASE_P(SSE2, SatdTest,
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(
- NEON, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_neon),
- make_tuple(16, 16, 5, 8, &aom_avg_8x8_neon),
- make_tuple(32, 32, 15, 8, &aom_avg_8x8_neon),
- make_tuple(16, 16, 0, 4, &aom_avg_4x4_neon),
- make_tuple(16, 16, 5, 4, &aom_avg_4x4_neon),
- make_tuple(32, 32, 15, 4, &aom_avg_4x4_neon)));
-
-INSTANTIATE_TEST_CASE_P(
NEON, IntProRowTest,
::testing::Values(make_tuple(16, &aom_int_pro_row_neon, &aom_int_pro_row_c),
make_tuple(32, &aom_int_pro_row_neon, &aom_int_pro_row_c),
@@ -382,15 +296,4 @@ INSTANTIATE_TEST_CASE_P(NEON, SatdTest,
make_tuple(1024, &aom_satd_neon)));
#endif
-#if HAVE_MSA
-INSTANTIATE_TEST_CASE_P(
- MSA, AverageTest,
- ::testing::Values(make_tuple(16, 16, 0, 8, &aom_avg_8x8_msa),
- make_tuple(16, 16, 5, 8, &aom_avg_8x8_msa),
- make_tuple(32, 32, 15, 8, &aom_avg_8x8_msa),
- make_tuple(16, 16, 0, 4, &aom_avg_4x4_msa),
- make_tuple(16, 16, 5, 4, &aom_avg_4x4_msa),
- make_tuple(32, 32, 15, 4, &aom_avg_4x4_msa)));
-#endif
-
} // namespace
diff --git a/third_party/aom/test/binary_codes_test.cc b/third_party/aom/test/binary_codes_test.cc
index 385ec7687..41efec781 100644
--- a/third_party/aom/test/binary_codes_test.cc
+++ b/third_party/aom/test/binary_codes_test.cc
@@ -15,6 +15,7 @@
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
+#include "./aom_config.h"
#include "test/acm_random.h"
#include "aom/aom_integer.h"
#include "aom_dsp/bitreader.h"
@@ -22,6 +23,8 @@
#include "aom_dsp/binary_codes_reader.h"
#include "aom_dsp/binary_codes_writer.h"
+#define ACCT_STR __func__
+
using libaom_test::ACMRandom;
namespace {
@@ -68,8 +71,8 @@ TEST(AV1, TestPrimitiveRefbilivel) {
const uint16_t range = enc_values[n][p][r][v][0];
const uint16_t near_range = enc_values[n][p][r][v][1];
const uint16_t ref = enc_values[n][p][r][v][2];
- const uint16_t value =
- aom_read_primitive_refbilevel(&br, range, near_range, ref);
+ const uint16_t value = aom_read_primitive_refbilevel(
+ &br, range, near_range, ref, ACCT_STR);
GTEST_ASSERT_EQ(value, enc_values[n][p][r][v][3]);
}
}
@@ -119,7 +122,7 @@ TEST(AV1, TestPrimitiveRefsubexpfin) {
assert(k == enc_values[n][k][r][v][1]);
const uint16_t ref = enc_values[n][k][r][v][2];
const uint16_t value =
- aom_read_primitive_refsubexpfin(&br, range, k, ref);
+ aom_read_primitive_refsubexpfin(&br, range, k, ref, ACCT_STR);
GTEST_ASSERT_EQ(value, enc_values[n][k][r][v][3]);
}
}
diff --git a/third_party/aom/test/boolcoder_test.cc b/third_party/aom/test/boolcoder_test.cc
index 4d9d7aaf4..7abe1b1b6 100644
--- a/third_party/aom/test/boolcoder_test.cc
+++ b/third_party/aom/test/boolcoder_test.cc
@@ -68,11 +68,6 @@ TEST(AV1, TestBitIO) {
aom_stop_encode(&bw);
-#if !CONFIG_DAALA_EC
- // First bit should be zero
- GTEST_ASSERT_EQ(bw_buffer[0] & 0x80, 0);
-#endif
-
aom_reader br;
aom_reader_init(&br, bw_buffer, bw.pos, NULL, NULL);
bit_rnd.Reset(random_seed);
@@ -91,10 +86,10 @@ TEST(AV1, TestBitIO) {
}
}
-#if CONFIG_DAALA_EC
-#define FRAC_DIFF_TOTAL_ERROR 0.07
+#if CONFIG_EC_SMALLMUL
+#define FRAC_DIFF_TOTAL_ERROR 0.16
#else
-#define FRAC_DIFF_TOTAL_ERROR 0.2
+#define FRAC_DIFF_TOTAL_ERROR 0.07
#endif
TEST(AV1, TestTell) {
diff --git a/third_party/aom/test/borders_test.cc b/third_party/aom/test/borders_test.cc
index 076f91404..d4e8dea23 100644
--- a/third_party/aom/test/borders_test.cc
+++ b/third_party/aom/test/borders_test.cc
@@ -59,7 +59,7 @@ TEST_P(BordersTest, TestEncodeHighBitrate) {
cfg_.rc_max_quantizer = 10;
::libaom_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
- 40);
+ 10);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
@@ -75,7 +75,7 @@ TEST_P(BordersTest, TestLowBitrate) {
cfg_.rc_min_quantizer = 40;
::libaom_test::I420VideoSource video("hantro_odd.yuv", 208, 144, 30, 1, 0,
- 40);
+ 10);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
}
diff --git a/third_party/aom/test/convolve_test.cc b/third_party/aom/test/convolve_test.cc
index a84ef4ec8..a1fb2087d 100644
--- a/third_party/aom/test/convolve_test.cc
+++ b/third_party/aom/test/convolve_test.cc
@@ -212,7 +212,7 @@ void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
* = 23
* and filter_max_width = 16
*/
- uint16_t intermediate_buffer[(kMaxDimension + 8) * kMaxDimension];
+ uint16_t intermediate_buffer[(kMaxDimension + 8) * kMaxDimension] = { 0 };
const int intermediate_next_stride =
1 - static_cast<int>(intermediate_height * output_width);
@@ -368,10 +368,17 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
#endif
/* Set up guard blocks for an inner block centered in the outer block */
for (int i = 0; i < kOutputBufferSize; ++i) {
- if (IsIndexInBorder(i))
+ if (IsIndexInBorder(i)) {
output_[i] = 255;
- else
+#if CONFIG_HIGHBITDEPTH
+ output16_[i] = mask_;
+#endif
+ } else {
output_[i] = 0;
+#if CONFIG_HIGHBITDEPTH
+ output16_[i] = 0;
+#endif
+ }
}
::libaom_test::ACMRandom prng;
diff --git a/third_party/aom/test/corner_match_test.cc b/third_party/aom/test/corner_match_test.cc
new file mode 100644
index 000000000..2197fffee
--- /dev/null
+++ b/third_party/aom/test/corner_match_test.cc
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, 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 "third_party/googletest/src/googletest/include/gtest/gtest.h"
+#include "test/acm_random.h"
+#include "test/util.h"
+#include "./av1_rtcd.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+
+#include "av1/encoder/corner_match.h"
+
+namespace test_libaom {
+
+namespace AV1CornerMatch {
+
+using libaom_test::ACMRandom;
+
+using std::tr1::tuple;
+using std::tr1::make_tuple;
+typedef tuple<int> CornerMatchParam;
+
+class AV1CornerMatchTest : public ::testing::TestWithParam<CornerMatchParam> {
+ public:
+ virtual ~AV1CornerMatchTest();
+ virtual void SetUp();
+
+ virtual void TearDown();
+
+ protected:
+ void RunCheckOutput();
+
+ libaom_test::ACMRandom rnd_;
+};
+
+AV1CornerMatchTest::~AV1CornerMatchTest() {}
+void AV1CornerMatchTest::SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
+void AV1CornerMatchTest::TearDown() { libaom_test::ClearSystemState(); }
+
+void AV1CornerMatchTest::RunCheckOutput() {
+ const int w = 128, h = 128;
+ const int num_iters = 10000;
+ int i, j;
+
+ uint8_t *input1 = new uint8_t[w * h];
+ uint8_t *input2 = new uint8_t[w * h];
+
+ // Test the two extreme cases:
+ // i) Random data, should have correlation close to 0
+ // ii) Linearly related data + noise, should have correlation close to 1
+ int mode = GET_PARAM(0);
+ if (mode == 0) {
+ for (i = 0; i < h; ++i)
+ for (j = 0; j < w; ++j) {
+ input1[i * w + j] = rnd_.Rand8();
+ input2[i * w + j] = rnd_.Rand8();
+ }
+ } else if (mode == 1) {
+ for (i = 0; i < h; ++i)
+ for (j = 0; j < w; ++j) {
+ int v = rnd_.Rand8();
+ input1[i * w + j] = v;
+ input2[i * w + j] = (v / 2) + (rnd_.Rand8() & 15);
+ }
+ }
+
+ for (i = 0; i < num_iters; ++i) {
+ int x1 = MATCH_SZ_BY2 + rnd_.PseudoUniform(w - 2 * MATCH_SZ_BY2);
+ int y1 = MATCH_SZ_BY2 + rnd_.PseudoUniform(h - 2 * MATCH_SZ_BY2);
+ int x2 = MATCH_SZ_BY2 + rnd_.PseudoUniform(w - 2 * MATCH_SZ_BY2);
+ int y2 = MATCH_SZ_BY2 + rnd_.PseudoUniform(h - 2 * MATCH_SZ_BY2);
+
+ double res_c =
+ compute_cross_correlation_c(input1, w, x1, y1, input2, w, x2, y2);
+ double res_sse4 =
+ compute_cross_correlation_sse4_1(input1, w, x1, y1, input2, w, x2, y2);
+
+ ASSERT_EQ(res_sse4, res_c);
+ }
+
+ delete[] input1;
+ delete[] input2;
+}
+
+TEST_P(AV1CornerMatchTest, CheckOutput) { RunCheckOutput(); }
+
+INSTANTIATE_TEST_CASE_P(SSE4_1, AV1CornerMatchTest,
+ ::testing::Values(make_tuple(0), make_tuple(1)));
+
+} // namespace AV1CornerMatch
+
+} // namespace test_libaom
diff --git a/third_party/aom/test/cpu_speed_test.cc b/third_party/aom/test/cpu_speed_test.cc
index 9b7966462..ad0f2a874 100644
--- a/third_party/aom/test/cpu_speed_test.cc
+++ b/third_party/aom/test/cpu_speed_test.cc
@@ -94,7 +94,7 @@ void CpuSpeedTest::TestQ0() {
}
void CpuSpeedTest::TestScreencastQ0() {
- ::libaom_test::Y4mVideoSource video("screendata.y4m", 0, 10);
+ ::libaom_test::Y4mVideoSource video("screendata.y4m", 0, 3);
cfg_.g_timebase = video.timebase();
cfg_.rc_2pass_vbr_minsection_pct = 5;
cfg_.rc_2pass_vbr_maxsection_pct = 2000;
@@ -109,7 +109,7 @@ void CpuSpeedTest::TestScreencastQ0() {
}
void CpuSpeedTest::TestTuneScreen() {
- ::libaom_test::Y4mVideoSource video("screendata.y4m", 0, 10);
+ ::libaom_test::Y4mVideoSource video("screendata.y4m", 0, 3);
cfg_.g_timebase = video.timebase();
cfg_.rc_2pass_vbr_minsection_pct = 5;
cfg_.rc_2pass_vbr_minsection_pct = 2000;
diff --git a/third_party/aom/test/datarate_test.cc b/third_party/aom/test/datarate_test.cc
index 48be4a46d..a4a682681 100644
--- a/third_party/aom/test/datarate_test.cc
+++ b/third_party/aom/test/datarate_test.cc
@@ -249,5 +249,5 @@ TEST_P(DatarateTestLarge, ChangingDropFrameThresh) {
AV1_INSTANTIATE_TEST_CASE(DatarateTestLarge,
::testing::Values(::libaom_test::kOnePassGood,
::libaom_test::kRealTime),
- ::testing::Range(2, 9, 2));
+ ::testing::Values(2, 5));
} // namespace
diff --git a/third_party/aom/test/decode_test_driver.cc b/third_party/aom/test/decode_test_driver.cc
index 35c28eafd..5f109e092 100644
--- a/third_party/aom/test/decode_test_driver.cc
+++ b/third_party/aom/test/decode_test_driver.cc
@@ -82,8 +82,6 @@ void DecoderTest::RunLoop(CompressedVideoSource *video,
PreDecodeFrameHook(*video, decoder);
aom_codec_stream_info_t stream_info;
- stream_info.sz = sizeof(stream_info);
-
if (video->cxdata() != NULL) {
const aom_codec_err_t res_peek = decoder->PeekStream(
video->cxdata(), video->frame_size(), &stream_info);
diff --git a/third_party/aom/test/error_resilience_test.cc b/third_party/aom/test/error_resilience_test.cc
index 63f10012f..b1d93a01f 100644
--- a/third_party/aom/test/error_resilience_test.cc
+++ b/third_party/aom/test/error_resilience_test.cc
@@ -150,7 +150,7 @@ TEST_P(ErrorResilienceTestLarge, OnVersusOff) {
init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- timebase.den, timebase.num, 0, 30);
+ timebase.den, timebase.num, 0, 12);
// Error resilient mode OFF.
cfg_.g_error_resilient = 0;
@@ -187,7 +187,7 @@ TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
init_flags_ = AOM_CODEC_USE_PSNR;
libaom_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
- timebase.den, timebase.num, 0, 40);
+ timebase.den, timebase.num, 0, 20);
// Error resilient mode ON.
cfg_.g_error_resilient = 1;
@@ -196,9 +196,8 @@ TEST_P(ErrorResilienceTestLarge, DropFramesWithoutRecovery) {
// Set an arbitrary set of error frames same as droppable frames.
// In addition to isolated loss/drop, add a long consecutive series
// (of size 9) of dropped frames.
- unsigned int num_droppable_frames = 11;
- unsigned int droppable_frame_list[] = { 5, 16, 22, 23, 24, 25,
- 26, 27, 28, 29, 30 };
+ unsigned int num_droppable_frames = 5;
+ unsigned int droppable_frame_list[] = { 5, 10, 13, 16, 19 };
SetDroppableFrames(num_droppable_frames, droppable_frame_list);
SetErrorFrames(num_droppable_frames, droppable_frame_list);
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
diff --git a/third_party/aom/test/frame_size_tests.cc b/third_party/aom/test/frame_size_tests.cc
index 73cc9c075..d2e762ff9 100644
--- a/third_party/aom/test/frame_size_tests.cc
+++ b/third_party/aom/test/frame_size_tests.cc
@@ -46,43 +46,25 @@ class AV1FrameSizeTests : public ::libaom_test::EncoderTest,
int expected_res_;
};
+#if CONFIG_SIZE_LIMIT
TEST_F(AV1FrameSizeTests, TestInvalidSizes) {
::libaom_test::RandomVideoSource video;
-#if CONFIG_SIZE_LIMIT
video.SetSize(DECODE_WIDTH_LIMIT + 16, DECODE_HEIGHT_LIMIT + 16);
video.set_limit(2);
expected_res_ = AOM_CODEC_CORRUPT_FRAME;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-#endif
}
TEST_F(AV1FrameSizeTests, LargeValidSizes) {
::libaom_test::RandomVideoSource video;
-#if CONFIG_SIZE_LIMIT
video.SetSize(DECODE_WIDTH_LIMIT, DECODE_HEIGHT_LIMIT);
video.set_limit(2);
expected_res_ = AOM_CODEC_OK;
ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-#else
- // This test produces a pretty large single frame allocation, (roughly
- // 25 megabits). The encoder allocates a good number of these frames
- // one for each lag in frames (for 2 pass), and then one for each possible
- // reference buffer (8) - we can end up with up to 30 buffers of roughly this
- // size or almost 1 gig of memory.
- // In total the allocations will exceed 2GiB which may cause a failure with
- // non-64 bit platforms, use a smaller size in that case.
- if (sizeof(void *) < 8)
- video.SetSize(2560, 1440);
- else
- video.SetSize(4096, 4096);
-
- video.set_limit(2);
- expected_res_ = AOM_CODEC_OK;
- ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
-#endif
}
+#endif
TEST_F(AV1FrameSizeTests, OneByOneVideo) {
::libaom_test::RandomVideoSource video;
diff --git a/third_party/aom/test/hiprec_convolve_test.cc b/third_party/aom/test/hiprec_convolve_test.cc
new file mode 100644
index 000000000..0b34c99c9
--- /dev/null
+++ b/third_party/aom/test/hiprec_convolve_test.cc
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2016, 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 "third_party/googletest/src/googletest/include/gtest/gtest.h"
+#include "test/hiprec_convolve_test_util.h"
+
+using std::tr1::tuple;
+using std::tr1::make_tuple;
+using libaom_test::ACMRandom;
+using libaom_test::AV1HiprecConvolve::AV1HiprecConvolveTest;
+#if CONFIG_HIGHBITDEPTH
+using libaom_test::AV1HighbdHiprecConvolve::AV1HighbdHiprecConvolveTest;
+#endif
+
+namespace {
+
+TEST_P(AV1HiprecConvolveTest, CheckOutput) { RunCheckOutput(GET_PARAM(3)); }
+
+INSTANTIATE_TEST_CASE_P(SSE2, AV1HiprecConvolveTest,
+ libaom_test::AV1HiprecConvolve::BuildParams(
+ aom_convolve8_add_src_hip_sse2));
+
+#if CONFIG_HIGHBITDEPTH && HAVE_SSSE3
+TEST_P(AV1HighbdHiprecConvolveTest, CheckOutput) {
+ RunCheckOutput(GET_PARAM(4));
+}
+
+INSTANTIATE_TEST_CASE_P(SSSE3, AV1HighbdHiprecConvolveTest,
+ libaom_test::AV1HighbdHiprecConvolve::BuildParams(
+ aom_highbd_convolve8_add_src_hip_ssse3));
+
+#endif
+
+} // namespace
diff --git a/third_party/aom/test/hiprec_convolve_test_util.cc b/third_party/aom/test/hiprec_convolve_test_util.cc
new file mode 100644
index 000000000..d53384c5b
--- /dev/null
+++ b/third_party/aom/test/hiprec_convolve_test_util.cc
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2016, 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 "test/hiprec_convolve_test_util.h"
+
+#include "av1/common/restoration.h"
+
+using std::tr1::tuple;
+using std::tr1::make_tuple;
+
+namespace libaom_test {
+
+// Generate a random pair of filter kernels, using the ranges
+// of possible values from the loop-restoration experiment
+static void generate_kernels(ACMRandom *rnd, InterpKernel hkernel,
+ InterpKernel vkernel) {
+ hkernel[0] = hkernel[6] =
+ WIENER_FILT_TAP0_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP0_MAXV + 1 - WIENER_FILT_TAP0_MINV);
+ hkernel[1] = hkernel[5] =
+ WIENER_FILT_TAP1_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP1_MAXV + 1 - WIENER_FILT_TAP1_MINV);
+ hkernel[2] = hkernel[4] =
+ WIENER_FILT_TAP2_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP2_MAXV + 1 - WIENER_FILT_TAP2_MINV);
+ hkernel[3] = -(hkernel[0] + hkernel[1] + hkernel[2]);
+ hkernel[7] = 0;
+
+ vkernel[0] = vkernel[6] =
+ WIENER_FILT_TAP0_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP0_MAXV + 1 - WIENER_FILT_TAP0_MINV);
+ vkernel[1] = vkernel[5] =
+ WIENER_FILT_TAP1_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP1_MAXV + 1 - WIENER_FILT_TAP1_MINV);
+ vkernel[2] = vkernel[4] =
+ WIENER_FILT_TAP2_MINV +
+ rnd->PseudoUniform(WIENER_FILT_TAP2_MAXV + 1 - WIENER_FILT_TAP2_MINV);
+ vkernel[3] = -(vkernel[0] + vkernel[1] + vkernel[2]);
+ vkernel[7] = 0;
+}
+
+namespace AV1HiprecConvolve {
+
+::testing::internal::ParamGenerator<HiprecConvolveParam> BuildParams(
+ hiprec_convolve_func filter) {
+ const HiprecConvolveParam params[] = {
+ make_tuple(8, 8, 50000, filter), make_tuple(64, 64, 1000, filter),
+ make_tuple(32, 8, 10000, filter),
+ };
+ return ::testing::ValuesIn(params);
+}
+
+AV1HiprecConvolveTest::~AV1HiprecConvolveTest() {}
+void AV1HiprecConvolveTest::SetUp() {
+ rnd_.Reset(ACMRandom::DeterministicSeed());
+}
+
+void AV1HiprecConvolveTest::TearDown() { libaom_test::ClearSystemState(); }
+
+void AV1HiprecConvolveTest::RunCheckOutput(hiprec_convolve_func test_impl) {
+ const int w = 128, h = 128;
+ const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
+ const int num_iters = GET_PARAM(2);
+ int i, j;
+
+ uint8_t *input_ = new uint8_t[h * w];
+ uint8_t *input = input_;
+
+ // The convolve functions always write rows with widths that are multiples of
+ // 8.
+ // So to avoid a buffer overflow, we may need to pad rows to a multiple of 8.
+ int output_n = ((out_w + 7) & ~7) * out_h;
+ uint8_t *output = new uint8_t[output_n];
+ uint8_t *output2 = new uint8_t[output_n];
+
+ // Generate random filter kernels
+ DECLARE_ALIGNED(16, InterpKernel, hkernel);
+ DECLARE_ALIGNED(16, InterpKernel, vkernel);
+
+ generate_kernels(&rnd_, hkernel, vkernel);
+
+ for (i = 0; i < h; ++i)
+ for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand8();
+
+ for (i = 0; i < num_iters; ++i) {
+ // Choose random locations within the source block
+ int offset_r = 3 + rnd_.PseudoUniform(w - out_w - 7);
+ int offset_c = 3 + rnd_.PseudoUniform(h - out_h - 7);
+ aom_convolve8_add_src_hip_c(input + offset_r * w + offset_c, w, output,
+ out_w, hkernel, 16, vkernel, 16, out_w, out_h);
+ test_impl(input + offset_r * w + offset_c, w, output2, out_w, hkernel, 16,
+ vkernel, 16, out_w, out_h);
+
+ for (j = 0; j < out_w * out_h; ++j)
+ ASSERT_EQ(output[j], output2[j]) << "Pixel mismatch at index " << j
+ << " = (" << (j % out_w) << ", "
+ << (j / out_w) << ") on iteration " << i;
+ }
+ delete[] input_;
+ delete[] output;
+ delete[] output2;
+}
+} // namespace AV1HiprecConvolve
+
+#if CONFIG_HIGHBITDEPTH
+namespace AV1HighbdHiprecConvolve {
+
+::testing::internal::ParamGenerator<HighbdHiprecConvolveParam> BuildParams(
+ highbd_hiprec_convolve_func filter) {
+ const HighbdHiprecConvolveParam params[] = {
+ make_tuple(8, 8, 50000, 8, filter), make_tuple(64, 64, 1000, 8, filter),
+ make_tuple(32, 8, 10000, 8, filter), make_tuple(8, 8, 50000, 10, filter),
+ make_tuple(64, 64, 1000, 10, filter), make_tuple(32, 8, 10000, 10, filter),
+ make_tuple(8, 8, 50000, 12, filter), make_tuple(64, 64, 1000, 12, filter),
+ make_tuple(32, 8, 10000, 12, filter),
+ };
+ return ::testing::ValuesIn(params);
+}
+
+AV1HighbdHiprecConvolveTest::~AV1HighbdHiprecConvolveTest() {}
+void AV1HighbdHiprecConvolveTest::SetUp() {
+ rnd_.Reset(ACMRandom::DeterministicSeed());
+}
+
+void AV1HighbdHiprecConvolveTest::TearDown() {
+ libaom_test::ClearSystemState();
+}
+
+void AV1HighbdHiprecConvolveTest::RunCheckOutput(
+ highbd_hiprec_convolve_func test_impl) {
+ const int w = 128, h = 128;
+ const int out_w = GET_PARAM(0), out_h = GET_PARAM(1);
+ const int num_iters = GET_PARAM(2);
+ const int bd = GET_PARAM(3);
+ int i, j;
+
+ uint16_t *input = new uint16_t[h * w];
+
+ // The convolve functions always write rows with widths that are multiples of
+ // 8.
+ // So to avoid a buffer overflow, we may need to pad rows to a multiple of 8.
+ int output_n = ((out_w + 7) & ~7) * out_h;
+ uint16_t *output = new uint16_t[output_n];
+ uint16_t *output2 = new uint16_t[output_n];
+
+ // Generate random filter kernels
+ DECLARE_ALIGNED(16, InterpKernel, hkernel);
+ DECLARE_ALIGNED(16, InterpKernel, vkernel);
+
+ generate_kernels(&rnd_, hkernel, vkernel);
+
+ for (i = 0; i < h; ++i)
+ for (j = 0; j < w; ++j) input[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
+
+ uint8_t *input_ptr = CONVERT_TO_BYTEPTR(input);
+ uint8_t *output_ptr = CONVERT_TO_BYTEPTR(output);
+ uint8_t *output2_ptr = CONVERT_TO_BYTEPTR(output2);
+
+ for (i = 0; i < num_iters; ++i) {
+ // Choose random locations within the source block
+ int offset_r = 3 + rnd_.PseudoUniform(w - out_w - 7);
+ int offset_c = 3 + rnd_.PseudoUniform(h - out_h - 7);
+ aom_highbd_convolve8_add_src_hip_c(input_ptr + offset_r * w + offset_c, w,
+ output_ptr, out_w, hkernel, 16, vkernel,
+ 16, out_w, out_h, bd);
+ test_impl(input_ptr + offset_r * w + offset_c, w, output2_ptr, out_w,
+ hkernel, 16, vkernel, 16, out_w, out_h, bd);
+
+ for (j = 0; j < out_w * out_h; ++j)
+ ASSERT_EQ(output[j], output2[j]) << "Pixel mismatch at index " << j
+ << " = (" << (j % out_w) << ", "
+ << (j / out_w) << ") on iteration " << i;
+ }
+ delete[] input;
+ delete[] output;
+ delete[] output2;
+}
+} // namespace AV1HighbdHiprecConvolve
+#endif // CONFIG_HIGHBITDEPTH
+} // namespace libaom_test
diff --git a/third_party/aom/test/hiprec_convolve_test_util.h b/third_party/aom/test/hiprec_convolve_test_util.h
new file mode 100644
index 000000000..fe31570f5
--- /dev/null
+++ b/third_party/aom/test/hiprec_convolve_test_util.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2016, 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.
+ */
+
+#ifndef TEST_HIPREC_CONVOLVE_TEST_UTIL_H_
+#define TEST_HIPREC_CONVOLVE_TEST_UTIL_H_
+
+#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
+#include "test/acm_random.h"
+#include "test/util.h"
+#include "./av1_rtcd.h"
+#include "./aom_dsp_rtcd.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+
+#include "av1/common/mv.h"
+
+namespace libaom_test {
+
+namespace AV1HiprecConvolve {
+
+typedef void (*hiprec_convolve_func)(const uint8_t *src, ptrdiff_t src_stride,
+ uint8_t *dst, ptrdiff_t dst_stride,
+ const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4,
+ int w, int h);
+
+typedef std::tr1::tuple<int, int, int, hiprec_convolve_func>
+ HiprecConvolveParam;
+
+::testing::internal::ParamGenerator<HiprecConvolveParam> BuildParams(
+ hiprec_convolve_func filter);
+
+class AV1HiprecConvolveTest
+ : public ::testing::TestWithParam<HiprecConvolveParam> {
+ public:
+ virtual ~AV1HiprecConvolveTest();
+ virtual void SetUp();
+
+ virtual void TearDown();
+
+ protected:
+ void RunCheckOutput(hiprec_convolve_func test_impl);
+
+ libaom_test::ACMRandom rnd_;
+};
+
+} // namespace AV1HiprecConvolve
+
+#if CONFIG_HIGHBITDEPTH
+namespace AV1HighbdHiprecConvolve {
+typedef void (*highbd_hiprec_convolve_func)(
+ const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst,
+ ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4,
+ const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+
+typedef std::tr1::tuple<int, int, int, int, highbd_hiprec_convolve_func>
+ HighbdHiprecConvolveParam;
+
+::testing::internal::ParamGenerator<HighbdHiprecConvolveParam> BuildParams(
+ highbd_hiprec_convolve_func filter);
+
+class AV1HighbdHiprecConvolveTest
+ : public ::testing::TestWithParam<HighbdHiprecConvolveParam> {
+ public:
+ virtual ~AV1HighbdHiprecConvolveTest();
+ virtual void SetUp();
+
+ virtual void TearDown();
+
+ protected:
+ void RunCheckOutput(highbd_hiprec_convolve_func test_impl);
+
+ libaom_test::ACMRandom rnd_;
+};
+
+} // namespace AV1HighbdHiprecConvolve
+#endif // CONFIG_HIGHBITDEPTH
+
+} // namespace libaom_test
+
+#endif // TEST_HIPREC_CONVOLVE_TEST_UTIL_H_
diff --git a/third_party/aom/test/intrapred_test.cc b/third_party/aom/test/intrapred_test.cc
index 4efed57b6..5dd8c00be 100644
--- a/third_party/aom/test/intrapred_test.cc
+++ b/third_party/aom/test/intrapred_test.cc
@@ -126,105 +126,111 @@ TEST_P(AV1IntraPredTest, IntraPredTests) {
#if HAVE_SSE2
#if CONFIG_HIGHBITDEPTH
-INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_8, AV1IntraPredTest,
- ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
- &aom_highbd_dc_predictor_32x32_c, 32, 8),
+const IntraPredFunc IntraPredTestVector8[] = {
+ IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 8),
#if !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
- &aom_highbd_tm_predictor_16x16_c, 16, 8),
- IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
- &aom_highbd_tm_predictor_32x32_c, 32, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 8),
#endif // !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
- &aom_highbd_dc_predictor_4x4_c, 4, 8),
- IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
- &aom_highbd_dc_predictor_8x8_c, 8, 8),
- IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
- &aom_highbd_dc_predictor_16x16_c, 16, 8),
- IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
- &aom_highbd_v_predictor_4x4_c, 4, 8),
- IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
- &aom_highbd_v_predictor_8x8_c, 8, 8),
- IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
- &aom_highbd_v_predictor_16x16_c, 16, 8),
- IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
- &aom_highbd_v_predictor_32x32_c, 32, 8)
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 8),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 8),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2, &aom_highbd_v_predictor_4x4_c,
+ 4, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2, &aom_highbd_v_predictor_8x8_c,
+ 8, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 8),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 8)
#if !CONFIG_ALT_INTRA
- ,
- IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
- &aom_highbd_tm_predictor_4x4_c, 4, 8),
- IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
- &aom_highbd_tm_predictor_8x8_c, 8, 8)
+ ,
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 8),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 8)
#endif // !CONFIG_ALT_INTRA
- ));
+};
+
+INSTANTIATE_TEST_CASE_P(SSE2_TO_C_8, AV1IntraPredTest,
+ ::testing::ValuesIn(IntraPredTestVector8));
-INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_10, AV1IntraPredTest,
- ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
- &aom_highbd_dc_predictor_32x32_c, 32, 10),
+const IntraPredFunc IntraPredTestVector10[] = {
+ IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 10),
#if !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
- &aom_highbd_tm_predictor_16x16_c, 16, 10),
- IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
- &aom_highbd_tm_predictor_32x32_c, 32, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 10),
#endif // !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
- &aom_highbd_dc_predictor_4x4_c, 4, 10),
- IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
- &aom_highbd_dc_predictor_8x8_c, 8, 10),
- IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
- &aom_highbd_dc_predictor_16x16_c, 16, 10),
- IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
- &aom_highbd_v_predictor_4x4_c, 4, 10),
- IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
- &aom_highbd_v_predictor_8x8_c, 8, 10),
- IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
- &aom_highbd_v_predictor_16x16_c, 16, 10),
- IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
- &aom_highbd_v_predictor_32x32_c, 32, 10)
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 10),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 10),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2, &aom_highbd_v_predictor_4x4_c,
+ 4, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2, &aom_highbd_v_predictor_8x8_c,
+ 8, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 10),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 10)
#if !CONFIG_ALT_INTRA
- ,
- IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
- &aom_highbd_tm_predictor_4x4_c, 4, 10),
- IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
- &aom_highbd_tm_predictor_8x8_c, 8, 10)
+ ,
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 10),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 10)
#endif // !CONFIG_ALT_INTRA
- ));
+};
-INSTANTIATE_TEST_CASE_P(
- SSE2_TO_C_12, AV1IntraPredTest,
- ::testing::Values(IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
- &aom_highbd_dc_predictor_32x32_c, 32, 12),
+INSTANTIATE_TEST_CASE_P(SSE2_TO_C_10, AV1IntraPredTest,
+ ::testing::ValuesIn(IntraPredTestVector10));
+
+const IntraPredFunc IntraPredTestVector12[] = {
+ IntraPredFunc(&aom_highbd_dc_predictor_32x32_sse2,
+ &aom_highbd_dc_predictor_32x32_c, 32, 12),
#if !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
- &aom_highbd_tm_predictor_16x16_c, 16, 12),
- IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
- &aom_highbd_tm_predictor_32x32_c, 32, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_16x16_sse2,
+ &aom_highbd_tm_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_32x32_sse2,
+ &aom_highbd_tm_predictor_32x32_c, 32, 12),
#endif // !CONFIG_ALT_INTRA
- IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
- &aom_highbd_dc_predictor_4x4_c, 4, 12),
- IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
- &aom_highbd_dc_predictor_8x8_c, 8, 12),
- IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
- &aom_highbd_dc_predictor_16x16_c, 16, 12),
- IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2,
- &aom_highbd_v_predictor_4x4_c, 4, 12),
- IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2,
- &aom_highbd_v_predictor_8x8_c, 8, 12),
- IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
- &aom_highbd_v_predictor_16x16_c, 16, 12),
- IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
- &aom_highbd_v_predictor_32x32_c, 32, 12)
+ IntraPredFunc(&aom_highbd_dc_predictor_4x4_sse2,
+ &aom_highbd_dc_predictor_4x4_c, 4, 12),
+ IntraPredFunc(&aom_highbd_dc_predictor_8x8_sse2,
+ &aom_highbd_dc_predictor_8x8_c, 8, 12),
+ IntraPredFunc(&aom_highbd_dc_predictor_16x16_sse2,
+ &aom_highbd_dc_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_4x4_sse2, &aom_highbd_v_predictor_4x4_c,
+ 4, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_8x8_sse2, &aom_highbd_v_predictor_8x8_c,
+ 8, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_16x16_sse2,
+ &aom_highbd_v_predictor_16x16_c, 16, 12),
+ IntraPredFunc(&aom_highbd_v_predictor_32x32_sse2,
+ &aom_highbd_v_predictor_32x32_c, 32, 12)
#if !CONFIG_ALT_INTRA
- ,
- IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
- &aom_highbd_tm_predictor_4x4_c, 4, 12),
- IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
- &aom_highbd_tm_predictor_8x8_c, 8, 12)
+ ,
+ IntraPredFunc(&aom_highbd_tm_predictor_4x4_sse2,
+ &aom_highbd_tm_predictor_4x4_c, 4, 12),
+ IntraPredFunc(&aom_highbd_tm_predictor_8x8_sse2,
+ &aom_highbd_tm_predictor_8x8_c, 8, 12)
#endif // !CONFIG_ALT_INTRA
- ));
+};
+
+INSTANTIATE_TEST_CASE_P(SSE2_TO_C_12, AV1IntraPredTest,
+ ::testing::ValuesIn(IntraPredTestVector12));
#endif // CONFIG_HIGHBITDEPTH
#endif // HAVE_SSE2
diff --git a/third_party/aom/test/masked_sad_test.cc b/third_party/aom/test/masked_sad_test.cc
index 53f85eef7..2dde3c537 100644
--- a/third_party/aom/test/masked_sad_test.cc
+++ b/third_party/aom/test/masked_sad_test.cc
@@ -25,11 +25,13 @@
using libaom_test::ACMRandom;
namespace {
-const int number_of_iterations = 500;
+const int number_of_iterations = 200;
-typedef unsigned int (*MaskedSADFunc)(const uint8_t *a, int a_stride,
- const uint8_t *b, int b_stride,
- const uint8_t *m, int m_stride);
+typedef unsigned int (*MaskedSADFunc)(const uint8_t *src, int src_stride,
+ const uint8_t *ref, int ref_stride,
+ const uint8_t *second_pred,
+ const uint8_t *msk, int msk_stride,
+ int invert_mask);
typedef std::tr1::tuple<MaskedSADFunc, MaskedSADFunc> MaskedSADParam;
class MaskedSADTest : public ::testing::TestWithParam<MaskedSADParam> {
@@ -52,6 +54,7 @@ TEST_P(MaskedSADTest, OperationCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+ DECLARE_ALIGNED(16, uint8_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
int err_count = 0;
int first_failure = -1;
@@ -62,18 +65,23 @@ TEST_P(MaskedSADTest, OperationCheck) {
for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
src_ptr[j] = rnd.Rand8();
ref_ptr[j] = rnd.Rand8();
+ second_pred_ptr[j] = rnd.Rand8();
msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
assert(msk_ptr[j] <= 64);
}
- ref_ret = ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride,
- msk_ptr, msk_stride);
- ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src_ptr, src_stride, ref_ptr,
- ref_stride, msk_ptr,
- msk_stride));
- if (ret != ref_ret) {
- err_count++;
- if (first_failure == -1) first_failure = i;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret =
+ ref_maskedSAD_op_(src_ptr, src_stride, ref_ptr, ref_stride,
+ second_pred_ptr, msk_ptr, msk_stride, invert_mask);
+ ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src_ptr, src_stride, ref_ptr,
+ ref_stride, second_pred_ptr,
+ msk_ptr, msk_stride,
+ invert_mask));
+ if (ret != ref_ret) {
+ err_count++;
+ if (first_failure == -1) first_failure = i;
+ }
}
}
EXPECT_EQ(0, err_count)
@@ -82,9 +90,11 @@ TEST_P(MaskedSADTest, OperationCheck) {
}
#if CONFIG_HIGHBITDEPTH
-typedef unsigned int (*HighbdMaskedSADFunc)(const uint8_t *a, int a_stride,
- const uint8_t *b, int b_stride,
- const uint8_t *m, int m_stride);
+typedef unsigned int (*HighbdMaskedSADFunc)(const uint8_t *src, int src_stride,
+ const uint8_t *ref, int ref_stride,
+ const uint8_t *second_pred,
+ const uint8_t *msk, int msk_stride,
+ int invert_mask);
typedef std::tr1::tuple<HighbdMaskedSADFunc, HighbdMaskedSADFunc>
HighbdMaskedSADParam;
@@ -109,9 +119,11 @@ TEST_P(HighbdMaskedSADTest, OperationCheck) {
ACMRandom rnd(ACMRandom::DeterministicSeed());
DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
+ DECLARE_ALIGNED(16, uint16_t, second_pred_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+ uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
int err_count = 0;
int first_failure = -1;
int src_stride = MAX_SB_SIZE;
@@ -121,17 +133,22 @@ TEST_P(HighbdMaskedSADTest, OperationCheck) {
for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
src_ptr[j] = rnd.Rand16() & 0xfff;
ref_ptr[j] = rnd.Rand16() & 0xfff;
+ second_pred_ptr[j] = rnd.Rand16() & 0xfff;
msk_ptr[j] = ((rnd.Rand8() & 0x7f) > 64) ? rnd.Rand8() & 0x3f : 64;
}
- ref_ret = ref_maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
- msk_ptr, msk_stride);
- ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride, ref8_ptr,
- ref_stride, msk_ptr,
- msk_stride));
- if (ret != ref_ret) {
- err_count++;
- if (first_failure == -1) first_failure = i;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret =
+ ref_maskedSAD_op_(src8_ptr, src_stride, ref8_ptr, ref_stride,
+ second_pred8_ptr, msk_ptr, msk_stride, invert_mask);
+ ASM_REGISTER_STATE_CHECK(ret = maskedSAD_op_(src8_ptr, src_stride,
+ ref8_ptr, ref_stride,
+ second_pred8_ptr, msk_ptr,
+ msk_stride, invert_mask));
+ if (ret != ref_ret) {
+ err_count++;
+ if (first_failure == -1) first_failure = i;
+ }
}
}
EXPECT_EQ(0, err_count)
diff --git a/third_party/aom/test/masked_variance_test.cc b/third_party/aom/test/masked_variance_test.cc
index 65e852aea..bf113c69e 100644
--- a/third_party/aom/test/masked_variance_test.cc
+++ b/third_party/aom/test/masked_variance_test.cc
@@ -29,107 +29,12 @@
using libaom_test::ACMRandom;
namespace {
-const int number_of_iterations = 500;
-
-typedef unsigned int (*MaskedVarianceFunc)(const uint8_t *a, int a_stride,
- const uint8_t *b, int b_stride,
- const uint8_t *m, int m_stride,
- unsigned int *sse);
-
-typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc>
- MaskedVarianceParam;
-
-class MaskedVarianceTest
- : public ::testing::TestWithParam<MaskedVarianceParam> {
- public:
- virtual ~MaskedVarianceTest() {}
- virtual void SetUp() {
- opt_func_ = GET_PARAM(0);
- ref_func_ = GET_PARAM(1);
- }
-
- virtual void TearDown() { libaom_test::ClearSystemState(); }
-
- protected:
- MaskedVarianceFunc opt_func_;
- MaskedVarianceFunc ref_func_;
-};
-
-TEST_P(MaskedVarianceTest, OperationCheck) {
- unsigned int ref_ret, opt_ret;
- unsigned int ref_sse, opt_sse;
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- int err_count = 0;
- int first_failure = -1;
- int src_stride = MAX_SB_SIZE;
- int ref_stride = MAX_SB_SIZE;
- int msk_stride = MAX_SB_SIZE;
-
- for (int i = 0; i < number_of_iterations; ++i) {
- for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
- src_ptr[j] = rnd.Rand8();
- ref_ptr[j] = rnd.Rand8();
- msk_ptr[j] = rnd(65);
- }
-
- ref_ret = ref_func_(src_ptr, src_stride, ref_ptr, ref_stride, msk_ptr,
- msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride, ref_ptr,
- ref_stride, msk_ptr,
- msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) first_failure = i;
- }
- }
-
- EXPECT_EQ(0, err_count) << "Error: Masked Variance Test OperationCheck,"
- << "C output doesn't match SSSE3 output. "
- << "First failed at test case " << first_failure;
-}
-
-TEST_P(MaskedVarianceTest, ExtremeValues) {
- unsigned int ref_ret, opt_ret;
- unsigned int ref_sse, opt_sse;
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint8_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- int err_count = 0;
- int first_failure = -1;
- int src_stride = MAX_SB_SIZE;
- int ref_stride = MAX_SB_SIZE;
- int msk_stride = MAX_SB_SIZE;
-
- for (int i = 0; i < 8; ++i) {
- memset(src_ptr, (i & 0x1) ? 255 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
- memset(ref_ptr, (i & 0x2) ? 255 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
- memset(msk_ptr, (i & 0x4) ? 64 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
-
- ref_ret = ref_func_(src_ptr, src_stride, ref_ptr, ref_stride, msk_ptr,
- msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src_ptr, src_stride, ref_ptr,
- ref_stride, msk_ptr,
- msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) first_failure = i;
- }
- }
-
- EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
- << "C output doesn't match SSSE3 output. "
- << "First failed at test case " << first_failure;
-}
+const int number_of_iterations = 200;
typedef unsigned int (*MaskedSubPixelVarianceFunc)(
- const uint8_t *a, int a_stride, int xoffset, int yoffset, const uint8_t *b,
- int b_stride, const uint8_t *m, int m_stride, unsigned int *sse);
+ const uint8_t *src, int src_stride, int xoffset, int yoffset,
+ const uint8_t *ref, int ref_stride, const uint8_t *second_pred,
+ const uint8_t *msk, int msk_stride, int invert_mask, unsigned int *sse);
typedef std::tr1::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc>
MaskedSubPixelVarianceParam;
@@ -154,9 +59,18 @@ TEST_P(MaskedSubPixelVarianceTest, OperationCheck) {
unsigned int ref_ret, opt_ret;
unsigned int ref_sse, opt_sse;
ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+ // Note: We pad the input arrays out with 15 extra elements, since the SSE
+ // implementations can read up to 15 elements off the end of the main data.
+ // The extra data is never actually used, but it simplifies the code
+ // if we can do this.
+ DECLARE_ALIGNED(16, uint8_t,
+ src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
int err_count = 0;
int first_failure = -1;
int src_stride = (MAX_SB_SIZE + 1);
@@ -171,23 +85,26 @@ TEST_P(MaskedSubPixelVarianceTest, OperationCheck) {
for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1); j++) {
src_ptr[j] = rnd.Rand8();
ref_ptr[j] = rnd.Rand8();
+ second_pred_ptr[j] = rnd.Rand8();
msk_ptr[j] = rnd(65);
}
for (int k = 0; k < 3; k++) {
- xoffset = xoffsets[k];
for (int l = 0; l < 3; l++) {
xoffset = xoffsets[k];
yoffset = yoffsets[l];
-
- ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
- ref_stride, msk_ptr, msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(
- opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
- ref_stride, msk_ptr, msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) first_failure = i;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+ ref_stride, second_pred_ptr, msk_ptr, msk_stride,
+ invert_mask, &ref_sse);
+ ASM_REGISTER_STATE_CHECK(
+ opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset,
+ ref_ptr, ref_stride, second_pred_ptr, msk_ptr,
+ msk_stride, invert_mask, &opt_sse));
+
+ if (opt_ret != ref_ret || opt_sse != ref_sse) {
+ err_count++;
+ if (first_failure == -1) first_failure = i;
+ }
}
}
}
@@ -203,9 +120,14 @@ TEST_P(MaskedSubPixelVarianceTest, ExtremeValues) {
unsigned int ref_ret, opt_ret;
unsigned int ref_sse, opt_sse;
ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint8_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+ DECLARE_ALIGNED(16, uint8_t,
+ src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
+ DECLARE_ALIGNED(16, uint8_t,
+ msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 15]);
int first_failure_x = -1;
int first_failure_y = -1;
int err_count = 0;
@@ -216,26 +138,32 @@ TEST_P(MaskedSubPixelVarianceTest, ExtremeValues) {
for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
- for (int i = 0; i < 8; ++i) {
+ for (int i = 0; i < 16; ++i) {
memset(src_ptr, (i & 0x1) ? 255 : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
memset(ref_ptr, (i & 0x2) ? 255 : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
- memset(msk_ptr, (i & 0x4) ? 64 : 0,
+ memset(second_pred_ptr, (i & 0x4) ? 255 : 0,
+ (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
+ memset(msk_ptr, (i & 0x8) ? 64 : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
- ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
- ref_stride, msk_ptr, msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(
- opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
- ref_stride, msk_ptr, msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) {
- first_failure = i;
- first_failure_x = xoffset;
- first_failure_y = yoffset;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret = ref_func_(src_ptr, src_stride, xoffset, yoffset, ref_ptr,
+ ref_stride, second_pred_ptr, msk_ptr, msk_stride,
+ invert_mask, &ref_sse);
+ ASM_REGISTER_STATE_CHECK(
+ opt_ret = opt_func_(src_ptr, src_stride, xoffset, yoffset,
+ ref_ptr, ref_stride, second_pred_ptr, msk_ptr,
+ msk_stride, invert_mask, &opt_sse));
+
+ if (opt_ret != ref_ret || opt_sse != ref_sse) {
+ err_count++;
+ if (first_failure == -1) {
+ first_failure = i;
+ first_failure_x = xoffset;
+ first_failure_y = yoffset;
+ }
}
}
}
@@ -250,105 +178,6 @@ TEST_P(MaskedSubPixelVarianceTest, ExtremeValues) {
}
#if CONFIG_HIGHBITDEPTH
-typedef std::tr1::tuple<MaskedVarianceFunc, MaskedVarianceFunc, aom_bit_depth_t>
- HighbdMaskedVarianceParam;
-
-class HighbdMaskedVarianceTest
- : public ::testing::TestWithParam<HighbdMaskedVarianceParam> {
- public:
- virtual ~HighbdMaskedVarianceTest() {}
- virtual void SetUp() {
- opt_func_ = GET_PARAM(0);
- ref_func_ = GET_PARAM(1);
- bit_depth_ = GET_PARAM(2);
- }
-
- virtual void TearDown() { libaom_test::ClearSystemState(); }
-
- protected:
- MaskedVarianceFunc opt_func_;
- MaskedVarianceFunc ref_func_;
- aom_bit_depth_t bit_depth_;
-};
-
-TEST_P(HighbdMaskedVarianceTest, OperationCheck) {
- unsigned int ref_ret, opt_ret;
- unsigned int ref_sse, opt_sse;
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
- uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
- int err_count = 0;
- int first_failure = -1;
- int src_stride = MAX_SB_SIZE;
- int ref_stride = MAX_SB_SIZE;
- int msk_stride = MAX_SB_SIZE;
-
- for (int i = 0; i < number_of_iterations; ++i) {
- for (int j = 0; j < MAX_SB_SIZE * MAX_SB_SIZE; j++) {
- src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
- ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
- msk_ptr[j] = rnd(65);
- }
-
- ref_ret = ref_func_(src8_ptr, src_stride, ref8_ptr, ref_stride, msk_ptr,
- msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride, ref8_ptr,
- ref_stride, msk_ptr,
- msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) first_failure = i;
- }
- }
-
- EXPECT_EQ(0, err_count) << "Error: Masked Variance Test OperationCheck,"
- << "C output doesn't match SSSE3 output. "
- << "First failed at test case " << first_failure;
-}
-
-TEST_P(HighbdMaskedVarianceTest, ExtremeValues) {
- unsigned int ref_ret, opt_ret;
- unsigned int ref_sse, opt_sse;
- ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint16_t, src_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint16_t, ref_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[MAX_SB_SIZE * MAX_SB_SIZE]);
- uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
- uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
- int err_count = 0;
- int first_failure = -1;
- int src_stride = MAX_SB_SIZE;
- int ref_stride = MAX_SB_SIZE;
- int msk_stride = MAX_SB_SIZE;
-
- for (int i = 0; i < 8; ++i) {
- aom_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
- MAX_SB_SIZE * MAX_SB_SIZE);
- aom_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
- MAX_SB_SIZE * MAX_SB_SIZE);
- memset(msk_ptr, (i & 0x4) ? 64 : 0, MAX_SB_SIZE * MAX_SB_SIZE);
-
- ref_ret = ref_func_(src8_ptr, src_stride, ref8_ptr, ref_stride, msk_ptr,
- msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret = opt_func_(src8_ptr, src_stride, ref8_ptr,
- ref_stride, msk_ptr,
- msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) first_failure = i;
- }
- }
-
- EXPECT_EQ(0, err_count) << "Error: Masked Variance Test ExtremeValues,"
- << "C output doesn't match SSSE3 output. "
- << "First failed at test case " << first_failure;
-}
-
typedef std::tr1::tuple<MaskedSubPixelVarianceFunc, MaskedSubPixelVarianceFunc,
aom_bit_depth_t>
HighbdMaskedSubPixelVarianceParam;
@@ -375,11 +204,21 @@ TEST_P(HighbdMaskedSubPixelVarianceTest, OperationCheck) {
unsigned int ref_ret, opt_ret;
unsigned int ref_sse, opt_sse;
ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+ // Note: We pad the input arrays out with 7 extra elements, since the SSE
+ // implementations can read up to 7 elements off the end of the main data.
+ // The extra data is never actually used, but it simplifies the code
+ // if we can do this.
+ DECLARE_ALIGNED(16, uint16_t,
+ src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint16_t,
+ ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint16_t,
+ second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint8_t,
+ msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+ uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
int err_count = 0;
int first_failure = -1;
int first_failure_x = -1;
@@ -390,27 +229,30 @@ TEST_P(HighbdMaskedSubPixelVarianceTest, OperationCheck) {
int xoffset, yoffset;
for (int i = 0; i < number_of_iterations; ++i) {
+ for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1); j++) {
+ src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
+ ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
+ second_pred_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
+ msk_ptr[j] = rnd(65);
+ }
for (xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
for (yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
- for (int j = 0; j < (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1); j++) {
- src_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
- ref_ptr[j] = rnd.Rand16() & ((1 << bit_depth_) - 1);
- msk_ptr[j] = rnd(65);
- }
-
- ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
- ref_stride, msk_ptr, msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret =
- opt_func_(src8_ptr, src_stride, xoffset,
- yoffset, ref8_ptr, ref_stride,
- msk_ptr, msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) {
- first_failure = i;
- first_failure_x = xoffset;
- first_failure_y = yoffset;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
+ ref_stride, second_pred8_ptr, msk_ptr, msk_stride,
+ invert_mask, &ref_sse);
+ ASM_REGISTER_STATE_CHECK(
+ opt_ret = opt_func_(src8_ptr, src_stride, xoffset, yoffset,
+ ref8_ptr, ref_stride, second_pred8_ptr,
+ msk_ptr, msk_stride, invert_mask, &opt_sse));
+
+ if (opt_ret != ref_ret || opt_sse != ref_sse) {
+ err_count++;
+ if (first_failure == -1) {
+ first_failure = i;
+ first_failure_x = xoffset;
+ first_failure_y = yoffset;
+ }
}
}
}
@@ -428,11 +270,17 @@ TEST_P(HighbdMaskedSubPixelVarianceTest, ExtremeValues) {
unsigned int ref_ret, opt_ret;
unsigned int ref_sse, opt_sse;
ACMRandom rnd(ACMRandom::DeterministicSeed());
- DECLARE_ALIGNED(16, uint16_t, src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint16_t, ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
- DECLARE_ALIGNED(16, uint8_t, msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1)]);
+ DECLARE_ALIGNED(16, uint16_t,
+ src_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint16_t,
+ ref_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint8_t,
+ msk_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
+ DECLARE_ALIGNED(16, uint16_t,
+ second_pred_ptr[(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1) + 7]);
uint8_t *src8_ptr = CONVERT_TO_BYTEPTR(src_ptr);
uint8_t *ref8_ptr = CONVERT_TO_BYTEPTR(ref_ptr);
+ uint8_t *second_pred8_ptr = CONVERT_TO_BYTEPTR(second_pred_ptr);
int first_failure_x = -1;
int first_failure_y = -1;
int err_count = 0;
@@ -443,27 +291,32 @@ TEST_P(HighbdMaskedSubPixelVarianceTest, ExtremeValues) {
for (int xoffset = 0; xoffset < BIL_SUBPEL_SHIFTS; xoffset++) {
for (int yoffset = 0; yoffset < BIL_SUBPEL_SHIFTS; yoffset++) {
- for (int i = 0; i < 8; ++i) {
+ for (int i = 0; i < 16; ++i) {
aom_memset16(src_ptr, (i & 0x1) ? ((1 << bit_depth_) - 1) : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
aom_memset16(ref_ptr, (i & 0x2) ? ((1 << bit_depth_) - 1) : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
- memset(msk_ptr, (i & 0x4) ? 64 : 0,
+ aom_memset16(second_pred_ptr, (i & 0x4) ? ((1 << bit_depth_) - 1) : 0,
+ (MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
+ memset(msk_ptr, (i & 0x8) ? 64 : 0,
(MAX_SB_SIZE + 1) * (MAX_SB_SIZE + 1));
- ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
- ref_stride, msk_ptr, msk_stride, &ref_sse);
- ASM_REGISTER_STATE_CHECK(opt_ret =
- opt_func_(src8_ptr, src_stride, xoffset,
- yoffset, ref8_ptr, ref_stride,
- msk_ptr, msk_stride, &opt_sse));
-
- if (opt_ret != ref_ret || opt_sse != ref_sse) {
- err_count++;
- if (first_failure == -1) {
- first_failure = i;
- first_failure_x = xoffset;
- first_failure_y = yoffset;
+ for (int invert_mask = 0; invert_mask < 2; ++invert_mask) {
+ ref_ret = ref_func_(src8_ptr, src_stride, xoffset, yoffset, ref8_ptr,
+ ref_stride, second_pred8_ptr, msk_ptr, msk_stride,
+ invert_mask, &ref_sse);
+ ASM_REGISTER_STATE_CHECK(
+ opt_ret = opt_func_(src8_ptr, src_stride, xoffset, yoffset,
+ ref8_ptr, ref_stride, second_pred8_ptr,
+ msk_ptr, msk_stride, invert_mask, &opt_sse));
+
+ if (opt_ret != ref_ret || opt_sse != ref_sse) {
+ err_count++;
+ if (first_failure == -1) {
+ first_failure = i;
+ first_failure_x = xoffset;
+ first_failure_y = yoffset;
+ }
}
}
}
@@ -482,38 +335,6 @@ using std::tr1::make_tuple;
#if HAVE_SSSE3
INSTANTIATE_TEST_CASE_P(
- SSSE3_C_COMPARE, MaskedVarianceTest,
- ::testing::Values(
-#if CONFIG_EXT_PARTITION
- make_tuple(&aom_masked_variance128x128_ssse3,
- &aom_masked_variance128x128_c),
- make_tuple(&aom_masked_variance128x64_ssse3,
- &aom_masked_variance128x64_c),
- make_tuple(&aom_masked_variance64x128_ssse3,
- &aom_masked_variance64x128_c),
-#endif // CONFIG_EXT_PARTITION
- make_tuple(&aom_masked_variance64x64_ssse3,
- &aom_masked_variance64x64_c),
- make_tuple(&aom_masked_variance64x32_ssse3,
- &aom_masked_variance64x32_c),
- make_tuple(&aom_masked_variance32x64_ssse3,
- &aom_masked_variance32x64_c),
- make_tuple(&aom_masked_variance32x32_ssse3,
- &aom_masked_variance32x32_c),
- make_tuple(&aom_masked_variance32x16_ssse3,
- &aom_masked_variance32x16_c),
- make_tuple(&aom_masked_variance16x32_ssse3,
- &aom_masked_variance16x32_c),
- make_tuple(&aom_masked_variance16x16_ssse3,
- &aom_masked_variance16x16_c),
- make_tuple(&aom_masked_variance16x8_ssse3, &aom_masked_variance16x8_c),
- make_tuple(&aom_masked_variance8x16_ssse3, &aom_masked_variance8x16_c),
- make_tuple(&aom_masked_variance8x8_ssse3, &aom_masked_variance8x8_c),
- make_tuple(&aom_masked_variance8x4_ssse3, &aom_masked_variance8x4_c),
- make_tuple(&aom_masked_variance4x8_ssse3, &aom_masked_variance4x8_c),
- make_tuple(&aom_masked_variance4x4_ssse3, &aom_masked_variance4x4_c)));
-
-INSTANTIATE_TEST_CASE_P(
SSSE3_C_COMPARE, MaskedSubPixelVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
@@ -553,148 +374,43 @@ INSTANTIATE_TEST_CASE_P(
#if CONFIG_HIGHBITDEPTH
INSTANTIATE_TEST_CASE_P(
- SSSE3_C_COMPARE, HighbdMaskedVarianceTest,
- ::testing::Values(
-#if CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_masked_variance128x128_ssse3,
- &aom_highbd_masked_variance128x128_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance128x64_ssse3,
- &aom_highbd_masked_variance128x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance64x128_ssse3,
- &aom_highbd_masked_variance64x128_c, AOM_BITS_8),
-#endif // CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_masked_variance64x64_ssse3,
- &aom_highbd_masked_variance64x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance64x32_ssse3,
- &aom_highbd_masked_variance64x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance32x64_ssse3,
- &aom_highbd_masked_variance32x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance32x32_ssse3,
- &aom_highbd_masked_variance32x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance32x16_ssse3,
- &aom_highbd_masked_variance32x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance16x32_ssse3,
- &aom_highbd_masked_variance16x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance16x16_ssse3,
- &aom_highbd_masked_variance16x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance16x8_ssse3,
- &aom_highbd_masked_variance16x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance8x16_ssse3,
- &aom_highbd_masked_variance8x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance8x8_ssse3,
- &aom_highbd_masked_variance8x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance8x4_ssse3,
- &aom_highbd_masked_variance8x4_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance4x8_ssse3,
- &aom_highbd_masked_variance4x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_variance4x4_ssse3,
- &aom_highbd_masked_variance4x4_c, AOM_BITS_8),
-#if CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_10_masked_variance128x128_ssse3,
- &aom_highbd_10_masked_variance128x128_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance128x64_ssse3,
- &aom_highbd_10_masked_variance128x64_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance64x128_ssse3,
- &aom_highbd_10_masked_variance64x128_c, AOM_BITS_10),
-#endif // CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_10_masked_variance64x64_ssse3,
- &aom_highbd_10_masked_variance64x64_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance64x32_ssse3,
- &aom_highbd_10_masked_variance64x32_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance32x64_ssse3,
- &aom_highbd_10_masked_variance32x64_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance32x32_ssse3,
- &aom_highbd_10_masked_variance32x32_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance32x16_ssse3,
- &aom_highbd_10_masked_variance32x16_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance16x32_ssse3,
- &aom_highbd_10_masked_variance16x32_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance16x16_ssse3,
- &aom_highbd_10_masked_variance16x16_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance16x8_ssse3,
- &aom_highbd_10_masked_variance16x8_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance8x16_ssse3,
- &aom_highbd_10_masked_variance8x16_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance8x8_ssse3,
- &aom_highbd_10_masked_variance8x8_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance8x4_ssse3,
- &aom_highbd_10_masked_variance8x4_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance4x8_ssse3,
- &aom_highbd_10_masked_variance4x8_c, AOM_BITS_10),
- make_tuple(&aom_highbd_10_masked_variance4x4_ssse3,
- &aom_highbd_10_masked_variance4x4_c, AOM_BITS_10),
-#if CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_12_masked_variance128x128_ssse3,
- &aom_highbd_12_masked_variance128x128_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance128x64_ssse3,
- &aom_highbd_12_masked_variance128x64_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance64x128_ssse3,
- &aom_highbd_12_masked_variance64x128_c, AOM_BITS_12),
-#endif // CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_12_masked_variance64x64_ssse3,
- &aom_highbd_12_masked_variance64x64_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance64x32_ssse3,
- &aom_highbd_12_masked_variance64x32_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance32x64_ssse3,
- &aom_highbd_12_masked_variance32x64_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance32x32_ssse3,
- &aom_highbd_12_masked_variance32x32_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance32x16_ssse3,
- &aom_highbd_12_masked_variance32x16_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance16x32_ssse3,
- &aom_highbd_12_masked_variance16x32_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance16x16_ssse3,
- &aom_highbd_12_masked_variance16x16_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance16x8_ssse3,
- &aom_highbd_12_masked_variance16x8_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance8x16_ssse3,
- &aom_highbd_12_masked_variance8x16_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance8x8_ssse3,
- &aom_highbd_12_masked_variance8x8_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance8x4_ssse3,
- &aom_highbd_12_masked_variance8x4_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance4x8_ssse3,
- &aom_highbd_12_masked_variance4x8_c, AOM_BITS_12),
- make_tuple(&aom_highbd_12_masked_variance4x4_ssse3,
- &aom_highbd_12_masked_variance4x4_c, AOM_BITS_12)));
-
-INSTANTIATE_TEST_CASE_P(
SSSE3_C_COMPARE, HighbdMaskedSubPixelVarianceTest,
::testing::Values(
#if CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_masked_sub_pixel_variance128x128_ssse3,
- &aom_highbd_masked_sub_pixel_variance128x128_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance128x64_ssse3,
- &aom_highbd_masked_sub_pixel_variance128x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance64x128_ssse3,
- &aom_highbd_masked_sub_pixel_variance64x128_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance128x128_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance128x128_c,
+ AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance128x64_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance128x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x128_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance64x128_c, AOM_BITS_8),
#endif // CONFIG_EXT_PARTITION
- make_tuple(&aom_highbd_masked_sub_pixel_variance64x64_ssse3,
- &aom_highbd_masked_sub_pixel_variance64x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance64x32_ssse3,
- &aom_highbd_masked_sub_pixel_variance64x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance32x64_ssse3,
- &aom_highbd_masked_sub_pixel_variance32x64_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance32x32_ssse3,
- &aom_highbd_masked_sub_pixel_variance32x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance32x16_ssse3,
- &aom_highbd_masked_sub_pixel_variance32x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance16x32_ssse3,
- &aom_highbd_masked_sub_pixel_variance16x32_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance16x16_ssse3,
- &aom_highbd_masked_sub_pixel_variance16x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance16x8_ssse3,
- &aom_highbd_masked_sub_pixel_variance16x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance8x16_ssse3,
- &aom_highbd_masked_sub_pixel_variance8x16_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance8x8_ssse3,
- &aom_highbd_masked_sub_pixel_variance8x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance8x4_ssse3,
- &aom_highbd_masked_sub_pixel_variance8x4_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance4x8_ssse3,
- &aom_highbd_masked_sub_pixel_variance4x8_c, AOM_BITS_8),
- make_tuple(&aom_highbd_masked_sub_pixel_variance4x4_ssse3,
- &aom_highbd_masked_sub_pixel_variance4x4_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x64_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance64x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance64x32_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance64x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x64_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance32x64_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x32_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance32x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance32x16_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance32x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x32_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance16x32_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x16_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance16x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance16x8_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance16x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x16_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance8x16_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x8_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance8x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance8x4_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance8x4_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance4x8_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance4x8_c, AOM_BITS_8),
+ make_tuple(&aom_highbd_8_masked_sub_pixel_variance4x4_ssse3,
+ &aom_highbd_8_masked_sub_pixel_variance4x4_c, AOM_BITS_8),
#if CONFIG_EXT_PARTITION
make_tuple(&aom_highbd_10_masked_sub_pixel_variance128x128_ssse3,
&aom_highbd_10_masked_sub_pixel_variance128x128_c,
diff --git a/third_party/aom/test/motion_vector_test.cc b/third_party/aom/test/motion_vector_test.cc
index 403a8f1a7..fa47494e8 100644
--- a/third_party/aom/test/motion_vector_test.cc
+++ b/third_party/aom/test/motion_vector_test.cc
@@ -17,12 +17,6 @@
#include "test/yuv_video_source.h"
namespace {
-#if defined(__has_feature)
-#if __has_feature(address_sanitizer)
-#define BUILDING_WITH_ASAN
-#endif
-#endif
-
#define MAX_EXTREME_MV 1
#define MIN_EXTREME_MV 2
@@ -32,7 +26,7 @@ const libaom_test::TestMode kEncodingModeVectors[] = {
};
// Encoding speeds
-const int kCpuUsedVectors[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+const int kCpuUsedVectors[] = { 1, 5 };
// MV test modes: 1 - always use maximum MV; 2 - always use minimum MV.
const int kMVTestModes[] = { MAX_EXTREME_MV, MIN_EXTREME_MV };
@@ -85,16 +79,11 @@ TEST_P(MotionVectorTestLarge, OverallTest) {
int width = 3840;
int height = 2160;
-#ifdef BUILDING_WITH_ASAN
- // On the 32-bit system, if using 4k test clip, an "out of memory" error
- // occurs because of the AddressSanitizer instrumentation memory overhead.
- // Here, reduce the test clip's resolution while testing on 32-bit system
- // and AddressSanitizer is enabled.
+ // Reduce the test clip's resolution while testing on 32-bit system.
if (sizeof(void *) == 4) {
width = 2048;
height = 1080;
}
-#endif
cfg_.rc_target_bitrate = 24000;
cfg_.g_profile = 0;
@@ -102,7 +91,7 @@ TEST_P(MotionVectorTestLarge, OverallTest) {
testing::internal::scoped_ptr<libaom_test::VideoSource> video;
video.reset(new libaom_test::YUVVideoSource(
- "niklas_640_480_30.yuv", AOM_IMG_FMT_I420, width, height, 30, 1, 0, 5));
+ "niklas_640_480_30.yuv", AOM_IMG_FMT_I420, width, height, 30, 1, 0, 3));
ASSERT_TRUE(video.get() != NULL);
ASSERT_NO_FATAL_FAILURE(RunLoop(video.get()));
diff --git a/third_party/aom/test/partial_idct_test.cc b/third_party/aom/test/partial_idct_test.cc
index 0899b60c3..033f18294 100644
--- a/third_party/aom/test/partial_idct_test.cc
+++ b/third_party/aom/test/partial_idct_test.cc
@@ -52,7 +52,7 @@ typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmWithBdFunc, InvTxfmWithBdFunc,
TX_SIZE, int, int, int>
PartialInvTxfmParam;
const int kMaxNumCoeffs = 1024;
-const int kCountTestBlock = 1000;
+const int kCountTestBlock = 10000;
class PartialIDctTest : public ::testing::TestWithParam<PartialInvTxfmParam> {
public:
@@ -231,8 +231,8 @@ TEST_P(PartialIDctTest, AddOutputBlock) {
}
TEST_P(PartialIDctTest, SingleExtremeCoeff) {
- const int16_t max_coeff = std::numeric_limits<int16_t>::max();
- const int16_t min_coeff = std::numeric_limits<int16_t>::min();
+ const int16_t max_coeff = INT16_MAX;
+ const int16_t min_coeff = INT16_MIN;
for (int i = 0; i < last_nonzero_; ++i) {
memset(input_block_, 0, sizeof(*input_block_) * input_block_size_);
// Run once for min and once for max.
@@ -418,6 +418,30 @@ INSTANTIATE_TEST_CASE_P(SSSE3, PartialIDctTest,
::testing::ValuesIn(ssse3_partial_idct_tests));
#endif // HAVE_SSSE3
+#if HAVE_AVX2
+const PartialInvTxfmParam avx2_partial_idct_tests[] = {
+ make_tuple(&aom_fdct16x16_c, &wrapper<aom_idct16x16_256_add_c>,
+ &wrapper<aom_idct16x16_256_add_avx2>, TX_16X16, 256, 8, 1),
+ make_tuple(&aom_fdct16x16_c, &wrapper<aom_idct16x16_256_add_c>,
+ &wrapper<aom_idct16x16_38_add_avx2>, TX_16X16, 38, 8, 1),
+ make_tuple(&aom_fdct16x16_c, &wrapper<aom_idct16x16_256_add_c>,
+ &wrapper<aom_idct16x16_10_add_avx2>, TX_16X16, 10, 8, 1),
+ make_tuple(&aom_fdct16x16_c, &wrapper<aom_idct16x16_256_add_c>,
+ &wrapper<aom_idct16x16_1_add_avx2>, TX_16X16, 1, 8, 1),
+ make_tuple(&aom_fdct32x32_c, &wrapper<aom_idct32x32_1024_add_c>,
+ &wrapper<aom_idct32x32_1024_add_avx2>, TX_32X32, 1024, 8, 1),
+ make_tuple(&aom_fdct32x32_c, &wrapper<aom_idct32x32_1024_add_c>,
+ &wrapper<aom_idct32x32_135_add_avx2>, TX_32X32, 135, 8, 1),
+ make_tuple(&aom_fdct32x32_c, &wrapper<aom_idct32x32_1024_add_c>,
+ &wrapper<aom_idct32x32_34_add_avx2>, TX_32X32, 34, 8, 1),
+ make_tuple(&aom_fdct32x32_c, &wrapper<aom_idct32x32_1024_add_c>,
+ &wrapper<aom_idct32x32_1_add_avx2>, TX_32X32, 1, 8, 1),
+};
+
+INSTANTIATE_TEST_CASE_P(AVX2, PartialIDctTest,
+ ::testing::ValuesIn(avx2_partial_idct_tests));
+#endif // HAVE_AVX2
+
#if HAVE_DSPR2 && !CONFIG_HIGHBITDEPTH
const PartialInvTxfmParam dspr2_partial_idct_tests[] = {
make_tuple(&aom_fdct32x32_c, &wrapper<aom_idct32x32_1024_add_c>,
diff --git a/third_party/aom/test/quantize_func_test.cc b/third_party/aom/test/quantize_func_test.cc
new file mode 100644
index 000000000..32b1d5139
--- /dev/null
+++ b/third_party/aom/test/quantize_func_test.cc
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2017, 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 "third_party/googletest/src/googletest/include/gtest/gtest.h"
+
+#include "./aom_config.h"
+#include "./av1_rtcd.h"
+#include "aom/aom_codec.h"
+#include "av1/encoder/encoder.h"
+#include "av1/encoder/av1_quantize.h"
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/util.h"
+
+namespace {
+using libaom_test::ACMRandom;
+
+#if !CONFIG_AOM_QM
+typedef void (*QuantizeFunc)(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
+ int skip_block, const int16_t *zbin_ptr,
+ const int16_t *round_ptr, const int16_t *quant_ptr,
+ const int16_t *quant_shift_ptr,
+ tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
+ const int16_t *dequant_ptr, uint16_t *eob_ptr,
+ const int16_t *scan, const int16_t *iscan);
+#else
+typedef void (*QuantizeFunc)(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
+ int skip_block, const int16_t *zbin_ptr,
+ const int16_t *round_ptr, const int16_t *quant_ptr,
+ const int16_t *quant_shift_ptr,
+ tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
+ const int16_t *dequant_ptr, uint16_t *eob_ptr,
+ const int16_t *scan, const int16_t *iscan,
+ const qm_val_t *qm_ptr, const qm_val_t *iqm_ptr);
+#endif
+
+typedef std::tr1::tuple<QuantizeFunc, QuantizeFunc, TX_SIZE, aom_bit_depth_t>
+ QuantizeParam;
+
+typedef struct {
+ QUANTS quant;
+ Dequants dequant;
+} QuanTable;
+
+const int kTestNum = 1000;
+
+class QuantizeTest : public ::testing::TestWithParam<QuantizeParam> {
+ protected:
+ QuantizeTest()
+ : quant_ref_(GET_PARAM(0)), quant_(GET_PARAM(1)), tx_size_(GET_PARAM(2)),
+ bd_(GET_PARAM(3)) {}
+
+ virtual ~QuantizeTest() {}
+
+ virtual void SetUp() {
+ qtab_ = reinterpret_cast<QuanTable *>(aom_memalign(16, sizeof(*qtab_)));
+ const int n_coeffs = getCoeffNum();
+ coeff_ = reinterpret_cast<tran_low_t *>(
+ aom_memalign(16, 6 * n_coeffs * sizeof(tran_low_t)));
+ InitQuantizer();
+ }
+
+ virtual void TearDown() {
+ aom_free(qtab_);
+ qtab_ = NULL;
+ aom_free(coeff_);
+ coeff_ = NULL;
+ libaom_test::ClearSystemState();
+ }
+
+ void InitQuantizer() {
+ av1_build_quantizer(bd_, 0, 0, 0, &qtab_->quant, &qtab_->dequant);
+ }
+
+ void QuantizeRun(bool isLoop, int q = 0, int testNum = 1) {
+ tran_low_t *coeff_ptr = coeff_;
+ const intptr_t n_coeffs = getCoeffNum();
+ const int skip_block = 0;
+
+ tran_low_t *qcoeff_ref = coeff_ptr + n_coeffs;
+ tran_low_t *dqcoeff_ref = qcoeff_ref + n_coeffs;
+
+ tran_low_t *qcoeff = dqcoeff_ref + n_coeffs;
+ tran_low_t *dqcoeff = qcoeff + n_coeffs;
+ uint16_t *eob = (uint16_t *)(dqcoeff + n_coeffs);
+
+ // Testing uses 2-D DCT scan order table
+ const SCAN_ORDER *const sc = get_default_scan(tx_size_, DCT_DCT, 0);
+
+ // Testing uses luminance quantization table
+ const int16_t *zbin = qtab_->quant.y_zbin[q];
+ const int16_t *round_fp = qtab_->quant.y_round_fp[q];
+ const int16_t *quant_fp = qtab_->quant.y_quant_fp[q];
+ const int16_t *quant_shift = qtab_->quant.y_quant_shift[q];
+ const int16_t *dequant = qtab_->dequant.y_dequant[q];
+ const size_t bufferSize = n_coeffs;
+
+ int i = 0;
+ while (i < testNum) {
+ if (isLoop) FillCoeffRandom();
+
+ memset(qcoeff_ref, 0, 5 * n_coeffs * sizeof(*qcoeff_ref));
+
+ quant_ref_(coeff_ptr, n_coeffs, skip_block, zbin, round_fp, quant_fp,
+ quant_shift, qcoeff_ref, dqcoeff_ref, dequant, &eob[0],
+ sc->scan, sc->iscan);
+
+ ASM_REGISTER_STATE_CHECK(quant_(
+ coeff_ptr, n_coeffs, skip_block, zbin, round_fp, quant_fp,
+ quant_shift, qcoeff, dqcoeff, dequant, &eob[1], sc->scan, sc->iscan));
+
+ CompareResults(qcoeff_ref, qcoeff, bufferSize, "Qcoeff", q, i);
+ CompareResults(dqcoeff_ref, dqcoeff, bufferSize, "Dqcoeff", q, i);
+ ASSERT_EQ(eob[0], eob[1]) << "eobs mismatch on test: " << i;
+
+ i++;
+ }
+ }
+
+ void CompareResults(const tran_low_t *buf_ref, const tran_low_t *buf,
+ int size, const char *text, int q, int number) {
+ int i;
+ for (i = 0; i < size; ++i) {
+ ASSERT_EQ(buf_ref[i], buf[i]) << text << " mismatch on test: " << number
+ << " at position: " << i << " Q: " << q;
+ }
+ }
+
+ int getCoeffNum() { return tx_size_2d[tx_size_]; }
+
+ void FillCoeffGeneric(bool isConstant, tran_low_t c = 0) {
+ const int n_coeffs = getCoeffNum();
+ int i;
+ if (isConstant) {
+ for (i = 0; i < n_coeffs; ++i) {
+ coeff_[i] = c;
+ }
+ } else {
+ FillCoeffZero();
+ int num = rnd_.Rand16() % n_coeffs;
+ for (i = 0; i < num; ++i) {
+ coeff_[i] = GetRandomCoeff();
+ }
+ }
+ }
+
+ void FillCoeffZero() { FillCoeffGeneric(true); }
+
+ void FillCoeffConstant() {
+ tran_low_t c = GetRandomCoeff();
+ FillCoeffGeneric(true, c);
+ }
+
+ void FillDcOnly() {
+ FillCoeffZero();
+ coeff_[0] = GetRandomCoeff();
+ }
+
+ void FillDcLargeNegative() {
+ FillCoeffZero();
+ // Generate a qcoeff which contains 512/-512 (0x0100/0xFE00) to catch issues
+ // like BUG=883 where the constant being compared was incorrectly
+ // initialized.
+ coeff_[0] = -8191;
+ }
+
+ void FillCoeffRandom() { FillCoeffGeneric(false); }
+
+ tran_low_t GetRandomCoeff() {
+ return clamp((int16_t)rnd_.Rand16(), INT16_MIN + 1, INT16_MAX);
+ }
+
+ ACMRandom rnd_;
+ QuanTable *qtab_;
+ tran_low_t *coeff_;
+ QuantizeFunc quant_ref_;
+ QuantizeFunc quant_;
+ TX_SIZE tx_size_;
+ aom_bit_depth_t bd_;
+};
+
+TEST_P(QuantizeTest, ZeroInput) {
+ FillCoeffZero();
+ QuantizeRun(false);
+}
+
+TEST_P(QuantizeTest, LargeNegativeInput) {
+ FillDcLargeNegative();
+ QuantizeRun(false);
+}
+
+TEST_P(QuantizeTest, DcOnlyInput) {
+ FillDcOnly();
+ QuantizeRun(false);
+}
+
+TEST_P(QuantizeTest, RandomInput) { QuantizeRun(true, 0, kTestNum); }
+
+TEST_P(QuantizeTest, MultipleQ) {
+ for (int q = 0; q < QINDEX_RANGE; ++q) {
+ QuantizeRun(true, q, kTestNum);
+ }
+}
+
+using std::tr1::make_tuple;
+
+#if HAVE_SSE2
+const QuantizeParam kQParamArraySSE2[] = { make_tuple(
+ &av1_quantize_fp_c, &av1_quantize_fp_sse2, TX_16X16, AOM_BITS_8) };
+
+INSTANTIATE_TEST_CASE_P(SSE2, QuantizeTest,
+ ::testing::ValuesIn(kQParamArraySSE2));
+#endif
+
+#if !CONFIG_HIGHBITDEPTH && HAVE_SSSE3 && ARCH_X86_64
+const QuantizeParam kQParamArraySSSE3[] = {
+ make_tuple(&av1_quantize_fp_c, &av1_quantize_fp_ssse3, TX_16X16, AOM_BITS_8),
+ // TODO(any):
+ // The following test couldn't pass yet
+ // make_tuple(av1_quantize_fp_c, av1_quantize_fp_32x32_ssse3, TX_32X32,
+ // AOM_BITS_8)
+};
+INSTANTIATE_TEST_CASE_P(SSSE3, QuantizeTest,
+ ::testing::ValuesIn(kQParamArraySSSE3));
+#endif
+
+} // namespace
diff --git a/third_party/aom/test/sad_test.cc b/third_party/aom/test/sad_test.cc
index c3b5dac42..7564a6760 100644
--- a/third_party/aom/test/sad_test.cc
+++ b/third_party/aom/test/sad_test.cc
@@ -740,13 +740,6 @@ INSTANTIATE_TEST_CASE_P(C, SADx4Test, ::testing::ValuesIn(x4d_c_tests));
//------------------------------------------------------------------------------
// ARM functions
-#if HAVE_MEDIA
-const SadMxNParam media_tests[] = {
- make_tuple(16, 16, &aom_sad16x16_media, -1),
-};
-INSTANTIATE_TEST_CASE_P(MEDIA, SADTest, ::testing::ValuesIn(media_tests));
-#endif // HAVE_MEDIA
-
#if HAVE_NEON
const SadMxNParam neon_tests[] = {
make_tuple(64, 64, &aom_sad64x64_neon, -1),
diff --git a/third_party/aom/test/simd_avx2_test.cc b/third_party/aom/test/simd_avx2_test.cc
new file mode 100644
index 000000000..d54d201b9
--- /dev/null
+++ b/third_party/aom/test/simd_avx2_test.cc
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2016, 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.
+ */
+
+#define ARCH AVX2
+#define ARCH_POSTFIX(name) name##_avx2
+#define SIMD_NAMESPACE simd_test_avx2
+#include "./simd_impl.h"
diff --git a/third_party/aom/test/simd_cmp_avx2.cc b/third_party/aom/test/simd_cmp_avx2.cc
new file mode 100644
index 000000000..47ae11c62
--- /dev/null
+++ b/third_party/aom/test/simd_cmp_avx2.cc
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2016, 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.
+ */
+
+#define ARCH AVX2
+#define ARCH_POSTFIX(name) name##_avx2
+#define SIMD_NAMESPACE simd_test_avx2
+#include "./simd_cmp_impl.h"
diff --git a/third_party/aom/test/simd_cmp_impl.h b/third_party/aom/test/simd_cmp_impl.h
index 28bd64a5b..4a9c1f7be 100644
--- a/third_party/aom/test/simd_cmp_impl.h
+++ b/third_party/aom/test/simd_cmp_impl.h
@@ -16,7 +16,7 @@
#include "aom_dsp/aom_simd.h"
#undef SIMD_INLINE
#define SIMD_INLINE static // Don't enforce inlining
-#include "aom_dsp/simd/v128_intrinsics_c.h"
+#include "aom_dsp/simd/v256_intrinsics_c.h"
// Machine tuned code goes into this file. This file is included from
// simd_cmp_sse2.cc, simd_cmp_ssse3.cc etc which define the macros
@@ -224,6 +224,104 @@ c_v128 c_imm_v128_align(c_v128 a, c_v128 b) {
return c_v128_align(a, b, shift);
}
+template <int shift>
+v256 imm_v256_shl_n_byte(v256 a) {
+ return v256_shl_n_byte(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_byte(v256 a) {
+ return v256_shr_n_byte(a, shift);
+}
+template <int shift>
+v256 imm_v256_shl_n_8(v256 a) {
+ return v256_shl_n_8(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_u8(v256 a) {
+ return v256_shr_n_u8(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_s8(v256 a) {
+ return v256_shr_n_s8(a, shift);
+}
+template <int shift>
+v256 imm_v256_shl_n_16(v256 a) {
+ return v256_shl_n_16(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_u16(v256 a) {
+ return v256_shr_n_u16(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_s16(v256 a) {
+ return v256_shr_n_s16(a, shift);
+}
+template <int shift>
+v256 imm_v256_shl_n_32(v256 a) {
+ return v256_shl_n_32(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_u32(v256 a) {
+ return v256_shr_n_u32(a, shift);
+}
+template <int shift>
+v256 imm_v256_shr_n_s32(v256 a) {
+ return v256_shr_n_s32(a, shift);
+}
+template <int shift>
+v256 imm_v256_align(v256 a, v256 b) {
+ return v256_align(a, b, shift);
+}
+
+template <int shift>
+c_v256 c_imm_v256_shl_n_byte(c_v256 a) {
+ return c_v256_shl_n_byte(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_byte(c_v256 a) {
+ return c_v256_shr_n_byte(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shl_n_8(c_v256 a) {
+ return c_v256_shl_n_8(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_u8(c_v256 a) {
+ return c_v256_shr_n_u8(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_s8(c_v256 a) {
+ return c_v256_shr_n_s8(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shl_n_16(c_v256 a) {
+ return c_v256_shl_n_16(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_u16(c_v256 a) {
+ return c_v256_shr_n_u16(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_s16(c_v256 a) {
+ return c_v256_shr_n_s16(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shl_n_32(c_v256 a) {
+ return c_v256_shl_n_32(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_u32(c_v256 a) {
+ return c_v256_shr_n_u32(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_shr_n_s32(c_v256 a) {
+ return c_v256_shr_n_s32(a, shift);
+}
+template <int shift>
+c_v256 c_imm_v256_align(c_v256 a, c_v256 b) {
+ return c_v256_align(a, b, shift);
+}
+
// Wrappers around the the SAD and SSD functions
uint32_t v64_sad_u8(v64 a, v64 b) {
return v64_sad_u8_sum(::v64_sad_u8(v64_sad_u8_init(), a, b));
@@ -250,6 +348,18 @@ uint32_t c_v128_sad_u8(c_v128 a, c_v128 b) {
uint32_t c_v128_ssd_u8(c_v128 a, c_v128 b) {
return c_v128_ssd_u8_sum(::c_v128_ssd_u8(c_v128_ssd_u8_init(), a, b));
}
+uint32_t v256_sad_u8(v256 a, v256 b) {
+ return v256_sad_u8_sum(::v256_sad_u8(v256_sad_u8_init(), a, b));
+}
+uint32_t v256_ssd_u8(v256 a, v256 b) {
+ return v256_ssd_u8_sum(::v256_ssd_u8(v256_ssd_u8_init(), a, b));
+}
+uint32_t c_v256_sad_u8(c_v256 a, c_v256 b) {
+ return c_v256_sad_u8_sum(::c_v256_sad_u8(c_v256_sad_u8_init(), a, b));
+}
+uint32_t c_v256_ssd_u8(c_v256 a, c_v256 b) {
+ return c_v256_ssd_u8_sum(::c_v256_ssd_u8(c_v256_ssd_u8_init(), a, b));
+}
namespace {
@@ -657,6 +767,265 @@ const mapping m[] = { MAP(v64_sad_u8),
MAP(v64_store_unaligned),
MAP(v128_load_unaligned),
MAP(v128_store_unaligned),
+ MAP(v256_sad_u8),
+ MAP(v256_ssd_u8),
+ MAP(v256_hadd_u8),
+ MAP(v256_dotp_s16),
+ MAP(v256_add_8),
+ MAP(v256_add_16),
+ MAP(v256_sadd_s16),
+ MAP(v256_add_32),
+ MAP(v256_sub_8),
+ MAP(v256_ssub_u8),
+ MAP(v256_ssub_s8),
+ MAP(v256_sub_16),
+ MAP(v256_ssub_u16),
+ MAP(v256_ssub_s16),
+ MAP(v256_sub_32),
+ MAP(v256_ziplo_8),
+ MAP(v256_ziphi_8),
+ MAP(v256_ziplo_16),
+ MAP(v256_ziphi_16),
+ MAP(v256_ziplo_32),
+ MAP(v256_ziphi_32),
+ MAP(v256_ziplo_64),
+ MAP(v256_ziphi_64),
+ MAP(v256_unziphi_8),
+ MAP(v256_unziplo_8),
+ MAP(v256_unziphi_16),
+ MAP(v256_unziplo_16),
+ MAP(v256_unziphi_32),
+ MAP(v256_unziplo_32),
+ MAP(v256_pack_s32_s16),
+ MAP(v256_pack_s16_u8),
+ MAP(v256_pack_s16_s8),
+ MAP(v256_or),
+ MAP(v256_xor),
+ MAP(v256_and),
+ MAP(v256_andn),
+ MAP(v256_mullo_s16),
+ MAP(v256_mulhi_s16),
+ MAP(v256_mullo_s32),
+ MAP(v256_madd_s16),
+ MAP(v256_madd_us8),
+ MAP(v256_avg_u8),
+ MAP(v256_rdavg_u8),
+ MAP(v256_avg_u16),
+ MAP(v256_min_u8),
+ MAP(v256_max_u8),
+ MAP(v256_min_s8),
+ MAP(v256_max_s8),
+ MAP(v256_min_s16),
+ MAP(v256_max_s16),
+ MAP(v256_cmpgt_s8),
+ MAP(v256_cmplt_s8),
+ MAP(v256_cmpeq_8),
+ MAP(v256_cmpgt_s16),
+ MAP(v256_cmplt_s16),
+ MAP(v256_cmpeq_16),
+ MAP(v256_shuffle_8),
+ MAP(v256_pshuffle_8),
+ MAP(imm_v256_align<1>),
+ MAP(imm_v256_align<2>),
+ MAP(imm_v256_align<3>),
+ MAP(imm_v256_align<4>),
+ MAP(imm_v256_align<5>),
+ MAP(imm_v256_align<6>),
+ MAP(imm_v256_align<7>),
+ MAP(imm_v256_align<8>),
+ MAP(imm_v256_align<9>),
+ MAP(imm_v256_align<10>),
+ MAP(imm_v256_align<11>),
+ MAP(imm_v256_align<12>),
+ MAP(imm_v256_align<13>),
+ MAP(imm_v256_align<14>),
+ MAP(imm_v256_align<15>),
+ MAP(imm_v256_align<16>),
+ MAP(imm_v256_align<17>),
+ MAP(imm_v256_align<18>),
+ MAP(imm_v256_align<19>),
+ MAP(imm_v256_align<20>),
+ MAP(imm_v256_align<21>),
+ MAP(imm_v256_align<22>),
+ MAP(imm_v256_align<23>),
+ MAP(imm_v256_align<24>),
+ MAP(imm_v256_align<25>),
+ MAP(imm_v256_align<26>),
+ MAP(imm_v256_align<27>),
+ MAP(imm_v256_align<28>),
+ MAP(imm_v256_align<29>),
+ MAP(imm_v256_align<30>),
+ MAP(imm_v256_align<31>),
+ MAP(v256_from_v128),
+ MAP(v256_zip_8),
+ MAP(v256_zip_16),
+ MAP(v256_zip_32),
+ MAP(v256_mul_s16),
+ MAP(v256_unpack_u8_s16),
+ MAP(v256_unpack_s8_s16),
+ MAP(v256_unpack_u16_s32),
+ MAP(v256_unpack_s16_s32),
+ MAP(v256_shl_8),
+ MAP(v256_shr_u8),
+ MAP(v256_shr_s8),
+ MAP(v256_shl_16),
+ MAP(v256_shr_u16),
+ MAP(v256_shr_s16),
+ MAP(v256_shl_32),
+ MAP(v256_shr_u32),
+ MAP(v256_shr_s32),
+ MAP(v256_abs_s8),
+ MAP(v256_abs_s16),
+ MAP(v256_padd_s16),
+ MAP(v256_unpacklo_u16_s32),
+ MAP(v256_unpacklo_s16_s32),
+ MAP(v256_unpackhi_u16_s32),
+ MAP(v256_unpackhi_s16_s32),
+ MAP(imm_v256_shr_n_byte<1>),
+ MAP(imm_v256_shr_n_byte<2>),
+ MAP(imm_v256_shr_n_byte<3>),
+ MAP(imm_v256_shr_n_byte<4>),
+ MAP(imm_v256_shr_n_byte<5>),
+ MAP(imm_v256_shr_n_byte<6>),
+ MAP(imm_v256_shr_n_byte<7>),
+ MAP(imm_v256_shr_n_byte<8>),
+ MAP(imm_v256_shr_n_byte<9>),
+ MAP(imm_v256_shr_n_byte<10>),
+ MAP(imm_v256_shr_n_byte<11>),
+ MAP(imm_v256_shr_n_byte<12>),
+ MAP(imm_v256_shr_n_byte<13>),
+ MAP(imm_v256_shr_n_byte<14>),
+ MAP(imm_v256_shr_n_byte<15>),
+ MAP(imm_v256_shr_n_byte<16>),
+ MAP(imm_v256_shr_n_byte<17>),
+ MAP(imm_v256_shr_n_byte<18>),
+ MAP(imm_v256_shr_n_byte<19>),
+ MAP(imm_v256_shr_n_byte<20>),
+ MAP(imm_v256_shr_n_byte<21>),
+ MAP(imm_v256_shr_n_byte<22>),
+ MAP(imm_v256_shr_n_byte<23>),
+ MAP(imm_v256_shr_n_byte<24>),
+ MAP(imm_v256_shr_n_byte<25>),
+ MAP(imm_v256_shr_n_byte<26>),
+ MAP(imm_v256_shr_n_byte<27>),
+ MAP(imm_v256_shr_n_byte<28>),
+ MAP(imm_v256_shr_n_byte<29>),
+ MAP(imm_v256_shr_n_byte<30>),
+ MAP(imm_v256_shr_n_byte<31>),
+ MAP(imm_v256_shl_n_byte<1>),
+ MAP(imm_v256_shl_n_byte<2>),
+ MAP(imm_v256_shl_n_byte<3>),
+ MAP(imm_v256_shl_n_byte<4>),
+ MAP(imm_v256_shl_n_byte<5>),
+ MAP(imm_v256_shl_n_byte<6>),
+ MAP(imm_v256_shl_n_byte<7>),
+ MAP(imm_v256_shl_n_byte<8>),
+ MAP(imm_v256_shl_n_byte<9>),
+ MAP(imm_v256_shl_n_byte<10>),
+ MAP(imm_v256_shl_n_byte<11>),
+ MAP(imm_v256_shl_n_byte<12>),
+ MAP(imm_v256_shl_n_byte<13>),
+ MAP(imm_v256_shl_n_byte<14>),
+ MAP(imm_v256_shl_n_byte<15>),
+ MAP(imm_v256_shl_n_byte<16>),
+ MAP(imm_v256_shl_n_byte<17>),
+ MAP(imm_v256_shl_n_byte<18>),
+ MAP(imm_v256_shl_n_byte<19>),
+ MAP(imm_v256_shl_n_byte<20>),
+ MAP(imm_v256_shl_n_byte<21>),
+ MAP(imm_v256_shl_n_byte<22>),
+ MAP(imm_v256_shl_n_byte<23>),
+ MAP(imm_v256_shl_n_byte<24>),
+ MAP(imm_v256_shl_n_byte<25>),
+ MAP(imm_v256_shl_n_byte<26>),
+ MAP(imm_v256_shl_n_byte<27>),
+ MAP(imm_v256_shl_n_byte<28>),
+ MAP(imm_v256_shl_n_byte<29>),
+ MAP(imm_v256_shl_n_byte<30>),
+ MAP(imm_v256_shl_n_byte<31>),
+ MAP(imm_v256_shl_n_8<1>),
+ MAP(imm_v256_shl_n_8<2>),
+ MAP(imm_v256_shl_n_8<3>),
+ MAP(imm_v256_shl_n_8<4>),
+ MAP(imm_v256_shl_n_8<5>),
+ MAP(imm_v256_shl_n_8<6>),
+ MAP(imm_v256_shl_n_8<7>),
+ MAP(imm_v256_shr_n_u8<1>),
+ MAP(imm_v256_shr_n_u8<2>),
+ MAP(imm_v256_shr_n_u8<3>),
+ MAP(imm_v256_shr_n_u8<4>),
+ MAP(imm_v256_shr_n_u8<5>),
+ MAP(imm_v256_shr_n_u8<6>),
+ MAP(imm_v256_shr_n_u8<7>),
+ MAP(imm_v256_shr_n_s8<1>),
+ MAP(imm_v256_shr_n_s8<2>),
+ MAP(imm_v256_shr_n_s8<3>),
+ MAP(imm_v256_shr_n_s8<4>),
+ MAP(imm_v256_shr_n_s8<5>),
+ MAP(imm_v256_shr_n_s8<6>),
+ MAP(imm_v256_shr_n_s8<7>),
+ MAP(imm_v256_shl_n_16<1>),
+ MAP(imm_v256_shl_n_16<2>),
+ MAP(imm_v256_shl_n_16<4>),
+ MAP(imm_v256_shl_n_16<6>),
+ MAP(imm_v256_shl_n_16<8>),
+ MAP(imm_v256_shl_n_16<10>),
+ MAP(imm_v256_shl_n_16<12>),
+ MAP(imm_v256_shl_n_16<14>),
+ MAP(imm_v256_shr_n_u16<1>),
+ MAP(imm_v256_shr_n_u16<2>),
+ MAP(imm_v256_shr_n_u16<4>),
+ MAP(imm_v256_shr_n_u16<6>),
+ MAP(imm_v256_shr_n_u16<8>),
+ MAP(imm_v256_shr_n_u16<10>),
+ MAP(imm_v256_shr_n_u16<12>),
+ MAP(imm_v256_shr_n_u16<14>),
+ MAP(imm_v256_shr_n_s16<1>),
+ MAP(imm_v256_shr_n_s16<2>),
+ MAP(imm_v256_shr_n_s16<4>),
+ MAP(imm_v256_shr_n_s16<6>),
+ MAP(imm_v256_shr_n_s16<8>),
+ MAP(imm_v256_shr_n_s16<10>),
+ MAP(imm_v256_shr_n_s16<12>),
+ MAP(imm_v256_shr_n_s16<14>),
+ MAP(imm_v256_shl_n_32<1>),
+ MAP(imm_v256_shl_n_32<4>),
+ MAP(imm_v256_shl_n_32<8>),
+ MAP(imm_v256_shl_n_32<12>),
+ MAP(imm_v256_shl_n_32<16>),
+ MAP(imm_v256_shl_n_32<20>),
+ MAP(imm_v256_shl_n_32<24>),
+ MAP(imm_v256_shl_n_32<28>),
+ MAP(imm_v256_shr_n_u32<1>),
+ MAP(imm_v256_shr_n_u32<4>),
+ MAP(imm_v256_shr_n_u32<8>),
+ MAP(imm_v256_shr_n_u32<12>),
+ MAP(imm_v256_shr_n_u32<16>),
+ MAP(imm_v256_shr_n_u32<20>),
+ MAP(imm_v256_shr_n_u32<24>),
+ MAP(imm_v256_shr_n_u32<28>),
+ MAP(imm_v256_shr_n_s32<1>),
+ MAP(imm_v256_shr_n_s32<4>),
+ MAP(imm_v256_shr_n_s32<8>),
+ MAP(imm_v256_shr_n_s32<12>),
+ MAP(imm_v256_shr_n_s32<16>),
+ MAP(imm_v256_shr_n_s32<20>),
+ MAP(imm_v256_shr_n_s32<24>),
+ MAP(imm_v256_shr_n_s32<28>),
+ MAP(v256_zero),
+ MAP(v256_dup_8),
+ MAP(v256_dup_16),
+ MAP(v256_dup_32),
+ MAP(v256_low_u32),
+ MAP(v256_low_v64),
+ MAP(v256_from_64),
+ MAP(v256_from_v64),
+ MAP(v256_ziplo_128),
+ MAP(v256_ziphi_128),
+ MAP(v256_unpacklo_u8_s16),
+ MAP(v256_unpackhi_u8_s16),
+ MAP(v256_unpacklo_s8_s16),
+ MAP(v256_unpackhi_s8_s16),
{ NULL, NULL, NULL } };
#undef MAP
@@ -922,6 +1291,14 @@ void TestSimd1Arg(uint32_t iterations, uint32_t mask, uint32_t maskwidth,
reinterpret_cast<fptr>(v128_load_aligned), simd, d,
reinterpret_cast<fptr>(c_u64_store_aligned),
reinterpret_cast<fptr>(c_v128_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(uint64_t) &&
+ typeid(CArg) == typeid(c_v256)) {
+ // U64_V256
+ error = CompareSimd1Arg<uint64_t, v256, CRet, CArg>(
+ reinterpret_cast<fptr>(u64_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_u64_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned), ref_simd, ref_d, s);
} else if (typeid(CRet) == typeid(c_v64) &&
typeid(CArg) == typeid(c_v128)) {
// V64_V128
@@ -970,6 +1347,62 @@ void TestSimd1Arg(uint32_t iterations, uint32_t mask, uint32_t maskwidth,
reinterpret_cast<fptr>(u32_load_aligned), simd, d,
reinterpret_cast<fptr>(c_v128_store_aligned),
reinterpret_cast<fptr>(c_u32_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg) == typeid(c_v256)) {
+ // V256_V256
+ error = CompareSimd1Arg<v256, v256, CRet, CArg>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg) == typeid(c_v128)) {
+ // V256_V128
+ error = CompareSimd1Arg<v256, v128, CRet, CArg>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(v128_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_v128_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg) == typeid(uint8_t)) {
+ // V256_U8
+ error = CompareSimd1Arg<v256, uint8_t, CRet, CArg>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(u8_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_u8_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg) == typeid(uint16_t)) {
+ // V256_U16
+ error = CompareSimd1Arg<v256, uint16_t, CRet, CArg>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(u16_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_u16_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg) == typeid(uint32_t)) {
+ // V256_U32
+ error = CompareSimd1Arg<v256, uint32_t, CRet, CArg>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(u32_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_u32_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(uint32_t) &&
+ typeid(CArg) == typeid(c_v256)) {
+ // U32_V256
+ error = CompareSimd1Arg<uint32_t, v256, CRet, CArg>(
+ reinterpret_cast<fptr>(u32_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_u32_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned), ref_simd, ref_d, s);
+ } else if (typeid(CRet) == typeid(c_v64) &&
+ typeid(CArg) == typeid(c_v256)) {
+ // V64_V256
+ error = CompareSimd1Arg<v64, v256, CRet, CArg>(
+ reinterpret_cast<fptr>(v64_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v64_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned), ref_simd, ref_d, s);
} else {
FAIL() << "Internal error: Unknown intrinsic function "
<< typeid(CRet).name() << " " << name << "(" << typeid(CArg).name()
@@ -1140,6 +1573,67 @@ void TestSimd2Args(uint32_t iterations, uint32_t mask, uint32_t maskwidth,
reinterpret_cast<fptr>(c_v128_load_aligned),
reinterpret_cast<fptr>(c_u32_load_aligned),
reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg1) == typeid(c_v256) &&
+ typeid(CArg2) == typeid(c_v256)) {
+ // V256_V256V256
+ error = CompareSimd2Args<v256, v256, v256, CRet, CArg1, CArg2>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+ } else if (typeid(CRet) == typeid(int64_t) &&
+ typeid(CArg1) == typeid(c_v256) &&
+ typeid(CArg2) == typeid(c_v256)) {
+ // S64_V256V256
+ error = CompareSimd2Args<int64_t, v256, v256, CRet, CArg1, CArg2>(
+ reinterpret_cast<fptr>(u64_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_u64_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+ } else if (typeid(CRet) == typeid(uint32_t) &&
+ typeid(CArg1) == typeid(c_v256) &&
+ typeid(CArg2) == typeid(c_v256)) {
+ // U32_V256V256
+ error = CompareSimd2Args<uint32_t, v256, v256, CRet, CArg1, CArg2>(
+ reinterpret_cast<fptr>(u32_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_u32_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg1) == typeid(c_v128) &&
+ typeid(CArg2) == typeid(c_v128)) {
+ // V256_V128V128
+ error = CompareSimd2Args<v256, v128, v128, CRet, CArg1, CArg2>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(v128_load_aligned),
+ reinterpret_cast<fptr>(v128_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_v128_load_aligned),
+ reinterpret_cast<fptr>(c_v128_load_aligned),
+ reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+ } else if (typeid(CRet) == typeid(c_v256) &&
+ typeid(CArg1) == typeid(c_v256) &&
+ typeid(CArg2) == typeid(uint32_t)) {
+ // V256_V256U32
+ error = CompareSimd2Args<v256, v256, uint32_t, CRet, CArg1, CArg2>(
+ reinterpret_cast<fptr>(v256_store_aligned),
+ reinterpret_cast<fptr>(v256_load_aligned),
+ reinterpret_cast<fptr>(u32_load_aligned), simd, d,
+ reinterpret_cast<fptr>(c_v256_store_aligned),
+ reinterpret_cast<fptr>(c_v256_load_aligned),
+ reinterpret_cast<fptr>(c_u32_load_aligned),
+ reinterpret_cast<fptr>(ref_simd), ref_d, s1, s2);
+
} else {
FAIL() << "Internal error: Unknown intrinsic function "
<< typeid(CRet).name() << " " << name << "("
@@ -1208,5 +1702,31 @@ template void TestSimd2Args<int64_t, c_v128, c_v128>(uint32_t, uint32_t,
uint32_t, const char *);
template void TestSimd2Args<uint32_t, c_v128, c_v128>(uint32_t, uint32_t,
uint32_t, const char *);
+template void TestSimd1Arg<c_v256, c_v128>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<c_v256, c_v256>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<uint64_t, c_v256>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<c_v256, uint8_t>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<c_v256, uint16_t>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<c_v256, uint32_t>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<uint32_t, c_v256>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd1Arg<c_v64, c_v256>(uint32_t, uint32_t, uint32_t,
+ const char *);
+template void TestSimd2Args<c_v256, c_v128, c_v128>(uint32_t, uint32_t,
+ uint32_t, const char *);
+template void TestSimd2Args<c_v256, c_v256, c_v256>(uint32_t, uint32_t,
+ uint32_t, const char *);
+template void TestSimd2Args<c_v256, c_v256, uint32_t>(uint32_t, uint32_t,
+ uint32_t, const char *);
+template void TestSimd2Args<int64_t, c_v256, c_v256>(uint32_t, uint32_t,
+ uint32_t, const char *);
+template void TestSimd2Args<uint32_t, c_v256, c_v256>(uint32_t, uint32_t,
+ uint32_t, const char *);
} // namespace SIMD_NAMESPACE
diff --git a/third_party/aom/test/simd_impl.h b/third_party/aom/test/simd_impl.h
index 5cfda675d..c3dfbc400 100644
--- a/third_party/aom/test/simd_impl.h
+++ b/third_party/aom/test/simd_impl.h
@@ -14,7 +14,7 @@
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "aom_dsp/aom_simd_inline.h"
-#include "aom_dsp/simd/v128_intrinsics_c.h"
+#include "aom_dsp/simd/v256_intrinsics_c.h"
namespace SIMD_NAMESPACE {
@@ -67,6 +67,19 @@ TYPEDEF_SIMD(V128_V128V128);
TYPEDEF_SIMD(S64_V128V128);
TYPEDEF_SIMD(V128_V128U32);
TYPEDEF_SIMD(U32_V128V128);
+TYPEDEF_SIMD(V256_V128);
+TYPEDEF_SIMD(V256_V256);
+TYPEDEF_SIMD(U64_V256);
+TYPEDEF_SIMD(V256_V128V128);
+TYPEDEF_SIMD(V256_V256V256);
+TYPEDEF_SIMD(S64_V256V256);
+TYPEDEF_SIMD(V256_V256U32);
+TYPEDEF_SIMD(U32_V256V256);
+TYPEDEF_SIMD(V256_U8);
+TYPEDEF_SIMD(V256_U16);
+TYPEDEF_SIMD(V256_U32);
+TYPEDEF_SIMD(U32_V256);
+TYPEDEF_SIMD(V64_V256);
// Google Test allows up to 50 tests per case, so split the largest
typedef ARCH_POSTFIX(V64_V64) ARCH_POSTFIX(V64_V64_Part2);
@@ -74,6 +87,9 @@ typedef ARCH_POSTFIX(V64_V64V64) ARCH_POSTFIX(V64_V64V64_Part2);
typedef ARCH_POSTFIX(V128_V128) ARCH_POSTFIX(V128_V128_Part2);
typedef ARCH_POSTFIX(V128_V128) ARCH_POSTFIX(V128_V128_Part3);
typedef ARCH_POSTFIX(V128_V128V128) ARCH_POSTFIX(V128_V128V128_Part2);
+typedef ARCH_POSTFIX(V256_V256) ARCH_POSTFIX(V256_V256_Part2);
+typedef ARCH_POSTFIX(V256_V256) ARCH_POSTFIX(V256_V256_Part3);
+typedef ARCH_POSTFIX(V256_V256V256) ARCH_POSTFIX(V256_V256V256_Part2);
// These functions are machine tuned located elsewhere
template <typename c_ret, typename c_arg>
@@ -219,6 +235,70 @@ MY_TEST_P(ARCH_POSTFIX(V128_V128_Part3), TestIntrinsics) {
TestSimd1Arg<c_v128, c_v128>(kIterations, mask, maskwidth, name);
}
+MY_TEST_P(ARCH_POSTFIX(U64_V256), TestIntrinsics) {
+ TestSimd1Arg<uint64_t, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256), TestIntrinsics) {
+ TestSimd1Arg<c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V128), TestIntrinsics) {
+ TestSimd1Arg<c_v256, c_v128>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256V256), TestIntrinsics) {
+ TestSimd2Args<c_v256, c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V128V128), TestIntrinsics) {
+ TestSimd2Args<c_v256, c_v128, c_v128>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(U32_V256V256), TestIntrinsics) {
+ TestSimd2Args<uint32_t, c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(S64_V256V256), TestIntrinsics) {
+ TestSimd2Args<int64_t, c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256V256_Part2), TestIntrinsics) {
+ TestSimd2Args<c_v256, c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256U32), TestIntrinsics) {
+ TestSimd2Args<c_v256, c_v256, uint32_t>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256_Part2), TestIntrinsics) {
+ TestSimd1Arg<c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_V256_Part3), TestIntrinsics) {
+ TestSimd1Arg<c_v256, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_U8), TestIntrinsics) {
+ TestSimd1Arg<c_v256, uint8_t>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_U16), TestIntrinsics) {
+ TestSimd1Arg<c_v256, uint16_t>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V256_U32), TestIntrinsics) {
+ TestSimd1Arg<c_v256, uint32_t>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(U32_V256), TestIntrinsics) {
+ TestSimd1Arg<uint32_t, c_v256>(kIterations, mask, maskwidth, name);
+}
+
+MY_TEST_P(ARCH_POSTFIX(V64_V256), TestIntrinsics) {
+ TestSimd1Arg<c_v64, c_v256>(kIterations, mask, maskwidth, name);
+}
+
// Add a macro layer since INSTANTIATE_TEST_CASE_P will quote the name
// so we need to expand it first with the prefix
#define INSTANTIATE(name, type, ...) \
@@ -591,4 +671,252 @@ INSTANTIATE(ARCH, ARCH_POSTFIX(V128_U32), SIMD_TUPLE(v128_dup_32, 0U, 0U));
INSTANTIATE(ARCH, ARCH_POSTFIX(S64_V128V128),
SIMD_TUPLE(v128_dotp_s16, 0U, 0U));
+INSTANTIATE(ARCH, ARCH_POSTFIX(U32_V256V256), SIMD_TUPLE(v256_sad_u8, 0U, 0U),
+ SIMD_TUPLE(v256_ssd_u8, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(U64_V256), SIMD_TUPLE(v256_hadd_u8, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(S64_V256V256),
+ SIMD_TUPLE(v256_dotp_s16, 0U, 0U));
+
+INSTANTIATE(
+ ARCH, ARCH_POSTFIX(V256_V256V256), SIMD_TUPLE(v256_add_8, 0U, 0U),
+ SIMD_TUPLE(v256_add_16, 0U, 0U), SIMD_TUPLE(v256_sadd_s16, 0U, 0U),
+ SIMD_TUPLE(v256_add_32, 0U, 0U), SIMD_TUPLE(v256_sub_8, 0U, 0U),
+ SIMD_TUPLE(v256_ssub_u8, 0U, 0U), SIMD_TUPLE(v256_ssub_s8, 0U, 0U),
+ SIMD_TUPLE(v256_sub_16, 0U, 0U), SIMD_TUPLE(v256_ssub_s16, 0U, 0U),
+ SIMD_TUPLE(v256_ssub_u16, 0U, 0U), SIMD_TUPLE(v256_sub_32, 0U, 0U),
+ SIMD_TUPLE(v256_ziplo_8, 0U, 0U), SIMD_TUPLE(v256_ziphi_8, 0U, 0U),
+ SIMD_TUPLE(v256_ziplo_16, 0U, 0U), SIMD_TUPLE(v256_ziphi_16, 0U, 0U),
+ SIMD_TUPLE(v256_ziplo_32, 0U, 0U), SIMD_TUPLE(v256_ziphi_32, 0U, 0U),
+ SIMD_TUPLE(v256_ziplo_64, 0U, 0U), SIMD_TUPLE(v256_ziphi_64, 0U, 0U),
+ SIMD_TUPLE(v256_ziplo_128, 0U, 0U), SIMD_TUPLE(v256_ziphi_128, 0U, 0U),
+ SIMD_TUPLE(v256_unziphi_8, 0U, 0U), SIMD_TUPLE(v256_unziplo_8, 0U, 0U),
+ SIMD_TUPLE(v256_unziphi_16, 0U, 0U), SIMD_TUPLE(v256_unziplo_16, 0U, 0U),
+ SIMD_TUPLE(v256_unziphi_32, 0U, 0U), SIMD_TUPLE(v256_unziplo_32, 0U, 0U),
+ SIMD_TUPLE(v256_pack_s32_s16, 0U, 0U), SIMD_TUPLE(v256_pack_s16_u8, 0U, 0U),
+ SIMD_TUPLE(v256_pack_s16_s8, 0U, 0U), SIMD_TUPLE(v256_or, 0U, 0U),
+ SIMD_TUPLE(v256_xor, 0U, 0U), SIMD_TUPLE(v256_and, 0U, 0U),
+ SIMD_TUPLE(v256_andn, 0U, 0U), SIMD_TUPLE(v256_mullo_s16, 0U, 0U),
+ SIMD_TUPLE(v256_mulhi_s16, 0U, 0U), SIMD_TUPLE(v256_mullo_s32, 0U, 0U),
+ SIMD_TUPLE(v256_madd_s16, 0U, 0U), SIMD_TUPLE(v256_madd_us8, 0U, 0U),
+ SIMD_TUPLE(v256_avg_u8, 0U, 0U), SIMD_TUPLE(v256_rdavg_u8, 0U, 0U),
+ SIMD_TUPLE(v256_avg_u16, 0U, 0U), SIMD_TUPLE(v256_min_u8, 0U, 0U),
+ SIMD_TUPLE(v256_max_u8, 0U, 0U), SIMD_TUPLE(v256_min_s8, 0U, 0U),
+ SIMD_TUPLE(v256_max_s8, 0U, 0U), SIMD_TUPLE(v256_min_s16, 0U, 0U),
+ SIMD_TUPLE(v256_max_s16, 0U, 0U), SIMD_TUPLE(v256_cmpgt_s8, 0U, 0U),
+ SIMD_TUPLE(v256_cmplt_s8, 0U, 0U));
+
+INSTANTIATE(
+ ARCH, ARCH_POSTFIX(V256_V256V256_Part2), SIMD_TUPLE(v256_cmpeq_8, 0U, 0U),
+ SIMD_TUPLE(v256_cmpgt_s16, 0U, 0U), SIMD_TUPLE(v256_cmplt_s16, 0U, 0U),
+ SIMD_TUPLE(v256_cmpeq_16, 0U, 0U), SIMD_TUPLE(v256_shuffle_8, 15U, 8U),
+ SIMD_TUPLE(v256_pshuffle_8, 15U, 8U), SIMD_TUPLE(imm_v256_align<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<9>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<10>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<11>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<13>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<15>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<17>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<18>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<19>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<21>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<22>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<23>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<25>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<26>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<27>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<28>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<29>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<30>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_align<31>, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V128V128),
+ SIMD_TUPLE(v256_from_v128, 0U, 0U), SIMD_TUPLE(v256_zip_8, 0U, 0U),
+ SIMD_TUPLE(v256_zip_16, 0U, 0U), SIMD_TUPLE(v256_zip_32, 0U, 0U),
+ SIMD_TUPLE(v256_mul_s16, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V128),
+ SIMD_TUPLE(v256_unpack_u8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpack_s8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpack_u16_s32, 0U, 0U),
+ SIMD_TUPLE(v256_unpack_s16_s32, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V256U32), SIMD_TUPLE(v256_shl_8, 7U, 32U),
+ SIMD_TUPLE(v256_shr_u8, 7U, 32U), SIMD_TUPLE(v256_shr_s8, 7U, 32U),
+ SIMD_TUPLE(v256_shl_16, 15U, 32U),
+ SIMD_TUPLE(v256_shr_u16, 15U, 32U),
+ SIMD_TUPLE(v256_shr_s16, 15U, 32U),
+ SIMD_TUPLE(v256_shl_32, 31U, 32U),
+ SIMD_TUPLE(v256_shr_u32, 31U, 32U),
+ SIMD_TUPLE(v256_shr_s32, 31U, 32U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V256), SIMD_TUPLE(v256_abs_s8, 0U, 0U),
+ SIMD_TUPLE(v256_abs_s16, 0U, 0U), SIMD_TUPLE(v256_padd_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpacklo_u8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpacklo_s8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpacklo_u16_s32, 0U, 0U),
+ SIMD_TUPLE(v256_unpacklo_s16_s32, 0U, 0U),
+ SIMD_TUPLE(v256_unpackhi_u8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpackhi_s8_s16, 0U, 0U),
+ SIMD_TUPLE(v256_unpackhi_u16_s32, 0U, 0U),
+ SIMD_TUPLE(v256_unpackhi_s16_s32, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<9>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<10>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<11>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<13>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<15>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<17>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<18>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<19>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<21>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<22>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<23>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<25>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<26>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<27>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<28>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<29>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<30>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_byte<31>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<8>, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V256_Part2),
+ SIMD_TUPLE(imm_v256_shl_n_byte<9>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<10>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<11>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<13>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<15>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<17>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<18>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<19>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<21>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<22>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<23>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<25>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<26>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<27>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<28>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<29>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<30>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_byte<31>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_8<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u8<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<3>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<5>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s8<7>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<10>, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_V256_Part3),
+ SIMD_TUPLE(imm_v256_shl_n_16<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_16<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<10>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u16<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<2>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<6>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<10>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s16<14>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shl_n_32<28>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_u32<28>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<1>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<4>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<8>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<12>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<16>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<20>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<24>, 0U, 0U),
+ SIMD_TUPLE(imm_v256_shr_n_s32<28>, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_U8), SIMD_TUPLE(v256_dup_8, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_U16), SIMD_TUPLE(v256_dup_16, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V256_U32), SIMD_TUPLE(v256_dup_32, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(U32_V256), SIMD_TUPLE(v256_low_u32, 0U, 0U));
+
+INSTANTIATE(ARCH, ARCH_POSTFIX(V64_V256), SIMD_TUPLE(v256_low_v64, 0U, 0U));
+
} // namespace SIMD_NAMESPACE
diff --git a/third_party/aom/test/superframe_test.cc b/third_party/aom/test/superframe_test.cc
index 0f54baeaf..a28d35d5f 100644
--- a/third_party/aom/test/superframe_test.cc
+++ b/third_party/aom/test/superframe_test.cc
@@ -119,23 +119,12 @@ TEST_P(SuperframeTest, TestSuperframeIndexIsOptional) {
// to the decoder starting at the end of the buffer.
#if CONFIG_EXT_TILE
// Single tile does not work with ANS (see comment above).
-#if CONFIG_ANS || CONFIG_DAALA_EC
const int tile_col_values[] = { 1, 2 };
-#else
-const int tile_col_values[] = { 1, 2, 32 };
-#endif
const int tile_row_values[] = { 1, 2, 32 };
AV1_INSTANTIATE_TEST_CASE(
SuperframeTest,
::testing::Combine(::testing::Values(::libaom_test::kTwoPassGood),
::testing::ValuesIn(tile_col_values),
::testing::ValuesIn(tile_row_values)));
-#else
-#if !CONFIG_ANS && !CONFIG_DAALA_EC
-AV1_INSTANTIATE_TEST_CASE(
- SuperframeTest,
- ::testing::Combine(::testing::Values(::libaom_test::kTwoPassGood),
- ::testing::Values(0), ::testing::Values(0)));
-#endif // !CONFIG_ANS
#endif // CONFIG_EXT_TILE
} // namespace
diff --git a/third_party/aom/test/test-data.mk b/third_party/aom/test/test-data.mk
index 168144a00..083b34953 100644
--- a/third_party/aom/test/test-data.mk
+++ b/third_party/aom/test/test-data.mk
@@ -1,22 +1,22 @@
LIBAOM_TEST_SRCS-yes += test-data.mk
# Encoder test source
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += hantro_collage_w352h288.yuv
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += hantro_odd.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += hantro_collage_w352h288.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += hantro_odd.yuv
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_10_420.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_10_422.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_10_444.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_10_440.yuv
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_12_420.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_12_422.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_12_444.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_12_440.yuv
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_420_a10-1.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_420.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_422.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_444.y4m
-LIBAOM_TEST_DATA-$(CONFIG_ENCODERS) += park_joy_90p_8_440.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_10_420.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_10_422.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_10_444.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_10_440.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_12_420.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_12_422.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_12_444.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_12_440.yuv
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_8_420_a10-1.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_8_420.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_8_422.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_8_444.y4m
+LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += park_joy_90p_8_440.yuv
LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += desktop_credits.y4m
LIBAOM_TEST_DATA-$(CONFIG_AV1_ENCODER) += niklas_1280_720_30.y4m
diff --git a/third_party/aom/test/test.cmake b/third_party/aom/test/test.cmake
index 8d3ab7059..d72a784ad 100644
--- a/third_party/aom/test/test.cmake
+++ b/third_party/aom/test/test.cmake
@@ -8,8 +8,15 @@
## 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.
##
+if (NOT AOM_TEST_TEST_CMAKE_)
+set(AOM_TEST_TEST_CMAKE_ 1)
+
+include(ProcessorCount)
+
include("${AOM_ROOT}/test/test_data_util.cmake")
+set(AOM_UNIT_TEST_DATA_LIST_FILE "${AOM_ROOT}/test/test-data.sha1")
+
set(AOM_UNIT_TEST_WRAPPER_SOURCES
"${AOM_CONFIG_DIR}/usage_exit.c"
"${AOM_ROOT}/test/test_libaom.cc")
@@ -19,6 +26,8 @@ set(AOM_UNIT_TEST_COMMON_SOURCES
"${AOM_ROOT}/test/clear_system_state.h"
"${AOM_ROOT}/test/codec_factory.h"
"${AOM_ROOT}/test/convolve_test.cc"
+ "${AOM_ROOT}/test/decode_test_driver.cc"
+ "${AOM_ROOT}/test/decode_test_driver.h"
"${AOM_ROOT}/test/function_equivalence_test.h"
"${AOM_ROOT}/test/md5_helper.h"
"${AOM_ROOT}/test/register_state_check.h"
@@ -50,8 +59,6 @@ endif ()
set(AOM_UNIT_TEST_DECODER_SOURCES
"${AOM_ROOT}/test/decode_api_test.cc"
- "${AOM_ROOT}/test/decode_test_driver.cc"
- "${AOM_ROOT}/test/decode_test_driver.h"
"${AOM_ROOT}/test/ivf_video_source.h")
set(AOM_UNIT_TEST_ENCODER_SOURCES
@@ -83,10 +90,6 @@ if (CONFIG_AV1)
${AOM_UNIT_TEST_COMMON_SOURCES}
"${AOM_ROOT}/test/av1_convolve_optimz_test.cc"
"${AOM_ROOT}/test/av1_convolve_test.cc"
- "${AOM_ROOT}/test/av1_fwd_txfm1d_test.cc"
- "${AOM_ROOT}/test/av1_fwd_txfm2d_test.cc"
- "${AOM_ROOT}/test/av1_inv_txfm1d_test.cc"
- "${AOM_ROOT}/test/av1_inv_txfm2d_test.cc"
"${AOM_ROOT}/test/av1_txfm_test.cc"
"${AOM_ROOT}/test/av1_txfm_test.h"
"${AOM_ROOT}/test/intrapred_test.cc"
@@ -103,9 +106,7 @@ if (CONFIG_AV1)
if (HAVE_SSE4_1)
set(AOM_UNIT_TEST_COMMON_SOURCES
${AOM_UNIT_TEST_COMMON_SOURCES}
- # TODO: not sure if this intrinsics or a wrapper calling intrin/asm.
- #"${AOM_ROOT}/test/filterintra_predictors_test.cc")
- )
+ "${AOM_ROOT}/test/filterintra_predictors_test.cc")
endif ()
endif ()
@@ -131,8 +132,13 @@ if (CONFIG_AV1_ENCODER)
"${AOM_ROOT}/test/arf_freq_test.cc"
"${AOM_ROOT}/test/av1_dct_test.cc"
"${AOM_ROOT}/test/av1_fht16x16_test.cc"
+ "${AOM_ROOT}/test/av1_fht32x32_test.cc"
"${AOM_ROOT}/test/av1_fht8x8_test.cc"
"${AOM_ROOT}/test/av1_inv_txfm_test.cc"
+ "${AOM_ROOT}/test/av1_fwd_txfm1d_test.cc"
+ "${AOM_ROOT}/test/av1_fwd_txfm2d_test.cc"
+ "${AOM_ROOT}/test/av1_inv_txfm1d_test.cc"
+ "${AOM_ROOT}/test/av1_inv_txfm2d_test.cc"
"${AOM_ROOT}/test/avg_test.cc"
"${AOM_ROOT}/test/blend_a64_mask_1d_test.cc"
"${AOM_ROOT}/test/blend_a64_mask_test.cc"
@@ -167,8 +173,14 @@ if (CONFIG_AV1_ENCODER)
"${AOM_ROOT}/test/av1_fht4x4_test.cc"
"${AOM_ROOT}/test/av1_fht4x8_test.cc"
"${AOM_ROOT}/test/av1_fht8x16_test.cc"
- "${AOM_ROOT}/test/av1_fht8x4_test.cc"
- "${AOM_ROOT}/test/fht32x32_test.cc")
+ "${AOM_ROOT}/test/av1_fht8x4_test.cc")
+
+ endif ()
+
+ if (CONFIG_GLOBAL_MOTION)
+ set(AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1
+ ${AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1}
+ "${AOM_ROOT}/test/corner_match_test.cc")
endif ()
if (CONFIG_MOTION_VAR)
@@ -177,6 +189,12 @@ if (CONFIG_AV1_ENCODER)
"${AOM_ROOT}/test/obmc_sad_test.cc"
"${AOM_ROOT}/test/obmc_variance_test.cc")
endif ()
+
+ if (CONFIG_TX64X64)
+ set(AOM_UNIT_TEST_ENCODER_SOURCES
+ ${AOM_UNIT_TEST_ENCODER_SOURCES}
+ "${AOM_ROOT}/test/av1_fht64x64_test.cc")
+ endif ()
endif ()
if (CONFIG_AV1_DECODER AND CONFIG_AV1_ENCODER)
@@ -209,7 +227,7 @@ if (CONFIG_AV1_DECODER AND CONFIG_AV1_ENCODER)
endif ()
if (CONFIG_HIGHBITDEPTH)
- if (CONFIG_AV1)
+ if (CONFIG_AV1_ENCODER)
set(AOM_UNIT_TEST_COMMON_INTRIN_SSE4_1
${AOM_UNIT_TEST_COMMON_INTRIN_SSE4_1}
"${AOM_ROOT}/test/av1_highbd_iht_test.cc"
@@ -245,8 +263,14 @@ endif ()
# exist before this function is called.
function (setup_aom_test_targets)
add_library(test_aom_common OBJECT ${AOM_UNIT_TEST_COMMON_SOURCES})
- add_library(test_aom_decoder OBJECT ${AOM_UNIT_TEST_DECODER_SOURCES})
- add_library(test_aom_encoder OBJECT ${AOM_UNIT_TEST_ENCODER_SOURCES})
+
+ if (CONFIG_AV1_DECODER)
+ add_library(test_aom_decoder OBJECT ${AOM_UNIT_TEST_DECODER_SOURCES})
+ endif ()
+
+ if (CONFIG_AV1_ENCODER)
+ add_library(test_aom_encoder OBJECT ${AOM_UNIT_TEST_ENCODER_SOURCES})
+ endif ()
set(AOM_LIB_TARGETS ${AOM_LIB_TARGETS} test_aom_common test_aom_decoder
test_aom_encoder PARENT_SCOPE)
@@ -255,7 +279,7 @@ function (setup_aom_test_targets)
$<TARGET_OBJECTS:aom_common_app_util>
$<TARGET_OBJECTS:test_aom_common>)
- if (CONFIG_DECODERS)
+ if (CONFIG_AV1_DECODER)
target_sources(test_libaom PUBLIC
$<TARGET_OBJECTS:aom_decoder_app_util>
$<TARGET_OBJECTS:test_aom_decoder>)
@@ -265,7 +289,7 @@ function (setup_aom_test_targets)
endif ()
endif ()
- if (CONFIG_ENCODERS)
+ if (CONFIG_AV1_ENCODER)
target_sources(test_libaom PUBLIC
$<TARGET_OBJECTS:test_aom_encoder>
$<TARGET_OBJECTS:aom_encoder_app_util>)
@@ -273,14 +297,14 @@ function (setup_aom_test_targets)
if (CONFIG_ENCODE_PERF_TESTS)
target_sources(test_libaom PUBLIC ${AOM_ENCODE_PERF_TEST_SOURCES})
endif ()
- endif ()
- target_link_libraries(test_libaom PUBLIC aom gtest)
+ add_executable(test_intra_pred_speed
+ ${AOM_TEST_INTRA_PRED_SPEED_SOURCES}
+ $<TARGET_OBJECTS:aom_common_app_util>)
+ target_link_libraries(test_intra_pred_speed ${AOM_LIB_LINK_TYPE} aom gtest)
+ endif ()
- add_executable(test_intra_pred_speed
- ${AOM_TEST_INTRA_PRED_SPEED_SOURCES}
- $<TARGET_OBJECTS:aom_common_app_util>)
- target_link_libraries(test_intra_pred_speed PUBLIC aom gtest)
+ target_link_libraries(test_libaom ${AOM_LIB_LINK_TYPE} aom gtest)
if (CONFIG_LIBYUV)
target_sources(test_libaom PUBLIC $<TARGET_OBJECTS:yuv>)
@@ -300,16 +324,73 @@ function (setup_aom_test_targets)
if (HAVE_SSE4_1)
add_intrinsics_source_to_target("-msse4.1" "test_libaom"
"AOM_UNIT_TEST_COMMON_INTRIN_SSE4_1")
+ if (CONFIG_AV1_ENCODER)
+ if (AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1)
+ add_intrinsics_source_to_target("-msse4.1" "test_libaom"
+ "AOM_UNIT_TEST_ENCODER_INTRIN_SSE4_1")
+ endif ()
+ endif ()
endif ()
if (HAVE_NEON)
add_intrinsics_source_to_target("${AOM_NEON_INTRIN_FLAG}" "test_libaom"
"AOM_UNIT_TEST_COMMON_INTRIN_NEON")
endif ()
- add_custom_target(testdata
- COMMAND ${CMAKE_COMMAND}
- -DAOM_CONFIG_DIR="${AOM_CONFIG_DIR}"
- -DAOM_ROOT="${AOM_ROOT}"
- -P "${AOM_ROOT}/test/test_worker.cmake"
- SOURCES ${AOM_TEST_DATA_LIST})
+ make_test_data_lists("${AOM_UNIT_TEST_DATA_LIST_FILE}"
+ test_files test_file_checksums)
+ list(LENGTH test_files num_test_files)
+ list(LENGTH test_file_checksums num_test_file_checksums)
+
+ math(EXPR max_file_index "${num_test_files} - 1")
+ foreach (test_index RANGE ${max_file_index})
+ list(GET test_files ${test_index} test_file)
+ list(GET test_file_checksums ${test_index} test_file_checksum)
+ add_custom_target(testdata_${test_index}
+ COMMAND ${CMAKE_COMMAND}
+ -DAOM_CONFIG_DIR="${AOM_CONFIG_DIR}"
+ -DAOM_ROOT="${AOM_ROOT}"
+ -DAOM_TEST_FILE="${test_file}"
+ -DAOM_TEST_CHECKSUM=${test_file_checksum}
+ -P "${AOM_ROOT}/test/test_data_download_worker.cmake")
+ set(testdata_targets ${testdata_targets} testdata_${test_index})
+ endforeach ()
+
+ # Create a custom build target for running each test data download target.
+ add_custom_target(testdata)
+ add_dependencies(testdata ${testdata_targets})
+
+ # Pick a reasonable number of targets (this controls parallelization).
+ ProcessorCount(num_test_targets)
+ if (num_test_targets EQUAL 0)
+ # Just default to 10 targets when there's no processor count available.
+ set(num_test_targets 10)
+ endif ()
+
+ # TODO(tomfinegan): This needs some work for MSVC and Xcode. Executable suffix
+ # and config based executable output paths are the obvious issues.
+ math(EXPR max_shard_index "${num_test_targets} - 1")
+ foreach (shard_index RANGE ${max_shard_index})
+ set(test_name "test_${shard_index}")
+ add_custom_target(${test_name}
+ COMMAND ${CMAKE_COMMAND}
+ -DGTEST_SHARD_INDEX=${shard_index}
+ -DGTEST_TOTAL_SHARDS=${num_test_targets}
+ -DTEST_LIBAOM=$<TARGET_FILE:test_libaom>
+ -P "${AOM_ROOT}/test/test_runner.cmake"
+ DEPENDS testdata test_libaom)
+ set(test_targets ${test_targets} ${test_name})
+ endforeach ()
+ add_custom_target(runtests)
+ add_dependencies(runtests ${test_targets})
+
+ if (MSVC)
+ set_target_properties(${testdata_targets} PROPERTIES
+ EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+ set_target_properties(${test_targets} PROPERTIES
+ EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+ set_target_properties(testdata runtests PROPERTIES
+ EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+ endif ()
endfunction ()
+
+endif () # AOM_TEST_TEST_CMAKE_
diff --git a/third_party/aom/test/test.mk b/third_party/aom/test/test.mk
index fb0ab371e..45bb21286 100644
--- a/third_party/aom/test/test.mk
+++ b/third_party/aom/test/test.mk
@@ -20,7 +20,6 @@ LIBAOM_TEST_SRCS-yes += util.h
LIBAOM_TEST_SRCS-yes += video_source.h
LIBAOM_TEST_SRCS-yes += transform_test_base.h
LIBAOM_TEST_SRCS-yes += function_equivalence_test.h
-LIBAOM_TEST_SRCS-yes += warp_filter_test_util.h
##
## BLACK BOX TESTS
@@ -28,18 +27,18 @@ LIBAOM_TEST_SRCS-yes += warp_filter_test_util.h
## Black box tests only use the public API.
##
LIBAOM_TEST_SRCS-yes += ../md5_utils.h ../md5_utils.c
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += ivf_video_source.h
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += ../y4minput.h ../y4minput.c
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += altref_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += aq_segment_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += datarate_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += encode_api_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += error_resilience_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += i420_video_source.h
-#LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += realtime_test.cc
-#LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += resize_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += y4m_video_source.h
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += yuv_video_source.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += ivf_video_source.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += ../y4minput.h ../y4minput.c
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += altref_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += aq_segment_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += datarate_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += encode_api_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += error_resilience_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += i420_video_source.h
+#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += realtime_test.cc
+#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += resize_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += y4m_video_source.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += yuv_video_source.h
#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += level_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += active_map_refresh_test.cc
@@ -51,14 +50,14 @@ LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += lossless_test.cc
LIBAOM_TEST_SRCS-yes += decode_test_driver.cc
LIBAOM_TEST_SRCS-yes += decode_test_driver.h
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += encode_test_driver.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += encode_test_driver.cc
LIBAOM_TEST_SRCS-yes += encode_test_driver.h
## IVF writing.
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += ../ivfenc.c ../ivfenc.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += ../ivfenc.c ../ivfenc.h
## Y4m parsing.
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += y4m_test.cc ../y4menc.c ../y4menc.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += y4m_test.cc ../y4menc.c ../y4menc.h
## WebM Parsing
ifeq ($(CONFIG_WEBM_IO), yes)
@@ -66,14 +65,14 @@ LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvparser.cc
LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvreader.cc
LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvparser.h
LIBWEBM_PARSER_SRCS += ../third_party/libwebm/mkvparser/mkvreader.h
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += $(LIBWEBM_PARSER_SRCS)
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += ../tools_common.h
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += ../webmdec.cc
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += ../webmdec.h
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += webm_video_source.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += $(LIBWEBM_PARSER_SRCS)
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += ../tools_common.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += ../webmdec.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += ../webmdec.h
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += webm_video_source.h
endif
-LIBAOM_TEST_SRCS-$(CONFIG_DECODERS) += decode_api_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += decode_api_test.cc
# Currently we only support decoder perf tests for av1. Also they read from WebM
# files, so WebM IO is required.
@@ -82,7 +81,6 @@ ifeq ($(CONFIG_DECODE_PERF_TESTS)$(CONFIG_AV1_DECODER)$(CONFIG_WEBM_IO), \
LIBAOM_TEST_SRCS-yes += decode_perf_test.cc
endif
-# encode perf tests are av1 only
ifeq ($(CONFIG_ENCODE_PERF_TESTS)$(CONFIG_AV1_ENCODER), yesyes)
LIBAOM_TEST_SRCS-yes += encode_perf_test.cc
endif
@@ -142,11 +140,13 @@ LIBAOM_TEST_SRCS-yes += simd_cmp_impl.h
LIBAOM_TEST_SRCS-$(HAVE_SSE2) += simd_cmp_sse2.cc
LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += simd_cmp_ssse3.cc
LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += simd_cmp_sse4.cc
+LIBAOM_TEST_SRCS-$(HAVE_AVX2) += simd_cmp_avx2.cc
LIBAOM_TEST_SRCS-$(HAVE_NEON) += simd_cmp_neon.cc
LIBAOM_TEST_SRCS-yes += simd_impl.h
LIBAOM_TEST_SRCS-$(HAVE_SSE2) += simd_sse2_test.cc
LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += simd_ssse3_test.cc
LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += simd_sse4_test.cc
+LIBAOM_TEST_SRCS-$(HAVE_AVX2) += simd_avx2_test.cc
LIBAOM_TEST_SRCS-$(HAVE_NEON) += simd_neon_test.cc
LIBAOM_TEST_SRCS-yes += intrapred_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_INTRABC) += intrabc_test.cc
@@ -162,13 +162,21 @@ LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += error_block_test.cc
#LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_quantize_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += subtract_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += arf_freq_test.cc
-
+ifneq ($(CONFIG_AOM_QM), yes)
+ifneq ($(CONFIG_NEW_QUANT), yes)
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += quantize_func_test.cc
+endif
+endif
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_inv_txfm_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_dct_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht4x4_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht8x8_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht16x16_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht32x32_test.cc
+ifeq ($(CONFIG_TX64X64),yes)
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht64x64_test.cc
+endif
ifeq ($(CONFIG_EXT_TX),yes)
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht4x8_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht8x4_test.cc
@@ -176,7 +184,6 @@ LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht8x16_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht16x8_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht16x32_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fht32x16_test.cc
-LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += fht32x32_test.cc
endif
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += sum_squares_test.cc
@@ -185,8 +192,8 @@ LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += blend_a64_mask_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += blend_a64_mask_1d_test.cc
ifeq ($(CONFIG_EXT_INTER),yes)
-LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += masked_variance_test.cc
-LIBAOM_TEST_SRCS-$(HAVE_SSSE3) += masked_sad_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += masked_variance_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += masked_sad_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_wedge_utils_test.cc
endif
@@ -217,7 +224,7 @@ endif
ifeq ($(CONFIG_INTERNAL_STATS),yes)
LIBAOM_TEST_SRCS-$(CONFIG_HIGHBITDEPTH) += hbd_metrics_test.cc
endif
-LIBAOM_TEST_SRCS-$(CONFIG_ENCODERS) += sad_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += sad_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_txfm_test.h
LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_txfm_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fwd_txfm1d_test.cc
@@ -226,13 +233,21 @@ LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_fwd_txfm2d_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += av1_inv_txfm2d_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_convolve_test.cc
LIBAOM_TEST_SRCS-$(CONFIG_AV1) += av1_convolve_optimz_test.cc
-ifneq ($(findstring yes,$(CONFIG_GLOBAL_MOTION) $(CONFIG_WARPED_MOTION)),)
+ifneq ($(findstring yes,$(CONFIG_GLOBAL_MOTION)$(CONFIG_WARPED_MOTION)),)
+LIBAOM_TEST_SRCS-$(HAVE_SSE2) += warp_filter_test_util.h
LIBAOM_TEST_SRCS-$(HAVE_SSE2) += warp_filter_test.cc warp_filter_test_util.cc
endif
ifeq ($(CONFIG_LOOP_RESTORATION),yes)
+LIBAOM_TEST_SRCS-$(HAVE_SSE2) += hiprec_convolve_test_util.h
+LIBAOM_TEST_SRCS-$(HAVE_SSE2) += hiprec_convolve_test.cc
+LIBAOM_TEST_SRCS-$(HAVE_SSE2) += hiprec_convolve_test_util.cc
LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += selfguided_filter_test.cc
endif
+ifeq ($(CONFIG_GLOBAL_MOTION)$(CONFIG_AV1_ENCODER),yesyes)
+LIBAOM_TEST_SRCS-$(HAVE_SSE4_1) += corner_match_test.cc
+endif
+
TEST_INTRA_PRED_SPEED_SRCS-yes := test_intra_pred_speed.cc
TEST_INTRA_PRED_SPEED_SRCS-yes += ../md5_utils.h ../md5_utils.c
diff --git a/third_party/aom/test/test_data_download_worker.cmake b/third_party/aom/test/test_data_download_worker.cmake
new file mode 100644
index 000000000..d7bf99edd
--- /dev/null
+++ b/third_party/aom/test/test_data_download_worker.cmake
@@ -0,0 +1,40 @@
+##
+## Copyright (c) 2017, 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("${AOM_ROOT}/test/test_data_util.cmake")
+
+if (NOT AOM_ROOT OR NOT AOM_CONFIG_DIR OR NOT AOM_TEST_FILE
+ OR NOT AOM_TEST_CHECKSUM)
+ message(FATAL_ERROR
+ "AOM_ROOT, AOM_CONFIG_DIR, AOM_TEST_FILE and AOM_TEST_CHECKSUM must be
+ defined.")
+endif ()
+
+set(AOM_TEST_DATA_URL
+ "https://storage.googleapis.com/downloads.webmproject.org/test_data/libvpx")
+set(AOM_TEST_DATA_PATH "$ENV{LIBAOM_TEST_DATA_PATH}")
+
+if ("${AOM_TEST_DATA_PATH}" STREQUAL "")
+ message(WARNING "Writing test data to ${AOM_CONFIG_DIR}, set "
+ "$LIBAOM_TEST_DATA_PATH in your environment to avoid this warning.")
+ set(AOM_TEST_DATA_PATH "${AOM_CONFIG_DIR}")
+endif ()
+
+if (NOT EXISTS "${AOM_TEST_DATA_PATH}")
+ file(MAKE_DIRECTORY "${AOM_TEST_DATA_PATH}")
+endif ()
+
+expand_test_file_paths("AOM_TEST_FILE" "${AOM_TEST_DATA_PATH}" "filepath")
+expand_test_file_paths("AOM_TEST_FILE" "${AOM_TEST_DATA_URL}" "url")
+
+check_file("${filepath}" "${AOM_TEST_CHECKSUM}" "needs_download")
+if (needs_download)
+ download_test_file("${url}" "${AOM_TEST_CHECKSUM}" "${filepath}")
+endif ()
diff --git a/third_party/aom/test/test_data_util.cmake b/third_party/aom/test/test_data_util.cmake
index f096e4e12..e4641049d 100644
--- a/third_party/aom/test/test_data_util.cmake
+++ b/third_party/aom/test/test_data_util.cmake
@@ -11,15 +11,14 @@
# Parses test/test-data.sha1 and writes captured file names and checksums to
# $out_files and $out_checksums as lists.
-function (make_test_data_lists out_files out_checksums)
- if (NOT AOM_TEST_DATA_LIST OR NOT EXISTS "${AOM_TEST_DATA_LIST}")
- message(FATAL_ERROR "AOM_TEST_DATA_LIST (${AOM_TEST_DATA_LIST}) missing or "
- "variable empty.")
+function (make_test_data_lists test_data_file out_files out_checksums)
+ if (NOT test_data_file OR NOT EXISTS "${test_data_file}")
+ message(FATAL_ERROR "Test info file missing or empty (${test_data_file})")
endif ()
- # Read test-data.sha1 into $files_and_checksums. $files_and_checksums becomes
- # a list with an entry for each line from $AOM_TEST_DATA_LIST.
- file(STRINGS "${AOM_TEST_DATA_LIST}" files_and_checksums)
+ # Read $test_data_file into $files_and_checksums. $files_and_checksums becomes
+ # a list with an entry for each line from $test_data_file.
+ file(STRINGS "${test_data_file}" files_and_checksums)
# Iterate over the list of lines and split it into $checksums and $filenames.
foreach (line ${files_and_checksums})
@@ -33,8 +32,10 @@ function (make_test_data_lists out_files out_checksums)
set(filenames ${filenames} ${filename})
endforeach ()
- if (NOT checksums OR NOT filenames)
- message(FATAL_ERROR "Parsing of ${AOM_TEST_DATA_LIST} failed.")
+ list(LENGTH filenames num_files)
+ list(LENGTH checksums num_checksums)
+ if (NOT checksums OR NOT filenames OR NOT num_files EQUAL num_checksums)
+ message(FATAL_ERROR "Parsing of ${test_data_file} failed.")
endif ()
set(${out_checksums} ${checksums} PARENT_SCOPE)
@@ -62,7 +63,9 @@ function (check_file local_path expected_checksum out_needs_update)
unset(${out_needs_update} PARENT_SCOPE)
else ()
set(${out_needs_update} 1 PARENT_SCOPE)
+ return ()
endif ()
+ message("${local_path} up to date.")
endfunction ()
# Downloads data from $file_url, confirms that $file_checksum matches, and
diff --git a/third_party/aom/test/test_intra_pred_speed.cc b/third_party/aom/test/test_intra_pred_speed.cc
index c4253628e..70d82484c 100644
--- a/third_party/aom/test/test_intra_pred_speed.cc
+++ b/third_party/aom/test/test_intra_pred_speed.cc
@@ -31,17 +31,16 @@ namespace {
typedef void (*AvxPredFunc)(uint8_t *dst, ptrdiff_t y_stride,
const uint8_t *above, const uint8_t *left);
-#if CONFIG_ALT_INTRA
-const int kNumAv1IntraFuncs = 14;
-#else
-const int kNumAv1IntraFuncs = 13;
-#endif // CONFIG_ALT_INTRA
+const int kNumAv1IntraFuncs = INTRA_MODES + 3; // 4 DC predictor variants.
const char *kAv1IntraPredNames[kNumAv1IntraFuncs] = {
- "DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
- "H_PRED", "D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED",
- "D207_PRED", "D63_PRED", "TM_PRED",
+ "DC_PRED", "DC_LEFT_PRED", "DC_TOP_PRED", "DC_128_PRED", "V_PRED",
+ "H_PRED", "D45_PRED", "D135_PRED", "D117_PRED", "D153_PRED",
+ "D207_PRED", "D63_PRED", "TM_PRED",
#if CONFIG_ALT_INTRA
- "SMOOTH_PRED"
+ "SMOOTH_PRED",
+#if CONFIG_SMOOTH_HV
+ "SMOOTH_V_PRED", "SMOOTH_H_PRED",
+#endif // CONFIG_SMOOTH_HV
#endif // CONFIG_ALT_INTRA
};
@@ -104,7 +103,11 @@ void TestIntraPred4(AvxPredFunc const *pred_funcs) {
"b852f42e6c4991d415400332d567872f",
#if CONFIG_ALT_INTRA
"828c49a4248993cce4876fa26eab697f",
- "718c8cee9011f92ef31f77a9a7560010"
+ "718c8cee9011f92ef31f77a9a7560010",
+#if CONFIG_SMOOTH_HV
+ "b37eeadbbd9e3bdff023a5097b59213a",
+ "d6fb9c659d82c78f0d0c891da6cba87f",
+#endif // CONFIG_SMOOTH_HV
#else
"309a618577b27c648f9c5ee45252bc8f",
#endif // CONFIG_ALT_INTRA
@@ -129,7 +132,11 @@ void TestIntraPred8(AvxPredFunc const *pred_funcs) {
"7a09adb0fa6c2bf889a99dd816622feb",
#if CONFIG_ALT_INTRA
"f6ade499c626d38eb70661184b79bc57",
- "1ad5b106c79b792e514ba25e87139b5e"
+ "1ad5b106c79b792e514ba25e87139b5e",
+#if CONFIG_SMOOTH_HV
+ "fe0d359b91a1d8141483d2e032f1b75f",
+ "0cfd7603ced02829d1ce18b6795d73d0",
+#endif // CONFIG_SMOOTH_HV
#else
"815b75c8e0d91cc1ae766dc5d3e445a3",
#endif // CONFIG_ALT_INTRA
@@ -154,7 +161,11 @@ void TestIntraPred16(AvxPredFunc const *pred_funcs) {
"f7063ccbc29f87303d5c3d0555b08944",
#if CONFIG_ALT_INTRA
"7adcaaa3554eb71a81fc48cb9043984b",
- "c0acea4397c1b4d54a21bbcec5731dff"
+ "c0acea4397c1b4d54a21bbcec5731dff",
+#if CONFIG_SMOOTH_HV
+ "f15b8712f0f064e98a7d804d3074afa7",
+ "01a09cdb8edd06d840c84643032fc02f",
+#endif // CONFIG_SMOOTH_HV
#else
"b8a41aa968ec108af447af4217cba91b",
#endif // CONFIG_ALT_INTRA
@@ -179,7 +190,11 @@ void TestIntraPred32(AvxPredFunc const *pred_funcs) {
"d520125ebd512c63c301bf67fea8e059",
#if CONFIG_ALT_INTRA
"297e8fbb5d33c29b12b228fa9d7c40a4",
- "31b9296d70dd82238c87173e6d5e65fd"
+ "31b9296d70dd82238c87173e6d5e65fd",
+#if CONFIG_SMOOTH_HV
+ "f1041f77a34e86aaf30ea779ba84a2e8",
+ "83e2b744a6a3d82321744442b1db945c",
+#endif // CONFIG_SMOOTH_HV
#else
"9e1370c6d42e08d357d9612c93a71cfc",
#endif // CONFIG_ALT_INTRA
@@ -193,11 +208,12 @@ void TestIntraPred32(AvxPredFunc const *pred_funcs) {
// Defines a test case for |arch| (e.g., C, SSE2, ...) passing the predictors
// to |test_func|. The test name is 'arch.test_func', e.g., C.TestIntraPred4.
#define INTRA_PRED_TEST(arch, test_func, dc, dc_left, dc_top, dc_128, v, h, \
- d45e, d135, d117, d153, d207e, d63e, tm, smooth) \
+ d45e, d135, d117, d153, d207e, d63e, tm, smooth, \
+ smooth_v, smooth_h) \
TEST(arch, test_func) { \
static const AvxPredFunc aom_intra_pred[] = { \
- dc, dc_left, dc_top, dc_128, v, h, d45e, \
- d135, d117, d153, d207e, d63e, tm, smooth \
+ dc, dc_left, dc_top, dc_128, v, h, d45e, d135, \
+ d117, d153, d207e, d63e, tm, smooth, smooth_v, smooth_h \
}; \
test_func(aom_intra_pred); \
}
@@ -208,9 +224,18 @@ void TestIntraPred32(AvxPredFunc const *pred_funcs) {
#if CONFIG_ALT_INTRA
#define tm_pred_func aom_paeth_predictor_4x4_c
#define smooth_pred_func aom_smooth_predictor_4x4_c
+#if CONFIG_SMOOTH_HV
+#define smooth_v_pred_func aom_smooth_v_predictor_4x4_c
+#define smooth_h_pred_func aom_smooth_h_predictor_4x4_c
+#else
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
+#endif // CONFIG_SMOOTH_HV
#else
#define tm_pred_func aom_tm_predictor_4x4_c
#define smooth_pred_func NULL
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(C, TestIntraPred4, aom_dc_predictor_4x4_c,
@@ -219,10 +244,13 @@ INTRA_PRED_TEST(C, TestIntraPred4, aom_dc_predictor_4x4_c,
aom_h_predictor_4x4_c, aom_d45e_predictor_4x4_c,
aom_d135_predictor_4x4_c, aom_d117_predictor_4x4_c,
aom_d153_predictor_4x4_c, aom_d207e_predictor_4x4_c,
- aom_d63e_predictor_4x4_c, tm_pred_func, smooth_pred_func)
+ aom_d63e_predictor_4x4_c, tm_pred_func, smooth_pred_func,
+ smooth_v_pred_func, smooth_h_pred_func)
#undef tm_pred_func
#undef smooth_pred_func
+#undef smooth_v_pred_func
+#undef smooth_h_pred_func
#if HAVE_SSE2
#if CONFIG_ALT_INTRA
@@ -235,7 +263,7 @@ INTRA_PRED_TEST(SSE2, TestIntraPred4, aom_dc_predictor_4x4_sse2,
aom_dc_left_predictor_4x4_sse2, aom_dc_top_predictor_4x4_sse2,
aom_dc_128_predictor_4x4_sse2, aom_v_predictor_4x4_sse2,
aom_h_predictor_4x4_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_SSE2
@@ -243,7 +271,7 @@ INTRA_PRED_TEST(SSE2, TestIntraPred4, aom_dc_predictor_4x4_sse2,
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, aom_d153_predictor_4x4_ssse3, NULL,
- aom_d63e_predictor_4x4_ssse3, NULL, NULL)
+ aom_d63e_predictor_4x4_ssse3, NULL, NULL, NULL, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
@@ -254,7 +282,7 @@ INTRA_PRED_TEST(SSSE3, TestIntraPred4, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(DSPR2, TestIntraPred4, aom_dc_predictor_4x4_dspr2, NULL, NULL,
NULL, NULL, aom_h_predictor_4x4_dspr2, NULL, NULL, NULL, NULL,
- NULL, NULL, tm_pred_func, NULL)
+ NULL, NULL, tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_DSPR2
@@ -268,7 +296,7 @@ INTRA_PRED_TEST(NEON, TestIntraPred4, aom_dc_predictor_4x4_neon,
aom_dc_left_predictor_4x4_neon, aom_dc_top_predictor_4x4_neon,
aom_dc_128_predictor_4x4_neon, aom_v_predictor_4x4_neon,
aom_h_predictor_4x4_neon, NULL, aom_d135_predictor_4x4_neon,
- NULL, NULL, NULL, NULL, tm_pred_func, NULL)
+ NULL, NULL, NULL, NULL, tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_NEON
@@ -282,7 +310,7 @@ INTRA_PRED_TEST(MSA, TestIntraPred4, aom_dc_predictor_4x4_msa,
aom_dc_left_predictor_4x4_msa, aom_dc_top_predictor_4x4_msa,
aom_dc_128_predictor_4x4_msa, aom_v_predictor_4x4_msa,
aom_h_predictor_4x4_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_MSA
@@ -292,9 +320,18 @@ INTRA_PRED_TEST(MSA, TestIntraPred4, aom_dc_predictor_4x4_msa,
#if CONFIG_ALT_INTRA
#define tm_pred_func aom_paeth_predictor_8x8_c
#define smooth_pred_func aom_smooth_predictor_8x8_c
+#if CONFIG_SMOOTH_HV
+#define smooth_v_pred_func aom_smooth_v_predictor_8x8_c
+#define smooth_h_pred_func aom_smooth_h_predictor_8x8_c
+#else
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
+#endif // CONFIG_SMOOTH_HV
#else
#define tm_pred_func aom_tm_predictor_8x8_c
#define smooth_pred_func NULL
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(C, TestIntraPred8, aom_dc_predictor_8x8_c,
aom_dc_left_predictor_8x8_c, aom_dc_top_predictor_8x8_c,
@@ -302,9 +339,12 @@ INTRA_PRED_TEST(C, TestIntraPred8, aom_dc_predictor_8x8_c,
aom_h_predictor_8x8_c, aom_d45e_predictor_8x8_c,
aom_d135_predictor_8x8_c, aom_d117_predictor_8x8_c,
aom_d153_predictor_8x8_c, aom_d207e_predictor_8x8_c,
- aom_d63e_predictor_8x8_c, tm_pred_func, smooth_pred_func)
+ aom_d63e_predictor_8x8_c, tm_pred_func, smooth_pred_func,
+ smooth_v_pred_func, smooth_h_pred_func)
#undef tm_pred_func
#undef smooth_pred_func
+#undef smooth_v_pred_func
+#undef smooth_h_pred_func
#if HAVE_SSE2
#if CONFIG_ALT_INTRA
@@ -316,14 +356,14 @@ INTRA_PRED_TEST(SSE2, TestIntraPred8, aom_dc_predictor_8x8_sse2,
aom_dc_left_predictor_8x8_sse2, aom_dc_top_predictor_8x8_sse2,
aom_dc_128_predictor_8x8_sse2, aom_v_predictor_8x8_sse2,
aom_h_predictor_8x8_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, aom_d153_predictor_8x8_ssse3, NULL, NULL, NULL,
- NULL)
+ NULL, NULL, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
@@ -334,7 +374,7 @@ INTRA_PRED_TEST(SSSE3, TestIntraPred8, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(DSPR2, TestIntraPred8, aom_dc_predictor_8x8_dspr2, NULL, NULL,
NULL, NULL, aom_h_predictor_8x8_dspr2, NULL, NULL, NULL, NULL,
- NULL, NULL, tm_pred_func, NULL)
+ NULL, NULL, tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_DSPR2
@@ -348,7 +388,7 @@ INTRA_PRED_TEST(NEON, TestIntraPred8, aom_dc_predictor_8x8_neon,
aom_dc_left_predictor_8x8_neon, aom_dc_top_predictor_8x8_neon,
aom_dc_128_predictor_8x8_neon, aom_v_predictor_8x8_neon,
aom_h_predictor_8x8_neon, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_NEON
@@ -362,7 +402,7 @@ INTRA_PRED_TEST(MSA, TestIntraPred8, aom_dc_predictor_8x8_msa,
aom_dc_left_predictor_8x8_msa, aom_dc_top_predictor_8x8_msa,
aom_dc_128_predictor_8x8_msa, aom_v_predictor_8x8_msa,
aom_h_predictor_8x8_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_MSA
@@ -372,9 +412,18 @@ INTRA_PRED_TEST(MSA, TestIntraPred8, aom_dc_predictor_8x8_msa,
#if CONFIG_ALT_INTRA
#define tm_pred_func aom_paeth_predictor_16x16_c
#define smooth_pred_func aom_smooth_predictor_16x16_c
+#if CONFIG_SMOOTH_HV
+#define smooth_v_pred_func aom_smooth_v_predictor_16x16_c
+#define smooth_h_pred_func aom_smooth_h_predictor_16x16_c
+#else
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
+#endif // CONFIG_SMOOTH_HV
#else
#define tm_pred_func aom_tm_predictor_16x16_c
#define smooth_pred_func NULL
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(C, TestIntraPred16, aom_dc_predictor_16x16_c,
aom_dc_left_predictor_16x16_c, aom_dc_top_predictor_16x16_c,
@@ -382,9 +431,12 @@ INTRA_PRED_TEST(C, TestIntraPred16, aom_dc_predictor_16x16_c,
aom_h_predictor_16x16_c, aom_d45e_predictor_16x16_c,
aom_d135_predictor_16x16_c, aom_d117_predictor_16x16_c,
aom_d153_predictor_16x16_c, aom_d207e_predictor_16x16_c,
- aom_d63e_predictor_16x16_c, tm_pred_func, smooth_pred_func)
+ aom_d63e_predictor_16x16_c, tm_pred_func, smooth_pred_func,
+ smooth_v_pred_func, smooth_h_pred_func)
#undef tm_pred_func
#undef smooth_pred_func
+#undef smooth_v_pred_func
+#undef smooth_h_pred_func
#if HAVE_SSE2
#if CONFIG_ALT_INTRA
@@ -397,20 +449,20 @@ INTRA_PRED_TEST(SSE2, TestIntraPred16, aom_dc_predictor_16x16_sse2,
aom_dc_top_predictor_16x16_sse2,
aom_dc_128_predictor_16x16_sse2, aom_v_predictor_16x16_sse2,
aom_h_predictor_16x16_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred16, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, aom_d153_predictor_16x16_ssse3, NULL, NULL,
- NULL, NULL)
+ NULL, NULL, NULL, NULL)
#endif // HAVE_SSSE3
#if HAVE_DSPR2
INTRA_PRED_TEST(DSPR2, TestIntraPred16, aom_dc_predictor_16x16_dspr2, NULL,
NULL, NULL, NULL, aom_h_predictor_16x16_dspr2, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL)
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL)
#endif // HAVE_DSPR2
#if HAVE_NEON
@@ -424,7 +476,7 @@ INTRA_PRED_TEST(NEON, TestIntraPred16, aom_dc_predictor_16x16_neon,
aom_dc_top_predictor_16x16_neon,
aom_dc_128_predictor_16x16_neon, aom_v_predictor_16x16_neon,
aom_h_predictor_16x16_neon, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_NEON
@@ -438,7 +490,7 @@ INTRA_PRED_TEST(MSA, TestIntraPred16, aom_dc_predictor_16x16_msa,
aom_dc_left_predictor_16x16_msa, aom_dc_top_predictor_16x16_msa,
aom_dc_128_predictor_16x16_msa, aom_v_predictor_16x16_msa,
aom_h_predictor_16x16_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_MSA
@@ -448,9 +500,18 @@ INTRA_PRED_TEST(MSA, TestIntraPred16, aom_dc_predictor_16x16_msa,
#if CONFIG_ALT_INTRA
#define tm_pred_func aom_paeth_predictor_32x32_c
#define smooth_pred_func aom_smooth_predictor_32x32_c
+#if CONFIG_SMOOTH_HV
+#define smooth_v_pred_func aom_smooth_v_predictor_32x32_c
+#define smooth_h_pred_func aom_smooth_h_predictor_32x32_c
+#else
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
+#endif // CONFIG_SMOOTH_HV
#else
#define tm_pred_func aom_tm_predictor_32x32_c
#define smooth_pred_func NULL
+#define smooth_v_pred_func NULL
+#define smooth_h_pred_func NULL
#endif // CONFIG_ALT_INTRA
INTRA_PRED_TEST(C, TestIntraPred32, aom_dc_predictor_32x32_c,
aom_dc_left_predictor_32x32_c, aom_dc_top_predictor_32x32_c,
@@ -458,9 +519,12 @@ INTRA_PRED_TEST(C, TestIntraPred32, aom_dc_predictor_32x32_c,
aom_h_predictor_32x32_c, aom_d45e_predictor_32x32_c,
aom_d135_predictor_32x32_c, aom_d117_predictor_32x32_c,
aom_d153_predictor_32x32_c, aom_d207e_predictor_32x32_c,
- aom_d63e_predictor_32x32_c, tm_pred_func, smooth_pred_func)
+ aom_d63e_predictor_32x32_c, tm_pred_func, smooth_pred_func,
+ smooth_v_pred_func, smooth_h_pred_func)
#undef tm_pred_func
#undef smooth_pred_func
+#undef smooth_v_pred_func
+#undef smooth_h_pred_func
#if HAVE_SSE2
#if CONFIG_ALT_INTRA
@@ -473,14 +537,14 @@ INTRA_PRED_TEST(SSE2, TestIntraPred32, aom_dc_predictor_32x32_sse2,
aom_dc_top_predictor_32x32_sse2,
aom_dc_128_predictor_32x32_sse2, aom_v_predictor_32x32_sse2,
aom_h_predictor_32x32_sse2, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_SSE2
#if HAVE_SSSE3
INTRA_PRED_TEST(SSSE3, TestIntraPred32, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, aom_d153_predictor_32x32_ssse3, NULL, NULL,
- NULL, NULL)
+ NULL, NULL, NULL, NULL)
#endif // HAVE_SSSE3
#if HAVE_NEON
@@ -494,7 +558,7 @@ INTRA_PRED_TEST(NEON, TestIntraPred32, aom_dc_predictor_32x32_neon,
aom_dc_top_predictor_32x32_neon,
aom_dc_128_predictor_32x32_neon, aom_v_predictor_32x32_neon,
aom_h_predictor_32x32_neon, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_NEON
@@ -508,7 +572,7 @@ INTRA_PRED_TEST(MSA, TestIntraPred32, aom_dc_predictor_32x32_msa,
aom_dc_left_predictor_32x32_msa, aom_dc_top_predictor_32x32_msa,
aom_dc_128_predictor_32x32_msa, aom_v_predictor_32x32_msa,
aom_h_predictor_32x32_msa, NULL, NULL, NULL, NULL, NULL, NULL,
- tm_pred_func, NULL)
+ tm_pred_func, NULL, NULL, NULL)
#undef tm_pred_func
#endif // HAVE_MSA
diff --git a/third_party/aom/test/test_runner.cmake b/third_party/aom/test/test_runner.cmake
new file mode 100644
index 000000000..48ebaf570
--- /dev/null
+++ b/third_party/aom/test/test_runner.cmake
@@ -0,0 +1,20 @@
+##
+## Copyright (c) 2017, 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.
+##
+if (NOT GTEST_TOTAL_SHARDS OR "${GTEST_SHARD_INDEX}" STREQUAL ""
+ OR NOT TEST_LIBAOM)
+ message(FATAL_ERROR
+ "The variables GTEST_SHARD_INDEX, GTEST_TOTAL_SHARDS and TEST_LIBAOM
+ must be defined.")
+endif ()
+
+set($ENV{GTEST_SHARD_INDEX} ${GTEST_SHARD_INDEX})
+set($ENV{GTEST_TOTAL_SHARDS} ${GTEST_TOTAL_SHARDS})
+execute_process(COMMAND ${TEST_LIBAOM})
diff --git a/third_party/aom/test/test_worker.cmake b/third_party/aom/test/test_worker.cmake
deleted file mode 100644
index fa1d58130..000000000
--- a/third_party/aom/test/test_worker.cmake
+++ /dev/null
@@ -1,49 +0,0 @@
-##
-## Copyright (c) 2017, 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.
-##
-if (NOT AOM_ROOT OR NOT AOM_CONFIG_DIR)
- message(FATAL_ERROR "AOM_ROOT AND AOM_CONFIG_DIR must be defined.")
-endif ()
-
-set(AOM_TEST_DATA_LIST "${AOM_ROOT}/test/test-data.sha1")
-set(AOM_TEST_DATA_URL "http://downloads.webmproject.org/test_data/libvpx")
-set(AOM_TEST_DATA_PATH "$ENV{LIBAOM_TEST_DATA_PATH}")
-
-include("${AOM_ROOT}/test/test_data_util.cmake")
-
-if (${AOM_TEST_DATA_PATH} STREQUAL "")
- message(WARNING "Writing test data to ${AOM_CONFIG_DIR}, set "
- "$LIBAOM_TEST_DATA_PATH in your environment to avoid this warning.")
- set(AOM_TEST_DATA_PATH "${AOM_CONFIG_DIR}")
-endif ()
-
-if (NOT EXISTS "${AOM_TEST_DATA_PATH}")
- file(MAKE_DIRECTORY "${AOM_TEST_DATA_PATH}")
-endif ()
-
-make_test_data_lists("AOM_TEST_DATA_FILES" "AOM_TEST_DATA_CHECKSUMS")
-expand_test_file_paths("AOM_TEST_DATA_FILES" "${AOM_TEST_DATA_PATH}"
- "AOM_TEST_DATA_FILE_PATHS")
-expand_test_file_paths("AOM_TEST_DATA_FILES" "${AOM_TEST_DATA_URL}"
- "AOM_TEST_DATA_URLS")
-list(LENGTH AOM_TEST_DATA_FILES num_files)
-math(EXPR num_files "${num_files} - 1")
-
-foreach (file_num RANGE ${num_files})
- list(GET AOM_TEST_DATA_FILES ${file_num} filename)
- list(GET AOM_TEST_DATA_CHECKSUMS ${file_num} checksum)
- list(GET AOM_TEST_DATA_FILE_PATHS ${file_num} filepath)
- list(GET AOM_TEST_DATA_URLS ${file_num} url)
-
- check_file("${filepath}" "${checksum}" "needs_download")
- if (needs_download)
- download_test_file("${url}" "${checksum}" "${filepath}")
- endif ()
-endforeach ()
diff --git a/third_party/aom/test/variance_test.cc b/third_party/aom/test/variance_test.cc
index 5b1003ca7..c712f96e2 100644
--- a/third_party/aom/test/variance_test.cc
+++ b/third_party/aom/test/variance_test.cc
@@ -565,8 +565,8 @@ class SubpelVarianceTest
aom_memalign(16, block_size_ * sizeof(uint16_t))));
sec_ = CONVERT_TO_BYTEPTR(reinterpret_cast<uint16_t *>(
aom_memalign(16, block_size_ * sizeof(uint16_t))));
- ref_ =
- CONVERT_TO_BYTEPTR(new uint16_t[block_size_ + width_ + height_ + 1]);
+ ref_ = CONVERT_TO_BYTEPTR(aom_memalign(
+ 16, (block_size_ + width_ + height_ + 1) * sizeof(uint16_t)));
#endif // CONFIG_HIGHBITDEPTH
}
ASSERT_TRUE(src_ != NULL);
@@ -582,7 +582,7 @@ class SubpelVarianceTest
#if CONFIG_HIGHBITDEPTH
} else {
aom_free(CONVERT_TO_SHORTPTR(src_));
- delete[] CONVERT_TO_SHORTPTR(ref_);
+ aom_free(CONVERT_TO_SHORTPTR(ref_));
aom_free(CONVERT_TO_SHORTPTR(sec_));
#endif // CONFIG_HIGHBITDEPTH
}
@@ -1277,22 +1277,6 @@ INSTANTIATE_TEST_CASE_P(
make_tuple(5, 5, &aom_sub_pixel_avg_variance32x32_avx2, 0)));
#endif // HAVE_AVX2
-#if HAVE_MEDIA
-INSTANTIATE_TEST_CASE_P(MEDIA, AvxMseTest,
- ::testing::Values(MseParams(4, 4,
- &aom_mse16x16_media)));
-
-INSTANTIATE_TEST_CASE_P(
- MEDIA, AvxVarianceTest,
- ::testing::Values(VarianceParams(4, 4, &aom_variance16x16_media),
- VarianceParams(3, 3, &aom_variance8x8_media)));
-
-INSTANTIATE_TEST_CASE_P(
- MEDIA, AvxSubpelVarianceTest,
- ::testing::Values(make_tuple(4, 4, &aom_sub_pixel_variance16x16_media, 0),
- make_tuple(3, 3, &aom_sub_pixel_variance8x8_media, 0)));
-#endif // HAVE_MEDIA
-
#if HAVE_NEON
INSTANTIATE_TEST_CASE_P(NEON, AvxSseTest,
::testing::Values(SseParams(2, 2,
diff --git a/third_party/aom/test/warp_filter_test.cc b/third_party/aom/test/warp_filter_test.cc
index fd6608bfc..2e4e6c32b 100644
--- a/third_party/aom/test/warp_filter_test.cc
+++ b/third_party/aom/test/warp_filter_test.cc
@@ -22,12 +22,17 @@ using libaom_test::AV1HighbdWarpFilter::AV1HighbdWarpFilterTest;
namespace {
-TEST_P(AV1WarpFilterTest, CheckOutput) { RunCheckOutput(av1_warp_affine_sse2); }
+TEST_P(AV1WarpFilterTest, CheckOutput) { RunCheckOutput(GET_PARAM(3)); }
-INSTANTIATE_TEST_CASE_P(SSE2, AV1WarpFilterTest,
- libaom_test::AV1WarpFilter::GetDefaultParams());
+INSTANTIATE_TEST_CASE_P(
+ SSE2, AV1WarpFilterTest,
+ libaom_test::AV1WarpFilter::BuildParams(av1_warp_affine_sse2));
-#if CONFIG_HIGHBITDEPTH
+INSTANTIATE_TEST_CASE_P(
+ SSSE3, AV1WarpFilterTest,
+ libaom_test::AV1WarpFilter::BuildParams(av1_warp_affine_ssse3));
+
+#if CONFIG_HIGHBITDEPTH && HAVE_SSSE3
TEST_P(AV1HighbdWarpFilterTest, CheckOutput) {
RunCheckOutput(av1_highbd_warp_affine_ssse3);
}
diff --git a/third_party/aom/test/warp_filter_test_util.cc b/third_party/aom/test/warp_filter_test_util.cc
index 1ce265b60..ac7518f47 100644
--- a/third_party/aom/test/warp_filter_test_util.cc
+++ b/third_party/aom/test/warp_filter_test_util.cc
@@ -13,23 +13,19 @@
using std::tr1::tuple;
using std::tr1::make_tuple;
-using std::vector;
-using libaom_test::ACMRandom;
-using libaom_test::AV1WarpFilter::AV1WarpFilterTest;
-using libaom_test::AV1WarpFilter::WarpTestParam;
-#if CONFIG_HIGHBITDEPTH
-using libaom_test::AV1HighbdWarpFilter::AV1HighbdWarpFilterTest;
-using libaom_test::AV1HighbdWarpFilter::HighbdWarpTestParam;
-#endif
-
-::testing::internal::ParamGenerator<WarpTestParam>
-libaom_test::AV1WarpFilter::GetDefaultParams() {
- const WarpTestParam defaultParams[] = {
- make_tuple(4, 4, 50000), make_tuple(8, 8, 50000),
- make_tuple(64, 64, 1000), make_tuple(4, 16, 20000),
- make_tuple(32, 8, 10000),
+
+namespace libaom_test {
+
+namespace AV1WarpFilter {
+
+::testing::internal::ParamGenerator<WarpTestParam> BuildParams(
+ warp_affine_func filter) {
+ const WarpTestParam params[] = {
+ make_tuple(4, 4, 50000, filter), make_tuple(8, 8, 50000, filter),
+ make_tuple(64, 64, 1000, filter), make_tuple(4, 16, 20000, filter),
+ make_tuple(32, 8, 10000, filter),
};
- return ::testing::ValuesIn(defaultParams);
+ return ::testing::ValuesIn(params);
}
AV1WarpFilterTest::~AV1WarpFilterTest() {}
@@ -84,6 +80,15 @@ void AV1WarpFilterTest::generate_model(int32_t *mat, int16_t *alpha,
(4 * abs(*gamma) + 4 * abs(*delta) >= (1 << WARPEDMODEL_PREC_BITS)))
continue;
+ *alpha = ROUND_POWER_OF_TWO_SIGNED(*alpha, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *beta = ROUND_POWER_OF_TWO_SIGNED(*beta, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *gamma = ROUND_POWER_OF_TWO_SIGNED(*gamma, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *delta = ROUND_POWER_OF_TWO_SIGNED(*delta, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+
// We have a valid model, so finish
return;
}
@@ -136,10 +141,12 @@ void AV1WarpFilterTest::RunCheckOutput(warp_affine_func test_impl) {
delete[] output;
delete[] output2;
}
+} // namespace AV1WarpFilter
#if CONFIG_HIGHBITDEPTH
-::testing::internal::ParamGenerator<HighbdWarpTestParam>
-libaom_test::AV1HighbdWarpFilter::GetDefaultParams() {
+namespace AV1HighbdWarpFilter {
+
+::testing::internal::ParamGenerator<HighbdWarpTestParam> GetDefaultParams() {
const HighbdWarpTestParam defaultParams[] = {
make_tuple(4, 4, 50000, 8), make_tuple(8, 8, 50000, 8),
make_tuple(64, 64, 1000, 8), make_tuple(4, 16, 20000, 8),
@@ -207,6 +214,15 @@ void AV1HighbdWarpFilterTest::generate_model(int32_t *mat, int16_t *alpha,
(4 * abs(*gamma) + 4 * abs(*delta) >= (1 << WARPEDMODEL_PREC_BITS)))
continue;
+ *alpha = ROUND_POWER_OF_TWO_SIGNED(*alpha, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *beta = ROUND_POWER_OF_TWO_SIGNED(*beta, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *gamma = ROUND_POWER_OF_TWO_SIGNED(*gamma, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+ *delta = ROUND_POWER_OF_TWO_SIGNED(*delta, WARP_PARAM_REDUCE_BITS) *
+ (1 << WARP_PARAM_REDUCE_BITS);
+
// We have a valid model, so finish
return;
}
@@ -265,4 +281,6 @@ void AV1HighbdWarpFilterTest::RunCheckOutput(
delete[] output;
delete[] output2;
}
+} // namespace AV1HighbdWarpFilter
#endif // CONFIG_HIGHBITDEPTH
+} // namespace libaom_test
diff --git a/third_party/aom/test/warp_filter_test_util.h b/third_party/aom/test/warp_filter_test_util.h
index 6a87e46d0..651a9f830 100644
--- a/third_party/aom/test/warp_filter_test_util.h
+++ b/third_party/aom/test/warp_filter_test_util.h
@@ -26,16 +26,18 @@ namespace libaom_test {
namespace AV1WarpFilter {
-typedef void (*warp_affine_func)(int32_t *mat, uint8_t *ref, int width,
- int height, int stride, uint8_t *pred,
- int p_col, int p_row, int p_width,
- int p_height, int p_stride, int subsampling_x,
- int subsampling_y, int ref_frm, int16_t alpha,
- int16_t beta, int16_t gamma, int16_t delta);
+typedef void (*warp_affine_func)(const int32_t *mat, const uint8_t *ref,
+ int width, int height, int stride,
+ uint8_t *pred, int p_col, int p_row,
+ int p_width, int p_height, int p_stride,
+ int subsampling_x, int subsampling_y,
+ int ref_frm, int16_t alpha, int16_t beta,
+ int16_t gamma, int16_t delta);
-typedef std::tr1::tuple<int, int, int> WarpTestParam;
+typedef std::tr1::tuple<int, int, int, warp_affine_func> WarpTestParam;
-::testing::internal::ParamGenerator<WarpTestParam> GetDefaultParams();
+::testing::internal::ParamGenerator<WarpTestParam> BuildParams(
+ warp_affine_func filter);
class AV1WarpFilterTest : public ::testing::TestWithParam<WarpTestParam> {
public:
@@ -59,7 +61,7 @@ class AV1WarpFilterTest : public ::testing::TestWithParam<WarpTestParam> {
#if CONFIG_HIGHBITDEPTH
namespace AV1HighbdWarpFilter {
typedef void (*highbd_warp_affine_func)(
- int32_t *mat, uint16_t *ref, int width, int height, int stride,
+ const int32_t *mat, const uint16_t *ref, int width, int height, int stride,
uint16_t *pred, int p_col, int p_row, int p_width, int p_height,
int p_stride, int subsampling_x, int subsampling_y, int bd, int ref_frm,
int16_t alpha, int16_t beta, int16_t gamma, int16_t delta);