- wine-devel - winehq.org

[PATCH v4 2/7] winex11.drv: Initialize GPU registry data.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/winex11.drv/Makefile.in | 2 +- dlls/winex11.drv/display.c | 190 +++++++++++++++++++++++++++++++++++ 2 files changed, 191 insertions(+), 1 deletion(-) diff --git a/dlls/winex11.drv/Makefile.in b/dlls/winex11.drv/Makefile.in index 9ca2fc6efe..72ab1bb77b 100644 --- a/dlls/winex11.drv/Makefile.in +++ b/dlls/winex11.drv/Makefile.in @@ -1,5 +1,5 @@ MODULE = winex11.drv -IMPORTS = uuid user32 gdi32 advapi32 +IMPORTS = uuid user32 gdi32 advapi32 ntoskrnl setupapi DELAYIMPORTS = comctl32 ole32 shell32 imm32 EXTRAINCL = $(X_CFLAGS) EXTRALIBS = $(X_LIBS) $(X_EXTRA_LIBS) diff --git a/dlls/winex11.drv/display.c b/dlls/winex11.drv/display.c index 7d81de09ac..d69380d8bc 100644 --- a/dlls/winex11.drv/display.c +++ b/dlls/winex11.drv/display.c @@ -26,11 +26,50 @@ #include "winbase.h" #include "winuser.h" #include "winreg.h" +#include "initguid.h" +#include "devguid.h" +#include "devpkey.h" +#include "setupapi.h" +#define WIN32_NO_STATUS +#include "winternl.h" +#include "ddk/ntddk.h" #include "wine/debug.h" +#include "wine/unicode.h" #include "x11drv.h" WINE_DEFAULT_DEBUG_CHANNEL(x11drv); +static const WCHAR driver_descW[] = {'D','r','i','v','e','r','D','e','s','c',0}; +static const WCHAR graphics_driverW[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0}; +static const WCHAR video_idW[] = {'V','i','d','e','o','I','D',0}; +static const WCHAR guid_fmtW[] = { + '{','%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0','2','x','%','0','2','x','-', + '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0}; +static const WCHAR gpu_instance_fmtW[] = { + 'P','C','I','\\', + 'V','E','N','_','%','0','4','X','&', + 'D','E','V','_','%','0','4','X','&', + 'S','U','B','S','Y','S','_','%','0','8','X','&', + 'R','E','V','_','%','0','2','X','\\', + '%','0','8','X',0}; +static const WCHAR gpu_hardware_id_fmtW[] = { + 'P','C','I','\\', + 'V','E','N','_','%','0','4','X','&', + 'D','E','V','_','%','0','4','X','&', + 'S','U','B','S','Y','S','_','0','0','0','0','0','0','0','0','&', + 'R','E','V','_','0','0',0}; +static const WCHAR winex11_drvW[] = { + 'C',':','\\', + 'W','i','n','d','o','w','s','\\', + 'S','y','s','t','e','m','3','2','\\', + 'w','i','n','e','x','1','1','.','d','r','v',0}; +static const WCHAR nt_classW[] = { + '\\','R','e','g','i','s','t','r','y','\\', + 'M','a','c','h','i','n','e','\\', + 'S','y','s','t','e','m','\\', + 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\', + 'C','o','n','t','r','o','l','\\', + 'C','l','a','s','s','\\',0}; static const WCHAR video_keyW[] = { 'H','A','R','D','W','A','R','E','\\', 'D','E','V','I','C','E','M','A','P','\\', @@ -47,10 +86,138 @@ void X11DRV_DisplayDevices_SetHandler(const struct x11drv_display_device_handler } } +/* Initialize a GPU instance and return its GUID string in guid_string and driver value in driver parameter */ +static BOOL X11DRV_InitGpu(HDEVINFO devinfo, const struct x11drv_gpu *gpu, INT gpu_index, WCHAR *guid_string, + WCHAR *driver) +{ + static const BOOL present = TRUE; + SP_DEVINFO_DATA device_data = {sizeof(device_data)}; + WCHAR instanceW[MAX_PATH]; + WCHAR bufferW[1024]; + HKEY hkey = NULL; + GUID guid; + INT written; + DWORD size; + BOOL ret = FALSE; + + sprintfW(instanceW, gpu_instance_fmtW, gpu->vendor_id, gpu->device_id, gpu->subsys_id, gpu->revision_id, gpu_index); + if (!SetupDiOpenDeviceInfoW(devinfo, instanceW, NULL, 0, &device_data)) + { + SetupDiCreateDeviceInfoW(devinfo, instanceW, &GUID_DEVCLASS_DISPLAY, gpu->name, NULL, 0, &device_data); + if (!SetupDiRegisterDeviceInfo(devinfo, &device_data, 0, NULL, NULL, NULL)) + goto fail; + } + + /* Write HaredwareID registry property */ + written = sprintfW(bufferW, gpu_hardware_id_fmtW, gpu->vendor_id, gpu->device_id); + bufferW[written + 1] = 0; + if (!SetupDiSetDeviceRegistryPropertyW(devinfo, &device_data, SPDRP_HARDWAREID, (const BYTE *)bufferW, + (written + 2) * sizeof(WCHAR))) + goto fail; + + /* Write DEVPKEY_Device_IsPresent property */ + if (!SetupDiSetDevicePropertyW(devinfo, &device_data, &DEVPKEY_Device_IsPresent, DEVPROP_TYPE_BOOLEAN, + (const BYTE *)&present, sizeof(present), 0)) + goto fail; + + /* Open driver key. + * This is where HKLM\System\CurrentControlSet\Control\Video\{GPU GUID}\{Adapter Index} links to */ + hkey = SetupDiOpenDevRegKey(devinfo, &device_data, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_ALL_ACCESS); + if (hkey == INVALID_HANDLE_VALUE) + hkey = SetupDiCreateDevRegKeyW(devinfo, &device_data, DICS_FLAG_GLOBAL, 0, DIREG_DRV, NULL, NULL); + + /* Write GraphicsDriver value */ + if (RegSetValueExW(hkey, graphics_driverW, 0, REG_SZ, (const BYTE *)winex11_drvW, sizeof(winex11_drvW))) + goto fail; + + /* Write DriverDesc value */ + if (RegSetValueExW(hkey, driver_descW, 0, REG_SZ, (const BYTE *)gpu->name, + (strlenW(gpu->name) + 1) * sizeof(WCHAR))) + goto fail; + RegCloseKey(hkey); + hkey = NULL; + + /* Retrieve driver value for adapters */ + if (!SetupDiGetDeviceRegistryPropertyW(devinfo, &device_data, SPDRP_DRIVER, NULL, (BYTE *)bufferW, sizeof(bufferW), + NULL)) + goto fail; + strcpyW(driver, nt_classW); + strcatW(driver, bufferW); + + /* Write GUID in VideoID in .../instance/Device Parameters, reuse the GUID if it's existent */ + hkey = SetupDiOpenDevRegKey(devinfo, &device_data, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_ALL_ACCESS); + if (hkey == INVALID_HANDLE_VALUE) + hkey = SetupDiCreateDevRegKeyW(devinfo, &device_data, DICS_FLAG_GLOBAL, 0, DIREG_DEV, NULL, NULL); + + size = sizeof(bufferW); + bufferW[0] = 0; + if (RegQueryValueExW(hkey, video_idW, 0, NULL, (BYTE *)bufferW, &size)) + { + ExUuidCreate(&guid); + sprintfW(bufferW, guid_fmtW, guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2], + guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]); + if (RegSetValueExW(hkey, video_idW, 0, REG_SZ, (const BYTE *)bufferW, (strlenW(bufferW) + 1) * sizeof(WCHAR))) + goto fail; + } + strcpyW(guid_string, bufferW); + + ret = TRUE; +fail: + RegCloseKey(hkey); + if (!ret) + ERR("Failed to initialize GPU\n"); + return ret; +} + +static void prepare_devices(void) +{ + static const BOOL not_present = FALSE; + SP_DEVINFO_DATA device_data = {sizeof(device_data)}; + HDEVINFO devinfo; + DWORD i = 0; + + /* Set all GPUs as not present. We can't simply delete them because we need to keep the GUID consistent with + * each initialization run. We clean up non present GPUs at the end of initialization */ + devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_DISPLAY, NULL, NULL, 0); + while (SetupDiEnumDeviceInfo(devinfo, i++, &device_data)) + { + if (!SetupDiSetDevicePropertyW(devinfo, &device_data, &DEVPKEY_Device_IsPresent, DEVPROP_TYPE_BOOLEAN, + (const BYTE *)&not_present, sizeof(not_present), 0)) + ERR("Failed to set GPU present property\n"); + } + SetupDiDestroyDeviceInfoList(devinfo); +} + +static void cleanup_devices(void) +{ + SP_DEVINFO_DATA device_data = {sizeof(device_data)}; + HDEVINFO devinfo; + DWORD type; + DWORD i = 0; + BOOL present; + + devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_DISPLAY, NULL, NULL, 0); + while (SetupDiEnumDeviceInfo(devinfo, i++, &device_data)) + { + present = FALSE; + SetupDiGetDevicePropertyW(devinfo, &device_data, &DEVPKEY_Device_IsPresent, &type, (BYTE *)&present, + sizeof(present), NULL, 0); + if (!present && !SetupDiRemoveDevice(devinfo, &device_data)) + ERR("Failed to remove GPU\n"); + } + SetupDiDestroyDeviceInfoList(devinfo); +} + void X11DRV_DisplayDevices_Init(void) { + struct x11drv_gpu *gpus = NULL; + INT gpu_count; + INT gpu; + HDEVINFO gpu_devinfo = NULL; HKEY video_hkey = NULL; DWORD disposition = 0; + WCHAR guidW[40]; + WCHAR driverW[1024]; BOOL success = FALSE; TRACE("via %s\n", wine_dbgstr_a(handler.name)); @@ -66,9 +233,32 @@ void X11DRV_DisplayDevices_Init(void) goto fail; } + /* FIXME: + * Currently we have no idea how to implement SetupDiGetClassDevsW with DIGCF_PRESENT properly. So we need to clean + * up not present devices in case application use SetupDiGetClassDevsW to enumerate devices. Wrong devices could + * exist in registry as a result of prefix copying or having devices unplugged. But then we couldn't simply delete + * GPUs because we need to retain the same GUID for the same GPU. */ + prepare_devices(); + + gpu_devinfo = SetupDiCreateDeviceInfoList(&GUID_DEVCLASS_DISPLAY, NULL); + + /* Initialize GPUs */ + if (!handler.pGetGpus(&gpus, &gpu_count)) + goto fail; + + for (gpu = 0; gpu < gpu_count; gpu++) + { + if (!X11DRV_InitGpu(gpu_devinfo, &gpus[gpu], gpu, guidW, driverW)) + goto fail; + } + success = TRUE; fail: + cleanup_devices(); + SetupDiDestroyDeviceInfoList(gpu_devinfo); RegCloseKey(video_hkey); + if (gpus) + handler.pFreeGpus(gpus); if (!success) ERR("Failed to initialize display devices\n"); } -- 2.20.1

1 0

[PATCH v4 1/7] winex11.drv: Add Xinerama display device handler.
by Zhiyi Zhang 20 May '19

20 May '19

Display device handlers are used to initialize the display device registry data. Different handlers can be implemented according to the defined interface, for example, via Xinerama or XRandR. With those registry data, EnumDisplayDevices, EnumDisplayMonitors and GetMonitorInfo can be built on top of it. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v2: Supersede 162308~162314, fix xinerama primary adapter reporting, fix registry data reinit failure. v3: Rebase v4: Merge patches. Rebase. dlls/winex11.drv/Makefile.in | 1 + dlls/winex11.drv/display.c | 74 ++++++++++++++++ dlls/winex11.drv/x11drv.h | 77 +++++++++++++++++ dlls/winex11.drv/x11drv_main.c | 1 + dlls/winex11.drv/xinerama.c | 154 +++++++++++++++++++++++++++++++++ 5 files changed, 307 insertions(+) create mode 100644 dlls/winex11.drv/display.c diff --git a/dlls/winex11.drv/Makefile.in b/dlls/winex11.drv/Makefile.in index 747f509b44..9ca2fc6efe 100644 --- a/dlls/winex11.drv/Makefile.in +++ b/dlls/winex11.drv/Makefile.in @@ -9,6 +9,7 @@ C_SRCS = \ brush.c \ clipboard.c \ desktop.c \ + display.c \ event.c \ graphics.c \ ime.c \ diff --git a/dlls/winex11.drv/display.c b/dlls/winex11.drv/display.c new file mode 100644 index 0000000000..7d81de09ac --- /dev/null +++ b/dlls/winex11.drv/display.c @@ -0,0 +1,74 @@ +/* + * X11DRV display device functions + * + * Copyright 2019 Zhiyi Zhang for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" + +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "winreg.h" +#include "wine/debug.h" +#include "x11drv.h" + +WINE_DEFAULT_DEBUG_CHANNEL(x11drv); + +static const WCHAR video_keyW[] = { + 'H','A','R','D','W','A','R','E','\\', + 'D','E','V','I','C','E','M','A','P','\\', + 'V','I','D','E','O',0}; + +static struct x11drv_display_device_handler handler; + +void X11DRV_DisplayDevices_SetHandler(const struct x11drv_display_device_handler *new_handler) +{ + if (new_handler->priority > handler.priority) + { + handler = *new_handler; + TRACE("Display device functions are now handled by: %s\n", handler.name); + } +} + +void X11DRV_DisplayDevices_Init(void) +{ + HKEY video_hkey = NULL; + DWORD disposition = 0; + BOOL success = FALSE; + + TRACE("via %s\n", wine_dbgstr_a(handler.name)); + + if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, video_keyW, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &video_hkey, + &disposition)) + goto fail; + + /* Ensure only one thread is initializing the registry and avoid unnecessary reinit */ + if (disposition != REG_CREATED_NEW_KEY) + { + success = TRUE; + goto fail; + } + + success = TRUE; +fail: + RegCloseKey(video_hkey); + if (!success) + ERR("Failed to initialize display devices\n"); +} diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index c633102a38..40392b03c0 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -665,6 +665,83 @@ struct x11drv_mode_info *X11DRV_Settings_SetHandlers(const char *name, void X11DRV_XF86VM_Init(void) DECLSPEC_HIDDEN; void X11DRV_XRandR_Init(void) DECLSPEC_HIDDEN; +/* X11 display device handler. Used to initialize display device registry data */ + +/* Represent a physical GPU in the PCI slots */ +struct x11drv_gpu +{ + /* ID to uniquely identify a GPU in handler */ + ULONG_PTR id; + /* Name */ + WCHAR name[128]; + /* PCI ID */ + UINT vendor_id; + UINT device_id; + UINT subsys_id; + UINT revision_id; +}; + +/* Represent an adapter in EnumDisplayDevices context */ +struct x11drv_adapter +{ + /* ID to uniquely identify an adapter in handler */ + ULONG_PTR id; + /* as StateFlags in DISPLAY_DEVICE struct */ + DWORD state_flags; +}; + +/* Represent a monitor in EnumDisplayDevices context */ +struct x11drv_monitor +{ + /* Name */ + WCHAR name[128]; + /* as RcMonitor in MONITORINFO struct */ + RECT rc_monitor; + /* as RcWork in MONITORINFO struct */ + RECT rc_work; + /* StateFlags in DISPLAY_DEVICE struct */ + DWORD state_flags; +}; + +/* Required functions for display device registry initialization */ +struct x11drv_display_device_handler +{ + /* A name to tell what host driver is used */ + CHAR name[MAX_PATH]; + + /* Higher priority can override handlers with lower proprity */ + INT priority; + + /* pGetGpus will be called to get a list of GPUs. First GPU has to be where the primary adapter is. + * + * Return FALSE on failure with parameters unchanged */ + BOOL (*pGetGpus)(struct x11drv_gpu **gpus, int *count); + + /* pGetAdapters will be called to get a list of adapters in EnumDisplayDevices context under a GPU. + * The first adapter has to be primary if GPU is primary. + * + * Return FALSE on failure with parameters unchanged */ + BOOL (*pGetAdapters)(ULONG_PTR gpu_id, struct x11drv_adapter **adapters, int *count); + + /* pGetMonitors will be called to get a list of monitors in EnumDisplayDevices context under an adapter. + * The first monitor has to be primary if adapter is primary. + * + * Return FALSE on failure with parameters unchanged */ + BOOL (*pGetMonitors)(ULONG_PTR adapter_id, struct x11drv_monitor **monitors, int *count); + + /* pFreeGpus will be called to free a GPU list from pGetGpus */ + void (*pFreeGpus)(struct x11drv_gpu *gpus); + + /* pFreeAdapters will be called to free an adapter list from pGetAdapters */ + void (*pFreeAdapters)(struct x11drv_adapter *adapters); + + /* pFreeMonitors will be called to free a monitor list from pGetMonitors */ + void (*pFreeMonitors)(struct x11drv_monitor *monitors); +}; + +extern void X11DRV_DisplayDevices_SetHandler(const struct x11drv_display_device_handler *handler) DECLSPEC_HIDDEN; +extern void X11DRV_DisplayDevices_Init(void) DECLSPEC_HIDDEN; + /* XIM support */ extern BOOL X11DRV_InitXIM( const char *input_style ) DECLSPEC_HIDDEN; extern XIC X11DRV_CreateIC(XIM xim, struct x11drv_win_data *data) DECLSPEC_HIDDEN; diff --git a/dlls/winex11.drv/x11drv_main.c b/dlls/winex11.drv/x11drv_main.c index e67a3c05a9..69478741f1 100644 --- a/dlls/winex11.drv/x11drv_main.c +++ b/dlls/winex11.drv/x11drv_main.c @@ -597,6 +597,7 @@ static BOOL process_attach(void) X11DRV_InitKeyboard( gdi_display ); if (use_xim) use_xim = X11DRV_InitXIM( input_style ); + X11DRV_DisplayDevices_Init(); return TRUE; } diff --git a/dlls/winex11.drv/xinerama.c b/dlls/winex11.drv/xinerama.c index 739b139736..49427890cb 100644 --- a/dlls/winex11.drv/xinerama.c +++ b/dlls/winex11.drv/xinerama.c @@ -30,6 +30,8 @@ #include "wine/library.h" #include "x11drv.h" #include "wine/debug.h" +#include "wine/heap.h" +#include "wine/unicode.h" WINE_DEFAULT_DEBUG_CHANNEL(x11drv); @@ -199,8 +201,150 @@ RECT get_primary_monitor_rect(void) return get_primary()->rcMonitor; } +static BOOL xinerama_get_gpus( struct x11drv_gpu **new_gpus, int *count ) +{ + static const WCHAR wine_gpuW[] = {'W','i','n','e',' ','G','P','U',0}; + struct x11drv_gpu *gpus; + + /* Xinerama has no support for GPU, faking one */ + gpus = heap_calloc( 1, sizeof(*gpus) ); + if (!gpus) + return FALSE; + + strcpyW( gpus[0].name, wine_gpuW ); + + *new_gpus = gpus; + *count = 1; + + return TRUE; +} + +static void xinerama_free_gpus( struct x11drv_gpu *gpus ) +{ + heap_free( gpus ); +} + +static BOOL xinerama_get_adapters( ULONG_PTR gpu_id, struct x11drv_adapter **new_adapters, int *count ) +{ + struct x11drv_adapter *adapters = NULL; + INT index = 0; + INT i, j; + INT primary_index; + BOOL mirrored; + + if (gpu_id) + return FALSE; + + /* Being lazy, actual adapter count maybe less */ + adapters = heap_calloc( nb_monitors, sizeof(*adapters) ); + if (!adapters) + return FALSE; + + primary_index = primary_monitor; + if (primary_index >= nb_monitors) + primary_index = 0; + + for (i = 0; i < nb_monitors; i++) + { + mirrored = FALSE; + for (j = 0; j < i; j++) + { + if (EqualRect( &monitors[i].rcMonitor, &monitors[j].rcMonitor) && !IsRectEmpty( &monitors[j].rcMonitor )) + { + mirrored = TRUE; + break; + } + } + + /* Mirrored monitors share the same adapter */ + if (mirrored) + continue; + + /* Use monitor index as id */ + adapters[index].id = (ULONG_PTR)i; + + if (i == primary_index) + adapters[index].state_flags |= DISPLAY_DEVICE_PRIMARY_DEVICE; + + if (!IsRectEmpty( &monitors[i].rcMonitor )) + adapters[index].state_flags |= DISPLAY_DEVICE_ATTACHED_TO_DESKTOP; + + index++; + } + + /* Primary adapter has to be first */ + if (primary_index) + { + struct x11drv_adapter tmp; + tmp = adapters[primary_index]; + adapters[primary_index] = adapters[0]; + adapters[0] = tmp; + } + + *new_adapters = adapters; + *count = index; + return TRUE; +} + +static void xinerama_free_adapters( struct x11drv_adapter *adapters ) +{ + heap_free( adapters ); +} + +static BOOL xinerama_get_monitors( ULONG_PTR adapter_id, struct x11drv_monitor **new_monitors, int *count ) +{ + static const WCHAR generic_nonpnp_monitorW[] = { + 'G','e','n','e','r','i','c',' ', + 'N','o','n','-','P','n','P',' ','M','o','n','i','t','o','r',0}; + struct x11drv_monitor *monitor; + INT first = (INT)adapter_id; + INT monitor_count = 0; + INT index = 0; + INT i; + + for (i = first; i < nb_monitors; i++) + { + if (i == first + || (EqualRect( &monitors[i].rcMonitor, &monitors[first].rcMonitor ) + && !IsRectEmpty( &monitors[first].rcMonitor ))) + monitor_count++; + } + + monitor = heap_calloc( monitor_count, sizeof(*monitor) ); + if (!monitor) + return FALSE; + + for (i = first; i < nb_monitors; i++) + { + if (i == first + || (EqualRect( &monitors[i].rcMonitor, &monitors[first].rcMonitor ) + && !IsRectEmpty( &monitors[first].rcMonitor ))) + { + strcpyW( monitor[index].name, generic_nonpnp_monitorW ); + monitor[index].rc_monitor = monitors[i].rcMonitor; + monitor[index].rc_work = monitors[i].rcWork; + /* Xinerama only reports monitors already attached */ + monitor[index].state_flags = DISPLAY_DEVICE_ATTACHED; + if (!IsRectEmpty( &monitors[i].rcMonitor )) + monitor[index].state_flags |= DISPLAY_DEVICE_ACTIVE; + + index++; + } + } + + *new_monitors = monitor; + *count = monitor_count; + return TRUE; +} + +static void xinerama_free_monitors( struct x11drv_monitor *monitors ) +{ + heap_free( monitors ); +} + void xinerama_init( unsigned int width, unsigned int height ) { + struct x11drv_display_device_handler handler; MONITORINFOEXW *primary; int i; RECT rect; @@ -234,6 +378,16 @@ void xinerama_init( unsigned int width, unsigned int height ) (monitors[i].dwFlags & MONITORINFOF_PRIMARY) ? " (primary)" : "" ); } + strcpy( handler.name, "Xinerama" ); + handler.priority = 100; + handler.pGetGpus = xinerama_get_gpus; + handler.pGetAdapters = xinerama_get_adapters; + handler.pGetMonitors = xinerama_get_monitors; + handler.pFreeGpus = xinerama_free_gpus; + handler.pFreeAdapters = xinerama_free_adapters; + handler.pFreeMonitors = xinerama_free_monitors; + X11DRV_DisplayDevices_SetHandler( &handler ); + TRACE( "virtual size: %s primary: %s\n", wine_dbgstr_rect(&virtual_screen_rect), wine_dbgstr_rect(&primary->rcMonitor) ); } -- 2.20.1

1 0

[PATCH v2 10/10] gdi32/tests: Add D3DKMTCheckOcclusion tests.
by Zhiyi Zhang 20 May '19

20 May '19

Mostly to show that D3DKMTCheckOcclusion is mainly composed of ownership checks rather than actually window occlusion. Also composition status doesn't affect its behavior despite MSDN say so. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v2: Remove tests with d3d swapchains as they seemed mostly duplicated. dlls/gdi32/tests/driver.c | 206 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 206 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index b9ee277a5a..ec3e66bf0d 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -27,12 +27,14 @@ #include "wingdi.h" #include "winuser.h" #include "winternl.h" +#include "dwmapi.h" #include "ddk/d3dkmthk.h" #include "wine/test.h" static const WCHAR display1W[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0}; +static NTSTATUS (WINAPI *pD3DKMTCheckOcclusion)(const D3DKMT_CHECKOCCLUSION *); static NTSTATUS (WINAPI *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); static NTSTATUS (WINAPI *pD3DKMTCreateDevice)(D3DKMT_CREATEDEVICE *); @@ -40,6 +42,7 @@ static NTSTATUS (WINAPI *pD3DKMTDestroyDevice)(const D3DKMT_DESTROYDEVICE *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromHdc)(D3DKMT_OPENADAPTERFROMHDC *); static NTSTATUS (WINAPI *pD3DKMTSetVidPnSourceOwner)(const D3DKMT_SETVIDPNSOURCEOWNER *); +static HRESULT (WINAPI *pDwmEnableComposition)(UINT); static void test_D3DKMTOpenAdapterFromGdiDisplayName(void) { @@ -615,10 +618,208 @@ static void test_D3DKMTSetVidPnSourceOwner(void) ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); } +static void test_D3DKMTCheckOcclusion(void) +{ + DISPLAY_DEVICEW display_device = {sizeof(display_device)}; + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP check_owner_desc; + D3DKMT_SETVIDPNSOURCEOWNER set_owner_desc; + D3DKMT_DESTROYDEVICE destroy_device_desc; + D3DKMT_VIDPNSOURCEOWNER_TYPE owner_type; + D3DKMT_CLOSEADAPTER close_adapter_desc; + D3DKMT_CREATEDEVICE create_device_desc; + D3DKMT_CHECKOCCLUSION occlusion_desc; + NTSTATUS expected_occlusion, status; + INT i, adapter_count = 0; + HWND hwnd, hwnd2; + HRESULT hr; + + if (!pD3DKMTCheckOcclusion || pD3DKMTCheckOcclusion(NULL) == STATUS_PROCEDURE_NOT_FOUND) + { + skip("D3DKMTCheckOcclusion() is unavailable.\n"); + return; + } + + /* NULL parameter check */ + status = pD3DKMTCheckOcclusion(NULL); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + occlusion_desc.hWnd = NULL; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + hwnd = CreateWindowA("static", "static1", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 200, 200, 0, 0, 0, 0); + ok(hwnd != NULL, "Failed to create window.\n"); + + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + /* Minimized state doesn't affect D3DKMTCheckOcclusion */ + ShowWindow(hwnd, SW_MINIMIZE); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + ShowWindow(hwnd, SW_SHOWNORMAL); + + /* Invisible state doesn't affect D3DKMTCheckOcclusion */ + ShowWindow(hwnd, SW_HIDE); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + ShowWindow(hwnd, SW_SHOW); + + /* hwnd2 covers hwnd */ + hwnd2 = CreateWindowA("static", "static2", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, 200, 200, 0, 0, 0, 0); + ok(hwnd2 != NULL, "Failed to create window.\n"); + + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + occlusion_desc.hWnd = hwnd2; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + /* Composition doesn't affect D3DKMTCheckOcclusion */ + if (pDwmEnableComposition) + { + hr = pDwmEnableComposition(DWM_EC_DISABLECOMPOSITION); + ok(hr == S_OK, "Failed to disable composition.\n"); + + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + /* This result means that D3DKMTCheckOcclusion doesn't check composition status despite MSDN says it will */ + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + occlusion_desc.hWnd = hwnd2; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + ShowWindow(hwnd, SW_MINIMIZE); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + ShowWindow(hwnd, SW_SHOWNORMAL); + + ShowWindow(hwnd, SW_HIDE); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + ShowWindow(hwnd, SW_SHOW); + + hr = pDwmEnableComposition(DWM_EC_ENABLECOMPOSITION); + ok(hr == S_OK, "Failed to enable composition.\n"); + } + else + skip("Skip testing composition.\n"); + + if (!(pD3DKMTCheckVidPnExclusiveOwnership && pD3DKMTCloseAdapter && pD3DKMTCreateDevice && pD3DKMTDestroyDevice + && pD3DKMTOpenAdapterFromGdiDisplayName && pD3DKMTSetVidPnSourceOwner)) + { + skip("Required functions are unavailable.\n"); + DestroyWindow(hwnd2); + goto done; + } + + lstrcpyW(open_adapter_gdi_desc.DeviceName, display1W); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + memset(&create_device_desc, 0, sizeof(create_device_desc)); + create_device_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCreateDevice(&create_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + check_owner_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_owner_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + /* Test D3DKMTCheckOcclusion relationship with video present source owner */ + set_owner_desc.hDevice = create_device_desc.hDevice; + owner_type = D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + for (i = 0; EnumDisplayDevicesW(NULL, i, &display_device, 0); ++i) + { + if ((display_device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) + adapter_count++; + } + /* STATUS_GRAPHICS_PRESENT_OCCLUDED on single monitor system. STATUS_SUCCESS on multiple monitor system. */ + expected_occlusion = adapter_count > 1 ? STATUS_SUCCESS : STATUS_GRAPHICS_PRESENT_OCCLUDED; + + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == expected_occlusion, "Got unexpected return code %#x.\n", status); + + /* Note hwnd2 is not actually occluded but D3DKMTCheckOcclusion reports STATUS_GRAPHICS_PRESENT_OCCLUDED as well */ + SetWindowPos(hwnd2, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); + ShowWindow(hwnd2, SW_SHOW); + occlusion_desc.hWnd = hwnd2; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == expected_occlusion, "Got unexpected return code %#x.\n", status); + + /* Now hwnd is HWND_TOPMOST. Still reports STATUS_GRAPHICS_PRESENT_OCCLUDED */ + ok(SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE), "Failed to SetWindowPos.\n"); + ok(GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_TOPMOST, "No WS_EX_TOPMOST style.\n"); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == expected_occlusion, "Got unexpected return code %#x.\n", status); + + DestroyWindow(hwnd2); + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == expected_occlusion, "Got unexpected return code %#x.\n", status); + + check_owner_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_owner_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected return code %#x.\n", status); + + /* Unset video present source owner */ + set_owner_desc.hDevice = create_device_desc.hDevice; + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + occlusion_desc.hWnd = hwnd; + status = pD3DKMTCheckOcclusion(&occlusion_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + check_owner_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_owner_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + /* D3DKMTCheckVidPnExclusiveOwnership gets STATUS_GRAPHICS_PRESENT_UNOCCLUDED sometimes and with some delay, + * it will always return STATUS_SUCCESS. So there are some timing issues here. */ + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected return code %#x.\n", status); + + destroy_device_desc.hDevice = create_device_desc.hDevice; + status = pD3DKMTDestroyDevice(&destroy_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + +done: + if (pD3DKMTCloseAdapter) + { + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + } + DestroyWindow(hwnd); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); + HMODULE dwmapi = LoadLibraryA("dwmapi.dll"); + pD3DKMTCheckOcclusion = (void *)GetProcAddress(gdi32, "D3DKMTCheckOcclusion"); pD3DKMTCheckVidPnExclusiveOwnership = (void *)GetProcAddress(gdi32, "D3DKMTCheckVidPnExclusiveOwnership"); pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32, "D3DKMTCloseAdapter"); pD3DKMTCreateDevice = (void *)GetProcAddress(gdi32, "D3DKMTCreateDevice"); @@ -627,6 +828,10 @@ START_TEST(driver) pD3DKMTOpenAdapterFromHdc = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromHdc"); pD3DKMTSetVidPnSourceOwner = (void *)GetProcAddress(gdi32, "D3DKMTSetVidPnSourceOwner"); + if (dwmapi) + pDwmEnableComposition = (void *)GetProcAddress(dwmapi, "DwmEnableComposition"); + + test_D3DKMTCheckOcclusion(); test_D3DKMTCheckVidPnExclusiveOwnership(); test_D3DKMTCloseAdapter(); test_D3DKMTCreateDevice(); @@ -636,4 +841,5 @@ START_TEST(driver) test_D3DKMTSetVidPnSourceOwner(); FreeLibrary(gdi32); + FreeLibrary(dwmapi); } -- 2.20.1

1 0

[PATCH v2 09/10] gdi32/tests: Add D3DKMTSetVidPnSourceOwner tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index aa404954ce..b9ee277a5a 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -592,6 +592,29 @@ static void test_D3DKMTCheckVidPnExclusiveOwnership(void) ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); } +static void test_D3DKMTSetVidPnSourceOwner(void) +{ + D3DKMT_SETVIDPNSOURCEOWNER set_owner_desc = {0}; + NTSTATUS status; + + if (!pD3DKMTSetVidPnSourceOwner || pD3DKMTSetVidPnSourceOwner(&set_owner_desc) == STATUS_PROCEDURE_NOT_FOUND) + { + skip("D3DKMTSetVidPnSourceOwner() is unavailable.\n"); + return; + } + + /* Invalid parameters */ + /* Crash on windows */ + if (0) + { + status = pD3DKMTSetVidPnSourceOwner(NULL); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + } + + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); @@ -610,6 +633,7 @@ START_TEST(driver) test_D3DKMTDestroyDevice(); test_D3DKMTOpenAdapterFromGdiDisplayName(); test_D3DKMTOpenAdapterFromHdc(); + test_D3DKMTSetVidPnSourceOwner(); FreeLibrary(gdi32); } -- 2.20.1

1 0

