wine-devel March 2019

wine-devel@winehq.org

76 participants
1010 discussions

[PATCH] kernel32: Add DECLSPEC_HOTPATCH to VirtualAllocEx().
by Zhiyi Zhang 24 Mar '19

24 Mar '19

This fix Tom Clancy's The Devision uplay version startup crash. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/kernel32/virtual.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernel32/virtual.c b/dlls/kernel32/virtual.c index 7f0a562db4..42da7f0d8c 100644 --- a/dlls/kernel32/virtual.c +++ b/dlls/kernel32/virtual.c @@ -86,7 +86,7 @@ LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAlloc( void *addr, SIZE_T size, DWORD typ * Success: Base address of allocated region of pages. * Failure: NULL. */ -LPVOID WINAPI VirtualAllocEx( HANDLE hProcess, LPVOID addr, SIZE_T size, +LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocEx( HANDLE hProcess, LPVOID addr, SIZE_T size, DWORD type, DWORD protect ) { LPVOID ret = addr; -- 2.20.1

1 0

[PATCH] include: Avoid type redefinition.
by Zhiyi Zhang 24 Mar '19

24 Mar '19

UUID_DEFINED doesn't exist on Windows but it's needed by wine because of the usage of some wine private headers. And some older compilers can't handle the redefinition. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46892 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- include/ddk/ntddk.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/ddk/ntddk.h b/include/ddk/ntddk.h index fb8cacc188..719ba67c6a 100644 --- a/include/ddk/ntddk.h +++ b/include/ddk/ntddk.h @@ -202,7 +202,11 @@ typedef NTSTATUS (WINAPI *PIO_QUERY_DEVICE_ROUTINE)(PVOID,PUNICODE_STRING,INTERF PKEY_VALUE_FULL_INFORMATION*,CONFIGURATION_TYPE,ULONG,PKEY_VALUE_FULL_INFORMATION*); typedef void (NTAPI EXPAND_STACK_CALLOUT)(void*); typedef EXPAND_STACK_CALLOUT *PEXPAND_STACK_CALLOUT; + +#ifndef UUID_DEFINED +#define UUID_DEFINED typedef GUID UUID; +#endif NTSTATUS WINAPI ExUuidCreate(UUID*); NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE,PULONG,PCONFIGURATION_TYPE,PULONG, -- 2.20.1

1 0

[PATCH 1/2] imagehlp/tests: Add tests for ImageLoad, ImageUnload, GetImageUnusedHeaderBytes.
by Vijay Kiran Kamuju 23 Mar '19

23 Mar '19

marked new tests as todo_wine From: Mark Jansen <learn0more(a)gmail.com> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/imagehlp/tests/image.c | 95 +++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/dlls/imagehlp/tests/image.c b/dlls/imagehlp/tests/image.c index c0a26c39dc..dd2d60b626 100644 --- a/dlls/imagehlp/tests/image.c +++ b/dlls/imagehlp/tests/image.c @@ -33,6 +33,10 @@ static HMODULE hImageHlp; static BOOL (WINAPI *pImageGetDigestStream)(HANDLE, DWORD, DIGEST_FUNCTION, DIGEST_HANDLE); static BOOL (WINAPI *pBindImageEx)(DWORD Flags, const char *ImageName, const char *DllPath, const char *SymbolPath, PIMAGEHLP_STATUS_ROUTINE StatusRoutine); +static DWORD (WINAPI* pGetImageUnusedHeaderBytes)(PLOADED_IMAGE, LPDWORD); +static PLOADED_IMAGE (WINAPI* pImageLoad)(PCSTR, PCSTR); +static BOOL (WINAPI* pImageUnload)(PLOADED_IMAGE); + /* minimal PE file image */ #define VA_START 0x400000 @@ -425,6 +429,93 @@ static void test_bind_image_ex(void) DeleteFileA(temp_file); } +static void test_image_load(void) +{ + char temp_file[MAX_PATH]; + PLOADED_IMAGE img; + DWORD ret, count; + HANDLE file; + + if (!pImageLoad || !pImageUnload) + { + win_skip("ImageLoad or ImageUnload function is not available\n"); + return; + } + if (!pGetImageUnusedHeaderBytes) + { + win_skip("GetImageUnusedHeaderBytes function is not available\n"); + return; + } + + file = create_temp_file(temp_file); + if (file == INVALID_HANDLE_VALUE) + { + skip("couldn't create temp file\n"); + return; + } + + WriteFile(file, &bin, sizeof(bin), &count, NULL); + CloseHandle(file); + + img = pImageLoad(temp_file, NULL); + ok(img != NULL, "ImageLoad unexpectedly failed\n"); + + if (img) + { + todo_wine ok(!strcmp(img->ModuleName, temp_file), + "unexpected ModuleName, got %s instead of %s\n", img->ModuleName, temp_file); + todo_wine ok(img->MappedAddress != NULL, "MappedAddress != NULL\n"); + if (img->MappedAddress) + { + ok(!memcmp(img->MappedAddress, &bin.dos_header, sizeof(bin.dos_header)), + "MappedAddress doesn't point to IMAGE_DOS_HEADER\n"); + } + ok(img->FileHeader != NULL, "FileHeader != NULL\n"); + if (img->FileHeader) + { + todo_wine ok(!memcmp(img->FileHeader, &bin.nt_headers, sizeof(bin.nt_headers)), + "FileHeader doesn't point to IMAGE_NT_HEADERS32\n"); + } + todo_wine ok(img->NumberOfSections == 3, + "unexpected NumberOfSections, got %d instead of 3\n", img->NumberOfSections); + if (img->NumberOfSections >= 3) + { + ok(!strcmp((const char *)img->Sections[0].Name, ".text"), + "unexpected name for section 0, expected .text, got %s\n", + (const char *)img->Sections[0].Name); + ok(!strcmp((const char *)img->Sections[1].Name, ".bss"), + "unexpected name for section 1, expected .bss, got %s\n", + (const char *)img->Sections[1].Name); + ok(!strcmp((const char *)img->Sections[2].Name, ".idata"), + "unexpected name for section 2, expected .idata, got %s\n", + (const char *)img->Sections[2].Name); + } + todo_wine ok(img->Characteristics == 0x102, + "unexpected Characteristics, got 0x%x instead of 0x102\n", img->Characteristics); + ok(img->fSystemImage == 0, + "unexpected fSystemImage, got %d instead of 0\n", img->fSystemImage); + ok(img->fDOSImage == 0, + "unexpected fDOSImage, got %d instead of 0\n", img->fDOSImage); + todo_wine ok(img->fReadOnly == 1 || broken(!img->fReadOnly) /* <= WinXP */, + "unexpected fReadOnly, got %d instead of 1\n", img->fReadOnly); + todo_wine ok(img->Version == 1 || broken(!img->Version) /* <= WinXP */, + "unexpected Version, got %d instead of 1\n", img->Version); + todo_wine ok(img->SizeOfImage == 0x600, + "unexpected SizeOfImage, got 0x%x instead of 0x600\n", img->SizeOfImage); + + count = 0xdeadbeef; + ret = pGetImageUnusedHeaderBytes(img, &count); + todo_wine + ok(ret == 448, "GetImageUnusedHeaderBytes returned %u instead of 448\n", ret); + todo_wine + ok(count == 64, "unexpected size for unused header bytes, got %u instead of 64\n", count); + + pImageUnload(img); + } + + DeleteFileA(temp_file); +} + START_TEST(image) { hImageHlp = LoadLibraryA("imagehlp.dll"); @@ -437,9 +528,13 @@ START_TEST(image) pImageGetDigestStream = (void *) GetProcAddress(hImageHlp, "ImageGetDigestStream"); pBindImageEx = (void *) GetProcAddress(hImageHlp, "BindImageEx"); + pGetImageUnusedHeaderBytes = (void *) GetProcAddress(hImageHlp, "GetImageUnusedHeaderBytes"); + pImageLoad = (void *) GetProcAddress(hImageHlp, "ImageLoad"); + pImageUnload = (void *) GetProcAddress(hImageHlp, "ImageUnload"); test_get_digest_stream(); test_bind_image_ex(); + test_image_load(); FreeLibrary(hImageHlp); } -- 2.21.0

