April 2019 - Wine-devel - list.winehq.org

[PATCH 1/7] qedit/tests: Add more tests for sample grabber filter interfaces.
by Zebediah Figura 17 Apr '19

17 Apr '19

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/qedit/tests/Makefile.in | 1 + dlls/qedit/tests/mediadet.c | 12 ----- dlls/qedit/tests/samplegrabber.c | 87 ++++++++++++++++++++++++++++++++ 3 files changed, 88 insertions(+), 12 deletions(-) create mode 100644 dlls/qedit/tests/samplegrabber.c diff --git a/dlls/qedit/tests/Makefile.in b/dlls/qedit/tests/Makefile.in index 07dd4b0bb7..052336d64d 100644 --- a/dlls/qedit/tests/Makefile.in +++ b/dlls/qedit/tests/Makefile.in @@ -3,6 +3,7 @@ IMPORTS = oleaut32 ole32 C_SRCS = \ mediadet.c \ + samplegrabber.c \ timeline.c RC_SRCS = qedit.rc diff --git a/dlls/qedit/tests/mediadet.c b/dlls/qedit/tests/mediadet.c index 6bc20e574e..5c567e26d4 100644 --- a/dlls/qedit/tests/mediadet.c +++ b/dlls/qedit/tests/mediadet.c @@ -612,18 +612,6 @@ static void test_samplegrabber(void) IMemInputPin_Release(inpin); IPin_Release(pin); - /* Interfaces that native does not support */ - hr = ISampleGrabber_QueryInterface(sg, &IID_IMediaPosition, (void**)&unk); - todo_wine ok(hr == E_NOINTERFACE, "QueryInterface for IID_IMediaPosition failed: %08x\n", hr); - hr = ISampleGrabber_QueryInterface(sg, &IID_IMediaSeeking, (void**)&unk); - todo_wine ok(hr == E_NOINTERFACE, "QueryInterface for IID_IMediaSeeking failed: %08x\n", hr); - hr = ISampleGrabber_QueryInterface(sg, &IID_IMemInputPin, (void**)&unk); - ok(hr == E_NOINTERFACE, "QueryInterface for IID_IMemInputPin failed: %08x\n", hr); - hr = ISampleGrabber_QueryInterface(sg, &IID_IQualityControl, (void**)&unk); - ok(hr == E_NOINTERFACE, "QueryInterface for IID_IQualityControl failed: %08x\n", hr); - hr = ISampleGrabber_QueryInterface(sg, &IID_ISeekingPassThru, (void**)&unk); - ok(hr == E_NOINTERFACE, "QueryInterface for IID_ISeekingPassThru failed: %08x\n", hr); - while (ISampleGrabber_Release(sg)); } diff --git a/dlls/qedit/tests/samplegrabber.c b/dlls/qedit/tests/samplegrabber.c new file mode 100644 index 0000000000..d6fa4051d5 --- /dev/null +++ b/dlls/qedit/tests/samplegrabber.c @@ -0,0 +1,87 @@ +/* + * Sample grabber filter unit tests + * + * Copyright 2018 Zebediah Figura + * + * 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 + */ + +#define COBJMACROS +#include "dshow.h" +#include "qedit.h" +#include "wine/test.h" + +static IBaseFilter *create_sample_grabber(void) +{ + IBaseFilter *filter = NULL; + HRESULT hr = CoCreateInstance(&CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter); + ok(hr == S_OK, "Got hr %#x.\n", hr); + return filter; +} + +#define check_interface(a, b, c) check_interface_(__LINE__, a, b, c) +static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOOL supported) +{ + IUnknown *iface = iface_ptr; + HRESULT hr, expected_hr; + IUnknown *unk; + + expected_hr = supported ? S_OK : E_NOINTERFACE; + + hr = IUnknown_QueryInterface(iface, iid, (void **)&unk); + ok_(__FILE__, line)(hr == expected_hr, "Got hr %#x, expected %#x.\n", hr, expected_hr); + if (SUCCEEDED(hr)) + IUnknown_Release(unk); +} + +static void test_interfaces(void) +{ + IBaseFilter *filter = create_sample_grabber(); + ULONG ref; + + check_interface(filter, &IID_IBaseFilter, TRUE); + check_interface(filter, &IID_IMediaFilter, TRUE); + check_interface(filter, &IID_IPersist, TRUE); + check_interface(filter, &IID_ISampleGrabber, TRUE); + check_interface(filter, &IID_IUnknown, TRUE); + + check_interface(filter, &IID_IAMFilterMiscFlags, FALSE); + check_interface(filter, &IID_IBasicAudio, FALSE); + check_interface(filter, &IID_IBasicVideo, FALSE); + check_interface(filter, &IID_IKsPropertySet, FALSE); + todo_wine check_interface(filter, &IID_IMediaPosition, FALSE); + todo_wine check_interface(filter, &IID_IMediaSeeking, FALSE); + check_interface(filter, &IID_IMemInputPin, FALSE); + check_interface(filter, &IID_IPersistPropertyBag, FALSE); + check_interface(filter, &IID_IPin, FALSE); + check_interface(filter, &IID_IQualityControl, FALSE); + check_interface(filter, &IID_IQualProp, FALSE); + check_interface(filter, &IID_IReferenceClock, FALSE); + check_interface(filter, &IID_ISeekingPassThru, FALSE); + check_interface(filter, &IID_IVideoWindow, FALSE); + + ref = IBaseFilter_Release(filter); + ok(!ref, "Got unexpected refcount %d.\n", ref); +} + +START_TEST(samplegrabber) +{ + CoInitialize(NULL); + + test_interfaces(); + + CoUninitialize(); +} -- 2.21.0

4 19

[PATCH] dinput: Report controllers as gamepads, not joysticks
by Andrew Eikum 17 Apr '19

17 Apr '19

This matches what Windows does with common controllers like xbox 360. Signed-off-by: Andrew Eikum <aeikum(a)codeweavers.com> --- This allows controllers to work in some games like Telltale games and Yakuza Kiwami. dlls/dinput/dinput_main.c | 1 + dlls/dinput/joystick_linux.c | 9 +++------ dlls/dinput/joystick_linuxinput.c | 9 +++------ dlls/dinput/joystick_osx.c | 7 +++++-- 4 files changed, 12 insertions(+), 14 deletions(-) diff --git a/dlls/dinput/dinput_main.c b/dlls/dinput/dinput_main.c index 1b2020c7110..7b6a5b075cd 100644 --- a/dlls/dinput/dinput_main.c +++ b/dlls/dinput/dinput_main.c @@ -246,6 +246,7 @@ static const char *_dump_DIDEVTYPE_value(DWORD dwDevType, DWORD dwVersion) case DIDEVTYPE_KEYBOARD: return "DIDEVTYPE_KEYBOARD"; case DIDEVTYPE_JOYSTICK: return "DIDEVTYPE_JOYSTICK"; case DIDEVTYPE_DEVICE: return "DIDEVTYPE_DEVICE"; + case DIDEVTYPE_GAMEPAD: return "DIDEVTYPE_GAMEPAD"; default: return "Unknown"; } } else { diff --git a/dlls/dinput/joystick_linux.c b/dlls/dinput/joystick_linux.c index 963e62f017c..736a06e2b27 100644 --- a/dlls/dinput/joystick_linux.c +++ b/dlls/dinput/joystick_linux.c @@ -316,9 +316,9 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver lpddi->guidProduct = joystick_devices[id].guid_product; /* we only support traditional joysticks for now */ if (version >= 0x0800) - lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8); + lpddi->dwDevType = DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8); else - lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8); + lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8); /* Assume the joystick as HID if it is attached to USB bus and has a valid VID/PID */ if (joystick_devices[id].bus_type == BUS_USB && @@ -326,10 +326,7 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver { lpddi->dwDevType |= DIDEVTYPE_HID; lpddi->wUsagePage = 0x01; /* Desktop */ - if (lpddi->dwDevType == DI8DEVTYPE_JOYSTICK || lpddi->dwDevType == DIDEVTYPE_JOYSTICK) - lpddi->wUsage = 0x04; /* Joystick */ - else - lpddi->wUsage = 0x05; /* Game Pad */ + lpddi->wUsage = 0x05; /* Game Pad */ } MultiByteToWideChar(CP_ACP, 0, joystick_devices[id].name, -1, lpddi->tszInstanceName, MAX_PATH); diff --git a/dlls/dinput/joystick_linuxinput.c b/dlls/dinput/joystick_linuxinput.c index 910e755d3ed..cea669b90cb 100644 --- a/dlls/dinput/joystick_linuxinput.c +++ b/dlls/dinput/joystick_linuxinput.c @@ -355,9 +355,9 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver lpddi->guidFFDriver = GUID_NULL; if (version >= 0x0800) - lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8); + lpddi->dwDevType = DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8); else - lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8); + lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8); /* Assume the joystick as HID if it is attached to USB bus and has a valid VID/PID */ if (joydevs[id].bus_type == BUS_USB && @@ -365,10 +365,7 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver { lpddi->dwDevType |= DIDEVTYPE_HID; lpddi->wUsagePage = 0x01; /* Desktop */ - if (lpddi->dwDevType == DI8DEVTYPE_JOYSTICK || lpddi->dwDevType == DIDEVTYPE_JOYSTICK) - lpddi->wUsage = 0x04; /* Joystick */ - else - lpddi->wUsage = 0x05; /* Game Pad */ + lpddi->wUsage = 0x05; /* Game Pad */ } MultiByteToWideChar(CP_ACP, 0, joydevs[id].name, -1, lpddi->tszInstanceName, MAX_PATH); diff --git a/dlls/dinput/joystick_osx.c b/dlls/dinput/joystick_osx.c index 0701b9f42cc..daef1a12ed5 100644 --- a/dlls/dinput/joystick_osx.c +++ b/dlls/dinput/joystick_osx.c @@ -969,9 +969,12 @@ static HRESULT joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINS lpddi->guidProduct.Data1 = make_vid_pid(device); /* we only support traditional joysticks for now */ if (version >= 0x0800) - lpddi->dwDevType = DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8); + lpddi->dwDevType = DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8); else - lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8); + lpddi->dwDevType = DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8); + lpddi->dwDevType |= DIDEVTYPE_HID; + lpddi->wUsagePage = 0x01; /* Desktop */ + lpddi->wUsage = 0x05; /* Game Pad */ sprintf(lpddi->tszInstanceName, "Joystick %d", id); /* get the device name */ -- 2.21.0

