test/consistency_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 <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 #include "vpx_dsp/ssim.h"
  27 #include "vpx_mem/vpx_mem.h"
  28
  29 extern "C"
  30 double vpx_get_ssim_metrics(uint8_t *img1, int img1_pitch,
  31                             uint8_t *img2, int img2_pitch,
  32                             int width, int height,
  33                             Ssimv *sv2, Metrics *m,
  34                             int do_inconsistency);
  35
  36 using libvpx_test::ACMRandom;
  37
  38 namespace {
  39 class ConsistencyTestBase : public ::testing::Test {
  40  public:
  41   ConsistencyTestBase(int width, int height) : width_(width), height_(height) {}
  42
  43   static void SetUpTestCase() {
  44     source_data_[0] = reinterpret_cast<uint8_t*>(
  45         vpx_memalign(kDataAlignment, kDataBufferSize));
  46     reference_data_[0] = reinterpret_cast<uint8_t*>(
  47         vpx_memalign(kDataAlignment, kDataBufferSize));
  48     source_data_[1] = reinterpret_cast<uint8_t*>(
  49         vpx_memalign(kDataAlignment, kDataBufferSize));
  50     reference_data_[1] = reinterpret_cast<uint8_t*>(
  51         vpx_memalign(kDataAlignment, kDataBufferSize));
  52     ssim_array_ = new Ssimv[kDataBufferSize / 16];
  53   }
  54
  55   static void ClearSsim() {
  56     memset(ssim_array_, 0, kDataBufferSize / 16);
  57   }
  58   static void TearDownTestCase() {
  59     vpx_free(source_data_[0]);
  60     source_data_[0] = NULL;
  61     vpx_free(reference_data_[0]);
  62     reference_data_[0] = NULL;
  63     vpx_free(source_data_[1]);
  64     source_data_[1] = NULL;
  65     vpx_free(reference_data_[1]);
  66     reference_data_[1] = NULL;
  67
  68     delete[] ssim_array_;
  69   }
  70
  71   virtual void TearDown() {
  72     libvpx_test::ClearSystemState();
  73   }
  74
  75  protected:
  76   // Handle frames up to 640x480
  77   static const int kDataAlignment = 16;
  78   static const int kDataBufferSize = 640*480;
  79
  80   virtual void SetUp() {
  81     source_stride_ = (width_ + 31) & ~31;
  82     reference_stride_ = width_ * 2;
  83     rnd_.Reset(ACMRandom::DeterministicSeed());
  84   }
  85
  86   void FillRandom(uint8_t *data, int stride, int width, int height) {
  87     for (int h = 0; h < height; ++h) {
  88       for (int w = 0; w < width; ++w) {
  89         data[h * stride + w] = rnd_.Rand8();
  90       }
  91     }
  92   }
  93
  94   void FillRandom(uint8_t *data, int stride) {
  95     FillRandom(data, stride, width_, height_);
  96   }
  97
  98   void Copy(uint8_t *reference, uint8_t *source) {
  99     memcpy(reference, source, kDataBufferSize);
 100   }
 101
 102   void Blur(uint8_t *data, int stride, int taps) {
 103     int sum = 0;
 104     int half_taps = taps / 2;
 105     for (int h = 0; h < height_; ++h) {
 106       for (int w = 0; w < taps; ++w) {
 107         sum += data[w + h * stride];
 108       }
 109       for (int w = taps; w < width_; ++w) {
 110         sum += data[w + h * stride] - data[w - taps + h * stride];
 111         data[w - half_taps + h * stride] = (sum + half_taps) / taps;
 112       }
 113     }
 114     for (int w = 0; w < width_; ++w) {
 115       for (int h = 0; h < taps; ++h) {
 116         sum += data[h + w * stride];
 117       }
 118       for (int h = taps; h < height_; ++h) {
 119         sum += data[w + h * stride] - data[(h - taps) * stride + w];
 120         data[(h - half_taps) * stride + w] = (sum + half_taps) / taps;
 121       }
 122     }
 123   }
 124   int width_, height_;
 125   static uint8_t* source_data_[2];
 126   int source_stride_;
 127   static uint8_t* reference_data_[2];
 128   int reference_stride_;
 129   static Ssimv *ssim_array_;
 130   Metrics metrics_;
 131
 132   ACMRandom rnd_;
 133 };
 134
 135 #if CONFIG_VP9_ENCODER
 136 typedef std::tr1::tuple<int, int> ConsistencyParam;
 137 class ConsistencyVP9Test
 138     : public ConsistencyTestBase,
 139       public ::testing::WithParamInterface<ConsistencyParam> {
 140  public:
 141   ConsistencyVP9Test() : ConsistencyTestBase(GET_PARAM(0), GET_PARAM(1)) {}
 142
 143  protected:
 144   double CheckConsistency(int frame) {
 145     EXPECT_LT(frame, 2)<< "Frame to check has to be less than 2.";
 146     return
 147         vpx_get_ssim_metrics(source_data_[frame], source_stride_,
 148                              reference_data_[frame], reference_stride_,
 149                              width_, height_, ssim_array_, &metrics_, 1);
 150   }
 151 };
 152 #endif  // CONFIG_VP9_ENCODER
 153
 154 uint8_t* ConsistencyTestBase::source_data_[2] = {NULL, NULL};
 155 uint8_t* ConsistencyTestBase::reference_data_[2] = {NULL, NULL};
 156 Ssimv* ConsistencyTestBase::ssim_array_ = NULL;
 157
 158 #if CONFIG_VP9_ENCODER
 159 TEST_P(ConsistencyVP9Test, ConsistencyIsZero) {
 160   FillRandom(source_data_[0], source_stride_);
 161   Copy(source_data_[1], source_data_[0]);
 162   Copy(reference_data_[0], source_data_[0]);
 163   Blur(reference_data_[0], reference_stride_, 3);
 164   Copy(reference_data_[1], source_data_[0]);
 165   Blur(reference_data_[1], reference_stride_, 3);
 166
 167   double inconsistency = CheckConsistency(1);
 168   inconsistency = CheckConsistency(0);
 169   EXPECT_EQ(inconsistency, 0.0)
 170       << "Should have 0 inconsistency if they are exactly the same.";
 171
 172   // If sources are not consistent reference frames inconsistency should
 173   // be less than if the source is consistent.
 174   FillRandom(source_data_[0], source_stride_);
 175   FillRandom(source_data_[1], source_stride_);
 176   FillRandom(reference_data_[0], reference_stride_);
 177   FillRandom(reference_data_[1], reference_stride_);
 178   CheckConsistency(0);
 179   inconsistency = CheckConsistency(1);
 180
 181   Copy(source_data_[1], source_data_[0]);
 182   CheckConsistency(0);
 183   double inconsistency2 = CheckConsistency(1);
 184   EXPECT_LT(inconsistency, inconsistency2)
 185       << "Should have less inconsistency if source itself is inconsistent.";
 186
 187   // Less of a blur should be less inconsistent than more blur coming off a
 188   // a frame with no blur.
 189   ClearSsim();
 190   FillRandom(source_data_[0], source_stride_);
 191   Copy(source_data_[1], source_data_[0]);
 192   Copy(reference_data_[0], source_data_[0]);
 193   Copy(reference_data_[1], source_data_[0]);
 194   Blur(reference_data_[1], reference_stride_, 4);
 195   CheckConsistency(0);
 196   inconsistency = CheckConsistency(1);
 197   ClearSsim();
 198   Copy(reference_data_[1], source_data_[0]);
 199   Blur(reference_data_[1], reference_stride_, 8);
 200   CheckConsistency(0);
 201   inconsistency2 = CheckConsistency(1);
 202
 203   EXPECT_LT(inconsistency, inconsistency2)
 204       << "Stronger Blur should produce more inconsistency.";
 205 }
 206 #endif  // CONFIG_VP9_ENCODER
 207
 208
 209 using std::tr1::make_tuple;
 210
 211 //------------------------------------------------------------------------------
 212 // C functions
 213
 214 #if CONFIG_VP9_ENCODER
 215 const ConsistencyParam c_vp9_tests[] = {
 216   make_tuple(320, 240),
 217   make_tuple(318, 242),
 218   make_tuple(318, 238),
 219 };
 220 INSTANTIATE_TEST_CASE_P(C, ConsistencyVP9Test,
 221                         ::testing::ValuesIn(c_vp9_tests));
 222 #endif
 223
 224 }  // namespace