av1_inv_txfm_test.cc 9.13 KB
Newer Older
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4 5 6 7 8 9
 * 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.
Johann's avatar
Johann committed
10
 */
11 12 13 14 15

#include <math.h>
#include <stdlib.h>
#include <string.h>

16
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
17

18 19
#include "./av1_rtcd.h"
#include "./aom_dsp_rtcd.h"
20
#include "test/acm_random.h"
21
#include "test/av1_txfm_test.h"
22 23 24
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
25 26
#include "av1/common/blockd.h"
#include "av1/common/scan.h"
27
#include "aom/aom_integer.h"
28
#include "aom_dsp/inv_txfm.h"
29

30
using libaom_test::ACMRandom;
31 32 33 34 35

namespace {

typedef void (*IdctFunc)(const tran_low_t *in, tran_low_t *out);

36 37
typedef std::tr1::tuple<IdctFunc, int, int> IdctParam;
class AV1InvTxfm : public ::testing::TestWithParam<IdctParam> {
38
 public:
39 40 41 42 43
  virtual void SetUp() {
    inv_txfm_ = GET_PARAM(0);
    txfm_size_ = GET_PARAM(1);
    max_error_ = GET_PARAM(2);
  }
44 45 46 47

  void RunInvAccuracyCheck() {
    ACMRandom rnd(ACMRandom::DeterministicSeed());
    const int count_test_block = 5000;
clang-format's avatar
clang-format committed
48
    for (int ti = 0; ti < count_test_block; ++ti) {
Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
49 50
      tran_low_t input[64];
      double ref_input[64];
51 52 53 54 55
      for (int ni = 0; ni < txfm_size_; ++ni) {
        input[ni] = rnd.Rand8() - rnd.Rand8();
        ref_input[ni] = static_cast<double>(input[ni]);
      }

Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
56
      tran_low_t output[64];
57
      inv_txfm_(input, output);
Sebastien Alaiwan's avatar
Sebastien Alaiwan committed
58 59

      double ref_output[64];
60
      libaom_test::reference_idct_1d(ref_input, ref_output, txfm_size_);
61 62 63 64 65 66 67 68 69

      for (int ni = 0; ni < txfm_size_; ++ni) {
        EXPECT_LE(
            abs(output[ni] - static_cast<tran_low_t>(round(ref_output[ni]))),
            max_error_);
      }
    }
  }

70
 private:
71 72
  double max_error_;
  int txfm_size_;
73
  IdctFunc inv_txfm_;
74 75
};

76
TEST_P(AV1InvTxfm, RunInvAccuracyCheck) { RunInvAccuracyCheck(); }
77

78 79 80 81 82
INSTANTIATE_TEST_CASE_P(C, AV1InvTxfm,
                        ::testing::Values(IdctParam(&aom_idct4_c, 4, 1),
                                          IdctParam(&aom_idct8_c, 8, 2),
                                          IdctParam(&aom_idct16_c, 16, 4),
                                          IdctParam(&aom_idct32_c, 32, 6)));
83

84
#if CONFIG_AV1_ENCODER && !CONFIG_LV_MAP
85 86
typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
clang-format's avatar
clang-format committed
87 88
typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, InvTxfmFunc, TX_SIZE, int>
    PartialInvTxfmParam;
89
const int kMaxNumCoeffs = 1024;
90
class AV1PartialIDctTest
91 92
    : public ::testing::TestWithParam<PartialInvTxfmParam> {
 public:
93
  virtual ~AV1PartialIDctTest() {}
94 95 96 97
  virtual void SetUp() {
    ftxfm_ = GET_PARAM(0);
    full_itxfm_ = GET_PARAM(1);
    partial_itxfm_ = GET_PARAM(2);
clang-format's avatar
clang-format committed
98
    tx_size_ = GET_PARAM(3);
99 100 101
    last_nonzero_ = GET_PARAM(4);
  }

102
  virtual void TearDown() { libaom_test::ClearSystemState(); }
103 104 105 106 107 108 109 110 111

 protected:
  int last_nonzero_;
  TX_SIZE tx_size_;
  FwdTxfmFunc ftxfm_;
  InvTxfmFunc full_itxfm_;
  InvTxfmFunc partial_itxfm_;
};

Angie Chiang's avatar
Angie Chiang committed
112 113 114 115 116 117 118
static MB_MODE_INFO get_mbmi() {
  MB_MODE_INFO mbmi;
  mbmi.ref_frame[0] = LAST_FRAME;
  assert(is_inter_block(&mbmi));
  return mbmi;
}

119
TEST_P(AV1PartialIDctTest, RunQuantCheck) {
120 121
  int size;
  switch (tx_size_) {
clang-format's avatar
clang-format committed
122 123 124 125 126
    case TX_4X4: size = 4; break;
    case TX_8X8: size = 8; break;
    case TX_16X16: size = 16; break;
    case TX_32X32: size = 32; break;
    default: FAIL() << "Wrong Size!"; break;
127 128 129 130 131 132 133 134 135 136 137 138 139
  }
  DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, uint8_t, dst1[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, uint8_t, dst2[kMaxNumCoeffs]);

  const int count_test_block = 1000;
  const int block_size = size * size;

  DECLARE_ALIGNED(16, int16_t, input_extreme_block[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, tran_low_t, output_ref_block[kMaxNumCoeffs]);

  int max_error = 0;
140
  for (int m = 0; m < count_test_block; ++m) {
141 142 143 144 145 146 147 148
    // clear out destination buffer
    memset(dst1, 0, sizeof(*dst1) * block_size);
    memset(dst2, 0, sizeof(*dst2) * block_size);
    memset(test_coef_block1, 0, sizeof(*test_coef_block1) * block_size);
    memset(test_coef_block2, 0, sizeof(*test_coef_block2) * block_size);

    ACMRandom rnd(ACMRandom::DeterministicSeed());

149
    for (int n = 0; n < count_test_block; ++n) {
150
      // Initialize a test block with input range [-255, 255].
151
      if (n == 0) {
clang-format's avatar
clang-format committed
152
        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = 255;
153
      } else if (n == 1) {
clang-format's avatar
clang-format committed
154
        for (int j = 0; j < block_size; ++j) input_extreme_block[j] = -255;
155 156 157 158 159 160 161 162 163 164
      } else {
        for (int j = 0; j < block_size; ++j) {
          input_extreme_block[j] = rnd.Rand8() % 2 ? 255 : -255;
        }
      }

      ftxfm_(input_extreme_block, output_ref_block, size);

      // quantization with maximum allowed step sizes
      test_coef_block1[0] = (output_ref_block[0] / 1336) * 1336;
Angie Chiang's avatar
Angie Chiang committed
165
      MB_MODE_INFO mbmi = get_mbmi();
166
      for (int j = 1; j < last_nonzero_; ++j)
Angie Chiang's avatar
Angie Chiang committed
167
        test_coef_block1[get_scan((const AV1_COMMON *)NULL, tx_size_, DCT_DCT,
Angie Chiang's avatar
Angie Chiang committed
168
                                  &mbmi)
Angie Chiang's avatar
Angie Chiang committed
169
                             ->scan[j]] = (output_ref_block[j] / 1828) * 1828;
170 171 172 173 174 175 176 177
    }

    ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size));
    ASM_REGISTER_STATE_CHECK(partial_itxfm_(test_coef_block1, dst2, size));

    for (int j = 0; j < block_size; ++j) {
      const int diff = dst1[j] - dst2[j];
      const int error = diff * diff;
clang-format's avatar
clang-format committed
178
      if (max_error < error) max_error = error;
179 180 181 182 183 184 185
    }
  }