[PATCH v2 08/10] gdi32/tests: Add D3DKMTCheckVidPnExclusiveOwnership tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 347 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 347 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index 2fda28138d..aa404954ce 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -33,11 +33,13 @@ static const WCHAR display1W[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0}; +static NTSTATUS (WINAPI *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); static NTSTATUS (WINAPI *pD3DKMTCreateDevice)(D3DKMT_CREATEDEVICE *); static NTSTATUS (WINAPI *pD3DKMTDestroyDevice)(const D3DKMT_DESTROYDEVICE *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromHdc)(D3DKMT_OPENADAPTERFROMHDC *); +static NTSTATUS (WINAPI *pD3DKMTSetVidPnSourceOwner)(const D3DKMT_SETVIDPNSOURCEOWNER *); static void test_D3DKMTOpenAdapterFromGdiDisplayName(void) { @@ -248,16 +250,361 @@ static void test_D3DKMTDestroyDevice(void) todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); } +static void test_D3DKMTCheckVidPnExclusiveOwnership(void) +{ + static const DWORD timeout = 1000; + static const DWORD wait_step = 100; + D3DKMT_CREATEDEVICE create_device_desc, create_device_desc2; + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP check_owner_desc; + D3DKMT_DESTROYDEVICE destroy_device_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + D3DKMT_VIDPNSOURCEOWNER_TYPE owner_type; + D3DKMT_SETVIDPNSOURCEOWNER set_owner_desc; + DWORD total_time; + NTSTATUS status; + INT i; + + /* Test cases using single device */ + static const struct test_data1 + { + D3DKMT_VIDPNSOURCEOWNER_TYPE owner_type; + NTSTATUS expected_set_status; + NTSTATUS expected_check_status; + } tests1[] = { + /* 0 */ + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI, STATUS_INVALID_PARAMETER, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + /* 10 */ + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + /* 20 */ + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + /* 30 */ + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_INVALID_PARAMETER, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + /* 40 */ + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_INVALID_PARAMETER, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + /* 50 */ + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_INVALID_PARAMETER, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS}, + {-1, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED + 1, STATUS_INVALID_PARAMETER, STATUS_SUCCESS}, + }; + + /* Test cases using two devices consecutively */ + static const struct test_data2 + { + D3DKMT_VIDPNSOURCEOWNER_TYPE set_owner_type1; + D3DKMT_VIDPNSOURCEOWNER_TYPE set_owner_type2; + NTSTATUS expected_set_status1; + NTSTATUS expected_set_status2; + NTSTATUS expected_check_status; + } tests2[] = { + /* 0 */ + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_UNOWNED, D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_SHARED, D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + /* 10 */ + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, D3DKMT_VIDPNSOURCEOWNER_UNOWNED, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, D3DKMT_VIDPNSOURCEOWNER_SHARED, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {D3DKMT_VIDPNSOURCEOWNER_EMULATED, D3DKMT_VIDPNSOURCEOWNER_EMULATED, STATUS_SUCCESS, STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE, STATUS_SUCCESS}, + {-1, D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, -1, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + {D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE, -1, STATUS_SUCCESS, STATUS_SUCCESS, STATUS_GRAPHICS_PRESENT_OCCLUDED}, + }; + + if (!pD3DKMTCheckVidPnExclusiveOwnership || pD3DKMTCheckVidPnExclusiveOwnership(NULL) == STATUS_PROCEDURE_NOT_FOUND + || !pD3DKMTOpenAdapterFromGdiDisplayName || !pD3DKMTCloseAdapter || !pD3DKMTCreateDevice + || !pD3DKMTDestroyDevice || !pD3DKMTSetVidPnSourceOwner) + { + skip("Required functions are unavailable.\n"); + return; + } + + /* Invalid parameters */ + status = pD3DKMTCheckVidPnExclusiveOwnership(NULL); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + memset(&check_owner_desc, 0, sizeof(check_owner_desc)); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + /* Test cases */ + lstrcpyW(open_adapter_gdi_desc.DeviceName, display1W); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + memset(&create_device_desc, 0, sizeof(create_device_desc)); + create_device_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCreateDevice(&create_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + check_owner_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_owner_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + for (i = 0; i < ARRAY_SIZE(tests1); ++i) + { + set_owner_desc.hDevice = create_device_desc.hDevice; + if (tests1[i].owner_type != -1) + { + owner_type = tests1[i].owner_type; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + } + else + { + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + } + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == tests1[i].expected_set_status || + /* win8 doesn't support D3DKMT_VIDPNSOURCEOWNER_EMULATED */ + (status == STATUS_INVALID_PARAMETER && tests1[i].owner_type == D3DKMT_VIDPNSOURCEOWNER_EMULATED) + || (status == STATUS_SUCCESS && tests1[i].owner_type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE + && tests1[i - 1].owner_type == D3DKMT_VIDPNSOURCEOWNER_EMULATED), + "Got unexpected return code %#x at test %d.\n", status, i); + + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + /* If don't sleep, D3DKMTCheckVidPnExclusiveOwnership may get STATUS_GRAPHICS_PRESENT_UNOCCLUDED instead + * of STATUS_SUCCESS */ + if ((tests1[i].expected_check_status == STATUS_SUCCESS && status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED)) + { + total_time = 0; + do + { + Sleep(wait_step); + total_time += wait_step; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + } while (status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED && total_time < timeout); + } + ok(status == tests1[i].expected_check_status + || (status == STATUS_GRAPHICS_PRESENT_OCCLUDED /* win8 */ + && tests1[i].owner_type == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE + && tests1[i - 1].owner_type == D3DKMT_VIDPNSOURCEOWNER_EMULATED), + "Got unexpected return code %#x at test %d.\n", status, i); + } + + /* Set owner and unset owner using different devices */ + memset(&create_device_desc2, 0, sizeof(create_device_desc2)); + create_device_desc2.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCreateDevice(&create_device_desc2); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + /* Set owner with the first device */ + set_owner_desc.hDevice = create_device_desc.hDevice; + owner_type = D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected return code %#x.\n", status); + + /* Unset owner with the second device */ + set_owner_desc.hDevice = create_device_desc2.hDevice; + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + /* No effect */ + ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected return code %#x.\n", status); + + /* Unset owner with the first device */ + set_owner_desc.hDevice = create_device_desc.hDevice; + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + /* Proves that the correct device is needed to unset owner */ + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected return code %#x.\n", + status); + + /* Set owner with the first device, set owner again with the second device */ + for (i = 0; i < ARRAY_SIZE(tests2); ++i) + { + if (tests2[i].set_owner_type1 != -1) + { + set_owner_desc.hDevice = create_device_desc.hDevice; + owner_type = tests2[i].set_owner_type1; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + /* If don't sleep, D3DKMTSetVidPnSourceOwner may return STATUS_OK for D3DKMT_VIDPNSOURCEOWNER_SHARED. + * Other owner type doesn't seems to be affected. */ + if (tests2[i].set_owner_type1 == D3DKMT_VIDPNSOURCEOWNER_SHARED) + Sleep(timeout); + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == tests2[i].expected_set_status1 + || (status == STATUS_INVALID_PARAMETER /* win8 */ + && tests2[i].set_owner_type1 == D3DKMT_VIDPNSOURCEOWNER_EMULATED), + "Got unexpected return code %#x at test %d.\n", status, i); + } + + if (tests2[i].set_owner_type2 != -1) + { + set_owner_desc.hDevice = create_device_desc2.hDevice; + owner_type = tests2[i].set_owner_type2; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == tests2[i].expected_set_status2 + || (status == STATUS_INVALID_PARAMETER /* win8 */ + && tests2[i].set_owner_type2 == D3DKMT_VIDPNSOURCEOWNER_EMULATED) + || (status == STATUS_SUCCESS && tests2[i].set_owner_type1 == D3DKMT_VIDPNSOURCEOWNER_EMULATED + && tests2[i].set_owner_type2 == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE), + "Got unexpected return code %#x at test %d.\n", status, i); + } + + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + if ((tests2[i].expected_check_status == STATUS_SUCCESS && status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED)) + { + total_time = 0; + do + { + Sleep(wait_step); + total_time += wait_step; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_owner_desc); + } while (status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED && total_time < timeout); + } + ok(status == tests2[i].expected_check_status + || (status == STATUS_GRAPHICS_PRESENT_OCCLUDED /* win8 */ + && tests2[i].set_owner_type2 == D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE + && tests2[i].set_owner_type1 == D3DKMT_VIDPNSOURCEOWNER_EMULATED), + "Got unexpected return code %#x at test %d.\n", status, i); + + /* Unset owner with first device */ + if (tests2[i].set_owner_type1 != -1) + { + set_owner_desc.hDevice = create_device_desc.hDevice; + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x at test %d.\n", status, i); + } + + /* Unset owner with second device */ + if (tests2[i].set_owner_type2 != -1) + { + set_owner_desc.hDevice = create_device_desc2.hDevice; + set_owner_desc.pType = NULL; + set_owner_desc.pVidPnSourceId = NULL; + set_owner_desc.VidPnSourceCount = 0; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x at test %d.\n", status, i); + } + } + + /* Destroy devices holding ownership */ + set_owner_desc.hDevice = create_device_desc.hDevice; + owner_type = D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + destroy_device_desc.hDevice = create_device_desc.hDevice; + status = pD3DKMTDestroyDevice(&destroy_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + set_owner_desc.hDevice = create_device_desc2.hDevice; + owner_type = D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE; + set_owner_desc.pType = &owner_type; + set_owner_desc.pVidPnSourceId = &open_adapter_gdi_desc.VidPnSourceId; + set_owner_desc.VidPnSourceCount = 1; + status = pD3DKMTSetVidPnSourceOwner(&set_owner_desc); + /* So ownership is released when device is destroyed. otherwise the return code should be + * STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE */ + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + destroy_device_desc.hDevice = create_device_desc2.hDevice; + status = pD3DKMTDestroyDevice(&destroy_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); + pD3DKMTCheckVidPnExclusiveOwnership = (void *)GetProcAddress(gdi32, "D3DKMTCheckVidPnExclusiveOwnership"); pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32, "D3DKMTCloseAdapter"); pD3DKMTCreateDevice = (void *)GetProcAddress(gdi32, "D3DKMTCreateDevice"); pD3DKMTDestroyDevice = (void *)GetProcAddress(gdi32, "D3DKMTDestroyDevice"); pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromGdiDisplayName"); pD3DKMTOpenAdapterFromHdc = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromHdc"); + pD3DKMTSetVidPnSourceOwner = (void *)GetProcAddress(gdi32, "D3DKMTSetVidPnSourceOwner"); + test_D3DKMTCheckVidPnExclusiveOwnership(); test_D3DKMTCloseAdapter(); test_D3DKMTCreateDevice(); test_D3DKMTDestroyDevice(); -- 2.20.1

1 0

[PATCH v2 07/10] gdi32/tests: Add D3DKMTDestroyDevice tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index be5d4202d3..2fda28138d 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -228,6 +228,26 @@ static void test_D3DKMTCreateDevice(void) ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); } +static void test_D3DKMTDestroyDevice(void) +{ + D3DKMT_DESTROYDEVICE destroy_device_desc; + NTSTATUS status; + + if (!pD3DKMTDestroyDevice || pD3DKMTDestroyDevice(NULL) == STATUS_PROCEDURE_NOT_FOUND) + { + skip("D3DKMTDestroyDevice() is unavailable.\n"); + return; + } + + /* Invalid parameters */ + status = pD3DKMTDestroyDevice(NULL); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + memset(&destroy_device_desc, 0, sizeof(destroy_device_desc)); + status = pD3DKMTDestroyDevice(&destroy_device_desc); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); @@ -240,6 +260,7 @@ START_TEST(driver) test_D3DKMTCloseAdapter(); test_D3DKMTCreateDevice(); + test_D3DKMTDestroyDevice(); test_D3DKMTOpenAdapterFromGdiDisplayName(); test_D3DKMTOpenAdapterFromHdc(); -- 2.20.1

1 0

[PATCH v2 06/10] gdi32/tests: Add D3DKMTCreateDevice tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 53 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index 5d87bbf6b9..be5d4202d3 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -34,6 +34,8 @@ static const WCHAR display1W[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0}; static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); +static NTSTATUS (WINAPI *pD3DKMTCreateDevice)(D3DKMT_CREATEDEVICE *); +static NTSTATUS (WINAPI *pD3DKMTDestroyDevice)(const D3DKMT_DESTROYDEVICE *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromHdc)(D3DKMT_OPENADAPTERFROMHDC *); @@ -178,15 +180,66 @@ static void test_D3DKMTCloseAdapter(void) todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); } +static void test_D3DKMTCreateDevice(void) +{ + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CREATEDEVICE create_device_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + D3DKMT_DESTROYDEVICE destroy_device_desc; + NTSTATUS status; + + if (!pD3DKMTCreateDevice || pD3DKMTCreateDevice(NULL) == STATUS_PROCEDURE_NOT_FOUND + || !pD3DKMTOpenAdapterFromGdiDisplayName || !pD3DKMTCloseAdapter || !pD3DKMTDestroyDevice) + { + skip("Required functions are unavailable.\n"); + return; + } + + /* Invalid parameters */ + status = pD3DKMTCreateDevice(NULL); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + memset(&create_device_desc, 0, sizeof(create_device_desc)); + status = pD3DKMTCreateDevice(&create_device_desc); + ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + lstrcpyW(open_adapter_gdi_desc.DeviceName, display1W); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + /* Create device */ + create_device_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCreateDevice(&create_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + ok(create_device_desc.hDevice, "Expect not null.\n"); + ok(create_device_desc.pCommandBuffer == NULL, "Expect null.\n"); + ok(create_device_desc.CommandBufferSize == 0, "Got wrong value %#x.\n", create_device_desc.CommandBufferSize); + ok(create_device_desc.pAllocationList == NULL, "Expect null.\n"); + ok(create_device_desc.AllocationListSize == 0, "Got wrong value %#x.\n", create_device_desc.AllocationListSize); + ok(create_device_desc.pPatchLocationList == NULL, "Expect null.\n"); + ok(create_device_desc.PatchLocationListSize == 0, "Got wrong value %#x.\n", create_device_desc.PatchLocationListSize); + + destroy_device_desc.hDevice = create_device_desc.hDevice; + status = pD3DKMTDestroyDevice(&destroy_device_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32, "D3DKMTCloseAdapter"); + pD3DKMTCreateDevice = (void *)GetProcAddress(gdi32, "D3DKMTCreateDevice"); + pD3DKMTDestroyDevice = (void *)GetProcAddress(gdi32, "D3DKMTDestroyDevice"); pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromGdiDisplayName"); pD3DKMTOpenAdapterFromHdc = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromHdc"); test_D3DKMTCloseAdapter(); + test_D3DKMTCreateDevice(); test_D3DKMTOpenAdapterFromGdiDisplayName(); test_D3DKMTOpenAdapterFromHdc(); -- 2.20.1

1 0

[PATCH v2 05/10] gdi32/tests: Add D3DKMTCloseAdapter tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index c1abe72217..5d87bbf6b9 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -158,6 +158,26 @@ static void test_D3DKMTOpenAdapterFromHdc(void) } } +static void test_D3DKMTCloseAdapter(void) +{ + D3DKMT_CLOSEADAPTER close_adapter_desc; + NTSTATUS status; + + if (!pD3DKMTCloseAdapter || pD3DKMTCloseAdapter(NULL) == STATUS_PROCEDURE_NOT_FOUND) + { + skip("D3DKMTCloseAdapter() is unavailable.\n"); + return; + } + + /* Invalid parameters */ + status = pD3DKMTCloseAdapter(NULL); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + memset(&close_adapter_desc, 0, sizeof(close_adapter_desc)); + status = pD3DKMTCloseAdapter(&close_adapter_desc); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); @@ -166,6 +186,7 @@ START_TEST(driver) pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromGdiDisplayName"); pD3DKMTOpenAdapterFromHdc = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromHdc"); + test_D3DKMTCloseAdapter(); test_D3DKMTOpenAdapterFromGdiDisplayName(); test_D3DKMTOpenAdapterFromHdc(); -- 2.20.1

1 0