2 1

[PATCH V2 1/3] mmsystem.dll16: Remove and replace tabs with spaces
by Vijay Kiran Kamuju 17 Apr '19

17 Apr '19

From: Vijay Kiran Kamuju <infyquest(a)gmail.com> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/mmsystem.dll16/message16.c | 938 ++++++++++++++++---------------- 1 file changed, 469 insertions(+), 469 deletions(-) diff --git a/dlls/mmsystem.dll16/message16.c b/dlls/mmsystem.dll16/message16.c index 012d3dca869..28f20ba0b29 100644 --- a/dlls/mmsystem.dll16/message16.c +++ b/dlls/mmsystem.dll16/message16.c @@ -42,29 +42,29 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); * ================================= */ /************************************************************************** - * MMSYSTDRV_Mixer_Map16To32W [internal] + * MMSYSTDRV_Mixer_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_Mixer_UnMap16To32W [internal] + * MMSYSTDRV_Mixer_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { #if 0 - MIXERCAPSA micA; - UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); + MIXERCAPSA micA; + UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); if (ret == MMSYSERR_NOERROR) { - mixcaps->wMid = micA.wMid; - mixcaps->wPid = micA.wPid; - mixcaps->vDriverVersion = micA.vDriverVersion; - strcpy(mixcaps->szPname, micA.szPname); - mixcaps->fdwSupport = micA.fdwSupport; - mixcaps->cDestinations = micA.cDestinations; + mixcaps->wMid = micA.wMid; + mixcaps->wPid = micA.wPid; + mixcaps->vDriverVersion = micA.vDriverVersion; + strcpy(mixcaps->szPname, micA.szPname); + mixcaps->fdwSupport = micA.fdwSupport; + mixcaps->cDestinations = micA.cDestinations; } return ret; #endif @@ -72,9 +72,9 @@ static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpPa } /************************************************************************** - * MMSYSTDRV_Mixer_MapCB + * MMSYSTDRV_Mixer_MapCB */ -static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { FIXME("NIY\n"); } @@ -84,50 +84,50 @@ static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser * ================================= */ /************************************************************************** - * MMSYSTDRV_MidiIn_Map16To32W [internal] + * MMSYSTDRV_MidiIn_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_MidiIn_UnMap16To32W [internal] + * MMSYSTDRV_MidiIn_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_MidiIn_MapCB [internal] + * MMSYSTDRV_MidiIn_MapCB [internal] */ -static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case MIM_OPEN: case MIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ case MIM_DATA: case MIM_MOREDATA: case MIM_ERROR: - /* dwParam1 & dwParam2 are data, nothing to do */ - break; + /* dwParam1 & dwParam2 are data, nothing to do */ + break; case MIM_LONGDATA: case MIM_LONGERROR: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(segmh16); - - *dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - } - break; + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(segmh16); + + *dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + mh16->dwBytesRecorded = mh32->dwBytesRecorded; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -136,187 +136,187 @@ static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DW * ================================= */ /************************************************************************** - * MMSYSTDRV_MidiOut_Map16To32W [internal] + * MMSYSTDRV_MidiOut_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case MODM_OPEN: case MODM_CLOSE: case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW)); - LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); - - if (moc32) { - *(LPMIDIOUTCAPS16*)moc32 = moc16; - moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); - *lpParam1 = (DWORD)moc32; - *lpParam2 = sizeof(MIDIOUTCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW)); + LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); + + if (moc32) { + *(LPMIDIOUTCAPS16*)moc32 = moc16; + moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); + *lpParam1 = (DWORD)moc32; + *lpParam2 = sizeof(MIDIOUTCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case MODM_PREPARE: - { - LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(*lpParam1); - - if (mh32) { - *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; - mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); - mh32->lpData = MapSL((SEGPTR)mh16->lpData); - mh32->dwBufferLength = mh16->dwBufferLength; - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - mh32->dwUser = mh16->dwUser; - mh32->dwFlags = mh16->dwFlags; - mh16->lpNext = (MIDIHDR16*)mh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)mh32; - *lpParam2 = offsetof(MIDIHDR,dwOffset); /* old size, without dwOffset */ - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + + if (mh32) { + *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; + mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); + mh32->lpData = MapSL((SEGPTR)mh16->lpData); + mh32->dwBufferLength = mh16->dwBufferLength; + mh32->dwBytesRecorded = mh16->dwBytesRecorded; + mh32->dwUser = mh16->dwUser; + mh32->dwFlags = mh16->dwFlags; + mh16->lpNext = (MIDIHDR16*)mh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)mh32; + *lpParam2 = offsetof(MIDIHDR,dwOffset); /* old size, without dwOffset */ + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case MODM_UNPREPARE: case MODM_LONGDATA: - { - LPMIDIHDR16 mh16 = MapSL(*lpParam1); - LPMIDIHDR mh32 = (MIDIHDR*)mh16->lpNext; - - *lpParam1 = (DWORD)mh32; - *lpParam2 = offsetof(MIDIHDR,dwOffset); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - mh32->dwBufferLength, mh16->dwBufferLength); - } else - mh32->dwBufferLength = mh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + LPMIDIHDR mh32 = (MIDIHDR*)mh16->lpNext; + + *lpParam1 = (DWORD)mh32; + *lpParam2 = offsetof(MIDIHDR,dwOffset); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + mh32->dwBufferLength, mh16->dwBufferLength); + } else + mh32->dwBufferLength = mh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case MODM_CACHEPATCHES: case MODM_CACHEDRUMPATCHES: default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_MidiOut_UnMap16To32W [internal] + * MMSYSTDRV_MidiOut_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case MODM_OPEN: case MODM_CLOSE: case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1); - LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - - moc16->wMid = moc32->wMid; - moc16->wPid = moc32->wPid; - moc16->vDriverVersion = moc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname, - sizeof(moc16->szPname), NULL, NULL ); - moc16->wTechnology = moc32->wTechnology; - moc16->wVoices = moc32->wVoices; - moc16->wNotes = moc32->wNotes; - moc16->wChannelMask = moc32->wChannelMask; - moc16->dwSupport = moc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1); + LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + + moc16->wMid = moc32->wMid; + moc16->wPid = moc32->wPid; + moc16->vDriverVersion = moc32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname, + sizeof(moc16->szPname), NULL, NULL ); + moc16->wTechnology = moc32->wTechnology; + moc16->wVoices = moc32->wVoices; + moc16->wNotes = moc32->wNotes; + moc16->wChannelMask = moc32->wChannelMask; + moc16->dwSupport = moc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case MODM_PREPARE: case MODM_UNPREPARE: case MODM_LONGDATA: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); - LPMIDIHDR16 mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); + LPMIDIHDR16 mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); - assert((MIDIHDR*)mh16->lpNext == mh32); - mh16->dwFlags = mh32->dwFlags; + assert((MIDIHDR*)mh16->lpNext == mh32); + mh16->dwFlags = mh32->dwFlags; - if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); - mh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); + mh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; case MODM_CACHEPATCHES: case MODM_CACHEDRUMPATCHES: default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /****************************************************************** - * MMSYSTDRV_MidiOut_MapCB + * MMSYSTDRV_MidiOut_MapCB */ -static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case MOM_OPEN: case MOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case MOM_POSITIONCB: - /* MIDIHDR.dwOffset exists since Win 32 only */ - FIXME("MOM_POSITIONCB/MEVT_F_CALLBACK wants MIDIHDR.dwOffset in 16 bit code\n"); - /* fall through */ + /* MIDIHDR.dwOffset exists since Win 32 only */ + FIXME("MOM_POSITIONCB/MEVT_F_CALLBACK wants MIDIHDR.dwOffset in 16 bit code\n"); + /* fall through */ case MOM_DONE: - { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(segmh16); - - *dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - } - break; + { + /* initial map is: 16 => 32 */ + LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(segmh16); + + *dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -325,120 +325,120 @@ static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dw * ================================= */ /************************************************************************** - * MMSYSTDRV_WaveIn_Map16To32W [internal] + * MMSYSTDRV_WaveIn_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WIDM_OPEN: case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW)); - LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); - - if (wic32) { - *(LPWAVEINCAPS16*)wic32 = wic16; - wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); - *lpParam1 = (DWORD)wic32; - *lpParam2 = sizeof(WAVEINCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW)); + LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); + + if (wic32) { + *(LPWAVEINCAPS16*)wic32 = wic16; + wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); + *lpParam1 = (DWORD)wic32; + *lpParam2 = sizeof(WAVEINCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_ADDBUFFER: case WIDM_UNPREPARE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case WIDM_MAPPER_STATUS: - /* just a single DWORD */ - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = MMSYSTEM_MAP_OK; - break; + /* just a single DWORD */ + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = MMSYSTEM_MAP_OK; + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveIn_UnMap16To32W [internal] + * MMSYSTDRV_WaveIn_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: @@ -446,87 +446,87 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpP case WIDM_START: case WIDM_STOP: case WIDM_MAPPER_STATUS: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WIDM_OPEN: case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1); - LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - - wic16->wMid = wic32->wMid; - wic16->wPid = wic32->wPid; - wic16->vDriverVersion = wic32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname, - sizeof(wic16->szPname), NULL, NULL ); - wic16->dwFormats = wic32->dwFormats; - wic16->wChannels = wic32->wChannels; - HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1); + LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + + wic16->wMid = wic32->wMid; + wic16->wPid = wic32->wPid; + wic16->vDriverVersion = wic32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname, + sizeof(wic16->szPname), NULL, NULL ); + wic16->dwFormats = wic32->dwFormats; + wic16->wChannels = wic32->wChannels; + HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WIDM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WIDM_ADDBUFFER: case WIDM_PREPARE: case WIDM_UNPREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwFlags = wh32->dwFlags; - - if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwFlags = wh32->dwFlags; + + if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveIn_MapCB [internal] + * MMSYSTDRV_WaveIn_MapCB [internal] */ -static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case WIM_OPEN: case WIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case WIM_DATA: - { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - *dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - } - break; + { + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + *dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -535,11 +535,11 @@ static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* * ================================= */ /************************************************************************** - * MMSYSTDRV_WaveOut_Map16To32W [internal] + * MMSYSTDRV_WaveOut_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { /* nothing to do */ @@ -552,112 +552,112 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lp case WODM_SETPITCH: case WODM_SETPLAYBACKRATE: case WODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WODM_GETPITCH: case WODM_GETPLAYBACKRATE: case WODM_GETVOLUME: case WODM_OPEN: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW)); - LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); - - if (woc32) { - *(LPWAVEOUTCAPS16*)woc32 = woc16; - woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); - *lpParam1 = (DWORD)woc32; - *lpParam2 = sizeof(WAVEOUTCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW)); + LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); + + if (woc32) { + *(LPWAVEOUTCAPS16*)woc32 = woc16; + woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); + *lpParam1 = (DWORD)woc32; + *lpParam2 = sizeof(WAVEOUTCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_UNPREPARE: case WODM_WRITE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case WODM_MAPPER_STATUS: - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = MMSYSTEM_MAP_OK; - break; + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = MMSYSTEM_MAP_OK; + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveOut_UnMap16To32W [internal] + * MMSYSTDRV_WaveOut_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { /* nothing to do */ @@ -671,90 +671,90 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lp case WODM_SETPLAYBACKRATE: case WODM_SETVOLUME: case WODM_MAPPER_STATUS: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WODM_GETPITCH: case WODM_GETPLAYBACKRATE: case WODM_GETVOLUME: case WODM_OPEN: - FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); + break; case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1); - LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - - woc16->wMid = woc32->wMid; - woc16->wPid = woc32->wPid; - woc16->vDriverVersion = woc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname, - sizeof(woc16->szPname), NULL, NULL ); - woc16->dwFormats = woc32->dwFormats; - woc16->wChannels = woc32->wChannels; - woc16->dwSupport = woc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1); + LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + + woc16->wMid = woc32->wMid; + woc16->wPid = woc32->wPid; + woc16->vDriverVersion = woc32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname, + sizeof(woc16->szPname), NULL, NULL ); + woc16->dwFormats = woc32->dwFormats; + woc16->wChannels = woc32->wChannels; + woc16->dwSupport = woc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WODM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WODM_PREPARE: case WODM_UNPREPARE: case WODM_WRITE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwFlags = wh32->dwFlags; - - if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwFlags = wh32->dwFlags; + + if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMDRV_WaveOut_Callback [internal] + * MMDRV_WaveOut_Callback [internal] */ -static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case WOM_OPEN: case WOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case WOM_DONE: { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - *dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - } - break; + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + *dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -762,12 +762,12 @@ static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dw * # DRIVER THUNKING # * ################################################### */ -typedef MMSYSTEM_MapType (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2); -typedef MMSYSTEM_MapType (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret); -typedef void (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2); +typedef MMSYSTEM_MapType (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2); +typedef MMSYSTEM_MapType (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret); +typedef void (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2); #include <pshpack1.h> -#define MMSYSTDRV_MAX_THUNKS 32 +#define MMSYSTDRV_MAX_THUNKS 32 static struct mmsystdrv_thunk { @@ -800,7 +800,7 @@ static struct MMSYSTDRV_Type }; /****************************************************************** - * MMSYSTDRV_Callback3216 + * MMSYSTDRV_Callback3216 * */ static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HDRVR hDev, @@ -852,10 +852,10 @@ static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HD } /****************************************************************** - * MMSYSTDRV_AddThunk + * MMSYSTDRV_AddThunk * */ -struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind) +struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind) { struct mmsystdrv_thunk* thunk; @@ -901,11 +901,11 @@ struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, en } /****************************************************************** - * MMSYSTDRV_FindHandle + * MMSYSTDRV_FindHandle * * Must be called with lock set */ -static void* MMSYSTDRV_FindHandle(void* h) +static void* MMSYSTDRV_FindHandle(void* h) { struct mmsystdrv_thunk* thunk; @@ -921,19 +921,19 @@ static void* MMSYSTDRV_FindHandle(void* h) } /****************************************************************** - * MMSYSTDRV_SetHandle + * MMSYSTDRV_SetHandle * */ -void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h) +void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h) { if (MMSYSTDRV_FindHandle(h)) FIXME("Already has a thunk for this handle %p!!!\n", h); thunk->hMmdrv = h; } /****************************************************************** - * MMSYSTDRV_DeleteThunk + * MMSYSTDRV_DeleteThunk */ -void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) +void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) { thunk->callback = 0; thunk->flags = CALLBACK_NULL; @@ -942,9 +942,9 @@ void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) } /****************************************************************** - * MMSYSTDRV_CloseHandle + * MMSYSTDRV_CloseHandle */ -void MMSYSTDRV_CloseHandle(void* h) +void MMSYSTDRV_CloseHandle(void* h) { struct mmsystdrv_thunk* thunk; @@ -957,9 +957,9 @@ void MMSYSTDRV_CloseHandle(void* h) } /****************************************************************** - * MMSYSTDRV_Message + * MMSYSTDRV_Message */ -DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2) +DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2) { struct mmsystdrv_thunk* thunk = MMSYSTDRV_FindHandle(h); struct MMSYSTDRV_Type* drvtype; -- 2.17.0

