test/idct_test.cc

   1 /*
   2  *  Copyright (c) 2010 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 "./vpx_config.h"
  12 #include "./vp8_rtcd.h"
  13
  14 #include "third_party/googletest/src/include/gtest/gtest.h"
  15
  16 #include "test/buffer.h"
  17 #include "test/clear_system_state.h"
  18 #include "test/register_state_check.h"
  19 #include "vpx/vpx_integer.h"
  20
  21 typedef void (*IdctFunc)(int16_t *input, unsigned char *pred_ptr,
  22                          int pred_stride, unsigned char *dst_ptr,
  23                          int dst_stride);
  24 namespace {
  25
  26 using libvpx_test::Buffer;
  27
  28 class IDCTTest : public ::testing::TestWithParam<IdctFunc> {
  29  protected:
  30   virtual void SetUp() {
  31     UUT = GetParam();
  32
  33     input = new Buffer<int16_t>(4, 4, 0);
  34     ASSERT_TRUE(input != NULL);
  35     ASSERT_TRUE(input->Init());
  36     predict = new Buffer<uint8_t>(4, 4, 3);
  37     ASSERT_TRUE(predict != NULL);
  38     ASSERT_TRUE(predict->Init());
  39     output = new Buffer<uint8_t>(4, 4, 3);
  40     ASSERT_TRUE(output != NULL);
  41     ASSERT_TRUE(output->Init());
  42   }
  43
  44   virtual void TearDown() {
  45     delete input;
  46     delete predict;
  47     delete output;
  48     libvpx_test::ClearSystemState();
  49   }
  50
  51   IdctFunc UUT;
  52   Buffer<int16_t> *input;
  53   Buffer<uint8_t> *predict;
  54   Buffer<uint8_t> *output;
  55 };
  56
  57 TEST_P(IDCTTest, TestAllZeros) {
  58   // When the input is '0' the output will be '0'.
  59   input->Set(0);
  60   predict->Set(0);
  61   output->Set(0);
  62
  63   ASM_REGISTER_STATE_CHECK(UUT(input->TopLeftPixel(), predict->TopLeftPixel(),
  64                                predict->stride(), output->TopLeftPixel(),
  65                                output->stride()));
  66
  67   ASSERT_TRUE(input->CheckValues(0));
  68   ASSERT_TRUE(input->CheckPadding());
  69   ASSERT_TRUE(output->CheckValues(0));
  70   ASSERT_TRUE(output->CheckPadding());
  71 }
  72
  73 TEST_P(IDCTTest, TestAllOnes) {
  74   input->Set(0);
  75   if (input->TopLeftPixel() != NULL) {
  76     // When the first element is '4' it will fill the output buffer with '1'.
  77     input->TopLeftPixel()[0] = 4;
  78     predict->Set(0);
  79     output->Set(0);
  80
  81     ASM_REGISTER_STATE_CHECK(UUT(input->TopLeftPixel(), predict->TopLeftPixel(),
  82                                  predict->stride(), output->TopLeftPixel(),
  83                                  output->stride()));
  84
  85     ASSERT_TRUE(output->CheckValues(1));
  86     ASSERT_TRUE(output->CheckPadding());
  87   } else {
  88     assert(0);
  89   }
  90 }
  91
  92 TEST_P(IDCTTest, TestAddOne) {
  93   // Set the transform output to '1' and make sure it gets added to the
  94   // prediction buffer.
  95   input->Set(0);
  96   if (input->TopLeftPixel() != NULL) {
  97     input->TopLeftPixel()[0] = 4;
  98     output->Set(0);
  99
 100     uint8_t *pred = predict->TopLeftPixel();
 101     for (int y = 0; y < 4; ++y) {
 102       for (int x = 0; x < 4; ++x) {
 103         pred[y * predict->stride() + x] = y * 4 + x;
 104       }
 105     }
 106
 107     ASM_REGISTER_STATE_CHECK(UUT(input->TopLeftPixel(), predict->TopLeftPixel(),
 108                                  predict->stride(), output->TopLeftPixel(),
 109                                  output->stride()));
 110
 111     uint8_t const *out = output->TopLeftPixel();
 112     for (int y = 0; y < 4; ++y) {
 113       for (int x = 0; x < 4; ++x) {
 114         EXPECT_EQ(1 + y * 4 + x, out[y * output->stride() + x]);
 115       }
 116     }
 117
 118     if (HasFailure()) {
 119       output->DumpBuffer();
 120     }
 121
 122     ASSERT_TRUE(output->CheckPadding());
 123   } else {
 124     assert(0);
 125   }
 126 }
 127
 128 TEST_P(IDCTTest, TestWithData) {
 129   // Test a single known input.
 130   predict->Set(0);
 131
 132   int16_t *in = input->TopLeftPixel();
 133   for (int y = 0; y < 4; ++y) {
 134     for (int x = 0; x < 4; ++x) {
 135       in[y * input->stride() + x] = y * 4 + x;
 136     }
 137   }
 138
 139   ASM_REGISTER_STATE_CHECK(UUT(input->TopLeftPixel(), predict->TopLeftPixel(),
 140                                predict->stride(), output->TopLeftPixel(),
 141                                output->stride()));
 142
 143   uint8_t *out = output->TopLeftPixel();
 144   for (int y = 0; y < 4; ++y) {
 145     for (int x = 0; x < 4; ++x) {
 146       switch (y * 4 + x) {
 147         case 0: EXPECT_EQ(11, out[y * output->stride() + x]); break;
 148         case 2:
 149         case 5:
 150         case 8: EXPECT_EQ(3, out[y * output->stride() + x]); break;
 151         case 10: EXPECT_EQ(1, out[y * output->stride() + x]); break;
 152         default: EXPECT_EQ(0, out[y * output->stride() + x]);
 153       }
 154     }
 155   }
 156
 157   if (HasFailure()) {
 158     output->DumpBuffer();
 159   }
 160
 161   ASSERT_TRUE(output->CheckPadding());
 162 }
 163
 164 INSTANTIATE_TEST_CASE_P(C, IDCTTest, ::testing::Values(vp8_short_idct4x4llm_c));
 165
 166 #if HAVE_NEON
 167 INSTANTIATE_TEST_CASE_P(NEON, IDCTTest,
 168                         ::testing::Values(vp8_short_idct4x4llm_neon));
 169 #endif  // HAVE_NEON
 170
 171 #if HAVE_MMX
 172 INSTANTIATE_TEST_CASE_P(MMX, IDCTTest,
 173                         ::testing::Values(vp8_short_idct4x4llm_mmx));
 174 #endif  // HAVE_MMX
 175
 176 #if HAVE_MSA
 177 INSTANTIATE_TEST_CASE_P(MSA, IDCTTest,
 178                         ::testing::Values(vp8_short_idct4x4llm_msa));
 179 #endif  // HAVE_MSA
 180
 181 #if HAVE_MMI
 182 INSTANTIATE_TEST_CASE_P(MMI, IDCTTest,
 183                         ::testing::Values(vp8_short_idct4x4llm_mmi));
 184 #endif  // HAVE_MMI
 185 }  // namespace