src/third_party/libvpx/source/libvpx/test/fdct8x8_test.cc

   1 /*
   2  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <math.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include "third_party/googletest/src/include/gtest/gtest.h"
  16 #include "test/acm_random.h"
  17 #include "test/clear_system_state.h"
  18 #include "test/register_state_check.h"
  19 #include "test/util.h"
  20
  21 #include "./vp9_rtcd.h"
  22 #include "vp9/common/vp9_entropy.h"
  23 #include "vpx/vpx_integer.h"
  24
  25 extern "C" {
  26 void vp9_idct8x8_64_add_c(const int16_t *input, uint8_t *output, int pitch);
  27 }
  28
  29 using libvpx_test::ACMRandom;
  30
  31 namespace {
  32 typedef void (*fdct_t)(const int16_t *in, int16_t *out, int stride);
  33 typedef void (*idct_t)(const int16_t *in, uint8_t *out, int stride);
  34 typedef void (*fht_t) (const int16_t *in, int16_t *out, int stride,
  35                        int tx_type);
  36 typedef void (*iht_t) (const int16_t *in, uint8_t *out, int stride,
  37                        int tx_type);
  38
  39 typedef std::tr1::tuple<fdct_t, idct_t, int> dct_8x8_param_t;
  40 typedef std::tr1::tuple<fht_t, iht_t, int> ht_8x8_param_t;
  41
  42 void fdct8x8_ref(const int16_t *in, int16_t *out, int stride, int tx_type) {
  43   vp9_fdct8x8_c(in, out, stride);
  44 }
  45
  46 void fht8x8_ref(const int16_t *in, int16_t *out, int stride, int tx_type) {
  47   vp9_fht8x8_c(in, out, stride, tx_type);
  48 }
  49
  50 class FwdTrans8x8TestBase {
  51  public:
  52   virtual ~FwdTrans8x8TestBase() {}
  53
  54  protected:
  55   virtual void RunFwdTxfm(int16_t *in, int16_t *out, int stride) = 0;
  56   virtual void RunInvTxfm(int16_t *out, uint8_t *dst, int stride) = 0;
  57
  58   void RunSignBiasCheck() {
  59     ACMRandom rnd(ACMRandom::DeterministicSeed());
  60     DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
  61     DECLARE_ALIGNED_ARRAY(16, int16_t, test_output_block, 64);
  62     int count_sign_block[64][2];
  63     const int count_test_block = 100000;
  64
  65     memset(count_sign_block, 0, sizeof(count_sign_block));
  66
  67     for (int i = 0; i < count_test_block; ++i) {
  68       // Initialize a test block with input range [-255, 255].
  69       for (int j = 0; j < 64; ++j)
  70         test_input_block[j] = rnd.Rand8() - rnd.Rand8();
  71       REGISTER_STATE_CHECK(
  72           RunFwdTxfm(test_input_block, test_output_block, pitch_));
  73
  74       for (int j = 0; j < 64; ++j) {
  75         if (test_output_block[j] < 0)
  76           ++count_sign_block[j][0];
  77         else if (test_output_block[j] > 0)
  78           ++count_sign_block[j][1];
  79       }
  80     }
  81
  82     for (int j = 0; j < 64; ++j) {
  83       const int diff = abs(count_sign_block[j][0] - count_sign_block[j][1]);
  84       const int max_diff = 1125;
  85       EXPECT_LT(diff, max_diff)
  86           << "Error: 8x8 FDCT/FHT has a sign bias > "
  87           << 1. * max_diff / count_test_block * 100 << "%"
  88           << " for input range [-255, 255] at index " << j
  89           << " count0: " << count_sign_block[j][0]
  90           << " count1: " << count_sign_block[j][1]
  91           << " diff: " << diff;
  92     }
  93
  94     memset(count_sign_block, 0, sizeof(count_sign_block));
  95
  96     for (int i = 0; i < count_test_block; ++i) {
  97       // Initialize a test block with input range [-15, 15].
  98       for (int j = 0; j < 64; ++j)
  99         test_input_block[j] = (rnd.Rand8() >> 4) - (rnd.Rand8() >> 4);
 100       REGISTER_STATE_CHECK(
 101           RunFwdTxfm(test_input_block, test_output_block, pitch_));
 102
 103       for (int j = 0; j < 64; ++j) {
 104         if (test_output_block[j] < 0)
 105           ++count_sign_block[j][0];
 106         else if (test_output_block[j] > 0)
 107           ++count_sign_block[j][1];
 108       }
 109     }
 110
 111     for (int j = 0; j < 64; ++j) {
 112       const int diff = abs(count_sign_block[j][0] - count_sign_block[j][1]);
 113       const int max_diff = 10000;
 114       EXPECT_LT(diff, max_diff)
 115           << "Error: 4x4 FDCT/FHT has a sign bias > "
 116           << 1. * max_diff / count_test_block * 100 << "%"
 117           << " for input range [-15, 15] at index " << j
 118           << " count0: " << count_sign_block[j][0]
 119           << " count1: " << count_sign_block[j][1]
 120           << " diff: " << diff;
 121     }
 122   }
 123
 124   void RunRoundTripErrorCheck() {
 125     ACMRandom rnd(ACMRandom::DeterministicSeed());
 126     int max_error = 0;
 127     int total_error = 0;
 128     const int count_test_block = 100000;
 129     DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
 130     DECLARE_ALIGNED_ARRAY(16, int16_t, test_temp_block, 64);
 131     DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, 64);
 132     DECLARE_ALIGNED_ARRAY(16, uint8_t, src, 64);
 133
 134     for (int i = 0; i < count_test_block; ++i) {
 135       // Initialize a test block with input range [-255, 255].
 136       for (int j = 0; j < 64; ++j) {
 137         src[j] = rnd.Rand8();
 138         dst[j] = rnd.Rand8();
 139         test_input_block[j] = src[j] - dst[j];
 140       }
 141
 142       REGISTER_STATE_CHECK(
 143           RunFwdTxfm(test_input_block, test_temp_block, pitch_));
 144       for (int j = 0; j < 64; ++j) {
 145           if (test_temp_block[j] > 0) {
 146             test_temp_block[j] += 2;
 147             test_temp_block[j] /= 4;
 148             test_temp_block[j] *= 4;
 149           } else {
 150             test_temp_block[j] -= 2;
 151             test_temp_block[j] /= 4;
 152             test_temp_block[j] *= 4;
 153           }
 154       }
 155       REGISTER_STATE_CHECK(
 156           RunInvTxfm(test_temp_block, dst, pitch_));
 157
 158       for (int j = 0; j < 64; ++j) {
 159         const int diff = dst[j] - src[j];
 160         const int error = diff * diff;
 161         if (max_error < error)
 162           max_error = error;
 163         total_error += error;
 164       }
 165     }
 166
 167     EXPECT_GE(1, max_error)
 168       << "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual"
 169       << " roundtrip error > 1";
 170
 171     EXPECT_GE(count_test_block/5, total_error)
 172       << "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip "
 173       << "error > 1/5 per block";
 174   }
 175
 176   void RunExtremalCheck() {
 177     ACMRandom rnd(ACMRandom::DeterministicSeed());
 178     int max_error = 0;
 179     int total_error = 0;
 180     const int count_test_block = 100000;
 181     DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
 182     DECLARE_ALIGNED_ARRAY(16, int16_t, test_temp_block, 64);
 183     DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, 64);
 184     DECLARE_ALIGNED_ARRAY(16, uint8_t, src, 64);
 185
 186     for (int i = 0; i < count_test_block; ++i) {
 187       // Initialize a test block with input range [-255, 255].
 188       for (int j = 0; j < 64; ++j) {
 189         src[j] = rnd.Rand8() % 2 ? 255 : 0;
 190         dst[j] = src[j] > 0 ? 0 : 255;
 191         test_input_block[j] = src[j] - dst[j];
 192       }
 193
 194       REGISTER_STATE_CHECK(
 195           RunFwdTxfm(test_input_block, test_temp_block, pitch_));
 196       REGISTER_STATE_CHECK(
 197           RunInvTxfm(test_temp_block, dst, pitch_));
 198
 199       for (int j = 0; j < 64; ++j) {
 200         const int diff = dst[j] - src[j];
 201         const int error = diff * diff;
 202         if (max_error < error)
 203           max_error = error;
 204         total_error += error;
 205       }
 206
 207       EXPECT_GE(1, max_error)
 208           << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has"
 209           << "an individual roundtrip error > 1";
 210
 211       EXPECT_GE(count_test_block/5, total_error)
 212           << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average"
 213           << " roundtrip error > 1/5 per block";
 214     }
 215   }
 216
 217   int pitch_;
 218   int tx_type_;
 219   fht_t fwd_txfm_ref;
 220 };
 221
 222 class FwdTrans8x8DCT
 223     : public FwdTrans8x8TestBase,
 224       public ::testing::TestWithParam<dct_8x8_param_t> {
 225  public:
 226   virtual ~FwdTrans8x8DCT() {}
 227
 228   virtual void SetUp() {
 229     fwd_txfm_ = GET_PARAM(0);
 230     inv_txfm_ = GET_PARAM(1);
 231     tx_type_  = GET_PARAM(2);
 232     pitch_    = 8;
 233     fwd_txfm_ref = fdct8x8_ref;
 234   }
 235
 236   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 237
 238  protected:
 239   void RunFwdTxfm(int16_t *in, int16_t *out, int stride) {
 240     fwd_txfm_(in, out, stride);
 241   }
 242   void RunInvTxfm(int16_t *out, uint8_t *dst, int stride) {
 243     inv_txfm_(out, dst, stride);
 244   }
 245
 246   fdct_t fwd_txfm_;
 247   idct_t inv_txfm_;
 248 };
 249
 250 TEST_P(FwdTrans8x8DCT, SignBiasCheck) {
 251   RunSignBiasCheck();
 252 }
 253
 254 TEST_P(FwdTrans8x8DCT, RoundTripErrorCheck) {
 255   RunRoundTripErrorCheck();
 256 }
 257
 258 TEST_P(FwdTrans8x8DCT, ExtremalCheck) {
 259   RunExtremalCheck();
 260 }
 261
 262 class FwdTrans8x8HT
 263     : public FwdTrans8x8TestBase,
 264       public ::testing::TestWithParam<ht_8x8_param_t> {
 265  public:
 266   virtual ~FwdTrans8x8HT() {}
 267
 268   virtual void SetUp() {
 269     fwd_txfm_ = GET_PARAM(0);
 270     inv_txfm_ = GET_PARAM(1);
 271     tx_type_  = GET_PARAM(2);
 272     pitch_    = 8;
 273     fwd_txfm_ref = fht8x8_ref;
 274   }
 275
 276   virtual void TearDown() { libvpx_test::ClearSystemState(); }
 277
 278  protected:
 279   void RunFwdTxfm(int16_t *in, int16_t *out, int stride) {
 280     fwd_txfm_(in, out, stride, tx_type_);
 281   }
 282   void RunInvTxfm(int16_t *out, uint8_t *dst, int stride) {
 283     inv_txfm_(out, dst, stride, tx_type_);
 284   }
 285
 286   fht_t fwd_txfm_;
 287   iht_t inv_txfm_;
 288 };
 289
 290 TEST_P(FwdTrans8x8HT, SignBiasCheck) {
 291   RunSignBiasCheck();
 292 }
 293
 294 TEST_P(FwdTrans8x8HT, RoundTripErrorCheck) {
 295   RunRoundTripErrorCheck();
 296 }
 297
 298 TEST_P(FwdTrans8x8HT, ExtremalCheck) {
 299   RunExtremalCheck();
 300 }
 301
 302 using std::tr1::make_tuple;
 303
 304 INSTANTIATE_TEST_CASE_P(
 305     C, FwdTrans8x8DCT,
 306     ::testing::Values(
 307         make_tuple(&vp9_fdct8x8_c, &vp9_idct8x8_64_add_c, 0)));
 308 INSTANTIATE_TEST_CASE_P(
 309     C, FwdTrans8x8HT,
 310     ::testing::Values(
 311         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 0),
 312         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 1),
 313         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 2),
 314         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 3)));
 315
 316 #if HAVE_NEON_ASM
 317 INSTANTIATE_TEST_CASE_P(
 318     NEON, FwdTrans8x8DCT,
 319     ::testing::Values(
 320         make_tuple(&vp9_fdct8x8_c, &vp9_idct8x8_64_add_neon, 0)));
 321 INSTANTIATE_TEST_CASE_P(
 322     DISABLED_NEON, FwdTrans8x8HT,
 323     ::testing::Values(
 324         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_neon, 0),
 325         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_neon, 1),
 326         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_neon, 2),
 327         make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_neon, 3)));
 328 #endif
 329
 330 #if HAVE_SSE2
 331 INSTANTIATE_TEST_CASE_P(
 332     SSE2, FwdTrans8x8DCT,
 333     ::testing::Values(
 334         make_tuple(&vp9_fdct8x8_sse2, &vp9_idct8x8_64_add_sse2, 0)));
 335 INSTANTIATE_TEST_CASE_P(
 336     SSE2, FwdTrans8x8HT,
 337     ::testing::Values(
 338         make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 0),
 339         make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 1),
 340         make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 2),
 341         make_tuple(&vp9_fht8x8_sse2, &vp9_iht8x8_64_add_sse2, 3)));
 342 #endif
 343
 344 #if HAVE_SSSE3 && ARCH_X86_64
 345 INSTANTIATE_TEST_CASE_P(
 346     SSSE3, FwdTrans8x8DCT,
 347     ::testing::Values(
 348         make_tuple(&vp9_fdct8x8_ssse3, &vp9_idct8x8_64_add_ssse3, 0)));
 349 #endif
 350 }  // namespace