path: root/ui/surface/accelerated_surface_transformer_win_unittest.cc

// Copyright (c) 2013 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/file_util.h"
#include "base/hash.h"
#include "base/scoped_native_library.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "base/win/scoped_comptr.h"
#include "base/win/windows_version.h"
#include "media/base/simd/convert_rgb_to_yuv.h"
#include "media/base/yuv_convert.h"
#include "skia/ext/image_operations.h"
#include "testing/gtest/include/gtest/gtest-param-test.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/codec/png_codec.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;

namespace {

// Debug flag, useful when hacking on tests.
const bool kDumpImagesOnFailure = false;

SkBitmap ToSkBitmap(IDirect3DSurface9* surface, bool is_single_channel) {
  D3DLOCKED_RECT locked_rect;
  EXPECT_HRESULT_SUCCEEDED(
      surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY));

  SkBitmap result;
  gfx::Size size = d3d_utils::GetSize(surface);
  if (is_single_channel)
    size = gfx::Size(size.width() * 4, size.height());
  result.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height(),
                   0, kOpaque_SkAlphaType);
  result.allocPixels();
  result.lockPixels();
  for (int y = 0; y < size.height(); ++y) {
    uint8* row8 = reinterpret_cast<uint8*>(locked_rect.pBits) +
        (y * locked_rect.Pitch);
    if (is_single_channel) {
      for (int x = 0; x < size.width(); ++x) {
        *result.getAddr32(x, y) = SkColorSetRGB(row8[x], row8[x], row8[x]);
      }
    } else {
      uint32* row32 = reinterpret_cast<uint32*>(row8);
      for (int x = 0; x < size.width(); ++x) {
        *result.getAddr32(x, y) = row32[x] | 0xFF000000;
      }
    }
  }
  result.unlockPixels();
  result.setImmutable();
  surface->UnlockRect();
  return result;
}

bool WritePNGFile(const SkBitmap& bitmap, const base::FilePath& file_path) {
  std::vector<unsigned char> png_data;
  const bool discard_transparency = true;
  if (gfx::PNGCodec::EncodeBGRASkBitmap(bitmap,
                                        discard_transparency,
                                        &png_data) &&
      base::CreateDirectory(file_path.DirName())) {
    char* data = reinterpret_cast<char*>(&png_data[0]);
    int size = static_cast<int>(png_data.size());
    return file_util::WriteFile(file_path, data, size) == size;
  }
  return false;
}

}  // namespace