[PATCH v2 04/10] gdi32/tests: Add D3DKMTOpenAdapterFromHdc tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/tests/driver.c | 72 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/dlls/gdi32/tests/driver.c b/dlls/gdi32/tests/driver.c index 57b158f16b..c1abe72217 100644 --- a/dlls/gdi32/tests/driver.c +++ b/dlls/gdi32/tests/driver.c @@ -35,6 +35,7 @@ static const WCHAR display1W[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y' static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); +static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromHdc)(D3DKMT_OPENADAPTERFROMHDC *); static void test_D3DKMTOpenAdapterFromGdiDisplayName(void) { @@ -88,14 +89,85 @@ static void test_D3DKMTOpenAdapterFromGdiDisplayName(void) } } +static void test_D3DKMTOpenAdapterFromHdc(void) +{ + DISPLAY_DEVICEW display_device = {sizeof(display_device)}; + D3DKMT_OPENADAPTERFROMHDC open_adapter_hdc_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + INT adapter_count = 0; + NTSTATUS status; + HDC hdc; + DWORD i; + + if (!pD3DKMTOpenAdapterFromHdc || pD3DKMTOpenAdapterFromHdc(NULL) == STATUS_PROCEDURE_NOT_FOUND + || !pD3DKMTCloseAdapter) + { + skip("Required functions are unavailable.\n"); + return; + } + + /* Invalid parameters */ + status = pD3DKMTOpenAdapterFromHdc(NULL); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + memset(&open_adapter_hdc_desc, 0, sizeof(open_adapter_hdc_desc)); + status = pD3DKMTOpenAdapterFromHdc(&open_adapter_hdc_desc); + todo_wine ok(status == STATUS_INVALID_PARAMETER, "Got unexpected return code %#x.\n", status); + + /* Open adapter */ + for (i = 0; EnumDisplayDevicesW(NULL, i, &display_device, 0); ++i) + { + if (!(display_device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) + continue; + + adapter_count++; + + hdc = CreateDCW(0, display_device.DeviceName, 0, NULL); + open_adapter_hdc_desc.hDc = hdc; + status = pD3DKMTOpenAdapterFromHdc(&open_adapter_hdc_desc); + todo_wine ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + todo_wine ok(open_adapter_hdc_desc.hAdapter, "Expect not null.\n"); + if (display_device.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) + ok(open_adapter_hdc_desc.VidPnSourceId == 0, "Got unexpected value %#x.\n", + open_adapter_hdc_desc.VidPnSourceId); + else + todo_wine ok(open_adapter_hdc_desc.VidPnSourceId, "Got unexpected value %#x.\n", + open_adapter_hdc_desc.VidPnSourceId); + DeleteDC(hdc); + + if (status == STATUS_SUCCESS) + { + close_adapter_desc.hAdapter = open_adapter_hdc_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + } + } + + /* HDC covering more than two adapters is invalid for D3DKMTOpenAdapterFromHdc */ + hdc = GetDC(0); + open_adapter_hdc_desc.hDc = hdc; + status = pD3DKMTOpenAdapterFromHdc(&open_adapter_hdc_desc); + ReleaseDC(0, hdc); + todo_wine ok(status == (adapter_count > 1 ? STATUS_INVALID_PARAMETER : STATUS_SUCCESS), + "Got unexpected return code %#x.\n", status); + if (status == STATUS_SUCCESS) + { + close_adapter_desc.hAdapter = open_adapter_hdc_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected return code %#x.\n", status); + } +} + START_TEST(driver) { HMODULE gdi32 = LoadLibraryA("gdi32.dll"); pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32, "D3DKMTCloseAdapter"); pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromGdiDisplayName"); + pD3DKMTOpenAdapterFromHdc = (void *)GetProcAddress(gdi32, "D3DKMTOpenAdapterFromHdc"); test_D3DKMTOpenAdapterFromGdiDisplayName(); + test_D3DKMTOpenAdapterFromHdc(); FreeLibrary(gdi32); } -- 2.20.1

1 0

[PATCH v2 02/10] dxgi/tests: Add more IDXGISwapChain_Present tests.
by Zhiyi Zhang 20 May '19

20 May '19

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 167 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index b8ab0763dd..317cf31533 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -3990,9 +3990,13 @@ static void test_swapchain_parameters(void) static void test_swapchain_present(IUnknown *device, BOOL is_d3d12) { + static const DWORD flags[] = {0, DXGI_PRESENT_TEST}; + static const DWORD timeout = 2000; DXGI_SWAP_CHAIN_DESC swapchain_desc; IDXGISwapChain *swapchain; IDXGIFactory *factory; + IDXGIOutput *output; + BOOL fullscreen; unsigned int i; ULONG refcount; HRESULT hr; @@ -4027,6 +4031,169 @@ static void test_swapchain_present(IUnknown *device, BOOL is_d3d12) hr = IDXGISwapChain_Present(swapchain, 0, 0); ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + for (i = 0; i < ARRAY_SIZE(flags); ++i) + { + HWND occluding_hwnd = CreateWindowA("static", "occluding_window", WS_POPUP | WS_VISIBLE, 0, 0, 400, 200, 0, 0, 0, 0); + + /* Another window covers the swapchain window, doesn't report as occluded */ + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + /* Minimized window */ + ShowWindow(swapchain_desc.OutputWindow, SW_MINIMIZE); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + todo_wine_if(!is_d3d12) ok(hr == (is_d3d12 ? S_OK : DXGI_STATUS_OCCLUDED), "Got unexpected hr %#x.\n", hr); + ShowWindow(swapchain_desc.OutputWindow, SW_NORMAL); + + /* Hidden window */ + ShowWindow(swapchain_desc.OutputWindow, SW_HIDE); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ShowWindow(swapchain_desc.OutputWindow, SW_SHOW); + DestroyWindow(occluding_hwnd); + + /* Test IDXGIOutput_ReleaseOwnership makes the swapchain exit fullscreen */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + /* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE on some machines. DXGI_ERROR_UNSUPPORTED on Win 7 testbot. */ + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || broken(hr == DXGI_ERROR_UNSUPPORTED)) + { + skip("Could not change fullscreen state.\n"); + continue; + } + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + output = NULL; + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, &output); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + todo_wine_if(is_d3d12) ok(output != NULL, "Expect output not null.\n"); + + if (output) IDXGIOutput_ReleaseOwnership(output); + /* Still in fullscreen */ + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + /* Now calling IDXGISwapChain_Present will exit the fullscreen */ + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + /* Now fullscreen mode is exited */ + if (flags[i] == 0 && !is_d3d12) + { + /* Still on fullscreen on vista and 2008 */ + todo_wine ok(!fullscreen || broken(fullscreen), "Unexpected fullscreen status.\n"); + } + else + ok(fullscreen, "Unexpected fullscreen status.\n"); + if (output) IDXGIOutput_Release(output); + + + /* Test creating a window when swapchain is in fullscreen. + * The window should break the swapchain out of fullscreen mode on d3d10/11. + * d3d12 is different, new occluding window doesn't break swapchain out of fullscreen because d3d12 swapchain + * fullscreen mode doesn't take exclusive ownership over output, nor does it disable compositing. + * d3d12 fullscreen mode acts just like borderless fullscreen window mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + occluding_hwnd = CreateWindowA("static", "occluding_window", WS_POPUP, 0, 0, 400, 200, 0, 0, 0, 0); + /* Invisible window doesn't cause fullscreen mode to exit */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen status.\n"); + /* Visible but with bottom z-order window still cause fullscreen mode to exit */ + SetWindowPos(occluding_hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); + ShowWindow(occluding_hwnd, SW_SHOW); + /* Fullscreen mode takes a while to exit */ + Sleep(timeout); + + /* No longer fullscreen before calling IDXGISwapChain_Present except for d3d12 */ + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(!is_d3d12) ok(is_d3d12 ? fullscreen : !fullscreen, "Unexpected fullscreen status.\n"); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + todo_wine_if(is_d3d12) ok(hr == (is_d3d12 ? DXGI_STATUS_OCCLUDED : S_OK), "Got unexpected hr %#x.\n", hr); + + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + if (flags[i] == DXGI_PRESENT_TEST) + todo_wine_if(!is_d3d12) ok(is_d3d12 ? fullscreen : !fullscreen, "Unexpected fullscreen status.\n"); + else + todo_wine ok(!fullscreen, "Unexpected fullscreen status.\n"); + + /* Even though d3d12 doesn't exit fullscreen, a IDXGISwapChain_ResizeBuffers is still needed for subsequent + * IDXGISwapChain_Present calls to work, otherwise they will return DXGI_ERROR_INVALID_CALL */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + if (flags[i] == DXGI_PRESENT_TEST) + todo_wine_if(is_d3d12) ok(hr == (is_d3d12 ? DXGI_STATUS_OCCLUDED : S_OK), "Got unexpected hr %#x.\n", hr); + else + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + + /* Trying break out of fullscreen mode again. This time, don't call IDXGISwapChain_GetFullscreenState before + * IDXGISwapChain_Present */ + ShowWindow(occluding_hwnd, SW_HIDE); + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ShowWindow(occluding_hwnd, SW_SHOW); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + /* hr == S_OK on vista and 2008 */ + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + if (flags[i] == DXGI_PRESENT_TEST) + { + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + /* IDXGISwapChain_Present without flags refresh the occlusion state */ + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, 0); + todo_wine ok(hr == DXGI_STATUS_OCCLUDED || broken(hr == S_OK), "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, DXGI_PRESENT_TEST); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + else + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine ok(!fullscreen, "Unexpected fullscreen status.\n"); + + DestroyWindow(occluding_hwnd); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + hr = IDXGISwapChain_Present(swapchain, 0, flags[i]); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + IDXGISwapChain_ResizeBuffers(swapchain, 0, 0, 0, DXGI_FORMAT_UNKNOWN, 0); + } + wait_device_idle(device); IDXGISwapChain_Release(swapchain); -- 2.20.1

1 0

[PATCH v2 01/10] dxgi/tests: Add IDXGIOutput ownership tests.
by Zhiyi Zhang 20 May '19

20 May '19

Mostly to show that TakeOwnership and ReleaseOwnership are based on VidPN ownership. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v2: Poll results instead of using Sleep() whenever possible. D3DKMTOpenAdapterFromGdiDisplayName opens the adapter used by the swapchain. D3DKMTOpenAdapterFromLuid could not be used here because we need to know VidPnSourceId as well, which D3DKMTOpenAdapterFromLuid doesn't offer. dlls/dxgi/tests/dxgi.c | 224 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 223 insertions(+), 1 deletion(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 79e4bc0c15..b8ab0763dd 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -17,11 +17,15 @@ */ #include <assert.h> +#include "ntstatus.h" +#define WIN32_NO_STATUS #define COBJMACROS #include "initguid.h" #include "dxgi1_6.h" #include "d3d11.h" #include "d3d12.h" +#include "winternl.h" +#include "ddk/d3dkmthk.h" #include "wine/heap.h" #include "wine/test.h" @@ -36,6 +40,10 @@ static DEVMODEW registry_mode; static HRESULT (WINAPI *pCreateDXGIFactory1)(REFIID iid, void **factory); static HRESULT (WINAPI *pCreateDXGIFactory2)(UINT flags, REFIID iid, void **factory); +static NTSTATUS (WINAPI *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); +static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); +static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); + static PFN_D3D12_CREATE_DEVICE pD3D12CreateDevice; static PFN_D3D12_GET_DEBUG_INTERFACE pD3D12GetDebugInterface; @@ -43,6 +51,9 @@ static unsigned int use_adapter_idx; static BOOL use_warp_adapter; static BOOL use_mt = TRUE; +static const DWORD wait_timeout = 1000; +static const DWORD wait_step = 100; + static struct test_entry { void (*test)(void); @@ -113,6 +124,22 @@ static ULONG get_refcount(void *iface) return IUnknown_Release(unknown); } +#define wait_result1(func, arg1, expected, todo) \ + do \ + { \ + DWORD total_time = 0; \ + typeof(expected) got; \ + do \ + { \ + got = func(arg1); \ + if (got == expected) \ + break; \ + Sleep(wait_step); \ + total_time += wait_step; \ + } while (total_time < wait_timeout); \ + todo_wine_if(todo) ok(got == expected, "Expect %#x, got unexpected result %#x.\n", expected, got); \ + } while (0) + #define check_interface(a, b, c, d) check_interface_(__LINE__, a, b, c, d) static HRESULT check_interface_(unsigned int line, void *iface, REFIID iid, BOOL supported, BOOL is_broken) @@ -4985,6 +5012,194 @@ done: ok(!refcount, "Factory has %u references left.\n", refcount); } +static void test_output_ownership(IUnknown *device, BOOL is_d3d12) +{ + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP check_ownership_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + DXGI_SWAP_CHAIN_DESC swapchain_desc; + DXGI_OUTPUT_DESC output_desc; + ID3D12Device *d3d12_device; + IDXGISwapChain *swapchain; + IDXGIFactory4 *factory4; + IDXGIFactory *factory; + IDXGIAdapter *adapter; + IDXGIOutput *output; + BOOL fullscreen; + NTSTATUS status; + ULONG refcount; + LUID luid; + HRESULT hr; + + if (!pD3DKMTCheckVidPnExclusiveOwnership || pD3DKMTCheckVidPnExclusiveOwnership(NULL) == STATUS_PROCEDURE_NOT_FOUND + || !pD3DKMTCloseAdapter || !pD3DKMTOpenAdapterFromGdiDisplayName) + { + skip("Required functions are unavailable.\n"); + return; + } + + get_factory(device, is_d3d12, &factory); + + if (is_d3d12) + { + hr = ID3D12CommandQueue_GetDevice((ID3D12CommandQueue *)device, &IID_ID3D12Device, (void **)&d3d12_device); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + luid = ID3D12Device_GetAdapterLuid(d3d12_device); + ID3D12Device_Release(d3d12_device); + hr = IDXGIFactory_QueryInterface(factory, &IID_IDXGIFactory4, (void **)&factory4); + if (hr == E_NOINTERFACE) + { + skip("DXGI 1.4 unsupported.\n"); + IDXGIFactory_Release(factory); + return; + } + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + hr = IDXGIFactory4_EnumAdapterByLuid(factory4, luid, &IID_IDXGIAdapter, (void **)&adapter); + IDXGIFactory4_Release(factory4); + if (hr == DXGI_ERROR_NOT_FOUND) + { + skip("Wine doesn't support IDXGIFactory4_EnumAdapterByLuid.\n"); + IDXGIFactory_Release(factory); + return; + } + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + else + { + hr = IDXGIDevice_GetAdapter((IDXGIDevice *)device, &adapter); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + } + + hr = IDXGIAdapter_EnumOutputs(adapter, 0, &output); + IDXGIAdapter_Release(adapter); + if (hr == DXGI_ERROR_NOT_FOUND) + { + skip("Adapter doesn't have any outputs.\n"); + IDXGIFactory_Release(factory); + return; + } + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDXGIOutput_GetDesc(output, &output_desc); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + lstrcpyW(open_adapter_gdi_desc.DeviceName, output_desc.DeviceName); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + + check_ownership_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_ownership_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + + swapchain_desc.BufferDesc.Width = 800; + swapchain_desc.BufferDesc.Height = 600; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = is_d3d12 ? 2 : 1; + swapchain_desc.OutputWindow = CreateWindowA("static", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = is_d3d12 ? DXGI_SWAP_EFFECT_FLIP_DISCARD : DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + + hr = IDXGIFactory_CreateSwapChain(factory, device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + + /* Swapchain in fullscreen mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, output); + /* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE on some machines. DXGI_ERROR_UNSUPPORTED on Win 7 testbot. */ + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || broken(hr == DXGI_ERROR_UNSUPPORTED)) + { + skip("Failed to change fullscreen state.\n"); + goto done; + } + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen state.\n"); + if (is_d3d12) + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + else + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : E_INVALIDARG), "Got unexpected hr %#x.\n", hr); + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + /* Calling IDXGIOutput_ReleaseOwnership makes it unoccluded. So we can be confident about IDXGIOutput_TakeOwnership + * was called in IDXGISwapChain_SetFullscreenState */ + IDXGIOutput_ReleaseOwnership(output); + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : DXGI_ERROR_NOT_CURRENTLY_AVAILABLE), "Got unexpected hr %#x.\n", hr); + IDXGIOutput_ReleaseOwnership(output); + + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + /* So the following results shows that IDXGIOutput_TakeOwnership(output, device, TRUE) is used in + * SetFullscreenState(swapchain, TRUE, NULL) + * + * This make me believe the MSDN documentation is saying the opposite about the last parameter, + * "HRESULT TakeOwnership(IUnknown *pDevice, BOOL Exclusive); + * Name: Exclusive Type: BOOL + * Set to TRUE to enable other threads or applications to take ownership of the device; otherwise, set to FALSE." + * + * Reasons: + * 1. The parameter name is called 'Exclusive' + * 2. D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE) makes D3DKMTCheckVidPnExclusiveOwnership return + * STATUS_GRAPHICS_PRESENT_OCCLUDED. And D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_SHARED) makes + * D3DKMTCheckVidPnExclusiveOwnership return STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE. So the opposite mapping of + * what MSDN is saying is consistent with the tests. + */ + if (is_d3d12) + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + else + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : E_INVALIDARG), "Got unexpected hr %#x.\n", hr); + IDXGIOutput_ReleaseOwnership(output); + + /* Swapchain in windowed mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(!fullscreen, "Unexpected fullscreen state.\n"); + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + + hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : DXGI_ERROR_NOT_CURRENTLY_AVAILABLE), "Got unexpected hr %#x.\n", hr); + + hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + if (is_d3d12) + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + else + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_GRAPHICS_PRESENT_OCCLUDED, TRUE); + IDXGIOutput_ReleaseOwnership(output); + wait_result1(pD3DKMTCheckVidPnExclusiveOwnership, &check_ownership_desc, STATUS_SUCCESS, FALSE); + +done: + wait_device_idle(device); + + IDXGIOutput_Release(output); + IDXGISwapChain_Release(swapchain); + DestroyWindow(swapchain_desc.OutputWindow); + refcount = IDXGIFactory_Release(factory); + ok(refcount == !is_d3d12, "Got unexpected refcount %u.\n", refcount); + + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); +} + static void run_on_d3d10(void (*test_func)(IUnknown *device, BOOL is_d3d12)) { IDXGIDevice *device; @@ -5028,7 +5243,7 @@ static void run_on_d3d12(void (*test_func)(IUnknown *device, BOOL is_d3d12)) START_TEST(dxgi) { - HMODULE dxgi_module, d3d12_module; + HMODULE dxgi_module, d3d12_module, gdi32_module; BOOL enable_debug_layer = FALSE; unsigned int argc, i; ID3D12Debug *debug; @@ -5038,6 +5253,11 @@ START_TEST(dxgi) pCreateDXGIFactory1 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory1"); pCreateDXGIFactory2 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory2"); + gdi32_module = GetModuleHandleA("gdi32.dll"); + pD3DKMTCheckVidPnExclusiveOwnership = (void *)GetProcAddress(gdi32_module, "D3DKMTCheckVidPnExclusiveOwnership"); + pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32_module, "D3DKMTCloseAdapter"); + pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32_module, "D3DKMTOpenAdapterFromGdiDisplayName"); + registry_mode.dmSize = sizeof(registry_mode); ok(EnumDisplaySettingsW(NULL, ENUM_REGISTRY_SETTINGS, &registry_mode), "Failed to get display mode.\n"); @@ -5088,6 +5308,7 @@ START_TEST(dxgi) run_on_d3d10(test_swapchain_present); run_on_d3d10(test_swapchain_backbuffer_index); run_on_d3d10(test_swapchain_formats); + run_on_d3d10(test_output_ownership); if (!(d3d12_module = LoadLibraryA("d3d12.dll"))) { @@ -5108,6 +5329,7 @@ START_TEST(dxgi) run_on_d3d12(test_swapchain_present); run_on_d3d12(test_swapchain_backbuffer_index); run_on_d3d12(test_swapchain_formats); + run_on_d3d12(test_output_ownership); FreeLibrary(d3d12_module); } -- 2.20.1

1 0

[PATCH 1/2] mfplat: Return properties for system time source.
by Nikolay Sivov 20 May '19

20 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mfplat/main.c | 12 ++++++++++-- dlls/mfplat/tests/mfplat.c | 17 +++++++++++++++++ include/mfidl.idl | 6 ++++++ 3 files changed, 33 insertions(+), 2 deletions(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index e80408d2b2..77edabec2c 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -6633,9 +6633,17 @@ static HRESULT WINAPI system_time_source_GetState(IMFPresentationTimeSource *ifa static HRESULT WINAPI system_time_source_GetProperties(IMFPresentationTimeSource *iface, MFCLOCK_PROPERTIES *props) { - FIXME("%p, %p.\n", iface, props); + TRACE("%p, %p.\n", iface, props); - return E_NOTIMPL; + if (!props) + return E_POINTER; + + memset(props, 0, sizeof(*props)); + props->qwClockFrequency = MFCLOCK_FREQUENCY_HNS; + props->dwClockTolerance = MFCLOCK_TOLERANCE_UNKNOWN; + props->dwClockJitter = 1; + + return S_OK; } static HRESULT WINAPI system_time_source_GetUnderlyingClock(IMFPresentationTimeSource *iface, IMFClock **clock) diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index 7fa3ddd876..4adfb1b8ad 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -2542,6 +2542,7 @@ static void test_system_time_source(void) }; IMFPresentationTimeSource *time_source; IMFClockStateSink *statesink; + MFCLOCK_PROPERTIES props; MFCLOCK_STATE state; unsigned int i; DWORD value; @@ -2595,6 +2596,22 @@ static void test_system_time_source(void) IMFClockStateSink_Release(statesink); + /* Properties. */ + hr = IMFPresentationTimeSource_GetProperties(time_source, NULL); + ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); + + hr = IMFPresentationTimeSource_GetProperties(time_source, &props); + ok(hr == S_OK, "Failed to get clock properties, hr %#x.\n", hr); + + ok(props.qwCorrelationRate == 0, "Unexpected correlation rate %s.\n", + wine_dbgstr_longlong(props.qwCorrelationRate)); + ok(IsEqualGUID(&props.guidClockId, &GUID_NULL), "Unexpected clock id %s.\n", wine_dbgstr_guid(&props.guidClockId)); + ok(props.dwClockFlags == 0, "Unexpected flags %#x.\n", props.dwClockFlags); + ok(props.qwClockFrequency == MFCLOCK_FREQUENCY_HNS, "Unexpected frequency %s.\n", + wine_dbgstr_longlong(props.qwClockFrequency)); + ok(props.dwClockTolerance == MFCLOCK_TOLERANCE_UNKNOWN, "Unexpected tolerance %u.\n", props.dwClockTolerance); + ok(props.dwClockJitter == 1, "Unexpected jitter %u.\n", props.dwClockJitter); + IMFPresentationTimeSource_Release(time_source); } diff --git a/include/mfidl.idl b/include/mfidl.idl index a5882e98e5..2421c06f50 100644 --- a/include/mfidl.idl +++ b/include/mfidl.idl @@ -47,6 +47,12 @@ typedef enum MF_OBJECT_TYPE MF_OBJECT_INVALID } MF_OBJECT_TYPE; +cpp_quote("#define MFCLOCK_FREQUENCY_HNS 10000000") +cpp_quote("#define MFCLOCK_TOLERANCE_UNKNOWN 50000") +cpp_quote("#define MFCLOCK_JITTER_ISR 1000") +cpp_quote("#define MFCLOCK_JITTER_DPC 4000") +cpp_quote("#define MFCLOCK_JITTER_PASSIVE 10000") + typedef struct _MFCLOCK_PROPERTIES { unsigned __int64 qwCorrelationRate; -- 2.20.1

1 1

[v2 PATCH 1/5] mf: Add sample grabber sink stub.
by Nikolay Sivov 20 May '19

20 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/main.c | 2 +- dlls/mf/samplegrabber.c | 422 +++++++++++++++++++++++++++++++++++++++- dlls/mf/tests/mf.c | 139 ++++++++++++- include/mferror.h | 14 ++ include/mfidl.idl | 32 +++ 5 files changed, 602 insertions(+), 7 deletions(-) diff --git a/dlls/mf/main.c b/dlls/mf/main.c index b5b4b0e7c8..6db13f19db 100644 --- a/dlls/mf/main.c +++ b/dlls/mf/main.c @@ -395,7 +395,7 @@ static HRESULT WINAPI activate_object_ActivateObject(IMFActivate *iface, REFIID if (FAILED(hr = activate->funcs->create_object((IMFAttributes *)iface, activate->context, &object))) return hr; - if (!InterlockedCompareExchangePointer((void **)&activate->object, object, NULL)) + if (InterlockedCompareExchangePointer((void **)&activate->object, object, NULL)) IUnknown_Release(object); } diff --git a/dlls/mf/samplegrabber.c b/dlls/mf/samplegrabber.c index 7b3536467c..997c9db539 100644 --- a/dlls/mf/samplegrabber.c +++ b/dlls/mf/samplegrabber.c @@ -19,6 +19,7 @@ #define COBJMACROS #include "mfidl.h" +#include "mferror.h" #include "mf_private.h" #include "wine/debug.h" @@ -26,6 +27,24 @@ WINE_DEFAULT_DEBUG_CHANNEL(mfplat); +struct sample_grabber_stream +{ + IMFStreamSink IMFStreamSink_iface; + LONG refcount; + IMFMediaSink *sink; +}; + +struct sample_grabber +{ + IMFMediaSink IMFMediaSink_iface; + LONG refcount; + IMFSampleGrabberSinkCallback *callback; + IMFMediaType *media_type; + BOOL is_shut_down; + IMFStreamSink *stream; + CRITICAL_SECTION cs; +}; + struct sample_grabber_activate_context { IMFMediaType *media_type; @@ -40,13 +59,412 @@ static void sample_grabber_free_private(void *user_context) heap_free(context); } -static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj) +static struct sample_grabber *impl_from_IMFMediaSink(IMFMediaSink *iface) +{ + return CONTAINING_RECORD(iface, struct sample_grabber, IMFMediaSink_iface); +} + +static struct sample_grabber_stream *impl_from_IMFStreamSink(IMFStreamSink *iface) { - FIXME("%p, %p, %p.\n", attributes, user_context, obj); + return CONTAINING_RECORD(iface, struct sample_grabber_stream, IMFStreamSink_iface); +} + +static HRESULT WINAPI sample_grabber_stream_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IMFStreamSink) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = &stream->IMFStreamSink_iface; + } + else + { + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*obj); + + return S_OK; +} + +static ULONG WINAPI sample_grabber_stream_AddRef(IMFStreamSink *iface) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + ULONG refcount = InterlockedIncrement(&stream->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI sample_grabber_stream_Release(IMFStreamSink *iface) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + ULONG refcount = InterlockedDecrement(&stream->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + IMFMediaSink_Release(stream->sink); + heap_free(stream); + } + + return refcount; +} + +static HRESULT WINAPI sample_grabber_stream_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event) +{ + FIXME("%p, %#x, %p.\n", iface, flags, event); return E_NOTIMPL; } +static HRESULT WINAPI sample_grabber_stream_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, + IUnknown *state) +{ + FIXME("%p, %p, %p.\n", iface, callback, state); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result, + IMFMediaEvent **event) +{ + FIXME("%p, %p, %p.\n", iface, result, event); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_QueueEvent(IMFStreamSink *iface, MediaEventType event_type, + REFGUID ext_type, HRESULT hr, const PROPVARIANT *value) +{ + FIXME("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + + TRACE("%p, %p.\n", iface, sink); + + *sink = stream->sink; + IMFMediaSink_AddRef(*sink); + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_stream_GetIdentifier(IMFStreamSink *iface, DWORD *identifier) +{ + TRACE("%p, %p.\n", iface, identifier); + + *identifier = 0; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_stream_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler) +{ + FIXME("%p, %p.\n", iface, handler); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_ProcessSample(IMFStreamSink *iface, IMFSample *sample) +{ + FIXME("%p, %p.\n", iface, sample); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type, + const PROPVARIANT *marker_value, const PROPVARIANT *context_value) +{ + FIXME("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_Flush(IMFStreamSink *iface) +{ + FIXME("%p.\n", iface); + + return E_NOTIMPL; +} + +static const IMFStreamSinkVtbl sample_grabber_stream_vtbl = +{ + sample_grabber_stream_QueryInterface, + sample_grabber_stream_AddRef, + sample_grabber_stream_Release, + sample_grabber_stream_GetEvent, + sample_grabber_stream_BeginGetEvent, + sample_grabber_stream_EndGetEvent, + sample_grabber_stream_QueueEvent, + sample_grabber_stream_GetMediaSink, + sample_grabber_stream_GetIdentifier, + sample_grabber_stream_GetMediaTypeHandler, + sample_grabber_stream_ProcessSample, + sample_grabber_stream_PlaceMarker, + sample_grabber_stream_Flush, +}; + +static HRESULT WINAPI sample_grabber_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IMFMediaSink) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = &grabber->IMFMediaSink_iface; + } + else + { + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*obj); + + return S_OK; +} + +static ULONG WINAPI sample_grabber_sink_AddRef(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + ULONG refcount = InterlockedIncrement(&grabber->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI sample_grabber_sink_Release(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + ULONG refcount = InterlockedDecrement(&grabber->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + IMFSampleGrabberSinkCallback_Release(grabber->callback); + IMFMediaType_Release(grabber->media_type); + DeleteCriticalSection(&grabber->cs); + heap_free(grabber); + } + + return refcount; +} + +static HRESULT WINAPI sample_grabber_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %p.\n", iface, flags); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + *flags = MEDIASINK_FIXED_STREAMS; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id, + IMFMediaType *media_type, IMFStreamSink **stream_sink) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink); + + return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED; +} + +static HRESULT WINAPI sample_grabber_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %#x.\n", iface, stream_sink_id); + + return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %p.\n", iface, count); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + *count = 1; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index, + IMFStreamSink **stream) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + HRESULT hr = S_OK; + + TRACE("%p, %u, %p.\n", iface, index, stream); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + EnterCriticalSection(&grabber->cs); + + if (grabber->is_shut_down) + hr = MF_E_SHUTDOWN; + else if (index > 0) + hr = MF_E_INVALIDINDEX; + else + { + *stream = grabber->stream; + IMFStreamSink_AddRef(*stream); + } + + LeaveCriticalSection(&grabber->cs); + + return hr; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id, + IMFStreamSink **stream) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + HRESULT hr = S_OK; + + TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream); + + EnterCriticalSection(&grabber->cs); + + if (grabber->is_shut_down) + hr = MF_E_SHUTDOWN; + else if (stream_sink_id > 0) + hr = MF_E_INVALIDSTREAMNUMBER; + else + { + *stream = grabber->stream; + IMFStreamSink_AddRef(*stream); + } + + LeaveCriticalSection(&grabber->cs); + + return hr; +} + +static HRESULT WINAPI sample_grabber_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock) +{ + FIXME("%p, %p.\n", iface, clock); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock) +{ + FIXME("%p, %p.\n", iface, clock); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_sink_Shutdown(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p.\n", iface); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + EnterCriticalSection(&grabber->cs); + grabber->is_shut_down = TRUE; + IMFStreamSink_Release(grabber->stream); + grabber->stream = NULL; + EnterCriticalSection(&grabber->cs); + + return E_NOTIMPL; +} + +static const IMFMediaSinkVtbl sample_grabber_sink_vtbl = +{ + sample_grabber_sink_QueryInterface, + sample_grabber_sink_AddRef, + sample_grabber_sink_Release, + sample_grabber_sink_GetCharacteristics, + sample_grabber_sink_AddStreamSink, + sample_grabber_sink_RemoveStreamSink, + sample_grabber_sink_GetStreamSinkCount, + sample_grabber_sink_GetStreamSinkByIndex, + sample_grabber_sink_GetStreamSinkById, + sample_grabber_sink_SetPresentationClock, + sample_grabber_sink_GetPresentationClock, + sample_grabber_sink_Shutdown, +}; + +static HRESULT sample_grabber_create_stream(IMFMediaSink *sink, IMFStreamSink **stream) +{ + struct sample_grabber_stream *object; + + object = heap_alloc_zero(sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + object->IMFStreamSink_iface.lpVtbl = &sample_grabber_stream_vtbl; + object->refcount = 1; + object->sink = sink; + IMFMediaSink_AddRef(object->sink); + + *stream = &object->IMFStreamSink_iface; + + return S_OK; +} + +static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj) +{ + struct sample_grabber_activate_context *context = user_context; + struct sample_grabber *object; + HRESULT hr; + + TRACE("%p, %p, %p.\n", attributes, user_context, obj); + + object = heap_alloc_zero(sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + object->IMFMediaSink_iface.lpVtbl = &sample_grabber_sink_vtbl; + object->refcount = 1; + object->callback = context->callback; + IMFSampleGrabberSinkCallback_AddRef(object->callback); + object->media_type = context->media_type; + IMFMediaType_AddRef(object->media_type); + InitializeCriticalSection(&object->cs); + if (FAILED(hr = sample_grabber_create_stream(&object->IMFMediaSink_iface, &object->stream))) + { + IMFMediaSink_Release(&object->IMFMediaSink_iface); + return hr; + } + + *obj = (IUnknown *)&object->IMFMediaSink_iface; + + TRACE("Created %p.\n", *obj); + + return S_OK; +} + static const struct activate_funcs sample_grabber_activate_funcs = { sample_grabber_create_object, diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index 37bcb8d029..2987e86f4b 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -1230,7 +1230,6 @@ todo_wine ok(hr == MF_E_TOPO_SINK_ACTIVATES_UNSUPPORTED, "Unexpected hr %#x.\n", hr); hr = IMFActivate_ActivateObject(sink_activate, &IID_IMFMediaSink, (void **)&sink); -todo_wine ok(hr == S_OK, "Failed to activate, hr %#x.\n", hr); hr = IMFTopologyNode_SetObject(sink_node, (IUnknown *)sink); @@ -1639,9 +1638,16 @@ static IMFSampleGrabberSinkCallback grabber_callback = { &grabber_callback_vtbl static void test_sample_grabber(void) { + IMFMediaTypeHandler *handler, *handler2; + IMFStreamSink *stream, *stream2; + IMFClockStateSink *clocksink; + IMFMediaEventGenerator *eg; + IMFMediaSink *sink, *sink2; IMFMediaType *media_type; + DWORD flags, count, id; IMFActivate *activate; ULONG refcount; + IUnknown *unk; HRESULT hr; hr = MFCreateMediaType(&media_type); @@ -1656,10 +1662,135 @@ static void test_sample_grabber(void) hr = MFCreateSampleGrabberSinkActivate(media_type, &grabber_callback, &activate); ok(hr == S_OK, "Failed to create grabber activate, hr %#x.\n", hr); - refcount = IMFMediaType_Release(media_type); - ok(refcount == 1, "Unexpected refcount %u.\n", refcount); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFActivate_ActivateObject(activate, &IID_IMFMediaSink, (void **)&sink); + ok(hr == S_OK, "Failed to activate object, hr %#x.\n", hr); + + hr = IMFMediaSink_GetCharacteristics(sink, &flags); + ok(hr == S_OK, "Failed to get sink flags, hr %#x.\n", hr); + ok(flags & MEDIASINK_FIXED_STREAMS, "Unexpected flags %#x.\n", flags); + + hr = IMFMediaSink_GetStreamSinkCount(sink, &count); + ok(hr == S_OK, "Failed to get stream count, hr %#x.\n", hr); + ok(count == 1, "Unexpected stream count %u.\n", count); + + EXPECT_REF(sink, 3); + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 0, &stream); + ok(hr == S_OK, "Failed to get sink stream, hr %#x.\n", hr); + EXPECT_REF(sink, 3); + EXPECT_REF(stream, 2); + + hr = IMFStreamSink_GetIdentifier(stream, &id); + ok(hr == S_OK, "Failed to get stream id, hr %#x.\n", hr); + ok(id == 0, "Unexpected id %#x.\n", id); + + hr = IMFStreamSink_GetMediaSink(stream, &sink2); + ok(hr == S_OK, "Failed to get media sink, hr %x.\n", hr); + ok(sink2 == sink, "Unexpected sink.\n"); + IMFMediaSink_Release(sink2); + + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 1, &stream2); + ok(hr == MF_E_INVALIDINDEX, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkById(sink, 1, &stream2); + ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_AddStreamSink(sink, 1, NULL, &stream2); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_RemoveStreamSink(sink, 0); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); - IMFActivate_Release(activate); + hr = IMFMediaSink_RemoveStreamSink(sink, 1); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFClockStateSink, (void **)&clocksink); +todo_wine + ok(hr == S_OK, "Failed to get interface, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + IMFClockStateSink_Release(clocksink); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFMediaEventGenerator, (void **)&eg); +todo_wine + ok(hr == S_OK, "Failed to get interface, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + IMFMediaEventGenerator_Release(eg); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFPresentationTimeSource, (void **)&unk); + ok(hr == E_NOINTERFACE, "Unexpected hr %#x.\n", hr); + + hr = IMFStreamSink_QueryInterface(stream, &IID_IMFMediaTypeHandler, (void **)&handler2); +todo_wine + ok(hr == S_OK, "Failed to get handler interface, hr %#x.\n", hr); + + if (SUCCEEDED(hr)) + { + hr = IMFStreamSink_GetMediaTypeHandler(stream, &handler); + ok(hr == S_OK, "Failed to get type handler, hr %#x.\n", hr); + hr = IMFMediaTypeHandler_GetMediaTypeCount(handler, &count); + ok(hr == S_OK, "Failed to get media type count, hr %#x.\n", hr); + ok(count == 0, "Unexpected count %u.\n", count); + + ok(handler == handler2, "Unexpected handler.\n"); + + IMFMediaTypeHandler_Release(handler); + IMFMediaTypeHandler_Release(handler2); + } + + hr = IMFActivate_ShutdownObject(activate); +todo_wine + ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr); + + hr = IMFMediaSink_Shutdown(sink); + ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_Shutdown(sink); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetCharacteristics(sink, &flags); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_AddStreamSink(sink, 1, NULL, &stream2); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkCount(sink, &count); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 0, &stream2); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFStreamSink_GetMediaSink(stream, &sink2); + ok(hr == S_OK, "Failed to get media sink, hr %x.\n", hr); + ok(sink2 == sink, "Unexpected sink.\n"); + IMFMediaSink_Release(sink2); + + hr = IMFStreamSink_GetIdentifier(stream, &id); + ok(hr == S_OK, "Failed to get stream id, hr %#x.\n", hr); + ok(id == 0, "Unexpected id %#x.\n", id); + + hr = IMFStreamSink_GetMediaTypeHandler(stream, &handler); +todo_wine + ok(hr == S_OK, "Failed to get type handler, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + { + hr = IMFMediaTypeHandler_GetMediaTypeCount(handler, &count); + ok(hr == S_OK, "Failed to get media type count, hr %#x.\n", hr); + ok(count == 0, "Unexpected count %u.\n", count); + + IMFMediaTypeHandler_Release(handler); + } + + IMFMediaSink_Release(sink); + IMFStreamSink_Release(stream); + + refcount = IMFActivate_Release(activate); + ok(!refcount, "Unexpected refcount %u.\n", refcount); + + IMFMediaType_Release(media_type); } START_TEST(mf) diff --git a/include/mferror.h b/include/mferror.h index a0acf90f8b..4d3a530734 100644 --- a/include/mferror.h +++ b/include/mferror.h @@ -94,6 +94,20 @@ #define MF_E_MEDIA_SOURCE_NO_STREAMS_SELECTED _HRESULT_TYPEDEF_(0xc00d3e9c) #define MF_E_UNSUPPORTED_CHARACTERISTICS _HRESULT_TYPEDEF_(0xc00d3e9e) +#define MF_E_STREAMSINK_REMOVED _HRESULT_TYPEDEF_(0xc00d4a38) +#define MF_E_STREAMSINKS_OUT_OF_SYNC _HRESULT_TYPEDEF_(0xc00d4a3a) +#define MF_E_STREAMSINKS_FIXED _HRESULT_TYPEDEF_(0xc00d4a3b) +#define MF_E_STREAMSINK_EXISTS _HRESULT_TYPEDEF_(0xc00d4a3c) +#define MF_E_SAMPLEALLOCATOR_CANCELED _HRESULT_TYPEDEF_(0xc00d4a3d) +#define MF_E_SAMPLEALLOCATOR_EMPTY _HRESULT_TYPEDEF_(0xc00d4a3e) +#define MF_E_SINK_ALREADYSTOPPED _HRESULT_TYPEDEF_(0xc00d4a3f) +#define MF_E_ASF_FILESINK_BITRATE_UNKNOWN _HRESULT_TYPEDEF_(0xc00d4a40) +#define MF_E_SINK_NO_STREAMS _HRESULT_TYPEDEF_(0xc00d4a41) +#define MF_S_SINK_NOT_FINALIZED _HRESULT_TYPEDEF_(0x000d4a42) +#define MF_E_METADATA_TOO_LONG _HRESULT_TYPEDEF_(0xc00d4a43) +#define MF_E_SINK_NO_SAMPLES_PROCESSED _HRESULT_TYPEDEF_(0xc00d4a44) +#define MF_E_SINK_HEADERS_NOT_FOUND _HRESULT_TYPEDEF_(0xc00d4a45) + #define MF_E_TOPO_INVALID_OPTIONAL_NODE _HRESULT_TYPEDEF_(0xc00d520e) #define MF_E_TOPO_CANNOT_FIND_DECRYPTOR _HRESULT_TYPEDEF_(0xc00d5211) #define MF_E_TOPO_CODEC_NOT_FOUND _HRESULT_TYPEDEF_(0xc00d5212) diff --git a/include/mfidl.idl b/include/mfidl.idl index c024e67378..a5882e98e5 100644 --- a/include/mfidl.idl +++ b/include/mfidl.idl @@ -83,6 +83,14 @@ typedef enum _MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS = 0x00000002, } MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS; +typedef enum _MFSTREAMSINK_MARKER_TYPE +{ + MFSTREAMSINK_MARKER_DEFAULT, + MFSTREAMSINK_MARKER_ENDOFSEGMENT, + MFSTREAMSINK_MARKER_TICK, + MFSTREAMSINK_MARKER_EVENT, +} MFSTREAMSINK_MARKER_TYPE; + [ object, uuid(2eb1e945-18b8-4139-9b1a-d5d584818530), @@ -646,6 +654,13 @@ interface IMFPresentationClock : IMFClock HRESULT Pause(); } +cpp_quote("#define MEDIASINK_FIXED_STREAMS 0x00000001") +cpp_quote("#define MEDIASINK_CANNOT_MATCH_CLOCK 0x00000002") +cpp_quote("#define MEDIASINK_RATELESS 0x00000004") +cpp_quote("#define MEDIASINK_CLOCK_REQUIRED 0x00000008") +cpp_quote("#define MEDIASINK_CAN_PREROLL 0x00000010") +cpp_quote("#define MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE 0x00000020") + [ object, uuid(6ef2a660-47c0-4666-b13d-cbb717f2fa2c) @@ -666,6 +681,23 @@ interface IMFMediaSink : IUnknown HRESULT Shutdown(); } +[ + object, + uuid(0a97b3cf-8e7c-4a3d-8f8c-0c843dc247fb), +] +interface IMFStreamSink : IMFMediaEventGenerator +{ + HRESULT GetMediaSink([out] IMFMediaSink **sink); + HRESULT GetIdentifier([out] DWORD *identifier); + HRESULT GetMediaTypeHandler([out] IMFMediaTypeHandler **handler); + HRESULT ProcessSample([in] IMFSample *sample); + HRESULT PlaceMarker( + [in] MFSTREAMSINK_MARKER_TYPE marker_type, + [in] const PROPVARIANT *marker_value, + [in] const PROPVARIANT *context_value); + HRESULT Flush(); +} + typedef enum _MFSHUTDOWN_STATUS { MFSHUTDOWN_INITIATED, -- 2.20.1

1 4

[PATCH 1/5] mf: Add sample grabber sink stub.
by Nikolay Sivov 20 May '19

20 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/main.c | 2 +- dlls/mf/samplegrabber.c | 422 +++++++++++++++++++++++++++++++++++++++- dlls/mf/tests/mf.c | 143 +++++++++++++- include/mferror.h | 14 ++ include/mfidl.idl | 32 +++ 5 files changed, 606 insertions(+), 7 deletions(-) diff --git a/dlls/mf/main.c b/dlls/mf/main.c index b5b4b0e7c8..6db13f19db 100644 --- a/dlls/mf/main.c +++ b/dlls/mf/main.c @@ -395,7 +395,7 @@ static HRESULT WINAPI activate_object_ActivateObject(IMFActivate *iface, REFIID if (FAILED(hr = activate->funcs->create_object((IMFAttributes *)iface, activate->context, &object))) return hr; - if (!InterlockedCompareExchangePointer((void **)&activate->object, object, NULL)) + if (InterlockedCompareExchangePointer((void **)&activate->object, object, NULL)) IUnknown_Release(object); } diff --git a/dlls/mf/samplegrabber.c b/dlls/mf/samplegrabber.c index 7b3536467c..997c9db539 100644 --- a/dlls/mf/samplegrabber.c +++ b/dlls/mf/samplegrabber.c @@ -19,6 +19,7 @@ #define COBJMACROS #include "mfidl.h" +#include "mferror.h" #include "mf_private.h" #include "wine/debug.h" @@ -26,6 +27,24 @@ WINE_DEFAULT_DEBUG_CHANNEL(mfplat); +struct sample_grabber_stream +{ + IMFStreamSink IMFStreamSink_iface; + LONG refcount; + IMFMediaSink *sink; +}; + +struct sample_grabber +{ + IMFMediaSink IMFMediaSink_iface; + LONG refcount; + IMFSampleGrabberSinkCallback *callback; + IMFMediaType *media_type; + BOOL is_shut_down; + IMFStreamSink *stream; + CRITICAL_SECTION cs; +}; + struct sample_grabber_activate_context { IMFMediaType *media_type; @@ -40,13 +59,412 @@ static void sample_grabber_free_private(void *user_context) heap_free(context); } -static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj) +static struct sample_grabber *impl_from_IMFMediaSink(IMFMediaSink *iface) +{ + return CONTAINING_RECORD(iface, struct sample_grabber, IMFMediaSink_iface); +} + +static struct sample_grabber_stream *impl_from_IMFStreamSink(IMFStreamSink *iface) { - FIXME("%p, %p, %p.\n", attributes, user_context, obj); + return CONTAINING_RECORD(iface, struct sample_grabber_stream, IMFStreamSink_iface); +} + +static HRESULT WINAPI sample_grabber_stream_QueryInterface(IMFStreamSink *iface, REFIID riid, void **obj) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IMFStreamSink) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = &stream->IMFStreamSink_iface; + } + else + { + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*obj); + + return S_OK; +} + +static ULONG WINAPI sample_grabber_stream_AddRef(IMFStreamSink *iface) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + ULONG refcount = InterlockedIncrement(&stream->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI sample_grabber_stream_Release(IMFStreamSink *iface) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + ULONG refcount = InterlockedDecrement(&stream->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + IMFMediaSink_Release(stream->sink); + heap_free(stream); + } + + return refcount; +} + +static HRESULT WINAPI sample_grabber_stream_GetEvent(IMFStreamSink *iface, DWORD flags, IMFMediaEvent **event) +{ + FIXME("%p, %#x, %p.\n", iface, flags, event); return E_NOTIMPL; } +static HRESULT WINAPI sample_grabber_stream_BeginGetEvent(IMFStreamSink *iface, IMFAsyncCallback *callback, + IUnknown *state) +{ + FIXME("%p, %p, %p.\n", iface, callback, state); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_EndGetEvent(IMFStreamSink *iface, IMFAsyncResult *result, + IMFMediaEvent **event) +{ + FIXME("%p, %p, %p.\n", iface, result, event); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_QueueEvent(IMFStreamSink *iface, MediaEventType event_type, + REFGUID ext_type, HRESULT hr, const PROPVARIANT *value) +{ + FIXME("%p, %u, %s, %#x, %p.\n", iface, event_type, debugstr_guid(ext_type), hr, value); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_GetMediaSink(IMFStreamSink *iface, IMFMediaSink **sink) +{ + struct sample_grabber_stream *stream = impl_from_IMFStreamSink(iface); + + TRACE("%p, %p.\n", iface, sink); + + *sink = stream->sink; + IMFMediaSink_AddRef(*sink); + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_stream_GetIdentifier(IMFStreamSink *iface, DWORD *identifier) +{ + TRACE("%p, %p.\n", iface, identifier); + + *identifier = 0; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_stream_GetMediaTypeHandler(IMFStreamSink *iface, IMFMediaTypeHandler **handler) +{ + FIXME("%p, %p.\n", iface, handler); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_ProcessSample(IMFStreamSink *iface, IMFSample *sample) +{ + FIXME("%p, %p.\n", iface, sample); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_PlaceMarker(IMFStreamSink *iface, MFSTREAMSINK_MARKER_TYPE marker_type, + const PROPVARIANT *marker_value, const PROPVARIANT *context_value) +{ + FIXME("%p, %d, %p, %p.\n", iface, marker_type, marker_value, context_value); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_stream_Flush(IMFStreamSink *iface) +{ + FIXME("%p.\n", iface); + + return E_NOTIMPL; +} + +static const IMFStreamSinkVtbl sample_grabber_stream_vtbl = +{ + sample_grabber_stream_QueryInterface, + sample_grabber_stream_AddRef, + sample_grabber_stream_Release, + sample_grabber_stream_GetEvent, + sample_grabber_stream_BeginGetEvent, + sample_grabber_stream_EndGetEvent, + sample_grabber_stream_QueueEvent, + sample_grabber_stream_GetMediaSink, + sample_grabber_stream_GetIdentifier, + sample_grabber_stream_GetMediaTypeHandler, + sample_grabber_stream_ProcessSample, + sample_grabber_stream_PlaceMarker, + sample_grabber_stream_Flush, +}; + +static HRESULT WINAPI sample_grabber_sink_QueryInterface(IMFMediaSink *iface, REFIID riid, void **obj) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IMFMediaSink) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = &grabber->IMFMediaSink_iface; + } + else + { + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*obj); + + return S_OK; +} + +static ULONG WINAPI sample_grabber_sink_AddRef(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + ULONG refcount = InterlockedIncrement(&grabber->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI sample_grabber_sink_Release(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + ULONG refcount = InterlockedDecrement(&grabber->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + IMFSampleGrabberSinkCallback_Release(grabber->callback); + IMFMediaType_Release(grabber->media_type); + DeleteCriticalSection(&grabber->cs); + heap_free(grabber); + } + + return refcount; +} + +static HRESULT WINAPI sample_grabber_sink_GetCharacteristics(IMFMediaSink *iface, DWORD *flags) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %p.\n", iface, flags); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + *flags = MEDIASINK_FIXED_STREAMS; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_sink_AddStreamSink(IMFMediaSink *iface, DWORD stream_sink_id, + IMFMediaType *media_type, IMFStreamSink **stream_sink) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %#x, %p, %p.\n", iface, stream_sink_id, media_type, stream_sink); + + return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED; +} + +static HRESULT WINAPI sample_grabber_sink_RemoveStreamSink(IMFMediaSink *iface, DWORD stream_sink_id) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %#x.\n", iface, stream_sink_id); + + return grabber->is_shut_down ? MF_E_SHUTDOWN : MF_E_STREAMSINKS_FIXED; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkCount(IMFMediaSink *iface, DWORD *count) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p, %p.\n", iface, count); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + *count = 1; + + return S_OK; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkByIndex(IMFMediaSink *iface, DWORD index, + IMFStreamSink **stream) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + HRESULT hr = S_OK; + + TRACE("%p, %u, %p.\n", iface, index, stream); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + EnterCriticalSection(&grabber->cs); + + if (grabber->is_shut_down) + hr = MF_E_SHUTDOWN; + else if (index > 0) + hr = MF_E_INVALIDINDEX; + else + { + *stream = grabber->stream; + IMFStreamSink_AddRef(*stream); + } + + LeaveCriticalSection(&grabber->cs); + + return hr; +} + +static HRESULT WINAPI sample_grabber_sink_GetStreamSinkById(IMFMediaSink *iface, DWORD stream_sink_id, + IMFStreamSink **stream) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + HRESULT hr = S_OK; + + TRACE("%p, %#x, %p.\n", iface, stream_sink_id, stream); + + EnterCriticalSection(&grabber->cs); + + if (grabber->is_shut_down) + hr = MF_E_SHUTDOWN; + else if (stream_sink_id > 0) + hr = MF_E_INVALIDSTREAMNUMBER; + else + { + *stream = grabber->stream; + IMFStreamSink_AddRef(*stream); + } + + LeaveCriticalSection(&grabber->cs); + + return hr; +} + +static HRESULT WINAPI sample_grabber_sink_SetPresentationClock(IMFMediaSink *iface, IMFPresentationClock *clock) +{ + FIXME("%p, %p.\n", iface, clock); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_sink_GetPresentationClock(IMFMediaSink *iface, IMFPresentationClock **clock) +{ + FIXME("%p, %p.\n", iface, clock); + + return E_NOTIMPL; +} + +static HRESULT WINAPI sample_grabber_sink_Shutdown(IMFMediaSink *iface) +{ + struct sample_grabber *grabber = impl_from_IMFMediaSink(iface); + + TRACE("%p.\n", iface); + + if (grabber->is_shut_down) + return MF_E_SHUTDOWN; + + EnterCriticalSection(&grabber->cs); + grabber->is_shut_down = TRUE; + IMFStreamSink_Release(grabber->stream); + grabber->stream = NULL; + EnterCriticalSection(&grabber->cs); + + return E_NOTIMPL; +} + +static const IMFMediaSinkVtbl sample_grabber_sink_vtbl = +{ + sample_grabber_sink_QueryInterface, + sample_grabber_sink_AddRef, + sample_grabber_sink_Release, + sample_grabber_sink_GetCharacteristics, + sample_grabber_sink_AddStreamSink, + sample_grabber_sink_RemoveStreamSink, + sample_grabber_sink_GetStreamSinkCount, + sample_grabber_sink_GetStreamSinkByIndex, + sample_grabber_sink_GetStreamSinkById, + sample_grabber_sink_SetPresentationClock, + sample_grabber_sink_GetPresentationClock, + sample_grabber_sink_Shutdown, +}; + +static HRESULT sample_grabber_create_stream(IMFMediaSink *sink, IMFStreamSink **stream) +{ + struct sample_grabber_stream *object; + + object = heap_alloc_zero(sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + object->IMFStreamSink_iface.lpVtbl = &sample_grabber_stream_vtbl; + object->refcount = 1; + object->sink = sink; + IMFMediaSink_AddRef(object->sink); + + *stream = &object->IMFStreamSink_iface; + + return S_OK; +} + +static HRESULT sample_grabber_create_object(IMFAttributes *attributes, void *user_context, IUnknown **obj) +{ + struct sample_grabber_activate_context *context = user_context; + struct sample_grabber *object; + HRESULT hr; + + TRACE("%p, %p, %p.\n", attributes, user_context, obj); + + object = heap_alloc_zero(sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + object->IMFMediaSink_iface.lpVtbl = &sample_grabber_sink_vtbl; + object->refcount = 1; + object->callback = context->callback; + IMFSampleGrabberSinkCallback_AddRef(object->callback); + object->media_type = context->media_type; + IMFMediaType_AddRef(object->media_type); + InitializeCriticalSection(&object->cs); + if (FAILED(hr = sample_grabber_create_stream(&object->IMFMediaSink_iface, &object->stream))) + { + IMFMediaSink_Release(&object->IMFMediaSink_iface); + return hr; + } + + *obj = (IUnknown *)&object->IMFMediaSink_iface; + + TRACE("Created %p.\n", *obj); + + return S_OK; +} + static const struct activate_funcs sample_grabber_activate_funcs = { sample_grabber_create_object, diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index 37bcb8d029..f2895d5bd3 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -1230,7 +1230,6 @@ todo_wine ok(hr == MF_E_TOPO_SINK_ACTIVATES_UNSUPPORTED, "Unexpected hr %#x.\n", hr); hr = IMFActivate_ActivateObject(sink_activate, &IID_IMFMediaSink, (void **)&sink); -todo_wine ok(hr == S_OK, "Failed to activate, hr %#x.\n", hr); hr = IMFTopologyNode_SetObject(sink_node, (IUnknown *)sink); @@ -1639,9 +1638,16 @@ static IMFSampleGrabberSinkCallback grabber_callback = { &grabber_callback_vtbl static void test_sample_grabber(void) { + IMFMediaTypeHandler *handler, *handler2; + IMFStreamSink *stream, *stream2; + IMFClockStateSink *clocksink; + IMFMediaEventGenerator *eg; + IMFMediaSink *sink, *sink2; IMFMediaType *media_type; + DWORD flags, count, id; IMFActivate *activate; ULONG refcount; + IUnknown *unk; HRESULT hr; hr = MFCreateMediaType(&media_type); @@ -1656,10 +1662,139 @@ static void test_sample_grabber(void) hr = MFCreateSampleGrabberSinkActivate(media_type, &grabber_callback, &activate); ok(hr == S_OK, "Failed to create grabber activate, hr %#x.\n", hr); - refcount = IMFMediaType_Release(media_type); - ok(refcount == 1, "Unexpected refcount %u.\n", refcount); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFActivate_ActivateObject(activate, &IID_IMFMediaSink, (void **)&sink); + ok(hr == S_OK, "Failed to activate object, hr %#x.\n", hr); + + hr = IMFMediaSink_GetCharacteristics(sink, &flags); + ok(hr == S_OK, "Failed to get sink flags, hr %#x.\n", hr); + ok(flags & MEDIASINK_FIXED_STREAMS, "Unexpected flags %#x.\n", flags); + + hr = IMFMediaSink_GetStreamSinkCount(sink, &count); + ok(hr == S_OK, "Failed to get stream count, hr %#x.\n", hr); + ok(count == 1, "Unexpected stream count %u.\n", count); + + EXPECT_REF(sink, 3); + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 0, &stream); + ok(hr == S_OK, "Failed to get sink stream, hr %#x.\n", hr); + EXPECT_REF(sink, 3); + EXPECT_REF(stream, 2); + + hr = IMFStreamSink_GetIdentifier(stream, &id); + ok(hr == S_OK, "Failed to get stream id, hr %#x.\n", hr); + ok(id == 0, "Unexpected id %#x.\n", id); + + hr = IMFStreamSink_GetMediaSink(stream, &sink2); + ok(hr == S_OK, "Failed to get media sink, hr %x.\n", hr); + ok(sink2 == sink, "Unexpected sink.\n"); + IMFMediaSink_Release(sink2); + + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 1, &stream2); + ok(hr == MF_E_INVALIDINDEX, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkById(sink, 1, &stream2); + ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_AddStreamSink(sink, 1, NULL, &stream2); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_RemoveStreamSink(sink, 0); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_RemoveStreamSink(sink, 1); + ok(hr == MF_E_STREAMSINKS_FIXED, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFClockStateSink, (void **)&clocksink); +todo_wine + ok(hr == S_OK, "Failed to get interface, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + IMFClockStateSink_Release(clocksink); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFMediaEventGenerator, (void **)&eg); +todo_wine + ok(hr == S_OK, "Failed to get interface, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + IMFMediaEventGenerator_Release(eg); + + hr = IMFMediaSink_QueryInterface(sink, &IID_IMFPresentationTimeSource, (void **)&unk); + ok(hr == E_NOINTERFACE, "Unexpected hr %#x.\n", hr); + + hr = IMFStreamSink_QueryInterface(stream, &IID_IMFMediaTypeHandler, (void **)&handler2); +todo_wine + ok(hr == S_OK, "Failed to get handler interface, hr %#x.\n", hr); + + if (SUCCEEDED(hr)) + { + hr = IMFStreamSink_GetMediaTypeHandler(stream, &handler); + ok(hr == S_OK, "Failed to get type handler, hr %#x.\n", hr); + hr = IMFMediaTypeHandler_GetMediaTypeCount(handler, &count); + ok(hr == S_OK, "Failed to get media type count, hr %#x.\n", hr); + ok(count == 0, "Unexpected count %u.\n", count); - IMFActivate_Release(activate); + ok(handler == handler2, "Unexpected handler.\n"); + + IMFMediaTypeHandler_Release(handler); + IMFMediaTypeHandler_Release(handler2); + } + + hr = IMFActivate_ShutdownObject(activate); +todo_wine + ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr); + + hr = IMFMediaSink_Shutdown(sink); + ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_Shutdown(sink); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetCharacteristics(sink, &flags); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_AddStreamSink(sink, 1, NULL, &stream2); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkCount(sink, &count); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFMediaSink_GetStreamSinkByIndex(sink, 0, &stream2); + ok(hr == MF_E_SHUTDOWN, "Unexpected hr %#x.\n", hr); + + hr = IMFStreamSink_GetMediaSink(stream, &sink2); + ok(hr == S_OK, "Failed to get media sink, hr %x.\n", hr); + ok(sink2 == sink, "Unexpected sink.\n"); + IMFMediaSink_Release(sink2); + + hr = IMFStreamSink_GetIdentifier(stream, &id); + ok(hr == S_OK, "Failed to get stream id, hr %#x.\n", hr); + ok(id == 0, "Unexpected id %#x.\n", id); + + hr = IMFStreamSink_GetMediaTypeHandler(stream, &handler); +todo_wine + ok(hr == S_OK, "Failed to get type handler, hr %#x.\n", hr); + if (SUCCEEDED(hr)) + { + hr = IMFMediaTypeHandler_GetMediaTypeCount(handler, &count); + ok(hr == S_OK, "Failed to get media type count, hr %#x.\n", hr); + ok(count == 0, "Unexpected count %u.\n", count); + + IMFMediaTypeHandler_Release(handler); + } + + hr = IMFStreamSink_Flush(stream); +todo_wine + ok(hr == S_OK, "Failed to flush, hr %#x.\n", hr); + + IMFMediaSink_Release(sink); + IMFStreamSink_Release(stream); + + refcount = IMFActivate_Release(activate); + ok(!refcount, "Unexpected refcount %u.\n", refcount); + + IMFMediaType_Release(media_type); } START_TEST(mf) diff --git a/include/mferror.h b/include/mferror.h index a0acf90f8b..4d3a530734 100644 --- a/include/mferror.h +++ b/include/mferror.h @@ -94,6 +94,20 @@ #define MF_E_MEDIA_SOURCE_NO_STREAMS_SELECTED _HRESULT_TYPEDEF_(0xc00d3e9c) #define MF_E_UNSUPPORTED_CHARACTERISTICS _HRESULT_TYPEDEF_(0xc00d3e9e) +#define MF_E_STREAMSINK_REMOVED _HRESULT_TYPEDEF_(0xc00d4a38) +#define MF_E_STREAMSINKS_OUT_OF_SYNC _HRESULT_TYPEDEF_(0xc00d4a3a) +#define MF_E_STREAMSINKS_FIXED _HRESULT_TYPEDEF_(0xc00d4a3b) +#define MF_E_STREAMSINK_EXISTS _HRESULT_TYPEDEF_(0xc00d4a3c) +#define MF_E_SAMPLEALLOCATOR_CANCELED _HRESULT_TYPEDEF_(0xc00d4a3d) +#define MF_E_SAMPLEALLOCATOR_EMPTY _HRESULT_TYPEDEF_(0xc00d4a3e) +#define MF_E_SINK_ALREADYSTOPPED _HRESULT_TYPEDEF_(0xc00d4a3f) +#define MF_E_ASF_FILESINK_BITRATE_UNKNOWN _HRESULT_TYPEDEF_(0xc00d4a40) +#define MF_E_SINK_NO_STREAMS _HRESULT_TYPEDEF_(0xc00d4a41) +#define MF_S_SINK_NOT_FINALIZED _HRESULT_TYPEDEF_(0x000d4a42) +#define MF_E_METADATA_TOO_LONG _HRESULT_TYPEDEF_(0xc00d4a43) +#define MF_E_SINK_NO_SAMPLES_PROCESSED _HRESULT_TYPEDEF_(0xc00d4a44) +#define MF_E_SINK_HEADERS_NOT_FOUND _HRESULT_TYPEDEF_(0xc00d4a45) + #define MF_E_TOPO_INVALID_OPTIONAL_NODE _HRESULT_TYPEDEF_(0xc00d520e) #define MF_E_TOPO_CANNOT_FIND_DECRYPTOR _HRESULT_TYPEDEF_(0xc00d5211) #define MF_E_TOPO_CODEC_NOT_FOUND _HRESULT_TYPEDEF_(0xc00d5212) diff --git a/include/mfidl.idl b/include/mfidl.idl index c024e67378..a5882e98e5 100644 --- a/include/mfidl.idl +++ b/include/mfidl.idl @@ -83,6 +83,14 @@ typedef enum _MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS = 0x00000002, } MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS; +typedef enum _MFSTREAMSINK_MARKER_TYPE +{ + MFSTREAMSINK_MARKER_DEFAULT, + MFSTREAMSINK_MARKER_ENDOFSEGMENT, + MFSTREAMSINK_MARKER_TICK, + MFSTREAMSINK_MARKER_EVENT, +} MFSTREAMSINK_MARKER_TYPE; + [ object, uuid(2eb1e945-18b8-4139-9b1a-d5d584818530), @@ -646,6 +654,13 @@ interface IMFPresentationClock : IMFClock HRESULT Pause(); } +cpp_quote("#define MEDIASINK_FIXED_STREAMS 0x00000001") +cpp_quote("#define MEDIASINK_CANNOT_MATCH_CLOCK 0x00000002") +cpp_quote("#define MEDIASINK_RATELESS 0x00000004") +cpp_quote("#define MEDIASINK_CLOCK_REQUIRED 0x00000008") +cpp_quote("#define MEDIASINK_CAN_PREROLL 0x00000010") +cpp_quote("#define MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE 0x00000020") + [ object, uuid(6ef2a660-47c0-4666-b13d-cbb717f2fa2c) @@ -666,6 +681,23 @@ interface IMFMediaSink : IUnknown HRESULT Shutdown(); } +[ + object, + uuid(0a97b3cf-8e7c-4a3d-8f8c-0c843dc247fb), +] +interface IMFStreamSink : IMFMediaEventGenerator +{ + HRESULT GetMediaSink([out] IMFMediaSink **sink); + HRESULT GetIdentifier([out] DWORD *identifier); + HRESULT GetMediaTypeHandler([out] IMFMediaTypeHandler **handler); + HRESULT ProcessSample([in] IMFSample *sample); + HRESULT PlaceMarker( + [in] MFSTREAMSINK_MARKER_TYPE marker_type, + [in] const PROPVARIANT *marker_value, + [in] const PROPVARIANT *context_value); + HRESULT Flush(); +} + typedef enum _MFSHUTDOWN_STATUS { MFSHUTDOWN_INITIATED, -- 2.20.1

2 8

[PATCH] urlmon: Add CoInternetGetBrowserProfile stub.
by Dmitry Timoshkov 20 May '19

20 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/urlmon/urlmon.spec | 1 + dlls/urlmon/urlmon_main.c | 10 ++++++++++ 2 files changed, 11 insertions(+) diff --git a/dlls/urlmon/urlmon.spec b/dlls/urlmon/urlmon.spec index 9c7a6d3b37..dab4aa2925 100644 --- a/dlls/urlmon/urlmon.spec +++ b/dlls/urlmon/urlmon.spec @@ -109,4 +109,5 @@ 423 stdcall @(long long long long) LogSqmUXCommandOffsetInternal 444 stdcall @(long long long) MapUriToBrowserEmulationState 445 stdcall @(long long) MapBrowserEmulationModeToUserAgent +446 stdcall @(long) CoInternetGetBrowserProfile 455 stdcall @() FlushUrlmonZonesCache diff --git a/dlls/urlmon/urlmon_main.c b/dlls/urlmon/urlmon_main.c index 06f0698efa..90ea6e7cf2 100644 --- a/dlls/urlmon/urlmon_main.c +++ b/dlls/urlmon/urlmon_main.c @@ -810,6 +810,16 @@ int WINAPI MapBrowserEmulationModeToUserAgent(DWORD unk1, DWORD unk2) return 0; } +/*********************************************************************** + * CoInternetGetBrowserProfile (URLMON.446) + * Undocumented, added in IE8 + */ +HRESULT WINAPI CoInternetGetBrowserProfile(DWORD unk) +{ + FIXME("%x: stub\n", unk); + return E_NOTIMPL; +} + /*********************************************************************** * FlushUrlmonZonesCache (URLMON.455) * Undocumented, added in IE8 -- 2.20.1

2 3

[PATCH v3 1/8] wined3d: Factor out wined3d_get_mcs() function.
by Paul Gofman 20 May '19

20 May '19

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/wined3d/utils.c | 25 +++++++++---------------- dlls/wined3d/wined3d_private.h | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 16 deletions(-) diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index ef469100fd..fb545cf610 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -6442,23 +6442,16 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_context *context, settings->point_size = state->gl_primitive_type == GL_POINTS; settings->per_vertex_point_size = !!(si->use_map & 1u << WINED3D_FFP_PSIZE); - if (state->render_states[WINED3D_RS_COLORVERTEX]) { - settings->diffuse_source = validate_material_colour_source(si->use_map, - state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE]); - settings->emissive_source = validate_material_colour_source(si->use_map, - state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE]); - settings->ambient_source = validate_material_colour_source(si->use_map, - state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE]); - settings->specular_source = validate_material_colour_source(si->use_map, - state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE]); - } - else - { - settings->diffuse_source = WINED3D_MCS_MATERIAL; - settings->emissive_source = WINED3D_MCS_MATERIAL; - settings->ambient_source = WINED3D_MCS_MATERIAL; - settings->specular_source = WINED3D_MCS_MATERIAL; + enum wined3d_material_color_source diffuse_source, emissive_source, + ambient_source, specular_source; + + wined3d_get_mcs(&diffuse_source, &emissive_source, &ambient_source, &specular_source, state, si); + + settings->diffuse_source = diffuse_source; + settings->emissive_source = emissive_source; + settings->ambient_source = ambient_source; + settings->specular_source = specular_source; } for (i = 0; i < WINED3D_MAX_TEXTURES; ++i) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 34fa1d3ef3..716f5101c9 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -4850,6 +4850,38 @@ static inline enum wined3d_material_color_source validate_material_colour_source return WINED3D_MCS_MATERIAL; } +static inline void wined3d_get_mcs(enum wined3d_material_color_source *diffuse_source, + enum wined3d_material_color_source *emissive_source, enum wined3d_material_color_source *ambient_source, + enum wined3d_material_color_source *specular_source, const struct wined3d_state *state, + const struct wined3d_stream_info *si) +{ + if (state->render_states[WINED3D_RS_LIGHTING]) + { + if (state->render_states[WINED3D_RS_COLORVERTEX]) + { + *diffuse_source = validate_material_colour_source(si->use_map, + state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE]); + *emissive_source = validate_material_colour_source(si->use_map, + state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE]); + *ambient_source = validate_material_colour_source(si->use_map, + state->render_states[WINED3D_RS_AMBIENTMATERIALSOURCE]); + *specular_source = validate_material_colour_source(si->use_map, + state->render_states[WINED3D_RS_SPECULARMATERIALSOURCE]); + } + else + { + *diffuse_source = *emissive_source = *ambient_source = + *specular_source = WINED3D_MCS_MATERIAL; + } + } + else + { + *diffuse_source = WINED3D_MCS_COLOR1; + *specular_source = WINED3D_MCS_COLOR2; + *emissive_source = *ambient_source = WINED3D_MCS_MATERIAL; + } +} + BOOL invert_matrix(struct wined3d_matrix *out, const struct wined3d_matrix *m) DECLSPEC_HIDDEN; void compute_normal_matrix(float *normal_matrix, BOOL legacy_lighting, -- 2.21.0

2 11

[PATCH vkd3d 1/3] vkd3d: Enable VK_KHR_draw_indirect_count
by Philip Rebohle 20 May '19

20 May '19

Signed-off-by: Philip Rebohle <philip.rebohle(a)tu-dortmund.de> --- libs/vkd3d/device.c | 1 + libs/vkd3d/vkd3d_private.h | 1 + libs/vkd3d/vulkan_procs.h | 4 ++++ 3 files changed, 6 insertions(+) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 5239911..ddec0f7 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -151,6 +151,7 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = { /* KHR extensions */ {VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_dedicated_allocation)}, + {VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_draw_indirect_count)}, {VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_get_memory_requirements2)}, {VK_KHR_MAINTENANCE3_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_maintenance3)}, {VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_push_descriptor)}, diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 0f0d77f..036b9eb 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -92,6 +92,7 @@ struct vkd3d_vulkan_info /* KHR device extensions */ bool KHR_dedicated_allocation; + bool KHR_draw_indirect_count; bool KHR_get_memory_requirements2; bool KHR_maintenance3; bool KHR_push_descriptor; diff --git a/libs/vkd3d/vulkan_procs.h b/libs/vkd3d/vulkan_procs.h index 38ead47..a55fb07 100644 --- a/libs/vkd3d/vulkan_procs.h +++ b/libs/vkd3d/vulkan_procs.h @@ -177,6 +177,10 @@ VK_DEVICE_PFN(vkUnmapMemory) VK_DEVICE_PFN(vkUpdateDescriptorSets) VK_DEVICE_PFN(vkWaitForFences) +/* VK_KHR_draw_indirect_count */ +VK_DEVICE_EXT_PFN(vkCmdDrawIndirectCountKHR); +VK_DEVICE_EXT_PFN(vkCmdDrawIndexedIndirectCountKHR); + /* VK_KHR_get_memory_requirements2 */ VK_DEVICE_EXT_PFN(vkGetBufferMemoryRequirements2KHR) VK_DEVICE_EXT_PFN(vkGetImageMemoryRequirements2KHR) -- 2.21.0

