diff options
Diffstat (limited to 'ui/surface/accelerated_surface_transformer_win_unittest.cc')
-rw-r--r-- | ui/surface/accelerated_surface_transformer_win_unittest.cc | 424 |
1 files changed, 0 insertions, 424 deletions
diff --git a/ui/surface/accelerated_surface_transformer_win_unittest.cc b/ui/surface/accelerated_surface_transformer_win_unittest.cc deleted file mode 100644 index 240468d..0000000 --- a/ui/surface/accelerated_surface_transformer_win_unittest.cc +++ /dev/null @@ -1,424 +0,0 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include <d3d9.h> -#include <random> - -#include "base/basictypes.h" -#include "base/hash.h" -#include "base/scoped_native_library.h" -#include "base/stringprintf.h" -#include "base/win/scoped_comptr.h" -#include "base/win/windows_version.h" -#include "testing/gtest/include/gtest/gtest-param-test.h" -#include "testing/gtest/include/gtest/gtest.h" -#include "ui/gfx/rect.h" -#include "ui/surface/accelerated_surface_transformer_win.h" -#include "ui/surface/accelerated_surface_win.h" -#include "ui/surface/d3d9_utils_win.h" - -namespace d3d_utils = ui_surface_d3d9_utils; - -using base::win::ScopedComPtr; -using std::uniform_int_distribution; - -// Provides a reference rasterizer (all rendering done by software emulation) -// Direct3D device, for use by unit tests. -// -// This class is parameterized so that it runs only on Vista+. See -// WindowsVersionIfVistaOrBetter() for details on this works. -class AcceleratedSurfaceTransformerTest : public testing::TestWithParam<int> { - public: - AcceleratedSurfaceTransformerTest() {}; - - IDirect3DDevice9Ex* device() { return device_.get(); } - - virtual void SetUp() { - if (!d3d_module_.is_valid()) { - if (!d3d_utils::LoadD3D9(&d3d_module_)) { - GTEST_FAIL(); - return; - } - } - if (!d3d_utils::CreateDevice(d3d_module_, - D3DDEVTYPE_HAL, - D3DPRESENT_INTERVAL_IMMEDIATE, - device_.Receive())) { - GTEST_FAIL(); - return; - } - const ::testing::TestInfo* const test_info = - ::testing::UnitTest::GetInstance()->current_test_info(); - SeedRandom("default"); - } - - virtual void TearDown() { - device_ = NULL; - } - - void SeedRandom(const char* seed) { - rng_.seed(base::Hash(seed)); - random_dword_.reset(); - } - - // Locks and fills a surface with a checkerboard pattern where the colors - // are random but the total image pattern is horizontally and vertically - // symmetric. - template<typename ColorType> - void FillSymmetricRandomCheckerboard( - IDirect3DSurface9* lockable_surface, - const gfx::Size& size, - int checker_square_size) { - - D3DLOCKED_RECT locked_rect; - ASSERT_HRESULT_SUCCEEDED( - lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD)); - ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits); - ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType)); - int pitch = locked_rect.Pitch / sizeof(ColorType); - - for (int y = 0; y <= size.height() / 2; y += checker_square_size) { - for (int x = 0; x <= size.width() / 2; x += checker_square_size) { - ColorType color = static_cast<ColorType>(RandomColor()); - int y_limit = std::min(size.height() / 2, y + checker_square_size - 1); - int x_limit = std::min(size.width() / 2, x + checker_square_size - 1); - for (int y_lo = y; y_lo <= y_limit; y_lo++) { - for (int x_lo = x; x_lo <= x_limit; x_lo++) { - int y_hi = size.height() - 1 - y_lo; - int x_hi = size.width() - 1 - x_lo; - surface[x_lo + y_lo*pitch] = color; - surface[x_lo + y_hi*pitch] = color; - surface[x_hi + y_lo*pitch] = color; - surface[x_hi + y_hi*pitch] = color; - } - } - } - } - - lockable_surface->UnlockRect(); - } - - template<typename ColorType> - void FillRandomCheckerboard( - IDirect3DSurface9* lockable_surface, - const gfx::Size& size, - int checker_square_size) { - - D3DLOCKED_RECT locked_rect; - ASSERT_HRESULT_SUCCEEDED( - lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_DISCARD)); - ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits); - ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType)); - int pitch = locked_rect.Pitch / sizeof(ColorType); - - for (int y = 0; y <= size.height(); y += checker_square_size) { - for (int x = 0; x <= size.width(); x += checker_square_size) { - ColorType color = static_cast<ColorType>(RandomColor()); - int y_limit = std::min(size.height(), y + checker_square_size); - int x_limit = std::min(size.width(), x + checker_square_size); - for (int square_y = y; square_y < y_limit; square_y++) { - for (int square_x = x; square_x < x_limit; square_x++) { - surface[square_x + square_y*pitch] = color; - } - } - } - } - - lockable_surface->UnlockRect(); - } - - // Approximate color-equality check. Allows for some rounding error. - bool AssertSameColor(DWORD color_a, DWORD color_b) { - if (color_a == color_b) - return true; - uint8* a = reinterpret_cast<uint8*>(&color_a); - uint8* b = reinterpret_cast<uint8*>(&color_b); - int max_error = 0; - for (int i = 0; i < 4; i++) - max_error = std::max(max_error, - std::abs(static_cast<int>(a[i]) - b[i])); - - if (max_error <= kAbsoluteColorErrorTolerance) - return true; - - EXPECT_EQ(StringPrintf("%d %d %d %d", a[0], a[1], a[2], a[3]), - StringPrintf("%d %d %d %d", b[0], b[1], b[2], b[3])); - - return false; - } - - // Asserts that an image is symmetric with respect to itself: both - // horizontally and vertically, within the tolerance of AssertSameColor. - template<typename ColorType> - void AssertSymmetry(IDirect3DSurface9* lockable_surface, - const gfx::Size& size) { - D3DLOCKED_RECT locked_rect; - ASSERT_HRESULT_SUCCEEDED( - lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY)); - ASSERT_EQ(0, locked_rect.Pitch % sizeof(ColorType)); - int pitch = locked_rect.Pitch / sizeof(ColorType); - ColorType* surface = reinterpret_cast<ColorType*>(locked_rect.pBits); - for (int y_lo = 0; y_lo < size.height() / 2; y_lo++) { - int y_hi = size.height() - 1 - y_lo; - for (int x_lo = 0; x_lo < size.width() / 2; x_lo++) { - int x_hi = size.width() - 1 - x_lo; - if (!AssertSameColor(surface[x_lo + y_lo*pitch], - surface[x_hi + y_lo*pitch])) { - FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)", - x_lo, y_lo, x_hi, y_lo); - } - if (!AssertSameColor(surface[x_hi + y_lo*pitch], - surface[x_hi + y_hi*pitch])) { - FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)", - x_hi, y_lo, x_hi, y_hi); - } - if (!AssertSameColor(surface[x_hi + y_hi*pitch], - surface[x_lo + y_hi*pitch])) { - FAIL() << StringPrintf("Pixels (%d, %d) vs. (%d, %d)", - x_hi, y_hi, x_lo, y_hi); - } - } - } - lockable_surface->UnlockRect(); - } - - // Asserts that the actual image is a bit-identical, vertically mirrored - // copy of the expected image. - template<typename ColorType> - void AssertIsInvertedCopy(const gfx::Size& size, - IDirect3DSurface9* expected, - IDirect3DSurface9* actual) { - - D3DLOCKED_RECT locked_expected, locked_actual; - ASSERT_HRESULT_SUCCEEDED( - expected->LockRect(&locked_expected, NULL, D3DLOCK_READONLY)); - ASSERT_HRESULT_SUCCEEDED( - actual->LockRect(&locked_actual, NULL, D3DLOCK_READONLY)); - ASSERT_EQ(0, locked_expected.Pitch % sizeof(ColorType)); - int pitch = locked_expected.Pitch / sizeof(ColorType); - ColorType* expected_image = - reinterpret_cast<ColorType*>(locked_expected.pBits); - ColorType* actual_image = - reinterpret_cast<ColorType*>(locked_actual.pBits); - for (int y = 0; y < size.height(); y++) { - int y_actual = size.height() - 1 - y; - ASSERT_EQ(0, - memcmp(&expected_image[y*pitch], &actual_image[y_actual*pitch], - sizeof(ColorType) * size.width())) - << StringPrintf("Rows not equal: %d vs. %d", y, y_actual); - } - expected->UnlockRect(); - actual->UnlockRect(); - } - - protected: - static const int kAbsoluteColorErrorTolerance = 4; - - DWORD RandomColor() { - return random_dword_(rng_); - } - - void DoResizeBilinearTest(AcceleratedSurfaceTransformer* gpu_ops, - const gfx::Size& src_size, - const gfx::Size& dst_size, - int checkerboard_size) { - - SCOPED_TRACE( - StringPrintf("Resizing %dx%d -> %dx%d at checkerboard size of %d", - src_size.width(), src_size.height(), - dst_size.width(), dst_size.height(), - checkerboard_size)); - - base::win::ScopedComPtr<IDirect3DSurface9> src, dst; - ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface( - device(), src_size, src.Receive())); - ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface( - device(), dst_size, dst.Receive())); - - FillSymmetricRandomCheckerboard<DWORD>(src, src_size, checkerboard_size); - - ASSERT_TRUE(gpu_ops->ResizeBilinear(src, gfx::Rect(src_size), dst)); - - AssertSymmetry<DWORD>(dst, dst_size); - } - - void DoCopyInvertedTest(AcceleratedSurfaceTransformer* gpu_ops, - const gfx::Size& size) { - - SCOPED_TRACE( - StringPrintf("CopyInverted @ %dx%d", size.width(), size.height())); - - base::win::ScopedComPtr<IDirect3DSurface9> checkerboard, src, dst; - base::win::ScopedComPtr<IDirect3DTexture9> src_texture; - ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(device(), size, - checkerboard.Receive())); - ASSERT_TRUE(d3d_utils::CreateTemporaryRenderTargetTexture(device(), size, - src_texture.Receive(), src.Receive())); - ASSERT_TRUE(d3d_utils::CreateTemporaryLockableSurface(device(), size, - dst.Receive())); - - FillRandomCheckerboard<DWORD>(checkerboard, size, 1); - ASSERT_HRESULT_SUCCEEDED( - device()->StretchRect(checkerboard, NULL, src, NULL, D3DTEXF_NONE)); - ASSERT_TRUE(gpu_ops->CopyInverted(src_texture, dst, size)); - AssertIsInvertedCopy<DWORD>(size, checkerboard, dst); - } - - uniform_int_distribution<DWORD> random_dword_; - std::mt19937 rng_; - base::ScopedNativeLibrary d3d_module_; - base::win::ScopedComPtr<IDirect3DDevice9Ex> device_; -}; - -TEST_P(AcceleratedSurfaceTransformerTest, Init) { - AcceleratedSurfaceTransformer gpu_ops; - ASSERT_TRUE(gpu_ops.Init(device())); -}; - -TEST_P(AcceleratedSurfaceTransformerTest, TestConsistentRandom) { - // This behavior should be the same for every execution on every machine. - // Otherwise tests might be flaky and impossible to debug. - SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom"); - ASSERT_EQ(2922058934, RandomColor()); - - SeedRandom("AcceleratedSurfaceTransformerTest.TestConsistentRandom"); - ASSERT_EQ(2922058934, RandomColor()); - ASSERT_EQ(4050239976, RandomColor()); - - SeedRandom("DifferentSeed"); - ASSERT_EQ(3904108833, RandomColor()); -} - -TEST_P(AcceleratedSurfaceTransformerTest, MixedOperations) { - SeedRandom("MixedOperations"); - - AcceleratedSurfaceTransformer t; - ASSERT_TRUE(t.Init(device())); - - DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 1); - DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 2); - DoCopyInvertedTest(&t, gfx::Size(20, 107)); - DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 5); - DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(64, 64), 5); - DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(3, 3), 1); - DoCopyInvertedTest(&t, gfx::Size(1412, 124)); - DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 1); - DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 2); - - DoCopyInvertedTest(&t, gfx::Size(1512, 7)); - DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 5); - DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 8); - DoCopyInvertedTest(&t, gfx::Size(1521, 3)); - DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 1); - DoCopyInvertedTest(&t, gfx::Size(33, 712)); - DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 8), 8); - DoCopyInvertedTest(&t, gfx::Size(33, 2)); - DoResizeBilinearTest(&t, gfx::Size(200, 256), gfx::Size(126, 8), 8); -} - -// Tests ResizeBilinear with 16K wide/hight src and dst surfaces. -TEST_P(AcceleratedSurfaceTransformerTest, LargeSurfaces) { - SeedRandom("LargeSurfaces"); - - AcceleratedSurfaceTransformer gpu_ops; - ASSERT_TRUE(gpu_ops.Init(device())); - - const int lo = 256; - const int hi = 16384; - - DoResizeBilinearTest(&gpu_ops, gfx::Size(hi, lo), gfx::Size(lo, lo), 1); - DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, hi), gfx::Size(lo, lo), 1); - DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(hi, lo), lo); - DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(lo, hi), lo); - DoCopyInvertedTest(&gpu_ops, gfx::Size(hi, lo)); - DoCopyInvertedTest(&gpu_ops, gfx::Size(lo, hi)); -} - -// Exercises ResizeBilinear with random minification cases where the -// aspect ratio does not change. -TEST_P(AcceleratedSurfaceTransformerTest, MinifyUniform) { - SeedRandom("MinifyUniform"); - - AcceleratedSurfaceTransformer gpu_ops; - ASSERT_TRUE(gpu_ops.Init(device())); - - int dims[] = { 21, 63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257}; - int checkerboards[] = {1, 2, 3, 9}; - uniform_int_distribution<int> dim(0, arraysize(dims) - 1); - uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1); - - for (int i = 0; i < 300; i++) { - // Widths are picked so that dst is smaller than src. - int dst_width = dims[dim(rng_)]; - int src_width = dims[dim(rng_)]; - if (src_width < dst_width) - std::swap(dst_width, src_width); - - // src_width is picked to preserve aspect ratio. - int dst_height = dims[dim(rng_)]; - int src_height = static_cast<int>( - static_cast<int64>(src_width) * dst_height / dst_width); - - int checkerboard_size = checkerboards[checkerboard(rng_)]; - - DoResizeBilinearTest(&gpu_ops, - gfx::Size(src_width, src_height), // Src size (larger) - gfx::Size(dst_width, dst_height), // Dst size (smaller) - checkerboard_size); - } -}; - -// Exercises ResizeBilinear with random magnification cases where the -// aspect ratio does not change. -// -// Disabled. This test relies on an assertion that resizing preserves -// symmetry in the image, but for the current implementation of ResizeBilinear, -// this does not seem to be true. -TEST_P(AcceleratedSurfaceTransformerTest, DISABLED_MagnifyUniform) { - SeedRandom("MagnifyUniform"); - - AcceleratedSurfaceTransformer gpu_ops; - ASSERT_TRUE(gpu_ops.Init(device())); - - int dims[] = {63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257}; - int checkerboards[] = {1, 2, 3, 9}; - uniform_int_distribution<int> dim(0, arraysize(dims) - 1); - uniform_int_distribution<int> checkerboard(0, arraysize(checkerboards) - 1); - - for (int i = 0; i < 50; i++) { - // Widths are picked so that b is smaller than a. - int dst_width = dims[dim(rng_)]; - int src_width = dims[dim(rng_)]; - if (dst_width < src_width) - std::swap(src_width, dst_width); - - int dst_height = dims[dim(rng_)]; - int src_height = static_cast<int>( - static_cast<int64>(src_width) * dst_height / dst_width); - - int checkerboard_size = checkerboards[checkerboard(rng_)]; - - DoResizeBilinearTest(&gpu_ops, - gfx::Size(src_width, src_height), // Src size (smaller) - gfx::Size(dst_width, dst_height), // Dst size (larger) - checkerboard_size); - } -}; - -namespace { - -// Used to suppress test on Windows versions prior to Vista. -std::vector<int> WindowsVersionIfVistaOrBetter() { - std::vector<int> result; - if (base::win::GetVersion() >= base::win::VERSION_VISTA) { - result.push_back(base::win::GetVersion()); - } - return result; -} - -} // namespace - -INSTANTIATE_TEST_CASE_P(VistaAndUp, - AcceleratedSurfaceTransformerTest, - ::testing::ValuesIn(WindowsVersionIfVistaOrBetter())); |