// Test fixture for AcceleratedSurfaceTransformer.
//
// 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() : color_error_tolerance_(0) {};

  IDirect3DDevice9Ex* device() { return device_.get(); }

  virtual void SetUp() {
    if (!d3d_module_.is_valid()) {
      if (!d3d_utils::LoadD3D9(&d3d_module_)) {
        GTEST_FAIL() << "Could not load d3d9.dll";
        return;
      }
    }
    if (!d3d_utils::CreateDevice(d3d_module_,
                                 D3DDEVTYPE_HAL,
                                 D3DPRESENT_INTERVAL_IMMEDIATE,
                                 device_.Receive())) {
      GTEST_FAIL() << "Could not create Direct3D device.";
      return;
    }

    SeedRandom("default");
  }

  virtual void TearDown() {
    device_ = NULL;
  }

  // Gets a human-readable identifier of the graphics hardware being used,
  // intended for use inside of SCOPED_TRACE().
  std::string GetAdapterInfo() {
    ScopedComPtr<IDirect3D9> d3d;
    EXPECT_HRESULT_SUCCEEDED(device()->GetDirect3D(d3d.Receive()));
    D3DADAPTER_IDENTIFIER9 info;
    EXPECT_HRESULT_SUCCEEDED(d3d->GetAdapterIdentifier(0, 0, &info));
    return base::StringPrintf(
        "Running on graphics hardware: %s", info.Description);
  }

  void SeedRandom(const char* seed) {
    rng_.seed(base::Hash(seed));
    random_dword_.reset();
  }

  // Driver workaround: on an Intel GPU (Mobile Intel 965 Express), it seems
  // necessary to flush between drawing and locking, for the synchronization
  // to behave properly.
  void BeforeLockWorkaround() {
    EXPECT_HRESULT_SUCCEEDED(
        device()->Present(0, 0, 0, 0));
  }

  void WarnOnMissingFeatures(AcceleratedSurfaceTransformer* gpu_ops) {
    // Prints a single warning line if some tests are feature-dependent
    // and the feature is not supported by the current GPU.
    if (!gpu_ops->device_supports_multiple_render_targets()) {
      LOG(WARNING) << "MRT not supported, some tests will be skipped. "
                   << GetAdapterInfo();
    }
  }

  // Locks and fills a surface with a checkerboard pattern where the colors
  // are random but the total image pattern is horizontally and vertically
  // symmetric.
  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));
    DWORD* surface = reinterpret_cast<DWORD*>(locked_rect.pBits);
    ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD));
    int pitch = locked_rect.Pitch / sizeof(DWORD);

    for (int y = 0; y < (size.height() + 1) / 2; y += checker_square_size) {
      for (int x = 0; x < (size.width() + 1) / 2; x += checker_square_size) {
        DWORD color = 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();
  }

  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));
    DWORD* surface = reinterpret_cast<DWORD*>(locked_rect.pBits);
    ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD));
    int pitch = locked_rect.Pitch / sizeof(DWORD);

    for (int y = 0; y <= size.height(); y += checker_square_size) {
      for (int x = 0; x <= size.width(); x += checker_square_size) {
        DWORD color = 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 <= color_error_tolerance())
      return true;

    std::string expected_color =
        base::StringPrintf("%3d, %3d, %3d, %3d", a[0], a[1], a[2], a[3]);
    std::string actual_color =
        base::StringPrintf("%3d, %3d, %3d, %3d", b[0], b[1], b[2], b[3]);
    EXPECT_EQ(expected_color, actual_color)
        << "Componentwise color difference was "
        << max_error << "; max allowed is " << color_error_tolerance();

    return false;
  }