1 2

[PATCH] msi: Remove system environment variables on uninstall.
by Hans Leidekker 17 Apr '19

17 Apr '19

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/msi/action.c | 2 +- dlls/msi/tests/action.c | 14 ++++++++++++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/dlls/msi/action.c b/dlls/msi/action.c index 849335edde..03b6abfa45 100644 --- a/dlls/msi/action.c +++ b/dlls/msi/action.c @@ -7050,7 +7050,7 @@ static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags ) else if (*cptr == '!') *flags |= ENV_ACT_REMOVEMATCH; else if (*cptr == '*') - *flags |= ENV_MOD_MACHINE; + *flags |= ENV_MOD_MACHINE | ENV_ACT_REMOVE; else break; diff --git a/dlls/msi/tests/action.c b/dlls/msi/tests/action.c index 068fc55b78..60ae92e64c 100644 --- a/dlls/msi/tests/action.c +++ b/dlls/msi/tests/action.c @@ -247,7 +247,8 @@ static const char env_environment_dat[] = "Var26\t+-MSITESTVAR20\t2[~]\tOne\n" "Var27\t+-MSITESTVAR21\t[~];1\tOne\n" "Var28\t-MSITESTVAR22\t1\tOne\n" - "Var29\t-MSITESTVAR23\t2\tOne\n"; + "Var29\t-MSITESTVAR23\t2\tOne\n" + "Var30\t*MSITESTVAR100\t1\tOne\n"; static const char service_install_dat[] = "ServiceInstall\tName\tDisplayName\tServiceType\tStartType\tErrorControl\t" @@ -4960,7 +4961,7 @@ static void test_envvar(void) { char buffer[16]; UINT r, i; - HKEY env; + HKEY env, env2; LONG res; if (is_process_limited()) @@ -4974,6 +4975,10 @@ static void test_envvar(void) res = RegCreateKeyExA(HKEY_CURRENT_USER, "Environment", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &env, NULL); ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res); + res = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Control\\Session Manager\\Environment", + 0, NULL, 0, KEY_ALL_ACCESS, NULL, &env2, NULL); + ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res); + res = RegSetValueExA(env, "MSITESTVAR1", 0, REG_SZ, (const BYTE *)"0", 2); ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res); @@ -5027,6 +5032,7 @@ static void test_envvar(void) CHECK_REG_STR(env, "MSITESTVAR19", "1"); CHECK_REG_STR(env, "MSITESTVAR20", "1"); CHECK_REG_STR(env, "MSITESTVAR21", "1"); + CHECK_REG_STR(env2, "MSITESTVAR100", "1"); res = RegSetValueExA(env, "MSITESTVAR22", 0, REG_SZ, (const BYTE *)"1", 2); ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res); @@ -5054,11 +5060,15 @@ todo_wine { ok(res == ERROR_FILE_NOT_FOUND, "[%d] got %u\n", i, res); } + res = RegDeleteValueA(env2, "MSITESTVAR100"); + ok(res == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %d\n", res); + error: RegDeleteValueA(env, "MSITESTVAR1"); RegDeleteValueA(env, "MSITESTVAR2"); RegDeleteValueA(env, "MSITESTVAR21"); RegCloseKey(env); + RegCloseKey(env2); DeleteFileA(msifile); } -- 2.20.1