2 2

[PATCH] kernel32: Allow empty profile section and key name strings.
by Vijay Kiran Kamuju 23 Mar '19

23 Mar '19

Consider "" a normal section, and fix calculation for zero length section name string and key name string. Changes by Sebastian Lackner <sebastian(a)fds-team.de>: * Several style improvements, remove todo_wine from tests Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=8036 Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=18099 From: Claudio Fontana <claudio.fontana(a)linaro.org> Signed-off-by: Claudio Fontana <claudio.fontana(a)gmail.com> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/kernel32/profile.c | 40 ++++++++++++++--------------------- dlls/kernel32/tests/profile.c | 2 -- 2 files changed, 16 insertions(+), 26 deletions(-) diff --git a/dlls/kernel32/profile.c b/dlls/kernel32/profile.c index 65a8f28768..027693e5da 100644 --- a/dlls/kernel32/profile.c +++ b/dlls/kernel32/profile.c @@ -500,7 +500,7 @@ static BOOL PROFILE_DeleteSection( PROFILESECTION **section, LPCWSTR name ) { while (*section) { - if ((*section)->name[0] && !strcmpiW( (*section)->name, name )) + if (!strcmpiW( (*section)->name, name )) { PROFILESECTION *to_del = *section; *section = to_del->next; @@ -524,7 +524,7 @@ static BOOL PROFILE_DeleteKey( PROFILESECTION **section, { while (*section) { - if ((*section)->name[0] && !strcmpiW( (*section)->name, section_name )) + if (!strcmpiW( (*section)->name, section_name )) { PROFILEKEY **key = &(*section)->key; while (*key) @@ -556,7 +556,7 @@ static void PROFILE_DeleteAllKeys( LPCWSTR section_name) PROFILESECTION **section= &CurProfile->section; while (*section) { - if ((*section)->name[0] && !strcmpiW( (*section)->name, section_name )) + if (!strcmpiW( (*section)->name, section_name )) { PROFILEKEY **key = &(*section)->key; while (*key) @@ -582,31 +582,28 @@ static PROFILEKEY *PROFILE_Find( PROFILESECTION **section, LPCWSTR section_name, LPCWSTR key_name, BOOL create, BOOL create_always ) { LPCWSTR p; - int seclen, keylen; + int seclen = 0, keylen = 0; while (PROFILE_isspaceW(*section_name)) section_name++; if (*section_name) + { p = section_name + strlenW(section_name) - 1; - else - p = section_name; - - while ((p > section_name) && PROFILE_isspaceW(*p)) p--; - seclen = p - section_name + 1; + while ((p > section_name) && PROFILE_isspaceW(*p)) p--; + seclen = p - section_name + 1; + } while (PROFILE_isspaceW(*key_name)) key_name++; if (*key_name) + { p = key_name + strlenW(key_name) - 1; - else - p = key_name; - - while ((p > key_name) && PROFILE_isspaceW(*p)) p--; - keylen = p - key_name + 1; + while ((p > key_name) && PROFILE_isspaceW(*p)) p--; + keylen = p - key_name + 1; + } while (*section) { - if ( ((*section)->name[0]) - && (!(strncmpiW( (*section)->name, section_name, seclen ))) - && (((*section)->name)[seclen] == '\0') ) + if (!strncmpiW((*section)->name, section_name, seclen) && + ((*section)->name)[seclen] == '\0') { PROFILEKEY **key = &(*section)->key; @@ -873,7 +870,7 @@ static INT PROFILE_GetSection( PROFILESECTION *section, LPCWSTR section_name, while (section) { - if (section->name[0] && !strcmpiW( section->name, section_name )) + if (!strcmpiW( section->name, section_name )) { UINT oldlen = len; for (key = section->key; key; key = key->next) @@ -988,11 +985,6 @@ static INT PROFILE_GetString( LPCWSTR section, LPCWSTR key_name, if (!def_val) def_val = empty_strW; if (key_name) { - if (!key_name[0]) - { - PROFILE_CopyEntry(buffer, def_val, len, TRUE); - return strlenW(buffer); - } key = PROFILE_Find( &CurProfile->section, section, key_name, FALSE, FALSE); PROFILE_CopyEntry( buffer, (key && key->value) ? key->value : def_val, len, TRUE ); @@ -1002,7 +994,7 @@ static INT PROFILE_GetString( LPCWSTR section, LPCWSTR key_name, return strlenW( buffer ); } /* no "else" here ! */ - if (section && section[0]) + if (section) { INT ret = PROFILE_GetSection(CurProfile->section, section, buffer, len, FALSE); if (!buffer[0]) /* no luck -> def_val */ diff --git a/dlls/kernel32/tests/profile.c b/dlls/kernel32/tests/profile.c index c075e0a745..8a0089bb1b 100644 --- a/dlls/kernel32/tests/profile.c +++ b/dlls/kernel32/tests/profile.c @@ -153,9 +153,7 @@ static void test_profile_string(void) /* works only in unicode, ascii crashes */ ret=GetPrivateProfileStringW(sW, emptyW, emptyW, bufW, ARRAY_SIZE(bufW), TESTFILE2W); - todo_wine ok(ret == 10, "expected 10, got %u\n", ret); - todo_wine ok(!lstrcmpW(valnokeyW,bufW), "expected %s, got %s\n", wine_dbgstr_w(valnokeyW), wine_dbgstr_w(bufW) ); -- 2.21.0

2 1

[PATCH v2] d3dx9_36/tests: Add initial tests for dummy skininfo interface.
by Vijay Kiran Kamuju 23 Mar '19

23 Mar '19

Added todo_wine and some more tests for returned dummy skininfo interface From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/d3dx9_36/tests/mesh.c | 168 +++++++++++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+) diff --git a/dlls/d3dx9_36/tests/mesh.c b/dlls/d3dx9_36/tests/mesh.c index e36ee0adcd..d9008f3624 100644 --- a/dlls/d3dx9_36/tests/mesh.c +++ b/dlls/d3dx9_36/tests/mesh.c @@ -25,6 +25,9 @@ #include <limits.h> #include "wine/test.h" #include "d3dx9.h" +#include "initguid.h" +#include "rmxftmpl.h" +#include "rmxfguid.h" #ifndef NAN /* From wine/port.h */ @@ -2544,6 +2547,170 @@ static void D3DXLoadMeshTest(void) free_test_context(test_context); } +static ID3DXFileData *get_mesh_data(const char *memory, SIZE_T length) +{ + D3DXF_FILELOADMEMORY source; + ID3DXFileEnumObject *enumobj = NULL; + ID3DXFileData *filedata = NULL; + ID3DXFileData *ret = NULL; + ID3DXFile *d3dxfile = NULL; + SIZE_T i, nb_children; + HRESULT hr; + GUID guid; + + hr = D3DXFileCreate(&d3dxfile); + if (FAILED(hr)) return NULL; + + hr = d3dxfile->lpVtbl->RegisterTemplates(d3dxfile, D3DRM_XTEMPLATES, D3DRM_XTEMPLATE_BYTES); + if (FAILED(hr)) goto cleanup; + + source.lpMemory = (void *)memory; + source.dSize = length; + + hr = d3dxfile->lpVtbl->CreateEnumObject(d3dxfile, &source, D3DXF_FILELOAD_FROMMEMORY, &enumobj); + if (FAILED(hr)) goto cleanup; + + hr = enumobj->lpVtbl->GetChildren(enumobj, &nb_children); + if (FAILED(hr)) goto cleanup; + + for (i = 0; i < nb_children; i++) + { + hr = enumobj->lpVtbl->GetChild(enumobj, i, &filedata); + if (FAILED(hr)) goto cleanup; + + hr = filedata->lpVtbl->GetType(filedata, &guid); + if (SUCCEEDED(hr) && IsEqualGUID(&guid, &TID_D3DRMMesh)) + { + ret = filedata; + break; + } + else + filedata->lpVtbl->Release(filedata); + } + +cleanup: + if (enumobj) enumobj->lpVtbl->Release(enumobj); + if (d3dxfile) d3dxfile->lpVtbl->Release(d3dxfile); + + return ret; +} + +static void D3DXLoadSkinMeshFromXofTest(void) +{ + static const char simple_xfile[] = + "xof 0303txt 0032" + "Mesh {" + "3;" + "0.0; 0.0; 0.0;," + "0.0; 1.0; 0.0;," + "1.0; 1.0; 0.0;;" + "1;" + "3; 0, 1, 2;;" + "}"; + ID3DXBuffer *adjacency, *materials, *effects; + D3DPRESENT_PARAMETERS d3dpp; + IDirect3DDevice9 *device; + ID3DXFileData *filedata; + ID3DXSkinInfo *skininfo; + ID3DXMesh *mesh; + IDirect3D9 *d3d; + DWORD mat_count; + HRESULT hr; + HWND hwnd; + + if (!(hwnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0, + 640, 480, NULL, NULL, NULL, NULL))) + { + skip("Couldn't create application window\n"); + return; + } + + d3d = Direct3DCreate9(D3D_SDK_VERSION); + if (!d3d) + { + skip("Couldn't create IDirect3D9 object\n"); + DestroyWindow(hwnd); + return; + } + + ZeroMemory(&d3dpp, sizeof(d3dpp)); + d3dpp.Windowed = TRUE; + d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; + + hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &device); + IDirect3D9_Release(d3d); + if (FAILED(hr)) + { + skip("Failed to create IDirect3DDevice9 object %#x\n", hr); + DestroyWindow(hwnd); + return; + } + + filedata = get_mesh_data(simple_xfile, sizeof(simple_xfile) - 1); + ok(filedata != NULL, "Failed to load mesh data\n"); + + adjacency = materials = effects = NULL; + skininfo = NULL; + mesh = NULL; + + hr = D3DXLoadSkinMeshFromXof(filedata, 0, device, &adjacency, &materials, &effects, &mat_count, &skininfo, &mesh); + ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr); + todo_wine ok(skininfo != NULL, "Expected non-null skininfo\n"); + + if (skininfo) + { + DWORD dword_result; + float flt_result; + const char *string_result; + D3DXMATRIX *transform; + D3DVERTEXELEMENT9 declaration_out[MAX_FVF_DECL_SIZE]; + const D3DVERTEXELEMENT9 expect_declaration[] = + { + {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, + D3DDECL_END(), + }; + + hr = skininfo->lpVtbl->GetDeclaration(skininfo, declaration_out); + ok(hr == D3D_OK, "Expected D3D_OK, got %#x\n", hr); + if (SUCCEEDED(hr)) + compare_elements(declaration_out, expect_declaration, __LINE__, 0); + + dword_result = skininfo->lpVtbl->GetNumBones(skininfo); + ok(dword_result == 0, "Expected 0, got %u\n", dword_result); + + flt_result = skininfo->lpVtbl->GetMinBoneInfluence(skininfo); + ok(flt_result == 0.0f, "Expected 0.0, got %g\n", flt_result); + + string_result = skininfo->lpVtbl->GetBoneName(skininfo, 0); + ok(string_result == NULL, "Expected NULL, got %p\n", string_result); + + dword_result = skininfo->lpVtbl->GetFVF(skininfo); + ok(dword_result == 2, "Expected 2, got %u\n", dword_result); + + dword_result = skininfo->lpVtbl->GetNumBoneInfluences(skininfo, 0); + ok(dword_result == 0, "Expected 0, got %u\n", dword_result); + + dword_result = skininfo->lpVtbl->GetNumBoneInfluences(skininfo, 1); + ok(dword_result == 0, "Expected 0, got %u\n", dword_result); + + transform = skininfo->lpVtbl->GetBoneOffsetMatrix(skininfo, -1); + ok(transform == NULL, "Expected NULL, got %p\n", transform); + + transform = skininfo->lpVtbl->GetBoneOffsetMatrix(skininfo, 0); + ok(transform == NULL, "Expected NULL, got %p\n", transform); + } + + if (adjacency) adjacency->lpVtbl->Release(adjacency); + if (materials) materials->lpVtbl->Release(materials); + if (effects) effects->lpVtbl->Release(effects); + if (skininfo) skininfo->lpVtbl->Release(skininfo); + if (mesh) mesh->lpVtbl->Release(mesh); + + filedata->lpVtbl->Release(filedata); + IDirect3DDevice9_Release(device); + DestroyWindow(hwnd); +} + static BOOL compute_box(struct mesh *mesh, float width, float height, float depth) { unsigned int i, face; @@ -11201,6 +11368,7 @@ START_TEST(mesh) D3DXCreateMeshTest(); D3DXCreateMeshFVFTest(); D3DXLoadMeshTest(); + D3DXLoadSkinMeshFromXofTest(); D3DXCreateBoxTest(); D3DXCreatePolygonTest(); D3DXCreateSphereTest(); -- 2.21.0

1 0

[PATCH v2 2/2] urlmon/tests: Add FTP encoded url test
by Alistair Leslie-Hughes 23 Mar '19

23 Mar '19

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/urlmon/tests/Makefile.in | 2 +- dlls/urlmon/tests/url.c | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/dlls/urlmon/tests/Makefile.in b/dlls/urlmon/tests/Makefile.in index 2eef12919a..48afdc9f9b 100644 --- a/dlls/urlmon/tests/Makefile.in +++ b/dlls/urlmon/tests/Makefile.in @@ -1,5 +1,5 @@ TESTDLL = urlmon.dll -IMPORTS = urlmon wininet ole32 oleaut32 user32 advapi32 +IMPORTS = urlmon wininet ole32 oleaut32 user32 advapi32 shlwapi C_SRCS = \ generated.c \ diff --git a/dlls/urlmon/tests/url.c b/dlls/urlmon/tests/url.c index ada78c930b..0f2b14edc4 100644 --- a/dlls/urlmon/tests/url.c +++ b/dlls/urlmon/tests/url.c @@ -32,6 +32,7 @@ #include "urlmon.h" #include "wininet.h" #include "mshtml.h" +#include "shlwapi.h" #include "wine/test.h" @@ -2905,7 +2906,7 @@ static void init_bind_test(int protocol, DWORD flags, DWORD t) url_a = (flags & BINDTEST_INVALID_CN) ? "https://4.15.184.77/favicon.ico" : "https://test.winehq.org/tests/hello.html"; break; case FTP_TEST: - url_a = "ftp://ftp.winehq.org/welcome.msg"; + url_a = "ftp://ftp.winehq.org/welcome%2emsg"; break; default: url_a = "winetest:test"; @@ -2969,6 +2970,13 @@ static void test_BindToStorage(int protocol, DWORD flags, DWORD t) if(FAILED(hres)) return; + if(protocol == FTP_TEST) + { + /* FTP url dont have any escape characters, so convert the url to what is expected */ + DWORD size = 0; + UrlUnescapeW(current_url, NULL, &size, URL_UNESCAPE_INPLACE); + } + hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind); ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n"); if(SUCCEEDED(hres)) -- 2.20.1

2 1

[PATCH 2/2] imagehlp: Fix checksum calculation for odd sizes.
by Vijay Kiran Kamuju 22 Mar '19

22 Mar '19

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/imagehlp/modify.c | 39 ++++++++++++++++----------------- dlls/imagehlp/tests/integrity.c | 2 +- 2 files changed, 20 insertions(+), 21 deletions(-) diff --git a/dlls/imagehlp/modify.c b/dlls/imagehlp/modify.c index aa29ca7a02..2a0214bacc 100644 --- a/dlls/imagehlp/modify.c +++ b/dlls/imagehlp/modify.c @@ -60,26 +60,25 @@ BOOL WINAPI BindImageEx( /*********************************************************************** * CheckSum (internal) */ -static WORD CalcCheckSum( - DWORD StartValue, LPVOID BaseAddress, DWORD WordCount) +static WORD CalcCheckSum(DWORD StartValue, LPVOID BaseAddress, DWORD ByteCount) { - LPWORD Ptr; - DWORD Sum; - DWORD i; - - Sum = StartValue; - Ptr = (LPWORD)BaseAddress; - for (i = 0; i < WordCount; i++) - { - Sum += *Ptr; - if (HIWORD(Sum) != 0) - { - Sum = LOWORD(Sum) + HIWORD(Sum); - } - Ptr++; - } - - return (WORD)(LOWORD(Sum) + HIWORD(Sum)); + LPWORD Ptr; + DWORD Sum, i; + + Sum = StartValue; + Ptr = (LPWORD)BaseAddress; + for (i = ByteCount; i > 1; i -= 2) + { + Sum += *Ptr; + if (HIWORD(Sum) != 0) + Sum = LOWORD(Sum) + HIWORD(Sum); + Ptr++; + } + + if (i == 1) + Sum += *(BYTE *)Ptr; + + return (WORD)(LOWORD(Sum) + HIWORD(Sum)); } @@ -102,7 +101,7 @@ PIMAGE_NT_HEADERS WINAPI CheckSumMappedFile( BaseAddress, FileLength, HeaderSum, CheckSum ); - CalcSum = (DWORD)CalcCheckSum(0, BaseAddress, (FileLength + 1) / sizeof(WORD)); + CalcSum = (DWORD)CalcCheckSum(0, BaseAddress, FileLength); __TRY { diff --git a/dlls/imagehlp/tests/integrity.c b/dlls/imagehlp/tests/integrity.c index b62b37cd4b..fff39127cf 100644 --- a/dlls/imagehlp/tests/integrity.c +++ b/dlls/imagehlp/tests/integrity.c @@ -350,7 +350,7 @@ static void test_pe_checksum(void) ret = pCheckSumMappedFile(buffer, 11, &checksum_orig, &checksum_new); ok(ret == NULL, "Expected NULL, got %p\n", ret); ok(checksum_orig == 0, "Expected 0, got %x\n", checksum_orig); - todo_wine ok(checksum_new == 0xaad7, "Expected 0xaad7, got %x\n", checksum_new); + ok(checksum_new == 0xaad7, "Expected 0xaad7, got %x\n", checksum_new); /* test checksum of PE module */ memset(buffer, 0x22, sizeof(buffer)); -- 2.21.0

2 1

[PATCH vkd3d 2/2] tests: Add test for SRV component mapping.
by Józef Kucia 22 Mar '19

22 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 247 +++++++++++++++++++++++++++++++++++++++ tests/d3d12_test_utils.h | 2 + 2 files changed, 249 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index c99928a40092..edd1f5954688 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -13040,6 +13040,252 @@ static void test_resinfo(void) destroy_test_context(&context); } +static void test_srv_component_mapping(void) +{ + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc; + D3D12_SUBRESOURCE_DATA subresource_data; + ID3D12GraphicsCommandList *command_list; + D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle; + D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle; + struct test_context_desc desc; + struct test_context context; + ID3D12DescriptorHeap *heap; + ID3D12CommandQueue *queue; + ID3D12Resource *texture; + uint32_t expected_color; + unsigned int i, j; + + static const DWORD ps_code[] = + { +#if 0 + Texture2D t; + SamplerState s; + + float4 main(float4 position : SV_POSITION) : SV_Target + { + float2 p; + D3D12_SUBRESOURCE_DATA data; + + p.x = position.x / 32.0f; + p.y = position.y / 32.0f; + return t.Sample(s, p); + } +#endif + 0x43425844, 0x7a0c3929, 0x75ff3ca4, 0xccb318b2, 0xe6965b4c, 0x00000001, 0x00000140, 0x00000003, + 0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000030f, 0x505f5653, 0x5449534f, 0x004e4f49, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x58454853, 0x000000a4, 0x00000050, + 0x00000029, 0x0100086a, 0x0300005a, 0x00106000, 0x00000000, 0x04001858, 0x00107000, 0x00000000, + 0x00005555, 0x04002064, 0x00101032, 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, + 0x02000068, 0x00000001, 0x0a000038, 0x00100032, 0x00000000, 0x00101046, 0x00000000, 0x00004002, + 0x3d000000, 0x3d000000, 0x00000000, 0x00000000, 0x8b000045, 0x800000c2, 0x00155543, 0x001020f2, + 0x00000000, 0x00100046, 0x00000000, 0x00107e46, 0x00000000, 0x00106000, 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps = {ps_code, sizeof(ps_code)}; + static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + static const uint32_t r8g8b8a8_data = 0x39495969; + static const uint16_t r8g8_data = 0xaabb; + static const uint8_t a8_data = 0x11; + static const uint8_t r8_data = 0xfe; + static const struct + { + const char *name; + DXGI_FORMAT format; + const void *data; + uint32_t color; + } + tests[] = + { + {"R8G8B8A8", DXGI_FORMAT_R8G8B8A8_UNORM, &r8g8b8a8_data, 0x39495969}, + {"R8G8", DXGI_FORMAT_R8G8_UNORM, &r8g8_data, 0xff00aabb}, + {"R8", DXGI_FORMAT_R8_UNORM, &r8_data, 0xff0000fe}, + {"A8", DXGI_FORMAT_A8_UNORM, &a8_data, 0x11000000}, + }; + static const struct + { + unsigned int mapping; + unsigned int r_shift; + unsigned int g_shift; + unsigned int b_shift; + unsigned int a_shift; + uint32_t forced_mask; + uint32_t forced_color; + } + component_mappings[] = + { + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0), + 0, 0, 0, 0, 0xffffffff, 0x00000000, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1), + 0, 0, 0, 0, 0xffffffff, 0xffffffff, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1), + 0, 0, 0, 0, 0xffffffff, 0xff0000ff, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0), + 0, 0, 0, 0, 0xffffffff, 0x00ff00ff, + }, + + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3), + 0, 8, 16, 24, 0x00000000, 0x00000000, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0), + 24, 16, 8, 0, 0x00000000, 0x00000000, + }, + + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0), + 0, 8, 16, 24, 0xff000000, 0x00000000, + }, + + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0), + 0, 0, 0, 0, 0x00000000, 0x00000000, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1), + 8, 8, 8, 8, 0x00000000, 0x00000000, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2), + 16, 16, 16, 16, 0x00000000, 0x00000000, + }, + { + D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING( + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, + D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3), + 24, 24, 24, 24, 0x00000000, 0x00000000, + }, + }; + + memset(&desc, 0, sizeof(desc)); + desc.rt_width = desc.rt_height = 32; + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + context.root_signature = create_texture_root_signature(context.device, + D3D12_SHADER_VISIBILITY_PIXEL, 0, 0); + context.pipeline_state = create_pipeline_state(context.device, + context.root_signature, context.render_target_desc.Format, NULL, &ps, NULL); + + heap = create_gpu_descriptor_heap(context.device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1); + cpu_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(heap); + gpu_handle = ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(heap); + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + vkd3d_test_set_context("Test %s", tests[i].name); + + texture = create_default_texture(context.device, 1, 1, + tests[i].format, 0, D3D12_RESOURCE_STATE_COPY_DEST); + subresource_data.pData = tests[i].data; + subresource_data.RowPitch = format_size(tests[i].format); + subresource_data.SlicePitch = subresource_data.RowPitch; + upload_texture_data(texture, &subresource_data, 1, queue, command_list); + reset_command_list(command_list, context.allocator); + + transition_resource_state(command_list, texture, + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + + for (j = 0; j < ARRAY_SIZE(component_mappings); ++j) + { + vkd3d_test_set_context("Test %s, %u", tests[i].name, j); + + memset(&srv_desc, 0, sizeof(srv_desc)); + srv_desc.Format = tests[i].format; + srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; + srv_desc.Shader4ComponentMapping = component_mappings[j].mapping; + srv_desc.Texture2D.MipLevels = 1; + ID3D12Device_CreateShaderResourceView(context.device, texture, &srv_desc, cpu_handle); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, 1, &heap); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 0, gpu_handle); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + expected_color = 0; + expected_color |= ((tests[i].color >> component_mappings[j].r_shift) & 0xff) << 0; + expected_color |= ((tests[i].color >> component_mappings[j].g_shift) & 0xff) << 8; + expected_color |= ((tests[i].color >> component_mappings[j].b_shift) & 0xff) << 16; + expected_color |= ((tests[i].color >> component_mappings[j].a_shift) & 0xff) << 24; + expected_color &= ~component_mappings[j].forced_mask; + expected_color |= component_mappings[j].forced_color & component_mappings[j].forced_mask; + check_sub_resource_uint(context.render_target, 0, queue, command_list, expected_color, 0); + + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + } + + ID3D12Resource_Release(texture); + } + vkd3d_test_set_context(NULL); + + ID3D12DescriptorHeap_Release(heap); + destroy_test_context(&context); +} + static void test_descriptor_tables(void) { ID3D12DescriptorHeap *heap, *sampler_heap, *heaps[2]; @@ -26416,6 +26662,7 @@ START_TEST(d3d12) run_test(test_cube_maps); run_test(test_multisample_array_texture); run_test(test_resinfo); + run_test(test_srv_component_mapping); run_test(test_descriptor_tables); run_test(test_descriptor_tables_overlapping_bindings); run_test(test_update_root_descriptors); diff --git a/tests/d3d12_test_utils.h b/tests/d3d12_test_utils.h index f181fe4ec04e..9c38cafb0480 100644 --- a/tests/d3d12_test_utils.h +++ b/tests/d3d12_test_utils.h @@ -228,9 +228,11 @@ static unsigned int format_size(DXGI_FORMAT format) case DXGI_FORMAT_UNKNOWN: case DXGI_FORMAT_A8_UNORM: case DXGI_FORMAT_R8_UINT: + case DXGI_FORMAT_R8_UNORM: return 1; case DXGI_FORMAT_R32G32B32A32_FLOAT: case DXGI_FORMAT_R32G32B32A32_UINT: + case DXGI_FORMAT_R8G8_UNORM: return 16; case DXGI_FORMAT_R32_TYPELESS: case DXGI_FORMAT_D32_FLOAT: -- 2.19.2

2 1

[PATCH vkd3d 1/2] vkd3d: Implement component mapping for SRVs.
by Józef Kucia 22 Mar '19

22 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/vkd3d_d3d12.idl | 4 ++ libs/vkd3d/resource.c | 105 +++++++++++++++++++++++++++++++++++-- libs/vkd3d/utils.c | 31 +++++++++++ libs/vkd3d/vkd3d_private.h | 1 + 4 files changed, 136 insertions(+), 5 deletions(-) diff --git a/include/vkd3d_d3d12.idl b/include/vkd3d_d3d12.idl index 9d5fd7351837..e3f9df0f7127 100644 --- a/include/vkd3d_d3d12.idl +++ b/include/vkd3d_d3d12.idl @@ -931,6 +931,10 @@ cpp_quote(" | (((w) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << (D3D12_SHAD cpp_quote(" | D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES)") cpp_quote("#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, 3)") +cpp_quote("#define D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(i, mapping) \\") +cpp_quote(" ((D3D12_SHADER_COMPONENT_MAPPING)(mapping >> (i * D3D12_SHADER_COMPONENT_MAPPING_SHIFT) \\") +cpp_quote(" & D3D12_SHADER_COMPONENT_MAPPING_MASK))") + typedef struct D3D12_BUFFER_SRV { UINT64 FirstElement; diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 1d13be5982c5..1cfc9b318d5d 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1618,10 +1618,10 @@ static bool vkd3d_create_buffer_view(struct d3d12_device *device, static void vkd3d_set_view_swizzle_for_format(VkComponentMapping *components, const struct vkd3d_format *format, bool allowed_swizzle) { - components->r = VK_COMPONENT_SWIZZLE_IDENTITY; - components->g = VK_COMPONENT_SWIZZLE_IDENTITY; - components->b = VK_COMPONENT_SWIZZLE_IDENTITY; - components->a = VK_COMPONENT_SWIZZLE_IDENTITY; + components->r = VK_COMPONENT_SWIZZLE_R; + components->g = VK_COMPONENT_SWIZZLE_G; + components->b = VK_COMPONENT_SWIZZLE_B; + components->a = VK_COMPONENT_SWIZZLE_A; if (format->vk_aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) { @@ -1671,6 +1671,89 @@ static void vkd3d_set_view_swizzle_for_format(VkComponentMapping *components, } } +static VkComponentSwizzle vk_component_swizzle_from_d3d12(unsigned int component_mapping, + unsigned int component_index) +{ + D3D12_SHADER_COMPONENT_MAPPING mapping + = D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(component_index, component_mapping); + + switch (mapping) + { + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0: + return VK_COMPONENT_SWIZZLE_R; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1: + return VK_COMPONENT_SWIZZLE_G; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2: + return VK_COMPONENT_SWIZZLE_B; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3: + return VK_COMPONENT_SWIZZLE_A; + case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0: + return VK_COMPONENT_SWIZZLE_ZERO; + case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1: + return VK_COMPONENT_SWIZZLE_ONE; + } + + FIXME("Invalid component mapping %#x.\n", mapping); + return VK_COMPONENT_SWIZZLE_IDENTITY; +} + +static void vk_component_mapping_from_d3d12(VkComponentMapping *components, + unsigned int component_mapping) +{ + components->r = vk_component_swizzle_from_d3d12(component_mapping, 0); + components->g = vk_component_swizzle_from_d3d12(component_mapping, 1); + components->b = vk_component_swizzle_from_d3d12(component_mapping, 2); + components->a = vk_component_swizzle_from_d3d12(component_mapping, 3); +} + +static VkComponentSwizzle swizzle_vk_component(const VkComponentMapping *components, + VkComponentSwizzle component, VkComponentSwizzle swizzle) +{ + switch (swizzle) + { + case VK_COMPONENT_SWIZZLE_IDENTITY: + break; + + case VK_COMPONENT_SWIZZLE_R: + component = components->r; + break; + + case VK_COMPONENT_SWIZZLE_G: + component = components->g; + break; + + case VK_COMPONENT_SWIZZLE_B: + component = components->b; + break; + + case VK_COMPONENT_SWIZZLE_A: + component = components->a; + break; + + case VK_COMPONENT_SWIZZLE_ONE: + case VK_COMPONENT_SWIZZLE_ZERO: + component = swizzle; + break; + + default: + FIXME("Invalid component swizzle %#x.\n", swizzle); + break; + } + + assert(component != VK_COMPONENT_SWIZZLE_IDENTITY); + return component; +} + +static void vk_component_mapping_compose(VkComponentMapping *dst, const VkComponentMapping *b) +{ + const VkComponentMapping a = *dst; + + dst->r = swizzle_vk_component(&a, a.r, b->r); + dst->g = swizzle_vk_component(&a, a.g, b->g); + dst->b = swizzle_vk_component(&a, a.b, b->b); + dst->a = swizzle_vk_component(&a, a.a, b->a); +} + struct vkd3d_texture_view_desc { VkImageViewType view_type; @@ -1679,6 +1762,7 @@ struct vkd3d_texture_view_desc unsigned int miplevel_count; unsigned int layer_idx; unsigned int layer_count; + VkComponentMapping components; bool allowed_swizzle; }; @@ -1719,6 +1803,10 @@ static bool init_default_texture_view_desc(struct vkd3d_texture_view_desc *desc, return false; } + desc->components.r = VK_COMPONENT_SWIZZLE_IDENTITY; + desc->components.g = VK_COMPONENT_SWIZZLE_IDENTITY; + desc->components.b = VK_COMPONENT_SWIZZLE_IDENTITY; + desc->components.a = VK_COMPONENT_SWIZZLE_IDENTITY; desc->allowed_swizzle = false; return true; } @@ -1743,6 +1831,8 @@ static bool vkd3d_create_texture_view(struct d3d12_device *device, view_desc.viewType = desc->view_type; view_desc.format = format->vk_format; vkd3d_set_view_swizzle_for_format(&view_desc.components, format, desc->allowed_swizzle); + if (desc->allowed_swizzle) + vk_component_mapping_compose(&view_desc.components, &desc->components); view_desc.subresourceRange.aspectMask = format->vk_aspect_mask; view_desc.subresourceRange.baseMipLevel = desc->miplevel_idx; view_desc.subresourceRange.levelCount = desc->miplevel_count; @@ -1874,7 +1964,12 @@ void d3d12_desc_create_srv(struct d3d12_desc *descriptor, if (desc) { if (desc->Shader4ComponentMapping != D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING) - FIXME("Ignoring component mapping %#x.\n", desc->Shader4ComponentMapping); + { + TRACE("Component mapping %s for format %#x.\n", + debug_d3d12_shader_component_mapping(desc->Shader4ComponentMapping), desc->Format); + + vk_component_mapping_from_d3d12(&vkd3d_desc.components, desc->Shader4ComponentMapping); + } switch (desc->ViewDimension) { diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index e0af3f6e2dfd..afa4da3fad5d 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -331,6 +331,37 @@ const char *debug_d3d12_box(const D3D12_BOX *box) box->right, box->bottom, box->back); } +static const char *debug_d3d12_shader_component(D3D12_SHADER_COMPONENT_MAPPING component) +{ + switch (component) + { + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0: + return "r"; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1: + return "g"; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2: + return "b"; + case D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3: + return "a"; + case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0: + return "0"; + case D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1: + return "1"; + } + + FIXME("Invalid component mapping %#x.\n", component); + return "invalid"; +} + +const char *debug_d3d12_shader_component_mapping(unsigned int mapping) +{ + return vkd3d_dbg_sprintf("{%s, %s, %s, %s}", + debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(mapping, 0)), + debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(mapping, 1)), + debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(mapping, 2)), + debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(mapping, 3))); +} + const char *debug_vk_extent_3d(VkExtent3D extent) { return vkd3d_dbg_sprintf("(%u, %u, %u)", diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index a6ada4b4e68f..ab6629112383 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -1016,6 +1016,7 @@ HRESULT return_interface(void *iface, REFIID iface_iid, REFIID requested_iid, void **object) DECLSPEC_HIDDEN; const char *debug_d3d12_box(const D3D12_BOX *box) DECLSPEC_HIDDEN; +const char *debug_d3d12_shader_component_mapping(unsigned int mapping) DECLSPEC_HIDDEN; const char *debug_vk_extent_3d(VkExtent3D extent) DECLSPEC_HIDDEN; const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags) DECLSPEC_HIDDEN; const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags) DECLSPEC_HIDDEN; -- 2.19.2

2 1

[PATCH] wined3d: Get rid of the "src_state" local variable from wined3d_stateblock_capture().
by Zebediah Figura 22 Mar '19

22 Mar '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wined3d/stateblock.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c index 530326934b..ddb202ad7c 100644 --- a/dlls/wined3d/stateblock.c +++ b/dlls/wined3d/stateblock.c @@ -749,14 +749,11 @@ static void wined3d_state_record_lights(struct wined3d_light_state *dst_state, void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock) { const struct wined3d_stateblock_state *state = &stateblock->device->stateblock_state; - const struct wined3d_state *src_state = &stateblock->device->state; unsigned int i; DWORD map; TRACE("stateblock %p.\n", stateblock); - TRACE("Capturing state %p.\n", src_state); - if (stateblock->changed.vertexShader && stateblock->stateblock_state.vs != state->vs) { TRACE("Updating vertex shader from %p to %p.\n", stateblock->stateblock_state.vs, state->vs); -- 2.20.1

2 1

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel March 2019