bool AssertSameColor(uint8 color_a, uint8 color_b) {
    if (color_a == color_b)
      return true;
    int max_error = std::abs((int) color_a - (int) color_b);
    if (max_error <= color_error_tolerance())
      return true;
    ADD_FAILURE() << "Colors not equal: "
                  << base::StringPrintf("0x%x", color_a)
                  << " vs. " << base::StringPrintf("0x%x", color_b);
    return false;
  }

  // Asserts that an image is symmetric with respect to itself: both
  // horizontally and vertically, within the tolerance of AssertSameColor.
  void AssertSymmetry(IDirect3DSurface9* lockable_surface,
                      const gfx::Size& size) {
    BeforeLockWorkaround();

    D3DLOCKED_RECT locked_rect;
    ASSERT_HRESULT_SUCCEEDED(
        lockable_surface->LockRect(&locked_rect, NULL, D3DLOCK_READONLY));
    ASSERT_EQ(0, locked_rect.Pitch % sizeof(DWORD));
    int pitch = locked_rect.Pitch / sizeof(DWORD);
    DWORD* surface = reinterpret_cast<DWORD*>(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])) {
          lockable_surface->UnlockRect();
          GTEST_FAIL() << "Pixels (" << x_lo << ", " << y_lo << ") vs. "
                       << "(" << x_hi << ", " << y_lo << ")";
        }
        if (!AssertSameColor(surface[x_hi + y_lo*pitch],
                             surface[x_hi + y_hi*pitch])) {
          lockable_surface->UnlockRect();
          GTEST_FAIL() << "Pixels (" << x_hi << ", " << y_lo << ") vs. "
                       << "(" << x_hi << ", " << y_hi << ")";
        }
        if (!AssertSameColor(surface[x_hi + y_hi*pitch],
                             surface[x_lo + y_hi*pitch])) {
          lockable_surface->UnlockRect();
          GTEST_FAIL() << "Pixels (" << x_hi << ", " << y_hi << ") vs. "
                       << "(" << x_lo << ", " << y_hi << ")";
        }
      }
    }
    lockable_surface->UnlockRect();
  }

  // Asserts that the actual image is a bit-identical, vertically mirrored
  // copy of the expected image.
  void AssertIsInvertedCopy(const gfx::Size& size,
                            IDirect3DSurface9* expected,
                            IDirect3DSurface9* actual) {
    BeforeLockWorkaround();

    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(DWORD));
    int pitch = locked_expected.Pitch / sizeof(DWORD);
    DWORD* expected_image = reinterpret_cast<DWORD*>(locked_expected.pBits);
    DWORD* actual_image = reinterpret_cast<DWORD*>(locked_actual.pBits);
    for (int y = 0; y < size.height(); y++) {
      int y_actual = size.height() - 1 - y;
      for (int x = 0; x < size.width(); ++x)
        if (!AssertSameColor(expected_image[y*pitch + x],
                             actual_image[y_actual*pitch + x])) {
          expected->UnlockRect();
          actual->UnlockRect();
          GTEST_FAIL() << "Pixels (" << x << ", " << y << ") vs. "
                       << "(" << x << ", " << y_actual << ")";
        }
    }
    expected->UnlockRect();
    actual->UnlockRect();
  }

 protected:
  DWORD RandomColor() {
    return random_dword_(rng_);
  }

  void set_color_error_tolerance(int value) {
    color_error_tolerance_ = value;
  }

  int color_error_tolerance() {
    return color_error_tolerance_;
  }

  void DoResizeBilinearTest(AcceleratedSurfaceTransformer* gpu_ops,
                            const gfx::Size& src_size,
                            const gfx::Size& dst_size,
                            int checkerboard_size) {

    SCOPED_TRACE(
        base::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));

    set_color_error_tolerance(4);

    base::win::ScopedComPtr<IDirect3DSurface9> src, dst;
    ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(
        device(), src_size, &src))
            << "Could not create src render target";
    ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(
        device(), dst_size, &dst))
            << "Could not create dst render target";

    FillSymmetricRandomCheckerboard(src, src_size, checkerboard_size);

    ASSERT_TRUE(gpu_ops->ResizeBilinear(src, gfx::Rect(src_size), dst,
                                        gfx::Rect(dst_size)));

    AssertSymmetry(dst, dst_size);
  }

  void CreateRandomCheckerboardTexture(
      const gfx::Size& size,
      int checkerboard_size,
      base::win::ScopedComPtr<IDirect3DSurface9>* reference_surface,
      base::win::ScopedComPtr<IDirect3DTexture9>* result) {
    base::win::ScopedComPtr<IDirect3DSurface9> dst;
    ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(device(), size,
        reference_surface));
    ASSERT_TRUE(d3d_utils::CreateOrReuseRenderTargetTexture(device(), size,
        result, dst.Receive()));
    FillRandomCheckerboard(*reference_surface, size, checkerboard_size);
    ASSERT_HRESULT_SUCCEEDED(
        device()->StretchRect(
            *reference_surface, NULL, dst, NULL, D3DTEXF_NONE));
  }

  void AssertSame(int width_in_bytes, int height, uint8* reference,
                  IDirect3DSurface9* lockable) {
    BeforeLockWorkaround();

    D3DLOCKED_RECT locked_rect;
    ASSERT_HRESULT_SUCCEEDED(
        lockable->LockRect(&locked_rect, NULL, D3DLOCK_READONLY));
    uint8* actual = reinterpret_cast<uint8*>(locked_rect.pBits);
    for (int y = 0; y < height; ++y) {
      for (int x = 0; x < width_in_bytes; ++x) {
        if (!AssertSameColor(reference[y * width_in_bytes + x],
                             actual[y * locked_rect.Pitch + x])) {
          lockable->UnlockRect();
          GTEST_FAIL() << "At pixel (" << x << ", " << y << ")";
        }
      }
    }
    lockable->UnlockRect();
  }

  void DoCopyInvertedTest(AcceleratedSurfaceTransformer* gpu_ops,
                          const gfx::Size& size) {

    SCOPED_TRACE(base::StringPrintf(
        "CopyInverted @ %dx%d", size.width(), size.height()));

    set_color_error_tolerance(0);

    base::win::ScopedComPtr<IDirect3DSurface9> dst, reference_pattern;
    base::win::ScopedComPtr<IDirect3DTexture9> src;

    CreateRandomCheckerboardTexture(size, 1, &reference_pattern, &src);

    // Alloc a slightly larger image 75% of the time, to test that the
    // viewport is set properly.
    const int kAlign = 4;
    gfx::Size alloc_size((size.width() + kAlign - 1) / kAlign * kAlign,
                         (size.height() + kAlign - 1) / kAlign * kAlign);

    ASSERT_TRUE(d3d_utils::CreateOrReuseLockableSurface(device(), alloc_size,
        &dst)) << "Could not create dst render target.";

    ASSERT_TRUE(gpu_ops->CopyInverted(src, dst, size));
    AssertIsInvertedCopy(size, reference_pattern, dst);
  }


  void DoYUVConversionTest(AcceleratedSurfaceTransformer* gpu_ops,
                           const gfx::Size& src_size,
                           int checkerboard_size) {
    // Test the non-MRT implementation, and the MRT implementation as well
    // (if supported by the device).
    ASSERT_NO_FATAL_FAILURE(
        DoYUVConversionTest(gpu_ops, src_size, src_size,
                            checkerboard_size, false));
    if (gpu_ops->device_supports_multiple_render_targets()) {
      ASSERT_NO_FATAL_FAILURE(
          DoYUVConversionTest(gpu_ops, src_size, src_size,
                              checkerboard_size, true));
    }
  }

  void DoYUVConversionScaleTest(AcceleratedSurfaceTransformer* gpu_ops,
                                const gfx::Size& src_size,
                                const gfx::Size& dst_size) {
    // Test the non-MRT implementation, and the MRT implementation as well
    // (if supported by the device).
    if (gpu_ops->device_supports_multiple_render_targets()) {
      ASSERT_NO_FATAL_FAILURE(
          DoYUVConversionTest(gpu_ops, src_size, dst_size, 4, true));
    }
    ASSERT_NO_FATAL_FAILURE(
        DoYUVConversionTest(gpu_ops, src_size, dst_size, 4, false));
  }

  void DoYUVConversionTest(AcceleratedSurfaceTransformer* gpu_ops,
                           const gfx::Size& src_size,
                           const gfx::Size& dst_size,
                           int checkerboard_size,
                           boolean use_multi_render_targets) {
    SCOPED_TRACE(
        base::StringPrintf(
            "YUV Converting %dx%d at checkerboard size of %d; MRT %s",
            src_size.width(), src_size.height(),
            checkerboard_size,
            use_multi_render_targets ? "enabled" : "disabled"));


    base::win::ScopedComPtr<IDirect3DTexture9> src;
    base::win::ScopedComPtr<IDirect3DSurface9> reference;
    base::win::ScopedComPtr<IDirect3DSurface9> dst_y, dst_u, dst_v;

    // TODO(ncarter): Use a better error metric that measures aggregate error
    // rather than simply max error. There seems to be slightly more error at
    // higher resolutions, maybe due to precision issues during rasterization
    // (or maybe more pixels = more test trials). Results are usually to an
    // error of 1, but we must use a tolerance of 3.
    set_color_error_tolerance(3);
    CreateRandomCheckerboardTexture(src_size, checkerboard_size, &reference,
                                    &src);

    gfx::Size packed_y_size, packed_uv_size;

    ASSERT_TRUE(gpu_ops->AllocYUVBuffers(dst_size,
                                         &packed_y_size,
                                         &packed_uv_size,
                                         dst_y.Receive(),
                                         dst_u.Receive(),
                                         dst_v.Receive()));

    // Actually do the conversion.
    if (use_multi_render_targets) {
      ASSERT_TRUE(gpu_ops->TransformRGBToYV12_MRT(src,
                                                  dst_size,
                                                  packed_y_size,
                                                  packed_uv_size,
                                                  dst_y,
                                                  dst_u,
                                                  dst_v));
    } else {
      ASSERT_TRUE(gpu_ops->TransformRGBToYV12_WithoutMRT(src,
                                                         dst_size,
                                                         packed_y_size,
                                                         packed_uv_size,
                                                         dst_y,
                                                         dst_u,
                                                         dst_v));
    }

    // UV size (in bytes/samples) is half, rounded up.
    gfx::Size uv_size((dst_size.width() + 1) / 2,
                      (dst_size.height() + 1) / 2);

    // Generate a reference bitmap by calling a software implementation.
    SkBitmap reference_rgb = ToSkBitmap(reference, false);
    SkBitmap reference_rgb_scaled;
    if (dst_size == src_size) {
      reference_rgb_scaled = reference_rgb;
    } else {
      // We'll call Copy to do the bilinear scaling if needed.
      base::win::ScopedComPtr<IDirect3DSurface9> reference_scaled;
      ASSERT_TRUE(
          d3d_utils::CreateOrReuseLockableSurface(
              device(), dst_size, &reference_scaled));
      ASSERT_TRUE(gpu_ops->Copy(src, reference_scaled, dst_size));
      BeforeLockWorkaround();
      reference_rgb_scaled = ToSkBitmap(reference_scaled, false);
    }

    scoped_ptr<uint8[]> reference_y(new uint8[dst_size.GetArea()]);
    scoped_ptr<uint8[]> reference_u(new uint8[uv_size.GetArea()]);
    scoped_ptr<uint8[]> reference_v(new uint8[uv_size.GetArea()]);
    reference_rgb_scaled.lockPixels();
    media::ConvertRGB32ToYUV_SSE2_Reference(
        reinterpret_cast<uint8*>(reference_rgb_scaled.getAddr32(0, 0)),
        &reference_y[0],
        &reference_u[0],
        &reference_v[0],
        dst_size.width(),
        dst_size.height(),
        reference_rgb_scaled.rowBytes(),
        dst_size.width(),
        uv_size.width());
    reference_rgb_scaled.unlockPixels();

    // Check for equality of the reference and the actual.
    AssertSame(dst_size.width(), dst_size.height(), &reference_y[0], dst_y);
    AssertSame(uv_size.width(), uv_size.height(), &reference_u[0], dst_u);
    AssertSame(uv_size.width(), uv_size.height(), &reference_v[0], dst_v);

    if (kDumpImagesOnFailure && HasFatalFailure()) {
      // Note that this will dump the full u and v buffers, including
      // extra columns added due to packing. That means up to 7 extra
      // columns for uv, and up to 3 extra columns for y.
      WritePNGFile(reference_rgb,
                   base::FilePath(FILE_PATH_LITERAL("test_fail_src.png")));
      WritePNGFile(reference_rgb_scaled,
                   base::FilePath(
                       FILE_PATH_LITERAL("test_fail_src_scaled.png")));
      WritePNGFile(ToSkBitmap(dst_y, true),
                   base::FilePath(FILE_PATH_LITERAL("test_fail_y.png")));
      WritePNGFile(ToSkBitmap(dst_u, true),
                   base::FilePath(FILE_PATH_LITERAL("test_fail_u.png")));
      WritePNGFile(ToSkBitmap(dst_v, true),
                   base::FilePath(FILE_PATH_LITERAL("test_fail_v.png")));
    }
  }

  int color_error_tolerance_;
  uniform_int_distribution<DWORD> random_dword_;
  std::mt19937 rng_;
  base::ScopedNativeLibrary d3d_module_;
  base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
};