2 1

[PATCH 1/3] mmsystem.dll16: Remove and replace tabs with spaces
by Vijay Kiran Kamuju 17 Apr '19

17 Apr '19

From: Vijay Kiran Kamuju <infyquest(a)gmail.com> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/mmsystem.dll16/message16.c | 938 ++++++++++++++++---------------- 1 file changed, 469 insertions(+), 469 deletions(-) diff --git a/dlls/mmsystem.dll16/message16.c b/dlls/mmsystem.dll16/message16.c index 012d3dca869..28f20ba0b29 100644 --- a/dlls/mmsystem.dll16/message16.c +++ b/dlls/mmsystem.dll16/message16.c @@ -42,29 +42,29 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); * ================================= */ /************************************************************************** - * MMSYSTDRV_Mixer_Map16To32W [internal] + * MMSYSTDRV_Mixer_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_Mixer_UnMap16To32W [internal] + * MMSYSTDRV_Mixer_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { #if 0 - MIXERCAPSA micA; - UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); + MIXERCAPSA micA; + UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); if (ret == MMSYSERR_NOERROR) { - mixcaps->wMid = micA.wMid; - mixcaps->wPid = micA.wPid; - mixcaps->vDriverVersion = micA.vDriverVersion; - strcpy(mixcaps->szPname, micA.szPname); - mixcaps->fdwSupport = micA.fdwSupport; - mixcaps->cDestinations = micA.cDestinations; + mixcaps->wMid = micA.wMid; + mixcaps->wPid = micA.wPid; + mixcaps->vDriverVersion = micA.vDriverVersion; + strcpy(mixcaps->szPname, micA.szPname); + mixcaps->fdwSupport = micA.fdwSupport; + mixcaps->cDestinations = micA.cDestinations; } return ret; #endif @@ -72,9 +72,9 @@ static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpPa } /************************************************************************** - * MMSYSTDRV_Mixer_MapCB + * MMSYSTDRV_Mixer_MapCB */ -static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { FIXME("NIY\n"); } @@ -84,50 +84,50 @@ static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser * ================================= */ /************************************************************************** - * MMSYSTDRV_MidiIn_Map16To32W [internal] + * MMSYSTDRV_MidiIn_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_MidiIn_UnMap16To32W [internal] + * MMSYSTDRV_MidiIn_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { return MMSYSTEM_MAP_MSGERROR; } /************************************************************************** - * MMSYSTDRV_MidiIn_MapCB [internal] + * MMSYSTDRV_MidiIn_MapCB [internal] */ -static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case MIM_OPEN: case MIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ case MIM_DATA: case MIM_MOREDATA: case MIM_ERROR: - /* dwParam1 & dwParam2 are data, nothing to do */ - break; + /* dwParam1 & dwParam2 are data, nothing to do */ + break; case MIM_LONGDATA: case MIM_LONGERROR: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(segmh16); - - *dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - } - break; + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(segmh16); + + *dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + mh16->dwBytesRecorded = mh32->dwBytesRecorded; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -136,187 +136,187 @@ static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DW * ================================= */ /************************************************************************** - * MMSYSTDRV_MidiOut_Map16To32W [internal] + * MMSYSTDRV_MidiOut_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case MODM_OPEN: case MODM_CLOSE: case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW)); - LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); - - if (moc32) { - *(LPMIDIOUTCAPS16*)moc32 = moc16; - moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); - *lpParam1 = (DWORD)moc32; - *lpParam2 = sizeof(MIDIOUTCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW)); + LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); + + if (moc32) { + *(LPMIDIOUTCAPS16*)moc32 = moc16; + moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); + *lpParam1 = (DWORD)moc32; + *lpParam2 = sizeof(MIDIOUTCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case MODM_PREPARE: - { - LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(*lpParam1); - - if (mh32) { - *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; - mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); - mh32->lpData = MapSL((SEGPTR)mh16->lpData); - mh32->dwBufferLength = mh16->dwBufferLength; - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - mh32->dwUser = mh16->dwUser; - mh32->dwFlags = mh16->dwFlags; - mh16->lpNext = (MIDIHDR16*)mh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)mh32; - *lpParam2 = offsetof(MIDIHDR,dwOffset); /* old size, without dwOffset */ - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + + if (mh32) { + *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; + mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); + mh32->lpData = MapSL((SEGPTR)mh16->lpData); + mh32->dwBufferLength = mh16->dwBufferLength; + mh32->dwBytesRecorded = mh16->dwBytesRecorded; + mh32->dwUser = mh16->dwUser; + mh32->dwFlags = mh16->dwFlags; + mh16->lpNext = (MIDIHDR16*)mh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)mh32; + *lpParam2 = offsetof(MIDIHDR,dwOffset); /* old size, without dwOffset */ + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case MODM_UNPREPARE: case MODM_LONGDATA: - { - LPMIDIHDR16 mh16 = MapSL(*lpParam1); - LPMIDIHDR mh32 = (MIDIHDR*)mh16->lpNext; - - *lpParam1 = (DWORD)mh32; - *lpParam2 = offsetof(MIDIHDR,dwOffset); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - mh32->dwBufferLength, mh16->dwBufferLength); - } else - mh32->dwBufferLength = mh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + LPMIDIHDR mh32 = (MIDIHDR*)mh16->lpNext; + + *lpParam1 = (DWORD)mh32; + *lpParam2 = offsetof(MIDIHDR,dwOffset); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + mh32->dwBufferLength, mh16->dwBufferLength); + } else + mh32->dwBufferLength = mh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case MODM_CACHEPATCHES: case MODM_CACHEDRUMPATCHES: default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_MidiOut_UnMap16To32W [internal] + * MMSYSTDRV_MidiOut_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case MODM_GETNUMDEVS: case MODM_DATA: case MODM_RESET: case MODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case MODM_OPEN: case MODM_CLOSE: case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1); - LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - - moc16->wMid = moc32->wMid; - moc16->wPid = moc32->wPid; - moc16->vDriverVersion = moc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname, - sizeof(moc16->szPname), NULL, NULL ); - moc16->wTechnology = moc32->wTechnology; - moc16->wVoices = moc32->wVoices; - moc16->wNotes = moc32->wNotes; - moc16->wChannelMask = moc32->wChannelMask; - moc16->dwSupport = moc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1); + LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + + moc16->wMid = moc32->wMid; + moc16->wPid = moc32->wPid; + moc16->vDriverVersion = moc32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname, + sizeof(moc16->szPname), NULL, NULL ); + moc16->wTechnology = moc32->wTechnology; + moc16->wVoices = moc32->wVoices; + moc16->wNotes = moc32->wNotes; + moc16->wChannelMask = moc32->wChannelMask; + moc16->dwSupport = moc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case MODM_PREPARE: case MODM_UNPREPARE: case MODM_LONGDATA: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); - LPMIDIHDR16 mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); + { + LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); + LPMIDIHDR16 mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); - assert((MIDIHDR*)mh16->lpNext == mh32); - mh16->dwFlags = mh32->dwFlags; + assert((MIDIHDR*)mh16->lpNext == mh32); + mh16->dwFlags = mh32->dwFlags; - if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); - mh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); + mh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; case MODM_CACHEPATCHES: case MODM_CACHEDRUMPATCHES: default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /****************************************************************** - * MMSYSTDRV_MidiOut_MapCB + * MMSYSTDRV_MidiOut_MapCB */ -static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case MOM_OPEN: case MOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case MOM_POSITIONCB: - /* MIDIHDR.dwOffset exists since Win 32 only */ - FIXME("MOM_POSITIONCB/MEVT_F_CALLBACK wants MIDIHDR.dwOffset in 16 bit code\n"); - /* fall through */ + /* MIDIHDR.dwOffset exists since Win 32 only */ + FIXME("MOM_POSITIONCB/MEVT_F_CALLBACK wants MIDIHDR.dwOffset in 16 bit code\n"); + /* fall through */ case MOM_DONE: - { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR16 mh16 = MapSL(segmh16); - - *dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - } - break; + { + /* initial map is: 16 => 32 */ + LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1); + SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); + LPMIDIHDR16 mh16 = MapSL(segmh16); + + *dwParam1 = (DWORD)segmh16; + mh16->dwFlags = mh32->dwFlags; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -325,120 +325,120 @@ static void MMSYSTDRV_MidiOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dw * ================================= */ /************************************************************************** - * MMSYSTDRV_WaveIn_Map16To32W [internal] + * MMSYSTDRV_WaveIn_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: case WIDM_RESET: case WIDM_START: case WIDM_STOP: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WIDM_OPEN: case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW)); - LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); - - if (wic32) { - *(LPWAVEINCAPS16*)wic32 = wic16; - wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); - *lpParam1 = (DWORD)wic32; - *lpParam2 = sizeof(WAVEINCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW)); + LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); + + if (wic32) { + *(LPWAVEINCAPS16*)wic32 = wic16; + wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); + *lpParam1 = (DWORD)wic32; + *lpParam2 = sizeof(WAVEINCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WIDM_ADDBUFFER: case WIDM_UNPREPARE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case WIDM_MAPPER_STATUS: - /* just a single DWORD */ - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = MMSYSTEM_MAP_OK; - break; + /* just a single DWORD */ + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = MMSYSTEM_MAP_OK; + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveIn_UnMap16To32W [internal] + * MMSYSTDRV_WaveIn_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { case WIDM_GETNUMDEVS: @@ -446,87 +446,87 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpP case WIDM_START: case WIDM_STOP: case WIDM_MAPPER_STATUS: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WIDM_OPEN: case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1); - LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - - wic16->wMid = wic32->wMid; - wic16->wPid = wic32->wPid; - wic16->vDriverVersion = wic32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname, - sizeof(wic16->szPname), NULL, NULL ); - wic16->dwFormats = wic32->dwFormats; - wic16->wChannels = wic32->wChannels; - HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1); + LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + + wic16->wMid = wic32->wMid; + wic16->wPid = wic32->wPid; + wic16->vDriverVersion = wic32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname, + sizeof(wic16->szPname), NULL, NULL ); + wic16->dwFormats = wic32->dwFormats; + wic16->wChannels = wic32->wChannels; + HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WIDM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WIDM_ADDBUFFER: case WIDM_PREPARE: case WIDM_UNPREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwFlags = wh32->dwFlags; - - if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + wh16->dwFlags = wh32->dwFlags; + + if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveIn_MapCB [internal] + * MMSYSTDRV_WaveIn_MapCB [internal] */ -static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case WIM_OPEN: case WIM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case WIM_DATA: - { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - *dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - } - break; + { + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + *dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + wh16->dwBytesRecorded = wh32->dwBytesRecorded; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -535,11 +535,11 @@ static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* * ================================= */ /************************************************************************** - * MMSYSTDRV_WaveOut_Map16To32W [internal] + * MMSYSTDRV_WaveOut_Map16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) +static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { /* nothing to do */ @@ -552,112 +552,112 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lp case WODM_SETPITCH: case WODM_SETPLAYBACKRATE: case WODM_SETVOLUME: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WODM_GETPITCH: case WODM_GETPLAYBACKRATE: case WODM_GETVOLUME: case WODM_OPEN: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); + break; case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW)); - LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); - - if (woc32) { - *(LPWAVEOUTCAPS16*)woc32 = woc16; - woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); - *lpParam1 = (DWORD)woc32; - *lpParam2 = sizeof(WAVEOUTCAPSW); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW)); + LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); + + if (woc32) { + *(LPWAVEOUTCAPS16*)woc32 = woc16; + woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); + *lpParam1 = (DWORD)woc32; + *lpParam2 = sizeof(WAVEOUTCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); + LPMMTIME16 mmt16 = MapSL(*lpParam1); + + if (mmt32) { + *(LPMMTIME16*)mmt32 = mmt16; + mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); + + mmt32->wType = mmt16->wType; + *lpParam1 = (DWORD)mmt32; + *lpParam2 = sizeof(MMTIME); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = MMSYSTEM_MAP_OKMEM; - } else { - ret = MMSYSTEM_MAP_NOMEM; - } - } - break; + { + LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); + LPWAVEHDR wh16 = MapSL(*lpParam1); + + if (wh32) { + *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; + wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); + wh32->lpData = MapSL((SEGPTR)wh16->lpData); + wh32->dwBufferLength = wh16->dwBufferLength; + wh32->dwBytesRecorded = wh16->dwBytesRecorded; + wh32->dwUser = wh16->dwUser; + wh32->dwFlags = wh16->dwFlags; + wh32->dwLoops = wh16->dwLoops; + /* FIXME: nothing on wh32->lpNext */ + /* could link the wh32->lpNext at this level for memory house keeping */ + wh16->lpNext = wh32; /* for reuse in unprepare and write */ + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + + ret = MMSYSTEM_MAP_OKMEM; + } else { + ret = MMSYSTEM_MAP_NOMEM; + } + } + break; case WODM_UNPREPARE: case WODM_WRITE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = MMSYSTEM_MAP_OKMEM; - } - break; + { + LPWAVEHDR wh16 = MapSL(*lpParam1); + LPWAVEHDR wh32 = wh16->lpNext; + + *lpParam1 = (DWORD)wh32; + *lpParam2 = sizeof(WAVEHDR); + /* dwBufferLength can be reduced between prepare & write */ + if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", + wh32->dwBufferLength, wh16->dwBufferLength); + } else + wh32->dwBufferLength = wh16->dwBufferLength; + ret = MMSYSTEM_MAP_OKMEM; + } + break; case WODM_MAPPER_STATUS: - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = MMSYSTEM_MAP_OK; - break; + *lpParam2 = (DWORD)MapSL(*lpParam2); + ret = MMSYSTEM_MAP_OK; + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMSYSTDRV_WaveOut_UnMap16To32W [internal] + * MMSYSTDRV_WaveOut_UnMap16To32W [internal] */ -static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) +static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; switch (wMsg) { /* nothing to do */ @@ -671,90 +671,90 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lp case WODM_SETPLAYBACKRATE: case WODM_SETVOLUME: case WODM_MAPPER_STATUS: - ret = MMSYSTEM_MAP_OK; - break; + ret = MMSYSTEM_MAP_OK; + break; case WODM_GETPITCH: case WODM_GETPLAYBACKRATE: case WODM_GETVOLUME: case WODM_OPEN: - FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); - break; + FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); + break; case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1); - LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - - woc16->wMid = woc32->wMid; - woc16->wPid = woc32->wPid; - woc16->vDriverVersion = woc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname, - sizeof(woc16->szPname), NULL, NULL ); - woc16->dwFormats = woc32->dwFormats; - woc16->wChannels = woc32->wChannels; - woc16->dwSupport = woc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1); + LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + + woc16->wMid = woc32->wMid; + woc16->wPid = woc32->wPid; + woc16->vDriverVersion = woc32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname, + sizeof(woc16->szPname), NULL, NULL ); + woc16->dwFormats = woc32->dwFormats; + woc16->wChannels = woc32->wChannels; + woc16->dwSupport = woc32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WODM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); + LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); + + MMSYSTEM_MMTIME32to16(mmt16, mmt32); + HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); + ret = MMSYSTEM_MAP_OK; + } + break; case WODM_PREPARE: case WODM_UNPREPARE: case WODM_WRITE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwFlags = wh32->dwFlags; - - if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = MMSYSTEM_MAP_OK; - } - break; + { + LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); + LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); + + assert(wh16->lpNext == wh32); + wh16->dwFlags = wh32->dwFlags; + + if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { + HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); + wh16->lpNext = 0; + } + ret = MMSYSTEM_MAP_OK; + } + break; default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; + FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); + break; } return ret; } /************************************************************************** - * MMDRV_WaveOut_Callback [internal] + * MMDRV_WaveOut_Callback [internal] */ -static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) +static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2) { switch (uMsg) { case WOM_OPEN: case WOM_CLOSE: - /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ - break; + /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */ + break; case WOM_DONE: { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - *dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - } - break; + /* initial map is: 16 => 32 */ + LPWAVEHDR wh32 = (LPWAVEHDR)(*dwParam1); + SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); + LPWAVEHDR wh16 = MapSL(segwh16); + + *dwParam1 = (DWORD)segwh16; + wh16->dwFlags = wh32->dwFlags; + } + break; default: - ERR("Unknown msg %u\n", uMsg); + ERR("Unknown msg %u\n", uMsg); } } @@ -762,12 +762,12 @@ static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dw * # DRIVER THUNKING # * ################################################### */ -typedef MMSYSTEM_MapType (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2); -typedef MMSYSTEM_MapType (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret); -typedef void (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2); +typedef MMSYSTEM_MapType (*MMSYSTDRV_MAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2); +typedef MMSYSTEM_MapType (*MMSYSTDRV_UNMAPMSG)(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret); +typedef void (*MMSYSTDRV_MAPCB)(DWORD wMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2); #include <pshpack1.h> -#define MMSYSTDRV_MAX_THUNKS 32 +#define MMSYSTDRV_MAX_THUNKS 32 static struct mmsystdrv_thunk { @@ -800,7 +800,7 @@ static struct MMSYSTDRV_Type }; /****************************************************************** - * MMSYSTDRV_Callback3216 + * MMSYSTDRV_Callback3216 * */ static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HDRVR hDev, @@ -852,10 +852,10 @@ static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, HD } /****************************************************************** - * MMSYSTDRV_AddThunk + * MMSYSTDRV_AddThunk * */ -struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind) +struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, enum MMSYSTEM_DriverType kind) { struct mmsystdrv_thunk* thunk; @@ -901,11 +901,11 @@ struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD callback, DWORD flags, en } /****************************************************************** - * MMSYSTDRV_FindHandle + * MMSYSTDRV_FindHandle * * Must be called with lock set */ -static void* MMSYSTDRV_FindHandle(void* h) +static void* MMSYSTDRV_FindHandle(void* h) { struct mmsystdrv_thunk* thunk; @@ -921,19 +921,19 @@ static void* MMSYSTDRV_FindHandle(void* h) } /****************************************************************** - * MMSYSTDRV_SetHandle + * MMSYSTDRV_SetHandle * */ -void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h) +void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h) { if (MMSYSTDRV_FindHandle(h)) FIXME("Already has a thunk for this handle %p!!!\n", h); thunk->hMmdrv = h; } /****************************************************************** - * MMSYSTDRV_DeleteThunk + * MMSYSTDRV_DeleteThunk */ -void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) +void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) { thunk->callback = 0; thunk->flags = CALLBACK_NULL; @@ -942,9 +942,9 @@ void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk) } /****************************************************************** - * MMSYSTDRV_CloseHandle + * MMSYSTDRV_CloseHandle */ -void MMSYSTDRV_CloseHandle(void* h) +void MMSYSTDRV_CloseHandle(void* h) { struct mmsystdrv_thunk* thunk; @@ -957,9 +957,9 @@ void MMSYSTDRV_CloseHandle(void* h) } /****************************************************************** - * MMSYSTDRV_Message + * MMSYSTDRV_Message */ -DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2) +DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2) { struct mmsystdrv_thunk* thunk = MMSYSTDRV_FindHandle(h); struct MMSYSTDRV_Type* drvtype; -- 2.17.0

2 4

[PATCH] include: Add missing definitions in inseng.idl and correct a few functions
by Vijay Kiran Kamuju 17 Apr '19

17 Apr '19

Split from the main patch From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- include/inseng.idl | 273 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 264 insertions(+), 9 deletions(-) diff --git a/include/inseng.idl b/include/inseng.idl index 8a3f4c4d270..bc6ee0a58ad 100644 --- a/include/inseng.idl +++ b/include/inseng.idl @@ -1,5 +1,6 @@ /* * Copyright 2015 Jacek Caban for CodeWeavers + * Copyright 2016 Michael Müller * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -26,13 +27,228 @@ cpp_quote("#endif") interface IStream; -/* FIXME: Add full declarations. */ -interface ICifComponent; -interface IEnumCifComponents; -interface ICifGroup; -interface IEnumCifGroups; -interface ICifMode; -interface IEnumCifModes; +cpp_quote("#define MAX_ID_LENGTH 48") +cpp_quote("#define MAX_DISPLAYNAME_LENGTH 128") + +cpp_quote("#define URLF_DEFAULT 0x0") +cpp_quote("#define URLF_EXTRACT 0x1") +cpp_quote("#define URLF_RELATIVEURL 0x2") +cpp_quote("#define URLF_DELETE_AFTER_EXTRACT 0x4") + +cpp_quote("#define ENGINESTATUS_NOTREADY 0x0") +cpp_quote("#define ENGINESTATUS_LOADING 0x1") +cpp_quote("#define ENGINESTATUS_INSTALLING 0x2") +cpp_quote("#define ENGINESTATUS_READY 0x3") + +cpp_quote("#define SETACTION_NONE 0x0") +cpp_quote("#define SETACTION_INSTALL 0x1") + +cpp_quote("#define INSTALLOPTIONS_NOCACHE 0x01") +cpp_quote("#define INSTALLOPTIONS_DOWNLOAD 0x02") +cpp_quote("#define INSTALLOPTIONS_INSTALL 0x04") +cpp_quote("#define INSTALLOPTIONS_DONTALLOWXPLATFORM 0x08") +cpp_quote("#define INSTALLOPTIONS_FORCEDEPENDENCIES 0x10") + +cpp_quote("#define EXECUTEJOB_SILENT 0x01") +cpp_quote("#define EXECUTEJOB_DELETE_JOB 0x02") +cpp_quote("#define EXECUTEJOB_VERIFYFILES 0x08") +cpp_quote("#define EXECUTEJOB_IGNORETRUST 0x10") +cpp_quote("#define EXECUTEJOB_IGNOREDOWNLOADERROR 0x20") +cpp_quote("#define EXECUTEJOB_DONTALLOWCANCEL 0x40") + +cpp_quote("#define ENGINEPROBLEM_DOWNLOADFAIL 0x1") + +cpp_quote("#define PLATFORM_WIN95 0x01") +cpp_quote("#define PLATFORM_WIN98 0x02") +cpp_quote("#define PLATFORM_NT4 0x04") +cpp_quote("#define PLATFORM_NT5 0x08") +cpp_quote("#define PLATFORM_NT4ALPHA 0x10") +cpp_quote("#define PLATFORM_NT5ALPHA 0x20") +cpp_quote("#define PLATFORM_MILLEN 0x40") +cpp_quote("#define PLATFORM_ALL (PLATFORM_WIN95 | PLATFORM_WIN98 | PLATFORM_NT4 | PLATFORM_NT5 | PLATFORM_NT4ALPHA | PLATFORM_NT5ALPHA | PLATFORM_MILLEN)") + +enum InstallStatus +{ + INSTALLSTATUS_INITIALIZING, + INSTALLSTATUS_DEPENDENCY, + INSTALLSTATUS_DOWNLOADING, + INSTALLSTATUS_COPYING, + INSTALLSTATUS_RETRYING, + INSTALLSTATUS_CHECKINGTRUST, + INSTALLSTATUS_EXTRACTING, + INSTALLSTATUS_RUNNING, + INSTALLSTATUS_FINISHED, + INSTALLSTATUS_DOWNLOADFINISHED, +}; + +enum ComponentAction +{ + ActionNone, + ActionInstall, + ActionUninstall, +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifComponent +{ + HRESULT GetID(char *id, DWORD size); + HRESULT GetGUID(char *guid, DWORD size); + HRESULT GetDescription(char *desc, DWORD size); + HRESULT GetDetails(char *details, DWORD size); + HRESULT GetUrl(UINT index, char *url, DWORD size, DWORD *flags); + HRESULT GetFileExtractList(UINT index, char *extract, DWORD size); + HRESULT GetUrlCheckRange(UINT index, DWORD *min, DWORD *max); + HRESULT GetCommand(UINT index, char *cmd, DWORD cmd_size, char *switches, DWORD switch_size, DWORD *type); + HRESULT GetVersion(DWORD *version, DWORD *build); + HRESULT GetLocale(char *pszLocale, DWORD size); + HRESULT GetUninstallKey(char *key, DWORD size); + HRESULT GetInstalledSize(DWORD *win, DWORD *app); + DWORD GetDownloadSize(); + DWORD GetExtractSize(); + HRESULT GetSuccessKey(char *key, DWORD size); + HRESULT GetProgressKeys(char *progress, DWORD progress_size, char *cancel, DWORD cancel_size); + HRESULT IsActiveSetupAware(); + HRESULT IsRebootRequired(); + HRESULT RequiresAdminRights(); + DWORD GetPriority(); + HRESULT GetDependency(UINT index, char *id, DWORD buf, char *type, DWORD *ver, DWORD *build); + DWORD GetPlatform(); + HRESULT GetMode(UINT index, char *mode, DWORD size); + HRESULT GetGroup(char *id, DWORD size); + HRESULT IsUIVisible(); + HRESULT GetPatchID(char *id, DWORD size); + HRESULT GetDetVersion(char *dll, DWORD dll_size, char *entry, DWORD entry_size); + HRESULT GetTreatAsOneComponents(UINT index, char *id, DWORD buf); + HRESULT GetCustomData(char *key, char *data, DWORD size); + DWORD IsComponentInstalled(); + HRESULT IsComponentDownloaded(); + DWORD IsThisVersionInstalled(DWORD version, DWORD build, DWORD *ret_version, DWORD *ret_build); + DWORD GetInstallQueueState(); + HRESULT SetInstallQueueState(DWORD state); + DWORD GetActualDownloadSize(); + DWORD GetCurrentPriority(); + HRESULT SetCurrentPriority(DWORD priority); +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifRWComponent : ICifComponent +{ + HRESULT SetGUID(const char *guid); + HRESULT SetDescription(const char *desc); + HRESULT SetUrl(UINT index, const char *url, DWORD url_flags); + HRESULT SetCommand(UINT index, const char *cmd, const char *switches, DWORD type); + HRESULT SetVersion(const char *version); + HRESULT SetUninstallKey(const char *key); + HRESULT SetInstalledSize(DWORD win, DWORD app); + HRESULT SetDownloadSize(DWORD size); + HRESULT SetExtractSize(DWORD size); + HRESULT DeleteDependency(const char *id, char type); + HRESULT AddDependency(const char *id, char type); + HRESULT SetUIVisible(BOOL visible); + HRESULT SetGroup(const char *id); + HRESULT SetPlatform(DWORD platform); + HRESULT SetPriority(DWORD priority); + HRESULT SetReboot(BOOL reboot); + HRESULT DeleteFromModes(const char *mode); + HRESULT AddToMode(const char *mode); + HRESULT SetModes(const char *mode); + HRESULT CopyComponent(const char *ciffile); + HRESULT AddToTreatAsOne(const char *compid); + HRESULT SetDetails(const char *desc); +}; + +[ + object, + local, + pointer_default(unique) +] +interface IEnumCifComponents : IUnknown +{ + HRESULT Next(ICifComponent **); + HRESULT Reset(); +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifGroup +{ + HRESULT GetID(char *id, DWORD size); + HRESULT GetDescription(char *desc, DWORD size); + DWORD GetPriority(); + + HRESULT EnumComponents(IEnumCifComponents **, DWORD filter, void *pv); + DWORD GetCurrentPriority(); +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifRWGroup : ICifGroup +{ + HRESULT SetDescription(const char *desc); + HRESULT SetPriority(DWORD priority); + HRESULT SetDetails(const char *details); +}; + +[ + object, + local, + pointer_default(unique) +] +interface IEnumCifGroups : IUnknown +{ + HRESULT Next(ICifGroup **); + HRESULT Reset(); +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifMode +{ + HRESULT GetID(char *id, DWORD size); + HRESULT GetDescription(char *desc, DWORD size); + HRESULT GetDetails(char *details, DWORD size); + + HRESULT EnumComponents(IEnumCifComponents **, DWORD filter, void *pv); +}; + +[ + object, + local, + pointer_default(unique) +] +interface ICifRWMode : ICifMode +{ + HRESULT SetDescription(const char *desc); + HRESULT SetDetails(const char *details); +}; + +[ + object, + local, + pointer_default(unique) +] +interface IEnumCifModes : IUnknown +{ + HRESULT Next(ICifMode **); + HRESULT Reset(); +}; typedef struct { DWORD cbSize; @@ -49,6 +265,15 @@ typedef struct { DWORD dwTotalDownloadSize; } COMPONENT_SIZES; +typedef struct +{ + DWORD cbSize; + DWORD dwDownloadKBRemaining; + DWORD dwInstallKBRemaining; + DWORD dwDownloadSecsRemaining; + DWORD dwInstallSecsRemaining; +} INSTALLPROGRESS; + [ uuid(6e449688-c509-11cf-aafa-00aa00b6015c), local @@ -62,7 +287,24 @@ interface ICifFile : IUnknown HRESULT EnumModes(IEnumCifModes **cuf_modes, DWORD filter, void *pv); HRESULT FindMode(const char *id, ICifMode **p); HRESULT GetDescription(char *desc, DWORD size); - HRESULT GetDetDlls(char **dlls, DWORD size); + HRESULT GetDetDlls(char *dlls, DWORD size); +} + +[ + object, + local, + pointer_default(unique) +] +interface ICifRWFile : ICifFile +{ + HRESULT SetDescription(const char *desc); + HRESULT CreateComponent(const char *id, ICifRWComponent **p); + HRESULT CreateGroup(const char *id, ICifRWGroup **p); + HRESULT CreateMode(const char *id, ICifRWMode **p); + HRESULT DeleteComponent(const char *id); + HRESULT DeleteGroup(const char *id); + HRESULT DeleteMode(const char *id); + HRESULT Flush(); } [ @@ -78,7 +320,7 @@ interface IInstallEngineCallback : IUnknown const char *msg_string, ULONG progress, ULONG max); HRESULT OnStopComponent(const char *id, HRESULT error, DWORD phrase, const char *string, DWORD status); HRESULT OnStopInstall(HRESULT error, const char *error_string, DWORD status); - HRESULT OnEngineProblem(DWORD problem, LPDWORD action); + HRESULT OnEngineProblem(DWORD problem, DWORD *action); } [ @@ -121,6 +363,16 @@ interface IInstallEngine2 : IInstallEngine HRESULT GetICifFile(ICifFile **cif_file); } +[ + uuid(6e449687-c509-11cf-aafa-00aa00b6015c), + local +] +interface IInstallEngineTiming : IUnknown +{ + HRESULT GetRates(DWORD *download, DWORD *install); + HRESULT GetInstallProgress(INSTALLPROGRESS *progress); +} + [ helpstring("Microsoft Active Setup Engine"), threading(apartment), @@ -134,3 +386,6 @@ coclass InstallEngine { } uuid(bfc880f1-7484-11d0-8309-00aa00b6015c) ] coclass DownloadSiteMgr { } + +cpp_quote("HRESULT WINAPI GetICifFileFromFile(ICifFile **, const char *);") +cpp_quote("HRESULT WINAPI GetICifRWFileFromFile(ICifRWFile **, const char *);") -- 2.17.0

1 0

[PATCH] cryptui: Implement CryptUIDlgSelectCertificateFromStore.
by Dmitry Timoshkov 17 Apr '19

17 Apr '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/cryptui/main.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/dlls/cryptui/main.c b/dlls/cryptui/main.c index 41938f5177..33f25a4490 100644 --- a/dlls/cryptui/main.c +++ b/dlls/cryptui/main.c @@ -7550,8 +7550,21 @@ PCCERT_CONTEXT WINAPI CryptUIDlgSelectCertificateFromStore(HCERTSTORE hCertStore LPCWSTR pwszDisplayString, DWORD dwDontUseColumn, DWORD dwFlags, void *pvReserved) { - FIXME("%p %p %s %s %d %d %p: stub\n", hCertStore, hwnd, debugstr_w(pwszTitle), debugstr_w(pwszDisplayString), dwDontUseColumn, dwFlags, pvReserved); - return NULL; + CRYPTUI_SELECTCERTIFICATE_STRUCTW sc; + + TRACE("%p %p %s %s %x %x %p\n", hCertStore, hwnd, debugstr_w(pwszTitle), debugstr_w(pwszDisplayString), dwDontUseColumn, dwFlags, pvReserved); + + memset(&sc, 0, sizeof(sc)); + + sc.dwSize = sizeof(sc); + sc.hwndParent = hwnd; + sc.dwFlags = dwFlags; + sc.szTitle = pwszTitle; + sc.szDisplayString = pwszDisplayString; + sc.dwDontUseColumn = dwDontUseColumn; + sc.cDisplayStores = 1; + sc.rghDisplayStores = &hCertStore; + return CryptUIDlgSelectCertificateW(&sc); } BOOL WINAPI CryptUIWizDigitalSign(DWORD flags, HWND parent, LPCWSTR title, PCCRYPTUI_WIZ_DIGITAL_SIGN_INFO info, -- 2.20.1

1 0

[PATCH] mmsystem.dll16: Translate MidiIn messages.
by Vijay Kiran Kamuju 17 Apr '19

17 Apr '19

From: Michael Müller <michael(a)fds-team.de> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=40024 From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/mmsystem.dll16/message16.c | 128 +++++++++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 2 deletions(-) diff --git a/dlls/mmsystem.dll16/message16.c b/dlls/mmsystem.dll16/message16.c index 012d3dca869..a1e27cf3474 100644 --- a/dlls/mmsystem.dll16/message16.c +++ b/dlls/mmsystem.dll16/message16.c @@ -88,7 +88,78 @@ static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser */ static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2) { - return MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + + switch (wMsg) + { + case MIDM_GETNUMDEVS: + case MIDM_RESET: + ret = MMSYSTEM_MAP_OK; + break; + + case MIDM_GETDEVCAPS: + { + LPMIDIINCAPSW mic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIINCAPS16) + sizeof(MIDIINCAPSW)); + LPMIDIINCAPS16 mic16 = MapSL(*lpParam1); + + if (mic32) + { + *(LPMIDIINCAPS16 *)mic32 = mic16; + mic32 = (LPMIDIINCAPSW)((LPSTR)mic32 + sizeof(LPMIDIINCAPS16)); + *lpParam1 = (DWORD)mic32; + *lpParam2 = sizeof(LPMIDIINCAPSW); + + ret = MMSYSTEM_MAP_OKMEM; + } + else + ret = MMSYSTEM_MAP_NOMEM; + } + break; + + case MIDM_ADDBUFFER: + case MIDM_PREPARE: + { + struct mihdrWrap *mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(struct mihdrWrap)); + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + + if (mh32) + { + mh32->ref = 2; + mh32->mh16 = (SEGPTR)*lpParam1; + mh32->hdr.lpData = MapSL((SEGPTR)mh16->lpData); + mh32->hdr.dwBufferLength = mh16->dwBufferLength; + mh32->hdr.dwBytesRecorded = mh16->dwBytesRecorded; + mh32->hdr.dwUser = mh16->dwUser; + mh32->hdr.dwFlags = mh16->dwFlags; + mh16->lpNext = (MIDIHDR16*)mh32; + *lpParam1 = (DWORD)&mh32->hdr; + *lpParam2 = offsetof(MIDIHDR,dwOffset); + + ret = MMSYSTEM_MAP_OKMEM; + } + else + ret = MMSYSTEM_MAP_NOMEM; + } + break; + + case MIDM_UNPREPARE: + { + LPMIDIHDR16 mh16 = MapSL(*lpParam1); + struct mihdrWrap *mh32 = (struct mihdrWrap *)mh16->lpNext; + + mh32->ref++; + + *lpParam1 = (DWORD)&mh32->hdr; + *lpParam2 = offsetof(MIDIHDR,dwOffset); + + mh32->hdr.dwBufferLength = mh16->dwBufferLength; + + ret = MMSYSTEM_MAP_OKMEM; + } + break; + } + + return ret; } /************************************************************************** @@ -96,7 +167,60 @@ static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpP */ static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret) { - return MMSYSTEM_MAP_MSGERROR; + MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR; + + switch (wMsg) + { + case MIDM_GETNUMDEVS: + case MIDM_RESET: + ret = MMSYSTEM_MAP_OK; + break; + + case MIDM_GETDEVCAPS: + { + LPMIDIINCAPSW mic32 = (LPMIDIINCAPSW)(*lpParam1); + LPMIDIINCAPS16 mic16 = *(LPMIDIINCAPS16*)((LPSTR)mic32 - sizeof(LPMIDIINCAPS16)); + + mic16->wMid = mic32->wMid; + mic16->wPid = mic32->wPid; + mic16->vDriverVersion = mic32->vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, mic32->szPname, -1, mic16->szPname, + sizeof(mic16->szPname), NULL, NULL ); + mic16->dwSupport = mic32->dwSupport; + HeapFree(GetProcessHeap(), 0, (LPSTR)mic32 - sizeof(LPMIDIINCAPS16)); + ret = MMSYSTEM_MAP_OK; + } + break; + + case MIDM_PREPARE: + case MIDM_UNPREPARE: + { + struct mihdrWrap *mh32 = CONTAINING_RECORD((MIDIHDR *)*lpParam1, struct mihdrWrap, hdr); + LPMIDIHDR16 mh16; + + if (mh32->mh16) + { + mh16 = MapSL(mh32->mh16); + assert((struct mihdrWrap *)mh16->lpNext == mh32); + mh16->dwFlags = mh32->hdr.dwFlags; + + if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) + { + mh32->mh16 = 0; + mh32->ref--; + mh16->lpNext = 0; + } + } + + if (!--mh32->ref) + HeapFree(GetProcessHeap(), 0, mh32); + + ret = MMSYSTEM_MAP_OK; + } + break; + + } + return ret; } /************************************************************************** -- 2.17.0

2 1

[PATCH] mciavi32: Add Support for MCI_MCIAVI_PLAY_FULLSCREEN
by Vijay Kiran Kamuju 17 Apr '19

17 Apr '19

From: Bruno Jesus <bjesus(a)codeweavers.com> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=15934 Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> From: Bruno Jesus <bjesus(a)codeweavers.com> --- dlls/mciavi32/mciavi.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/dlls/mciavi32/mciavi.c b/dlls/mciavi32/mciavi.c index b32accb6455..9aa6cd81a05 100644 --- a/dlls/mciavi32/mciavi.c +++ b/dlls/mciavi32/mciavi.c @@ -556,7 +556,7 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms if (dwFlags & MCI_DGV_PLAY_REVERSE) return MCIERR_UNSUPPORTED_FUNCTION; if (dwFlags & MCI_TEST) return 0; - if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLSCREEN|MCI_MCIAVI_PLAY_FULLBY2)) + if (dwFlags & (MCI_MCIAVI_PLAY_WINDOW|MCI_MCIAVI_PLAY_FULLBY2)) FIXME("Unsupported flag %08x\n", dwFlags); EnterCriticalSection(&wma->cs); @@ -591,7 +591,18 @@ static DWORD MCIAVI_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms LeaveCriticalSection(&wma->cs); - if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE)) + if (dwFlags & MCI_MCIAVI_PLAY_FULLSCREEN) + { + HMONITOR mon = MonitorFromWindow(wma->hWndPaint, MONITOR_DEFAULTTONEAREST); + MONITORINFO mi; + mi.cbSize = sizeof(mi); + GetMonitorInfoA(mon, &mi); + wma->hWndPaint = CreateWindowA("STATIC", NULL, WS_POPUP | WS_VISIBLE, mi.rcMonitor.left, + mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, + NULL, NULL, NULL, 0); + } + /* if not fullscreen ensure the window is visible */ + else if (!(GetWindowLongW(wma->hWndPaint, GWL_STYLE) & WS_VISIBLE)) ShowWindow(wma->hWndPaint, SW_SHOWNA); EnterCriticalSection(&wma->cs); -- 2.17.0

1 0

Thanks for all your hard work
by Jefferson Carpenter 17 Apr '19

17 Apr '19

Growing up I always liked to play computer games, and also had the linux bug (no pun intended) so I ran Linux at home. Gaming on Linux was only really possible through Wine, and so I spent a great deal of time working through problems trying to get my games to work. That some games did work, and worked flawlessly, was one of the major reasons I think I was able to stay on Linux semi-permanently at a young age. So to all of you hard-working Wine devs, a big thank you for making this software, since now I'm spending much of my time on Linux at work. Hopefully I can contribute something to this great project, and be that inspiration to others that you all were and are to me.

1 0