December 2019 - Wine-Devel - list.winehq.org

[PATCH 1/3] d3d9/tests: Add out-of-bounds region tests.
by Henri Verbeet Dec. 2, 2019

Dec. 2, 2019

From: Akihiro Sagawa <sagawa.aki(a)gmail.com> Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- This supersedes patch 174850. dlls/d3d9/tests/visual.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index cbfb98bec68..f19bd11607a 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -19249,6 +19249,15 @@ static void add_dirty_rect_test(void) HWND window; D3DLOCKED_RECT locked_rect; static const RECT part_rect = {96, 96, 160, 160}; + static const RECT oob_rect[] = + { + { 0, 0, 200, 300}, + { 0, 0, 300, 200}, + {100, 100, 10, 10}, + {200, 300, 10, 10}, + {300, 200, 310, 210}, + { 0, 0, 0, 0}, + }; DWORD color; window = create_window(); @@ -19595,6 +19604,17 @@ static void add_dirty_rect_test(void) hr = IDirect3DTexture9_AddDirtyRect(tex_managed, NULL); ok(SUCCEEDED(hr), "Failed to add dirty rect, hr %#x.\n", hr); + /* Test out-of-bounds regions. */ + for (i = 0; i < ARRAY_SIZE(oob_rect); ++i) + { + hr = IDirect3DTexture9_AddDirtyRect(tex_src_red, &oob_rect[i]); + todo_wine ok(hr == D3DERR_INVALIDCALL, "[%u] Got unexpected hr %#x.\n", i, hr); + hr = IDirect3DTexture9_LockRect(tex_src_red, 0, &locked_rect, &oob_rect[i], 0); + ok(SUCCEEDED(hr), "[%u] Got unexpected hr %#x.\n", i, hr); + hr = IDirect3DTexture9_UnlockRect(tex_src_red, 0); + ok(SUCCEEDED(hr), "[%u] Got unexpected hr %#x.\n", i, hr); + } + hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE); ok(SUCCEEDED(hr), "Failed to set color op, hr %#x.\n", hr); hr = IDirect3DDevice9_SetTexture(device, 0, NULL); -- 2.11.0

1 0

[PATCH v2 1/2] wined3d: Support stretching compressed format surfaces in surface_cpu_blt().
by Paul Gofman Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- v2: - check for success before uploading. dlls/wined3d/surface.c | 82 +++++++++++++++++++++++++++++++----------- 1 file changed, 61 insertions(+), 21 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 6c8d9eaf1c..9acfeea57c 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -1653,6 +1653,7 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int unsigned int texture_level; HRESULT hr = WINED3D_OK; BOOL same_sub_resource; + BOOL upload = FALSE; DWORD map_binding; const BYTE *sbase; const BYTE *sbuf; @@ -1673,6 +1674,11 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int if (wined3d_format_is_typeless(dst_format) && dst_format->id == src_format->typeless_id) dst_format = src_format; + src_height = src_box->bottom - src_box->top; + src_width = src_box->right - src_box->left; + dst_height = dst_box->bottom - dst_box->top; + dst_width = dst_box->right - dst_box->left; + dst_range.offset = 0; dst_range.size = dst_texture->sub_resources[dst_sub_resource_idx].size; if (src_texture == dst_texture && src_sub_resource_idx == dst_sub_resource_idx) @@ -1694,6 +1700,15 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int else { same_sub_resource = FALSE; + upload = dst_format->flags[dst_texture->resource.gl_type] & WINED3DFMT_FLAG_BLOCKS + && (dst_width != src_width || dst_height != src_height); + + if (upload) + { + dst_format = src_format->flags[dst_texture->resource.gl_type] & WINED3DFMT_FLAG_BLOCKS + ? wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, 0) : src_format; + } + if (!(flags & WINED3D_BLT_RAW) && dst_format->id != src_format->id) { if (!(converted_texture = surface_convert_format(src_texture, src_sub_resource_idx, dst_format))) @@ -1717,25 +1732,31 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int src_map.data = wined3d_context_map_bo_address(context, &src_data, src_texture->sub_resources[src_sub_resource_idx].size, 0, WINED3D_MAP_READ); - map_binding = dst_texture->resource.map_binding; - texture_level = dst_sub_resource_idx % dst_texture->level_count; - if (!wined3d_texture_load_location(dst_texture, dst_sub_resource_idx, context, map_binding)) - ERR("Failed to load the destination sub-resource into %s.\n", wined3d_debug_location(map_binding)); - wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~map_binding); - wined3d_texture_get_pitch(dst_texture, texture_level, &dst_map.row_pitch, &dst_map.slice_pitch); - wined3d_texture_get_memory(dst_texture, dst_sub_resource_idx, &dst_data, map_binding); - dst_map.data = wined3d_context_map_bo_address(context, &dst_data, - dst_texture->sub_resources[dst_sub_resource_idx].size, 0, WINED3D_MAP_WRITE); + if (upload) + { + wined3d_format_calculate_pitch(dst_format, 1, dst_box->right, dst_box->bottom, + &dst_map.row_pitch, &dst_map.slice_pitch); + dst_map.data = heap_alloc(dst_map.slice_pitch); + } + else + { + map_binding = dst_texture->resource.map_binding; + texture_level = dst_sub_resource_idx % dst_texture->level_count; + if (!wined3d_texture_load_location(dst_texture, dst_sub_resource_idx, context, map_binding)) + ERR("Failed to load the destination sub-resource into %s.\n", wined3d_debug_location(map_binding)); + + wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~map_binding); + wined3d_texture_get_pitch(dst_texture, texture_level, &dst_map.row_pitch, &dst_map.slice_pitch); + wined3d_texture_get_memory(dst_texture, dst_sub_resource_idx, &dst_data, map_binding); + dst_map.data = wined3d_context_map_bo_address(context, &dst_data, + dst_texture->sub_resources[dst_sub_resource_idx].size, 0, WINED3D_MAP_WRITE); + } } src_fmt_flags = src_format->flags[src_texture->resource.gl_type]; dst_fmt_flags = dst_format->flags[dst_texture->resource.gl_type]; flags &= ~WINED3D_BLT_RAW; bpp = dst_format->byte_count; - src_height = src_box->bottom - src_box->top; - src_width = src_box->right - src_box->left; - dst_height = dst_box->bottom - dst_box->top; - dst_width = dst_box->right - dst_box->left; row_byte_count = dst_width * bpp; sbase = (BYTE *)src_map.data @@ -1756,13 +1777,6 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int goto release; } - if (src_height != dst_height || src_width != dst_width) - { - WARN("Stretching not supported on compressed surfaces.\n"); - hr = WINED3DERR_INVALIDCALL; - goto release; - } - hr = surface_cpu_blt_compressed(sbase, dbuf, src_map.row_pitch, dst_map.row_pitch, dst_width, dst_height, src_format, flags, fx); @@ -2103,7 +2117,33 @@ error: FIXME(" Unsupported flags %#x.\n", flags); release: - wined3d_context_unmap_bo_address(context, &dst_data, 0, 1, &dst_range); + if (upload && hr == WINED3D_OK) + { + struct wined3d_bo_address data; + + data.buffer_object = 0; + data.addr = dst_map.data; + + texture_level = dst_sub_resource_idx % dst_texture->level_count; + + wined3d_texture_prepare_location(dst_texture, texture_level, context, WINED3D_LOCATION_TEXTURE_RGB); + dst_texture->texture_ops->texture_upload_data(context, wined3d_const_bo_address(&data), dst_format, + dst_box, dst_map.row_pitch, dst_map.slice_pitch, dst_texture, texture_level, + WINED3D_LOCATION_TEXTURE_RGB, dst_box->left, dst_box->top, 0); + + wined3d_texture_validate_location(dst_texture, texture_level, WINED3D_LOCATION_TEXTURE_RGB); + wined3d_texture_invalidate_location(dst_texture, texture_level, ~WINED3D_LOCATION_TEXTURE_RGB); + } + + if (upload) + { + heap_free(dst_map.data); + } + else + { + wined3d_context_unmap_bo_address(context, &dst_data, 0, 1, &dst_range); + } + if (!same_sub_resource) wined3d_context_unmap_bo_address(context, &src_data, 0, 0, NULL); if (SUCCEEDED(hr) && dst_texture->swapchain && dst_texture->swapchain->front_buffer == dst_texture) -- 2.23.0

3 4

[PATCH vkd3d v3 1/2] vkd3d: Add more features to CheckFeatureSupport().
by Conor McCarthy Dec. 2, 2019

Dec. 2, 2019

Some games, e.g. Hitman 2, do not check for success, and if the feature check is unimplemented they will use uninitialised data for the result. Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- v3: Report FALSE for Native16BitShaderOpsSupported. Supersedes 174444. --- include/vkd3d_d3d12.idl | 141 +++++++++++++++++++ libs/vkd3d/device.c | 279 +++++++++++++++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 5 + 3 files changed, 425 insertions(+) diff --git a/include/vkd3d_d3d12.idl b/include/vkd3d_d3d12.idl index ec8b83d..e4d5454 100644 --- a/include/vkd3d_d3d12.idl +++ b/include/vkd3d_d3d12.idl @@ -1608,6 +1608,141 @@ typedef struct D3D12_FEATURE_DATA_SHADER_MODEL D3D_SHADER_MODEL HighestShaderModel; } D3D12_FEATURE_DATA_SHADER_MODEL; +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 +{ + BOOL WaveOps; + UINT WaveLaneCountMin; + UINT WaveLaneCountMax; + UINT TotalLaneCount; + BOOL ExpandedComputeResourceStates; + BOOL Int64ShaderOps; +} D3D12_FEATURE_DATA_D3D12_OPTIONS1; + +typedef enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER +{ + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = 0, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = 1, + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = 2, +} D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2 +{ + BOOL DepthBoundsTestSupported; + D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS2; + +typedef enum D3D12_SHADER_CACHE_SUPPORT_FLAGS +{ + D3D12_SHADER_CACHE_SUPPORT_NONE = 0x0, + D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 0x1, + D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4, + D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8, +} D3D12_SHADER_CACHE_SUPPORT_FLAGS; + +typedef struct D3D12_FEATURE_DATA_SHADER_CACHE +{ + D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags; +} D3D12_FEATURE_DATA_SHADER_CACHE; + +typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY +{ + D3D12_COMMAND_LIST_TYPE CommandListType; + UINT Priority; + BOOL PriorityForTypeIsSupported; +} D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY; + +typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1 +{ + UINT NodeIndex; + BOOL TileBasedRenderer; + BOOL UMA; + BOOL CacheCoherentUMA; + BOOL IsolatedMMU; +} D3D12_FEATURE_DATA_ARCHITECTURE1; + +typedef enum D3D12_COMMAND_LIST_SUPPORT_FLAGS +{ + D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0x0, + D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = 0x1, + D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = 0x2, + D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = 0x4, + D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = 0x8, +} D3D12_COMMAND_LIST_SUPPORT_FLAGS; + +typedef enum D3D12_VIEW_INSTANCING_TIER +{ + D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = 0, + D3D12_VIEW_INSTANCING_TIER_1 = 1, + D3D12_VIEW_INSTANCING_TIER_2 = 2, + D3D12_VIEW_INSTANCING_TIER_3 = 3, +} D3D12_VIEW_INSTANCING_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3 +{ + BOOL CopyQueueTimestampQueriesSupported; + BOOL CastingFullyTypedFormatSupported; + D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags; + D3D12_VIEW_INSTANCING_TIER ViewInstancingTier; + BOOL BarycentricsSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS3; + +typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS +{ + BOOL Supported; +} D3D12_FEATURE_DATA_EXISTING_HEAPS; + +typedef enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER +{ + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0, + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = 1, +} D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4 +{ + BOOL MSAA64KBAlignedTextureSupported; + D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier; + BOOL Native16BitShaderOpsSupported; +} D3D12_FEATURE_DATA_D3D12_OPTIONS4; + +typedef enum D3D12_HEAP_SERIALIZATION_TIER +{ + D3D12_HEAP_SERIALIZATION_TIER_0 = 0, + D3D12_HEAP_SERIALIZATION_TIER_10 = 10, +} D3D12_HEAP_SERIALIZATION_TIER; + +typedef struct D3D12_FEATURE_DATA_SERIALIZATION +{ + UINT NodeIndex; + D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier; +} D3D12_FEATURE_DATA_SERIALIZATION; + +typedef struct D3D12_FEATURE_DATA_CROSS_NODE +{ + D3D12_CROSS_NODE_SHARING_TIER SharingTier; + BOOL AtomicShaderInstructions; +} D3D12_FEATURE_DATA_CROSS_NODE; + +typedef enum D3D12_RENDER_PASS_TIER +{ + D3D12_RENDER_PASS_TIER_0 = 0, + D3D12_RENDER_PASS_TIER_1 = 1, + D3D12_RENDER_PASS_TIER_2 = 2, +} D3D12_RENDER_PASS_TIER; + +typedef enum D3D12_RAYTRACING_TIER +{ + D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0, + D3D12_RAYTRACING_TIER_1_0 = 10, +} D3D12_RAYTRACING_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5 +{ + BOOL SRVOnlyTiledResourceTier3; + D3D12_RENDER_PASS_TIER RenderPassesTier; + D3D12_RAYTRACING_TIER RaytracingTier; +} D3D12_FEATURE_DATA_D3D12_OPTIONS5; + typedef enum D3D12_FEATURE { D3D12_FEATURE_D3D12_OPTIONS = 0, @@ -1624,6 +1759,12 @@ typedef enum D3D12_FEATURE D3D12_FEATURE_D3D12_OPTIONS2 = 18, D3D12_FEATURE_SHADER_CACHE = 19, D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20, + D3D12_FEATURE_D3D12_OPTIONS3 = 21, + D3D12_FEATURE_EXISTING_HEAPS = 22, + D3D12_FEATURE_D3D12_OPTIONS4 = 23, + D3D12_FEATURE_SERIALIZATION = 24, + D3D12_FEATURE_CROSS_NODE = 25, + D3D12_FEATURE_D3D12_OPTIONS5 = 27, } D3D12_FEATURE; typedef struct D3D12_MEMCPY_DEST diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index e3bb2aa..ae1c4c9 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1336,6 +1336,34 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, device->feature_options.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = FALSE; device->feature_options.ResourceHeapTier = D3D12_RESOURCE_HEAP_TIER_2; + device->feature_options1.WaveOps = FALSE; + device->feature_options1.WaveLaneCountMin = 0; + device->feature_options1.WaveLaneCountMax = 0; + device->feature_options1.TotalLaneCount = 0; + device->feature_options1.ExpandedComputeResourceStates = TRUE; + device->feature_options1.Int64ShaderOps = features->shaderInt64; + + /* Depth bounds test is enabled in D3D12_DEPTH_STENCIL_DESC1, which is not supported. */ + device->feature_options2.DepthBoundsTestSupported = FALSE; + /* d3d12_command_list_SetSamplePositions() is not implemented. */ + device->feature_options2.ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED; + + device->feature_options3.CopyQueueTimestampQueriesSupported = FALSE; + device->feature_options3.CastingFullyTypedFormatSupported = FALSE; + device->feature_options3.WriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE; + device->feature_options3.ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED; + device->feature_options3.BarycentricsSupported = FALSE; + + /* Alignment support can be tested later. */ + device->feature_options4.MSAA64KBAlignedTextureSupported = FALSE; + device->feature_options4.SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0; + /* An SM 6.2 feature. This would require features->shaderInt16 and VK_KHR_shader_float16_int8. */ + device->feature_options4.Native16BitShaderOpsSupported = FALSE; + + device->feature_options5.SRVOnlyTiledResourceTier3 = FALSE; + device->feature_options5.RenderPassesTier = D3D12_RENDER_PASS_TIER_0; + device->feature_options5.RaytracingTier = D3D12_RAYTRACING_TIER_NOT_SUPPORTED; + if ((vr = VK_CALL(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL))) < 0) { ERR("Failed to enumerate device extensions, vr %d.\n", vr); @@ -1590,6 +1618,8 @@ static HRESULT d3d12_device_create_vkd3d_queues(struct d3d12_device *device, else goto out_destroy_queues; + device->feature_options3.CopyQueueTimestampQueriesSupported = !!device->copy_queue->timestamp_bits; + return S_OK; out_destroy_queues: @@ -2418,6 +2448,29 @@ bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent) return true; } +/* The 4MB alignment requirement for MSAA was lowered to 64KB on hardware that supports it. + * This is distinct from the small MSAA requirement which applies to a total size of 4MB or less. */ +static bool d3d12_is_64k_msaa_supported(struct d3d12_device *device) +{ + D3D12_RESOURCE_ALLOCATION_INFO info; + D3D12_RESOURCE_DESC resource_desc; + + memset(&resource_desc, 0, sizeof(resource_desc)); + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resource_desc.Width = 1024; + resource_desc.Height = 1025; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + resource_desc.SampleDesc.Count = 4; + resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + + /* FIXME: in some cases Vulkan requires 0x20000 or more for non-MSAA resources, which must have + * 0x10000 in their description, so we might resonably return true here for 0x20000 or 0x40000. */ + return SUCCEEDED(vkd3d_get_image_allocation_info(device, &resource_desc, &info)) + && info.Alignment <= 0x10000; +} + static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device *iface, D3D12_FEATURE feature, void *feature_data, UINT feature_data_size) { @@ -2668,6 +2721,27 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device * return S_OK; } + case D3D12_FEATURE_D3D12_OPTIONS1: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS1 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options1; + + TRACE("Wave ops %#x.\n", data->WaveOps); + TRACE("Min wave lane count %#x.\n", data->WaveLaneCountMin); + TRACE("Max wave lane count %#x.\n", data->WaveLaneCountMax); + TRACE("Total lane count %#x.\n", data->TotalLaneCount); + TRACE("Expanded compute resource states %#x.\n", data->ExpandedComputeResourceStates); + TRACE("Int64 shader ops %#x.\n", data->Int64ShaderOps); + return S_OK; + } + case D3D12_FEATURE_ROOT_SIGNATURE: { D3D12_FEATURE_DATA_ROOT_SIGNATURE *data = feature_data; @@ -2685,6 +2759,211 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device * return S_OK; } + case D3D12_FEATURE_ARCHITECTURE1: + { + D3D12_FEATURE_DATA_ARCHITECTURE1 *data = feature_data; + bool coherent; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + if (data->NodeIndex) + { + FIXME("Multi-adapter not supported.\n"); + return E_INVALIDARG; + } + + WARN("Assuming device does not support tile based rendering.\n"); + data->TileBasedRenderer = FALSE; + + data->UMA = d3d12_device_is_uma(device, &coherent); + data->CacheCoherentUMA = data->UMA ? coherent : FALSE; + + WARN("Assuming device does not have an isolated memory management unit.\n"); + data->IsolatedMMU = FALSE; + + TRACE("Tile based renderer %#x, UMA %#x, cache coherent UMA %#x, isolated MMU %#x.\n", + data->TileBasedRenderer, data->UMA, data->CacheCoherentUMA, data->IsolatedMMU); + return S_OK; + } + + case D3D12_FEATURE_D3D12_OPTIONS2: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS2 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options2; + + TRACE("Depth bounds test %#x.\n", data->DepthBoundsTestSupported); + TRACE("Programmable sample positions tier %#x.\n", data->ProgrammableSamplePositionsTier); + return S_OK; + } + + case D3D12_FEATURE_SHADER_CACHE: + { + D3D12_FEATURE_DATA_SHADER_CACHE *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + /* FIXME: The D3D12 documentation states that D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO is + * always supported, but the CachedPSO field of D3D12_GRAPHICS_PIPELINE_STATE_DESC is + * ignored and GetCachedBlob() is a stub. */ + data->SupportFlags = D3D12_SHADER_CACHE_SUPPORT_NONE; + + TRACE("Shader cache support %#x.\n", data->SupportFlags); + return S_OK; + } + + case D3D12_FEATURE_COMMAND_QUEUE_PRIORITY: + { + D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + switch (data->CommandListType) + { + case D3D12_COMMAND_LIST_TYPE_DIRECT: + case D3D12_COMMAND_LIST_TYPE_COMPUTE: + case D3D12_COMMAND_LIST_TYPE_COPY: + data->PriorityForTypeIsSupported = FALSE; + TRACE("Command list type %#x, priority %u, supported %#x.\n", + data->CommandListType, data->Priority, data->PriorityForTypeIsSupported); + return S_OK; + + default: + FIXME("Unhandled command list type %#x.\n", data->CommandListType); + return E_INVALIDARG; + } + } + + case D3D12_FEATURE_D3D12_OPTIONS3: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS3 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options3; + + TRACE("Copy queue timestamp queries %#x.\n", data->CopyQueueTimestampQueriesSupported); + TRACE("Casting fully typed format %#x.\n", data->CastingFullyTypedFormatSupported); + TRACE("Write buffer immediate %#x.\n", data->WriteBufferImmediateSupportFlags); + TRACE("View instancing tier %#x.\n", data->ViewInstancingTier); + TRACE("Barycentrics %#x.\n", data->BarycentricsSupported); + return S_OK; + } + + case D3D12_FEATURE_EXISTING_HEAPS: + { + D3D12_FEATURE_DATA_EXISTING_HEAPS *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + data->Supported = FALSE; + + TRACE("Existing heaps %#x.\n", data->Supported); + return S_OK; + } + + case D3D12_FEATURE_D3D12_OPTIONS4: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS4 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options4; + data->MSAA64KBAlignedTextureSupported = d3d12_is_64k_msaa_supported(device); + + TRACE("64KB aligned MSAA textures %#x.\n", data->MSAA64KBAlignedTextureSupported); + TRACE("Shared resource compatibility tier %#x.\n", data->SharedResourceCompatibilityTier); + TRACE("Native 16-bit shader ops %#x.\n", data->Native16BitShaderOpsSupported); + return S_OK; + } + + case D3D12_FEATURE_SERIALIZATION: + { + D3D12_FEATURE_DATA_SERIALIZATION *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + if (data->NodeIndex) + { + FIXME("Multi-adapter not supported.\n"); + return E_INVALIDARG; + } + + data->HeapSerializationTier = D3D12_HEAP_SERIALIZATION_TIER_0; + + TRACE("Heap serialization tier %#x.\n", data->HeapSerializationTier); + return S_OK; + } + + case D3D12_FEATURE_CROSS_NODE: + { + D3D12_FEATURE_DATA_CROSS_NODE *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + data->SharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED; + data->AtomicShaderInstructions = FALSE; + + TRACE("Cross node sharing tier %#x.\n", data->SharingTier); + TRACE("Cross node shader atomics %#x.\n", data->AtomicShaderInstructions); + return S_OK; + } + + case D3D12_FEATURE_D3D12_OPTIONS5: + { + D3D12_FEATURE_DATA_D3D12_OPTIONS5 *data = feature_data; + + if (feature_data_size != sizeof(*data)) + { + WARN("Invalid size %u.\n", feature_data_size); + return E_INVALIDARG; + } + + *data = device->feature_options5; + + TRACE("SRV tiled resource tier 3 only %#x.\n", data->SRVOnlyTiledResourceTier3); + TRACE("Render pass tier %#x.\n", data->RenderPassesTier); + TRACE("Ray tracing tier %#x.\n", data->RaytracingTier); + return S_OK; + } + default: FIXME("Unhandled feature %#x.\n", feature); return E_NOTIMPL; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 9ff6bba..d18fba1 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -1131,6 +1131,11 @@ struct d3d12_device VkPhysicalDeviceMemoryProperties memory_properties; D3D12_FEATURE_DATA_D3D12_OPTIONS feature_options; + D3D12_FEATURE_DATA_D3D12_OPTIONS1 feature_options1; + D3D12_FEATURE_DATA_D3D12_OPTIONS2 feature_options2; + D3D12_FEATURE_DATA_D3D12_OPTIONS3 feature_options3; + D3D12_FEATURE_DATA_D3D12_OPTIONS4 feature_options4; + D3D12_FEATURE_DATA_D3D12_OPTIONS5 feature_options5; struct vkd3d_vulkan_info vk_info; -- 2.24.0

2 2

[PATCH vkd3d] vkd3d/shader: Print more info about skipped dxbc chunks.
by Conor McCarthy Dec. 2, 2019

Dec. 2, 2019

