wine-devel September 2021

wine-devel@winehq.org

83 participants
748 discussions

[PATCH] wined3d: Allow constant buffers to be forced to be write-mappable.
by Jan Sikorski 09 Sep '21

09 Sep '21

Using a registry setting. Games sometimes use DEFAULT usage and no CPU access combined with UpdateSubresource() for often-changing constants, causing us to interrupt the render pass and transfer through a staging buffer on each update. In such cases forcing the buffers to be mappable greatly increases performance. Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> --- I'm not sure if that kind of change is desired upstream, but I think it's pretty useful. --- dlls/wined3d/buffer.c | 9 +++++++-- dlls/wined3d/wined3d_main.c | 5 +++++ dlls/wined3d/wined3d_private.h | 1 + 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c index da61f36af45..a42259a5ece 100644 --- a/dlls/wined3d/buffer.c +++ b/dlls/wined3d/buffer.c @@ -1139,6 +1139,7 @@ static HRESULT wined3d_buffer_init(struct wined3d_buffer *buffer, struct wined3d { const struct wined3d_format *format = wined3d_get_format(device->adapter, WINED3DFMT_R8_UNORM, desc->bind_flags); struct wined3d_resource *resource = &buffer->resource; + unsigned int access; HRESULT hr; TRACE("buffer %p, device %p, desc byte_width %u, usage %s, bind_flags %s, " @@ -1164,8 +1165,12 @@ static HRESULT wined3d_buffer_init(struct wined3d_buffer *buffer, struct wined3d return E_INVALIDARG; } + access = desc->access; + if (desc->bind_flags & WINED3D_BIND_CONSTANT_BUFFER && wined3d_settings.write_mappable_cbuffers) + access |= WINED3D_RESOURCE_ACCESS_MAP_W; + if (FAILED(hr = resource_init(resource, device, WINED3D_RTYPE_BUFFER, format, - WINED3D_MULTISAMPLE_NONE, 0, desc->usage, desc->bind_flags, desc->access, + WINED3D_MULTISAMPLE_NONE, 0, desc->usage, desc->bind_flags, access, desc->byte_width, 1, 1, desc->byte_width, parent, parent_ops, &buffer_resource_ops))) { WARN("Failed to initialize resource, hr %#x.\n", hr); @@ -1179,7 +1184,7 @@ static HRESULT wined3d_buffer_init(struct wined3d_buffer *buffer, struct wined3d buffer, buffer->resource.size, buffer->resource.usage, buffer->resource.heap_memory); if (device->create_parms.flags & WINED3DCREATE_SOFTWARE_VERTEXPROCESSING - || wined3d_resource_access_is_managed(desc->access)) + || wined3d_resource_access_is_managed(access)) { /* SWvp and managed buffers always return the same pointer in buffer * maps and retain data in DISCARD maps. Keep a system memory copy of diff --git a/dlls/wined3d/wined3d_main.c b/dlls/wined3d/wined3d_main.c index 6e93b8dc683..a059598ec21 100644 --- a/dlls/wined3d/wined3d_main.c +++ b/dlls/wined3d/wined3d_main.c @@ -394,6 +394,11 @@ static BOOL wined3d_dll_init(HINSTANCE hInstDLL) wined3d_settings.renderer = WINED3D_RENDERER_NO3D; } } + if (!get_config_key_dword(hkey, appkey, "WriteMappableConstantBuffers", &tmpvalue) && tmpvalue) + { + TRACE("Forcing all constant buffers to be write-mappable.\n"); + wined3d_settings.write_mappable_cbuffers = TRUE; + } } if (appkey) RegCloseKey( appkey ); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 86c053df0db..9357223cb97 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -482,6 +482,7 @@ struct wined3d_settings unsigned int max_sm_cs; enum wined3d_renderer renderer; enum wined3d_shader_backend shader_backend; + BOOL write_mappable_cbuffers; }; extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN; -- 2.30.2

2 1

[PATCH v3 0/5] Implement reflink support
by Alex Xu (Hello71) 09 Sep '21

09 Sep '21

Over the years, Wine prefixes have gotten bigger and bigger, for a number of reasons. Creating a new Wine prefix for each application is still the current recommendation, as despite the best efforts of Wine developers, some applications still require system-wide workarounds. This leads to significant bloat for each application installed. With a MinGW build of Wine without Mono or Gecko, new 32-bit prefixes are over 150 MB, and new 64-bit prefixes are over 300 MB. The vast majority of these files are byte-for-byte identical to Wine's central DLL copies. This patch set implements reflink support in Wine via the copy_file_range syscall. The reasons for selecting copy_file_range over FICLONE are outlined in patch 2. A previous unpublished version of this patch set used FICLONERANGE, but it was less convenient to use from setupapi and has inferior system support. When reflink is supported by the underlying filesystem, new Wine prefix sizes with Mono and Gecko disabled are reduced to less than 1 MB. The resulting Wine prefix is byte-for-byte identical to one created without reflink, but occupies less space on disk. If hard links or symlinks were used, if an application such as winetricks writes to a system file, it would overwrite the central copy. With reflink, the file blocks will be transparently copied by the Linux kernel so that each Wine prefix can be independent. Some files cannot be deduplicated in the current Wine system, as they are dynamically generated during the Wine prefix installation process. These include 16-bit fake DLLs and manifest files. In theory, it should be possible to pre-generate these files, but considering the Wine prefix size is already reduced to less than 1 MB, the extra space savings are likely not worth the effort. Changes since v2: Fix/improve errno handling. Alex Xu (Hello71) (5): ntdll: add support for IOCTL_COPYCHUNK. kernelbase: use IOCTL_COPYCHUNK in CopyFile* setupapi: Use IOCTL_COPYCHUNK, avoid buffering whole file lmshare.h: define STYPE_TEMPORARY kernel32/tests: add IOCTL_COPYCHUNK test configure | 1 + configure.ac | 1 + dlls/kernel32/tests/file.c | 137 +++++++++++++++++++++++++ dlls/kernelbase/file.c | 44 ++++---- dlls/ntdll/unix/file.c | 121 ++++++++++++++++++++++ dlls/setupapi/fakedll.c | 202 ++++++++++++++++++++----------------- include/config.h.in | 3 + include/lmshare.h | 11 +- include/winioctl.h | 34 +++++++ 9 files changed, 431 insertions(+), 123 deletions(-) -- 2.33.0

2 7

[PATCH 1/5] winegstreamer: Fix multiple leaks in failure pathes.
by Derek Lesho 09 Sep '21

09 Sep '21

Signed-off-by: Derek Lesho <dlesho(a)codeweavers.com> --- dlls/winegstreamer/media_source.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/dlls/winegstreamer/media_source.c b/dlls/winegstreamer/media_source.c index 01ab626254a..383afcfce75 100644 --- a/dlls/winegstreamer/media_source.c +++ b/dlls/winegstreamer/media_source.c @@ -733,6 +733,9 @@ static HRESULT new_media_stream(struct media_source *source, object->IMFMediaStream_iface.lpVtbl = &media_stream_vtbl; object->ref = 1; + if (FAILED(hr = MFCreateEventQueue(&object->event_queue))) + goto fail; + IMFMediaSource_AddRef(&source->IMFMediaSource_iface); object->parent_source = source; object->stream_id = stream_id; @@ -741,9 +744,6 @@ static HRESULT new_media_stream(struct media_source *source, object->eos = FALSE; object->wg_stream = wg_stream; - if (FAILED(hr = MFCreateEventQueue(&object->event_queue))) - goto fail; - TRACE("Created stream object %p.\n", object); *out_stream = object; @@ -1211,7 +1211,8 @@ static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface) source->state = SOURCE_SHUTDOWN; - unix_funcs->wg_parser_disconnect(source->wg_parser); + if (source->stream_count) + unix_funcs->wg_parser_disconnect(source->wg_parser); if (source->read_thread) { @@ -1231,6 +1232,9 @@ static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface) { struct media_stream *stream = source->streams[i]; + if (!stream) + continue; + stream->state = STREAM_SHUTDOWN; if (stream->event_queue) @@ -1245,7 +1249,7 @@ static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface) unix_funcs->wg_parser_destroy(source->wg_parser); - if (source->stream_count) + if (source->streams) free(source->streams); if (source->async_commands_queue) @@ -1353,7 +1357,6 @@ static HRESULT media_source_constructor(IMFByteStream *bytestream, struct media_ if (FAILED(hr = media_stream_init_desc(object->streams[i]))) { ERR("Failed to finish initialization of media stream %p, hr %x.\n", object->streams[i], hr); - IMFMediaStream_Release(&object->streams[i]->IMFMediaStream_iface); goto fail; } } @@ -1392,6 +1395,8 @@ static HRESULT media_source_constructor(IMFByteStream *bytestream, struct media_ fail: WARN("Failed to construct MFMediaSource, hr %#x.\n", hr); + if (object->wg_parser) + IMFMediaSource_Shutdown(&object->IMFMediaSource_iface); free(descriptors); IMFMediaSource_Release(&object->IMFMediaSource_iface); return hr; -- 2.33.0

4 17

[PATCH] wined3d: Handle null semantics in stream output description cache.
by Nikolay Sivov 09 Sep '21

09 Sep '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- Let me know if a test is useful for this, as it seems like implementation detail. To see the crash it's enough to create two shaders with matching descriptions, containing gaps. dlls/wined3d/device.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index d2147447ee0..4f7a46340d4 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -5620,7 +5620,9 @@ static int wined3d_so_desc_compare(const void *key, const struct wine_rb_entry * if ((ret = (a->stream_idx - b->stream_idx))) return ret; - if ((ret = strcmp(a->semantic_name, b->semantic_name))) + if (!!a->semantic_name ^ !!b->semantic_name) + return a->semantic_name ? -1 : 1; + if (a->semantic_name && (ret = strcmp(a->semantic_name, b->semantic_name))) return ret; if ((ret = (a->semantic_idx - b->semantic_idx))) return ret; -- 2.33.0

2 2

[PATCH] d2d1/tests: Add tests for 2D affine effect.
by Ziqing Hui 09 Sep '21

09 Sep '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- dlls/d2d1/tests/d2d1.c | 127 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c index 3e2eda8a4a4..e9bb31ad6ff 100644 --- a/dlls/d2d1/tests/d2d1.c +++ b/dlls/d2d1/tests/d2d1.c @@ -9875,6 +9875,132 @@ static void test_effect(BOOL d3d11) release_test_context(&ctx); } +static void test_effect_2d_affine(BOOL d3d11) +{ + D2D1_MATRIX_3X2_F rotate, scale, skew; + D2D1_BITMAP_PROPERTIES1 bitmap_desc; + D2D_RECT_F output_bounds = {0}; + struct d2d1_test_context ctx; + struct resource_readback rb; + ID2D1DeviceContext *context; + D2D1_SIZE_U input_size; + ID2D1Factory1 *factory; + ID2D1Bitmap1 *bitmap; + ID2D1Effect *effect; + ID2D1Image *output; + unsigned int i; + DWORD colour; + HRESULT hr; + + const DWORD image_4x4[] = + { + 0xfdcba987, 0xffff0000, 0x98765432, 0xffffffff, + 0x4b4b4b4b, 0x89abcdef, 0xdeadbeef, 0xabcdef01, + 0x7f000011, 0x40ffffff, 0x12345678, 0xaabbccdd, + 0x44444444, 0xff7f7f7f, 0x1221abba, 0x00000000 + }; + DWORD image_16x16[16 * 16]; + + const struct effect_2d_affine_test + { + const DWORD *img_data; + unsigned int img_width; + unsigned int img_height; + + D2D1_MATRIX_3X2_F *matrix; + + D2D_RECT_F bounds; + DWORD origin_colour; + } + effect_2d_affine_tests[] = + { + {image_4x4, 4, 4, &rotate, {-6.0f, -3.0f, 2.0f, 4.0f}, 0x7b7b7b7b}, + {image_4x4, 4, 4, &scale, {-2.0f, -3.0f, 1.0f, 9.0f}, 0xd0d7e482}, + {image_4x4, 4, 4, &skew, {-7.0f, -3.0f, 3.0f, 7.0f}, 0x4c3b2a19}, + {image_16x16, 16, 16, &rotate, {-14.0f, -3.0f, 10.0f, 21.0f}, 0x7f7f7f7f}, + {image_16x16, 16, 16, &scale, {-2.0f, -3.0f, 10.0f, 39.0f}, 0xffffffff}, + {image_16x16, 16, 16, &skew, {-19.0f, -3.0f, 15.0f, 31.0f}, 0x7f7f7f7f}, + }; + + memset(image_16x16, 0xff, sizeof(image_16x16)); + set_matrix_identity(&rotate); + set_matrix_identity(&scale); + set_matrix_identity(&skew); + translate_matrix(&rotate, -2.0f, -2.0f); + translate_matrix(&scale, -2.0f, -2.0f); + translate_matrix(&skew, -2.0f, -2.0f); + rotate_matrix(&rotate, M_PI_4); + scale_matrix(&scale, 0.75f, 2.5f); + skew_matrix(&skew, -1.0f, 1.0f); + + if (!init_test_context(&ctx, d3d11)) + return; + + if (FAILED(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &IID_ID2D1Factory1, NULL, (void **)&factory))) + { + win_skip("ID2D1Factory1 is not supported.\n"); + release_test_context(&ctx); + return; + } + + hr = ID2D1RenderTarget_QueryInterface(ctx.rt, &IID_ID2D1DeviceContext, (void **)&context); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + hr = ID2D1DeviceContext_CreateEffect(context, &CLSID_D2D12DAffineTransform, &effect); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(effect_2d_affine_tests); ++i) + { + const struct effect_2d_affine_test *test = &effect_2d_affine_tests[i]; + winetest_push_context("Test %u", i); + + set_size_u(&input_size, test->img_width, test->img_height); + bitmap_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; + bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE; + bitmap_desc.dpiX = 96.0f; + bitmap_desc.dpiY = 96.0f; + bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_NONE; + bitmap_desc.colorContext = NULL; + hr = ID2D1DeviceContext_CreateBitmap(context, input_size, test->img_data, + sizeof(*test->img_data) * test->img_width, &bitmap_desc, &bitmap); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + ID2D1Effect_SetInput(effect, 0, (ID2D1Image *)bitmap, FALSE); + todo_wine + hr = ID2D1Effect_SetValue(effect, D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX, + D2D1_PROPERTY_TYPE_MATRIX_3X2, (const BYTE *)test->matrix, sizeof(*test->matrix)); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ID2D1Effect_GetOutput(effect, &output); + + ID2D1DeviceContext_GetImageLocalBounds(context, output, &output_bounds); + todo_wine + ok(compare_rect(&output_bounds, test->bounds.left, test->bounds.top, test->bounds.right, test->bounds.bottom, 1), + "Got unexpected output bounds {%.8e, %.8e, %.8e, %.8e}, expected {%.8e, %.8e, %.8e, %.8e}.\n", + output_bounds.left, output_bounds.top, output_bounds.right, output_bounds.bottom, + test->bounds.left, test->bounds.top, test->bounds.right, test->bounds.bottom); + + ID2D1DeviceContext_BeginDraw(context); + ID2D1DeviceContext_Clear(context, 0); + ID2D1DeviceContext_DrawImage(context, output, NULL, NULL, 0, 0); + hr = ID2D1DeviceContext_EndDraw(context, NULL, NULL); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + get_surface_readback(&ctx, &rb); + colour = get_readback_colour(&rb, 0, 0); + todo_wine + ok(compare_colour(colour, test->origin_colour, 1), + "Got unexpected colour %#x, expected %#x.\n", colour, test->origin_colour); + + ID2D1Image_Release(output); + ID2D1Bitmap1_Release(bitmap); + winetest_pop_context(); + } + + ID2D1Effect_Release(effect); + ID2D1DeviceContext_Release(context); + ID2D1Factory1_Release(factory); + release_test_context(&ctx); +} + START_TEST(d2d1) { HMODULE d2d1_dll = GetModuleHandleA("d2d1.dll"); @@ -9937,6 +10063,7 @@ START_TEST(d2d1) queue_test(test_geometry_group); queue_test(test_mt_factory); queue_test(test_effect); + queue_test(test_effect_2d_affine); run_queued_tests(); } -- 2.25.1

2 1

[Patch resend] msxml3: Fix crash when iterating through attributes with namespaces.
by Bernhard Übelacker 09 Sep '21

09 Sep '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50475 Signed-off-by: Bernhard Übelacker <bernhardu(a)mailbox.org> --- dlls/msxml3/element.c | 5 ++- dlls/msxml3/tests/domdoc.c | 62 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 1 deletion(-) diff --git a/dlls/msxml3/element.c b/dlls/msxml3/element.c index 1a523798328..c11d28b066c 100644 --- a/dlls/msxml3/element.c +++ b/dlls/msxml3/element.c @@ -1832,7 +1832,10 @@ static HRESULT domelem_get_item(const xmlNodePtr node, LONG index, IXMLDOMNode * if (!xmlns) return E_OUTOFMEMORY; - curr = xmlNewNsProp(NULL, xmlns, ns->prefix, ns->href); + if (ns->prefix) + curr = xmlNewNsProp(NULL, xmlns, ns->prefix, ns->href); + else + curr = xmlNewProp(NULL, xmlns->prefix, ns->href); if (!curr) { xmlFreeNs(xmlns); return E_OUTOFMEMORY; diff --git a/dlls/msxml3/tests/domdoc.c b/dlls/msxml3/tests/domdoc.c index 063f9433a77..e57c71b6a7a 100644 --- a/dlls/msxml3/tests/domdoc.c +++ b/dlls/msxml3/tests/domdoc.c @@ -13650,6 +13650,67 @@ todo_wine DeleteFileA(path); } +static const char svg[] = + "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"></svg>"; + +static void test_prefixless_namespace(void) +{ + HRESULT hr; + IXMLDOMDocument *doc; + VARIANT_BOOL b; + BSTR str; + IXMLDOMNodeList *node_list; + LONG length; + IXMLDOMNode *node1; + IXMLDOMNode *node2; + IXMLDOMNamedNodeMap *node_map; + int found; + + doc = create_document(&IID_IXMLDOMDocument); + EXPECT_REF(doc, 1); + + hr = IXMLDOMDocument_loadXML(doc, _bstr_(svg), &b); + EXPECT_HR(hr, S_OK); + + hr = IXMLDOMDocument_get_childNodes(doc, &node_list); + EXPECT_HR(hr, S_OK); + + hr = IXMLDOMNodeList_get_item(node_list, 0, &node1); + EXPECT_HR(hr, S_OK); + + node_map = (void *)0xdeadbeef; + hr = IXMLDOMNode_get_attributes(node1, &node_map); + EXPECT_HR(hr, S_OK); + + length = 0xdeadbeef; + hr = IXMLDOMNamedNodeMap_get_length(node_map, &length); + EXPECT_HR(hr, S_OK); + ok(length == 3, "expected length=%d, got %d\n", 3, length); + + found = 0; + for (int i = 0; i < length; i++) + { + hr = IXMLDOMNamedNodeMap_get_item(node_map, i, &node2); + EXPECT_HR(hr, S_OK); + + str = (void *)0xdeadbeef; + hr = IXMLDOMNode_get_xml(node2, &str); + EXPECT_HR(hr, S_OK); + if (lstrcmpW(str, L"version=\"1.1\"") == 0) found++; + if (lstrcmpW(str, L"xmlns=\"http://www.w3.org/2000/svg\"") == 0) found++; + if (lstrcmpW(str, L"xmlns:xlink=\"http://www.w3.org/1999/xlink\"") == 0) found++; + SysFreeString(str); + + IXMLDOMNode_Release(node2); + } + ok(found == 3, "expected to find %d elements, found %d\n", 3, found); + + IXMLDOMNamedNodeMap_Release(node_map); + IXMLDOMNode_Release(node1); + IXMLDOMNodeList_Release(node_list); + IXMLDOMDocument_Release(doc); +} + START_TEST(domdoc) { HRESULT hr; @@ -13745,6 +13806,7 @@ START_TEST(domdoc) test_mxnamespacemanager(); test_mxnamespacemanager_override(); } + test_prefixless_namespace(); CoUninitialize(); } -- 2.30.2

2 2

[PATCH v4] dsound: Commit next audio chunk between play cursor and write cursor to playing.
by Eduard Permyakov 09 Sep '21

09 Sep '21

This region of the audio buffer is forbidden to be written to by the DirectSound specification. The documentation states: "The write cursor is the point after which it is safe to write data into the buffer. The block between the play cursor and the write cursor is already committed to be played, and cannot be changed safely." However, some applications still do this, which has lead to audio glitches only when using the Wine DirectSound implementation. Experiments showed that the native DirctSound implementation will still play the old audio the first time around when the buffer region gets overwritten. Use an approach of copying the next forbidden region into a "committed buffer" to add the same behavior to the Wine implementation. Out of performance considerations, only copy data to the committed buffer when we detect that an overwrite is possible (i.e. the current mixing region of the buffer gets locked). Signed-off-by: Eduard Permyakov <epermyakov(a)codeweavers.com> --- dlls/dsound/buffer.c | 51 +++++++++++++++++++++++++++++++++--- dlls/dsound/dsound_convert.c | 33 ++++++++++++++++------- dlls/dsound/dsound_private.h | 6 ++++- dlls/dsound/mixer.c | 1 + 4 files changed, 77 insertions(+), 14 deletions(-) diff --git a/dlls/dsound/buffer.c b/dlls/dsound/buffer.c index dc3b54906ce..12c8345c4a8 100644 --- a/dlls/dsound/buffer.c +++ b/dlls/dsound/buffer.c @@ -101,6 +101,25 @@ static int __cdecl notify_compar(const void *l, const void *r) return 1; } +static void copy_circular(VOID *dstbuff, VOID *srcbuff, DWORD srcoff, DWORD srcsize, DWORD cpysize) +{ + DWORD overflow; + if(cpysize > srcsize - srcoff) { + overflow = cpysize - (srcsize - srcoff); + memcpy(dstbuff, (BYTE*)srcbuff + srcoff, srcsize - srcoff); + memcpy((BYTE*)dstbuff + (srcsize - srcoff), srcbuff, overflow); + }else{ + memcpy(dstbuff, (BYTE*)srcbuff + srcoff, cpysize); + } +} + +static void commit_next_chunk(IDirectSoundBufferImpl *dsb) +{ + copy_circular(dsb->committedbuff, dsb->buffer->memory, dsb->sec_mixpos, dsb->buflen, dsb->writelead); + dsb->use_committed = TRUE; + TRACE("committing %u bytes from offset %u\n", dsb->writelead, dsb->sec_mixpos); +} + static HRESULT WINAPI IDirectSoundNotifyImpl_SetNotificationPositions(IDirectSoundNotify *iface, DWORD howmuch, const DSBPOSITIONNOTIFY *notify) { @@ -503,8 +522,10 @@ static HRESULT WINAPI IDirectSoundBufferImpl_Lock(IDirectSoundBuffer8 *iface, DW if (writecursor+writebytes <= This->buflen) { *(LPBYTE*)lplpaudioptr1 = This->buffer->memory+writecursor; - if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING) + if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING) { WARN("Overwriting mixing position, case 1\n"); + commit_next_chunk(This); + } *audiobytes1 = writebytes; if (lplpaudioptr2) *(LPBYTE*)lplpaudioptr2 = NULL; @@ -519,16 +540,20 @@ static HRESULT WINAPI IDirectSoundBufferImpl_Lock(IDirectSoundBuffer8 *iface, DW *(LPBYTE*)lplpaudioptr1 = This->buffer->memory+writecursor; *audiobytes1 = This->buflen-writecursor; This->buffer->lockedbytes += *audiobytes1; - if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING) + if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING) { WARN("Overwriting mixing position, case 2\n"); + commit_next_chunk(This); + } if (lplpaudioptr2) *(LPBYTE*)lplpaudioptr2 = This->buffer->memory; if (audiobytes2) { *audiobytes2 = writebytes-(This->buflen-writecursor); This->buffer->lockedbytes += *audiobytes2; } - if (audiobytes2 && This->sec_mixpos < remainder && This->state == STATE_PLAYING) + if (audiobytes2 && This->sec_mixpos < remainder && This->state == STATE_PLAYING) { WARN("Overwriting mixing position, case 3\n"); + commit_next_chunk(This); + } TRACE("Locked %p(%i bytes) and %p(%i bytes) writecursor=%d\n", *(LPBYTE*)lplpaudioptr1, *audiobytes1, lplpaudioptr2 ? *(LPBYTE*)lplpaudioptr2 : NULL, audiobytes2 ? *audiobytes2: 0, writecursor); } @@ -1081,6 +1106,13 @@ HRESULT secondarybuffer_create(DirectSoundDevice *device, const DSBUFFERDESC *ds /* calculate fragment size and write lead */ DSOUND_RecalcFormat(dsb); + dsb->committedbuff = HeapAlloc(GetProcessHeap(), 0, dsb->writelead); + if(!dsb->committedbuff) { + IDirectSoundBuffer8_Release(&dsb->IDirectSoundBuffer8_iface); + return DSERR_OUTOFMEMORY; + } + FillMemory(dsb->committedbuff, dsb->writelead, dsbd->lpwfxFormat->wBitsPerSample == 8 ? 128 : 0); + if (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D) { dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER); dsb->ds3db_ds3db.vPosition.x = 0.0; @@ -1135,6 +1167,7 @@ void secondarybuffer_destroy(IDirectSoundBufferImpl *This) HeapFree(GetProcessHeap(), 0, This->notifies); HeapFree(GetProcessHeap(), 0, This->pwfx); + HeapFree(GetProcessHeap(), 0, This->committedbuff); if (This->filters) { int i; @@ -1157,6 +1190,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( { IDirectSoundBufferImpl *dsb; HRESULT hres = DS_OK; + VOID *committedbuff; TRACE("(%p,%p,%p)\n", device, ppdsb, pdsb); dsb = HeapAlloc(GetProcessHeap(),0,sizeof(*dsb)); @@ -1166,6 +1200,14 @@ HRESULT IDirectSoundBufferImpl_Duplicate( return DSERR_OUTOFMEMORY; } + committedbuff = HeapAlloc(GetProcessHeap(),0,pdsb->writelead); + if (committedbuff == NULL) { + HeapFree(GetProcessHeap(),0,dsb); + *ppdsb = NULL; + return DSERR_OUTOFMEMORY; + } + FillMemory(committedbuff, pdsb->writelead, pdsb->pwfx->wBitsPerSample == 8 ? 128 : 0); + AcquireSRWLockShared(&pdsb->lock); CopyMemory(dsb, pdsb, sizeof(*dsb)); @@ -1175,6 +1217,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( ReleaseSRWLockShared(&pdsb->lock); if (dsb->pwfx == NULL) { + HeapFree(GetProcessHeap(),0,committedbuff); HeapFree(GetProcessHeap(),0,dsb); *ppdsb = NULL; return DSERR_OUTOFMEMORY; @@ -1192,6 +1235,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( dsb->notifies = NULL; dsb->nrofnotifies = 0; dsb->device = device; + dsb->committedbuff = committedbuff; DSOUND_RecalcFormat(dsb); InitializeSRWLock(&dsb->lock); @@ -1202,6 +1246,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( list_remove(&dsb->entry); dsb->buffer->ref--; HeapFree(GetProcessHeap(),0,dsb->pwfx); + HeapFree(GetProcessHeap(),0,dsb->committedbuff); HeapFree(GetProcessHeap(),0,dsb); dsb = NULL; }else diff --git a/dlls/dsound/dsound_convert.c b/dlls/dsound/dsound_convert.c index 4735178a9a8..76c36b607c7 100644 --- a/dlls/dsound/dsound_convert.c +++ b/dlls/dsound/dsound_convert.c @@ -55,17 +55,30 @@ WINE_DEFAULT_DEBUG_CHANNEL(dsound); #define le32(x) (x) #endif +static BYTE *buff_byte(const IDirectSoundBufferImpl *dsb, DWORD offset) +{ + if(!dsb->use_committed) + return dsb->buffer->memory + offset; + + if(offset >= dsb->sec_mixpos && offset < dsb->sec_mixpos + dsb->writelead) { + return (BYTE*)dsb->committedbuff + (offset - dsb->sec_mixpos); + }else if(offset < (dsb->sec_mixpos + dsb->writelead) % dsb->buflen) { + return (BYTE*)dsb->committedbuff + (dsb->buflen - dsb->sec_mixpos + offset); + }else{ + return dsb->buffer->memory + offset; + } +} + static float get8(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - buf += pos + channel; + const BYTE *buf = buff_byte(dsb, pos + channel); return (buf[0] - 0x80) / (float)0x80; } static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const SHORT *sbuf = (const SHORT*)(buf + pos + 2 * channel); + const BYTE *buf = buff_byte(dsb, pos + 2 * channel); + const SHORT *sbuf = (const SHORT*)(buf); SHORT sample = (SHORT)le16(*sbuf); return sample / (float)0x8000; } @@ -73,8 +86,8 @@ static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { LONG sample; - const BYTE* buf = dsb->buffer->memory; - buf += pos + 3 * channel; + const BYTE *buf = buff_byte(dsb, pos + 3 * channel); + /* The next expression deliberately has an overflow for buf[2] >= 0x80, this is how negative values are made. */ @@ -84,16 +97,16 @@ static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) static float get32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const LONG *sbuf = (const LONG*)(buf + pos + 4 * channel); + const BYTE *buf = buff_byte(dsb, pos + 4 * channel); + const LONG *sbuf = (const LONG*)(buf); LONG sample = le32(*sbuf); return sample / (float)0x80000000U; } static float getieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const float *sbuf = (const float*)(buf + pos + 4 * channel); + const BYTE *buf = buff_byte(dsb, pos + 4 * channel); + const float *sbuf = (const float*)(buf); /* The value will be clipped later, when put into some non-float buffer */ return *sbuf; } diff --git a/dlls/dsound/dsound_private.h b/dlls/dsound/dsound_private.h index bdb9ebee544..48f83315180 100644 --- a/dlls/dsound/dsound_private.h +++ b/dlls/dsound/dsound_private.h @@ -153,7 +153,11 @@ struct IDirectSoundBufferImpl LONG64 freqAccNum; /* used for mixing */ DWORD sec_mixpos; - + /* Holds a copy of the next 'writelead' bytes, to be used for mixing. This makes it + * so that these bytes get played once even if this region of the buffer gets overwritten, + * which is more in-line with native DirectSound behavior. */ + BOOL use_committed; + LPVOID committedbuff; /* IDirectSoundNotify fields */ LPDSBPOSITIONNOTIFY notifies; int nrofnotifies; diff --git a/dlls/dsound/mixer.c b/dlls/dsound/mixer.c index 124d1e4fba1..5cc1f70afdb 100644 --- a/dlls/dsound/mixer.c +++ b/dlls/dsound/mixer.c @@ -389,6 +389,7 @@ static void cp_fields(IDirectSoundBufferImpl *dsb, UINT count, LONG64 *freqAccNu } dsb->sec_mixpos = ipos; + dsb->use_committed = FALSE; } /** -- 2.25.1

2 1

[PATCH 7/7] gdi32: Factor out get_icm_profile.
by Jacek Caban 09 Sep '21

09 Sep '21

And move it to dc.c. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- I don't think there is a way to get that information directly from ntgdi. On Windows, ICM profiles are stored in registry for each display (printers seem to use a different config). There seems to be a way to match DCs with monotors and then it should be possible to use it. It does not fit well into our gdi32, so I suggest to extent ntgdi interface, at least for now. dlls/gdi32/dc.c | 17 +++++++++++++++++ dlls/gdi32/gdi_private.h | 2 ++ dlls/gdi32/icm.c | 32 ++++---------------------------- 3 files changed, 23 insertions(+), 28 deletions(-)

2 1

[PATCH 6/7] gdi32: Use GetICMProfile driver entry point for EnumICMProfilesW.
by Jacek Caban 09 Sep '21

09 Sep '21

When display ICM is not explicitly configured on Windows, GetICMProfile returns the default profile, but EnumICMProfiles does not enumerate anything. For non-default configuration, EnumICMProfiles returns configured profiles. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- My main motivation is to replace EnumICMProfiles driver entry point with something more ntgdi-friendly. It's currently implemented only for X11 driver and it just enumerates a registry key. ACAICT, we never set this key, so in practice, it never enumerates anything (unless used configured it himself in registries). This patch makes it much closed to Windows, except for support for multiple profiles (which we generally don't have). dlls/gdi32/dibdrv/dc.c | 2 -- dlls/gdi32/driver.c | 8 +---- dlls/gdi32/emfdrv.c | 1 - dlls/gdi32/font.c | 1 - dlls/gdi32/icm.c | 15 ++++++---- dlls/gdi32/path.c | 1 - dlls/wineandroid.drv/init.c | 1 - dlls/winemac.drv/gdi.c | 1 - dlls/wineps.drv/init.c | 1 - dlls/winex11.drv/graphics.c | 58 ++----------------------------------- dlls/winex11.drv/init.c | 1 - dlls/winex11.drv/x11drv.h | 3 +- dlls/winex11.drv/xrender.c | 1 - include/wine/gdi_driver.h | 5 ++-- 14 files changed, 15 insertions(+), 84 deletions(-)

2 1

[PATCH 5/7] gdi32: Support NULL prev_value in NtGdiGetAndSetDCDword.
by Jacek Caban 09 Sep '21

09 Sep '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/gdi32/dc.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)

2 1

← Newer
1
...
51
52
53
54
55
56
57
...
75
Older →

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 September 2021