  EXPECT_EQ(0, max_error)
      << "Error: partial inverse transform produces different results";
}

186
TEST_P(AV1PartialIDctTest, ResultsMatch) {
187 188 189
  ACMRandom rnd(ACMRandom::DeterministicSeed());
  int size;
  switch (tx_size_) {
clang-format's avatar
clang-format committed
190 191 192 193 194
    case TX_4X4: size = 4; break;
    case TX_8X8: size = 8; break;
    case TX_16X16: size = 16; break;
    case TX_32X32: size = 32; break;
    default: FAIL() << "Wrong Size!"; break;
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
  }
  DECLARE_ALIGNED(16, tran_low_t, test_coef_block1[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, tran_low_t, test_coef_block2[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, uint8_t, dst1[kMaxNumCoeffs]);
  DECLARE_ALIGNED(16, uint8_t, dst2[kMaxNumCoeffs]);
  const int count_test_block = 1000;
  const int max_coeff = 32766 / 4;
  const int block_size = size * size;
  int max_error = 0;
  for (int i = 0; i < count_test_block; ++i) {
    // clear out destination buffer
    memset(dst1, 0, sizeof(*dst1) * block_size);
    memset(dst2, 0, sizeof(*dst2) * block_size);
    memset(test_coef_block1, 0, sizeof(*test_coef_block1) * block_size);
    memset(test_coef_block2, 0, sizeof(*test_coef_block2) * block_size);
    int max_energy_leftover = max_coeff * max_coeff;
    for (int j = 0; j < last_nonzero_; ++j) {
      int16_t coef = static_cast<int16_t>(sqrt(1.0 * max_energy_leftover) *
                                          (rnd.Rand16() - 32768) / 65536);
      max_energy_leftover -= coef * coef;
      if (max_energy_leftover < 0) {
        max_energy_leftover = 0;
        coef = 0;
      }
Angie Chiang's avatar
Angie Chiang committed
219 220 221
      MB_MODE_INFO mbmi = get_mbmi();
      test_coef_block1[get_scan((const AV1_COMMON *)NULL, tx_size_, DCT_DCT,
                                &mbmi)
Angie Chiang's avatar
Angie Chiang committed
222
                           ->scan[j]] = coef;
223 224 225 226 227 228 229 230 231 232 233
    }

    memcpy(test_coef_block2, test_coef_block1,
           sizeof(*test_coef_block2) * block_size);

    ASM_REGISTER_STATE_CHECK(full_itxfm_(test_coef_block1, dst1, size));
    ASM_REGISTER_STATE_CHECK(partial_itxfm_(test_coef_block2, dst2, size));

    for (int j = 0; j < block_size; ++j) {
      const int diff = dst1[j] - dst2[j];
      const int error = diff * diff;
clang-format's avatar
clang-format committed
234
      if (max_error < error) max_error = error;
235 236 237 238 239 240 241 242 243
    }
  }

  EXPECT_EQ(0, max_error)
      << "Error: partial inverse transform produces different results";
}
using std::tr1::make_tuple;

INSTANTIATE_TEST_CASE_P(
244
    C, AV1PartialIDctTest,
245 246 247 248 249 250 251 252 253 254 255 256 257 258
    ::testing::Values(make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
                                 &aom_idct32x32_34_add_c, TX_32X32, 34),
                      make_tuple(&aom_fdct32x32_c, &aom_idct32x32_1024_add_c,
                                 &aom_idct32x32_1_add_c, TX_32X32, 1),
                      make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
                                 &aom_idct16x16_10_add_c, TX_16X16, 10),
                      make_tuple(&aom_fdct16x16_c, &aom_idct16x16_256_add_c,
                                 &aom_idct16x16_1_add_c, TX_16X16, 1),
                      make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
                                 &aom_idct8x8_12_add_c, TX_8X8, 12),
                      make_tuple(&aom_fdct8x8_c, &aom_idct8x8_64_add_c,
                                 &aom_idct8x8_1_add_c, TX_8X8, 1),
                      make_tuple(&aom_fdct4x4_c, &aom_idct4x4_16_add_c,
                                 &aom_idct4x4_1_add_c, TX_4X4, 1)));
259
#endif  // CONFIG_AV1_ENCODER && !CONFIG_LV_MAP
260
}  // namespace