Wine-devel
Threads by month
- ----- 2026 -----
- March
- February
- January
- ----- 2025 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2024 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2007 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2006 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2005 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2004 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2003 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2002 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2001 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
April 2019
- 82 participants
- 743 discussions
[PATCH 1/7] qedit/tests: Add more tests for sample grabber filter interfaces.
by Zebediah Figura 17 Apr '19
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
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
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
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
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
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
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
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
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
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