OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |