[PATCH 0/4] MR8929: d3dx11: Use shared code to implement D3DX11GetImageInfoFromMemory().
From: Connor McAdams cmcadams@codeweavers.com
Signed-off-by: Connor McAdams cmcadams@codeweavers.com --- dlls/d3dx11_42/Makefile.in | 7 ++-- dlls/d3dx11_42/d3dx11_42.spec | 40 ++++++++++----------- dlls/d3dx11_42/d3dx11_42_main.c | 33 +++++++++++++++++ dlls/d3dx11_43/Makefile.in | 2 +- dlls/d3dx11_43/{main.c => d3dx11_43_main.c} | 0 5 files changed, 56 insertions(+), 26 deletions(-) create mode 100644 dlls/d3dx11_42/d3dx11_42_main.c rename dlls/d3dx11_43/{main.c => d3dx11_43_main.c} (100%)
diff --git a/dlls/d3dx11_42/Makefile.in b/dlls/d3dx11_42/Makefile.in index 985fc1c59c2..c833ce17818 100644 --- a/dlls/d3dx11_42/Makefile.in +++ b/dlls/d3dx11_42/Makefile.in @@ -1,13 +1,10 @@ EXTRADEFS = -DD3DX11_SDK_VERSION=42 MODULE = d3dx11_42.dll IMPORTLIB = d3dx11_42 -IMPORTS = d3dcompiler -PARENTSRC = ../d3dx11_43 +IMPORTS = d3dcompiler d3dx11
EXTRADLLFLAGS = -Wb,--prefer-native
SOURCES = \ - async.c \ - main.c \ - texture.c \ + d3dx11_42_main.c \ version.rc diff --git a/dlls/d3dx11_42/d3dx11_42.spec b/dlls/d3dx11_42/d3dx11_42.spec index 2d93b8d760a..2d125ea119f 100644 --- a/dlls/d3dx11_42/d3dx11_42.spec +++ b/dlls/d3dx11_42/d3dx11_42.spec @@ -1,44 +1,44 @@ @ stdcall D3DX11CheckVersion(long long) -@ stdcall D3DX11CompileFromFileA(str ptr ptr str str long long ptr ptr ptr ptr) -@ stdcall D3DX11CompileFromFileW(wstr ptr ptr str str long long ptr ptr ptr ptr) -@ stdcall D3DX11CompileFromMemory(ptr long str ptr ptr str str long long ptr ptr ptr ptr) +@ stdcall -import D3DX11CompileFromFileA(str ptr ptr str str long long ptr ptr ptr ptr) +@ stdcall -import D3DX11CompileFromFileW(wstr ptr ptr str str long long ptr ptr ptr ptr) +@ stdcall -import D3DX11CompileFromMemory(ptr long str ptr ptr str str long long ptr ptr ptr ptr) @ stub D3DX11CompileFromResourceA @ stub D3DX11CompileFromResourceW @ stub D3DX11ComputeNormalMap @ stub D3DX11CreateAsyncCompilerProcessor -@ stdcall D3DX11CreateAsyncFileLoaderA(str ptr) -@ stdcall D3DX11CreateAsyncFileLoaderW(wstr ptr) -@ stdcall D3DX11CreateAsyncMemoryLoader(ptr long ptr) -@ stdcall D3DX11CreateAsyncResourceLoaderA(long str ptr) -@ stdcall D3DX11CreateAsyncResourceLoaderW(long wstr ptr) +@ stdcall -import D3DX11CreateAsyncFileLoaderA(str ptr) +@ stdcall -import D3DX11CreateAsyncFileLoaderW(wstr ptr) +@ stdcall -import D3DX11CreateAsyncMemoryLoader(ptr long ptr) +@ stdcall -import D3DX11CreateAsyncResourceLoaderA(long str ptr) +@ stdcall -import D3DX11CreateAsyncResourceLoaderW(long wstr ptr) @ stub D3DX11CreateAsyncShaderPreprocessProcessor @ stub D3DX11CreateAsyncShaderResourceViewProcessor @ stub D3DX11CreateAsyncTextureInfoProcessor @ stub D3DX11CreateAsyncTextureProcessor @ stub D3DX11CreateShaderResourceViewFromFileA @ stub D3DX11CreateShaderResourceViewFromFileW -@ stdcall D3DX11CreateShaderResourceViewFromMemory(ptr ptr long ptr ptr ptr ptr) +@ stdcall -import D3DX11CreateShaderResourceViewFromMemory(ptr ptr long ptr ptr ptr ptr) @ stub D3DX11CreateShaderResourceViewFromResourceA @ stub D3DX11CreateShaderResourceViewFromResourceW -@ stdcall D3DX11CreateTextureFromFileA(ptr str ptr ptr ptr ptr) -@ stdcall D3DX11CreateTextureFromFileW(ptr wstr ptr ptr ptr ptr) -@ stdcall D3DX11CreateTextureFromMemory(ptr ptr long ptr ptr ptr ptr) +@ stdcall -import D3DX11CreateTextureFromFileA(ptr str ptr ptr ptr ptr) +@ stdcall -import D3DX11CreateTextureFromFileW(ptr wstr ptr ptr ptr ptr) +@ stdcall -import D3DX11CreateTextureFromMemory(ptr ptr long ptr ptr ptr ptr) @ stub D3DX11CreateTextureFromResourceA @ stub D3DX11CreateTextureFromResourceW @ stub D3DX11CreateThreadPump -@ stdcall D3DX11FilterTexture(ptr ptr long long) -@ stdcall D3DX11GetImageInfoFromFileA(str ptr ptr ptr) -@ stdcall D3DX11GetImageInfoFromFileW(wstr ptr ptr ptr) -@ stdcall D3DX11GetImageInfoFromMemory(ptr long ptr ptr ptr) +@ stdcall -import D3DX11FilterTexture(ptr ptr long long) +@ stdcall -import D3DX11GetImageInfoFromFileA(str ptr ptr ptr) +@ stdcall -import D3DX11GetImageInfoFromFileW(wstr ptr ptr ptr) +@ stdcall -import D3DX11GetImageInfoFromMemory(ptr long ptr ptr ptr) @ stub D3DX11GetImageInfoFromResourceA @ stub D3DX11GetImageInfoFromResourceW -@ stdcall D3DX11LoadTextureFromTexture(ptr ptr ptr ptr) +@ stdcall -import D3DX11LoadTextureFromTexture(ptr ptr ptr ptr) @ stub D3DX11PreprocessShaderFromFileA @ stub D3DX11PreprocessShaderFromFileW @ stub D3DX11PreprocessShaderFromMemory @ stub D3DX11PreprocessShaderFromResourceA @ stub D3DX11PreprocessShaderFromResourceW @ stub D3DX11SHProjectCubeMap -@ stdcall D3DX11SaveTextureToFileA(ptr ptr long str) -@ stdcall D3DX11SaveTextureToFileW(ptr ptr long wstr) -@ stdcall D3DX11SaveTextureToMemory(ptr ptr long ptr long) +@ stdcall -import D3DX11SaveTextureToFileA(ptr ptr long str) +@ stdcall -import D3DX11SaveTextureToFileW(ptr ptr long wstr) +@ stdcall -import D3DX11SaveTextureToMemory(ptr ptr long ptr long) diff --git a/dlls/d3dx11_42/d3dx11_42_main.c b/dlls/d3dx11_42/d3dx11_42_main.c new file mode 100644 index 00000000000..0692e2c8caa --- /dev/null +++ b/dlls/d3dx11_42/d3dx11_42_main.c @@ -0,0 +1,33 @@ +/* + * Copyright 2025 Connor McAdams for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + */ + +#include "d3dx11.h" +#include "d3dx11core.h" +#include "d3dx11tex.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(d3dx); + +BOOL WINAPI D3DX11CheckVersion(UINT d3d_sdk_ver, UINT d3dx_sdk_ver) +{ + TRACE("d3d_sdk_ver %u, d3dx_sdk_ver %u.\n", d3d_sdk_ver, d3dx_sdk_ver); + + return d3d_sdk_ver == D3D11_SDK_VERSION && d3dx_sdk_ver == D3DX11_SDK_VERSION; +} diff --git a/dlls/d3dx11_43/Makefile.in b/dlls/d3dx11_43/Makefile.in index 762987a89ad..a44fafb1541 100644 --- a/dlls/d3dx11_43/Makefile.in +++ b/dlls/d3dx11_43/Makefile.in @@ -7,6 +7,6 @@ EXTRADLLFLAGS = -Wb,--prefer-native
SOURCES = \ async.c \ - main.c \ + d3dx11_43_main.c \ texture.c \ version.rc diff --git a/dlls/d3dx11_43/main.c b/dlls/d3dx11_43/d3dx11_43_main.c similarity index 100% rename from dlls/d3dx11_43/main.c rename to dlls/d3dx11_43/d3dx11_43_main.c
From: Connor McAdams cmcadams@codeweavers.com
Signed-off-by: Connor McAdams cmcadams@codeweavers.com --- dlls/d3dx11_43/tests/d3dx11.c | 210 ++++++++++++++-------------------- 1 file changed, 84 insertions(+), 126 deletions(-)
diff --git a/dlls/d3dx11_43/tests/d3dx11.c b/dlls/d3dx11_43/tests/d3dx11.c index 5b7bd6ebfe2..fcba41a7018 100644 --- a/dlls/d3dx11_43/tests/d3dx11.c +++ b/dlls/d3dx11_43/tests/d3dx11.c @@ -21,6 +21,7 @@ #include "d3d11.h" #include "d3dx11.h" #include "wine/test.h" +#include <stdint.h>
#ifndef MAKEFOURCC #define MAKEFOURCC(ch0, ch1, ch2, ch3) \ @@ -249,6 +250,47 @@ static const unsigned char noimage[4] = 0x11,0x22,0x33,0x44 };
+#define check_image_info_values(info, width, height, depth, array_size, mip_levels, misc_flags, format, resource_dimension, \ + image_file_format, wine_todo) \ + check_image_info_values_(__LINE__, info, width, height, depth, array_size, mip_levels, misc_flags, format, resource_dimension, \ + image_file_format, wine_todo) +static inline void check_image_info_values_(unsigned int line, const D3DX11_IMAGE_INFO *info, uint32_t width, + uint32_t height, uint32_t depth, uint32_t array_size, uint32_t mip_levels, uint32_t misc_flags, + DXGI_FORMAT format, D3D11_RESOURCE_DIMENSION resource_dimension, D3DX11_IMAGE_FILE_FORMAT image_file_format, + BOOL wine_todo) +{ + const D3DX11_IMAGE_INFO expected_info = { width, height, depth, array_size, mip_levels, misc_flags, format, + resource_dimension, image_file_format }; + BOOL matched; + + matched = !memcmp(&expected_info, info, sizeof(*info)); + todo_wine_if(wine_todo) ok_(__FILE__, line)(matched, "Got unexpected image info values.\n"); + if (matched) + return; + + todo_wine_if(wine_todo && info->Width != width) + ok_(__FILE__, line)(info->Width == width, "Expected width %u, got %u.\n", width, info->Width); + todo_wine_if(wine_todo && info->Height != height) + ok_(__FILE__, line)(info->Height == height, "Expected height %u, got %u.\n", height, info->Height); + todo_wine_if(wine_todo && info->Depth != depth) + ok_(__FILE__, line)(info->Depth == depth, "Expected depth %u, got %u.\n", depth, info->Depth); + todo_wine_if(wine_todo && info->ArraySize != array_size) + ok_(__FILE__, line)(info->ArraySize == array_size, "Expected array_size %u, got %u.\n", array_size, + info->ArraySize); + todo_wine_if(wine_todo && info->MipLevels != mip_levels) + ok_(__FILE__, line)(info->MipLevels == mip_levels, "Expected mip_levels %u, got %u.\n", mip_levels, + info->MipLevels); + todo_wine_if(wine_todo && info->MiscFlags != misc_flags) + ok_(__FILE__, line)(info->MiscFlags == misc_flags, "Expected misc_flags %u, got %u.\n", misc_flags, + info->MiscFlags); + ok_(__FILE__, line)(info->Format == format, "Expected texture format %d, got %d.\n", format, info->Format); + todo_wine_if(wine_todo && info->ResourceDimension != resource_dimension) + ok_(__FILE__, line)(info->ResourceDimension == resource_dimension, "Expected resource_dimension %d, got %d.\n", + resource_dimension, info->ResourceDimension); + ok_(__FILE__, line)(info->ImageFileFormat == image_file_format, "Expected image_file_format %d, got %d.\n", + image_file_format, info->ImageFileFormat); +} + static WCHAR temp_dir[MAX_PATH];
static BOOL create_file(const WCHAR *filename, const char *data, unsigned int size, WCHAR *out_path) @@ -779,183 +821,99 @@ static void test_D3DX11GetImageInfoFromMemory(void) ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr);
/* test BMP support */ + memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(bmp_1bpp, sizeof(bmp_1bpp), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 1, "Unexpected width %u.\n", info.Width); - ok(info.Height == 1, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_BMP, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 1, 1, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_BMP, FALSE);
hr = D3DX11GetImageInfoFromMemory(bmp_2bpp, sizeof(bmp_2bpp), NULL, &info, NULL); ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(bmp_4bpp, sizeof(bmp_4bpp), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 1, "Unexpected width %u.\n", info.Width); - ok(info.Height == 1, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_BMP, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 1, 1, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_BMP, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(bmp_8bpp, sizeof(bmp_8bpp), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 1, "Unexpected width %u.\n", info.Width); - ok(info.Height == 1, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_BMP, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 1, 1, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_BMP, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(bmp_32bpp_xrgb, sizeof(bmp_32bpp_xrgb), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_BMP, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_BMP, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(bmp_32bpp_argb, sizeof(bmp_32bpp_argb), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_BMP, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_BMP, FALSE);
/* Grayscale PNG */ + memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(png_grayscale, sizeof(png_grayscale), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 1, "Unexpected width %u.\n", info.Width); - ok(info.Height == 1, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.MiscFlags == 0, "Unexpected misc flags %#x\n", info.MiscFlags); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_PNG, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 1, 1, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_PNG, FALSE);
/* test DDS support */ + memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_24bit, sizeof(dds_24bit), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 2, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 2, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_DDS, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_24bit, sizeof(dds_24bit) - 1, NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 2, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 2, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_DDS, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_16bit, sizeof(dds_16bit), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_DDS, FALSE);
memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_16bit, sizeof(dds_16bit) - 1, NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 2, "Unexpected width %u.\n", info.Width); - ok(info.Height == 2, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 2, 2, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_DDS, FALSE);
memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_8bit, sizeof(dds_8bit), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 16, "Unexpected width %u.\n", info.Width); - ok(info.Height == 4, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_R8G8B8A8_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 16, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3DX11_IFF_DDS, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_cube_map, sizeof(dds_cube_map), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 4, "Unexpected width %u.\n", info.Width); - ok(info.Height == 4, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 6, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_BC3_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 4, 4, 1, 6, 1, D3D11_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_BC3_UNORM, + D3D11_RESOURCE_DIMENSION_TEXTURE2D, D3DX11_IFF_DDS, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_cube_map, sizeof(dds_cube_map) - 1, NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 4, "Unexpected width %u.\n", info.Width); - ok(info.Height == 4, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 1, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 6, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 1, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_BC3_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE2D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 4, 4, 1, 6, 1, D3D11_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_BC3_UNORM, + D3D11_RESOURCE_DIMENSION_TEXTURE2D, D3DX11_IFF_DDS, FALSE);
+ memset(&info, 0, sizeof(info)); hr = D3DX11GetImageInfoFromMemory(dds_volume_map, sizeof(dds_volume_map), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 4, "Unexpected width %u.\n", info.Width); - ok(info.Height == 4, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 2, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 3, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_BC2_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE3D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 4, 4, 2, 1, 3, 0, DXGI_FORMAT_BC2_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, + D3DX11_IFF_DDS, FALSE);
hr = D3DX11GetImageInfoFromMemory(dds_volume_map, sizeof(dds_volume_map) - 1, NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr); - ok(info.Width == 4, "Unexpected width %u.\n", info.Width); - ok(info.Height == 4, "Unexpected height %u.\n", info.Height); - ok(info.Depth == 2, "Unexpected depth %u.\n", info.Depth); - ok(info.ArraySize == 1, "Unexpected array size %u.\n", info.ArraySize); - ok(info.MipLevels == 3, "Unexpected miplevels %u\n", info.MipLevels); - ok(info.Format == DXGI_FORMAT_BC2_UNORM, "Unexpected format %#x.\n", info.Format); - ok(info.ResourceDimension == D3D11_RESOURCE_DIMENSION_TEXTURE3D, "Unexpected resource type %#x.\n", info.ResourceDimension); - ok(info.ImageFileFormat == D3DX11_IFF_DDS, "Unexpected image file format %#x.\n", info.ImageFileFormat); + check_image_info_values(&info, 4, 4, 2, 1, 3, 0, DXGI_FORMAT_BC2_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, + D3DX11_IFF_DDS, FALSE);
check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC1_UNORM); check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC2_UNORM);
From: Connor McAdams cmcadams@codeweavers.com
Signed-off-by: Connor McAdams cmcadams@codeweavers.com --- dlls/d3dx11_43/tests/d3dx11.c | 600 +++++++++++++++++++++++++++++++++- 1 file changed, 587 insertions(+), 13 deletions(-)
diff --git a/dlls/d3dx11_43/tests/d3dx11.c b/dlls/d3dx11_43/tests/d3dx11.c index fcba41a7018..ac310d2a947 100644 --- a/dlls/d3dx11_43/tests/d3dx11.c +++ b/dlls/d3dx11_43/tests/d3dx11.c @@ -29,6 +29,140 @@ ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 )) #endif
+static unsigned int get_bpp_from_format(DXGI_FORMAT format) +{ + switch (format) + { + case DXGI_FORMAT_R32G32B32A32_TYPELESS: + case DXGI_FORMAT_R32G32B32A32_FLOAT: + case DXGI_FORMAT_R32G32B32A32_UINT: + case DXGI_FORMAT_R32G32B32A32_SINT: + return 128; + case DXGI_FORMAT_R32G32B32_TYPELESS: + case DXGI_FORMAT_R32G32B32_FLOAT: + case DXGI_FORMAT_R32G32B32_UINT: + case DXGI_FORMAT_R32G32B32_SINT: + return 96; + case DXGI_FORMAT_R16G16B16A16_TYPELESS: + case DXGI_FORMAT_R16G16B16A16_FLOAT: + case DXGI_FORMAT_R16G16B16A16_UNORM: + case DXGI_FORMAT_R16G16B16A16_UINT: + case DXGI_FORMAT_R16G16B16A16_SNORM: + case DXGI_FORMAT_R16G16B16A16_SINT: + case DXGI_FORMAT_R32G32_TYPELESS: + case DXGI_FORMAT_R32G32_FLOAT: + case DXGI_FORMAT_R32G32_UINT: + case DXGI_FORMAT_R32G32_SINT: + case DXGI_FORMAT_R32G8X24_TYPELESS: + case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: + case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: + case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: + case DXGI_FORMAT_Y416: + case DXGI_FORMAT_Y210: + case DXGI_FORMAT_Y216: + return 64; + case DXGI_FORMAT_R10G10B10A2_TYPELESS: + case DXGI_FORMAT_R10G10B10A2_UNORM: + case DXGI_FORMAT_R10G10B10A2_UINT: + case DXGI_FORMAT_R11G11B10_FLOAT: + case DXGI_FORMAT_R8G8B8A8_TYPELESS: + case DXGI_FORMAT_R8G8B8A8_UNORM: + case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: + case DXGI_FORMAT_R8G8B8A8_UINT: + case DXGI_FORMAT_R8G8B8A8_SNORM: + case DXGI_FORMAT_R8G8B8A8_SINT: + case DXGI_FORMAT_R16G16_TYPELESS: + case DXGI_FORMAT_R16G16_FLOAT: + case DXGI_FORMAT_R16G16_UNORM: + case DXGI_FORMAT_R16G16_UINT: + case DXGI_FORMAT_R16G16_SNORM: + case DXGI_FORMAT_R16G16_SINT: + case DXGI_FORMAT_R32_TYPELESS: + case DXGI_FORMAT_D32_FLOAT: + case DXGI_FORMAT_R32_FLOAT: + case DXGI_FORMAT_R32_UINT: + case DXGI_FORMAT_R32_SINT: + case DXGI_FORMAT_R24G8_TYPELESS: + case DXGI_FORMAT_D24_UNORM_S8_UINT: + case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: + case DXGI_FORMAT_X24_TYPELESS_G8_UINT: + case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: + case DXGI_FORMAT_R8G8_B8G8_UNORM: + case DXGI_FORMAT_G8R8_G8B8_UNORM: + case DXGI_FORMAT_B8G8R8A8_UNORM: + case DXGI_FORMAT_B8G8R8X8_UNORM: + case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: + case DXGI_FORMAT_B8G8R8A8_TYPELESS: + case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: + case DXGI_FORMAT_B8G8R8X8_TYPELESS: + case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: + case DXGI_FORMAT_AYUV: + case DXGI_FORMAT_Y410: + case DXGI_FORMAT_YUY2: + return 32; + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + return 24; + case DXGI_FORMAT_R8G8_TYPELESS: + case DXGI_FORMAT_R8G8_UNORM: + case DXGI_FORMAT_R8G8_UINT: + case DXGI_FORMAT_R8G8_SNORM: + case DXGI_FORMAT_R8G8_SINT: + case DXGI_FORMAT_R16_TYPELESS: + case DXGI_FORMAT_R16_FLOAT: + case DXGI_FORMAT_D16_UNORM: + case DXGI_FORMAT_R16_UNORM: + case DXGI_FORMAT_R16_UINT: + case DXGI_FORMAT_R16_SNORM: + case DXGI_FORMAT_R16_SINT: + case DXGI_FORMAT_B5G6R5_UNORM: + case DXGI_FORMAT_B5G5R5A1_UNORM: + case DXGI_FORMAT_A8P8: + case DXGI_FORMAT_B4G4R4A4_UNORM: + return 16; + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_420_OPAQUE: + case DXGI_FORMAT_NV11: + return 12; + case DXGI_FORMAT_R8_TYPELESS: + case DXGI_FORMAT_R8_UNORM: + case DXGI_FORMAT_R8_UINT: + case DXGI_FORMAT_R8_SNORM: + case DXGI_FORMAT_R8_SINT: + case DXGI_FORMAT_A8_UNORM: + case DXGI_FORMAT_AI44: + case DXGI_FORMAT_IA44: + case DXGI_FORMAT_P8: + case DXGI_FORMAT_BC2_TYPELESS: + case DXGI_FORMAT_BC2_UNORM: + case DXGI_FORMAT_BC2_UNORM_SRGB: + case DXGI_FORMAT_BC3_TYPELESS: + case DXGI_FORMAT_BC3_UNORM: + case DXGI_FORMAT_BC3_UNORM_SRGB: + case DXGI_FORMAT_BC5_TYPELESS: + case DXGI_FORMAT_BC5_UNORM: + case DXGI_FORMAT_BC5_SNORM: + case DXGI_FORMAT_BC6H_TYPELESS: + case DXGI_FORMAT_BC6H_UF16: + case DXGI_FORMAT_BC6H_SF16: + case DXGI_FORMAT_BC7_TYPELESS: + case DXGI_FORMAT_BC7_UNORM: + case DXGI_FORMAT_BC7_UNORM_SRGB: + return 8; + case DXGI_FORMAT_BC1_TYPELESS: + case DXGI_FORMAT_BC1_UNORM: + case DXGI_FORMAT_BC1_UNORM_SRGB: + case DXGI_FORMAT_BC4_TYPELESS: + case DXGI_FORMAT_BC4_UNORM: + case DXGI_FORMAT_BC4_SNORM: + return 4; + case DXGI_FORMAT_R1_UNORM: + return 1; + default: + return 0; + } +} + /* 1x1 bmp (1 bpp) */ static const unsigned char bmp_1bpp[] = { @@ -668,15 +802,31 @@ static void test_D3DX11CompileFromFile(void) #define DDS_PIXELFORMAT 0x00001000 #define DDS_MIPMAPCOUNT 0x00020000 #define DDS_LINEARSIZE 0x00080000 +#define DDS_DEPTH 0x00800000
/* dds_header.caps */ #define DDSCAPS_ALPHA 0x00000002 +#define DDS_CAPS_COMPLEX 0x00000008 #define DDS_CAPS_TEXTURE 0x00001000
+/* dds_header.caps2 */ +#define DDS_CAPS2_VOLUME 0x00200000 +#define DDS_CAPS2_CUBEMAP 0x00000200 +#define DDS_CAPS2_CUBEMAP_POSITIVEX 0x00000400 +#define DDS_CAPS2_CUBEMAP_NEGATIVEX 0x00000800 +#define DDS_CAPS2_CUBEMAP_POSITIVEY 0x00001000 +#define DDS_CAPS2_CUBEMAP_NEGATIVEY 0x00002000 +#define DDS_CAPS2_CUBEMAP_POSITIVEZ 0x00004000 +#define DDS_CAPS2_CUBEMAP_NEGATIVEZ 0x00008000 +#define DDS_CAPS2_CUBEMAP_ALL_FACES ( DDS_CAPS2_CUBEMAP_POSITIVEX | DDS_CAPS2_CUBEMAP_NEGATIVEX \ + | DDS_CAPS2_CUBEMAP_POSITIVEY | DDS_CAPS2_CUBEMAP_NEGATIVEY \ + | DDS_CAPS2_CUBEMAP_POSITIVEZ | DDS_CAPS2_CUBEMAP_NEGATIVEZ ) + /* dds_pixel_format.flags */ #define DDS_PF_ALPHA 0x00000001 #define DDS_PF_ALPHA_ONLY 0x00000002 #define DDS_PF_FOURCC 0x00000004 +#define DDS_PF_INDEXED 0x00000020 #define DDS_PF_RGB 0x00000040 #define DDS_PF_LUMINANCE 0x00020000 #define DDS_PF_BUMPLUMINANCE 0x00040000 @@ -712,6 +862,16 @@ struct dds_header DWORD reserved2; };
+#define DDS_RESOURCE_MISC_TEXTURECUBE 0x04 +struct dds_header_dxt10 +{ + DWORD dxgi_format; + DWORD resource_dimension; + DWORD misc_flag; + DWORD array_size; + DWORD misc_flags2; +}; + /* fills dds_header with reasonable default values */ static void fill_dds_header(struct dds_header *header) { @@ -733,10 +893,37 @@ static void fill_dds_header(struct dds_header *header) header->caps = DDS_CAPS_TEXTURE; }
-#define check_dds_pixel_format(flags, fourcc, bpp, rmask, gmask, bmask, amask, format) \ - check_dds_pixel_format_(__LINE__, flags, fourcc, bpp, rmask, gmask, bmask, amask, format) -static void check_dds_pixel_format_(unsigned int line, DWORD flags, DWORD fourcc, DWORD bpp, - DWORD rmask, DWORD gmask, DWORD bmask, DWORD amask, DXGI_FORMAT expected_format) +static void set_dxt10_dds_header(struct dds_header *header, uint32_t append_flags, uint32_t width, uint32_t height, + uint32_t depth, uint32_t mip_levels, uint32_t pitch, uint32_t caps, uint32_t caps2) +{ + memset(header, 0, sizeof(*header)); + + header->size = sizeof(*header); + header->flags = DDS_CAPS | DDS_PIXELFORMAT | append_flags; + header->height = height; + header->width = width; + header->depth = depth; + header->miplevels = mip_levels; + header->pitch_or_linear_size = pitch; + header->pixel_format.size = sizeof(header->pixel_format); + header->pixel_format.flags = DDS_PF_FOURCC; + header->pixel_format.fourcc = MAKEFOURCC('D','X','1','0'); + header->caps = caps; + header->caps2 = caps2; +} + +static void set_dds_header_dxt10(struct dds_header_dxt10 *dxt10, DXGI_FORMAT format, uint32_t resource_dimension, + uint32_t misc_flag, uint32_t array_size, uint32_t misc_flags2) +{ + dxt10->dxgi_format = format; + dxt10->resource_dimension = resource_dimension; + dxt10->misc_flag = misc_flag; + dxt10->array_size = array_size; + dxt10->misc_flags2 = misc_flags2; +} + +static void check_dds_pixel_format_image_info(unsigned int line, DWORD flags, DWORD fourcc, DWORD bpp, + DWORD rmask, DWORD gmask, DWORD bmask, DWORD amask, HRESULT expected_hr, DXGI_FORMAT expected_format) { D3DX11_IMAGE_INFO info; HRESULT hr; @@ -744,6 +931,7 @@ static void check_dds_pixel_format_(unsigned int line, DWORD flags, DWORD fourcc { DWORD magic; struct dds_header header; + PALETTEENTRY palette[256]; BYTE data[256]; } dds;
@@ -759,25 +947,359 @@ static void check_dds_pixel_format_(unsigned int line, DWORD flags, DWORD fourcc memset(dds.data, 0, sizeof(dds.data));
hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds), NULL, &info, NULL); - ok_(__FILE__, line)(hr == S_OK, "Got unexpected hr %#lx for pixel format %#x.\n", hr, expected_format); - if (SUCCEEDED(hr)) + ok_(__FILE__, line)(hr == expected_hr, "Unexpected hr %#lx.\n", hr); + if (SUCCEEDED(hr) && hr == expected_hr) + ok_(__FILE__, line)(info.Format == expected_format, "Unexpected format %#x.\n", info.Format); +} + +#define check_dds_pixel_format(flags, fourcc, bpp, rmask, gmask, bmask, amask, format) \ + check_dds_pixel_format_image_info(__LINE__, flags, fourcc, bpp, rmask, gmask, bmask, amask, S_OK, format) + +#define check_dds_pixel_format_unsupported(flags, fourcc, bpp, rmask, gmask, bmask, amask, expected_hr) \ + check_dds_pixel_format_image_info(__LINE__, flags, fourcc, bpp, rmask, gmask, bmask, amask, expected_hr, \ + DXGI_FORMAT_UNKNOWN) + +static void check_dds_dxt10_format_image_info(unsigned int line, DXGI_FORMAT format, DXGI_FORMAT expected_format, + HRESULT expected_hr, BOOL todo_format) +{ + const unsigned int stride = (4 * get_bpp_from_format(format) + 7) / 8; + D3DX11_IMAGE_INFO info; + HRESULT hr; + struct + { + DWORD magic; + struct dds_header header; + struct dds_header_dxt10 dxt10; + BYTE data[256]; + } dds; + + dds.magic = MAKEFOURCC('D','D','S',' '); + set_dxt10_dds_header(&dds.header, 0, 4, 4, 1, 1, stride, 0, 0); + set_dds_header_dxt10(&dds.dxt10, format, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, 1, 0); + + hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds), NULL, &info, NULL); + ok_(__FILE__, line)(hr == expected_hr, "Unexpected hr %#lx.\n", hr); + if (SUCCEEDED(hr) && hr == expected_hr) + todo_wine_if(todo_format) ok_(__FILE__, line)(info.Format == expected_format, "Unexpected format %#x.\n", + info.Format); +} + +#define check_dds_dxt10_format(format, expected_format, todo_format) \ + check_dds_dxt10_format_image_info(__LINE__, format, expected_format, S_OK, todo_format) + +#define check_dds_dxt10_format_unsupported(format, expected_hr) \ + check_dds_dxt10_format_image_info(__LINE__, format, DXGI_FORMAT_UNKNOWN, expected_hr, FALSE) + +static void test_legacy_dds_header_image_info(void) +{ + struct expected + { + HRESULT hr; + uint32_t width; + uint32_t height; + uint32_t depth; + uint32_t array_size; + uint32_t mip_levels; + uint32_t misc_flags; + DXGI_FORMAT format; + D3D11_RESOURCE_DIMENSION resource_dimension; + }; + static const struct + { + uint32_t flags; + uint32_t width; + uint32_t height; + uint32_t depth; + uint32_t row_pitch; + uint32_t mip_levels; + uint32_t caps; + uint32_t caps2; + uint32_t pixel_data_size; + struct expected expected; + BOOL todo_hr; + } tests[] = { - ok_(__FILE__, line)(info.Format == expected_format, "Unexpected format %#x, expected %#x\n", - info.Format, expected_format); + /* + * Only DDS header size is validated on d3dx11, unlike d3dx9 where image pixel size + * is as well. + */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT), 4, 4, 1, (4 * 4), 3, 0, 0, 0, + { S_OK, 4, 4, 1, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, }, + }, + /* Depth value set to 4, but no caps bits are set. Depth is ignored. */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT), 4, 4, 4, (4 * 4), 3, 0, 0, 292, + { S_OK, 4, 4, 1, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, }, + }, + /* The volume texture caps2 field is ignored. */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT), 4, 4, 4, (4 * 4), 3, + (DDS_CAPS_TEXTURE | DDS_CAPS_COMPLEX), DDS_CAPS2_VOLUME, 292, + { S_OK, 4, 4, 1, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, } + }, + /* + * The DDS_DEPTH flag is the only thing checked to determine if a DDS + * file represents a 3D texture. + */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT | DDS_DEPTH), 4, 4, 4, (4 * 4), 3, 0, 0, 292, + { S_OK, 4, 4, 4, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, } + }, + /* Even if the depth field is set to 0, it's still a 3D texture. */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT | DDS_DEPTH), 4, 4, 0, (4 * 4), 3, 0, 0, 292, + { S_OK, 4, 4, 1, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, } + }, + /* + * 5. + * The DDS_DEPTH flag overrides cubemap caps. + */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT | DDS_DEPTH), 4, 4, 4, (4 * 4), 3, + (DDS_CAPS_TEXTURE | DDS_CAPS_COMPLEX), (DDS_CAPS2_CUBEMAP | DDS_CAPS2_CUBEMAP_ALL_FACES), 292, + { S_OK, 4, 4, 4, 1, 3, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, } + }, + /* Cubemap where width field does not equal height. */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT), 4, 5, 1, (4 * 4), 1, + (DDS_CAPS_TEXTURE | DDS_CAPS_COMPLEX), (DDS_CAPS2_CUBEMAP | DDS_CAPS2_CUBEMAP_ALL_FACES), (80 * 6), + { + S_OK, 4, 5, 1, 6, 1, D3D11_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_R8G8B8A8_UNORM, + D3D11_RESOURCE_DIMENSION_TEXTURE2D, + } + }, + /* Partial cubemaps are not supported. */ + { + (DDS_CAPS | DDS_WIDTH | DDS_HEIGHT | DDS_PIXELFORMAT), 4, 4, 1, (4 * 4), 1, + (DDS_CAPS_TEXTURE | DDS_CAPS_COMPLEX), (DDS_CAPS2_CUBEMAP | DDS_CAPS2_CUBEMAP_POSITIVEX), (64 * 6), + { E_FAIL, } + }, + }; + D3DX11_IMAGE_INFO info; + unsigned int i; + struct + { + DWORD magic; + struct dds_header header; + } dds; + HRESULT hr; + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + const uint32_t file_size = sizeof(dds) + tests[i].pixel_data_size; + + winetest_push_context("Test %u", i); + + dds.magic = MAKEFOURCC('D','D','S',' '); + fill_dds_header(&dds.header); + dds.header.flags = tests[i].flags; + dds.header.width = tests[i].width; + dds.header.height = tests[i].height; + dds.header.depth = tests[i].depth; + dds.header.pitch_or_linear_size = tests[i].row_pitch; + dds.header.miplevels = tests[i].mip_levels; + dds.header.caps = tests[i].caps; + dds.header.caps2 = tests[i].caps2; + + memset(&info, 0, sizeof(info)); + hr = D3DX11GetImageInfoFromMemory(&dds, file_size, NULL, &info, NULL); + todo_wine_if(tests[i].todo_hr) ok(hr == tests[i].expected.hr, "Got unexpected hr %#lx.\n", hr); + if (SUCCEEDED(hr) && SUCCEEDED(tests[i].expected.hr)) + check_image_info_values(&info, tests[i].expected.width, tests[i].expected.height, + tests[i].expected.depth, tests[i].expected.array_size, tests[i].expected.mip_levels, + tests[i].expected.misc_flags, tests[i].expected.format, + tests[i].expected.resource_dimension, D3DX11_IFF_DDS, FALSE); + + winetest_pop_context(); } + + /* + * Image size (e.g, the size of the pixels) isn't validated, but header + * size is. + */ + dds.magic = MAKEFOURCC('D','D','S',' '); + fill_dds_header(&dds.header); + + hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds) - 1, NULL, &info, NULL); + ok(hr == E_FAIL, "Unexpected hr %#lx.\n", hr); + + hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds), NULL, &info, NULL); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); }
-static void test_D3DX11GetImageInfoFromMemory(void) +static void test_dxt10_dds_header_image_info(void) { + struct expected + { + HRESULT hr; + uint32_t width; + uint32_t height; + uint32_t depth; + uint32_t array_size; + uint32_t mip_levels; + uint32_t misc_flags; + DXGI_FORMAT format; + D3D11_RESOURCE_DIMENSION resource_dimension; + }; + static const struct + { + uint32_t append_flags; + uint32_t width; + uint32_t height; + uint32_t depth; + uint32_t row_pitch; + uint32_t mip_levels; + uint32_t caps; + uint32_t caps2; + struct dds_header_dxt10 dxt10; + uint32_t pixel_data_size; + struct expected expected; + BOOL todo_hr; + BOOL todo_info; + } tests[] = + { + /* File size validation isn't done on d3dx11. */ + { + 0, 4, 4, 0, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, 1, 0, }, 0, + { S_OK, 4, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, }, + }, + /* + * Setting the misc_flags2 field to anything other than 0 results in + * E_FAIL. + */ + { + 0, 4, 4, 0, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, 1, 1, }, (4 * 4 * 4), + { E_FAIL } + }, + /* + * The misc_flags field isn't passed through directly, only the + * cube texture flag is (if it's set). + */ + { + 0, 4, 4, 0, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0xfffffffb, 1, 0, }, (4 * 4 * 4), + { S_OK, 4, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, } + }, + /* Resource dimension field of the header isn't validated. */ + { + 0, 4, 4, 0, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, 500, 0, 1, 0, }, (4 * 4 * 4), + { S_OK, 4, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, 500, }, .todo_hr = TRUE + }, + /* Depth value of 2, but D3D11_RESOURCE_DIMENSION_TEXTURE2D. */ + { + DDS_DEPTH, 4, 4, 2, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, 1, 0, }, (4 * 4 * 4 * 2), + { S_OK, 4, 4, 2, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, } + }, + /* + * 5. + * Depth field value is ignored if DDS_DEPTH isn't set. + */ + { + 0, 4, 4, 2, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, 1, 0, }, (4 * 4 * 4 * 2), + { S_OK, 4, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, }, + }, + /* + * 3D texture with an array size larger than 1. Technically there's no + * such thing as a 3D texture array, but it succeeds. + */ + { + DDS_DEPTH, 4, 4, 2, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, 0, 2, 0, }, (4 * 4 * 4 * 2 * 2), + { S_OK, 4, 4, 2, 2, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, } + }, + /* Cubemap caps are ignored for DXT10 files. */ + { + 0, 4, 4, 1, (4 * 4), 1, 0, DDS_CAPS2_CUBEMAP | DDS_CAPS2_CUBEMAP_ALL_FACES, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, 0, 1, 0, }, (4 * 4 * 4 * 6), + { S_OK, 4, 4, 1, 1, 1, 0, DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D } + }, + /* Array size value is multiplied by 6 for cubemap files. */ + { + 0, 4, 4, 1, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE2D, DDS_RESOURCE_MISC_TEXTURECUBE, 2, 0, }, + (4 * 4 * 4 * 12), + { + S_OK, 4, 4, 1, 12, 1, D3D11_RESOURCE_MISC_TEXTURECUBE, DXGI_FORMAT_R8G8B8A8_UNORM, + D3D11_RESOURCE_DIMENSION_TEXTURE2D + } + }, + /* Resource dimension is validated for cube textures. */ + { + 0, 4, 4, 1, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE3D, DDS_RESOURCE_MISC_TEXTURECUBE, 2, 0, }, + (4 * 4 * 4 * 12), { E_FAIL } + }, + /* + * 10. + * 1D Texture cube, invalid. + */ + { + 0, 4, 4, 1, (4 * 4), 1, 0, 0, + { DXGI_FORMAT_R8G8B8A8_UNORM, D3D11_RESOURCE_DIMENSION_TEXTURE1D, DDS_RESOURCE_MISC_TEXTURECUBE, 2, 0, }, + (4 * 4 * 4 * 12), { E_FAIL } + }, + }; D3DX11_IMAGE_INFO info; + unsigned int i; + struct + { + DWORD magic; + struct dds_header header; + struct dds_header_dxt10 dxt10; + } dds; HRESULT hr;
- if (!strcmp(winetest_platform, "wine")) + for (i = 0; i < ARRAY_SIZE(tests); ++i) { - skip("Skipping D3DX11GetImageInfoFromMemory() tests.\n"); - return; + const uint32_t file_size = sizeof(dds) + tests[i].pixel_data_size; + + winetest_push_context("Test %u", i); + + dds.magic = MAKEFOURCC('D','D','S',' '); + set_dxt10_dds_header(&dds.header, tests[i].append_flags, tests[i].width, tests[i].height, + tests[i].depth, tests[i].mip_levels, tests[i].row_pitch, tests[i].caps, + tests[i].caps2); + dds.dxt10 = tests[i].dxt10; + + memset(&info, 0, sizeof(info)); + hr = D3DX11GetImageInfoFromMemory(&dds, file_size, NULL, &info, NULL); + todo_wine_if(tests[i].todo_hr) ok(hr == tests[i].expected.hr, "Got unexpected hr %#lx.\n", hr); + if (SUCCEEDED(hr) && SUCCEEDED(tests[i].expected.hr)) + check_image_info_values(&info, tests[i].expected.width, tests[i].expected.height, + tests[i].expected.depth, tests[i].expected.array_size, tests[i].expected.mip_levels, + tests[i].expected.misc_flags, tests[i].expected.format, + tests[i].expected.resource_dimension, D3DX11_IFF_DDS, tests[i].todo_info); + + winetest_pop_context(); }
+ /* + * Image size (e.g, the size of the pixels) isn't validated, but header + * size is. + */ + dds.magic = MAKEFOURCC('D','D','S',' '); + set_dxt10_dds_header(&dds.header, tests[0].append_flags, tests[0].width, tests[0].height, + tests[0].depth, tests[0].mip_levels, tests[0].row_pitch, tests[0].caps, tests[0].caps2); + dds.dxt10 = tests[0].dxt10; + + hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds) - 1, NULL, &info, NULL); + ok(hr == E_FAIL, "Unexpected hr %#lx.\n", hr); + + hr = D3DX11GetImageInfoFromMemory(&dds, sizeof(dds), NULL, &info, NULL); + ok(hr == S_OK, "Unexpected hr %#lx.\n", hr); +} + +static void test_D3DX11GetImageInfoFromMemory(void) +{ + D3DX11_IMAGE_INFO info; + HRESULT hr; + hr = D3DX11GetImageInfoFromMemory(bmp_1bpp, sizeof(bmp_1bpp), NULL, &info, NULL); ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
@@ -941,6 +1463,49 @@ static void test_D3DX11GetImageInfoFromMemory(void) check_dds_pixel_format(DDS_PF_LUMINANCE, 0, 16, 0xffff, 0, 0, 0, DXGI_FORMAT_R16G16B16A16_UNORM); check_dds_pixel_format(DDS_PF_LUMINANCE | DDS_PF_ALPHA, 0, 16, 0x00ff, 0, 0, 0xff00, DXGI_FORMAT_R8G8B8A8_UNORM); check_dds_pixel_format(DDS_PF_LUMINANCE | DDS_PF_ALPHA, 0, 8, 0x0f, 0, 0, 0xf0, DXGI_FORMAT_R8G8B8A8_UNORM); + check_dds_pixel_format(DDS_PF_INDEXED, 0, 8, 0, 0, 0, 0, DXGI_FORMAT_R8G8B8A8_UNORM); + check_dds_pixel_format(DDS_PF_INDEXED | DDS_PF_ALPHA, 0, 16, 0, 0, 0, 0xff00, DXGI_FORMAT_R8G8B8A8_UNORM); + check_dds_pixel_format(DDS_PF_FOURCC, 0x24, 0, 0, 0, 0, 0, DXGI_FORMAT_R16G16B16A16_UNORM); /* D3DFMT_A16B16G16R16 */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x6e, 0, 0, 0, 0, 0, DXGI_FORMAT_R16G16B16A16_SNORM); /* D3DFMT_Q16W16V16U16 */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x6f, 0, 0, 0, 0, 0, DXGI_FORMAT_R16_FLOAT); /* D3DFMT_R16F */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x70, 0, 0, 0, 0, 0, DXGI_FORMAT_R16G16_FLOAT); /* D3DFMT_G16R16F */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x71, 0, 0, 0, 0, 0, DXGI_FORMAT_R16G16B16A16_FLOAT); /* D3DFMT_A16B16G16R16F */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x72, 0, 0, 0, 0, 0, DXGI_FORMAT_R32_FLOAT); /* D3DFMT_R32F */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x73, 0, 0, 0, 0, 0, DXGI_FORMAT_R32G32_FLOAT); /* D3DFMT_G32R32F */ + check_dds_pixel_format(DDS_PF_FOURCC, 0x74, 0, 0, 0, 0, 0, DXGI_FORMAT_R32G32B32A32_FLOAT); /* D3DFMT_A32B32G32R32F */ + + /* Test for DDS pixel formats that are valid on d3dx9, but not d3dx10. */ + check_dds_pixel_format_unsupported(DDS_PF_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0, E_FAIL); + check_dds_pixel_format_unsupported(DDS_PF_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0, E_FAIL); + /* Bumpmap formats aren't supported. */ + check_dds_pixel_format_unsupported(DDS_PF_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0, E_FAIL); + check_dds_pixel_format_unsupported(DDS_PF_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0, E_FAIL); + check_dds_pixel_format_unsupported(DDS_PF_BUMPDUDV, 0, 32, 0xff, 0xff00, 0x00ff0000, 0xff000000, E_FAIL); + check_dds_pixel_format_unsupported(DDS_PF_BUMPLUMINANCE, 0, 32, 0x0000ff, 0x00ff00, 0xff0000, 0, E_FAIL); + + /* Newer fourCC formats. */ + check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC4_UNORM); + check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC5_UNORM); + check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC4_SNORM); + check_dds_pixel_format(DDS_PF_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0, DXGI_FORMAT_BC5_SNORM); + + check_dds_dxt10_format_unsupported(DXGI_FORMAT_B5G6R5_UNORM, E_FAIL); + check_dds_dxt10_format_unsupported(DXGI_FORMAT_B5G5R5A1_UNORM, E_FAIL); + check_dds_dxt10_format_unsupported(DXGI_FORMAT_B4G4R4A4_UNORM, E_FAIL); + + /* + * These formats should map 1:1 from the DXT10 header, unlike legacy DDS + * file equivalents. + */ + check_dds_dxt10_format(DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_R8_UNORM, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_R16_UNORM, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_R8G8_UNORM, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_B8G8R8X8_UNORM, DXGI_FORMAT_B8G8R8X8_UNORM, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, FALSE); + /* Formats unsupported on d3dx10, but now supported on d3dx11. */ + check_dds_dxt10_format(DXGI_FORMAT_BC6H_UF16, DXGI_FORMAT_BC6H_UF16, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_BC6H_SF16, FALSE); + check_dds_dxt10_format(DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM, FALSE); }
START_TEST(d3dx11) @@ -949,5 +1514,14 @@ START_TEST(d3dx11) test_D3DX11CreateAsyncFileLoader(); test_D3DX11CreateAsyncResourceLoader(); test_D3DX11CompileFromFile(); - test_D3DX11GetImageInfoFromMemory(); + if (!strcmp(winetest_platform, "wine")) + { + skip("Skipping D3DX11GetImageInfoFromMemory() tests.\n"); + } + else + { + test_D3DX11GetImageInfoFromMemory(); + test_legacy_dds_header_image_info(); + test_dxt10_dds_header_image_info(); + } }
From: Connor McAdams cmcadams@codeweavers.com
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50210 Signed-off-by: Connor McAdams cmcadams@codeweavers.com --- dlls/d3dx11_43/Makefile.in | 5 +- dlls/d3dx11_43/d3dx11_43_main.c | 9 -- dlls/d3dx11_43/dxhelpers.h | 21 +++ dlls/d3dx11_43/tests/d3dx11.c | 21 +-- dlls/d3dx11_43/texture.c | 243 ++++++++++++++++++++++++++++++++ 5 files changed, 275 insertions(+), 24 deletions(-) create mode 100644 dlls/d3dx11_43/dxhelpers.h
diff --git a/dlls/d3dx11_43/Makefile.in b/dlls/d3dx11_43/Makefile.in index a44fafb1541..1491bd23fb4 100644 --- a/dlls/d3dx11_43/Makefile.in +++ b/dlls/d3dx11_43/Makefile.in @@ -1,12 +1,15 @@ EXTRADEFS = -DD3DX11_SDK_VERSION=43 MODULE = d3dx11_43.dll IMPORTLIB = d3dx11 -IMPORTS = d3dcompiler +IMPORTS = d3dcompiler gdi32 ole32 user32 +PARENTSRC = ../d3dx9_36 +DELAYIMPORTS = windowscodecs
EXTRADLLFLAGS = -Wb,--prefer-native
SOURCES = \ async.c \ + d3dx_helpers.c \ d3dx11_43_main.c \ texture.c \ version.rc diff --git a/dlls/d3dx11_43/d3dx11_43_main.c b/dlls/d3dx11_43/d3dx11_43_main.c index 5dad027864f..00c1db35e42 100644 --- a/dlls/d3dx11_43/d3dx11_43_main.c +++ b/dlls/d3dx11_43/d3dx11_43_main.c @@ -66,12 +66,3 @@ HRESULT WINAPI D3DX11GetImageInfoFromFileW(const WCHAR *filename, ID3DX11ThreadP
return E_NOTIMPL; } - -HRESULT WINAPI D3DX11GetImageInfoFromMemory(const void *src_data, SIZE_T src_data_size, ID3DX11ThreadPump *pump, - D3DX11_IMAGE_INFO *img_info, HRESULT *hresult) -{ - FIXME("src_data %p, src_data_size %Iu, pump %p, img_info %p, hresult %p stub!\n", - src_data, src_data_size, pump, img_info, hresult); - - return E_NOTIMPL; -} diff --git a/dlls/d3dx11_43/dxhelpers.h b/dlls/d3dx11_43/dxhelpers.h new file mode 100644 index 00000000000..5be2ac93944 --- /dev/null +++ b/dlls/d3dx11_43/dxhelpers.h @@ -0,0 +1,21 @@ +/* + * Copyright 2025 Connor McAdams for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "d3dx_helpers.h" + +HRESULT get_image_info(const void *data, SIZE_T size, D3DX11_IMAGE_INFO *img_info); diff --git a/dlls/d3dx11_43/tests/d3dx11.c b/dlls/d3dx11_43/tests/d3dx11.c index ac310d2a947..5e2d28824c3 100644 --- a/dlls/d3dx11_43/tests/d3dx11.c +++ b/dlls/d3dx11_43/tests/d3dx11.c @@ -1313,7 +1313,7 @@ static void test_D3DX11GetImageInfoFromMemory(void) ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr);
hr = D3DX11GetImageInfoFromMemory(bmp_1bpp, sizeof(bmp_1bpp) - 1, NULL, &info, NULL); - ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr); + todo_wine ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr);
hr = D3DX11GetImageInfoFromMemory(bmp_1bpp + 1, sizeof(bmp_1bpp) - 1, NULL, &info, NULL); ok(hr == E_FAIL, "Got unexpected hr %#lx.\n", hr); @@ -1503,9 +1503,9 @@ static void test_D3DX11GetImageInfoFromMemory(void) check_dds_dxt10_format(DXGI_FORMAT_B8G8R8X8_UNORM, DXGI_FORMAT_B8G8R8X8_UNORM, FALSE); check_dds_dxt10_format(DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT_B8G8R8A8_UNORM, FALSE); /* Formats unsupported on d3dx10, but now supported on d3dx11. */ - check_dds_dxt10_format(DXGI_FORMAT_BC6H_UF16, DXGI_FORMAT_BC6H_UF16, FALSE); - check_dds_dxt10_format(DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_BC6H_SF16, FALSE); - check_dds_dxt10_format(DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM, FALSE); + todo_wine check_dds_dxt10_format(DXGI_FORMAT_BC6H_UF16, DXGI_FORMAT_BC6H_UF16, FALSE); + todo_wine check_dds_dxt10_format(DXGI_FORMAT_BC6H_SF16, DXGI_FORMAT_BC6H_SF16, FALSE); + todo_wine check_dds_dxt10_format(DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM, FALSE); }
START_TEST(d3dx11) @@ -1514,14 +1514,7 @@ START_TEST(d3dx11) test_D3DX11CreateAsyncFileLoader(); test_D3DX11CreateAsyncResourceLoader(); test_D3DX11CompileFromFile(); - if (!strcmp(winetest_platform, "wine")) - { - skip("Skipping D3DX11GetImageInfoFromMemory() tests.\n"); - } - else - { - test_D3DX11GetImageInfoFromMemory(); - test_legacy_dds_header_image_info(); - test_dxt10_dds_header_image_info(); - } + test_D3DX11GetImageInfoFromMemory(); + test_legacy_dds_header_image_info(); + test_dxt10_dds_header_image_info(); } diff --git a/dlls/d3dx11_43/texture.c b/dlls/d3dx11_43/texture.c index fe7ab8549d0..cbf3b630f58 100644 --- a/dlls/d3dx11_43/texture.c +++ b/dlls/d3dx11_43/texture.c @@ -18,11 +18,235 @@
#include "d3dx11.h" #include "d3dcompiler.h" +#include "dxhelpers.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
+/* + * These are mappings from legacy DDS header formats to DXGI formats. Some + * don't map to a DXGI_FORMAT at all, and some only map to the default format. + */ +static DXGI_FORMAT dxgi_format_from_legacy_dds_d3dx_pixel_format_id(enum d3dx_pixel_format_id format) +{ + switch (format) + { + /* + * Some of these formats do have DXGI_FORMAT equivalents, but get + * mapped to DXGI_FORMAT_R8G8B8A8_UNORM instead. + */ + case D3DX_PIXEL_FORMAT_P8_UINT: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B8G8R8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B5G6R5_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B2G3R3_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_L8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_L4A4_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_L8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + + /* B10G10R10A2 doesn't exist in DXGI, both map to R10G10B10A2. */ + case D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM: + case D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM: return DXGI_FORMAT_R10G10B10A2_UNORM; + + case D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM: return DXGI_FORMAT_R16G16B16A16_SNORM; + case D3DX_PIXEL_FORMAT_L16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM; + case D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM; + case D3DX_PIXEL_FORMAT_R16G16_UNORM: return DXGI_FORMAT_R16G16_UNORM; + case D3DX_PIXEL_FORMAT_A8_UNORM: return DXGI_FORMAT_A8_UNORM; + case D3DX_PIXEL_FORMAT_R16_FLOAT: return DXGI_FORMAT_R16_FLOAT; + case D3DX_PIXEL_FORMAT_R16G16_FLOAT: return DXGI_FORMAT_R16G16_FLOAT; + case D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT; + case D3DX_PIXEL_FORMAT_R32_FLOAT: return DXGI_FORMAT_R32_FLOAT; + case D3DX_PIXEL_FORMAT_R32G32_FLOAT: return DXGI_FORMAT_R32G32_FLOAT; + case D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT: return DXGI_FORMAT_R32G32B32A32_FLOAT; + case D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM: return DXGI_FORMAT_G8R8_G8B8_UNORM; + case D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM: return DXGI_FORMAT_R8G8_B8G8_UNORM; + + case D3DX_PIXEL_FORMAT_DXT1_UNORM: return DXGI_FORMAT_BC1_UNORM; + case D3DX_PIXEL_FORMAT_DXT2_UNORM: return DXGI_FORMAT_BC2_UNORM; + case D3DX_PIXEL_FORMAT_DXT3_UNORM: return DXGI_FORMAT_BC2_UNORM; + case D3DX_PIXEL_FORMAT_DXT4_UNORM: return DXGI_FORMAT_BC3_UNORM; + case D3DX_PIXEL_FORMAT_DXT5_UNORM: return DXGI_FORMAT_BC3_UNORM; + case D3DX_PIXEL_FORMAT_BC4_UNORM: return DXGI_FORMAT_BC4_UNORM; + case D3DX_PIXEL_FORMAT_BC4_SNORM: return DXGI_FORMAT_BC4_SNORM; + case D3DX_PIXEL_FORMAT_BC5_UNORM: return DXGI_FORMAT_BC5_UNORM; + case D3DX_PIXEL_FORMAT_BC5_SNORM: return DXGI_FORMAT_BC5_SNORM; + + /* These formats are known and explicitly unsupported on d3dx10+. */ + case D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM: + case D3DX_PIXEL_FORMAT_U8V8_SNORM: + case D3DX_PIXEL_FORMAT_U16V16_SNORM: + case D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM: + case D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM: + case D3DX_PIXEL_FORMAT_UYVY: + case D3DX_PIXEL_FORMAT_YUY2: + return DXGI_FORMAT_UNKNOWN; + + default: + FIXME("Unknown d3dx_pixel_format_id %#x.\n", format); + return DXGI_FORMAT_UNKNOWN; + } +} + +static DXGI_FORMAT dxgi_format_from_d3dx_pixel_format_id(enum d3dx_pixel_format_id format) +{ + switch (format) + { + case D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM; + case D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM; + case D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM: return DXGI_FORMAT_B8G8R8X8_UNORM; + case D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM: return DXGI_FORMAT_R10G10B10A2_UNORM; + case D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM: return DXGI_FORMAT_R16G16B16A16_UNORM; + case D3DX_PIXEL_FORMAT_R8_UNORM: return DXGI_FORMAT_R8_UNORM; + case D3DX_PIXEL_FORMAT_R8G8_UNORM: return DXGI_FORMAT_R8G8_UNORM; + case D3DX_PIXEL_FORMAT_R16_UNORM: return DXGI_FORMAT_R16_UNORM; + case D3DX_PIXEL_FORMAT_R16G16_UNORM: return DXGI_FORMAT_R16G16_UNORM; + case D3DX_PIXEL_FORMAT_A8_UNORM: return DXGI_FORMAT_A8_UNORM; + case D3DX_PIXEL_FORMAT_R16_FLOAT: return DXGI_FORMAT_R16_FLOAT; + case D3DX_PIXEL_FORMAT_R16G16_FLOAT: return DXGI_FORMAT_R16G16_FLOAT; + case D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT; + case D3DX_PIXEL_FORMAT_R32_FLOAT: return DXGI_FORMAT_R32_FLOAT; + case D3DX_PIXEL_FORMAT_R32G32_FLOAT: return DXGI_FORMAT_R32G32_FLOAT; + case D3DX_PIXEL_FORMAT_R32G32B32_FLOAT: return DXGI_FORMAT_R32G32B32_FLOAT; + case D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT: return DXGI_FORMAT_R32G32B32A32_FLOAT; + case D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM: return DXGI_FORMAT_G8R8_G8B8_UNORM; + case D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM: return DXGI_FORMAT_R8G8_B8G8_UNORM; + case D3DX_PIXEL_FORMAT_BC1_UNORM: return DXGI_FORMAT_BC1_UNORM; + case D3DX_PIXEL_FORMAT_BC2_UNORM: return DXGI_FORMAT_BC2_UNORM; + case D3DX_PIXEL_FORMAT_BC3_UNORM: return DXGI_FORMAT_BC3_UNORM; + case D3DX_PIXEL_FORMAT_BC4_UNORM: return DXGI_FORMAT_BC4_UNORM; + case D3DX_PIXEL_FORMAT_BC4_SNORM: return DXGI_FORMAT_BC4_SNORM; + case D3DX_PIXEL_FORMAT_BC5_UNORM: return DXGI_FORMAT_BC5_UNORM; + case D3DX_PIXEL_FORMAT_BC5_SNORM: return DXGI_FORMAT_BC5_SNORM; + case D3DX_PIXEL_FORMAT_R16G16B16A16_SNORM: return DXGI_FORMAT_R16G16B16A16_SNORM; + case D3DX_PIXEL_FORMAT_R8G8B8A8_SNORM: return DXGI_FORMAT_R8G8B8A8_SNORM; + case D3DX_PIXEL_FORMAT_R8G8_SNORM: return DXGI_FORMAT_R8G8_SNORM; + case D3DX_PIXEL_FORMAT_R16G16_SNORM: return DXGI_FORMAT_R16G16_SNORM; + + /* + * These have DXGI_FORMAT equivalents, but are explicitly unsupported on + * d3dx10+. + */ + case D3DX_PIXEL_FORMAT_B5G6R5_UNORM: + case D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM: + case D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM: + return DXGI_FORMAT_UNKNOWN; + + default: + FIXME("Unhandled d3dx_pixel_format_id %#x.\n", format); + return DXGI_FORMAT_UNKNOWN; + } +} + +static D3DX11_IMAGE_FILE_FORMAT d3dx11_image_file_format_from_d3dx_image_file_format(enum d3dx_image_file_format iff) +{ + switch (iff) + { + case D3DX_IMAGE_FILE_FORMAT_BMP: return D3DX11_IFF_BMP; + case D3DX_IMAGE_FILE_FORMAT_JPG: return D3DX11_IFF_JPG; + case D3DX_IMAGE_FILE_FORMAT_PNG: return D3DX11_IFF_PNG; + case D3DX_IMAGE_FILE_FORMAT_DDS: return D3DX11_IFF_DDS; + case D3DX_IMAGE_FILE_FORMAT_TIFF: return D3DX11_IFF_TIFF; + case D3DX_IMAGE_FILE_FORMAT_GIF: return D3DX11_IFF_GIF; + case D3DX_IMAGE_FILE_FORMAT_WMP: return D3DX11_IFF_WMP; + case D3DX_IMAGE_FILE_FORMAT_DDS_DXT10: return D3DX11_IFF_DDS; + default: + FIXME("No D3DX11_IMAGE_FILE_FORMAT for d3dx_image_file_format %d.\n", iff); + return D3DX11_IFF_FORCE_DWORD; + } +} + +static HRESULT d3dx11_image_info_from_d3dx_image(D3DX11_IMAGE_INFO *info, struct d3dx_image *image) +{ + D3DX11_IMAGE_FILE_FORMAT iff = d3dx11_image_file_format_from_d3dx_image_file_format(image->image_file_format); + DXGI_FORMAT format; + + memset(info, 0, sizeof(*info)); + switch (image->image_file_format) + { + case D3DX_IMAGE_FILE_FORMAT_DDS_DXT10: + format = dxgi_format_from_d3dx_pixel_format_id(image->format); + break; + + case D3DX_IMAGE_FILE_FORMAT_DDS: + format = dxgi_format_from_legacy_dds_d3dx_pixel_format_id(image->format); + break; + + default: + if (iff == D3DX11_IFF_FORCE_DWORD) + return E_FAIL; + + /* All other image file formats use the default format. */ + format = DXGI_FORMAT_R8G8B8A8_UNORM; + break; + } + + if (format == DXGI_FORMAT_UNKNOWN) + { + WARN("Tried to load file with unsupported pixel format %#x.\n", image->format); + return E_FAIL; + } + + switch (image->resource_type) + { + case D3DX_RESOURCE_TYPE_TEXTURE_2D: + info->ResourceDimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D; + break; + + case D3DX_RESOURCE_TYPE_CUBE_TEXTURE: + info->ResourceDimension = D3D11_RESOURCE_DIMENSION_TEXTURE2D; + info->MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE; + break; + + case D3DX_RESOURCE_TYPE_TEXTURE_3D: + info->ResourceDimension = D3D11_RESOURCE_DIMENSION_TEXTURE3D; + break; + + default: + ERR("Unhandled resource type %d.\n", image->resource_type); + return E_FAIL; + } + + info->ImageFileFormat = iff; + info->Width = image->size.width; + info->Height = image->size.height; + info->Depth = image->size.depth; + info->ArraySize = image->layer_count; + info->MipLevels = image->mip_levels; + info->Format = format; + return S_OK; +} + +HRESULT get_image_info(const void *data, SIZE_T size, D3DX11_IMAGE_INFO *img_info) +{ + struct d3dx_image image; + HRESULT hr; + + if (!data || !size) + return E_FAIL; + + hr = d3dx_image_init(data, size, &image, 0, D3DX_IMAGE_INFO_ONLY | D3DX_IMAGE_SUPPORT_DXT10); + if (SUCCEEDED(hr)) + hr = d3dx11_image_info_from_d3dx_image(img_info, &image); + + if (hr != S_OK) + { + WARN("Invalid or unsupported image file.\n"); + return E_FAIL; + } + return S_OK; +} + HRESULT WINAPI D3DX11CreateShaderResourceViewFromMemory(ID3D11Device *device, const void *data, SIZE_T data_size, D3DX11_IMAGE_LOAD_INFO *load_info, ID3DX11ThreadPump *pump, ID3D11ShaderResourceView **view, HRESULT *hresult) @@ -98,3 +322,22 @@ HRESULT WINAPI D3DX11LoadTextureFromTexture(ID3D11DeviceContext *context, ID3D11
return E_NOTIMPL; } + +HRESULT WINAPI D3DX11GetImageInfoFromMemory(const void *src_data, SIZE_T src_data_size, ID3DX11ThreadPump *pump, + D3DX11_IMAGE_INFO *img_info, HRESULT *hresult) +{ + HRESULT hr; + + TRACE("src_data %p, src_data_size %Iu, pump %p, img_info %p, hresult %p.\n", src_data, src_data_size, pump, + img_info, hresult); + + if (!src_data) + return E_FAIL; + if (pump) + FIXME("D3DX11 thread pump is currently unimplemented.\n"); + + hr = get_image_info(src_data, src_data_size, img_info); + if (hresult) + *hresult = hr; + return hr; +}
This merge request was approved by Matteo Bruni.
WRT patch 3, I guess there are no significant differences from the d3dx10 tests? At a quick glance I didn't notice anything aside from a bunch of s/d3d10/d3d11/ and BC6, BC7 formats.
On Thu Sep 11 12:27:23 2025 +0000, Matteo Bruni wrote:
WRT patch 3, I guess there are no significant differences from the d3dx10 tests? At a quick glance I didn't notice anything aside from a bunch of s/d3d10/d3d11/ and BC6, BC7 formats.
Yep. I kind of expected the behavior to be a bit different, but aside from the support of newer formats everything seems to behave the same, which makes things a lot easier. :)
-
Connor McAdams -
Connor McAdams (＠cmcadams)
-
Matteo Bruni (＠Mystral)