winmm: rename a 16-Bit File (mmsystem)

Detlef Riekenberg wine.dev at web.de
Thu Feb 1 13:59:37 CST 2007


Got lost, so i send it again:

-------- Forwarded Message --------
From: Detlef Riekenberg <wine.dev at web.de>
To: wine-patches at winehq.org <wine-patches at winehq.org>
Subject: winmm: rename a 16-Bit File (mmsystem)
Date: Wed, 31 Jan 2007 22:37:40 +0100

Janatorial: 16-Bit Separation


Changelog:
winmm: rename a 16-Bit File (mmsystem)



-- 
 
By by ... Detlef

-------------- next part --------------
>From ce91227ab3e57e85fe36273d5f738501055468d8 Mon Sep 17 00:00:00 2001
From: Detlef Riekenberg <wine.dev at web.de>
Date: Wed, 31 Jan 2007 22:22:54 +0100
Subject: [PATCH] winmm: rename 16-Bit File (mmsystem.c)
---
 dlls/winmm/Makefile.in  |    2 
 dlls/winmm/mmsystem.c   | 3215 -----------------------------------------------
 dlls/winmm/mmsystem16.c | 3215 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 3216 insertions(+), 3216 deletions(-)

diff --git a/dlls/winmm/Makefile.in b/dlls/winmm/Makefile.in
index 850a656..af8eef5 100644
--- a/dlls/winmm/Makefile.in
+++ b/dlls/winmm/Makefile.in
@@ -19,7 +19,7 @@ C_SRCS = \
 
 C_SRCS16 = \
 	message16.c \
-	mmsystem.c \
+	mmsystem16.c \
 	sound16.c
 
 SPEC_SRCS16 = \
