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 "vpx_ports/mem.h"
  17
  18 extern "C" {
  19 #include "vp9_rtcd.h"
  20 void vp9_short_idct8x8_add_c(short *input, uint8_t *output, int pitch);
  21 }
  22
  23 #include "acm_random.h"
  24 #include "vpx/vpx_integer.h"
  25
  26 using libvpx_test::ACMRandom;
  27
  28 namespace {
  29 void fdct8x8(int16_t *in, int16_t *out, uint8_t* /*dst*/,
  30              int stride, int /*tx_type*/) {
  31   vp9_short_fdct8x8_c(in, out, stride);
  32 }
  33 void idct8x8_add(int16_t* /*in*/, int16_t *out, uint8_t *dst,
  34                  int stride, int /*tx_type*/) {
  35   vp9_short_idct8x8_add_c(out, dst, stride >> 1);
  36 }
  37 void fht8x8(int16_t *in, int16_t *out, uint8_t* /*dst*/,
  38             int stride, int tx_type) {
  39   // TODO(jingning): need to refactor this to test both _c and _sse2 functions,
  40   // when we have all inverse dct functions done sse2.
  41 #if HAVE_SSE2
  42   vp9_short_fht8x8_sse2(in, out, stride >> 1, tx_type);
  43 #else
  44   vp9_short_fht8x8_c(in, out, stride >> 1, tx_type);
  45 #endif
  46 }
  47 void iht8x8_add(int16_t* /*in*/, int16_t *out, uint8_t *dst,
  48                 int stride, int tx_type) {
  49   vp9_short_iht8x8_add_c(out, dst, stride >> 1, tx_type);
  50 }
  51
  52 class FwdTrans8x8Test : public ::testing::TestWithParam<int> {
  53  public:
  54   virtual ~FwdTrans8x8Test() {}
  55   virtual void SetUp() {
  56     tx_type_ = GetParam();
  57     if (tx_type_ == 0) {
  58       fwd_txfm = fdct8x8;
  59       inv_txfm = idct8x8_add;
  60     } else {
  61       fwd_txfm = fht8x8;
  62       inv_txfm = iht8x8_add;
  63     }
  64   }
  65
  66  protected:
  67   void RunFwdTxfm(int16_t *in, int16_t *out, uint8_t *dst,
  68                   int stride, int tx_type) {
  69     (*fwd_txfm)(in, out, dst, stride, tx_type);
  70   }
  71   void RunInvTxfm(int16_t *in, int16_t *out, uint8_t *dst,
  72                   int stride, int tx_type) {
  73     (*inv_txfm)(in, out, dst, stride, tx_type);
  74   }
  75
  76   int tx_type_;
  77   void (*fwd_txfm)(int16_t*, int16_t*, uint8_t*, int, int);
  78   void (*inv_txfm)(int16_t*, int16_t*, uint8_t*, int, int);
  79 };
  80
  81 TEST_P(FwdTrans8x8Test, SignBiasCheck) {
  82   ACMRandom rnd(ACMRandom::DeterministicSeed());
  83   DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
  84   DECLARE_ALIGNED_ARRAY(16, int16_t, test_output_block, 64);
  85   const int pitch = 16;
  86   int count_sign_block[64][2];
  87   const int count_test_block = 100000;
  88
  89   memset(count_sign_block, 0, sizeof(count_sign_block));
  90
  91   for (int i = 0; i < count_test_block; ++i) {
  92     // Initialize a test block with input range [-255, 255].
  93     for (int j = 0; j < 64; ++j)
  94       test_input_block[j] = rnd.Rand8() - rnd.Rand8();
  95
  96     RunFwdTxfm(test_input_block, test_output_block, NULL, pitch, tx_type_);
  97
  98     for (int j = 0; j < 64; ++j) {
  99       if (test_output_block[j] < 0)
 100         ++count_sign_block[j][0];
 101       else if (test_output_block[j] > 0)
 102         ++count_sign_block[j][1];
 103     }
 104   }
 105
 106   for (int j = 0; j < 64; ++j) {
 107     const int diff = abs(count_sign_block[j][0] - count_sign_block[j][1]);
 108     const int max_diff = 1125;
 109     EXPECT_LT(diff, max_diff)
 110         << "Error: 8x8 FDCT/FHT has a sign bias > "
 111         << 1. * max_diff / count_test_block * 100 << "%"
 112         << " for input range [-255, 255] at index " << j
 113         << " count0: " << count_sign_block[j][0]
 114         << " count1: " << count_sign_block[j][1]
 115         << " diff: " << diff;
 116   }
 117
 118   memset(count_sign_block, 0, sizeof(count_sign_block));
 119
 120   for (int i = 0; i < count_test_block; ++i) {
 121     // Initialize a test block with input range [-15, 15].
 122     for (int j = 0; j < 64; ++j)
 123       test_input_block[j] = (rnd.Rand8() >> 4) - (rnd.Rand8() >> 4);
 124
 125     RunFwdTxfm(test_input_block, test_output_block, NULL, pitch, tx_type_);
 126
 127     for (int j = 0; j < 64; ++j) {
 128       if (test_output_block[j] < 0)
 129         ++count_sign_block[j][0];
 130       else if (test_output_block[j] > 0)
 131         ++count_sign_block[j][1];
 132     }
 133   }
 134
 135   for (int j = 0; j < 64; ++j) {
 136     const int diff = abs(count_sign_block[j][0] - count_sign_block[j][1]);
 137     const int max_diff = 10000;
 138     EXPECT_LT(diff, max_diff)
 139         << "Error: 4x4 FDCT/FHT has a sign bias > "
 140         << 1. * max_diff / count_test_block * 100 << "%"
 141         << " for input range [-15, 15] at index " << j
 142         << " count0: " << count_sign_block[j][0]
 143         << " count1: " << count_sign_block[j][1]
 144         << " diff: " << diff;
 145   }
 146 }
 147
 148 TEST_P(FwdTrans8x8Test, RoundTripErrorCheck) {
 149   ACMRandom rnd(ACMRandom::DeterministicSeed());
 150   int max_error = 0;
 151   double total_error = 0;
 152   const int count_test_block = 100000;
 153   for (int i = 0; i < count_test_block; ++i) {
 154     DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
 155     DECLARE_ALIGNED_ARRAY(16, int16_t, test_temp_block, 64);
 156     DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, 64);
 157     DECLARE_ALIGNED_ARRAY(16, uint8_t, src, 64);
 158
 159     for (int j = 0; j < 64; ++j) {
 160       src[j] = rnd.Rand8();
 161       dst[j] = rnd.Rand8();
 162     }
 163     // Initialize a test block with input range [-255, 255].
 164     for (int j = 0; j < 64; ++j)
 165       test_input_block[j] = src[j] - dst[j];
 166
 167     const int pitch = 16;
 168     RunFwdTxfm(test_input_block, test_temp_block, dst, pitch, tx_type_);
 169     for (int j = 0; j < 64; ++j){
 170         if(test_temp_block[j] > 0) {
 171           test_temp_block[j] += 2;
 172           test_temp_block[j] /= 4;
 173           test_temp_block[j] *= 4;
 174         } else {
 175           test_temp_block[j] -= 2;
 176           test_temp_block[j] /= 4;
 177           test_temp_block[j] *= 4;
 178         }
 179     }
 180     RunInvTxfm(test_input_block, test_temp_block, dst, pitch, tx_type_);
 181
 182     for (int j = 0; j < 64; ++j) {
 183       const int diff = dst[j] - src[j];
 184       const int error = diff * diff;
 185       if (max_error < error)
 186         max_error = error;
 187       total_error += error;
 188     }
 189   }
 190
 191   EXPECT_GE(1, max_error)
 192     << "Error: 8x8 FDCT/IDCT or FHT/IHT has an individual roundtrip error > 1";
 193
 194   EXPECT_GE(count_test_block/5, total_error)
 195     << "Error: 8x8 FDCT/IDCT or FHT/IHT has average roundtrip "
 196         "error > 1/5 per block";
 197 }
 198
 199 TEST_P(FwdTrans8x8Test, ExtremalCheck) {
 200   ACMRandom rnd(ACMRandom::DeterministicSeed());
 201   int max_error = 0;
 202   double total_error = 0;
 203   const int count_test_block = 100000;
 204   for (int i = 0; i < count_test_block; ++i) {
 205     DECLARE_ALIGNED_ARRAY(16, int16_t, test_input_block, 64);
 206     DECLARE_ALIGNED_ARRAY(16, int16_t, test_temp_block, 64);
 207     DECLARE_ALIGNED_ARRAY(16, uint8_t, dst, 64);
 208     DECLARE_ALIGNED_ARRAY(16, uint8_t, src, 64);
 209
 210     for (int j = 0; j < 64; ++j) {
 211       src[j] = rnd.Rand8() % 2 ? 255 : 0;
 212       dst[j] = src[j] > 0 ? 0 : 255;
 213     }
 214     // Initialize a test block with input range [-255, 255].
 215     for (int j = 0; j < 64; ++j)
 216       test_input_block[j] = src[j] - dst[j];
 217
 218     const int pitch = 16;
 219     RunFwdTxfm(test_input_block, test_temp_block, dst, pitch, tx_type_);
 220     RunInvTxfm(test_input_block, test_temp_block, dst, pitch, tx_type_);
 221
 222     for (int j = 0; j < 64; ++j) {
 223       const int diff = dst[j] - src[j];
 224       const int error = diff * diff;
 225       if (max_error < error)
 226         max_error = error;
 227       total_error += error;
 228     }
 229
 230     EXPECT_GE(1, max_error)
 231         << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has an"
 232         << " individual roundtrip error > 1";
 233
 234     EXPECT_GE(count_test_block/5, total_error)
 235         << "Error: Extremal 8x8 FDCT/IDCT or FHT/IHT has average"
 236         << " roundtrip error > 1/5 per block";
 237   }
 238 }
 239
 240 INSTANTIATE_TEST_CASE_P(VP9, FwdTrans8x8Test, ::testing::Range(0, 4));
 241 }  // namespace