// Fails on some bots because Direct3D isn't allowed.
TEST_P(AcceleratedSurfaceTransformerTest, Init) {
  SCOPED_TRACE(GetAdapterInfo());
  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  WarnOnMissingFeatures(&gpu_ops);
};

// Fails on some bots because Direct3D isn't allowed.
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());
}

// Fails on some bots because Direct3D isn't allowed.
TEST_P(AcceleratedSurfaceTransformerTest, CopyInverted) {
  // This behavior should be the same for every execution on every machine.
  // Otherwise tests might be flaky and impossible to debug.
  SCOPED_TRACE(GetAdapterInfo());
  SeedRandom("CopyInverted");

  AcceleratedSurfaceTransformer t;
  ASSERT_TRUE(t.Init(device()));

  uniform_int_distribution<int> size(1, 512);

  for (int i = 0; i < 100; ++i) {
    ASSERT_NO_FATAL_FAILURE(
        DoCopyInvertedTest(&t, gfx::Size(size(rng_), size(rng_))))
            << "At iteration " << i;
  }
}

// Fails on some bots because Direct3D isn't allowed.
// Fails on other bots because of ResizeBilinear symmetry failures.
// Should pass, at least, on NVIDIA Quadro 600.
TEST_P(AcceleratedSurfaceTransformerTest, MixedOperations) {
  SCOPED_TRACE(GetAdapterInfo());
  SeedRandom("MixedOperations");

  AcceleratedSurfaceTransformer t;
  ASSERT_TRUE(t.Init(device()));

  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 2));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(20, 107)));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(255, 255), 5));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(256, 256), gfx::Size(64, 64), 5));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&t, gfx::Size(128, 128), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(3, 3), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(1412, 124)));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&t, gfx::Size(100, 200), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 2));

  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(1512, 7)));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(255, 255), gfx::Size(257, 257), 5));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 8));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(1521, 3)));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&t, gfx::Size(140, 181), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 256), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(33, 712)));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(150, 256), gfx::Size(126, 8), 8));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&t, gfx::Size(33, 2)));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&t, gfx::Size(200, 256), gfx::Size(126, 8), 8));
}

