[PATCH v3 6/6] d2d1/tests: Test IsSupported() for bitmap render targets.

[Zhiyi Zhang]

From: Zhiyi Zhang

---
 dlls/d2d1/tests/d2d1.c | 355 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 355 insertions(+)

diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c
index 6441f239af9..4ee8fc3c426 100644
--- a/dlls/d2d1/tests/d2d1.c
+++ b/dlls/d2d1/tests/d2d1.c
@@ -13806,6 +13806,360 @@ static void test_dc_target_is_supported(void)
     DestroyWindow(window);
 }

+static void test_bitmap_target_is_supported(void)
+{
+    static const DWORD levels[] = {D2D1_FEATURE_LEVEL_DEFAULT, D2D1_FEATURE_LEVEL_9, D2D1_FEATURE_LEVEL_10};
+    D2D1_RENDER_TARGET_PROPERTIES desc, template_desc, test_desc;
+    D2D1_HWND_RENDER_TARGET_PROPERTIES hwnd_rt_desc;
+    D2D1_BITMAP_PROPERTIES1 bitmap_desc;
+    ID2D1BitmapRenderTarget *bitmap_rt;
+    ID2D1DeviceContext *device_context;
+    D2D1_PIXEL_FORMAT pixel_format;
+    ID2D1HwndRenderTarget *hwnd_rt;
+    ID2D1Factory *factory;
+    ID2D1Bitmap1 *bitmap;
+    unsigned int i, j;
+    D2D1_SIZE_U size;
+    BOOL supported;
+    HWND window;
+    HRESULT hr;
+
+    window = create_window();
+    ok(!!window, "Failed to create test window.\n");
+    hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &IID_ID2D1Factory, NULL, (void **)&factory);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+    template_desc.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+    template_desc.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
+    template_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
+    template_desc.dpiX = 96.0f;
+    template_desc.dpiY = 96.0f;
+    template_desc.usage = D2D1_RENDER_TARGET_USAGE_NONE;
+    template_desc.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+    hwnd_rt_desc.hwnd = window;
+    hwnd_rt_desc.pixelSize.width = 64;
+    hwnd_rt_desc.pixelSize.height = 64;
+    hwnd_rt_desc.presentOptions = D2D1_PRESENT_OPTIONS_NONE;
+
+    /* Make sure the render target description template is valid */
+    hr = ID2D1Factory_CreateHwndRenderTarget(factory, &template_desc, &hwnd_rt_desc, &hwnd_rt);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+            D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &template_desc);
+    ok(supported, "Expected supported.\n");
+    ID2D1BitmapRenderTarget_Release(bitmap_rt);
+    ID2D1HwndRenderTarget_Release(hwnd_rt);
+
+    /* Test that SetTarget() with a bitmap of a different usage doesn't change the render target usage */
+    hr = ID2D1Factory_CreateHwndRenderTarget(factory, &template_desc, &hwnd_rt_desc, &hwnd_rt);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+            D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1BitmapRenderTarget_QueryInterface(bitmap_rt, &IID_ID2D1DeviceContext, (void **)&device_context);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+    test_desc = template_desc;
+    test_desc.usage = D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;
+    supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+    ok(!supported, "Expected unsupported.\n");
+
+    memset(&bitmap_desc, 0, sizeof(bitmap_desc));
+    bitmap_desc.pixelFormat = ID2D1DeviceContext_GetPixelFormat(device_context);
+    bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE;
+    size.width = 4;
+    size.height = 4;
+    hr = ID2D1DeviceContext_CreateBitmap(device_context, size, NULL, 0, &bitmap_desc, &bitmap);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    ID2D1DeviceContext_SetTarget(device_context, (ID2D1Image *)bitmap);
+    supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+    ok(!supported, "Expected unsupported.\n");
+    ID2D1Bitmap1_Release(bitmap);
+
+    /* Test that SetTarget() with a bitmap of a different format changes the render target format */
+    test_desc = template_desc;
+    test_desc.pixelFormat.format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    test_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
+    supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+    ok(!supported, "Expected unsupported.\n");
+
+    memset(&bitmap_desc, 0, sizeof(bitmap_desc));
+    bitmap_desc.pixelFormat.format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
+    bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET;
+    size.width = 4;
+    size.height = 4;
+    hr = ID2D1DeviceContext_CreateBitmap(device_context, size, NULL, 0, &bitmap_desc, &bitmap);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    ID2D1DeviceContext_SetTarget(device_context, (ID2D1Image *)bitmap);
+    pixel_format = ID2D1DeviceContext_GetPixelFormat(device_context);
+    ok(pixel_format.format == DXGI_FORMAT_R8G8B8A8_UNORM, "Got unexpected format %#x.\n", pixel_format.format);
+    ok(pixel_format.alphaMode == D2D1_ALPHA_MODE_PREMULTIPLIED, "Got unexpected alpha %u.\n", pixel_format.alphaMode);
+    supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+    ok(supported, "Expected supported.\n");
+    ID2D1Bitmap1_Release(bitmap);
+
+    ID2D1DeviceContext_Release(device_context);
+    ID2D1BitmapRenderTarget_Release(bitmap_rt);
+    ID2D1HwndRenderTarget_Release(hwnd_rt);
+
+    /* Type */
+    for (i = D2D1_RENDER_TARGET_TYPE_DEFAULT; i <= D2D1_RENDER_TARGET_TYPE_HARDWARE; ++i)
+    {
+        desc = template_desc;
+        desc.type = i;
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = D2D1_RENDER_TARGET_TYPE_DEFAULT; j <= D2D1_RENDER_TARGET_TYPE_HARDWARE; ++j)
+        {
+            winetest_push_context("type %u test %u", i, j);
+
+            test_desc = template_desc;
+            test_desc.type = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (i == j || (i == D2D1_RENDER_TARGET_TYPE_DEFAULT && j == D2D1_RENDER_TARGET_TYPE_HARDWARE)
+                    || (i == D2D1_RENDER_TARGET_TYPE_HARDWARE && j == D2D1_RENDER_TARGET_TYPE_DEFAULT)
+                    || (i == D2D1_RENDER_TARGET_TYPE_SOFTWARE && j == D2D1_RENDER_TARGET_TYPE_DEFAULT))
+                ok(supported || broken(i == D2D1_RENDER_TARGET_TYPE_DEFAULT
+                        && j == D2D1_RENDER_TARGET_TYPE_HARDWARE) /* Win7 */, "Expected supported.\n");
+            else
+                ok(!supported || broken(i == D2D1_RENDER_TARGET_TYPE_DEFAULT
+                        && j == D2D1_RENDER_TARGET_TYPE_SOFTWARE) /* Win7 */, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    /* Pixel DXGI format */
+    for (i = DXGI_FORMAT_UNKNOWN; i <= DXGI_FORMAT_V408; ++i)
+    {
+        if (i > DXGI_FORMAT_B4G4R4A4_UNORM && i < DXGI_FORMAT_P208)
+            continue;
+
+        desc = template_desc;
+        desc.pixelFormat.format = i;
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        todo_wine_if(hr == D2DERR_UNSUPPORTED_PIXEL_FORMAT)
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+        if (FAILED(hr))
+            continue;
+
+        for (j = DXGI_FORMAT_UNKNOWN; j <= DXGI_FORMAT_V408; ++j)
+        {
+            if (j > DXGI_FORMAT_B4G4R4A4_UNORM && j < DXGI_FORMAT_P208)
+                continue;
+
+            winetest_push_context("format %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.pixelFormat.format = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (i == j || (i == DXGI_FORMAT_UNKNOWN && j == DXGI_FORMAT_B8G8R8A8_UNORM)
+                    || (i == DXGI_FORMAT_B8G8R8A8_UNORM && j == DXGI_FORMAT_UNKNOWN)
+                    || (i == DXGI_FORMAT_R8G8B8A8_UNORM && j == DXGI_FORMAT_UNKNOWN))
+                ok(supported, "Expected supported.\n");
+            else
+                ok(!supported, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    /* Pixel alpha mode */
+    for (i = D2D1_ALPHA_MODE_UNKNOWN; i <= D2D1_ALPHA_MODE_IGNORE; ++i)
+    {
+        desc = template_desc;
+        desc.pixelFormat.alphaMode = i;
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = D2D1_ALPHA_MODE_UNKNOWN; j <= D2D1_ALPHA_MODE_IGNORE; ++j)
+        {
+            winetest_push_context("alpha %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.pixelFormat.alphaMode = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (j == D2D1_ALPHA_MODE_UNKNOWN || j == D2D1_ALPHA_MODE_PREMULTIPLIED)
+                ok(supported, "Expected supported.\n");
+            else
+                ok(!supported, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL,
+                &desc.pixelFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        todo_wine_if(hr == D2DERR_UNSUPPORTED_PIXEL_FORMAT)
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+        if (FAILED(hr))
+        {
+            ID2D1HwndRenderTarget_Release(hwnd_rt);
+            continue;
+        }
+
+        for (j = D2D1_ALPHA_MODE_UNKNOWN; j <= D2D1_ALPHA_MODE_IGNORE; ++j)
+        {
+            winetest_push_context("alpha %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.pixelFormat.alphaMode = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (((i == D2D1_ALPHA_MODE_UNKNOWN || i == D2D1_ALPHA_MODE_PREMULTIPLIED)
+                    && (j == D2D1_ALPHA_MODE_UNKNOWN || j == D2D1_ALPHA_MODE_PREMULTIPLIED))
+                    || (i == D2D1_ALPHA_MODE_IGNORE && (j == D2D1_ALPHA_MODE_IGNORE || j == D2D1_ALPHA_MODE_UNKNOWN)))
+                ok(supported, "Expected supported.\n");
+            else
+                ok(!supported, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    /* DPI */
+    for (i = 0; i <= 192; i += 96)
+    {
+        desc = template_desc;
+        desc.dpiX = i;
+        desc.dpiY = i;
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = 0; j <= 192; j += 96)
+        {
+            winetest_push_context("dpi %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.dpiX = j;
+            test_desc.dpiY = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            ok(supported, "Expected supported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    /* Usage */
+    for (i = D2D1_RENDER_TARGET_USAGE_NONE; i <= D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE; ++i)
+    {
+        desc = template_desc;
+        desc.usage = i;
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = D2D1_RENDER_TARGET_USAGE_NONE; j <= D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE; ++j)
+        {
+            winetest_push_context("usage %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.usage = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (j == D2D1_RENDER_TARGET_USAGE_NONE
+                    || (i == D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING
+                    && j == D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING))
+                ok(supported, "Expected supported.\n");
+            else
+                ok(!supported, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = D2D1_RENDER_TARGET_USAGE_NONE; j <= D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE; ++j)
+        {
+            winetest_push_context("usage %#x test %#x", i, j);
+
+            test_desc = template_desc;
+            test_desc.usage = j;
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            if (j == D2D1_RENDER_TARGET_USAGE_NONE
+                    || j == D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE
+                    || (i == D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING
+                    && j == D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING))
+                ok(supported, "Expected supported.\n");
+            else
+                ok(!supported, "Expected unsupported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    /* Min level */
+    for (i = 0; i < ARRAY_SIZE(levels); ++i)
+    {
+        desc = template_desc;
+        desc.minLevel = levels[i];
+        hr = ID2D1Factory_CreateHwndRenderTarget(factory, &desc, &hwnd_rt_desc, &hwnd_rt);
+        if (FAILED(hr))
+            continue;
+        hr = ID2D1HwndRenderTarget_CreateCompatibleRenderTarget(hwnd_rt, NULL, NULL, NULL,
+                D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &bitmap_rt);
+        ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+        for (j = 0; j < ARRAY_SIZE(levels); ++j)
+        {
+            winetest_push_context("level %#lx test %#lx", levels[i], levels[j]);
+
+            test_desc = template_desc;
+            test_desc.minLevel = levels[j];
+            supported = ID2D1BitmapRenderTarget_IsSupported(bitmap_rt, &test_desc);
+            ok(supported || broken(j != D2D1_FEATURE_LEVEL_DEFAULT) /* Win7 */, "Expected supported.\n");
+
+            winetest_pop_context();
+        }
+
+        ID2D1BitmapRenderTarget_Release(bitmap_rt);
+        ID2D1HwndRenderTarget_Release(hwnd_rt);
+    }
+
+    ID2D1Factory_Release(factory);
+    DestroyWindow(window);
+}
+
 static void test_is_supported(BOOL d3d11)
 {
     struct d2d1_test_context ctx;
@@ -13816,6 +14170,7 @@ static void test_is_supported(BOOL d3d11)

test_hwnd_target_is_supported();
     test_dc_target_is_supported();
+    test_bitmap_target_is_supported();
 }

START_TEST(d2d1)