Instead of a hex number, print the type of chunk, or at least the four tag chars. This makes it easier to check if a skipped chunk is a problem. Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 98c51e4..20a273c 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1862,6 +1862,11 @@ bool shader_sm4_is_end(void *data, const DWORD **ptr) #define TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X') #define TAG_AON9 MAKE_TAG('A', 'o', 'n', '9') #define TAG_RTS0 MAKE_TAG('R', 'T', 'S', '0') +#define TAG_ICFE MAKE_TAG('I', 'C', 'F', 'E') +#define TAG_RDEF MAKE_TAG('R', 'D', 'E', 'F') +#define TAG_SFI0 MAKE_TAG('S', 'F', 'I', '0') +#define TAG_SPDB MAKE_TAG('S', 'P', 'D', 'B') +#define TAG_STAT MAKE_TAG('S', 'T', 'A', 'T') static bool require_space(size_t offset, size_t count, size_t size, size_t data_size) { @@ -2092,6 +2097,7 @@ int shader_parse_input_signature(const void *dxbc, size_t dxbc_length, static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *context) { struct vkd3d_shader_desc *desc = context; + char tag_chars[sizeof(tag) + 1]; int ret; switch (tag) @@ -2142,8 +2148,33 @@ static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *cont TRACE("Skipping AON9 shader code chunk.\n"); break; + case TAG_ICFE: + TRACE("Skipping interface/class reflection chunk.\n"); + break; + + case TAG_RDEF: + TRACE("Skipping resource reflection chunk.\n"); + break; + + case TAG_SFI0: + if (data_size >= sizeof(DWORD)) + TRACE("Ignoring flag chunk, value %#x.\n", *(const DWORD *)data); + else + TRACE("Ignoring flag chunk.\n"); + break; + + case TAG_SPDB: + TRACE("Skipping debug info chunk.\n"); + break; + + case TAG_STAT: + TRACE("Skipping statistics chunk.\n"); + break; + default: - TRACE("Skipping chunk %#x.\n", tag); + memcpy(tag_chars, &tag, sizeof(tag)); + tag_chars[sizeof(tag)] = 0; + TRACE("Skipping chunk %s.\n", tag_chars); break; } -- 2.24.0

2 2

[PATCH] kernel32/tests: Reorder the WINAPI with the void.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/kernel32/tests/dummy.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernel32/tests/dummy.c b/dlls/kernel32/tests/dummy.c index 14d0d90dea..b8eab8c219 100644 --- a/dlls/kernel32/tests/dummy.c +++ b/dlls/kernel32/tests/dummy.c @@ -14,7 +14,7 @@ BOOL WINAPI DllMain(HINSTANCE instance_new, DWORD reason, LPVOID reserved) return TRUE; } -WINAPI void get_path(char *buffer, int buffer_size) +void WINAPI get_path(char *buffer, int buffer_size) { GetModuleFileNameA(instance, buffer, buffer_size); } -- 2.23.0

1 0