// Tests ResizeBilinear with 16K wide/hight src and dst surfaces.
//
// Fails on some bots because Direct3D isn't allowed.
// Should pass, at least, on NVIDIA Quadro 600.
TEST_P(AcceleratedSurfaceTransformerTest, LargeSurfaces) {
  SCOPED_TRACE(GetAdapterInfo());
  SeedRandom("LargeSurfaces");

  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  D3DCAPS9 caps;
  ASSERT_HRESULT_SUCCEEDED(
      device()->GetDeviceCaps(&caps));

  SCOPED_TRACE(base::StringPrintf(
     "max texture size: %dx%d, max texture aspect: %d",
      caps.MaxTextureWidth, caps.MaxTextureHeight, caps.MaxTextureAspectRatio));

  const int w = caps.MaxTextureWidth;
  const int h = caps.MaxTextureHeight;
  const int lo = 256;

  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&gpu_ops, gfx::Size(w, lo), gfx::Size(lo, lo), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, h), gfx::Size(lo, lo), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(w, lo), lo));
  ASSERT_NO_FATAL_FAILURE(
      DoResizeBilinearTest(&gpu_ops, gfx::Size(lo, lo), gfx::Size(lo, h), lo));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&gpu_ops, gfx::Size(w, lo)));
  ASSERT_NO_FATAL_FAILURE(
      DoCopyInvertedTest(&gpu_ops, gfx::Size(lo, h)));

  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(w, lo), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(lo, h), 1));

}

// Exercises ResizeBilinear with random minification cases where the
// aspect ratio does not change.
//
// Fails on some bots because Direct3D isn't allowed.
// Fails on other bots because of StretchRect symmetry failures.
// Should pass, at least, on NVIDIA Quadro 600.
TEST_P(AcceleratedSurfaceTransformerTest, MinifyUniform) {
  SCOPED_TRACE(GetAdapterInfo());
  SeedRandom("MinifyUniform");

  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  const int dims[] = {21, 63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257};
  const 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_height 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_)];

    ASSERT_NO_FATAL_FAILURE(
        DoResizeBilinearTest(&gpu_ops,
            gfx::Size(src_width, src_height),  // Src size (larger)
            gfx::Size(dst_width, dst_height),  // Dst size (smaller)
            checkerboard_size)) << "Failed on iteration " << i;
  }
};

// Exercises ResizeBilinear with random magnification cases where the
// aspect ratio does not change.
//
// 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 (fails on NVIDIA Quadro 600; passes on
// Intel Mobile 965 Express)
TEST_P(AcceleratedSurfaceTransformerTest, DISABLED_MagnifyUniform) {
  SCOPED_TRACE(GetAdapterInfo());
  SeedRandom("MagnifyUniform");

  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  const int dims[] = {63, 64, 65, 99, 127, 128, 129, 192, 255, 256, 257};
  const 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 src is smaller than dst.
    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_)];

    ASSERT_NO_FATAL_FAILURE(
        DoResizeBilinearTest(&gpu_ops,
            gfx::Size(src_width, src_height),  // Src size (smaller)
            gfx::Size(dst_width, dst_height),  // Dst size (larger)
            checkerboard_size)) << "Failed on iteration " << i;
  }
};