2 4

[PATCH 1/2] urlmon/tests: Add a test for ProtocolCF_CreateInstance not supporting aggregation.
by Dmitry Timoshkov 20 May '19

20 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/urlmon/tests/url.c | 49 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 3 deletions(-) diff --git a/dlls/urlmon/tests/url.c b/dlls/urlmon/tests/url.c index 1aef981b83..84dedc07f4 100644 --- a/dlls/urlmon/tests/url.c +++ b/dlls/urlmon/tests/url.c @@ -140,6 +140,9 @@ DEFINE_EXPECT(UnlockRequest); DEFINE_EXPECT(Continue); DEFINE_EXPECT(Abort); DEFINE_EXPECT(CreateInstance); +DEFINE_EXPECT(Protocol_CreateInstance); +DEFINE_EXPECT(Protocol_CreateInstance_aggregation); +DEFINE_EXPECT(Protocol_CreateInstance_no_aggregation); DEFINE_EXPECT(Load); DEFINE_EXPECT(PutProperty_MIMETYPEPROP); DEFINE_EXPECT(PutProperty_CLASSIDPROP); @@ -181,7 +184,7 @@ static HRESULT binding_hres; static HRESULT onsecurityproblem_hres; static HRESULT abort_hres; static BOOL have_IHttpNegotiate2, use_bscex, is_async_prot; -static BOOL test_redirect, use_cache_file, callback_read, no_callback, test_abort; +static BOOL test_redirect, use_cache_file, callback_read, no_callback, no_aggregation, test_abort; static WCHAR cache_file_name[MAX_PATH]; static WCHAR http_cache_file[MAX_PATH]; static BOOL only_check_prot_args = FALSE; @@ -2414,8 +2417,22 @@ static HRESULT WINAPI ProtocolCF_CreateInstance(IClassFactory *iface, IUnknown * if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) return E_NOINTERFACE; - ok(outer != NULL, "outer == NULL\n"); + if (!outer) + { + CHECK_EXPECT(Protocol_CreateInstance); + ok(IsEqualGUID(&IID_IInternetProtocol, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid)); + *ppv = &Protocol; + return S_OK; + } + ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid)); + if (no_aggregation) + { + CHECK_EXPECT(Protocol_CreateInstance_no_aggregation); + return CLASS_E_NOAGGREGATION; + } + + CHECK_EXPECT(Protocol_CreateInstance_aggregation); *ppv = &Protocol; return S_OK; } @@ -2864,6 +2881,7 @@ static BOOL test_RegisterBindStatusCallback(void) #define BINDTEST_ABORT_PROGRESS 0x0800 #define BINDTEST_ASYNC_SWITCH 0x1000 #define BINDTEST_ALLOW_FINDINGRESOURCE 0x2000 +#define BINDTEST_NO_AGGREGATION 0x4000 static void init_bind_test(int protocol, DWORD flags, DWORD t) { @@ -2919,6 +2937,7 @@ static void init_bind_test(int protocol, DWORD flags, DWORD t) use_cache_file = (flags & BINDTEST_USE_CACHE) != 0; callback_read = !(flags & BINDTEST_NO_CALLBACK_READ); no_callback = (flags & BINDTEST_NO_CALLBACK) != 0; + no_aggregation = (flags & BINDTEST_NO_AGGREGATION) != 0; test_abort = (flags & BINDTEST_ABORT) != 0; abort_start = (flags & BINDTEST_ABORT_START) != 0; abort_progress = (flags & BINDTEST_ABORT_PROGRESS) != 0; @@ -3013,6 +3032,13 @@ static void test_BindToStorage(int protocol, DWORD flags, DWORD t) if(is_urlmon_protocol(test_protocol)) SET_EXPECT(SetPriority); SET_EXPECT(Start); + if(no_aggregation) { + SET_EXPECT(Protocol_CreateInstance_no_aggregation); + SET_EXPECT(Protocol_CreateInstance); + } + else + SET_EXPECT(Protocol_CreateInstance_aggregation); + if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST || test_protocol == WINETEST_SYNC_TEST) SET_EXPECT(Terminate); @@ -3083,8 +3109,11 @@ static void test_BindToStorage(int protocol, DWORD flags, DWORD t) ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres); else if(no_callback) { if(emulate_protocol) - ok( WaitForSingleObject(complete_event2, 90000) == WAIT_OBJECT_0, "wait timed out\n" ); + todo_wine_if(no_aggregation) + ok( WaitForSingleObject(complete_event2, 3000) == WAIT_OBJECT_0, "wait timed out\n" ); + todo_wine_if(no_aggregation) ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres); + todo_wine_if(no_aggregation) ok(unk != NULL, "unk == NULL\n"); }else if(!(bindf & BINDF_ASYNCHRONOUS) && tymed == TYMED_FILE) { ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres); @@ -3149,6 +3178,17 @@ static void test_BindToStorage(int protocol, DWORD flags, DWORD t) if(is_urlmon_protocol(test_protocol)) CLEAR_CALLED(SetPriority); /* Not called by IE11 */ CHECK_CALLED(Start); + if(no_callback) { + if(no_aggregation) { + CHECK_NOT_CALLED(Protocol_CreateInstance_aggregation); + CHECK_CALLED(Protocol_CreateInstance_no_aggregation); + CHECK_CALLED(Protocol_CreateInstance); + } else { + CHECK_CALLED(Protocol_CreateInstance_aggregation); + CHECK_NOT_CALLED(Protocol_CreateInstance_no_aggregation); + CHECK_NOT_CALLED(Protocol_CreateInstance); + } + } if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST || test_protocol == WINETEST_SYNC_TEST) { if(tymed == TYMED_FILE) @@ -4081,6 +4121,9 @@ START_TEST(url) trace("winetest test (no callback)...\n"); test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_NO_CALLBACK|BINDTEST_USE_CACHE, TYMED_ISTREAM); + trace("winetest test (no callback + no aggregation)...\n"); + test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_NO_CALLBACK|BINDTEST_USE_CACHE|BINDTEST_NO_AGGREGATION, TYMED_ISTREAM); + trace("emulated https test...\n"); test_BindToStorage(HTTPS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM); -- 2.20.1

2 2

[PATCH v2 1/6] server: Added support for tracking registered device notifications
by Micah N Gorrell 20 May '19

20 May '19

Signed-off-by: Micah N Gorrell <mgorrell(a)codeweavers.com> --- server/protocol.def | 23 ++++++++++ server/user.h | 3 +- server/window.c | 108 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 133 insertions(+), 1 deletion(-) diff --git a/server/protocol.def b/server/protocol.def index 21008d7a87..314a4477d0 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3684,6 +3684,29 @@ struct handle_info @END +/* Register a handle for device notifications */ +@REQ(register_device_notification) + user_handle_t recipient; /* handle to a window or service that will receive device events */ +@REPLY + user_handle_t handle; /* handle associated with the registration */ +@END + + +/* Unregister device notifications for a handle */ +@REQ(unregister_device_notification) + user_handle_t notification; /* handle that was previously returned by register_device_notification */ +@END + + +/* Return a list of handles that have registered for device notifications */ +@REQ(get_device_notifications) +@REPLY + int count; /* total count of registered handles */ + VARARG(handles,user_handles); /* registered handles */ +@END + + + /* Make the current process a system process */ @REQ(make_process_system) @REPLY diff --git a/server/user.h b/server/user.h index eb1b7ce1e4..282cb63339 100644 --- a/server/user.h +++ b/server/user.h @@ -36,7 +36,8 @@ enum user_object { USER_WINDOW = 1, USER_HOOK, - USER_CLIENT /* arbitrary client handle */ + USER_CLIENT, /* arbitrary client handle */ + USER_DEVNOTIFY }; #define DESKTOP_ATOM ((atom_t)32769) diff --git a/server/window.c b/server/window.c index c9b131cba5..5116fb12ff 100644 --- a/server/window.c +++ b/server/window.c @@ -129,6 +129,18 @@ static struct window *taskman_window; #define WINPTR_TOPMOST ((struct window *)3L) #define WINPTR_NOTOPMOST ((struct window *)4L) +struct device_notification +{ + user_handle_t recipient; /* the window handle to send notifications to */ + user_handle_t handle; /* full handle for this window */ + struct list entry; /* entry in global notifications list */ + + /* FIXME: Add support for notification filters */ +}; + +/* global list of handles that have registered for device notifications */ +static struct list device_notifications = LIST_INIT(device_notifications); + /* retrieve a pointer to a window from its handle */ static inline struct window *get_window( user_handle_t handle ) { @@ -2880,3 +2892,99 @@ DECL_HANDLER(set_window_layered_info) } else set_win32_error( ERROR_INVALID_WINDOW_HANDLE ); } + +/* retrieve a pointer to a device_notification from its handle */ +static inline struct device_notification *get_device_notification( user_handle_t handle ) +{ + struct device_notification *ret = get_user_object( handle, USER_DEVNOTIFY ); + if (!ret) set_win32_error( ERROR_INVALID_HANDLE ); + return ret; +} + +/* create a new device notification structure and link it into the global list */ +static struct device_notification *register_device_notification( struct window *recipient ) +{ + struct device_notification *notification; + + if (!recipient) + { + return NULL; + } + + if (!(notification = mem_alloc( sizeof(*notification) ))) goto failed; + if (!(notification->handle = alloc_user_handle( notification, USER_DEVNOTIFY ))) goto failed; + + notification->recipient = recipient->handle; + /* FIXME: Add support for notification filters */ + + list_add_tail( &device_notifications, &notification->entry ); + + return notification; +failed: + if (notification) + { + if (notification->handle) free_user_handle( notification->handle ); + free( notification ); + } + + return NULL; +} + +static void unregister_device_notification( struct device_notification *notification) +{ + list_remove( &notification->entry ); + free_user_handle( notification->handle ); + memset( notification, 0x55, sizeof(*notification) ); + free( notification ); +} + +static int get_device_notifications( struct user_handle_array *array ) +{ + struct device_notification *notification; + + LIST_FOR_EACH_ENTRY( notification, &device_notifications, struct device_notification, entry ) + { + /* FIXME: Implement notification filtering */ + if (!add_handle_to_array( array, notification->recipient )) return 0; + } + + return 1; +} + +/* register for device notifications */ +DECL_HANDLER(register_device_notification) +{ + struct device_notification *notification = NULL; + struct window *recipient = get_window( req->recipient ); + + reply->handle = 0; + if (!recipient) return; + + if (!(notification = register_device_notification( recipient ))) return; + + reply->handle = notification->handle; +} + +DECL_HANDLER(unregister_device_notification) +{ + struct device_notification *notification = get_device_notification( req->notification ); + if (notification) unregister_device_notification(notification); +} + +DECL_HANDLER(get_device_notifications) +{ + struct user_handle_array array; + data_size_t len; + + array.handles = NULL; + array.count = 0; + array.total = 0; + + if (!get_device_notifications( &array )) return; + + reply->count = array.count; + len = min( get_reply_max_size(), array.count * sizeof(user_handle_t) ); + if (len) set_reply_data_ptr( array.handles, len ); + else free( array.handles ); +} + -- 2.21.0

3 12

[PATCH v3 1/6] server: Added support for tracking registered device notifications
by Micah N Gorrell 19 May '19

19 May '19

Signed-off-by: Micah N Gorrell <mgorrell(a)codeweavers.com> --- server/protocol.def | 23 ++++++++++ server/user.h | 3 +- server/window.c | 107 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 132 insertions(+), 1 deletion(-) diff --git a/server/protocol.def b/server/protocol.def index 21008d7a87..314a4477d0 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3684,6 +3684,29 @@ struct handle_info @END +/* Register a handle for device notifications */ +@REQ(register_device_notification) + user_handle_t recipient; /* handle to a window or service that will receive device events */ +@REPLY + user_handle_t handle; /* handle associated with the registration */ +@END + + +/* Unregister device notifications for a handle */ +@REQ(unregister_device_notification) + user_handle_t notification; /* handle that was previously returned by register_device_notification */ +@END + + +/* Return a list of handles that have registered for device notifications */ +@REQ(get_device_notifications) +@REPLY + int count; /* total count of registered handles */ + VARARG(handles,user_handles); /* registered handles */ +@END + + + /* Make the current process a system process */ @REQ(make_process_system) @REPLY diff --git a/server/user.h b/server/user.h index eb1b7ce1e4..282cb63339 100644 --- a/server/user.h +++ b/server/user.h @@ -36,7 +36,8 @@ enum user_object { USER_WINDOW = 1, USER_HOOK, - USER_CLIENT /* arbitrary client handle */ + USER_CLIENT, /* arbitrary client handle */ + USER_DEVNOTIFY }; #define DESKTOP_ATOM ((atom_t)32769) diff --git a/server/window.c b/server/window.c index c9b131cba5..d47c3c7ac1 100644 --- a/server/window.c +++ b/server/window.c @@ -129,6 +129,18 @@ static struct window *taskman_window; #define WINPTR_TOPMOST ((struct window *)3L) #define WINPTR_NOTOPMOST ((struct window *)4L) +struct device_notification +{ + user_handle_t recipient; /* the window handle to send notifications to */ + user_handle_t handle; /* full handle for this window */ + struct list entry; /* entry in global notifications list */ + + /* FIXME: Add support for notification filters */ +}; + +/* global list of handles that have registered for device notifications */ +static struct list device_notifications = LIST_INIT(device_notifications); + /* retrieve a pointer to a window from its handle */ static inline struct window *get_window( user_handle_t handle ) { @@ -2880,3 +2892,98 @@ DECL_HANDLER(set_window_layered_info) } else set_win32_error( ERROR_INVALID_WINDOW_HANDLE ); } + +/* retrieve a pointer to a device_notification from its handle */ +static inline struct device_notification *get_device_notification( user_handle_t handle ) +{ + struct device_notification *ret = get_user_object( handle, USER_DEVNOTIFY ); + if (!ret) set_win32_error( ERROR_INVALID_HANDLE ); + return ret; +} + +/* create a new device notification structure and link it into the global list */ +static struct device_notification *register_device_notification( struct window *recipient ) +{ + struct device_notification *notification; + + if (!recipient) + { + return NULL; + } + + if (!(notification = mem_alloc( sizeof(*notification) ))) goto failed; + if (!(notification->handle = alloc_user_handle( notification, USER_DEVNOTIFY ))) goto failed; + + notification->recipient = recipient->handle; + /* FIXME: Add support for notification filters */ + + list_add_tail( &device_notifications, &notification->entry ); + + return notification; +failed: + if (notification) + { + if (notification->handle) free_user_handle( notification->handle ); + free( notification ); + } + + return NULL; +} + +static void unregister_device_notification( struct device_notification *notification) +{ + list_remove( &notification->entry ); + free_user_handle( notification->handle ); + memset( notification, 0x55, sizeof(*notification) ); + free( notification ); +} + +static int get_device_notifications( struct user_handle_array *array ) +{ + struct device_notification *notification; + + LIST_FOR_EACH_ENTRY( notification, &device_notifications, struct device_notification, entry ) + { + /* FIXME: Implement notification filtering */ + if (!add_handle_to_array( array, notification->recipient )) return 0; + } + + return 1; +} + +/* register for device notifications */ +DECL_HANDLER(register_device_notification) +{ + struct device_notification *notification = NULL; + struct window *recipient = get_window( req->recipient ); + + reply->handle = 0; + if (!recipient) return; + + if (!(notification = register_device_notification( recipient ))) return; + + reply->handle = notification->handle; +} + +DECL_HANDLER(unregister_device_notification) +{ + struct device_notification *notification = get_device_notification( req->notification ); + if (notification) unregister_device_notification(notification); +} + +DECL_HANDLER(get_device_notifications) +{ + struct user_handle_array array; + data_size_t len; + + array.handles = NULL; + array.count = 0; + array.total = 0; + + if (!get_device_notifications( &array )) return; + + reply->count = array.count; + len = min( get_reply_max_size(), array.count * sizeof(user_handle_t) ); + if (len) set_reply_data_ptr( array.handles, len ); + else free( array.handles ); +} -- 2.21.0