[PATCH] mapi32: Reorder the WINAPI with the HRESULT.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/mapi32/prop.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mapi32/prop.c b/dlls/mapi32/prop.c index 55baf9129a..b217035e2c 100644 --- a/dlls/mapi32/prop.c +++ b/dlls/mapi32/prop.c @@ -1497,7 +1497,7 @@ static inline void IMAPIPROP_Unlock(IPropDataImpl *This) * Inherited method from the IUnknown Interface. * See IUnknown_QueryInterface. */ -static WINAPI HRESULT IPropData_fnQueryInterface(LPPROPDATA iface, REFIID riid, LPVOID *ppvObj) +static HRESULT WINAPI IPropData_fnQueryInterface(LPPROPDATA iface, REFIID riid, LPVOID *ppvObj) { IPropDataImpl *This = impl_from_IPropData(iface); -- 2.23.0

1 0

[PATCH] uianimation: Remove duplicate WINAPI.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/uianimation/main.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/uianimation/main.c b/dlls/uianimation/main.c index 492c1b757a..c0c7367e09 100644 --- a/dlls/uianimation/main.c +++ b/dlls/uianimation/main.c @@ -132,7 +132,7 @@ struct animation_storyboard *impl_from_IUIAnimationStoryboard( IUIAnimationStory return CONTAINING_RECORD( iface, struct animation_storyboard, IUIAnimationStoryboard_iface ); } -static HRESULT WINAPI WINAPI animation_storyboard_QueryInterface( IUIAnimationStoryboard *iface, +static HRESULT WINAPI animation_storyboard_QueryInterface( IUIAnimationStoryboard *iface, REFIID iid, void **obj ) { struct animation_storyboard *This = impl_from_IUIAnimationStoryboard( iface ); @@ -352,7 +352,7 @@ struct animation_var *impl_from_IUIAnimationVariable( IUIAnimationVariable *ifac return CONTAINING_RECORD( iface, struct animation_var, IUIAnimationVariable_iface ); } -static HRESULT WINAPI WINAPI animation_var_QueryInterface( IUIAnimationVariable *iface, +static HRESULT WINAPI animation_var_QueryInterface( IUIAnimationVariable *iface, REFIID iid, void **obj ) { struct animation_var *This = impl_from_IUIAnimationVariable( iface ); @@ -998,7 +998,7 @@ struct tr_library *impl_from_IUIAnimationTransitionLibrary( IUIAnimationTransiti return CONTAINING_RECORD( iface, struct tr_library, IUIAnimationTransitionLibrary_iface ); } -static HRESULT WINAPI WINAPI tr_library_QueryInterface( IUIAnimationTransitionLibrary *iface, +static HRESULT WINAPI tr_library_QueryInterface( IUIAnimationTransitionLibrary *iface, REFIID iid, void **obj ) { struct tr_library *This = impl_from_IUIAnimationTransitionLibrary( iface ); -- 2.23.0

1 0

[PATCH] kernelbase/tests: Fix a typo in ok() message.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/kernelbase/tests/path.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernelbase/tests/path.c b/dlls/kernelbase/tests/path.c index abe586b0a2..93303bafc3 100644 --- a/dlls/kernelbase/tests/path.c +++ b/dlls/kernelbase/tests/path.c @@ -797,7 +797,7 @@ static void test_PathCchAddBackslashEx(void) } else { - ok(ptrW == NULL, "%u: unexpecred end pointer.\n", i); + ok(ptrW == NULL, "%u: unexpected end pointer.\n", i); ok(remaining == 0, "%u: unexpected remaining buffer length.\n", i); } } -- 2.23.0

1 0

[PATCH] ieframe/tests: Fix a typo in ok() message.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/ieframe/tests/webbrowser.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/ieframe/tests/webbrowser.c b/dlls/ieframe/tests/webbrowser.c index db47fdf616..a99c68ac5e 100644 --- a/dlls/ieframe/tests/webbrowser.c +++ b/dlls/ieframe/tests/webbrowser.c @@ -283,7 +283,7 @@ static void _test_ready_state(unsigned line, READYSTATE exstate, VARIANT_BOOL ex hres = IWebBrowser2_get_Busy(wb, &busy); if(expect_busy != BUSY_FAIL) { ok_(__FILE__,line)(hres == S_OK, "get_ReadyState failed: %08x\n", hres); - ok_(__FILE__,line)(busy == expect_busy, "Busy = %x, exoected %x for ready state %d\n", + ok_(__FILE__,line)(busy == expect_busy, "Busy = %x, expected %x for ready state %d\n", busy, expect_busy, state); }else { todo_wine -- 2.23.0

1 0

[PATCH] sapiaut.idl: Fix a typo.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- include/sapiaut.idl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/sapiaut.idl b/include/sapiaut.idl index 4ae4ebe231..99932e49cb 100644 --- a/include/sapiaut.idl +++ b/include/sapiaut.idl @@ -1784,7 +1784,7 @@ interface ISpeechRecoGrammar : IDispatch HRESULT CmdLoadFromObject([in]const BSTR classid, [in] const BSTR grammarname, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); [id(DISPID_SRGCmdLoadFromResource)] - HRESULT CmdLoadFromResource([in]long mod, [in] VARIANT name, [in] VARIANT yype, [in] SpeechLanguageId language, + HRESULT CmdLoadFromResource([in]long mod, [in] VARIANT name, [in] VARIANT type, [in] SpeechLanguageId language, [in, defaultvalue(SLOStatic)] SpeechLoadOption option); [id(DISPID_SRGCmdLoadFromMemory)] -- 2.23.0

1 0

[PATCH 1/2] wined3d: Support stretching compressed format surfaces in surface_cpu_blt().
by Paul Gofman Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/wined3d/surface.c | 79 +++++++++++++++++++++++++++++++----------- 1 file changed, 58 insertions(+), 21 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 6c8d9eaf1c..48eeccdb0d 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -1653,6 +1653,7 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int unsigned int texture_level; HRESULT hr = WINED3D_OK; BOOL same_sub_resource; + BOOL upload = FALSE; DWORD map_binding; const BYTE *sbase; const BYTE *sbuf; @@ -1673,6 +1674,11 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int if (wined3d_format_is_typeless(dst_format) && dst_format->id == src_format->typeless_id) dst_format = src_format; + src_height = src_box->bottom - src_box->top; + src_width = src_box->right - src_box->left; + dst_height = dst_box->bottom - dst_box->top; + dst_width = dst_box->right - dst_box->left; + dst_range.offset = 0; dst_range.size = dst_texture->sub_resources[dst_sub_resource_idx].size; if (src_texture == dst_texture && src_sub_resource_idx == dst_sub_resource_idx) @@ -1694,6 +1700,15 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int else { same_sub_resource = FALSE; + upload = dst_format->flags[dst_texture->resource.gl_type] & WINED3DFMT_FLAG_BLOCKS + && (dst_width != src_width || dst_height != src_height); + + if (upload) + { + dst_format = src_format->flags[dst_texture->resource.gl_type] & WINED3DFMT_FLAG_BLOCKS + ? wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, 0) : src_format; + } + if (!(flags & WINED3D_BLT_RAW) && dst_format->id != src_format->id) { if (!(converted_texture = surface_convert_format(src_texture, src_sub_resource_idx, dst_format))) @@ -1717,25 +1732,31 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int src_map.data = wined3d_context_map_bo_address(context, &src_data, src_texture->sub_resources[src_sub_resource_idx].size, 0, WINED3D_MAP_READ); - map_binding = dst_texture->resource.map_binding; - texture_level = dst_sub_resource_idx % dst_texture->level_count; - if (!wined3d_texture_load_location(dst_texture, dst_sub_resource_idx, context, map_binding)) - ERR("Failed to load the destination sub-resource into %s.\n", wined3d_debug_location(map_binding)); - wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~map_binding); - wined3d_texture_get_pitch(dst_texture, texture_level, &dst_map.row_pitch, &dst_map.slice_pitch); - wined3d_texture_get_memory(dst_texture, dst_sub_resource_idx, &dst_data, map_binding); - dst_map.data = wined3d_context_map_bo_address(context, &dst_data, - dst_texture->sub_resources[dst_sub_resource_idx].size, 0, WINED3D_MAP_WRITE); + if (upload) + { + wined3d_format_calculate_pitch(dst_format, 1, dst_box->right, dst_box->bottom, + &dst_map.row_pitch, &dst_map.slice_pitch); + dst_map.data = heap_alloc(dst_map.slice_pitch); + } + else + { + map_binding = dst_texture->resource.map_binding; + texture_level = dst_sub_resource_idx % dst_texture->level_count; + if (!wined3d_texture_load_location(dst_texture, dst_sub_resource_idx, context, map_binding)) + ERR("Failed to load the destination sub-resource into %s.\n", wined3d_debug_location(map_binding)); + + wined3d_texture_invalidate_location(dst_texture, dst_sub_resource_idx, ~map_binding); + wined3d_texture_get_pitch(dst_texture, texture_level, &dst_map.row_pitch, &dst_map.slice_pitch); + wined3d_texture_get_memory(dst_texture, dst_sub_resource_idx, &dst_data, map_binding); + dst_map.data = wined3d_context_map_bo_address(context, &dst_data, + dst_texture->sub_resources[dst_sub_resource_idx].size, 0, WINED3D_MAP_WRITE); + } } src_fmt_flags = src_format->flags[src_texture->resource.gl_type]; dst_fmt_flags = dst_format->flags[dst_texture->resource.gl_type]; flags &= ~WINED3D_BLT_RAW; bpp = dst_format->byte_count; - src_height = src_box->bottom - src_box->top; - src_width = src_box->right - src_box->left; - dst_height = dst_box->bottom - dst_box->top; - dst_width = dst_box->right - dst_box->left; row_byte_count = dst_width * bpp; sbase = (BYTE *)src_map.data @@ -1756,13 +1777,6 @@ static HRESULT surface_cpu_blt(struct wined3d_texture *dst_texture, unsigned int goto release; } - if (src_height != dst_height || src_width != dst_width) - { - WARN("Stretching not supported on compressed surfaces.\n"); - hr = WINED3DERR_INVALIDCALL; - goto release; - } - hr = surface_cpu_blt_compressed(sbase, dbuf, src_map.row_pitch, dst_map.row_pitch, dst_width, dst_height, src_format, flags, fx); @@ -2103,7 +2117,30 @@ error: FIXME(" Unsupported flags %#x.\n", flags); release: - wined3d_context_unmap_bo_address(context, &dst_data, 0, 1, &dst_range); + if (upload) + { + struct wined3d_bo_address data; + + data.buffer_object = 0; + data.addr = dst_map.data; + + texture_level = dst_sub_resource_idx % dst_texture->level_count; + + wined3d_texture_prepare_location(dst_texture, texture_level, context, WINED3D_LOCATION_TEXTURE_RGB); + dst_texture->texture_ops->texture_upload_data(context, wined3d_const_bo_address(&data), dst_format, + dst_box, dst_map.row_pitch, dst_map.slice_pitch, dst_texture, texture_level, + WINED3D_LOCATION_TEXTURE_RGB, dst_box->left, dst_box->top, 0); + + wined3d_texture_validate_location(dst_texture, texture_level, WINED3D_LOCATION_TEXTURE_RGB); + wined3d_texture_invalidate_location(dst_texture, texture_level, ~WINED3D_LOCATION_TEXTURE_RGB); + + heap_free(dst_map.data); + } + else + { + wined3d_context_unmap_bo_address(context, &dst_data, 0, 1, &dst_range); + } + if (!same_sub_resource) wined3d_context_unmap_bo_address(context, &src_data, 0, 0, NULL); if (SUCCEEDED(hr) && dst_texture->swapchain && dst_texture->swapchain->front_buffer == dst_texture) -- 2.23.0

3 3

[PATCH v3 1/2] wined3d: Move the wined3d_light_state structure to the wined3d_stateblock structure.
by Zebediah Figura Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wined3d/stateblock.c | 37 +++++++++++++++++----------------- dlls/wined3d/wined3d_private.h | 4 +++- 2 files changed, 22 insertions(+), 19 deletions(-) diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c index 1c3704c10a5..24017490e67 100644 --- a/dlls/wined3d/stateblock.c +++ b/dlls/wined3d/stateblock.c @@ -575,7 +575,7 @@ void wined3d_stateblock_state_cleanup(struct wined3d_stateblock_state *state) for (i = 0; i < LIGHTMAP_SIZE; ++i) { - LIST_FOR_EACH_ENTRY_SAFE(light, cursor, &state->light_state.light_map[i], struct wined3d_light_info, entry) + LIST_FOR_EACH_ENTRY_SAFE(light, cursor, &state->light_state->light_map[i], struct wined3d_light_info, entry) { list_remove(&light->entry); heap_free(light); @@ -1025,7 +1025,7 @@ void CDECL wined3d_stateblock_capture(struct wined3d_stateblock *stateblock, stateblock->stateblock_state.ps = state->ps; } - wined3d_state_record_lights(&stateblock->stateblock_state.light_state, &state->light_state); + wined3d_state_record_lights(stateblock->stateblock_state.light_state, state->light_state); TRACE("Capture done.\n"); } @@ -1073,17 +1073,17 @@ void CDECL wined3d_stateblock_apply(const struct wined3d_stateblock *stateblock, wined3d_device_set_vs_consts_b(device, idx, 1, &stateblock->stateblock_state.vs_consts_b[idx]); } - for (i = 0; i < ARRAY_SIZE(stateblock->stateblock_state.light_state.light_map); ++i) + for (i = 0; i < ARRAY_SIZE(stateblock->stateblock_state.light_state->light_map); ++i) { const struct wined3d_light_info *light; struct wined3d_light_info *new_light; - LIST_FOR_EACH_ENTRY(light, &stateblock->stateblock_state.light_state.light_map[i], struct wined3d_light_info, entry) + LIST_FOR_EACH_ENTRY(light, &stateblock->stateblock_state.light_state->light_map[i], struct wined3d_light_info, entry) { - if (SUCCEEDED(wined3d_light_state_set_light(&state->light_state, light->OriginalIndex, + if (SUCCEEDED(wined3d_light_state_set_light(state->light_state, light->OriginalIndex, &light->OriginalParms, &new_light))) { - wined3d_light_state_enable_light(&state->light_state, &device->adapter->d3d_info, new_light, light->glIndex != -1); + wined3d_light_state_enable_light(state->light_state, &device->adapter->d3d_info, new_light, light->glIndex != -1); } wined3d_device_set_light(device, light->OriginalIndex, &light->OriginalParms); wined3d_device_set_light_enable(device, light->OriginalIndex, light->glIndex != -1); @@ -1678,24 +1678,23 @@ HRESULT CDECL wined3d_stateblock_set_light(struct wined3d_stateblock *stateblock return WINED3DERR_INVALIDCALL; } - return wined3d_light_state_set_light(&stateblock->stateblock_state.light_state, light_idx, light, &object); + return wined3d_light_state_set_light(stateblock->stateblock_state.light_state, light_idx, light, &object); } HRESULT CDECL wined3d_stateblock_set_light_enable(struct wined3d_stateblock *stateblock, UINT light_idx, BOOL enable) { + struct wined3d_light_state *light_state = stateblock->stateblock_state.light_state; struct wined3d_light_info *light_info; HRESULT hr; TRACE("stateblock %p, light_idx %u, enable %#x.\n", stateblock, light_idx, enable); - if (!(light_info = wined3d_light_state_get_light(&stateblock->stateblock_state.light_state, light_idx))) + if (!(light_info = wined3d_light_state_get_light(light_state, light_idx))) { - if (FAILED(hr = wined3d_light_state_set_light(&stateblock->stateblock_state.light_state, light_idx, - &WINED3D_default_light, &light_info))) + if (FAILED(hr = wined3d_light_state_set_light(light_state, light_idx, &WINED3D_default_light, &light_info))) return hr; } - wined3d_light_state_enable_light(&stateblock->stateblock_state.light_state, - &stateblock->device->adapter->d3d_info, light_info, enable); + wined3d_light_state_enable_light(light_state, &stateblock->device->adapter->d3d_info, light_info, enable); return S_OK; } @@ -1981,9 +1980,9 @@ void wined3d_stateblock_state_init(struct wined3d_stateblock_state *state, { unsigned int i; - for (i = 0; i < ARRAY_SIZE(state->light_state.light_map); i++) + for (i = 0; i < ARRAY_SIZE(state->light_state->light_map); i++) { - list_init(&state->light_state.light_map[i]); + list_init(&state->light_state->light_map[i]); } if (flags & WINED3D_STATE_INIT_DEFAULT) @@ -1998,6 +1997,7 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, const stru stateblock->ref = 1; stateblock->device = device; + stateblock->stateblock_state.light_state = &stateblock->light_state; wined3d_stateblock_state_init(&stateblock->stateblock_state, device, type == WINED3D_SBT_PRIMARY ? WINED3D_STATE_INIT_DEFAULT : 0); @@ -2011,8 +2011,8 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, const stru switch (type) { case WINED3D_SBT_ALL: - stateblock_init_lights(stateblock->stateblock_state.light_state.light_map, - device_state->stateblock_state.light_state.light_map); + stateblock_init_lights(stateblock->stateblock_state.light_state->light_map, + device_state->stateblock_state.light_state->light_map); stateblock_savedstates_set_all(&stateblock->changed, d3d_info->limits.vs_uniform_count, d3d_info->limits.ps_uniform_count); break; @@ -2023,8 +2023,8 @@ static HRESULT stateblock_init(struct wined3d_stateblock *stateblock, const stru break; case WINED3D_SBT_VERTEX_STATE: - stateblock_init_lights(stateblock->stateblock_state.light_state.light_map, - device_state->stateblock_state.light_state.light_map); + stateblock_init_lights(stateblock->stateblock_state.light_state->light_map, + device_state->stateblock_state.light_state->light_map); stateblock_savedstates_set_vertex(&stateblock->changed, d3d_info->limits.vs_uniform_count); break; @@ -2078,5 +2078,6 @@ void CDECL wined3d_stateblock_reset(struct wined3d_stateblock *stateblock) wined3d_stateblock_state_cleanup(&stateblock->stateblock_state); memset(&stateblock->stateblock_state, 0, sizeof(stateblock->stateblock_state)); + stateblock->stateblock_state.light_state = &stateblock->light_state; wined3d_stateblock_state_init(&stateblock->stateblock_state, stateblock->device, WINED3D_STATE_INIT_DEFAULT); } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 3ae7dab858e..5f779f041f0 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3247,7 +3247,7 @@ struct wined3d_stateblock_state struct wined3d_viewport viewport; RECT scissor_rect; - struct wined3d_light_state light_state; + struct wined3d_light_state *light_state; }; struct wined3d_device @@ -3946,7 +3946,9 @@ struct wined3d_stateblock /* Array indicating whether things have been set or changed */ struct wined3d_saved_states changed; + struct wined3d_stateblock_state stateblock_state; + struct wined3d_light_state light_state; /* Contained state management */ DWORD contained_render_states[WINEHIGHEST_RENDER_STATE + 1]; -- 2.23.0

2 3

[PATCH] wined3d: Add Intel HD 615 PCI id and device description.
by elee＠codeweavers.com Dec. 2, 2019

Dec. 2, 2019

From: Ethan Lee <elee(a)codeweavers.com> Signed-off-by: Ethan Lee <elee(a)codeweavers.com> --- dlls/wined3d/directx.c | 1 + dlls/wined3d/wined3d_private.h | 1 + 2 files changed, 2 insertions(+) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 902cc444ce..12b53f7577 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -565,6 +565,7 @@ static const struct wined3d_gpu_description gpu_description_table[] = {HW_VENDOR_INTEL, CARD_INTEL_IPP580_2, "Intel(R) Iris(TM) Pro Graphics P580", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_UHD617, "Intel(R) UHD Graphics 617", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_UHD620, "Intel(R) UHD Graphics 620", DRIVER_INTEL_HD4000, 3072}, + {HW_VENDOR_INTEL, CARD_INTEL_HD615, "Intel(R) HD Graphics 615", DRIVER_INTEL_HD4000, 2048}, {HW_VENDOR_INTEL, CARD_INTEL_HD620, "Intel(R) HD Graphics 620", DRIVER_INTEL_HD4000, 3072}, {HW_VENDOR_INTEL, CARD_INTEL_HD630_1, "Intel(R) HD Graphics 630", DRIVER_INTEL_HD4000, 3072}, {HW_VENDOR_INTEL, CARD_INTEL_HD630_2, "Intel(R) HD Graphics 630", DRIVER_INTEL_HD4000, 3072}, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index f86853e9c9..b08a843f7f 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2640,6 +2640,7 @@ enum wined3d_pci_device CARD_INTEL_IPP580_2 = 0x193d, CARD_INTEL_UHD617 = 0x87c0, CARD_INTEL_UHD620 = 0x3ea0, + CARD_INTEL_HD615 = 0x591e, CARD_INTEL_HD620 = 0x5916, CARD_INTEL_HD630_1 = 0x5912, CARD_INTEL_HD630_2 = 0x591b, -- 2.21.0

2 1

[PATCH] ddraw/tests: Skip test_colorkey_precision() test on WARP.
by Paul Gofman Dec. 2, 2019

Dec. 2, 2019

Fixes ddraw7 test crashes in Testbow(w10). Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- The test was already mostly marked broken on WARP due to Win8 WARP failures. dlls/ddraw/tests/ddraw7.c | 111 +++++++++++++++++++------------------- 1 file changed, 56 insertions(+), 55 deletions(-) diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c index be59c7d3ac..ee77474f74 100644 --- a/dlls/ddraw/tests/ddraw7.c +++ b/dlls/ddraw/tests/ddraw7.c @@ -11040,21 +11040,7 @@ static void test_colorkey_precision(void) {{ 1.0f, -1.0f, 0.0f}, {1.0f, 1.0f}}, {{ 1.0f, 1.0f, 0.0f}, {1.0f, 0.0f}}, }; - IDirect3DDevice7 *device; - IDirect3D7 *d3d; - IDirectDraw7 *ddraw; - IDirectDrawSurface7 *rt; - HWND window; - HRESULT hr; - IDirectDrawSurface7 *src, *dst, *texture; - DDSURFACEDESC2 surface_desc, lock_desc; - ULONG refcount; - D3DCOLOR color; - unsigned int t, c; - DDCOLORKEY ckey; - DDBLTFX fx; - DWORD data[4] = {0}, color_mask; - BOOL is_nvidia, is_warp; + static const struct { unsigned int max, shift, bpp, clear; @@ -11097,6 +11083,22 @@ static void test_colorkey_precision(void) }, }; + IDirectDrawSurface7 *src, *dst, *texture; + DDSURFACEDESC2 surface_desc, lock_desc; + DWORD data[4] = {0}, color_mask; + IDirect3DDevice7 *device; + IDirectDrawSurface7 *rt; + IDirectDraw7 *ddraw; + unsigned int t, c; + DDCOLORKEY ckey; + IDirect3D7 *d3d; + BOOL is_nvidia; + ULONG refcount; + D3DCOLOR color; + HWND window; + HRESULT hr; + DDBLTFX fx; + window = create_window(); if (!(device = create_device(window, DDSCL_NORMAL))) { @@ -11106,40 +11108,43 @@ static void test_colorkey_precision(void) } hr = IDirect3DDevice7_GetDirect3D(device, &d3d); - ok(SUCCEEDED(hr), "Failed to get Direct3D7 interface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **)&ddraw); - ok(SUCCEEDED(hr), "Failed to get DirectDraw7 interface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); IDirect3D7_Release(d3d); hr = IDirect3DDevice7_GetRenderTarget(device, &rt); - ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); is_nvidia = ddraw_is_nvidia(ddraw); /* The Windows 8 WARP driver has plenty of false negatives in X8R8G8B8 * (color key doesn't match although the values are equal), and a false * positive when the color key is 0 and the texture contains the value 1. - * I don't want to mark this broken unconditionally since this would - * essentially disable the test on Windows. Also on random occasions - * 254 == 255 and 255 != 255.*/ - is_warp = ddraw_is_warp(ddraw); + * Also on random occasions 254 == 255 and 255 != 255. + * Crashes on Windows 10 WARP. */ + if (ddraw_is_warp(ddraw)) + { + win_skip("Skipping test on WARP driver.\n"); + goto done; + } hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE); - ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE); - ok(SUCCEEDED(hr), "Failed to disable z-buffering, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_COLORKEYENABLE, TRUE); - ok(SUCCEEDED(hr), "Failed to enable color keying, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); /* Multiply the texture read result with 0, that way the result color if the key doesn't * match is constant. In theory color keying works without reading the texture result * (meaning we could just op=arg1, arg1=tfactor), but the Geforce7 Windows driver begs * to differ. */ hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE); - ok(SUCCEEDED(hr), "Failed to set color op, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE); - ok(SUCCEEDED(hr), "Failed to set color arg, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR); - ok(SUCCEEDED(hr), "Failed to set color arg, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_TEXTUREFACTOR, 0x00000000); - ok(SUCCEEDED(hr), "Failed to set render state, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); memset(&fx, 0, sizeof(fx)); fx.dwSize = sizeof(fx); @@ -11164,9 +11169,9 @@ static void test_colorkey_precision(void) /* Windows XP (at least with the r200 driver, other drivers untested) produces * garbage when doing color keyed texture->texture blits. */ hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &src, NULL); - ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &dst, NULL); - ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); U5(fx).dwFillColor = tests[t].clear; /* On the w8 testbot (WARP driver) the blit result has different values in the @@ -11184,15 +11189,15 @@ static void test_colorkey_precision(void) surface_desc.ddckCKSrcBlt.dwColorSpaceLowValue = c << tests[t].shift; surface_desc.ddckCKSrcBlt.dwColorSpaceHighValue = c << tests[t].shift; hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &texture, NULL); - ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_SetTexture(device, 0, texture); - ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface7_Blt(dst, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx); - ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface7_Lock(src, NULL, &lock_desc, DDLOCK_WAIT, NULL); - ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); switch (tests[t].bpp) { case 4: @@ -11210,21 +11215,21 @@ static void test_colorkey_precision(void) break; } hr = IDirectDrawSurface7_Unlock(src, 0); - ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface7_Blt(texture, NULL, src, NULL, DDBLT_WAIT, NULL); - ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); ckey.dwColorSpaceLowValue = c << tests[t].shift; ckey.dwColorSpaceHighValue = c << tests[t].shift; hr = IDirectDrawSurface7_SetColorKey(src, DDCKEY_SRCBLT, &ckey); - ok(SUCCEEDED(hr), "Failed to set color key, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirectDrawSurface7_Blt(dst, NULL, src, NULL, DDBLT_KEYSRC | DDBLT_WAIT, NULL); - ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); /* Don't make this read only, it somehow breaks the detection of the Nvidia bug below. */ hr = IDirectDrawSurface7_Lock(dst, NULL, &lock_desc, DDLOCK_WAIT, NULL); - ok(SUCCEEDED(hr), "Failed to lock surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); switch (tests[t].bpp) { case 4: @@ -11242,7 +11247,7 @@ static void test_colorkey_precision(void) break; } hr = IDirectDrawSurface7_Unlock(dst, 0); - ok(SUCCEEDED(hr), "Failed to unlock surface, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); if (!c) { @@ -11284,38 +11289,34 @@ static void test_colorkey_precision(void) (c + 1) << tests[t].shift, data[2], tests[t].name, c); hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x0000ff00, 1.0f, 0); - ok(SUCCEEDED(hr), "Failed to clear, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_BeginScene(device); - ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEX1, quad, 4, 0); - ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); hr = IDirect3DDevice7_EndScene(device); - ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); + ok(hr == DD_OK, "Got unexpected hr %#x.\n", hr); color = get_surface_color(rt, 80, 240); + if (!c) - ok(compare_color(color, 0x0000ff00, 1) || broken(is_warp && compare_color(color, 0x00000000, 1)), - "Got unexpected color 0x%08x, format %s, c=%u.\n", + ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x, format %s, c=%u.\n", color, tests[t].name, c); else - ok(compare_color(color, 0x00000000, 1) || broken(is_warp && compare_color(color, 0x0000ff00, 1)), - "Got unexpected color 0x%08x, format %s, c=%u.\n", + ok(compare_color(color, 0x00000000, 1), "Got unexpected color 0x%08x, format %s, c=%u.\n", color, tests[t].name, c); color = get_surface_color(rt, 240, 240); - ok(compare_color(color, 0x0000ff00, 1) || broken(is_warp && compare_color(color, 0x00000000, 1)), - "Got unexpected color 0x%08x, format %s, c=%u.\n", + ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x, format %s, c=%u.\n", color, tests[t].name, c); color = get_surface_color(rt, 400, 240); if (c == tests[t].max) - ok(compare_color(color, 0x0000ff00, 1) || broken(is_warp && compare_color(color, 0x00000000, 1)), - "Got unexpected color 0x%08x, format %s, c=%u.\n", + ok(compare_color(color, 0x0000ff00, 1), "Got unexpected color 0x%08x, format %s, c=%u.\n", color, tests[t].name, c); else - ok(compare_color(color, 0x00000000, 1) || broken(is_warp && compare_color(color, 0x0000ff00, 1)), - "Got unexpected color 0x%08x, format %s, c=%u.\n", + ok(compare_color(color, 0x00000000, 1), "Got unexpected color 0x%08x, format %s, c=%u.\n", color, tests[t].name, c); IDirectDrawSurface7_Release(texture); -- 2.23.0

3 2

[PATCH] dxgi/tests: Fix a typo in ok() message.
by Andrey Gusev Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Andrey Gusev <andrey.goosev(a)gmail.com> --- dlls/dxgi/tests/dxgi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 874c39b88e..b2b53f7a4c 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -2151,7 +2151,7 @@ static void test_get_containing_output(void) { ret = SetWindowPos(swapchain_desc.OutputWindow, 0, points[i].x, points[i].y, 0, 0, SWP_NOSIZE | SWP_NOZORDER); - ok(ret, "Faled to set window position.\n"); + ok(ret, "Failed to set window position.\n"); monitor = MonitorFromWindow(swapchain_desc.OutputWindow, MONITOR_DEFAULTTONEAREST); ok(!!monitor, "Failed to get monitor from window.\n"); -- 2.23.0

3 2

[PATCH] testbot: Validate VM names and add UntaintName().
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

This prevents discrepencies between the VM creation interface and LibvirtTool's validation of VM names. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/LibvirtTool.pl | 23 +++++++++++++---------- testbot/lib/WineTestBot/VMs.pm | 17 +++++++++++++++++ 2 files changed, 30 insertions(+), 10 deletions(-) diff --git a/testbot/bin/LibvirtTool.pl b/testbot/bin/LibvirtTool.pl index bc45533d2..e5dc8372e 100755 --- a/testbot/bin/LibvirtTool.pl +++ b/testbot/bin/LibvirtTool.pl @@ -118,20 +118,23 @@ if (!defined $Usage) Error "you must specify the VM name\n"; $Usage = 2; } - elsif ($VMKey =~ /^([a-zA-Z0-9_]+)$/) + else { - $VMKey = $1; # untaint - $VM = CreateVMs()->GetItem($VMKey); - if (!defined $VM) + $VMKey = WineTestBot::VM::UntaintName($VMKey); + if (!defined $VMKey) { - Error "VM $VMKey does not exist\n"; + Error "'$VMKey' is not a valid VM name\n"; $Usage = 2; } - } - else - { - Error "'$VMKey' is not a valid VM name\n"; - $Usage = 2; + else + { + $VM = CreateVMs()->GetItem($VMKey); + if (!defined $VM) + { + Error "VM $VMKey does not exist\n"; + $Usage = 2; + } + } } } if (defined $Usage) diff --git a/testbot/lib/WineTestBot/VMs.pm b/testbot/lib/WineTestBot/VMs.pm index 279b7bccd..2f4b70362 100644 --- a/testbot/lib/WineTestBot/VMs.pm +++ b/testbot/lib/WineTestBot/VMs.pm @@ -320,10 +320,27 @@ my $_SupportedMissions = { "wine" => { "win32" => 1, "wow32" => 1, "wow64" => 1 }, }; +sub UntaintName($) +{ + my ($VMName) = @_; + + return undef if (!defined $VMName); + $VMName =~ /^([a-zA-Z0-9_]+)$/; + return $1; +} + sub Validate($) { my ($self) = @_; + if (!defined $self->Name) + { + return ("Name", "The name must be set"); + } + if (!defined UntaintName($self->Name)) + { + return ("Name", "The name '". $self->Name ."' contains invalid characters"); + } if ($self->Type !~ /^(?:win32|win64|wine)$/ and $self->Role =~ /^(?:extra|winetest)$/) { -- 2.20.1

1 0

[PATCH 1/3] dwrite: Update to IDWriteFontFace5.
by Nikolay Sivov Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/dwrite/dwrite_private.h | 40 +- dlls/dwrite/font.c | 732 +++++++++++++++++++---------------- dlls/dwrite/freetype.c | 40 +- dlls/dwrite/main.c | 15 +- dlls/dwrite/opentype.c | 24 +- 5 files changed, 470 insertions(+), 381 deletions(-) diff --git a/dlls/dwrite/dwrite_private.h b/dlls/dwrite/dwrite_private.h index d3d74e0709..7898403dd9 100644 --- a/dlls/dwrite/dwrite_private.h +++ b/dlls/dwrite/dwrite_private.h @@ -175,7 +175,7 @@ struct dwrite_fonttable struct fontfacecached { struct list entry; - IDWriteFontFace4 *fontface; + IDWriteFontFace5 *fontface; }; #define GLYPH_BLOCK_SHIFT 8 @@ -185,8 +185,8 @@ struct fontfacecached struct dwrite_fontface { - IDWriteFontFace4 IDWriteFontFace4_iface; - LONG ref; + IDWriteFontFace5 IDWriteFontFace5_iface; + LONG refcount; IDWriteFontFileStream *stream; IDWriteFontFile **files; @@ -244,7 +244,8 @@ extern IDWriteTextAnalyzer *get_text_analyzer(void) DECLSPEC_HIDDEN; extern HRESULT create_font_file(IDWriteFontFileLoader *loader, const void *reference_key, UINT32 key_size, IDWriteFontFile **font_file) DECLSPEC_HIDDEN; extern void init_local_fontfile_loader(void) DECLSPEC_HIDDEN; extern IDWriteFontFileLoader *get_local_fontfile_loader(void) DECLSPEC_HIDDEN; -extern HRESULT create_fontface(const struct fontface_desc*,struct list*,IDWriteFontFace4**) DECLSPEC_HIDDEN; +extern HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_list, + IDWriteFontFace5 **fontface) DECLSPEC_HIDDEN; extern HRESULT create_font_collection(IDWriteFactory5 *factory, IDWriteFontFileEnumerator *enumerator, BOOL is_system, IDWriteFontCollection3 **collection) DECLSPEC_HIDDEN; extern HRESULT create_glyphrunanalysis(const struct glyphrunanalysis_desc*,IDWriteGlyphRunAnalysis**) DECLSPEC_HIDDEN; @@ -267,13 +268,14 @@ extern HRESULT factory_get_cached_fontface(IDWriteFactory5*,IDWriteFontFile*cons struct list**,REFIID,void**) DECLSPEC_HIDDEN; extern void factory_detach_fontcollection(IDWriteFactory5 *factory, IDWriteFontCollection3 *collection) DECLSPEC_HIDDEN; extern void factory_detach_gdiinterop(IDWriteFactory5*,IDWriteGdiInterop1*) DECLSPEC_HIDDEN; -extern struct fontfacecached *factory_cache_fontface(IDWriteFactory5*,struct list*,IDWriteFontFace4*) DECLSPEC_HIDDEN; +extern struct fontfacecached *factory_cache_fontface(IDWriteFactory5 *factory, struct list *fontfaces, + IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; extern void get_logfont_from_font(IDWriteFont*,LOGFONTW*) DECLSPEC_HIDDEN; extern void get_logfont_from_fontface(IDWriteFontFace*,LOGFONTW*) DECLSPEC_HIDDEN; extern HRESULT get_fontsig_from_font(IDWriteFont*,FONTSIGNATURE*) DECLSPEC_HIDDEN; extern HRESULT get_fontsig_from_fontface(IDWriteFontFace*,FONTSIGNATURE*) DECLSPEC_HIDDEN; extern HRESULT create_gdiinterop(IDWriteFactory5*,IDWriteGdiInterop1**) DECLSPEC_HIDDEN; -extern void fontface_detach_from_cache(IDWriteFontFace4*) DECLSPEC_HIDDEN; +extern void fontface_detach_from_cache(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; extern void factory_lock(IDWriteFactory5*) DECLSPEC_HIDDEN; extern void factory_unlock(IDWriteFactory5*) DECLSPEC_HIDDEN; extern HRESULT create_inmemory_fileloader(IDWriteFontFileLoader**) DECLSPEC_HIDDEN; @@ -300,7 +302,7 @@ struct file_stream_desc { UINT32 face_index; }; -extern const void* get_fontface_table(IDWriteFontFace4 *fontface, UINT32 tag, +extern const void* get_fontface_table(IDWriteFontFace5 *fontface, UINT32 tag, struct dwrite_fonttable *table) DECLSPEC_HIDDEN; extern HRESULT opentype_analyze_font(IDWriteFontFileStream*,BOOL*,DWRITE_FONT_FILE_TYPE*,DWRITE_FONT_FACE_TYPE*,UINT32*) DECLSPEC_HIDDEN; @@ -321,8 +323,8 @@ extern unsigned int opentype_get_cpal_palettecount(const struct dwrite_fonttable extern unsigned int opentype_get_cpal_paletteentrycount(const struct dwrite_fonttable *table) DECLSPEC_HIDDEN; extern HRESULT opentype_get_cpal_entries(const struct dwrite_fonttable *table, unsigned int palette, unsigned int first_entry_index, unsigned int entry_count, DWRITE_COLOR_F *entries) DECLSPEC_HIDDEN; -extern BOOL opentype_has_vertical_variants(IDWriteFontFace4*) DECLSPEC_HIDDEN; -extern UINT32 opentype_get_glyph_image_formats(IDWriteFontFace4*) DECLSPEC_HIDDEN; +extern BOOL opentype_has_vertical_variants(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; +extern UINT32 opentype_get_glyph_image_formats(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; extern DWRITE_CONTAINER_TYPE opentype_analyze_container_type(void const *, UINT32) DECLSPEC_HIDDEN; struct dwrite_colorglyph { @@ -373,19 +375,21 @@ extern void release_freetype(void) DECLSPEC_HIDDEN; extern HRESULT freetype_get_design_glyph_metrics(struct dwrite_fontface *fontface, UINT16 glyph, DWRITE_GLYPH_METRICS *metrics) DECLSPEC_HIDDEN; -extern void freetype_notify_cacheremove(IDWriteFontFace4*) DECLSPEC_HIDDEN; -extern BOOL freetype_is_monospaced(IDWriteFontFace4*) DECLSPEC_HIDDEN; -extern HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, float emsize, UINT16 const *glyphs, +extern void freetype_notify_cacheremove(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; +extern BOOL freetype_is_monospaced(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; +extern HRESULT freetype_get_glyphrun_outline(IDWriteFontFace5 *fontface, float emsize, UINT16 const *glyphs, float const *advances, DWRITE_GLYPH_OFFSET const *offsets, unsigned int count, BOOL is_rtl, IDWriteGeometrySink *sink) DECLSPEC_HIDDEN; -extern UINT16 freetype_get_glyphcount(IDWriteFontFace4*) DECLSPEC_HIDDEN; -extern void freetype_get_glyphs(IDWriteFontFace4*,INT,UINT32 const*,UINT32,UINT16*) DECLSPEC_HIDDEN; -extern BOOL freetype_has_kerning_pairs(IDWriteFontFace4*) DECLSPEC_HIDDEN; -extern INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4*,UINT16,UINT16) DECLSPEC_HIDDEN; +extern UINT16 freetype_get_glyphcount(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; +extern void freetype_get_glyphs(IDWriteFontFace5 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count, + UINT16 *glyphs) DECLSPEC_HIDDEN; +extern BOOL freetype_has_kerning_pairs(IDWriteFontFace5 *fontface) DECLSPEC_HIDDEN; +extern INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace5 *fontface, UINT16 left, UINT16 right) DECLSPEC_HIDDEN; extern void freetype_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap_desc) DECLSPEC_HIDDEN; extern BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap*) DECLSPEC_HIDDEN; -extern INT freetype_get_charmap_index(IDWriteFontFace4*,BOOL*) DECLSPEC_HIDDEN; -extern INT32 freetype_get_glyph_advance(IDWriteFontFace4*,FLOAT,UINT16,DWRITE_MEASURING_MODE,BOOL*) DECLSPEC_HIDDEN; +extern INT freetype_get_charmap_index(IDWriteFontFace5 *fontface, BOOL *is_symbol) DECLSPEC_HIDDEN; +extern INT32 freetype_get_glyph_advance(IDWriteFontFace5 *fontface, FLOAT emsize, UINT16 index, + DWRITE_MEASURING_MODE measuring_mode, BOOL *has_contours) DECLSPEC_HIDDEN; extern void freetype_get_design_glyph_bbox(IDWriteFontFace4*,UINT16,UINT16,RECT*) DECLSPEC_HIDDEN; /* Glyph shaping */ diff --git a/dlls/dwrite/font.c b/dlls/dwrite/font.c index 306f431d65..1bf88d6b17 100644 --- a/dlls/dwrite/font.c +++ b/dlls/dwrite/font.c @@ -185,7 +185,7 @@ struct dwrite_colorglyphenum FLOAT origin_x; /* original run origin */ FLOAT origin_y; - IDWriteFontFace4 *fontface; /* for convenience */ + IDWriteFontFace5 *fontface; /* for convenience */ DWRITE_COLOR_GLYPH_RUN1 colorrun; /* returned with GetCurrentRun() */ DWRITE_GLYPH_RUN run; /* base run */ UINT32 palette; /* palette index to get layer color from */ @@ -239,7 +239,7 @@ static void dwrite_grab_font_table(void *context, UINT32 table, const BYTE **dat struct dwrite_fontface *fontface = context; BOOL exists = FALSE; - if (FAILED(IDWriteFontFace4_TryGetFontTable(&fontface->IDWriteFontFace4_iface, table, (const void **)data, + if (FAILED(IDWriteFontFace5_TryGetFontTable(&fontface->IDWriteFontFace5_iface, table, (const void **)data, size, data_context, &exists)) || !exists) { *data = NULL; @@ -251,7 +251,7 @@ static void dwrite_grab_font_table(void *context, UINT32 table, const BYTE **dat static void dwrite_release_font_table(void *context, void *data_context) { struct dwrite_fontface *fontface = context; - IDWriteFontFace4_ReleaseFontTable(&fontface->IDWriteFontFace4_iface, data_context); + IDWriteFontFace5_ReleaseFontTable(&fontface->IDWriteFontFace5_iface, data_context); } static UINT16 dwrite_get_font_upem(void *context) @@ -275,9 +275,9 @@ struct scriptshaping_cache *fontface_get_shaping_cache(struct dwrite_fontface *f return fontface->shaping_cache = create_scriptshaping_cache(fontface, &dwrite_font_ops); } -static inline struct dwrite_fontface *impl_from_IDWriteFontFace4(IDWriteFontFace4 *iface) +static inline struct dwrite_fontface *impl_from_IDWriteFontFace5(IDWriteFontFace5 *iface) { - return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace4_iface); + return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace5_iface); } static inline struct dwrite_font *impl_from_IDWriteFont3(IDWriteFont3 *iface) @@ -350,7 +350,7 @@ static HRESULT set_cached_glyph_metrics(struct dwrite_fontface *fontface, UINT16 return S_OK; } -const void* get_fontface_table(IDWriteFontFace4 *fontface, UINT32 tag, struct dwrite_fonttable *table) +const void* get_fontface_table(IDWriteFontFace5 *fontface, UINT32 tag, struct dwrite_fonttable *table) { HRESULT hr; @@ -358,7 +358,7 @@ const void* get_fontface_table(IDWriteFontFace4 *fontface, UINT32 tag, struct dw return table->data; table->exists = FALSE; - hr = IDWriteFontFace4_TryGetFontTable(fontface, tag, (const void**)&table->data, &table->size, &table->context, + hr = IDWriteFontFace5_TryGetFontTable(fontface, tag, (const void **)&table->data, &table->size, &table->context, &table->exists); if (FAILED(hr) || !table->exists) { TRACE("Font does not have %s table\n", debugstr_tag(tag)); @@ -388,25 +388,25 @@ static FLOAT get_font_prop_vec_dotproduct(const struct dwrite_font_propvec *left static const struct dwrite_fonttable *get_fontface_vdmx(struct dwrite_fontface *fontface) { - get_fontface_table(&fontface->IDWriteFontFace4_iface, MS_VDMX_TAG, &fontface->vdmx); + get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_VDMX_TAG, &fontface->vdmx); return &fontface->vdmx; } static const struct dwrite_fonttable *get_fontface_gasp(struct dwrite_fontface *fontface) { - get_fontface_table(&fontface->IDWriteFontFace4_iface, MS_GASP_TAG, &fontface->gasp); + get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_GASP_TAG, &fontface->gasp); return &fontface->gasp; } static const struct dwrite_fonttable *get_fontface_cpal(struct dwrite_fontface *fontface) { - get_fontface_table(&fontface->IDWriteFontFace4_iface, MS_CPAL_TAG, &fontface->cpal); + get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_CPAL_TAG, &fontface->cpal); return &fontface->cpal; } static const void* get_fontface_colr(struct dwrite_fontface *fontface) { - return get_fontface_table(&fontface->IDWriteFontFace4_iface, MS_COLR_TAG, &fontface->colr); + return get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_COLR_TAG, &fontface->colr); } static void addref_font_data(struct dwrite_font_data *data) @@ -447,17 +447,17 @@ static void release_fontfamily_data(struct dwrite_fontfamily_data *data) heap_free(data); } -void fontface_detach_from_cache(IDWriteFontFace4 *iface) +void fontface_detach_from_cache(IDWriteFontFace5 *iface) { - struct dwrite_fontface *fontface = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); fontface->cached = NULL; } -static HRESULT WINAPI dwritefontface_QueryInterface(IDWriteFontFace4 *iface, REFIID riid, void **obj) +static HRESULT WINAPI dwritefontface_QueryInterface(IDWriteFontFace5 *iface, REFIID riid, void **obj) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); - TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj); + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); if (IsEqualIID(riid, &IID_IDWriteFontFace4) || IsEqualIID(riid, &IID_IDWriteFontFace3) || @@ -467,8 +467,9 @@ static HRESULT WINAPI dwritefontface_QueryInterface(IDWriteFontFace4 *iface, REF IsEqualIID(riid, &IID_IUnknown)) { *obj = iface; - if (InterlockedIncrement(&This->ref) == 1) { - InterlockedDecrement(&This->ref); + if (InterlockedIncrement(&fontface->refcount) == 1) + { + InterlockedDecrement(&fontface->refcount); *obj = NULL; return E_FAIL; } @@ -481,131 +482,148 @@ static HRESULT WINAPI dwritefontface_QueryInterface(IDWriteFontFace4 *iface, REF return E_NOINTERFACE; } -static ULONG WINAPI dwritefontface_AddRef(IDWriteFontFace4 *iface) +static ULONG WINAPI dwritefontface_AddRef(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - ULONG ref = InterlockedIncrement(&This->ref); - TRACE("(%p)->(%d)\n", This, ref); - return ref; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + ULONG refcount = InterlockedIncrement(&fontface->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; } -static ULONG WINAPI dwritefontface_Release(IDWriteFontFace4 *iface) +static ULONG WINAPI dwritefontface_Release(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - ULONG ref = InterlockedDecrement(&This->ref); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + ULONG refcount = InterlockedDecrement(&fontface->refcount); - TRACE("(%p)->(%d)\n", This, ref); + TRACE("%p, refcount %u.\n", iface, refcount); - if (!ref) { + if (!refcount) + { UINT32 i; - if (This->cached) { - factory_lock(This->factory); - list_remove(&This->cached->entry); - factory_unlock(This->factory); - heap_free(This->cached); + if (fontface->cached) + { + factory_lock(fontface->factory); + list_remove(&fontface->cached->entry); + factory_unlock(fontface->factory); + heap_free(fontface->cached); } - release_scriptshaping_cache(This->shaping_cache); - if (This->cmap.context) - IDWriteFontFace4_ReleaseFontTable(iface, This->cmap.context); - if (This->vdmx.context) - IDWriteFontFace4_ReleaseFontTable(iface, This->vdmx.context); - if (This->gasp.context) - IDWriteFontFace4_ReleaseFontTable(iface, This->gasp.context); - if (This->cpal.context) - IDWriteFontFace4_ReleaseFontTable(iface, This->cpal.context); - if (This->colr.context) - IDWriteFontFace4_ReleaseFontTable(iface, This->colr.context); - for (i = 0; i < This->file_count; i++) { - if (This->files[i]) - IDWriteFontFile_Release(This->files[i]); + release_scriptshaping_cache(fontface->shaping_cache); + if (fontface->cmap.context) + IDWriteFontFace5_ReleaseFontTable(iface, fontface->cmap.context); + if (fontface->vdmx.context) + IDWriteFontFace5_ReleaseFontTable(iface, fontface->vdmx.context); + if (fontface->gasp.context) + IDWriteFontFace5_ReleaseFontTable(iface, fontface->gasp.context); + if (fontface->cpal.context) + IDWriteFontFace5_ReleaseFontTable(iface, fontface->cpal.context); + if (fontface->colr.context) + IDWriteFontFace5_ReleaseFontTable(iface, fontface->colr.context); + for (i = 0; i < fontface->file_count; i++) + { + if (fontface->files[i]) + IDWriteFontFile_Release(fontface->files[i]); } - if (This->stream) - IDWriteFontFileStream_Release(This->stream); - heap_free(This->files); + if (fontface->stream) + IDWriteFontFileStream_Release(fontface->stream); + heap_free(fontface->files); - for (i = 0; i < ARRAY_SIZE(This->glyphs); i++) - heap_free(This->glyphs[i]); + for (i = 0; i < ARRAY_SIZE(fontface->glyphs); i++) + heap_free(fontface->glyphs[i]); freetype_notify_cacheremove(iface); - IDWriteFactory5_Release(This->factory); - heap_free(This); + IDWriteFactory5_Release(fontface->factory); + heap_free(fontface); } - return ref; + return refcount; } -static DWRITE_FONT_FACE_TYPE WINAPI dwritefontface_GetType(IDWriteFontFace4 *iface) +static DWRITE_FONT_FACE_TYPE WINAPI dwritefontface_GetType(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->type; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->type; } -static HRESULT WINAPI dwritefontface_GetFiles(IDWriteFontFace4 *iface, UINT32 *number_of_files, +static HRESULT WINAPI dwritefontface_GetFiles(IDWriteFontFace5 *iface, UINT32 *number_of_files, IDWriteFontFile **fontfiles) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); int i; - TRACE("(%p)->(%p %p)\n", This, number_of_files, fontfiles); + TRACE("%p, %p, %p.\n", iface, number_of_files, fontfiles); + if (fontfiles == NULL) { - *number_of_files = This->file_count; + *number_of_files = fontface->file_count; return S_OK; } - if (*number_of_files < This->file_count) + + if (*number_of_files < fontface->file_count) return E_INVALIDARG; - for (i = 0; i < This->file_count; i++) + for (i = 0; i < fontface->file_count; i++) { - IDWriteFontFile_AddRef(This->files[i]); - fontfiles[i] = This->files[i]; + IDWriteFontFile_AddRef(fontface->files[i]); + fontfiles[i] = fontface->files[i]; } return S_OK; } -static UINT32 WINAPI dwritefontface_GetIndex(IDWriteFontFace4 *iface) +static UINT32 WINAPI dwritefontface_GetIndex(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->index; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->index; } -static DWRITE_FONT_SIMULATIONS WINAPI dwritefontface_GetSimulations(IDWriteFontFace4 *iface) +static DWRITE_FONT_SIMULATIONS WINAPI dwritefontface_GetSimulations(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->simulations; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->simulations; } -static BOOL WINAPI dwritefontface_IsSymbolFont(IDWriteFontFace4 *iface) +static BOOL WINAPI dwritefontface_IsSymbolFont(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return !!(This->flags & FONTFACE_IS_SYMBOL); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return !!(fontface->flags & FONTFACE_IS_SYMBOL); } -static void WINAPI dwritefontface_GetMetrics(IDWriteFontFace4 *iface, DWRITE_FONT_METRICS *metrics) +static void WINAPI dwritefontface_GetMetrics(IDWriteFontFace5 *iface, DWRITE_FONT_METRICS *metrics) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)->(%p)\n", This, metrics); - memcpy(metrics, &This->metrics, sizeof(*metrics)); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p, %p.\n", iface, metrics); + + memcpy(metrics, &fontface->metrics, sizeof(*metrics)); } -static UINT16 WINAPI dwritefontface_GetGlyphCount(IDWriteFontFace4 *iface) +static UINT16 WINAPI dwritefontface_GetGlyphCount(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); + TRACE("%p.\n", iface); + return freetype_get_glyphcount(iface); } -static HRESULT WINAPI dwritefontface_GetDesignGlyphMetrics(IDWriteFontFace4 *iface, +static HRESULT WINAPI dwritefontface_GetDesignGlyphMetrics(IDWriteFontFace5 *iface, UINT16 const *glyphs, UINT32 glyph_count, DWRITE_GLYPH_METRICS *ret, BOOL is_sideways) { - struct dwrite_fontface *fontface = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); unsigned int i; HRESULT hr; @@ -644,50 +662,48 @@ static HRESULT fontface_get_glyphs(struct dwrite_fontface *fontface, UINT32 cons return E_INVALIDARG; } - freetype_get_glyphs(&fontface->IDWriteFontFace4_iface, fontface->charmap, codepoints, count, glyphs); + freetype_get_glyphs(&fontface->IDWriteFontFace5_iface, fontface->charmap, codepoints, count, glyphs); return S_OK; } -static HRESULT WINAPI dwritefontface_GetGlyphIndices(IDWriteFontFace4 *iface, UINT32 const *codepoints, +static HRESULT WINAPI dwritefontface_GetGlyphIndices(IDWriteFontFace5 *iface, UINT32 const *codepoints, UINT32 count, UINT16 *glyphs) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); - TRACE("(%p)->(%p %u %p)\n", This, codepoints, count, glyphs); + TRACE("%p, %p, %u, %p.\n", iface, codepoints, count, glyphs); - return fontface_get_glyphs(This, codepoints, count, glyphs); + return fontface_get_glyphs(fontface, codepoints, count, glyphs); } -static HRESULT WINAPI dwritefontface_TryGetFontTable(IDWriteFontFace4 *iface, UINT32 table_tag, +static HRESULT WINAPI dwritefontface_TryGetFontTable(IDWriteFontFace5 *iface, UINT32 table_tag, const void **table_data, UINT32 *table_size, void **context, BOOL *exists) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); struct file_stream_desc stream_desc; - TRACE("(%p)->(%s %p %p %p %p)\n", This, debugstr_tag(table_tag), table_data, table_size, context, exists); + TRACE("%p, %s, %p, %p, %p, %p.\n", iface, debugstr_tag(table_tag), table_data, table_size, context, exists); - stream_desc.stream = This->stream; - stream_desc.face_type = This->type; - stream_desc.face_index = This->index; + stream_desc.stream = fontface->stream; + stream_desc.face_type = fontface->type; + stream_desc.face_index = fontface->index; return opentype_get_font_table(&stream_desc, table_tag, table_data, context, table_size, exists); } -static void WINAPI dwritefontface_ReleaseFontTable(IDWriteFontFace4 *iface, void *table_context) +static void WINAPI dwritefontface_ReleaseFontTable(IDWriteFontFace5 *iface, void *table_context) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); - TRACE("(%p)->(%p)\n", This, table_context); + TRACE("%p, %p.\n", iface, table_context); - IDWriteFontFileStream_ReleaseFileFragment(This->stream, table_context); + IDWriteFontFileStream_ReleaseFileFragment(fontface->stream, table_context); } -static HRESULT WINAPI dwritefontface_GetGlyphRunOutline(IDWriteFontFace4 *iface, FLOAT emSize, +static HRESULT WINAPI dwritefontface_GetGlyphRunOutline(IDWriteFontFace5 *iface, FLOAT emSize, UINT16 const *glyphs, FLOAT const* advances, DWRITE_GLYPH_OFFSET const *offsets, UINT32 count, BOOL is_sideways, BOOL is_rtl, IDWriteGeometrySink *sink) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - - TRACE("(%p)->(%.2f %p %p %p %u %d %d %p)\n", This, emSize, glyphs, advances, offsets, + TRACE("%p, %.8e, %p, %p, %p, %u, %d, %d, %p.\n", iface, emSize, glyphs, advances, offsets, count, is_sideways, is_rtl, sink); if (!glyphs || !sink) @@ -727,14 +743,14 @@ static DWRITE_RENDERING_MODE fontface_renderingmode_from_measuringmode(DWRITE_ME return mode; } -static HRESULT WINAPI dwritefontface_GetRecommendedRenderingMode(IDWriteFontFace4 *iface, FLOAT emSize, +static HRESULT WINAPI dwritefontface_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT ppdip, DWRITE_MEASURING_MODE measuring, IDWriteRenderingParams *params, DWRITE_RENDERING_MODE *mode) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); unsigned int flags; FLOAT ppem; - TRACE("(%p)->(%.2f %.2f %d %p %p)\n", This, emSize, ppdip, measuring, params, mode); + TRACE("%p, %.8e, %.8e, %d, %p, %p.\n", iface, emSize, ppdip, measuring, params, mode); if (!params) { *mode = DWRITE_RENDERING_MODE_DEFAULT; @@ -752,16 +768,16 @@ static HRESULT WINAPI dwritefontface_GetRecommendedRenderingMode(IDWriteFontFace return S_OK; } - flags = opentype_get_gasp_flags(get_fontface_gasp(This), ppem); + flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), ppem); *mode = fontface_renderingmode_from_measuringmode(measuring, ppem, flags); return S_OK; } -static HRESULT WINAPI dwritefontface_GetGdiCompatibleMetrics(IDWriteFontFace4 *iface, FLOAT emSize, FLOAT pixels_per_dip, +static HRESULT WINAPI dwritefontface_GetGdiCompatibleMetrics(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT pixels_per_dip, DWRITE_MATRIX const *transform, DWRITE_FONT_METRICS *metrics) { DWRITE_FONT_METRICS1 metrics1; - HRESULT hr = IDWriteFontFace4_GetGdiCompatibleMetrics(iface, emSize, pixels_per_dip, transform, &metrics1); + HRESULT hr = IDWriteFontFace5_GetGdiCompatibleMetrics(iface, emSize, pixels_per_dip, transform, &metrics1); memcpy(metrics, &metrics1, sizeof(*metrics)); return hr; } @@ -779,25 +795,25 @@ static UINT32 fontface_get_horz_metric_adjustment(const struct dwrite_fontface * return (fontface->metrics.designUnitsPerEm + 49) / 50; } -static HRESULT WINAPI dwritefontface_GetGdiCompatibleGlyphMetrics(IDWriteFontFace4 *iface, FLOAT emSize, FLOAT ppdip, +static HRESULT WINAPI dwritefontface_GetGdiCompatibleGlyphMetrics(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT ppdip, DWRITE_MATRIX const *m, BOOL use_gdi_natural, UINT16 const *glyphs, UINT32 glyph_count, DWRITE_GLYPH_METRICS *metrics, BOOL is_sideways) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - UINT32 adjustment = fontface_get_horz_metric_adjustment(This); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + UINT32 adjustment = fontface_get_horz_metric_adjustment(fontface); DWRITE_MEASURING_MODE mode; FLOAT scale, size; HRESULT hr; UINT32 i; - TRACE("(%p)->(%.2f %.2f %p %d %p %u %p %d)\n", This, emSize, ppdip, m, use_gdi_natural, glyphs, + TRACE("%p, %.8e, %.8e, %p, %d, %p, %u, %p, %d.\n", iface, emSize, ppdip, m, use_gdi_natural, glyphs, glyph_count, metrics, is_sideways); if (m && memcmp(m, &identity, sizeof(*m))) FIXME("transform is not supported, %s\n", debugstr_matrix(m)); size = emSize * ppdip; - scale = size / This->metrics.designUnitsPerEm; + scale = size / fontface->metrics.designUnitsPerEm; mode = use_gdi_natural ? DWRITE_MEASURING_MODE_GDI_NATURAL : DWRITE_MEASURING_MODE_GDI_CLASSIC; for (i = 0; i < glyph_count; i++) { @@ -805,15 +821,15 @@ static HRESULT WINAPI dwritefontface_GetGdiCompatibleGlyphMetrics(IDWriteFontFac DWRITE_GLYPH_METRICS design; BOOL has_contours; - hr = IDWriteFontFace4_GetDesignGlyphMetrics(iface, glyphs + i, 1, &design, is_sideways); + hr = IDWriteFontFace5_GetDesignGlyphMetrics(iface, glyphs + i, 1, &design, is_sideways); if (FAILED(hr)) return hr; ret->advanceWidth = freetype_get_glyph_advance(iface, size, glyphs[i], mode, &has_contours); if (has_contours) - ret->advanceWidth = round_metric(ret->advanceWidth * This->metrics.designUnitsPerEm / size + adjustment); + ret->advanceWidth = round_metric(ret->advanceWidth * fontface->metrics.designUnitsPerEm / size + adjustment); else - ret->advanceWidth = round_metric(ret->advanceWidth * This->metrics.designUnitsPerEm / size); + ret->advanceWidth = round_metric(ret->advanceWidth * fontface->metrics.designUnitsPerEm / size); #define SCALE_METRIC(x) ret->x = round_metric(round_metric((design.x) * scale) / scale) SCALE_METRIC(leftSideBearing); @@ -828,22 +844,24 @@ static HRESULT WINAPI dwritefontface_GetGdiCompatibleGlyphMetrics(IDWriteFontFac return S_OK; } -static void WINAPI dwritefontface1_GetMetrics(IDWriteFontFace4 *iface, DWRITE_FONT_METRICS1 *metrics) +static void WINAPI dwritefontface1_GetMetrics(IDWriteFontFace5 *iface, DWRITE_FONT_METRICS1 *metrics) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)->(%p)\n", This, metrics); - *metrics = This->metrics; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p, %p.\n", iface, metrics); + + *metrics = fontface->metrics; } -static HRESULT WINAPI dwritefontface1_GetGdiCompatibleMetrics(IDWriteFontFace4 *iface, FLOAT em_size, FLOAT pixels_per_dip, - const DWRITE_MATRIX *m, DWRITE_FONT_METRICS1 *metrics) +static HRESULT WINAPI dwritefontface1_GetGdiCompatibleMetrics(IDWriteFontFace5 *iface, FLOAT em_size, + FLOAT pixels_per_dip, const DWRITE_MATRIX *m, DWRITE_FONT_METRICS1 *metrics) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - const DWRITE_FONT_METRICS1 *design = &This->metrics; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + const DWRITE_FONT_METRICS1 *design = &fontface->metrics; UINT16 ascent, descent; FLOAT scale; - TRACE("(%p)->(%.2f %.2f %p %p)\n", This, em_size, pixels_per_dip, m, metrics); + TRACE("%p, %.8e, %.8e, %p, %p.\n", iface, em_size, pixels_per_dip, m, metrics); if (em_size <= 0.0f || pixels_per_dip <= 0.0f) { memset(metrics, 0, sizeof(*metrics)); @@ -855,7 +873,8 @@ static HRESULT WINAPI dwritefontface1_GetGdiCompatibleMetrics(IDWriteFontFace4 * em_size *= fabs(m->m22); scale = em_size / design->designUnitsPerEm; - if (!opentype_get_vdmx_size(get_fontface_vdmx(This), em_size, &ascent, &descent)) { + if (!opentype_get_vdmx_size(get_fontface_vdmx(fontface), em_size, &ascent, &descent)) + { ascent = round_metric(design->ascent * scale); descent = round_metric(design->descent * scale); } @@ -891,33 +910,37 @@ static HRESULT WINAPI dwritefontface1_GetGdiCompatibleMetrics(IDWriteFontFace4 * return S_OK; } -static void WINAPI dwritefontface1_GetCaretMetrics(IDWriteFontFace4 *iface, DWRITE_CARET_METRICS *metrics) +static void WINAPI dwritefontface1_GetCaretMetrics(IDWriteFontFace5 *iface, DWRITE_CARET_METRICS *metrics) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)->(%p)\n", This, metrics); - *metrics = This->caret; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p, %p.\n", iface, metrics); + + *metrics = fontface->caret; } -static HRESULT WINAPI dwritefontface1_GetUnicodeRanges(IDWriteFontFace4 *iface, UINT32 max_count, +static HRESULT WINAPI dwritefontface1_GetUnicodeRanges(IDWriteFontFace5 *iface, UINT32 max_count, DWRITE_UNICODE_RANGE *ranges, UINT32 *count) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); - TRACE("(%p)->(%u %p %p)\n", This, max_count, ranges, count); + TRACE("%p, %u, %p, %p.\n", iface, max_count, ranges, count); *count = 0; if (max_count && !ranges) return E_INVALIDARG; - get_fontface_table(iface, MS_CMAP_TAG, &This->cmap); - return opentype_cmap_get_unicode_ranges(&This->cmap, max_count, ranges, count); + get_fontface_table(iface, MS_CMAP_TAG, &fontface->cmap); + return opentype_cmap_get_unicode_ranges(&fontface->cmap, max_count, ranges, count); } -static BOOL WINAPI dwritefontface1_IsMonospacedFont(IDWriteFontFace4 *iface) +static BOOL WINAPI dwritefontface1_IsMonospacedFont(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return !!(This->flags & FONTFACE_IS_MONOSPACED); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return !!(fontface->flags & FONTFACE_IS_MONOSPACED); } static int fontface_get_design_advance(struct dwrite_fontface *fontface, DWRITE_MEASURING_MODE measuring_mode, @@ -933,7 +956,7 @@ static int fontface_get_design_advance(struct dwrite_fontface *fontface, DWRITE_ switch (measuring_mode) { case DWRITE_MEASURING_MODE_NATURAL: - advance = freetype_get_glyph_advance(&fontface->IDWriteFontFace4_iface, fontface->metrics.designUnitsPerEm, + advance = freetype_get_glyph_advance(&fontface->IDWriteFontFace5_iface, fontface->metrics.designUnitsPerEm, glyph, measuring_mode, &has_contours); if (has_contours) advance += adjustment; @@ -948,7 +971,7 @@ static int fontface_get_design_advance(struct dwrite_fontface *fontface, DWRITE_ if (transform && memcmp(transform, &identity, sizeof(*transform))) FIXME("Transform is not supported.\n"); - advance = freetype_get_glyph_advance(&fontface->IDWriteFontFace4_iface, emsize, glyph, measuring_mode, + advance = freetype_get_glyph_advance(&fontface->IDWriteFontFace5_iface, emsize, glyph, measuring_mode, &has_contours); if (has_contours) advance = round_metric(advance * fontface->metrics.designUnitsPerEm / emsize + adjustment); @@ -962,35 +985,35 @@ static int fontface_get_design_advance(struct dwrite_fontface *fontface, DWRITE_ } } -static HRESULT WINAPI dwritefontface1_GetDesignGlyphAdvances(IDWriteFontFace4 *iface, +static HRESULT WINAPI dwritefontface1_GetDesignGlyphAdvances(IDWriteFontFace5 *iface, UINT32 glyph_count, UINT16 const *glyphs, INT32 *advances, BOOL is_sideways) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); unsigned int i; - TRACE("(%p)->(%u %p %p %d)\n", This, glyph_count, glyphs, advances, is_sideways); + TRACE("%p, %u, %p, %p, %d.\n", iface, glyph_count, glyphs, advances, is_sideways); if (is_sideways) FIXME("sideways mode not supported\n"); for (i = 0; i < glyph_count; ++i) { - advances[i] = fontface_get_design_advance(This, DWRITE_MEASURING_MODE_NATURAL, This->metrics.designUnitsPerEm, - 1.0f, NULL, glyphs[i], is_sideways); + advances[i] = fontface_get_design_advance(fontface, DWRITE_MEASURING_MODE_NATURAL, + fontface->metrics.designUnitsPerEm, 1.0f, NULL, glyphs[i], is_sideways); } return S_OK; } -static HRESULT WINAPI dwritefontface1_GetGdiCompatibleGlyphAdvances(IDWriteFontFace4 *iface, +static HRESULT WINAPI dwritefontface1_GetGdiCompatibleGlyphAdvances(IDWriteFontFace5 *iface, float em_size, float ppdip, const DWRITE_MATRIX *transform, BOOL use_gdi_natural, BOOL is_sideways, UINT32 glyph_count, UINT16 const *glyphs, INT32 *advances) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); DWRITE_MEASURING_MODE measuring_mode; UINT32 i; - TRACE("(%p)->(%.2f %.2f %p %d %d %u %p %p)\n", This, em_size, ppdip, transform, + TRACE("%p, %.8e, %.8e, %p, %d, %d, %u, %p, %p.\n", iface, em_size, ppdip, transform, use_gdi_natural, is_sideways, glyph_count, glyphs, advances); if (em_size < 0.0f || ppdip <= 0.0f) { @@ -1006,20 +1029,20 @@ static HRESULT WINAPI dwritefontface1_GetGdiCompatibleGlyphAdvances(IDWriteFontF measuring_mode = use_gdi_natural ? DWRITE_MEASURING_MODE_GDI_NATURAL : DWRITE_MEASURING_MODE_GDI_CLASSIC; for (i = 0; i < glyph_count; ++i) { - advances[i] = fontface_get_design_advance(This, measuring_mode, em_size, ppdip, transform, + advances[i] = fontface_get_design_advance(fontface, measuring_mode, em_size, ppdip, transform, glyphs[i], is_sideways); } return S_OK; } -static HRESULT WINAPI dwritefontface1_GetKerningPairAdjustments(IDWriteFontFace4 *iface, UINT32 count, +static HRESULT WINAPI dwritefontface1_GetKerningPairAdjustments(IDWriteFontFace5 *iface, UINT32 count, const UINT16 *indices, INT32 *adjustments) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); UINT32 i; - TRACE("(%p)->(%u %p %p)\n", This, count, indices, adjustments); + TRACE("%p, %u, %p, %p.\n", iface, count, indices, adjustments); if (!(indices || adjustments) || !count) return E_INVALIDARG; @@ -1029,7 +1052,8 @@ static HRESULT WINAPI dwritefontface1_GetKerningPairAdjustments(IDWriteFontFace4 return E_INVALIDARG; } - if (!(This->flags & FONTFACE_HAS_KERNING_PAIRS)) { + if (!(fontface->flags & FONTFACE_HAS_KERNING_PAIRS)) + { memset(adjustments, 0, count*sizeof(INT32)); return S_OK; } @@ -1041,76 +1065,88 @@ static HRESULT WINAPI dwritefontface1_GetKerningPairAdjustments(IDWriteFontFace4 return S_OK; } -static BOOL WINAPI dwritefontface1_HasKerningPairs(IDWriteFontFace4 *iface) +static BOOL WINAPI dwritefontface1_HasKerningPairs(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return !!(This->flags & FONTFACE_HAS_KERNING_PAIRS); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return !!(fontface->flags & FONTFACE_HAS_KERNING_PAIRS); } -static HRESULT WINAPI dwritefontface1_GetRecommendedRenderingMode(IDWriteFontFace4 *iface, +static HRESULT WINAPI dwritefontface1_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT font_emsize, FLOAT dpiX, FLOAT dpiY, const DWRITE_MATRIX *transform, BOOL is_sideways, DWRITE_OUTLINE_THRESHOLD threshold, DWRITE_MEASURING_MODE measuring_mode, DWRITE_RENDERING_MODE *rendering_mode) { DWRITE_GRID_FIT_MODE gridfitmode; - return IDWriteFontFace2_GetRecommendedRenderingMode((IDWriteFontFace2*)iface, font_emsize, dpiX, dpiY, transform, is_sideways, - threshold, measuring_mode, NULL, rendering_mode, &gridfitmode); + return IDWriteFontFace2_GetRecommendedRenderingMode((IDWriteFontFace2 *)iface, font_emsize, dpiX, dpiY, transform, + is_sideways, threshold, measuring_mode, NULL, rendering_mode, &gridfitmode); } -static HRESULT WINAPI dwritefontface1_GetVerticalGlyphVariants(IDWriteFontFace4 *iface, UINT32 glyph_count, +static HRESULT WINAPI dwritefontface1_GetVerticalGlyphVariants(IDWriteFontFace5 *iface, UINT32 glyph_count, const UINT16 *nominal_indices, UINT16 *vertical_indices) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%u %p %p): stub\n", This, glyph_count, nominal_indices, vertical_indices); + FIXME("%p, %u, %p, %p: stub\n", iface, glyph_count, nominal_indices, vertical_indices); + return E_NOTIMPL; } -static BOOL WINAPI dwritefontface1_HasVerticalGlyphVariants(IDWriteFontFace4 *iface) +static BOOL WINAPI dwritefontface1_HasVerticalGlyphVariants(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return !!(This->flags & FONTFACE_HAS_VERTICAL_VARIANTS); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return !!(fontface->flags & FONTFACE_HAS_VERTICAL_VARIANTS); } -static BOOL WINAPI dwritefontface2_IsColorFont(IDWriteFontFace4 *iface) +static BOOL WINAPI dwritefontface2_IsColorFont(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return get_fontface_cpal(This) && get_fontface_colr(This); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return get_fontface_cpal(fontface) && get_fontface_colr(fontface); } -static UINT32 WINAPI dwritefontface2_GetColorPaletteCount(IDWriteFontFace4 *iface) +static UINT32 WINAPI dwritefontface2_GetColorPaletteCount(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return opentype_get_cpal_palettecount(get_fontface_cpal(This)); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return opentype_get_cpal_palettecount(get_fontface_cpal(fontface)); } -static UINT32 WINAPI dwritefontface2_GetPaletteEntryCount(IDWriteFontFace4 *iface) +static UINT32 WINAPI dwritefontface2_GetPaletteEntryCount(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return opentype_get_cpal_paletteentrycount(get_fontface_cpal(This)); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return opentype_get_cpal_paletteentrycount(get_fontface_cpal(fontface)); } -static HRESULT WINAPI dwritefontface2_GetPaletteEntries(IDWriteFontFace4 *iface, UINT32 palette_index, +static HRESULT WINAPI dwritefontface2_GetPaletteEntries(IDWriteFontFace5 *iface, UINT32 palette_index, UINT32 first_entry_index, UINT32 entry_count, DWRITE_COLOR_F *entries) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)->(%u %u %u %p)\n", This, palette_index, first_entry_index, entry_count, entries); - return opentype_get_cpal_entries(get_fontface_cpal(This), palette_index, first_entry_index, entry_count, entries); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p, %u, %u, %u, %p.\n", iface, palette_index, first_entry_index, entry_count, entries); + + return opentype_get_cpal_entries(get_fontface_cpal(fontface), palette_index, first_entry_index, entry_count, entries); } -static HRESULT WINAPI dwritefontface2_GetRecommendedRenderingMode(IDWriteFontFace4 *iface, FLOAT emSize, +static HRESULT WINAPI dwritefontface2_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT dpiX, FLOAT dpiY, DWRITE_MATRIX const *m, BOOL is_sideways, DWRITE_OUTLINE_THRESHOLD threshold, DWRITE_MEASURING_MODE measuringmode, IDWriteRenderingParams *params, DWRITE_RENDERING_MODE *renderingmode, DWRITE_GRID_FIT_MODE *gridfitmode) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); unsigned int flags; FLOAT emthreshold; - TRACE("(%p)->(%.2f %.2f %.2f %p %d %d %d %p %p %p)\n", This, emSize, dpiX, dpiY, m, is_sideways, threshold, + TRACE("%p, %.8e, %.8e, %.8e, %p, %d, %d, %d, %p, %p, %p.\n", iface, emSize, dpiX, dpiY, m, is_sideways, threshold, measuringmode, params, renderingmode, gridfitmode); if (m) @@ -1139,7 +1175,7 @@ static HRESULT WINAPI dwritefontface2_GetRecommendedRenderingMode(IDWriteFontFac emthreshold = threshold == DWRITE_OUTLINE_THRESHOLD_ANTIALIASED ? RECOMMENDED_OUTLINE_AA_THRESHOLD : RECOMMENDED_OUTLINE_A_THRESHOLD; - flags = opentype_get_gasp_flags(get_fontface_gasp(This), emSize); + flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), emSize); if (*renderingmode == DWRITE_RENDERING_MODE_DEFAULT) { if (emSize >= emthreshold) @@ -1161,86 +1197,94 @@ static HRESULT WINAPI dwritefontface2_GetRecommendedRenderingMode(IDWriteFontFac return S_OK; } -static HRESULT WINAPI dwritefontface3_GetFontFaceReference(IDWriteFontFace4 *iface, IDWriteFontFaceReference **ref) +static HRESULT WINAPI dwritefontface3_GetFontFaceReference(IDWriteFontFace5 *iface, IDWriteFontFaceReference **ref) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%p): stub\n", This, ref); + FIXME("%p, %p: stub\n", iface, ref); + return E_NOTIMPL; } -static void WINAPI dwritefontface3_GetPanose(IDWriteFontFace4 *iface, DWRITE_PANOSE *panose) +static void WINAPI dwritefontface3_GetPanose(IDWriteFontFace5 *iface, DWRITE_PANOSE *panose) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)->(%p)\n", This, panose); - *panose = This->panose; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p, %p.\n", iface, panose); + + *panose = fontface->panose; } -static DWRITE_FONT_WEIGHT WINAPI dwritefontface3_GetWeight(IDWriteFontFace4 *iface) +static DWRITE_FONT_WEIGHT WINAPI dwritefontface3_GetWeight(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->weight; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->weight; } -static DWRITE_FONT_STRETCH WINAPI dwritefontface3_GetStretch(IDWriteFontFace4 *iface) +static DWRITE_FONT_STRETCH WINAPI dwritefontface3_GetStretch(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->stretch; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->stretch; } -static DWRITE_FONT_STYLE WINAPI dwritefontface3_GetStyle(IDWriteFontFace4 *iface) +static DWRITE_FONT_STYLE WINAPI dwritefontface3_GetStyle(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - TRACE("(%p)\n", This); - return This->style; + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); + + TRACE("%p.\n", iface); + + return fontface->style; } -static HRESULT WINAPI dwritefontface3_GetFamilyNames(IDWriteFontFace4 *iface, IDWriteLocalizedStrings **names) +static HRESULT WINAPI dwritefontface3_GetFamilyNames(IDWriteFontFace5 *iface, IDWriteLocalizedStrings **names) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%p): stub\n", This, names); + FIXME("%p, %p: stub\n", iface, names); + return E_NOTIMPL; } -static HRESULT WINAPI dwritefontface3_GetFaceNames(IDWriteFontFace4 *iface, IDWriteLocalizedStrings **names) +static HRESULT WINAPI dwritefontface3_GetFaceNames(IDWriteFontFace5 *iface, IDWriteLocalizedStrings **names) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%p): stub\n", This, names); + FIXME("%p, %p: stub\n", iface, names); + return E_NOTIMPL; } -static HRESULT WINAPI dwritefontface3_GetInformationalStrings(IDWriteFontFace4 *iface, DWRITE_INFORMATIONAL_STRING_ID stringid, - IDWriteLocalizedStrings **strings, BOOL *exists) +static HRESULT WINAPI dwritefontface3_GetInformationalStrings(IDWriteFontFace5 *iface, + DWRITE_INFORMATIONAL_STRING_ID stringid, IDWriteLocalizedStrings **strings, BOOL *exists) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%u %p %p): stub\n", This, stringid, strings, exists); + FIXME("%p, %u, %p, %p: stub\n", iface, stringid, strings, exists); + return E_NOTIMPL; } -static BOOL WINAPI dwritefontface3_HasCharacter(IDWriteFontFace4 *iface, UINT32 ch) +static BOOL WINAPI dwritefontface3_HasCharacter(IDWriteFontFace5 *iface, UINT32 ch) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); UINT16 index; - TRACE("(%p)->(%#x)\n", This, ch); + TRACE("%p, %#x.\n", iface, ch); index = 0; - if (FAILED(fontface_get_glyphs(This, &ch, 1, &index))) + if (FAILED(fontface_get_glyphs(fontface, &ch, 1, &index))) return FALSE; return index != 0; } -static HRESULT WINAPI dwritefontface3_GetRecommendedRenderingMode(IDWriteFontFace4 *iface, FLOAT emSize, FLOAT dpiX, FLOAT dpiY, +static HRESULT WINAPI dwritefontface3_GetRecommendedRenderingMode(IDWriteFontFace5 *iface, FLOAT emSize, FLOAT dpiX, FLOAT dpiY, DWRITE_MATRIX const *m, BOOL is_sideways, DWRITE_OUTLINE_THRESHOLD threshold, DWRITE_MEASURING_MODE measuring_mode, IDWriteRenderingParams *params, DWRITE_RENDERING_MODE1 *rendering_mode, DWRITE_GRID_FIT_MODE *gridfit_mode) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); unsigned int flags; FLOAT emthreshold; - TRACE("(%p)->(%.2f %.2f %.2f %p %d %d %d %p %p %p)\n", This, emSize, dpiX, dpiY, m, is_sideways, threshold, + TRACE("%p, %.8e, %.8e, %.8e, %p, %d, %d, %d, %p, %p, %p.\n", iface, emSize, dpiX, dpiY, m, is_sideways, threshold, measuring_mode, params, rendering_mode, gridfit_mode); if (m) @@ -1269,7 +1313,7 @@ static HRESULT WINAPI dwritefontface3_GetRecommendedRenderingMode(IDWriteFontFac emthreshold = threshold == DWRITE_OUTLINE_THRESHOLD_ANTIALIASED ? RECOMMENDED_OUTLINE_AA_THRESHOLD : RECOMMENDED_OUTLINE_A_THRESHOLD; - flags = opentype_get_gasp_flags(get_fontface_gasp(This), emSize); + flags = opentype_get_gasp_flags(get_fontface_gasp(fontface), emSize); if (*rendering_mode == DWRITE_RENDERING_MODE1_DEFAULT) { if (emSize >= emthreshold) @@ -1291,68 +1335,97 @@ static HRESULT WINAPI dwritefontface3_GetRecommendedRenderingMode(IDWriteFontFac return S_OK; } -static BOOL WINAPI dwritefontface3_IsCharacterLocal(IDWriteFontFace4 *iface, UINT32 ch) +static BOOL WINAPI dwritefontface3_IsCharacterLocal(IDWriteFontFace5 *iface, UINT32 ch) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(0x%x): stub\n", This, ch); + FIXME("%p, %#x: stub\n", iface, ch); + return FALSE; } -static BOOL WINAPI dwritefontface3_IsGlyphLocal(IDWriteFontFace4 *iface, UINT16 glyph) +static BOOL WINAPI dwritefontface3_IsGlyphLocal(IDWriteFontFace5 *iface, UINT16 glyph) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%u): stub\n", This, glyph); + FIXME("%p, %u: stub\n", iface, glyph); + return FALSE; } -static HRESULT WINAPI dwritefontface3_AreCharactersLocal(IDWriteFontFace4 *iface, WCHAR const *text, +static HRESULT WINAPI dwritefontface3_AreCharactersLocal(IDWriteFontFace5 *iface, WCHAR const *text, UINT32 count, BOOL enqueue_if_not, BOOL *are_local) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%s:%u %d %p): stub\n", This, debugstr_wn(text, count), count, enqueue_if_not, are_local); + FIXME("%p, %s:%u, %d %p: stub\n", iface, debugstr_wn(text, count), count, enqueue_if_not, are_local); + return E_NOTIMPL; } -static HRESULT WINAPI dwritefontface3_AreGlyphsLocal(IDWriteFontFace4 *iface, UINT16 const *glyphs, +static HRESULT WINAPI dwritefontface3_AreGlyphsLocal(IDWriteFontFace5 *iface, UINT16 const *glyphs, UINT32 count, BOOL enqueue_if_not, BOOL *are_local) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%p %u %d %p): stub\n", This, glyphs, count, enqueue_if_not, are_local); + FIXME("%p, %p, %u, %d, %p: stub\n", iface, glyphs, count, enqueue_if_not, are_local); + return E_NOTIMPL; } -static HRESULT WINAPI dwritefontface4_GetGlyphImageFormats_(IDWriteFontFace4 *iface, UINT16 glyph, +static HRESULT WINAPI dwritefontface4_GetGlyphImageFormats_(IDWriteFontFace5 *iface, UINT16 glyph, UINT32 ppem_first, UINT32 ppem_last, DWRITE_GLYPH_IMAGE_FORMATS *formats) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%u %u %u %p): stub\n", This, glyph, ppem_first, ppem_last, formats); + FIXME("%p, %u, %u, %u, %p: stub\n", iface, glyph, ppem_first, ppem_last, formats); + return E_NOTIMPL; } -static DWRITE_GLYPH_IMAGE_FORMATS WINAPI dwritefontface4_GetGlyphImageFormats(IDWriteFontFace4 *iface) +static DWRITE_GLYPH_IMAGE_FORMATS WINAPI dwritefontface4_GetGlyphImageFormats(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); + struct dwrite_fontface *fontface = impl_from_IDWriteFontFace5(iface); - TRACE("(%p)\n", This); + TRACE("%p.\n", iface); - return This->glyph_image_formats; + return fontface->glyph_image_formats; } -static HRESULT WINAPI dwritefontface4_GetGlyphImageData(IDWriteFontFace4 *iface, UINT16 glyph, +static HRESULT WINAPI dwritefontface4_GetGlyphImageData(IDWriteFontFace5 *iface, UINT16 glyph, UINT32 ppem, DWRITE_GLYPH_IMAGE_FORMATS format, DWRITE_GLYPH_IMAGE_DATA *data, void **context) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%u %u %d %p %p): stub\n", This, glyph, ppem, format, data, context); + FIXME("%p, %u, %u, %d, %p, %p: stub\n", iface, glyph, ppem, format, data, context); + + return E_NOTIMPL; +} + +static void WINAPI dwritefontface4_ReleaseGlyphImageData(IDWriteFontFace5 *iface, void *context) +{ + FIXME("%p, %p: stub\n", iface, context); +} + +static UINT32 WINAPI dwritefontface5_GetFontAxisValueCount(IDWriteFontFace5 *iface) +{ + FIXME("%p: stub\n", iface); + + return 0; +} + +static HRESULT WINAPI dwritefontface5_GetFontAxisValues(IDWriteFontFace5 *iface, DWRITE_FONT_AXIS_VALUE *axis_values, + UINT32 value_count) +{ + FIXME("%p, %p, %u: stub\n", iface, axis_values, value_count); + return E_NOTIMPL; } -static void WINAPI dwritefontface4_ReleaseGlyphImageData(IDWriteFontFace4 *iface, void *context) +static BOOL WINAPI dwritefontface5_HasVariantions(IDWriteFontFace5 *iface) { - struct dwrite_fontface *This = impl_from_IDWriteFontFace4(iface); - FIXME("(%p)->(%p): stub\n", This, context); + FIXME("%p: stub\n", iface); + + return FALSE; } -static const IDWriteFontFace4Vtbl dwritefontfacevtbl = { +static HRESULT WINAPI dwritefontface5_GetFontResource(IDWriteFontFace5 *iface, IDWriteFontResource **resource) +{ + FIXME("%p, %p: stub\n", iface, resource); + + return E_NOTIMPL; +} + +static const IDWriteFontFace5Vtbl dwritefontfacevtbl = +{ dwritefontface_QueryInterface, dwritefontface_AddRef, dwritefontface_Release, @@ -1405,10 +1478,14 @@ static const IDWriteFontFace4Vtbl dwritefontfacevtbl = { dwritefontface4_GetGlyphImageFormats_, dwritefontface4_GetGlyphImageFormats, dwritefontface4_GetGlyphImageData, - dwritefontface4_ReleaseGlyphImageData + dwritefontface4_ReleaseGlyphImageData, + dwritefontface5_GetFontAxisValueCount, + dwritefontface5_GetFontAxisValues, + dwritefontface5_HasVariantions, + dwritefontface5_GetFontResource, }; -static HRESULT get_fontface_from_font(struct dwrite_font *font, IDWriteFontFace4 **fontface) +static HRESULT get_fontface_from_font(struct dwrite_font *font, IDWriteFontFace5 **fontface) { struct dwrite_font_data *data = font->data; struct fontface_desc desc; @@ -1518,19 +1595,19 @@ static DWRITE_FONT_STYLE WINAPI dwritefont_GetStyle(IDWriteFont3 *iface) static BOOL WINAPI dwritefont_IsSymbolFont(IDWriteFont3 *iface) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - IDWriteFontFace4 *fontface; + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + IDWriteFontFace5 *fontface; HRESULT hr; BOOL ret; - TRACE("(%p)\n", This); + TRACE("%p.\n", iface); - hr = get_fontface_from_font(This, &fontface); + hr = get_fontface_from_font(font, &fontface); if (FAILED(hr)) return FALSE; - ret = IDWriteFontFace4_IsSymbolFont(fontface); - IDWriteFontFace4_Release(fontface); + ret = IDWriteFontFace5_IsSymbolFont(fontface); + IDWriteFontFace5_Release(fontface); return ret; } @@ -1544,11 +1621,11 @@ static HRESULT WINAPI dwritefont_GetFaceNames(IDWriteFont3 *iface, IDWriteLocali static HRESULT WINAPI dwritefont_GetInformationalStrings(IDWriteFont3 *iface, DWRITE_INFORMATIONAL_STRING_ID stringid, IDWriteLocalizedStrings **strings, BOOL *exists) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - struct dwrite_font_data *data = This->data; + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + struct dwrite_font_data *data = font->data; HRESULT hr; - TRACE("(%p)->(%d %p %p)\n", This, stringid, strings, exists); + TRACE("%p, %d, %p, %p.\n", iface, stringid, strings, exists); *exists = FALSE; *strings = NULL; @@ -1556,29 +1633,31 @@ static HRESULT WINAPI dwritefont_GetInformationalStrings(IDWriteFont3 *iface, if (stringid > DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME || stringid == DWRITE_INFORMATIONAL_STRING_NONE) return S_OK; - if (!data->info_strings[stringid]) { - IDWriteFontFace4 *fontface; + if (!data->info_strings[stringid]) + { + IDWriteFontFace5 *fontface; const void *table_data; BOOL table_exists; void *context; UINT32 size; - hr = get_fontface_from_font(This, &fontface); + hr = get_fontface_from_font(font, &fontface); if (FAILED(hr)) return hr; table_exists = FALSE; - hr = IDWriteFontFace4_TryGetFontTable(fontface, MS_NAME_TAG, &table_data, &size, &context, &table_exists); + hr = IDWriteFontFace5_TryGetFontTable(fontface, MS_NAME_TAG, &table_data, &size, &context, &table_exists); if (FAILED(hr) || !table_exists) WARN("no NAME table found.\n"); - if (table_exists) { + if (table_exists) + { hr = opentype_get_font_info_strings(table_data, stringid, &data->info_strings[stringid]); - IDWriteFontFace4_ReleaseFontTable(fontface, context); + IDWriteFontFace5_ReleaseFontTable(fontface, context); if (FAILED(hr) || !data->info_strings[stringid]) return hr; } - IDWriteFontFace4_Release(fontface); + IDWriteFontFace5_Release(fontface); } hr = clone_localizedstring(data->info_strings[stringid], strings); @@ -1606,7 +1685,7 @@ static void WINAPI dwritefont_GetMetrics(IDWriteFont3 *iface, DWRITE_FONT_METRIC static HRESULT font_has_character(struct dwrite_font *font, UINT32 ch, BOOL *exists) { - IDWriteFontFace4 *fontface; + IDWriteFontFace5 *fontface; UINT16 index; HRESULT hr; @@ -1617,8 +1696,8 @@ static HRESULT font_has_character(struct dwrite_font *font, UINT32 ch, BOOL *exi return hr; index = 0; - hr = IDWriteFontFace4_GetGlyphIndices(fontface, &ch, 1, &index); - IDWriteFontFace4_Release(fontface); + hr = IDWriteFontFace5_GetGlyphIndices(fontface, &ch, 1, &index); + IDWriteFontFace5_Release(fontface); if (FAILED(hr)) return hr; @@ -1637,9 +1716,11 @@ static HRESULT WINAPI dwritefont_HasCharacter(IDWriteFont3 *iface, UINT32 ch, BO static HRESULT WINAPI dwritefont_CreateFontFace(IDWriteFont3 *iface, IDWriteFontFace **fontface) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - TRACE("(%p)->(%p)\n", This, fontface); - return get_fontface_from_font(This, (IDWriteFontFace4 **)fontface); + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + + TRACE("%p, %p.\n", iface, fontface); + + return get_fontface_from_font(font, (IDWriteFontFace5 **)fontface); } static void WINAPI dwritefont1_GetMetrics(IDWriteFont3 *iface, DWRITE_FONT_METRICS1 *metrics) @@ -1658,64 +1739,64 @@ static void WINAPI dwritefont1_GetPanose(IDWriteFont3 *iface, DWRITE_PANOSE *pan static HRESULT WINAPI dwritefont1_GetUnicodeRanges(IDWriteFont3 *iface, UINT32 max_count, DWRITE_UNICODE_RANGE *ranges, UINT32 *count) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - IDWriteFontFace4 *fontface; + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + IDWriteFontFace5 *fontface; HRESULT hr; - TRACE("(%p)->(%u %p %p)\n", This, max_count, ranges, count); + TRACE("%p, %u, %p, %p.\n", iface, max_count, ranges, count); - hr = get_fontface_from_font(This, &fontface); + hr = get_fontface_from_font(font, &fontface); if (FAILED(hr)) return hr; - hr = IDWriteFontFace4_GetUnicodeRanges(fontface, max_count, ranges, count); - IDWriteFontFace4_Release(fontface); + hr = IDWriteFontFace5_GetUnicodeRanges(fontface, max_count, ranges, count); + IDWriteFontFace5_Release(fontface); return hr; } static BOOL WINAPI dwritefont1_IsMonospacedFont(IDWriteFont3 *iface) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - IDWriteFontFace4 *fontface; + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + IDWriteFontFace5 *fontface; HRESULT hr; BOOL ret; - TRACE("(%p)\n", This); + TRACE("%p.\n", iface); - hr = get_fontface_from_font(This, &fontface); + hr = get_fontface_from_font(font, &fontface); if (FAILED(hr)) return FALSE; - ret = IDWriteFontFace4_IsMonospacedFont(fontface); - IDWriteFontFace4_Release(fontface); + ret = IDWriteFontFace5_IsMonospacedFont(fontface); + IDWriteFontFace5_Release(fontface); return ret; } static BOOL WINAPI dwritefont2_IsColorFont(IDWriteFont3 *iface) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); - IDWriteFontFace4 *fontface; + struct dwrite_font *font = impl_from_IDWriteFont3(iface); + IDWriteFontFace5 *fontface; HRESULT hr; BOOL ret; - TRACE("(%p)\n", This); + TRACE("%p.\n", iface); - hr = get_fontface_from_font(This, &fontface); + hr = get_fontface_from_font(font, &fontface); if (FAILED(hr)) return FALSE; - ret = IDWriteFontFace4_IsColorFont(fontface); - IDWriteFontFace4_Release(fontface); + ret = IDWriteFontFace5_IsColorFont(fontface); + IDWriteFontFace5_Release(fontface); return ret; } static HRESULT WINAPI dwritefont3_CreateFontFace(IDWriteFont3 *iface, IDWriteFontFace3 **fontface) { - struct dwrite_font *This = impl_from_IDWriteFont3(iface); + struct dwrite_font *font = impl_from_IDWriteFont3(iface); - TRACE("(%p)->(%p)\n", This, fontface); + TRACE("%p, %p.\n", iface, fontface); - return get_fontface_from_font(This, (IDWriteFontFace4 **)fontface); + return get_fontface_from_font(font, (IDWriteFontFace5 **)fontface); } static BOOL WINAPI dwritefont3_Equals(IDWriteFont3 *iface, IDWriteFont *font) @@ -1792,7 +1873,7 @@ struct dwrite_fontface *unsafe_impl_from_IDWriteFontFace(IDWriteFontFace *iface) if (!iface) return NULL; assert(iface->lpVtbl == (IDWriteFontFaceVtbl*)&dwritefontfacevtbl); - return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace4_iface); + return CONTAINING_RECORD(iface, struct dwrite_fontface, IDWriteFontFace5_iface); } void get_logfont_from_font(IDWriteFont *iface, LOGFONTW *lf) @@ -4532,7 +4613,7 @@ HRESULT create_font_file(IDWriteFontFileLoader *loader, const void *reference_ke return S_OK; } -HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_list, IDWriteFontFace4 **ret) +HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_list, IDWriteFontFace5 **ret) { struct file_stream_desc stream_desc; struct dwrite_fontface *fontface; @@ -4552,8 +4633,8 @@ HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_li return E_OUTOFMEMORY; } - fontface->IDWriteFontFace4_iface.lpVtbl = &dwritefontfacevtbl; - fontface->ref = 1; + fontface->IDWriteFontFace5_iface.lpVtbl = &dwritefontfacevtbl; + fontface->refcount = 1; fontface->type = desc->face_type; fontface->file_count = desc->files_number; fontface->cmap.exists = TRUE; @@ -4585,16 +4666,16 @@ HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_li } } - fontface->charmap = freetype_get_charmap_index(&fontface->IDWriteFontFace4_iface, &is_symbol); + fontface->charmap = freetype_get_charmap_index(&fontface->IDWriteFontFace5_iface, &is_symbol); if (is_symbol) fontface->flags |= FONTFACE_IS_SYMBOL; - if (freetype_has_kerning_pairs(&fontface->IDWriteFontFace4_iface)) + if (freetype_has_kerning_pairs(&fontface->IDWriteFontFace5_iface)) fontface->flags |= FONTFACE_HAS_KERNING_PAIRS; - if (freetype_is_monospaced(&fontface->IDWriteFontFace4_iface)) + if (freetype_is_monospaced(&fontface->IDWriteFontFace5_iface)) fontface->flags |= FONTFACE_IS_MONOSPACED; - if (opentype_has_vertical_variants(&fontface->IDWriteFontFace4_iface)) + if (opentype_has_vertical_variants(&fontface->IDWriteFontFace5_iface)) fontface->flags |= FONTFACE_HAS_VERTICAL_VARIANTS; - fontface->glyph_image_formats = opentype_get_glyph_image_formats(&fontface->IDWriteFontFace4_iface); + fontface->glyph_image_formats = opentype_get_glyph_image_formats(&fontface->IDWriteFontFace5_iface); /* Font properties are reused from font object when 'normal' face creation path is used: collection -> family -> matching font -> fontface. @@ -4614,8 +4695,9 @@ HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_li struct dwrite_font_data *data; hr = init_font_data(desc, &names, &data); - if (FAILED(hr)) { - IDWriteFontFace4_Release(&fontface->IDWriteFontFace4_iface); + if (FAILED(hr)) + { + IDWriteFontFace5_Release(&fontface->IDWriteFontFace5_iface); return hr; } @@ -4630,9 +4712,10 @@ HRESULT create_fontface(const struct fontface_desc *desc, struct list *cached_li release_font_data(data); } - fontface->cached = factory_cache_fontface(fontface->factory, cached_list, &fontface->IDWriteFontFace4_iface); + fontface->cached = factory_cache_fontface(fontface->factory, cached_list, &fontface->IDWriteFontFace5_iface); + + *ret = &fontface->IDWriteFontFace5_iface; - *ret = &fontface->IDWriteFontFace4_iface; return S_OK; } @@ -5670,8 +5753,8 @@ static ULONG WINAPI colorglyphenum_Release(IDWriteColorGlyphRunEnumerator1 *ifac heap_free(glyphenum->glyphindices); heap_free(glyphenum->glyphs); if (glyphenum->colr.context) - IDWriteFontFace4_ReleaseFontTable(glyphenum->fontface, glyphenum->colr.context); - IDWriteFontFace4_Release(glyphenum->fontface); + IDWriteFontFace5_ReleaseFontTable(glyphenum->fontface, glyphenum->colr.context); + IDWriteFontFace5_Release(glyphenum->fontface); heap_free(glyphenum); } @@ -5744,9 +5827,10 @@ static BOOL colorglyphenum_build_color_run(struct dwrite_colorglyphenum *glyphen colorrun->paletteIndex = glyphenum->glyphs[g].palette_index; /* use foreground color or request one from the font */ memset(&colorrun->runColor, 0, sizeof(colorrun->runColor)); - if (colorrun->paletteIndex != 0xffff) { - HRESULT hr = IDWriteFontFace4_GetPaletteEntries(glyphenum->fontface, glyphenum->palette, colorrun->paletteIndex, - 1, &colorrun->runColor); + if (colorrun->paletteIndex != 0xffff) + { + HRESULT hr = IDWriteFontFace5_GetPaletteEntries(glyphenum->fontface, glyphenum->palette, + colorrun->paletteIndex, 1, &colorrun->runColor); if (FAILED(hr)) WARN("failed to get palette entry, fontface %p, palette %u, index %u, 0x%08x\n", glyphenum->fontface, glyphenum->palette, colorrun->paletteIndex, hr); @@ -5857,8 +5941,8 @@ HRESULT create_colorglyphenum(float originX, float originY, const DWRITE_GLYPH_R fontface = unsafe_impl_from_IDWriteFontFace(run->fontFace); - colorfont = IDWriteFontFace4_IsColorFont(&fontface->IDWriteFontFace4_iface) && - IDWriteFontFace4_GetColorPaletteCount(&fontface->IDWriteFontFace4_iface) > palette; + colorfont = IDWriteFontFace5_IsColorFont(&fontface->IDWriteFontFace5_iface) && + IDWriteFontFace5_GetColorPaletteCount(&fontface->IDWriteFontFace5_iface) > palette; if (!colorfont) return DWRITE_E_NOCOLOR; @@ -5870,8 +5954,8 @@ HRESULT create_colorglyphenum(float originX, float originY, const DWRITE_GLYPH_R colorglyphenum->refcount = 1; colorglyphenum->origin_x = originX; colorglyphenum->origin_y = originY; - colorglyphenum->fontface = &fontface->IDWriteFontFace4_iface; - IDWriteFontFace4_AddRef(colorglyphenum->fontface); + colorglyphenum->fontface = &fontface->IDWriteFontFace5_iface; + IDWriteFontFace5_AddRef(colorglyphenum->fontface); colorglyphenum->glyphs = NULL; colorglyphenum->run = *run; colorglyphenum->run.glyphIndices = NULL; @@ -5880,7 +5964,7 @@ HRESULT create_colorglyphenum(float originX, float originY, const DWRITE_GLYPH_R colorglyphenum->palette = palette; memset(&colorglyphenum->colr, 0, sizeof(colorglyphenum->colr)); colorglyphenum->colr.exists = TRUE; - get_fontface_table(&fontface->IDWriteFontFace4_iface, MS_COLR_TAG, &colorglyphenum->colr); + get_fontface_table(&fontface->IDWriteFontFace5_iface, MS_COLR_TAG, &colorglyphenum->colr); colorglyphenum->current_layer = 0; colorglyphenum->max_layer_num = 0; diff --git a/dlls/dwrite/freetype.c b/dlls/dwrite/freetype.c index 16317036e3..ffc97f1d8a 100644 --- a/dlls/dwrite/freetype.c +++ b/dlls/dwrite/freetype.c @@ -256,7 +256,7 @@ void release_freetype(void) pFT_Done_FreeType(library); } -void freetype_notify_cacheremove(IDWriteFontFace4 *fontface) +void freetype_notify_cacheremove(IDWriteFontFace5 *fontface) { EnterCriticalSection(&freetype_cs); pFTC_Manager_RemoveFaceID(cache_manager, fontface); @@ -268,7 +268,7 @@ HRESULT freetype_get_design_glyph_metrics(struct dwrite_fontface *fontface, UINT FTC_ScalerRec scaler; FT_Size size; - scaler.face_id = &fontface->IDWriteFontFace4_iface; + scaler.face_id = &fontface->IDWriteFontFace5_iface; scaler.width = fontface->metrics.designUnitsPerEm; scaler.height = fontface->metrics.designUnitsPerEm; scaler.pixel = 1; @@ -303,7 +303,7 @@ HRESULT freetype_get_design_glyph_metrics(struct dwrite_fontface *fontface, UINT return S_OK; } -BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface) +BOOL freetype_is_monospaced(IDWriteFontFace5 *fontface) { BOOL is_monospaced = FALSE; FT_Face face; @@ -484,7 +484,7 @@ static void embolden_glyph(FT_Glyph glyph, FLOAT emsize) embolden_glyph_outline(&outline_glyph->outline, emsize); } -HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, float emSize, UINT16 const *glyphs, +HRESULT freetype_get_glyphrun_outline(IDWriteFontFace5 *fontface, float emSize, UINT16 const *glyphs, float const *advances, DWRITE_GLYPH_OFFSET const *offsets, unsigned int count, BOOL is_rtl, IDWriteGeometrySink *sink) { @@ -498,7 +498,7 @@ HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, float emSize, ID2D1SimplifiedGeometrySink_SetFillMode(sink, D2D1_FILL_MODE_WINDING); - simulations = IDWriteFontFace4_GetSimulations(fontface); + simulations = IDWriteFontFace5_GetSimulations(fontface); scaler.face_id = fontface; scaler.width = emSize; @@ -563,7 +563,7 @@ HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, float emSize, return hr; } -UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface) +UINT16 freetype_get_glyphcount(IDWriteFontFace5 *fontface) { UINT16 count = 0; FT_Face face; @@ -576,7 +576,7 @@ UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface) return count; } -void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count, +void freetype_get_glyphs(IDWriteFontFace5 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count, UINT16 *glyphs) { UINT32 i; @@ -597,7 +597,7 @@ void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const * LeaveCriticalSection(&freetype_cs); } -BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface) +BOOL freetype_has_kerning_pairs(IDWriteFontFace5 *fontface) { BOOL has_kerning_pairs = FALSE; FT_Face face; @@ -610,7 +610,7 @@ BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface) return has_kerning_pairs; } -INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right) +INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace5 *fontface, UINT16 left, UINT16 right) { INT32 adjustment = 0; FT_Face face; @@ -855,7 +855,7 @@ BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap) return ret; } -INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol) +INT freetype_get_charmap_index(IDWriteFontFace5 *fontface, BOOL *is_symbol) { INT charmap_index = -1; FT_Face face; @@ -887,7 +887,7 @@ INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol) return charmap_index; } -INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode, +INT32 freetype_get_glyph_advance(IDWriteFontFace5 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode, BOOL *has_contours) { FTC_ImageTypeRec imagetype; @@ -926,7 +926,7 @@ void release_freetype(void) { } -void freetype_notify_cacheremove(IDWriteFontFace4 *fontface) +void freetype_notify_cacheremove(IDWriteFontFace5 *fontface) { } @@ -935,35 +935,35 @@ HRESULT freetype_get_design_glyph_metrics(struct dwrite_fontface *fontface, UINT return E_NOTIMPL; } -BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface) +BOOL freetype_is_monospaced(IDWriteFontFace5 *fontface) { return FALSE; } -HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, float emSize, UINT16 const *glyphs, +HRESULT freetype_get_glyphrun_outline(IDWriteFontFace5 *fontface, float emSize, UINT16 const *glyphs, float const *advances, DWRITE_GLYPH_OFFSET const *offsets, unsigned int count, BOOL is_rtl, IDWriteGeometrySink *sink) { return E_NOTIMPL; } -UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface) +UINT16 freetype_get_glyphcount(IDWriteFontFace5 *fontface) { return 0; } -void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count, +void freetype_get_glyphs(IDWriteFontFace5 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count, UINT16 *glyphs) { memset(glyphs, 0, count * sizeof(*glyphs)); } -BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface) +BOOL freetype_has_kerning_pairs(IDWriteFontFace5 *fontface) { return FALSE; } -INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right) +INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace5 *fontface, UINT16 left, UINT16 right) { return 0; } @@ -978,13 +978,13 @@ BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap) return FALSE; } -INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol) +INT freetype_get_charmap_index(IDWriteFontFace5 *fontface, BOOL *is_symbol) { *is_symbol = FALSE; return -1; } -INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode, +INT32 freetype_get_glyph_advance(IDWriteFontFace5 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode, BOOL *has_contours) { *has_contours = FALSE; diff --git a/dlls/dwrite/main.c b/dlls/dwrite/main.c index fb3ed090e6..7b97d77bd1 100644 --- a/dlls/dwrite/main.c +++ b/dlls/dwrite/main.c @@ -901,14 +901,14 @@ HRESULT factory_get_cached_fontface(IDWriteFactory5 *iface, IDWriteFontFile * co const void *cached_key; IDWriteFontFile *file; - cached_face_index = IDWriteFontFace4_GetIndex(cached->fontface); - cached_simulations = IDWriteFontFace4_GetSimulations(cached->fontface); + cached_face_index = IDWriteFontFace5_GetIndex(cached->fontface); + cached_simulations = IDWriteFontFace5_GetSimulations(cached->fontface); /* skip earlier */ if (cached_face_index != index || cached_simulations != simulations) continue; - hr = IDWriteFontFace4_GetFiles(cached->fontface, &count, &file); + hr = IDWriteFontFace5_GetFiles(cached->fontface, &count, &file); if (FAILED(hr)) break; @@ -917,8 +917,9 @@ HRESULT factory_get_cached_fontface(IDWriteFactory5 *iface, IDWriteFontFile * co if (FAILED(hr)) break; - if (cached_key_size == key_size && !memcmp(cached_key, key, key_size)) { - if (FAILED(hr = IDWriteFontFace4_QueryInterface(cached->fontface, riid, obj))) + if (cached_key_size == key_size && !memcmp(cached_key, key, key_size)) + { + if (FAILED(hr = IDWriteFontFace5_QueryInterface(cached->fontface, riid, obj))) WARN("Failed to get %s from fontface, hr %#x.\n", debugstr_guid(riid), hr); TRACE("returning cached fontface %p\n", cached->fontface); @@ -932,7 +933,7 @@ HRESULT factory_get_cached_fontface(IDWriteFactory5 *iface, IDWriteFontFile * co } struct fontfacecached *factory_cache_fontface(IDWriteFactory5 *iface, struct list *fontfaces, - IDWriteFontFace4 *fontface) + IDWriteFontFace5 *fontface) { struct dwritefactory *factory = impl_from_IDWriteFactory5(iface); struct fontfacecached *cached; @@ -1011,7 +1012,7 @@ static HRESULT WINAPI dwritefactory_CreateFontFace(IDWriteFactory5 *iface, DWRIT desc.index = index; desc.simulations = simulations; desc.font_data = NULL; - hr = create_fontface(&desc, fontfaces, (IDWriteFontFace4 **)fontface); + hr = create_fontface(&desc, fontfaces, (IDWriteFontFace5 **)fontface); failed: IDWriteFontFileStream_Release(stream); diff --git a/dlls/dwrite/opentype.c b/dlls/dwrite/opentype.c index efae402f91..09a9a861c3 100644 --- a/dlls/dwrite/opentype.c +++ b/dlls/dwrite/opentype.c @@ -2440,7 +2440,7 @@ void opentype_colr_next_glyph(const struct dwrite_fonttable *colr, struct dwrite } } -BOOL opentype_has_vertical_variants(IDWriteFontFace4 *fontface) +BOOL opentype_has_vertical_variants(IDWriteFontFace5 *fontface) { const struct gpos_gsub_header *header; const struct ot_feature_list *featurelist; @@ -2452,7 +2452,7 @@ BOOL opentype_has_vertical_variants(IDWriteFontFace4 *fontface) UINT32 size; HRESULT hr; - hr = IDWriteFontFace4_TryGetFontTable(fontface, MS_GSUB_TAG, &data, &size, &context, &exists); + hr = IDWriteFontFace5_TryGetFontTable(fontface, MS_GSUB_TAG, &data, &size, &context, &exists); if (FAILED(hr) || !exists) return FALSE; @@ -2510,12 +2510,12 @@ BOOL opentype_has_vertical_variants(IDWriteFontFace4 *fontface) } } - IDWriteFontFace4_ReleaseFontTable(fontface, context); + IDWriteFontFace5_ReleaseFontTable(fontface, context); return ret; } -static BOOL opentype_has_font_table(IDWriteFontFace4 *fontface, UINT32 tag) +static BOOL opentype_has_font_table(IDWriteFontFace5 *fontface, UINT32 tag) { BOOL exists = FALSE; const void *data; @@ -2523,17 +2523,17 @@ static BOOL opentype_has_font_table(IDWriteFontFace4 *fontface, UINT32 tag) UINT32 size; HRESULT hr; - hr = IDWriteFontFace4_TryGetFontTable(fontface, tag, &data, &size, &context, &exists); + hr = IDWriteFontFace5_TryGetFontTable(fontface, tag, &data, &size, &context, &exists); if (FAILED(hr)) return FALSE; if (exists) - IDWriteFontFace4_ReleaseFontTable(fontface, context); + IDWriteFontFace5_ReleaseFontTable(fontface, context); return exists; } -static unsigned int opentype_get_sbix_formats(IDWriteFontFace4 *fontface) +static unsigned int opentype_get_sbix_formats(IDWriteFontFace5 *fontface) { unsigned int num_strikes, num_glyphs, i, j, ret = 0; const struct sbix_header *sbix_header; @@ -2547,7 +2547,7 @@ static unsigned int opentype_get_sbix_formats(IDWriteFontFace4 *fontface) num_glyphs = table_read_be_word(&table, FIELD_OFFSET(struct maxp, num_glyphs)); - IDWriteFontFace4_ReleaseFontTable(fontface, table.context); + IDWriteFontFace5_ReleaseFontTable(fontface, table.context); memset(&table, 0, sizeof(table)); table.exists = TRUE; @@ -2600,12 +2600,12 @@ static unsigned int opentype_get_sbix_formats(IDWriteFontFace4 *fontface) } } - IDWriteFontFace4_ReleaseFontTable(fontface, table.context); + IDWriteFontFace5_ReleaseFontTable(fontface, table.context); return ret; } -static unsigned int opentype_get_cblc_formats(IDWriteFontFace4 *fontface) +static unsigned int opentype_get_cblc_formats(IDWriteFontFace5 *fontface) { const unsigned int format_mask = DWRITE_GLYPH_IMAGE_FORMATS_PNG | DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8; @@ -2637,12 +2637,12 @@ static unsigned int opentype_get_cblc_formats(IDWriteFontFace4 *fontface) } } - IDWriteFontFace4_ReleaseFontTable(fontface, cblc.context); + IDWriteFontFace5_ReleaseFontTable(fontface, cblc.context); return ret; } -UINT32 opentype_get_glyph_image_formats(IDWriteFontFace4 *fontface) +UINT32 opentype_get_glyph_image_formats(IDWriteFontFace5 *fontface) { UINT32 ret = DWRITE_GLYPH_IMAGE_FORMATS_NONE; -- 2.24.0

1 2

[PATCH] testbot/LibvirtTool: Only check the start count after a reboot.
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

The start count check is not related to taking live snapshots. And we can skip it if the VM was not freshly booted. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/LibvirtTool.pl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testbot/bin/LibvirtTool.pl b/testbot/bin/LibvirtTool.pl index e5dc8372e..a2939e738 100755 --- a/testbot/bin/LibvirtTool.pl +++ b/testbot/bin/LibvirtTool.pl @@ -463,14 +463,14 @@ sub SetupTestAgentd($$$$) # So it all works out. $TA->SetProperty("start.count", 0); } - else + elsif ($Booting) { # Check that TestAgentd is not displaying the "Has Windows rebooted?" # warning. my $Count = $TA->GetProperties("start.count"); if (defined $Count and $Count > 1) { - FatalError("Cannot take a live snapshot because start.count=$Count > 1"); + FatalError("The VM has been rebooted too many times: start.count=$Count > 1"); } } $TA->Disconnect(); -- 2.20.1

1 0

[PATCH] testbot/LogUtils: Skip the search for new errors if there is no error.
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

This avoids loading and parsing the reference log when not needed. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/LogUtils.pm | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/testbot/lib/WineTestBot/LogUtils.pm b/testbot/lib/WineTestBot/LogUtils.pm index 282906e62..51932965c 100644 --- a/testbot/lib/WineTestBot/LogUtils.pm +++ b/testbot/lib/WineTestBot/LogUtils.pm @@ -888,10 +888,12 @@ sub GetNewLogErrors($$$) { my ($RefFileName, $Groups, $Errors) = @_; + my (@NewGroups, %NewErrors, %NewIndices); + return (\@NewGroups, \%NewErrors, \%NewIndices) if (!@$Groups); + my ($RefGroups, $RefErrors) = GetLogErrors($RefFileName); return (undef, undef) if (!$RefGroups); - my (@NewGroups, %NewErrors, %NewIndices); foreach my $GroupName (@$Groups) { if ($RefErrors->{$GroupName}) -- 2.20.1

1 0

[PATCH] testbot/WineRunTask: Move TestAgent error reporting to match WineRunWineTest.
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

It belongs in the wrap up section which makes it less likely that code will be inserted between it and WrapUpAndExit(). Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/WineRunTask.pl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/testbot/bin/WineRunTask.pl b/testbot/bin/WineRunTask.pl index 1f21050b3..a324265eb 100755 --- a/testbot/bin/WineRunTask.pl +++ b/testbot/bin/WineRunTask.pl @@ -584,11 +584,11 @@ elsif (!defined $TAError) } $TA->Disconnect(); -FatalTAError(undef, $TAError, $PossibleCrash) if (defined $TAError); - # # Wrap up # +FatalTAError(undef, $TAError, $PossibleCrash) if (defined $TAError); + WrapUpAndExit($NewStatus, $TaskFailures, undef, $TaskTimedOut); -- 2.20.1

1 0

[PATCH] testbotWineRunReconfig: Fix formatting of a trace.
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/WineRunReconfig.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testbot/bin/WineRunReconfig.pl b/testbot/bin/WineRunReconfig.pl index 5c7b46bb9..985d9312e 100755 --- a/testbot/bin/WineRunReconfig.pl +++ b/testbot/bin/WineRunReconfig.pl @@ -503,7 +503,7 @@ if ($NewStatus eq "completed") my $ErrMessage = $TA->GetLastError(); FatalError("Could not connect to the new ". $VM->Name ." TestAgent: $ErrMessage\n"); } - Debug(Elapsed($Start), "Upgraded testagentd to $Version\n"); + Debug(Elapsed($Start), " Upgraded testagentd to $Version\n"); } } -- 2.20.1

1 0

[PATCH] testbot: Fix the VM Missions validation.
by Francois Gouget Dec. 2, 2019

Dec. 2, 2019

$Item->Xxx("foo") does not go through PutColValue()! Instead AUTOLOAD sets the specified property directly, maybe fori performance reasons, and PutColValue() is only used by DBIBackend.pm. WineTestBot::VMs was overriding PutColValue() to only revalidate a VM's missions field if either the VM Type of Missions field were modified. But instead ValidateMissions was always true after loading a VM from the database (because of the PutColValue() calls), and not when creating a new VM (in which case all the properties are set through AUTOLOAD). So take a snapshot of the initial Type and Missions values when the database code resets the IsModified field by calling ResetModified(); and then revalidate them whenever they have changed. Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/lib/WineTestBot/VMs.pm | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/testbot/lib/WineTestBot/VMs.pm b/testbot/lib/WineTestBot/VMs.pm index 37ebf9a62..279b7bccd 100644 --- a/testbot/lib/WineTestBot/VMs.pm +++ b/testbot/lib/WineTestBot/VMs.pm @@ -304,15 +304,13 @@ sub KillChild($) $self->ChildPid(undef); } -sub PutColValue($$$) +sub ResetModified($) { - my ($self, $ColName, $Value) = @_; + my ($self) = @_; - $self->SUPER::PutColValue($ColName, $Value); - if ($self->{IsModified} and ($ColName eq "Type" or $ColName eq "Missions")) - { - $self->{ValidateMissions} = 1; - } + $self->SUPER::ResetModified(); + $self->{OldType} = $self->Type; + $self->{OldMissions} = $self->Missions; } my $_SupportedMissions = { @@ -331,7 +329,8 @@ sub Validate($) { return ("Role", "Only win32, win64 and wine VMs can have a role of '" . $self->Role . "'"); } - if ($self->{ValidateMissions}) + if ($self->ValuesDiffer($self->{OldType}, $self->Type) or + $self->ValuesDiffer($self->{OldMissions}, $self->Missions)) { my ($ErrMessage, $Missions) = ParseMissionStatement($self->Missions); return ("Missions", $ErrMessage) if (defined $ErrMessage); @@ -350,7 +349,8 @@ sub Validate($) } } } - delete $self->{ValidateMissions}; + $self->{OldType} = $self->Type; + $self->{OldMissions} = $self->Missions; } return $self->SUPER::Validate(); -- 2.20.1

1 0

[PATCH v2 3/3] wined3d: Check dirty region dimensions.
by Akihiro Sagawa Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d8/tests/visual.c | 2 +- dlls/d3d9/tests/visual.c | 2 +- dlls/wined3d/texture.c | 7 +++++++ 3 files changed, 9 insertions(+), 2 deletions(-)

1 0

[PATCH v2 2/3] d3d8/tests: Add out-of-bounds region tests.
by Akihiro Sagawa Dec. 2, 2019

Dec. 2, 2019

In v2, fix todo_wine keyword position. Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d8/tests/visual.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)

1 0

[PATCH v2 1/3] d3d9/tests: Add out-of-bounds region tests.
by Akihiro Sagawa Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d9/tests/visual.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)

1 0

[PATCH 4/4] wusa: Install updates.
by Hans Leidekker Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- programs/wusa/Makefile.in | 2 +- programs/wusa/main.c | 562 ++++++++++++++++++++++++++++++++++++++ programs/wusa/wusa.h | 19 ++ 3 files changed, 582 insertions(+), 1 deletion(-) diff --git a/programs/wusa/Makefile.in b/programs/wusa/Makefile.in index 87bfe1dae0..4167747ffc 100644 --- a/programs/wusa/Makefile.in +++ b/programs/wusa/Makefile.in @@ -1,5 +1,5 @@ MODULE = wusa.exe -IMPORTS = cabinet shlwapi ole32 oleaut32 +IMPORTS = cabinet shlwapi ole32 oleaut32 advapi32 EXTRADLLFLAGS = -mconsole -municode -mno-cygwin diff --git a/programs/wusa/main.c b/programs/wusa/main.c index 8df8731e2b..49e7dc7530 100644 --- a/programs/wusa/main.c +++ b/programs/wusa/main.c @@ -29,6 +29,13 @@ WINE_DEFAULT_DEBUG_CHANNEL(wusa); +struct strbuf +{ + WCHAR *buf; + DWORD pos; + DWORD len; +}; + struct installer_tempdir { struct list entry; @@ -394,6 +401,508 @@ static BOOL load_assemblies_from_cab(const WCHAR *filename, struct installer_sta return TRUE; } +static BOOL compare_assembly_string(const WCHAR *str1, const WCHAR *str2) +{ + return !wcscmp(str1, str2) || !wcscmp(str1, L"*") || !wcscmp(str2, L"*"); +} + +static struct assembly_entry *lookup_assembly(struct list *manifest_list, struct assembly_identity *identity) +{ + struct assembly_entry *assembly; + + LIST_FOR_EACH_ENTRY(assembly, manifest_list, struct assembly_entry, entry) + { + if (wcsicmp(assembly->identity.name, identity->name)) continue; + if (!compare_assembly_string(assembly->identity.architecture, identity->architecture)) continue; + if (!compare_assembly_string(assembly->identity.language, identity->language)) continue; + if (!compare_assembly_string(assembly->identity.pubkey_token, identity->pubkey_token)) continue; + if (!compare_assembly_string(assembly->identity.version, identity->version)) + { + WARN("Ignoring version difference for %s (expected %s, found %s)\n", + debugstr_w(identity->name), debugstr_w(identity->version), debugstr_w(assembly->identity.version)); + } + return assembly; + } + + return NULL; +} + +static WCHAR *get_assembly_source(struct assembly_entry *assembly) +{ + WCHAR *p, *path = strdupW(assembly->filename); + if (path && (p = wcsrchr(path, '.'))) *p = 0; + return path; +} + +static BOOL strbuf_init(struct strbuf *buf) +{ + buf->pos = 0; + buf->len = 64; + buf->buf = heap_alloc(buf->len * sizeof(WCHAR)); + return buf->buf != NULL; +} + +static void strbuf_free(struct strbuf *buf) +{ + heap_free(buf->buf); + buf->buf = NULL; +} + +static BOOL strbuf_append(struct strbuf *buf, const WCHAR *str, DWORD len) +{ + DWORD new_len; + WCHAR *new_buf; + + if (!buf->buf) return FALSE; + if (!str) return TRUE; + + if (len == ~0U) len = lstrlenW(str); + if (buf->pos + len + 1 > buf->len) + { + new_len = max(buf->pos + len + 1, buf->len * 2); + new_buf = heap_realloc(buf->buf, new_len * sizeof(WCHAR)); + if (!new_buf) + { + strbuf_free(buf); + return FALSE; + } + buf->buf = new_buf; + buf->len = new_len; + } + + memcpy(&buf->buf[buf->pos], str, len * sizeof(WCHAR)); + buf->buf[buf->pos + len] = 0; + buf->pos += len; + return TRUE; +} + +static WCHAR *lookup_expression(struct assembly_entry *assembly, const WCHAR *key) +{ + WCHAR path[MAX_PATH]; + + if (!wcscmp(key, L"runtime.system32")) + { +#ifdef __x86_64__ + if (!wcscmp(assembly->identity.architecture, L"x86")) + { + GetSystemWow64DirectoryW(path, ARRAY_SIZE(path)); + return strdupW(path); + } +#endif + GetSystemDirectoryW(path, ARRAY_SIZE(path)); + return strdupW(path); + } + if (!wcscmp(key, L"runtime.windows")) + { + GetWindowsDirectoryW(path, ARRAY_SIZE(path)); + return strdupW(path); + } + + FIXME("Unknown expression %s\n", debugstr_w(key)); + return NULL; +} + +static WCHAR *expand_expression(struct assembly_entry *assembly, const WCHAR *expression) +{ + const WCHAR *pos, *next; + WCHAR *key, *value; + struct strbuf buf; + + if (!expression || !strbuf_init(&buf)) return NULL; + + for (pos = expression; (next = wcsstr(pos, L"$(")); pos = next + 1) + { + strbuf_append(&buf, pos, next - pos); + pos = next + 2; + if (!(next = wcsstr(pos, L")"))) + { + strbuf_append(&buf, L"$(", 2); + break; + } + + if (!(key = strdupWn(pos, next - pos))) goto error; + value = lookup_expression(assembly, key); + heap_free(key); + if (!value) goto error; + strbuf_append(&buf, value, ~0U); + heap_free(value); + } + + strbuf_append(&buf, pos, ~0U); + return buf.buf; + +error: + FIXME("Couldn't resolve expression %s\n", debugstr_w(expression)); + strbuf_free(&buf); + return NULL; +} + +static BOOL install_files_copy(struct assembly_entry *assembly, const WCHAR *source_path, struct fileop_entry *fileop, BOOL dryrun) +{ + WCHAR *target_path, *target, *source = NULL; + BOOL ret = FALSE; + + if (!(target_path = expand_expression(assembly, fileop->target))) return FALSE; + if (!(target = path_combine(target_path, fileop->source))) goto error; + if (!(source = path_combine(source_path, fileop->source))) goto error; + + if (dryrun) + { + if (!(ret = PathFileExistsW(source))) + { + ERR("Required file %s not found\n", debugstr_w(source)); + goto error; + } + } + else + { + TRACE("Copying %s -> %s\n", debugstr_w(source), debugstr_w(target)); + + if (!create_parent_directory(target)) + { + ERR("Failed to create parent directory for %s\n", debugstr_w(target)); + goto error; + } + if (!(ret = CopyFileExW(source, target, NULL, NULL, NULL, 0))) + { + ERR("Failed to copy %s to %s\n", debugstr_w(source), debugstr_w(target)); + goto error; + } + } + +error: + heap_free(target_path); + heap_free(target); + heap_free(source); + return ret; +} + +static BOOL install_files(struct assembly_entry *assembly, BOOL dryrun) +{ + struct fileop_entry *fileop; + WCHAR *source_path; + BOOL ret = TRUE; + + if (!(source_path = get_assembly_source(assembly))) + { + ERR("Failed to get assembly source directory\n"); + return FALSE; + } + + LIST_FOR_EACH_ENTRY(fileop, &assembly->fileops, struct fileop_entry, entry) + { + if (!(ret = install_files_copy(assembly, source_path, fileop, dryrun))) break; + } + + heap_free(source_path); + return ret; +} + +static WCHAR *split_registry_key(WCHAR *key, HKEY *root) +{ + DWORD size; + WCHAR *p; + + if (!(p = wcschr(key, '\\'))) return NULL; + size = p - key; + + if (lstrlenW(L"HKEY_CLASSES_ROOT") == size && !wcsncmp(key, L"HKEY_CLASSES_ROOT", size)) + *root = HKEY_CLASSES_ROOT; + else if (lstrlenW(L"HKEY_CURRENT_CONFIG") == size && !wcsncmp(key, L"HKEY_CURRENT_CONFIG", size)) + *root = HKEY_CURRENT_CONFIG; + else if (lstrlenW(L"HKEY_CURRENT_USER") == size && !wcsncmp(key, L"HKEY_CURRENT_USER", size)) + *root = HKEY_CURRENT_USER; + else if (lstrlenW(L"HKEY_LOCAL_MACHINE") == size && !wcsncmp(key, L"HKEY_LOCAL_MACHINE", size)) + *root = HKEY_LOCAL_MACHINE; + else if (lstrlenW(L"HKEY_USERS") == size && !wcsncmp(key, L"HKEY_USERS", size)) + *root = HKEY_USERS; + else + { + FIXME("Unknown root key %s\n", debugstr_wn(key, size)); + return NULL; + } + + return p + 1; +} + +static BOOL install_registry_string(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, DWORD type, BOOL dryrun) +{ + DWORD value_size; + WCHAR *value = expand_expression(assembly, registrykv->value); + BOOL ret = TRUE; + + if (registrykv->value && !value) + return FALSE; + + value_size = value ? (lstrlenW(value) + 1) * sizeof(WCHAR) : 0; + if (!dryrun && RegSetValueExW(key, registrykv->name, 0, type, (void *)value, value_size)) + { + ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name)); + ret = FALSE; + } + + heap_free(value); + return ret; +} + +static WCHAR *parse_multisz(const WCHAR *input, DWORD *size) +{ + const WCHAR *pos, *next; + struct strbuf buf; + + *size = 0; + if (!input || !input[0] || !strbuf_init(&buf)) return NULL; + + for (pos = input; pos[0] == '"'; pos++) + { + pos++; + if (!(next = wcsstr(pos, L"\""))) goto error; + strbuf_append(&buf, pos, next - pos); + strbuf_append(&buf, L"", ARRAY_SIZE(L"")); + + pos = next + 1; + if (!pos[0]) break; + if (pos[0] != ',') + { + FIXME("Error while parsing REG_MULTI_SZ string: Expected comma but got '%c'\n", pos[0]); + goto error; + } + } + + if (pos[0]) + { + FIXME("Error while parsing REG_MULTI_SZ string: Garbage at end of string\n"); + goto error; + } + + strbuf_append(&buf, L"", ARRAY_SIZE(L"")); + *size = buf.pos * sizeof(WCHAR); + return buf.buf; + +error: + strbuf_free(&buf); + return NULL; +} + +static BOOL install_registry_multisz(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun) +{ + DWORD value_size; + WCHAR *value = parse_multisz(registrykv->value, &value_size); + BOOL ret = TRUE; + + if (registrykv->value && registrykv->value[0] && !value) + return FALSE; + + if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_MULTI_SZ, (void *)value, value_size)) + { + ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name)); + ret = FALSE; + } + + heap_free(value); + return ret; +} + +static BOOL install_registry_dword(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun) +{ + DWORD value = registrykv->value_type ? wcstoul(registrykv->value_type, NULL, 16) : 0; + BOOL ret = TRUE; + + if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_DWORD, (void *)&value, sizeof(value))) + { + ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name)); + ret = FALSE; + } + + return ret; +} + +static BYTE *parse_hex(const WCHAR *input, DWORD *size) +{ + WCHAR number[3] = {0, 0, 0}; + BYTE *output, *p; + int length; + + *size = 0; + if (!input) return NULL; + length = lstrlenW(input); + if (length & 1) return NULL; + length >>= 1; + + if (!(output = heap_alloc(length))) return NULL; + for (p = output; *input; input += 2) + { + number[0] = input[0]; + number[1] = input[1]; + *p++ = wcstoul(number, 0, 16); + } + *size = length; + return output; +} + +static BOOL install_registry_binary(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun) +{ + DWORD value_size; + BYTE *value = parse_hex(registrykv->value, &value_size); + BOOL ret = TRUE; + + if (registrykv->value && !value) + return FALSE; + + if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_BINARY, value, value_size)) + { + ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name)); + ret = FALSE; + } + + heap_free(value); + return ret; +} + +static BOOL install_registry_value(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun) +{ + TRACE("Setting registry key %s = %s\n", debugstr_w(registrykv->name), debugstr_w(registrykv->value)); + + if (!wcscmp(registrykv->value_type, L"REG_SZ")) + return install_registry_string(assembly, key, registrykv, REG_SZ, dryrun); + if (!wcscmp(registrykv->value_type, L"REG_EXPAND_SZ")) + return install_registry_string(assembly, key, registrykv, REG_EXPAND_SZ, dryrun); + if (!wcscmp(registrykv->value_type, L"REG_MULTI_SZ")) + return install_registry_multisz(assembly, key, registrykv, dryrun); + if (!wcscmp(registrykv->value_type, L"REG_DWORD")) + return install_registry_dword(assembly, key, registrykv, dryrun); + if (!wcscmp(registrykv->value_type, L"REG_BINARY")) + return install_registry_binary(assembly, key, registrykv, dryrun); + + FIXME("Unsupported registry value type %s\n", debugstr_w(registrykv->value_type)); + return FALSE; +} + +static BOOL install_registry(struct assembly_entry *assembly, BOOL dryrun) +{ + struct registryop_entry *registryop; + struct registrykv_entry *registrykv; + HKEY root, subkey; + WCHAR *path; + REGSAM sam = KEY_ALL_ACCESS; + BOOL ret = TRUE; + +#ifdef __x86_64__ + if (!wcscmp(assembly->identity.architecture, L"x86")) sam |= KEY_WOW64_32KEY; +#endif + + LIST_FOR_EACH_ENTRY(registryop, &assembly->registryops, struct registryop_entry, entry) + { + if (!(path = split_registry_key(registryop->key, &root))) + { + ret = FALSE; + break; + } + + TRACE("Processing registry key %s\n", debugstr_w(registryop->key)); + + if (!dryrun && RegCreateKeyExW(root, path, 0, NULL, 0, sam, NULL, &subkey, NULL)) + { + ERR("Failed to open registry key %s\n", debugstr_w(registryop->key)); + ret = FALSE; + break; + } + + LIST_FOR_EACH_ENTRY(registrykv, &registryop->keyvalues, struct registrykv_entry, entry) + { + if (!(ret = install_registry_value(assembly, subkey, registrykv, dryrun))) break; + } + + if (!dryrun) RegCloseKey(subkey); + if (!ret) break; + } + + return ret; +} + +static BOOL install_assembly(struct list *manifest_list, struct assembly_identity *identity, BOOL dryrun) +{ + struct dependency_entry *dependency; + struct assembly_entry *assembly; + const WCHAR *name; + + if (!(assembly = lookup_assembly(manifest_list, identity))) + { + FIXME("Assembly %s not found\n", debugstr_w(identity->name)); + return FALSE; + } + + name = assembly->identity.name; + + if (assembly->status == ASSEMBLY_STATUS_INSTALLED) + { + TRACE("Assembly %s already installed\n", debugstr_w(name)); + return TRUE; + } + if (assembly->status == ASSEMBLY_STATUS_IN_PROGRESS) + { + ERR("Assembly %s caused circular dependency\n", debugstr_w(name)); + return FALSE; + } + +#ifdef __i386__ + if (!wcscmp(assembly->identity.architecture, L"amd64")) + { + ERR("Cannot install amd64 assembly in 32-bit prefix\n"); + return FALSE; + } +#endif + + assembly->status = ASSEMBLY_STATUS_IN_PROGRESS; + + LIST_FOR_EACH_ENTRY(dependency, &assembly->dependencies, struct dependency_entry, entry) + { + if (!install_assembly(manifest_list, &dependency->identity, dryrun)) return FALSE; + } + + TRACE("Installing assembly %s%s\n", debugstr_w(name), dryrun ? " (dryrun)" : ""); + + if (!install_files(assembly, dryrun)) + { + ERR("Failed to install all files for %s\n", debugstr_w(name)); + return FALSE; + } + + if (!install_registry(assembly, dryrun)) + { + ERR("Failed to install registry keys for %s\n", debugstr_w(name)); + return FALSE; + } + + TRACE("Installation of %s finished\n", debugstr_w(name)); + + assembly->status = ASSEMBLY_STATUS_INSTALLED; + return TRUE; +} + +static BOOL install_updates(struct installer_state *state, BOOL dryrun) +{ + struct dependency_entry *dependency; + LIST_FOR_EACH_ENTRY(dependency, &state->updates, struct dependency_entry, entry) + { + if (!install_assembly(&state->assemblies, &dependency->identity, dryrun)) + { + ERR("Failed to install update %s\n", debugstr_w(dependency->identity.name)); + return FALSE; + } + } + return TRUE; +} + +static void set_assembly_status(struct list *manifest_list, DWORD status) +{ + struct assembly_entry *assembly; + LIST_FOR_EACH_ENTRY(assembly, manifest_list, struct assembly_entry, entry) + { + assembly->status = status; + } +} + static BOOL install_msu(const WCHAR *filename, struct installer_state *state) { const WCHAR *temp_path; @@ -474,6 +983,29 @@ static BOOL install_msu(const WCHAR *filename, struct installer_state *state) } } + if (list_empty(&state->updates)) + { + ERR("No updates found, probably incompatible MSU file format?\n"); + goto done; + } + + /* perform dry run */ + set_assembly_status(&state->assemblies, ASSEMBLY_STATUS_NONE); + if (!install_updates(state, TRUE)) + { + ERR("Dry run failed, aborting installation\n"); + goto done; + } + + /* installation */ + set_assembly_status(&state->assemblies, ASSEMBLY_STATUS_NONE); + if (!install_updates(state, FALSE)) + { + ERR("Installation failed\n"); + goto done; + } + + TRACE("Installation finished\n"); ret = TRUE; done: @@ -481,12 +1013,42 @@ done: return ret; } +static void restart_as_x86_64(void) +{ + WCHAR filename[MAX_PATH]; + PROCESS_INFORMATION pi; + STARTUPINFOW si; + DWORD exit_code = 1; + void *redir; + + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + GetModuleFileNameW(0, filename, MAX_PATH); + + Wow64DisableWow64FsRedirection(&redir); + if (CreateProcessW(filename, GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) + { + TRACE("Restarting %s\n", wine_dbgstr_w(filename)); + WaitForSingleObject(pi.hProcess, INFINITE); + GetExitCodeProcess(pi.hProcess, &exit_code); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + } + else ERR("Failed to restart 64-bit %s, err %u\n", wine_dbgstr_w(filename), GetLastError()); + Wow64RevertWow64FsRedirection(redir); + + ExitProcess(exit_code); +} + int __cdecl wmain(int argc, WCHAR *argv[]) { struct installer_state state; const WCHAR *filename = NULL; + BOOL is_wow64; int i; + if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64) restart_as_x86_64(); + state.norestart = FALSE; state.quiet = FALSE; diff --git a/programs/wusa/wusa.h b/programs/wusa/wusa.h index e717fad6e0..dcd784e764 100644 --- a/programs/wusa/wusa.h +++ b/programs/wusa/wusa.h @@ -90,6 +90,12 @@ static inline void *heap_alloc_zero(size_t len) return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); } +static void *heap_realloc(void *mem, size_t len) __WINE_ALLOC_SIZE(2); +static inline void *heap_realloc(void *mem, size_t len) +{ + return HeapReAlloc(GetProcessHeap(), 0, mem, len); +} + static inline BOOL heap_free(void *mem) { return HeapFree(GetProcessHeap(), 0, mem); @@ -127,3 +133,16 @@ static inline WCHAR *strdupW(const WCHAR *str) if (ret) lstrcpyW(ret, str); return ret; } + +static inline WCHAR *strdupWn(const WCHAR *str, DWORD len) +{ + WCHAR *ret; + if (!str) return NULL; + ret = heap_alloc((len + 1) * sizeof(WCHAR)); + if (ret) + { + memcpy(ret, str, len * sizeof(WCHAR)); + ret[len] = 0; + } + return ret; +} -- 2.20.1

1 0

[PATCH 3/4] wusa: Parse update descriptions.
by Hans Leidekker Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- programs/wusa/main.c | 46 +++++++++++++++++ programs/wusa/manifest.c | 106 +++++++++++++++++++++++++++++++++++++++ programs/wusa/wusa.h | 2 + 3 files changed, 154 insertions(+) diff --git a/programs/wusa/main.c b/programs/wusa/main.c index a1cdea4ee8..8df8731e2b 100644 --- a/programs/wusa/main.c +++ b/programs/wusa/main.c @@ -41,6 +41,7 @@ struct installer_state BOOL quiet; struct list tempdirs; struct list assemblies; + struct list updates; }; static void * CDECL cabinet_alloc(ULONG cb) @@ -317,6 +318,7 @@ static void installer_cleanup(struct installer_state *state) { struct installer_tempdir *tempdir, *tempdir2; struct assembly_entry *assembly, *assembly2; + struct dependency_entry *dependency, *dependency2; LIST_FOR_EACH_ENTRY_SAFE(tempdir, tempdir2, &state->tempdirs, struct installer_tempdir, entry) { @@ -330,6 +332,11 @@ static void installer_cleanup(struct installer_state *state) list_remove(&assembly->entry); free_assembly(assembly); } + LIST_FOR_EACH_ENTRY_SAFE(dependency, dependency2, &state->updates, struct dependency_entry, entry) + { + list_remove(&dependency->entry); + free_dependency(dependency); + } } static BOOL str_ends_with(const WCHAR *str, const WCHAR *suffix) @@ -397,6 +404,7 @@ static BOOL install_msu(const WCHAR *filename, struct installer_state *state) list_init(&state->tempdirs); list_init(&state->assemblies); + list_init(&state->updates); CoInitialize(NULL); TRACE("Processing msu file %s\n", debugstr_w(filename)); @@ -428,6 +436,44 @@ static BOOL install_msu(const WCHAR *filename, struct installer_state *state) FindClose(search); } + /* load all update descriptions */ + if (!(path = path_combine(temp_path, L"*.xml"))) goto done; + search = FindFirstFileW(path, &data); + heap_free(path); + + if (search != INVALID_HANDLE_VALUE) + { + do + { + if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue; + if (!(path = path_combine(temp_path, data.cFileName))) continue; + if (!load_update(path, &state->updates)) + ERR("Failed to load all updates from %s, ignoring\n", debugstr_w(path)); + heap_free(path); + } + while (FindNextFileW(search, &data)); + FindClose(search); + } + + /* dump package information (for debugging) */ + if (TRACE_ON(wusa)) + { + struct dependency_entry *dependency; + struct assembly_entry *assembly; + + TRACE("List of updates:\n"); + LIST_FOR_EACH_ENTRY(dependency, &state->updates, struct dependency_entry, entry) + TRACE(" * %s\n", debugstr_w(dependency->identity.name)); + + TRACE("List of manifests (with dependencies):\n"); + LIST_FOR_EACH_ENTRY(assembly, &state->assemblies, struct assembly_entry, entry) + { + TRACE(" * %s\n", debugstr_w(assembly->identity.name)); + LIST_FOR_EACH_ENTRY(dependency, &assembly->dependencies, struct dependency_entry, entry) + TRACE(" -> %s\n", debugstr_w(dependency->identity.name)); + } + } + ret = TRUE; done: diff --git a/programs/wusa/manifest.c b/programs/wusa/manifest.c index 44c263f6c0..e80c11998c 100644 --- a/programs/wusa/manifest.c +++ b/programs/wusa/manifest.c @@ -565,3 +565,109 @@ done: IXMLDOMElement_Release(root); return entry; } + +/* <unattend><servicing><package> */ +static BOOL read_update_package(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct dependency_entry *entry; + struct list *update_list = context; + + if (!wcscmp(tagname, L"source")) return TRUE; + if (wcscmp(tagname, L"assemblyIdentity")) + { + TRACE("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + if ((entry = alloc_dependency())) + { + if (read_identity(child, &entry->identity)) + { + TRACE("Found update %s\n", debugstr_w(entry->identity.name)); + list_add_tail(update_list, &entry->entry); + return TRUE; + } + free_dependency(entry); + } + + return FALSE; +} + +static BOOL iter_update_package(IXMLDOMElement *root, struct list *update_list) +{ + return call_xml_callbacks(root, read_update_package, update_list); +} + +/* <unattend><servicing> */ +static BOOL read_servicing(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct list *update_list = context; + WCHAR *action; + BOOL ret = TRUE; + + if (wcscmp(tagname, L"package")) + { + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + if (!(action = get_xml_attribute(child, L"action"))) + { + FIXME("Servicing tag doesn't specify action\n"); + return FALSE; + } + + if (!wcscmp(action, L"install")) + ret = iter_update_package(child, update_list); + else + FIXME("action %s not supported\n", debugstr_w(action)); + + heap_free(action); + return ret; +} + +static BOOL iter_servicing(IXMLDOMElement *root, struct list *update_list) +{ + return call_xml_callbacks(root, read_servicing, update_list); +} + +/* <unattend> */ +static BOOL read_unattend(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct list *update_list = context; + + if (wcscmp(tagname, L"servicing")) + { + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + return iter_servicing(child, update_list); + +} + +static BOOL iter_unattend(IXMLDOMElement *root, struct list *update_list) +{ + return call_xml_callbacks(root, read_unattend, update_list); +} + +BOOL load_update(const WCHAR *filename, struct list *update_list) +{ + IXMLDOMElement *root = NULL; + BOOL ret = FALSE; + + TRACE("Reading update %s\n", debugstr_w(filename)); + + if (!(root = load_xml(filename))) return FALSE; + if (!check_xml_tagname(root, L"unattend")) + { + FIXME("Didn't find unattend root node?\n"); + goto done; + } + + ret = iter_unattend(root, update_list); + +done: + IXMLDOMElement_Release(root); + return ret; +} diff --git a/programs/wusa/wusa.h b/programs/wusa/wusa.h index 2c81b639b9..e717fad6e0 100644 --- a/programs/wusa/wusa.h +++ b/programs/wusa/wusa.h @@ -74,7 +74,9 @@ struct assembly_entry }; void free_assembly(struct assembly_entry *entry) DECLSPEC_HIDDEN; +void free_dependency(struct dependency_entry *entry) DECLSPEC_HIDDEN; struct assembly_entry *load_manifest(const WCHAR *filename) DECLSPEC_HIDDEN; +BOOL load_update(const WCHAR *filename, struct list *update_list) DECLSPEC_HIDDEN; static void *heap_alloc(size_t len) __WINE_ALLOC_SIZE(1); static inline void *heap_alloc(size_t len) -- 2.20.1

1 0

[PATCH 2/4] wusa: Parse assembly manifests.
by Hans Leidekker Dec. 2, 2019

Dec. 2, 2019

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- programs/wusa/Makefile.in | 5 +- programs/wusa/main.c | 87 ++++++ programs/wusa/manifest.c | 567 ++++++++++++++++++++++++++++++++++++++ programs/wusa/wusa.h | 65 +++++ 4 files changed, 722 insertions(+), 2 deletions(-) create mode 100644 programs/wusa/manifest.c diff --git a/programs/wusa/Makefile.in b/programs/wusa/Makefile.in index 5e60bdf1b0..87bfe1dae0 100644 --- a/programs/wusa/Makefile.in +++ b/programs/wusa/Makefile.in @@ -1,7 +1,8 @@ MODULE = wusa.exe -IMPORTS = cabinet shlwapi +IMPORTS = cabinet shlwapi ole32 oleaut32 EXTRADLLFLAGS = -mconsole -municode -mno-cygwin C_SRCS = \ - main.c + main.c \ + manifest.c diff --git a/programs/wusa/main.c b/programs/wusa/main.c index a719eefc5b..a1cdea4ee8 100644 --- a/programs/wusa/main.c +++ b/programs/wusa/main.c @@ -40,6 +40,7 @@ struct installer_state BOOL norestart; BOOL quiet; struct list tempdirs; + struct list assemblies; }; static void * CDECL cabinet_alloc(ULONG cb) @@ -315,6 +316,7 @@ static BOOL delete_directory(const WCHAR *path) static void installer_cleanup(struct installer_state *state) { struct installer_tempdir *tempdir, *tempdir2; + struct assembly_entry *assembly, *assembly2; LIST_FOR_EACH_ENTRY_SAFE(tempdir, tempdir2, &state->tempdirs, struct installer_tempdir, entry) { @@ -323,14 +325,79 @@ static void installer_cleanup(struct installer_state *state) heap_free(tempdir->path); heap_free(tempdir); } + LIST_FOR_EACH_ENTRY_SAFE(assembly, assembly2, &state->assemblies, struct assembly_entry, entry) + { + list_remove(&assembly->entry); + free_assembly(assembly); + } +} + +static BOOL str_ends_with(const WCHAR *str, const WCHAR *suffix) +{ + DWORD str_len = lstrlenW(str), suffix_len = lstrlenW(suffix); + if (suffix_len > str_len) return FALSE; + return !wcsicmp(str + str_len - suffix_len, suffix); +} + +static BOOL load_assemblies_from_cab(const WCHAR *filename, struct installer_state *state) +{ + struct assembly_entry *assembly; + const WCHAR *temp_path; + WIN32_FIND_DATAW data; + HANDLE search; + WCHAR *path; + + TRACE("Processing cab file %s\n", debugstr_w(filename)); + + if (!(temp_path = create_temp_directory(state))) return FALSE; + if (!extract_cabinet(filename, temp_path)) + { + ERR("Failed to extract %s\n", debugstr_w(filename)); + return FALSE; + } + + if (!(path = path_combine(temp_path, L"_manifest_.cix.xml"))) return FALSE; + if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES) + { + FIXME("Cabinet uses proprietary msdelta file compression which is not (yet) supported\n"); + FIXME("Installation of msu file will most likely fail\n"); + } + heap_free(path); + + if (!(path = path_combine(temp_path, L"*"))) return FALSE; + search = FindFirstFileW(path, &data); + heap_free(path); + + if (search != INVALID_HANDLE_VALUE) + { + do + { + if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue; + if (!str_ends_with(data.cFileName, L".manifest") && + !str_ends_with(data.cFileName, L".mum")) continue; + if (!(path = path_combine(temp_path, data.cFileName))) continue; + if ((assembly = load_manifest(path))) + list_add_tail(&state->assemblies, &assembly->entry); + heap_free(path); + } + while (FindNextFileW(search, &data)); + FindClose(search); + } + + return TRUE; } static BOOL install_msu(const WCHAR *filename, struct installer_state *state) { const WCHAR *temp_path; + WIN32_FIND_DATAW data; + HANDLE search; + WCHAR *path; BOOL ret = FALSE; list_init(&state->tempdirs); + list_init(&state->assemblies); + CoInitialize(NULL); TRACE("Processing msu file %s\n", debugstr_w(filename)); @@ -341,6 +408,26 @@ static BOOL install_msu(const WCHAR *filename, struct installer_state *state) goto done; } + /* load all manifests from contained cabinet archives */ + if (!(path = path_combine(temp_path, L"*.cab"))) goto done; + search = FindFirstFileW(path, &data); + heap_free(path); + + if (search != INVALID_HANDLE_VALUE) + { + do + { + if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue; + if (!wcsicmp(data.cFileName, L"WSUSSCAN.cab")) continue; + if (!(path = path_combine(temp_path, data.cFileName))) continue; + if (!load_assemblies_from_cab(path, state)) + ERR("Failed to load all manifests from %s, ignoring\n", debugstr_w(path)); + heap_free(path); + } + while (FindNextFileW(search, &data)); + FindClose(search); + } + ret = TRUE; done: diff --git a/programs/wusa/manifest.c b/programs/wusa/manifest.c new file mode 100644 index 0000000000..44c263f6c0 --- /dev/null +++ b/programs/wusa/manifest.c @@ -0,0 +1,567 @@ +/* + * Manifest parser for WUSA + * + * Copyright 2015 Michael Müller + * Copyright 2015 Sebastian Lackner + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <windows.h> +#define COBJMACROS +#include <initguid.h> +#include <msxml.h> + +#include "wine/debug.h" +#include "wine/list.h" +#include "wusa.h" + +WINE_DEFAULT_DEBUG_CHANNEL(wusa); + +static struct dependency_entry *alloc_dependency(void) +{ + struct dependency_entry *entry = heap_alloc_zero(sizeof(*entry)); + if (!entry) ERR("Failed to allocate memory for dependency\n"); + return entry; +} + +static struct fileop_entry *alloc_fileop(void) +{ + struct fileop_entry *entry = heap_alloc_zero(sizeof(*entry)); + if (!entry) ERR("Failed to allocate memory for fileop\n"); + return entry; +} + +static struct registrykv_entry *alloc_registrykv(void) +{ + struct registrykv_entry *entry = heap_alloc_zero(sizeof(*entry)); + if (!entry) ERR("Failed to allocate memory for registrykv\n"); + return entry; +} + +static struct registryop_entry *alloc_registryop(void) +{ + struct registryop_entry *entry = heap_alloc_zero(sizeof(*entry)); + if (!entry) ERR("Failed to allocate memory for registryop\n"); + else + { + list_init(&entry->keyvalues); + } + return entry; +} + +static struct assembly_entry *alloc_assembly(void) +{ + struct assembly_entry *entry = heap_alloc_zero(sizeof(*entry)); + if (!entry) ERR("Failed to allocate memory for assembly\n"); + else + { + list_init(&entry->dependencies); + list_init(&entry->fileops); + list_init(&entry->registryops); + } + return entry; +} + +static void clear_identity(struct assembly_identity *entry) +{ + heap_free(entry->name); + heap_free(entry->version); + heap_free(entry->architecture); + heap_free(entry->language); + heap_free(entry->pubkey_token); +} + +void free_dependency(struct dependency_entry *entry) +{ + clear_identity(&entry->identity); + heap_free(entry); +} + +static void free_fileop(struct fileop_entry *entry) +{ + heap_free(entry->source); + heap_free(entry->target); + heap_free(entry); +} + +static void free_registrykv(struct registrykv_entry *entry) +{ + heap_free(entry->name); + heap_free(entry->value_type); + heap_free(entry->value); + heap_free(entry); +} + +static void free_registryop(struct registryop_entry *entry) +{ + struct registrykv_entry *keyvalue, *keyvalue2; + + heap_free(entry->key); + + LIST_FOR_EACH_ENTRY_SAFE(keyvalue, keyvalue2, &entry->keyvalues, struct registrykv_entry, entry) + { + list_remove(&keyvalue->entry); + free_registrykv(keyvalue); + } + + heap_free(entry); +} + +void free_assembly(struct assembly_entry *entry) +{ + struct dependency_entry *dependency, *dependency2; + struct fileop_entry *fileop, *fileop2; + struct registryop_entry *registryop, *registryop2; + + heap_free(entry->filename); + heap_free(entry->displayname); + clear_identity(&entry->identity); + + LIST_FOR_EACH_ENTRY_SAFE(dependency, dependency2, &entry->dependencies, struct dependency_entry, entry) + { + list_remove(&dependency->entry); + free_dependency(dependency); + } + LIST_FOR_EACH_ENTRY_SAFE(fileop, fileop2, &entry->fileops, struct fileop_entry, entry) + { + list_remove(&fileop->entry); + free_fileop(fileop); + } + LIST_FOR_EACH_ENTRY_SAFE(registryop, registryop2, &entry->registryops, struct registryop_entry, entry) + { + list_remove(&registryop->entry); + free_registryop(registryop); + } + + heap_free(entry); +} + +static WCHAR *get_xml_attribute(IXMLDOMElement *root, const WCHAR *name) +{ + WCHAR *ret = NULL; + VARIANT var; + BSTR bstr; + + if ((bstr = SysAllocString(name))) + { + VariantInit(&var); + if (SUCCEEDED(IXMLDOMElement_getAttribute(root, bstr, &var))) + { + ret = (V_VT(&var) == VT_BSTR) ? strdupW(V_BSTR(&var)) : NULL; + VariantClear(&var); + } + SysFreeString(bstr); + } + + return ret; +} + +static BOOL check_xml_tagname(IXMLDOMElement *root, const WCHAR *tagname) +{ + BOOL ret = FALSE; + BSTR bstr; + + if (SUCCEEDED(IXMLDOMElement_get_tagName(root, &bstr))) + { + ret = !wcscmp(bstr, tagname); + SysFreeString(bstr); + } + + return ret; +} + +static IXMLDOMElement *select_xml_node(IXMLDOMElement *root, const WCHAR *name) +{ + IXMLDOMElement *ret = NULL; + IXMLDOMNode *node; + BSTR bstr; + + if ((bstr = SysAllocString(name))) + { + if (SUCCEEDED(IXMLDOMElement_selectSingleNode(root, bstr, &node))) + { + if (FAILED(IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void **)&ret))) + ret = NULL; + IXMLDOMNode_Release(node); + } + SysFreeString(bstr); + } + + return ret; +} + +static BOOL call_xml_callbacks(IXMLDOMElement *root, BOOL (*func)(IXMLDOMElement *child, WCHAR *tagname, void *context), void *context) +{ + IXMLDOMNodeList *children; + IXMLDOMElement *child; + IXMLDOMNode *node; + BSTR tagname; + BOOL ret = TRUE; + + if (FAILED(IXMLDOMElement_get_childNodes(root, &children))) + return FALSE; + + while (ret && IXMLDOMNodeList_nextNode(children, &node) == S_OK) + { + if (SUCCEEDED(IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void **)&child))) + { + if (SUCCEEDED(IXMLDOMElement_get_tagName(child, &tagname))) + { + ret = func(child, tagname, context); + SysFreeString(tagname); + } + IXMLDOMElement_Release(child); + } + IXMLDOMNode_Release(node); + } + + IXMLDOMNodeList_Release(children); + return ret; +} + +static IXMLDOMElement *load_xml(const WCHAR *filename) +{ + IXMLDOMDocument *document = NULL; + IXMLDOMElement *root = NULL; + VARIANT_BOOL success; + VARIANT variant; + BSTR bstr; + + TRACE("Loading XML from %s\n", debugstr_w(filename)); + + if (!(bstr = SysAllocString(filename))) + return FALSE; + + if (SUCCEEDED(CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void **)&document))) + { + VariantInit(&variant); + V_VT(&variant) = VT_BSTR; + V_BSTR(&variant) = bstr; + + if (SUCCEEDED(IXMLDOMDocument_load(document, variant, &success)) && success) + { + if (FAILED(IXMLDOMDocument_get_documentElement(document, &root))) + root = NULL; + } + IXMLDOMDocument_Release(document); + } + + SysFreeString(bstr); + return root; +} + +static BOOL read_identity(IXMLDOMElement *root, struct assembly_identity *identity) +{ + memset(identity, 0, sizeof(*identity)); + if (!(identity->name = get_xml_attribute(root, L"name"))) goto error; + if (!(identity->version = get_xml_attribute(root, L"version"))) goto error; + if (!(identity->architecture = get_xml_attribute(root, L"processorArchitecture"))) goto error; + if (!(identity->language = get_xml_attribute(root, L"language"))) goto error; + if (!(identity->pubkey_token = get_xml_attribute(root, L"publicKeyToken"))) goto error; + return TRUE; + +error: + clear_identity(identity); + return FALSE; +} + +/* <assembly><dependency><dependentAssembly> */ +static BOOL read_dependent_assembly(IXMLDOMElement *root, struct assembly_identity *identity) +{ + IXMLDOMElement *child = NULL; + WCHAR *dependency_type; + BOOL ret = FALSE; + + if (!(dependency_type = get_xml_attribute(root, L"dependencyType"))) + { + WARN("Failed to get dependency type, assuming install\n"); + } + if (dependency_type && wcscmp(dependency_type, L"install") && wcscmp(dependency_type, L"prerequisite")) + { + FIXME("Unimplemented dependency type %s\n", debugstr_w(dependency_type)); + goto error; + } + if (!(child = select_xml_node(root, L".//assemblyIdentity"))) + { + FIXME("Failed to find assemblyIdentity child node\n"); + goto error; + } + + ret = read_identity(child, identity); + +error: + if (child) IXMLDOMElement_Release(child); + heap_free(dependency_type); + return ret; +} + +/* <assembly><dependency> */ +static BOOL read_dependency(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + struct dependency_entry *entry; + + if (wcscmp(tagname, L"dependentAssembly")) + { + FIXME("Don't know how to handle dependency tag %s\n", debugstr_w(tagname)); + return FALSE; + } + + if ((entry = alloc_dependency())) + { + if (read_dependent_assembly(child, &entry->identity)) + { + TRACE("Found dependency %s\n", debugstr_w(entry->identity.name)); + list_add_tail(&assembly->dependencies, &entry->entry); + return TRUE; + } + free_dependency(entry); + } + + return FALSE; +} + +static BOOL iter_dependency(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_dependency, assembly); +} + +/* <assembly><package><update><component> */ +/* <assembly><package><update><package> */ +static BOOL read_components(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + struct dependency_entry *entry; + + if (wcscmp(tagname, L"assemblyIdentity")) + { + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + if ((entry = alloc_dependency())) + { + if (read_identity(child, &entry->identity)) + { + TRACE("Found identity %s\n", debugstr_w(entry->identity.name)); + list_add_tail(&assembly->dependencies, &entry->entry); + return TRUE; + } + free_dependency(entry); + } + + return FALSE; +} + +static BOOL iter_components(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_components, assembly); +} + +/* <assembly><package><update> */ +static BOOL read_update(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + + if (!wcscmp(tagname, L"component")) + return iter_components(child, assembly); + if (!wcscmp(tagname, L"package")) + return iter_components(child, assembly); + if (!wcscmp(tagname, L"applicable")) + return TRUE; + + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return FALSE; +} + +static BOOL iter_update(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_update, assembly); +} + +/* <assembly><package> */ +static BOOL read_package(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + + if (!wcscmp(tagname, L"update")) + return iter_update(child, assembly); + if (!wcscmp(tagname, L"parent")) + return TRUE; + + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; +} + +static BOOL iter_package(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_package, assembly); +} + +/* <assembly><file> */ +static BOOL read_file(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + struct fileop_entry *entry; + + if (!(entry = alloc_fileop())) + return FALSE; + + if (!(entry->source = get_xml_attribute(root, L"sourceName"))) goto error; + if (!(entry->target = get_xml_attribute(root, L"destinationPath"))) goto error; + + TRACE("Found fileop %s -> %s\n", debugstr_w(entry->source), debugstr_w(entry->target)); + list_add_tail(&assembly->fileops, &entry->entry); + return TRUE; + +error: + free_fileop(entry); + return FALSE; +} + +/* <assembly><registryKeys><registryKey> */ +static BOOL read_registry_key(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct registryop_entry *registryop = context; + struct registrykv_entry *entry; + + if (!wcscmp(tagname, L"securityDescriptor")) return TRUE; + if (!wcscmp(tagname, L"systemProtection")) return TRUE; + if (wcscmp(tagname, L"registryValue")) + { + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + if (!(entry = alloc_registrykv())) + return FALSE; + + if (!(entry->value_type = get_xml_attribute(child, L"valueType"))) goto error; + entry->name = get_xml_attribute(child, L"name"); /* optional */ + entry->value = get_xml_attribute(child, L"value"); /* optional */ + + TRACE("Found registry %s -> %s\n", debugstr_w(entry->name), debugstr_w(entry->value)); + list_add_tail(&registryop->keyvalues, &entry->entry); + return TRUE; + +error: + free_registrykv(entry); + return FALSE; +} + +static BOOL iter_registry_key(IXMLDOMElement *root, struct registryop_entry *registryop) +{ + return call_xml_callbacks(root, read_registry_key, registryop); +} + +/* <assembly><registryKeys> */ +static BOOL read_registry_keys(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + struct registryop_entry *entry; + WCHAR *keyname; + + if (wcscmp(tagname, L"registryKey")) + { + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; + } + + if (!(keyname = get_xml_attribute(child, L"keyName"))) + { + FIXME("RegistryKey tag doesn't specify keyName\n"); + return FALSE; + } + + if ((entry = alloc_registryop())) + { + list_init(&entry->keyvalues); + if (iter_registry_key(child, entry)) + { + entry->key = keyname; + TRACE("Found registryop %s\n", debugstr_w(entry->key)); + list_add_tail(&assembly->registryops, &entry->entry); + return TRUE; + } + free_registryop(entry); + } + + heap_free(keyname); + return FALSE; +} + +static BOOL iter_registry_keys(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_registry_keys, assembly); +} + +/* <assembly> */ +static BOOL read_assembly(IXMLDOMElement *child, WCHAR *tagname, void *context) +{ + struct assembly_entry *assembly = context; + + if (!wcscmp(tagname, L"assemblyIdentity") && !assembly->identity.name) + return read_identity(child, &assembly->identity); + if (!wcscmp(tagname, L"dependency")) + return iter_dependency(child, assembly); + if (!wcscmp(tagname, L"package")) + return iter_package(child, assembly); + if (!wcscmp(tagname, L"file")) + return read_file(child, assembly); + if (!wcscmp(tagname, L"registryKeys")) + return iter_registry_keys(child, assembly); + if (!wcscmp(tagname, L"trustInfo")) + return TRUE; + if (!wcscmp(tagname, L"configuration")) + return TRUE; + if (!wcscmp(tagname, L"deployment")) + return TRUE; + + FIXME("Ignoring unexpected tag %s\n", debugstr_w(tagname)); + return TRUE; +} + +static BOOL iter_assembly(IXMLDOMElement *root, struct assembly_entry *assembly) +{ + return call_xml_callbacks(root, read_assembly, assembly); +} + +struct assembly_entry *load_manifest(const WCHAR *filename) +{ + struct assembly_entry *entry = NULL; + IXMLDOMElement *root = NULL; + + TRACE("Loading manifest %s\n", debugstr_w(filename)); + + if (!(root = load_xml(filename))) return NULL; + if (!check_xml_tagname(root, L"assembly")) + { + FIXME("Didn't find assembly root node?\n"); + goto done; + } + + if ((entry = alloc_assembly())) + { + entry->filename = strdupW(filename); + entry->displayname = get_xml_attribute(root, L"displayName"); + if (iter_assembly(root, entry)) goto done; + free_assembly(entry); + entry = NULL; + } + +done: + IXMLDOMElement_Release(root); + return entry; +} diff --git a/programs/wusa/wusa.h b/programs/wusa/wusa.h index c6bf7eda11..2c81b639b9 100644 --- a/programs/wusa/wusa.h +++ b/programs/wusa/wusa.h @@ -17,12 +17,77 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +enum +{ + ASSEMBLY_STATUS_NONE, + ASSEMBLY_STATUS_IN_PROGRESS, + ASSEMBLY_STATUS_INSTALLED, +}; + +struct assembly_identity +{ + WCHAR *name; + WCHAR *version; + WCHAR *architecture; + WCHAR *language; + WCHAR *pubkey_token; +}; + +struct dependency_entry +{ + struct list entry; + struct assembly_identity identity; +}; + +struct fileop_entry +{ + struct list entry; + WCHAR *source; + WCHAR *target; +}; + +struct registrykv_entry +{ + struct list entry; + WCHAR *name; + WCHAR *value_type; + WCHAR *value; +}; + +struct registryop_entry +{ + struct list entry; + WCHAR *key; + struct list keyvalues; +}; + +struct assembly_entry +{ + struct list entry; + DWORD status; + WCHAR *filename; + WCHAR *displayname; + struct assembly_identity identity; + struct list dependencies; + struct list fileops; + struct list registryops; +}; + +void free_assembly(struct assembly_entry *entry) DECLSPEC_HIDDEN; +struct assembly_entry *load_manifest(const WCHAR *filename) DECLSPEC_HIDDEN; + static void *heap_alloc(size_t len) __WINE_ALLOC_SIZE(1); static inline void *heap_alloc(size_t len) { return HeapAlloc(GetProcessHeap(), 0, len); } +static void *heap_alloc_zero(size_t len) __WINE_ALLOC_SIZE(1); +static inline void *heap_alloc_zero(size_t len) +{ + return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); +} + static inline BOOL heap_free(void *mem) { return HeapFree(GetProcessHeap(), 0, mem); -- 2.20.1

1 0

[PATCH 2/3] d3d8/tests: Add out-of-bounds region tests.
by Akihiro Sagawa Dec. 1, 2019

Dec. 1, 2019

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d8/tests/visual.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)

