1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <d3d9.h> 6 #include <random> 7 8 #include "base/basictypes.h" 9 #include "base/file_util.h" 10 #include "base/hash.h" 11 #include "base/scoped_native_library.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/time/time.h" 14 #include "base/win/scoped_comptr.h" 15 #include "base/win/windows_version.h" 16 #include "media/base/simd/convert_rgb_to_yuv.h" 17 #include "media/base/yuv_convert.h" 18 #include "skia/ext/image_operations.h" 19 #include "testing/gtest/include/gtest/gtest-param-test.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 #include "third_party/skia/include/core/SkBitmap.h" 22 #include "third_party/skia/include/core/SkColor.h" 23 #include "ui/gfx/codec/png_codec.h" 24 #include "ui/gfx/rect.h" 25 #include "ui/surface/accelerated_surface_transformer_win.h" 26 #include "ui/surface/accelerated_surface_win.h" 27 #include "ui/surface/d3d9_utils_win.h" 28 29 namespace d3d_utils = ui_surface_d3d9_utils; 30 31 using base::win::ScopedComPtr; 32 using std::uniform_int_distribution; 33 34 namespace { 35 36 // Debug flag, useful when hacking on tests. 37 const bool kDumpImagesOnFailure = false; 38 39 SkBitmap ToSkBitmap(IDirect3DSurface9* surface, bool is_single_channel) { 40 D3DLOCKED_RECT locked_rect; 41 EXPECT_HRESULT_SUCCEEDED( 42 surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY)); 43 44 SkBitmap result; 45 gfx::Size size = d3d_utils::GetSize(surface); 46 if (is_single_channel) 47 size = gfx::Size(size.width() * 4, size.height()); 48 result.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height(), 49 0, kOpaque_SkAlphaType); 50 result.allocPixels(); 51 result.lockPixels(); 52 for (int y = 0; y < size.height(); ++y) { 53 uint8* row8 = reinterpret_cast<uint8*>(locked_rect.pBits) + 54 (y * locked_rect.Pitch); 55 if (is_single_channel) { 56 for (int x = 0; x < size.width(); ++x) { 57 *result.getAddr32(x, y) = SkColorSetRGB(row8[x], row8[x], row8[x]); 58 } 59 } else { 60 uint32* row32 = reinterpret_cast<uint32*>(row8); 61 for (int x = 0; x < size.width(); ++x) { 62 *result.getAddr32(x, y) = row32[x] | 0xFF000000; 63 } 64 } 65 } 66 result.unlockPixels(); 67 result.setImmutable(); 68 surface->UnlockRect(); 69 return result; 70 } 71 72 bool WritePNGFile(const SkBitmap& bitmap, const base::FilePath& file_path) { 73 std::vector<unsigned char> png_data; 74 const bool discard_transparency = true; 75 if (gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, 76 discard_transparency, 77 &png_data) && 78 base::CreateDirectory(file_path.DirName())) { 79 char* data = reinterpret_cast<char*>(&png_data[0]); 80 int size = static_cast<int>(png_data.size()); 81 return file_util::WriteFile(file_path, data, size) == size; 82 } 83 return false; 84 } 85 86 } // namespace 87 88 // Test fixture for AcceleratedSurfaceTransformer. 89 // 90 // This class is parameterized so that it runs only on Vista+. See 91 // WindowsVersionIfVistaOrBetter() for details on this works. 92 class AcceleratedSurfaceTransformerTest : public testing::TestWithParam<int> { 93 public: 94 AcceleratedSurfaceTransformerTest() : color_error_tolerance_(0) {}; 95 96 IDirect3DDevice9Ex* device() { return device_.get(); } 97 98 virtual void SetUp() { 99 if (!d3d_module_.is_valid()) { 100 if (!d3d_utils::LoadD3D9(&d3d_module_)) { 101 GTEST_FAIL() << "Could not load d3d9.dll"; 102 return; 103 } 104 } 105 if (!d3d_utils::CreateDevice(d3d_module_, 106 D3DDEVTYPE_HAL, 107 D3DPRESENT_INTERVAL_IMMEDIATE, 108 device_.Receive())) { 109 GTEST_FAIL() << "Could not create Direct3D device."; 110 return; 111 } 112 113 SeedRandom("default"); 114 } 115 116 virtual void TearDown() { 117 device_ = NULL; 118 } 119 120 // Gets a human-readable identifier of the graphics hardware being used, 121 // intended for use inside of SCOPED_TRACE(). 122 std::string GetAdapterInfo() { 123 ScopedComPtr<IDirect3D9> d3d; 124 EXPECT_HRESULT_SUCCEEDED(device()->GetDirect3D(d3d.Receive())); 125 D3DADAPTER_IDENTIFIER9 info; 126 EXPECT_HRESULT_SUCCEEDED(d3d->GetAdapterIdentifier(0, 0, &info)); 127 return base::StringPrintf( 128 "Running on graphics hardware: %s", info.Description); 129 } 130 131 void SeedRandom(const char* seed) { 132 rng_.seed(base::Hash(seed)); 133 random_dword_.reset(); 134 } 135 136 // Driver workaround: on an Intel GPU (Mobile Intel 965 Express), it seems 137 // necessary to flush between drawing and locking, for the synchronization 138 // to behave properly. 139 void BeforeLockWorkaround() { 140 EXPECT_HRESULT_SUCCEEDED( 141 device()->Present(0, 0, 0, 0)); 142 } 143 144 void WarnOnMissingFeatures(AcceleratedSurfaceTransformer* gpu_ops) { 145 // Prints a single warning line if some tests are feature-dependent 146 // and the feature is not supported by the current GPU. 147 if (!gpu_ops->device_supports_multiple_render_targets()) { 148 LOG(WARNING) << "MRT not supported, some tests will be skipped. " 149 << GetAdapterInfo(); 150 } 151 } 152 153 // Locks and fills a surface with a checkerboard pattern where the colors 154 // are random but the total image pattern is horizontally and vertically 155 // symmetric. 156 void FillSymmetricRandomCheckerboard( 157 IDirect3DSurface9* lockable_surface, 158 const gfx::Size& size, 159 int checker_square_size) { 160 161 D3DLOCKED_RECT locked_rect; 162 ASSERT_HRESULT_SUCCEEDED( 163 lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD)); 164 DWORD* surface = reinterpret_cast<DWORD*>(locked_rect.pBits); 165 ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD)); 166 int pitch = locked_rect.Pitch / sizeof(DWORD); 167 168 for (int y = 0; y < (size.height() + 1) / 2; y += checker_square_size) { 169 for (int x = 0; x < (size.width() + 1) / 2; x += checker_square_size) { 170 DWORD color = RandomColor(); 171 int y_limit = std::min(size.height() / 2, y + checker_square_size - 1); 172 int x_limit = std::min(size.width() / 2, x + checker_square_size - 1); 173 for (int y_lo = y; y_lo <= y_limit; y_lo++) { 174 for (int x_lo = x; x_lo <= x_limit; x_lo++) { 175 int y_hi = size.height() - 1 - y_lo; 176 int x_hi = size.width() - 1 - x_lo; 177 surface[x_lo + y_lo*pitch] = color; 178 surface[x_lo + y_hi*pitch] = color; 179 surface[x_hi + y_lo*pitch] = color; 180 surface[x_hi + y_hi*pitch] = color; 181 } 182 } 183 } 184 } 185 186 lockable_surface->UnlockRect(); 187 } 188 189 void FillRandomCheckerboard( 190 IDirect3DSurface9* lockable_surface, 191 const gfx::Size& size, 192 int checker_square_size) { 193 194 D3DLOCKED_RECT locked_rect; 195 ASSERT_HRESULT_SUCCEEDED( 196 lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD)); 197 DWORD* surface = reinterpret_cast<DWORD*>(locked_rect.pBits); 198 ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD)); 199 int pitch = locked_rect.Pitch / sizeof(DWORD); 200 201 for (int y = 0; y <= size.height(); y += checker_square_size) { 202 for (int x = 0; x <= size.width(); x += checker_square_size) { 203 DWORD color = RandomColor(); 204 int y_limit = std::min(size.height(), y + checker_square_size); 205 int x_limit = std::min(size.width(), x + checker_square_size); 206 for (int square_y = y; square_y < y_limit; square_y++) { 207 for (int square_x = x; square_x < x_limit; square_x++) { 208 surface[square_x + square_y*pitch] = color; 209 } 210 } 211 } 212 } 213 214 lockable_surface->UnlockRect(); 215 } 216 217 // Approximate color-equality check. Allows for some rounding error. 218 bool AssertSameColor(DWORD color_a, DWORD color_b) { 219 if (color_a == color_b) 220 return true; 221 uint8* a = reinterpret_cast<uint8*>(&color_a); 222 uint8* b = reinterpret_cast<uint8*>(&color_b); 223 int max_error = 0; 224 for (int i = 0; i < 4; i++) 225 max_error = std::max(max_error, 226 std::abs(static_cast<int>(a[i]) - b[i])); 227 228 if (max_error <= color_error_tolerance()) 229 return true; 230 231 std::string expected_color = 232 base::StringPrintf("%3d, %3d, %3d, %3d", a[0], a[1], a[2], a[3]); 233 std::string actual_color = 234 base::StringPrintf("%3d, %3d, %3d, %3d", b[0], b[1], b[2], b[3]); 235 EXPECT_EQ(expected_color, actual_color) 236 << "Componentwise color difference was " 237 << max_error << "; max allowed is " << color_error_tolerance(); 238 239 return false; 240 } 241 242 bool AssertSameColor(uint8 color_a, uint8 color_b) { 243 if (color_a == color_b) 244 return true; 245 int max_error = std::abs((int) color_a - (int) color_b); 246 if (max_error <= color_error_tolerance()) 247 return true; 248 ADD_FAILURE() << "Colors not equal: " 249 << base::StringPrintf("0x%x", color_a) 250 << " vs. " << base::StringPrintf("0x%x", color_b); 251 return false; 252 } 253 254 // Asserts that an image is symmetric with respect to itself: both 255 // horizontally and vertically, within the tolerance of AssertSameColor. 256 void AssertSymmetry(IDirect3DSurface9* lockable_surface, 257 const gfx::Size& size) { 258 BeforeLockWorkaround(); 259 260 D3DLOCKED_RECT locked_rect; 261 ASSERT_HRESULT_SUCCEEDED( 262 lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY)); 263 ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD)); 264 int pitch = locked_rect.Pitch / sizeof(DWORD); 265 DWORD* surface = reinterpret_cast<DWORD*>(locked_rect.pBits); 266 for (int y_lo = 0; y_lo < size.height() / 2; y_lo++) { 267 int y_hi = size.height() - 1 - y_lo; 268 for (int x_lo = 0; x_lo < size.width() / 2; x_lo++) { 269 int x_hi = size.width() - 1 - x_lo; 270 if (!AssertSameColor(surface[x_lo + y_lo*pitch], 271 surface[x_hi + y_lo*pitch])) { 272 lockable_surface->UnlockRect(); 273 GTEST_FAIL() << "Pixels (" << x_lo << ", " << y_lo << ") vs. " 274 << "(" << x_hi << ", " << y_lo << ")"; 275 } 276 if (!AssertSameColor(surface[x_hi + y_lo*pitch], 277 surface[x_hi + y_hi*pitch])) { 278 lockable_surface->UnlockRect(); 279 GTEST_FAIL() << "Pixels (" << x_hi << ", " << y_lo << ") vs. " 280 << "(" << x_hi << ", " << y_hi << ")"; 281 } 282 if (!AssertSameColor(surface[x_hi + y_hi*pitch], 283 surface[x_lo + y_hi*pitch])) { 284 lockable_surface->UnlockRect(); 285 GTEST_FAIL() << "Pixels (" << x_hi << ", " << y_hi << ") vs. " 286 << "(" << x_lo << ", " << y_hi << ")"; 287 } 288 } 289 } 290 lockable_surface->UnlockRect(); 291 } 292 293 // Asserts that the actual image is a bit-identical, vertically mirrored 294 // copy of the expected image. 295 void AssertIsInvertedCopy(const gfx::Size& size, 296 IDirect3DSurface9* expected, 297 IDirect3DSurface9* actual) { 298 BeforeLockWorkaround(); 299 300 D3DLOCKED_RECT locked_expected, locked_actual; 301 ASSERT_HRESULT_SUCCEEDED( 302 expected->LockRect(&locked_expected, NULL, D3DLOCK_READONLY)); 303 ASSERT_HRESULT_SUCCEEDED( 304 actual->LockRect(&locked_actual, NULL, D3DLOCK_READONLY)); 305 ASSERT_EQ(0, locked_expected.Pitch % sizeof(DWORD)); 306 int pitch = locked_expected.Pitch / sizeof(DWORD); 307 DWORD* expected_image = reinterpret_cast<DWORD*>(locked_expected.pBits); 308 DWORD* actual_image = reinterpret_cast<DWORD*>(locked_actual.pBits); 309 for (int y = 0; y < size.height(); y++) { 310 int y_actual = size.height() - 1 - y; 311 for (int x = 0; x < size.width(); ++x) 312 if (!AssertSameColor(expected_image[y*pitch + x], 313 actual_image[y_actual*pitch + x])) { 314 expected->UnlockRect(); 315 actual->UnlockRect(); 316 GTEST_FAIL() << "Pixels (" << x << ", " << y << ") vs. " 317 << "(" << x << ", " << y_actual << ")"; 318 } 319 } 320 expected->UnlockRect(); 321 actual->UnlockRect(); 322 } 323 324 protected: 325 DWORD RandomColor() { 326 return random_dword_(rng_); 327 } 328 329 void set_color_error_tolerance(int value) { 330 color_error_tolerance_ = value; 331 } 332 333 int color_error_tolerance() { 334 return color_error_tolerance_; 335 } 336 337 void DoResizeBilinearTest(AcceleratedSurfaceTransformer* gpu_ops, 338 const gfx::Size& src_size, 339 const gfx::Size& dst_size, 340 int checkerboard_size) { 341 342 SCOPED_TRACE( 343 base::StringPrintf( 344 "Resizing %dx%d -> %dx%d at checkerboard size of %d", 345 src_size.width(), src_size.height(), 346 dst_size.width(), dst_size.height(), 347 checkerboard_size)); 348 349 set_color_error_tolerance(4); 350 351 base::win::ScopedComPtr<IDirect3DSurface9> src, dst; 352 ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface( 353 device(), src_size, &src)) 354 << "Could not create src render target"; 355 ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface( 356 device(), dst_size, &dst)) 357 << "Could not create dst render target"; 358 359 FillSymmetricRandomCheckerboard(src, src_size, checkerboard_size); 360 361 ASSERT_TRUE(gpu_ops->ResizeBilinear(src, gfx::Rect(src_size), dst, 362 gfx::Rect(dst_size))); 363 364 AssertSymmetry(dst, dst_size); 365 } 366 367 void CreateRandomCheckerboardTexture( 368 const gfx::Size& size, 369 int checkerboard_size, 370 base::win::ScopedComPtr<IDirect3DSurface9>* reference_surface, 371 base::win::ScopedComPtr<IDirect3DTexture9>* result) { 372 base::win::ScopedComPtr<IDirect3DSurface9> dst; 373 ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(device(), size, 374 reference_surface)); 375 ASSERT_TRUE(d3d_utils::CreateOrReuseRenderTargetTexture(device(), size, 376 result, dst.Receive())); 377 FillRandomCheckerboard(*reference_surface, size, checkerboard_size); 378 ASSERT_HRESULT_SUCCEEDED( 379 device()->StretchRect( 380 *reference_surface, NULL, dst, NULL, D3DTEXF_NONE)); 381 } 382 383 void AssertSame(int width_in_bytes, int height, uint8* reference, 384 IDirect3DSurface9* lockable) { 385 BeforeLockWorkaround(); 386 387 D3DLOCKED_RECT locked_rect; 388 ASSERT_HRESULT_SUCCEEDED( 389 lockable->LockRect(&locked_rect, NULL, D3DLOCK_READONLY)); 390 uint8* actual = reinterpret_cast<uint8*>(locked_rect.pBits); 391 for (int y = 0; y < height; ++y) { 392 for (int x = 0; x < width_in_bytes; ++x) { 393 if (!AssertSameColor(reference[y * width_in_bytes + x], 394 actual[y * locked_rect.Pitch + x])) { 395 lockable->UnlockRect(); 396 GTEST_FAIL() << "At pixel (" << x << ", " << y << ")"; 397 } 398 } 399 } 400 lockable->UnlockRect(); 401 } 402 403 void DoCopyInvertedTest(AcceleratedSurfaceTransformer* gpu_ops, 404 const gfx::Size& size) { 405 406 SCOPED_TRACE(base::StringPrintf( 407 "CopyInverted @ %dx%d", size.width(), size.height())); 408 409 set_color_error_tolerance(0); 410 411 base::win::ScopedComPtr<IDirect3DSurface9> dst, reference_pattern; 412 base::win::ScopedComPtr<IDirect3DTexture9> src; 413 414 CreateRandomCheckerboardTexture(size, 1, &reference_pattern, &src); 415 416 // Alloc a slightly larger image 75% of the time, to test that the 417 // viewport is set properly. 418 const int kAlign = 4; 419 gfx::Size alloc_size((size.width() + kAlign - 1) / kAlign * kAlign, 420 (size.height() + kAlign - 1) / kAlign * kAlign); 421 422 ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(device(), alloc_size, 423 &dst)) << "Could not create dst render target."; 424 425 ASSERT_TRUE(gpu_ops->CopyInverted(src, dst, size)); 426 AssertIsInvertedCopy(size, reference_pattern, dst); 427 } 428 429 430 void DoYUVConversionTest(AcceleratedSurfaceTransformer* gpu_ops, 431 const gfx::Size& src_size, 432 int checkerboard_size) { 433 // Test the non-MRT implementation, and the MRT implementation as well 434 // (if supported by the device). 435 ASSERT_NO_FATAL_FAILURE( 436 DoYUVConversionTest(gpu_ops, src_size, src_size, 437 checkerboard_size, false)); 438 if (gpu_ops->device_supports_multiple_render_targets()) { 439 ASSERT_NO_FATAL_FAILURE( 440 DoYUVConversionTest(gpu_ops, src_size, src_size, 441 checkerboard_size, true)); 442 } 443 } 444 445 void DoYUVConversionScaleTest(AcceleratedSurfaceTransformer* gpu_ops, 446 const gfx::Size& src_size, 447 const gfx::Size& dst_size) { 448 // Test the non-MRT implementation, and the MRT implementation as well 449 // (if supported by the device). 450 if (gpu_ops->device_supports_multiple_render_targets()) { 451 ASSERT_NO_FATAL_FAILURE( 452 DoYUVConversionTest(gpu_ops, src_size, dst_size, 4, true)); 453 } 454 ASSERT_NO_FATAL_FAILURE( 455 DoYUVConversionTest(gpu_ops, src_size, dst_size, 4, false)); 456 } 457 458 void DoYUVConversionTest(AcceleratedSurfaceTransformer* gpu_ops, 459 const gfx::Size& src_size, 460 const gfx::Size& dst_size, 461 int checkerboard_size, 462 boolean use_multi_render_targets) { 463 SCOPED_TRACE( 464 base::StringPrintf( 465 "YUV Converting %dx%d at checkerboard size of %d; MRT %s", 466 src_size.width(), src_size.height(), 467 checkerboard_size, 468 use_multi_render_targets ? "enabled" : "disabled")); 469 470 471 base::win::ScopedComPtr<IDirect3DTexture9> src; 472 base::win::ScopedComPtr<IDirect3DSurface9> reference; 473 base::win::ScopedComPtr<IDirect3DSurface9> dst_y, dst_u, dst_v; 474 475 // TODO(ncarter): Use a better error metric that measures aggregate error 476 // rather than simply max error. There seems to be slightly more error at 477 // higher resolutions, maybe due to precision issues during rasterization 478 // (or maybe more pixels = more test trials). Results are usually to an 479 // error of 1, but we must use a tolerance of 3. 480 set_color_error_tolerance(3); 481 CreateRandomCheckerboardTexture(src_size, checkerboard_size, &reference, 482 &src); 483 484 gfx::Size packed_y_size, packed_uv_size; 485 486 ASSERT_TRUE(gpu_ops->AllocYUVBuffers(dst_size, 487 &packed_y_size, 488 &packed_uv_size, 489 dst_y.Receive(), 490 dst_u.Receive(), 491 dst_v.Receive())); 492 493 // Actually do the conversion. 494 if (use_multi_render_targets) { 495 ASSERT_TRUE(gpu_ops->TransformRGBToYV12_MRT(src, 496 dst_size, 497 packed_y_size, 498 packed_uv_size, 499 dst_y, 500 dst_u, 501 dst_v)); 502 } else { 503 ASSERT_TRUE(gpu_ops->TransformRGBToYV12_WithoutMRT(src, 504 dst_size, 505 packed_y_size, 506 packed_uv_size, 507 dst_y, 508 dst_u, 509 dst_v)); 510 } 511 512 // UV size (in bytes/samples) is half, rounded up. 513 gfx::Size uv_size((dst_size.width() + 1) / 2, 514 (dst_size.height() + 1) / 2); 515 516 // Generate a reference bitmap by calling a software implementation. 517 SkBitmap reference_rgb = ToSkBitmap(reference, false); 518 SkBitmap reference_rgb_scaled; 519 if (dst_size == src_size) { 520 reference_rgb_scaled = reference_rgb; 521 } else { 522 // We'll call Copy to do the bilinear scaling if needed. 523 base::win::ScopedComPtr<IDirect3DSurface9> reference_scaled; 524 ASSERT_TRUE( 525 d3d_utils::CreateOrReuseLockableSurface( 526 device(), dst_size, &reference_scaled)); 527 ASSERT_TRUE(gpu_ops->Copy(src, reference_scaled, dst_size)); 528 BeforeLockWorkaround(); 529 reference_rgb_scaled = ToSkBitmap(reference_scaled, false); 530 } 531 532 scoped_ptr<uint8[]> reference_y(new uint8[dst_size.GetArea()]); 533 scoped_ptr<uint8[]> reference_u(new uint8[uv_size.GetArea()]); 534 scoped_ptr<uint8[]> reference_v(new uint8[uv_size.GetArea()]); 535 reference_rgb_scaled.lockPixels(); 536 media::ConvertRGB32ToYUV_SSE2_Reference( 537 reinterpret_cast<uint8*>(reference_rgb_scaled.getAddr32(0, 0)), 538 &reference_y[0], 539 &reference_u[0], 540 &reference_v[0], 541 dst_size.width(), 542 dst_size.height(), 543 reference_rgb_scaled.rowBytes(), 544 dst_size.width(), 545 uv_size.width()); 546 reference_rgb_scaled.unlockPixels(); 547 548 // Check for equality of the reference and the actual. 549 AssertSame(dst_size.width(), dst_size.height(), &reference_y[0], dst_y); 550 AssertSame(uv_size.width(), uv_size.height(), &reference_u[0], dst_u); 551 AssertSame(uv_size.width(), uv_size.height(), &reference_v[0], dst_v); 552 553 if (kDumpImagesOnFailure && HasFatalFailure()) { 554 // Note that this will dump the full u and v buffers, including 555 // extra columns added due to packing. That means up to 7 extra 556 // columns for uv, and up to 3 extra columns for y. 557 WritePNGFile(reference_rgb, 558 base::FilePath(FILE_PATH_LITERAL("test_fail_src.png"))); 559 WritePNGFile(reference_rgb_scaled, 560 base::FilePath( 561 FILE_PATH_LITERAL("test_fail_src_scaled.png"))); 562 WritePNGFile(ToSkBitmap(dst_y, true), 563 base::FilePath(FILE_PATH_LITERAL("test_fail_y.png"))); 564 WritePNGFile(ToSkBitmap(dst_u, true), 565 base::FilePath(FILE_PATH_LITERAL("test_fail_u.png"))); 566 WritePNGFile(ToSkBitmap(dst_v, true), 567 base::FilePath(FILE_PATH_LITERAL("test_fail_v.png"))); 568 } 569 } 570 571 int color_error_tolerance_; 572 uniform_int_distribution<DWORD> random_dword_; 573 std::mt19937 rng_; 574 base::ScopedNativeLibrary d3d_module_; 575 base::win::ScopedComPtr<IDirect3DDevice9Ex> device_; 576 }; 577 578 // Fails on some bots because Direct3D isn't allowed. 579 TEST_P(AcceleratedSurfaceTransformerTest, Init) { 580 SCOPED_TRACE(GetAdapterInfo()); 581 AcceleratedSurfaceTransformer gpu_ops; 582 ASSERT_TRUE(gpu_ops.Init(device())); 583 584 WarnOnMissingFeatures(&gpu_ops); 585 }; 586 587 // Fails on some bots because Direct3D isn't allowed. 588 TEST_P(AcceleratedSurfaceTransformerTest, TestConsistentRandom) { 589 // This behavior should be the same for every execution on every machine. 590 // Otherwise tests might be flaky and impossible to debug. 591 SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom"); 592 ASSERT_EQ(2922058934, RandomColor()); 593 594 SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom"); 595 ASSERT_EQ(2922058934, RandomColor()); 596 ASSERT_EQ(4050239976, RandomColor()); 597 598 SeedRandom("DifferentSeed"); 599 ASSERT_EQ(3904108833, RandomColor()); 600 } 601 602 // Fails on some bots because Direct3D isn't allowed. 603 TEST_P(AcceleratedSurfaceTransformerTest, CopyInverted) { 604 // This behavior should be the same for every execution on every machine. 605 // Otherwise tests might be flaky and impossible to debug. 606 SCOPED_TRACE(GetAdapterInfo()); 607 SeedRandom("CopyInverted"); 608 609 AcceleratedSurfaceTransformer t; 610 ASSERT_TRUE(t.Init(device())); 611 612 uniform_int_distribution<int> size(1, 512); 613 614 for (int i = 0; i < 100; ++i) { 615 ASSERT_NO_FATAL_FAILURE( 616 DoCopyInvertedTest(&t, gfx::Size(size(rng_), size(rng_)))) 617 << "At iteration " << i; 618 } 619 } 620 621 // Fails on some bots because Direct3D isn't allowed. 622 // Fails on other bots because of ResizeBilinear symmetry failures. 623 // Should pass, at least, on NVIDIA Quadro 600. 624 TEST_P(AcceleratedSurfaceTransformerTest, MixedOperations) { 625 SCOPED_TRACE(GetAdapterInfo()); 626 SeedRandom("MixedOperations"); 627 628 AcceleratedSurfaceTransformer t; 629 ASSERT_TRUE(t.Init(device())); 630 631 ASSERT_NO_FATAL_FAILURE( 632 DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 1)); 633 ASSERT_NO_FATAL_FAILURE( 634 DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 2)); 635 ASSERT_NO_FATAL_FAILURE( 636 DoCopyInvertedTest(&t, gfx::Size(20, 107))); 637 ASSERT_NO_FATAL_FAILURE( 638 DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 5)); 639 ASSERT_NO_FATAL_FAILURE( 640 DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(64, 64), 5)); 641 ASSERT_NO_FATAL_FAILURE( 642 DoYUVConversionTest(&t, gfx::Size(128, 128), 1)); 643 ASSERT_NO_FATAL_FAILURE( 644 DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(3, 3), 1)); 645 ASSERT_NO_FATAL_FAILURE( 646 DoCopyInvertedTest(&t, gfx::Size(1412, 124))); 647 ASSERT_NO_FATAL_FAILURE( 648 DoYUVConversionTest(&t, gfx::Size(100, 200), 1)); 649 ASSERT_NO_FATAL_FAILURE( 650 DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 1)); 651 ASSERT_NO_FATAL_FAILURE( 652 DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 2)); 653 654 ASSERT_NO_FATAL_FAILURE( 655 DoCopyInvertedTest(&t, gfx::Size(1512, 7))); 656 ASSERT_NO_FATAL_FAILURE( 657 DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 5)); 658 ASSERT_NO_FATAL_FAILURE( 659 DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 8)); 660 ASSERT_NO_FATAL_FAILURE( 661 DoCopyInvertedTest(&t, gfx::Size(1521, 3))); 662 ASSERT_NO_FATAL_FAILURE( 663 DoYUVConversionTest(&t, gfx::Size(140, 181), 1)); 664 ASSERT_NO_FATAL_FAILURE( 665 DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 1)); 666 ASSERT_NO_FATAL_FAILURE( 667 DoCopyInvertedTest(&t, gfx::Size(33, 712))); 668 ASSERT_NO_FATAL_FAILURE( 669 DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 8), 8)); 670 ASSERT_NO_FATAL_FAILURE( 671 DoCopyInvertedTest(&t, gfx::Size(33, 2))); 672 ASSERT_NO_FATAL_FAILURE( 673 DoResizeBilinearTest(&t, gfx::Size(200, 256), gfx::Size(126, 8), 8)); 674 } 675 676 // Tests ResizeBilinear with 16K wide/hight src and dst surfaces. 677 // 678 // Fails on some bots because Direct3D isn't allowed. 679 // Should pass, at least, on NVIDIA Quadro 600. 680 TEST_P(AcceleratedSurfaceTransformerTest, LargeSurfaces) { 681 SCOPED_TRACE(GetAdapterInfo()); 682 SeedRandom("LargeSurfaces"); 683 684 AcceleratedSurfaceTransformer gpu_ops; 685 ASSERT_TRUE(gpu_ops.Init(device())); 686 687 D3DCAPS9 caps; 688 ASSERT_HRESULT_SUCCEEDED( 689 device()->GetDeviceCaps(&caps)); 690 691 SCOPED_TRACE(base::StringPrintf( 692 "max texture size: %dx%d, max texture aspect: %d", 693 caps.MaxTextureWidth, caps.MaxTextureHeight, caps.MaxTextureAspectRatio)); 694 695 const int w = caps.MaxTextureWidth; 696 const int h = caps.MaxTextureHeight; 697 const int lo = 256; 698 699 ASSERT_NO_FATAL_FAILURE( 700 DoResizeBilinearTest(&gpu_ops, gfx::Size(w, lo), gfx::Size(lo, lo), 1)); 701 ASSERT_NO_FATAL_FAILURE( 702 DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, h), gfx::Size(lo, lo), 1)); 703 ASSERT_NO_FATAL_FAILURE( 704 DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(w, lo), lo)); 705 ASSERT_NO_FATAL_FAILURE( 706 DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(lo, h), lo)); 707 ASSERT_NO_FATAL_FAILURE( 708 DoCopyInvertedTest(&gpu_ops, gfx::Size(w, lo))); 709 ASSERT_NO_FATAL_FAILURE( 710 DoCopyInvertedTest(&gpu_ops, gfx::Size(lo, h))); 711 712 ASSERT_NO_FATAL_FAILURE( 713 DoYUVConversionTest(&gpu_ops, gfx::Size(w, lo), 1)); 714 ASSERT_NO_FATAL_FAILURE( 715 DoYUVConversionTest(&gpu_ops, gfx::Size(lo, h), 1)); 716 717 } 718 719 // Exercises ResizeBilinear with random minification cases where the 720 // aspect ratio does not change. 721 // 722 // Fails on some bots because Direct3D isn't allowed. 723 // Fails on other bots because of StretchRect symmetry failures. 724 // Should pass, at least, on NVIDIA Quadro 600. 725 TEST_P(AcceleratedSurfaceTransformerTest, MinifyUniform) { 726 SCOPED_TRACE(GetAdapterInfo()); 727 SeedRandom("MinifyUniform"); 728 729 AcceleratedSurfaceTransformer gpu_ops; 730 ASSERT_TRUE(gpu_ops.Init(device())); 731 732 const int dims[] = {21, 63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257}; 733 const int checkerboards[] = {1, 2, 3, 9}; 734 uniform_int_distribution<int> dim(0, arraysize(dims) - 1); 735 uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1); 736 737 for (int i = 0; i < 300; i++) { 738 // Widths are picked so that dst is smaller than src. 739 int dst_width = dims[dim(rng_)]; 740 int src_width = dims[dim(rng_)]; 741 if (src_width < dst_width) 742 std::swap(dst_width, src_width); 743 744 // src_height is picked to preserve aspect ratio. 745 int dst_height = dims[dim(rng_)]; 746 int src_height = static_cast<int>( 747 static_cast<int64>(src_width) * dst_height / dst_width); 748 749 int checkerboard_size = checkerboards[checkerboard(rng_)]; 750 751 ASSERT_NO_FATAL_FAILURE( 752 DoResizeBilinearTest(&gpu_ops, 753 gfx::Size(src_width, src_height), // Src size (larger) 754 gfx::Size(dst_width, dst_height), // Dst size (smaller) 755 checkerboard_size)) << "Failed on iteration " << i; 756 } 757 }; 758 759 // Exercises ResizeBilinear with random magnification cases where the 760 // aspect ratio does not change. 761 // 762 // This test relies on an assertion that resizing preserves symmetry in the 763 // image, but for the current implementation of ResizeBilinear, this does not 764 // seem to be true (fails on NVIDIA Quadro 600; passes on 765 // Intel Mobile 965 Express) 766 TEST_P(AcceleratedSurfaceTransformerTest, DISABLED_MagnifyUniform) { 767 SCOPED_TRACE(GetAdapterInfo()); 768 SeedRandom("MagnifyUniform"); 769 770 AcceleratedSurfaceTransformer gpu_ops; 771 ASSERT_TRUE(gpu_ops.Init(device())); 772 773 const int dims[] = {63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257}; 774 const int checkerboards[] = {1, 2, 3, 9}; 775 uniform_int_distribution<int> dim(0, arraysize(dims) - 1); 776 uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1); 777 778 for (int i = 0; i < 50; i++) { 779 // Widths are picked so that src is smaller than dst. 780 int dst_width = dims[dim(rng_)]; 781 int src_width = dims[dim(rng_)]; 782 if (dst_width < src_width) 783 std::swap(src_width, dst_width); 784 785 int dst_height = dims[dim(rng_)]; 786 int src_height = static_cast<int>( 787 static_cast<int64>(src_width) * dst_height / dst_width); 788 789 int checkerboard_size = checkerboards[checkerboard(rng_)]; 790 791 ASSERT_NO_FATAL_FAILURE( 792 DoResizeBilinearTest(&gpu_ops, 793 gfx::Size(src_width, src_height), // Src size (smaller) 794 gfx::Size(dst_width, dst_height), // Dst size (larger) 795 checkerboard_size)) << "Failed on iteration " << i; 796 } 797 }; 798 799 TEST_P(AcceleratedSurfaceTransformerTest, RGBtoYUV) { 800 SeedRandom("RGBtoYUV"); 801 802 AcceleratedSurfaceTransformer gpu_ops; 803 ASSERT_TRUE(gpu_ops.Init(device())); 804 805 // Start with some easy-to-debug cases. A checkerboard size of 1 is the 806 // best test, but larger checkerboard sizes give more insight into where 807 // a bug might be. 808 ASSERT_NO_FATAL_FAILURE( 809 DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 4)); 810 ASSERT_NO_FATAL_FAILURE( 811 DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 2)); 812 ASSERT_NO_FATAL_FAILURE( 813 DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 3)); 814 815 // All cases of width (mod 8) and height (mod 8), using 1x1 checkerboard. 816 for (int w = 32; w < 40; ++w) { 817 for (int h = 32; h < 40; ++h) { 818 ASSERT_NO_FATAL_FAILURE( 819 DoYUVConversionTest(&gpu_ops, gfx::Size(w, h), 1)); 820 } 821 } 822 823 // All the very small sizes which require the most shifting in the 824 // texture coordinates when doing alignment. 825 for (int w = 1; w <= 9; ++w) { 826 for (int h = 1; h <= 9; ++h) { 827 ASSERT_NO_FATAL_FAILURE( 828 DoYUVConversionTest(&gpu_ops, gfx::Size(w, h), 1)); 829 } 830 } 831 832 // Random medium dimensions. 833 ASSERT_NO_FATAL_FAILURE( 834 DoYUVConversionTest(&gpu_ops, gfx::Size(10, 142), 1)); 835 ASSERT_NO_FATAL_FAILURE( 836 DoYUVConversionTest(&gpu_ops, gfx::Size(124, 333), 1)); 837 ASSERT_NO_FATAL_FAILURE( 838 DoYUVConversionTest(&gpu_ops, gfx::Size(853, 225), 1)); 839 ASSERT_NO_FATAL_FAILURE( 840 DoYUVConversionTest(&gpu_ops, gfx::Size(231, 412), 1)); 841 ASSERT_NO_FATAL_FAILURE( 842 DoYUVConversionTest(&gpu_ops, gfx::Size(512, 128), 1)); 843 ASSERT_NO_FATAL_FAILURE( 844 DoYUVConversionTest(&gpu_ops, gfx::Size(1024, 768), 1)); 845 846 // Common video/monitor resolutions 847 ASSERT_NO_FATAL_FAILURE( 848 DoYUVConversionTest(&gpu_ops, gfx::Size(800, 768), 1)); 849 ASSERT_NO_FATAL_FAILURE( 850 DoYUVConversionTest(&gpu_ops, gfx::Size(1024, 768), 1)); 851 ASSERT_NO_FATAL_FAILURE( 852 DoYUVConversionTest(&gpu_ops, gfx::Size(1280, 720), 1)); 853 ASSERT_NO_FATAL_FAILURE( 854 DoYUVConversionTest(&gpu_ops, gfx::Size(1280, 720), 2)); 855 ASSERT_NO_FATAL_FAILURE( 856 DoYUVConversionTest(&gpu_ops, gfx::Size(1920, 1080), 1)); 857 ASSERT_NO_FATAL_FAILURE( 858 DoYUVConversionTest(&gpu_ops, gfx::Size(1920, 1080), 2)); 859 ASSERT_NO_FATAL_FAILURE( 860 DoYUVConversionTest(&gpu_ops, gfx::Size(2048, 1536), 1)); 861 } 862 863 TEST_P(AcceleratedSurfaceTransformerTest, RGBtoYUVScaled) { 864 SeedRandom("RGBtoYUVScaled"); 865 866 AcceleratedSurfaceTransformer gpu_ops; 867 ASSERT_TRUE(gpu_ops.Init(device())); 868 869 ASSERT_NO_FATAL_FAILURE( 870 DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(64, 64))); 871 872 ASSERT_NO_FATAL_FAILURE( 873 DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(16, 16))); 874 ASSERT_NO_FATAL_FAILURE( 875 DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(24, 24))); 876 ASSERT_NO_FATAL_FAILURE( 877 DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(48, 48))); 878 } 879 880 namespace { 881 882 // Used to suppress test on Windows versions prior to Vista. 883 std::vector<int> WindowsVersionIfVistaOrBetter() { 884 std::vector<int> result; 885 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { 886 result.push_back(base::win::GetVersion()); 887 } 888 return result; 889 } 890 891 } // namespace 892 893 INSTANTIATE_TEST_CASE_P(VistaAndUp, 894 AcceleratedSurfaceTransformerTest, 895 ::testing::ValuesIn(WindowsVersionIfVistaOrBetter())); 896
