hbd_metrics_test.cc (9130B)
1 /* 2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved. 3 * 4 * This source code is subject to the terms of the BSD 2 Clause License and 5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License 6 * was not distributed with this source code in the LICENSE file, you can 7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open 8 * Media Patent License 1.0 was not distributed with this source code in the 9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent. 10 */ 11 12 #include <math.h> 13 #include <stdlib.h> 14 #include <new> 15 #include <tuple> 16 17 #include "gtest/gtest.h" 18 #include "test/acm_random.h" 19 #include "test/util.h" 20 21 #include "config/aom_config.h" 22 23 #include "aom_dsp/psnr.h" 24 #include "aom_dsp/ssim.h" 25 #include "aom_ports/mem.h" 26 #include "aom_scale/yv12config.h" 27 28 using libaom_test::ACMRandom; 29 30 namespace { 31 32 using LBDMetricFunc = double (*)(const YV12_BUFFER_CONFIG *source, 33 const YV12_BUFFER_CONFIG *dest); 34 using HBDMetricFunc = double (*)(const YV12_BUFFER_CONFIG *source, 35 const YV12_BUFFER_CONFIG *dest, uint32_t in_bd, 36 uint32_t bd); 37 38 double compute_hbd_psnr(const YV12_BUFFER_CONFIG *source, 39 const YV12_BUFFER_CONFIG *dest, uint32_t in_bd, 40 uint32_t bd) { 41 PSNR_STATS psnr; 42 aom_calc_highbd_psnr(source, dest, &psnr, bd, in_bd); 43 return psnr.psnr[0]; 44 } 45 46 double compute_psnr(const YV12_BUFFER_CONFIG *source, 47 const YV12_BUFFER_CONFIG *dest) { 48 PSNR_STATS psnr; 49 aom_calc_psnr(source, dest, &psnr); 50 return psnr.psnr[0]; 51 } 52 53 double compute_hbd_psnrhvs(const YV12_BUFFER_CONFIG *source, 54 const YV12_BUFFER_CONFIG *dest, uint32_t in_bd, 55 uint32_t bd) { 56 double tempy, tempu, tempv; 57 return aom_psnrhvs(source, dest, &tempy, &tempu, &tempv, bd, in_bd); 58 } 59 60 double compute_psnrhvs(const YV12_BUFFER_CONFIG *source, 61 const YV12_BUFFER_CONFIG *dest) { 62 double tempy, tempu, tempv; 63 return aom_psnrhvs(source, dest, &tempy, &tempu, &tempv, 8, 8); 64 } 65 66 double compute_hbd_fastssim(const YV12_BUFFER_CONFIG *source, 67 const YV12_BUFFER_CONFIG *dest, uint32_t in_bd, 68 uint32_t bd) { 69 double tempy, tempu, tempv; 70 return aom_calc_fastssim(source, dest, &tempy, &tempu, &tempv, bd, in_bd); 71 } 72 73 double compute_fastssim(const YV12_BUFFER_CONFIG *source, 74 const YV12_BUFFER_CONFIG *dest) { 75 double tempy, tempu, tempv; 76 return aom_calc_fastssim(source, dest, &tempy, &tempu, &tempv, 8, 8); 77 } 78 79 double compute_hbd_aomssim(const YV12_BUFFER_CONFIG *source, 80 const YV12_BUFFER_CONFIG *dest, uint32_t in_bd, 81 uint32_t bd) { 82 double ssim[2], weight[2]; 83 aom_highbd_calc_ssim(source, dest, weight, bd, in_bd, ssim); 84 return 100 * pow(ssim[0] / weight[0], 8.0); 85 } 86 87 double compute_aomssim(const YV12_BUFFER_CONFIG *source, 88 const YV12_BUFFER_CONFIG *dest) { 89 double ssim, weight; 90 aom_lowbd_calc_ssim(source, dest, &weight, &ssim); 91 return 100 * pow(ssim / weight, 8.0); 92 } 93 94 class HBDMetricsTestBase { 95 public: 96 virtual ~HBDMetricsTestBase() = default; 97 98 protected: 99 void RunAccuracyCheck() { 100 const int width = 1920; 101 const int height = 1080; 102 size_t i = 0; 103 const uint8_t kPixFiller = 128; 104 YV12_BUFFER_CONFIG lbd_src, lbd_dst; 105 YV12_BUFFER_CONFIG hbd_src, hbd_dst; 106 ACMRandom rnd(ACMRandom::DeterministicSeed()); 107 double lbd_db, hbd_db; 108 109 memset(&lbd_src, 0, sizeof(lbd_src)); 110 memset(&lbd_dst, 0, sizeof(lbd_dst)); 111 memset(&hbd_src, 0, sizeof(hbd_src)); 112 memset(&hbd_dst, 0, sizeof(hbd_dst)); 113 114 aom_alloc_frame_buffer(&lbd_src, width, height, 1, 1, 0, 32, 16, false, 0); 115 aom_alloc_frame_buffer(&lbd_dst, width, height, 1, 1, 0, 32, 16, false, 0); 116 aom_alloc_frame_buffer(&hbd_src, width, height, 1, 1, 1, 32, 16, false, 0); 117 aom_alloc_frame_buffer(&hbd_dst, width, height, 1, 1, 1, 32, 16, false, 0); 118 119 memset(lbd_src.buffer_alloc, kPixFiller, lbd_src.buffer_alloc_sz); 120 while (i < lbd_src.buffer_alloc_sz) { 121 uint16_t spel, dpel; 122 spel = lbd_src.buffer_alloc[i]; 123 // Create some distortion for dst buffer. 124 dpel = rnd.Rand8(); 125 lbd_dst.buffer_alloc[i] = (uint8_t)dpel; 126 ((uint16_t *)(hbd_src.buffer_alloc))[i] = spel << (bit_depth_ - 8); 127 ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8); 128 i++; 129 } 130 131 lbd_db = lbd_metric_(&lbd_src, &lbd_dst); 132 hbd_db = hbd_metric_(&hbd_src, &hbd_dst, input_bit_depth_, bit_depth_); 133 EXPECT_LE(fabs(lbd_db - hbd_db), threshold_); 134 135 i = 0; 136 while (i < lbd_src.buffer_alloc_sz) { 137 uint16_t dpel; 138 // Create some small distortion for dst buffer. 139 dpel = 120 + (rnd.Rand8() >> 4); 140 lbd_dst.buffer_alloc[i] = (uint8_t)dpel; 141 ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8); 142 i++; 143 } 144 145 lbd_db = lbd_metric_(&lbd_src, &lbd_dst); 146 hbd_db = hbd_metric_(&hbd_src, &hbd_dst, input_bit_depth_, bit_depth_); 147 EXPECT_LE(fabs(lbd_db - hbd_db), threshold_); 148 149 i = 0; 150 while (i < lbd_src.buffer_alloc_sz) { 151 uint16_t dpel; 152 // Create some small distortion for dst buffer. 153 dpel = 126 + (rnd.Rand8() >> 6); 154 lbd_dst.buffer_alloc[i] = (uint8_t)dpel; 155 ((uint16_t *)(hbd_dst.buffer_alloc))[i] = dpel << (bit_depth_ - 8); 156 i++; 157 } 158 159 lbd_db = lbd_metric_(&lbd_src, &lbd_dst); 160 hbd_db = hbd_metric_(&hbd_src, &hbd_dst, input_bit_depth_, bit_depth_); 161 EXPECT_LE(fabs(lbd_db - hbd_db), threshold_); 162 163 aom_free_frame_buffer(&lbd_src); 164 aom_free_frame_buffer(&lbd_dst); 165 aom_free_frame_buffer(&hbd_src); 166 aom_free_frame_buffer(&hbd_dst); 167 } 168 169 int input_bit_depth_; 170 int bit_depth_; 171 double threshold_; 172 LBDMetricFunc lbd_metric_; 173 HBDMetricFunc hbd_metric_; 174 }; 175 176 using MetricTestTParam = 177 std::tuple<LBDMetricFunc, HBDMetricFunc, int, int, double>; 178 class HBDMetricsTest : public HBDMetricsTestBase, 179 public ::testing::TestWithParam<MetricTestTParam> { 180 public: 181 void SetUp() override { 182 lbd_metric_ = GET_PARAM(0); 183 hbd_metric_ = GET_PARAM(1); 184 input_bit_depth_ = GET_PARAM(2); 185 bit_depth_ = GET_PARAM(3); 186 threshold_ = GET_PARAM(4); 187 } 188 }; 189 190 TEST_P(HBDMetricsTest, RunAccuracyCheck) { RunAccuracyCheck(); } 191 192 // Allow small variation due to floating point operations. 193 static const double kSsim_thresh = 0.001; 194 // Allow some additional errors accumulated in floating point operations. 195 static const double kFSsim_thresh = 0.03; 196 // Allow some extra variation due to rounding error accumulated in dct. 197 static const double kPhvs_thresh = 0.3; 198 199 INSTANTIATE_TEST_SUITE_P( 200 AOMSSIM, HBDMetricsTest, 201 ::testing::Values(MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim, 202 8, 10, kSsim_thresh), 203 MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim, 204 10, 10, kPhvs_thresh), 205 MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim, 206 8, 12, kSsim_thresh), 207 MetricTestTParam(&compute_aomssim, &compute_hbd_aomssim, 208 12, 12, kPhvs_thresh))); 209 INSTANTIATE_TEST_SUITE_P( 210 FASTSSIM, HBDMetricsTest, 211 ::testing::Values(MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 212 8, 10, kFSsim_thresh), 213 MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 214 10, 10, kFSsim_thresh), 215 MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 216 8, 12, kFSsim_thresh), 217 MetricTestTParam(&compute_fastssim, &compute_hbd_fastssim, 218 12, 12, kFSsim_thresh))); 219 INSTANTIATE_TEST_SUITE_P( 220 PSNRHVS, HBDMetricsTest, 221 ::testing::Values(MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 222 8, 10, kPhvs_thresh), 223 MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 224 10, 10, kPhvs_thresh), 225 MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 226 8, 12, kPhvs_thresh), 227 MetricTestTParam(&compute_psnrhvs, &compute_hbd_psnrhvs, 228 12, 12, kPhvs_thresh))); 229 INSTANTIATE_TEST_SUITE_P( 230 PSNR, HBDMetricsTest, 231 ::testing::Values( 232 MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 10, kPhvs_thresh), 233 MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 10, 10, 234 kPhvs_thresh), 235 MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 8, 12, kPhvs_thresh), 236 MetricTestTParam(&compute_psnr, &compute_hbd_psnr, 12, 12, 237 kPhvs_thresh))); 238 } // namespace