3 9

[PATCH] dbgstr: Initialize hex list using a proper char array
by Tim Schumacher 19 May '19

19 May '19

Some compilers (or rather, compiler settings) are unhappy with the terminating null-char, which is one byte beyond the 16 char limit. Initialize the array without the null char to circumvent this issue. Signed-off-by: Tim Schumacher <timschumi(a)gmx.de> --- include/wine/debug.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/wine/debug.h b/include/wine/debug.h index aa4dc0d77e0..1c312e93221 100644 --- a/include/wine/debug.h +++ b/include/wine/debug.h @@ -220,7 +220,7 @@ static inline int __wine_dbg_cdecl wine_dbg_log( enum __wine_debug_class cls, static inline const char *wine_dbgstr_an( const char *str, int n ) { - static const char hex[16] = "0123456789abcdef"; + static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; char buffer[300], *dst = buffer; if (!str) return "(null)"; @@ -262,7 +262,7 @@ static inline const char *wine_dbgstr_an( const char *str, int n ) static inline const char *wine_dbgstr_wn( const WCHAR *str, int n ) { - static const char hex[16] = "0123456789abcdef"; + static const char hex[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; char buffer[300], *dst = buffer; if (!str) return "(null)"; -- 2.21.0

1 0

[PATCH 1/2] mshtml: Fix a copy-paste error.
by Zebediah Figura 19 May '19

19 May '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/mshtml/dispex.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mshtml/dispex.c b/dlls/mshtml/dispex.c index e637f131d0..2033e90872 100644 --- a/dlls/mshtml/dispex.c +++ b/dlls/mshtml/dispex.c @@ -299,7 +299,7 @@ static void add_func_info(dispex_data_t *data, tid_t tid, const FUNCDESC *desc, if(!info->arg_types) return; info->arg_info = heap_alloc_zero(sizeof(*info->arg_info) * info->argc); - if(!info->arg_types) + if(!info->arg_info) return; for(i=0; i < info->argc; i++) -- 2.21.0

2 2

[PATCH 5/5] wined3d: Use wined3d_texture_get_level_box() in texture2d_load_texture().
by Henri Verbeet 19 May '19

19 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/surface.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index a95b18e6951..40e8bc17f24 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -1548,9 +1548,7 @@ BOOL texture2d_load_texture(struct wined3d_texture *texture, unsigned int sub_re } level = sub_resource_idx % texture->level_count; - width = wined3d_texture_get_level_width(texture, level); - height = wined3d_texture_get_level_height(texture, level); - wined3d_box_set(&src_box, 0, 0, width, height, 0, 1); + wined3d_texture_get_level_box(texture, level, &src_box); if (!depth && sub_resource->locations & (WINED3D_LOCATION_TEXTURE_SRGB | WINED3D_LOCATION_TEXTURE_RGB) && (texture->resource.format_flags & WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB) @@ -1560,7 +1558,7 @@ BOOL texture2d_load_texture(struct wined3d_texture *texture, unsigned int sub_re { RECT src_rect; - SetRect(&src_rect, 0, 0, width, height); + SetRect(&src_rect, src_box.left, src_box.top, src_box.right, src_box.bottom); if (srgb) texture2d_blt_fbo(device, context, WINED3D_TEXF_POINT, texture, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB, &src_rect, @@ -1581,7 +1579,7 @@ BOOL texture2d_load_texture(struct wined3d_texture *texture, unsigned int sub_re DWORD dst_location = srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB; RECT src_rect; - SetRect(&src_rect, 0, 0, width, height); + SetRect(&src_rect, src_box.left, src_box.top, src_box.right, src_box.bottom); if (fbo_blitter_supported(WINED3D_BLIT_OP_COLOR_BLIT, gl_info, &texture->resource, src_location, &texture->resource, dst_location)) texture2d_blt_fbo(device, context, WINED3D_TEXF_POINT, texture, sub_resource_idx, @@ -1640,6 +1638,8 @@ BOOL texture2d_load_texture(struct wined3d_texture *texture, unsigned int sub_re wined3d_texture_get_memory(texture, sub_resource_idx, &data, sub_resource->locations); if (conversion) { + width = src_box.right - src_box.left; + height = src_box.bottom - src_box.top; wined3d_format_calculate_pitch(format, device->surface_alignment, width, height, &dst_row_pitch, &dst_slice_pitch); -- 2.11.0

1 0

[PATCH 4/5] wined3d: Pass a wined3d_context_gl structure to context_set_pixel_format().
by Henri Verbeet 19 May '19

19 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 0908ed1092f..aa4d2601b68 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1152,19 +1152,18 @@ static BOOL wined3d_context_gl_restore_pixel_format(struct wined3d_context_gl *c return ret; } -static BOOL context_set_pixel_format(struct wined3d_context *context) +static BOOL wined3d_context_gl_set_pixel_format(struct wined3d_context_gl *context_gl) { - struct wined3d_context_gl *context_gl = wined3d_context_gl(context); - const struct wined3d_gl_info *gl_info = context->gl_info; - BOOL private = context->hdc_is_private; - int format = context->pixel_format; - HDC dc = context->hdc; + const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; + BOOL private = context_gl->c.hdc_is_private; + int format = context_gl->c.pixel_format; + HDC dc = context_gl->c.hdc; int current; - if (private && context->hdc_has_format) + if (private && context_gl->c.hdc_has_format) return TRUE; - if (!private && WindowFromDC(dc) != context->win_handle) + if (!private && WindowFromDC(dc) != context_gl->c.win_handle) return FALSE; current = gl_info->gl_ops.wgl.p_wglGetPixelFormat(dc); @@ -1180,8 +1179,8 @@ static BOOL context_set_pixel_format(struct wined3d_context *context) return FALSE; } - context->restore_pf = 0; - context->restore_pf_win = private ? NULL : WindowFromDC(dc); + context_gl->c.restore_pf = 0; + context_gl->c.restore_pf_win = private ? NULL : WindowFromDC(dc); goto success; } @@ -1201,12 +1200,12 @@ static BOOL context_set_pixel_format(struct wined3d_context *context) } win = private ? NULL : WindowFromDC(dc); - if (win != context->restore_pf_win) + if (win != context_gl->c.restore_pf_win) { wined3d_context_gl_restore_pixel_format(context_gl); - context->restore_pf = private ? 0 : current; - context->restore_pf_win = win; + context_gl->c.restore_pf = private ? 0 : current; + context_gl->c.restore_pf_win = win; } goto success; @@ -1222,16 +1221,17 @@ static BOOL context_set_pixel_format(struct wined3d_context *context) success: if (private) - context->hdc_has_format = TRUE; + context_gl->c.hdc_has_format = TRUE; return TRUE; } static BOOL context_set_gl_context(struct wined3d_context *ctx) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(ctx); struct wined3d_swapchain *swapchain = ctx->swapchain; BOOL backup = FALSE; - if (!context_set_pixel_format(ctx)) + if (!wined3d_context_gl_set_pixel_format(context_gl)) { WARN("Failed to set pixel format %d on device context %p.\n", ctx->pixel_format, ctx->hdc); @@ -1265,7 +1265,7 @@ static BOOL context_set_gl_context(struct wined3d_context *ctx) ctx->hdc_is_private = TRUE; ctx->hdc_has_format = FALSE; - if (!context_set_pixel_format(ctx)) + if (!wined3d_context_gl_set_pixel_format(context_gl)) { ERR("Failed to set pixel format %d on device context %p.\n", ctx->pixel_format, ctx->hdc); @@ -2113,7 +2113,7 @@ HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wi context_enter(context); - if (!context_set_pixel_format(context)) + if (!wined3d_context_gl_set_pixel_format(context_gl)) { ERR("Failed to set pixel format %d on device context %p.\n", context->pixel_format, context->hdc); context_release(context); -- 2.11.0

1 0

[PATCH 3/5] wined3d: Pass a wined3d_context_gl structure to wined3d_context_gl_restore_pixel_format().
by Henri Verbeet 19 May '19

19 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 0847cb92c65..0908ed1092f 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1120,39 +1120,41 @@ void wined3d_context_gl_texture_update(struct wined3d_context_gl *context_gl, } } -static BOOL context_restore_pixel_format(struct wined3d_context *ctx) +static BOOL wined3d_context_gl_restore_pixel_format(struct wined3d_context_gl *context_gl) { - const struct wined3d_gl_info *gl_info = ctx->gl_info; + const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; BOOL ret = FALSE; - if (ctx->restore_pf && IsWindow(ctx->restore_pf_win)) + if (context_gl->c.restore_pf && IsWindow(context_gl->c.restore_pf_win)) { - if (ctx->gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH]) + if (context_gl->c.gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH]) { - HDC dc = GetDCEx(ctx->restore_pf_win, 0, DCX_USESTYLE | DCX_CACHE); + HDC dc = GetDCEx(context_gl->c.restore_pf_win, 0, DCX_USESTYLE | DCX_CACHE); if (dc) { - if (!(ret = GL_EXTCALL(wglSetPixelFormatWINE(dc, ctx->restore_pf)))) + if (!(ret = GL_EXTCALL(wglSetPixelFormatWINE(dc, context_gl->c.restore_pf)))) { - ERR("wglSetPixelFormatWINE failed to restore pixel format %d on window %p.\n", - ctx->restore_pf, ctx->restore_pf_win); + ERR("Failed to restore pixel format %d on window %p.\n", + context_gl->c.restore_pf, context_gl->c.restore_pf_win); } - ReleaseDC(ctx->restore_pf_win, dc); + ReleaseDC(context_gl->c.restore_pf_win, dc); } } else { - ERR("can't restore pixel format %d on window %p\n", ctx->restore_pf, ctx->restore_pf_win); + ERR("Unable to restore pixel format %d on window %p.\n", + context_gl->c.restore_pf, context_gl->c.restore_pf_win); } } - ctx->restore_pf = 0; - ctx->restore_pf_win = NULL; + context_gl->c.restore_pf = 0; + context_gl->c.restore_pf_win = NULL; return ret; } static BOOL context_set_pixel_format(struct wined3d_context *context) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; BOOL private = context->hdc_is_private; int format = context->pixel_format; @@ -1201,7 +1203,7 @@ static BOOL context_set_pixel_format(struct wined3d_context *context) win = private ? NULL : WindowFromDC(dc); if (win != context->restore_pf_win) { - context_restore_pixel_format(context); + wined3d_context_gl_restore_pixel_format(context_gl); context->restore_pf = private ? 0 : current; context->restore_pf_win = win; @@ -1324,6 +1326,7 @@ static void context_update_window(struct wined3d_context *context) void wined3d_context_cleanup(struct wined3d_context *context) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; HGLRC restore_ctx; HDC restore_dc; @@ -1336,7 +1339,7 @@ void wined3d_context_cleanup(struct wined3d_context *context) else if (context->valid) context_set_gl_context(context); - context_restore_pixel_format(context); + wined3d_context_gl_restore_pixel_format(context_gl); if (restore_ctx) { context_restore_gl_context(gl_info, restore_dc, restore_ctx); @@ -1499,7 +1502,7 @@ void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) heap_free(context_gl->texture_type); - context_restore_pixel_format(&context_gl->c); + wined3d_context_gl_restore_pixel_format(context_gl); if (restore_ctx) context_restore_gl_context(gl_info, restore_dc, restore_ctx); @@ -1582,6 +1585,8 @@ BOOL context_set_current(struct wined3d_context *ctx) void context_release(struct wined3d_context *context) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); + TRACE("Releasing context %p, level %u.\n", context, context->level); if (WARN_ON(d3d)) @@ -1594,7 +1599,7 @@ void context_release(struct wined3d_context *context) if (!--context->level) { - if (context_restore_pixel_format(context)) + if (wined3d_context_gl_restore_pixel_format(context_gl)) context->needs_set = 1; if (context->restore_ctx) { -- 2.11.0

1 0

[PATCH 2/5] wined3d: Pass a wined3d_context_gl structure to context_get_offscreen_gl_buffer().
by Henri Verbeet 19 May '19

19 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 8 +++++--- dlls/wined3d/surface.c | 12 +++++++----- dlls/wined3d/wined3d_private.h | 2 +- 3 files changed, 13 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 84d6f4e86ae..0847cb92c65 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -2724,7 +2724,7 @@ static void context_set_render_offscreen(struct wined3d_context *context, BOOL o context->render_offscreen = offscreen; } -GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) +GLenum wined3d_context_gl_get_offscreen_gl_buffer(const struct wined3d_context_gl *context_gl) { switch (wined3d_settings.offscreen_rendering_mode) { @@ -2732,7 +2732,7 @@ GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) return GL_COLOR_ATTACHMENT0; case ORM_BACKBUFFER: - return context->aux_buffers > 0 ? GL_AUX0 : GL_BACK; + return context_gl->c.aux_buffers > 0 ? GL_AUX0 : GL_BACK; default: FIXME("Unhandled offscreen rendering mode %#x.\n", wined3d_settings.offscreen_rendering_mode); @@ -2742,12 +2742,14 @@ GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) static DWORD context_generate_rt_mask_no_fbo(const struct wined3d_context *context, struct wined3d_resource *rt) { + const struct wined3d_context_gl *context_gl = wined3d_context_gl_const(context); + if (!rt || rt->format->id == WINED3DFMT_NULL) return 0; else if (rt->type != WINED3D_RTYPE_BUFFER && texture_from_resource(rt)->swapchain) return context_generate_rt_mask_from_resource(rt); else - return context_generate_rt_mask(context_get_offscreen_gl_buffer(context)); + return context_generate_rt_mask(wined3d_context_gl_get_offscreen_gl_buffer(context_gl)); } /* Context activation is done by the caller. */ diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 318ac19f941..a95b18e6951 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -754,7 +754,7 @@ static void texture2d_read_from_framebuffer(struct wined3d_texture *texture, uns /* Mapping the primary render target which is not on a swapchain. * Read from the back buffer. */ TRACE("Mapping offscreen render target.\n"); - gl_info->gl_ops.gl.p_glReadBuffer(context_get_offscreen_gl_buffer(context)); + gl_info->gl_ops.gl.p_glReadBuffer(wined3d_context_gl_get_offscreen_gl_buffer(context_gl)); src_is_upside_down = TRUE; } else @@ -845,6 +845,7 @@ void texture2d_load_fb_texture(struct wined3d_texture_gl *texture_gl, { struct wined3d_texture *restore_texture; const struct wined3d_gl_info *gl_info; + struct wined3d_context_gl *context_gl; struct wined3d_resource *resource; unsigned int restore_idx, level; struct wined3d_device *device; @@ -858,17 +859,18 @@ void texture2d_load_fb_texture(struct wined3d_texture_gl *texture_gl, context = context_acquire(device, &texture_gl->t, sub_resource_idx); else restore_texture = NULL; + context_gl = wined3d_context_gl(context); gl_info = context->gl_info; device_invalidate_state(device, STATE_FRAMEBUFFER); wined3d_texture_prepare_texture(&texture_gl->t, context, srgb); - wined3d_texture_gl_bind_and_dirtify(texture_gl, wined3d_context_gl(context), srgb); + wined3d_texture_gl_bind_and_dirtify(texture_gl, context_gl, srgb); TRACE("Reading back offscreen render target %p, %u.\n", texture_gl, sub_resource_idx); if (wined3d_resource_is_offscreen(resource)) - gl_info->gl_ops.gl.p_glReadBuffer(context_get_offscreen_gl_buffer(context)); + gl_info->gl_ops.gl.p_glReadBuffer(wined3d_context_gl_get_offscreen_gl_buffer(context_gl)); else gl_info->gl_ops.gl.p_glReadBuffer(wined3d_texture_get_gl_buffer(&texture_gl->t)); checkGLcall("glReadBuffer"); @@ -922,7 +924,7 @@ static void fb_copy_to_texture_direct(struct wined3d_texture_gl *dst_texture, un { TRACE("Reading from an offscreen target\n"); upsidedown = !upsidedown; - gl_info->gl_ops.gl.p_glReadBuffer(context_get_offscreen_gl_buffer(context)); + gl_info->gl_ops.gl.p_glReadBuffer(wined3d_context_gl_get_offscreen_gl_buffer(context_gl)); } else { @@ -1036,7 +1038,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, wined3d_context_gl_apply_ffp_blit_state(context_gl, device); wined3d_texture_load(&dst_texture->t, context, FALSE); - offscreen_buffer = context_get_offscreen_gl_buffer(context); + offscreen_buffer = wined3d_context_gl_get_offscreen_gl_buffer(context_gl); src_level = src_sub_resource_idx % src_texture->t.level_count; src_width = wined3d_texture_get_level_width(&src_texture->t, src_level); src_height = wined3d_texture_get_level_height(&src_texture->t, src_level); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 94765cb0c3a..0fc56462b0c 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2081,6 +2081,7 @@ void wined3d_context_gl_free_occlusion_query(struct wined3d_occlusion_query *que void wined3d_context_gl_free_pipeline_statistics_query(struct wined3d_pipeline_statistics_query *query) DECLSPEC_HIDDEN; void wined3d_context_gl_free_so_statistics_query(struct wined3d_so_statistics_query *query) DECLSPEC_HIDDEN; void wined3d_context_gl_free_timestamp_query(struct wined3d_timestamp_query *query) DECLSPEC_HIDDEN; +GLenum wined3d_context_gl_get_offscreen_gl_buffer(const struct wined3d_context_gl *context_gl) DECLSPEC_HIDDEN; const unsigned int *wined3d_context_gl_get_tex_unit_mapping(const struct wined3d_context_gl *context_gl, const struct wined3d_shader_version *shader_version, unsigned int *base, unsigned int *count) DECLSPEC_HIDDEN; HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, @@ -2246,7 +2247,6 @@ void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_ void context_enable_clip_distances(struct wined3d_context *context, unsigned int mask) DECLSPEC_HIDDEN; void context_end_transform_feedback(struct wined3d_context *context) DECLSPEC_HIDDEN; struct wined3d_context *context_get_current(void) DECLSPEC_HIDDEN; -GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) DECLSPEC_HIDDEN; DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN; void context_gl_resource_released(struct wined3d_device *device, GLuint name, BOOL rb_namespace) DECLSPEC_HIDDEN; -- 2.11.0

1 0

[PATCH 1/5] wined3d: Move the FBO fields from struct wined3d_context to struct wined3d_context_gl.
by Henri Verbeet 19 May '19

19 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 150 +++++++++++++++++++++-------------------- dlls/wined3d/wined3d_private.h | 28 ++++---- 2 files changed, 90 insertions(+), 88 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 5735d02a5af..84d6f4e86ae 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -53,23 +53,23 @@ static void wined3d_context_gl_bind_fbo(struct wined3d_context_gl *context_gl, G switch (target) { case GL_READ_FRAMEBUFFER: - if (context_gl->c.fbo_read_binding == fbo) + if (context_gl->fbo_read_binding == fbo) return; - context_gl->c.fbo_read_binding = fbo; + context_gl->fbo_read_binding = fbo; break; case GL_DRAW_FRAMEBUFFER: - if (context_gl->c.fbo_draw_binding == fbo) + if (context_gl->fbo_draw_binding == fbo) return; - context_gl->c.fbo_draw_binding = fbo; + context_gl->fbo_draw_binding = fbo; break; case GL_FRAMEBUFFER: - if (context_gl->c.fbo_read_binding == fbo - && context_gl->c.fbo_draw_binding == fbo) + if (context_gl->fbo_read_binding == fbo + && context_gl->fbo_draw_binding == fbo) return; - context_gl->c.fbo_read_binding = fbo; - context_gl->c.fbo_draw_binding = fbo; + context_gl->fbo_read_binding = fbo; + context_gl->fbo_draw_binding = fbo; break; default: @@ -397,7 +397,7 @@ void wined3d_context_gl_check_fbo_status(const struct wined3d_context_gl *contex FIXME("FBO status %s (%#x).\n", debug_fbostatus(status), status); - if (!context_gl->c.current_fbo) + if (!context_gl->current_fbo) { ERR("FBO 0 is incomplete, driver bug?\n"); return; @@ -568,7 +568,7 @@ static void wined3d_context_gl_destroy_fbo_entry(struct wined3d_context_gl *cont TRACE("Destroy FBO %u.\n", entry->id); wined3d_context_gl_destroy_fbo(context_gl, entry->id); } - --context_gl->c.fbo_entry_count; + --context_gl->fbo_entry_count; list_remove(&entry->entry); heap_free(entry); } @@ -675,29 +675,29 @@ static struct fbo_entry *wined3d_context_gl_find_fbo_entry(struct wined3d_contex } } - LIST_FOR_EACH_ENTRY(entry, &context_gl->c.fbo_list, struct fbo_entry, entry) + LIST_FOR_EACH_ENTRY(entry, &context_gl->fbo_list, struct fbo_entry, entry) { if (memcmp(&fbo_key, &entry->key, sizeof(fbo_key))) continue; list_remove(&entry->entry); - list_add_head(&context_gl->c.fbo_list, &entry->entry); + list_add_head(&context_gl->fbo_list, &entry->entry); return entry; } - if (context_gl->c.fbo_entry_count < WINED3D_MAX_FBO_ENTRIES) + if (context_gl->fbo_entry_count < WINED3D_MAX_FBO_ENTRIES) { entry = context_create_fbo_entry(&context_gl->c, render_targets, depth_stencil, color_location, ds_location); - list_add_head(&context_gl->c.fbo_list, &entry->entry); - ++context_gl->c.fbo_entry_count; + list_add_head(&context_gl->fbo_list, &entry->entry); + ++context_gl->fbo_entry_count; } else { - entry = LIST_ENTRY(list_tail(&context_gl->c.fbo_list), struct fbo_entry, entry); + entry = LIST_ENTRY(list_tail(&context_gl->fbo_list), struct fbo_entry, entry); wined3d_context_gl_reuse_fbo_entry(context_gl, target, render_targets, depth_stencil, color_location, ds_location, entry); list_remove(&entry->entry); - list_add_head(&context_gl->c.fbo_list, &entry->entry); + list_add_head(&context_gl->fbo_list, &entry->entry); } return entry; @@ -717,8 +717,8 @@ static void wined3d_context_gl_apply_fbo_entry(struct wined3d_context_gl *contex return; } - read_binding = context_gl->c.fbo_read_binding; - draw_binding = context_gl->c.fbo_draw_binding; + read_binding = context_gl->fbo_read_binding; + draw_binding = context_gl->fbo_draw_binding; wined3d_context_gl_bind_fbo(context_gl, GL_FRAMEBUFFER, entry->id); if (gl_info->supported[ARB_FRAMEBUFFER_NO_ATTACHMENTS]) @@ -763,27 +763,27 @@ static void wined3d_context_gl_apply_fbo_state(struct wined3d_context_gl *contex { struct fbo_entry *entry, *entry2; - LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->c.fbo_destroy_list, struct fbo_entry, entry) + LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->fbo_destroy_list, struct fbo_entry, entry) { wined3d_context_gl_destroy_fbo_entry(context_gl, entry); } - if (context_gl->c.rebind_fbo) + if (context_gl->rebind_fbo) { wined3d_context_gl_bind_fbo(context_gl, GL_FRAMEBUFFER, 0); - context_gl->c.rebind_fbo = FALSE; + context_gl->rebind_fbo = FALSE; } if (color_location == WINED3D_LOCATION_DRAWABLE) { - context_gl->c.current_fbo = NULL; + context_gl->current_fbo = NULL; wined3d_context_gl_bind_fbo(context_gl, target, 0); } else { - context_gl->c.current_fbo = wined3d_context_gl_find_fbo_entry(context_gl, target, - render_targets, depth_stencil, color_location, ds_location); - wined3d_context_gl_apply_fbo_entry(context_gl, target, context_gl->c.current_fbo); + context_gl->current_fbo = wined3d_context_gl_find_fbo_entry(context_gl, + target, render_targets, depth_stencil, color_location, ds_location); + wined3d_context_gl_apply_fbo_entry(context_gl, target, context_gl->current_fbo); } } @@ -794,12 +794,12 @@ void wined3d_context_gl_apply_fbo_state_blit(struct wined3d_context_gl *context_ { struct wined3d_rendertarget_info ds_info = {{0}}; - memset(context_gl->c.blit_targets, 0, sizeof(context_gl->c.blit_targets)); + memset(context_gl->blit_targets, 0, sizeof(context_gl->blit_targets)); if (rt) { - context_gl->c.blit_targets[0].resource = rt; - context_gl->c.blit_targets[0].sub_resource_idx = rt_sub_resource_idx; - context_gl->c.blit_targets[0].layer_count = 1; + context_gl->blit_targets[0].resource = rt; + context_gl->blit_targets[0].sub_resource_idx = rt_sub_resource_idx; + context_gl->blit_targets[0].layer_count = 1; } if (ds) @@ -809,7 +809,7 @@ void wined3d_context_gl_apply_fbo_state_blit(struct wined3d_context_gl *context_ ds_info.layer_count = 1; } - wined3d_context_gl_apply_fbo_state(context_gl, target, context_gl->c.blit_targets, &ds_info, location, location); + wined3d_context_gl_apply_fbo_state(context_gl, target, context_gl->blit_targets, &ds_info, location, location); } /* Context activation is done by the caller. */ @@ -1051,7 +1051,7 @@ static void wined3d_context_gl_enum_fbo_entries(const struct wined3d_device *dev const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; struct fbo_entry *entry, *entry2; - LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->c.fbo_list, struct fbo_entry, entry) + LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->fbo_list, struct fbo_entry, entry) { for (j = 0; j < gl_info->limits.buffers + 1; ++j) { @@ -1070,7 +1070,7 @@ static void wined3d_context_gl_queue_fbo_entry_destruction(struct wined3d_contex struct fbo_entry *entry) { list_remove(&entry->entry); - list_add_head(&context_gl->c.fbo_destroy_list, &entry->entry); + list_add_head(&context_gl->fbo_destroy_list, &entry->entry); } void context_resource_released(const struct wined3d_device *device, struct wined3d_resource *resource) @@ -1102,10 +1102,10 @@ void wined3d_context_gl_texture_update(struct wined3d_context_gl *context_gl, const struct wined3d_texture_gl *texture_gl) { const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; - struct fbo_entry *entry = context_gl->c.current_fbo; + struct fbo_entry *entry = context_gl->current_fbo; unsigned int i; - if (!entry || context_gl->c.rebind_fbo) + if (!entry || context_gl->rebind_fbo) return; for (i = 0; i < gl_info->limits.buffers + 1; ++i) @@ -1114,7 +1114,7 @@ void wined3d_context_gl_texture_update(struct wined3d_context_gl *context_gl, || texture_gl->texture_srgb.name == entry->key.objects[i].object) { TRACE("Updated texture %p is bound as attachment %u to the current FBO.\n", texture_gl, i); - context_gl->c.rebind_fbo = TRUE; + context_gl->rebind_fbo = TRUE; return; } } @@ -1325,7 +1325,6 @@ static void context_update_window(struct wined3d_context *context) void wined3d_context_cleanup(struct wined3d_context *context) { const struct wined3d_gl_info *gl_info = context->gl_info; - struct fbo_entry *entry, *entry2; HGLRC restore_ctx; HDC restore_dc; @@ -1337,18 +1336,6 @@ void wined3d_context_cleanup(struct wined3d_context *context) else if (context->valid) context_set_gl_context(context); - LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry) - { - if (!context->valid) entry->id = 0; - wined3d_context_gl_destroy_fbo_entry(wined3d_context_gl(context), entry); - } - - LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry) - { - if (!context->valid) entry->id = 0; - wined3d_context_gl_destroy_fbo_entry(wined3d_context_gl(context), entry); - } - context_restore_pixel_format(context); if (restore_ctx) { @@ -1375,6 +1362,7 @@ void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) struct wined3d_so_statistics_query *so_statistics_query; struct wined3d_timestamp_query *timestamp_query; struct wined3d_occlusion_query *occlusion_query; + struct fbo_entry *entry, *entry2; struct wined3d_fence *fence; HGLRC restore_ctx; HDC restore_dc; @@ -1495,6 +1483,20 @@ void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) occlusion_query->context_gl = NULL; } + LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->fbo_destroy_list, struct fbo_entry, entry) + { + if (!context_gl->c.valid) + entry->id = 0; + wined3d_context_gl_destroy_fbo_entry(context_gl, entry); + } + + LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context_gl->fbo_list, struct fbo_entry, entry) + { + if (!context_gl->c.valid) + entry->id = 0; + wined3d_context_gl_destroy_fbo_entry(context_gl, entry); + } + heap_free(context_gl->texture_type); context_restore_pixel_format(&context_gl->c); @@ -1911,9 +1913,6 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d struct wined3d_device *device = swapchain->device; DWORD state; - list_init(&context->fbo_list); - list_init(&context->fbo_destroy_list); - if (!(context->hdc = GetDCEx(swapchain->win_handle, 0, DCX_USESTYLE | DCX_CACHE))) { WARN("Failed to retrieve device context, trying swapchain backup.\n"); @@ -1986,6 +1985,9 @@ HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wi gl_info = context->gl_info; d3d_info = context->d3d_info; + list_init(&context_gl->fbo_list); + list_init(&context_gl->fbo_destroy_list); + list_init(&context_gl->occlusion_queries); list_init(&context_gl->fences); list_init(&context_gl->timestamp_queries); @@ -2146,7 +2148,7 @@ HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wi } context->render_offscreen = wined3d_resource_is_offscreen(target); - context->draw_buffers_mask = context_generate_rt_mask(GL_BACK); + context_gl->draw_buffers_mask = context_generate_rt_mask(GL_BACK); context->valid = 1; context->glCtx = ctx; @@ -2515,11 +2517,11 @@ static void context_apply_draw_buffers(struct wined3d_context *context, DWORD rt void wined3d_context_gl_set_draw_buffer(struct wined3d_context_gl *context_gl, GLenum buffer) { const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; - struct fbo_entry *current_fbo = context_gl->c.current_fbo; + struct fbo_entry *current_fbo = context_gl->current_fbo; uint32_t new_mask = context_generate_rt_mask(buffer); uint32_t *current_mask; - current_mask = current_fbo ? &current_fbo->rt_mask : &context_gl->c.draw_buffers_mask; + current_mask = current_fbo ? &current_fbo->rt_mask : &context_gl->draw_buffers_mask; if (new_mask == *current_mask) return; @@ -2778,7 +2780,7 @@ void wined3d_context_gl_apply_blit_state(struct wined3d_context_gl *context_gl, } else { - context->current_fbo = NULL; + context_gl->current_fbo = NULL; wined3d_context_gl_bind_fbo(context_gl, GL_FRAMEBUFFER, 0); rt_mask = context_generate_rt_mask_from_resource(&rt->resource); } @@ -2788,7 +2790,7 @@ void wined3d_context_gl_apply_blit_state(struct wined3d_context_gl *context_gl, rt_mask = context_generate_rt_mask_no_fbo(context, &rt->resource); } - cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask; + cur_mask = context_gl->current_fbo ? &context_gl->current_fbo->rt_mask : &context_gl->draw_buffers_mask; if (rt_mask != *cur_mask) { @@ -3036,16 +3038,16 @@ BOOL wined3d_context_gl_apply_clear_state(struct wined3d_context_gl *context_gl, if (!rt_count || wined3d_resource_is_offscreen(rts[0]->resource)) { - memset(context_gl->c.blit_targets, 0, sizeof(context_gl->c.blit_targets)); + memset(context_gl->blit_targets, 0, sizeof(context_gl->blit_targets)); for (i = 0; i < rt_count; ++i) { if (rts[i]) { struct wined3d_rendertarget_view_gl *rtv_gl = wined3d_rendertarget_view_gl(rts[i]); - context_gl->c.blit_targets[i].gl_view = rtv_gl->gl_view; - context_gl->c.blit_targets[i].resource = rtv_gl->v.resource; - context_gl->c.blit_targets[i].sub_resource_idx = rtv_gl->v.sub_resource_idx; - context_gl->c.blit_targets[i].layer_count = rtv_gl->v.layer_count; + context_gl->blit_targets[i].gl_view = rtv_gl->gl_view; + context_gl->blit_targets[i].resource = rtv_gl->v.resource; + context_gl->blit_targets[i].sub_resource_idx = rtv_gl->v.sub_resource_idx; + context_gl->blit_targets[i].layer_count = rtv_gl->v.layer_count; } if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL) rt_mask |= (1u << i); @@ -3060,9 +3062,8 @@ BOOL wined3d_context_gl_apply_clear_state(struct wined3d_context_gl *context_gl, ds_info.layer_count = dsv_gl->v.layer_count; } - wined3d_context_gl_apply_fbo_state(context_gl, GL_FRAMEBUFFER, context_gl->c.blit_targets, &ds_info, - rt_count ? rts[0]->resource->draw_binding : 0, - dsv ? dsv->resource->draw_binding : 0); + wined3d_context_gl_apply_fbo_state(context_gl, GL_FRAMEBUFFER, context_gl->blit_targets, &ds_info, + rt_count ? rts[0]->resource->draw_binding : 0, dsv ? dsv->resource->draw_binding : 0); } else { @@ -3095,7 +3096,7 @@ BOOL wined3d_context_gl_apply_clear_state(struct wined3d_context_gl *context_gl, rt_mask = context_generate_rt_mask_no_fbo(&context_gl->c, rt_count ? rts[0]->resource : NULL); } - cur_mask = context_gl->c.current_fbo ? &context_gl->c.current_fbo->rt_mask : &context_gl->c.draw_buffers_mask; + cur_mask = context_gl->current_fbo ? &context_gl->current_fbo->rt_mask : &context_gl->draw_buffers_mask; if (rt_mask != *cur_mask) { @@ -3182,17 +3183,17 @@ void context_state_fb(struct wined3d_context *context, const struct wined3d_stat const struct wined3d_rendertarget_view_gl *view_gl; unsigned int i; - memset(context->blit_targets, 0, sizeof(context->blit_targets)); + memset(context_gl->blit_targets, 0, sizeof(context_gl->blit_targets)); for (i = 0; i < context->gl_info->limits.buffers; ++i) { if (!fb->render_targets[i]) continue; view_gl = wined3d_rendertarget_view_gl(fb->render_targets[i]); - context->blit_targets[i].gl_view = view_gl->gl_view; - context->blit_targets[i].resource = view_gl->v.resource; - context->blit_targets[i].sub_resource_idx = view_gl->v.sub_resource_idx; - context->blit_targets[i].layer_count = view_gl->v.layer_count; + context_gl->blit_targets[i].gl_view = view_gl->gl_view; + context_gl->blit_targets[i].resource = view_gl->v.resource; + context_gl->blit_targets[i].sub_resource_idx = view_gl->v.sub_resource_idx; + context_gl->blit_targets[i].layer_count = view_gl->v.layer_count; if (!color_location) color_location = view_gl->v.resource->draw_binding; @@ -3207,12 +3208,12 @@ void context_state_fb(struct wined3d_context *context, const struct wined3d_stat ds_info.layer_count = view_gl->v.layer_count; } - wined3d_context_gl_apply_fbo_state(context_gl, GL_FRAMEBUFFER, context->blit_targets, &ds_info, + wined3d_context_gl_apply_fbo_state(context_gl, GL_FRAMEBUFFER, context_gl->blit_targets, &ds_info, color_location, fb->depth_stencil ? fb->depth_stencil->resource->draw_binding : 0); } } - cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask; + cur_mask = context_gl->current_fbo ? &context_gl->current_fbo->rt_mask : &context_gl->draw_buffers_mask; if (rt_mask != *cur_mask) { context_apply_draw_buffers(context, rt_mask); @@ -3462,11 +3463,12 @@ static void wined3d_context_gl_update_tex_unit_map(struct wined3d_context_gl *co /* Context activation is done by the caller. */ void context_state_drawbuf(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); DWORD rt_mask, *cur_mask; if (isStateDirty(context, STATE_FRAMEBUFFER)) return; - cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask; + cur_mask = context_gl->current_fbo ? &context_gl->current_fbo->rt_mask : &context_gl->draw_buffers_mask; rt_mask = find_draw_buffers_mask(context, state); if (rt_mask != *cur_mask) { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 34fa1d3ef33..94765cb0c3a 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1924,11 +1924,10 @@ struct wined3d_context DWORD fixed_function_usage_map : 8; /* WINED3D_MAX_TEXTURES, 8 */ DWORD lowest_disabled_stage : 4; /* Max WINED3D_MAX_TEXTURES, 8 */ DWORD use_immediate_mode_draw : 1; - DWORD rebind_fbo : 1; DWORD needs_set : 1; DWORD hdc_is_private : 1; - DWORD hdc_has_format : 1; /* only meaningful if hdc_is_private */ + DWORD update_shader_resource_bindings : 1; DWORD update_compute_shader_resource_bindings : 1; DWORD update_unordered_access_view_bindings : 1; @@ -1939,7 +1938,7 @@ struct wined3d_context DWORD shader_update_mask : 6; /* WINED3D_SHADER_TYPE_COUNT, 6 */ DWORD clip_distance_mask : 8; /* WINED3D_MAX_CLIP_DISTANCES, 8 */ DWORD num_untracked_materials : 2; /* Max value 2 */ - DWORD padding : 8; + DWORD padding : 9; DWORD constant_update_mask; DWORD numbered_array_mask; @@ -1966,16 +1965,6 @@ struct wined3d_context void *shader_backend_data; void *fragment_pipe_data; - /* FBOs */ - UINT fbo_entry_count; - struct list fbo_list; - struct list fbo_destroy_list; - struct fbo_entry *current_fbo; - GLuint fbo_read_binding; - GLuint fbo_draw_binding; - struct wined3d_rendertarget_info blit_targets[MAX_RENDER_TARGET_VIEWS]; - DWORD draw_buffers_mask; /* Enabled draw buffers, 31 max. */ - struct wined3d_stream_info stream_info; /* Fences for GL_APPLE_flush_buffer_range */ @@ -1997,12 +1986,23 @@ struct wined3d_context_gl uint32_t fog_enabled : 1; uint32_t diffuse_attrib_to_1 : 1; - uint32_t padding : 30; + uint32_t rebind_fbo : 1; + uint32_t padding : 29; uint32_t default_attrib_value_set; GLenum *texture_type; + /* FBOs. */ + unsigned int fbo_entry_count; + struct list fbo_list; + struct list fbo_destroy_list; + struct fbo_entry *current_fbo; + GLuint fbo_read_binding; + GLuint fbo_draw_binding; + struct wined3d_rendertarget_info blit_targets[MAX_RENDER_TARGET_VIEWS]; + uint32_t draw_buffers_mask; /* Enabled draw buffers, 31 max. */ + /* Queries. */ struct list occlusion_queries; struct list fences; -- 2.11.0

1 0

[PATCH 1/2] gdi32: Add tests for CreatePolyPolygonRgn
by Fabian Maurer 19 May '19

19 May '19

Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/gdi32/tests/Makefile.in | 3 +- dlls/gdi32/tests/region.c | 68 ++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 dlls/gdi32/tests/region.c diff --git a/dlls/gdi32/tests/Makefile.in b/dlls/gdi32/tests/Makefile.in index 90d7223f47..e97df6f843 100644 --- a/dlls/gdi32/tests/Makefile.in +++ b/dlls/gdi32/tests/Makefile.in @@ -15,7 +15,8 @@ C_SRCS = \ metafile.c \ palette.c \ path.c \ - pen.c + pen.c \ + region.c FONT_SRCS = \ vertical.sfd \ diff --git a/dlls/gdi32/tests/region.c b/dlls/gdi32/tests/region.c new file mode 100644 index 0000000000..90f91d4440 --- /dev/null +++ b/dlls/gdi32/tests/region.c @@ -0,0 +1,68 @@ +/* + * Unit test suite for region + * + * Copyright 2019 Fabian Maurer + * + * 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 <stdarg.h> +#include <stdio.h> + +#include "windef.h" +#include "winbase.h" +#include "wingdi.h" +#include "winuser.h" + +#include "wine/heap.h" +#include "wine/test.h" + +static void test_CreatePolyPolygonRgn(void) +{ + HRGN region; + POINT points_zero[] = { {0, 0}, {0, 0}, {0, 0} }; + POINT points_mixed[] = { {0, 0}, {0, 0}, {0, 0}, {6, 6}, {6, 6}, {6, 6} }; + POINT points_six[] = { {6, 6}, {6, 6}, {6, 6} }; + POINT points_line[] = { {1, 0}, {11, 0}, {21, 0}}; + INT counts_single_poly[] = { 3 }; + INT counts_two_poly[] = { 3, 3 }; + + /* When all polygons are just one point or line, return must not be NULL */ + + region = CreatePolyPolygonRgn(points_zero, counts_single_poly, ARRAY_SIZE(counts_single_poly), ALTERNATE); + todo_wine + ok (region != NULL, "region must not be NULL\n"); + DeleteObject(region); + + region = CreatePolyPolygonRgn(points_six, counts_single_poly, ARRAY_SIZE(counts_single_poly), ALTERNATE); + todo_wine + ok (region != NULL, "region must not be NULL\n"); + DeleteObject(region); + + region = CreatePolyPolygonRgn(points_line, counts_single_poly, ARRAY_SIZE(counts_single_poly), ALTERNATE); + todo_wine + ok (region != NULL, "region must not be NULL\n"); + DeleteObject(region); + + region = CreatePolyPolygonRgn(points_mixed, counts_two_poly, ARRAY_SIZE(counts_two_poly), ALTERNATE); + todo_wine + ok (region != NULL, "region must not be NULL\n"); + DeleteObject(region); +} + +START_TEST(region) +{ + test_CreatePolyPolygonRgn(); +} -- 2.21.0

1 1

[PATCH] joy.cpl: Check if effect is allocated before releasing it
by Tim Schumacher 19 May '19

19 May '19

Since IDirectInputEffect_Release(obj) is just a macro for (obj)->Release(), the program crashes if the effect we are trying to release is null. This mostly happens when the effect failed to allocate in the first place. Signed-off-by: Tim Schumacher <timschumi(a)gmx.de> --- dlls/joy.cpl/main.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/dlls/joy.cpl/main.c b/dlls/joy.cpl/main.c index 9768917641..06084f3166 100644 --- a/dlls/joy.cpl/main.c +++ b/dlls/joy.cpl/main.c @@ -137,7 +137,8 @@ static void destroy_joysticks(struct JoystickData *data) if (data->joysticks[i].forcefeedback && data->joysticks[i].num_effects > 0) { for (j = 0; j < data->joysticks[i].num_effects; j++) - IDirectInputEffect_Release(data->joysticks[i].effects[j].effect); + if (data->joysticks[i].effects[j].effect) + IDirectInputEffect_Release(data->joysticks[i].effects[j].effect); HeapFree(GetProcessHeap(), 0, data->joysticks[i].effects); } -- 2.21.0

2 4

[PATCH v2 1/7] quartz/tests: Add some tests for IMediaSeeking on the filter graph.
by Zebediah Figura 19 May '19

19 May '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 441 +++++++++++++++++++++++++++++++- 1 file changed, 427 insertions(+), 14 deletions(-) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 6b6d8aeb20..f63f7386b4 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -26,6 +26,8 @@ #include "wine/heap.h" #include "wine/test.h" +static const GUID testguid = {0xabbccdde}; + typedef struct TestFilterImpl { IBaseFilter IBaseFilter_iface; @@ -1165,6 +1167,10 @@ struct testfilter ULONG misc_flags; IMediaSeeking IMediaSeeking_iface; + DWORD seek_caps; + BOOL support_testguid; + LONGLONG seek_duration, seek_current, seek_stop; + double seek_rate; }; static inline struct testfilter *impl_from_IEnumPins(IEnumPins *iface) @@ -1520,8 +1526,10 @@ static ULONG WINAPI testseek_Release(IMediaSeeking *iface) static HRESULT WINAPI testseek_GetCapabilities(IMediaSeeking *iface, DWORD *caps) { + struct testfilter *filter = impl_from_IMediaSeeking(iface); if (winetest_debug > 1) trace("%p->GetCapabilities()\n", iface); - return E_NOTIMPL; + *caps = filter->seek_caps; + return S_OK; } static HRESULT WINAPI testseek_CheckCapabilities(IMediaSeeking *iface, DWORD *caps) @@ -1532,13 +1540,16 @@ static HRESULT WINAPI testseek_CheckCapabilities(IMediaSeeking *iface, DWORD *ca static HRESULT WINAPI testseek_IsFormatSupported(IMediaSeeking *iface, const GUID *format) { + struct testfilter *filter = impl_from_IMediaSeeking(iface); if (winetest_debug > 1) trace("%p->IsFormatSupported(%s)\n", iface, wine_dbgstr_guid(format)); + if (IsEqualGUID(format, &testguid) && !filter->support_testguid) + return S_FALSE; return S_OK; } static HRESULT WINAPI testseek_QueryPreferredFormat(IMediaSeeking *iface, GUID *format) { - ok(0, "Unexpected call.\n"); + if (winetest_debug > 1) trace("%p->QueryPreferredFormat()\n", iface); return E_NOTIMPL; } @@ -1551,25 +1562,32 @@ static HRESULT WINAPI testseek_GetTimeFormat(IMediaSeeking *iface, GUID *format) static HRESULT WINAPI testseek_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *format) { if (winetest_debug > 1) trace("%p->IsUsingTimeFormat(%s)\n", iface, wine_dbgstr_guid(format)); - return S_FALSE; + return S_OK; } static HRESULT WINAPI testseek_SetTimeFormat(IMediaSeeking *iface, const GUID *format) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetTimeFormat(%s)\n", iface, wine_dbgstr_guid(format)); + if (IsEqualGUID(format, &testguid) && !filter->support_testguid) + return E_INVALIDARG; + return S_OK; } static HRESULT WINAPI testseek_GetDuration(IMediaSeeking *iface, LONGLONG *duration) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->GetDuration()\n", iface); + *duration = filter->seek_duration; + return S_OK; } static HRESULT WINAPI testseek_GetStopPosition(IMediaSeeking *iface, LONGLONG *stop) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->GetStopPosition()\n", iface); + *stop = filter->seek_stop; + return S_OK; } static HRESULT WINAPI testseek_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *current) @@ -1588,8 +1606,14 @@ static HRESULT WINAPI testseek_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG static HRESULT WINAPI testseek_SetPositions(IMediaSeeking *iface, LONGLONG *current, DWORD current_flags, LONGLONG *stop, DWORD stop_flags ) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetPositions(%s, %#x, %s, %#x)\n", + iface, wine_dbgstr_longlong(*current), current_flags, wine_dbgstr_longlong(*stop), stop_flags); + filter->seek_current = *current; + filter->seek_stop = *stop; + *current = 0x1234; + *stop = 0x4321; + return S_OK; } static HRESULT WINAPI testseek_GetPositions(IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop) @@ -1606,8 +1630,10 @@ static HRESULT WINAPI testseek_GetAvailable(IMediaSeeking *iface, LONGLONG *earl static HRESULT WINAPI testseek_SetRate(IMediaSeeking *iface, double rate) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetRate(%.16e)\n", iface, rate); + filter->seek_rate = rate; + return S_OK; } static HRESULT WINAPI testseek_GetRate(IMediaSeeking *iface, double *rate) @@ -1618,7 +1644,7 @@ static HRESULT WINAPI testseek_GetRate(IMediaSeeking *iface, double *rate) static HRESULT WINAPI testseek_GetPreroll(IMediaSeeking *iface, LONGLONG *preroll) { - ok(0, "Unexpected call.\n"); + if (winetest_debug > 1) trace("%p->GetPreroll()\n", iface); return E_NOTIMPL; } @@ -3217,6 +3243,392 @@ static void test_ec_complete(void) ok(filter3.ref == 1, "Got outstanding refcount %d.\n", filter3.ref); } +static void test_graph_seeking(void) +{ + struct testfilter filter1, filter2; + + LONGLONG time, current, stop, earliest, latest; + IFilterGraph2 *graph = create_graph(); + IMediaSeeking *seeking; + unsigned int i; + double rate; + GUID format; + HRESULT hr; + DWORD caps; + ULONG ref; + + static const GUID *const all_formats[] = + { + NULL, + &TIME_FORMAT_NONE, + &TIME_FORMAT_FRAME, + &TIME_FORMAT_SAMPLE, + &TIME_FORMAT_FIELD, + &TIME_FORMAT_BYTE, + &TIME_FORMAT_MEDIA_TIME, + &testguid, + }; + + static const GUID *const unsupported_formats[] = + { + &TIME_FORMAT_FRAME, + &TIME_FORMAT_SAMPLE, + &TIME_FORMAT_FIELD, + &TIME_FORMAT_BYTE, + &testguid, + }; + + testfilter_init(&filter1, NULL, 0); + testfilter_init(&filter2, NULL, 0); + + filter1.IMediaSeeking_iface.lpVtbl = &testseek_vtbl; + filter2.IMediaSeeking_iface.lpVtbl = &testseek_vtbl; + + IFilterGraph2_QueryInterface(graph, &IID_IMediaSeeking, (void **)&seeking); + + hr = IMediaSeeking_GetCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + caps = 0; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + ok(!caps, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanSeekAbsolute; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + hr = IMediaSeeking_IsFormatSupported(seeking, NULL); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(all_formats); ++i) + { + hr = IMediaSeeking_IsFormatSupported(seeking, all_formats[i]); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x for format %s.\n", hr, wine_dbgstr_guid(all_formats[i])); + } + + hr = IMediaSeeking_QueryPreferredFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_GetTimeFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_NONE); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_NONE); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_NONE); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(unsupported_formats); ++i) + { + hr = IMediaSeeking_SetTimeFormat(seeking, unsupported_formats[i]); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x for format %s.\n", hr, wine_dbgstr_guid(unsupported_formats[i])); + } + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, NULL); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, &TIME_FORMAT_NONE); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &testguid); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetDuration(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetDuration(seeking, &time); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetStopPosition(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetStopPosition(seeking, &time); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetPositions(seeking, &current, 0, &stop, 0); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetPositions(seeking, NULL, NULL); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetPositions(seeking, NULL, &stop); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + current = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, NULL); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + current = 0xdeadbeef; + hr = IMediaSeeking_GetCurrentPosition(seeking, &current); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetAvailable(seeking, &earliest, &latest); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetRate(seeking, 1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_SetRate(seeking, 2.0); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetRate(seeking, &rate); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(rate == 1.0, "Got rate %.16e.\n", rate); + + hr = IMediaSeeking_GetPreroll(seeking, &time); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + /* Try with filters added. Note that a filter need only expose + * IMediaSeeking—no other heuristics are used to determine if it is a + * renderer. */ + + IFilterGraph2_AddFilter(graph, &filter1.IBaseFilter_iface, NULL); + IFilterGraph2_AddFilter(graph, &filter2.IBaseFilter_iface, NULL); + + filter1.seek_caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetCurrentPos; + filter2.seek_caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetDuration; + hr = IMediaSeeking_GetCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetCurrentPos; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); + todo_wine ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanDoSegments; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanGetCurrentPos; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + filter1.support_testguid = TRUE; + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + filter1.support_testguid = FALSE; + filter2.support_testguid = TRUE; + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + /* Filters are not consulted about preferred formats. */ + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + filter2.support_testguid = FALSE; + hr = IMediaSeeking_SetTimeFormat(seeking, &testguid); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + filter1.support_testguid = TRUE; + hr = IMediaSeeking_SetTimeFormat(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(IsEqualGUID(&format, &testguid), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &testguid); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + filter1.seek_duration = 0x12345; + filter2.seek_duration = 0x23456; + hr = IMediaSeeking_GetDuration(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x23456, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter2.seek_duration = 0x12345; + filter1.seek_duration = 0x23456; + hr = IMediaSeeking_GetDuration(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x23456, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter1.seek_stop = 0x54321; + filter2.seek_stop = 0x65432; + hr = IMediaSeeking_GetStopPosition(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter2.seek_stop = 0x54321; + filter1.seek_stop = 0x65432; + hr = IMediaSeeking_GetStopPosition(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, &time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!time, "Got time %s.\n", wine_dbgstr_longlong(time)); + + current = stop = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(current)); + todo_wine ok(stop == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning, + &stop, AM_SEEKING_AbsolutePositioning); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, &time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(time)); + + current = stop = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning | AM_SEEKING_ReturnTime, + &stop, AM_SEEKING_AbsolutePositioning); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning, + &stop, AM_SEEKING_AbsolutePositioning | AM_SEEKING_ReturnTime); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(current)); + todo_wine ok(stop == 0x4321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x4321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + hr = IMediaSeeking_SetRate(seeking, 2.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == 2.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == 2.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_SetRate(seeking, 1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == 1.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == 1.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_SetRate(seeking, -1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == -1.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == -1.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_GetRate(seeking, &rate); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(rate == -1.0, "Got rate %.16e.\n", rate); + + IMediaSeeking_Release(seeking); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", hr); + ok(filter1.ref == 1, "Got outstanding refcount %d.\n", filter1.ref); + ok(filter2.ref == 1, "Got outstanding refcount %d.\n", filter2.ref); +} + START_TEST(filtergraph) { CoInitializeEx(NULL, COINIT_MULTITHREADED); @@ -3236,6 +3648,7 @@ START_TEST(filtergraph) test_sync_source(); test_filter_state(); test_ec_complete(); + test_graph_seeking(); CoUninitialize(); test_render_with_multithread(); -- 2.21.0

2 8

[PATCH] joy.cpl: Fix high CPU load in FF test window
by Tim Schumacher 18 May '19

18 May '19

If no effects are in the effects list, the loop in ff_input_thread is immediately restarted, skipping the poll interval. This causes an incredibly high refresh rate, which maxes out at least one CPU core. Move the Sleep call to the top of the loop, so that it is always done, no matter if there are effects listed or not. Additionally, this fixes a race condition that crashes the program when the thread is closed. Signed-off-by: Tim Schumacher <timschumi(a)gmx.de> --- dlls/joy.cpl/main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/joy.cpl/main.c b/dlls/joy.cpl/main.c index 32dfad0eb5..9768917641 100644 --- a/dlls/joy.cpl/main.c +++ b/dlls/joy.cpl/main.c @@ -677,6 +677,8 @@ static DWORD WINAPI ff_input_thread(void *param) DWORD flags = DIEP_AXES | DIEP_DIRECTION | DIEP_NORESTART; RECT r; + Sleep(TEST_POLL_TIME); + /* Skip this if we have no effects */ if (joy->num_effects == 0 || chosen_effect < 0) continue; @@ -701,8 +703,6 @@ static DWORD WINAPI ff_input_thread(void *param) IDirectInputEffect_Start(joy->effects[chosen_effect].effect, 1, 0); break; } - - Sleep(TEST_POLL_TIME); } return 0; -- 2.21.0

1 0

[PATCH] comctl32: Always free the tooltip text before setting it (Valgrind).
by Sven Baars 18 May '19

18 May '19

Signed-off-by: Sven Baars <sven.wine(a)gmail.com> --- dlls/comctl32/tooltips.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/dlls/comctl32/tooltips.c b/dlls/comctl32/tooltips.c index 1aa55d12e3..b1e8f5147a 100644 --- a/dlls/comctl32/tooltips.c +++ b/dlls/comctl32/tooltips.c @@ -1660,6 +1660,13 @@ TOOLTIPS_SetToolInfoT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW) toolPtr->rect = ti->rect; toolPtr->hinst = ti->hinst; + if ( (toolPtr->lpszText) && + !IS_INTRESOURCE(toolPtr->lpszText) ) { + if( toolPtr->lpszText != LPSTR_TEXTCALLBACKW) + Free (toolPtr->lpszText); + toolPtr->lpszText = NULL; + } + if (IS_INTRESOURCE(ti->lpszText)) { TRACE("set string id %x\n", LOWORD(ti->lpszText)); toolPtr->lpszText = ti->lpszText; @@ -1668,12 +1675,6 @@ TOOLTIPS_SetToolInfoT (TOOLTIPS_INFO *infoPtr, const TTTOOLINFOW *ti, BOOL isW) if (ti->lpszText == LPSTR_TEXTCALLBACKW) toolPtr->lpszText = LPSTR_TEXTCALLBACKW; else { - if ( (toolPtr->lpszText) && - !IS_INTRESOURCE(toolPtr->lpszText) ) { - if( toolPtr->lpszText != LPSTR_TEXTCALLBACKW) - Free (toolPtr->lpszText); - toolPtr->lpszText = NULL; - } if (ti->lpszText) { if (isW) { INT len = lstrlenW (ti->lpszText); -- 2.17.1

1 0

[PATCH vkd3d] vkd3d-shader: Parse ISG1, PSG1 and OSG1 signatures
by Philip Rebohle 18 May '19

18 May '19

These signatures extend the OSG5 format by a minimum precision hint, which gets ignored for now but could be implemented using 16-bit floats in the future. Fixes some shader parsing errors in Resident Evil 2. Signed-off-by: Philip Rebohle <philip.rebohle(a)tu-dortmund.de> --- include/vkd3d_shader.h | 1 + libs/vkd3d-shader/dxbc.c | 21 ++++++++++++++++++--- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index 28c3274..318a438 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -580,6 +580,7 @@ struct vkd3d_shader_signature_element enum vkd3d_component_type component_type; unsigned int register_index; unsigned int mask; + unsigned int min_precision; }; struct vkd3d_shader_signature diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 520e208..92ea174 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1852,9 +1852,12 @@ bool shader_sm4_is_end(void *data, const DWORD **ptr) ((DWORD)(ch2) << 16) | ((DWORD)(ch3) << 24 )) #define TAG_DXBC MAKE_TAG('D', 'X', 'B', 'C') #define TAG_ISGN MAKE_TAG('I', 'S', 'G', 'N') +#define TAG_ISG1 MAKE_TAG('I', 'S', 'G', '1') #define TAG_OSGN MAKE_TAG('O', 'S', 'G', 'N') #define TAG_OSG5 MAKE_TAG('O', 'S', 'G', '5') +#define TAG_OSG1 MAKE_TAG('O', 'S', 'G', '1') #define TAG_PCSG MAKE_TAG('P', 'C', 'S', 'G') +#define TAG_PSG1 MAKE_TAG('P', 'S', 'G', '1') #define TAG_SHDR MAKE_TAG('S', 'H', 'D', 'R') #define TAG_SHEX MAKE_TAG('S', 'H', 'E', 'X') #define TAG_AON9 MAKE_TAG('A', 'o', 'n', '9') @@ -1993,6 +1996,7 @@ static int shader_parse_signature(DWORD tag, const char *data, DWORD data_size, const char *ptr = data; unsigned int i; DWORD count; + bool has_stream_index, has_min_precision; if (!require_space(0, 2, sizeof(DWORD), data_size)) { @@ -2017,11 +2021,14 @@ static int shader_parse_signature(DWORD tag, const char *data, DWORD data_size, return VKD3D_ERROR_OUT_OF_MEMORY; } + has_min_precision = tag == TAG_OSG1 || tag == TAG_PSG1 || tag == TAG_ISG1; + has_stream_index = tag == TAG_OSG5 || has_min_precision; + for (i = 0; i < count; ++i) { DWORD name_offset; - if (tag == TAG_OSG5) + if (has_stream_index) read_dword(&ptr, &e[i].stream_index); else e[i].stream_index = 0; @@ -2038,10 +2045,15 @@ static int shader_parse_signature(DWORD tag, const char *data, DWORD data_size, read_dword(&ptr, &e[i].register_index); read_dword(&ptr, &e[i].mask); + if (has_min_precision) + read_dword(&ptr, &e[i].min_precision); + else + e[i].min_precision = 0; + TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, " - "type %u, register idx: %u, use_mask %#x, input_mask %#x.\n", + "type %u, register idx: %u, use_mask %#x, input_mask %#x, precision %u.\n", e[i].stream_index, debugstr_a(e[i].semantic_name), e[i].semantic_index, e[i].sysval_semantic, - e[i].component_type, e[i].register_index, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff); + e[i].component_type, e[i].register_index, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff, e[i].min_precision); } s->elements = e; @@ -2084,6 +2096,7 @@ static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *cont switch (tag) { case TAG_ISGN: + case TAG_ISG1: if (desc->input_signature.elements) { FIXME("Multiple input signatures.\n"); @@ -2095,6 +2108,7 @@ static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *cont case TAG_OSGN: case TAG_OSG5: + case TAG_OSG1: if (desc->output_signature.elements) { FIXME("Multiple output signatures.\n"); @@ -2105,6 +2119,7 @@ static int shdr_handler(const char *data, DWORD data_size, DWORD tag, void *cont break; case TAG_PCSG: + case TAG_PSG1: if (desc->patch_constant_signature.elements) { FIXME("Multiple patch constant signatures.\n"); -- 2.21.0

2 1

[PATCH 1/5] server: Added support for tracking registered device notifications
by Micah N Gorrell 18 May '19

18 May '19

Signed-off-by: Micah N Gorrell <mgorrell(a)codeweavers.com> --- server/protocol.def | 23 ++++++++++ server/user.h | 3 +- server/window.c | 108 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 133 insertions(+), 1 deletion(-) diff --git a/server/protocol.def b/server/protocol.def index 21008d7a87..314a4477d0 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3684,6 +3684,29 @@ struct handle_info @END +/* Register a handle for device notifications */ +@REQ(register_device_notification) + user_handle_t recipient; /* handle to a window or service that will receive device events */ +@REPLY + user_handle_t handle; /* handle associated with the registration */ +@END + + +/* Unregister device notifications for a handle */ +@REQ(unregister_device_notification) + user_handle_t notification; /* handle that was previously returned by register_device_notification */ +@END + + +/* Return a list of handles that have registered for device notifications */ +@REQ(get_device_notifications) +@REPLY + int count; /* total count of registered handles */ + VARARG(handles,user_handles); /* registered handles */ +@END + + + /* Make the current process a system process */ @REQ(make_process_system) @REPLY diff --git a/server/user.h b/server/user.h index eb1b7ce1e4..282cb63339 100644 --- a/server/user.h +++ b/server/user.h @@ -36,7 +36,8 @@ enum user_object { USER_WINDOW = 1, USER_HOOK, - USER_CLIENT /* arbitrary client handle */ + USER_CLIENT, /* arbitrary client handle */ + USER_DEVNOTIFY }; #define DESKTOP_ATOM ((atom_t)32769) diff --git a/server/window.c b/server/window.c index c9b131cba5..5116fb12ff 100644 --- a/server/window.c +++ b/server/window.c @@ -129,6 +129,18 @@ static struct window *taskman_window; #define WINPTR_TOPMOST ((struct window *)3L) #define WINPTR_NOTOPMOST ((struct window *)4L) +struct device_notification +{ + user_handle_t recipient; /* the window handle to send notifications to */ + user_handle_t handle; /* full handle for this window */ + struct list entry; /* entry in global notifications list */ + + /* FIXME: Add support for notification filters */ +}; + +/* global list of handles that have registered for device notifications */ +static struct list device_notifications = LIST_INIT(device_notifications); + /* retrieve a pointer to a window from its handle */ static inline struct window *get_window( user_handle_t handle ) { @@ -2880,3 +2892,99 @@ DECL_HANDLER(set_window_layered_info) } else set_win32_error( ERROR_INVALID_WINDOW_HANDLE ); } + +/* retrieve a pointer to a device_notification from its handle */ +static inline struct device_notification *get_device_notification( user_handle_t handle ) +{ + struct device_notification *ret = get_user_object( handle, USER_DEVNOTIFY ); + if (!ret) set_win32_error( ERROR_INVALID_HANDLE ); + return ret; +} + +/* create a new device notification structure and link it into the global list */ +static struct device_notification *register_device_notification( struct window *recipient ) +{ + struct device_notification *notification; + + if (!recipient) + { + return NULL; + } + + if (!(notification = mem_alloc( sizeof(*notification) ))) goto failed; + if (!(notification->handle = alloc_user_handle( notification, USER_DEVNOTIFY ))) goto failed; + + notification->recipient = recipient->handle; + /* FIXME: Add support for notification filters */ + + list_add_tail( &device_notifications, &notification->entry ); + + return notification; +failed: + if (notification) + { + if (notification->handle) free_user_handle( notification->handle ); + free( notification ); + } + + return NULL; +} + +static void unregister_device_notification( struct device_notification *notification) +{ + list_remove( &notification->entry ); + free_user_handle( notification->handle ); + memset( notification, 0x55, sizeof(*notification) ); + free( notification ); +} + +static int get_device_notifications( struct user_handle_array *array ) +{ + struct device_notification *notification; + + LIST_FOR_EACH_ENTRY( notification, &device_notifications, struct device_notification, entry ) + { + /* FIXME: Implement notification filtering */ + if (!add_handle_to_array( array, notification->recipient )) return 0; + } + + return 1; +} + +/* register for device notifications */ +DECL_HANDLER(register_device_notification) +{ + struct device_notification *notification = NULL; + struct window *recipient = get_window( req->recipient ); + + reply->handle = 0; + if (!recipient) return; + + if (!(notification = register_device_notification( recipient ))) return; + + reply->handle = notification->handle; +} + +DECL_HANDLER(unregister_device_notification) +{ + struct device_notification *notification = get_device_notification( req->notification ); + if (notification) unregister_device_notification(notification); +} + +DECL_HANDLER(get_device_notifications) +{ + struct user_handle_array array; + data_size_t len; + + array.handles = NULL; + array.count = 0; + array.total = 0; + + if (!get_device_notifications( &array )) return; + + reply->count = array.count; + len = min( get_reply_max_size(), array.count * sizeof(user_handle_t) ); + if (len) set_reply_data_ptr( array.handles, len ); + else free( array.handles ); +} + -- 2.21.0

2 7

[PATCH 1/7] quartz/tests: Add some tests for IMediaSeeking on the filter graph.
by Zebediah Figura 17 May '19

17 May '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/quartz/tests/filtergraph.c | 439 +++++++++++++++++++++++++++++++- 1 file changed, 426 insertions(+), 13 deletions(-) diff --git a/dlls/quartz/tests/filtergraph.c b/dlls/quartz/tests/filtergraph.c index 6b6d8aeb20..08a3fc5c78 100644 --- a/dlls/quartz/tests/filtergraph.c +++ b/dlls/quartz/tests/filtergraph.c @@ -26,6 +26,8 @@ #include "wine/heap.h" #include "wine/test.h" +static const GUID testguid = {0xabbccdde}; + typedef struct TestFilterImpl { IBaseFilter IBaseFilter_iface; @@ -1165,6 +1167,10 @@ struct testfilter ULONG misc_flags; IMediaSeeking IMediaSeeking_iface; + DWORD seek_caps; + BOOL support_testguid; + LONGLONG seek_duration, seek_current, seek_stop; + double seek_rate; }; static inline struct testfilter *impl_from_IEnumPins(IEnumPins *iface) @@ -1520,8 +1526,10 @@ static ULONG WINAPI testseek_Release(IMediaSeeking *iface) static HRESULT WINAPI testseek_GetCapabilities(IMediaSeeking *iface, DWORD *caps) { + struct testfilter *filter = impl_from_IMediaSeeking(iface); if (winetest_debug > 1) trace("%p->GetCapabilities()\n", iface); - return E_NOTIMPL; + *caps = filter->seek_caps; + return S_OK; } static HRESULT WINAPI testseek_CheckCapabilities(IMediaSeeking *iface, DWORD *caps) @@ -1532,13 +1540,16 @@ static HRESULT WINAPI testseek_CheckCapabilities(IMediaSeeking *iface, DWORD *ca static HRESULT WINAPI testseek_IsFormatSupported(IMediaSeeking *iface, const GUID *format) { + struct testfilter *filter = impl_from_IMediaSeeking(iface); if (winetest_debug > 1) trace("%p->IsFormatSupported(%s)\n", iface, wine_dbgstr_guid(format)); + if (IsEqualGUID(format, &testguid) && !filter->support_testguid) + return S_FALSE; return S_OK; } static HRESULT WINAPI testseek_QueryPreferredFormat(IMediaSeeking *iface, GUID *format) { - ok(0, "Unexpected call.\n"); + if (winetest_debug > 1) trace("%p->QueryPreferredFormat()\n", iface); return E_NOTIMPL; } @@ -1551,25 +1562,32 @@ static HRESULT WINAPI testseek_GetTimeFormat(IMediaSeeking *iface, GUID *format) static HRESULT WINAPI testseek_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *format) { if (winetest_debug > 1) trace("%p->IsUsingTimeFormat(%s)\n", iface, wine_dbgstr_guid(format)); - return S_FALSE; + return S_OK; } static HRESULT WINAPI testseek_SetTimeFormat(IMediaSeeking *iface, const GUID *format) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetTimeFormat(%s)\n", iface, wine_dbgstr_guid(format)); + if (IsEqualGUID(format, &testguid) && !filter->support_testguid) + return E_INVALIDARG; + return S_OK; } static HRESULT WINAPI testseek_GetDuration(IMediaSeeking *iface, LONGLONG *duration) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->GetDuration()\n", iface); + *duration = filter->seek_duration; + return S_OK; } static HRESULT WINAPI testseek_GetStopPosition(IMediaSeeking *iface, LONGLONG *stop) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->GetStopPosition()\n", iface); + *stop = filter->seek_stop; + return S_OK; } static HRESULT WINAPI testseek_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *current) @@ -1588,8 +1606,14 @@ static HRESULT WINAPI testseek_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG static HRESULT WINAPI testseek_SetPositions(IMediaSeeking *iface, LONGLONG *current, DWORD current_flags, LONGLONG *stop, DWORD stop_flags ) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetPositions(%s, %#x, %s, %#x)\n", + iface, wine_dbgstr_longlong(*current), current_flags, wine_dbgstr_longlong(*stop), stop_flags); + filter->seek_current = *current; + filter->seek_stop = *stop; + *current = 0x1234; + *stop = 0x4321; + return S_OK; } static HRESULT WINAPI testseek_GetPositions(IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop) @@ -1606,8 +1630,10 @@ static HRESULT WINAPI testseek_GetAvailable(IMediaSeeking *iface, LONGLONG *earl static HRESULT WINAPI testseek_SetRate(IMediaSeeking *iface, double rate) { - ok(0, "Unexpected call.\n"); - return E_NOTIMPL; + struct testfilter *filter = impl_from_IMediaSeeking(iface); + if (winetest_debug > 1) trace("%p->SetRate(%.16e)\n", iface, rate); + filter->seek_rate = rate; + return S_OK; } static HRESULT WINAPI testseek_GetRate(IMediaSeeking *iface, double *rate) @@ -3217,6 +3243,392 @@ static void test_ec_complete(void) ok(filter3.ref == 1, "Got outstanding refcount %d.\n", filter3.ref); } +static void test_graph_seeking(void) +{ + struct testfilter filter1, filter2; + + LONGLONG time, current, stop, earliest, latest; + IFilterGraph2 *graph = create_graph(); + IMediaSeeking *seeking; + unsigned int i; + double rate; + GUID format; + HRESULT hr; + DWORD caps; + ULONG ref; + + static const GUID *const all_formats[] = + { + NULL, + &TIME_FORMAT_NONE, + &TIME_FORMAT_FRAME, + &TIME_FORMAT_SAMPLE, + &TIME_FORMAT_FIELD, + &TIME_FORMAT_BYTE, + &TIME_FORMAT_MEDIA_TIME, + &testguid, + }; + + static const GUID *const unsupported_formats[] = + { + &TIME_FORMAT_FRAME, + &TIME_FORMAT_SAMPLE, + &TIME_FORMAT_FIELD, + &TIME_FORMAT_BYTE, + &testguid, + }; + + testfilter_init(&filter1, NULL, 0); + testfilter_init(&filter2, NULL, 0); + + filter1.IMediaSeeking_iface.lpVtbl = &testseek_vtbl; + filter2.IMediaSeeking_iface.lpVtbl = &testseek_vtbl; + + IFilterGraph2_QueryInterface(graph, &IID_IMediaSeeking, (void **)&seeking); + + hr = IMediaSeeking_GetCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + caps = 0; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + ok(!caps, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanSeekAbsolute; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + hr = IMediaSeeking_IsFormatSupported(seeking, NULL); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(all_formats); ++i) + { + hr = IMediaSeeking_IsFormatSupported(seeking, all_formats[i]); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x for format %s.\n", hr, wine_dbgstr_guid(all_formats[i])); + } + + hr = IMediaSeeking_QueryPreferredFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_GetTimeFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_NONE); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_NONE); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_NONE); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(unsupported_formats); ++i) + { + hr = IMediaSeeking_SetTimeFormat(seeking, unsupported_formats[i]); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x for format %s.\n", hr, wine_dbgstr_guid(unsupported_formats[i])); + } + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, NULL); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, &TIME_FORMAT_MEDIA_TIME); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, NULL); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_MEDIA_TIME, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, NULL, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &TIME_FORMAT_NONE, 0x123456789a, &TIME_FORMAT_NONE); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &testguid); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetDuration(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetDuration(seeking, &time); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetStopPosition(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetStopPosition(seeking, &time); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetPositions(seeking, &current, 0, &stop, 0); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetPositions(seeking, NULL, NULL); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetPositions(seeking, NULL, &stop); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + current = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, NULL); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, NULL); + ok(hr == E_POINTER, "Got hr %#x.\n", hr); + current = 0xdeadbeef; + hr = IMediaSeeking_GetCurrentPosition(seeking, &current); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetAvailable(seeking, &earliest, &latest); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetRate(seeking, 1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaSeeking_SetRate(seeking, 2.0); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetRate(seeking, &rate); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(rate == 1.0, "Got rate %.16e.\n", rate); + + hr = IMediaSeeking_GetPreroll(seeking, &time); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + /* Try with filters added. Note that a filter need only expose + * IMediaSeeking—no other heuristics are used to determine if it is a + * renderer. */ + + IFilterGraph2_AddFilter(graph, &filter1.IBaseFilter_iface, NULL); + IFilterGraph2_AddFilter(graph, &filter2.IBaseFilter_iface, NULL); + + filter1.seek_caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetCurrentPos; + filter2.seek_caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetDuration; + hr = IMediaSeeking_GetCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanDoSegments | AM_SEEKING_CanGetCurrentPos; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); + todo_wine ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanDoSegments; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(caps == AM_SEEKING_CanDoSegments, "Got caps %#x.\n", caps); + + caps = AM_SEEKING_CanGetCurrentPos; + hr = IMediaSeeking_CheckCapabilities(seeking, &caps); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + todo_wine ok(!caps, "Got caps %#x.\n", caps); + + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + + filter1.support_testguid = TRUE; + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + filter1.support_testguid = FALSE; + filter2.support_testguid = TRUE; + hr = IMediaSeeking_IsFormatSupported(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + /* Filters are not consulted about preferred formats. */ + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + filter2.support_testguid = FALSE; + hr = IMediaSeeking_SetTimeFormat(seeking, &testguid); + todo_wine ok(hr == E_FAIL, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + filter1.support_testguid = TRUE; + hr = IMediaSeeking_SetTimeFormat(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_GetTimeFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(IsEqualGUID(&format, &testguid), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_QueryPreferredFormat(seeking, &format); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME), "Got format %s.\n", wine_dbgstr_guid(&format)); + + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + todo_wine ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaSeeking_IsUsingTimeFormat(seeking, &testguid); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSeeking_SetTimeFormat(seeking, &TIME_FORMAT_MEDIA_TIME); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + time = 0xdeadbeef; + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &testguid); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(time == 0x123456789a, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_ConvertTimeFormat(seeking, &time, &testguid, 0x123456789a, &TIME_FORMAT_NONE); + todo_wine ok(hr == E_NOTIMPL, "Got hr %#x.\n", hr); + + filter1.seek_duration = 0x12345; + filter2.seek_duration = 0x23456; + hr = IMediaSeeking_GetDuration(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x23456, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter2.seek_duration = 0x12345; + filter1.seek_duration = 0x23456; + hr = IMediaSeeking_GetDuration(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x23456, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter1.seek_stop = 0x54321; + filter2.seek_stop = 0x65432; + hr = IMediaSeeking_GetStopPosition(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(time)); + + filter2.seek_stop = 0x54321; + filter1.seek_stop = 0x65432; + hr = IMediaSeeking_GetStopPosition(seeking, &time); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(time)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, &time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!time, "Got time %s.\n", wine_dbgstr_longlong(time)); + + current = stop = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(!current, "Got time %s.\n", wine_dbgstr_longlong(current)); + todo_wine ok(stop == 0x65432, "Got time %s.\n", wine_dbgstr_longlong(stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning, + &stop, AM_SEEKING_AbsolutePositioning); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + hr = IMediaSeeking_GetCurrentPosition(seeking, &time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(time == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(time)); + + current = stop = 0xdeadbeef; + hr = IMediaSeeking_GetPositions(seeking, &current, &stop); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning | AM_SEEKING_ReturnTime, + &stop, AM_SEEKING_AbsolutePositioning); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(current)); + ok(stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x1234, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + current = 0x123; + stop = 0x321; + hr = IMediaSeeking_SetPositions(seeking, &current, AM_SEEKING_AbsolutePositioning, + &stop, AM_SEEKING_AbsolutePositioning | AM_SEEKING_ReturnTime); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(current)); + todo_wine ok(stop == 0x4321, "Got time %s.\n", wine_dbgstr_longlong(stop)); + todo_wine ok(filter1.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_current)); + todo_wine ok(filter1.seek_stop == 0x4321, "Got time %s.\n", wine_dbgstr_longlong(filter1.seek_stop)); + todo_wine ok(filter2.seek_current == 0x123, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_current)); + todo_wine ok(filter2.seek_stop == 0x321, "Got time %s.\n", wine_dbgstr_longlong(filter2.seek_stop)); + + hr = IMediaSeeking_SetRate(seeking, 2.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == 2.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == 2.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_SetRate(seeking, 1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == 1.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == 1.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_SetRate(seeking, -1.0); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(filter1.seek_rate == -1.0, "Got rate %.16e.\n", filter1.seek_rate); + todo_wine ok(filter2.seek_rate == -1.0, "Got rate %.16e.\n", filter2.seek_rate); + + hr = IMediaSeeking_GetRate(seeking, &rate); + ok(hr == S_OK, "Got hr %#x.\n", hr); + todo_wine ok(rate == -1.0, "Got rate %.16e.\n", rate); + + IMediaSeeking_Release(seeking); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", hr); + ok(filter1.ref == 1, "Got outstanding refcount %d.\n", filter1.ref); + ok(filter2.ref == 1, "Got outstanding refcount %d.\n", filter2.ref); +} + START_TEST(filtergraph) { CoInitializeEx(NULL, COINIT_MULTITHREADED); @@ -3236,6 +3648,7 @@ START_TEST(filtergraph) test_sync_source(); test_filter_state(); test_ec_complete(); + test_graph_seeking(); CoUninitialize(); test_render_with_multithread(); -- 2.21.0

1 6

[PATCH 1/4] setupapi/tests: Add some tests for SetupInstallFile().
by Zebediah Figura 17 May '19

17 May '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/setupapi/tests/install.c | 91 +++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) diff --git a/dlls/setupapi/tests/install.c b/dlls/setupapi/tests/install.c index 85f532a78b..3677e0e530 100644 --- a/dlls/setupapi/tests/install.c +++ b/dlls/setupapi/tests/install.c @@ -1317,6 +1317,96 @@ static void run_queue_(unsigned int line, HSPFILEQ queue, PSP_FILE_CALLBACK_A cb ok_(__FILE__,line)(ret, "Failed to close queue, error %#x.\n", GetLastError()); } +static void test_install_file(void) +{ + static const char inf_data[] = "[Version]\n" + "Signature=\"$Chicago$\"\n" + "[section1]\n" + "one.txt\n" + "two.txt\n" + "three.txt\n" + "[SourceDisksNames]\n" + "1=heis\n" + "2=duo,,,alpha\n" + "[SourceDisksFiles]\n" + "one.txt=1\n" + "two.txt=1,beta\n" + "three.txt=2\n" + "[DestinationDirs]\n" + "DefaultDestDir=40000,dst\n"; + + char path[MAX_PATH]; + INFCONTEXT infctx; + HINF hinf; + BOOL ret; + + create_inf_file(inffile, inf_data); + + sprintf(path, "%s\\%s", CURR_DIR, inffile); + hinf = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); + ok(hinf != INVALID_HANDLE_VALUE, "Failed to open INF file, error %#x.\n", GetLastError()); + + ret = CreateDirectoryA("src", NULL); + ok(ret, "Failed to create test directory, error %u.\n", GetLastError()); + ret = CreateDirectoryA("src/alpha", NULL); + ok(ret, "Failed to create test directory, error %u.\n", GetLastError()); + ret = CreateDirectoryA("src/beta", NULL); + ok(ret, "Failed to create test directory, error %u.\n", GetLastError()); + ret = CreateDirectoryA("dst", NULL); + ok(ret, "Failed to create test directory, error %u.\n", GetLastError()); + create_file("src/one.txt"); + create_file("src/beta/two.txt"); + create_file("src/alpha/three.txt"); + + ret = SetupFindFirstLineA(hinf, "section1", "one.txt", &infctx); + ok(ret, "Failed to find line.\n"); + SetLastError(0xdeadbeef); + ret = SetupInstallFileA(hinf, &infctx, "one.txt", "src", "one.txt", 0, NULL, NULL); + ok(ret, "Expected success.\n"); + ok(GetLastError() == ERROR_SUCCESS, "Got unexpected error %#x.\n", GetLastError()); + todo_wine ok(delete_file("dst/one.txt"), "Destination file should exist.\n"); + + SetLastError(0xdeadbeef); + ret = SetupInstallFileA(hinf, &infctx, "one.txt", "src", "one.txt", SP_COPY_REPLACEONLY, NULL, NULL); + todo_wine ok(!ret, "Expected failure.\n"); + todo_wine ok(GetLastError() == ERROR_SUCCESS, "Got unexpected error %#x.\n", GetLastError()); + ok(!file_exists("dst/one.txt"), "Destination file should not exist.\n"); + + ret = SetupFindFirstLineA(hinf, "section1", "two.txt", &infctx); + ok(ret, "Failed to find line.\n"); + SetLastError(0xdeadbeef); + ret = SetupInstallFileA(hinf, &infctx, "two.txt", "src", "two.txt", 0, NULL, NULL); + todo_wine ok(ret, "Expected success.\n"); + todo_wine ok(GetLastError() == ERROR_SUCCESS, "Got unexpected error %#x.\n", GetLastError()); + todo_wine ok(delete_file("dst/two.txt"), "Destination file should exist.\n"); + + ret = SetupFindFirstLineA(hinf, "section1", "three.txt", &infctx); + ok(ret, "Failed to find line.\n"); + SetLastError(0xdeadbeef); + ret = SetupInstallFileA(hinf, &infctx, "three.txt", "src", "three.txt", 0, NULL, NULL); + ok(!ret, "Expected failure.\n"); + ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Got unexpected error %#x.\n", GetLastError()); + ok(!file_exists("dst/three.txt"), "Destination file should not exist.\n"); + + ret = SetupFindFirstLineA(hinf, "section1", "three.txt", &infctx); + ok(ret, "Failed to find line.\n"); + SetLastError(0xdeadbeef); + ret = SetupInstallFileA(hinf, &infctx, "three.txt", "src/alpha", "three.txt", 0, NULL, NULL); + ok(ret, "Expected success.\n"); + ok(GetLastError() == ERROR_SUCCESS, "Got unexpected error %#x.\n", GetLastError()); + todo_wine ok(delete_file("dst/three.txt"), "Destination file should exist.\n"); + + SetupCloseInfFile(hinf); + delete_file("src/one.txt"); + delete_file("src/beta/two.txt"); + delete_file("src/beta/"); + delete_file("src/alpha/three.txt"); + delete_file("src/alpha/"); + delete_file("src/"); + delete_file("dst/"); + ok(delete_file(inffile), "Failed to delete INF file.\n"); +} + static void test_need_media(void) { static const char inf_data[] = "[Version]\n" @@ -1857,6 +1947,7 @@ START_TEST(install) test_install_files_queue(); test_need_media(); test_close_queue(); + test_install_file(); UnhookWindowsHookEx(hhook); -- 2.21.0

1 3

[PATCH 1/2] winepulse.drv: Adjust the buffer volume before sending it to PulseAudio
by Gabriel Ivăncescu 17 May '19

17 May '19

Only fixes the PulseAudio driver for the first bug, not ALSA. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=38182 Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46450 Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/winepulse.drv/mmdevdrv.c | 154 ++++++++++++++++++++++++++++++---- 1 file changed, 138 insertions(+), 16 deletions(-) diff --git a/dlls/winepulse.drv/mmdevdrv.c b/dlls/winepulse.drv/mmdevdrv.c index 8d57f1a..ac53039 100644 --- a/dlls/winepulse.drv/mmdevdrv.c +++ b/dlls/winepulse.drv/mmdevdrv.c @@ -621,6 +621,135 @@ static void silence_buffer(pa_sample_format_t format, BYTE *buffer, UINT32 bytes memset(buffer, format == PA_SAMPLE_U8 ? 0x80 : 0, bytes); } +static void pulse_free_noop(void *buf) +{ +} + +enum write_buffer_flags +{ + WINEPULSE_WRITE_NOFREE = 0x01, + WINEPULSE_WRITE_SILENT = 0x02 +}; + +static int write_buffer(const ACImpl *This, BYTE *buffer, UINT32 bytes, + enum write_buffer_flags flags) +{ + float vol[PA_CHANNELS_MAX]; + BOOL adjust = FALSE; + UINT32 i, channels; + BYTE *end; + + if (!bytes) return 0; + if (This->session->mute || (flags & WINEPULSE_WRITE_SILENT)) + { + silence_buffer(This->ss.format, buffer, bytes); + goto write; + } + + /* Adjust the buffer based on the volume for each channel */ + channels = This->session->channel_count; + for (i = 0; i < channels; i++) + { + vol[i] = This->vol[i] * This->session->master_vol * This->session->channel_vols[i]; + adjust |= vol[i] != 1.0f; + } + if (!adjust) goto write; + + end = buffer + bytes; + switch (This->ss.format) + { +#ifndef WORDS_BIGENDIAN +#define PROCESS_BUFFER(type) do \ +{ \ + type *p = (type*)buffer; \ + do \ + { \ + for (i = 0; i < channels; i++) \ + p[i] = p[i] * vol[i]; \ + p += i; \ + } while ((BYTE*)p != end); \ +} while (0); + case PA_SAMPLE_S16LE: + PROCESS_BUFFER(INT16); + break; + case PA_SAMPLE_S32LE: + PROCESS_BUFFER(INT32); + break; + case PA_SAMPLE_FLOAT32LE: + PROCESS_BUFFER(float); + break; +#undef PROCESS_BUFFER + case PA_SAMPLE_S24_32LE: + { + UINT32 *p = (UINT32*)buffer; + do + { + for (i = 0; i < channels; i++) + { + p[i] = (INT32)((INT32)(p[i] << 8) * vol[i]); + p[i] >>= 8; + } + p += i; + } while ((BYTE*)p != end); + break; + } + case PA_SAMPLE_S24LE: + { + /* do it 12 bytes at a time until it is no longer possible */ + UINT32 *q = (UINT32*)buffer; + BYTE *p; + + i = 0; + while (end - (BYTE*)q >= 12) + { + UINT32 v[4], k; + v[0] = q[0] << 8; + v[1] = q[1] << 16 | (q[0] >> 16 & ~0xff); + v[2] = q[2] << 24 | (q[1] >> 8 & ~0xff); + v[3] = q[2] & ~0xff; + for (k = 0; k < 4; k++) + { + v[k] = (INT32)((INT32)v[k] * vol[i]); + if (++i == channels) i = 0; + } + *q++ = v[0] >> 8 | (v[1] & ~0xff) << 16; + *q++ = v[1] >> 16 | (v[2] & ~0xff) << 8; + *q++ = v[2] >> 24 | (v[3] & ~0xff); + } + p = (BYTE*)q; + while (p != end) + { + UINT32 v = (INT32)((INT32)(p[0] << 8 | p[1] << 16 | p[2] << 24) * vol[i]); + *p++ = v >> 8 & 0xff; + *p++ = v >> 16 & 0xff; + *p++ = v >> 24; + if (++i == channels) i = 0; + } + break; + } +#endif + case PA_SAMPLE_U8: + { + UINT8 *p = (UINT8*)buffer; + do + { + for (i = 0; i < channels; i++) + p[i] = (int)((p[i] - 128) * vol[i]) + 128; + p += i; + } while ((BYTE*)p != end); + break; + } + default: + TRACE("Unhandled format %i, not adjusting volume.\n", This->ss.format); + break; + } + +write: + return pa_stream_write(This->stream, buffer, bytes, + (flags & WINEPULSE_WRITE_NOFREE) ? pulse_free_noop : NULL, + 0, PA_SEEK_RELATIVE); +} + static void dump_attr(const pa_buffer_attr *attr) { TRACE("maxlength: %u\n", attr->maxlength); TRACE("minreq: %u\n", attr->minreq); @@ -681,7 +810,7 @@ static void pulse_wr_callback(pa_stream *s, size_t bytes, void *userdata) if(This->lcl_offs_bytes + bytes > This->bufsize_bytes){ to_write = This->bufsize_bytes - This->lcl_offs_bytes; TRACE("writing small chunk of %u bytes\n", to_write); - pa_stream_write(This->stream, buf, to_write, NULL, 0, PA_SEEK_RELATIVE); + write_buffer(This, buf, to_write, 0); This->held_bytes -= to_write; to_write = bytes - to_write; This->lcl_offs_bytes = 0; @@ -690,7 +819,7 @@ static void pulse_wr_callback(pa_stream *s, size_t bytes, void *userdata) to_write = bytes; TRACE("writing main chunk of %u bytes\n", to_write); - pa_stream_write(This->stream, buf, to_write, NULL, 0, PA_SEEK_RELATIVE); + write_buffer(This, buf, to_write, 0); This->lcl_offs_bytes += to_write; This->lcl_offs_bytes %= This->bufsize_bytes; This->held_bytes -= to_write; @@ -2126,10 +2255,6 @@ static void pulse_wrap_buffer(ACImpl *This, BYTE *buffer, UINT32 written_bytes) } } -static void pulse_free_noop(void *buf) -{ -} - static HRESULT WINAPI AudioRenderClient_ReleaseBuffer( IAudioRenderClient *iface, UINT32 written_frames, DWORD flags) { @@ -2181,7 +2306,7 @@ static HRESULT WINAPI AudioRenderClient_ReleaseBuffer( TRACE("pre-writing %u bytes\n", to_write); - e = pa_stream_write(This->stream, buffer, to_write, NULL, 0, PA_SEEK_RELATIVE); + e = write_buffer(This, buffer, to_write, 0); if(e) ERR("pa_stream_write failed: 0x%x\n", e); @@ -2191,15 +2316,12 @@ static HRESULT WINAPI AudioRenderClient_ReleaseBuffer( } }else{ - if (This->locked_ptr) { - if (flags & AUDCLNT_BUFFERFLAGS_SILENT) - silence_buffer(This->ss.format, This->locked_ptr, written_bytes); - pa_stream_write(This->stream, This->locked_ptr, written_bytes, NULL, 0, PA_SEEK_RELATIVE); - } else { - if (flags & AUDCLNT_BUFFERFLAGS_SILENT) - silence_buffer(This->ss.format, This->tmp_buffer, written_bytes); - pa_stream_write(This->stream, This->tmp_buffer, written_bytes, pulse_free_noop, 0, PA_SEEK_RELATIVE); - } + enum write_buffer_flags wr_flags = 0; + + if (flags & AUDCLNT_BUFFERFLAGS_SILENT) wr_flags |= WINEPULSE_WRITE_SILENT; + if (!This->locked_ptr) wr_flags |= WINEPULSE_WRITE_NOFREE; + + write_buffer(This, This->locked_ptr ? This->locked_ptr : This->tmp_buffer, written_bytes, wr_flags); This->pad += written_bytes; } -- 2.21.0

2 5

[PATCH] d3dcompiler: Accept a stat chunk size of 28 for reflection
by Philip Rebohle 17 May '19

17 May '19

Fixes "unhandled size" error for Crysis shaders. Signed-off-by: Philip Rebohle <philip.rebohle(a)tu-dortmund.de> --- dlls/d3dcompiler_43/reflection.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/dlls/d3dcompiler_43/reflection.c b/dlls/d3dcompiler_43/reflection.c index 24190f6afe..7c67c92954 100644 --- a/dlls/d3dcompiler_43/reflection.c +++ b/dlls/d3dcompiler_43/reflection.c @@ -1127,7 +1127,12 @@ static HRESULT d3dcompiler_parse_stat(struct d3dcompiler_shader_reflection *r, c read_dword(&ptr, &r->gs_max_output_vertex_count); TRACE("GSMaxOutputVertexCount: %u\n", r->gs_max_output_vertex_count); - skip_dword_unknown(&ptr, 3); + skip_dword_unknown(&ptr, 2); + + /* old dx10 stat size */ + if (size == 28) return S_OK; + + skip_dword_unknown(&ptr, 1); /* dx10 stat size */ if (size == 29) return S_OK; -- 2.21.0

2 2

[PATCH] include: Stop macro redefined on the mac build
by Alistair Leslie-Hughes 17 May '19

17 May '19

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- include/winerror.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/include/winerror.h b/include/winerror.h index 32680e0..d58aee8 100644 --- a/include/winerror.h +++ b/include/winerror.h @@ -66,6 +66,22 @@ #define SEVERITY_SUCCESS 0 #define SEVERITY_ERROR 1 +#undef MAKE_HRESULT +#undef SUCCEEDED +#undef FAILED +#undef IS_ERROR +#undef HRESULT_FACILITY +#undef S_OK +#undef S_FALSE +#undef E_NOTIMPL +#undef E_NOINTERFACE +#undef E_POINTER +#undef E_ABORT +#undef E_FAIL +#undef E_UNEXPECTED +#undef E_HANDLE +#undef E_OUTOFMEMORY +#undef E_INVALIDARG #define MAKE_HRESULT(sev,fac,code) \ ((HRESULT) (((unsigned int)(sev)<<31) | ((unsigned int)(fac)<<16) | ((unsigned int)(code))) ) -- 1.9.1

2 1

[PATCH] msctf: Remove useless cast to self
by Michael Stefaniuc 17 May '19

17 May '19

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/msctf/context.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/msctf/context.c b/dlls/msctf/context.c index 452895c07e..ff67d38456 100644 --- a/dlls/msctf/context.c +++ b/dlls/msctf/context.c @@ -852,7 +852,7 @@ static HRESULT WINAPI TextStoreACPSink_OnLockGranted(ITextStoreACPSink *iface, /*TODO: implement ITfEditRecord */ SINK_FOR_EACH(cursor, &This->pTextEditSink, ITfTextEditSink, sink) { - ITfTextEditSink_OnEndEdit(sink, (ITfContext*) &This->ITfContext_iface, sc, NULL); + ITfTextEditSink_OnEndEdit(sink, &This->ITfContext_iface, sc, NULL); } sinkcookie = remove_Cookie(sc); } -- 2.20.1

1 0

[PATCH 01/10] dxgi/tests: Add IDXGIOutput ownership tests.
by Zhiyi Zhang 17 May '19

17 May '19

Mostly to show that TakeOwnership and ReleaseOwnership are based on VidPN ownership. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/dxgi/tests/dxgi.c | 178 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 177 insertions(+), 1 deletion(-) diff --git a/dlls/dxgi/tests/dxgi.c b/dlls/dxgi/tests/dxgi.c index 79e4bc0c15..5e1fb43b7e 100644 --- a/dlls/dxgi/tests/dxgi.c +++ b/dlls/dxgi/tests/dxgi.c @@ -17,11 +17,15 @@ */ #include <assert.h> +#include "ntstatus.h" +#define WIN32_NO_STATUS #define COBJMACROS #include "initguid.h" #include "dxgi1_6.h" #include "d3d11.h" #include "d3d12.h" +#include "winternl.h" +#include "ddk/d3dkmthk.h" #include "wine/heap.h" #include "wine/test.h" @@ -36,6 +40,10 @@ static DEVMODEW registry_mode; static HRESULT (WINAPI *pCreateDXGIFactory1)(REFIID iid, void **factory); static HRESULT (WINAPI *pCreateDXGIFactory2)(UINT flags, REFIID iid, void **factory); +static NTSTATUS (WINAPI *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); +static NTSTATUS (WINAPI *pD3DKMTCloseAdapter)(const D3DKMT_CLOSEADAPTER *); +static NTSTATUS (WINAPI *pD3DKMTOpenAdapterFromGdiDisplayName)(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *); + static PFN_D3D12_CREATE_DEVICE pD3D12CreateDevice; static PFN_D3D12_GET_DEBUG_INTERFACE pD3D12GetDebugInterface; @@ -4985,6 +4993,167 @@ done: ok(!refcount, "Factory has %u references left.\n", refcount); } +static void test_output_ownership(IUnknown *device, BOOL is_d3d12) +{ + static const DWORD timeout = 1000; + static const WCHAR display1W[] = {'\\','\\','.','\\','D','I','S','P','L','A','Y','1',0}; + D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME open_adapter_gdi_desc; + D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP check_ownership_desc; + D3DKMT_CLOSEADAPTER close_adapter_desc; + DXGI_SWAP_CHAIN_DESC swapchain_desc; + IDXGISwapChain *swapchain; + IDXGIFactory *factory; + IDXGIOutput *output; + BOOL fullscreen; + ULONG refcount; + NTSTATUS status; + HRESULT hr; + + if (!pD3DKMTCheckVidPnExclusiveOwnership || pD3DKMTCheckVidPnExclusiveOwnership(NULL) == STATUS_PROCEDURE_NOT_FOUND + || !pD3DKMTCloseAdapter || !pD3DKMTOpenAdapterFromGdiDisplayName) + { + skip("Required functions are unavailable.\n"); + return; + } + + lstrcpyW(open_adapter_gdi_desc.DeviceName, display1W); + status = pD3DKMTOpenAdapterFromGdiDisplayName(&open_adapter_gdi_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + + check_ownership_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + check_ownership_desc.VidPnSourceId = open_adapter_gdi_desc.VidPnSourceId; + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", status); + + get_factory(device, is_d3d12, &factory); + + swapchain_desc.BufferDesc.Width = 800; + swapchain_desc.BufferDesc.Height = 600; + swapchain_desc.BufferDesc.RefreshRate.Numerator = 60; + swapchain_desc.BufferDesc.RefreshRate.Denominator = 60; + swapchain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + swapchain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; + swapchain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; + swapchain_desc.SampleDesc.Count = 1; + swapchain_desc.SampleDesc.Quality = 0; + swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + swapchain_desc.BufferCount = is_d3d12 ? 2 : 1; + swapchain_desc.OutputWindow = CreateWindowA("static", "dxgi_test", 0, 0, 0, 400, 200, 0, 0, 0, 0); + swapchain_desc.Windowed = TRUE; + swapchain_desc.SwapEffect = is_d3d12 ? DXGI_SWAP_EFFECT_FLIP_DISCARD : DXGI_SWAP_EFFECT_DISCARD; + swapchain_desc.Flags = 0; + + hr = IDXGIFactory_CreateSwapChain(factory, device, &swapchain_desc, &swapchain); + ok(hr == S_OK, "Failed to create swapchain, hr %#x.\n", hr); + + /* Swapchain in fullscreen mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, TRUE, NULL); + /* DXGI_ERROR_NOT_CURRENTLY_AVAILABLE on some machines. DXGI_ERROR_UNSUPPORTED on Win 7 testbot. */ + if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE || broken(hr == DXGI_ERROR_UNSUPPORTED)) + { + skip("Failed to change fullscreen state.\n"); + goto done; + } + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + Sleep(timeout); + output = NULL; + fullscreen = FALSE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, &output); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(fullscreen, "Unexpected fullscreen state.\n"); + todo_wine_if(is_d3d12) ok(output != NULL, "Expect output not null.\n"); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + if (is_d3d12) + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", + status); + else + todo_wine ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected status %#x.\n", status); + if (output) hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : E_INVALIDARG), "Got unexpected hr %#x.\n", hr); + if (output) hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + /* Calling IDXGIOutput_ReleaseOwnership makes it unoccluded. So we can be confident about IDXGIOutput_TakeOwnership + * was called in IDXGISwapChain_SetFullscreenState */ + if (output) IDXGIOutput_ReleaseOwnership(output); + Sleep(timeout); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", + status); + + if (output) hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : DXGI_ERROR_NOT_CURRENTLY_AVAILABLE), "Got unexpected hr %#x.\n", hr); + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", + status); + if (output) IDXGIOutput_ReleaseOwnership(output); + + if (output) hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + /* So the following results shows that IDXGIOutput_TakeOwnership(output, device, TRUE) is used in + * SetFullscreenState(swapchain, TRUE, NULL) + * + * This make me believe the MSDN documentation is saying the opposite about the last parameter, + * "HRESULT TakeOwnership(IUnknown *pDevice, BOOL Exclusive); + * Name: Exclusive Type: BOOL + * Set to TRUE to enable other threads or applications to take ownership of the device; otherwise, set to FALSE." + * + * Reasons: + * 1. The parameter name is called 'Exclusive' + * 2. D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE) makes D3DKMTCheckVidPnExclusiveOwnership return + * STATUS_GRAPHICS_PRESENT_OCCLUDED. And D3DKMTSetVidPnSourceOwner(D3DKMT_VIDPNSOURCEOWNER_SHARED) makes + * D3DKMTCheckVidPnExclusiveOwnership return STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE. So the opposite mapping of + * what MSDN is saying is consistent with the tests. + */ + if (is_d3d12) + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", + status); + else + todo_wine ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected status %#x.\n", status); + if (output) hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : E_INVALIDARG), "Got unexpected hr %#x.\n", hr); + if (output) IDXGIOutput_ReleaseOwnership(output); + + /* Swapchain in windowed mode */ + hr = IDXGISwapChain_SetFullscreenState(swapchain, FALSE, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + Sleep(timeout); + fullscreen = TRUE; + hr = IDXGISwapChain_GetFullscreenState(swapchain, &fullscreen, NULL); + todo_wine_if(is_d3d12) ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + todo_wine_if(is_d3d12) ok(!fullscreen, "Unexpected fullscreen state.\n"); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + + if (output) hr = IDXGIOutput_TakeOwnership(output, device, FALSE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : DXGI_ERROR_NOT_CURRENTLY_AVAILABLE), "Got unexpected hr %#x.\n", hr); + + if (output) hr = IDXGIOutput_TakeOwnership(output, device, TRUE); + todo_wine ok(hr == (is_d3d12 ? E_NOINTERFACE : S_OK), "Got unexpected hr %#x.\n", hr); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + if (is_d3d12) + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", + status); + else + todo_wine ok(status == STATUS_GRAPHICS_PRESENT_OCCLUDED, "Got unexpected status %#x.\n", status); + if (output) IDXGIOutput_ReleaseOwnership(output); + status = pD3DKMTCheckVidPnExclusiveOwnership(&check_ownership_desc); + ok(status == STATUS_SUCCESS || status == STATUS_GRAPHICS_PRESENT_UNOCCLUDED, "Got unexpected status %#x.\n", status); + + if (output) IDXGIOutput_Release(output); + +done: + wait_device_idle(device); + + IDXGISwapChain_Release(swapchain); + DestroyWindow(swapchain_desc.OutputWindow); + refcount = IDXGIFactory_Release(factory); + ok(refcount == !is_d3d12, "Got unexpected refcount %u.\n", refcount); + + close_adapter_desc.hAdapter = open_adapter_gdi_desc.hAdapter; + status = pD3DKMTCloseAdapter(&close_adapter_desc); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); +} + static void run_on_d3d10(void (*test_func)(IUnknown *device, BOOL is_d3d12)) { IDXGIDevice *device; @@ -5028,7 +5197,7 @@ static void run_on_d3d12(void (*test_func)(IUnknown *device, BOOL is_d3d12)) START_TEST(dxgi) { - HMODULE dxgi_module, d3d12_module; + HMODULE dxgi_module, d3d12_module, gdi32_module; BOOL enable_debug_layer = FALSE; unsigned int argc, i; ID3D12Debug *debug; @@ -5038,6 +5207,11 @@ START_TEST(dxgi) pCreateDXGIFactory1 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory1"); pCreateDXGIFactory2 = (void *)GetProcAddress(dxgi_module, "CreateDXGIFactory2"); + gdi32_module = GetModuleHandleA("gdi32.dll"); + pD3DKMTCheckVidPnExclusiveOwnership = (void *)GetProcAddress(gdi32_module, "D3DKMTCheckVidPnExclusiveOwnership"); + pD3DKMTCloseAdapter = (void *)GetProcAddress(gdi32_module, "D3DKMTCloseAdapter"); + pD3DKMTOpenAdapterFromGdiDisplayName = (void *)GetProcAddress(gdi32_module, "D3DKMTOpenAdapterFromGdiDisplayName"); + registry_mode.dmSize = sizeof(registry_mode); ok(EnumDisplaySettingsW(NULL, ENUM_REGISTRY_SETTINGS, &registry_mode), "Failed to get display mode.\n"); @@ -5088,6 +5262,7 @@ START_TEST(dxgi) run_on_d3d10(test_swapchain_present); run_on_d3d10(test_swapchain_backbuffer_index); run_on_d3d10(test_swapchain_formats); + run_on_d3d10(test_output_ownership); if (!(d3d12_module = LoadLibraryA("d3d12.dll"))) { @@ -5108,6 +5283,7 @@ START_TEST(dxgi) run_on_d3d12(test_swapchain_present); run_on_d3d12(test_swapchain_backbuffer_index); run_on_d3d12(test_swapchain_formats); + run_on_d3d12(test_output_ownership); FreeLibrary(d3d12_module); } -- 2.20.1

3 5

[PATCH 2/2] jscript/tests: Add more Enumerator tests.
by Jacek Caban 17 May '19

17 May '19

From: Andreas Maier <staubim(a)quantentunnel.de> Signed-off-by: Andreas Maier <staubim(a)quantentunnel.de> Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- Resent with proper From: line. dlls/jscript/tests/api.js | 15 ++++ dlls/jscript/tests/run.c | 169 +++++++++++++++++++++++++++++++++++++- 2 files changed, 183 insertions(+), 1 deletion(-)

1 0

[PATCH 2/2] jscript/tests: Add more Enumerator tests.
by Jacek Caban 17 May '19

17 May '19

Signed-off-by: Andreas Maier <staubim(a)quantentunnel.de> Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/tests/api.js | 15 ++++ dlls/jscript/tests/run.c | 169 +++++++++++++++++++++++++++++++++++++- 2 files changed, 183 insertions(+), 1 deletion(-)

1 0

[PATCH 1/2] jscript: Implement Enumerator object.
by Jacek Caban 17 May '19

17 May '19

From: Andreas Maier <staubim(a)quantentunnel.de> Signed-off-by: Andreas Maier <staubim(a)quantentunnel.de> Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/jscript/enumerator.c | 262 ++++++++++++++++++++++++++++++-------- dlls/jscript/jscript.h | 3 +- dlls/jscript/object.c | 2 +- dlls/jscript/resource.h | 1 + dlls/jscript/tests/api.js | 6 +- 5 files changed, 217 insertions(+), 57 deletions(-)

1 0

[PATCH] urlmon: Add ShouldShowIntranetWarningSecband stub.
by Dmitry Timoshkov 17 May '19

17 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/urlmon/urlmon.spec | 1 + dlls/urlmon/urlmon_main.c | 10 ++++++++++ 2 files changed, 11 insertions(+) diff --git a/dlls/urlmon/urlmon.spec b/dlls/urlmon/urlmon.spec index dab4aa2925..445db63f95 100644 --- a/dlls/urlmon/urlmon.spec +++ b/dlls/urlmon/urlmon.spec @@ -77,6 +77,7 @@ @ stdcall RevokeBindStatusCallback(ptr ptr) @ stdcall RevokeFormatEnumerator(ptr ptr) @ stub SetSoftwareUpdateAdvertisementState +@ stdcall ShouldShowIntranetWarningSecband(long) @ stub URLDownloadA @ stdcall URLDownloadToCacheFileA(ptr str str long long ptr) @ stdcall URLDownloadToCacheFileW(ptr wstr wstr long long ptr) diff --git a/dlls/urlmon/urlmon_main.c b/dlls/urlmon/urlmon_main.c index 90ea6e7cf2..d416cc43de 100644 --- a/dlls/urlmon/urlmon_main.c +++ b/dlls/urlmon/urlmon_main.c @@ -838,3 +838,13 @@ HRESULT WINAPI RegisterMediaTypes(UINT types, LPCSTR *szTypes, CLIPFORMAT *cfTyp FIXME("stub: %u %p %p\n", types, szTypes, cfTypes); return E_INVALIDARG; } + +/*********************************************************************** + * ShouldShowIntranetWarningSecband + * Undocumented, added in IE7 + */ +BOOL WINAPI ShouldShowIntranetWarningSecband(DWORD unk) +{ + FIXME("%x: stub\n", unk); + return FALSE; +} -- 2.20.1

2 1

[PATCH] urlmon: Add GetIUriPriv stub.
by Dmitry Timoshkov 17 May '19

17 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/urlmon/urlmon.spec | 1 + dlls/urlmon/urlmon_main.c | 12 ++++++++++++ 2 files changed, 13 insertions(+) diff --git a/dlls/urlmon/urlmon.spec b/dlls/urlmon/urlmon.spec index 445db63f95..d6a6b438cc 100644 --- a/dlls/urlmon/urlmon.spec +++ b/dlls/urlmon/urlmon.spec @@ -53,6 +53,7 @@ @ stdcall GetClassFileOrMime(ptr wstr ptr long wstr long ptr) @ stub GetClassURL @ stub GetComponentIDFromCLSSPEC +@ stdcall GetIUriPriv(ptr ptr) @ stub GetMarkOfTheWeb @ stdcall GetSoftwareUpdateInfo(wstr ptr) @ stub HlinkGoBack diff --git a/dlls/urlmon/urlmon_main.c b/dlls/urlmon/urlmon_main.c index d416cc43de..aea1a5c332 100644 --- a/dlls/urlmon/urlmon_main.c +++ b/dlls/urlmon/urlmon_main.c @@ -848,3 +848,15 @@ BOOL WINAPI ShouldShowIntranetWarningSecband(DWORD unk) FIXME("%x: stub\n", unk); return FALSE; } + +/*********************************************************************** + * GetIUriPriv (urlmon.@) + * + * Not documented. + */ +HRESULT WINAPI GetIUriPriv(IUri *uri, void **p) +{ + FIXME("(%p,%p): stub\n", uri, p); + *p = NULL; + return E_NOTIMPL; +} -- 2.20.1

3 2

[PATCH v2] urlmon: Add support for PARSE_UNESCAPE to CoInternetParseUrl.
by Dmitry Timoshkov 17 May '19

17 May '19

This patch should be applied on top of Jacek's patch. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/urlmon/internet.c | 7 ++++--- dlls/urlmon/tests/misc.c | 23 +++++++++++++++++++++++ 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/dlls/urlmon/internet.c b/dlls/urlmon/internet.c index 7c997a03b0..da4fa9abd3 100644 --- a/dlls/urlmon/internet.c +++ b/dlls/urlmon/internet.c @@ -218,7 +218,7 @@ static HRESULT parse_security_url(LPCWSTR url, DWORD flags, LPWSTR result, DWORD return E_FAIL; } -static HRESULT parse_encode(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) +static HRESULT parse_encode(LPCWSTR url, PARSEACTION action, DWORD flags, LPWSTR result, DWORD size, DWORD *rsize) { IInternetProtocolInfo *protocol_info; DWORD prsize; @@ -229,7 +229,7 @@ static HRESULT parse_encode(LPCWSTR url, DWORD flags, LPWSTR result, DWORD size, protocol_info = get_protocol_info(url); if(protocol_info) { - hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, PARSE_ENCODE, + hres = IInternetProtocolInfo_ParseUrl(protocol_info, url, action, flags, result, size, rsize, 0); IInternetProtocolInfo_Release(protocol_info); if(SUCCEEDED(hres)) @@ -401,7 +401,8 @@ HRESULT WINAPI CoInternetParseUrl(LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD case PARSE_SECURITY_URL: return parse_security_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); case PARSE_ENCODE: - return parse_encode(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); + case PARSE_UNESCAPE: + return parse_encode(pwzUrl, ParseAction, dwFlags, pszResult, cchResult, pcchResult); case PARSE_PATH_FROM_URL: return parse_path_from_url(pwzUrl, dwFlags, pszResult, cchResult, pcchResult); case PARSE_SCHEMA: diff --git a/dlls/urlmon/tests/misc.c b/dlls/urlmon/tests/misc.c index de0c6544e2..6f4da47e6e 100644 --- a/dlls/urlmon/tests/misc.c +++ b/dlls/urlmon/tests/misc.c @@ -62,6 +62,7 @@ DEFINE_GUID(CLSID_AboutProtocol, 0x3050F406, 0x98B5, 0x11CF, 0xBB,0x82, 0x00,0xA DEFINE_EXPECT(ParseUrl); DEFINE_EXPECT(ParseUrl_ENCODE); +DEFINE_EXPECT(ParseUrl_UNESCAPE); DEFINE_EXPECT(QI_IInternetProtocolInfo); DEFINE_EXPECT(CreateInstance); DEFINE_EXPECT(unk_Release); @@ -382,6 +383,13 @@ static void test_CoInternetParseUrl(void) ok(size == lstrlenW(parse_tests[i].encoded_url), "[%d] wrong size\n", i); ok(!lstrcmpW(parse_tests[i].encoded_url, buf), "[%d] wrong encoded url\n", i); + memset(buf, 0xf0, sizeof(buf)); + hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_UNESCAPE, 0, buf, + ARRAY_SIZE(buf), &size, 0); + ok(hres == S_OK, "[%d] encoding failed: %08x\n", i, hres); + ok(size == lstrlenW(parse_tests[i].encoded_url), "[%d] wrong size\n", i); + ok(!lstrcmpW(parse_tests[i].encoded_url, buf), "[%d] wrong encoded url\n", i); + memset(buf, 0xf0, sizeof(buf)); hres = pCoInternetParseUrl(parse_tests[i].url, PARSE_PATH_FROM_URL, 0, buf, ARRAY_SIZE(buf), &size, 0); @@ -890,6 +898,11 @@ static HRESULT WINAPI InternetProtocolInfo_ParseUrl(IInternetProtocolInfo *iface case PARSE_ENCODE: CHECK_EXPECT2(ParseUrl_ENCODE); break; + + case PARSE_UNESCAPE: + CHECK_EXPECT2(ParseUrl_UNESCAPE); + break; + default: CHECK_EXPECT2(ParseUrl); break; @@ -1056,6 +1069,16 @@ static void test_NameSpace(void) CHECK_CALLED(QI_IInternetProtocolInfo); CHECK_CALLED(ParseUrl_ENCODE); + qiret = S_OK; + SET_EXPECT(QI_IInternetProtocolInfo); + SET_EXPECT(ParseUrl_UNESCAPE); + + hres = pCoInternetParseUrl(url8, PARSE_UNESCAPE, 0, buf, ARRAY_SIZE(buf), &size, 0); + ok(hres == S_OK, "CoInternetParseUrl failed: %08x\n", hres); + + CHECK_CALLED(QI_IInternetProtocolInfo); + CHECK_CALLED(ParseUrl_UNESCAPE); + SET_EXPECT(QI_IInternetProtocolInfo); SET_EXPECT(ParseUrl); -- 2.20.1

3 2

[PATCH 1/2] mfplat: Handle null destination for GetItem().
by Nikolay Sivov 17 May '19

17 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mfplat/main.c | 2 +- dlls/mfplat/tests/mfplat.c | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index 14b9e2376a..e80408d2b2 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -1112,7 +1112,7 @@ HRESULT attributes_GetItem(struct attributes *attributes, REFGUID key, PROPVARIA EnterCriticalSection(&attributes->cs); if ((attribute = attributes_find_item(attributes, key, NULL))) - hr = PropVariantCopy(value, &attribute->value); + hr = value ? PropVariantCopy(value, &attribute->value) : S_OK; else hr = MF_E_ATTRIBUTENOTFOUND; diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index 3afb3300a8..7fa3ddd876 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -763,6 +763,12 @@ static void test_attributes(void) PropVariantClear(&ret_propvar); CHECK_ATTR_COUNT(attributes, 1); + hr = IMFAttributes_GetItem(attributes, &DUMMY_GUID1, NULL); + ok(hr == S_OK, "Item check failed, hr %#x.\n", hr); + + hr = IMFAttributes_GetItem(attributes, &DUMMY_GUID2, NULL); + ok(hr == MF_E_ATTRIBUTENOTFOUND, "Unexpected hr %#x.\n", hr); + PropVariantInit(&ret_propvar); ret_propvar.vt = MF_ATTRIBUTE_STRING; U(ret_propvar).pwszVal = NULL; -- 2.20.1

2 2

[PATCH vkd3d 8/8] vkd3d: Simplify checking for render pass compatibility.
by Józef Kucia 17 May '19

17 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 21 +++++++++++++-------- libs/vkd3d/state.c | 22 ---------------------- libs/vkd3d/vkd3d_private.h | 2 -- 3 files changed, 13 insertions(+), 32 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index d5283275786f..9187ad02d836 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -2415,6 +2415,7 @@ static bool d3d12_command_list_update_current_framebuffer(struct d3d12_command_l static bool d3d12_command_list_update_current_pipeline(struct d3d12_command_list *list) { const struct vkd3d_vk_device_procs *vk_procs = &list->device->vk_procs; + VkRenderPass vk_render_pass; VkPipeline vk_pipeline; if (list->current_pipeline != VK_NULL_HANDLE) @@ -2427,11 +2428,20 @@ static bool d3d12_command_list_update_current_pipeline(struct d3d12_command_list } if (!(vk_pipeline = d3d12_pipeline_state_get_or_create_pipeline(list->state, - list->primitive_topology, list->strides, list->dsv_format, &list->pso_render_pass))) + list->primitive_topology, list->strides, list->dsv_format, &vk_render_pass))) return false; - if (!list->pso_render_pass) - list->pso_render_pass = list->state->u.graphics.render_pass; + if (!vk_render_pass) + vk_render_pass = list->state->u.graphics.render_pass; + + /* The render pass cache ensures that we use the same Vulkan render pass + * object for compatible render passes. */ + if (list->pso_render_pass != vk_render_pass) + { + list->pso_render_pass = vk_render_pass; + d3d12_command_list_invalidate_current_framebuffer(list); + d3d12_command_list_invalidate_current_render_pass(list); + } VK_CALL(vkCmdBindPipeline(list->vk_command_buffer, list->state->vk_bind_point, vk_pipeline)); list->current_pipeline = vk_pipeline; @@ -3648,11 +3658,6 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetPipelineState(ID3D12Graphics } else { - if (!d3d12_pipeline_state_is_render_pass_compatible(list->state, state)) - { - d3d12_command_list_invalidate_current_framebuffer(list); - d3d12_command_list_invalidate_current_render_pass(list); - } d3d12_command_list_invalidate_current_pipeline(list); } diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index a447eb5e5c74..c5f66b699548 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -2027,28 +2027,6 @@ static unsigned int vkd3d_get_rt_format_swizzle(const struct vkd3d_format *forma return VKD3D_NO_SWIZZLE; } -/* - * This must return results in accordance with render passes created by - * d3d12_pipeline_state_init_graphics(). - */ -bool d3d12_pipeline_state_is_render_pass_compatible(const struct d3d12_pipeline_state *state_a, - const struct d3d12_pipeline_state *state_b) -{ - const struct d3d12_graphics_pipeline_state *a = &state_a->u.graphics; - const struct d3d12_graphics_pipeline_state *b = &state_b->u.graphics; - - if (!state_a != !state_b) - return false; - if (!state_a && !state_b) - return true; - - if (state_a->vk_bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS - || state_b->vk_bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS) - return false; - - return a->render_pass == b->render_pass; -} - STATIC_ASSERT(sizeof(struct vkd3d_shader_transform_feedback_element) == sizeof(D3D12_SO_DECLARATION_ENTRY)); static HRESULT d3d12_graphics_pipeline_state_create_render_pass( diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 44e61c2aaac6..0f0d77fea38d 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -743,8 +743,6 @@ HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_state *state, D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format, VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN; -bool d3d12_pipeline_state_is_render_pass_compatible(const struct d3d12_pipeline_state *state_a, - const struct d3d12_pipeline_state *state_b) DECLSPEC_HIDDEN; struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface) DECLSPEC_HIDDEN; struct vkd3d_buffer -- 2.21.0

2 1

[PATCH vkd3d 2/8] vkd3d: Refactor render pass attachments.
by Józef Kucia 17 May '19

17 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Use the last attachment for depth-stencil instead of the first. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 67 +++++++------ libs/vkd3d/state.c | 192 ++++++++++++++++++------------------- libs/vkd3d/vkd3d_private.h | 5 +- 3 files changed, 137 insertions(+), 127 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 1c518f3b7120..d5283275786f 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -2247,11 +2247,12 @@ static void d3d12_command_list_reset_state(struct d3d12_command_list *list, list->index_buffer_format = DXGI_FORMAT_UNKNOWN; - memset(list->views, 0, sizeof(list->views)); + memset(list->rtvs, 0, sizeof(list->rtvs)); + list->dsv = VK_NULL_HANDLE; + list->dsv_format = VK_FORMAT_UNDEFINED; list->fb_width = 0; list->fb_height = 0; list->fb_layer_count = 0; - list->dsv_format = VK_FORMAT_UNDEFINED; list->xfb_enabled = false; @@ -2309,12 +2310,24 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_list_ClearState(ID3D12GraphicsCom return E_NOTIMPL; } +static bool d3d12_command_list_has_depth_stencil_view(struct d3d12_command_list *list) +{ + struct d3d12_graphics_pipeline_state *graphics; + + assert(d3d12_pipeline_state_is_graphics(list->state)); + graphics = &list->state->u.graphics; + + return graphics->dsv_format + || (graphics->null_attachment_mask & (1u << graphics->rt_count) && list->dsv_format); +} + static void d3d12_command_list_get_fb_extent(struct d3d12_command_list *list, uint32_t *width, uint32_t *height, uint32_t *layer_count) { + struct d3d12_graphics_pipeline_state *graphics = &list->state->u.graphics; struct d3d12_device *device = list->device; - if (list->state->u.graphics.attachment_count) + if (graphics->rt_count || d3d12_command_list_has_depth_stencil_view(list)) { *width = list->fb_width; *height = list->fb_height; @@ -2339,8 +2352,6 @@ static bool d3d12_command_list_update_current_framebuffer(struct d3d12_command_l struct VkFramebufferCreateInfo fb_desc; VkFramebuffer vk_framebuffer; unsigned int view_count; - size_t start_idx = 0; - bool null_attachment; unsigned int i; VkResult vr; @@ -2349,29 +2360,31 @@ static bool d3d12_command_list_update_current_framebuffer(struct d3d12_command_l graphics = &list->state->u.graphics; - if (!graphics->rt_idx) - ++start_idx; - - for (i = 0, view_count = 0; i < graphics->attachment_count; ++i) + for (i = 0, view_count = 0; i < graphics->rt_count; ++i) { - null_attachment = graphics->null_attachment_mask & (1u << i); - if (graphics->rt_idx && i == 0) - null_attachment = list->dsv_format == VK_FORMAT_UNDEFINED; - - if (null_attachment) + if (graphics->null_attachment_mask & (1u << i)) { - if (list->views[start_idx + i]) - WARN("Expected NULL view for attachment %u.\n", i); + if (list->rtvs[i]) + WARN("Expected NULL RTV for attachment %u.\n", i); continue; } - if (!list->views[start_idx + i]) + if (!list->rtvs[i]) { - FIXME("Invalid view for attachment %u.\n", i); + FIXME("Invalid RTV for attachment %u.\n", i); return false; } - views[view_count++] = list->views[start_idx + i]; + views[view_count++] = list->rtvs[i]; + } + + if (d3d12_command_list_has_depth_stencil_view(list)) + { + if (!(views[view_count++] = list->dsv)) + { + FIXME("Invalid DSV.\n"); + return false; + } } fb_desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; @@ -4319,11 +4332,11 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi iface, render_target_descriptor_count, render_target_descriptors, single_descriptor_handle, depth_stencil_descriptor); - if (render_target_descriptor_count > ARRAY_SIZE(list->views) - 1) + if (render_target_descriptor_count > ARRAY_SIZE(list->rtvs)) { WARN("Descriptor count %u > %zu, ignoring extra descriptors.\n", - render_target_descriptor_count, ARRAY_SIZE(list->views) - 1); - render_target_descriptor_count = ARRAY_SIZE(list->views) - 1; + render_target_descriptor_count, ARRAY_SIZE(list->rtvs)); + render_target_descriptor_count = ARRAY_SIZE(list->rtvs); } list->fb_width = 0; @@ -4344,7 +4357,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi if (!rtv_desc || !rtv_desc->resource) { WARN("RTV descriptor %u is not initialized.\n", i); - list->views[i + 1] = VK_NULL_HANDLE; + list->rtvs[i] = VK_NULL_HANDLE; continue; } @@ -4357,7 +4370,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi WARN("Failed to add view.\n"); } - list->views[i + 1] = view->u.vk_image_view; + list->rtvs[i] = view->u.vk_image_view; list->fb_width = max(list->fb_width, rtv_desc->width); list->fb_height = max(list->fb_height, rtv_desc->height); list->fb_layer_count = max(list->fb_layer_count, rtv_desc->layer_count); @@ -4375,10 +4388,10 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi if (!d3d12_command_allocator_add_view(list->allocator, view)) { WARN("Failed to add view.\n"); - list->views[0] = VK_NULL_HANDLE; + list->dsv = VK_NULL_HANDLE; } - list->views[0] = view->u.vk_image_view; + list->dsv = view->u.vk_image_view; list->fb_width = max(list->fb_width, dsv_desc->width); list->fb_height = max(list->fb_height, dsv_desc->height); list->fb_layer_count = max(list->fb_layer_count, dsv_desc->layer_count); @@ -4387,7 +4400,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_OMSetRenderTargets(ID3D12Graphi else { WARN("DSV descriptor is not initialized.\n"); - list->views[0] = VK_NULL_HANDLE; + list->dsv = VK_NULL_HANDLE; list->dsv_format = VK_FORMAT_UNDEFINED; } } diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 5d2f49019364..b3348d601b9e 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -1050,10 +1050,10 @@ static HRESULT vkd3d_render_pass_cache_create_pass_locked(struct vkd3d_render_pa const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct vkd3d_render_pass_entry *entry; unsigned int index, attachment_index; - unsigned int color_attachment_index; VkSubpassDescription sub_pass_desc; VkRenderPassCreateInfo pass_info; bool have_depth_stencil; + unsigned int rt_count; VkResult vr; if (!vkd3d_array_reserve((void **)&cache->render_passes, &cache->render_passes_size, @@ -1068,51 +1068,10 @@ static HRESULT vkd3d_render_pass_cache_create_pass_locked(struct vkd3d_render_pa entry->key = *key; have_depth_stencil = key->depth_enable || key->stencil_enable; - color_attachment_index = have_depth_stencil ? 1 : 0; + rt_count = have_depth_stencil ? key->attachment_count - 1 : key->attachment_count; + assert(rt_count <= D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT); - index = 0; - if (have_depth_stencil) - { - VkImageLayout depth_layout = key->depth_stencil_write - ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL - : VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; - - attachments[index].flags = 0; - attachments[index].format = key->vk_formats[index]; - attachments[index].samples = key->sample_count; - - if (key->depth_enable) - { - attachments[index].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; - attachments[index].storeOp = VK_ATTACHMENT_STORE_OP_STORE; - } - else - { - attachments[index].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - attachments[index].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - } - if (key->stencil_enable) - { - attachments[index].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD; - attachments[index].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE; - } - else - { - attachments[index].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; - attachments[index].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - } - attachments[index].initialLayout = depth_layout; - attachments[index].finalLayout = depth_layout; - - attachment_references[index].attachment = index; - attachment_references[index].layout = depth_layout; - - ++index; - } - - attachment_index = index; - assert(index == color_attachment_index); - for (; index < key->attachment_count; ++index) + for (index = 0, attachment_index = 0; index < rt_count; ++index) { if (!key->vk_formats[index]) { @@ -1137,15 +1096,54 @@ static HRESULT vkd3d_render_pass_cache_create_pass_locked(struct vkd3d_render_pa ++attachment_index; } + if (have_depth_stencil) + { + VkImageLayout depth_layout = key->depth_stencil_write + ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL + : VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; + + attachments[attachment_index].flags = 0; + attachments[attachment_index].format = key->vk_formats[index]; + attachments[attachment_index].samples = key->sample_count; + + if (key->depth_enable) + { + attachments[attachment_index].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD; + attachments[attachment_index].storeOp = VK_ATTACHMENT_STORE_OP_STORE; + } + else + { + attachments[attachment_index].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + attachments[attachment_index].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + } + if (key->stencil_enable) + { + attachments[attachment_index].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD; + attachments[attachment_index].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE; + } + else + { + attachments[attachment_index].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; + attachments[attachment_index].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + } + attachments[attachment_index].initialLayout = depth_layout; + attachments[attachment_index].finalLayout = depth_layout; + + attachment_references[index].attachment = attachment_index; + attachment_references[index].layout = depth_layout; + + attachment_index++; + } + sub_pass_desc.flags = 0; sub_pass_desc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; sub_pass_desc.inputAttachmentCount = 0; sub_pass_desc.pInputAttachments = NULL; - sub_pass_desc.colorAttachmentCount = key->attachment_count - color_attachment_index; - sub_pass_desc.pColorAttachments = &attachment_references[color_attachment_index]; + sub_pass_desc.colorAttachmentCount = rt_count; + sub_pass_desc.pColorAttachments = attachment_references; sub_pass_desc.pResolveAttachments = NULL; if (have_depth_stencil) - sub_pass_desc.pDepthStencilAttachment = &attachment_references[0]; + sub_pass_desc.pDepthStencilAttachment = &attachment_references[rt_count]; else sub_pass_desc.pDepthStencilAttachment = NULL; sub_pass_desc.preserveAttachmentCount = 0; @@ -2059,11 +2057,13 @@ static HRESULT d3d12_graphics_pipeline_state_create_render_pass( { struct vkd3d_render_pass_key key; VkFormat dsv_format; - unsigned int i = 0; + unsigned int i; - dsv_format = graphics->rt_idx ? - graphics->dsv_format ? graphics->dsv_format : dynamic_dsv_format - : VK_FORMAT_UNDEFINED; + memcpy(key.vk_formats, graphics->rtv_formats, sizeof(graphics->rtv_formats)); + key.attachment_count = graphics->rt_count; + + if (!(dsv_format = graphics->dsv_format) && (graphics->null_attachment_mask & (1u << graphics->rt_count))) + dsv_format = dynamic_dsv_format; if (dsv_format) { @@ -2072,23 +2072,20 @@ static HRESULT d3d12_graphics_pipeline_state_create_render_pass( key.stencil_enable = graphics->ds_desc.stencilTestEnable; key.depth_stencil_write = graphics->ds_desc.depthWriteEnable || graphics->ds_desc.front.writeMask; - key.vk_formats[i++] = dsv_format; + key.vk_formats[key.attachment_count++] = dsv_format; } else { key.depth_enable = false; key.stencil_enable = false; key.depth_stencil_write = false; - key.vk_formats[ARRAY_SIZE(key.vk_formats) - 1] = VK_FORMAT_UNDEFINED; } - memcpy(&key.vk_formats[i], graphics->rtv_formats, sizeof(graphics->rtv_formats)); - for (i = graphics->attachment_count; i < ARRAY_SIZE(key.vk_formats); ++i) + if (key.attachment_count != ARRAY_SIZE(key.vk_formats)) + key.vk_formats[ARRAY_SIZE(key.vk_formats) - 1] = VK_FORMAT_UNDEFINED; + for (i = key.attachment_count; i < ARRAY_SIZE(key.vk_formats); ++i) assert(key.vk_formats[i] == VK_FORMAT_UNDEFINED); - key.attachment_count = graphics->attachment_count; - if (!dsv_format && graphics->rt_idx) - --key.attachment_count; key.padding = 0; key.sample_count = graphics->ms_desc.rasterizationSamples; @@ -2118,6 +2115,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s const struct vkd3d_format *format; unsigned int instance_divisor; VkVertexInputRate input_rate; + bool have_attachment; unsigned int i, j; size_t rt_count; uint32_t mask; @@ -2187,41 +2185,7 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s rt_count = ARRAY_SIZE(graphics->blend_attachments); } - graphics->rt_idx = 0; graphics->null_attachment_mask = 0; - if (desc->DepthStencilState.DepthEnable || desc->DepthStencilState.StencilEnable) - { - if (desc->DSVFormat == DXGI_FORMAT_UNKNOWN) - { - WARN("DSV format is DXGI_FORMAT_UNKNOWN.\n"); - graphics->dsv_format = VK_FORMAT_UNDEFINED; - } - else if ((format = vkd3d_get_format(device, desc->DSVFormat, true))) - { - if (!(format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) - FIXME("Format %#x is not depth/stencil format.\n", format->dxgi_format); - - graphics->dsv_format = format->vk_format; - } - else - { - WARN("Invalid DSV format %#x.\n", desc->DSVFormat); - hr = E_INVALIDARG; - goto fail; - } - - ++graphics->rt_idx; - - if (!desc->PS.pShaderBytecode) - { - if (FAILED(hr = create_shader_stage(device, &graphics->stages[graphics->stage_count], - VK_SHADER_STAGE_FRAGMENT_BIT, &default_ps, NULL, NULL))) - goto fail; - - ++graphics->stage_count; - } - } - for (i = 0; i < rt_count; ++i) { const D3D12_RENDER_TARGET_BLEND_DESC *rt_desc; @@ -2260,11 +2224,42 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s blend_attachment_from_d3d12(&graphics->blend_attachments[i], rt_desc); } - graphics->null_attachment_mask <<= graphics->rt_idx; - graphics->attachment_count = graphics->rt_idx + rt_count; - for (i = rt_count; i < ARRAY_SIZE(graphics->rtv_formats); ++i) graphics->rtv_formats[i] = VK_FORMAT_UNDEFINED; + graphics->rt_count = rt_count; + + graphics->dsv_format = VK_FORMAT_UNDEFINED; + if (desc->DepthStencilState.DepthEnable || desc->DepthStencilState.StencilEnable) + { + if (desc->DSVFormat == DXGI_FORMAT_UNKNOWN) + { + WARN("DSV format is DXGI_FORMAT_UNKNOWN.\n"); + graphics->dsv_format = VK_FORMAT_UNDEFINED; + graphics->null_attachment_mask |= 1u << graphics->rt_count; + } + else if ((format = vkd3d_get_format(device, desc->DSVFormat, true))) + { + if (!(format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) + FIXME("Format %#x is not depth/stencil format.\n", format->dxgi_format); + + graphics->dsv_format = format->vk_format; + } + else + { + WARN("Invalid DSV format %#x.\n", desc->DSVFormat); + hr = E_INVALIDARG; + goto fail; + } + + if (!desc->PS.pShaderBytecode) + { + if (FAILED(hr = create_shader_stage(device, &graphics->stages[graphics->stage_count], + VK_SHADER_STAGE_FRAGMENT_BIT, &default_ps, NULL, NULL))) + goto fail; + + ++graphics->stage_count; + } + } ps_shader_parameters[0].name = VKD3D_SHADER_PARAMETER_NAME_RASTERIZER_SAMPLE_COUNT; ps_shader_parameters[0].type = VKD3D_SHADER_PARAMETER_TYPE_IMMEDIATE_CONSTANT; @@ -2524,7 +2519,8 @@ static HRESULT d3d12_pipeline_state_init_graphics(struct d3d12_pipeline_state *s } rs_desc_from_d3d12(&graphics->rs_desc, &desc->RasterizerState); - if ((!graphics->attachment_count && !(desc->PS.pShaderBytecode && desc->PS.BytecodeLength)) + have_attachment = graphics->rt_count || graphics->dsv_format || (graphics->null_attachment_mask & (1u << graphics->rt_count)); + if ((!have_attachment && !(desc->PS.pShaderBytecode && desc->PS.BytecodeLength)) || so_desc->RasterizedStream == D3D12_SO_NO_RASTERIZED_STREAM) graphics->rs_desc.rasterizerDiscardEnable = VK_TRUE; @@ -2846,7 +2842,7 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta blend_desc.flags = 0; blend_desc.logicOpEnable = VK_FALSE; blend_desc.logicOp = VK_LOGIC_OP_COPY; - blend_desc.attachmentCount = graphics->attachment_count - graphics->rt_idx; + blend_desc.attachmentCount = graphics->rt_count; blend_desc.pAttachments = graphics->blend_attachments; blend_desc.blendConstants[0] = D3D12_DEFAULT_BLEND_FACTOR_RED; blend_desc.blendConstants[1] = D3D12_DEFAULT_BLEND_FACTOR_GREEN; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 002eeacf0748..44e61c2aaac6 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -674,7 +674,7 @@ struct d3d12_graphics_pipeline_state size_t attribute_count; VkPipelineColorBlendAttachmentState blend_attachments[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; - unsigned int attachment_count, rt_idx; + unsigned int rt_count; unsigned int null_attachment_mask; VkFormat dsv_format; VkFormat rtv_formats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; @@ -858,7 +858,8 @@ struct d3d12_command_list DXGI_FORMAT index_buffer_format; - VkImageView views[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT + 1]; + VkImageView rtvs[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT]; + VkImageView dsv; unsigned int fb_width; unsigned int fb_height; unsigned int fb_layer_count; -- 2.21.0

2 1

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel