April 2020 - Wine-Devel - list.winehq.org

[PATCH] msi: Add support for bitmap buttons.
by Hans Leidekker April 21, 2020

April 21, 2020

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=48974 Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msi/dialog.c | 166 +++++++++++++++++++++++++--------------------- 1 file changed, 91 insertions(+), 75 deletions(-) diff --git a/dlls/msi/dialog.c b/dlls/msi/dialog.c index 67a0633991..81b0d3dba0 100644 --- a/dlls/msi/dialog.c +++ b/dlls/msi/dialog.c @@ -1014,38 +1014,120 @@ static UINT msi_dialog_button_handler( msi_dialog *dialog, msi_control *control, return r; } +static HBITMAP msi_load_picture( MSIDATABASE *db, const WCHAR *name, INT cx, INT cy, DWORD flags ) +{ + HBITMAP hOleBitmap = 0, hBitmap = 0, hOldSrcBitmap, hOldDestBitmap; + MSIRECORD *rec = NULL; + IStream *stm = NULL; + IPicture *pic = NULL; + HDC srcdc, destdc; + BITMAP bm; + UINT r; + + rec = msi_get_binary_record( db, name ); + if (!rec) + goto end; + + r = MSI_RecordGetIStream( rec, 2, &stm ); + msiobj_release( &rec->hdr ); + if (r != ERROR_SUCCESS) + goto end; + + r = OleLoadPicture( stm, 0, TRUE, &IID_IPicture, (void **)&pic ); + IStream_Release( stm ); + if (FAILED( r )) + { + ERR("failed to load picture\n"); + goto end; + } + + r = IPicture_get_Handle( pic, (OLE_HANDLE *)&hOleBitmap ); + if (FAILED( r )) + { + ERR("failed to get bitmap handle\n"); + goto end; + } + + /* make the bitmap the desired size */ + r = GetObjectW( hOleBitmap, sizeof(bm), &bm ); + if (r != sizeof(bm)) + { + ERR("failed to get bitmap size\n"); + goto end; + } + + if (flags & LR_DEFAULTSIZE) + { + cx = bm.bmWidth; + cy = bm.bmHeight; + } + + srcdc = CreateCompatibleDC( NULL ); + hOldSrcBitmap = SelectObject( srcdc, hOleBitmap ); + destdc = CreateCompatibleDC( NULL ); + hBitmap = CreateCompatibleBitmap( srcdc, cx, cy ); + hOldDestBitmap = SelectObject( destdc, hBitmap ); + StretchBlt( destdc, 0, 0, cx, cy, srcdc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY ); + SelectObject( srcdc, hOldSrcBitmap ); + SelectObject( destdc, hOldDestBitmap ); + DeleteDC( srcdc ); + DeleteDC( destdc ); + +end: + if (pic) IPicture_Release( pic ); + return hBitmap; +} + static UINT msi_dialog_button_control( msi_dialog *dialog, MSIRECORD *rec ) { msi_control *control; - UINT attributes, style; + UINT attributes, style, cx = 0, cy = 0, flags = 0; + WCHAR *name = NULL; TRACE("%p %p\n", dialog, rec); style = WS_TABSTOP; attributes = MSI_RecordGetInteger( rec, 8 ); - if( attributes & msidbControlAttributesIcon ) - style |= BS_ICON; + if (attributes & msidbControlAttributesIcon) style |= BS_ICON; + else if (attributes & msidbControlAttributesBitmap) + { + style |= BS_BITMAP; + if (attributes & msidbControlAttributesFixedSize) flags |= LR_DEFAULTSIZE; + else + { + cx = msi_dialog_scale_unit( dialog, MSI_RecordGetInteger(rec, 6) ); + cy = msi_dialog_scale_unit( dialog, MSI_RecordGetInteger(rec, 7) ); + } + } control = msi_dialog_add_control( dialog, rec, szButton, style ); - if( !control ) + if (!control) return ERROR_FUNCTION_FAILED; control->handler = msi_dialog_button_handler; if (attributes & msidbControlAttributesIcon) { - /* set the icon */ - LPWSTR name = msi_get_binary_name( dialog->package, rec ); + name = msi_get_binary_name( dialog->package, rec ); control->hIcon = msi_load_icon( dialog->package->db, name, attributes ); if (control->hIcon) { SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM) control->hIcon ); } - else - ERR("Failed to load icon %s\n", debugstr_w(name)); - msi_free( name ); + else ERR("Failed to load icon %s\n", debugstr_w(name)); + } + else if (attributes & msidbControlAttributesBitmap) + { + name = msi_get_binary_name( dialog->package, rec ); + control->hBitmap = msi_load_picture( dialog->package->db, name, cx, cy, flags ); + if (control->hBitmap) + { + SendMessageW( control->hwnd, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) control->hBitmap ); + } + else ERR("Failed to load bitmap %s\n", debugstr_w(name)); } + msi_free( name ); return ERROR_SUCCESS; } @@ -1341,72 +1423,6 @@ static UINT msi_dialog_scrolltext_control( msi_dialog *dialog, MSIRECORD *rec ) return ERROR_SUCCESS; } -static HBITMAP msi_load_picture( MSIDATABASE *db, LPCWSTR name, - INT cx, INT cy, DWORD flags ) -{ - HBITMAP hOleBitmap = 0, hBitmap = 0, hOldSrcBitmap, hOldDestBitmap; - MSIRECORD *rec = NULL; - IStream *stm = NULL; - IPicture *pic = NULL; - HDC srcdc, destdc; - BITMAP bm; - UINT r; - - rec = msi_get_binary_record( db, name ); - if( !rec ) - goto end; - - r = MSI_RecordGetIStream( rec, 2, &stm ); - msiobj_release( &rec->hdr ); - if( r != ERROR_SUCCESS ) - goto end; - - r = OleLoadPicture( stm, 0, TRUE, &IID_IPicture, (LPVOID*) &pic ); - IStream_Release( stm ); - if( FAILED( r ) ) - { - ERR("failed to load picture\n"); - goto end; - } - - r = IPicture_get_Handle( pic, (OLE_HANDLE*) &hOleBitmap ); - if( FAILED( r ) ) - { - ERR("failed to get bitmap handle\n"); - goto end; - } - - /* make the bitmap the desired size */ - r = GetObjectW( hOleBitmap, sizeof bm, &bm ); - if (r != sizeof bm ) - { - ERR("failed to get bitmap size\n"); - goto end; - } - - if (flags & LR_DEFAULTSIZE) - { - cx = bm.bmWidth; - cy = bm.bmHeight; - } - - srcdc = CreateCompatibleDC( NULL ); - hOldSrcBitmap = SelectObject( srcdc, hOleBitmap ); - destdc = CreateCompatibleDC( NULL ); - hBitmap = CreateCompatibleBitmap( srcdc, cx, cy ); - hOldDestBitmap = SelectObject( destdc, hBitmap ); - StretchBlt( destdc, 0, 0, cx, cy, - srcdc, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY); - SelectObject( srcdc, hOldSrcBitmap ); - SelectObject( destdc, hOldDestBitmap ); - DeleteDC( srcdc ); - DeleteDC( destdc ); - -end: - if ( pic ) - IPicture_Release( pic ); - return hBitmap; -} static UINT msi_dialog_bitmap_control( msi_dialog *dialog, MSIRECORD *rec ) { -- 2.20.1

1 0

Wine theme
by Олег April 21, 2020

April 21, 2020

Hi, There is a great theme for Wine in the form of a registry file wine_breeze_colors.reg . I suggest that you enable this theme by default in Wine, since the existing theme is very outdated. -- Олег *****

1 0

[PATCH 9/9] windowscodecs/tests: Add a separate test for 4bps BGRA TIFF format.
by Dmitry Timoshkov April 21, 2020

April 21, 2020

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/windowscodecs/tests/tiffformat.c | 104 ++++++++++++++++++++++++++ 1 file changed, 104 insertions(+) diff --git a/dlls/windowscodecs/tests/tiffformat.c b/dlls/windowscodecs/tests/tiffformat.c index 2a03dc19af..504a053983 100644 --- a/dlls/windowscodecs/tests/tiffformat.c +++ b/dlls/windowscodecs/tests/tiffformat.c @@ -302,6 +302,47 @@ static const struct tiff_24bpp_data { 900, 3 }, { 0x11, 0x22, 0x33 } }; + +static const struct tiff_4bps_bgra +{ + USHORT byte_order; + USHORT version; + ULONG dir_offset; + USHORT number_of_entries; + struct IFD_entry entry[14]; + ULONG next_IFD; + struct IFD_rational res; + BYTE pixel_data[4]; +} tiff_4bps_bgra = +{ +#ifdef WORDS_BIGENDIAN + 'M' | 'M' << 8, +#else + 'I' | 'I' << 8, +#endif + 42, + FIELD_OFFSET(struct tiff_4bps_bgra, number_of_entries), + 14, + { + { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */ + { 0x100, IFD_LONG, 1, 3 }, /* IMAGEWIDTH */ + { 0x101, IFD_LONG, 1, 2 }, /* IMAGELENGTH */ + { 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */ + { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION */ + { 0x106, IFD_SHORT, 1, 2 }, /* PHOTOMETRIC */ + { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_4bps_bgra, pixel_data) }, /* STRIPOFFSETS */ + { 0x115, IFD_SHORT, 1, 4 }, /* SAMPLESPERPIXEL */ + { 0x116, IFD_LONG, 1, 2 }, /* ROWSPERSTRIP */ + { 0x117, IFD_LONG, 1, 4 }, /* STRIPBYTECOUNT */ + { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_4bps_bgra, res) }, /* XRESOLUTION */ + { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_4bps_bgra, res) }, /* YRESOLUTION */ + { 0x11c, IFD_SHORT, 1, 1 }, /* PLANARCONFIGURATION */ + { 0x128, IFD_SHORT, 1, 2 } /* RESOLUTIONUNIT */ + }, + 0, + { 96, 1 }, + { 0x12,0x30, 0x47,0xe0 } +}; #include "poppack.h" static IWICImagingFactory *factory; @@ -1177,6 +1218,68 @@ static void test_color_formats(void) } } +static void test_tiff_4bps_bgra(void) +{ + HRESULT hr; + IWICBitmapDecoder *decoder; + IWICBitmapFrameDecode *frame; + UINT frame_count, width, height, i; + double dpi_x, dpi_y; + IWICPalette *palette; + GUID format; + WICRect rc; + BYTE data[24]; + static const BYTE expected_data[24] = { 0,0,0,0xff, 0xff,0,0,0, 0xff,0,0,0xff, + 0,0xff,0,0, 0xff,0xff,0,0xff, 0xff,0xff,0xff,0 }; + + hr = create_decoder(&tiff_4bps_bgra, sizeof(tiff_4bps_bgra), &decoder); + ok(hr == S_OK, "Failed to load TIFF image data %#x\n", hr); + if (hr != S_OK) return; + + hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count); + ok(hr == S_OK, "GetFrameCount error %#x\n", hr); + ok(frame_count == 1, "expected 1, got %u\n", frame_count); + + hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame); + ok(hr == S_OK, "GetFrame error %#x\n", hr); + + hr = IWICBitmapFrameDecode_GetSize(frame, &width, &height); + ok(hr == S_OK, "GetSize error %#x\n", hr); + ok(width == 3, "got %u\n", width); + ok(height == 2, "got %u\n", height); + + hr = IWICBitmapFrameDecode_GetResolution(frame, &dpi_x, &dpi_y); + ok(hr == S_OK, "GetResolution error %#x\n", hr); + ok(dpi_x == 96.0, "expected 96.0, got %f\n", dpi_x); + ok(dpi_y == 96.0, "expected 96.0, got %f\n", dpi_y); + + hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format); + ok(hr == S_OK, "GetPixelFormat error %#x\n", hr); + ok(IsEqualGUID(&format, &GUID_WICPixelFormat32bppBGRA), + "got wrong format %s\n", wine_dbgstr_guid(&format)); + + hr = IWICImagingFactory_CreatePalette(factory, &palette); + ok(hr == S_OK, "CreatePalette error %#x\n", hr); + hr = IWICBitmapFrameDecode_CopyPalette(frame, palette); + ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, + "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %#x\n", hr); + IWICPalette_Release(palette); + + memset(data, 0xaa, sizeof(data)); + rc.X = 0; + rc.Y = 0; + rc.Width = 3; + rc.Height = 2; + hr = IWICBitmapFrameDecode_CopyPixels(frame, &rc, 12, sizeof(data), data); + ok(hr == S_OK, "CopyPixels error %#x\n", hr); + + for (i = 0; i < sizeof(data); i++) + ok(data[i] == expected_data[i], "%u: expected %02x, got %02x\n", i, expected_data[i], data[i]); + + IWICBitmapFrameDecode_Release(frame); + IWICBitmapDecoder_Release(decoder); +} + START_TEST(tiffformat) { HRESULT hr; @@ -1188,6 +1291,7 @@ START_TEST(tiffformat) ok(hr == S_OK, "CoCreateInstance error %#x\n", hr); if (FAILED(hr)) return; + test_tiff_4bps_bgra(); test_color_formats(); test_tiff_1bpp_palette(); test_tiff_8bpp_palette(); -- 2.25.2

2 1

d2d1: Which tests to add for cubic bezier path geometries?
by Connor McAdams April 20, 2020

April 20, 2020

Hi! Currently I'm trying to write tests for implementing cubic bezier support, however, I'm not sure which tests need to be added within the test_path geometry function. There are tests currently for transformation, and some for reading back a surface to compare against. Since my first patch series only implements bounds checking, bezier-bezier intersection, and bezier-line intersection, comparing against a surface won't really be applicable. Transformation is a more generic path geometry thing, I can add that, but I'm not sure it's necessary. Currently, I imagine the tests that will be necessary in test_path_geometry will be simplification and bounds checking. I'm thinking the bezier-bezier and bezier-line intersection checking would go into test_bezier_intersect, but I'd like confirmation of that. If there's any I missed, let me know. Mainly, I want to be sure I'm writing the correct tests/enough tests, and that they're contained within the correct test functions. Thanks, Connor McAdams

1 0

[PATCH v2 1/5] strmbase: Make the pin_get_media_type() callback optional.
by Zebediah Figura April 20, 2020

April 20, 2020

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/strmbase/pin.c | 36 ++++++++++++++++++++++++++---------- dlls/strmbase/renderer.c | 1 - 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/dlls/strmbase/pin.c b/dlls/strmbase/pin.c index 4676c9d82b..d9d25f7627 100644 --- a/dlls/strmbase/pin.c +++ b/dlls/strmbase/pin.c @@ -57,10 +57,13 @@ static HRESULT enum_media_types_create(struct strmbase_pin *pin, IEnumMediaTypes object->pin = pin; IPin_AddRef(&pin->IPin_iface); - while (pin->ops->pin_get_media_type(pin, object->count, &mt) == S_OK) + if (pin->ops->pin_get_media_type) { - FreeMediaType(&mt); - ++object->count; + while (pin->ops->pin_get_media_type(pin, object->count, &mt) == S_OK) + { + FreeMediaType(&mt); + ++object->count; + } } TRACE("Created enumerator %p.\n", object); @@ -121,6 +124,13 @@ static HRESULT WINAPI enum_media_types_Next(IEnumMediaTypes *iface, ULONG count, TRACE("enummt %p, count %u, mts %p, ret_count %p.\n", enummt, count, mts, ret_count); + if (!enummt->pin->ops->pin_get_media_type) + { + if (ret_count) + *ret_count = 0; + return count ? S_FALSE : S_OK; + } + for (i = 0; i < count; ++i) { if ((mts[i] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)))) @@ -169,10 +179,13 @@ static HRESULT WINAPI enum_media_types_Reset(IEnumMediaTypes *iface) TRACE("enummt %p.\n", enummt); enummt->count = 0; - while (enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->count, &mt) == S_OK) + if (enummt->pin->ops->pin_get_media_type) { - FreeMediaType(&mt); - ++enummt->count; + while (enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->count, &mt) == S_OK) + { + FreeMediaType(&mt); + ++enummt->count; + } } enummt->index = 0; @@ -397,10 +410,13 @@ static HRESULT WINAPI pin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **enum_med TRACE("pin %p %s:%s, enum_media_types %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), enum_media_types); - if (FAILED(hr = pin->ops->pin_get_media_type(pin, 0, &mt))) - return hr; - if (hr == S_OK) - FreeMediaType(&mt); + if (pin->ops->pin_get_media_type) + { + if (FAILED(hr = pin->ops->pin_get_media_type(pin, 0, &mt))) + return hr; + if (hr == S_OK) + FreeMediaType(&mt); + } return enum_media_types_create(pin, enum_media_types); } diff --git a/dlls/strmbase/renderer.c b/dlls/strmbase/renderer.c index fd999d3ae9..f1e74f6476 100644 --- a/dlls/strmbase/renderer.c +++ b/dlls/strmbase/renderer.c @@ -257,7 +257,6 @@ static const struct strmbase_sink_ops sink_ops = { .base.pin_query_accept = sink_query_accept, .base.pin_query_interface = sink_query_interface, - .base.pin_get_media_type = strmbase_pin_get_media_type, .pfnReceive = BaseRenderer_Receive, .sink_connect = sink_connect, .sink_disconnect = sink_disconnect, -- 2.26.0

2 7

[PATCH 5/5] wined3d: Introduce a slab allocator for small buffers.
by Henri Verbeet April 20, 2020

April 20, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 29 ++++- dlls/wined3d/context_vk.c | 192 +++++++++++++++++++++++++++++++++ dlls/wined3d/texture.c | 4 +- dlls/wined3d/wined3d_private.h | 29 +++++ include/wine/rbtree.h | 16 +++ 5 files changed, 264 insertions(+), 6 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 35b4e8da6aa..8a6bc2b01cf 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -553,13 +553,23 @@ static void *wined3d_bo_vk_map(struct wined3d_bo_vk *bo, struct wined3d_context_ { const struct wined3d_vk_info *vk_info; struct wined3d_device_vk *device_vk; + struct wined3d_bo_slab_vk *slab; void *map_ptr; VkResult vr; vk_info = context_vk->vk_info; device_vk = wined3d_device_vk(context_vk->c.device); - if (bo->memory) + if ((slab = bo->slab)) + { + if (!(map_ptr = slab->map_ptr) && !(map_ptr = wined3d_bo_vk_map(&slab->bo, context_vk))) + { + ERR("Failed to map slab.\n"); + return NULL; + } + ++slab->map_count; + } + else if (bo->memory) { struct wined3d_allocator_chunk_vk *chunk_vk = wined3d_allocator_chunk_vk(bo->memory->chunk); @@ -582,6 +592,17 @@ static void wined3d_bo_vk_unmap(struct wined3d_bo_vk *bo, struct wined3d_context { const struct wined3d_vk_info *vk_info; struct wined3d_device_vk *device_vk; + struct wined3d_bo_slab_vk *slab; + + if ((slab = bo->slab)) + { + if (--slab->map_count) + return; + + wined3d_bo_vk_unmap(&slab->bo, context_vk); + slab->map_ptr = NULL; + return; + } vk_info = context_vk->vk_info; device_vk = wined3d_device_vk(context_vk->c.device); @@ -628,7 +649,7 @@ static void *adapter_vk_map_bo_address(struct wined3d_context *context, vk_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; vk_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; vk_barrier.buffer = bo->vk_buffer; - vk_barrier.offset = (uintptr_t)data->addr; + vk_barrier.offset = bo->buffer_offset + (uintptr_t)data->addr; vk_barrier.size = size; VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, NULL, 1, &vk_barrier, 0, NULL)); @@ -718,8 +739,8 @@ static void adapter_vk_copy_bo_address(struct wined3d_context *context, return; } - region.srcOffset = (uintptr_t)src->addr; - region.dstOffset = (uintptr_t)dst->addr; + region.srcOffset = src_bo->buffer_offset + (uintptr_t)src->addr; + region.dstOffset = dst_bo->buffer_offset + (uintptr_t)dst->addr; region.size = size; vk_barrier[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 0d90c40fe64..76aafa4c110 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -110,6 +110,97 @@ struct wined3d_allocator_block *wined3d_context_vk_allocate_memory(struct wined3 return block; } +static bool wined3d_context_vk_create_slab_bo(struct wined3d_context_vk *context_vk, + VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) +{ + const struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk(context_vk->c.device->adapter); + const VkPhysicalDeviceLimits *limits = &adapter_vk->device_limits; + struct wined3d_bo_slab_vk_key key; + struct wined3d_bo_slab_vk *slab; + struct wine_rb_entry *entry; + size_t object_size, idx; + size_t alignment; + + if (size > WINED3D_ALLOCATOR_MIN_BLOCK_SIZE / 2) + return false; + + alignment = WINED3D_SLAB_BO_MIN_OBJECT_ALIGN; + if ((usage & (VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) + && limits->minTexelBufferOffsetAlignment > alignment) + alignment = limits->minTexelBufferOffsetAlignment; + if ((usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) && limits->minUniformBufferOffsetAlignment) + alignment = limits->minUniformBufferOffsetAlignment; + if ((usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) && limits->minStorageBufferOffsetAlignment) + alignment = limits->minStorageBufferOffsetAlignment; + + object_size = (size + (alignment - 1)) & ~(alignment - 1); + if (object_size < WINED3D_ALLOCATOR_MIN_BLOCK_SIZE / 32) + object_size = WINED3D_ALLOCATOR_MIN_BLOCK_SIZE / 32; + key.memory_type = memory_type; + key.usage = usage; + key.size = 32 * object_size; + + if ((entry = wine_rb_get(&context_vk->bo_slab_available, &key))) + { + slab = WINE_RB_ENTRY_VALUE(entry, struct wined3d_bo_slab_vk, entry); + TRACE("Using existing bo slab %p.\n", slab); + } + else + { + if (!(slab = heap_alloc_zero(sizeof(*slab)))) + { + ERR("Failed to allocate bo slab.\n"); + return false; + } + + if (!wined3d_context_vk_create_bo(context_vk, key.size, usage, memory_type, &slab->bo)) + { + ERR("Failed to create slab bo.\n"); + heap_free(slab); + return false; + } + slab->map = ~0u; + + if (wine_rb_put(&context_vk->bo_slab_available, &key, &slab->entry) < 0) + { + ERR("Failed to add slab to available tree.\n"); + wined3d_context_vk_destroy_bo(context_vk, &slab->bo); + heap_free(slab); + return false; + } + + TRACE("Created new bo slab %p.\n", slab); + } + + idx = wined3d_bit_scan(&slab->map); + if (!slab->map) + { + if (slab->next) + { + wine_rb_replace(&context_vk->bo_slab_available, &slab->entry, &slab->next->entry); + slab->next = NULL; + } + else + { + wine_rb_remove(&context_vk->bo_slab_available, &slab->entry); + } + } + + *bo = slab->bo; + bo->memory = NULL; + bo->slab = slab; + bo->buffer_offset = idx * object_size; + bo->memory_offset = slab->bo.memory_offset + bo->buffer_offset; + bo->size = size; + bo->command_buffer_id = 0; + + TRACE("Using buffer 0x%s, memory 0x%s, offset 0x%s for bo %p.\n", + wine_dbgstr_longlong(bo->vk_buffer), wine_dbgstr_longlong(bo->vk_memory), + wine_dbgstr_longlong(bo->buffer_offset), bo); + + return true; +} + BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) { @@ -121,6 +212,9 @@ BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDevic unsigned int memory_type_idx; VkResult vr; + if (wined3d_context_vk_create_slab_bo(context_vk, size, usage, memory_type, bo)) + return TRUE; + adapter_vk = wined3d_adapter_vk(device_vk->d.adapter); create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; @@ -170,8 +264,12 @@ BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDevic return FALSE; } + bo->buffer_offset = 0; + bo->size = size; + bo->usage = usage; bo->memory_type = adapter_vk->memory_properties.memoryTypes[memory_type_idx].propertyFlags; bo->command_buffer_id = 0; + bo->slab = NULL; TRACE("Created buffer 0x%s, memory 0x%s for bo %p.\n", wine_dbgstr_longlong(bo->vk_buffer), wine_dbgstr_longlong(bo->vk_memory), bo); @@ -246,6 +344,56 @@ void wined3d_context_vk_destroy_allocator_block(struct wined3d_context_vk *conte o->command_buffer_id = command_buffer_id; } +static void wined3d_bo_slab_vk_free_slice(struct wined3d_bo_slab_vk *slab, + size_t idx, struct wined3d_context_vk *context_vk) +{ + struct wined3d_bo_slab_vk_key key; + struct wine_rb_entry *entry; + + TRACE("slab %p, idx %zu, context_vk %p.\n", slab, idx, context_vk); + + if (!slab->map) + { + key.memory_type = slab->bo.memory_type; + key.usage = slab->bo.usage; + key.size = slab->bo.size; + + if ((entry = wine_rb_get(&context_vk->bo_slab_available, &key))) + { + slab->next = WINE_RB_ENTRY_VALUE(entry, struct wined3d_bo_slab_vk, entry); + wine_rb_replace(&context_vk->bo_slab_available, entry, &slab->entry); + } + else if (wine_rb_put(&context_vk->bo_slab_available, &key, &slab->entry) < 0) + { + ERR("Unable to return slab %p (map 0x%08x) to available tree.\n", slab, slab->map); + } + } + slab->map |= 1u << idx; +} + +static void wined3d_context_vk_destroy_bo_slab_slice(struct wined3d_context_vk *context_vk, + struct wined3d_bo_slab_vk *slab, size_t idx, uint64_t command_buffer_id) +{ + struct wined3d_retired_object_vk *o; + + if (context_vk->completed_command_buffer_id > command_buffer_id) + { + wined3d_bo_slab_vk_free_slice(slab, idx, context_vk); + return; + } + + if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk))) + { + ERR("Leaking slab %p, slice %#zx.\n", slab, idx); + return; + } + + o->type = WINED3D_RETIRED_BO_SLAB_SLICE_VK; + o->u.slice.slab = slab; + o->u.slice.idx = idx; + o->command_buffer_id = command_buffer_id; +} + static void wined3d_context_vk_destroy_buffer(struct wined3d_context_vk *context_vk, VkBuffer vk_buffer, uint64_t command_buffer_id) { @@ -298,8 +446,18 @@ void wined3d_context_vk_destroy_image(struct wined3d_context_vk *context_vk, void wined3d_context_vk_destroy_bo(struct wined3d_context_vk *context_vk, const struct wined3d_bo_vk *bo) { + size_t object_size, idx; + TRACE("context_vk %p, bo %p.\n", context_vk, bo); + if (bo->slab) + { + object_size = bo->slab->bo.size / 32; + idx = bo->buffer_offset / object_size; + wined3d_context_vk_destroy_bo_slab_slice(context_vk, bo->slab, idx, bo->command_buffer_id); + return; + } + wined3d_context_vk_destroy_buffer(context_vk, bo->vk_buffer, bo->command_buffer_id); if (bo->memory) { @@ -365,6 +523,10 @@ static void wined3d_context_vk_cleanup_resources(struct wined3d_context_vk *cont wined3d_allocator_block_free(o->u.block); break; + case WINED3D_RETIRED_BO_SLAB_SLICE_VK: + wined3d_bo_slab_vk_free_slice(o->u.slice.slab, o->u.slice.idx, context_vk); + break; + case WINED3D_RETIRED_BUFFER_VK: VK_CALL(vkDestroyBuffer(device_vk->vk_device, o->u.vk_buffer, NULL)); TRACE("Destroyed buffer 0x%s.\n", wine_dbgstr_longlong(o->u.vk_buffer)); @@ -392,6 +554,21 @@ static void wined3d_context_vk_cleanup_resources(struct wined3d_context_vk *cont } } +static void wined3d_context_vk_destroy_bo_slab(struct wine_rb_entry *entry, void *ctx) +{ + struct wined3d_context_vk *context_vk = ctx; + struct wined3d_bo_slab_vk *slab, *next; + + slab = WINE_RB_ENTRY_VALUE(entry, struct wined3d_bo_slab_vk, entry); + while (slab) + { + next = slab->next; + wined3d_context_vk_destroy_bo(context_vk, &slab->bo); + heap_free(slab); + slab = next; + } +} + void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) { struct wined3d_command_buffer_vk *buffer = &context_vk->current_command_buffer; @@ -409,6 +586,7 @@ void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) wined3d_context_vk_wait_command_buffer(context_vk, buffer->id - 1); context_vk->completed_command_buffer_id = buffer->id; wined3d_context_vk_cleanup_resources(context_vk); + wine_rb_destroy(&context_vk->bo_slab_available, wined3d_context_vk_destroy_bo_slab, context_vk); heap_free(context_vk->submitted.buffers); heap_free(context_vk->retired.objects); @@ -576,6 +754,18 @@ void wined3d_context_vk_image_barrier(struct wined3d_context_vk *context_vk, VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, src_stage_mask, dst_stage_mask, 0, 0, NULL, 0, NULL, 1, &barrier)); } +static int wined3d_bo_slab_vk_compare(const void *key, const struct wine_rb_entry *entry) +{ + const struct wined3d_bo_slab_vk *slab = WINE_RB_ENTRY_VALUE(entry, const struct wined3d_bo_slab_vk, entry); + const struct wined3d_bo_slab_vk_key *k = key; + + if (k->memory_type != slab->bo.memory_type) + return k->memory_type - slab->bo.memory_type; + if (k->usage != slab->bo.usage) + return k->usage - slab->bo.usage; + return k->size - slab->bo.size; +} + HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain) { VkCommandPoolCreateInfo command_pool_info; @@ -604,5 +794,7 @@ HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wi } context_vk->current_command_buffer.id = 1; + wine_rb_init(&context_vk->bo_slab_available, wined3d_bo_slab_vk_compare); + return WINED3D_OK; } diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 9adb978b1c7..89d7096f3c1 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -4326,7 +4326,7 @@ static void wined3d_texture_vk_upload_data(struct wined3d_context *context, dst_texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dst_texture_vk->vk_image, aspect_mask); - region.bufferOffset = dst_offset; + region.bufferOffset = staging_bo.buffer_offset + dst_offset; region.bufferRowLength = (dst_row_pitch / src_format->block_byte_count) * src_format->block_width; if (dst_row_pitch) region.bufferImageHeight = (dst_slice_pitch / dst_row_pitch) * src_format->block_height; @@ -4461,7 +4461,7 @@ static void wined3d_texture_vk_download_data(struct wined3d_context *context, src_texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, src_texture_vk->vk_image, aspect_mask); - region.bufferOffset = 0; + region.bufferOffset = staging_bo.buffer_offset; region.bufferRowLength = 0; region.bufferImageHeight = 0; region.imageSubresource.aspectMask = aspect_mask; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fee61266c16..244c320734c 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1523,15 +1523,36 @@ struct wined3d_bo_vk { VkBuffer vk_buffer; struct wined3d_allocator_block *memory; + struct wined3d_bo_slab_vk *slab; VkDeviceMemory vk_memory; + VkDeviceSize buffer_offset; VkDeviceSize memory_offset; + VkDeviceSize size; + VkBufferUsageFlags usage; VkMemoryPropertyFlags memory_type; uint64_t command_buffer_id; }; +struct wined3d_bo_slab_vk_key +{ + VkMemoryPropertyFlags memory_type; + VkBufferUsageFlags usage; + VkDeviceSize size; +}; + +struct wined3d_bo_slab_vk +{ + struct wine_rb_entry entry; + struct wined3d_bo_slab_vk *next; + struct wined3d_bo_vk bo; + unsigned int map_count; + void *map_ptr; + uint32_t map; +}; + struct wined3d_bo_address { UINT_PTR buffer_object; @@ -2194,6 +2215,7 @@ enum wined3d_retired_object_type_vk WINED3D_RETIRED_FREE_VK, WINED3D_RETIRED_MEMORY_VK, WINED3D_RETIRED_ALLOCATOR_BLOCK_VK, + WINED3D_RETIRED_BO_SLAB_SLICE_VK, WINED3D_RETIRED_BUFFER_VK, WINED3D_RETIRED_IMAGE_VK, }; @@ -2206,6 +2228,11 @@ struct wined3d_retired_object_vk struct wined3d_retired_object_vk *next; VkDeviceMemory vk_memory; struct wined3d_allocator_block *block; + struct + { + struct wined3d_bo_slab_vk *slab; + size_t idx; + } slice; VkBuffer vk_buffer; VkImage vk_image; } u; @@ -2238,6 +2265,7 @@ struct wined3d_context_vk } submitted; struct wined3d_retired_objects_vk retired; + struct wine_rb_tree bo_slab_available; }; static inline struct wined3d_context_vk *wined3d_context_vk(struct wined3d_context *context) @@ -3448,6 +3476,7 @@ static inline struct wined3d_device_gl *wined3d_device_gl(struct wined3d_device #define WINED3D_ALLOCATOR_CHUNK_SIZE (64 * 1024 * 1024) #define WINED3D_ALLOCATOR_CHUNK_ORDER_COUNT 15 #define WINED3D_ALLOCATOR_MIN_BLOCK_SIZE (WINED3D_ALLOCATOR_CHUNK_SIZE >> (WINED3D_ALLOCATOR_CHUNK_ORDER_COUNT - 1)) +#define WINED3D_SLAB_BO_MIN_OBJECT_ALIGN 16 struct wined3d_allocator_chunk { diff --git a/include/wine/rbtree.h b/include/wine/rbtree.h index dc50b5e712f..8aae29c8c10 100644 --- a/include/wine/rbtree.h +++ b/include/wine/rbtree.h @@ -389,4 +389,20 @@ static inline void wine_rb_remove_key(struct wine_rb_tree *tree, const void *key if (entry) wine_rb_remove(tree, entry); } +static inline void wine_rb_replace(struct wine_rb_tree *tree, struct wine_rb_entry *dst, struct wine_rb_entry *src) +{ + if (!(src->parent = dst->parent)) + tree->root = src; + else if (dst->parent->left == dst) + dst->parent->left = src; + else + dst->parent->right = src; + + if ((src->left = dst->left)) + src->left->parent = src; + if ((src->right = dst->right)) + src->right->parent = src; + src->flags = dst->flags; +} + #endif /* __WINE_WINE_RBTREE_H */ -- 2.20.1

1 0

[PATCH 4/5] wined3d: Implement Vulkan texture downloads.
by Henri Verbeet April 20, 2020

April 20, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/texture.c | 174 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 173 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 98bc8a510ce..9adb978b1c7 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -4363,7 +4363,151 @@ static void wined3d_texture_vk_download_data(struct wined3d_context *context, const struct wined3d_format *dst_format, unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, unsigned int dst_row_pitch, unsigned int dst_slice_pitch) { - FIXME("Not implemented.\n"); + struct wined3d_texture_vk *src_texture_vk = wined3d_texture_vk(src_texture); + struct wined3d_context_vk *context_vk = wined3d_context_vk(context); + unsigned int src_level, src_width, src_height, src_depth; + struct wined3d_texture_sub_resource *sub_resource; + unsigned int src_row_pitch, src_slice_pitch; + struct wined3d_bo_address staging_bo_addr; + const struct wined3d_vk_info *vk_info; + VkCommandBuffer vk_command_buffer; + struct wined3d_bo_vk staging_bo; + VkImageAspectFlags aspect_mask; + struct wined3d_range range; + VkBufferImageCopy region; + void *map_ptr; + + TRACE("context %p, src_texture %p, src_sub_resource_idx %u, src_location %s, src_box %s, dst_bo_addr %s, " + "dst_format %s, dst_x %u, dst_y %u, dst_z %u, dst_row_pitch %u, dst_slice_pitch %u.\n", + context, src_texture, src_sub_resource_idx, wined3d_debug_location(src_location), + debug_box(src_box), debug_bo_address(dst_bo_addr), debug_d3dformat(dst_format->id), + dst_x, dst_y, dst_z, dst_row_pitch, dst_slice_pitch); + + if (src_location != WINED3D_LOCATION_TEXTURE_RGB) + { + FIXME("Unhandled location %s.\n", wined3d_debug_location(src_location)); + return; + } + + src_level = src_sub_resource_idx % src_texture->level_count; + src_width = wined3d_texture_get_level_width(src_texture, src_level); + src_height = wined3d_texture_get_level_height(src_texture, src_level); + src_depth = wined3d_texture_get_level_depth(src_texture, src_level); + if (src_box->left || src_box->top || src_box->right != src_width || src_box->bottom != src_height + || src_box->front || src_box->back != src_depth) + { + FIXME("Unhandled source box %s.\n", debug_box(src_box)); + return; + } + + if (dst_bo_addr->buffer_object) + { + FIXME("Unhandled buffer object %#lx.\n", dst_bo_addr->buffer_object); + return; + } + + if (dst_format->id != src_texture->resource.format->id) + { + FIXME("Unhandled format conversion (%s -> %s).\n", + debug_d3dformat(dst_format->id), + debug_d3dformat(src_texture->resource.format->id)); + return; + } + + if (dst_x || dst_y || dst_z) + { + FIXME("Unhandled destination (%u, %u, %u).\n", dst_x, dst_y, dst_z); + return; + } + + if (wined3d_resource_get_sample_count(&src_texture_vk->t.resource) > 1) + { + FIXME("Not supported for multisample textures.\n"); + return; + } + + aspect_mask = vk_aspect_mask_from_format(src_texture->resource.format); + if (wined3d_popcount(aspect_mask) > 1) + { + FIXME("Unhandled multi-aspect format %s.\n", debug_d3dformat(src_texture->resource.format->id)); + return; + } + + wined3d_texture_get_pitch(src_texture, src_level, &src_row_pitch, &src_slice_pitch); + if (src_texture->resource.type == WINED3D_RTYPE_TEXTURE_1D) + src_row_pitch = dst_row_pitch = 0; + if (src_texture->resource.type != WINED3D_RTYPE_TEXTURE_3D) + src_slice_pitch = dst_slice_pitch = 0; + + sub_resource = &src_texture_vk->t.sub_resources[src_sub_resource_idx]; + vk_info = context_vk->vk_info; + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) + { + ERR("Failed to get command buffer.\n"); + return; + } + + if (!wined3d_context_vk_create_bo(context_vk, sub_resource->size, + VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)) + { + ERR("Failed to create staging bo.\n"); + return; + } + + wined3d_context_vk_image_barrier(context_vk, vk_command_buffer, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, + vk_access_mask_from_bind_flags(src_texture_vk->t.resource.bind_flags), + VK_ACCESS_TRANSFER_READ_BIT, + src_texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + src_texture_vk->vk_image, aspect_mask); + + region.bufferOffset = 0; + region.bufferRowLength = 0; + region.bufferImageHeight = 0; + region.imageSubresource.aspectMask = aspect_mask; + region.imageSubresource.mipLevel = src_level; + region.imageSubresource.baseArrayLayer = src_sub_resource_idx / src_texture_vk->t.level_count; + region.imageSubresource.layerCount = 1; + region.imageOffset.x = 0; + region.imageOffset.y = 0; + region.imageOffset.z = 0; + region.imageExtent.width = src_width; + region.imageExtent.height = src_height; + region.imageExtent.depth = src_depth; + + VK_CALL(vkCmdCopyImageToBuffer(vk_command_buffer, src_texture_vk->vk_image, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, staging_bo.vk_buffer, 1, &region)); + + wined3d_context_vk_image_barrier(context_vk, vk_command_buffer, + VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_TRANSFER_READ_BIT, + vk_access_mask_from_bind_flags(src_texture_vk->t.resource.bind_flags), + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, src_texture_vk->layout, + src_texture_vk->vk_image, aspect_mask); + + src_texture_vk->command_buffer_id = context_vk->current_command_buffer.id; + staging_bo.command_buffer_id = context_vk->current_command_buffer.id; + wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL); + wined3d_context_vk_wait_command_buffer(context_vk, src_texture_vk->command_buffer_id); + + staging_bo_addr.buffer_object = (uintptr_t)&staging_bo; + staging_bo_addr.addr = (uint8_t *)NULL; + if (!(map_ptr = wined3d_context_map_bo_address(context, &staging_bo_addr, + sub_resource->size, 0, WINED3D_MAP_READ))) + { + ERR("Failed to map staging bo.\n"); + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); + return; + } + + wined3d_format_copy_data(dst_format, map_ptr, src_row_pitch, src_slice_pitch, + dst_bo_addr->addr, dst_row_pitch, dst_slice_pitch, src_box->right - src_box->left, + src_box->bottom - src_box->top, src_box->back - src_box->front); + + range.offset = 0; + range.size = sub_resource->size; + wined3d_context_unmap_bo_address(context, &staging_bo_addr, 0, 1, &range); + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); } static BOOL wined3d_texture_vk_load_texture(struct wined3d_texture_vk *texture_vk, @@ -4392,6 +4536,31 @@ static BOOL wined3d_texture_vk_load_texture(struct wined3d_texture_vk *texture_v return TRUE; } +static BOOL wined3d_texture_vk_load_sysmem(struct wined3d_texture_vk *texture_vk, + unsigned int sub_resource_idx, struct wined3d_context *context) +{ + struct wined3d_texture_sub_resource *sub_resource; + unsigned int level, row_pitch, slice_pitch; + struct wined3d_bo_address data; + struct wined3d_box src_box; + + sub_resource = &texture_vk->t.sub_resources[sub_resource_idx]; + if (!(sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)) + { + ERR("Unimplemented load from %s.\n", wined3d_debug_location(sub_resource->locations)); + return FALSE; + } + + level = sub_resource_idx % texture_vk->t.level_count; + wined3d_texture_get_memory(&texture_vk->t, sub_resource_idx, &data, WINED3D_LOCATION_SYSMEM); + wined3d_texture_get_level_box(&texture_vk->t, level, &src_box); + wined3d_texture_get_pitch(&texture_vk->t, level, &row_pitch, &slice_pitch); + wined3d_texture_vk_download_data(context, &texture_vk->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB, + &src_box, &data, texture_vk->t.resource.format, 0, 0, 0, row_pitch, slice_pitch); + + return TRUE; +} + static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk) { @@ -4584,6 +4753,9 @@ static BOOL wined3d_texture_vk_load_location(struct wined3d_texture *texture, case WINED3D_LOCATION_TEXTURE_RGB: return wined3d_texture_vk_load_texture(wined3d_texture_vk(texture), sub_resource_idx, context); + case WINED3D_LOCATION_SYSMEM: + return wined3d_texture_vk_load_sysmem(wined3d_texture_vk(texture), sub_resource_idx, context); + default: FIXME("Unimplemented location %s.\n", wined3d_debug_location(location)); return FALSE; -- 2.20.1

1 0

[PATCH 3/5] wined3d: Implement Vulkan texture uploads.
by Henri Verbeet April 20, 2020

April 20, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_vk.c | 26 ++++ dlls/wined3d/texture.c | 213 ++++++++++++++++++++++++++++++++- dlls/wined3d/utils.c | 30 +++++ dlls/wined3d/wined3d_private.h | 22 ++++ 4 files changed, 288 insertions(+), 3 deletions(-) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 35a0c655ef3..0d90c40fe64 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -550,6 +550,32 @@ void wined3d_context_vk_wait_command_buffer(struct wined3d_context_vk *context_v ERR("Failed to find fence for command buffer with id 0x%s.\n", wine_dbgstr_longlong(id)); } +void wined3d_context_vk_image_barrier(struct wined3d_context_vk *context_vk, + VkCommandBuffer vk_command_buffer, VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask, + VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask, VkImageLayout old_layout, + VkImageLayout new_layout, VkImage image, VkImageAspectFlags aspect_mask) +{ + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + VkImageMemoryBarrier barrier; + + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.pNext = NULL; + barrier.srcAccessMask = src_access_mask; + barrier.dstAccessMask = dst_access_mask; + barrier.oldLayout = old_layout; + barrier.newLayout = new_layout; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange.aspectMask = aspect_mask; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; + + VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, src_stage_mask, dst_stage_mask, 0, 0, NULL, 0, NULL, 1, &barrier)); +} + HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain) { VkCommandPoolCreateInfo command_pool_info; diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 66cee442ff9..98bc8a510ce 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -4218,7 +4218,143 @@ static void wined3d_texture_vk_upload_data(struct wined3d_context *context, struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx, unsigned int dst_location, unsigned int dst_x, unsigned int dst_y, unsigned int dst_z) { - FIXME("Not implemented.\n"); + struct wined3d_texture_vk *dst_texture_vk = wined3d_texture_vk(dst_texture); + struct wined3d_context_vk *context_vk = wined3d_context_vk(context); + unsigned int dst_level, dst_row_pitch, dst_slice_pitch; + struct wined3d_texture_sub_resource *sub_resource; + struct wined3d_bo_address staging_bo_addr; + const struct wined3d_vk_info *vk_info; + VkCommandBuffer vk_command_buffer; + struct wined3d_bo_vk staging_bo; + VkImageAspectFlags aspect_mask; + size_t src_offset, dst_offset; + struct wined3d_range range; + VkBufferImageCopy region; + void *map_ptr; + + TRACE("context %p, src_bo_addr %s, src_format %s, src_box %s, src_row_pitch %u, src_slice_pitch %u, " + "dst_texture %p, dst_sub_resource_idx %u, dst_location %s, dst_x %u, dst_y %u, dst_z %u.\n", + context, debug_const_bo_address(src_bo_addr), debug_d3dformat(src_format->id), debug_box(src_box), + src_row_pitch, src_slice_pitch, dst_texture, dst_sub_resource_idx, + wined3d_debug_location(dst_location), dst_x, dst_y, dst_z); + + if (src_bo_addr->buffer_object) + { + FIXME("Unhandled buffer object %#lx.\n", src_bo_addr->buffer_object); + return; + } + + if (src_format->id != dst_texture->resource.format->id) + { + FIXME("Unhandled format conversion (%s -> %s).\n", + debug_d3dformat(src_format->id), + debug_d3dformat(dst_texture->resource.format->id)); + return; + } + + dst_level = dst_sub_resource_idx % dst_texture->level_count; + wined3d_texture_get_pitch(dst_texture, dst_level, &dst_row_pitch, &dst_slice_pitch); + if (dst_texture->resource.type == WINED3D_RTYPE_TEXTURE_1D) + src_row_pitch = dst_row_pitch = 0; + if (dst_texture->resource.type != WINED3D_RTYPE_TEXTURE_3D) + src_slice_pitch = dst_slice_pitch = 0; + + if (dst_location != WINED3D_LOCATION_TEXTURE_RGB) + { + FIXME("Unhandled location %s.\n", wined3d_debug_location(dst_location)); + return; + } + + if (wined3d_resource_get_sample_count(&dst_texture_vk->t.resource) > 1) + { + FIXME("Not supported for multisample textures.\n"); + return; + } + + aspect_mask = vk_aspect_mask_from_format(dst_texture->resource.format); + if (wined3d_popcount(aspect_mask) > 1) + { + FIXME("Unhandled multi-aspect format %s.\n", debug_d3dformat(dst_texture->resource.format->id)); + return; + } + + sub_resource = &dst_texture_vk->t.sub_resources[dst_sub_resource_idx]; + vk_info = context_vk->vk_info; + + src_offset = src_box->front * src_slice_pitch + + (src_box->top / src_format->block_height) * src_row_pitch + + (src_box->left / src_format->block_width) * src_format->block_byte_count; + dst_offset = dst_z * src_slice_pitch + + (dst_y / src_format->block_height) * src_row_pitch + + (dst_x / src_format->block_width) * src_format->block_byte_count; + + if (!wined3d_context_vk_create_bo(context_vk, sub_resource->size, + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)) + { + ERR("Failed to create staging bo.\n"); + return; + } + + staging_bo_addr.buffer_object = (uintptr_t)&staging_bo; + staging_bo_addr.addr = NULL; + if (!(map_ptr = wined3d_context_map_bo_address(context, &staging_bo_addr, + sub_resource->size, 0, WINED3D_MAP_DISCARD | WINED3D_MAP_WRITE))) + { + ERR("Failed to map staging bo.\n"); + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); + return; + } + + wined3d_format_copy_data(src_format, src_bo_addr->addr + src_offset, src_row_pitch, src_slice_pitch, + (uint8_t *)map_ptr + dst_offset, dst_row_pitch, dst_slice_pitch, src_box->right - src_box->left, + src_box->bottom - src_box->top, src_box->back - src_box->front); + + range.offset = 0; + range.size = sub_resource->size; + wined3d_context_unmap_bo_address(context, &staging_bo_addr, 0, 1, &range); + + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) + { + ERR("Failed to get command buffer.\n"); + return; + } + + wined3d_context_vk_image_barrier(context_vk, vk_command_buffer, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, + vk_access_mask_from_bind_flags(dst_texture_vk->t.resource.bind_flags), + VK_ACCESS_TRANSFER_WRITE_BIT, + dst_texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + dst_texture_vk->vk_image, aspect_mask); + + region.bufferOffset = dst_offset; + region.bufferRowLength = (dst_row_pitch / src_format->block_byte_count) * src_format->block_width; + if (dst_row_pitch) + region.bufferImageHeight = (dst_slice_pitch / dst_row_pitch) * src_format->block_height; + else + region.bufferImageHeight = 1; + region.imageSubresource.aspectMask = aspect_mask; + region.imageSubresource.mipLevel = dst_level; + region.imageSubresource.baseArrayLayer = dst_sub_resource_idx / dst_texture_vk->t.level_count; + region.imageSubresource.layerCount = 1; + region.imageOffset.x = dst_x; + region.imageOffset.y = dst_y; + region.imageOffset.z = dst_z; + region.imageExtent.width = src_box->right - src_box->left; + region.imageExtent.height = src_box->bottom - src_box->top; + region.imageExtent.depth = src_box->back - src_box->front; + + VK_CALL(vkCmdCopyBufferToImage(vk_command_buffer, staging_bo.vk_buffer, + dst_texture_vk->vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region)); + + wined3d_context_vk_image_barrier(context_vk, vk_command_buffer, + VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_ACCESS_TRANSFER_WRITE_BIT, + vk_access_mask_from_bind_flags(dst_texture_vk->t.resource.bind_flags), + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, dst_texture_vk->layout, + dst_texture_vk->vk_image, aspect_mask); + dst_texture_vk->command_buffer_id = context_vk->current_command_buffer.id; + staging_bo.command_buffer_id = context_vk->current_command_buffer.id; + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); } static void wined3d_texture_vk_download_data(struct wined3d_context *context, @@ -4230,6 +4366,32 @@ static void wined3d_texture_vk_download_data(struct wined3d_context *context, FIXME("Not implemented.\n"); } +static BOOL wined3d_texture_vk_load_texture(struct wined3d_texture_vk *texture_vk, + unsigned int sub_resource_idx, struct wined3d_context *context) +{ + struct wined3d_texture_sub_resource *sub_resource; + unsigned int level, row_pitch, slice_pitch; + struct wined3d_bo_address data; + struct wined3d_box src_box; + + sub_resource = &texture_vk->t.sub_resources[sub_resource_idx]; + if (!(sub_resource->locations & WINED3D_LOCATION_SYSMEM)) + { + ERR("Unimplemented load from %s.\n", wined3d_debug_location(sub_resource->locations)); + return FALSE; + } + + level = sub_resource_idx % texture_vk->t.level_count; + wined3d_texture_get_memory(&texture_vk->t, sub_resource_idx, &data, WINED3D_LOCATION_SYSMEM); + wined3d_texture_get_level_box(&texture_vk->t, level, &src_box); + wined3d_texture_get_pitch(&texture_vk->t, level, &row_pitch, &slice_pitch); + wined3d_texture_vk_upload_data(context, wined3d_const_bo_address(&data), texture_vk->t.resource.format, + &src_box, row_pitch, slice_pitch, &texture_vk->t, sub_resource_idx, + WINED3D_LOCATION_TEXTURE_RGB, 0, 0, 0); + + return TRUE; +} + static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk) { @@ -4239,6 +4401,7 @@ static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *textur struct wined3d_adapter_vk *adapter_vk; struct wined3d_device_vk *device_vk; struct wined3d_resource *resource; + VkCommandBuffer vk_command_buffer; VkImageCreateInfo create_info; unsigned int memory_type_idx; VkResult vr; @@ -4246,6 +4409,12 @@ static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *textur if (texture_vk->t.flags & WINED3D_TEXTURE_RGB_ALLOCATED) return TRUE; + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) + { + ERR("Failed to get command buffer.\n"); + return FALSE; + } + resource = &texture_vk->t.resource; device_vk = wined3d_device_vk(resource->device); adapter_vk = wined3d_adapter_vk(device_vk->d.adapter); @@ -4299,6 +4468,28 @@ static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *textur if (resource->bind_flags & WINED3D_BIND_UNORDERED_ACCESS) create_info.usage |= VK_IMAGE_USAGE_STORAGE_BIT; + texture_vk->layout = VK_IMAGE_LAYOUT_GENERAL; + if (wined3d_popcount(resource->bind_flags == 1)) + { + switch (resource->bind_flags) + { + case WINED3D_BIND_RENDER_TARGET: + texture_vk->layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + break; + + case WINED3D_BIND_DEPTH_STENCIL: + texture_vk->layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + break; + + case WINED3D_BIND_SHADER_RESOURCE: + texture_vk->layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + break; + + default: + break; + } + } + create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; create_info.queueFamilyIndexCount = 0; create_info.pQueueFamilyIndices = NULL; @@ -4345,6 +4536,13 @@ static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *textur return FALSE; } + texture_vk->command_buffer_id = context_vk->current_command_buffer.id; + wined3d_context_vk_image_barrier(context_vk, vk_command_buffer, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + 0, 0, + VK_IMAGE_LAYOUT_UNDEFINED, texture_vk->layout, + texture_vk->vk_image, vk_aspect_mask_from_format(&format_vk->f)); + texture_vk->t.flags |= WINED3D_TEXTURE_RGB_ALLOCATED; TRACE("Created image 0x%s, memory 0x%s for texture %p.\n", @@ -4378,9 +4576,18 @@ static BOOL wined3d_texture_vk_prepare_location(struct wined3d_texture *texture, static BOOL wined3d_texture_vk_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location) { - FIXME("Not implemented.\n"); + if (!wined3d_texture_vk_prepare_location(texture, sub_resource_idx, context, location)) + return FALSE; - return FALSE; + switch (location) + { + case WINED3D_LOCATION_TEXTURE_RGB: + return wined3d_texture_vk_load_texture(wined3d_texture_vk(texture), sub_resource_idx, context); + + default: + FIXME("Unimplemented location %s.\n", wined3d_debug_location(location)); + return FALSE; + } } static void wined3d_texture_vk_unload_location(struct wined3d_texture *texture, diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 926a6a51edf..d08485c8d4b 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -5977,6 +5977,36 @@ enum wined3d_format_id pixelformat_for_depth(DWORD depth) } } +void wined3d_format_copy_data(const struct wined3d_format *format, const uint8_t *src, + unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, + unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d) +{ + unsigned int row_block_count, row_count, row_size, slice, row; + unsigned int slice_count = d; + const uint8_t *src_row; + uint8_t *dst_row; + + row_block_count = (w + format->block_width - 1) / format->block_width; + row_count = (h + format->block_height - 1) / format->block_height; + row_size = row_block_count * format->block_byte_count; + + if (src_row_pitch == row_size && dst_row_pitch == row_size && src_slice_pitch == dst_slice_pitch) + { + memcpy(dst, src, slice_count * row_count * row_size); + return; + } + + for (slice = 0; slice < slice_count; ++slice) + { + for (row = 0; row < row_count; ++row) + { + src_row = &src[slice * src_slice_pitch + row * src_row_pitch]; + dst_row = &dst[slice * dst_slice_pitch + row * dst_row_pitch]; + memcpy(dst_row, src_row, row_size); + } + } +} + void multiply_matrix(struct wined3d_matrix *dst, const struct wined3d_matrix *src1, const struct wined3d_matrix *src2) { struct wined3d_matrix tmp; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index de07c5909aa..fee61266c16 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2261,6 +2261,10 @@ void wined3d_context_vk_destroy_image(struct wined3d_context_vk *context_vk, void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk, VkDeviceMemory vk_memory, uint64_t command_buffer_id) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_get_command_buffer(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; +void wined3d_context_vk_image_barrier(struct wined3d_context_vk *context_vk, + VkCommandBuffer vk_command_buffer, VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask, + VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask, VkImageLayout old_layout, + VkImageLayout new_layout, VkImage image, VkImageAspectFlags aspect_mask) DECLSPEC_HIDDEN; HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; void wined3d_context_vk_submit_command_buffer(struct wined3d_context_vk *context_vk, @@ -3958,6 +3962,7 @@ struct wined3d_texture_vk VkImage vk_image; struct wined3d_allocator_block *memory; VkDeviceMemory vk_memory; + enum VkImageLayout layout; uint64_t command_buffer_id; }; @@ -5155,6 +5160,9 @@ UINT wined3d_format_calculate_size(const struct wined3d_format *format, UINT alignment, UINT width, UINT height, UINT depth) DECLSPEC_HIDDEN; DWORD wined3d_format_convert_from_float(const struct wined3d_format *format, const struct wined3d_color *color) DECLSPEC_HIDDEN; +void wined3d_format_copy_data(const struct wined3d_format *format, const uint8_t *src, + unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, + unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d) DECLSPEC_HIDDEN; void wined3d_format_get_float_color_key(const struct wined3d_format *format, const struct wined3d_color_key *key, struct wined3d_color *float_colors) DECLSPEC_HIDDEN; BOOL wined3d_format_is_depth_view(enum wined3d_format_id resource_format_id, @@ -5538,6 +5546,20 @@ static inline BOOL wined3d_bitmap_get_range(const DWORD *bitmap, unsigned int bi return TRUE; } +static inline VkImageAspectFlags vk_aspect_mask_from_format(const struct wined3d_format *format) +{ + VkImageAspectFlags mask = 0; + + if (format->depth_size) + mask |= VK_IMAGE_ASPECT_DEPTH_BIT; + if (format->stencil_size) + mask |= VK_IMAGE_ASPECT_STENCIL_BIT; + if (!mask || format->red_size || format->green_size || format->blue_size || format->alpha_size) + mask |= VK_IMAGE_ASPECT_COLOR_BIT; + + return mask; +} + /* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */ #define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL" -- 2.20.1

1 0

[PATCH 2/5] wined3d: Create Vulkan images for texture resources.
by Henri Verbeet April 20, 2020

April 20, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_vk.c | 36 +++++++- dlls/wined3d/texture.c | 160 ++++++++++++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 15 ++++ 3 files changed, 205 insertions(+), 6 deletions(-) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index b3239a4f9ee..35a0c655ef3 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -86,7 +86,7 @@ VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_cont return vk_memory; } -static struct wined3d_allocator_block *wined3d_context_vk_allocate_memory(struct wined3d_context_vk *context_vk, +struct wined3d_allocator_block *wined3d_context_vk_allocate_memory(struct wined3d_context_vk *context_vk, unsigned int memory_type, VkDeviceSize size, VkDeviceMemory *vk_memory) { struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); @@ -198,7 +198,7 @@ static struct wined3d_retired_object_vk *wined3d_context_vk_get_retired_object_v return &retired->objects[retired->count++]; } -static void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk, +void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk, VkDeviceMemory vk_memory, uint64_t command_buffer_id) { struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); @@ -223,7 +223,7 @@ static void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context o->command_buffer_id = command_buffer_id; } -static void wined3d_context_vk_destroy_allocator_block(struct wined3d_context_vk *context_vk, +void wined3d_context_vk_destroy_allocator_block(struct wined3d_context_vk *context_vk, struct wined3d_allocator_block *block, uint64_t command_buffer_id) { struct wined3d_retired_object_vk *o; @@ -271,6 +271,31 @@ static void wined3d_context_vk_destroy_buffer(struct wined3d_context_vk *context o->command_buffer_id = command_buffer_id; } +void wined3d_context_vk_destroy_image(struct wined3d_context_vk *context_vk, + VkImage vk_image, uint64_t command_buffer_id) +{ + struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + struct wined3d_retired_object_vk *o; + + if (context_vk->completed_command_buffer_id > command_buffer_id) + { + VK_CALL(vkDestroyImage(device_vk->vk_device, vk_image, NULL)); + TRACE("Destroyed image 0x%s.\n", wine_dbgstr_longlong(vk_image)); + return; + } + + if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk))) + { + ERR("Leaking image 0x%s.\n", wine_dbgstr_longlong(vk_image)); + return; + } + + o->type = WINED3D_RETIRED_IMAGE_VK; + o->u.vk_image = vk_image; + o->command_buffer_id = command_buffer_id; +} + void wined3d_context_vk_destroy_bo(struct wined3d_context_vk *context_vk, const struct wined3d_bo_vk *bo) { TRACE("context_vk %p, bo %p.\n", context_vk, bo); @@ -345,6 +370,11 @@ static void wined3d_context_vk_cleanup_resources(struct wined3d_context_vk *cont TRACE("Destroyed buffer 0x%s.\n", wine_dbgstr_longlong(o->u.vk_buffer)); break; + case WINED3D_RETIRED_IMAGE_VK: + VK_CALL(vkDestroyImage(device_vk->vk_device, o->u.vk_image, NULL)); + TRACE("Destroyed image 0x%s.\n", wine_dbgstr_longlong(o->u.vk_image)); + break; + default: ERR("Unhandled object type %#x.\n", o->type); break; diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 85f09ee3489..66cee442ff9 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -4230,6 +4230,129 @@ static void wined3d_texture_vk_download_data(struct wined3d_context *context, FIXME("Not implemented.\n"); } +static BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *texture_vk, + struct wined3d_context_vk *context_vk) +{ + const struct wined3d_format_vk *format_vk; + VkMemoryRequirements memory_requirements; + const struct wined3d_vk_info *vk_info; + struct wined3d_adapter_vk *adapter_vk; + struct wined3d_device_vk *device_vk; + struct wined3d_resource *resource; + VkImageCreateInfo create_info; + unsigned int memory_type_idx; + VkResult vr; + + if (texture_vk->t.flags & WINED3D_TEXTURE_RGB_ALLOCATED) + return TRUE; + + resource = &texture_vk->t.resource; + device_vk = wined3d_device_vk(resource->device); + adapter_vk = wined3d_adapter_vk(device_vk->d.adapter); + format_vk = wined3d_format_vk(resource->format); + vk_info = context_vk->vk_info; + + create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + create_info.pNext = NULL; + + create_info.flags = 0; + if (wined3d_format_is_typeless(&format_vk->f)) + create_info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; + + switch (resource->type) + { + case WINED3D_RTYPE_TEXTURE_1D: + create_info.imageType = VK_IMAGE_TYPE_1D; + break; + case WINED3D_RTYPE_TEXTURE_2D: + create_info.imageType = VK_IMAGE_TYPE_2D; + if (texture_vk->t.layer_count >= 6 && resource->width == resource->height) + create_info.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; + break; + case WINED3D_RTYPE_TEXTURE_3D: + create_info.imageType = VK_IMAGE_TYPE_3D; + if (resource->bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_UNORDERED_ACCESS)) + create_info.flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; + break; + default: + ERR("Invalid resource type %s.\n", debug_d3dresourcetype(resource->type)); + create_info.imageType = VK_IMAGE_TYPE_2D; + break; + } + + create_info.format = format_vk->vk_format; + create_info.extent.width = resource->width; + create_info.extent.height = resource->height; + create_info.extent.depth = resource->depth; + create_info.mipLevels = texture_vk->t.level_count; + create_info.arrayLayers = texture_vk->t.layer_count; + create_info.samples = max(1, wined3d_resource_get_sample_count(resource)); + create_info.tiling = VK_IMAGE_TILING_OPTIMAL; + + create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; + if (resource->bind_flags & WINED3D_BIND_SHADER_RESOURCE) + create_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; + if (resource->bind_flags & WINED3D_BIND_RENDER_TARGET) + create_info.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL) + create_info.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (resource->bind_flags & WINED3D_BIND_UNORDERED_ACCESS) + create_info.usage |= VK_IMAGE_USAGE_STORAGE_BIT; + + create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + create_info.queueFamilyIndexCount = 0; + create_info.pQueueFamilyIndices = NULL; + create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + if ((vr = VK_CALL(vkCreateImage(device_vk->vk_device, &create_info, NULL, &texture_vk->vk_image))) < 0) + { + ERR("Failed to create Vulkan image, vr %s.\n", wined3d_debug_vkresult(vr)); + return FALSE; + } + + VK_CALL(vkGetImageMemoryRequirements(device_vk->vk_device, texture_vk->vk_image, &memory_requirements)); + + memory_type_idx = wined3d_adapter_vk_get_memory_type_index(adapter_vk, + memory_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (memory_type_idx == ~0u) + { + ERR("Failed to find suitable memory type.\n"); + VK_CALL(vkDestroyImage(device_vk->vk_device, texture_vk->vk_image, NULL)); + texture_vk->vk_image = VK_NULL_HANDLE; + return FALSE; + } + + texture_vk->memory = wined3d_context_vk_allocate_memory(context_vk, + memory_type_idx, memory_requirements.size, &texture_vk->vk_memory); + if (!texture_vk->vk_memory) + { + ERR("Failed to allocate image memory.\n"); + VK_CALL(vkDestroyImage(device_vk->vk_device, texture_vk->vk_image, NULL)); + texture_vk->vk_image = VK_NULL_HANDLE; + return FALSE; + } + + if ((vr = VK_CALL(vkBindImageMemory(device_vk->vk_device, texture_vk->vk_image, + texture_vk->vk_memory, texture_vk->memory ? texture_vk->memory->offset : 0))) < 0) + { + WARN("Failed to bind memory, vr %s.\n", wined3d_debug_vkresult(vr)); + if (texture_vk->memory) + wined3d_allocator_block_free(texture_vk->memory); + else + VK_CALL(vkFreeMemory(device_vk->vk_device, texture_vk->vk_memory, NULL)); + texture_vk->vk_memory = VK_NULL_HANDLE; + VK_CALL(vkDestroyImage(device_vk->vk_device, texture_vk->vk_image, NULL)); + texture_vk->vk_image = VK_NULL_HANDLE; + return FALSE; + } + + texture_vk->t.flags |= WINED3D_TEXTURE_RGB_ALLOCATED; + + TRACE("Created image 0x%s, memory 0x%s for texture %p.\n", + wine_dbgstr_longlong(texture_vk->vk_image), wine_dbgstr_longlong(texture_vk->vk_memory), texture_vk); + + return TRUE; +} + static BOOL wined3d_texture_vk_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx, struct wined3d_context *context, unsigned int location) { @@ -4244,8 +4367,7 @@ static BOOL wined3d_texture_vk_prepare_location(struct wined3d_texture *texture, return TRUE; case WINED3D_LOCATION_TEXTURE_RGB: - /* The Vulkan image is created during resource creation. */ - return TRUE; + return wined3d_texture_vk_prepare_texture(wined3d_texture_vk(texture), wined3d_context_vk(context)); default: FIXME("Unhandled location %s.\n", wined3d_debug_location(location)); @@ -4264,7 +4386,39 @@ static BOOL wined3d_texture_vk_load_location(struct wined3d_texture *texture, static void wined3d_texture_vk_unload_location(struct wined3d_texture *texture, struct wined3d_context *context, unsigned int location) { - FIXME("texture %p, context %p, location %s.\n", texture, context, wined3d_debug_location(location)); + struct wined3d_texture_vk *texture_vk = wined3d_texture_vk(texture); + struct wined3d_context_vk *context_vk = wined3d_context_vk(context); + + TRACE("texture %p, context %p, location %s.\n", texture, context, wined3d_debug_location(location)); + + switch (location) + { + case WINED3D_LOCATION_TEXTURE_RGB: + if (texture_vk->vk_image) + { + wined3d_context_vk_destroy_image(context_vk, texture_vk->vk_image, texture_vk->command_buffer_id); + texture_vk->vk_image = VK_NULL_HANDLE; + if (texture_vk->memory) + wined3d_context_vk_destroy_allocator_block(context_vk, + texture_vk->memory, texture_vk->command_buffer_id); + else + wined3d_context_vk_destroy_memory(context_vk, + texture_vk->vk_memory, texture_vk->command_buffer_id); + texture_vk->vk_memory = VK_NULL_HANDLE; + texture_vk->memory = NULL; + } + break; + + case WINED3D_LOCATION_BUFFER: + case WINED3D_LOCATION_TEXTURE_SRGB: + case WINED3D_LOCATION_RB_MULTISAMPLE: + case WINED3D_LOCATION_RB_RESOLVED: + break; + + default: + ERR("Unhandled location %s.\n", wined3d_debug_location(location)); + break; + } } static const struct wined3d_texture_ops wined3d_texture_vk_ops = diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 7e78cb60df5..de07c5909aa 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2195,6 +2195,7 @@ enum wined3d_retired_object_type_vk WINED3D_RETIRED_MEMORY_VK, WINED3D_RETIRED_ALLOCATOR_BLOCK_VK, WINED3D_RETIRED_BUFFER_VK, + WINED3D_RETIRED_IMAGE_VK, }; struct wined3d_retired_object_vk @@ -2206,6 +2207,7 @@ struct wined3d_retired_object_vk VkDeviceMemory vk_memory; struct wined3d_allocator_block *block; VkBuffer vk_buffer; + VkImage vk_image; } u; uint64_t command_buffer_id; }; @@ -2243,13 +2245,21 @@ static inline struct wined3d_context_vk *wined3d_context_vk(struct wined3d_conte return CONTAINING_RECORD(context, struct wined3d_context_vk, c); } +struct wined3d_allocator_block *wined3d_context_vk_allocate_memory(struct wined3d_context_vk *context_vk, + unsigned int memory_type, VkDeviceSize size, VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN; VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_context_vk *context_vk, unsigned int pool, size_t size) DECLSPEC_HIDDEN; void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) DECLSPEC_HIDDEN; +void wined3d_context_vk_destroy_allocator_block(struct wined3d_context_vk *context_vk, + struct wined3d_allocator_block *block, uint64_t command_buffer_id) DECLSPEC_HIDDEN; void wined3d_context_vk_destroy_bo(struct wined3d_context_vk *context_vk, const struct wined3d_bo_vk *bo) DECLSPEC_HIDDEN; +void wined3d_context_vk_destroy_image(struct wined3d_context_vk *context_vk, + VkImage vk_image, uint64_t command_buffer_id) DECLSPEC_HIDDEN; +void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk, + VkDeviceMemory vk_memory, uint64_t command_buffer_id) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_get_command_buffer(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; @@ -3944,6 +3954,11 @@ void wined3d_texture_gl_set_compatible_renderbuffer(struct wined3d_texture_gl *t struct wined3d_texture_vk { struct wined3d_texture t; + + VkImage vk_image; + struct wined3d_allocator_block *memory; + VkDeviceMemory vk_memory; + uint64_t command_buffer_id; }; static inline struct wined3d_texture_vk *wined3d_texture_vk(struct wined3d_texture *texture) -- 2.20.1

1 0

[PATCH 1/5] wined3d: Implement Vulkan GPU buffer copies.
by Henri Verbeet April 20, 2020

April 20, 2020

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 101 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 78a8df6b8b4..35b4e8da6aa 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -697,8 +697,109 @@ static void adapter_vk_copy_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *dst, uint32_t dst_bind_flags, const struct wined3d_bo_address *src, uint32_t src_bind_flags, size_t size) { + struct wined3d_context_vk *context_vk = wined3d_context_vk(context); + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + struct wined3d_bo_vk staging_bo, *src_bo, *dst_bo; + VkBufferMemoryBarrier vk_barrier[2]; + struct wined3d_bo_address staging; + VkCommandBuffer vk_command_buffer; struct wined3d_range range; void *dst_ptr, *src_ptr; + VkBufferCopy region; + + src_bo = (struct wined3d_bo_vk *)src->buffer_object; + dst_bo = (struct wined3d_bo_vk *)dst->buffer_object; + + if (src_bo && dst_bo) + { + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) + { + ERR("Failed to get command buffer.\n"); + return; + } + + region.srcOffset = (uintptr_t)src->addr; + region.dstOffset = (uintptr_t)dst->addr; + region.size = size; + + vk_barrier[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + vk_barrier[0].pNext = NULL; + vk_barrier[0].srcAccessMask = vk_access_mask_from_bind_flags(src_bind_flags); + vk_barrier[0].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + vk_barrier[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vk_barrier[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vk_barrier[0].buffer = src_bo->vk_buffer; + vk_barrier[0].offset = region.srcOffset; + vk_barrier[0].size = region.size; + + vk_barrier[1].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; + vk_barrier[1].pNext = NULL; + vk_barrier[1].srcAccessMask = vk_access_mask_from_bind_flags(dst_bind_flags); + vk_barrier[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + vk_barrier[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vk_barrier[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + vk_barrier[1].buffer = dst_bo->vk_buffer; + vk_barrier[1].offset = region.dstOffset; + vk_barrier[1].size = region.size; + + VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL)); + + VK_CALL(vkCmdCopyBuffer(vk_command_buffer, src_bo->vk_buffer, dst_bo->vk_buffer, 1, &region)); + + vk_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; + vk_barrier[0].dstAccessMask = vk_access_mask_from_bind_flags(src_bind_flags); + + vk_barrier[1].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + vk_barrier[1].dstAccessMask = vk_access_mask_from_bind_flags(dst_bind_flags); + + VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL)); + + src_bo->command_buffer_id = context_vk->current_command_buffer.id; + dst_bo->command_buffer_id = context_vk->current_command_buffer.id; + + return; + } + + if (src_bo && !(src_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) + { + if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo))) + { + ERR("Failed to create staging bo.\n"); + return; + } + + staging.buffer_object = (uintptr_t)&staging_bo; + staging.addr = NULL; + adapter_vk_copy_bo_address(context, &staging, 0, src, src_bind_flags, size); + adapter_vk_copy_bo_address(context, dst, dst_bind_flags, &staging, 0, size); + + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); + + return; + } + + if (dst_bo && (dst_bo->command_buffer_id > context_vk->completed_command_buffer_id + || !(dst_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))) + { + if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo))) + { + ERR("Failed to create staging bo.\n"); + return; + } + + staging.buffer_object = (uintptr_t)&staging_bo; + staging.addr = NULL; + adapter_vk_copy_bo_address(context, &staging, 0, src, src_bind_flags, size); + adapter_vk_copy_bo_address(context, dst, dst_bind_flags, &staging, 0, size); + + wined3d_context_vk_destroy_bo(context_vk, &staging_bo); + + return; + } src_ptr = adapter_vk_map_bo_address(context, src, size, src_bind_flags, WINED3D_MAP_READ); dst_ptr = adapter_vk_map_bo_address(context, dst, size, dst_bind_flags, WINED3D_MAP_WRITE); -- 2.20.1

1 0