diff --git a/dlls/winmm/mmsystem.c b/dlls/winmm/mmsystem.c
deleted file mode 100644
index 83f63d4..0000000
--- a/dlls/winmm/mmsystem.c
+++ /dev/null
@@ -1,3215 +0,0 @@
-/* -*- tab-width: 8; c-basic-offset: 4 -*- */
-
-/*
- * MMSYTEM 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 "winreg.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);
-
-static WINE_MMTHREAD*   WINMM_GetmmThread(HANDLE16);
-static LPWINE_DRIVER    DRIVER_OpenDriver16(LPCWSTR, LPCWSTR, LPARAM);
-static LRESULT          DRIVER_CloseDriver16(HDRVR16, LPARAM, LPARAM);
-static LRESULT          DRIVER_SendMessage16(HDRVR16, UINT, LPARAM, LPARAM);
-static LRESULT          MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM);
-
-/* ###################################################
- * #                  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);
-
-    switch (fdwReason) {
-    case DLL_PROCESS_ATTACH:
-	/* need to load WinMM in order to:
-	 * - initiate correctly shared variables (WINMM_Init())
-	 */
-        if (!GetModuleHandleA("WINMM.DLL"))
-        {
-            ERR("Could not load sibling WinMM.dll\n");
-            return FALSE;
-	}
-	WINMM_IData.hWinMM16Instance = hinstDLL;
-        /* hook in our 16 bit function pointers */
-        pFnGetMMThread16    = WINMM_GetmmThread;
-        pFnOpenDriver16     = DRIVER_OpenDriver16;
-        pFnCloseDriver16    = DRIVER_CloseDriver16;
-        pFnSendMessage16    = DRIVER_SendMessage16;
-        pFnMmioCallback16   = MMIO_Callback16;
-        pFnReleaseThunkLock = ReleaseThunkLock;
-        pFnRestoreThunkLock = RestoreThunkLock;
-        MMDRV_Init16();
-	break;
-    case DLL_PROCESS_DETACH:
-	WINMM_IData.hWinMM16Instance = 0;
-        pFnGetMMThread16    = NULL;
-        pFnOpenDriver16     = NULL;
-        pFnCloseDriver16    = NULL;
-        pFnSendMessage16    = NULL;
-        pFnMmioCallback16   = NULL;
-        pFnReleaseThunkLock = NULL;
-        pFnRestoreThunkLock = NULL;
-        /* FIXME: add equivalent for MMDRV_Init16() */
-	break;
-    case DLL_THREAD_ATTACH:
-    case DLL_THREAD_DETACH:
-	break;
-    }
-    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 MMDRV_GetNum(MMDRV_MIXER);
-}
-
-/**************************************************************************
- * 				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;
-
-    ret = MIXER_Open(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen, FALSE);
-    if (lphmix) *lphmix = HMIXER_16(hmix);
-    return ret;
-}
-
-/**************************************************************************
- * 				mixerClose			[MMSYSTEM.803]
- */
-UINT16 WINAPI mixerClose16(HMIXER16 hMix)
-{
-    return mixerClose(HMIXER_32(hMix));
-}
-
-/**************************************************************************
- * 				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);
-}
-
-/**************************************************************************
- * 				auxGetNumDevs		[MMSYSTEM.350]
- */
-UINT16 WINAPI auxGetNumDevs16(void)
-{
-    return MMDRV_GetNum(MMDRV_AUX);
-}
-
-/* ###################################################
- * #                     AUX                         #
- * ###################################################
- */
-
-/**************************************************************************
- * 				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)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
-
-    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-    return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
-}
-
-/**************************************************************************
- * 				auxSetVolume		[MMSYSTEM.353]
- */
-UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
-
-    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-    return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
-}
-
-/**************************************************************************
- * 				auxOutMessage		[MMSYSTEM.354]
- */
-DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
-{
-    LPWINE_MLD		wmld;
-
-    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 auxGetVolume16(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;
-    }
-    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
-}
-
-/* ###################################################
- * #                     MCI                         #
- * ###################################################
- */
-
-/**************************************************************************
- * 				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 dwParam2)
-{
-    DWORD		dwRet;
-
-    TRACE("(%04X, %s, %08X, %08X)\n",
-	  wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
-
-    dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE);
-    dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2));
-    TRACE("=> %d\n", dwRet);
-    return dwRet;
-}
-
-/**************************************************************************
- * 				mciGetDeviceID		       	[MMSYSTEM.703]
- */
-UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
-{
-    TRACE("(\"%s\")\n", lpstrName);
-
-    return mciGetDeviceIDA(lpstrName);
-}
-
-/**************************************************************************
- * 				mciSetYieldProc			[MMSYSTEM.714]
- */
-BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
-{
-    LPWINE_MCIDRIVER	wmd;
-
-    TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
-
-    if (!(wmd = MCI_GetDriver(uDeviceID))) {
-	WARN("Bad uDeviceID\n");
-	return FALSE;
-    }
-
-    wmd->lpfnYieldProc = (YIELDPROC)fpYieldProc;
-    wmd->dwYieldData   = dwYieldData;
-    wmd->bIs32         = FALSE;
-
-    return TRUE;
-}
-
-/**************************************************************************
- * 				mciGetDeviceIDFromElementID	[MMSYSTEM.715]
- */
-UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
-{
-    FIXME("(%u, %s) stub\n", dwElementID, lpstrType);
-    return 0;
-}
-
-/**************************************************************************
- * 				mciGetYieldProc			[MMSYSTEM.716]
- */
-YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
-{
-    LPWINE_MCIDRIVER	wmd;
-
-    TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
-
-    if (!(wmd = MCI_GetDriver(uDeviceID))) {
-	WARN("Bad uDeviceID\n");
-	return NULL;
-    }
-    if (!wmd->lpfnYieldProc) {
-	WARN("No proc set\n");
-	return NULL;
-    }
-    if (wmd->bIs32) {
-	WARN("Proc is 32 bit\n");
-	return NULL;
-    }
-    return (YIELDPROC16)wmd->lpfnYieldProc;
-}
-
-/**************************************************************************
- * 				mciGetCreatorTask		[MMSYSTEM.717]
- */
-HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
-{
-    LPWINE_MCIDRIVER wmd;
-    HTASK16 ret = 0;
-
-    if ((wmd = MCI_GetDriver(uDeviceID))) 
-        ret = HTASK_16(wmd->CreatorThread);
-
-    TRACE("(%u) => %04x\n", uDeviceID, ret);
-    return ret;
-}
-
-/**************************************************************************
- * 				mciDriverYield			[MMSYSTEM.710]
- */
-UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
-{
-    LPWINE_MCIDRIVER	wmd;
-    UINT16		ret = 0;
-
-    /*    TRACE("(%04x)\n", uDeviceID); */
-
-    if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || wmd->bIs32) {
-	UserYield16();
-    } else {
-	ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
-    }
-
-    return ret;
-}
-
-/* ###################################################
- * #                     MIDI                        #
- * ###################################################
- */
-
-/**************************************************************************
- * 				midiOutGetNumDevs	[MMSYSTEM.201]
- */
-UINT16 WINAPI midiOutGetNumDevs16(void)
-{
-    return MMDRV_GetNum(MMDRV_MIDIOUT);
-}
-
-/**************************************************************************
- * 				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;
-
-    ret = MIDI_OutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE);
-
-    if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
-    return ret;
-}
-
-/**************************************************************************
- * 				midiOutClose		[MMSYSTEM.205]
- */
-UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
-{
-    return midiOutClose(HMIDIOUT_32(hMidiOut));
-}
-
-/**************************************************************************
- * 				midiOutPrepareHeader	[MMSYSTEM.206]
- */
-UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
-                                     SEGPTR lpsegMidiOutHdr,      /* [???] */
-				     UINT16 uSize)                /* [in] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
-    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MODM_PREPARE, lpsegMidiOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				midiOutUnprepareHeader	[MMSYSTEM.207]
- */
-UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
-				       SEGPTR lpsegMidiOutHdr,      /* [???] */
-				       UINT16 uSize)                /* [in] */
-{
-    LPWINE_MLD		wmld;
-    LPMIDIHDR16		lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
-
-    TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
-    if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
-	return MMSYSERR_NOERROR;
-    }
-
-    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MODM_UNPREPARE, lpsegMidiOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				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] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
-
-    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				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)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p)\n", hMidiOut, lpuDeviceID);
-
-    if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
-    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    *lpuDeviceID = wmld->uDeviceID;
-    return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * 				midiOutMessage		[MMSYSTEM.216]
- */
-DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
-                              DWORD dwParam1, DWORD dwParam2)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
-
-    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    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 MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
-}
-
-/**************************************************************************
- * 				midiInGetNumDevs	[MMSYSTEM.301]
- */
-UINT16 WINAPI midiInGetNumDevs16(void)
-{
-    return MMDRV_GetNum(MMDRV_MIDIIN);
-}
-
-/**************************************************************************
- * 				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	xhmid;
-    UINT 	ret;
-
-    ret = MIDI_InOpen(&xhmid, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE);
-
-    if (lphMidiIn) *lphMidiIn = HMIDIIN_16(xhmid);
-    return ret;
-}
-
-/**************************************************************************
- * 				midiInClose		[MMSYSTEM.305]
- */
-UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
-{
-    return midiInClose(HMIDIIN_32(hMidiIn));
-}
-
-/**************************************************************************
- * 				midiInPrepareHeader	[MMSYSTEM.306]
- */
-UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
-                                    SEGPTR lpsegMidiInHdr,     /* [???] */
-				    UINT16 uSize)              /* [in] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
-    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MIDM_PREPARE, lpsegMidiInHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				midiInUnprepareHeader	[MMSYSTEM.307]
- */
-UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
-                                      SEGPTR lpsegMidiInHdr,     /* [???] */
-				      UINT16 uSize)              /* [in] */
-{
-    LPWINE_MLD		wmld;
-    LPMIDIHDR16		lpMidiInHdr = MapSL(lpsegMidiInHdr);
-
-    TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
-    if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
-	return MMSYSERR_NOERROR;
-    }
-
-    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MIDM_UNPREPARE, lpsegMidiInHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				midiInAddBuffer		[MMSYSTEM.308]
- */
-UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,         /* [in] */
-                                MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
-				UINT16 uSize)              /* [in] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
-
-    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				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)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p)\n", hMidiIn, lpuDeviceID);
-
-    if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
-
-    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, TRUE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    *lpuDeviceID = wmld->uDeviceID;
-
-    return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * 				midiInMessage		[MMSYSTEM.313]
- */
-DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
-                             DWORD dwParam1, DWORD dwParam2)
-{
-    LPWINE_MLD		wmld;
-
-    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);
-    }
-
-    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
-}
-
-/**************************************************************************
- * 				midiStreamClose			[MMSYSTEM.252]
- */
-MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
-{
-    return midiStreamClose(HMIDISTRM_32(hMidiStrm));
-}
-
-/**************************************************************************
- * 				midiStreamOpen			[MMSYSTEM.251]
- */
-MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
-				   DWORD cMidi, DWORD dwCallback,
-				   DWORD dwInstance, DWORD fdwOpen)
-{
-    HMIDISTRM	hMidiStrm32;
-    MMRESULT 	ret;
-    UINT	devid32;
-
-    if (!phMidiStrm || !devid)
-	return MMSYSERR_INVALPARAM;
-    devid32 = *devid;
-    ret = MIDI_StreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback,
-                          dwInstance, fdwOpen, FALSE);
-    *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
-    *devid = devid32;
-    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 MMDRV_GetNum(MMDRV_WAVEOUT);
-}
-
-/**************************************************************************
- * 				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,
-                            const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
-			    DWORD dwInstance, DWORD dwFlags)
-{
-    HANDLE		hWaveOut;
-    UINT		ret;
-
-    /* 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 = WAVE_Open(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
-                    MMDRV_WAVEOUT, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
-
-    if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut);
-    return ret;
-}
-
-/**************************************************************************
- * 				waveOutClose		[MMSYSTEM.405]
- */
-UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
-{
-    DWORD	level;
-    UINT16	ret;
-
-    ReleaseThunkLock(&level);
-    ret = waveOutClose(HWAVEOUT_32(hWaveOut));
-    RestoreThunkLock(level);
-    return ret;
-}
-
-/**************************************************************************
- * 				waveOutPrepareHeader	[MMSYSTEM.406]
- */
-UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,      /* [in] */
-                                     SEGPTR lpsegWaveOutHdr,   /* [???] */
-				     UINT16 uSize)             /* [in] */
-{
-    LPWINE_MLD		wmld;
-    LPWAVEHDR		lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
-
-    TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
-    if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
-
-    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, WODM_PREPARE, lpsegWaveOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				waveOutUnprepareHeader	[MMSYSTEM.407]
- */
-UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,       /* [in] */
-				       SEGPTR lpsegWaveOutHdr,    /* [???] */
-				       UINT16 uSize)              /* [in] */
-{
-    LPWINE_MLD		wmld;
-    LPWAVEHDR		lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
-
-    TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
-    if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
-	return MMSYSERR_NOERROR;
-    }
-
-    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, WODM_UNPREPARE, lpsegWaveOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				waveOutWrite		[MMSYSTEM.408]
- */
-UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut,       /* [in] */
-			     LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
-			     UINT16 uSize)              /* [in] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
-
-    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				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)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p);\n", hWaveOut, lpuDeviceID);
-
-    if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
-
-    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    *lpuDeviceID = wmld->uDeviceID;
-    return 0;
-}
-
-/**************************************************************************
- * 				waveOutMessage 		[MMSYSTEM.421]
- */
-DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
-                              DWORD dwParam1, DWORD dwParam2)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
-
-    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) {
-	if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, TRUE)) != NULL) {
-            if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
-                dwParam1 = (DWORD)MapSL(dwParam1);
-	    return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
-	}
-	return MMSYSERR_INVALHANDLE;
-    }
-
-    /* from M$ KB */
-    if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
-	return MMSYSERR_INVALPARAM;
-
-    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
-}
-
-/**************************************************************************
- * 				waveInGetNumDevs 		[MMSYSTEM.501]
- */
-UINT16 WINAPI waveInGetNumDevs16(void)
-{
-    return MMDRV_GetNum(MMDRV_WAVEIN);
-}
-
-/**************************************************************************
- * 				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,
-                           const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
-                           DWORD dwInstance, DWORD dwFlags)
-{
-    HANDLE		hWaveIn;
-    UINT		ret;
-
-    /* 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 = WAVE_Open(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
-                    MMDRV_WAVEIN, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
-
-    if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn);
-    return ret;
-}
-
-/**************************************************************************
- * 				waveInClose			[MMSYSTEM.505]
- */
-UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
-{
-    DWORD	level;
-    UINT16	ret;
-
-    ReleaseThunkLock(&level);
-    ret = waveInClose(HWAVEIN_32(hWaveIn));
-    RestoreThunkLock(level);
-    return ret;
-}
-
-/**************************************************************************
- * 				waveInPrepareHeader		[MMSYSTEM.506]
- */
-UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
-				    SEGPTR lpsegWaveInHdr,   /* [???] */
-				    UINT16 uSize)            /* [in] */
-{
-    LPWINE_MLD		wmld;
-    LPWAVEHDR		lpWaveInHdr = MapSL(lpsegWaveInHdr);
-    UINT16		ret;
-
-    TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
-
-    if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
-    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    lpWaveInHdr->dwBytesRecorded = 0;
-
-    ret = MMDRV_Message(wmld, WIDM_PREPARE, lpsegWaveInHdr, uSize, FALSE);
-    return ret;
-}
-
-/**************************************************************************
- * 				waveInUnprepareHeader	[MMSYSTEM.507]
- */
-UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
-				      SEGPTR lpsegWaveInHdr,   /* [???] */
-				      UINT16 uSize)            /* [in] */
-{
-    LPWINE_MLD		wmld;
-    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;
-    }
-
-    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, WIDM_UNPREPARE, lpsegWaveInHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				waveInAddBuffer		[MMSYSTEM.508]
- */
-UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,       /* [in] */
-				WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
-				UINT16 uSize)            /* [in] */
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
-
-    if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
-    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize, FALSE);
-}
-
-/**************************************************************************
- * 				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)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04X, %p);\n", hWaveIn, lpuDeviceID);
-
-    if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
-
-    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    *lpuDeviceID = wmld->uDeviceID;
-    return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * 				waveInMessage 		[MMSYSTEM.514]
- */
-DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
-                             DWORD dwParam1, DWORD dwParam2)
-{
-    LPWINE_MLD		wmld;
-
-    TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
-
-    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) {
-	if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, TRUE)) != NULL) {
-            if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
-                dwParam1 = (DWORD)MapSL(dwParam1);
-	    return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
-	}
-	return MMSYSERR_INVALHANDLE;
-    }
-
-    /* from M$ KB */
-    if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
-	return MMSYSERR_INVALPARAM;
-
-    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
-}
-
-/* ###################################################
- * #                     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 (WINE_MMTHREAD*)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");
-}
-
-/* ###################################################
- * #                    DRIVER                       #
- * ###################################################
- */
-
-/**************************************************************************
- *				DRIVER_MapMsg32To16		[internal]
- *
- * Map a 32 bit driver message to a 16 bit driver message.
- */
-static WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, LPARAM *lParam1, LPARAM *lParam2)
-{
-    WINMM_MapType       ret = WINMM_MAP_MSGERROR;
-
-    switch (wMsg) {
-    case DRV_LOAD:
-    case DRV_ENABLE:
-    case DRV_DISABLE:
-    case DRV_FREE:
-    case DRV_QUERYCONFIGURE:
-    case DRV_REMOVE:
-    case DRV_EXITSESSION:
-    case DRV_EXITAPPLICATION:
-    case DRV_POWER:
-    case DRV_CLOSE:	/* should be 0/0 */
-    case DRV_OPEN:	/* pass through */
-	/* lParam1 and lParam2 are not used */
-	ret = WINMM_MAP_OK;
-	break;
-    case DRV_CONFIGURE:
-    case DRV_INSTALL:
-	/* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
-	 * lParam2 is a pointer to DRVCONFIGINFO
-	 */
-	if (*lParam2) {
-            LPDRVCONFIGINFO16 dci16 = HeapAlloc( GetProcessHeap(), 0, sizeof(*dci16) );
-            LPDRVCONFIGINFO	dci32 = (LPDRVCONFIGINFO)(*lParam2);
-
-	    if (dci16) {
-		LPSTR str1 = NULL,str2;
-                INT len;
-		dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
-
-                if (dci32->lpszDCISectionName) {
-                    len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, NULL, 0, NULL, NULL );
-                    str1 = HeapAlloc( GetProcessHeap(), 0, len );
-                    if (str1) {
-                        WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, str1, len, NULL, NULL );
-                        dci16->lpszDCISectionName = MapLS( str1 );
-                    } else {
-                        HeapFree( GetProcessHeap(), 0, dci16);
-                        return WINMM_MAP_NOMEM;
-                    }
-		} else {
-		    dci16->lpszDCISectionName = 0L;
-		}
-                if (dci32->lpszDCIAliasName) {
-                    len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, NULL, 0, NULL, NULL );
-                    str2 = HeapAlloc( GetProcessHeap(), 0, len );
-                    if (str2) {
-                        WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, str2, len, NULL, NULL );
-                        dci16->lpszDCIAliasName = MapLS( str2 );
-                    } else {
-                        HeapFree( GetProcessHeap(), 0, str1);
-                        HeapFree( GetProcessHeap(), 0, dci16);
-                        return WINMM_MAP_NOMEM;
-                    }
-		} else {
-		    dci16->lpszDCISectionName = 0L;
-		}
-	    } else {
-		return WINMM_MAP_NOMEM;
-	    }
-	    *lParam2 = MapLS( dci16 );
-	    ret = WINMM_MAP_OKMEM;
-	} else {
-	    ret = WINMM_MAP_OK;
-	}
-	break;
-    default:
-	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-	   FIXME("Unknown message 0x%04x\n", wMsg);
-	}
-	ret = WINMM_MAP_OK;
-    }
-    return ret;
-}
-
-/**************************************************************************
- *				DRIVER_UnMapMsg32To16		[internal]
- *
- * UnMap a 32 bit driver message to a 16 bit driver message.
- */
-static WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
-{
-    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
-
-    switch (wMsg) {
-    case DRV_LOAD:
-    case DRV_ENABLE:
-    case DRV_DISABLE:
-    case DRV_FREE:
-    case DRV_QUERYCONFIGURE:
-    case DRV_REMOVE:
-    case DRV_EXITSESSION:
-    case DRV_EXITAPPLICATION:
-    case DRV_POWER:
-    case DRV_OPEN:
-    case DRV_CLOSE:
-	/* lParam1 and lParam2 are not used */
-	break;
-    case DRV_CONFIGURE:
-    case DRV_INSTALL:
-	/* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
-	if (lParam2) {
-	    LPDRVCONFIGINFO16	dci16 = MapSL(lParam2);
-            HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCISectionName) );
-            HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCIAliasName) );
-            UnMapLS( lParam2 );
-            UnMapLS( dci16->lpszDCISectionName );
-            UnMapLS( dci16->lpszDCIAliasName );
-            HeapFree( GetProcessHeap(), 0, dci16 );
-	}
-	ret = WINMM_MAP_OK;
-	break;
-    default:
-	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-	    FIXME("Unknown message 0x%04x\n", wMsg);
-	}
-	ret = WINMM_MAP_OK;
-    }
-    return ret;
-}
-
-/**************************************************************************
- *				DRIVER_TryOpenDriver16		[internal]
- *
- * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
- */
-static	LPWINE_DRIVER	DRIVER_OpenDriver16(LPCWSTR fn, LPCWSTR sn, LPARAM lParam2)
-{
-    LPWINE_DRIVER 	lpDrv = NULL;
-    LPCSTR		cause = NULL;
-    LPSTR               fnA = NULL, snA = NULL;
-    unsigned            len;
-
-    TRACE("(%s, %s, %08lX);\n", debugstr_w(fn), debugstr_w(sn), lParam2);
-
-    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
-    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
-
-    if (fn)
-    {
-        len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL );
-        fnA = HeapAlloc(GetProcessHeap(), 0, len);
-        if (fnA == NULL) {cause = "OOM"; goto exit;}
-        WideCharToMultiByte( CP_ACP, 0, fn, -1, fnA, len, NULL, NULL );
-    }
-
-    if (sn)
-    {
-        len = WideCharToMultiByte( CP_ACP, 0, sn, -1, NULL, 0, NULL, NULL );
-        snA = HeapAlloc(GetProcessHeap(), 0, len);
-        if (snA == NULL) {cause = "OOM"; goto exit;}
-        WideCharToMultiByte( CP_ACP, 0, sn, -1, snA, len, NULL, NULL );
-    }
-
-    /* FIXME: shall we do some black magic here on sn ?
-     *	drivers32 => drivers
-     *	mci32 => mci
-     * ...
-     */
-    lpDrv->d.d16.hDriver16 = OpenDriver16(fnA, snA, lParam2);
-    if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
-    lpDrv->dwFlags = WINE_GDF_16BIT;
-
-    TRACE("=> %p\n", lpDrv);
-    return lpDrv;
-
-exit:
-    HeapFree(GetProcessHeap(), 0, lpDrv);
-    HeapFree(GetProcessHeap(), 0, fnA);
-    HeapFree(GetProcessHeap(), 0, snA);
-    TRACE("Unable to load 16 bit module %s[%s]: %s\n", 
-          debugstr_w(fn), debugstr_w(sn), cause);
-    return NULL;
-}
-
-/******************************************************************
- *		DRIVER_SendMessage16
- *
- *
- */
-static LRESULT  DRIVER_SendMessage16(HDRVR16 hDrv16, UINT msg, 
-                                     LPARAM lParam1, LPARAM lParam2)
-{
-    LRESULT             ret = 0;
-    WINMM_MapType	map;
-
-    TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
-          hDrv16, msg, lParam1, lParam2);
-
-    switch (map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) {
-    case WINMM_MAP_OKMEM:
-    case WINMM_MAP_OK:
-        ret = SendDriverMessage16(hDrv16, msg, lParam1, lParam2);
-        if (map == WINMM_MAP_OKMEM)
-            DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
-    default:
-        break;
-    }
-    return ret;
-}
-
-/******************************************************************
- *		DRIVER_CloseDriver16
- *
- *
- */
-static LRESULT DRIVER_CloseDriver16(HDRVR16 hDrv16, LPARAM lParam1, LPARAM lParam2)
-{
-    return CloseDriver16(hDrv16, lParam1, lParam2);
-}
-
-/**************************************************************************
- * 				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;
-}
-
-/**************************************************************************
- * 				timeSetEvent		[MMSYSTEM.602]
- */
-MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
-				 DWORD dwUser, UINT16 wFlags)
-{
-    if (wFlags & WINE_TIMER_IS32)
-	WARN("Unknown windows flag... wine internally used.. ooch\n");
-
-    return TIME_SetEventInternal(wDelay, wResol, (LPTIMECALLBACK)lpFunc,
-                                 dwUser, wFlags & ~WINE_TIMER_IS32);
-}
-
-/**************************************************************************
- * 				timeKillEvent		[MMSYSTEM.603]
- */
-MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
-{
-    return timeKillEvent(wID);
-}
-
-/**************************************************************************
- * 				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);
-}
-
-/**************************************************************************
- * 				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)
-{
-    HRSRC16     res;
-    HGLOBAL16   handle;
-    const BYTE* ptr16;
-    BYTE*       ptr32;
-    unsigned    pos = 0, size = 1024, len;
-    const char* str;
-    DWORD	flg;
-    WORD	eid;
-    UINT16      ret = MCIERR_OUT_OF_MEMORY;
-
-    if (!(res = FindResource16( hInst, resname, (LPSTR)RT_RCDATA))) return MCI_NO_COMMAND_TABLE;
-    if (!(handle = LoadResource16( hInst, res ))) return MCI_NO_COMMAND_TABLE;
-    ptr16 = LockResource16(handle);
-    /* converting the 16 bit resource table into a 32W one */
-    if ((ptr32 = HeapAlloc(GetProcessHeap(), 0, size)))
-    {
-        do {
-            str = (LPCSTR)ptr16;
-            ptr16 += strlen(str) + 1;
-            flg = *(const DWORD*)ptr16;
-            eid = *(const WORD*)(ptr16 + sizeof(DWORD));
-            ptr16 += sizeof(DWORD) + sizeof(WORD);
-            len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0) * sizeof(WCHAR);
-            if (pos + len + sizeof(DWORD) + sizeof(WORD) > size)
-            {
-                while (pos + len * sizeof(WCHAR) + sizeof(DWORD) + sizeof(WORD) > size) size += 1024;
-                ptr32 = HeapReAlloc(GetProcessHeap(), 0, ptr32, size);
-                if (!ptr32) goto the_end;
-            }
-            MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)(ptr32 + pos), len / sizeof(WCHAR));
-            *(DWORD*)(ptr32 + pos + len) = flg;
-            *(WORD*)(ptr32 + pos + len + sizeof(DWORD)) = eid;
-            pos += len + sizeof(DWORD) + sizeof(WORD);
-        } while (eid != MCI_END_COMMAND_LIST);
-    }
-the_end:
-    FreeResource16( handle );
-    if (ptr32) ret = MCI_SetCommandTable(ptr32, type);
-    return ret;
-}
-
-/**************************************************************************
- *                    	mciFreeCommandResource			[MMSYSTEM.713]
- */
-BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
-{
-    TRACE("(%04x)!\n", uTable);
-
-    return MCI_DeleteCommandTable(uTable, TRUE);
-}
-
-/* ###################################################
- * #                     MMIO                        #
- * ###################################################
- */
-
-/****************************************************************
- *       		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_Callback16
- *
- *
- */
-static LRESULT MMIO_Callback16(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage,
-                               LPARAM lParam1, LPARAM lParam2)
-{
-    DWORD 		result;
-    MMIOINFO16          mmioInfo16;
-    SEGPTR		segmmioInfo16;
-    LPARAM		lp1 = lParam1, lp2 = lParam2;
-    WORD args[7];
-
-    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_ResetSegmentedData
- *
- */
-static LRESULT     MMIO_SetSegmentedBuffer(HMMIO hmmio, SEGPTR ptr, BOOL release)
-{
-    LPWINE_MMIO		wm;
-
-    if ((wm = MMIO_Get(hmmio)) == NULL)
-	return MMSYSERR_INVALHANDLE;
-    if (release) UnMapLS(wm->segBuffer16);
-    wm->segBuffer16 = ptr;
-    return MMSYSERR_NOERROR;
-}
-
-/**************************************************************************
- * 				mmioOpen       		[MMSYSTEM.1210]
- */
-HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
-			  DWORD dwOpenFlags)
-{
-    HMMIO 	ret;
-
-    if (lpmmioinfo16) {
-	MMIOINFO	mmioinfo;
-
-	memset(&mmioinfo, 0, sizeof(mmioinfo));
-
-	mmioinfo.dwFlags     = lpmmioinfo16->dwFlags;
-	mmioinfo.fccIOProc   = lpmmioinfo16->fccIOProc;
-	mmioinfo.pIOProc     = (LPMMIOPROC)lpmmioinfo16->pIOProc;
-	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 = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, MMIO_PROC_16);
-        MMIO_SetSegmentedBuffer(mmioinfo.hmmio, (SEGPTR)lpmmioinfo16->pchBuffer, FALSE);
-
-	lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet;
-        lpmmioinfo16->hmmio     = HMMIO_16(mmioinfo.hmmio);
-    } else {
-	ret = MMIO_Open(szFileName, NULL, dwOpenFlags, MMIO_PROC_32A);
-    }
-    return HMMIO_16(ret);
-}
-
-/**************************************************************************
- * 				mmioClose      		[MMSYSTEM.1211]
- */
-MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
-{
-    MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (SEGPTR)NULL, TRUE);
-    return mmioClose(HMMIO_32(hmmio), uFlags);
-}
-
-/**************************************************************************
- * 				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;
-    LPWINE_MMIO		wm;
-
-    TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags);
-
-    if ((wm = MMIO_Get(HMMIO_32(hmmio))) == NULL)
-	return MMSYSERR_INVALHANDLE;
-
-    ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
-    if (ret != MMSYSERR_NOERROR) return ret;
-
-    lpmmioinfo->dwFlags     = mmioinfo.dwFlags;
-    lpmmioinfo->fccIOProc   = mmioinfo.fccIOProc;
-    lpmmioinfo->pIOProc     = (wm->ioProc->type == MMIO_PROC_16) ?
-        (LPMMIOPROC16)wm->ioProc->pIOProc : NULL;
-    lpmmioinfo->wErrorRet   = mmioinfo.wErrorRet;
-    lpmmioinfo->hTask       = HTASK_16(mmioinfo.hTask);
-    lpmmioinfo->cchBuffer   = mmioinfo.cchBuffer;
-    lpmmioinfo->pchBuffer   = (void*)wm->segBuffer16;
-    lpmmioinfo->pchNext     = (void*)(wm->segBuffer16 + (mmioinfo.pchNext - mmioinfo.pchBuffer));
-    lpmmioinfo->pchEndRead  = (void*)(wm->segBuffer16 + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
-    lpmmioinfo->pchEndWrite = (void*)(wm->segBuffer16 + (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);
-
-    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)
-        MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (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)
-{
-    return (LPMMIOPROC16)MMIO_InstallIOProc(fccIOProc, (LPMMIOPROC)pIOProc,
-                                            dwFlags, MMIO_PROC_16);
-}
-
-/**************************************************************************
- * 				mmioSendMessage	[MMSYSTEM.1222]
- */
-LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
-				 LPARAM lParam1, LPARAM lParam2)
-{
-    return MMIO_SendMessage(HMMIO_32(hmmio), uMessage, 
-                            lParam1, lParam2, MMIO_PROC_16);
-}
-
-/**************************************************************************
- * 				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) {
-        MMIO_InstallIOProc(lpmmioinfo->fccIOProc, (LPMMIOPROC)lpmmioinfo->pIOProc,
-                           MMIO_INSTALLPROC, MMIO_PROC_16);
-        inst = TRUE;
-    }
-    memset(&mmioinfo, 0, sizeof(mmioinfo));
-    mmioinfo.fccIOProc = lpmmioinfo->fccIOProc;
-    ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags);
-    if (inst) {
-        MMIO_InstallIOProc(lpmmioinfo->fccIOProc, NULL,
-                           MMIO_REMOVEPROC, MMIO_PROC_16);
-    }
-    return ret;
-}
-
-/* ###################################################
- * #                     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 joySetCapture16(hWnd, wID, wPeriod, bChanged);
-}
-
-/**************************************************************************
- * 				joySetThreshold		[MMSYSTEM.107]
- */
-MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
-{
-    return joySetThreshold16(wID,wThreshold);
-}
-
-/**************************************************************************
- * 				joySetCalibration	[MMSYSTEM.109]
- */
-MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
-{
-    FIXME("(%04X): stub.\n", wID);
-    return JOYERR_NOCANDO;
-}
diff --git a/dlls/winmm/mmsystem16.c b/dlls/winmm/mmsystem16.c
new file mode 100644
index 0000000..83f63d4
--- /dev/null
+++ b/dlls/winmm/mmsystem16.c
@@ -0,0 +1,3215 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/*
+ * MMSYTEM 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 "winreg.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);
+
+static WINE_MMTHREAD*   WINMM_GetmmThread(HANDLE16);
+static LPWINE_DRIVER    DRIVER_OpenDriver16(LPCWSTR, LPCWSTR, LPARAM);
+static LRESULT          DRIVER_CloseDriver16(HDRVR16, LPARAM, LPARAM);
+static LRESULT          DRIVER_SendMessage16(HDRVR16, UINT, LPARAM, LPARAM);
+static LRESULT          MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM);
+
+/* ###################################################
+ * #                  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);
+
+    switch (fdwReason) {
+    case DLL_PROCESS_ATTACH:
+	/* need to load WinMM in order to:
+	 * - initiate correctly shared variables (WINMM_Init())
+	 */
+        if (!GetModuleHandleA("WINMM.DLL"))
+        {
+            ERR("Could not load sibling WinMM.dll\n");
+            return FALSE;
+	}
+	WINMM_IData.hWinMM16Instance = hinstDLL;
+        /* hook in our 16 bit function pointers */
+        pFnGetMMThread16    = WINMM_GetmmThread;
+        pFnOpenDriver16     = DRIVER_OpenDriver16;
+        pFnCloseDriver16    = DRIVER_CloseDriver16;
+        pFnSendMessage16    = DRIVER_SendMessage16;
+        pFnMmioCallback16   = MMIO_Callback16;
+        pFnReleaseThunkLock = ReleaseThunkLock;
+        pFnRestoreThunkLock = RestoreThunkLock;
+        MMDRV_Init16();
+	break;
+    case DLL_PROCESS_DETACH:
+	WINMM_IData.hWinMM16Instance = 0;
+        pFnGetMMThread16    = NULL;
+        pFnOpenDriver16     = NULL;
+        pFnCloseDriver16    = NULL;
+        pFnSendMessage16    = NULL;
+        pFnMmioCallback16   = NULL;
+        pFnReleaseThunkLock = NULL;
+        pFnRestoreThunkLock = NULL;
+        /* FIXME: add equivalent for MMDRV_Init16() */
+	break;
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+	break;
+    }
+    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 MMDRV_GetNum(MMDRV_MIXER);
+}
+
+/**************************************************************************
+ * 				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;
+
+    ret = MIXER_Open(&hmix, uDeviceID, dwCallback, dwInstance, fdwOpen, FALSE);
+    if (lphmix) *lphmix = HMIXER_16(hmix);
+    return ret;
+}
+
+/**************************************************************************
+ * 				mixerClose			[MMSYSTEM.803]
+ */
+UINT16 WINAPI mixerClose16(HMIXER16 hMix)
+{
+    return mixerClose(HMIXER_32(hMix));
+}
+
+/**************************************************************************
+ * 				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);
+}
+
+/**************************************************************************
+ * 				auxGetNumDevs		[MMSYSTEM.350]
+ */
+UINT16 WINAPI auxGetNumDevs16(void)
+{
+    return MMDRV_GetNum(MMDRV_AUX);
+}
+
+/* ###################################################
+ * #                     AUX                         #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * 				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)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
+
+    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+    return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
+}
+
+/**************************************************************************
+ * 				auxSetVolume		[MMSYSTEM.353]
+ */
+UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
+
+    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+    return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE);
+}
+
+/**************************************************************************
+ * 				auxOutMessage		[MMSYSTEM.354]
+ */
+DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
+{
+    LPWINE_MLD		wmld;
+
+    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 auxGetVolume16(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;
+    }
+    if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE);
+}
+
+/* ###################################################
+ * #                     MCI                         #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * 				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 dwParam2)
+{
+    DWORD		dwRet;
+
+    TRACE("(%04X, %s, %08X, %08X)\n",
+	  wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
+
+    dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE);
+    dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2));
+    TRACE("=> %d\n", dwRet);
+    return dwRet;
+}
+
+/**************************************************************************
+ * 				mciGetDeviceID		       	[MMSYSTEM.703]
+ */
+UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
+{
+    TRACE("(\"%s\")\n", lpstrName);
+
+    return mciGetDeviceIDA(lpstrName);
+}
+
+/**************************************************************************
+ * 				mciSetYieldProc			[MMSYSTEM.714]
+ */
+BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
+{
+    LPWINE_MCIDRIVER	wmd;
+
+    TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
+
+    if (!(wmd = MCI_GetDriver(uDeviceID))) {
+	WARN("Bad uDeviceID\n");
+	return FALSE;
+    }
+
+    wmd->lpfnYieldProc = (YIELDPROC)fpYieldProc;
+    wmd->dwYieldData   = dwYieldData;
+    wmd->bIs32         = FALSE;
+
+    return TRUE;
+}
+
+/**************************************************************************
+ * 				mciGetDeviceIDFromElementID	[MMSYSTEM.715]
+ */
+UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
+{
+    FIXME("(%u, %s) stub\n", dwElementID, lpstrType);
+    return 0;
+}
+
+/**************************************************************************
+ * 				mciGetYieldProc			[MMSYSTEM.716]
+ */
+YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
+{
+    LPWINE_MCIDRIVER	wmd;
+
+    TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
+
+    if (!(wmd = MCI_GetDriver(uDeviceID))) {
+	WARN("Bad uDeviceID\n");
+	return NULL;
+    }
+    if (!wmd->lpfnYieldProc) {
+	WARN("No proc set\n");
+	return NULL;
+    }
+    if (wmd->bIs32) {
+	WARN("Proc is 32 bit\n");
+	return NULL;
+    }
+    return (YIELDPROC16)wmd->lpfnYieldProc;
+}
+
+/**************************************************************************
+ * 				mciGetCreatorTask		[MMSYSTEM.717]
+ */
+HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
+{
+    LPWINE_MCIDRIVER wmd;
+    HTASK16 ret = 0;
+
+    if ((wmd = MCI_GetDriver(uDeviceID))) 
+        ret = HTASK_16(wmd->CreatorThread);
+
+    TRACE("(%u) => %04x\n", uDeviceID, ret);
+    return ret;
+}
+
+/**************************************************************************
+ * 				mciDriverYield			[MMSYSTEM.710]
+ */
+UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
+{
+    LPWINE_MCIDRIVER	wmd;
+    UINT16		ret = 0;
+
+    /*    TRACE("(%04x)\n", uDeviceID); */
+
+    if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || wmd->bIs32) {
+	UserYield16();
+    } else {
+	ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData);
+    }
+
+    return ret;
+}
+
+/* ###################################################
+ * #                     MIDI                        #
+ * ###################################################
+ */
+
+/**************************************************************************
+ * 				midiOutGetNumDevs	[MMSYSTEM.201]
+ */
+UINT16 WINAPI midiOutGetNumDevs16(void)
+{
+    return MMDRV_GetNum(MMDRV_MIDIOUT);
+}
+
+/**************************************************************************
+ * 				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;
+
+    ret = MIDI_OutOpen(&hmo, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE);
+
+    if (lphMidiOut != NULL) *lphMidiOut = HMIDIOUT_16(hmo);
+    return ret;
+}
+
+/**************************************************************************
+ * 				midiOutClose		[MMSYSTEM.205]
+ */
+UINT16 WINAPI midiOutClose16(HMIDIOUT16 hMidiOut)
+{
+    return midiOutClose(HMIDIOUT_32(hMidiOut));
+}
+
+/**************************************************************************
+ * 				midiOutPrepareHeader	[MMSYSTEM.206]
+ */
+UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
+                                     SEGPTR lpsegMidiOutHdr,      /* [???] */
+				     UINT16 uSize)                /* [in] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MODM_PREPARE, lpsegMidiOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				midiOutUnprepareHeader	[MMSYSTEM.207]
+ */
+UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut,         /* [in] */
+				       SEGPTR lpsegMidiOutHdr,      /* [???] */
+				       UINT16 uSize)                /* [in] */
+{
+    LPWINE_MLD		wmld;
+    LPMIDIHDR16		lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
+
+    TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+    if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
+	return MMSYSERR_NOERROR;
+    }
+
+    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MODM_UNPREPARE, lpsegMidiOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				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] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
+
+    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				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)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p)\n", hMidiOut, lpuDeviceID);
+
+    if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
+    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    *lpuDeviceID = wmld->uDeviceID;
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				midiOutMessage		[MMSYSTEM.216]
+ */
+DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
+                              DWORD dwParam1, DWORD dwParam2)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
+
+    if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    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 MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE);
+}
+
+/**************************************************************************
+ * 				midiInGetNumDevs	[MMSYSTEM.301]
+ */
+UINT16 WINAPI midiInGetNumDevs16(void)
+{
+    return MMDRV_GetNum(MMDRV_MIDIIN);
+}
+
+/**************************************************************************
+ * 				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	xhmid;
+    UINT 	ret;
+
+    ret = MIDI_InOpen(&xhmid, uDeviceID, dwCallback, dwInstance, dwFlags, FALSE);
+
+    if (lphMidiIn) *lphMidiIn = HMIDIIN_16(xhmid);
+    return ret;
+}
+
+/**************************************************************************
+ * 				midiInClose		[MMSYSTEM.305]
+ */
+UINT16 WINAPI midiInClose16(HMIDIIN16 hMidiIn)
+{
+    return midiInClose(HMIDIIN_32(hMidiIn));
+}
+
+/**************************************************************************
+ * 				midiInPrepareHeader	[MMSYSTEM.306]
+ */
+UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
+                                    SEGPTR lpsegMidiInHdr,     /* [???] */
+				    UINT16 uSize)              /* [in] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MIDM_PREPARE, lpsegMidiInHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				midiInUnprepareHeader	[MMSYSTEM.307]
+ */
+UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn,         /* [in] */
+                                      SEGPTR lpsegMidiInHdr,     /* [???] */
+				      UINT16 uSize)              /* [in] */
+{
+    LPWINE_MLD		wmld;
+    LPMIDIHDR16		lpMidiInHdr = MapSL(lpsegMidiInHdr);
+
+    TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+    if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
+	return MMSYSERR_NOERROR;
+    }
+
+    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MIDM_UNPREPARE, lpsegMidiInHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				midiInAddBuffer		[MMSYSTEM.308]
+ */
+UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn,         /* [in] */
+                                MIDIHDR16* lpsegMidiInHdr, /* [???] NOTE: SEGPTR */
+				UINT16 uSize)              /* [in] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
+
+    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				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)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p)\n", hMidiIn, lpuDeviceID);
+
+    if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
+
+    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, TRUE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    *lpuDeviceID = wmld->uDeviceID;
+
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				midiInMessage		[MMSYSTEM.313]
+ */
+DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
+                             DWORD dwParam1, DWORD dwParam2)
+{
+    LPWINE_MLD		wmld;
+
+    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);
+    }
+
+    if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
+}
+
+/**************************************************************************
+ * 				midiStreamClose			[MMSYSTEM.252]
+ */
+MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hMidiStrm)
+{
+    return midiStreamClose(HMIDISTRM_32(hMidiStrm));
+}
+
+/**************************************************************************
+ * 				midiStreamOpen			[MMSYSTEM.251]
+ */
+MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16* phMidiStrm, LPUINT16 devid,
+				   DWORD cMidi, DWORD dwCallback,
+				   DWORD dwInstance, DWORD fdwOpen)
+{
+    HMIDISTRM	hMidiStrm32;
+    MMRESULT 	ret;
+    UINT	devid32;
+
+    if (!phMidiStrm || !devid)
+	return MMSYSERR_INVALPARAM;
+    devid32 = *devid;
+    ret = MIDI_StreamOpen(&hMidiStrm32, &devid32, cMidi, dwCallback,
+                          dwInstance, fdwOpen, FALSE);
+    *phMidiStrm = HMIDISTRM_16(hMidiStrm32);
+    *devid = devid32;
+    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 MMDRV_GetNum(MMDRV_WAVEOUT);
+}
+
+/**************************************************************************
+ * 				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,
+                            const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
+			    DWORD dwInstance, DWORD dwFlags)
+{
+    HANDLE		hWaveOut;
+    UINT		ret;
+
+    /* 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 = WAVE_Open(&hWaveOut, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
+                    MMDRV_WAVEOUT, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
+
+    if (lphWaveOut != NULL) *lphWaveOut = HWAVEOUT_16(hWaveOut);
+    return ret;
+}
+
+/**************************************************************************
+ * 				waveOutClose		[MMSYSTEM.405]
+ */
+UINT16 WINAPI waveOutClose16(HWAVEOUT16 hWaveOut)
+{
+    DWORD	level;
+    UINT16	ret;
+
+    ReleaseThunkLock(&level);
+    ret = waveOutClose(HWAVEOUT_32(hWaveOut));
+    RestoreThunkLock(level);
+    return ret;
+}
+
+/**************************************************************************
+ * 				waveOutPrepareHeader	[MMSYSTEM.406]
+ */
+UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut,      /* [in] */
+                                     SEGPTR lpsegWaveOutHdr,   /* [???] */
+				     UINT16 uSize)             /* [in] */
+{
+    LPWINE_MLD		wmld;
+    LPWAVEHDR		lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
+
+    TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+    if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
+
+    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, WODM_PREPARE, lpsegWaveOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				waveOutUnprepareHeader	[MMSYSTEM.407]
+ */
+UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut,       /* [in] */
+				       SEGPTR lpsegWaveOutHdr,    /* [???] */
+				       UINT16 uSize)              /* [in] */
+{
+    LPWINE_MLD		wmld;
+    LPWAVEHDR		lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
+
+    TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+    if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
+	return MMSYSERR_NOERROR;
+    }
+
+    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, WODM_UNPREPARE, lpsegWaveOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				waveOutWrite		[MMSYSTEM.408]
+ */
+UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut,       /* [in] */
+			     LPWAVEHDR lpsegWaveOutHdr, /* [???] NOTE: SEGPTR */
+			     UINT16 uSize)              /* [in] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
+
+    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				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)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p);\n", hWaveOut, lpuDeviceID);
+
+    if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
+
+    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    *lpuDeviceID = wmld->uDeviceID;
+    return 0;
+}
+
+/**************************************************************************
+ * 				waveOutMessage 		[MMSYSTEM.421]
+ */
+DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
+                              DWORD dwParam1, DWORD dwParam2)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
+
+    if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) {
+	if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, TRUE)) != NULL) {
+            if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
+                dwParam1 = (DWORD)MapSL(dwParam1);
+	    return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
+	}
+	return MMSYSERR_INVALHANDLE;
+    }
+
+    /* from M$ KB */
+    if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
+	return MMSYSERR_INVALPARAM;
+
+    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
+}
+
+/**************************************************************************
+ * 				waveInGetNumDevs 		[MMSYSTEM.501]
+ */
+UINT16 WINAPI waveInGetNumDevs16(void)
+{
+    return MMDRV_GetNum(MMDRV_WAVEIN);
+}
+
+/**************************************************************************
+ * 				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,
+                           const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
+                           DWORD dwInstance, DWORD dwFlags)
+{
+    HANDLE		hWaveIn;
+    UINT		ret;
+
+    /* 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 = WAVE_Open(&hWaveIn, (uDeviceID == (UINT16)-1) ? (UINT)-1 : uDeviceID,
+                    MMDRV_WAVEIN, lpFormat, dwCallback, dwInstance, dwFlags, FALSE);
+
+    if (lphWaveIn != NULL) *lphWaveIn = HWAVEIN_16(hWaveIn);
+    return ret;
+}
+
+/**************************************************************************
+ * 				waveInClose			[MMSYSTEM.505]
+ */
+UINT16 WINAPI waveInClose16(HWAVEIN16 hWaveIn)
+{
+    DWORD	level;
+    UINT16	ret;
+
+    ReleaseThunkLock(&level);
+    ret = waveInClose(HWAVEIN_32(hWaveIn));
+    RestoreThunkLock(level);
+    return ret;
+}
+
+/**************************************************************************
+ * 				waveInPrepareHeader		[MMSYSTEM.506]
+ */
+UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
+				    SEGPTR lpsegWaveInHdr,   /* [???] */
+				    UINT16 uSize)            /* [in] */
+{
+    LPWINE_MLD		wmld;
+    LPWAVEHDR		lpWaveInHdr = MapSL(lpsegWaveInHdr);
+    UINT16		ret;
+
+    TRACE("(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
+
+    if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
+    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    lpWaveInHdr->dwBytesRecorded = 0;
+
+    ret = MMDRV_Message(wmld, WIDM_PREPARE, lpsegWaveInHdr, uSize, FALSE);
+    return ret;
+}
+
+/**************************************************************************
+ * 				waveInUnprepareHeader	[MMSYSTEM.507]
+ */
+UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn,       /* [in] */
+				      SEGPTR lpsegWaveInHdr,   /* [???] */
+				      UINT16 uSize)            /* [in] */
+{
+    LPWINE_MLD		wmld;
+    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;
+    }
+
+    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, WIDM_UNPREPARE, lpsegWaveInHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				waveInAddBuffer		[MMSYSTEM.508]
+ */
+UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn,       /* [in] */
+				WAVEHDR* lpsegWaveInHdr, /* [???] NOTE: SEGPTR */
+				UINT16 uSize)            /* [in] */
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
+
+    if (lpsegWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
+    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize, FALSE);
+}
+
+/**************************************************************************
+ * 				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)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04X, %p);\n", hWaveIn, lpuDeviceID);
+
+    if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE;
+
+    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    *lpuDeviceID = wmld->uDeviceID;
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				waveInMessage 		[MMSYSTEM.514]
+ */
+DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
+                             DWORD dwParam1, DWORD dwParam2)
+{
+    LPWINE_MLD		wmld;
+
+    TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
+
+    if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) {
+	if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, TRUE)) != NULL) {
+            if (uMessage == DRV_QUERYDRVENTRY || uMessage == DRV_QUERYDEVNODE)
+                dwParam1 = (DWORD)MapSL(dwParam1);
+	    return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
+	}
+	return MMSYSERR_INVALHANDLE;
+    }
+
+    /* from M$ KB */
+    if (uMessage < DRVM_IOCTL || (uMessage >= DRVM_IOCTL_LAST && uMessage < DRVM_MAPPER))
+	return MMSYSERR_INVALPARAM;
+
+    return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, FALSE);
+}
+
+/* ###################################################
+ * #                     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 (WINE_MMTHREAD*)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");
+}
+
+/* ###################################################
+ * #                    DRIVER                       #
+ * ###################################################
+ */
+
+/**************************************************************************
+ *				DRIVER_MapMsg32To16		[internal]
+ *
+ * Map a 32 bit driver message to a 16 bit driver message.
+ */
+static WINMM_MapType DRIVER_MapMsg32To16(WORD wMsg, LPARAM *lParam1, LPARAM *lParam2)
+{
+    WINMM_MapType       ret = WINMM_MAP_MSGERROR;
+
+    switch (wMsg) {
+    case DRV_LOAD:
+    case DRV_ENABLE:
+    case DRV_DISABLE:
+    case DRV_FREE:
+    case DRV_QUERYCONFIGURE:
+    case DRV_REMOVE:
+    case DRV_EXITSESSION:
+    case DRV_EXITAPPLICATION:
+    case DRV_POWER:
+    case DRV_CLOSE:	/* should be 0/0 */
+    case DRV_OPEN:	/* pass through */
+	/* lParam1 and lParam2 are not used */
+	ret = WINMM_MAP_OK;
+	break;
+    case DRV_CONFIGURE:
+    case DRV_INSTALL:
+	/* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
+	 * lParam2 is a pointer to DRVCONFIGINFO
+	 */
+	if (*lParam2) {
+            LPDRVCONFIGINFO16 dci16 = HeapAlloc( GetProcessHeap(), 0, sizeof(*dci16) );
+            LPDRVCONFIGINFO	dci32 = (LPDRVCONFIGINFO)(*lParam2);
+
+	    if (dci16) {
+		LPSTR str1 = NULL,str2;
+                INT len;
+		dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
+
+                if (dci32->lpszDCISectionName) {
+                    len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, NULL, 0, NULL, NULL );
+                    str1 = HeapAlloc( GetProcessHeap(), 0, len );
+                    if (str1) {
+                        WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCISectionName, -1, str1, len, NULL, NULL );
+                        dci16->lpszDCISectionName = MapLS( str1 );
+                    } else {
+                        HeapFree( GetProcessHeap(), 0, dci16);
+                        return WINMM_MAP_NOMEM;
+                    }
+		} else {
+		    dci16->lpszDCISectionName = 0L;
+		}
+                if (dci32->lpszDCIAliasName) {
+                    len = WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, NULL, 0, NULL, NULL );
+                    str2 = HeapAlloc( GetProcessHeap(), 0, len );
+                    if (str2) {
+                        WideCharToMultiByte( CP_ACP, 0, dci32->lpszDCIAliasName, -1, str2, len, NULL, NULL );
+                        dci16->lpszDCIAliasName = MapLS( str2 );
+                    } else {
+                        HeapFree( GetProcessHeap(), 0, str1);
+                        HeapFree( GetProcessHeap(), 0, dci16);
+                        return WINMM_MAP_NOMEM;
+                    }
+		} else {
+		    dci16->lpszDCISectionName = 0L;
+		}
+	    } else {
+		return WINMM_MAP_NOMEM;
+	    }
+	    *lParam2 = MapLS( dci16 );
+	    ret = WINMM_MAP_OKMEM;
+	} else {
+	    ret = WINMM_MAP_OK;
+	}
+	break;
+    default:
+	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+	   FIXME("Unknown message 0x%04x\n", wMsg);
+	}
+	ret = WINMM_MAP_OK;
+    }
+    return ret;
+}
+
+/**************************************************************************
+ *				DRIVER_UnMapMsg32To16		[internal]
+ *
+ * UnMap a 32 bit driver message to a 16 bit driver message.
+ */
+static WINMM_MapType DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
+{
+    WINMM_MapType	ret = WINMM_MAP_MSGERROR;
+
+    switch (wMsg) {
+    case DRV_LOAD:
+    case DRV_ENABLE:
+    case DRV_DISABLE:
+    case DRV_FREE:
+    case DRV_QUERYCONFIGURE:
+    case DRV_REMOVE:
+    case DRV_EXITSESSION:
+    case DRV_EXITAPPLICATION:
+    case DRV_POWER:
+    case DRV_OPEN:
+    case DRV_CLOSE:
+	/* lParam1 and lParam2 are not used */
+	break;
+    case DRV_CONFIGURE:
+    case DRV_INSTALL:
+	/* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
+	if (lParam2) {
+	    LPDRVCONFIGINFO16	dci16 = MapSL(lParam2);
+            HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCISectionName) );
+            HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCIAliasName) );
+            UnMapLS( lParam2 );
+            UnMapLS( dci16->lpszDCISectionName );
+            UnMapLS( dci16->lpszDCIAliasName );
+            HeapFree( GetProcessHeap(), 0, dci16 );
+	}
+	ret = WINMM_MAP_OK;
+	break;
+    default:
+	if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+	    FIXME("Unknown message 0x%04x\n", wMsg);
+	}
+	ret = WINMM_MAP_OK;
+    }
+    return ret;
+}
+
+/**************************************************************************
+ *				DRIVER_TryOpenDriver16		[internal]
+ *
+ * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
+ */
+static	LPWINE_DRIVER	DRIVER_OpenDriver16(LPCWSTR fn, LPCWSTR sn, LPARAM lParam2)
+{
+    LPWINE_DRIVER 	lpDrv = NULL;
+    LPCSTR		cause = NULL;
+    LPSTR               fnA = NULL, snA = NULL;
+    unsigned            len;
+
+    TRACE("(%s, %s, %08lX);\n", debugstr_w(fn), debugstr_w(sn), lParam2);
+
+    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
+    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
+
+    if (fn)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL );
+        fnA = HeapAlloc(GetProcessHeap(), 0, len);
+        if (fnA == NULL) {cause = "OOM"; goto exit;}
+        WideCharToMultiByte( CP_ACP, 0, fn, -1, fnA, len, NULL, NULL );
+    }
+
+    if (sn)
+    {
+        len = WideCharToMultiByte( CP_ACP, 0, sn, -1, NULL, 0, NULL, NULL );
+        snA = HeapAlloc(GetProcessHeap(), 0, len);
+        if (snA == NULL) {cause = "OOM"; goto exit;}
+        WideCharToMultiByte( CP_ACP, 0, sn, -1, snA, len, NULL, NULL );
+    }
+
+    /* FIXME: shall we do some black magic here on sn ?
+     *	drivers32 => drivers
+     *	mci32 => mci
+     * ...
+     */
+    lpDrv->d.d16.hDriver16 = OpenDriver16(fnA, snA, lParam2);
+    if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
+    lpDrv->dwFlags = WINE_GDF_16BIT;
+
+    TRACE("=> %p\n", lpDrv);
+    return lpDrv;
+
+exit:
+    HeapFree(GetProcessHeap(), 0, lpDrv);
+    HeapFree(GetProcessHeap(), 0, fnA);
+    HeapFree(GetProcessHeap(), 0, snA);
+    TRACE("Unable to load 16 bit module %s[%s]: %s\n", 
+          debugstr_w(fn), debugstr_w(sn), cause);
+    return NULL;
+}
+
+/******************************************************************
+ *		DRIVER_SendMessage16
+ *
+ *
+ */
+static LRESULT  DRIVER_SendMessage16(HDRVR16 hDrv16, UINT msg, 
+                                     LPARAM lParam1, LPARAM lParam2)
+{
+    LRESULT             ret = 0;
+    WINMM_MapType	map;
+
+    TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
+          hDrv16, msg, lParam1, lParam2);
+
+    switch (map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) {
+    case WINMM_MAP_OKMEM:
+    case WINMM_MAP_OK:
+        ret = SendDriverMessage16(hDrv16, msg, lParam1, lParam2);
+        if (map == WINMM_MAP_OKMEM)
+            DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
+    default:
+        break;
+    }
+    return ret;
+}
+
+/******************************************************************
+ *		DRIVER_CloseDriver16
+ *
+ *
+ */
+static LRESULT DRIVER_CloseDriver16(HDRVR16 hDrv16, LPARAM lParam1, LPARAM lParam2)
+{
+    return CloseDriver16(hDrv16, lParam1, lParam2);
+}
+
+/**************************************************************************
+ * 				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;
+}
+
+/**************************************************************************
+ * 				timeSetEvent		[MMSYSTEM.602]
+ */
+MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
+				 DWORD dwUser, UINT16 wFlags)
+{
+    if (wFlags & WINE_TIMER_IS32)
+	WARN("Unknown windows flag... wine internally used.. ooch\n");
+
+    return TIME_SetEventInternal(wDelay, wResol, (LPTIMECALLBACK)lpFunc,
+                                 dwUser, wFlags & ~WINE_TIMER_IS32);
+}
+
+/**************************************************************************
+ * 				timeKillEvent		[MMSYSTEM.603]
+ */
+MMRESULT16 WINAPI timeKillEvent16(UINT16 wID)
+{
+    return timeKillEvent(wID);
+}
+
+/**************************************************************************
+ * 				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);
+}
+
+/**************************************************************************
+ * 				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)
+{
+    HRSRC16     res;
+    HGLOBAL16   handle;
+    const BYTE* ptr16;
+    BYTE*       ptr32;
+    unsigned    pos = 0, size = 1024, len;
+    const char* str;
+    DWORD	flg;
+    WORD	eid;
+    UINT16      ret = MCIERR_OUT_OF_MEMORY;
+
+    if (!(res = FindResource16( hInst, resname, (LPSTR)RT_RCDATA))) return MCI_NO_COMMAND_TABLE;
+    if (!(handle = LoadResource16( hInst, res ))) return MCI_NO_COMMAND_TABLE;
+    ptr16 = LockResource16(handle);
+    /* converting the 16 bit resource table into a 32W one */
+    if ((ptr32 = HeapAlloc(GetProcessHeap(), 0, size)))
+    {
+        do {
+            str = (LPCSTR)ptr16;
+            ptr16 += strlen(str) + 1;
+            flg = *(const DWORD*)ptr16;
+            eid = *(const WORD*)(ptr16 + sizeof(DWORD));
+            ptr16 += sizeof(DWORD) + sizeof(WORD);
+            len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0) * sizeof(WCHAR);
+            if (pos + len + sizeof(DWORD) + sizeof(WORD) > size)
+            {
+                while (pos + len * sizeof(WCHAR) + sizeof(DWORD) + sizeof(WORD) > size) size += 1024;
+                ptr32 = HeapReAlloc(GetProcessHeap(), 0, ptr32, size);
+                if (!ptr32) goto the_end;
+            }
+            MultiByteToWideChar(CP_ACP, 0, str, -1, (LPWSTR)(ptr32 + pos), len / sizeof(WCHAR));
+            *(DWORD*)(ptr32 + pos + len) = flg;
+            *(WORD*)(ptr32 + pos + len + sizeof(DWORD)) = eid;
+            pos += len + sizeof(DWORD) + sizeof(WORD);
+        } while (eid != MCI_END_COMMAND_LIST);
+    }
+the_end:
+    FreeResource16( handle );
+    if (ptr32) ret = MCI_SetCommandTable(ptr32, type);
+    return ret;
+}
+
+/**************************************************************************
+ *                    	mciFreeCommandResource			[MMSYSTEM.713]
+ */
+BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
+{
+    TRACE("(%04x)!\n", uTable);
+
+    return MCI_DeleteCommandTable(uTable, TRUE);
+}
+
+/* ###################################################
+ * #                     MMIO                        #
+ * ###################################################
+ */
+
+/****************************************************************
+ *       		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_Callback16
+ *
+ *
+ */
+static LRESULT MMIO_Callback16(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage,
+                               LPARAM lParam1, LPARAM lParam2)
+{
+    DWORD 		result;
+    MMIOINFO16          mmioInfo16;
+    SEGPTR		segmmioInfo16;
+    LPARAM		lp1 = lParam1, lp2 = lParam2;
+    WORD args[7];
+
+    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_ResetSegmentedData
+ *
+ */
+static LRESULT     MMIO_SetSegmentedBuffer(HMMIO hmmio, SEGPTR ptr, BOOL release)
+{
+    LPWINE_MMIO		wm;
+
+    if ((wm = MMIO_Get(hmmio)) == NULL)
+	return MMSYSERR_INVALHANDLE;
+    if (release) UnMapLS(wm->segBuffer16);
+    wm->segBuffer16 = ptr;
+    return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+ * 				mmioOpen       		[MMSYSTEM.1210]
+ */
+HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
+			  DWORD dwOpenFlags)
+{
+    HMMIO 	ret;
+
+    if (lpmmioinfo16) {
+	MMIOINFO	mmioinfo;
+
+	memset(&mmioinfo, 0, sizeof(mmioinfo));
+
+	mmioinfo.dwFlags     = lpmmioinfo16->dwFlags;
+	mmioinfo.fccIOProc   = lpmmioinfo16->fccIOProc;
+	mmioinfo.pIOProc     = (LPMMIOPROC)lpmmioinfo16->pIOProc;
+	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 = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, MMIO_PROC_16);
+        MMIO_SetSegmentedBuffer(mmioinfo.hmmio, (SEGPTR)lpmmioinfo16->pchBuffer, FALSE);
+
+	lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet;
+        lpmmioinfo16->hmmio     = HMMIO_16(mmioinfo.hmmio);
+    } else {
+	ret = MMIO_Open(szFileName, NULL, dwOpenFlags, MMIO_PROC_32A);
+    }
+    return HMMIO_16(ret);
+}
+
+/**************************************************************************
+ * 				mmioClose      		[MMSYSTEM.1211]
+ */
+MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
+{
+    MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (SEGPTR)NULL, TRUE);
+    return mmioClose(HMMIO_32(hmmio), uFlags);
+}
+
+/**************************************************************************
+ * 				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;
+    LPWINE_MMIO		wm;
+
+    TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags);
+
+    if ((wm = MMIO_Get(HMMIO_32(hmmio))) == NULL)
+	return MMSYSERR_INVALHANDLE;
+
+    ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
+    if (ret != MMSYSERR_NOERROR) return ret;
+
+    lpmmioinfo->dwFlags     = mmioinfo.dwFlags;
+    lpmmioinfo->fccIOProc   = mmioinfo.fccIOProc;
+    lpmmioinfo->pIOProc     = (wm->ioProc->type == MMIO_PROC_16) ?
+        (LPMMIOPROC16)wm->ioProc->pIOProc : NULL;
+    lpmmioinfo->wErrorRet   = mmioinfo.wErrorRet;
+    lpmmioinfo->hTask       = HTASK_16(mmioinfo.hTask);
+    lpmmioinfo->cchBuffer   = mmioinfo.cchBuffer;
+    lpmmioinfo->pchBuffer   = (void*)wm->segBuffer16;
+    lpmmioinfo->pchNext     = (void*)(wm->segBuffer16 + (mmioinfo.pchNext - mmioinfo.pchBuffer));
+    lpmmioinfo->pchEndRead  = (void*)(wm->segBuffer16 + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
+    lpmmioinfo->pchEndWrite = (void*)(wm->segBuffer16 + (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);
+
+    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)
+        MMIO_SetSegmentedBuffer(HMMIO_32(hmmio), (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)
+{
+    return (LPMMIOPROC16)MMIO_InstallIOProc(fccIOProc, (LPMMIOPROC)pIOProc,
+                                            dwFlags, MMIO_PROC_16);
+}
+
+/**************************************************************************
+ * 				mmioSendMessage	[MMSYSTEM.1222]
+ */
+LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
+				 LPARAM lParam1, LPARAM lParam2)
+{
+    return MMIO_SendMessage(HMMIO_32(hmmio), uMessage, 
+                            lParam1, lParam2, MMIO_PROC_16);
+}
+
+/**************************************************************************
+ * 				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) {
+        MMIO_InstallIOProc(lpmmioinfo->fccIOProc, (LPMMIOPROC)lpmmioinfo->pIOProc,
+                           MMIO_INSTALLPROC, MMIO_PROC_16);
+        inst = TRUE;
+    }
+    memset(&mmioinfo, 0, sizeof(mmioinfo));
+    mmioinfo.fccIOProc = lpmmioinfo->fccIOProc;
+    ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags);
+    if (inst) {
+        MMIO_InstallIOProc(lpmmioinfo->fccIOProc, NULL,
+                           MMIO_REMOVEPROC, MMIO_PROC_16);
+    }
+    return ret;
+}
+
+/* ###################################################
+ * #                     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 joySetCapture16(hWnd, wID, wPeriod, bChanged);
+}
+
+/**************************************************************************
+ * 				joySetThreshold		[MMSYSTEM.107]
+ */
+MMRESULT16 WINAPI joySetThreshold16(UINT16 wID, UINT16 wThreshold)
+{
+    return joySetThreshold16(wID,wThreshold);
+}
+
+/**************************************************************************
+ * 				joySetCalibration	[MMSYSTEM.109]
+ */
+MMRESULT16 WINAPI joySetCalibration16(UINT16 wID)
+{
+    FIXME("(%04X): stub.\n", wID);
+    return JOYERR_NOCANDO;
+}
-- 
1.4.1



More information about the wine-patches mailing list