TEST_P(AcceleratedSurfaceTransformerTest, RGBtoYUV) {
  SeedRandom("RGBtoYUV");

  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  // Start with some easy-to-debug cases. A checkerboard size of 1 is the
  // best test, but larger checkerboard sizes give more insight into where
  // a bug might be.
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 4));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 2));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(32, 32), 3));

  // All cases of width (mod 8) and height (mod 8), using 1x1 checkerboard.
  for (int w = 32; w < 40; ++w) {
    for (int h = 32; h < 40; ++h) {
      ASSERT_NO_FATAL_FAILURE(
          DoYUVConversionTest(&gpu_ops, gfx::Size(w, h), 1));
    }
  }

  // All the very small sizes which require the most shifting in the
  // texture coordinates when doing alignment.
  for (int w = 1; w <= 9; ++w) {
    for (int h = 1; h <= 9; ++h) {
      ASSERT_NO_FATAL_FAILURE(
          DoYUVConversionTest(&gpu_ops, gfx::Size(w, h), 1));
    }
  }

  // Random medium dimensions.
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(10, 142), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(124, 333), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(853, 225), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(231, 412), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(512, 128), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1024, 768), 1));

  // Common video/monitor resolutions
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(800, 768), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1024, 768), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1280, 720), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1280, 720), 2));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1920, 1080), 1));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(1920, 1080), 2));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionTest(&gpu_ops, gfx::Size(2048, 1536), 1));
}

TEST_P(AcceleratedSurfaceTransformerTest, RGBtoYUVScaled) {
  SeedRandom("RGBtoYUVScaled");

  AcceleratedSurfaceTransformer gpu_ops;
  ASSERT_TRUE(gpu_ops.Init(device()));

  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(64, 64)));

  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(16, 16)));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(24, 24)));
  ASSERT_NO_FATAL_FAILURE(
      DoYUVConversionScaleTest(&gpu_ops, gfx::Size(32, 32), gfx::Size(48, 48)));
}

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()));