2 1

[PATCH 3/3] wined3d: Check dirty region dimensions.
by Akihiro Sagawa Dec. 1, 2019

Dec. 1, 2019

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d8/tests/visual.c | 2 +- dlls/d3d9/tests/visual.c | 2 +- dlls/wined3d/texture.c | 7 +++++++ 3 files changed, 9 insertions(+), 2 deletions(-)

1 0

[PATCH 1/3] d3d9/tests: Add out-of-bounds region tests.
by Akihiro Sagawa Dec. 1, 2019

Dec. 1, 2019

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/d3d9/tests/visual.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)

1 0

[PATCH]: po: Update Lithuanian translation
by Aurimas Fišeras Dec. 1, 2019

Dec. 1, 2019

1 0

[PATCH] ieframe: WebBrowser shouldn't support COM aggregation
by Damjan Jovanovic Dec. 1, 2019

Dec. 1, 2019

COM objects should either fully support aggregation or cleanly fail. Our ieframe's WebBrowser completely ignores it. Fail with CLASS_E_NOAGGREGATION like Windows does instead. Signed-off-by: Damjan Jovanovic <damjan.jov(a)gmail.com> --- dlls/ieframe/tests/webbrowser.c | 3 +++ dlls/ieframe/webbrowser.c | 3 +++ 2 files changed, 6 insertions(+)

2 2

[PATCH 1/6] strmbase: Don't hold the filter lock while calling IPin::NewSegment().
by Zebediah Figura Dec. 1, 2019

Dec. 1, 2019

It's not safe to hold the filter lock from a streaming thread, and anyway we aren't protecting anything that needs locking. Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/strmbase/transform.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/dlls/strmbase/transform.c b/dlls/strmbase/transform.c index d39dbbd3ab..7650232c44 100644 --- a/dlls/strmbase/transform.c +++ b/dlls/strmbase/transform.c @@ -495,12 +495,10 @@ static HRESULT WINAPI TransformFilter_InputPin_NewSegment(IPin * iface, REFERENC TRACE("iface %p, start %s, stop %s, rate %.16e.\n", iface, debugstr_time(tStart), debugstr_time(tStop), dRate); - EnterCriticalSection(&pTransform->filter.csFilter); if (pTransform->pFuncsTable->pfnNewSegment) hr = pTransform->pFuncsTable->pfnNewSegment(pTransform, tStart, tStop, dRate); if (SUCCEEDED(hr)) hr = BaseInputPinImpl_NewSegment(iface, tStart, tStop, dRate); - LeaveCriticalSection(&pTransform->filter.csFilter); return hr; } -- 2.24.0

2 8