test/av1_convolve_2d_test.cc

   1 /*
   2  * Copyright (c) 2016, Alliance for Open Media. All rights reserved
   3  *
   4  * This source code is subject to the terms of the BSD 2 Clause License and
   5  * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
   6  * was not distributed with this source code in the LICENSE file, you can
   7  * obtain it at www.aomedia.org/license/software. If the Alliance for Open
   8  * Media Patent License 1.0 was not distributed with this source code in the
   9  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  10  */
  11
  12 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
  13 #include "test/av1_convolve_2d_test_util.h"
  14
  15 using ::testing::make_tuple;
  16 using ::testing::tuple;
  17 using libaom_test::ACMRandom;
  18 using libaom_test::AV1Convolve2D::AV1Convolve2DSrTest;
  19 using libaom_test::AV1Convolve2D::AV1JntConvolve2DTest;
  20 using libaom_test::AV1HighbdConvolve2D::AV1HighbdConvolve2DSrTest;
  21 using libaom_test::AV1HighbdConvolve2D::AV1HighbdJntConvolve2DTest;
  22 namespace {
  23
  24 TEST_P(AV1Convolve2DSrTest, DISABLED_Speed) { RunSpeedTest(GET_PARAM(0)); }
  25
  26 TEST_P(AV1Convolve2DSrTest, CheckOutput) { RunCheckOutput(GET_PARAM(0)); }
  27
  28 INSTANTIATE_TEST_CASE_P(
  29     C_COPY, AV1Convolve2DSrTest,
  30     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_copy_sr_c, 0, 0));
  31 INSTANTIATE_TEST_CASE_P(
  32     C_X, AV1Convolve2DSrTest,
  33     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_sr_c, 1, 0));
  34 INSTANTIATE_TEST_CASE_P(
  35     C_Y, AV1Convolve2DSrTest,
  36     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_sr_c, 0, 1));
  37 INSTANTIATE_TEST_CASE_P(
  38     C, AV1Convolve2DSrTest,
  39     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sr_c, 1, 1));
  40 #if HAVE_SSE2
  41 INSTANTIATE_TEST_CASE_P(SSE2_COPY, AV1Convolve2DSrTest,
  42                         libaom_test::AV1Convolve2D::BuildParams(
  43                             av1_convolve_2d_copy_sr_sse2, 0, 0));
  44 INSTANTIATE_TEST_CASE_P(
  45     SSE2_X, AV1Convolve2DSrTest,
  46     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_sr_sse2, 1, 0));
  47 INSTANTIATE_TEST_CASE_P(
  48     SSE2_Y, AV1Convolve2DSrTest,
  49     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_sr_sse2, 0, 1));
  50 INSTANTIATE_TEST_CASE_P(
  51     SSE2, AV1Convolve2DSrTest,
  52     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sr_sse2, 1, 1));
  53 #if HAVE_AVX2
  54 INSTANTIATE_TEST_CASE_P(AVX2_COPY, AV1Convolve2DSrTest,
  55                         libaom_test::AV1Convolve2D::BuildParams(
  56                             av1_convolve_2d_copy_sr_avx2, 0, 0));
  57 INSTANTIATE_TEST_CASE_P(
  58     AVX2_X, AV1Convolve2DSrTest,
  59     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_sr_avx2, 1, 0));
  60
  61 INSTANTIATE_TEST_CASE_P(
  62     AVX2_Y, AV1Convolve2DSrTest,
  63     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_sr_avx2, 0, 1));
  64
  65 INSTANTIATE_TEST_CASE_P(
  66     AVX2, AV1Convolve2DSrTest,
  67     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sr_avx2, 1, 1));
  68 #endif  // HAVE_AVX2
  69 #endif  // HAVE_SSE2
  70
  71 #if HAVE_NEON
  72 INSTANTIATE_TEST_CASE_P(
  73     NEON_X, AV1Convolve2DSrTest,
  74     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_x_sr_neon, 1, 0));
  75
  76 INSTANTIATE_TEST_CASE_P(
  77     NEON_Y, AV1Convolve2DSrTest,
  78     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_y_sr_neon, 0, 1));
  79
  80 INSTANTIATE_TEST_CASE_P(
  81     NEON, AV1Convolve2DSrTest,
  82     libaom_test::AV1Convolve2D::BuildParams(av1_convolve_2d_sr_neon, 1, 1));
  83
  84 INSTANTIATE_TEST_CASE_P(NEON_COPY, AV1Convolve2DSrTest,
  85                         libaom_test::AV1Convolve2D::BuildParams(
  86                             av1_convolve_2d_copy_sr_neon, 0, 0));
  87 #endif  // HAVE_NEON
  88
  89 TEST_P(AV1JntConvolve2DTest, CheckOutput) { RunCheckOutput(GET_PARAM(0)); }
  90 TEST_P(AV1JntConvolve2DTest, DISABLED_Speed) { RunSpeedTest(GET_PARAM(0)); }
  91
  92 INSTANTIATE_TEST_CASE_P(
  93     C_COPY, AV1JntConvolve2DTest,
  94     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_copy_c, 0, 0));
  95
  96 INSTANTIATE_TEST_CASE_P(
  97     C_X, AV1JntConvolve2DTest,
  98     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_x_c, 1, 0));
  99
 100 INSTANTIATE_TEST_CASE_P(
 101     C_Y, AV1JntConvolve2DTest,
 102     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_y_c, 0, 1));
 103
 104 #if HAVE_SSE2
 105 INSTANTIATE_TEST_CASE_P(SSE2_COPY, AV1JntConvolve2DTest,
 106                         libaom_test::AV1Convolve2D::BuildParams(
 107                             av1_jnt_convolve_2d_copy_sse2, 0, 0));
 108 #if HAVE_SSE4_1
 109 INSTANTIATE_TEST_CASE_P(
 110     SSE2_X, AV1JntConvolve2DTest,
 111     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_x_sse2, 1, 0));
 112
 113 INSTANTIATE_TEST_CASE_P(
 114     SSE2_Y, AV1JntConvolve2DTest,
 115     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_y_sse2, 0, 1));
 116
 117 INSTANTIATE_TEST_CASE_P(
 118     SSSE3, AV1JntConvolve2DTest,
 119     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_ssse3, 1, 1));
 120
 121 #if HAVE_AVX2
 122 INSTANTIATE_TEST_CASE_P(AVX2_COPY, AV1JntConvolve2DTest,
 123                         libaom_test::AV1Convolve2D::BuildParams(
 124                             av1_jnt_convolve_2d_copy_avx2, 0, 0));
 125 INSTANTIATE_TEST_CASE_P(
 126     AVX2_X, AV1JntConvolve2DTest,
 127     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_x_avx2, 1, 0));
 128
 129 INSTANTIATE_TEST_CASE_P(
 130     AVX2_Y, AV1JntConvolve2DTest,
 131     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_y_avx2, 0, 1));
 132
 133 INSTANTIATE_TEST_CASE_P(
 134     AVX2, AV1JntConvolve2DTest,
 135     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_avx2, 1, 1));
 136 #endif  // HAVE_AVX2
 137 #endif  // HAVE_SSE4_1
 138 #endif  // HAVE_SSE2
 139 #if HAVE_NEON
 140 INSTANTIATE_TEST_CASE_P(NEON_COPY, AV1JntConvolve2DTest,
 141                         libaom_test::AV1Convolve2D::BuildParams(
 142                             av1_jnt_convolve_2d_copy_neon, 0, 0));
 143
 144 INSTANTIATE_TEST_CASE_P(
 145     NEON, AV1JntConvolve2DTest,
 146     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_2d_neon, 1, 1));
 147 INSTANTIATE_TEST_CASE_P(
 148     NEON_X, AV1JntConvolve2DTest,
 149     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_x_neon, 1, 0));
 150
 151 INSTANTIATE_TEST_CASE_P(
 152     NEON_Y, AV1JntConvolve2DTest,
 153     libaom_test::AV1Convolve2D::BuildParams(av1_jnt_convolve_y_neon, 0, 1));
 154 #endif  // HAVE_NEON
 155
 156 TEST_P(AV1HighbdConvolve2DSrTest, CheckOutput) { RunCheckOutput(GET_PARAM(1)); }
 157 TEST_P(AV1HighbdConvolve2DSrTest, DISABLED_Speed) {
 158   RunSpeedTest(GET_PARAM(1));
 159 }
 160
 161 INSTANTIATE_TEST_CASE_P(C_X, AV1HighbdConvolve2DSrTest,
 162                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 163                             av1_highbd_convolve_x_sr_c, 1, 0));
 164
 165 INSTANTIATE_TEST_CASE_P(C_Y, AV1HighbdConvolve2DSrTest,
 166                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 167                             av1_highbd_convolve_y_sr_c, 0, 1));
 168
 169 INSTANTIATE_TEST_CASE_P(C_COPY, AV1HighbdConvolve2DSrTest,
 170                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 171                             av1_highbd_convolve_2d_copy_sr_c, 0, 0));
 172 #if HAVE_SSE2
 173 INSTANTIATE_TEST_CASE_P(SSE2_COPY, AV1HighbdConvolve2DSrTest,
 174                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 175                             av1_highbd_convolve_2d_copy_sr_sse2, 0, 0));
 176 #if HAVE_SSSE3
 177 INSTANTIATE_TEST_CASE_P(SSSE3, AV1HighbdConvolve2DSrTest,
 178                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 179                             av1_highbd_convolve_2d_sr_ssse3, 1, 1));
 180 INSTANTIATE_TEST_CASE_P(SSSE3_X, AV1HighbdConvolve2DSrTest,
 181                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 182                             av1_highbd_convolve_x_sr_ssse3, 1, 0));
 183 INSTANTIATE_TEST_CASE_P(SSSE3_Y, AV1HighbdConvolve2DSrTest,
 184                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 185                             av1_highbd_convolve_y_sr_ssse3, 0, 1));
 186 #if HAVE_AVX2
 187 INSTANTIATE_TEST_CASE_P(AVX2, AV1HighbdConvolve2DSrTest,
 188                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 189                             av1_highbd_convolve_2d_sr_avx2, 1, 1));
 190 INSTANTIATE_TEST_CASE_P(AVX2_X, AV1HighbdConvolve2DSrTest,
 191                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 192                             av1_highbd_convolve_x_sr_avx2, 1, 0));
 193 INSTANTIATE_TEST_CASE_P(AVX2_Y, AV1HighbdConvolve2DSrTest,
 194                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 195                             av1_highbd_convolve_y_sr_avx2, 0, 1));
 196 INSTANTIATE_TEST_CASE_P(AVX2_COPY, AV1HighbdConvolve2DSrTest,
 197                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 198                             av1_highbd_convolve_2d_copy_sr_avx2, 0, 0));
 199 #endif  // HAVE_AVX2
 200 #endif  // HAVE_SSSE3
 201 #endif  // HAVE_SSE2
 202 TEST_P(AV1HighbdJntConvolve2DTest, CheckOutput) {
 203   RunCheckOutput(GET_PARAM(1));
 204 }
 205
 206 TEST_P(AV1HighbdJntConvolve2DTest, DISABLED_Speed) {
 207   RunSpeedTest(GET_PARAM(1));
 208 }
 209
 210 INSTANTIATE_TEST_CASE_P(C_X, AV1HighbdJntConvolve2DTest,
 211                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 212                             av1_highbd_jnt_convolve_x_c, 1, 0));
 213
 214 INSTANTIATE_TEST_CASE_P(C_Y, AV1HighbdJntConvolve2DTest,
 215                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 216                             av1_highbd_jnt_convolve_y_c, 0, 1));
 217
 218 INSTANTIATE_TEST_CASE_P(C_COPY, AV1HighbdJntConvolve2DTest,
 219                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 220                             av1_highbd_jnt_convolve_2d_copy_c, 0, 0));
 221 #if HAVE_SSE4_1
 222 INSTANTIATE_TEST_CASE_P(SSE4_1_COPY, AV1HighbdJntConvolve2DTest,
 223                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 224                             av1_highbd_jnt_convolve_2d_copy_sse4_1, 0, 0));
 225 INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdJntConvolve2DTest,
 226                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 227                             av1_highbd_jnt_convolve_2d_sse4_1, 1, 1));
 228 INSTANTIATE_TEST_CASE_P(SSE4_1_X, AV1HighbdJntConvolve2DTest,
 229                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 230                             av1_highbd_jnt_convolve_x_sse4_1, 1, 0));
 231 INSTANTIATE_TEST_CASE_P(SSE4_1_Y, AV1HighbdJntConvolve2DTest,
 232                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 233                             av1_highbd_jnt_convolve_y_sse4_1, 0, 1));
 234 #if HAVE_AVX2
 235 INSTANTIATE_TEST_CASE_P(AVX2_COPY, AV1HighbdJntConvolve2DTest,
 236                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 237                             av1_highbd_jnt_convolve_2d_copy_avx2, 0, 0));
 238 INSTANTIATE_TEST_CASE_P(AVX2, AV1HighbdJntConvolve2DTest,
 239                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 240                             av1_highbd_jnt_convolve_2d_avx2, 1, 1));
 241 INSTANTIATE_TEST_CASE_P(AVX2_X, AV1HighbdJntConvolve2DTest,
 242                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 243                             av1_highbd_jnt_convolve_x_avx2, 1, 0));
 244 INSTANTIATE_TEST_CASE_P(AVX2_Y, AV1HighbdJntConvolve2DTest,
 245                         libaom_test::AV1HighbdConvolve2D::BuildParams(
 246                             av1_highbd_jnt_convolve_y_avx2, 0, 1));
 247 #endif  // HAVE_AVX2
 248 #endif  // HAVE_SSE4_1
 249 }  // namespace