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 <limits.h> 12 #include <stdio.h> 13 #include <string.h> 14 15 #include "third_party/googletest/src/include/gtest/gtest.h" 16 17 #include "./vpx_config.h" 18 #if CONFIG_VP9_ENCODER 19 #include "./vp9_rtcd.h" 20 #endif 21 22 #include "test/acm_random.h" 23 #include "test/clear_system_state.h" 24 #include "test/register_state_check.h" 25 #include "test/util.h" 26 27 #include "vpx_mem/vpx_mem.h" 28 29 extern "C" double vp9_get_blockiness(const unsigned char *img1, int img1_pitch, 30 const unsigned char *img2, int img2_pitch, 31 int width, int height); 32 33 using libvpx_test::ACMRandom; 34 35 namespace { 36 class BlockinessTestBase : public ::testing::Test { 37 public: 38 BlockinessTestBase(int width, int height) : width_(width), height_(height) {} 39 40 static void SetUpTestCase() { 41 source_data_ = reinterpret_cast<uint8_t *>( 42 vpx_memalign(kDataAlignment, kDataBufferSize)); 43 reference_data_ = reinterpret_cast<uint8_t *>( 44 vpx_memalign(kDataAlignment, kDataBufferSize)); 45 } 46 47 static void TearDownTestCase() { 48 vpx_free(source_data_); 49 source_data_ = NULL; 50 vpx_free(reference_data_); 51 reference_data_ = NULL; 52 } 53 54 virtual void TearDown() { libvpx_test::ClearSystemState(); } 55 56 protected: 57 // Handle frames up to 640x480 58 static const int kDataAlignment = 16; 59 static const int kDataBufferSize = 640 * 480; 60 61 virtual void SetUp() { 62 source_stride_ = (width_ + 31) & ~31; 63 reference_stride_ = width_ * 2; 64 rnd_.Reset(ACMRandom::DeterministicSeed()); 65 } 66 67 void FillConstant(uint8_t *data, int stride, uint8_t fill_constant, int width, 68 int height) { 69 for (int h = 0; h < height; ++h) { 70 for (int w = 0; w < width; ++w) { 71 data[h * stride + w] = fill_constant; 72 } 73 } 74 } 75 76 void FillConstant(uint8_t *data, int stride, uint8_t fill_constant) { 77 FillConstant(data, stride, fill_constant, width_, height_); 78 } 79 80 void FillRandom(uint8_t *data, int stride, int width, int height) { 81 for (int h = 0; h < height; ++h) { 82 for (int w = 0; w < width; ++w) { 83 data[h * stride + w] = rnd_.Rand8(); 84 } 85 } 86 } 87 88 void FillRandom(uint8_t *data, int stride) { 89 FillRandom(data, stride, width_, height_); 90 } 91 92 void FillRandomBlocky(uint8_t *data, int stride) { 93 for (int h = 0; h < height_; h += 4) { 94 for (int w = 0; w < width_; w += 4) { 95 FillRandom(data + h * stride + w, stride, 4, 4); 96 } 97 } 98 } 99 100 void FillCheckerboard(uint8_t *data, int stride) { 101 for (int h = 0; h < height_; h += 4) { 102 for (int w = 0; w < width_; w += 4) { 103 if (((h / 4) ^ (w / 4)) & 1) { 104 FillConstant(data + h * stride + w, stride, 255, 4, 4); 105 } else { 106 FillConstant(data + h * stride + w, stride, 0, 4, 4); 107 } 108 } 109 } 110 } 111 112 void Blur(uint8_t *data, int stride, int taps) { 113 int sum = 0; 114 int half_taps = taps / 2; 115 for (int h = 0; h < height_; ++h) { 116 for (int w = 0; w < taps; ++w) { 117 sum += data[w + h * stride]; 118 } 119 for (int w = taps; w < width_; ++w) { 120 sum += data[w + h * stride] - data[w - taps + h * stride]; 121 data[w - half_taps + h * stride] = (sum + half_taps) / taps; 122 } 123 } 124 for (int w = 0; w < width_; ++w) { 125 for (int h = 0; h < taps; ++h) { 126 sum += data[h + w * stride]; 127 } 128 for (int h = taps; h < height_; ++h) { 129 sum += data[w + h * stride] - data[(h - taps) * stride + w]; 130 data[(h - half_taps) * stride + w] = (sum + half_taps) / taps; 131 } 132 } 133 } 134 int width_, height_; 135 static uint8_t *source_data_; 136 int source_stride_; 137 static uint8_t *reference_data_; 138 int reference_stride_; 139 140 ACMRandom rnd_; 141 }; 142 143 #if CONFIG_VP9_ENCODER 144 typedef std::tr1::tuple<int, int> BlockinessParam; 145 class BlockinessVP9Test 146 : public BlockinessTestBase, 147 public ::testing::WithParamInterface<BlockinessParam> { 148 public: 149 BlockinessVP9Test() : BlockinessTestBase(GET_PARAM(0), GET_PARAM(1)) {} 150 151 protected: 152 double GetBlockiness() const { 153 return vp9_get_blockiness(source_data_, source_stride_, reference_data_, 154 reference_stride_, width_, height_); 155 } 156 }; 157 #endif // CONFIG_VP9_ENCODER 158 159 uint8_t *BlockinessTestBase::source_data_ = NULL; 160 uint8_t *BlockinessTestBase::reference_data_ = NULL; 161 162 #if CONFIG_VP9_ENCODER 163 TEST_P(BlockinessVP9Test, SourceBlockierThanReference) { 164 // Source is blockier than reference. 165 FillRandomBlocky(source_data_, source_stride_); 166 FillConstant(reference_data_, reference_stride_, 128); 167 const double super_blocky = GetBlockiness(); 168 169 EXPECT_DOUBLE_EQ(0.0, super_blocky) 170 << "Blocky source should produce 0 blockiness."; 171 } 172 173 TEST_P(BlockinessVP9Test, ReferenceBlockierThanSource) { 174 // Source is blockier than reference. 175 FillConstant(source_data_, source_stride_, 128); 176 FillRandomBlocky(reference_data_, reference_stride_); 177 const double super_blocky = GetBlockiness(); 178 179 EXPECT_GT(super_blocky, 0.0) 180 << "Blocky reference should score high for blockiness."; 181 } 182 183 TEST_P(BlockinessVP9Test, BlurringDecreasesBlockiness) { 184 // Source is blockier than reference. 185 FillConstant(source_data_, source_stride_, 128); 186 FillRandomBlocky(reference_data_, reference_stride_); 187 const double super_blocky = GetBlockiness(); 188 189 Blur(reference_data_, reference_stride_, 4); 190 const double less_blocky = GetBlockiness(); 191 192 EXPECT_GT(super_blocky, less_blocky) 193 << "A straight blur should decrease blockiness."; 194 } 195 196 TEST_P(BlockinessVP9Test, WorstCaseBlockiness) { 197 // Source is blockier than reference. 198 FillConstant(source_data_, source_stride_, 128); 199 FillCheckerboard(reference_data_, reference_stride_); 200 201 const double super_blocky = GetBlockiness(); 202 203 Blur(reference_data_, reference_stride_, 4); 204 const double less_blocky = GetBlockiness(); 205 206 EXPECT_GT(super_blocky, less_blocky) 207 << "A straight blur should decrease blockiness."; 208 } 209 #endif // CONFIG_VP9_ENCODER 210 211 using std::tr1::make_tuple; 212 213 //------------------------------------------------------------------------------ 214 // C functions 215 216 #if CONFIG_VP9_ENCODER 217 const BlockinessParam c_vp9_tests[] = { 218 make_tuple(320, 240), make_tuple(318, 242), make_tuple(318, 238), 219 }; 220 INSTANTIATE_TEST_CASE_P(C, BlockinessVP9Test, ::testing::ValuesIn(c_vp9_tests)); 221 #endif 222 223 } // namespace 224
