d3d8/tests: Add tests for block-based volume formats.

dlls/d3d8/tests/device.c

@@ -5373,6 +5373,366 @@ static void test_create_rt_ds_fail(void)
     DestroyWindow(window);
 }
 
+static void test_volume_blocks(void)
+{
+    IDirect3DDevice8 *device;
+    IDirect3D8 *d3d8;
+    UINT refcount;
+    HWND window;
+    HRESULT hr;
+    D3DCAPS8 caps;
+    IDirect3DVolumeTexture8 *texture;
+    unsigned int w, h, d, i, j;
+    static const struct
+    {
+        D3DFORMAT fmt;
+        const char *name;
+        unsigned int block_width;
+        unsigned int block_height;
+        unsigned int block_depth;
+        unsigned int block_size;
+        BOOL broken;
+        BOOL create_size_checked, core_fmt;
+    }
+    formats[] =
+    {
+        /* Scratch volumes enforce DXTn block locks, unlike their surface counterparts.
+         * ATI2N and YUV blocks are not enforced on any tested card (r200, gtx 460). */
+        {D3DFMT_DXT1,                 "D3DFMT_DXT1", 4, 4, 1, 8,  FALSE, TRUE,  TRUE },
+        {D3DFMT_DXT2,                 "D3DFMT_DXT2", 4, 4, 1, 16, FALSE, TRUE,  TRUE },
+        {D3DFMT_DXT3,                 "D3DFMT_DXT3", 4, 4, 1, 16, FALSE, TRUE,  TRUE },
+        {D3DFMT_DXT4,                 "D3DFMT_DXT4", 4, 4, 1, 16, FALSE, TRUE,  TRUE },
+        {D3DFMT_DXT5,                 "D3DFMT_DXT5", 4, 4, 1, 16, FALSE, TRUE,  TRUE },
+        {D3DFMT_DXT5,                 "D3DFMT_DXT5", 4, 4, 1, 16, FALSE, TRUE,  TRUE },
+        /* ATI2N has 2x2 blocks on all AMD cards and Geforce 7 cards,
+         * which doesn't match the format spec. On newer Nvidia cards
+         * it has the correct 4x4 block size */
+        {MAKEFOURCC('A','T','I','2'), "ATI2N",       4, 4, 1, 16, TRUE,  FALSE, FALSE},
+        {D3DFMT_YUY2,                 "D3DFMT_YUY2", 2, 1, 1, 4,  TRUE,  FALSE, TRUE },
+        {D3DFMT_UYVY,                 "D3DFMT_UYVY", 2, 1, 1, 4,  TRUE,  FALSE, TRUE },
+    };
+    static const struct
+    {
+        D3DPOOL pool;
+        const char *name;
+        BOOL need_driver_support, need_runtime_support;
+    }
+    create_tests[] =
+    {
+        {D3DPOOL_DEFAULT,       "D3DPOOL_DEFAULT",  TRUE,  FALSE},
+        {D3DPOOL_SCRATCH,       "D3DPOOL_SCRATCH",  FALSE, TRUE },
+        {D3DPOOL_SYSTEMMEM,     "D3DPOOL_SYSTEMMEM",TRUE,  FALSE},
+        {D3DPOOL_MANAGED,       "D3DPOOL_MANAGED",  TRUE,  FALSE},
+    };
+    static const struct
+    {
+        unsigned int x, y, z, x2, y2, z2;
+    }
+    offset_tests[] =
+    {
+        {0, 0, 0, 8, 8, 8},
+        {0, 0, 3, 8, 8, 8},
+        {0, 4, 0, 8, 8, 8},
+        {0, 4, 3, 8, 8, 8},
+        {4, 0, 0, 8, 8, 8},
+        {4, 0, 3, 8, 8, 8},
+        {4, 4, 0, 8, 8, 8},
+        {4, 4, 3, 8, 8, 8},
+    };
+    D3DBOX box;
+    D3DLOCKED_BOX locked_box;
+    BYTE *base;
+    INT expected_row_pitch, expected_slice_pitch;
+    BOOL support, support_2d;
+    BOOL pow2;
+    unsigned int offset, expected_offset;
+
+    if (!(d3d8 = pDirect3DCreate8(D3D_SDK_VERSION)))
+    {
+        skip("Failed to create IDirect3D8 object, skipping tests.\n");
+        return;
+    }
+
+    window = CreateWindowA("static", "d3d8_test", WS_OVERLAPPEDWINDOW,
+            0, 0, 640, 480, 0, 0, 0, 0);
+    if (!(device = create_device(d3d8, window, window, TRUE)))
+    {
+        skip("Failed to create a D3D device, skipping tests.\n");
+        IDirect3D8_Release(d3d8);
+        DestroyWindow(window);
+        return;
+    }
+    hr = IDirect3DDevice8_GetDeviceCaps(device, &caps);
+    ok(SUCCEEDED(hr), "Failed to get caps, hr %#x.\n", hr);
+    pow2 = !!(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2);
+
+    for (i = 0; i < sizeof(formats) / sizeof(*formats); i++)
+    {
+        hr = IDirect3D8_CheckDeviceFormat(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
+                0, D3DRTYPE_VOLUMETEXTURE, formats[i].fmt);
+        support = SUCCEEDED(hr);
+        hr = IDirect3D8_CheckDeviceFormat(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
+                0, D3DRTYPE_TEXTURE, formats[i].fmt);
+        support_2d = SUCCEEDED(hr);
+
+        /* Test creation restrictions */
+        for (w = 1; w <= 8; w++)
+        {
+            for (h = 1; h <= 8; h++)
+            {
+                for (d = 1; d <= 8; d++)
+                {
+                    HRESULT expect_hr;
+                    BOOL size_is_pow2;
+                    BOOL block_aligned = TRUE;
+
+                    if (w & (formats[i].block_width - 1) || h & (formats[i].block_height - 1))
+                        block_aligned = FALSE;
+
+                    size_is_pow2 = !((w & (w - 1)) || (h & (h - 1)) || (d & (d - 1)));
+
+                    for (j = 0; j < sizeof(create_tests) / sizeof(*create_tests); j++)
+                    {
+                        BOOL may_succeed = FALSE;
+                        BOOL todo = FALSE;
+
+                        if (create_tests[j].need_runtime_support && !formats[i].core_fmt && !support)
+                            expect_hr = D3DERR_INVALIDCALL;
+                        else if (formats[i].create_size_checked && !block_aligned)
+                            expect_hr = D3DERR_INVALIDCALL;
+                        else if (pow2 && !size_is_pow2 && create_tests[j].need_driver_support)
+                            expect_hr = D3DERR_INVALIDCALL;
+                        else if (create_tests[j].need_driver_support && !support)
+                        {
+                            todo = support_2d;
+                            expect_hr = D3DERR_INVALIDCALL;
+                        }
+                        else
+                            expect_hr = D3D_OK;
+
+                        texture = (IDirect3DVolumeTexture8 *)0xdeadbeef;
+                        hr = IDirect3DDevice8_CreateVolumeTexture(device, w, h, d, 1, 0,
+                                formats[i].fmt, create_tests[j].pool, &texture);
+
+                        /* Wine knows about ATI2N and happily creates a scratch resource even if GL
+                         * does not support it. Accept scratch creation of extension formats on
+                         * Windows as well if it occurs. We don't really care if e.g. a Windows 7
+                         * on an r200 GPU creates scratch ATI2N texture even though the card doesn't
+                         * support it. */
+                        if (!formats[i].core_fmt && !support && FAILED(expect_hr))
+                            may_succeed = TRUE;
+
+                        if (todo)
+                        {
+                            todo_wine ok(hr == expect_hr || ((SUCCEEDED(hr) && may_succeed)),
+                                    "Got unexpected hr %#x for format %s, pool %s, size %ux%ux%u.\n",
+                                    hr, formats[i].name, create_tests[j].name, w, h, d);
+                        }
+                        else
+                        {
+                            ok(hr == expect_hr || ((SUCCEEDED(hr) && may_succeed)),
+                                    "Got unexpected hr %#x for format %s, pool %s, size %ux%ux%u.\n",
+                                    hr, formats[i].name, create_tests[j].name, w, h, d);
+                        }
+
+                        if (FAILED(hr))
+                            ok(texture == NULL, "Got texture ptr %p, expected NULL.\n", texture);
+                        else
+                            IDirect3DVolumeTexture8_Release(texture);
+                    }
+                }
+            }
+        }
+
+        if (!support && !formats[i].core_fmt)
+            continue;
+
+        hr = IDirect3DDevice8_CreateVolumeTexture(device, 24, 8, 8, 1, 0,
+                formats[i].fmt, D3DPOOL_SCRATCH, &texture);
+        ok(SUCCEEDED(hr), "Failed to create volume texture, hr %#x.\n", hr);
+
+        /* Test lockrect offset */
+        for (j = 0; j < sizeof(offset_tests) / sizeof(*offset_tests); j++)
+        {
+            unsigned int bytes_per_pixel;
+            bytes_per_pixel = formats[i].block_size / (formats[i].block_width * formats[i].block_height);
+
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, NULL, 0);
+            ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+
+            base = locked_box.pBits;
+            if (formats[i].broken)
+            {
+                expected_row_pitch = bytes_per_pixel * 24;
+            }
+            else
+            {
+                expected_row_pitch = (24 /* tex width */ + formats[i].block_height - 1) / formats[i].block_width
+                        * formats[i].block_size;
+            }
+            ok(locked_box.RowPitch == expected_row_pitch, "Got unexpected row pitch %d for format %s, expected %d.\n",
+                    locked_box.RowPitch, formats[i].name, expected_row_pitch);
+
+            if (formats[i].broken)
+            {
+                expected_slice_pitch = expected_row_pitch * 8;
+            }
+            else
+            {
+                expected_slice_pitch = (8 /* tex height */ + formats[i].block_depth - 1) / formats[i].block_height
+                        * expected_row_pitch;
+            }
+            ok(locked_box.SlicePitch == expected_slice_pitch,
+                    "Got unexpected slice pitch %d for format %s, expected %d.\n",
+                    locked_box.SlicePitch, formats[i].name, expected_slice_pitch);
+
+            hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+            ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x, j %u.\n", hr, j);
+
+            box.Left = offset_tests[j].x;
+            box.Top = offset_tests[j].y;
+            box.Front = offset_tests[j].z;
+            box.Right = offset_tests[j].x2;
+            box.Bottom = offset_tests[j].y2;
+            box.Back = offset_tests[j].z2;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+            ok(SUCCEEDED(hr), "Failed to lock volume texture, hr %#x, j %u.\n", hr, j);
+
+            offset = (BYTE *)locked_box.pBits - base;
+            if (formats[i].broken)
+            {
+                expected_offset = box.Front * expected_slice_pitch
+                        + box.Top * expected_row_pitch
+                        + box.Left * bytes_per_pixel;
+            }
+            else
+            {
+                expected_offset = (box.Front / formats[i].block_depth) * expected_slice_pitch
+                        + (box.Top / formats[i].block_height) * expected_row_pitch
+                        + (box.Left / formats[i].block_width) * formats[i].block_size;
+            }
+            ok(offset == expected_offset, "Got unexpected offset %u for format %s, expected %u, box start %ux%ux%u.\n",
+                    offset, formats[i].name, expected_offset, box.Left, box.Top, box.Front);
+
+            hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+            ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+        }
+
+        /* Test partial block locks */
+        box.Front = 0;
+        box.Back = 1;
+        if (formats[i].block_width > 1)
+        {
+            box.Left = formats[i].block_width >> 1;
+            box.Top = 0;
+            box.Right = formats[i].block_width;
+            box.Bottom = formats[i].block_height;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+            ok(FAILED(hr) || broken(formats[i].broken),
+                    "Partial block lock succeeded, expected failure, format %s.\n",
+                    formats[i].name);
+            if (SUCCEEDED(hr))
+            {
+                hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+                ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+            }
+
+            box.Left = 0;
+            box.Top = 0;
+            box.Right = formats[i].block_width >> 1;
+            box.Bottom = formats[i].block_height;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+            ok(FAILED(hr) || broken(formats[i].broken),
+                    "Partial block lock succeeded, expected failure, format %s.\n",
+                    formats[i].name);
+            if (SUCCEEDED(hr))
+            {
+                hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+                ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+            }
+        }
+
+        if (formats[i].block_height > 1)
+        {
+            box.Left = 0;
+            box.Top = formats[i].block_height >> 1;
+            box.Right = formats[i].block_width;
+            box.Bottom = formats[i].block_height;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+            ok(FAILED(hr) || broken(formats[i].broken),
+                    "Partial block lock succeeded, expected failure, format %s.\n",
+                    formats[i].name);
+            if (SUCCEEDED(hr))
+            {
+                hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+                ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+            }
+
+            box.Left = 0;
+            box.Top = 0;
+            box.Right = formats[i].block_width;
+            box.Bottom = formats[i].block_height >> 1;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+            ok(FAILED(hr) || broken(formats[i].broken),
+                    "Partial block lock succeeded, expected failure, format %s.\n",
+                    formats[i].name);
+            if (SUCCEEDED(hr))
+            {
+                hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+                ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+            }
+        }
+
+        /* Test full block lock */
+        box.Left = 0;
+        box.Top = 0;
+        box.Right = formats[i].block_width;
+        box.Bottom = formats[i].block_height;
+        hr = IDirect3DVolumeTexture8_LockBox(texture, 0, &locked_box, &box, 0);
+        ok(SUCCEEDED(hr), "Failed to lock volume texture, hr %#x.\n", hr);
+        hr = IDirect3DVolumeTexture8_UnlockBox(texture, 0);
+        ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+
+        IDirect3DVolumeTexture8_Release(texture);
+
+        /* Test mipmap locks. Don't do this with ATI2N, AMD warns that the runtime
+         * does not allocate surfaces smaller than the blocksize properly. */
+        if ((formats[i].block_width > 1 || formats[i].block_height > 1) && formats[i].core_fmt)
+        {
+            hr = IDirect3DDevice8_CreateVolumeTexture(device, formats[i].block_width, formats[i].block_height,
+                    2, 2, 0, formats[i].fmt, D3DPOOL_SCRATCH, &texture);
+
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 1, &locked_box, NULL, 0);
+            ok(SUCCEEDED(hr), "Failed to lock volume texture mipmap, hr %#x.\n", hr);
+            hr = IDirect3DVolumeTexture8_UnlockBox(texture, 1);
+            ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+
+            box.Left = box.Top = box.Front = 0;
+            box.Right = formats[i].block_width == 1 ? 1 : formats[i].block_width >> 1;
+            box.Bottom = formats[i].block_height == 1 ? 1 : formats[i].block_height >> 1;
+            box.Back = 1;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 1, &locked_box, &box, 0);
+            ok(SUCCEEDED(hr), "Failed to lock volume texture mipmap, hr %#x.\n", hr);
+            hr = IDirect3DVolumeTexture8_UnlockBox(texture, 1);
+            ok(SUCCEEDED(hr), "Failed to unlock volume texture, hr %#x.\n", hr);
+
+            box.Right = formats[i].block_width;
+            box.Bottom = formats[i].block_height;
+            hr = IDirect3DVolumeTexture8_LockBox(texture, 1, &locked_box, &box, 0);
+            ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
+            if (SUCCEEDED(hr))
+                IDirect3DVolumeTexture8_UnlockBox(texture, 1);
+
+            IDirect3DVolumeTexture8_Release(texture);
+        }
+    }
+
+    refcount = IDirect3DDevice8_Release(device);
+    ok(!refcount, "Device has %u references left.\n", refcount);
+    IDirect3D8_Release(d3d8);
+    DestroyWindow(window);
+}
+
 START_TEST(device)
 {
     HMODULE d3d8_handle = LoadLibraryA( "d3d8.dll" );
@@ -5453,6 +5813,7 @@ START_TEST(device)
         test_volume_locking();
         test_update_volumetexture();
         test_create_rt_ds_fail();
+        test_volume_blocks();
     }
     UnregisterClassA("d3d8_test_wc", GetModuleHandleA(NULL));
 }