[PATCH 16/16] [WinMM,MMSystem]: final split
Eric Pouech
eric.pouech at orange.fr
Thu Oct 22 15:11:29 CDT 2009
A+
---
dlls/mmsystem.dll16/Makefile.in | 18
dlls/mmsystem.dll16/mci16.c | 760 ++++++++++
dlls/mmsystem.dll16/message16.c | 1000 +++++++++++++
dlls/mmsystem.dll16/mmio16.c | 640 ++++++++
dlls/mmsystem.dll16/mmsystem.c | 2409 +++++++++++++++++++++++++++++++
dlls/mmsystem.dll16/mmsystem.dll16.spec | 176 ++
dlls/mmsystem.dll16/winemm16.h | 99 +
7 files changed, 5102 insertions(+), 0 deletions(-)
create mode 100644 dlls/mmsystem.dll16/Makefile.in
create mode 100644 dlls/mmsystem.dll16/mci16.c
create mode 100644 dlls/mmsystem.dll16/message16.c
create mode 100644 dlls/mmsystem.dll16/mmio16.c
create mode 100644 dlls/mmsystem.dll16/mmsystem.c
create mode 100644 dlls/mmsystem.dll16/mmsystem.dll16.spec
create mode 100644 dlls/mmsystem.dll16/winemm16.h
diff --git a/.gitignore b/.gitignore
index 5d498c8..2ac3a69 100644
--- a/.gitignore
+++ b/.gitignore
@@ -64,7 +64,6 @@ dlls/krnl386.exe16
dlls/libd3dx9.def
dlls/libwinspool.def
dlls/libxinput.def
-dlls/mmsystem.dll16
dlls/msdaps/msdaps.h
dlls/msdaps/msdaps_i.c
dlls/msdaps/msdaps_p.c
diff --git a/configure b/configure
index 1507ead..32e37b2 100755
--- a/configure
+++ b/configure
@@ -15351,6 +15351,14 @@ dlls/mmdevldr.vxd/Makefile: dlls/mmdevldr.vxd/Makefile.in dlls/Makedll.rules"
ac_config_files="$ac_config_files dlls/mmdevldr.vxd/Makefile"
ALL_MAKEFILES="$ALL_MAKEFILES \\
+ dlls/mmsystem.dll16/Makefile"
+test "x$enable_win16" != xno && ALL_DLL_DIRS="$ALL_DLL_DIRS \\
+ mmsystem.dll16"
+ALL_MAKEFILE_DEPENDS="$ALL_MAKEFILE_DEPENDS
+dlls/mmsystem.dll16/Makefile: dlls/mmsystem.dll16/Makefile.in dlls/Makedll.rules"
+ac_config_files="$ac_config_files dlls/mmsystem.dll16/Makefile"
+
+ALL_MAKEFILES="$ALL_MAKEFILES \\
dlls/monodebg.vxd/Makefile"
test "x$enable_win16" != xno && ALL_DLL_DIRS="$ALL_DLL_DIRS \\
monodebg.vxd"
@@ -18937,6 +18945,7 @@ do
"dlls/mlang/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mlang/Makefile" ;;
"dlls/mlang/tests/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mlang/tests/Makefile" ;;
"dlls/mmdevldr.vxd/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mmdevldr.vxd/Makefile" ;;
+ "dlls/mmsystem.dll16/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mmsystem.dll16/Makefile" ;;
"dlls/monodebg.vxd/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/monodebg.vxd/Makefile" ;;
"dlls/mountmgr.sys/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mountmgr.sys/Makefile" ;;
"dlls/mouse.drv16/Makefile") CONFIG_FILES="$CONFIG_FILES dlls/mouse.drv16/Makefile" ;;
diff --git a/configure.ac b/configure.ac
index 7fddf44..68f0f27 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2305,6 +2305,7 @@ WINE_CONFIG_MAKEFILE([dlls/midimap/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DL
WINE_CONFIG_MAKEFILE([dlls/mlang/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS])
WINE_CONFIG_MAKEFILE([dlls/mlang/tests/Makefile],[dlls/Maketest.rules],[dlls],[ALL_TEST_DIRS],[enable_tests])
WINE_CONFIG_MAKEFILE([dlls/mmdevldr.vxd/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS],[enable_win16])
+WINE_CONFIG_MAKEFILE([dlls/mmsystem.dll16/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS],[enable_win16])
WINE_CONFIG_MAKEFILE([dlls/monodebg.vxd/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS],[enable_win16])
WINE_CONFIG_MAKEFILE([dlls/mountmgr.sys/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS])
WINE_CONFIG_MAKEFILE([dlls/mouse.drv16/Makefile],[dlls/Makedll.rules],[dlls],[ALL_DLL_DIRS],[enable_win16])
diff --git a/dlls/Makefile.in b/dlls/Makefile.in
index 8dcfdab..92f129f 100644
--- a/dlls/Makefile.in
+++ b/dlls/Makefile.in
@@ -21,7 +21,6 @@ WIN16_FILES = \
commdlg.dll16 \
gdi.exe16 \
krnl386.exe16 \
- mmsystem.dll16 \
user.exe16 \
wprocs.dll16
@@ -48,9 +47,6 @@ user.exe16:
wprocs.dll16:
echo "winedos.dll" >$@
-mmsystem.dll16:
- echo "winmm.dll" >$@
-
# Import libraries
STATIC_IMPLIBEXT = $(IMPLIBEXT:def=def.a)
diff --git a/dlls/mmsystem.dll16/Makefile.in b/dlls/mmsystem.dll16/Makefile.in
new file mode 100644
index 0000000..58d07cf
--- /dev/null
+++ b/dlls/mmsystem.dll16/Makefile.in
@@ -0,0 +1,18 @@
+TOPSRCDIR = @top_srcdir@
+TOPOBJDIR = ../..
+SRCDIR = @srcdir@
+VPATH = @srcdir@
+MODULE = mmsystem.dll16
+IMPORTS = winmm user32 kernel32
+
+EXTRADLLFLAGS = -Wb,--subsystem,win16,--main-module,winmm.dll
+
+C_SRCS = \
+ mci16.c \
+ message16.c \
+ mmio16.c \
+ mmsystem.c
+
+ at MAKE_DLL_RULES@
+
+ at DEPENDENCIES@ # everything below this line is overwritten by make depend
diff --git a/dlls/mmsystem.dll16/mci16.c b/dlls/mmsystem.dll16/mci16.c
new file mode 100644
index 0000000..75d7202
--- /dev/null
+++ b/dlls/mmsystem.dll16/mci16.c
@@ -0,0 +1,760 @@
+/*
+ * MMSYSTEM functions
+ *
+ * Copyright 1993 Martin Ayotte
+ * 1998-2003,2009 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+#define NONAMELESSUNION
+#define NONAMELESSSTRUCT
+#include "windef.h"
+#include "winbase.h"
+#include "mmsystem.h"
+#include "winternl.h"
+#include "wownt32.h"
+#include "winnls.h"
+
+#include "wine/winuser16.h"
+#include "winemm16.h"
+#include "digitalv.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
+
+/**************************************************************************
+ * MCI_MessageToString [internal]
+ */
+static const char* MCI_MessageToString(UINT wMsg)
+{
+ static char buffer[100];
+
+#define CASE(s) case (s): return #s
+
+ switch (wMsg) {
+ CASE(DRV_LOAD);
+ CASE(DRV_ENABLE);
+ CASE(DRV_OPEN);
+ CASE(DRV_CLOSE);
+ CASE(DRV_DISABLE);
+ CASE(DRV_FREE);
+ CASE(DRV_CONFIGURE);
+ CASE(DRV_QUERYCONFIGURE);
+ CASE(DRV_INSTALL);
+ CASE(DRV_REMOVE);
+ CASE(DRV_EXITSESSION);
+ CASE(DRV_EXITAPPLICATION);
+ CASE(DRV_POWER);
+ CASE(MCI_BREAK);
+ CASE(MCI_CLOSE);
+ CASE(MCI_CLOSE_DRIVER);
+ CASE(MCI_COPY);
+ CASE(MCI_CUE);
+ CASE(MCI_CUT);
+ CASE(MCI_DELETE);
+ CASE(MCI_ESCAPE);
+ CASE(MCI_FREEZE);
+ CASE(MCI_PAUSE);
+ CASE(MCI_PLAY);
+ CASE(MCI_GETDEVCAPS);
+ CASE(MCI_INFO);
+ CASE(MCI_LOAD);
+ CASE(MCI_OPEN);
+ CASE(MCI_OPEN_DRIVER);
+ CASE(MCI_PASTE);
+ CASE(MCI_PUT);
+ CASE(MCI_REALIZE);
+ CASE(MCI_RECORD);
+ CASE(MCI_RESUME);
+ CASE(MCI_SAVE);
+ CASE(MCI_SEEK);
+ CASE(MCI_SET);
+ CASE(MCI_SPIN);
+ CASE(MCI_STATUS);
+ CASE(MCI_STEP);
+ CASE(MCI_STOP);
+ CASE(MCI_SYSINFO);
+ CASE(MCI_UNFREEZE);
+ CASE(MCI_UPDATE);
+ CASE(MCI_WHERE);
+ CASE(MCI_WINDOW);
+ /* constants for digital video */
+ CASE(MCI_CAPTURE);
+ CASE(MCI_MONITOR);
+ CASE(MCI_RESERVE);
+ CASE(MCI_SETAUDIO);
+ CASE(MCI_SIGNAL);
+ CASE(MCI_SETVIDEO);
+ CASE(MCI_QUALITY);
+ CASE(MCI_LIST);
+ CASE(MCI_UNDO);
+ CASE(MCI_CONFIGURE);
+ CASE(MCI_RESTORE);
+#undef CASE
+ default:
+ sprintf(buffer, "MCI_<<%04X>>", wMsg);
+ return buffer;
+ }
+}
+
+static LPWSTR MCI_strdupAtoW( LPCSTR str )
+{
+ LPWSTR ret;
+ INT len;
+
+ if (!str) return NULL;
+ len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
+ ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
+ if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
+ return ret;
+}
+
+/**************************************************************************
+ * MCI_MapMsg16To32W [internal]
+ */
+static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
+{
+ if (*lParam == 0)
+ return MMSYSTEM_MAP_OK;
+ /* FIXME: to add also (with seg/linear modifications to do):
+ * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
+ * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
+ */
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS: /* FIXME: is wrong for digital video */
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ *lParam = (DWORD)MapSL(*lParam);
+ return MMSYSTEM_MAP_OK;
+ case MCI_WINDOW:
+ /* in fact, I would also need the dwFlags... to see
+ * which members of lParam are effectively used
+ */
+ *lParam = (DWORD)MapSL(*lParam);
+ FIXME("Current mapping may be wrong\n");
+ break;
+ case MCI_BREAK:
+ {
+ LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
+ LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
+
+ if (mbp32) {
+ mbp32->dwCallback = mbp16->dwCallback;
+ mbp32->nVirtKey = mbp16->nVirtKey;
+ mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mbp32;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case MCI_ESCAPE:
+ {
+ LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
+ LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
+
+ if (mvep32w) {
+ mvep32w->dwCallback = mvep16->dwCallback;
+ mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mvep32w;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case MCI_INFO:
+ {
+ LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
+ LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
+
+ /* FIXME this is wrong if device is of type
+ * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
+ */
+ if (mip32w) {
+ *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
+ mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
+ mip32w->dwCallback = mip16->dwCallback;
+ mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
+ mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mip32w;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ {
+ LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
+ LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
+
+ if (mop32w) {
+ *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
+ mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
+ mop32w->dwCallback = mop16->dwCallback;
+ mop32w->wDeviceID = mop16->wDeviceID;
+ if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
+ mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
+ else
+ mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
+ if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
+ mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
+ else
+ mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
+ if( ( dwFlags & MCI_OPEN_ALIAS))
+ mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
+ else
+ mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
+ /* copy extended information if any...
+ * FIXME: this may seg fault if initial structure does not contain them and
+ * the reads after msip16 fail under LDT limits...
+ * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
+ * should not take care of extended parameters, and should be used by MCI_Open
+ * to fetch uDevType. When, this is known, the mapping for sending the
+ * MCI_OPEN_DRIVER shall be done depending on uDevType.
+ */
+ memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mop32w;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case MCI_SYSINFO:
+ {
+ LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
+ LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
+
+ if (msip32w) {
+ *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
+ msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
+ msip32w->dwCallback = msip16->dwCallback;
+ msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
+ msip32w->dwRetSize = msip16->dwRetSize;
+ msip32w->dwNumber = msip16->dwNumber;
+ msip32w->wDeviceType = msip16->wDeviceType;
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)msip32w;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case MCI_SOUND:
+ {
+ LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
+ LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
+
+ if (mbp32) {
+ mbp32->dwCallback = mbp16->dwCallback;
+ mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
+ } else {
+ return MMSYSTEM_MAP_NOMEM;
+ }
+ *lParam = (DWORD)mbp32;
+ }
+ return MMSYSTEM_MAP_OKMEM;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME("This is a hack\n");
+ return MMSYSTEM_MAP_OK;
+ default:
+ FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
+ }
+ return MMSYSTEM_MAP_MSGERROR;
+}
+
+/**************************************************************************
+ * MCI_UnMapMsg16To32W [internal]
+ */
+static MMSYSTEM_MapType MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
+{
+ switch (wMsg) {
+ /* case MCI_CAPTURE */
+ case MCI_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CONFIGURE:
+ case MCI_COPY:
+ case MCI_CUE:
+ case MCI_CUT:
+ case MCI_DELETE:
+ case MCI_FREEZE:
+ case MCI_GETDEVCAPS:
+ /* case MCI_INDEX: */
+ /* case MCI_MARK: */
+ /* case MCI_MONITOR: */
+ case MCI_PASTE:
+ case MCI_PAUSE:
+ case MCI_PLAY:
+ case MCI_PUT:
+ case MCI_REALIZE:
+ case MCI_RECORD:
+ case MCI_RESUME:
+ case MCI_SEEK:
+ case MCI_SET:
+ /* case MCI_SETTIMECODE:*/
+ /* case MCI_SIGNAL:*/
+ case MCI_SPIN:
+ case MCI_STATUS:
+ case MCI_STEP:
+ case MCI_STOP:
+ /* case MCI_UNDO: */
+ case MCI_UNFREEZE:
+ case MCI_UPDATE:
+ case MCI_WHERE:
+ return MMSYSTEM_MAP_OK;
+
+ case MCI_WINDOW:
+ /* FIXME ?? see Map function */
+ return MMSYSTEM_MAP_OK;
+
+ case MCI_BREAK:
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ return MMSYSTEM_MAP_OK;
+ case MCI_ESCAPE:
+ if (lParam) {
+ LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
+ HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return MMSYSTEM_MAP_OK;
+ case MCI_INFO:
+ if (lParam) {
+ LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
+ LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
+
+ WideCharToMultiByte(CP_ACP, 0,
+ mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
+ MapSL(mip16->lpstrReturn), mip16->dwRetSize,
+ NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return MMSYSTEM_MAP_OK;
+ case MCI_SYSINFO:
+ if (lParam) {
+ LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
+ LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
+
+ WideCharToMultiByte(CP_ACP, 0,
+ msip32w->lpstrReturn, msip32w->dwRetSize,
+ MapSL(msip16->lpstrReturn), msip16->dwRetSize,
+ NULL, NULL);
+ HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return MMSYSTEM_MAP_OK;
+ case MCI_SOUND:
+ if (lParam) {
+ LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
+ HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
+ HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
+ }
+ return MMSYSTEM_MAP_OK;
+ case MCI_OPEN:
+ case MCI_OPEN_DRIVER:
+ if (lParam) {
+ LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
+ LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
+
+ mop16->wDeviceID = mop32w->wDeviceID;
+ if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
+ HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
+ if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
+ HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
+ if( ( dwFlags & MCI_OPEN_ALIAS))
+ HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
+ if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
+ FIXME("bad free line=%d\n", __LINE__);
+ }
+ return MMSYSTEM_MAP_OK;
+ case DRV_LOAD:
+ case DRV_ENABLE:
+ case DRV_OPEN:
+ case DRV_CLOSE:
+ case DRV_DISABLE:
+ case DRV_FREE:
+ case DRV_CONFIGURE:
+ case DRV_QUERYCONFIGURE:
+ case DRV_INSTALL:
+ case DRV_REMOVE:
+ case DRV_EXITSESSION:
+ case DRV_EXITAPPLICATION:
+ case DRV_POWER:
+ FIXME("This is a hack\n");
+ return MMSYSTEM_MAP_OK;
+ default:
+ FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
+ }
+ return MMSYSTEM_MAP_MSGERROR;
+}
+
+/* ###################################################
+ * # MCI #
+ * ###################################################
+ */
+
+#include <pshpack1.h>
+#define MCI_MAX_THUNKS 32
+
+static struct mci_thunk
+{
+ BYTE popl_eax; /* popl %eax (return address) */
+ BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
+ YIELDPROC16 yield16;
+ BYTE pushl_eax; /* pushl %eax */
+ BYTE jmp; /* ljmp MCI_Yield1632 */
+ DWORD callback;
+ MCIDEVICEID id;
+} *MCI_Thunks;
+
+#include <poppack.h>
+
+static CRITICAL_SECTION mci_cs;
+static CRITICAL_SECTION_DEBUG mci_critsect_debug =
+{
+ 0, 0, &mci_cs,
+ { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
+};
+static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
+
+static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
+{
+ WORD args[8];
+
+ if (!pfn16)
+ {
+ UserYield16();
+ return 0;
+ }
+
+ /* 16 bit func, call it */
+ TRACE("Function (16 bit) !\n");
+
+ args[2] = (MCIDEVICEID16)id;
+ args[1] = HIWORD(yield_data);
+ args[0] = LOWORD(yield_data);
+ return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
+}
+
+/******************************************************************
+ * MCI_AddThunk
+ *
+ */
+static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
+{
+ struct mci_thunk* thunk;
+
+ if (!MCI_Thunks)
+ {
+ MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
+ PAGE_EXECUTE_READWRITE);
+ if (!MCI_Thunks) return NULL;
+ for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
+ {
+ thunk->popl_eax = 0x58; /* popl %eax */
+ thunk->pushl_func = 0x68; /* pushl $pfn16 */
+ thunk->yield16 = 0;
+ thunk->pushl_eax = 0x50; /* pushl %eax */
+ thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */
+ thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
+ thunk->id = 0;
+ }
+ }
+ for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->yield16 == 0)
+ {
+ thunk->yield16 = pfn16;
+ thunk->id = id;
+ return thunk;
+ }
+ }
+ FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
+ return NULL;
+}
+
+/******************************************************************
+ * MCI_HasThunk
+ *
+ */
+static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn)
+{
+ struct mci_thunk* thunk;
+
+ if (!MCI_Thunks) return NULL;
+ for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
+ {
+ if ((YIELDPROC)thunk == pfn) return thunk;
+ }
+ return NULL;
+}
+
+/**************************************************************************
+ * mciSetYieldProc [MMSYSTEM.714]
+ */
+BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
+{
+ struct mci_thunk* thunk;
+ BOOL ret;
+
+ TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
+
+ if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
+ return FALSE;
+ ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
+ if (!ret) thunk->yield16 = NULL;
+ return ret;
+}
+
+/**************************************************************************
+ * mciGetYieldProc [MMSYSTEM.716]
+ */
+YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
+{
+ YIELDPROC yield;
+ DWORD data;
+ struct mci_thunk* thunk;
+
+ TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
+
+ yield = mciGetYieldProc(uDeviceID, &data);
+ if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
+
+ if (lpdwYieldData) *lpdwYieldData = data;
+ return thunk->yield16;
+}
+
+/**************************************************************************
+ * mciGetErrorString [MMSYSTEM.706]
+ */
+BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
+{
+ return mciGetErrorStringA(wError, lpstrBuffer, uLength);
+}
+
+/**************************************************************************
+ * mciDriverNotify [MMSYSTEM.711]
+ */
+BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
+{
+ TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
+
+ return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
+}
+
+/**************************************************************************
+ * mciGetDriverData [MMSYSTEM.708]
+ */
+DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
+{
+ return mciGetDriverData(uDeviceID);
+}
+
+/**************************************************************************
+ * mciSetDriverData [MMSYSTEM.707]
+ */
+BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
+{
+ return mciSetDriverData(uDeviceID, data);
+}
+
+/**************************************************************************
+ * mciSendCommand [MMSYSTEM.701]
+ */
+DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
+{
+ DWORD dwRet;
+ BOOL to32;
+ DWORD_PTR dwParam2 = p2;
+
+ TRACE("(%04X, %u, %08X, %08lX)\n", wDevID, wMsg, dwParam1, dwParam2);
+
+ switch (wMsg) {
+ case MCI_CLOSE:
+ case MCI_OPEN:
+ case MCI_SYSINFO:
+ case MCI_BREAK:
+ case MCI_SOUND:
+ to32 = TRUE;
+ break;
+ default:
+ /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
+ * doing 16=>32W, then 32W=>16 conversions.
+ * We could directly call the 16bit driver if we had the information.
+ */
+ to32 = TRUE;
+ }
+ if (to32) {
+ MMSYSTEM_MapType res;
+
+ dwRet = MCIERR_INVALID_DEVICE_ID;
+
+ switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
+ case MMSYSTEM_MAP_MSGERROR:
+ TRACE("Not handled yet (%u)\n", wMsg);
+ dwRet = MCIERR_DRIVER_INTERNAL;
+ break;
+ case MMSYSTEM_MAP_NOMEM:
+ TRACE("Problem mapping msg=%u from 16 to 32a\n", wMsg);
+ dwRet = MCIERR_OUT_OF_MEMORY;
+ break;
+ case MMSYSTEM_MAP_OK:
+ case MMSYSTEM_MAP_OKMEM:
+ dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
+ if (res == MMSYSTEM_MAP_OKMEM)
+ MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2);
+ break;
+ }
+ }
+ else
+ {
+#if 0
+ if (wDevID == MCI_ALL_DEVICE_ID) {
+ FIXME("unhandled MCI_ALL_DEVICE_ID\n");
+ dwRet = MCIERR_CANNOT_USE_ALL;
+ } else {
+ dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
+ }
+#endif
+ }
+ if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
+ {
+ /* free yield thunks, if any */
+ unsigned i;
+ for (i = 0; i < MCI_MAX_THUNKS; i++)
+ {
+ if (MCI_Thunks[i].id == wDevID)
+ MCI_Thunks[i].yield16 = NULL;
+ }
+ }
+ return dwRet;
+}
+
+/**************************************************************************
+ * mciGetDeviceID [MMSYSTEM.703]
+ */
+UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
+{
+ TRACE("(\"%s\")\n", lpstrName);
+
+ return mciGetDeviceIDA(lpstrName);
+}
+
+/**************************************************************************
+ * mciGetDeviceIDFromElementID [MMSYSTEM.715]
+ */
+UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
+{
+ return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
+}
+
+/**************************************************************************
+ * mciGetCreatorTask [MMSYSTEM.717]
+ */
+HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
+{
+ return HTASK_16(mciGetCreatorTask(uDeviceID));
+}
+
+/**************************************************************************
+ * mciDriverYield [MMSYSTEM.710]
+ */
+UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
+{
+ return mciDriverYield(uDeviceID);
+}
+
+/**************************************************************************
+ * mciSendString [MMSYSTEM.702]
+ */
+DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
+ UINT16 uRetLen, HWND16 hwndCallback)
+{
+ return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
+}
+
+/**************************************************************************
+ * mciLoadCommandResource [MMSYSTEM.705]
+ */
+UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
+{
+ TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
+ return MCI_NO_COMMAND_TABLE;
+}
+
+/**************************************************************************
+ * mciFreeCommandResource [MMSYSTEM.713]
+ */
+BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
+{
+ TRACE("(%04x)!\n", uTable);
+
+ return FALSE;
+}
+
+/**************************************************************************
+ * mciExecute [MMSYSTEM.712]
+ */
+BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
+{
+ return mciExecute(lpstrCommand);
+}
diff --git a/dlls/mmsystem.dll16/message16.c b/dlls/mmsystem.dll16/message16.c
new file mode 100644
index 0000000..a43c559
--- /dev/null
+++ b/dlls/mmsystem.dll16/message16.c
@@ -0,0 +1,1000 @@
+/*
+ * MMSYSTEM MCI and low level mapping functions
+ *
+ * Copyright 1999 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <assert.h>
+#include "wine/winbase16.h"
+#include "windef.h"
+#include "winbase.h"
+#include "wownt32.h"
+#include "winemm16.h"
+#include "digitalv.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(winmm);
+
+/* =================================
+ * A U X M A P P E R S
+ * ================================= */
+
+/* =================================
+ * M I X E R M A P P E R S
+ * ================================= */
+
+/**************************************************************************
+ * MMSYSTDRV_Mixer_Map16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
+{
+ return MMSYSTEM_MAP_MSGERROR;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_Mixer_UnMap16To32W [internal]
+ */
+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));
+
+ 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;
+ }
+ return ret;
+#endif
+ return MMSYSTEM_MAP_MSGERROR;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_Mixer_MapCB
+ */
+static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
+{
+ FIXME("NIY\n");
+}
+
+/* =================================
+ * M I D I I N M A P P E R S
+ * ================================= */
+
+/**************************************************************************
+ * MMSYSTDRV_MidiIn_Map16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
+{
+ return MMSYSTEM_MAP_MSGERROR;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_MidiIn_UnMap16To32W [internal]
+ */
+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]
+ */
+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 */
+
+ case MIM_DATA:
+ case MIM_MOREDATA:
+ case MIM_ERROR:
+ /* 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));
+ LPMIDIHDR mh16 = MapSL(segmh16);
+
+ *dwParam1 = (DWORD)segmh16;
+ mh16->dwFlags = mh32->dwFlags;
+ mh16->dwBytesRecorded = mh32->dwBytesRecorded;
+ if (mh16->reserved >= sizeof(MIDIHDR))
+ mh16->dwOffset = mh32->dwOffset;
+ }
+ break;
+ default:
+ ERR("Unknown msg %u\n", uMsg);
+ }
+}
+
+/* =================================
+ * M I D I O U T M A P P E R S
+ * ================================= */
+
+/**************************************************************************
+ * MMSYSTDRV_MidiOut_Map16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
+{
+ 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;
+
+ 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;
+
+ 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;
+ case MODM_PREPARE:
+ {
+ LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
+ LPMIDIHDR 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;
+ /* FIXME: nothing on mh32->lpNext */
+ /* could link the mh32->lpNext at this level for memory house keeping */
+ mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh16->dwOffset : 0;
+ mh16->lpNext = mh32; /* for reuse in unprepare and write */
+ /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
+ mh16->reserved = *lpParam2;
+ *lpParam1 = (DWORD)mh32;
+ *lpParam2 = sizeof(MIDIHDR);
+
+ ret = MMSYSTEM_MAP_OKMEM;
+ } else {
+ ret = MMSYSTEM_MAP_NOMEM;
+ }
+ }
+ break;
+ case MODM_UNPREPARE:
+ case MODM_LONGDATA:
+ {
+ LPMIDIHDR mh16 = MapSL(*lpParam1);
+ LPMIDIHDR mh32 = mh16->lpNext;
+
+ *lpParam1 = (DWORD)mh32;
+ *lpParam2 = sizeof(MIDIHDR);
+ /* 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;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_MidiOut_UnMap16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
+{
+ 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;
+
+ 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;
+
+ 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;
+ case MODM_PREPARE:
+ case MODM_UNPREPARE:
+ case MODM_LONGDATA:
+ {
+ LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
+ LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
+
+ assert(mh16->lpNext == mh32);
+ mh16->dwBufferLength = mh32->dwBufferLength;
+ mh16->dwBytesRecorded = mh32->dwBytesRecorded;
+ mh16->dwUser = mh32->dwUser;
+ mh16->dwFlags = mh32->dwFlags;
+ if (mh16->reserved >= sizeof(MIDIHDR))
+ mh16->dwOffset = mh32->dwOffset;
+
+ 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;
+ }
+ return ret;
+}
+
+/******************************************************************
+ * MMSYSTDRV_MidiOut_MapCB
+ */
+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;
+ case MOM_DONE:
+ {
+ /* initial map is: 16 => 32 */
+ LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1);
+ SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
+ LPMIDIHDR mh16 = MapSL(segmh16);
+
+ *dwParam1 = (DWORD)segmh16;
+ mh16->dwFlags = mh32->dwFlags;
+ if (mh16->reserved >= sizeof(MIDIHDR))
+ mh16->dwOffset = mh32->dwOffset;
+ }
+ break;
+ case MOM_POSITIONCB:
+ FIXME("NIY\n");
+ /* FIXME: would require to recreate a 16bit MIDIHDR here */
+ *dwParam1 = *dwParam2 = 0;
+ break;
+ default:
+ ERR("Unknown msg %u\n", uMsg);
+ }
+}
+
+/* =================================
+ * W A V E I N M A P P E R S
+ * ================================= */
+
+/**************************************************************************
+ * MMSYSTDRV_WaveIn_Map16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
+{
+ 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;
+ case WIDM_OPEN:
+ case WIDM_CLOSE:
+ 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;
+ 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;
+ 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;
+ 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;
+ case WIDM_MAPPER_STATUS:
+ /* 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;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_WaveIn_UnMap16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
+{
+ MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
+
+ switch (wMsg) {
+ case WIDM_GETNUMDEVS:
+ case WIDM_RESET:
+ case WIDM_START:
+ case WIDM_STOP:
+ case WIDM_MAPPER_STATUS:
+ 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;
+ 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;
+ 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;
+ 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->dwBufferLength = wh32->dwBufferLength;
+ wh16->dwBytesRecorded = wh32->dwBytesRecorded;
+ wh16->dwUser = wh32->dwUser;
+ wh16->dwFlags = wh32->dwFlags;
+ wh16->dwLoops = wh32->dwLoops;
+
+ 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;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_WaveIn_MapCB [internal]
+ */
+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;
+ 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;
+ default:
+ ERR("Unknown msg %u\n", uMsg);
+ }
+}
+
+/* =================================
+ * W A V E O U T M A P P E R S
+ * ================================= */
+
+/**************************************************************************
+ * MMSYSTDRV_WaveOut_Map16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
+{
+ MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
+
+ switch (wMsg) {
+ /* nothing to do */
+ case WODM_BREAKLOOP:
+ case WODM_CLOSE:
+ case WODM_GETNUMDEVS:
+ case WODM_PAUSE:
+ case WODM_RESET:
+ case WODM_RESTART:
+ case WODM_SETPITCH:
+ case WODM_SETPLAYBACKRATE:
+ case WODM_SETVOLUME:
+ 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;
+
+ 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;
+ 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;
+ 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;
+ 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;
+ case WODM_MAPPER_STATUS:
+ *lpParam2 = (DWORD)MapSL(*lpParam2);
+ ret = MMSYSTEM_MAP_OK;
+ break;
+ default:
+ FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
+ break;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MMSYSTDRV_WaveOut_UnMap16To32W [internal]
+ */
+static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
+{
+ MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
+
+ switch (wMsg) {
+ /* nothing to do */
+ case WODM_BREAKLOOP:
+ case WODM_CLOSE:
+ case WODM_GETNUMDEVS:
+ case WODM_PAUSE:
+ case WODM_RESET:
+ case WODM_RESTART:
+ case WODM_SETPITCH:
+ case WODM_SETPLAYBACKRATE:
+ case WODM_SETVOLUME:
+ case WODM_MAPPER_STATUS:
+ 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;
+
+ 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;
+ 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;
+ 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->dwBufferLength = wh32->dwBufferLength;
+ wh16->dwBytesRecorded = wh32->dwBytesRecorded;
+ wh16->dwUser = wh32->dwUser;
+ wh16->dwFlags = wh32->dwFlags;
+ wh16->dwLoops = wh32->dwLoops;
+
+ 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;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * MMDRV_WaveOut_Callback [internal]
+ */
+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;
+ 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;
+ default:
+ ERR("Unknown msg %u\n", uMsg);
+ }
+}
+
+/* ###################################################
+ * # 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);
+
+#include <pshpack1.h>
+#define MMSYSTDRV_MAX_THUNKS 32
+
+static struct mmsystdrv_thunk
+{
+ BYTE popl_eax; /* popl %eax (return address) */
+ BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
+ struct mmsystdrv_thunk* this;
+ BYTE pushl_eax; /* pushl %eax */
+ BYTE jmp; /* ljmp MMDRV_Callback1632 */
+ DWORD callback;
+ DWORD pfn16;
+ void* hMmdrv; /* Handle to 32bit mmdrv object */
+ enum MMSYSTEM_DriverType kind;
+} *MMSYSTDRV_Thunks;
+
+#include <poppack.h>
+
+static struct MMSYSTDRV_Type
+{
+ MMSYSTDRV_MAPMSG mapmsg16to32W;
+ MMSYSTDRV_UNMAPMSG unmapmsg16to32W;
+ MMSYSTDRV_MAPCB mapcb;
+} MMSYSTEM_DriversType[MMSYSTDRV_MAX] =
+{
+ {MMSYSTDRV_Mixer_Map16To32W, MMSYSTDRV_Mixer_UnMap16To32W, MMSYSTDRV_Mixer_MapCB},
+ {MMSYSTDRV_MidiIn_Map16To32W, MMSYSTDRV_MidiIn_UnMap16To32W, MMSYSTDRV_MidiIn_MapCB},
+ {MMSYSTDRV_MidiOut_Map16To32W, MMSYSTDRV_MidiOut_UnMap16To32W, MMSYSTDRV_MidiOut_MapCB},
+ {MMSYSTDRV_WaveIn_Map16To32W, MMSYSTDRV_WaveIn_UnMap16To32W, MMSYSTDRV_WaveIn_MapCB},
+ {MMSYSTDRV_WaveOut_Map16To32W, MMSYSTDRV_WaveOut_UnMap16To32W, MMSYSTDRV_WaveOut_MapCB},
+};
+
+/******************************************************************
+ * MMSYSTDRV_Callback3216
+ *
+ */
+static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, DWORD uFlags, HDRVR hDev,
+ DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
+ DWORD_PTR dwParam2)
+{
+ assert(thunk->kind < MMSYSTDRV_MAX);
+ assert(MMSYSTEM_DriversType[thunk->kind].mapcb);
+
+ MMSYSTEM_DriversType[thunk->kind].mapcb(wMsg, &dwUser, &dwParam1, &dwParam2);
+
+ if ((uFlags & DCB_TYPEMASK) == DCB_FUNCTION)
+ {
+ WORD args[8];
+ /* 16 bit func, call it */
+ TRACE("Function (16 bit) !\n");
+
+ args[7] = HDRVR_16(hDev);
+ args[6] = wMsg;
+ args[5] = HIWORD(dwUser);
+ args[4] = LOWORD(dwUser);
+ args[3] = HIWORD(dwParam1);
+ args[2] = LOWORD(dwParam1);
+ args[1] = HIWORD(dwParam2);
+ args[0] = LOWORD(dwParam2);
+ return WOWCallback16Ex(thunk->pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
+ }
+ return DriverCallback(thunk->pfn16, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
+}
+
+/******************************************************************
+ * MMSYSTDRV_AddThunk
+ *
+ */
+struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD pfn16, enum MMSYSTEM_DriverType kind)
+{
+ struct mmsystdrv_thunk* thunk;
+
+ EnterCriticalSection(&mmdrv_cs);
+ if (!MMSYSTDRV_Thunks)
+ {
+ MMSYSTDRV_Thunks = VirtualAlloc(NULL, MMSYSTDRV_MAX_THUNKS * sizeof(*MMSYSTDRV_Thunks),
+ MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+ if (!MMSYSTDRV_Thunks)
+ {
+ LeaveCriticalSection(&mmdrv_cs);
+ return NULL;
+ }
+ for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
+ {
+ thunk->popl_eax = 0x58; /* popl %eax */
+ thunk->pushl_func = 0x68; /* pushl $pfn16 */
+ thunk->this = thunk;
+ thunk->pushl_eax = 0x50; /* pushl %eax */
+ thunk->jmp = 0xe9; /* jmp MMDRV_Callback3216 */
+ thunk->callback = (char *)MMSYSTDRV_Callback3216 - (char *)(&thunk->callback + 1);
+ thunk->pfn16 = 0;
+ thunk->hMmdrv = NULL;
+ thunk->kind = MMSYSTDRV_MAX;
+ }
+ }
+ for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->pfn16 == 0 && thunk->hMmdrv == NULL)
+ {
+ thunk->pfn16 = pfn16;
+ thunk->hMmdrv = NULL;
+ thunk->kind = kind;
+ LeaveCriticalSection(&mmdrv_cs);
+ return thunk;
+ }
+ }
+ LeaveCriticalSection(&mmdrv_cs);
+ FIXME("Out of mmdrv-thunks. Bump MMDRV_MAX_THUNKS\n");
+ return NULL;
+}
+
+/******************************************************************
+ * MMSYSTDRV_FindHandle
+ *
+ * Must be called with lock set
+ */
+static void* MMSYSTDRV_FindHandle(void* h)
+{
+ struct mmsystdrv_thunk* thunk;
+
+ for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->hMmdrv == h)
+ {
+ if (thunk->kind >= MMSYSTDRV_MAX) FIXME("Kind isn't properly initialized %x\n", thunk->kind);
+ return thunk;
+ }
+ }
+ return NULL;
+}
+
+/******************************************************************
+ * MMSYSTDRV_SetHandle
+ *
+ */
+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
+ */
+void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk)
+{
+ thunk->pfn16 = 0;
+ thunk->hMmdrv = NULL;
+ thunk->kind = MMSYSTDRV_MAX;
+}
+
+/******************************************************************
+ * MMSYSTDRV_CloseHandle
+ */
+void MMSYSTDRV_CloseHandle(void* h)
+{
+ struct mmsystdrv_thunk* thunk;
+
+ EnterCriticalSection(&mmdrv_cs);
+ if ((thunk = MMSYSTDRV_FindHandle(h)))
+ {
+ MMSYSTDRV_DeleteThunk(thunk);
+ }
+ LeaveCriticalSection(&mmdrv_cs);
+}
+
+/******************************************************************
+ * MMSYSTDRV_Message
+ */
+DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2)
+{
+ struct mmsystdrv_thunk* thunk = MMSYSTDRV_FindHandle(h);
+ struct MMSYSTDRV_Type* drvtype;
+ MMSYSTEM_MapType map;
+ DWORD ret;
+
+ if (!thunk) return MMSYSERR_INVALHANDLE;
+ drvtype = &MMSYSTEM_DriversType[thunk->kind];
+
+ map = drvtype->mapmsg16to32W(msg, ¶m1, ¶m2);
+ switch (map) {
+ case MMSYSTEM_MAP_NOMEM:
+ ret = MMSYSERR_NOMEM;
+ break;
+ case MMSYSTEM_MAP_MSGERROR:
+ FIXME("NIY: no conversion yet 16->32 kind=%u msg=%u\n", thunk->kind, msg);
+ ret = MMSYSERR_ERROR;
+ break;
+ case MMSYSTEM_MAP_OK:
+ case MMSYSTEM_MAP_OKMEM:
+ TRACE("Calling message(msg=%u p1=0x%08lx p2=0x%08lx)\n",
+ msg, param1, param2);
+ switch (thunk->kind)
+ {
+ case MMSYSTDRV_MIXER: ret = mixerMessage (h, msg, param1, param2); break;
+ case MMSYSTDRV_MIDIIN: ret = midiInMessage (h, msg, param1, param2); break;
+ case MMSYSTDRV_MIDIOUT: ret = midiOutMessage(h, msg, param1, param2); break;
+ case MMSYSTDRV_WAVEIN: ret = waveInMessage (h, msg, param1, param2); break;
+ case MMSYSTDRV_WAVEOUT: ret = waveOutMessage(h, msg, param1, param2); break;
+ default: ret = MMSYSERR_INVALHANDLE; break; /* should never be reached */
+ }
+ if (map == MMSYSTEM_MAP_OKMEM)
+ drvtype->unmapmsg16to32W(msg, ¶m1, ¶m2, ret);
+ break;
+ default:
+ FIXME("NIY\n");
+ ret = MMSYSERR_NOTSUPPORTED;
+ break;
+ }
+ return ret;
+}
diff --git a/dlls/mmsystem.dll16/mmio16.c b/dlls/mmsystem.dll16/mmio16.c
new file mode 100644
index 0000000..d0e24bc
--- /dev/null
+++ b/dlls/mmsystem.dll16/mmio16.c
@@ -0,0 +1,640 @@
+/*
+ * MMSYSTEM mmio* functions
+ *
+ * Copyright 1993 Martin Ayotte
+ * 1998-2003,2009 Eric Pouech
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#include <string.h>
+
+#define NONAMELESSUNION
+#define NONAMELESSSTRUCT
+#include "windef.h"
+#include "winbase.h"
+#include "mmsystem.h"
+#include "winternl.h"
+#include "wownt32.h"
+#include "winnls.h"
+
+#include "wine/winuser16.h"
+#include "winemm16.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
+
+/* ###################################################
+ * # MMIO #
+ * ###################################################
+ */
+#include <pshpack1.h>
+#define MMIO_MAX_THUNKS 32
+
+static struct mmio_thunk
+{
+ BYTE popl_eax; /* popl %eax (return address) */
+ BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
+ LPMMIOPROC16 pfn16;
+ BYTE pushl_eax; /* pushl %eax */
+ BYTE jmp; /* ljmp MMIO_Callback1632 */
+ DWORD callback;
+ HMMIO hMmio; /* Handle to 32bit mmio object */
+ SEGPTR segbuffer; /* actual segmented ptr to buffer */
+} *MMIO_Thunks;
+
+#include <poppack.h>
+
+static CRITICAL_SECTION mmio_cs;
+static CRITICAL_SECTION_DEBUG mmio_critsect_debug =
+{
+ 0, 0, &mmio_cs,
+ { &mmio_critsect_debug.ProcessLocksList, &mmio_critsect_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmio_cs") }
+};
+static CRITICAL_SECTION mmio_cs = { &mmio_critsect_debug, -1, 0, 0, 0, 0 };
+
+/****************************************************************
+ * MMIO_Map32To16 [INTERNAL]
+ */
+static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2)
+{
+ switch (wMsg) {
+ case MMIOM_CLOSE:
+ case MMIOM_SEEK:
+ /* nothing to do */
+ break;
+ case MMIOM_OPEN:
+ case MMIOM_READ:
+ case MMIOM_WRITE:
+ case MMIOM_WRITEFLUSH:
+ *lp1 = MapLS( (void *)*lp1 );
+ break;
+ case MMIOM_RENAME:
+ *lp1 = MapLS( (void *)*lp1 );
+ *lp2 = MapLS( (void *)*lp2 );
+ break;
+ default:
+ if (wMsg < MMIOM_USER)
+ TRACE("Not a mappable message (%d)\n", wMsg);
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/****************************************************************
+ * MMIO_UnMap32To16 [INTERNAL]
+ */
+static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2,
+ LPARAM lp1, LPARAM lp2)
+{
+ switch (wMsg) {
+ case MMIOM_CLOSE:
+ case MMIOM_SEEK:
+ /* nothing to do */
+ break;
+ case MMIOM_OPEN:
+ case MMIOM_READ:
+ case MMIOM_WRITE:
+ case MMIOM_WRITEFLUSH:
+ UnMapLS( lp1 );
+ break;
+ case MMIOM_RENAME:
+ UnMapLS( lp1 );
+ UnMapLS( lp2 );
+ break;
+ default:
+ if (wMsg < MMIOM_USER)
+ TRACE("Not a mappable message (%d)\n", wMsg);
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/******************************************************************
+ * MMIO_Callback3216
+ *
+ *
+ */
+static LRESULT MMIO_Callback3216(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage,
+ LPARAM lParam1, LPARAM lParam2)
+{
+ DWORD result;
+ MMIOINFO16 mmioInfo16;
+ SEGPTR segmmioInfo16;
+ LPARAM lp1 = lParam1, lp2 = lParam2;
+ WORD args[7];
+
+ if (!cb16) return MMSYSERR_INVALPARAM;
+
+ memset(&mmioInfo16, 0, sizeof(MMIOINFO16));
+ mmioInfo16.lDiskOffset = lpmmioinfo->lDiskOffset;
+ mmioInfo16.adwInfo[0] = lpmmioinfo->adwInfo[0];
+ mmioInfo16.adwInfo[1] = lpmmioinfo->adwInfo[1];
+ mmioInfo16.adwInfo[2] = lpmmioinfo->adwInfo[2];
+ /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */
+ if ((result = MMIO_Map32To16(uMessage, &lp1, &lp2)) != MMSYSERR_NOERROR)
+ return result;
+
+ segmmioInfo16 = MapLS(&mmioInfo16);
+ args[6] = HIWORD(segmmioInfo16);
+ args[5] = LOWORD(segmmioInfo16);
+ args[4] = uMessage;
+ args[3] = HIWORD(lp1);
+ args[2] = LOWORD(lp1);
+ args[1] = HIWORD(lp2);
+ args[0] = LOWORD(lp2);
+ WOWCallback16Ex( cb16, WCB16_PASCAL, sizeof(args), args, &result );
+ UnMapLS(segmmioInfo16);
+ MMIO_UnMap32To16(uMessage, lParam1, lParam2, lp1, lp2);
+
+ lpmmioinfo->lDiskOffset = mmioInfo16.lDiskOffset;
+ lpmmioinfo->adwInfo[0] = mmioInfo16.adwInfo[0];
+ lpmmioinfo->adwInfo[1] = mmioInfo16.adwInfo[1];
+ lpmmioinfo->adwInfo[2] = mmioInfo16.adwInfo[2];
+
+ return result;
+}
+
+/******************************************************************
+ * MMIO_AddThunk
+ *
+ */
+static struct mmio_thunk* MMIO_AddThunk(LPMMIOPROC16 pfn16, HPSTR segbuf)
+{
+ struct mmio_thunk* thunk;
+
+ if (!MMIO_Thunks)
+ {
+ MMIO_Thunks = VirtualAlloc(NULL, MMIO_MAX_THUNKS * sizeof(*MMIO_Thunks), MEM_COMMIT,
+ PAGE_EXECUTE_READWRITE);
+ if (!MMIO_Thunks) return NULL;
+ for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
+ {
+ thunk->popl_eax = 0x58; /* popl %eax */
+ thunk->pushl_func = 0x68; /* pushl $pfn16 */
+ thunk->pfn16 = 0;
+ thunk->pushl_eax = 0x50; /* pushl %eax */
+ thunk->jmp = 0xe9; /* jmp MMIO_Callback3216 */
+ thunk->callback = (char *)MMIO_Callback3216 - (char *)(&thunk->callback + 1);
+ thunk->hMmio = NULL;
+ thunk->segbuffer = 0;
+ }
+ }
+ for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->pfn16 == 0 && thunk->hMmio == NULL)
+ {
+ thunk->pfn16 = pfn16;
+ thunk->hMmio = NULL;
+ thunk->segbuffer = (SEGPTR)segbuf;
+ return thunk;
+ }
+ }
+ FIXME("Out of mmio-thunks. Bump MMIO_MAX_THUNKS\n");
+ return NULL;
+}
+
+/******************************************************************
+ * MMIO_HasThunk
+ *
+ */
+static struct mmio_thunk* MMIO_HasThunk(HMMIO hmmio)
+{
+ struct mmio_thunk* thunk;
+
+ if (!MMIO_Thunks) return NULL;
+ for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->hMmio == hmmio) return thunk;
+ }
+ return NULL;
+}
+
+/******************************************************************
+ * MMIO_SetSegmentedBuffer
+ *
+ */
+static void MMIO_SetSegmentedBuffer(struct mmio_thunk* thunk, SEGPTR ptr, BOOL release)
+{
+ if (release) UnMapLS(thunk->segbuffer);
+ thunk->segbuffer = ptr;
+}
+
+/**************************************************************************
+ * mmioOpen [MMSYSTEM.1210]
+ */
+HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
+ DWORD dwOpenFlags)
+{
+ HMMIO ret;
+
+ if (lpmmioinfo16) {
+ MMIOINFO mmioinfo;
+ struct mmio_thunk* thunk = NULL;
+
+ memset(&mmioinfo, 0, sizeof(mmioinfo));
+
+ EnterCriticalSection(&mmio_cs);
+ if (lpmmioinfo16->pIOProc && !(thunk = MMIO_AddThunk(lpmmioinfo16->pIOProc, lpmmioinfo16->pchBuffer)))
+ {
+ LeaveCriticalSection(&mmio_cs);
+ return 0;
+ }
+
+ mmioinfo.dwFlags = lpmmioinfo16->dwFlags;
+ mmioinfo.fccIOProc = lpmmioinfo16->fccIOProc;
+ mmioinfo.pIOProc = (LPMMIOPROC)thunk;
+ mmioinfo.cchBuffer = lpmmioinfo16->cchBuffer;
+ mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo16->pchBuffer);
+ mmioinfo.adwInfo[0] = lpmmioinfo16->adwInfo[0];
+ /* if we don't have a file name, it's likely a passed open file descriptor */
+ if (!szFileName)
+ mmioinfo.adwInfo[0] = (DWORD)DosFileHandleToWin32Handle(mmioinfo.adwInfo[0]);
+ mmioinfo.adwInfo[1] = lpmmioinfo16->adwInfo[1];
+ mmioinfo.adwInfo[2] = lpmmioinfo16->adwInfo[2];
+
+ ret = mmioOpenA(szFileName, &mmioinfo, dwOpenFlags);
+ if (thunk)
+ {
+ if (!ret || (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)))
+ {
+ thunk->pfn16 = NULL;
+ thunk->hMmio = NULL;
+ }
+ else thunk->hMmio = ret;
+ }
+ LeaveCriticalSection(&mmio_cs);
+
+ lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet;
+ lpmmioinfo16->hmmio = HMMIO_16(mmioinfo.hmmio);
+ } else {
+ ret = mmioOpenA(szFileName, NULL, dwOpenFlags);
+ }
+ return HMMIO_16(ret);
+}
+
+/**************************************************************************
+ * mmioClose [MMSYSTEM.1211]
+ */
+MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
+{
+ MMRESULT ret;
+
+ EnterCriticalSection(&mmio_cs);
+ ret = mmioClose(HMMIO_32(hmmio), uFlags);
+ if (ret == MMSYSERR_NOERROR)
+ {
+ struct mmio_thunk* thunk;
+
+ if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
+ {
+ MMIO_SetSegmentedBuffer(thunk, 0, TRUE);
+ thunk->pfn16 = NULL;
+ thunk->hMmio = NULL;
+ }
+ }
+ LeaveCriticalSection(&mmio_cs);
+ return ret;
+}
+
+/**************************************************************************
+ * mmioRead [MMSYSTEM.1212]
+ */
+LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch)
+{
+ return mmioRead(HMMIO_32(hmmio), pch, cch);
+}
+
+/**************************************************************************
+ * mmioWrite [MMSYSTEM.1213]
+ */
+LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch)
+{
+ return mmioWrite(HMMIO_32(hmmio),pch,cch);
+}
+
+/**************************************************************************
+ * mmioSeek [MMSYSTEM.1214]
+ */
+LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin)
+{
+ return mmioSeek(HMMIO_32(hmmio), lOffset, iOrigin);
+}
+
+/**************************************************************************
+ * mmioGetInfo [MMSYSTEM.1215]
+ */
+MMRESULT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
+{
+ MMIOINFO mmioinfo;
+ MMRESULT ret;
+ struct mmio_thunk* thunk;
+
+ TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags);
+
+ EnterCriticalSection(&mmio_cs);
+ if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
+ {
+ LeaveCriticalSection(&mmio_cs);
+ return MMSYSERR_INVALHANDLE;
+ }
+
+ ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
+ if (ret != MMSYSERR_NOERROR)
+ {
+ LeaveCriticalSection(&mmio_cs);
+ return ret;
+ }
+
+ lpmmioinfo->dwFlags = mmioinfo.dwFlags;
+ lpmmioinfo->fccIOProc = mmioinfo.fccIOProc;
+ lpmmioinfo->pIOProc = thunk->pfn16;
+ lpmmioinfo->wErrorRet = mmioinfo.wErrorRet;
+ lpmmioinfo->hTask = HTASK_16(mmioinfo.hTask);
+ lpmmioinfo->cchBuffer = mmioinfo.cchBuffer;
+ lpmmioinfo->pchBuffer = (void*)thunk->segbuffer;
+ lpmmioinfo->pchNext = (void*)(thunk->segbuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
+ lpmmioinfo->pchEndRead = (void*)(thunk->segbuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
+ lpmmioinfo->pchEndWrite = (void*)(thunk->segbuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
+ lpmmioinfo->lBufOffset = mmioinfo.lBufOffset;
+ lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
+ lpmmioinfo->adwInfo[0] = mmioinfo.adwInfo[0];
+ lpmmioinfo->adwInfo[1] = mmioinfo.adwInfo[1];
+ lpmmioinfo->adwInfo[2] = mmioinfo.adwInfo[2];
+ lpmmioinfo->dwReserved1 = 0;
+ lpmmioinfo->dwReserved2 = 0;
+ lpmmioinfo->hmmio = HMMIO_16(mmioinfo.hmmio);
+ LeaveCriticalSection(&mmio_cs);
+
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * mmioSetInfo [MMSYSTEM.1216]
+ */
+MMRESULT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16* lpmmioinfo, UINT16 uFlags)
+{
+ MMIOINFO mmioinfo;
+ MMRESULT ret;
+
+ TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
+
+ ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0);
+ if (ret != MMSYSERR_NOERROR) return ret;
+
+ /* check if seg and lin buffers are the same */
+ if (mmioinfo.cchBuffer != lpmmioinfo->cchBuffer ||
+ mmioinfo.pchBuffer != MapSL((DWORD)lpmmioinfo->pchBuffer))
+ return MMSYSERR_INVALPARAM;
+
+ /* check pointers coherence */
+ if (lpmmioinfo->pchNext < lpmmioinfo->pchBuffer ||
+ lpmmioinfo->pchNext > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
+ lpmmioinfo->pchEndRead < lpmmioinfo->pchBuffer ||
+ lpmmioinfo->pchEndRead > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
+ lpmmioinfo->pchEndWrite < lpmmioinfo->pchBuffer ||
+ lpmmioinfo->pchEndWrite > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer)
+ return MMSYSERR_INVALPARAM;
+
+ mmioinfo.pchNext = mmioinfo.pchBuffer + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer);
+ mmioinfo.pchEndRead = mmioinfo.pchBuffer + (lpmmioinfo->pchEndRead - lpmmioinfo->pchBuffer);
+ mmioinfo.pchEndWrite = mmioinfo.pchBuffer + (lpmmioinfo->pchEndWrite - lpmmioinfo->pchBuffer);
+
+ return mmioSetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
+}
+
+/**************************************************************************
+ * mmioSetBuffer [MMSYSTEM.1217]
+ */
+MMRESULT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, LPSTR pchBuffer,
+ LONG cchBuffer, UINT16 uFlags)
+{
+ MMRESULT ret = mmioSetBuffer(HMMIO_32(hmmio), MapSL((DWORD)pchBuffer),
+ cchBuffer, uFlags);
+
+ if (ret == MMSYSERR_NOERROR)
+ {
+ struct mmio_thunk* thunk;
+
+ if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
+ {
+ FIXME("really ?\n");
+ return MMSYSERR_INVALHANDLE;
+ }
+ MMIO_SetSegmentedBuffer(thunk, (DWORD)pchBuffer, TRUE);
+ }
+ else
+ UnMapLS((DWORD)pchBuffer);
+ return ret;
+}
+
+/**************************************************************************
+ * mmioFlush [MMSYSTEM.1218]
+ */
+MMRESULT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags)
+{
+ return mmioFlush(HMMIO_32(hmmio), uFlags);
+}
+
+/***********************************************************************
+ * mmioAdvance [MMSYSTEM.1219]
+ */
+MMRESULT16 WINAPI mmioAdvance16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
+{
+ MMIOINFO mmioinfo;
+ LRESULT ret;
+
+ /* WARNING: this heavily relies on mmioAdvance implementation (for choosing which
+ * fields to init
+ */
+ if (lpmmioinfo)
+ {
+ mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo->pchBuffer);
+ mmioinfo.pchNext = MapSL((DWORD)lpmmioinfo->pchNext);
+ mmioinfo.dwFlags = lpmmioinfo->dwFlags;
+ mmioinfo.lBufOffset = lpmmioinfo->lBufOffset;
+ ret = mmioAdvance(HMMIO_32(hmmio), &mmioinfo, uFlags);
+ }
+ else
+ ret = mmioAdvance(HMMIO_32(hmmio), NULL, uFlags);
+
+ if (ret != MMSYSERR_NOERROR) return ret;
+
+ if (lpmmioinfo)
+ {
+ lpmmioinfo->dwFlags = mmioinfo.dwFlags;
+ lpmmioinfo->pchNext = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
+ lpmmioinfo->pchEndRead = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
+ lpmmioinfo->pchEndWrite = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
+ lpmmioinfo->lBufOffset = mmioinfo.lBufOffset;
+ lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
+ }
+
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * mmioStringToFOURCC [MMSYSTEM.1220]
+ */
+FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags)
+{
+ return mmioStringToFOURCCA(sz, uFlags);
+}
+
+/**************************************************************************
+ * mmioInstallIOProc [MMSYSTEM.1221]
+ */
+LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
+ DWORD dwFlags)
+{
+ struct mmio_thunk* thunk = NULL;
+ LPMMIOPROC pIOProc32;
+
+ EnterCriticalSection(&mmio_cs);
+
+ switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
+ case MMIO_INSTALLPROC:
+ if (!(thunk = MMIO_AddThunk(pIOProc, NULL)))
+ {
+ LeaveCriticalSection(&mmio_cs);
+ return NULL;
+ }
+ if (!mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
+ {
+ thunk->pfn16 = NULL;
+ pIOProc = NULL;
+ }
+ break;
+ case MMIO_REMOVEPROC:
+ if (MMIO_Thunks)
+ {
+ for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
+ {
+ if (thunk->pfn16 == pIOProc && thunk->segbuffer == 0)
+ {
+ if (mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
+ thunk->pfn16 = NULL;
+ else
+ pIOProc = NULL;
+ break;
+ }
+ }
+ }
+ if (!thunk) pIOProc = NULL;
+ break;
+ case MMIO_FINDPROC:
+ if ((pIOProc32 = mmioInstallIOProcA(fccIOProc, NULL, dwFlags)) && MMIO_Thunks)
+ {
+ for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
+ {
+ if ((LPMMIOPROC)thunk == pIOProc32)
+ {
+ pIOProc = thunk->pfn16;
+ break;
+ }
+ }
+ }
+ break;
+ default:
+ WINE_FIXME("Unsupported flags %08x\n", dwFlags);
+ pIOProc = NULL;
+ }
+ LeaveCriticalSection(&mmio_cs);
+
+ return pIOProc;
+}
+
+/**************************************************************************
+ * mmioSendMessage [MMSYSTEM.1222]
+ */
+LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
+ LPARAM lParam1, LPARAM lParam2)
+{
+ struct mmio_thunk* thunk;
+
+ if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
+ {
+ MMIOINFO mmioinfo;
+ if (mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0) == MMSYSERR_NOERROR)
+ {
+ return MMIO_Callback3216((SEGPTR)thunk->pfn16, &mmioinfo, uMessage, lParam1, lParam2);
+ }
+ return MMSYSERR_INVALHANDLE;
+ }
+ else
+ {
+ /* FIXME: we need to map lParam1 and lParam2 to 32bit entities */
+ return mmioSendMessage(HMMIO_32(hmmio), uMessage, lParam1, lParam2);
+ }
+}
+
+/**************************************************************************
+ * mmioDescend [MMSYSTEM.1223]
+ */
+MMRESULT16 WINAPI mmioDescend16(HMMIO16 hmmio, LPMMCKINFO lpck,
+ const MMCKINFO* lpckParent, UINT16 uFlags)
+{
+ return mmioDescend(HMMIO_32(hmmio), lpck, lpckParent, uFlags);
+}
+
+/**************************************************************************
+ * mmioAscend [MMSYSTEM.1224]
+ */
+MMRESULT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
+{
+ return mmioAscend(HMMIO_32(hmmio),lpck,uFlags);
+}
+
+/**************************************************************************
+ * mmioCreateChunk [MMSYSTEM.1225]
+ */
+MMRESULT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
+{
+ return mmioCreateChunk(HMMIO_32(hmmio), lpck, uFlags);
+}
+
+/**************************************************************************
+ * mmioRename [MMSYSTEM.1226]
+ */
+MMRESULT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
+ MMIOINFO16* lpmmioinfo, DWORD dwRenameFlags)
+{
+ BOOL inst = FALSE;
+ MMRESULT ret;
+ MMIOINFO mmioinfo;
+
+ if (lpmmioinfo != NULL && lpmmioinfo->pIOProc != NULL &&
+ lpmmioinfo->fccIOProc == 0) {
+ FIXME("Can't handle this case yet\n");
+ return MMSYSERR_ERROR;
+ }
+
+ /* this is a bit hacky, but it'll work if we get a fourCC code or nothing.
+ * but a non installed ioproc without a fourcc won't do
+ */
+ if (lpmmioinfo && lpmmioinfo->fccIOProc && lpmmioinfo->pIOProc) {
+ mmioInstallIOProc16(lpmmioinfo->fccIOProc, lpmmioinfo->pIOProc,
+ MMIO_INSTALLPROC);
+ inst = TRUE;
+ }
+ memset(&mmioinfo, 0, sizeof(mmioinfo));
+ mmioinfo.fccIOProc = lpmmioinfo->fccIOProc;
+ ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags);
+ if (inst) {
+ mmioInstallIOProc16(lpmmioinfo->fccIOProc, NULL, MMIO_REMOVEPROC);
+ }
+ return ret;
+}
diff --git a/dlls/mmsystem.dll16/mmsystem.c b/dlls/mmsystem.dll16/mmsystem.c
new file mode 100644
index 0000000..f258fee
--- /dev/null
+++ b/dlls/mmsystem.dll16/mmsystem.c
@@ -0,0 +1,2409 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/*
+ * MMSYSTEM functions
+ *
+ * Copyright 1993 Martin Ayotte
+ * 1998-2003 Eric Pouech
+ *
+ * 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
+ */
+
+/*
+ * Eric POUECH :
+ * 99/4 added mmTask and mmThread functions support
+ */
+
+#include <stdarg.h>
+#include <string.h>
+
+#define NONAMELESSUNION
+#define NONAMELESSSTRUCT
+#include "windef.h"
+#include "winbase.h"
+#include "mmsystem.h"
+#include "winternl.h"
+#include "wownt32.h"
+#include "winnls.h"
+
+#include "wine/list.h"
+#include "wine/winuser16.h"
+#include "winemm16.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
+
+static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16);
+
+static CRITICAL_SECTION_DEBUG mmdrv_critsect_debug =
+{
+ 0, 0, &mmdrv_cs,
+ { &mmdrv_critsect_debug.ProcessLocksList, &mmdrv_critsect_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmdrv_cs") }
+};
+CRITICAL_SECTION mmdrv_cs = { &mmdrv_critsect_debug, -1, 0, 0, 0, 0 };
+
+/* ###################################################
+ * # LIBRARY #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * DllEntryPoint (MMSYSTEM.4)
+ *
+ * MMSYSTEM DLL entry point
+ *
+ */
+BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
+ WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
+{
+ TRACE("%p 0x%x\n", hinstDLL, fdwReason);
+
+ return TRUE;
+}
+
+/**************************************************************************
+ * WEP [MMSYSTEM.1]
+ */
+int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
+ WORD cbHeapSize, LPSTR lpCmdLine)
+{
+ TRACE("STUB: Unloading MMSystem DLL ... hInst=%04X\n", hInstance);
+ return TRUE;
+}
+
+/* ###################################################
+ * # PlaySound #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * PlaySound [MMSYSTEM.3]
+ */
+BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound)
+{
+ BOOL16 retv;
+ DWORD lc;
+
+ if ((fdwSound & SND_RESOURCE) == SND_RESOURCE)
+ {
+ HGLOBAL16 handle;
+ HRSRC16 res;
+
+ if (!(res = FindResource16( hmod, pszSound, "WAVE" ))) return FALSE;
+ if (!(handle = LoadResource16( hmod, res ))) return FALSE;
+ pszSound = LockResource16(handle);
+ fdwSound = (fdwSound & ~SND_RESOURCE) | SND_MEMORY;
+ /* FIXME: FreeResource16 */
+ }
+
+ ReleaseThunkLock(&lc);
+ retv = PlaySoundA(pszSound, 0, fdwSound);
+ RestoreThunkLock(lc);
+
+ return retv;
+}
+
+/**************************************************************************
+ * sndPlaySound [MMSYSTEM.2]
+ */
+BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags)
+{
+ BOOL16 retv;
+ DWORD lc;
+
+ ReleaseThunkLock(&lc);
+ retv = sndPlaySoundA(lpszSoundName, uFlags);
+ RestoreThunkLock(lc);
+
+ return retv;
+}
+
+/* ###################################################
+ * # MISC #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * mmsystemGetVersion [MMSYSTEM.5]
+ *
+ */
+UINT16 WINAPI mmsystemGetVersion16(void)
+{
+ return mmsystemGetVersion();
+}
+
+/**************************************************************************
+ * DriverCallback [MMSYSTEM.31]
+ */
+BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev,
+ WORD wMsg, DWORD dwUser, DWORD dwParam1,
+ DWORD dwParam2)
+{
+ return DriverCallback(dwCallBack, uFlags, HDRVR_32(hDev), wMsg, dwUser, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * OutputDebugStr [MMSYSTEM.30]
+ */
+void WINAPI OutputDebugStr16(LPCSTR str)
+{
+ OutputDebugStringA( str );
+}
+
+/* ###################################################
+ * # MIXER #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * Mixer devices. New to Win95
+ */
+
+/**************************************************************************
+ * mixerGetNumDevs [MMSYSTEM.800]
+ */
+UINT16 WINAPI mixerGetNumDevs16(void)
+{
+ return mixerGetNumDevs();
+}
+
+/**************************************************************************
+ * mixerGetDevCaps [MMSYSTEM.801]
+ */
+UINT16 WINAPI mixerGetDevCaps16(UINT16 uDeviceID, LPMIXERCAPS16 lpCaps,
+ UINT16 uSize)
+{
+ MIXERCAPSA micA;
+ UINT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
+ if (ret == MMSYSERR_NOERROR) {
+ MIXERCAPS16 mic16;
+ mic16.wMid = micA.wMid;
+ mic16.wPid = micA.wPid;
+ mic16.vDriverVersion = micA.vDriverVersion;
+ strcpy(mic16.szPname, micA.szPname);
+ mic16.fdwSupport = micA.fdwSupport;
+ mic16.cDestinations = micA.cDestinations;
+ memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * mixerOpen [MMSYSTEM.802]
+ */
+UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
+ DWORD dwInstance, DWORD fdwOpen)
+{
+ HMIXER hmix;
+ UINT ret;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIXER)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+
+ ret = mixerOpen(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen);
+ if (ret == MMSYSERR_NOERROR)
+ {
+ if (lphmix) *lphmix = HMIXER_16(hmix);
+ if (thunk) MMSYSTDRV_SetHandle(thunk, hmix);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * mixerClose [MMSYSTEM.803]
+ */
+UINT16 WINAPI mixerClose16(HMIXER16 hMix)
+{
+ UINT ret = mixerClose(HMIXER_32(hMix));
+
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HMIXER_32(hMix));
+ return ret;
+}
+
+/**************************************************************************
+ * mixerGetID (MMSYSTEM.806)
+ */
+UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
+{
+ UINT xid;
+ UINT ret = mixerGetID(HMIXEROBJ_32(hmix), &xid, fdwID);
+
+ if (lpid)
+ *lpid = xid;
+ return ret;
+}
+
+/**************************************************************************
+ * mixerGetControlDetails [MMSYSTEM.808]
+ */
+UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
+ LPMIXERCONTROLDETAILS16 lpmcd,
+ DWORD fdwDetails)
+{
+ DWORD ret = MMSYSERR_NOTENABLED;
+ SEGPTR sppaDetails;
+
+ TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
+
+ if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
+ return MMSYSERR_INVALPARAM;
+
+ sppaDetails = (SEGPTR)lpmcd->paDetails;
+ lpmcd->paDetails = MapSL(sppaDetails);
+ ret = mixerGetControlDetailsA(HMIXEROBJ_32(hmix),
+ (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails);
+ lpmcd->paDetails = (LPVOID)sppaDetails;
+
+ return ret;
+}
+
+/**************************************************************************
+ * mixerGetLineControls [MMSYSTEM.807]
+ */
+UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
+ LPMIXERLINECONTROLS16 lpmlc16,
+ DWORD fdwControls)
+{
+ MIXERLINECONTROLSA mlcA;
+ DWORD ret;
+ unsigned int i;
+ LPMIXERCONTROL16 lpmc16;
+
+ TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls);
+
+ if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
+ lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
+ return MMSYSERR_INVALPARAM;
+
+ mlcA.cbStruct = sizeof(mlcA);
+ mlcA.dwLineID = lpmlc16->dwLineID;
+ mlcA.u.dwControlID = lpmlc16->u.dwControlID;
+ mlcA.u.dwControlType = lpmlc16->u.dwControlType;
+ mlcA.cControls = lpmlc16->cControls;
+ mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
+ mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
+ mlcA.cControls * mlcA.cbmxctrl);
+
+ ret = mixerGetLineControlsA(HMIXEROBJ_32(hmix), &mlcA, fdwControls);
+
+ if (ret == MMSYSERR_NOERROR) {
+ lpmlc16->dwLineID = mlcA.dwLineID;
+ lpmlc16->u.dwControlID = mlcA.u.dwControlID;
+ lpmlc16->u.dwControlType = mlcA.u.dwControlType;
+ lpmlc16->cControls = mlcA.cControls;
+
+ lpmc16 = MapSL(lpmlc16->pamxctrl);
+
+ for (i = 0; i < mlcA.cControls; i++) {
+ lpmc16[i].cbStruct = sizeof(MIXERCONTROL16);
+ lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
+ lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
+ lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
+ lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
+ strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName);
+ strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName);
+ /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
+ memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds,
+ sizeof(mlcA.pamxctrl[i].Bounds));
+ /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
+ memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics,
+ sizeof(mlcA.pamxctrl[i].Metrics));
+ }
+ }
+
+ HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
+
+ return ret;
+}
+
+/**************************************************************************
+ * mixerGetLineInfo [MMSYSTEM.805]
+ */
+UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
+ DWORD fdwInfo)
+{
+ MIXERLINEA mliA;
+ UINT ret;
+
+ TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo);
+
+ if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
+ return MMSYSERR_INVALPARAM;
+
+ mliA.cbStruct = sizeof(mliA);
+ switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
+ case MIXER_GETLINEINFOF_COMPONENTTYPE:
+ mliA.dwComponentType = lpmli16->dwComponentType;
+ break;
+ case MIXER_GETLINEINFOF_DESTINATION:
+ mliA.dwDestination = lpmli16->dwDestination;
+ break;
+ case MIXER_GETLINEINFOF_LINEID:
+ mliA.dwLineID = lpmli16->dwLineID;
+ break;
+ case MIXER_GETLINEINFOF_SOURCE:
+ mliA.dwDestination = lpmli16->dwDestination;
+ mliA.dwSource = lpmli16->dwSource;
+ break;
+ case MIXER_GETLINEINFOF_TARGETTYPE:
+ mliA.Target.dwType = lpmli16->Target.dwType;
+ mliA.Target.wMid = lpmli16->Target.wMid;
+ mliA.Target.wPid = lpmli16->Target.wPid;
+ mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion;
+ strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
+ break;
+ default:
+ FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo);
+ }
+
+ ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo);
+
+ lpmli16->dwDestination = mliA.dwDestination;
+ lpmli16->dwSource = mliA.dwSource;
+ lpmli16->dwLineID = mliA.dwLineID;
+ lpmli16->fdwLine = mliA.fdwLine;
+ lpmli16->dwUser = mliA.dwUser;
+ lpmli16->dwComponentType = mliA.dwComponentType;
+ lpmli16->cChannels = mliA.cChannels;
+ lpmli16->cConnections = mliA.cConnections;
+ lpmli16->cControls = mliA.cControls;
+ strcpy(lpmli16->szShortName, mliA.szShortName);
+ strcpy(lpmli16->szName, mliA.szName);
+ lpmli16->Target.dwType = mliA.Target.dwType;
+ lpmli16->Target.dwDeviceID = mliA.Target.dwDeviceID;
+ lpmli16->Target.wMid = mliA.Target.wMid;
+ lpmli16->Target.wPid = mliA.Target.wPid;
+ lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion;
+ strcpy(lpmli16->Target.szPname, mliA.Target.szPname);
+
+ return ret;
+}
+
+/**************************************************************************
+ * mixerSetControlDetails [MMSYSTEM.809]
+ */
+UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
+ LPMIXERCONTROLDETAILS16 lpmcd,
+ DWORD fdwDetails)
+{
+ TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
+ return MMSYSERR_NOTENABLED;
+}
+
+/**************************************************************************
+ * mixerMessage [MMSYSTEM.804]
+ */
+DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1,
+ DWORD dwParam2)
+{
+ return mixerMessage(HMIXER_32(hmix), uMsg, dwParam1, dwParam2);
+}
+
+/* ###################################################
+ * # AUX #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * auxGetNumDevs [MMSYSTEM.350]
+ */
+UINT16 WINAPI auxGetNumDevs16(void)
+{
+ return auxGetNumDevs();
+}
+
+/**************************************************************************
+ * auxGetDevCaps [MMSYSTEM.351]
+ */
+UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
+{
+ AUXCAPSA acA;
+ UINT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
+ if (ret == MMSYSERR_NOERROR) {
+ AUXCAPS16 ac16;
+ ac16.wMid = acA.wMid;
+ ac16.wPid = acA.wPid;
+ ac16.vDriverVersion = acA.vDriverVersion;
+ strcpy(ac16.szPname, acA.szPname);
+ ac16.wTechnology = acA.wTechnology;
+ ac16.dwSupport = acA.dwSupport;
+ memcpy(lpCaps, &ac16, min(uSize, sizeof(ac16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * auxGetVolume [MMSYSTEM.352]
+ */
+UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
+{
+ return auxGetVolume(uDeviceID, lpdwVolume);
+}
+
+/**************************************************************************
+ * auxSetVolume [MMSYSTEM.353]
+ */
+UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
+{
+ return auxSetVolume(uDeviceID, dwVolume);
+}
+
+/**************************************************************************
+ * auxOutMessage [MMSYSTEM.354]
+ */
+DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
+{
+ TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2);
+
+ switch (uMessage) {
+ case AUXDM_GETNUMDEVS:
+ case AUXDM_SETVOLUME:
+ /* no argument conversion needed */
+ break;
+ case AUXDM_GETVOLUME:
+ return auxGetVolume(uDeviceID, MapSL(dw1));
+ case AUXDM_GETDEVCAPS:
+ return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
+ default:
+ TRACE("(%04x, %04x, %08x, %08x): unhandled message\n",
+ uDeviceID, uMessage, dw1, dw2);
+ break;
+ }
+ return auxOutMessage(uDeviceID, uMessage, dw1, dw2);
+}
+
+/* ###################################################
+ * # MIDI #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * midiOutGetNumDevs [MMSYSTEM.201]
+ */
+UINT16 WINAPI midiOutGetNumDevs16(void)
+{
+ return midiOutGetNumDevs();
+}
+
+/**************************************************************************
+ * midiOutGetDevCaps [MMSYSTEM.202]
+ */
+UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps,
+ UINT16 uSize)
+{
+ MIDIOUTCAPSA mocA;
+ UINT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA));
+ if (ret == MMSYSERR_NOERROR) {
+ MIDIOUTCAPS16 moc16;
+ moc16.wMid = mocA.wMid;
+ moc16.wPid = mocA.wPid;
+ moc16.vDriverVersion = mocA.vDriverVersion;
+ strcpy(moc16.szPname, mocA.szPname);
+ moc16.wTechnology = mocA.wTechnology;
+ moc16.wVoices = mocA.wVoices;
+ moc16.wNotes = mocA.wNotes;
+ moc16.wChannelMask = mocA.wChannelMask;
+ moc16.dwSupport = mocA.dwSupport;
+ memcpy(lpCaps, &moc16, min(uSize, sizeof(moc16)));
+ }
+ return ret;
+ }
+
+/**************************************************************************
+ * midiOutGetErrorText [MMSYSTEM.203]
+ * midiInGetErrorText [MMSYSTEM.303]
+ */
+UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
+{
+ return midiOutGetErrorTextA(uError, lpText, uSize);
+}
+
+/**************************************************************************
+ * midiOutOpen [MMSYSTEM.204]
+ */
+UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
+ DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
+{
+ HMIDIOUT hmo;
+ UINT ret;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+ ret = midiOutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags);
+ if (ret == MMSYSERR_NOERROR)
+ {
+ if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
+ MMSYSTDRV_SetHandle(thunk, (void*)hmo);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * midiOutClose [MMSYSTEM.205]
+ */
+UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
+{
+ UINT ret = midiOutClose(HMIDIOUT_32(hMidiOut));
+
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HMIDIOUT_32(hMidiOut));
+ return ret;
+}
+
+/**************************************************************************
+ * midiOutPrepareHeader [MMSYSTEM.206]
+ */
+UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
+ SEGPTR lpsegMidiOutHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+ return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_PREPARE, lpsegMidiOutHdr, uSize);
+}
+
+/**************************************************************************
+ * midiOutUnprepareHeader [MMSYSTEM.207]
+ */
+UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
+ SEGPTR lpsegMidiOutHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
+
+ TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+ if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
+ return MMSYSERR_NOERROR;
+ }
+
+ return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_UNPREPARE, lpsegMidiOutHdr, uSize);
+}
+
+/**************************************************************************
+ * midiOutShortMsg [MMSYSTEM.208]
+ */
+UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
+{
+ return midiOutShortMsg(HMIDIOUT_32(hMidiOut), dwMsg);
+}
+
+/**************************************************************************
+ * midiOutLongMsg [MMSYSTEM.209]
+ */
+UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, /* [in] */
+ LPMIDIHDR16 lpsegMidiOutHdr, /* [???] NOTE: SEGPTR */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+ return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize);
+}
+
+/**************************************************************************
+ * midiOutReset [MMSYSTEM.210]
+ */
+UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
+{
+ return midiOutReset(HMIDIOUT_32(hMidiOut));
+}
+
+/**************************************************************************
+ * midiOutGetVolume [MMSYSTEM.211]
+ */
+UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
+{
+ return midiOutGetVolume(HMIDIOUT_32(uDeviceID), lpdwVolume);
+}
+
+/**************************************************************************
+ * midiOutSetVolume [MMSYSTEM.212]
+ */
+UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
+{
+ return midiOutSetVolume(HMIDIOUT_32(uDeviceID), dwVolume);
+}
+
+/**************************************************************************
+ * midiOutCachePatches [MMSYSTEM.213]
+ */
+UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
+ WORD* lpwPatchArray, UINT16 uFlags)
+{
+ return midiOutCachePatches(HMIDIOUT_32(hMidiOut), uBank, lpwPatchArray,
+ uFlags);
+}
+
+/**************************************************************************
+ * midiOutCacheDrumPatches [MMSYSTEM.214]
+ */
+UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
+ WORD* lpwKeyArray, UINT16 uFlags)
+{
+ return midiOutCacheDrumPatches(HMIDIOUT_32(hMidiOut), uPatch, lpwKeyArray, uFlags);
+}
+
+/**************************************************************************
+ * midiOutGetID [MMSYSTEM.215]
+ */
+UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
+{
+ UINT devid;
+ UINT16 ret;
+
+ ret = midiOutGetID(HMIDIOUT_32(hMidiOut), &devid);
+ if (ret != MMSYSERR_NOERROR) return ret;
+ *lpuDeviceID = devid;
+ return ret;
+}
+
+/**************************************************************************
+ * midiOutMessage [MMSYSTEM.216]
+ */
+DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
+
+ switch (uMessage) {
+ case MODM_OPEN:
+ case MODM_CLOSE:
+ FIXME("can't handle OPEN or CLOSE message!\n");
+ return MMSYSERR_NOTSUPPORTED;
+
+ case MODM_GETVOLUME:
+ return midiOutGetVolume16(hMidiOut, MapSL(dwParam1));
+ case MODM_LONGDATA:
+ return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2);
+ case MODM_PREPARE:
+ /* lpMidiOutHdr is still a segmented pointer for this function */
+ return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2);
+ case MODM_UNPREPARE:
+ return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2);
+ }
+ return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), uMessage, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * midiInGetNumDevs [MMSYSTEM.301]
+ */
+UINT16 WINAPI midiInGetNumDevs16(void)
+{
+ return midiInGetNumDevs();
+}
+
+/**************************************************************************
+ * midiInGetDevCaps [MMSYSTEM.302]
+ */
+UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
+ UINT16 uSize)
+{
+ MIDIINCAPSA micA;
+ UINT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
+ if (ret == MMSYSERR_NOERROR) {
+ MIDIINCAPS16 mic16;
+ mic16.wMid = micA.wMid;
+ mic16.wPid = micA.wPid;
+ mic16.vDriverVersion = micA.vDriverVersion;
+ strcpy(mic16.szPname, micA.szPname);
+ mic16.dwSupport = micA.dwSupport;
+ memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * midiInOpen [MMSYSTEM.304]
+ */
+UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
+ DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
+{
+ HMIDIIN hmid;
+ UINT ret;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIIN)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+ ret = midiInOpen(&hmid, uDeviceID, dwCallback, dwInstance, dwFlags);
+ if (ret == MMSYSERR_NOERROR)
+ {
+ if (lphMidiIn) *lphMidiIn = HMIDIIN_16(hmid);
+ MMSYSTDRV_SetHandle(thunk, (void*)hmid);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * midiInClose [MMSYSTEM.305]
+ */
+UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
+{
+ UINT ret = midiInClose(HMIDIIN_32(hMidiIn));
+
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HMIDIIN_32(hMidiIn));
+ return ret;
+}
+
+/**************************************************************************
+ * midiInPrepareHeader [MMSYSTEM.306]
+ */
+UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
+ SEGPTR lpsegMidiInHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+ return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_PREPARE, lpsegMidiInHdr, uSize);
+}
+
+/**************************************************************************
+ * midiInUnprepareHeader [MMSYSTEM.307]
+ */
+UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
+ SEGPTR lpsegMidiInHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr);
+
+ TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+ if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
+ return MMSYSERR_NOERROR;
+ }
+
+ return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_UNPREPARE, lpsegMidiInHdr, uSize);
+}
+
+/**************************************************************************
+ * midiInAddBuffer [MMSYSTEM.308]
+ */
+UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */
+ MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+ return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize);
+}
+
+/**************************************************************************
+ * midiInStart [MMSYSTEM.309]
+ */
+UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
+{
+ return midiInStart(HMIDIIN_32(hMidiIn));
+}
+
+/**************************************************************************
+ * midiInStop [MMSYSTEM.310]
+ */
+UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
+{
+ return midiInStop(HMIDIIN_32(hMidiIn));
+}
+
+/**************************************************************************
+ * midiInReset [MMSYSTEM.311]
+ */
+UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
+{
+ return midiInReset(HMIDIIN_32(hMidiIn));
+}
+
+/**************************************************************************
+ * midiInGetID [MMSYSTEM.312]
+ */
+UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
+{
+ UINT devid;
+ UINT16 ret;
+
+ ret = midiInGetID(HMIDIIN_32(hMidiIn), &devid);
+ if (ret != MMSYSERR_NOERROR) return ret;
+ *lpuDeviceID = devid;
+ return ret;
+}
+
+/**************************************************************************
+ * midiInMessage [MMSYSTEM.313]
+ */
+DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("(%04X, %04X, %08X, %08X)\n", hMidiIn, uMessage, dwParam1, dwParam2);
+
+ switch (uMessage) {
+ case MIDM_OPEN:
+ case MIDM_CLOSE:
+ FIXME("can't handle OPEN or CLOSE message!\n");
+ return MMSYSERR_NOTSUPPORTED;
+
+ case MIDM_GETDEVCAPS:
+ return midiInGetDevCaps16(hMidiIn, MapSL(dwParam1), dwParam2);
+ case MIDM_PREPARE:
+ return midiInPrepareHeader16(hMidiIn, dwParam1, dwParam2);
+ case MIDM_UNPREPARE:
+ return midiInUnprepareHeader16(hMidiIn, dwParam1, dwParam2);
+ case MIDM_ADDBUFFER:
+ return midiInAddBuffer16(hMidiIn, MapSL(dwParam1), dwParam2);
+ }
+ return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), uMessage, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * midiStreamClose [MMSYSTEM.252]
+ */
+MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
+{
+ UINT ret = midiStreamClose(HMIDISTRM_32(hMidiStrm));
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HMIDISTRM_32(hMidiStrm));
+ return ret;
+}
+
+/**************************************************************************
+ * midiStreamOpen [MMSYSTEM.251]
+ */
+MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
+ DWORD cMidi, DWORD dwCallback,
+ DWORD dwInstance, DWORD fdwOpen)
+{
+ HMIDISTRM hMidiStrm32;
+ MMRESULT ret;
+ UINT devid32;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!phMidiStrm || !devid)
+ return MMSYSERR_INVALPARAM;
+ devid32 = *devid;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+ ret = midiStreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen);
+ if (ret == MMSYSERR_NOERROR)
+ {
+ *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
+ *devid = devid32;
+ MMSYSTDRV_SetHandle(thunk, hMidiStrm32);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * midiStreamOut [MMSYSTEM.254]
+ */
+MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
+{
+ return midiStreamOut(HMIDISTRM_32(hMidiStrm), (LPMIDIHDR)lpMidiHdr,
+ cbMidiHdr);
+}
+
+/**************************************************************************
+ * midiStreamPause [MMSYSTEM.255]
+ */
+MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm)
+{
+ return midiStreamPause(HMIDISTRM_32(hMidiStrm));
+}
+
+/**************************************************************************
+ * midiStreamPosition [MMSYSTEM.253]
+ */
+MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt)
+{
+ MMTIME mmt32;
+ MMRESULT ret;
+
+ if (!lpmmt16)
+ return MMSYSERR_INVALPARAM;
+ MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16);
+ ret = midiStreamPosition(HMIDISTRM_32(hMidiStrm), &mmt32, sizeof(MMTIME));
+ MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32);
+ return ret;
+}
+
+/**************************************************************************
+ * midiStreamProperty [MMSYSTEM.250]
+ */
+MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
+{
+ return midiStreamProperty(HMIDISTRM_32(hMidiStrm), lpPropData, dwProperty);
+}
+
+/**************************************************************************
+ * midiStreamRestart [MMSYSTEM.256]
+ */
+MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm)
+{
+ return midiStreamRestart(HMIDISTRM_32(hMidiStrm));
+}
+
+/**************************************************************************
+ * midiStreamStop [MMSYSTEM.257]
+ */
+MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm)
+{
+ return midiStreamStop(HMIDISTRM_32(hMidiStrm));
+}
+
+/* ###################################################
+ * # WAVE #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * waveOutGetNumDevs [MMSYSTEM.401]
+ */
+UINT16 WINAPI waveOutGetNumDevs16(void)
+{
+ return waveOutGetNumDevs();
+}
+
+/**************************************************************************
+ * waveOutGetDevCaps [MMSYSTEM.402]
+ */
+UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID,
+ LPWAVEOUTCAPS16 lpCaps, UINT16 uSize)
+{
+ WAVEOUTCAPSA wocA;
+ UINT ret;
+ TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
+ if (ret == MMSYSERR_NOERROR) {
+ WAVEOUTCAPS16 woc16;
+ woc16.wMid = wocA.wMid;
+ woc16.wPid = wocA.wPid;
+ woc16.vDriverVersion = wocA.vDriverVersion;
+ strcpy(woc16.szPname, wocA.szPname);
+ woc16.dwFormats = wocA.dwFormats;
+ woc16.wChannels = wocA.wChannels;
+ woc16.dwSupport = wocA.dwSupport;
+ memcpy(lpCaps, &woc16, min(uSize, sizeof(woc16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutGetErrorText [MMSYSTEM.403]
+ * waveInGetErrorText [MMSYSTEM.503]
+ */
+UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
+{
+ return waveOutGetErrorTextA(uError, lpText, uSize);
+}
+
+/**************************************************************************
+ * waveOutOpen [MMSYSTEM.404]
+ */
+UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
+ LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
+ DWORD dwInstance, DWORD dwFlags)
+{
+ HWAVEOUT hWaveOut;
+ UINT ret;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEOUT)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+ /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
+ * call the 32 bit version
+ * however, we need to promote correctly the wave mapper id
+ * (0xFFFFFFFF and not 0x0000FFFF)
+ */
+ ret = waveOutOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
+ lpFormat, dwCallback, dwInstance, dwFlags);
+
+ if (ret == MMSYSERR_NOERROR)
+ {
+ if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut);
+ MMSYSTDRV_SetHandle(thunk, (void*)hWaveOut);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutClose [MMSYSTEM.405]
+ */
+UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveOutClose(HWAVEOUT_32(hWaveOut));
+ RestoreThunkLock(level);
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HWAVEOUT_32(hWaveOut));
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutPrepareHeader [MMSYSTEM.406]
+ */
+UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
+ SEGPTR lpsegWaveOutHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
+ UINT16 result;
+
+ TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+ if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
+
+ if ((result = MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_PREPARE, lpsegWaveOutHdr,
+ uSize)) != MMSYSERR_NOTSUPPORTED)
+ return result;
+
+ if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
+ return WAVERR_STILLPLAYING;
+
+ lpWaveOutHdr->dwFlags |= WHDR_PREPARED;
+ lpWaveOutHdr->dwFlags &= ~WHDR_DONE;
+
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * waveOutUnprepareHeader [MMSYSTEM.407]
+ */
+UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
+ SEGPTR lpsegWaveOutHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
+
+ TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+ if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
+ return MMSYSERR_NOERROR;
+ }
+
+ return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_UNPREPARE, lpsegWaveOutHdr, uSize);
+}
+
+/**************************************************************************
+ * waveOutWrite [MMSYSTEM.408]
+ */
+UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */
+ LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+ return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize);
+}
+
+/**************************************************************************
+ * waveOutBreakLoop [MMSYSTEM.419]
+ */
+UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveOutBreakLoop(HWAVEOUT_32(hWaveOut16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutPause [MMSYSTEM.409]
+ */
+UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveOutPause(HWAVEOUT_32(hWaveOut16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutReset [MMSYSTEM.411]
+ */
+UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveOutReset(HWAVEOUT_32(hWaveOut16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutRestart [MMSYSTEM.410]
+ */
+UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveOutRestart(HWAVEOUT_32(hWaveOut16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutGetPosition [MMSYSTEM.412]
+ */
+UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
+ UINT16 uSize)
+{
+ UINT ret;
+ MMTIME mmt;
+
+ mmt.wType = lpTime->wType;
+ ret = waveOutGetPosition(HWAVEOUT_32(hWaveOut), &mmt, sizeof(mmt));
+ MMSYSTEM_MMTIME32to16(lpTime, &mmt);
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutGetPitch [MMSYSTEM.413]
+ */
+UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
+{
+ return waveOutGetPitch(HWAVEOUT_32(hWaveOut16), lpdw);
+}
+
+/**************************************************************************
+ * waveOutSetPitch [MMSYSTEM.414]
+ */
+UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw)
+{
+ return waveOutSetPitch(HWAVEOUT_32(hWaveOut16), dw);
+}
+
+/**************************************************************************
+ * waveOutGetPlaybackRate [MMSYSTEM.417]
+ */
+UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
+{
+ return waveOutGetPlaybackRate(HWAVEOUT_32(hWaveOut16), lpdw);
+}
+
+/**************************************************************************
+ * waveOutSetPlaybackRate [MMSYSTEM.418]
+ */
+UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw)
+{
+ return waveOutSetPlaybackRate(HWAVEOUT_32(hWaveOut16), dw);
+}
+
+/**************************************************************************
+ * waveOutGetVolume [MMSYSTEM.415]
+ */
+UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw)
+{
+ return waveOutGetVolume(HWAVEOUT_32(devid), lpdw);
+}
+
+/**************************************************************************
+ * waveOutSetVolume [MMSYSTEM.416]
+ */
+UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw)
+{
+ return waveOutSetVolume(HWAVEOUT_32(devid), dw);
+}
+
+/**************************************************************************
+ * waveOutGetID [MMSYSTEM.420]
+ */
+UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
+{
+ UINT devid;
+ UINT16 ret;
+
+ ret = waveOutGetID(HWAVEOUT_32(hWaveOut), &devid);
+ if (ret != MMSYSERR_NOERROR) return ret;
+ *lpuDeviceID = devid;
+ return ret;
+}
+
+/**************************************************************************
+ * waveOutMessage [MMSYSTEM.421]
+ */
+DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
+
+ if ((DWORD_PTR)hWaveOut < waveOutGetNumDevs())
+ {
+ if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
+ dwParam1 = (DWORD)MapSL(dwParam1);
+ }
+ else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
+ /* from M$ KB */
+ return MMSYSERR_INVALPARAM;
+
+ return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), uMessage, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * waveInGetNumDevs [MMSYSTEM.501]
+ */
+UINT16 WINAPI waveInGetNumDevs16(void)
+{
+ return waveInGetNumDevs();
+}
+
+/**************************************************************************
+ * waveInGetDevCaps [MMSYSTEM.502]
+ */
+UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps,
+ UINT16 uSize)
+{
+ WAVEINCAPSA wicA;
+ UINT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA));
+ if (ret == MMSYSERR_NOERROR) {
+ WAVEINCAPS16 wic16;
+ wic16.wMid = wicA.wMid;
+ wic16.wPid = wicA.wPid;
+ wic16.vDriverVersion = wicA.vDriverVersion;
+ strcpy(wic16.szPname, wicA.szPname);
+ wic16.dwFormats = wicA.dwFormats;
+ wic16.wChannels = wicA.wChannels;
+ memcpy(lpCaps, &wic16, min(uSize, sizeof(wic16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * waveInOpen [MMSYSTEM.504]
+ */
+UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
+ LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
+ DWORD dwInstance, DWORD dwFlags)
+{
+ HWAVEIN hWaveIn;
+ UINT ret;
+ struct mmsystdrv_thunk* thunk;
+
+ if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEIN)))
+ {
+ return MMSYSERR_NOMEM;
+ }
+ if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
+ {
+ dwCallback = (DWORD)thunk;
+ }
+ /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
+ * call the 32 bit version
+ * however, we need to promote correctly the wave mapper id
+ * (0xFFFFFFFF and not 0x0000FFFF)
+ */
+ ret = waveInOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
+ lpFormat, dwCallback, dwInstance, dwFlags);
+
+ if (ret == MMSYSERR_NOERROR)
+ {
+ if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn);
+ MMSYSTDRV_SetHandle(thunk, (void*)hWaveIn);
+ }
+ else MMSYSTDRV_DeleteThunk(thunk);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInClose [MMSYSTEM.505]
+ */
+UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveInClose(HWAVEIN_32(hWaveIn));
+ RestoreThunkLock(level);
+ if (ret == MMSYSERR_NOERROR)
+ MMSYSTDRV_CloseHandle((void*)HWAVEIN_32(hWaveIn));
+ return ret;
+}
+
+/**************************************************************************
+ * waveInPrepareHeader [MMSYSTEM.506]
+ */
+UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
+ SEGPTR lpsegWaveInHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
+ UINT16 ret;
+
+ TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
+
+ if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
+ lpWaveInHdr->dwBytesRecorded = 0;
+
+ ret = MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_PREPARE, lpsegWaveInHdr, uSize);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInUnprepareHeader [MMSYSTEM.507]
+ */
+UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
+ SEGPTR lpsegWaveInHdr, /* [???] */
+ UINT16 uSize) /* [in] */
+{
+ LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
+
+ TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
+
+ if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
+
+ if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
+ return MMSYSERR_NOERROR;
+ }
+
+ return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_UNPREPARE, lpsegWaveInHdr, uSize);
+}
+
+/**************************************************************************
+ * waveInAddBuffer [MMSYSTEM.508]
+ */
+UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */
+ WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
+ UINT16 uSize) /* [in] */
+{
+ TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
+
+ if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
+
+ return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize);
+}
+
+/**************************************************************************
+ * waveInReset [MMSYSTEM.511]
+ */
+UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveInReset(HWAVEIN_32(hWaveIn16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInStart [MMSYSTEM.509]
+ */
+UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveInStart(HWAVEIN_32(hWaveIn16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInStop [MMSYSTEM.510]
+ */
+UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16)
+{
+ DWORD level;
+ UINT16 ret;
+
+ ReleaseThunkLock(&level);
+ ret = waveInStop(HWAVEIN_32(hWaveIn16));
+ RestoreThunkLock(level);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInGetPosition [MMSYSTEM.512]
+ */
+UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
+ UINT16 uSize)
+{
+ UINT ret;
+ MMTIME mmt;
+
+ mmt.wType = lpTime->wType;
+ ret = waveInGetPosition(HWAVEIN_32(hWaveIn), &mmt, sizeof(mmt));
+ MMSYSTEM_MMTIME32to16(lpTime, &mmt);
+ return ret;
+}
+
+/**************************************************************************
+ * waveInGetID [MMSYSTEM.513]
+ */
+UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
+{
+ UINT devid;
+ UINT16 ret;
+
+ ret = waveInGetID(HWAVEIN_32(hWaveIn), &devid);
+ if (ret != MMSYSERR_NOERROR) return ret;
+ *lpuDeviceID = devid;
+ return ret;
+}
+
+/**************************************************************************
+ * waveInMessage [MMSYSTEM.514]
+ */
+DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
+
+ if ((DWORD_PTR)hWaveIn < waveInGetNumDevs())
+ {
+ if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
+ dwParam1 = (DWORD)MapSL(dwParam1);
+ }
+ else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
+ /* from M$ KB */
+ return MMSYSERR_INVALPARAM;
+
+ return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), uMessage, dwParam1, dwParam2);
+}
+
+/* ###################################################
+ * # TASK #
+ * ###################################################
+ */
+
+/*#define USE_MM_TSK_WINE*/
+
+/**************************************************************************
+ * mmTaskCreate [MMSYSTEM.900]
+ *
+ * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
+ * called upon creation with dwPmt as parameter.
+ */
+HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt)
+{
+ HINSTANCE16 ret;
+ HINSTANCE16 handle;
+ char cmdline[16];
+ DWORD showCmd = 0x40002;
+ LOADPARAMS16 lp;
+
+ TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt);
+ /* This to work requires NE modules to be started with a binary command line
+ * which is not currently the case. A patch exists but has never been committed.
+ * A workaround would be to integrate code for mmtask.tsk into Wine, but
+ * this requires tremendous work (starting with patching tools/build to
+ * create NE executables (and not only DLLs) for builtins modules.
+ * EP 99/04/25
+ */
+ FIXME("This is currently broken. It will fail\n");
+
+ cmdline[0] = 0x0d;
+ *(LPDWORD)(cmdline + 1) = (DWORD)spProc;
+ *(LPDWORD)(cmdline + 5) = dwPmt;
+ *(LPDWORD)(cmdline + 9) = 0;
+
+ lp.hEnvironment = 0;
+ lp.cmdLine = MapLS(cmdline);
+ lp.showCmd = MapLS(&showCmd);
+ lp.reserved = 0;
+
+#ifndef USE_MM_TSK_WINE
+ handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp);
+#else
+ handle = LoadModule16("mmtask.tsk", &lp);
+#endif
+ if (handle < 32) {
+ ret = (handle) ? 1 : 2;
+ handle = 0;
+ } else {
+ ret = 0;
+ }
+ if (lphMmTask)
+ *lphMmTask = handle;
+
+ UnMapLS( lp.cmdLine );
+ UnMapLS( lp.showCmd );
+ TRACE("=> 0x%04x/%d\n", handle, ret);
+ return ret;
+}
+
+#ifdef USE_MM_TSK_WINE
+/* C equivalent to mmtask.tsk binary content */
+void mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si)
+{
+ int len = cmdLine[0x80];
+
+ if (len / 2 == 6) {
+ void (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1)));
+ DWORD dwPmt = *((DWORD*)(cmdLine + 5));
+
+#if 0
+ InitTask16(); /* FIXME: pmts / from context ? */
+ InitApp(di);
+#endif
+ if (SetMessageQueue16(0x40)) {
+ WaitEvent16(0);
+ if (HIWORD(fpProc)) {
+ OldYield16();
+/* EPP StackEnter16(); */
+ (fpProc)(dwPmt);
+ }
+ }
+ }
+ OldYield16();
+ OldYield16();
+ OldYield16();
+ ExitProcess(0);
+}
+#endif
+
+/**************************************************************************
+ * mmTaskBlock [MMSYSTEM.902]
+ */
+void WINAPI mmTaskBlock16(HINSTANCE16 hInst)
+{
+ MSG msg;
+
+ do {
+ GetMessageA(&msg, 0, 0, 0);
+ if (msg.hwnd) {
+ TranslateMessage(&msg);
+ DispatchMessageA(&msg);
+ }
+ } while (msg.message < 0x3A0);
+}
+
+/**************************************************************************
+ * mmTaskSignal [MMSYSTEM.903]
+ */
+LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
+{
+ TRACE("(%04x);\n", ht);
+ return PostThreadMessageW( HTASK_32(ht), WM_USER, 0, 0 );
+}
+
+/**************************************************************************
+ * mmGetCurrentTask [MMSYSTEM.904]
+ */
+HTASK16 WINAPI mmGetCurrentTask16(void)
+{
+ return GetCurrentTask();
+}
+
+/**************************************************************************
+ * mmTaskYield [MMSYSTEM.905]
+ */
+void WINAPI mmTaskYield16(void)
+{
+ MSG msg;
+
+ if (PeekMessageA(&msg, 0, 0, 0, 0)) {
+ WOWYield16();
+ }
+}
+
+extern DWORD WINAPI GetProcessFlags(DWORD);
+
+/******************************************************************
+ * WINMM_GetmmThread
+ *
+ *
+ */
+static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16 h)
+{
+ return MapSL(MAKESEGPTR(h, 0));
+}
+
+DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID);
+
+/**************************************************************************
+ * mmThreadCreate [MMSYSTEM.1120]
+ *
+ * undocumented
+ * Creates a MM thread, calling fpThreadAddr(dwPmt).
+ * dwFlags:
+ * bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
+ * bit.1 set means to open a VxD for this thread (unsupported)
+ */
+LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD dwPmt, DWORD dwFlags)
+{
+ HANDLE16 hndl;
+ LRESULT ret;
+
+ TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
+
+ hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
+
+ if (hndl == 0) {
+ ret = 2;
+ } else {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+
+#if 0
+ /* force mmtask routines even if mmthread is required */
+ /* this will work only if the patch about binary cmd line and NE tasks
+ * is committed
+ */
+ dwFlags |= 1;
+#endif
+
+ lpMMThd->dwSignature = WINE_MMTHREAD_CREATED;
+ lpMMThd->dwCounter = 0;
+ lpMMThd->hThread = 0;
+ lpMMThd->dwThreadID = 0;
+ lpMMThd->fpThread = (DWORD)fpThreadAddr;
+ lpMMThd->dwThreadPmt = dwPmt;
+ lpMMThd->dwSignalCount = 0;
+ lpMMThd->hEvent = 0;
+ lpMMThd->hVxD = 0;
+ lpMMThd->dwStatus = 0;
+ lpMMThd->dwFlags = dwFlags;
+ lpMMThd->hTask = 0;
+
+ if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
+ lpMMThd->hEvent = CreateEventW(NULL, FALSE, TRUE, NULL);
+
+ TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd);
+ if (lpMMThd->dwFlags & 2) {
+ /* as long as we don't support MM VxD in wine, we don't need
+ * to care about this flag
+ */
+ /* FIXME("Don't know how to properly open VxD handles\n"); */
+ /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
+ }
+
+ lpMMThd->hThread = CreateThread(0, 0, WINE_mmThreadEntryPoint,
+ (LPVOID)(DWORD_PTR)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID);
+ if (lpMMThd->hThread == 0) {
+ WARN("Couldn't create thread\n");
+ /* clean-up(VxDhandle...); devicedirectio... */
+ if (lpMMThd->hEvent != 0)
+ CloseHandle(lpMMThd->hEvent);
+ ret = 2;
+ } else {
+ SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL);
+ TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID);
+ ret = 0;
+ }
+ } else {
+ /* get WINE_mmThreadEntryPoint()
+ * 2047 is its ordinal in mmsystem.spec
+ */
+ FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
+
+ TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp));
+
+ ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
+ }
+
+ if (ret == 0) {
+ if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread))
+ WARN("Couldn't resume thread\n");
+
+ while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */
+ UserYield16();
+ }
+ }
+ }
+
+ if (ret != 0) {
+ GlobalFree16(hndl);
+ hndl = 0;
+ }
+
+ if (lpHndl)
+ *lpHndl = hndl;
+
+ TRACE("ok => %ld\n", ret);
+ return ret;
+}
+
+/**************************************************************************
+ * mmThreadSignal [MMSYSTEM.1121]
+ */
+void WINAPI mmThreadSignal16(HANDLE16 hndl)
+{
+ TRACE("(%04x)!\n", hndl);
+
+ if (hndl) {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+
+ lpMMThd->dwCounter++;
+ if (lpMMThd->hThread != 0) {
+ InterlockedIncrement(&lpMMThd->dwSignalCount);
+ SetEvent(lpMMThd->hEvent);
+ } else {
+ mmTaskSignal16(lpMMThd->hTask);
+ }
+ lpMMThd->dwCounter--;
+ }
+}
+
+static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
+{
+ MSG msg;
+ DWORD ret;
+
+ if (lpMMThd->dwThreadID != GetCurrentThreadId())
+ ERR("Not called by thread itself\n");
+
+ for (;;) {
+ ResetEvent(lpMMThd->hEvent);
+ if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0)
+ break;
+ InterlockedIncrement(&lpMMThd->dwSignalCount);
+
+ TRACE("S1\n");
+
+ ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT);
+ switch (ret) {
+ case WAIT_OBJECT_0: /* Event */
+ TRACE("S2.1\n");
+ break;
+ case WAIT_OBJECT_0 + 1: /* Msg */
+ TRACE("S2.2\n");
+ if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
+ TranslateMessage(&msg);
+ DispatchMessageA(&msg);
+ }
+ break;
+ default:
+ WARN("S2.x unsupported ret val 0x%08x\n", ret);
+ }
+ TRACE("S3\n");
+ }
+}
+
+/**************************************************************************
+ * mmThreadBlock [MMSYSTEM.1122]
+ */
+void WINAPI mmThreadBlock16(HANDLE16 hndl)
+{
+ TRACE("(%04x)!\n", hndl);
+
+ if (hndl) {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+
+ if (lpMMThd->hThread != 0) {
+ DWORD lc;
+
+ ReleaseThunkLock(&lc);
+ MMSYSTEM_ThreadBlock(lpMMThd);
+ RestoreThunkLock(lc);
+ } else {
+ mmTaskBlock16(lpMMThd->hTask);
+ }
+ }
+ TRACE("done\n");
+}
+
+/**************************************************************************
+ * mmThreadIsCurrent [MMSYSTEM.1123]
+ */
+BOOL16 WINAPI mmThreadIsCurrent16(HANDLE16 hndl)
+{
+ BOOL16 ret = FALSE;
+
+ TRACE("(%04x)!\n", hndl);
+
+ if (hndl && mmThreadIsValid16(hndl)) {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+ ret = (GetCurrentThreadId() == lpMMThd->dwThreadID);
+ }
+ TRACE("=> %d\n", ret);
+ return ret;
+}
+
+/**************************************************************************
+ * mmThreadIsValid [MMSYSTEM.1124]
+ */
+BOOL16 WINAPI mmThreadIsValid16(HANDLE16 hndl)
+{
+ BOOL16 ret = FALSE;
+
+ TRACE("(%04x)!\n", hndl);
+
+ if (hndl) {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+
+ if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) &&
+ lpMMThd->dwSignature == WINE_MMTHREAD_CREATED &&
+ IsTask16(lpMMThd->hTask)) {
+ lpMMThd->dwCounter++;
+ if (lpMMThd->hThread != 0) {
+ DWORD dwThreadRet;
+ if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) &&
+ dwThreadRet == STATUS_PENDING) {
+ ret = TRUE;
+ }
+ } else {
+ ret = TRUE;
+ }
+ lpMMThd->dwCounter--;
+ }
+ }
+ TRACE("=> %d\n", ret);
+ return ret;
+}
+
+/**************************************************************************
+ * mmThreadGetTask [MMSYSTEM.1125]
+ */
+HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl)
+{
+ HANDLE16 ret = 0;
+
+ TRACE("(%04x)\n", hndl);
+
+ if (mmThreadIsValid16(hndl)) {
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+ ret = lpMMThd->hTask;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * __wine_mmThreadEntryPoint (MMSYSTEM.2047)
+ */
+DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID p)
+{
+ HANDLE16 hndl = (HANDLE16)(DWORD_PTR)p;
+ WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
+
+ TRACE("(%04x %p)\n", hndl, lpMMThd);
+
+ lpMMThd->hTask = LOWORD(GetCurrentTask());
+ TRACE("[10-%p] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask);
+ lpMMThd->dwStatus = 0x10;
+ MMSYSTEM_ThreadBlock(lpMMThd);
+ TRACE("[20-%p]\n", lpMMThd->hThread);
+ lpMMThd->dwStatus = 0x20;
+ if (lpMMThd->fpThread) {
+ WOWCallback16(lpMMThd->fpThread, lpMMThd->dwThreadPmt);
+ }
+ lpMMThd->dwStatus = 0x30;
+ TRACE("[30-%p]\n", lpMMThd->hThread);
+ while (lpMMThd->dwCounter) {
+ Sleep(1);
+ /* WOWYield16();*/
+ }
+ TRACE("[XX-%p]\n", lpMMThd->hThread);
+ /* paranoia */
+ lpMMThd->dwSignature = WINE_MMTHREAD_DELETED;
+ /* close lpMMThread->hVxD directIO */
+ if (lpMMThd->hEvent)
+ CloseHandle(lpMMThd->hEvent);
+ GlobalFree16(hndl);
+ TRACE("done\n");
+
+ return 0;
+}
+
+typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR);
+
+/**************************************************************************
+ * mmShowMMCPLPropertySheet [MMSYSTEM.1150]
+ */
+BOOL16 WINAPI mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice,
+ LPCSTR lpStrTab, LPCSTR lpStrTitle)
+{
+ HANDLE hndl;
+ BOOL16 ret = FALSE;
+
+ TRACE("(%p \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle);
+
+ hndl = LoadLibraryA("MMSYS.CPL");
+ if (hndl != 0) {
+ MMCPLCALLBACK fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet");
+ if (fp != NULL) {
+ DWORD lc;
+ ReleaseThunkLock(&lc);
+ ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle);
+ RestoreThunkLock(lc);
+ }
+ FreeLibrary(hndl);
+ }
+
+ return ret;
+}
+
+/**************************************************************************
+ * StackEnter [MMSYSTEM.32]
+ */
+void WINAPI StackEnter16(void)
+{
+#ifdef __i386__
+ /* mmsystem.dll from Win 95 does only this: so does Wine */
+ __asm__("stc");
+#endif
+}
+
+/**************************************************************************
+ * StackLeave [MMSYSTEM.33]
+ */
+void WINAPI StackLeave16(void)
+{
+#ifdef __i386__
+ /* mmsystem.dll from Win 95 does only this: so does Wine */
+ __asm__("stc");
+#endif
+}
+
+/**************************************************************************
+ * WMMMidiRunOnce [MMSYSTEM.8]
+ */
+void WINAPI WMMMidiRunOnce16(void)
+{
+ FIXME("(), stub!\n");
+}
+
+/**************************************************************************
+ * DrvOpen [MMSYSTEM.1100]
+ */
+HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
+{
+ return OpenDriver16(lpDriverName, lpSectionName, lParam);
+}
+
+/**************************************************************************
+ * DrvClose [MMSYSTEM.1101]
+ */
+LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
+{
+ return CloseDriver16(hDrv, lParam1, lParam2);
+}
+
+/**************************************************************************
+ * DrvSendMessage [MMSYSTEM.1102]
+ */
+LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
+ LPARAM lParam2)
+{
+ return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
+}
+
+/**************************************************************************
+ * DrvGetModuleHandle [MMSYSTEM.1103]
+ */
+HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
+{
+ return GetDriverModuleHandle16(hDrv);
+}
+
+/**************************************************************************
+ * DrvDefDriverProc [MMSYSTEM.1104]
+ */
+LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
+}
+
+/**************************************************************************
+ * DriverProc [MMSYSTEM.6]
+ */
+LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ TRACE("dwDevID=%08x hDrv=%04x wMsg=%04x dwParam1=%08x dwParam2=%08x\n",
+ dwDevID, hDrv, wMsg, dwParam1, dwParam2);
+
+ return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
+}
+
+/* ###################################################
+ * # TIME #
+ * ###################################################
+ */
+
+/******************************************************************
+ * MMSYSTEM_MMTIME32to16
+ *
+ *
+ */
+void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32)
+{
+ mmt16->wType = mmt32->wType;
+ /* layout of rest is the same for 32/16,
+ * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
+ */
+ memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
+}
+
+/******************************************************************
+ * MMSYSTEM_MMTIME16to32
+ *
+ *
+ */
+void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16)
+{
+ mmt32->wType = mmt16->wType;
+ /* layout of rest is the same for 32/16,
+ * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
+ */
+ memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
+}
+
+/**************************************************************************
+ * timeGetSystemTime [MMSYSTEM.601]
+ */
+MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
+{
+ if (wSize >= sizeof(*lpTime)) {
+ lpTime->wType = TIME_MS;
+ lpTime->u.ms = GetTickCount();
+
+ TRACE("=> %u\n", lpTime->u.ms);
+ }
+
+ return 0;
+}
+
+struct timer_entry {
+ struct list entry;
+ UINT id;
+ LPTIMECALLBACK16 func16;
+ DWORD user;
+};
+
+static struct list timer_list = LIST_INIT(timer_list);
+
+static void CALLBACK timeCB3216(UINT id, UINT uMsg, DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2)
+{
+ struct timer_entry* te = (void*)user;
+ WORD args[8];
+ DWORD ret;
+
+ args[7] = LOWORD(id);
+ args[6] = LOWORD(uMsg);
+ args[5] = HIWORD(te->user);
+ args[4] = LOWORD(te->user);
+ args[3] = HIWORD(dw1);
+ args[2] = LOWORD(dw2);
+ args[1] = HIWORD(dw2);
+ args[0] = LOWORD(dw2);
+ WOWCallback16Ex((DWORD)te->func16, WCB16_PASCAL, sizeof(args), args, &ret);
+}
+
+/**************************************************************************
+ * timeSetEvent [MMSYSTEM.602]
+ */
+MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
+ DWORD dwUser, UINT16 wFlags)
+{
+ MMRESULT16 id;
+ struct timer_entry* te;
+
+ switch (wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE))
+ {
+ case TIME_CALLBACK_EVENT_SET:
+ case TIME_CALLBACK_EVENT_PULSE:
+ id = timeSetEvent(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags);
+ break;
+ case TIME_CALLBACK_FUNCTION:
+ te = HeapAlloc(GetProcessHeap(), 0, sizeof(*te));
+ if (!te) return 0;
+ te->func16 = lpFunc;
+ te->user = dwUser;
+ id = te->id = timeSetEvent(wDelay, wResol, timeCB3216, (DWORD_PTR)te, wFlags);
+ if (id)
+ {
+ EnterCriticalSection(&mmdrv_cs);
+ list_add_tail(&timer_list, &te->entry);
+ LeaveCriticalSection(&mmdrv_cs);
+ }
+ else HeapFree(GetProcessHeap(), 0, te);
+ break;
+ default:
+ id = 0;
+ break;
+ }
+ return id;
+}
+
+/**************************************************************************
+ * timeKillEvent [MMSYSTEM.603]
+ */
+MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
+{
+ MMRESULT16 ret = timeKillEvent(wID);
+ struct timer_entry* te;
+
+ if (ret == TIMERR_NOERROR)
+ {
+ EnterCriticalSection(&mmdrv_cs);
+ LIST_FOR_EACH_ENTRY(te, &timer_list, struct timer_entry, entry)
+ {
+ if (wID == te->id)
+ {
+ list_remove(&te->entry);
+ HeapFree(GetProcessHeap(), 0, te);
+ break;
+ }
+ }
+ LeaveCriticalSection(&mmdrv_cs);
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * timeGetDevCaps [MMSYSTEM.604]
+ */
+MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize)
+{
+ TIMECAPS caps;
+ MMRESULT ret;
+ TRACE("(%p, %u) !\n", lpCaps, wSize);
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = timeGetDevCaps(&caps, sizeof(caps));
+ if (ret == MMSYSERR_NOERROR) {
+ TIMECAPS16 tc16;
+ tc16.wPeriodMin = caps.wPeriodMin;
+ tc16.wPeriodMax = caps.wPeriodMax;
+ memcpy(lpCaps, &tc16, min(wSize, sizeof(tc16)));
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * timeBeginPeriod [MMSYSTEM.605]
+ */
+MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
+{
+ TRACE("(%u) !\n", wPeriod);
+
+ return timeBeginPeriod(wPeriod);
+}
+
+/**************************************************************************
+ * timeEndPeriod [MMSYSTEM.606]
+ */
+MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
+{
+ TRACE("(%u) !\n", wPeriod);
+
+ return timeEndPeriod(wPeriod);
+}
+
+/**************************************************************************
+ * timeGetTime [MMSYSTEM.607]
+ */
+DWORD WINAPI timeGetTime16(void)
+{
+ return timeGetTime();
+}
+
+/* ###################################################
+ * # JOYSTICK #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * joyGetNumDevs [MMSYSTEM.101]
+ */
+UINT16 WINAPI joyGetNumDevs16(void)
+{
+ return joyGetNumDevs();
+}
+
+/**************************************************************************
+ * joyGetDevCaps [MMSYSTEM.102]
+ */
+MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
+{
+ JOYCAPSA jca;
+ MMRESULT ret;
+
+ if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
+
+ ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
+
+ if (ret != JOYERR_NOERROR) return ret;
+ lpCaps->wMid = jca.wMid;
+ lpCaps->wPid = jca.wPid;
+ strcpy(lpCaps->szPname, jca.szPname);
+ lpCaps->wXmin = jca.wXmin;
+ lpCaps->wXmax = jca.wXmax;
+ lpCaps->wYmin = jca.wYmin;
+ lpCaps->wYmax = jca.wYmax;
+ lpCaps->wZmin = jca.wZmin;
+ lpCaps->wZmax = jca.wZmax;
+ lpCaps->wNumButtons = jca.wNumButtons;
+ lpCaps->wPeriodMin = jca.wPeriodMin;
+ lpCaps->wPeriodMax = jca.wPeriodMax;
+
+ if (wSize >= sizeof(JOYCAPS16)) { /* Win95 extensions ? */
+ lpCaps->wRmin = jca.wRmin;
+ lpCaps->wRmax = jca.wRmax;
+ lpCaps->wUmin = jca.wUmin;
+ lpCaps->wUmax = jca.wUmax;
+ lpCaps->wVmin = jca.wVmin;
+ lpCaps->wVmax = jca.wVmax;
+ lpCaps->wCaps = jca.wCaps;
+ lpCaps->wMaxAxes = jca.wMaxAxes;
+ lpCaps->wNumAxes = jca.wNumAxes;
+ lpCaps->wMaxButtons = jca.wMaxButtons;
+ strcpy(lpCaps->szRegKey, jca.szRegKey);
+ strcpy(lpCaps->szOEMVxD, jca.szOEMVxD);
+ }
+
+ return ret;
+}
+
+/**************************************************************************
+ * joyGetPosEx [MMSYSTEM.110]
+ */
+MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
+{
+ return joyGetPosEx(wID, lpInfo);
+}
+
+/**************************************************************************
+ * joyGetPos [MMSYSTEM.103]
+ */
+MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
+{
+ JOYINFO ji;
+ MMRESULT ret;
+
+ TRACE("(%d, %p);\n", wID, lpInfo);
+
+ if ((ret = joyGetPos(wID, &ji)) == JOYERR_NOERROR) {
+ lpInfo->wXpos = ji.wXpos;
+ lpInfo->wYpos = ji.wYpos;
+ lpInfo->wZpos = ji.wZpos;
+ lpInfo->wButtons = ji.wButtons;
+ }
+ return ret;
+}
+
+/**************************************************************************
+ * joyGetThreshold [MMSYSTEM.104]
+ */
+MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
+{
+ UINT t;
+ MMRESULT ret;
+
+ ret = joyGetThreshold(wID, &t);
+ if (ret == JOYERR_NOERROR)
+ *lpThreshold = t;
+ return ret;
+}
+
+/**************************************************************************
+ * joyReleaseCapture [MMSYSTEM.105]
+ */
+MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
+{
+ return joyReleaseCapture(wID);
+}
+
+/**************************************************************************
+ * joySetCapture [MMSYSTEM.106]
+ */
+MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged)
+{
+ return joySetCapture(HWND_32(hWnd), wID, wPeriod, bChanged);
+}
+
+/**************************************************************************
+ * joySetThreshold [MMSYSTEM.107]
+ */
+MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
+{
+ return joySetThreshold(wID,wThreshold);
+}
+
+/**************************************************************************
+ * joySetCalibration [MMSYSTEM.109]
+ */
+MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
+{
+ FIXME("(%04X): stub.\n", wID);
+ return JOYERR_NOCANDO;
+}
diff --git a/dlls/mmsystem.dll16/mmsystem.dll16.spec b/dlls/mmsystem.dll16/mmsystem.dll16.spec
new file mode 100644
index 0000000..66d1e9b
--- /dev/null
+++ b/dlls/mmsystem.dll16/mmsystem.dll16.spec
@@ -0,0 +1,176 @@
+1 pascal WEP(word word word ptr) MMSYSTEM_WEP
+2 pascal sndPlaySound(ptr word) sndPlaySound16
+3 pascal PlaySound(ptr word long) PlaySound16
+4 pascal DllEntryPoint(long word word word long word) MMSYSTEM_LibMain
+5 pascal mmsystemGetVersion() mmsystemGetVersion16
+6 pascal DriverProc(long word word long long) DriverProc16
+8 pascal WMMMidiRunOnce() WMMMidiRunOnce16
+30 pascal -ret16 OutputDebugStr(str) OutputDebugStr16
+31 pascal DriverCallback(long word word word long long long) DriverCallback16
+32 pascal StackEnter() StackEnter16
+33 pascal StackLeave() StackLeave16
+34 stub MMDRVINSTALL
+101 pascal joyGetNumDevs() joyGetNumDevs16
+102 pascal joyGetDevCaps(word ptr word) joyGetDevCaps16
+103 pascal joyGetPos(word ptr) joyGetPos16
+104 pascal joyGetThreshold(word ptr) joyGetThreshold16
+105 pascal joyReleaseCapture(word) joyReleaseCapture16
+106 pascal joySetCapture(word word word word) joySetCapture16
+107 pascal joySetThreshold(word word) joySetThreshold16
+109 pascal joySetCalibration(word) joySetCalibration16
+110 pascal joyGetPosEx(word ptr) joyGetPosEx16
+111 stub JOYCONFIGCHANGED
+201 pascal midiOutGetNumDevs() midiOutGetNumDevs16
+202 pascal midiOutGetDevCaps(word ptr word) midiOutGetDevCaps16
+203 pascal midiOutGetErrorText(word ptr word) midiOutGetErrorText16
+204 pascal midiOutOpen(ptr word long long long) midiOutOpen16
+205 pascal midiOutClose(word) midiOutClose16
+206 pascal midiOutPrepareHeader(word segptr word) midiOutPrepareHeader16
+207 pascal midiOutUnprepareHeader(word segptr word) midiOutUnprepareHeader16
+208 pascal midiOutShortMsg(word long) midiOutShortMsg16
+209 pascal midiOutLongMsg(word segptr word) midiOutLongMsg16
+210 pascal midiOutReset(word) midiOutReset16
+211 pascal midiOutGetVolume(word ptr) midiOutGetVolume16
+212 pascal midiOutSetVolume(word long) midiOutSetVolume16
+213 pascal midiOutCachePatches(word word ptr word) midiOutCachePatches16
+214 pascal midiOutCacheDrumPatches(word word ptr word) midiOutCacheDrumPatches16
+215 pascal midiOutGetID(word ptr) midiOutGetID16
+216 pascal midiOutMessage(word word long long) midiOutMessage16
+250 pascal midiStreamProperty(word ptr long) midiStreamProperty16
+251 pascal midiStreamOpen(ptr ptr long long long long) midiStreamOpen16
+252 pascal midiStreamClose(word) midiStreamClose16
+253 pascal midiStreamPosition(word ptr word) midiStreamPosition16
+254 pascal midiStreamOut(word ptr word) midiStreamOut16
+255 pascal midiStreamPause(word) midiStreamPause16
+256 pascal midiStreamRestart(word) midiStreamRestart16
+257 pascal midiStreamStop(word) midiStreamStop16
+301 pascal midiInGetNumDevs() midiInGetNumDevs16
+302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16
+303 pascal midiInGetErrorText(word ptr word) midiOutGetErrorText16
+304 pascal midiInOpen(ptr word long long long) midiInOpen16
+305 pascal midiInClose(word) midiInClose16
+306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16
+307 pascal midiInUnprepareHeader(word segptr word) midiInUnprepareHeader16
+308 pascal midiInAddBuffer(word segptr word) midiInAddBuffer16
+309 pascal midiInStart(word) midiInStart16
+310 pascal midiInStop(word) midiInStop16
+311 pascal midiInReset(word) midiInReset16
+312 pascal midiInGetID(word ptr) midiInGetID16
+313 pascal midiInMessage(word word long long) midiInMessage16
+350 pascal auxGetNumDevs() auxGetNumDevs16
+351 pascal auxGetDevCaps(word ptr word) auxGetDevCaps16
+352 pascal auxGetVolume(word ptr) auxGetVolume16
+353 pascal auxSetVolume(word long) auxSetVolume16
+354 pascal auxOutMessage(word word long long) auxOutMessage16
+401 pascal waveOutGetNumDevs() waveOutGetNumDevs16
+402 pascal waveOutGetDevCaps(word ptr word) waveOutGetDevCaps16
+403 pascal waveOutGetErrorText(word ptr word) waveOutGetErrorText16
+404 pascal waveOutOpen(ptr word ptr long long long) waveOutOpen16
+405 pascal waveOutClose(word) waveOutClose16
+406 pascal waveOutPrepareHeader(word segptr word) waveOutPrepareHeader16
+407 pascal waveOutUnprepareHeader(word segptr word) waveOutUnprepareHeader16
+408 pascal waveOutWrite(word segptr word) waveOutWrite16
+409 pascal waveOutPause(word) waveOutPause16
+410 pascal waveOutRestart(word) waveOutRestart16
+411 pascal waveOutReset(word) waveOutReset16
+412 pascal waveOutGetPosition(word ptr word) waveOutGetPosition16
+413 pascal waveOutGetPitch(word ptr) waveOutGetPitch16
+414 pascal waveOutSetPitch(word long) waveOutSetPitch16
+415 pascal waveOutGetVolume(word ptr) waveOutGetVolume16
+416 pascal waveOutSetVolume(word long) waveOutSetVolume16
+417 pascal waveOutGetPlaybackRate(word ptr) waveOutGetPlaybackRate16
+418 pascal waveOutSetPlaybackRate(word long) waveOutSetPlaybackRate16
+419 pascal waveOutBreakLoop(word) waveOutBreakLoop16
+420 pascal waveOutGetID(word ptr) waveOutGetID16
+421 pascal waveOutMessage(word word long long) waveOutMessage16
+501 pascal waveInGetNumDevs() waveInGetNumDevs16
+502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16
+503 pascal waveInGetErrorText(word ptr word) waveOutGetErrorText16
+504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16
+505 pascal waveInClose(word) waveInClose16
+506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16
+507 pascal waveInUnprepareHeader(word segptr word) waveInUnprepareHeader16
+508 pascal waveInAddBuffer(word segptr word) waveInAddBuffer16
+509 pascal waveInStart(word) waveInStart16
+510 pascal waveInStop(word) waveInStop16
+511 pascal waveInReset(word) waveInReset16
+512 pascal waveInGetPosition(word ptr word) waveInGetPosition16
+513 pascal waveInGetID(word ptr) waveInGetID16
+514 pascal waveInMessage(word word long long) waveInMessage16
+601 pascal timeGetSystemTime(ptr word) timeGetSystemTime16
+602 pascal timeSetEvent(word word segptr long word) timeSetEvent16
+603 pascal timeKillEvent(word) timeKillEvent16
+604 pascal timeGetDevCaps(ptr word) timeGetDevCaps16
+605 pascal timeBeginPeriod(word) timeBeginPeriod16
+606 pascal timeEndPeriod(word) timeEndPeriod16
+607 pascal timeGetTime() timeGetTime16
+701 pascal mciSendCommand(word word long long) mciSendCommand16
+702 pascal mciSendString(str ptr word word) mciSendString16
+703 pascal mciGetDeviceID(ptr) mciGetDeviceID16
+705 pascal mciLoadCommandResource(word str word) mciLoadCommandResource16
+706 pascal mciGetErrorString(long ptr word) mciGetErrorString16
+707 pascal mciSetDriverData(word long) mciSetDriverData16
+708 pascal mciGetDriverData(word) mciGetDriverData16
+710 pascal mciDriverYield(word) mciDriverYield16
+711 pascal mciDriverNotify(word word word) mciDriverNotify16
+712 pascal mciExecute(ptr) mciExecute16
+713 pascal mciFreeCommandResource(word) mciFreeCommandResource16
+714 pascal mciSetYieldProc(word ptr long) mciSetYieldProc16
+715 pascal mciGetDeviceIDFromElementID(long ptr) mciGetDeviceIDFromElementID16
+716 pascal mciGetYieldProc(word ptr) mciGetYieldProc16
+717 pascal mciGetCreatorTask(word) mciGetCreatorTask16
+800 pascal mixerGetNumDevs() mixerGetNumDevs16
+801 pascal mixerGetDevCaps(word ptr word) mixerGetDevCaps16
+802 pascal mixerOpen(ptr word long long long) mixerOpen16
+803 pascal mixerClose(word) mixerClose16
+804 pascal mixerMessage(word word long long) mixerMessage16
+805 pascal mixerGetLineInfo(word ptr long) mixerGetLineInfo16
+806 pascal mixerGetID(word ptr long) mixerGetID16
+807 pascal mixerGetLineControls(word ptr long) mixerGetLineControls16
+808 pascal mixerGetControlDetails(word ptr long) mixerGetControlDetails16
+809 pascal mixerSetControlDetails(word ptr long) mixerSetControlDetails16
+900 pascal mmTaskCreate(long ptr long) mmTaskCreate16
+902 pascal mmTaskBlock(word) mmTaskBlock16
+903 pascal mmTaskSignal(word) mmTaskSignal16
+904 pascal -ret16 mmGetCurrentTask() mmGetCurrentTask16
+905 pascal mmTaskYield() mmTaskYield16
+1100 pascal DrvOpen(str str long) DrvOpen16
+1101 pascal DrvClose(word long long) DrvClose16
+1102 pascal DrvSendMessage(word word long long) DrvSendMessage16
+1103 pascal DrvGetModuleHandle(word) DrvGetModuleHandle16
+1104 pascal DrvDefDriverProc(long word word long long) DrvDefDriverProc16
+1120 pascal mmThreadCreate(segptr ptr long long) mmThreadCreate16
+1121 pascal mmThreadSignal(word) mmThreadSignal16
+1122 pascal mmThreadBlock(word) mmThreadBlock16
+1123 pascal mmThreadIsCurrent(word) mmThreadIsCurrent16
+1124 pascal mmThreadIsValid(word) mmThreadIsValid16
+1125 pascal mmThreadGetTask(word) mmThreadGetTask16
+1150 pascal mmShowMMCPLPropertySheet(word str str str) mmShowMMCPLPropertySheet16
+
+1210 pascal mmioOpen(str ptr long) mmioOpen16
+1211 pascal mmioClose(word word) mmioClose16
+1212 pascal mmioRead(word ptr long) mmioRead16
+1213 pascal mmioWrite(word ptr long) mmioWrite16
+1214 pascal mmioSeek(word long word) mmioSeek16
+1215 pascal mmioGetInfo(word ptr word) mmioGetInfo16
+1216 pascal mmioSetInfo(word ptr word) mmioSetInfo16
+1217 pascal mmioSetBuffer(word segptr long word) mmioSetBuffer16
+1218 pascal mmioFlush(word word) mmioFlush16
+1219 pascal mmioAdvance(word ptr word) mmioAdvance16
+1220 pascal mmioStringToFOURCC(str word) mmioStringToFOURCC16
+1221 pascal mmioInstallIOProc(long ptr long) mmioInstallIOProc16
+1222 pascal mmioSendMessage(word word long long) mmioSendMessage16
+1223 pascal mmioDescend(word ptr ptr word) mmioDescend16
+1224 pascal mmioAscend(word ptr word) mmioAscend16
+1225 pascal mmioCreateChunk(word ptr word) mmioCreateChunk16
+1226 pascal mmioRename(ptr ptr ptr long) mmioRename16
+
+#2000 stub WINMMF_THUNKDATA16
+#2001 stub RING3_DEVLOADER
+#2002 stub WINMMTILEBUFFER
+#2003 stub WINMMUNTILEBUFFER
+#2005 stub MCIGETTHUNKTABLE
+#2006 stub WINMMSL_THUNKDATA16
+
+# these are Wine only exported functions. Is there another way to do it ?
+2047 pascal __wine_mmThreadEntryPoint(long) WINE_mmThreadEntryPoint
diff --git a/dlls/mmsystem.dll16/winemm16.h b/dlls/mmsystem.dll16/winemm16.h
new file mode 100644
index 0000000..2435e90
--- /dev/null
+++ b/dlls/mmsystem.dll16/winemm16.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright 1998, Luiz Otavio L. Zorzella
+ * 1999, Eric Pouech
+ *
+ * Purpose: multimedia declarations (internal to WINMM & MMSYSTEM DLLs)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "wine/mmsystem16.h"
+#include "wownt32.h"
+
+/* mmsystem (16 bit files) only functions */
+void MMDRV_Init16(void);
+void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16);
+void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32);
+
+typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
+
+/* HANDLE16 -> HANDLE conversions */
+#define HDRVR_32(h16) ((HDRVR)(ULONG_PTR)(h16))
+#define HMIDI_32(h16) ((HMIDI)(ULONG_PTR)(h16))
+#define HMIDIIN_32(h16) ((HMIDIIN)(ULONG_PTR)(h16))
+#define HMIDIOUT_32(h16) ((HMIDIOUT)(ULONG_PTR)(h16))
+#define HMIDISTRM_32(h16) ((HMIDISTRM)(ULONG_PTR)(h16))
+#define HMIXER_32(h16) ((HMIXER)(ULONG_PTR)(h16))
+#define HMIXEROBJ_32(h16) ((HMIXEROBJ)(ULONG_PTR)(h16))
+#define HMMIO_32(h16) ((HMMIO)(ULONG_PTR)(h16))
+#define HWAVE_32(h16) ((HWAVE)(ULONG_PTR)(h16))
+#define HWAVEIN_32(h16) ((HWAVEIN)(ULONG_PTR)(h16))
+#define HWAVEOUT_32(h16) ((HWAVEOUT)(ULONG_PTR)(h16))
+
+/* HANDLE -> HANDLE16 conversions */
+#define HDRVR_16(h32) (LOWORD(h32))
+#define HMIDI_16(h32) (LOWORD(h32))
+#define HMIDIIN_16(h32) (LOWORD(h32))
+#define HMIDIOUT_16(h32) (LOWORD(h32))
+#define HMIDISTRM_16(h32) (LOWORD(h32))
+#define HMIXER_16(h32) (LOWORD(h32))
+#define HMIXEROBJ_16(h32) (LOWORD(h32))
+#define HMMIO_16(h32) (LOWORD(h32))
+#define HWAVE_16(h32) (LOWORD(h32))
+#define HWAVEIN_16(h32) (LOWORD(h32))
+#define HWAVEOUT_16(h32) (LOWORD(h32))
+
+typedef enum {
+ MMSYSTEM_MAP_NOMEM, /* ko, memory problem */
+ MMSYSTEM_MAP_MSGERROR, /* ko, unknown message */
+ MMSYSTEM_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
+ MMSYSTEM_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
+} MMSYSTEM_MapType;
+
+extern CRITICAL_SECTION mmdrv_cs;
+
+enum MMSYSTEM_DriverType
+{
+ MMSYSTDRV_MIXER,
+ MMSYSTDRV_MIDIIN,
+ MMSYSTDRV_MIDIOUT,
+ MMSYSTDRV_WAVEIN,
+ MMSYSTDRV_WAVEOUT,
+ MMSYSTDRV_MAX
+};
+
+extern struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD pfn16, enum MMSYSTEM_DriverType kind);
+extern void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk);
+extern void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h);
+extern void MMSYSTDRV_CloseHandle(void* h);
+extern DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2);
+
+#define WINE_MMTHREAD_CREATED 0x4153494C /* "BSIL" */
+#define WINE_MMTHREAD_DELETED 0xDEADDEAD
+
+typedef struct {
+ DWORD dwSignature; /* 00 "BSIL" when ok, 0xDEADDEAD when being deleted */
+ DWORD dwCounter; /* 04 > 1 when in mmThread functions */
+ HANDLE hThread; /* 08 hThread */
+ DWORD dwThreadID; /* 0C */
+ DWORD fpThread; /* 10 address of thread proc (segptr or lin depending on dwFlags) */
+ DWORD dwThreadPmt; /* 14 parameter to be passed upon thread creation to fpThread */
+ LONG dwSignalCount; /* 18 counter used for signaling */
+ HANDLE hEvent; /* 1C event */
+ HANDLE hVxD; /* 20 return from OpenVxDHandle */
+ DWORD dwStatus; /* 24 0x00, 0x10, 0x20, 0x30 */
+ DWORD dwFlags; /* 28 dwFlags upon creation */
+ UINT16 hTask; /* 2C handle to created task */
+} WINE_MMTHREAD;
diff --git a/dlls/winmm/Makefile.in b/dlls/winmm/Makefile.in
index 416b56b..0848ca5 100644
--- a/dlls/winmm/Makefile.in
+++ b/dlls/winmm/Makefile.in
@@ -17,15 +17,6 @@ C_SRCS = \
time.c \
winmm.c
-C_SRCS16 = \
- mci16.c \
- message16.c \
- mmio16.c \
- mmsystem.c
-
-SPEC_SRCS16 = \
- mmsystem.spec
-
RC_SRCS = \
winmm_Cs.rc \
winmm_Da.rc \
diff --git a/dlls/winmm/mci16.c b/dlls/winmm/mci16.c
deleted file mode 100644
index 75d7202..0000000
--- a/dlls/winmm/mci16.c
+++ /dev/null
@@ -1,760 +0,0 @@
-/*
- * MMSYSTEM functions
- *
- * Copyright 1993 Martin Ayotte
- * 1998-2003,2009 Eric Pouech
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include <stdarg.h>
-#include <string.h>
-#include <stdio.h>
-
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-#include "windef.h"
-#include "winbase.h"
-#include "mmsystem.h"
-#include "winternl.h"
-#include "wownt32.h"
-#include "winnls.h"
-
-#include "wine/winuser16.h"
-#include "winemm16.h"
-#include "digitalv.h"
-
-#include "wine/debug.h"
-
-WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
-
-/**************************************************************************
- * MCI_MessageToString [internal]
- */
-static const char* MCI_MessageToString(UINT wMsg)
-{
- static char buffer[100];
-
-#define CASE(s) case (s): return #s
-
- switch (wMsg) {
- CASE(DRV_LOAD);
- CASE(DRV_ENABLE);
- CASE(DRV_OPEN);
- CASE(DRV_CLOSE);
- CASE(DRV_DISABLE);
- CASE(DRV_FREE);
- CASE(DRV_CONFIGURE);
- CASE(DRV_QUERYCONFIGURE);
- CASE(DRV_INSTALL);
- CASE(DRV_REMOVE);
- CASE(DRV_EXITSESSION);
- CASE(DRV_EXITAPPLICATION);
- CASE(DRV_POWER);
- CASE(MCI_BREAK);
- CASE(MCI_CLOSE);
- CASE(MCI_CLOSE_DRIVER);
- CASE(MCI_COPY);
- CASE(MCI_CUE);
- CASE(MCI_CUT);
- CASE(MCI_DELETE);
- CASE(MCI_ESCAPE);
- CASE(MCI_FREEZE);
- CASE(MCI_PAUSE);
- CASE(MCI_PLAY);
- CASE(MCI_GETDEVCAPS);
- CASE(MCI_INFO);
- CASE(MCI_LOAD);
- CASE(MCI_OPEN);
- CASE(MCI_OPEN_DRIVER);
- CASE(MCI_PASTE);
- CASE(MCI_PUT);
- CASE(MCI_REALIZE);
- CASE(MCI_RECORD);
- CASE(MCI_RESUME);
- CASE(MCI_SAVE);
- CASE(MCI_SEEK);
- CASE(MCI_SET);
- CASE(MCI_SPIN);
- CASE(MCI_STATUS);
- CASE(MCI_STEP);
- CASE(MCI_STOP);
- CASE(MCI_SYSINFO);
- CASE(MCI_UNFREEZE);
- CASE(MCI_UPDATE);
- CASE(MCI_WHERE);
- CASE(MCI_WINDOW);
- /* constants for digital video */
- CASE(MCI_CAPTURE);
- CASE(MCI_MONITOR);
- CASE(MCI_RESERVE);
- CASE(MCI_SETAUDIO);
- CASE(MCI_SIGNAL);
- CASE(MCI_SETVIDEO);
- CASE(MCI_QUALITY);
- CASE(MCI_LIST);
- CASE(MCI_UNDO);
- CASE(MCI_CONFIGURE);
- CASE(MCI_RESTORE);
-#undef CASE
- default:
- sprintf(buffer, "MCI_<<%04X>>", wMsg);
- return buffer;
- }
-}
-
-static LPWSTR MCI_strdupAtoW( LPCSTR str )
-{
- LPWSTR ret;
- INT len;
-
- if (!str) return NULL;
- len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
- ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
- if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
- return ret;
-}
-
-/**************************************************************************
- * MCI_MapMsg16To32W [internal]
- */
-static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
-{
- if (*lParam == 0)
- return MMSYSTEM_MAP_OK;
- /* FIXME: to add also (with seg/linear modifications to do):
- * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
- * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
- */
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- case MCI_CONFIGURE:
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS: /* FIXME: is wrong for digital video */
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- *lParam = (DWORD)MapSL(*lParam);
- return MMSYSTEM_MAP_OK;
- case MCI_WINDOW:
- /* in fact, I would also need the dwFlags... to see
- * which members of lParam are effectively used
- */
- *lParam = (DWORD)MapSL(*lParam);
- FIXME("Current mapping may be wrong\n");
- break;
- case MCI_BREAK:
- {
- LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
- LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
-
- if (mbp32) {
- mbp32->dwCallback = mbp16->dwCallback;
- mbp32->nVirtKey = mbp16->nVirtKey;
- mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)mbp32;
- }
- return MMSYSTEM_MAP_OKMEM;
- case MCI_ESCAPE:
- {
- LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
- LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
-
- if (mvep32w) {
- mvep32w->dwCallback = mvep16->dwCallback;
- mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)mvep32w;
- }
- return MMSYSTEM_MAP_OKMEM;
- case MCI_INFO:
- {
- LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
- LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
-
- /* FIXME this is wrong if device is of type
- * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
- */
- if (mip32w) {
- *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
- mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
- mip32w->dwCallback = mip16->dwCallback;
- mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
- mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)mip32w;
- }
- return MMSYSTEM_MAP_OKMEM;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- {
- LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
- LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
-
- if (mop32w) {
- *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
- mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
- mop32w->dwCallback = mop16->dwCallback;
- mop32w->wDeviceID = mop16->wDeviceID;
- if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
- mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
- else
- mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
- if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
- mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
- else
- mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
- if( ( dwFlags & MCI_OPEN_ALIAS))
- mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
- else
- mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
- /* copy extended information if any...
- * FIXME: this may seg fault if initial structure does not contain them and
- * the reads after msip16 fail under LDT limits...
- * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
- * should not take care of extended parameters, and should be used by MCI_Open
- * to fetch uDevType. When, this is known, the mapping for sending the
- * MCI_OPEN_DRIVER shall be done depending on uDevType.
- */
- memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)mop32w;
- }
- return MMSYSTEM_MAP_OKMEM;
- case MCI_SYSINFO:
- {
- LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
- LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
-
- if (msip32w) {
- *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
- msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
- msip32w->dwCallback = msip16->dwCallback;
- msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
- msip32w->dwRetSize = msip16->dwRetSize;
- msip32w->dwNumber = msip16->dwNumber;
- msip32w->wDeviceType = msip16->wDeviceType;
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)msip32w;
- }
- return MMSYSTEM_MAP_OKMEM;
- case MCI_SOUND:
- {
- LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
- LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
-
- if (mbp32) {
- mbp32->dwCallback = mbp16->dwCallback;
- mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
- } else {
- return MMSYSTEM_MAP_NOMEM;
- }
- *lParam = (DWORD)mbp32;
- }
- return MMSYSTEM_MAP_OKMEM;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME("This is a hack\n");
- return MMSYSTEM_MAP_OK;
- default:
- FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
- }
- return MMSYSTEM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MCI_UnMapMsg16To32W [internal]
- */
-static MMSYSTEM_MapType MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
-{
- switch (wMsg) {
- /* case MCI_CAPTURE */
- case MCI_CLOSE:
- case MCI_CLOSE_DRIVER:
- case MCI_CONFIGURE:
- case MCI_COPY:
- case MCI_CUE:
- case MCI_CUT:
- case MCI_DELETE:
- case MCI_FREEZE:
- case MCI_GETDEVCAPS:
- /* case MCI_INDEX: */
- /* case MCI_MARK: */
- /* case MCI_MONITOR: */
- case MCI_PASTE:
- case MCI_PAUSE:
- case MCI_PLAY:
- case MCI_PUT:
- case MCI_REALIZE:
- case MCI_RECORD:
- case MCI_RESUME:
- case MCI_SEEK:
- case MCI_SET:
- /* case MCI_SETTIMECODE:*/
- /* case MCI_SIGNAL:*/
- case MCI_SPIN:
- case MCI_STATUS:
- case MCI_STEP:
- case MCI_STOP:
- /* case MCI_UNDO: */
- case MCI_UNFREEZE:
- case MCI_UPDATE:
- case MCI_WHERE:
- return MMSYSTEM_MAP_OK;
-
- case MCI_WINDOW:
- /* FIXME ?? see Map function */
- return MMSYSTEM_MAP_OK;
-
- case MCI_BREAK:
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- return MMSYSTEM_MAP_OK;
- case MCI_ESCAPE:
- if (lParam) {
- LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
- HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- }
- return MMSYSTEM_MAP_OK;
- case MCI_INFO:
- if (lParam) {
- LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
- LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
-
- WideCharToMultiByte(CP_ACP, 0,
- mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
- MapSL(mip16->lpstrReturn), mip16->dwRetSize,
- NULL, NULL);
- HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- }
- return MMSYSTEM_MAP_OK;
- case MCI_SYSINFO:
- if (lParam) {
- LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
- LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
-
- WideCharToMultiByte(CP_ACP, 0,
- msip32w->lpstrReturn, msip32w->dwRetSize,
- MapSL(msip16->lpstrReturn), msip16->dwRetSize,
- NULL, NULL);
- HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- }
- return MMSYSTEM_MAP_OK;
- case MCI_SOUND:
- if (lParam) {
- LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
- HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
- HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
- }
- return MMSYSTEM_MAP_OK;
- case MCI_OPEN:
- case MCI_OPEN_DRIVER:
- if (lParam) {
- LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
- LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
-
- mop16->wDeviceID = mop32w->wDeviceID;
- if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
- HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
- if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
- HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
- if( ( dwFlags & MCI_OPEN_ALIAS))
- HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
- if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
- FIXME("bad free line=%d\n", __LINE__);
- }
- return MMSYSTEM_MAP_OK;
- case DRV_LOAD:
- case DRV_ENABLE:
- case DRV_OPEN:
- case DRV_CLOSE:
- case DRV_DISABLE:
- case DRV_FREE:
- case DRV_CONFIGURE:
- case DRV_QUERYCONFIGURE:
- case DRV_INSTALL:
- case DRV_REMOVE:
- case DRV_EXITSESSION:
- case DRV_EXITAPPLICATION:
- case DRV_POWER:
- FIXME("This is a hack\n");
- return MMSYSTEM_MAP_OK;
- default:
- FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
- }
- return MMSYSTEM_MAP_MSGERROR;
-}
-
-/* ###################################################
- * # MCI #
- * ###################################################
- */
-
-#include <pshpack1.h>
-#define MCI_MAX_THUNKS 32
-
-static struct mci_thunk
-{
- BYTE popl_eax; /* popl %eax (return address) */
- BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
- YIELDPROC16 yield16;
- BYTE pushl_eax; /* pushl %eax */
- BYTE jmp; /* ljmp MCI_Yield1632 */
- DWORD callback;
- MCIDEVICEID id;
-} *MCI_Thunks;
-
-#include <poppack.h>
-
-static CRITICAL_SECTION mci_cs;
-static CRITICAL_SECTION_DEBUG mci_critsect_debug =
-{
- 0, 0, &mci_cs,
- { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
-};
-static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
-
-static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
-{
- WORD args[8];
-
- if (!pfn16)
- {
- UserYield16();
- return 0;
- }
-
- /* 16 bit func, call it */
- TRACE("Function (16 bit) !\n");
-
- args[2] = (MCIDEVICEID16)id;
- args[1] = HIWORD(yield_data);
- args[0] = LOWORD(yield_data);
- return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
-}
-
-/******************************************************************
- * MCI_AddThunk
- *
- */
-static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
-{
- struct mci_thunk* thunk;
-
- if (!MCI_Thunks)
- {
- MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
- PAGE_EXECUTE_READWRITE);
- if (!MCI_Thunks) return NULL;
- for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
- {
- thunk->popl_eax = 0x58; /* popl %eax */
- thunk->pushl_func = 0x68; /* pushl $pfn16 */
- thunk->yield16 = 0;
- thunk->pushl_eax = 0x50; /* pushl %eax */
- thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */
- thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
- thunk->id = 0;
- }
- }
- for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
- {
- if (thunk->yield16 == 0)
- {
- thunk->yield16 = pfn16;
- thunk->id = id;
- return thunk;
- }
- }
- FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
- return NULL;
-}
-
-/******************************************************************
- * MCI_HasThunk
- *
- */
-static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn)
-{
- struct mci_thunk* thunk;
-
- if (!MCI_Thunks) return NULL;
- for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
- {
- if ((YIELDPROC)thunk == pfn) return thunk;
- }
- return NULL;
-}
-
-/**************************************************************************
- * mciSetYieldProc [MMSYSTEM.714]
- */
-BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
-{
- struct mci_thunk* thunk;
- BOOL ret;
-
- TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
-
- if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
- return FALSE;
- ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
- if (!ret) thunk->yield16 = NULL;
- return ret;
-}
-
-/**************************************************************************
- * mciGetYieldProc [MMSYSTEM.716]
- */
-YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
-{
- YIELDPROC yield;
- DWORD data;
- struct mci_thunk* thunk;
-
- TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
-
- yield = mciGetYieldProc(uDeviceID, &data);
- if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
-
- if (lpdwYieldData) *lpdwYieldData = data;
- return thunk->yield16;
-}
-
-/**************************************************************************
- * mciGetErrorString [MMSYSTEM.706]
- */
-BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
-{
- return mciGetErrorStringA(wError, lpstrBuffer, uLength);
-}
-
-/**************************************************************************
- * mciDriverNotify [MMSYSTEM.711]
- */
-BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
-{
- TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
-
- return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
-}
-
-/**************************************************************************
- * mciGetDriverData [MMSYSTEM.708]
- */
-DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
-{
- return mciGetDriverData(uDeviceID);
-}
-
-/**************************************************************************
- * mciSetDriverData [MMSYSTEM.707]
- */
-BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
-{
- return mciSetDriverData(uDeviceID, data);
-}
-
-/**************************************************************************
- * mciSendCommand [MMSYSTEM.701]
- */
-DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
-{
- DWORD dwRet;
- BOOL to32;
- DWORD_PTR dwParam2 = p2;
-
- TRACE("(%04X, %u, %08X, %08lX)\n", wDevID, wMsg, dwParam1, dwParam2);
-
- switch (wMsg) {
- case MCI_CLOSE:
- case MCI_OPEN:
- case MCI_SYSINFO:
- case MCI_BREAK:
- case MCI_SOUND:
- to32 = TRUE;
- break;
- default:
- /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
- * doing 16=>32W, then 32W=>16 conversions.
- * We could directly call the 16bit driver if we had the information.
- */
- to32 = TRUE;
- }
- if (to32) {
- MMSYSTEM_MapType res;
-
- dwRet = MCIERR_INVALID_DEVICE_ID;
-
- switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
- case MMSYSTEM_MAP_MSGERROR:
- TRACE("Not handled yet (%u)\n", wMsg);
- dwRet = MCIERR_DRIVER_INTERNAL;
- break;
- case MMSYSTEM_MAP_NOMEM:
- TRACE("Problem mapping msg=%u from 16 to 32a\n", wMsg);
- dwRet = MCIERR_OUT_OF_MEMORY;
- break;
- case MMSYSTEM_MAP_OK:
- case MMSYSTEM_MAP_OKMEM:
- dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
- if (res == MMSYSTEM_MAP_OKMEM)
- MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2);
- break;
- }
- }
- else
- {
-#if 0
- if (wDevID == MCI_ALL_DEVICE_ID) {
- FIXME("unhandled MCI_ALL_DEVICE_ID\n");
- dwRet = MCIERR_CANNOT_USE_ALL;
- } else {
- dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
- }
-#endif
- }
- if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
- {
- /* free yield thunks, if any */
- unsigned i;
- for (i = 0; i < MCI_MAX_THUNKS; i++)
- {
- if (MCI_Thunks[i].id == wDevID)
- MCI_Thunks[i].yield16 = NULL;
- }
- }
- return dwRet;
-}
-
-/**************************************************************************
- * mciGetDeviceID [MMSYSTEM.703]
- */
-UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
-{
- TRACE("(\"%s\")\n", lpstrName);
-
- return mciGetDeviceIDA(lpstrName);
-}
-
-/**************************************************************************
- * mciGetDeviceIDFromElementID [MMSYSTEM.715]
- */
-UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
-{
- return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
-}
-
-/**************************************************************************
- * mciGetCreatorTask [MMSYSTEM.717]
- */
-HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
-{
- return HTASK_16(mciGetCreatorTask(uDeviceID));
-}
-
-/**************************************************************************
- * mciDriverYield [MMSYSTEM.710]
- */
-UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
-{
- return mciDriverYield(uDeviceID);
-}
-
-/**************************************************************************
- * mciSendString [MMSYSTEM.702]
- */
-DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
- UINT16 uRetLen, HWND16 hwndCallback)
-{
- return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
-}
-
-/**************************************************************************
- * mciLoadCommandResource [MMSYSTEM.705]
- */
-UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
-{
- TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
- return MCI_NO_COMMAND_TABLE;
-}
-
-/**************************************************************************
- * mciFreeCommandResource [MMSYSTEM.713]
- */
-BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
-{
- TRACE("(%04x)!\n", uTable);
-
- return FALSE;
-}
-
-/**************************************************************************
- * mciExecute [MMSYSTEM.712]
- */
-BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
-{
- return mciExecute(lpstrCommand);
-}
diff --git a/dlls/winmm/message16.c b/dlls/winmm/message16.c
deleted file mode 100644
index a43c559..0000000
--- a/dlls/winmm/message16.c
+++ /dev/null
@@ -1,1000 +0,0 @@
-/*
- * MMSYSTEM MCI and low level mapping functions
- *
- * Copyright 1999 Eric Pouech
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include <string.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <assert.h>
-#include "wine/winbase16.h"
-#include "windef.h"
-#include "winbase.h"
-#include "wownt32.h"
-#include "winemm16.h"
-#include "digitalv.h"
-#include "wine/debug.h"
-
-WINE_DEFAULT_DEBUG_CHANNEL(winmm);
-
-/* =================================
- * A U X M A P P E R S
- * ================================= */
-
-/* =================================
- * M I X E R M A P P E R S
- * ================================= */
-
-/**************************************************************************
- * MMSYSTDRV_Mixer_Map16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_Mixer_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- return MMSYSTEM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMSYSTDRV_Mixer_UnMap16To32W [internal]
- */
-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));
-
- 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;
- }
- return ret;
-#endif
- return MMSYSTEM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMSYSTDRV_Mixer_MapCB
- */
-static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
-{
- FIXME("NIY\n");
-}
-
-/* =================================
- * M I D I I N M A P P E R S
- * ================================= */
-
-/**************************************************************************
- * MMSYSTDRV_MidiIn_Map16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_MidiIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- return MMSYSTEM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMSYSTDRV_MidiIn_UnMap16To32W [internal]
- */
-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]
- */
-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 */
-
- case MIM_DATA:
- case MIM_MOREDATA:
- case MIM_ERROR:
- /* 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));
- LPMIDIHDR mh16 = MapSL(segmh16);
-
- *dwParam1 = (DWORD)segmh16;
- mh16->dwFlags = mh32->dwFlags;
- mh16->dwBytesRecorded = mh32->dwBytesRecorded;
- if (mh16->reserved >= sizeof(MIDIHDR))
- mh16->dwOffset = mh32->dwOffset;
- }
- break;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-}
-
-/* =================================
- * M I D I O U T M A P P E R S
- * ================================= */
-
-/**************************************************************************
- * MMSYSTDRV_MidiOut_Map16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_MidiOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- 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;
-
- 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;
-
- 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;
- case MODM_PREPARE:
- {
- LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
- LPMIDIHDR 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;
- /* FIXME: nothing on mh32->lpNext */
- /* could link the mh32->lpNext at this level for memory house keeping */
- mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh16->dwOffset : 0;
- mh16->lpNext = mh32; /* for reuse in unprepare and write */
- /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
- mh16->reserved = *lpParam2;
- *lpParam1 = (DWORD)mh32;
- *lpParam2 = sizeof(MIDIHDR);
-
- ret = MMSYSTEM_MAP_OKMEM;
- } else {
- ret = MMSYSTEM_MAP_NOMEM;
- }
- }
- break;
- case MODM_UNPREPARE:
- case MODM_LONGDATA:
- {
- LPMIDIHDR mh16 = MapSL(*lpParam1);
- LPMIDIHDR mh32 = mh16->lpNext;
-
- *lpParam1 = (DWORD)mh32;
- *lpParam2 = sizeof(MIDIHDR);
- /* 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;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMSYSTDRV_MidiOut_UnMap16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- 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;
-
- 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;
-
- 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;
- case MODM_PREPARE:
- case MODM_UNPREPARE:
- case MODM_LONGDATA:
- {
- LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
- LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
-
- assert(mh16->lpNext == mh32);
- mh16->dwBufferLength = mh32->dwBufferLength;
- mh16->dwBytesRecorded = mh32->dwBytesRecorded;
- mh16->dwUser = mh32->dwUser;
- mh16->dwFlags = mh32->dwFlags;
- if (mh16->reserved >= sizeof(MIDIHDR))
- mh16->dwOffset = mh32->dwOffset;
-
- 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;
- }
- return ret;
-}
-
-/******************************************************************
- * MMSYSTDRV_MidiOut_MapCB
- */
-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;
- case MOM_DONE:
- {
- /* initial map is: 16 => 32 */
- LPMIDIHDR mh32 = (LPMIDIHDR)(*dwParam1);
- SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
- LPMIDIHDR mh16 = MapSL(segmh16);
-
- *dwParam1 = (DWORD)segmh16;
- mh16->dwFlags = mh32->dwFlags;
- if (mh16->reserved >= sizeof(MIDIHDR))
- mh16->dwOffset = mh32->dwOffset;
- }
- break;
- case MOM_POSITIONCB:
- FIXME("NIY\n");
- /* FIXME: would require to recreate a 16bit MIDIHDR here */
- *dwParam1 = *dwParam2 = 0;
- break;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-}
-
-/* =================================
- * W A V E I N M A P P E R S
- * ================================= */
-
-/**************************************************************************
- * MMSYSTDRV_WaveIn_Map16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_WaveIn_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- 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;
- case WIDM_OPEN:
- case WIDM_CLOSE:
- 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;
- 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;
- 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;
- 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;
- case WIDM_MAPPER_STATUS:
- /* 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;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMSYSTDRV_WaveIn_UnMap16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
-
- switch (wMsg) {
- case WIDM_GETNUMDEVS:
- case WIDM_RESET:
- case WIDM_START:
- case WIDM_STOP:
- case WIDM_MAPPER_STATUS:
- 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;
- 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;
- 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;
- 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->dwBufferLength = wh32->dwBufferLength;
- wh16->dwBytesRecorded = wh32->dwBytesRecorded;
- wh16->dwUser = wh32->dwUser;
- wh16->dwFlags = wh32->dwFlags;
- wh16->dwLoops = wh32->dwLoops;
-
- 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;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMSYSTDRV_WaveIn_MapCB [internal]
- */
-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;
- 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;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-}
-
-/* =================================
- * W A V E O U T M A P P E R S
- * ================================= */
-
-/**************************************************************************
- * MMSYSTDRV_WaveOut_Map16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_WaveOut_Map16To32W (UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
-
- switch (wMsg) {
- /* nothing to do */
- case WODM_BREAKLOOP:
- case WODM_CLOSE:
- case WODM_GETNUMDEVS:
- case WODM_PAUSE:
- case WODM_RESET:
- case WODM_RESTART:
- case WODM_SETPITCH:
- case WODM_SETPLAYBACKRATE:
- case WODM_SETVOLUME:
- 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;
-
- 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;
- 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;
- 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;
- 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;
- case WODM_MAPPER_STATUS:
- *lpParam2 = (DWORD)MapSL(*lpParam2);
- ret = MMSYSTEM_MAP_OK;
- break;
- default:
- FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMSYSTDRV_WaveOut_UnMap16To32W [internal]
- */
-static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- MMSYSTEM_MapType ret = MMSYSTEM_MAP_MSGERROR;
-
- switch (wMsg) {
- /* nothing to do */
- case WODM_BREAKLOOP:
- case WODM_CLOSE:
- case WODM_GETNUMDEVS:
- case WODM_PAUSE:
- case WODM_RESET:
- case WODM_RESTART:
- case WODM_SETPITCH:
- case WODM_SETPLAYBACKRATE:
- case WODM_SETVOLUME:
- case WODM_MAPPER_STATUS:
- 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;
-
- 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;
- 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;
- 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->dwBufferLength = wh32->dwBufferLength;
- wh16->dwBytesRecorded = wh32->dwBytesRecorded;
- wh16->dwUser = wh32->dwUser;
- wh16->dwFlags = wh32->dwFlags;
- wh16->dwLoops = wh32->dwLoops;
-
- 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;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_WaveOut_Callback [internal]
- */
-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;
- 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;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-}
-
-/* ###################################################
- * # 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);
-
-#include <pshpack1.h>
-#define MMSYSTDRV_MAX_THUNKS 32
-
-static struct mmsystdrv_thunk
-{
- BYTE popl_eax; /* popl %eax (return address) */
- BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
- struct mmsystdrv_thunk* this;
- BYTE pushl_eax; /* pushl %eax */
- BYTE jmp; /* ljmp MMDRV_Callback1632 */
- DWORD callback;
- DWORD pfn16;
- void* hMmdrv; /* Handle to 32bit mmdrv object */
- enum MMSYSTEM_DriverType kind;
-} *MMSYSTDRV_Thunks;
-
-#include <poppack.h>
-
-static struct MMSYSTDRV_Type
-{
- MMSYSTDRV_MAPMSG mapmsg16to32W;
- MMSYSTDRV_UNMAPMSG unmapmsg16to32W;
- MMSYSTDRV_MAPCB mapcb;
-} MMSYSTEM_DriversType[MMSYSTDRV_MAX] =
-{
- {MMSYSTDRV_Mixer_Map16To32W, MMSYSTDRV_Mixer_UnMap16To32W, MMSYSTDRV_Mixer_MapCB},
- {MMSYSTDRV_MidiIn_Map16To32W, MMSYSTDRV_MidiIn_UnMap16To32W, MMSYSTDRV_MidiIn_MapCB},
- {MMSYSTDRV_MidiOut_Map16To32W, MMSYSTDRV_MidiOut_UnMap16To32W, MMSYSTDRV_MidiOut_MapCB},
- {MMSYSTDRV_WaveIn_Map16To32W, MMSYSTDRV_WaveIn_UnMap16To32W, MMSYSTDRV_WaveIn_MapCB},
- {MMSYSTDRV_WaveOut_Map16To32W, MMSYSTDRV_WaveOut_UnMap16To32W, MMSYSTDRV_WaveOut_MapCB},
-};
-
-/******************************************************************
- * MMSYSTDRV_Callback3216
- *
- */
-static LRESULT CALLBACK MMSYSTDRV_Callback3216(struct mmsystdrv_thunk* thunk, DWORD uFlags, HDRVR hDev,
- DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
- DWORD_PTR dwParam2)
-{
- assert(thunk->kind < MMSYSTDRV_MAX);
- assert(MMSYSTEM_DriversType[thunk->kind].mapcb);
-
- MMSYSTEM_DriversType[thunk->kind].mapcb(wMsg, &dwUser, &dwParam1, &dwParam2);
-
- if ((uFlags & DCB_TYPEMASK) == DCB_FUNCTION)
- {
- WORD args[8];
- /* 16 bit func, call it */
- TRACE("Function (16 bit) !\n");
-
- args[7] = HDRVR_16(hDev);
- args[6] = wMsg;
- args[5] = HIWORD(dwUser);
- args[4] = LOWORD(dwUser);
- args[3] = HIWORD(dwParam1);
- args[2] = LOWORD(dwParam1);
- args[1] = HIWORD(dwParam2);
- args[0] = LOWORD(dwParam2);
- return WOWCallback16Ex(thunk->pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
- }
- return DriverCallback(thunk->pfn16, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
-}
-
-/******************************************************************
- * MMSYSTDRV_AddThunk
- *
- */
-struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD pfn16, enum MMSYSTEM_DriverType kind)
-{
- struct mmsystdrv_thunk* thunk;
-
- EnterCriticalSection(&mmdrv_cs);
- if (!MMSYSTDRV_Thunks)
- {
- MMSYSTDRV_Thunks = VirtualAlloc(NULL, MMSYSTDRV_MAX_THUNKS * sizeof(*MMSYSTDRV_Thunks),
- MEM_COMMIT, PAGE_EXECUTE_READWRITE);
- if (!MMSYSTDRV_Thunks)
- {
- LeaveCriticalSection(&mmdrv_cs);
- return NULL;
- }
- for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
- {
- thunk->popl_eax = 0x58; /* popl %eax */
- thunk->pushl_func = 0x68; /* pushl $pfn16 */
- thunk->this = thunk;
- thunk->pushl_eax = 0x50; /* pushl %eax */
- thunk->jmp = 0xe9; /* jmp MMDRV_Callback3216 */
- thunk->callback = (char *)MMSYSTDRV_Callback3216 - (char *)(&thunk->callback + 1);
- thunk->pfn16 = 0;
- thunk->hMmdrv = NULL;
- thunk->kind = MMSYSTDRV_MAX;
- }
- }
- for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
- {
- if (thunk->pfn16 == 0 && thunk->hMmdrv == NULL)
- {
- thunk->pfn16 = pfn16;
- thunk->hMmdrv = NULL;
- thunk->kind = kind;
- LeaveCriticalSection(&mmdrv_cs);
- return thunk;
- }
- }
- LeaveCriticalSection(&mmdrv_cs);
- FIXME("Out of mmdrv-thunks. Bump MMDRV_MAX_THUNKS\n");
- return NULL;
-}
-
-/******************************************************************
- * MMSYSTDRV_FindHandle
- *
- * Must be called with lock set
- */
-static void* MMSYSTDRV_FindHandle(void* h)
-{
- struct mmsystdrv_thunk* thunk;
-
- for (thunk = MMSYSTDRV_Thunks; thunk < &MMSYSTDRV_Thunks[MMSYSTDRV_MAX_THUNKS]; thunk++)
- {
- if (thunk->hMmdrv == h)
- {
- if (thunk->kind >= MMSYSTDRV_MAX) FIXME("Kind isn't properly initialized %x\n", thunk->kind);
- return thunk;
- }
- }
- return NULL;
-}
-
-/******************************************************************
- * MMSYSTDRV_SetHandle
- *
- */
-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
- */
-void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk)
-{
- thunk->pfn16 = 0;
- thunk->hMmdrv = NULL;
- thunk->kind = MMSYSTDRV_MAX;
-}
-
-/******************************************************************
- * MMSYSTDRV_CloseHandle
- */
-void MMSYSTDRV_CloseHandle(void* h)
-{
- struct mmsystdrv_thunk* thunk;
-
- EnterCriticalSection(&mmdrv_cs);
- if ((thunk = MMSYSTDRV_FindHandle(h)))
- {
- MMSYSTDRV_DeleteThunk(thunk);
- }
- LeaveCriticalSection(&mmdrv_cs);
-}
-
-/******************************************************************
- * MMSYSTDRV_Message
- */
-DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2)
-{
- struct mmsystdrv_thunk* thunk = MMSYSTDRV_FindHandle(h);
- struct MMSYSTDRV_Type* drvtype;
- MMSYSTEM_MapType map;
- DWORD ret;
-
- if (!thunk) return MMSYSERR_INVALHANDLE;
- drvtype = &MMSYSTEM_DriversType[thunk->kind];
-
- map = drvtype->mapmsg16to32W(msg, ¶m1, ¶m2);
- switch (map) {
- case MMSYSTEM_MAP_NOMEM:
- ret = MMSYSERR_NOMEM;
- break;
- case MMSYSTEM_MAP_MSGERROR:
- FIXME("NIY: no conversion yet 16->32 kind=%u msg=%u\n", thunk->kind, msg);
- ret = MMSYSERR_ERROR;
- break;
- case MMSYSTEM_MAP_OK:
- case MMSYSTEM_MAP_OKMEM:
- TRACE("Calling message(msg=%u p1=0x%08lx p2=0x%08lx)\n",
- msg, param1, param2);
- switch (thunk->kind)
- {
- case MMSYSTDRV_MIXER: ret = mixerMessage (h, msg, param1, param2); break;
- case MMSYSTDRV_MIDIIN: ret = midiInMessage (h, msg, param1, param2); break;
- case MMSYSTDRV_MIDIOUT: ret = midiOutMessage(h, msg, param1, param2); break;
- case MMSYSTDRV_WAVEIN: ret = waveInMessage (h, msg, param1, param2); break;
- case MMSYSTDRV_WAVEOUT: ret = waveOutMessage(h, msg, param1, param2); break;
- default: ret = MMSYSERR_INVALHANDLE; break; /* should never be reached */
- }
- if (map == MMSYSTEM_MAP_OKMEM)
- drvtype->unmapmsg16to32W(msg, ¶m1, ¶m2, ret);
- break;
- default:
- FIXME("NIY\n");
- ret = MMSYSERR_NOTSUPPORTED;
- break;
- }
- return ret;
-}
diff --git a/dlls/winmm/mmio16.c b/dlls/winmm/mmio16.c
deleted file mode 100644
index d0e24bc..0000000
--- a/dlls/winmm/mmio16.c
+++ /dev/null
@@ -1,640 +0,0 @@
-/*
- * MMSYSTEM mmio* functions
- *
- * Copyright 1993 Martin Ayotte
- * 1998-2003,2009 Eric Pouech
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include <stdarg.h>
-#include <string.h>
-
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-#include "windef.h"
-#include "winbase.h"
-#include "mmsystem.h"
-#include "winternl.h"
-#include "wownt32.h"
-#include "winnls.h"
-
-#include "wine/winuser16.h"
-#include "winemm16.h"
-
-#include "wine/debug.h"
-
-WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
-
-/* ###################################################
- * # MMIO #
- * ###################################################
- */
-#include <pshpack1.h>
-#define MMIO_MAX_THUNKS 32
-
-static struct mmio_thunk
-{
- BYTE popl_eax; /* popl %eax (return address) */
- BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
- LPMMIOPROC16 pfn16;
- BYTE pushl_eax; /* pushl %eax */
- BYTE jmp; /* ljmp MMIO_Callback1632 */
- DWORD callback;
- HMMIO hMmio; /* Handle to 32bit mmio object */
- SEGPTR segbuffer; /* actual segmented ptr to buffer */
-} *MMIO_Thunks;
-
-#include <poppack.h>
-
-static CRITICAL_SECTION mmio_cs;
-static CRITICAL_SECTION_DEBUG mmio_critsect_debug =
-{
- 0, 0, &mmio_cs,
- { &mmio_critsect_debug.ProcessLocksList, &mmio_critsect_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmio_cs") }
-};
-static CRITICAL_SECTION mmio_cs = { &mmio_critsect_debug, -1, 0, 0, 0, 0 };
-
-/****************************************************************
- * MMIO_Map32To16 [INTERNAL]
- */
-static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2)
-{
- switch (wMsg) {
- case MMIOM_CLOSE:
- case MMIOM_SEEK:
- /* nothing to do */
- break;
- case MMIOM_OPEN:
- case MMIOM_READ:
- case MMIOM_WRITE:
- case MMIOM_WRITEFLUSH:
- *lp1 = MapLS( (void *)*lp1 );
- break;
- case MMIOM_RENAME:
- *lp1 = MapLS( (void *)*lp1 );
- *lp2 = MapLS( (void *)*lp2 );
- break;
- default:
- if (wMsg < MMIOM_USER)
- TRACE("Not a mappable message (%d)\n", wMsg);
- }
- return MMSYSERR_NOERROR;
-}
-
-/****************************************************************
- * MMIO_UnMap32To16 [INTERNAL]
- */
-static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2,
- LPARAM lp1, LPARAM lp2)
-{
- switch (wMsg) {
- case MMIOM_CLOSE:
- case MMIOM_SEEK:
- /* nothing to do */
- break;
- case MMIOM_OPEN:
- case MMIOM_READ:
- case MMIOM_WRITE:
- case MMIOM_WRITEFLUSH:
- UnMapLS( lp1 );
- break;
- case MMIOM_RENAME:
- UnMapLS( lp1 );
- UnMapLS( lp2 );
- break;
- default:
- if (wMsg < MMIOM_USER)
- TRACE("Not a mappable message (%d)\n", wMsg);
- }
- return MMSYSERR_NOERROR;
-}
-
-/******************************************************************
- * MMIO_Callback3216
- *
- *
- */
-static LRESULT MMIO_Callback3216(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage,
- LPARAM lParam1, LPARAM lParam2)
-{
- DWORD result;
- MMIOINFO16 mmioInfo16;
- SEGPTR segmmioInfo16;
- LPARAM lp1 = lParam1, lp2 = lParam2;
- WORD args[7];
-
- if (!cb16) return MMSYSERR_INVALPARAM;
-
- memset(&mmioInfo16, 0, sizeof(MMIOINFO16));
- mmioInfo16.lDiskOffset = lpmmioinfo->lDiskOffset;
- mmioInfo16.adwInfo[0] = lpmmioinfo->adwInfo[0];
- mmioInfo16.adwInfo[1] = lpmmioinfo->adwInfo[1];
- mmioInfo16.adwInfo[2] = lpmmioinfo->adwInfo[2];
- /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */
- if ((result = MMIO_Map32To16(uMessage, &lp1, &lp2)) != MMSYSERR_NOERROR)
- return result;
-
- segmmioInfo16 = MapLS(&mmioInfo16);
- args[6] = HIWORD(segmmioInfo16);
- args[5] = LOWORD(segmmioInfo16);
- args[4] = uMessage;
- args[3] = HIWORD(lp1);
- args[2] = LOWORD(lp1);
- args[1] = HIWORD(lp2);
- args[0] = LOWORD(lp2);
- WOWCallback16Ex( cb16, WCB16_PASCAL, sizeof(args), args, &result );
- UnMapLS(segmmioInfo16);
- MMIO_UnMap32To16(uMessage, lParam1, lParam2, lp1, lp2);
-
- lpmmioinfo->lDiskOffset = mmioInfo16.lDiskOffset;
- lpmmioinfo->adwInfo[0] = mmioInfo16.adwInfo[0];
- lpmmioinfo->adwInfo[1] = mmioInfo16.adwInfo[1];
- lpmmioinfo->adwInfo[2] = mmioInfo16.adwInfo[2];
-
- return result;
-}
-
-/******************************************************************
- * MMIO_AddThunk
- *
- */
-static struct mmio_thunk* MMIO_AddThunk(LPMMIOPROC16 pfn16, HPSTR segbuf)
-{
- struct mmio_thunk* thunk;
-
- if (!MMIO_Thunks)
- {
- MMIO_Thunks = VirtualAlloc(NULL, MMIO_MAX_THUNKS * sizeof(*MMIO_Thunks), MEM_COMMIT,
- PAGE_EXECUTE_READWRITE);
- if (!MMIO_Thunks) return NULL;
- for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
- {
- thunk->popl_eax = 0x58; /* popl %eax */
- thunk->pushl_func = 0x68; /* pushl $pfn16 */
- thunk->pfn16 = 0;
- thunk->pushl_eax = 0x50; /* pushl %eax */
- thunk->jmp = 0xe9; /* jmp MMIO_Callback3216 */
- thunk->callback = (char *)MMIO_Callback3216 - (char *)(&thunk->callback + 1);
- thunk->hMmio = NULL;
- thunk->segbuffer = 0;
- }
- }
- for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
- {
- if (thunk->pfn16 == 0 && thunk->hMmio == NULL)
- {
- thunk->pfn16 = pfn16;
- thunk->hMmio = NULL;
- thunk->segbuffer = (SEGPTR)segbuf;
- return thunk;
- }
- }
- FIXME("Out of mmio-thunks. Bump MMIO_MAX_THUNKS\n");
- return NULL;
-}
-
-/******************************************************************
- * MMIO_HasThunk
- *
- */
-static struct mmio_thunk* MMIO_HasThunk(HMMIO hmmio)
-{
- struct mmio_thunk* thunk;
-
- if (!MMIO_Thunks) return NULL;
- for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
- {
- if (thunk->hMmio == hmmio) return thunk;
- }
- return NULL;
-}
-
-/******************************************************************
- * MMIO_SetSegmentedBuffer
- *
- */
-static void MMIO_SetSegmentedBuffer(struct mmio_thunk* thunk, SEGPTR ptr, BOOL release)
-{
- if (release) UnMapLS(thunk->segbuffer);
- thunk->segbuffer = ptr;
-}
-
-/**************************************************************************
- * mmioOpen [MMSYSTEM.1210]
- */
-HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
- DWORD dwOpenFlags)
-{
- HMMIO ret;
-
- if (lpmmioinfo16) {
- MMIOINFO mmioinfo;
- struct mmio_thunk* thunk = NULL;
-
- memset(&mmioinfo, 0, sizeof(mmioinfo));
-
- EnterCriticalSection(&mmio_cs);
- if (lpmmioinfo16->pIOProc && !(thunk = MMIO_AddThunk(lpmmioinfo16->pIOProc, lpmmioinfo16->pchBuffer)))
- {
- LeaveCriticalSection(&mmio_cs);
- return 0;
- }
-
- mmioinfo.dwFlags = lpmmioinfo16->dwFlags;
- mmioinfo.fccIOProc = lpmmioinfo16->fccIOProc;
- mmioinfo.pIOProc = (LPMMIOPROC)thunk;
- mmioinfo.cchBuffer = lpmmioinfo16->cchBuffer;
- mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo16->pchBuffer);
- mmioinfo.adwInfo[0] = lpmmioinfo16->adwInfo[0];
- /* if we don't have a file name, it's likely a passed open file descriptor */
- if (!szFileName)
- mmioinfo.adwInfo[0] = (DWORD)DosFileHandleToWin32Handle(mmioinfo.adwInfo[0]);
- mmioinfo.adwInfo[1] = lpmmioinfo16->adwInfo[1];
- mmioinfo.adwInfo[2] = lpmmioinfo16->adwInfo[2];
-
- ret = mmioOpenA(szFileName, &mmioinfo, dwOpenFlags);
- if (thunk)
- {
- if (!ret || (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)))
- {
- thunk->pfn16 = NULL;
- thunk->hMmio = NULL;
- }
- else thunk->hMmio = ret;
- }
- LeaveCriticalSection(&mmio_cs);
-
- lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet;
- lpmmioinfo16->hmmio = HMMIO_16(mmioinfo.hmmio);
- } else {
- ret = mmioOpenA(szFileName, NULL, dwOpenFlags);
- }
- return HMMIO_16(ret);
-}
-
-/**************************************************************************
- * mmioClose [MMSYSTEM.1211]
- */
-MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
-{
- MMRESULT ret;
-
- EnterCriticalSection(&mmio_cs);
- ret = mmioClose(HMMIO_32(hmmio), uFlags);
- if (ret == MMSYSERR_NOERROR)
- {
- struct mmio_thunk* thunk;
-
- if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
- {
- MMIO_SetSegmentedBuffer(thunk, 0, TRUE);
- thunk->pfn16 = NULL;
- thunk->hMmio = NULL;
- }
- }
- LeaveCriticalSection(&mmio_cs);
- return ret;
-}
-
-/**************************************************************************
- * mmioRead [MMSYSTEM.1212]
- */
-LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch)
-{
- return mmioRead(HMMIO_32(hmmio), pch, cch);
-}
-
-/**************************************************************************
- * mmioWrite [MMSYSTEM.1213]
- */
-LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch)
-{
- return mmioWrite(HMMIO_32(hmmio),pch,cch);
-}
-
-/**************************************************************************
- * mmioSeek [MMSYSTEM.1214]
- */
-LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin)
-{
- return mmioSeek(HMMIO_32(hmmio), lOffset, iOrigin);
-}
-
-/**************************************************************************
- * mmioGetInfo [MMSYSTEM.1215]
- */
-MMRESULT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
-{
- MMIOINFO mmioinfo;
- MMRESULT ret;
- struct mmio_thunk* thunk;
-
- TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags);
-
- EnterCriticalSection(&mmio_cs);
- if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
- {
- LeaveCriticalSection(&mmio_cs);
- return MMSYSERR_INVALHANDLE;
- }
-
- ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
- if (ret != MMSYSERR_NOERROR)
- {
- LeaveCriticalSection(&mmio_cs);
- return ret;
- }
-
- lpmmioinfo->dwFlags = mmioinfo.dwFlags;
- lpmmioinfo->fccIOProc = mmioinfo.fccIOProc;
- lpmmioinfo->pIOProc = thunk->pfn16;
- lpmmioinfo->wErrorRet = mmioinfo.wErrorRet;
- lpmmioinfo->hTask = HTASK_16(mmioinfo.hTask);
- lpmmioinfo->cchBuffer = mmioinfo.cchBuffer;
- lpmmioinfo->pchBuffer = (void*)thunk->segbuffer;
- lpmmioinfo->pchNext = (void*)(thunk->segbuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
- lpmmioinfo->pchEndRead = (void*)(thunk->segbuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
- lpmmioinfo->pchEndWrite = (void*)(thunk->segbuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
- lpmmioinfo->lBufOffset = mmioinfo.lBufOffset;
- lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
- lpmmioinfo->adwInfo[0] = mmioinfo.adwInfo[0];
- lpmmioinfo->adwInfo[1] = mmioinfo.adwInfo[1];
- lpmmioinfo->adwInfo[2] = mmioinfo.adwInfo[2];
- lpmmioinfo->dwReserved1 = 0;
- lpmmioinfo->dwReserved2 = 0;
- lpmmioinfo->hmmio = HMMIO_16(mmioinfo.hmmio);
- LeaveCriticalSection(&mmio_cs);
-
- return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * mmioSetInfo [MMSYSTEM.1216]
- */
-MMRESULT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16* lpmmioinfo, UINT16 uFlags)
-{
- MMIOINFO mmioinfo;
- MMRESULT ret;
-
- TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
-
- ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0);
- if (ret != MMSYSERR_NOERROR) return ret;
-
- /* check if seg and lin buffers are the same */
- if (mmioinfo.cchBuffer != lpmmioinfo->cchBuffer ||
- mmioinfo.pchBuffer != MapSL((DWORD)lpmmioinfo->pchBuffer))
- return MMSYSERR_INVALPARAM;
-
- /* check pointers coherence */
- if (lpmmioinfo->pchNext < lpmmioinfo->pchBuffer ||
- lpmmioinfo->pchNext > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
- lpmmioinfo->pchEndRead < lpmmioinfo->pchBuffer ||
- lpmmioinfo->pchEndRead > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
- lpmmioinfo->pchEndWrite < lpmmioinfo->pchBuffer ||
- lpmmioinfo->pchEndWrite > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer)
- return MMSYSERR_INVALPARAM;
-
- mmioinfo.pchNext = mmioinfo.pchBuffer + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer);
- mmioinfo.pchEndRead = mmioinfo.pchBuffer + (lpmmioinfo->pchEndRead - lpmmioinfo->pchBuffer);
- mmioinfo.pchEndWrite = mmioinfo.pchBuffer + (lpmmioinfo->pchEndWrite - lpmmioinfo->pchBuffer);
-
- return mmioSetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
-}
-
-/**************************************************************************
- * mmioSetBuffer [MMSYSTEM.1217]
- */
-MMRESULT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, LPSTR pchBuffer,
- LONG cchBuffer, UINT16 uFlags)
-{
- MMRESULT ret = mmioSetBuffer(HMMIO_32(hmmio), MapSL((DWORD)pchBuffer),
- cchBuffer, uFlags);
-
- if (ret == MMSYSERR_NOERROR)
- {
- struct mmio_thunk* thunk;
-
- if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
- {
- FIXME("really ?\n");
- return MMSYSERR_INVALHANDLE;
- }
- MMIO_SetSegmentedBuffer(thunk, (DWORD)pchBuffer, TRUE);
- }
- else
- UnMapLS((DWORD)pchBuffer);
- return ret;
-}
-
-/**************************************************************************
- * mmioFlush [MMSYSTEM.1218]
- */
-MMRESULT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags)
-{
- return mmioFlush(HMMIO_32(hmmio), uFlags);
-}
-
-/***********************************************************************
- * mmioAdvance [MMSYSTEM.1219]
- */
-MMRESULT16 WINAPI mmioAdvance16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
-{
- MMIOINFO mmioinfo;
- LRESULT ret;
-
- /* WARNING: this heavily relies on mmioAdvance implementation (for choosing which
- * fields to init
- */
- if (lpmmioinfo)
- {
- mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo->pchBuffer);
- mmioinfo.pchNext = MapSL((DWORD)lpmmioinfo->pchNext);
- mmioinfo.dwFlags = lpmmioinfo->dwFlags;
- mmioinfo.lBufOffset = lpmmioinfo->lBufOffset;
- ret = mmioAdvance(HMMIO_32(hmmio), &mmioinfo, uFlags);
- }
- else
- ret = mmioAdvance(HMMIO_32(hmmio), NULL, uFlags);
-
- if (ret != MMSYSERR_NOERROR) return ret;
-
- if (lpmmioinfo)
- {
- lpmmioinfo->dwFlags = mmioinfo.dwFlags;
- lpmmioinfo->pchNext = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
- lpmmioinfo->pchEndRead = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
- lpmmioinfo->pchEndWrite = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
- lpmmioinfo->lBufOffset = mmioinfo.lBufOffset;
- lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
- }
-
- return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * mmioStringToFOURCC [MMSYSTEM.1220]
- */
-FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags)
-{
- return mmioStringToFOURCCA(sz, uFlags);
-}
-
-/**************************************************************************
- * mmioInstallIOProc [MMSYSTEM.1221]
- */
-LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
- DWORD dwFlags)
-{
- struct mmio_thunk* thunk = NULL;
- LPMMIOPROC pIOProc32;
-
- EnterCriticalSection(&mmio_cs);
-
- switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
- case MMIO_INSTALLPROC:
- if (!(thunk = MMIO_AddThunk(pIOProc, NULL)))
- {
- LeaveCriticalSection(&mmio_cs);
- return NULL;
- }
- if (!mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
- {
- thunk->pfn16 = NULL;
- pIOProc = NULL;
- }
- break;
- case MMIO_REMOVEPROC:
- if (MMIO_Thunks)
- {
- for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
- {
- if (thunk->pfn16 == pIOProc && thunk->segbuffer == 0)
- {
- if (mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
- thunk->pfn16 = NULL;
- else
- pIOProc = NULL;
- break;
- }
- }
- }
- if (!thunk) pIOProc = NULL;
- break;
- case MMIO_FINDPROC:
- if ((pIOProc32 = mmioInstallIOProcA(fccIOProc, NULL, dwFlags)) && MMIO_Thunks)
- {
- for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
- {
- if ((LPMMIOPROC)thunk == pIOProc32)
- {
- pIOProc = thunk->pfn16;
- break;
- }
- }
- }
- break;
- default:
- WINE_FIXME("Unsupported flags %08x\n", dwFlags);
- pIOProc = NULL;
- }
- LeaveCriticalSection(&mmio_cs);
-
- return pIOProc;
-}
-
-/**************************************************************************
- * mmioSendMessage [MMSYSTEM.1222]
- */
-LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
- LPARAM lParam1, LPARAM lParam2)
-{
- struct mmio_thunk* thunk;
-
- if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
- {
- MMIOINFO mmioinfo;
- if (mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0) == MMSYSERR_NOERROR)
- {
- return MMIO_Callback3216((SEGPTR)thunk->pfn16, &mmioinfo, uMessage, lParam1, lParam2);
- }
- return MMSYSERR_INVALHANDLE;
- }
- else
- {
- /* FIXME: we need to map lParam1 and lParam2 to 32bit entities */
- return mmioSendMessage(HMMIO_32(hmmio), uMessage, lParam1, lParam2);
- }
-}
-
-/**************************************************************************
- * mmioDescend [MMSYSTEM.1223]
- */
-MMRESULT16 WINAPI mmioDescend16(HMMIO16 hmmio, LPMMCKINFO lpck,
- const MMCKINFO* lpckParent, UINT16 uFlags)
-{
- return mmioDescend(HMMIO_32(hmmio), lpck, lpckParent, uFlags);
-}
-
-/**************************************************************************
- * mmioAscend [MMSYSTEM.1224]
- */
-MMRESULT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
-{
- return mmioAscend(HMMIO_32(hmmio),lpck,uFlags);
-}
-
-/**************************************************************************
- * mmioCreateChunk [MMSYSTEM.1225]
- */
-MMRESULT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
-{
- return mmioCreateChunk(HMMIO_32(hmmio), lpck, uFlags);
-}
-
-/**************************************************************************
- * mmioRename [MMSYSTEM.1226]
- */
-MMRESULT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
- MMIOINFO16* lpmmioinfo, DWORD dwRenameFlags)
-{
- BOOL inst = FALSE;
- MMRESULT ret;
- MMIOINFO mmioinfo;
-
- if (lpmmioinfo != NULL && lpmmioinfo->pIOProc != NULL &&
- lpmmioinfo->fccIOProc == 0) {
- FIXME("Can't handle this case yet\n");
- return MMSYSERR_ERROR;
- }
-
- /* this is a bit hacky, but it'll work if we get a fourCC code or nothing.
- * but a non installed ioproc without a fourcc won't do
- */
- if (lpmmioinfo && lpmmioinfo->fccIOProc && lpmmioinfo->pIOProc) {
- mmioInstallIOProc16(lpmmioinfo->fccIOProc, lpmmioinfo->pIOProc,
- MMIO_INSTALLPROC);
- inst = TRUE;
- }
- memset(&mmioinfo, 0, sizeof(mmioinfo));
- mmioinfo.fccIOProc = lpmmioinfo->fccIOProc;
- ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags);
- if (inst) {
- mmioInstallIOProc16(lpmmioinfo->fccIOProc, NULL, MMIO_REMOVEPROC);
- }
- return ret;
-}
diff --git a/dlls/winmm/mmsystem.c b/dlls/winmm/mmsystem.c
deleted file mode 100644
index f258fee..0000000
--- a/dlls/winmm/mmsystem.c
+++ /dev/null
@@ -1,2409 +0,0 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
-/*
- * MMSYSTEM functions
- *
- * Copyright 1993 Martin Ayotte
- * 1998-2003 Eric Pouech
- *
- * 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
- */
-
-/*
- * Eric POUECH :
- * 99/4 added mmTask and mmThread functions support
- */
-
-#include <stdarg.h>
-#include <string.h>
-
-#define NONAMELESSUNION
-#define NONAMELESSSTRUCT
-#include "windef.h"
-#include "winbase.h"
-#include "mmsystem.h"
-#include "winternl.h"
-#include "wownt32.h"
-#include "winnls.h"
-
-#include "wine/list.h"
-#include "wine/winuser16.h"
-#include "winemm16.h"
-
-#include "wine/debug.h"
-
-WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
-
-static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16);
-
-static CRITICAL_SECTION_DEBUG mmdrv_critsect_debug =
-{
- 0, 0, &mmdrv_cs,
- { &mmdrv_critsect_debug.ProcessLocksList, &mmdrv_critsect_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmdrv_cs") }
-};
-CRITICAL_SECTION mmdrv_cs = { &mmdrv_critsect_debug, -1, 0, 0, 0, 0 };
-
-/* ###################################################
- * # LIBRARY #
- * ###################################################
- */
-
-/**************************************************************************
- * DllEntryPoint (MMSYSTEM.4)
- *
- * MMSYSTEM DLL entry point
- *
- */
-BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
- WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
-{
- TRACE("%p 0x%x\n", hinstDLL, fdwReason);
-
- return TRUE;
-}
-
-/**************************************************************************
- * WEP [MMSYSTEM.1]
- */
-int WINAPI MMSYSTEM_WEP(HINSTANCE16 hInstance, WORD wDataSeg,
- WORD cbHeapSize, LPSTR lpCmdLine)
-{
- TRACE("STUB: Unloading MMSystem DLL ... hInst=%04X\n", hInstance);
- return TRUE;
-}
-
-/* ###################################################
- * # PlaySound #
- * ###################################################
- */
-
-/**************************************************************************
- * PlaySound [MMSYSTEM.3]
- */
-BOOL16 WINAPI PlaySound16(LPCSTR pszSound, HMODULE16 hmod, DWORD fdwSound)
-{
- BOOL16 retv;
- DWORD lc;
-
- if ((fdwSound & SND_RESOURCE) == SND_RESOURCE)
- {
- HGLOBAL16 handle;
- HRSRC16 res;
-
- if (!(res = FindResource16( hmod, pszSound, "WAVE" ))) return FALSE;
- if (!(handle = LoadResource16( hmod, res ))) return FALSE;
- pszSound = LockResource16(handle);
- fdwSound = (fdwSound & ~SND_RESOURCE) | SND_MEMORY;
- /* FIXME: FreeResource16 */
- }
-
- ReleaseThunkLock(&lc);
- retv = PlaySoundA(pszSound, 0, fdwSound);
- RestoreThunkLock(lc);
-
- return retv;
-}
-
-/**************************************************************************
- * sndPlaySound [MMSYSTEM.2]
- */
-BOOL16 WINAPI sndPlaySound16(LPCSTR lpszSoundName, UINT16 uFlags)
-{
- BOOL16 retv;
- DWORD lc;
-
- ReleaseThunkLock(&lc);
- retv = sndPlaySoundA(lpszSoundName, uFlags);
- RestoreThunkLock(lc);
-
- return retv;
-}
-
-/* ###################################################
- * # MISC #
- * ###################################################
- */
-
-/**************************************************************************
- * mmsystemGetVersion [MMSYSTEM.5]
- *
- */
-UINT16 WINAPI mmsystemGetVersion16(void)
-{
- return mmsystemGetVersion();
-}
-
-/**************************************************************************
- * DriverCallback [MMSYSTEM.31]
- */
-BOOL16 WINAPI DriverCallback16(DWORD dwCallBack, UINT16 uFlags, HDRVR16 hDev,
- WORD wMsg, DWORD dwUser, DWORD dwParam1,
- DWORD dwParam2)
-{
- return DriverCallback(dwCallBack, uFlags, HDRVR_32(hDev), wMsg, dwUser, dwParam1, dwParam2);
-}
-
-/**************************************************************************
- * OutputDebugStr [MMSYSTEM.30]
- */
-void WINAPI OutputDebugStr16(LPCSTR str)
-{
- OutputDebugStringA( str );
-}
-
-/* ###################################################
- * # MIXER #
- * ###################################################
- */
-
-/**************************************************************************
- * Mixer devices. New to Win95
- */
-
-/**************************************************************************
- * mixerGetNumDevs [MMSYSTEM.800]
- */
-UINT16 WINAPI mixerGetNumDevs16(void)
-{
- return mixerGetNumDevs();
-}
-
-/**************************************************************************
- * mixerGetDevCaps [MMSYSTEM.801]
- */
-UINT16 WINAPI mixerGetDevCaps16(UINT16 uDeviceID, LPMIXERCAPS16 lpCaps,
- UINT16 uSize)
-{
- MIXERCAPSA micA;
- UINT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
- if (ret == MMSYSERR_NOERROR) {
- MIXERCAPS16 mic16;
- mic16.wMid = micA.wMid;
- mic16.wPid = micA.wPid;
- mic16.vDriverVersion = micA.vDriverVersion;
- strcpy(mic16.szPname, micA.szPname);
- mic16.fdwSupport = micA.fdwSupport;
- mic16.cDestinations = micA.cDestinations;
- memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * mixerOpen [MMSYSTEM.802]
- */
-UINT16 WINAPI mixerOpen16(LPHMIXER16 lphmix, UINT16 uDeviceID, DWORD dwCallback,
- DWORD dwInstance, DWORD fdwOpen)
-{
- HMIXER hmix;
- UINT ret;
- struct mmsystdrv_thunk* thunk;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIXER)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
-
- ret = mixerOpen(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen);
- if (ret == MMSYSERR_NOERROR)
- {
- if (lphmix) *lphmix = HMIXER_16(hmix);
- if (thunk) MMSYSTDRV_SetHandle(thunk, hmix);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * mixerClose [MMSYSTEM.803]
- */
-UINT16 WINAPI mixerClose16(HMIXER16 hMix)
-{
- UINT ret = mixerClose(HMIXER_32(hMix));
-
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HMIXER_32(hMix));
- return ret;
-}
-
-/**************************************************************************
- * mixerGetID (MMSYSTEM.806)
- */
-UINT16 WINAPI mixerGetID16(HMIXEROBJ16 hmix, LPUINT16 lpid, DWORD fdwID)
-{
- UINT xid;
- UINT ret = mixerGetID(HMIXEROBJ_32(hmix), &xid, fdwID);
-
- if (lpid)
- *lpid = xid;
- return ret;
-}
-
-/**************************************************************************
- * mixerGetControlDetails [MMSYSTEM.808]
- */
-UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
- LPMIXERCONTROLDETAILS16 lpmcd,
- DWORD fdwDetails)
-{
- DWORD ret = MMSYSERR_NOTENABLED;
- SEGPTR sppaDetails;
-
- TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
-
- if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
- return MMSYSERR_INVALPARAM;
-
- sppaDetails = (SEGPTR)lpmcd->paDetails;
- lpmcd->paDetails = MapSL(sppaDetails);
- ret = mixerGetControlDetailsA(HMIXEROBJ_32(hmix),
- (LPMIXERCONTROLDETAILS)lpmcd, fdwDetails);
- lpmcd->paDetails = (LPVOID)sppaDetails;
-
- return ret;
-}
-
-/**************************************************************************
- * mixerGetLineControls [MMSYSTEM.807]
- */
-UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
- LPMIXERLINECONTROLS16 lpmlc16,
- DWORD fdwControls)
-{
- MIXERLINECONTROLSA mlcA;
- DWORD ret;
- unsigned int i;
- LPMIXERCONTROL16 lpmc16;
-
- TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls);
-
- if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
- lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
- return MMSYSERR_INVALPARAM;
-
- mlcA.cbStruct = sizeof(mlcA);
- mlcA.dwLineID = lpmlc16->dwLineID;
- mlcA.u.dwControlID = lpmlc16->u.dwControlID;
- mlcA.u.dwControlType = lpmlc16->u.dwControlType;
- mlcA.cControls = lpmlc16->cControls;
- mlcA.cbmxctrl = sizeof(MIXERCONTROLA);
- mlcA.pamxctrl = HeapAlloc(GetProcessHeap(), 0,
- mlcA.cControls * mlcA.cbmxctrl);
-
- ret = mixerGetLineControlsA(HMIXEROBJ_32(hmix), &mlcA, fdwControls);
-
- if (ret == MMSYSERR_NOERROR) {
- lpmlc16->dwLineID = mlcA.dwLineID;
- lpmlc16->u.dwControlID = mlcA.u.dwControlID;
- lpmlc16->u.dwControlType = mlcA.u.dwControlType;
- lpmlc16->cControls = mlcA.cControls;
-
- lpmc16 = MapSL(lpmlc16->pamxctrl);
-
- for (i = 0; i < mlcA.cControls; i++) {
- lpmc16[i].cbStruct = sizeof(MIXERCONTROL16);
- lpmc16[i].dwControlID = mlcA.pamxctrl[i].dwControlID;
- lpmc16[i].dwControlType = mlcA.pamxctrl[i].dwControlType;
- lpmc16[i].fdwControl = mlcA.pamxctrl[i].fdwControl;
- lpmc16[i].cMultipleItems = mlcA.pamxctrl[i].cMultipleItems;
- strcpy(lpmc16[i].szShortName, mlcA.pamxctrl[i].szShortName);
- strcpy(lpmc16[i].szName, mlcA.pamxctrl[i].szName);
- /* sizeof(lpmc16[i].Bounds) == sizeof(mlcA.pamxctrl[i].Bounds) */
- memcpy(&lpmc16[i].Bounds, &mlcA.pamxctrl[i].Bounds,
- sizeof(mlcA.pamxctrl[i].Bounds));
- /* sizeof(lpmc16[i].Metrics) == sizeof(mlcA.pamxctrl[i].Metrics) */
- memcpy(&lpmc16[i].Metrics, &mlcA.pamxctrl[i].Metrics,
- sizeof(mlcA.pamxctrl[i].Metrics));
- }
- }
-
- HeapFree(GetProcessHeap(), 0, mlcA.pamxctrl);
-
- return ret;
-}
-
-/**************************************************************************
- * mixerGetLineInfo [MMSYSTEM.805]
- */
-UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
- DWORD fdwInfo)
-{
- MIXERLINEA mliA;
- UINT ret;
-
- TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo);
-
- if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
- return MMSYSERR_INVALPARAM;
-
- mliA.cbStruct = sizeof(mliA);
- switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK) {
- case MIXER_GETLINEINFOF_COMPONENTTYPE:
- mliA.dwComponentType = lpmli16->dwComponentType;
- break;
- case MIXER_GETLINEINFOF_DESTINATION:
- mliA.dwDestination = lpmli16->dwDestination;
- break;
- case MIXER_GETLINEINFOF_LINEID:
- mliA.dwLineID = lpmli16->dwLineID;
- break;
- case MIXER_GETLINEINFOF_SOURCE:
- mliA.dwDestination = lpmli16->dwDestination;
- mliA.dwSource = lpmli16->dwSource;
- break;
- case MIXER_GETLINEINFOF_TARGETTYPE:
- mliA.Target.dwType = lpmli16->Target.dwType;
- mliA.Target.wMid = lpmli16->Target.wMid;
- mliA.Target.wPid = lpmli16->Target.wPid;
- mliA.Target.vDriverVersion = lpmli16->Target.vDriverVersion;
- strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
- break;
- default:
- FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo);
- }
-
- ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo);
-
- lpmli16->dwDestination = mliA.dwDestination;
- lpmli16->dwSource = mliA.dwSource;
- lpmli16->dwLineID = mliA.dwLineID;
- lpmli16->fdwLine = mliA.fdwLine;
- lpmli16->dwUser = mliA.dwUser;
- lpmli16->dwComponentType = mliA.dwComponentType;
- lpmli16->cChannels = mliA.cChannels;
- lpmli16->cConnections = mliA.cConnections;
- lpmli16->cControls = mliA.cControls;
- strcpy(lpmli16->szShortName, mliA.szShortName);
- strcpy(lpmli16->szName, mliA.szName);
- lpmli16->Target.dwType = mliA.Target.dwType;
- lpmli16->Target.dwDeviceID = mliA.Target.dwDeviceID;
- lpmli16->Target.wMid = mliA.Target.wMid;
- lpmli16->Target.wPid = mliA.Target.wPid;
- lpmli16->Target.vDriverVersion = mliA.Target.vDriverVersion;
- strcpy(lpmli16->Target.szPname, mliA.Target.szPname);
-
- return ret;
-}
-
-/**************************************************************************
- * mixerSetControlDetails [MMSYSTEM.809]
- */
-UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
- LPMIXERCONTROLDETAILS16 lpmcd,
- DWORD fdwDetails)
-{
- TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
- return MMSYSERR_NOTENABLED;
-}
-
-/**************************************************************************
- * mixerMessage [MMSYSTEM.804]
- */
-DWORD WINAPI mixerMessage16(HMIXER16 hmix, UINT16 uMsg, DWORD dwParam1,
- DWORD dwParam2)
-{
- return mixerMessage(HMIXER_32(hmix), uMsg, dwParam1, dwParam2);
-}
-
-/* ###################################################
- * # AUX #
- * ###################################################
- */
-
-/**************************************************************************
- * auxGetNumDevs [MMSYSTEM.350]
- */
-UINT16 WINAPI auxGetNumDevs16(void)
-{
- return auxGetNumDevs();
-}
-
-/**************************************************************************
- * auxGetDevCaps [MMSYSTEM.351]
- */
-UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID, LPAUXCAPS16 lpCaps, UINT16 uSize)
-{
- AUXCAPSA acA;
- UINT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
- if (ret == MMSYSERR_NOERROR) {
- AUXCAPS16 ac16;
- ac16.wMid = acA.wMid;
- ac16.wPid = acA.wPid;
- ac16.vDriverVersion = acA.vDriverVersion;
- strcpy(ac16.szPname, acA.szPname);
- ac16.wTechnology = acA.wTechnology;
- ac16.dwSupport = acA.dwSupport;
- memcpy(lpCaps, &ac16, min(uSize, sizeof(ac16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * auxGetVolume [MMSYSTEM.352]
- */
-UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
-{
- return auxGetVolume(uDeviceID, lpdwVolume);
-}
-
-/**************************************************************************
- * auxSetVolume [MMSYSTEM.353]
- */
-UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
-{
- return auxSetVolume(uDeviceID, dwVolume);
-}
-
-/**************************************************************************
- * auxOutMessage [MMSYSTEM.354]
- */
-DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
-{
- TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2);
-
- switch (uMessage) {
- case AUXDM_GETNUMDEVS:
- case AUXDM_SETVOLUME:
- /* no argument conversion needed */
- break;
- case AUXDM_GETVOLUME:
- return auxGetVolume(uDeviceID, MapSL(dw1));
- case AUXDM_GETDEVCAPS:
- return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
- default:
- TRACE("(%04x, %04x, %08x, %08x): unhandled message\n",
- uDeviceID, uMessage, dw1, dw2);
- break;
- }
- return auxOutMessage(uDeviceID, uMessage, dw1, dw2);
-}
-
-/* ###################################################
- * # MIDI #
- * ###################################################
- */
-
-/**************************************************************************
- * midiOutGetNumDevs [MMSYSTEM.201]
- */
-UINT16 WINAPI midiOutGetNumDevs16(void)
-{
- return midiOutGetNumDevs();
-}
-
-/**************************************************************************
- * midiOutGetDevCaps [MMSYSTEM.202]
- */
-UINT16 WINAPI midiOutGetDevCaps16(UINT16 uDeviceID, LPMIDIOUTCAPS16 lpCaps,
- UINT16 uSize)
-{
- MIDIOUTCAPSA mocA;
- UINT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = midiOutGetDevCapsA(uDeviceID, &mocA, sizeof(mocA));
- if (ret == MMSYSERR_NOERROR) {
- MIDIOUTCAPS16 moc16;
- moc16.wMid = mocA.wMid;
- moc16.wPid = mocA.wPid;
- moc16.vDriverVersion = mocA.vDriverVersion;
- strcpy(moc16.szPname, mocA.szPname);
- moc16.wTechnology = mocA.wTechnology;
- moc16.wVoices = mocA.wVoices;
- moc16.wNotes = mocA.wNotes;
- moc16.wChannelMask = mocA.wChannelMask;
- moc16.dwSupport = mocA.dwSupport;
- memcpy(lpCaps, &moc16, min(uSize, sizeof(moc16)));
- }
- return ret;
- }
-
-/**************************************************************************
- * midiOutGetErrorText [MMSYSTEM.203]
- * midiInGetErrorText [MMSYSTEM.303]
- */
-UINT16 WINAPI midiOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return midiOutGetErrorTextA(uError, lpText, uSize);
-}
-
-/**************************************************************************
- * midiOutOpen [MMSYSTEM.204]
- */
-UINT16 WINAPI midiOutOpen16(HMIDIOUT16* lphMidiOut, UINT16 uDeviceID,
- DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
-{
- HMIDIOUT hmo;
- UINT ret;
- struct mmsystdrv_thunk* thunk;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
- ret = midiOutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags);
- if (ret == MMSYSERR_NOERROR)
- {
- if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
- MMSYSTDRV_SetHandle(thunk, (void*)hmo);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * midiOutClose [MMSYSTEM.205]
- */
-UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
-{
- UINT ret = midiOutClose(HMIDIOUT_32(hMidiOut));
-
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HMIDIOUT_32(hMidiOut));
- return ret;
-}
-
-/**************************************************************************
- * midiOutPrepareHeader [MMSYSTEM.206]
- */
-UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
- SEGPTR lpsegMidiOutHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
- return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_PREPARE, lpsegMidiOutHdr, uSize);
-}
-
-/**************************************************************************
- * midiOutUnprepareHeader [MMSYSTEM.207]
- */
-UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
- SEGPTR lpsegMidiOutHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
-
- TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
- if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
- return MMSYSERR_NOERROR;
- }
-
- return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_UNPREPARE, lpsegMidiOutHdr, uSize);
-}
-
-/**************************************************************************
- * midiOutShortMsg [MMSYSTEM.208]
- */
-UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16 hMidiOut, DWORD dwMsg)
-{
- return midiOutShortMsg(HMIDIOUT_32(hMidiOut), dwMsg);
-}
-
-/**************************************************************************
- * midiOutLongMsg [MMSYSTEM.209]
- */
-UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, /* [in] */
- LPMIDIHDR16 lpsegMidiOutHdr, /* [???] NOTE: SEGPTR */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
- return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize);
-}
-
-/**************************************************************************
- * midiOutReset [MMSYSTEM.210]
- */
-UINT16 WINAPI midiOutReset16(HMIDIOUT16 hMidiOut)
-{
- return midiOutReset(HMIDIOUT_32(hMidiOut));
-}
-
-/**************************************************************************
- * midiOutGetVolume [MMSYSTEM.211]
- */
-UINT16 WINAPI midiOutGetVolume16(UINT16 uDeviceID, DWORD* lpdwVolume)
-{
- return midiOutGetVolume(HMIDIOUT_32(uDeviceID), lpdwVolume);
-}
-
-/**************************************************************************
- * midiOutSetVolume [MMSYSTEM.212]
- */
-UINT16 WINAPI midiOutSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
-{
- return midiOutSetVolume(HMIDIOUT_32(uDeviceID), dwVolume);
-}
-
-/**************************************************************************
- * midiOutCachePatches [MMSYSTEM.213]
- */
-UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16 hMidiOut, UINT16 uBank,
- WORD* lpwPatchArray, UINT16 uFlags)
-{
- return midiOutCachePatches(HMIDIOUT_32(hMidiOut), uBank, lpwPatchArray,
- uFlags);
-}
-
-/**************************************************************************
- * midiOutCacheDrumPatches [MMSYSTEM.214]
- */
-UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16 hMidiOut, UINT16 uPatch,
- WORD* lpwKeyArray, UINT16 uFlags)
-{
- return midiOutCacheDrumPatches(HMIDIOUT_32(hMidiOut), uPatch, lpwKeyArray, uFlags);
-}
-
-/**************************************************************************
- * midiOutGetID [MMSYSTEM.215]
- */
-UINT16 WINAPI midiOutGetID16(HMIDIOUT16 hMidiOut, UINT16* lpuDeviceID)
-{
- UINT devid;
- UINT16 ret;
-
- ret = midiOutGetID(HMIDIOUT_32(hMidiOut), &devid);
- if (ret != MMSYSERR_NOERROR) return ret;
- *lpuDeviceID = devid;
- return ret;
-}
-
-/**************************************************************************
- * midiOutMessage [MMSYSTEM.216]
- */
-DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
- DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
-
- switch (uMessage) {
- case MODM_OPEN:
- case MODM_CLOSE:
- FIXME("can't handle OPEN or CLOSE message!\n");
- return MMSYSERR_NOTSUPPORTED;
-
- case MODM_GETVOLUME:
- return midiOutGetVolume16(hMidiOut, MapSL(dwParam1));
- case MODM_LONGDATA:
- return midiOutLongMsg16(hMidiOut, MapSL(dwParam1), dwParam2);
- case MODM_PREPARE:
- /* lpMidiOutHdr is still a segmented pointer for this function */
- return midiOutPrepareHeader16(hMidiOut, dwParam1, dwParam2);
- case MODM_UNPREPARE:
- return midiOutUnprepareHeader16(hMidiOut, dwParam1, dwParam2);
- }
- return MMSYSTDRV_Message(HMIDIOUT_32(hMidiOut), uMessage, dwParam1, dwParam2);
-}
-
-/**************************************************************************
- * midiInGetNumDevs [MMSYSTEM.301]
- */
-UINT16 WINAPI midiInGetNumDevs16(void)
-{
- return midiInGetNumDevs();
-}
-
-/**************************************************************************
- * midiInGetDevCaps [MMSYSTEM.302]
- */
-UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID, LPMIDIINCAPS16 lpCaps,
- UINT16 uSize)
-{
- MIDIINCAPSA micA;
- UINT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
- if (ret == MMSYSERR_NOERROR) {
- MIDIINCAPS16 mic16;
- mic16.wMid = micA.wMid;
- mic16.wPid = micA.wPid;
- mic16.vDriverVersion = micA.vDriverVersion;
- strcpy(mic16.szPname, micA.szPname);
- mic16.dwSupport = micA.dwSupport;
- memcpy(lpCaps, &mic16, min(uSize, sizeof(mic16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * midiInOpen [MMSYSTEM.304]
- */
-UINT16 WINAPI midiInOpen16(HMIDIIN16* lphMidiIn, UINT16 uDeviceID,
- DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
-{
- HMIDIIN hmid;
- UINT ret;
- struct mmsystdrv_thunk* thunk;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIIN)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
- ret = midiInOpen(&hmid, uDeviceID, dwCallback, dwInstance, dwFlags);
- if (ret == MMSYSERR_NOERROR)
- {
- if (lphMidiIn) *lphMidiIn = HMIDIIN_16(hmid);
- MMSYSTDRV_SetHandle(thunk, (void*)hmid);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * midiInClose [MMSYSTEM.305]
- */
-UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
-{
- UINT ret = midiInClose(HMIDIIN_32(hMidiIn));
-
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HMIDIIN_32(hMidiIn));
- return ret;
-}
-
-/**************************************************************************
- * midiInPrepareHeader [MMSYSTEM.306]
- */
-UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
- SEGPTR lpsegMidiInHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
- return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_PREPARE, lpsegMidiInHdr, uSize);
-}
-
-/**************************************************************************
- * midiInUnprepareHeader [MMSYSTEM.307]
- */
-UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
- SEGPTR lpsegMidiInHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr);
-
- TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
- if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
- return MMSYSERR_NOERROR;
- }
-
- return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_UNPREPARE, lpsegMidiInHdr, uSize);
-}
-
-/**************************************************************************
- * midiInAddBuffer [MMSYSTEM.308]
- */
-UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */
- MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
- return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize);
-}
-
-/**************************************************************************
- * midiInStart [MMSYSTEM.309]
- */
-UINT16 WINAPI midiInStart16(HMIDIIN16 hMidiIn)
-{
- return midiInStart(HMIDIIN_32(hMidiIn));
-}
-
-/**************************************************************************
- * midiInStop [MMSYSTEM.310]
- */
-UINT16 WINAPI midiInStop16(HMIDIIN16 hMidiIn)
-{
- return midiInStop(HMIDIIN_32(hMidiIn));
-}
-
-/**************************************************************************
- * midiInReset [MMSYSTEM.311]
- */
-UINT16 WINAPI midiInReset16(HMIDIIN16 hMidiIn)
-{
- return midiInReset(HMIDIIN_32(hMidiIn));
-}
-
-/**************************************************************************
- * midiInGetID [MMSYSTEM.312]
- */
-UINT16 WINAPI midiInGetID16(HMIDIIN16 hMidiIn, UINT16* lpuDeviceID)
-{
- UINT devid;
- UINT16 ret;
-
- ret = midiInGetID(HMIDIIN_32(hMidiIn), &devid);
- if (ret != MMSYSERR_NOERROR) return ret;
- *lpuDeviceID = devid;
- return ret;
-}
-
-/**************************************************************************
- * midiInMessage [MMSYSTEM.313]
- */
-DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
- DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("(%04X, %04X, %08X, %08X)\n", hMidiIn, uMessage, dwParam1, dwParam2);
-
- switch (uMessage) {
- case MIDM_OPEN:
- case MIDM_CLOSE:
- FIXME("can't handle OPEN or CLOSE message!\n");
- return MMSYSERR_NOTSUPPORTED;
-
- case MIDM_GETDEVCAPS:
- return midiInGetDevCaps16(hMidiIn, MapSL(dwParam1), dwParam2);
- case MIDM_PREPARE:
- return midiInPrepareHeader16(hMidiIn, dwParam1, dwParam2);
- case MIDM_UNPREPARE:
- return midiInUnprepareHeader16(hMidiIn, dwParam1, dwParam2);
- case MIDM_ADDBUFFER:
- return midiInAddBuffer16(hMidiIn, MapSL(dwParam1), dwParam2);
- }
- return MMSYSTDRV_Message(HMIDIIN_32(hMidiIn), uMessage, dwParam1, dwParam2);
-}
-
-/**************************************************************************
- * midiStreamClose [MMSYSTEM.252]
- */
-MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
-{
- UINT ret = midiStreamClose(HMIDISTRM_32(hMidiStrm));
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HMIDISTRM_32(hMidiStrm));
- return ret;
-}
-
-/**************************************************************************
- * midiStreamOpen [MMSYSTEM.251]
- */
-MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
- DWORD cMidi, DWORD dwCallback,
- DWORD dwInstance, DWORD fdwOpen)
-{
- HMIDISTRM hMidiStrm32;
- MMRESULT ret;
- UINT devid32;
- struct mmsystdrv_thunk* thunk;
-
- if (!phMidiStrm || !devid)
- return MMSYSERR_INVALPARAM;
- devid32 = *devid;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_MIDIOUT)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((fdwOpen & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
- ret = midiStreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback, dwInstance, fdwOpen);
- if (ret == MMSYSERR_NOERROR)
- {
- *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
- *devid = devid32;
- MMSYSTDRV_SetHandle(thunk, hMidiStrm32);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * midiStreamOut [MMSYSTEM.254]
- */
-MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16 hMidiStrm, LPMIDIHDR16 lpMidiHdr, UINT16 cbMidiHdr)
-{
- return midiStreamOut(HMIDISTRM_32(hMidiStrm), (LPMIDIHDR)lpMidiHdr,
- cbMidiHdr);
-}
-
-/**************************************************************************
- * midiStreamPause [MMSYSTEM.255]
- */
-MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16 hMidiStrm)
-{
- return midiStreamPause(HMIDISTRM_32(hMidiStrm));
-}
-
-/**************************************************************************
- * midiStreamPosition [MMSYSTEM.253]
- */
-MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16 hMidiStrm, LPMMTIME16 lpmmt16, UINT16 cbmmt)
-{
- MMTIME mmt32;
- MMRESULT ret;
-
- if (!lpmmt16)
- return MMSYSERR_INVALPARAM;
- MMSYSTEM_MMTIME16to32(&mmt32, lpmmt16);
- ret = midiStreamPosition(HMIDISTRM_32(hMidiStrm), &mmt32, sizeof(MMTIME));
- MMSYSTEM_MMTIME32to16(lpmmt16, &mmt32);
- return ret;
-}
-
-/**************************************************************************
- * midiStreamProperty [MMSYSTEM.250]
- */
-MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16 hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
-{
- return midiStreamProperty(HMIDISTRM_32(hMidiStrm), lpPropData, dwProperty);
-}
-
-/**************************************************************************
- * midiStreamRestart [MMSYSTEM.256]
- */
-MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16 hMidiStrm)
-{
- return midiStreamRestart(HMIDISTRM_32(hMidiStrm));
-}
-
-/**************************************************************************
- * midiStreamStop [MMSYSTEM.257]
- */
-MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16 hMidiStrm)
-{
- return midiStreamStop(HMIDISTRM_32(hMidiStrm));
-}
-
-/* ###################################################
- * # WAVE #
- * ###################################################
- */
-
-/**************************************************************************
- * waveOutGetNumDevs [MMSYSTEM.401]
- */
-UINT16 WINAPI waveOutGetNumDevs16(void)
-{
- return waveOutGetNumDevs();
-}
-
-/**************************************************************************
- * waveOutGetDevCaps [MMSYSTEM.402]
- */
-UINT16 WINAPI waveOutGetDevCaps16(UINT16 uDeviceID,
- LPWAVEOUTCAPS16 lpCaps, UINT16 uSize)
-{
- WAVEOUTCAPSA wocA;
- UINT ret;
- TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize);
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = waveOutGetDevCapsA(uDeviceID, &wocA, sizeof(wocA));
- if (ret == MMSYSERR_NOERROR) {
- WAVEOUTCAPS16 woc16;
- woc16.wMid = wocA.wMid;
- woc16.wPid = wocA.wPid;
- woc16.vDriverVersion = wocA.vDriverVersion;
- strcpy(woc16.szPname, wocA.szPname);
- woc16.dwFormats = wocA.dwFormats;
- woc16.wChannels = wocA.wChannels;
- woc16.dwSupport = wocA.dwSupport;
- memcpy(lpCaps, &woc16, min(uSize, sizeof(woc16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * waveOutGetErrorText [MMSYSTEM.403]
- * waveInGetErrorText [MMSYSTEM.503]
- */
-UINT16 WINAPI waveOutGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
-{
- return waveOutGetErrorTextA(uError, lpText, uSize);
-}
-
-/**************************************************************************
- * waveOutOpen [MMSYSTEM.404]
- */
-UINT16 WINAPI waveOutOpen16(HWAVEOUT16* lphWaveOut, UINT16 uDeviceID,
- LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
- DWORD dwInstance, DWORD dwFlags)
-{
- HWAVEOUT hWaveOut;
- UINT ret;
- struct mmsystdrv_thunk* thunk;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEOUT)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
- /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
- * call the 32 bit version
- * however, we need to promote correctly the wave mapper id
- * (0xFFFFFFFF and not 0x0000FFFF)
- */
- ret = waveOutOpen(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
- lpFormat, dwCallback, dwInstance, dwFlags);
-
- if (ret == MMSYSERR_NOERROR)
- {
- if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut);
- MMSYSTDRV_SetHandle(thunk, (void*)hWaveOut);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * waveOutClose [MMSYSTEM.405]
- */
-UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveOutClose(HWAVEOUT_32(hWaveOut));
- RestoreThunkLock(level);
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HWAVEOUT_32(hWaveOut));
- return ret;
-}
-
-/**************************************************************************
- * waveOutPrepareHeader [MMSYSTEM.406]
- */
-UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
- SEGPTR lpsegWaveOutHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
- UINT16 result;
-
- TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
- if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
-
- if ((result = MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_PREPARE, lpsegWaveOutHdr,
- uSize)) != MMSYSERR_NOTSUPPORTED)
- return result;
-
- if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE)
- return WAVERR_STILLPLAYING;
-
- lpWaveOutHdr->dwFlags |= WHDR_PREPARED;
- lpWaveOutHdr->dwFlags &= ~WHDR_DONE;
-
- return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * waveOutUnprepareHeader [MMSYSTEM.407]
- */
-UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
- SEGPTR lpsegWaveOutHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
-
- TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
- if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
- return MMSYSERR_NOERROR;
- }
-
- return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_UNPREPARE, lpsegWaveOutHdr, uSize);
-}
-
-/**************************************************************************
- * waveOutWrite [MMSYSTEM.408]
- */
-UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */
- LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
- return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize);
-}
-
-/**************************************************************************
- * waveOutBreakLoop [MMSYSTEM.419]
- */
-UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16 hWaveOut16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveOutBreakLoop(HWAVEOUT_32(hWaveOut16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveOutPause [MMSYSTEM.409]
- */
-UINT16 WINAPI waveOutPause16(HWAVEOUT16 hWaveOut16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveOutPause(HWAVEOUT_32(hWaveOut16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveOutReset [MMSYSTEM.411]
- */
-UINT16 WINAPI waveOutReset16(HWAVEOUT16 hWaveOut16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveOutReset(HWAVEOUT_32(hWaveOut16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveOutRestart [MMSYSTEM.410]
- */
-UINT16 WINAPI waveOutRestart16(HWAVEOUT16 hWaveOut16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveOutRestart(HWAVEOUT_32(hWaveOut16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveOutGetPosition [MMSYSTEM.412]
- */
-UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut, LPMMTIME16 lpTime,
- UINT16 uSize)
-{
- UINT ret;
- MMTIME mmt;
-
- mmt.wType = lpTime->wType;
- ret = waveOutGetPosition(HWAVEOUT_32(hWaveOut), &mmt, sizeof(mmt));
- MMSYSTEM_MMTIME32to16(lpTime, &mmt);
- return ret;
-}
-
-/**************************************************************************
- * waveOutGetPitch [MMSYSTEM.413]
- */
-UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
-{
- return waveOutGetPitch(HWAVEOUT_32(hWaveOut16), lpdw);
-}
-
-/**************************************************************************
- * waveOutSetPitch [MMSYSTEM.414]
- */
-UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16 hWaveOut16, DWORD dw)
-{
- return waveOutSetPitch(HWAVEOUT_32(hWaveOut16), dw);
-}
-
-/**************************************************************************
- * waveOutGetPlaybackRate [MMSYSTEM.417]
- */
-UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16 hWaveOut16, LPDWORD lpdw)
-{
- return waveOutGetPlaybackRate(HWAVEOUT_32(hWaveOut16), lpdw);
-}
-
-/**************************************************************************
- * waveOutSetPlaybackRate [MMSYSTEM.418]
- */
-UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16 hWaveOut16, DWORD dw)
-{
- return waveOutSetPlaybackRate(HWAVEOUT_32(hWaveOut16), dw);
-}
-
-/**************************************************************************
- * waveOutGetVolume [MMSYSTEM.415]
- */
-UINT16 WINAPI waveOutGetVolume16(UINT16 devid, LPDWORD lpdw)
-{
- return waveOutGetVolume(HWAVEOUT_32(devid), lpdw);
-}
-
-/**************************************************************************
- * waveOutSetVolume [MMSYSTEM.416]
- */
-UINT16 WINAPI waveOutSetVolume16(UINT16 devid, DWORD dw)
-{
- return waveOutSetVolume(HWAVEOUT_32(devid), dw);
-}
-
-/**************************************************************************
- * waveOutGetID [MMSYSTEM.420]
- */
-UINT16 WINAPI waveOutGetID16(HWAVEOUT16 hWaveOut, UINT16* lpuDeviceID)
-{
- UINT devid;
- UINT16 ret;
-
- ret = waveOutGetID(HWAVEOUT_32(hWaveOut), &devid);
- if (ret != MMSYSERR_NOERROR) return ret;
- *lpuDeviceID = devid;
- return ret;
-}
-
-/**************************************************************************
- * waveOutMessage [MMSYSTEM.421]
- */
-DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
- DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
-
- if ((DWORD_PTR)hWaveOut < waveOutGetNumDevs())
- {
- if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
- dwParam1 = (DWORD)MapSL(dwParam1);
- }
- else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
- /* from M$ KB */
- return MMSYSERR_INVALPARAM;
-
- return MMSYSTDRV_Message(HWAVEOUT_32(hWaveOut), uMessage, dwParam1, dwParam2);
-}
-
-/**************************************************************************
- * waveInGetNumDevs [MMSYSTEM.501]
- */
-UINT16 WINAPI waveInGetNumDevs16(void)
-{
- return waveInGetNumDevs();
-}
-
-/**************************************************************************
- * waveInGetDevCaps [MMSYSTEM.502]
- */
-UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps,
- UINT16 uSize)
-{
- WAVEINCAPSA wicA;
- UINT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = waveInGetDevCapsA(uDeviceID, &wicA, sizeof(wicA));
- if (ret == MMSYSERR_NOERROR) {
- WAVEINCAPS16 wic16;
- wic16.wMid = wicA.wMid;
- wic16.wPid = wicA.wPid;
- wic16.vDriverVersion = wicA.vDriverVersion;
- strcpy(wic16.szPname, wicA.szPname);
- wic16.dwFormats = wicA.dwFormats;
- wic16.wChannels = wicA.wChannels;
- memcpy(lpCaps, &wic16, min(uSize, sizeof(wic16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * waveInOpen [MMSYSTEM.504]
- */
-UINT16 WINAPI waveInOpen16(HWAVEIN16* lphWaveIn, UINT16 uDeviceID,
- LPCWAVEFORMATEX lpFormat, DWORD dwCallback,
- DWORD dwInstance, DWORD dwFlags)
-{
- HWAVEIN hWaveIn;
- UINT ret;
- struct mmsystdrv_thunk* thunk;
-
- if (!(thunk = MMSYSTDRV_AddThunk(dwCallback, MMSYSTDRV_WAVEIN)))
- {
- return MMSYSERR_NOMEM;
- }
- if ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION)
- {
- dwCallback = (DWORD)thunk;
- }
- /* since layout of WAVEFORMATEX is the same for 16/32 bits, we directly
- * call the 32 bit version
- * however, we need to promote correctly the wave mapper id
- * (0xFFFFFFFF and not 0x0000FFFF)
- */
- ret = waveInOpen(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
- lpFormat, dwCallback, dwInstance, dwFlags);
-
- if (ret == MMSYSERR_NOERROR)
- {
- if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn);
- MMSYSTDRV_SetHandle(thunk, (void*)hWaveIn);
- }
- else MMSYSTDRV_DeleteThunk(thunk);
- return ret;
-}
-
-/**************************************************************************
- * waveInClose [MMSYSTEM.505]
- */
-UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveInClose(HWAVEIN_32(hWaveIn));
- RestoreThunkLock(level);
- if (ret == MMSYSERR_NOERROR)
- MMSYSTDRV_CloseHandle((void*)HWAVEIN_32(hWaveIn));
- return ret;
-}
-
-/**************************************************************************
- * waveInPrepareHeader [MMSYSTEM.506]
- */
-UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
- SEGPTR lpsegWaveInHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
- UINT16 ret;
-
- TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
-
- if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
- lpWaveInHdr->dwBytesRecorded = 0;
-
- ret = MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_PREPARE, lpsegWaveInHdr, uSize);
- return ret;
-}
-
-/**************************************************************************
- * waveInUnprepareHeader [MMSYSTEM.507]
- */
-UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
- SEGPTR lpsegWaveInHdr, /* [???] */
- UINT16 uSize) /* [in] */
-{
- LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
-
- TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
-
- if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
-
- if (!(lpWaveInHdr->dwFlags & WHDR_PREPARED)) {
- return MMSYSERR_NOERROR;
- }
-
- return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_UNPREPARE, lpsegWaveInHdr, uSize);
-}
-
-/**************************************************************************
- * waveInAddBuffer [MMSYSTEM.508]
- */
-UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */
- WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
- UINT16 uSize) /* [in] */
-{
- TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
-
- if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
-
- return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize);
-}
-
-/**************************************************************************
- * waveInReset [MMSYSTEM.511]
- */
-UINT16 WINAPI waveInReset16(HWAVEIN16 hWaveIn16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveInReset(HWAVEIN_32(hWaveIn16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveInStart [MMSYSTEM.509]
- */
-UINT16 WINAPI waveInStart16(HWAVEIN16 hWaveIn16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveInStart(HWAVEIN_32(hWaveIn16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveInStop [MMSYSTEM.510]
- */
-UINT16 WINAPI waveInStop16(HWAVEIN16 hWaveIn16)
-{
- DWORD level;
- UINT16 ret;
-
- ReleaseThunkLock(&level);
- ret = waveInStop(HWAVEIN_32(hWaveIn16));
- RestoreThunkLock(level);
- return ret;
-}
-
-/**************************************************************************
- * waveInGetPosition [MMSYSTEM.512]
- */
-UINT16 WINAPI waveInGetPosition16(HWAVEIN16 hWaveIn, LPMMTIME16 lpTime,
- UINT16 uSize)
-{
- UINT ret;
- MMTIME mmt;
-
- mmt.wType = lpTime->wType;
- ret = waveInGetPosition(HWAVEIN_32(hWaveIn), &mmt, sizeof(mmt));
- MMSYSTEM_MMTIME32to16(lpTime, &mmt);
- return ret;
-}
-
-/**************************************************************************
- * waveInGetID [MMSYSTEM.513]
- */
-UINT16 WINAPI waveInGetID16(HWAVEIN16 hWaveIn, UINT16* lpuDeviceID)
-{
- UINT devid;
- UINT16 ret;
-
- ret = waveInGetID(HWAVEIN_32(hWaveIn), &devid);
- if (ret != MMSYSERR_NOERROR) return ret;
- *lpuDeviceID = devid;
- return ret;
-}
-
-/**************************************************************************
- * waveInMessage [MMSYSTEM.514]
- */
-DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
- DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
-
- if ((DWORD_PTR)hWaveIn < waveInGetNumDevs())
- {
- if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
- dwParam1 = (DWORD)MapSL(dwParam1);
- }
- else if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
- /* from M$ KB */
- return MMSYSERR_INVALPARAM;
-
- return MMSYSTDRV_Message(HWAVEIN_32(hWaveIn), uMessage, dwParam1, dwParam2);
-}
-
-/* ###################################################
- * # TASK #
- * ###################################################
- */
-
-/*#define USE_MM_TSK_WINE*/
-
-/**************************************************************************
- * mmTaskCreate [MMSYSTEM.900]
- *
- * Creates a 16 bit MM task. It's entry point is lpFunc, and it should be
- * called upon creation with dwPmt as parameter.
- */
-HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD dwPmt)
-{
- HINSTANCE16 ret;
- HINSTANCE16 handle;
- char cmdline[16];
- DWORD showCmd = 0x40002;
- LOADPARAMS16 lp;
-
- TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt);
- /* This to work requires NE modules to be started with a binary command line
- * which is not currently the case. A patch exists but has never been committed.
- * A workaround would be to integrate code for mmtask.tsk into Wine, but
- * this requires tremendous work (starting with patching tools/build to
- * create NE executables (and not only DLLs) for builtins modules.
- * EP 99/04/25
- */
- FIXME("This is currently broken. It will fail\n");
-
- cmdline[0] = 0x0d;
- *(LPDWORD)(cmdline + 1) = (DWORD)spProc;
- *(LPDWORD)(cmdline + 5) = dwPmt;
- *(LPDWORD)(cmdline + 9) = 0;
-
- lp.hEnvironment = 0;
- lp.cmdLine = MapLS(cmdline);
- lp.showCmd = MapLS(&showCmd);
- lp.reserved = 0;
-
-#ifndef USE_MM_TSK_WINE
- handle = LoadModule16("c:\\windows\\system\\mmtask.tsk", &lp);
-#else
- handle = LoadModule16("mmtask.tsk", &lp);
-#endif
- if (handle < 32) {
- ret = (handle) ? 1 : 2;
- handle = 0;
- } else {
- ret = 0;
- }
- if (lphMmTask)
- *lphMmTask = handle;
-
- UnMapLS( lp.cmdLine );
- UnMapLS( lp.showCmd );
- TRACE("=> 0x%04x/%d\n", handle, ret);
- return ret;
-}
-
-#ifdef USE_MM_TSK_WINE
-/* C equivalent to mmtask.tsk binary content */
-void mmTaskEntryPoint16(LPSTR cmdLine, WORD di, WORD si)
-{
- int len = cmdLine[0x80];
-
- if (len / 2 == 6) {
- void (*fpProc)(DWORD) = MapSL(*((DWORD*)(cmdLine + 1)));
- DWORD dwPmt = *((DWORD*)(cmdLine + 5));
-
-#if 0
- InitTask16(); /* FIXME: pmts / from context ? */
- InitApp(di);
-#endif
- if (SetMessageQueue16(0x40)) {
- WaitEvent16(0);
- if (HIWORD(fpProc)) {
- OldYield16();
-/* EPP StackEnter16(); */
- (fpProc)(dwPmt);
- }
- }
- }
- OldYield16();
- OldYield16();
- OldYield16();
- ExitProcess(0);
-}
-#endif
-
-/**************************************************************************
- * mmTaskBlock [MMSYSTEM.902]
- */
-void WINAPI mmTaskBlock16(HINSTANCE16 hInst)
-{
- MSG msg;
-
- do {
- GetMessageA(&msg, 0, 0, 0);
- if (msg.hwnd) {
- TranslateMessage(&msg);
- DispatchMessageA(&msg);
- }
- } while (msg.message < 0x3A0);
-}
-
-/**************************************************************************
- * mmTaskSignal [MMSYSTEM.903]
- */
-LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
-{
- TRACE("(%04x);\n", ht);
- return PostThreadMessageW( HTASK_32(ht), WM_USER, 0, 0 );
-}
-
-/**************************************************************************
- * mmGetCurrentTask [MMSYSTEM.904]
- */
-HTASK16 WINAPI mmGetCurrentTask16(void)
-{
- return GetCurrentTask();
-}
-
-/**************************************************************************
- * mmTaskYield [MMSYSTEM.905]
- */
-void WINAPI mmTaskYield16(void)
-{
- MSG msg;
-
- if (PeekMessageA(&msg, 0, 0, 0, 0)) {
- WOWYield16();
- }
-}
-
-extern DWORD WINAPI GetProcessFlags(DWORD);
-
-/******************************************************************
- * WINMM_GetmmThread
- *
- *
- */
-static WINE_MMTHREAD* WINMM_GetmmThread(HANDLE16 h)
-{
- return MapSL(MAKESEGPTR(h, 0));
-}
-
-DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID);
-
-/**************************************************************************
- * mmThreadCreate [MMSYSTEM.1120]
- *
- * undocumented
- * Creates a MM thread, calling fpThreadAddr(dwPmt).
- * dwFlags:
- * bit.0 set means create a 16 bit task instead of thread calling a 16 bit proc
- * bit.1 set means to open a VxD for this thread (unsupported)
- */
-LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD dwPmt, DWORD dwFlags)
-{
- HANDLE16 hndl;
- LRESULT ret;
-
- TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
-
- hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
-
- if (hndl == 0) {
- ret = 2;
- } else {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
-
-#if 0
- /* force mmtask routines even if mmthread is required */
- /* this will work only if the patch about binary cmd line and NE tasks
- * is committed
- */
- dwFlags |= 1;
-#endif
-
- lpMMThd->dwSignature = WINE_MMTHREAD_CREATED;
- lpMMThd->dwCounter = 0;
- lpMMThd->hThread = 0;
- lpMMThd->dwThreadID = 0;
- lpMMThd->fpThread = (DWORD)fpThreadAddr;
- lpMMThd->dwThreadPmt = dwPmt;
- lpMMThd->dwSignalCount = 0;
- lpMMThd->hEvent = 0;
- lpMMThd->hVxD = 0;
- lpMMThd->dwStatus = 0;
- lpMMThd->dwFlags = dwFlags;
- lpMMThd->hTask = 0;
-
- if ((dwFlags & 1) == 0 && (GetProcessFlags(GetCurrentThreadId()) & 8) == 0) {
- lpMMThd->hEvent = CreateEventW(NULL, FALSE, TRUE, NULL);
-
- TRACE("Let's go crazy... trying new MM thread. lpMMThd=%p\n", lpMMThd);
- if (lpMMThd->dwFlags & 2) {
- /* as long as we don't support MM VxD in wine, we don't need
- * to care about this flag
- */
- /* FIXME("Don't know how to properly open VxD handles\n"); */
- /* lpMMThd->hVxD = OpenVxDHandle(lpMMThd->hEvent); */
- }
-
- lpMMThd->hThread = CreateThread(0, 0, WINE_mmThreadEntryPoint,
- (LPVOID)(DWORD_PTR)hndl, CREATE_SUSPENDED, &lpMMThd->dwThreadID);
- if (lpMMThd->hThread == 0) {
- WARN("Couldn't create thread\n");
- /* clean-up(VxDhandle...); devicedirectio... */
- if (lpMMThd->hEvent != 0)
- CloseHandle(lpMMThd->hEvent);
- ret = 2;
- } else {
- SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL);
- TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID);
- ret = 0;
- }
- } else {
- /* get WINE_mmThreadEntryPoint()
- * 2047 is its ordinal in mmsystem.spec
- */
- FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
-
- TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp));
-
- ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
- }
-
- if (ret == 0) {
- if (lpMMThd->hThread && !ResumeThread(lpMMThd->hThread))
- WARN("Couldn't resume thread\n");
-
- while (lpMMThd->dwStatus != 0x10) { /* test also HIWORD of dwStatus */
- UserYield16();
- }
- }
- }
-
- if (ret != 0) {
- GlobalFree16(hndl);
- hndl = 0;
- }
-
- if (lpHndl)
- *lpHndl = hndl;
-
- TRACE("ok => %ld\n", ret);
- return ret;
-}
-
-/**************************************************************************
- * mmThreadSignal [MMSYSTEM.1121]
- */
-void WINAPI mmThreadSignal16(HANDLE16 hndl)
-{
- TRACE("(%04x)!\n", hndl);
-
- if (hndl) {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
-
- lpMMThd->dwCounter++;
- if (lpMMThd->hThread != 0) {
- InterlockedIncrement(&lpMMThd->dwSignalCount);
- SetEvent(lpMMThd->hEvent);
- } else {
- mmTaskSignal16(lpMMThd->hTask);
- }
- lpMMThd->dwCounter--;
- }
-}
-
-static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
-{
- MSG msg;
- DWORD ret;
-
- if (lpMMThd->dwThreadID != GetCurrentThreadId())
- ERR("Not called by thread itself\n");
-
- for (;;) {
- ResetEvent(lpMMThd->hEvent);
- if (InterlockedDecrement(&lpMMThd->dwSignalCount) >= 0)
- break;
- InterlockedIncrement(&lpMMThd->dwSignalCount);
-
- TRACE("S1\n");
-
- ret = MsgWaitForMultipleObjects(1, &lpMMThd->hEvent, FALSE, INFINITE, QS_ALLINPUT);
- switch (ret) {
- case WAIT_OBJECT_0: /* Event */
- TRACE("S2.1\n");
- break;
- case WAIT_OBJECT_0 + 1: /* Msg */
- TRACE("S2.2\n");
- if (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
- TranslateMessage(&msg);
- DispatchMessageA(&msg);
- }
- break;
- default:
- WARN("S2.x unsupported ret val 0x%08x\n", ret);
- }
- TRACE("S3\n");
- }
-}
-
-/**************************************************************************
- * mmThreadBlock [MMSYSTEM.1122]
- */
-void WINAPI mmThreadBlock16(HANDLE16 hndl)
-{
- TRACE("(%04x)!\n", hndl);
-
- if (hndl) {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
-
- if (lpMMThd->hThread != 0) {
- DWORD lc;
-
- ReleaseThunkLock(&lc);
- MMSYSTEM_ThreadBlock(lpMMThd);
- RestoreThunkLock(lc);
- } else {
- mmTaskBlock16(lpMMThd->hTask);
- }
- }
- TRACE("done\n");
-}
-
-/**************************************************************************
- * mmThreadIsCurrent [MMSYSTEM.1123]
- */
-BOOL16 WINAPI mmThreadIsCurrent16(HANDLE16 hndl)
-{
- BOOL16 ret = FALSE;
-
- TRACE("(%04x)!\n", hndl);
-
- if (hndl && mmThreadIsValid16(hndl)) {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
- ret = (GetCurrentThreadId() == lpMMThd->dwThreadID);
- }
- TRACE("=> %d\n", ret);
- return ret;
-}
-
-/**************************************************************************
- * mmThreadIsValid [MMSYSTEM.1124]
- */
-BOOL16 WINAPI mmThreadIsValid16(HANDLE16 hndl)
-{
- BOOL16 ret = FALSE;
-
- TRACE("(%04x)!\n", hndl);
-
- if (hndl) {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
-
- if (!IsBadWritePtr(lpMMThd, sizeof(WINE_MMTHREAD)) &&
- lpMMThd->dwSignature == WINE_MMTHREAD_CREATED &&
- IsTask16(lpMMThd->hTask)) {
- lpMMThd->dwCounter++;
- if (lpMMThd->hThread != 0) {
- DWORD dwThreadRet;
- if (GetExitCodeThread(lpMMThd->hThread, &dwThreadRet) &&
- dwThreadRet == STATUS_PENDING) {
- ret = TRUE;
- }
- } else {
- ret = TRUE;
- }
- lpMMThd->dwCounter--;
- }
- }
- TRACE("=> %d\n", ret);
- return ret;
-}
-
-/**************************************************************************
- * mmThreadGetTask [MMSYSTEM.1125]
- */
-HANDLE16 WINAPI mmThreadGetTask16(HANDLE16 hndl)
-{
- HANDLE16 ret = 0;
-
- TRACE("(%04x)\n", hndl);
-
- if (mmThreadIsValid16(hndl)) {
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
- ret = lpMMThd->hTask;
- }
- return ret;
-}
-
-/**************************************************************************
- * __wine_mmThreadEntryPoint (MMSYSTEM.2047)
- */
-DWORD WINAPI WINE_mmThreadEntryPoint(LPVOID p)
-{
- HANDLE16 hndl = (HANDLE16)(DWORD_PTR)p;
- WINE_MMTHREAD* lpMMThd = WINMM_GetmmThread(hndl);
-
- TRACE("(%04x %p)\n", hndl, lpMMThd);
-
- lpMMThd->hTask = LOWORD(GetCurrentTask());
- TRACE("[10-%p] setting hTask to 0x%08x\n", lpMMThd->hThread, lpMMThd->hTask);
- lpMMThd->dwStatus = 0x10;
- MMSYSTEM_ThreadBlock(lpMMThd);
- TRACE("[20-%p]\n", lpMMThd->hThread);
- lpMMThd->dwStatus = 0x20;
- if (lpMMThd->fpThread) {
- WOWCallback16(lpMMThd->fpThread, lpMMThd->dwThreadPmt);
- }
- lpMMThd->dwStatus = 0x30;
- TRACE("[30-%p]\n", lpMMThd->hThread);
- while (lpMMThd->dwCounter) {
- Sleep(1);
- /* WOWYield16();*/
- }
- TRACE("[XX-%p]\n", lpMMThd->hThread);
- /* paranoia */
- lpMMThd->dwSignature = WINE_MMTHREAD_DELETED;
- /* close lpMMThread->hVxD directIO */
- if (lpMMThd->hEvent)
- CloseHandle(lpMMThd->hEvent);
- GlobalFree16(hndl);
- TRACE("done\n");
-
- return 0;
-}
-
-typedef BOOL16 (WINAPI *MMCPLCALLBACK)(HWND, LPCSTR, LPCSTR, LPCSTR);
-
-/**************************************************************************
- * mmShowMMCPLPropertySheet [MMSYSTEM.1150]
- */
-BOOL16 WINAPI mmShowMMCPLPropertySheet16(HWND hWnd, LPCSTR lpStrDevice,
- LPCSTR lpStrTab, LPCSTR lpStrTitle)
-{
- HANDLE hndl;
- BOOL16 ret = FALSE;
-
- TRACE("(%p \"%s\" \"%s\" \"%s\")\n", hWnd, lpStrDevice, lpStrTab, lpStrTitle);
-
- hndl = LoadLibraryA("MMSYS.CPL");
- if (hndl != 0) {
- MMCPLCALLBACK fp = (MMCPLCALLBACK)GetProcAddress(hndl, "ShowMMCPLPropertySheet");
- if (fp != NULL) {
- DWORD lc;
- ReleaseThunkLock(&lc);
- ret = (fp)(hWnd, lpStrDevice, lpStrTab, lpStrTitle);
- RestoreThunkLock(lc);
- }
- FreeLibrary(hndl);
- }
-
- return ret;
-}
-
-/**************************************************************************
- * StackEnter [MMSYSTEM.32]
- */
-void WINAPI StackEnter16(void)
-{
-#ifdef __i386__
- /* mmsystem.dll from Win 95 does only this: so does Wine */
- __asm__("stc");
-#endif
-}
-
-/**************************************************************************
- * StackLeave [MMSYSTEM.33]
- */
-void WINAPI StackLeave16(void)
-{
-#ifdef __i386__
- /* mmsystem.dll from Win 95 does only this: so does Wine */
- __asm__("stc");
-#endif
-}
-
-/**************************************************************************
- * WMMMidiRunOnce [MMSYSTEM.8]
- */
-void WINAPI WMMMidiRunOnce16(void)
-{
- FIXME("(), stub!\n");
-}
-
-/**************************************************************************
- * DrvOpen [MMSYSTEM.1100]
- */
-HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
-{
- return OpenDriver16(lpDriverName, lpSectionName, lParam);
-}
-
-/**************************************************************************
- * DrvClose [MMSYSTEM.1101]
- */
-LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
-{
- return CloseDriver16(hDrv, lParam1, lParam2);
-}
-
-/**************************************************************************
- * DrvSendMessage [MMSYSTEM.1102]
- */
-LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
- LPARAM lParam2)
-{
- return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
-}
-
-/**************************************************************************
- * DrvGetModuleHandle [MMSYSTEM.1103]
- */
-HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
-{
- return GetDriverModuleHandle16(hDrv);
-}
-
-/**************************************************************************
- * DrvDefDriverProc [MMSYSTEM.1104]
- */
-LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
- DWORD dwParam1, DWORD dwParam2)
-{
- return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
-}
-
-/**************************************************************************
- * DriverProc [MMSYSTEM.6]
- */
-LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
- DWORD dwParam1, DWORD dwParam2)
-{
- TRACE("dwDevID=%08x hDrv=%04x wMsg=%04x dwParam1=%08x dwParam2=%08x\n",
- dwDevID, hDrv, wMsg, dwParam1, dwParam2);
-
- return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
-}
-
-/* ###################################################
- * # TIME #
- * ###################################################
- */
-
-/******************************************************************
- * MMSYSTEM_MMTIME32to16
- *
- *
- */
-void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32)
-{
- mmt16->wType = mmt32->wType;
- /* layout of rest is the same for 32/16,
- * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
- */
- memcpy(&(mmt16->u), &(mmt32->u), sizeof(mmt16->u));
-}
-
-/******************************************************************
- * MMSYSTEM_MMTIME16to32
- *
- *
- */
-void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16)
-{
- mmt32->wType = mmt16->wType;
- /* layout of rest is the same for 32/16,
- * Note: mmt16->u is 2 bytes smaller than mmt32->u, which has padding
- */
- memcpy(&(mmt32->u), &(mmt16->u), sizeof(mmt16->u));
-}
-
-/**************************************************************************
- * timeGetSystemTime [MMSYSTEM.601]
- */
-MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
-{
- if (wSize >= sizeof(*lpTime)) {
- lpTime->wType = TIME_MS;
- lpTime->u.ms = GetTickCount();
-
- TRACE("=> %u\n", lpTime->u.ms);
- }
-
- return 0;
-}
-
-struct timer_entry {
- struct list entry;
- UINT id;
- LPTIMECALLBACK16 func16;
- DWORD user;
-};
-
-static struct list timer_list = LIST_INIT(timer_list);
-
-static void CALLBACK timeCB3216(UINT id, UINT uMsg, DWORD_PTR user, DWORD_PTR dw1, DWORD_PTR dw2)
-{
- struct timer_entry* te = (void*)user;
- WORD args[8];
- DWORD ret;
-
- args[7] = LOWORD(id);
- args[6] = LOWORD(uMsg);
- args[5] = HIWORD(te->user);
- args[4] = LOWORD(te->user);
- args[3] = HIWORD(dw1);
- args[2] = LOWORD(dw2);
- args[1] = HIWORD(dw2);
- args[0] = LOWORD(dw2);
- WOWCallback16Ex((DWORD)te->func16, WCB16_PASCAL, sizeof(args), args, &ret);
-}
-
-/**************************************************************************
- * timeSetEvent [MMSYSTEM.602]
- */
-MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
- DWORD dwUser, UINT16 wFlags)
-{
- MMRESULT16 id;
- struct timer_entry* te;
-
- switch (wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE))
- {
- case TIME_CALLBACK_EVENT_SET:
- case TIME_CALLBACK_EVENT_PULSE:
- id = timeSetEvent(wDelay, wResol, (LPTIMECALLBACK)lpFunc, dwUser, wFlags);
- break;
- case TIME_CALLBACK_FUNCTION:
- te = HeapAlloc(GetProcessHeap(), 0, sizeof(*te));
- if (!te) return 0;
- te->func16 = lpFunc;
- te->user = dwUser;
- id = te->id = timeSetEvent(wDelay, wResol, timeCB3216, (DWORD_PTR)te, wFlags);
- if (id)
- {
- EnterCriticalSection(&mmdrv_cs);
- list_add_tail(&timer_list, &te->entry);
- LeaveCriticalSection(&mmdrv_cs);
- }
- else HeapFree(GetProcessHeap(), 0, te);
- break;
- default:
- id = 0;
- break;
- }
- return id;
-}
-
-/**************************************************************************
- * timeKillEvent [MMSYSTEM.603]
- */
-MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
-{
- MMRESULT16 ret = timeKillEvent(wID);
- struct timer_entry* te;
-
- if (ret == TIMERR_NOERROR)
- {
- EnterCriticalSection(&mmdrv_cs);
- LIST_FOR_EACH_ENTRY(te, &timer_list, struct timer_entry, entry)
- {
- if (wID == te->id)
- {
- list_remove(&te->entry);
- HeapFree(GetProcessHeap(), 0, te);
- break;
- }
- }
- LeaveCriticalSection(&mmdrv_cs);
- }
- return ret;
-}
-
-/**************************************************************************
- * timeGetDevCaps [MMSYSTEM.604]
- */
-MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16 lpCaps, UINT16 wSize)
-{
- TIMECAPS caps;
- MMRESULT ret;
- TRACE("(%p, %u) !\n", lpCaps, wSize);
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = timeGetDevCaps(&caps, sizeof(caps));
- if (ret == MMSYSERR_NOERROR) {
- TIMECAPS16 tc16;
- tc16.wPeriodMin = caps.wPeriodMin;
- tc16.wPeriodMax = caps.wPeriodMax;
- memcpy(lpCaps, &tc16, min(wSize, sizeof(tc16)));
- }
- return ret;
-}
-
-/**************************************************************************
- * timeBeginPeriod [MMSYSTEM.605]
- */
-MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
-{
- TRACE("(%u) !\n", wPeriod);
-
- return timeBeginPeriod(wPeriod);
-}
-
-/**************************************************************************
- * timeEndPeriod [MMSYSTEM.606]
- */
-MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
-{
- TRACE("(%u) !\n", wPeriod);
-
- return timeEndPeriod(wPeriod);
-}
-
-/**************************************************************************
- * timeGetTime [MMSYSTEM.607]
- */
-DWORD WINAPI timeGetTime16(void)
-{
- return timeGetTime();
-}
-
-/* ###################################################
- * # JOYSTICK #
- * ###################################################
- */
-
-/**************************************************************************
- * joyGetNumDevs [MMSYSTEM.101]
- */
-UINT16 WINAPI joyGetNumDevs16(void)
-{
- return joyGetNumDevs();
-}
-
-/**************************************************************************
- * joyGetDevCaps [MMSYSTEM.102]
- */
-MMRESULT16 WINAPI joyGetDevCaps16(UINT16 wID, LPJOYCAPS16 lpCaps, UINT16 wSize)
-{
- JOYCAPSA jca;
- MMRESULT ret;
-
- if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
-
- ret = joyGetDevCapsA(wID, &jca, sizeof(jca));
-
- if (ret != JOYERR_NOERROR) return ret;
- lpCaps->wMid = jca.wMid;
- lpCaps->wPid = jca.wPid;
- strcpy(lpCaps->szPname, jca.szPname);
- lpCaps->wXmin = jca.wXmin;
- lpCaps->wXmax = jca.wXmax;
- lpCaps->wYmin = jca.wYmin;
- lpCaps->wYmax = jca.wYmax;
- lpCaps->wZmin = jca.wZmin;
- lpCaps->wZmax = jca.wZmax;
- lpCaps->wNumButtons = jca.wNumButtons;
- lpCaps->wPeriodMin = jca.wPeriodMin;
- lpCaps->wPeriodMax = jca.wPeriodMax;
-
- if (wSize >= sizeof(JOYCAPS16)) { /* Win95 extensions ? */
- lpCaps->wRmin = jca.wRmin;
- lpCaps->wRmax = jca.wRmax;
- lpCaps->wUmin = jca.wUmin;
- lpCaps->wUmax = jca.wUmax;
- lpCaps->wVmin = jca.wVmin;
- lpCaps->wVmax = jca.wVmax;
- lpCaps->wCaps = jca.wCaps;
- lpCaps->wMaxAxes = jca.wMaxAxes;
- lpCaps->wNumAxes = jca.wNumAxes;
- lpCaps->wMaxButtons = jca.wMaxButtons;
- strcpy(lpCaps->szRegKey, jca.szRegKey);
- strcpy(lpCaps->szOEMVxD, jca.szOEMVxD);
- }
-
- return ret;
-}
-
-/**************************************************************************
- * joyGetPosEx [MMSYSTEM.110]
- */
-MMRESULT16 WINAPI joyGetPosEx16(UINT16 wID, LPJOYINFOEX lpInfo)
-{
- return joyGetPosEx(wID, lpInfo);
-}
-
-/**************************************************************************
- * joyGetPos [MMSYSTEM.103]
- */
-MMRESULT16 WINAPI joyGetPos16(UINT16 wID, LPJOYINFO16 lpInfo)
-{
- JOYINFO ji;
- MMRESULT ret;
-
- TRACE("(%d, %p);\n", wID, lpInfo);
-
- if ((ret = joyGetPos(wID, &ji)) == JOYERR_NOERROR) {
- lpInfo->wXpos = ji.wXpos;
- lpInfo->wYpos = ji.wYpos;
- lpInfo->wZpos = ji.wZpos;
- lpInfo->wButtons = ji.wButtons;
- }
- return ret;
-}
-
-/**************************************************************************
- * joyGetThreshold [MMSYSTEM.104]
- */
-MMRESULT16 WINAPI joyGetThreshold16(UINT16 wID, LPUINT16 lpThreshold)
-{
- UINT t;
- MMRESULT ret;
-
- ret = joyGetThreshold(wID, &t);
- if (ret == JOYERR_NOERROR)
- *lpThreshold = t;
- return ret;
-}
-
-/**************************************************************************
- * joyReleaseCapture [MMSYSTEM.105]
- */
-MMRESULT16 WINAPI joyReleaseCapture16(UINT16 wID)
-{
- return joyReleaseCapture(wID);
-}
-
-/**************************************************************************
- * joySetCapture [MMSYSTEM.106]
- */
-MMRESULT16 WINAPI joySetCapture16(HWND16 hWnd, UINT16 wID, UINT16 wPeriod, BOOL16 bChanged)
-{
- return joySetCapture(HWND_32(hWnd), wID, wPeriod, bChanged);
-}
-
-/**************************************************************************
- * joySetThreshold [MMSYSTEM.107]
- */
-MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
-{
- return joySetThreshold(wID,wThreshold);
-}
-
-/**************************************************************************
- * joySetCalibration [MMSYSTEM.109]
- */
-MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
-{
- FIXME("(%04X): stub.\n", wID);
- return JOYERR_NOCANDO;
-}
diff --git a/dlls/winmm/mmsystem.spec b/dlls/winmm/mmsystem.spec
deleted file mode 100644
index 66d1e9b..0000000
--- a/dlls/winmm/mmsystem.spec
+++ /dev/null
@@ -1,176 +0,0 @@
-1 pascal WEP(word word word ptr) MMSYSTEM_WEP
-2 pascal sndPlaySound(ptr word) sndPlaySound16
-3 pascal PlaySound(ptr word long) PlaySound16
-4 pascal DllEntryPoint(long word word word long word) MMSYSTEM_LibMain
-5 pascal mmsystemGetVersion() mmsystemGetVersion16
-6 pascal DriverProc(long word word long long) DriverProc16
-8 pascal WMMMidiRunOnce() WMMMidiRunOnce16
-30 pascal -ret16 OutputDebugStr(str) OutputDebugStr16
-31 pascal DriverCallback(long word word word long long long) DriverCallback16
-32 pascal StackEnter() StackEnter16
-33 pascal StackLeave() StackLeave16
-34 stub MMDRVINSTALL
-101 pascal joyGetNumDevs() joyGetNumDevs16
-102 pascal joyGetDevCaps(word ptr word) joyGetDevCaps16
-103 pascal joyGetPos(word ptr) joyGetPos16
-104 pascal joyGetThreshold(word ptr) joyGetThreshold16
-105 pascal joyReleaseCapture(word) joyReleaseCapture16
-106 pascal joySetCapture(word word word word) joySetCapture16
-107 pascal joySetThreshold(word word) joySetThreshold16
-109 pascal joySetCalibration(word) joySetCalibration16
-110 pascal joyGetPosEx(word ptr) joyGetPosEx16
-111 stub JOYCONFIGCHANGED
-201 pascal midiOutGetNumDevs() midiOutGetNumDevs16
-202 pascal midiOutGetDevCaps(word ptr word) midiOutGetDevCaps16
-203 pascal midiOutGetErrorText(word ptr word) midiOutGetErrorText16
-204 pascal midiOutOpen(ptr word long long long) midiOutOpen16
-205 pascal midiOutClose(word) midiOutClose16
-206 pascal midiOutPrepareHeader(word segptr word) midiOutPrepareHeader16
-207 pascal midiOutUnprepareHeader(word segptr word) midiOutUnprepareHeader16
-208 pascal midiOutShortMsg(word long) midiOutShortMsg16
-209 pascal midiOutLongMsg(word segptr word) midiOutLongMsg16
-210 pascal midiOutReset(word) midiOutReset16
-211 pascal midiOutGetVolume(word ptr) midiOutGetVolume16
-212 pascal midiOutSetVolume(word long) midiOutSetVolume16
-213 pascal midiOutCachePatches(word word ptr word) midiOutCachePatches16
-214 pascal midiOutCacheDrumPatches(word word ptr word) midiOutCacheDrumPatches16
-215 pascal midiOutGetID(word ptr) midiOutGetID16
-216 pascal midiOutMessage(word word long long) midiOutMessage16
-250 pascal midiStreamProperty(word ptr long) midiStreamProperty16
-251 pascal midiStreamOpen(ptr ptr long long long long) midiStreamOpen16
-252 pascal midiStreamClose(word) midiStreamClose16
-253 pascal midiStreamPosition(word ptr word) midiStreamPosition16
-254 pascal midiStreamOut(word ptr word) midiStreamOut16
-255 pascal midiStreamPause(word) midiStreamPause16
-256 pascal midiStreamRestart(word) midiStreamRestart16
-257 pascal midiStreamStop(word) midiStreamStop16
-301 pascal midiInGetNumDevs() midiInGetNumDevs16
-302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16
-303 pascal midiInGetErrorText(word ptr word) midiOutGetErrorText16
-304 pascal midiInOpen(ptr word long long long) midiInOpen16
-305 pascal midiInClose(word) midiInClose16
-306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16
-307 pascal midiInUnprepareHeader(word segptr word) midiInUnprepareHeader16
-308 pascal midiInAddBuffer(word segptr word) midiInAddBuffer16
-309 pascal midiInStart(word) midiInStart16
-310 pascal midiInStop(word) midiInStop16
-311 pascal midiInReset(word) midiInReset16
-312 pascal midiInGetID(word ptr) midiInGetID16
-313 pascal midiInMessage(word word long long) midiInMessage16
-350 pascal auxGetNumDevs() auxGetNumDevs16
-351 pascal auxGetDevCaps(word ptr word) auxGetDevCaps16
-352 pascal auxGetVolume(word ptr) auxGetVolume16
-353 pascal auxSetVolume(word long) auxSetVolume16
-354 pascal auxOutMessage(word word long long) auxOutMessage16
-401 pascal waveOutGetNumDevs() waveOutGetNumDevs16
-402 pascal waveOutGetDevCaps(word ptr word) waveOutGetDevCaps16
-403 pascal waveOutGetErrorText(word ptr word) waveOutGetErrorText16
-404 pascal waveOutOpen(ptr word ptr long long long) waveOutOpen16
-405 pascal waveOutClose(word) waveOutClose16
-406 pascal waveOutPrepareHeader(word segptr word) waveOutPrepareHeader16
-407 pascal waveOutUnprepareHeader(word segptr word) waveOutUnprepareHeader16
-408 pascal waveOutWrite(word segptr word) waveOutWrite16
-409 pascal waveOutPause(word) waveOutPause16
-410 pascal waveOutRestart(word) waveOutRestart16
-411 pascal waveOutReset(word) waveOutReset16
-412 pascal waveOutGetPosition(word ptr word) waveOutGetPosition16
-413 pascal waveOutGetPitch(word ptr) waveOutGetPitch16
-414 pascal waveOutSetPitch(word long) waveOutSetPitch16
-415 pascal waveOutGetVolume(word ptr) waveOutGetVolume16
-416 pascal waveOutSetVolume(word long) waveOutSetVolume16
-417 pascal waveOutGetPlaybackRate(word ptr) waveOutGetPlaybackRate16
-418 pascal waveOutSetPlaybackRate(word long) waveOutSetPlaybackRate16
-419 pascal waveOutBreakLoop(word) waveOutBreakLoop16
-420 pascal waveOutGetID(word ptr) waveOutGetID16
-421 pascal waveOutMessage(word word long long) waveOutMessage16
-501 pascal waveInGetNumDevs() waveInGetNumDevs16
-502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16
-503 pascal waveInGetErrorText(word ptr word) waveOutGetErrorText16
-504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16
-505 pascal waveInClose(word) waveInClose16
-506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16
-507 pascal waveInUnprepareHeader(word segptr word) waveInUnprepareHeader16
-508 pascal waveInAddBuffer(word segptr word) waveInAddBuffer16
-509 pascal waveInStart(word) waveInStart16
-510 pascal waveInStop(word) waveInStop16
-511 pascal waveInReset(word) waveInReset16
-512 pascal waveInGetPosition(word ptr word) waveInGetPosition16
-513 pascal waveInGetID(word ptr) waveInGetID16
-514 pascal waveInMessage(word word long long) waveInMessage16
-601 pascal timeGetSystemTime(ptr word) timeGetSystemTime16
-602 pascal timeSetEvent(word word segptr long word) timeSetEvent16
-603 pascal timeKillEvent(word) timeKillEvent16
-604 pascal timeGetDevCaps(ptr word) timeGetDevCaps16
-605 pascal timeBeginPeriod(word) timeBeginPeriod16
-606 pascal timeEndPeriod(word) timeEndPeriod16
-607 pascal timeGetTime() timeGetTime16
-701 pascal mciSendCommand(word word long long) mciSendCommand16
-702 pascal mciSendString(str ptr word word) mciSendString16
-703 pascal mciGetDeviceID(ptr) mciGetDeviceID16
-705 pascal mciLoadCommandResource(word str word) mciLoadCommandResource16
-706 pascal mciGetErrorString(long ptr word) mciGetErrorString16
-707 pascal mciSetDriverData(word long) mciSetDriverData16
-708 pascal mciGetDriverData(word) mciGetDriverData16
-710 pascal mciDriverYield(word) mciDriverYield16
-711 pascal mciDriverNotify(word word word) mciDriverNotify16
-712 pascal mciExecute(ptr) mciExecute16
-713 pascal mciFreeCommandResource(word) mciFreeCommandResource16
-714 pascal mciSetYieldProc(word ptr long) mciSetYieldProc16
-715 pascal mciGetDeviceIDFromElementID(long ptr) mciGetDeviceIDFromElementID16
-716 pascal mciGetYieldProc(word ptr) mciGetYieldProc16
-717 pascal mciGetCreatorTask(word) mciGetCreatorTask16
-800 pascal mixerGetNumDevs() mixerGetNumDevs16
-801 pascal mixerGetDevCaps(word ptr word) mixerGetDevCaps16
-802 pascal mixerOpen(ptr word long long long) mixerOpen16
-803 pascal mixerClose(word) mixerClose16
-804 pascal mixerMessage(word word long long) mixerMessage16
-805 pascal mixerGetLineInfo(word ptr long) mixerGetLineInfo16
-806 pascal mixerGetID(word ptr long) mixerGetID16
-807 pascal mixerGetLineControls(word ptr long) mixerGetLineControls16
-808 pascal mixerGetControlDetails(word ptr long) mixerGetControlDetails16
-809 pascal mixerSetControlDetails(word ptr long) mixerSetControlDetails16
-900 pascal mmTaskCreate(long ptr long) mmTaskCreate16
-902 pascal mmTaskBlock(word) mmTaskBlock16
-903 pascal mmTaskSignal(word) mmTaskSignal16
-904 pascal -ret16 mmGetCurrentTask() mmGetCurrentTask16
-905 pascal mmTaskYield() mmTaskYield16
-1100 pascal DrvOpen(str str long) DrvOpen16
-1101 pascal DrvClose(word long long) DrvClose16
-1102 pascal DrvSendMessage(word word long long) DrvSendMessage16
-1103 pascal DrvGetModuleHandle(word) DrvGetModuleHandle16
-1104 pascal DrvDefDriverProc(long word word long long) DrvDefDriverProc16
-1120 pascal mmThreadCreate(segptr ptr long long) mmThreadCreate16
-1121 pascal mmThreadSignal(word) mmThreadSignal16
-1122 pascal mmThreadBlock(word) mmThreadBlock16
-1123 pascal mmThreadIsCurrent(word) mmThreadIsCurrent16
-1124 pascal mmThreadIsValid(word) mmThreadIsValid16
-1125 pascal mmThreadGetTask(word) mmThreadGetTask16
-1150 pascal mmShowMMCPLPropertySheet(word str str str) mmShowMMCPLPropertySheet16
-
-1210 pascal mmioOpen(str ptr long) mmioOpen16
-1211 pascal mmioClose(word word) mmioClose16
-1212 pascal mmioRead(word ptr long) mmioRead16
-1213 pascal mmioWrite(word ptr long) mmioWrite16
-1214 pascal mmioSeek(word long word) mmioSeek16
-1215 pascal mmioGetInfo(word ptr word) mmioGetInfo16
-1216 pascal mmioSetInfo(word ptr word) mmioSetInfo16
-1217 pascal mmioSetBuffer(word segptr long word) mmioSetBuffer16
-1218 pascal mmioFlush(word word) mmioFlush16
-1219 pascal mmioAdvance(word ptr word) mmioAdvance16
-1220 pascal mmioStringToFOURCC(str word) mmioStringToFOURCC16
-1221 pascal mmioInstallIOProc(long ptr long) mmioInstallIOProc16
-1222 pascal mmioSendMessage(word word long long) mmioSendMessage16
-1223 pascal mmioDescend(word ptr ptr word) mmioDescend16
-1224 pascal mmioAscend(word ptr word) mmioAscend16
-1225 pascal mmioCreateChunk(word ptr word) mmioCreateChunk16
-1226 pascal mmioRename(ptr ptr ptr long) mmioRename16
-
-#2000 stub WINMMF_THUNKDATA16
-#2001 stub RING3_DEVLOADER
-#2002 stub WINMMTILEBUFFER
-#2003 stub WINMMUNTILEBUFFER
-#2005 stub MCIGETTHUNKTABLE
-#2006 stub WINMMSL_THUNKDATA16
-
-# these are Wine only exported functions. Is there another way to do it ?
-2047 pascal __wine_mmThreadEntryPoint(long) WINE_mmThreadEntryPoint
diff --git a/dlls/winmm/winemm16.h b/dlls/winmm/winemm16.h
deleted file mode 100644
index 2435e90..0000000
--- a/dlls/winmm/winemm16.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 1998, Luiz Otavio L. Zorzella
- * 1999, Eric Pouech
- *
- * Purpose: multimedia declarations (internal to WINMM & MMSYSTEM DLLs)
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
- */
-
-#include "wine/mmsystem16.h"
-#include "wownt32.h"
-
-/* mmsystem (16 bit files) only functions */
-void MMDRV_Init16(void);
-void MMSYSTEM_MMTIME16to32(LPMMTIME mmt32, const MMTIME16* mmt16);
-void MMSYSTEM_MMTIME32to16(LPMMTIME16 mmt16, const MMTIME* mmt32);
-
-typedef LONG (*MCIPROC16)(DWORD, HDRVR16, WORD, DWORD, DWORD);
-
-/* HANDLE16 -> HANDLE conversions */
-#define HDRVR_32(h16) ((HDRVR)(ULONG_PTR)(h16))
-#define HMIDI_32(h16) ((HMIDI)(ULONG_PTR)(h16))
-#define HMIDIIN_32(h16) ((HMIDIIN)(ULONG_PTR)(h16))
-#define HMIDIOUT_32(h16) ((HMIDIOUT)(ULONG_PTR)(h16))
-#define HMIDISTRM_32(h16) ((HMIDISTRM)(ULONG_PTR)(h16))
-#define HMIXER_32(h16) ((HMIXER)(ULONG_PTR)(h16))
-#define HMIXEROBJ_32(h16) ((HMIXEROBJ)(ULONG_PTR)(h16))
-#define HMMIO_32(h16) ((HMMIO)(ULONG_PTR)(h16))
-#define HWAVE_32(h16) ((HWAVE)(ULONG_PTR)(h16))
-#define HWAVEIN_32(h16) ((HWAVEIN)(ULONG_PTR)(h16))
-#define HWAVEOUT_32(h16) ((HWAVEOUT)(ULONG_PTR)(h16))
-
-/* HANDLE -> HANDLE16 conversions */
-#define HDRVR_16(h32) (LOWORD(h32))
-#define HMIDI_16(h32) (LOWORD(h32))
-#define HMIDIIN_16(h32) (LOWORD(h32))
-#define HMIDIOUT_16(h32) (LOWORD(h32))
-#define HMIDISTRM_16(h32) (LOWORD(h32))
-#define HMIXER_16(h32) (LOWORD(h32))
-#define HMIXEROBJ_16(h32) (LOWORD(h32))
-#define HMMIO_16(h32) (LOWORD(h32))
-#define HWAVE_16(h32) (LOWORD(h32))
-#define HWAVEIN_16(h32) (LOWORD(h32))
-#define HWAVEOUT_16(h32) (LOWORD(h32))
-
-typedef enum {
- MMSYSTEM_MAP_NOMEM, /* ko, memory problem */
- MMSYSTEM_MAP_MSGERROR, /* ko, unknown message */
- MMSYSTEM_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
- MMSYSTEM_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
-} MMSYSTEM_MapType;
-
-extern CRITICAL_SECTION mmdrv_cs;
-
-enum MMSYSTEM_DriverType
-{
- MMSYSTDRV_MIXER,
- MMSYSTDRV_MIDIIN,
- MMSYSTDRV_MIDIOUT,
- MMSYSTDRV_WAVEIN,
- MMSYSTDRV_WAVEOUT,
- MMSYSTDRV_MAX
-};
-
-extern struct mmsystdrv_thunk* MMSYSTDRV_AddThunk(DWORD pfn16, enum MMSYSTEM_DriverType kind);
-extern void MMSYSTDRV_DeleteThunk(struct mmsystdrv_thunk* thunk);
-extern void MMSYSTDRV_SetHandle(struct mmsystdrv_thunk* thunk, void* h);
-extern void MMSYSTDRV_CloseHandle(void* h);
-extern DWORD MMSYSTDRV_Message(void* h, UINT msg, DWORD_PTR param1, DWORD_PTR param2);
-
-#define WINE_MMTHREAD_CREATED 0x4153494C /* "BSIL" */
-#define WINE_MMTHREAD_DELETED 0xDEADDEAD
-
-typedef struct {
- DWORD dwSignature; /* 00 "BSIL" when ok, 0xDEADDEAD when being deleted */
- DWORD dwCounter; /* 04 > 1 when in mmThread functions */
- HANDLE hThread; /* 08 hThread */
- DWORD dwThreadID; /* 0C */
- DWORD fpThread; /* 10 address of thread proc (segptr or lin depending on dwFlags) */
- DWORD dwThreadPmt; /* 14 parameter to be passed upon thread creation to fpThread */
- LONG dwSignalCount; /* 18 counter used for signaling */
- HANDLE hEvent; /* 1C event */
- HANDLE hVxD; /* 20 return from OpenVxDHandle */
- DWORD dwStatus; /* 24 0x00, 0x10, 0x20, 0x30 */
- DWORD dwFlags; /* 28 dwFlags upon creation */
- UINT16 hTask; /* 2C handle to created task */
-} WINE_MMTHREAD;
More information about the wine-patches
mailing list