Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(563)

Side by Side Diff: unit_test/compare_test.cc

Issue 2001373002: remove row.h from unittests (Closed) Base URL: https://chromium.googlesource.com/libyuv/libyuv@master
Patch Set: test csum buffer is aligned Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « unit_test/color_test.cc ('k') | unit_test/convert_test.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2011 The LibYuv Project Authors. All rights reserved. 2 * Copyright 2011 The LibYuv Project Authors. All rights reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 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 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 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
11 #include <stdlib.h> 11 #include <stdlib.h>
12 #include <string.h> 12 #include <string.h>
13 #include <time.h> 13 #include <time.h>
14 14
15 #include "../unit_test/unit_test.h" 15 #include "../unit_test/unit_test.h"
16 #include "libyuv/basic_types.h" 16 #include "libyuv/basic_types.h"
17 #include "libyuv/compare.h" 17 #include "libyuv/compare.h"
18 #include "libyuv/cpu_id.h" 18 #include "libyuv/cpu_id.h"
19 #include "libyuv/row.h"
20 #include "libyuv/video_common.h" 19 #include "libyuv/video_common.h"
21 20
22 namespace libyuv { 21 namespace libyuv {
23 22
24 // hash seed of 5381 recommended. 23 // hash seed of 5381 recommended.
25 static uint32 ReferenceHashDjb2(const uint8* src, uint64 count, uint32 seed) { 24 static uint32 ReferenceHashDjb2(const uint8* src, uint64 count, uint32 seed) {
26 uint32 hash = seed; 25 uint32 hash = seed;
27 if (count > 0) { 26 if (count > 0) {
28 do { 27 do {
29 hash = hash * 33 + *src++; 28 hash = hash * 33 + *src++;
30 } while (--count); 29 } while (--count);
31 } 30 }
32 return hash; 31 return hash;
33 } 32 }
34 33
35 TEST_F(LibYUVBaseTest, Djb2_Test) { 34 TEST_F(LibYUVBaseTest, Djb2_Test) {
36 const int kMaxTest = benchmark_width_ * benchmark_height_; 35 const int kMaxTest = benchmark_width_ * benchmark_height_;
37 align_buffer_64(src_a, kMaxTest); 36 align_buffer_page_end(src_a, kMaxTest);
38 align_buffer_64(src_b, kMaxTest); 37 align_buffer_page_end(src_b, kMaxTest);
39 38
40 const char* fox = "The quick brown fox jumps over the lazy dog" 39 const char* fox = "The quick brown fox jumps over the lazy dog"
41 " and feels as if he were in the seventh heaven of typography" 40 " and feels as if he were in the seventh heaven of typography"
42 " together with Hermann Zapf"; 41 " together with Hermann Zapf";
43 uint32 foxhash = HashDjb2(reinterpret_cast<const uint8*>(fox), 131, 5381); 42 uint32 foxhash = HashDjb2(reinterpret_cast<const uint8*>(fox), 131, 5381);
44 const uint32 kExpectedFoxHash = 2611006483u; 43 const uint32 kExpectedFoxHash = 2611006483u;
45 EXPECT_EQ(kExpectedFoxHash, foxhash); 44 EXPECT_EQ(kExpectedFoxHash, foxhash);
46 45
47 for (int i = 0; i < kMaxTest; ++i) { 46 for (int i = 0; i < kMaxTest; ++i) {
48 src_a[i] = (fastrand() & 0xff); 47 src_a[i] = (fastrand() & 0xff);
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
105 h1 = HashDjb2(src_a, kMaxTest, 5381); 104 h1 = HashDjb2(src_a, kMaxTest, 5381);
106 h2 = HashDjb2(src_a, kMaxTest / 2, 5381); 105 h2 = HashDjb2(src_a, kMaxTest / 2, 5381);
107 EXPECT_NE(h1, h2); 106 EXPECT_NE(h1, h2);
108 107
109 // Make a zeros and seed of zero. Test different lengths. Expect hash is same. 108 // Make a zeros and seed of zero. Test different lengths. Expect hash is same.
110 memset(src_a, 0, kMaxTest); 109 memset(src_a, 0, kMaxTest);
111 h1 = HashDjb2(src_a, kMaxTest, 0); 110 h1 = HashDjb2(src_a, kMaxTest, 0);
112 h2 = HashDjb2(src_a, kMaxTest / 2, 0); 111 h2 = HashDjb2(src_a, kMaxTest / 2, 0);
113 EXPECT_EQ(h1, h2); 112 EXPECT_EQ(h1, h2);
114 113
115 free_aligned_buffer_64(src_a); 114 free_aligned_buffer_page_end(src_a);
116 free_aligned_buffer_64(src_b); 115 free_aligned_buffer_page_end(src_b);
117 } 116 }
118 117
119 TEST_F(LibYUVBaseTest, BenchmarkDjb2_Opt) { 118 TEST_F(LibYUVBaseTest, BenchmarkDjb2_Opt) {
120 const int kMaxTest = benchmark_width_ * benchmark_height_; 119 const int kMaxTest = benchmark_width_ * benchmark_height_;
121 align_buffer_64(src_a, kMaxTest); 120 align_buffer_page_end(src_a, kMaxTest);
122 121
123 for (int i = 0; i < kMaxTest; ++i) { 122 for (int i = 0; i < kMaxTest; ++i) {
124 src_a[i] = i; 123 src_a[i] = i;
125 } 124 }
126 uint32 h2 = ReferenceHashDjb2(src_a, kMaxTest, 5381); 125 uint32 h2 = ReferenceHashDjb2(src_a, kMaxTest, 5381);
127 uint32 h1; 126 uint32 h1;
128 for (int i = 0; i < benchmark_iterations_; ++i) { 127 for (int i = 0; i < benchmark_iterations_; ++i) {
129 h1 = HashDjb2(src_a, kMaxTest, 5381); 128 h1 = HashDjb2(src_a, kMaxTest, 5381);
130 } 129 }
131 EXPECT_EQ(h1, h2); 130 EXPECT_EQ(h1, h2);
132 free_aligned_buffer_64(src_a); 131 free_aligned_buffer_page_end(src_a);
133 } 132 }
134 133
135 TEST_F(LibYUVBaseTest, BenchmarkDjb2_Unaligned) { 134 TEST_F(LibYUVBaseTest, BenchmarkDjb2_Unaligned) {
136 const int kMaxTest = benchmark_width_ * benchmark_height_; 135 const int kMaxTest = benchmark_width_ * benchmark_height_;
137 align_buffer_64(src_a, kMaxTest + 1); 136 align_buffer_page_end(src_a, kMaxTest + 1);
138 for (int i = 0; i < kMaxTest; ++i) { 137 for (int i = 0; i < kMaxTest; ++i) {
139 src_a[i + 1] = i; 138 src_a[i + 1] = i;
140 } 139 }
141 uint32 h2 = ReferenceHashDjb2(src_a + 1, kMaxTest, 5381); 140 uint32 h2 = ReferenceHashDjb2(src_a + 1, kMaxTest, 5381);
142 uint32 h1; 141 uint32 h1;
143 for (int i = 0; i < benchmark_iterations_; ++i) { 142 for (int i = 0; i < benchmark_iterations_; ++i) {
144 h1 = HashDjb2(src_a + 1, kMaxTest, 5381); 143 h1 = HashDjb2(src_a + 1, kMaxTest, 5381);
145 } 144 }
146 EXPECT_EQ(h1, h2); 145 EXPECT_EQ(h1, h2);
147 free_aligned_buffer_64(src_a); 146 free_aligned_buffer_page_end(src_a);
148 } 147 }
149 148
150 TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) { 149 TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Opt) {
151 uint32 fourcc; 150 uint32 fourcc;
152 const int kMaxTest = benchmark_width_ * benchmark_height_ * 4; 151 const int kMaxTest = benchmark_width_ * benchmark_height_ * 4;
153 align_buffer_64(src_a, kMaxTest); 152 align_buffer_page_end(src_a, kMaxTest);
154 for (int i = 0; i < kMaxTest; ++i) { 153 for (int i = 0; i < kMaxTest; ++i) {
155 src_a[i] = 255; 154 src_a[i] = 255;
156 } 155 }
157 156
158 src_a[0] = 0; 157 src_a[0] = 0;
159 fourcc = ARGBDetect(src_a, benchmark_width_ * 4, 158 fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
160 benchmark_width_, benchmark_height_); 159 benchmark_width_, benchmark_height_);
161 EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc); 160 EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
162 src_a[0] = 255; 161 src_a[0] = 255;
163 src_a[3] = 0; 162 src_a[3] = 0;
164 fourcc = ARGBDetect(src_a, benchmark_width_ * 4, 163 fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
165 benchmark_width_, benchmark_height_); 164 benchmark_width_, benchmark_height_);
166 EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc); 165 EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc);
167 src_a[3] = 255; 166 src_a[3] = 255;
168 167
169 for (int i = 0; i < benchmark_iterations_; ++i) { 168 for (int i = 0; i < benchmark_iterations_; ++i) {
170 fourcc = ARGBDetect(src_a, benchmark_width_ * 4, 169 fourcc = ARGBDetect(src_a, benchmark_width_ * 4,
171 benchmark_width_, benchmark_height_); 170 benchmark_width_, benchmark_height_);
172 } 171 }
173 EXPECT_EQ(0, fourcc); 172 EXPECT_EQ(0, fourcc);
174 173
175 free_aligned_buffer_64(src_a); 174 free_aligned_buffer_page_end(src_a);
176 } 175 }
177 176
178 TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) { 177 TEST_F(LibYUVBaseTest, BenchmarkARGBDetect_Unaligned) {
179 uint32 fourcc; 178 uint32 fourcc;
180 const int kMaxTest = benchmark_width_ * benchmark_height_ * 4 + 1; 179 const int kMaxTest = benchmark_width_ * benchmark_height_ * 4 + 1;
181 align_buffer_64(src_a, kMaxTest); 180 align_buffer_page_end(src_a, kMaxTest);
182 for (int i = 1; i < kMaxTest; ++i) { 181 for (int i = 1; i < kMaxTest; ++i) {
183 src_a[i] = 255; 182 src_a[i] = 255;
184 } 183 }
185 184
186 src_a[0 + 1] = 0; 185 src_a[0 + 1] = 0;
187 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, 186 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
188 benchmark_width_, benchmark_height_); 187 benchmark_width_, benchmark_height_);
189 EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc); 188 EXPECT_EQ(libyuv::FOURCC_BGRA, fourcc);
190 src_a[0 + 1] = 255; 189 src_a[0 + 1] = 255;
191 src_a[3 + 1] = 0; 190 src_a[3 + 1] = 0;
192 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, 191 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
193 benchmark_width_, benchmark_height_); 192 benchmark_width_, benchmark_height_);
194 EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc); 193 EXPECT_EQ(libyuv::FOURCC_ARGB, fourcc);
195 src_a[3 + 1] = 255; 194 src_a[3 + 1] = 255;
196 195
197 for (int i = 0; i < benchmark_iterations_; ++i) { 196 for (int i = 0; i < benchmark_iterations_; ++i) {
198 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4, 197 fourcc = ARGBDetect(src_a + 1, benchmark_width_ * 4,
199 benchmark_width_, benchmark_height_); 198 benchmark_width_, benchmark_height_);
200 } 199 }
201 EXPECT_EQ(0, fourcc); 200 EXPECT_EQ(0, fourcc);
202 201
203 free_aligned_buffer_64(src_a); 202 free_aligned_buffer_page_end(src_a);
204 } 203 }
205 TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) { 204 TEST_F(LibYUVBaseTest, BenchmarkSumSquareError_Opt) {
206 const int kMaxWidth = 4096 * 3; 205 const int kMaxWidth = 4096 * 3;
207 align_buffer_64(src_a, kMaxWidth); 206 align_buffer_page_end(src_a, kMaxWidth);
208 align_buffer_64(src_b, kMaxWidth); 207 align_buffer_page_end(src_b, kMaxWidth);
209 memset(src_a, 0, kMaxWidth); 208 memset(src_a, 0, kMaxWidth);
210 memset(src_b, 0, kMaxWidth); 209 memset(src_b, 0, kMaxWidth);
211 210
212 memcpy(src_a, "test0123test4567", 16); 211 memcpy(src_a, "test0123test4567", 16);
213 memcpy(src_b, "tick0123tock4567", 16); 212 memcpy(src_b, "tick0123tock4567", 16);
214 uint64 h1 = ComputeSumSquareError(src_a, src_b, 16); 213 uint64 h1 = ComputeSumSquareError(src_a, src_b, 16);
215 EXPECT_EQ(790u, h1); 214 EXPECT_EQ(790u, h1);
216 215
217 for (int i = 0; i < kMaxWidth; ++i) { 216 for (int i = 0; i < kMaxWidth; ++i) {
218 src_a[i] = i; 217 src_a[i] = i;
219 src_b[i] = i; 218 src_b[i] = i;
220 } 219 }
221 memset(src_a, 0, kMaxWidth); 220 memset(src_a, 0, kMaxWidth);
222 memset(src_b, 0, kMaxWidth); 221 memset(src_b, 0, kMaxWidth);
223 222
224 int count = benchmark_iterations_ * 223 int count = benchmark_iterations_ *
225 ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth); 224 ((benchmark_width_ * benchmark_height_ + kMaxWidth - 1) / kMaxWidth);
226 for (int i = 0; i < count; ++i) { 225 for (int i = 0; i < count; ++i) {
227 h1 = ComputeSumSquareError(src_a, src_b, kMaxWidth); 226 h1 = ComputeSumSquareError(src_a, src_b, kMaxWidth);
228 } 227 }
229 228
230 EXPECT_EQ(0, h1); 229 EXPECT_EQ(0, h1);
231 230
232 free_aligned_buffer_64(src_a); 231 free_aligned_buffer_page_end(src_a);
233 free_aligned_buffer_64(src_b); 232 free_aligned_buffer_page_end(src_b);
234 } 233 }
235 234
236 TEST_F(LibYUVBaseTest, SumSquareError) { 235 TEST_F(LibYUVBaseTest, SumSquareError) {
237 const int kMaxWidth = 4096 * 3; 236 const int kMaxWidth = 4096 * 3;
238 align_buffer_64(src_a, kMaxWidth); 237 align_buffer_page_end(src_a, kMaxWidth);
239 align_buffer_64(src_b, kMaxWidth); 238 align_buffer_page_end(src_b, kMaxWidth);
240 memset(src_a, 0, kMaxWidth); 239 memset(src_a, 0, kMaxWidth);
241 memset(src_b, 0, kMaxWidth); 240 memset(src_b, 0, kMaxWidth);
242 241
243 uint64 err; 242 uint64 err;
244 err = ComputeSumSquareError(src_a, src_b, kMaxWidth); 243 err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
245 244
246 EXPECT_EQ(0, err); 245 EXPECT_EQ(0, err);
247 246
248 memset(src_a, 1, kMaxWidth); 247 memset(src_a, 1, kMaxWidth);
249 err = ComputeSumSquareError(src_a, src_b, kMaxWidth); 248 err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
(...skipping 12 matching lines...) Expand all
262 } 261 }
263 262
264 MaskCpuFlags(disable_cpu_flags_); 263 MaskCpuFlags(disable_cpu_flags_);
265 uint64 c_err = ComputeSumSquareError(src_a, src_b, kMaxWidth); 264 uint64 c_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
266 265
267 MaskCpuFlags(benchmark_cpu_info_); 266 MaskCpuFlags(benchmark_cpu_info_);
268 uint64 opt_err = ComputeSumSquareError(src_a, src_b, kMaxWidth); 267 uint64 opt_err = ComputeSumSquareError(src_a, src_b, kMaxWidth);
269 268
270 EXPECT_EQ(c_err, opt_err); 269 EXPECT_EQ(c_err, opt_err);
271 270
272 free_aligned_buffer_64(src_a); 271 free_aligned_buffer_page_end(src_a);
273 free_aligned_buffer_64(src_b); 272 free_aligned_buffer_page_end(src_b);
274 } 273 }
275 274
276 TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) { 275 TEST_F(LibYUVBaseTest, BenchmarkPsnr_Opt) {
277 align_buffer_64(src_a, benchmark_width_ * benchmark_height_); 276 align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
278 align_buffer_64(src_b, benchmark_width_ * benchmark_height_); 277 align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
279 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) { 278 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
280 src_a[i] = i; 279 src_a[i] = i;
281 src_b[i] = i; 280 src_b[i] = i;
282 } 281 }
283 282
284 MaskCpuFlags(benchmark_cpu_info_); 283 MaskCpuFlags(benchmark_cpu_info_);
285 284
286 double opt_time = get_time(); 285 double opt_time = get_time();
287 for (int i = 0; i < benchmark_iterations_; ++i) 286 for (int i = 0; i < benchmark_iterations_; ++i)
288 CalcFramePsnr(src_a, benchmark_width_, 287 CalcFramePsnr(src_a, benchmark_width_,
289 src_b, benchmark_width_, 288 src_b, benchmark_width_,
290 benchmark_width_, benchmark_height_); 289 benchmark_width_, benchmark_height_);
291 290
292 opt_time = (get_time() - opt_time) / benchmark_iterations_; 291 opt_time = (get_time() - opt_time) / benchmark_iterations_;
293 printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6); 292 printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
294 293
295 EXPECT_EQ(0, 0); 294 EXPECT_EQ(0, 0);
296 295
297 free_aligned_buffer_64(src_a); 296 free_aligned_buffer_page_end(src_a);
298 free_aligned_buffer_64(src_b); 297 free_aligned_buffer_page_end(src_b);
299 } 298 }
300 299
301 TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) { 300 TEST_F(LibYUVBaseTest, BenchmarkPsnr_Unaligned) {
302 align_buffer_64(src_a, benchmark_width_ * benchmark_height_ + 1); 301 align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_ + 1);
303 align_buffer_64(src_b, benchmark_width_ * benchmark_height_); 302 align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
304 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) { 303 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
305 src_a[i + 1] = i; 304 src_a[i + 1] = i;
306 src_b[i] = i; 305 src_b[i] = i;
307 } 306 }
308 307
309 MaskCpuFlags(benchmark_cpu_info_); 308 MaskCpuFlags(benchmark_cpu_info_);
310 309
311 double opt_time = get_time(); 310 double opt_time = get_time();
312 for (int i = 0; i < benchmark_iterations_; ++i) 311 for (int i = 0; i < benchmark_iterations_; ++i)
313 CalcFramePsnr(src_a + 1, benchmark_width_, 312 CalcFramePsnr(src_a + 1, benchmark_width_,
314 src_b, benchmark_width_, 313 src_b, benchmark_width_,
315 benchmark_width_, benchmark_height_); 314 benchmark_width_, benchmark_height_);
316 315
317 opt_time = (get_time() - opt_time) / benchmark_iterations_; 316 opt_time = (get_time() - opt_time) / benchmark_iterations_;
318 printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6); 317 printf("BenchmarkPsnr_Opt - %8.2f us opt\n", opt_time * 1e6);
319 318
320 EXPECT_EQ(0, 0); 319 EXPECT_EQ(0, 0);
321 320
322 free_aligned_buffer_64(src_a); 321 free_aligned_buffer_page_end(src_a);
323 free_aligned_buffer_64(src_b); 322 free_aligned_buffer_page_end(src_b);
324 } 323 }
325 324
326 TEST_F(LibYUVBaseTest, Psnr) { 325 TEST_F(LibYUVBaseTest, Psnr) {
327 const int kSrcWidth = benchmark_width_; 326 const int kSrcWidth = benchmark_width_;
328 const int kSrcHeight = benchmark_height_; 327 const int kSrcHeight = benchmark_height_;
329 const int b = 128; 328 const int b = 128;
330 const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2); 329 const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2);
331 const int kSrcStride = 2 * b + kSrcWidth; 330 const int kSrcStride = 2 * b + kSrcWidth;
332 align_buffer_64(src_a, kSrcPlaneSize); 331 align_buffer_page_end(src_a, kSrcPlaneSize);
333 align_buffer_64(src_b, kSrcPlaneSize); 332 align_buffer_page_end(src_b, kSrcPlaneSize);
334 memset(src_a, 0, kSrcPlaneSize); 333 memset(src_a, 0, kSrcPlaneSize);
335 memset(src_b, 0, kSrcPlaneSize); 334 memset(src_b, 0, kSrcPlaneSize);
336 335
337 double err; 336 double err;
338 err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride, 337 err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
339 src_b + kSrcStride * b + b, kSrcStride, 338 src_b + kSrcStride * b + b, kSrcStride,
340 kSrcWidth, kSrcHeight); 339 kSrcWidth, kSrcHeight);
341 340
342 EXPECT_EQ(err, kMaxPsnr); 341 EXPECT_EQ(err, kMaxPsnr);
343 342
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
389 kSrcWidth, kSrcHeight); 388 kSrcWidth, kSrcHeight);
390 389
391 MaskCpuFlags(benchmark_cpu_info_); 390 MaskCpuFlags(benchmark_cpu_info_);
392 391
393 opt_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride, 392 opt_err = CalcFramePsnr(src_a + kSrcStride * b + b, kSrcStride,
394 src_b + kSrcStride * b + b, kSrcStride, 393 src_b + kSrcStride * b + b, kSrcStride,
395 kSrcWidth, kSrcHeight); 394 kSrcWidth, kSrcHeight);
396 395
397 EXPECT_EQ(opt_err, c_err); 396 EXPECT_EQ(opt_err, c_err);
398 397
399 free_aligned_buffer_64(src_a); 398 free_aligned_buffer_page_end(src_a);
400 free_aligned_buffer_64(src_b); 399 free_aligned_buffer_page_end(src_b);
401 } 400 }
402 401
403 TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) { 402 TEST_F(LibYUVBaseTest, DISABLED_BenchmarkSsim_Opt) {
404 align_buffer_64(src_a, benchmark_width_ * benchmark_height_); 403 align_buffer_page_end(src_a, benchmark_width_ * benchmark_height_);
405 align_buffer_64(src_b, benchmark_width_ * benchmark_height_); 404 align_buffer_page_end(src_b, benchmark_width_ * benchmark_height_);
406 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) { 405 for (int i = 0; i < benchmark_width_ * benchmark_height_; ++i) {
407 src_a[i] = i; 406 src_a[i] = i;
408 src_b[i] = i; 407 src_b[i] = i;
409 } 408 }
410 409
411 MaskCpuFlags(benchmark_cpu_info_); 410 MaskCpuFlags(benchmark_cpu_info_);
412 411
413 double opt_time = get_time(); 412 double opt_time = get_time();
414 for (int i = 0; i < benchmark_iterations_; ++i) 413 for (int i = 0; i < benchmark_iterations_; ++i)
415 CalcFrameSsim(src_a, benchmark_width_, 414 CalcFrameSsim(src_a, benchmark_width_,
416 src_b, benchmark_width_, 415 src_b, benchmark_width_,
417 benchmark_width_, benchmark_height_); 416 benchmark_width_, benchmark_height_);
418 417
419 opt_time = (get_time() - opt_time) / benchmark_iterations_; 418 opt_time = (get_time() - opt_time) / benchmark_iterations_;
420 printf("BenchmarkSsim_Opt - %8.2f us opt\n", opt_time * 1e6); 419 printf("BenchmarkSsim_Opt - %8.2f us opt\n", opt_time * 1e6);
421 420
422 EXPECT_EQ(0, 0); // Pass if we get this far. 421 EXPECT_EQ(0, 0); // Pass if we get this far.
423 422
424 free_aligned_buffer_64(src_a); 423 free_aligned_buffer_page_end(src_a);
425 free_aligned_buffer_64(src_b); 424 free_aligned_buffer_page_end(src_b);
426 } 425 }
427 426
428 TEST_F(LibYUVBaseTest, Ssim) { 427 TEST_F(LibYUVBaseTest, Ssim) {
429 const int kSrcWidth = benchmark_width_; 428 const int kSrcWidth = benchmark_width_;
430 const int kSrcHeight = benchmark_height_; 429 const int kSrcHeight = benchmark_height_;
431 const int b = 128; 430 const int b = 128;
432 const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2); 431 const int kSrcPlaneSize = (kSrcWidth + b * 2) * (kSrcHeight + b * 2);
433 const int kSrcStride = 2 * b + kSrcWidth; 432 const int kSrcStride = 2 * b + kSrcWidth;
434 align_buffer_64(src_a, kSrcPlaneSize); 433 align_buffer_page_end(src_a, kSrcPlaneSize);
435 align_buffer_64(src_b, kSrcPlaneSize); 434 align_buffer_page_end(src_b, kSrcPlaneSize);
436 memset(src_a, 0, kSrcPlaneSize); 435 memset(src_a, 0, kSrcPlaneSize);
437 memset(src_b, 0, kSrcPlaneSize); 436 memset(src_b, 0, kSrcPlaneSize);
438 437
439 if (kSrcWidth <=8 || kSrcHeight <= 8) { 438 if (kSrcWidth <=8 || kSrcHeight <= 8) {
440 printf("warning - Ssim size too small. Testing function executes.\n"); 439 printf("warning - Ssim size too small. Testing function executes.\n");
441 } 440 }
442 441
443 double err; 442 double err;
444 err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride, 443 err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
445 src_b + kSrcStride * b + b, kSrcStride, 444 src_b + kSrcStride * b + b, kSrcStride,
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
500 MaskCpuFlags(benchmark_cpu_info_); 499 MaskCpuFlags(benchmark_cpu_info_);
501 500
502 opt_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride, 501 opt_err = CalcFrameSsim(src_a + kSrcStride * b + b, kSrcStride,
503 src_b + kSrcStride * b + b, kSrcStride, 502 src_b + kSrcStride * b + b, kSrcStride,
504 kSrcWidth, kSrcHeight); 503 kSrcWidth, kSrcHeight);
505 504
506 if (kSrcWidth > 8 && kSrcHeight > 8) { 505 if (kSrcWidth > 8 && kSrcHeight > 8) {
507 EXPECT_EQ(opt_err, c_err); 506 EXPECT_EQ(opt_err, c_err);
508 } 507 }
509 508
510 free_aligned_buffer_64(src_a); 509 free_aligned_buffer_page_end(src_a);
511 free_aligned_buffer_64(src_b); 510 free_aligned_buffer_page_end(src_b);
512 } 511 }
513 512
514 } // namespace libyuv 513 } // namespace libyuv
OLDNEW
« no previous file with comments | « unit_test/color_test.cc ('k') | unit_test/convert_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698