[PATCH 15/16] [WinMM]: get rid of 16bit driver support
Eric Pouech
eric.pouech at orange.fr
Thu Oct 22 15:11:15 CDT 2009
A+
---
0 files changed, 0 insertions(+), 0 deletions(-)
diff --git a/dlls/winmm/driver.c b/dlls/winmm/driver.c
index 58afcba..48152ab 100644
--- a/dlls/winmm/driver.c
+++ b/dlls/winmm/driver.c
@@ -53,10 +53,6 @@ static LPWINE_DRIVER lpDrvItemList /* = NULL */;
static const WCHAR HKLM_BASE[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
-LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM) /* = NULL */;
-LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
-LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */;
-
static void DRIVER_Dump(const char *comment)
{
#if 0
@@ -90,7 +86,7 @@ static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** foun
if (found) *found = NULL;
for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
{
- if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule == hModule)
+ if (lpDrv->hModule == hModule)
{
if (found && !*found) *found = lpDrv;
count++;
@@ -121,7 +117,7 @@ LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr)
}
__ENDTRY;
- if (d) TRACE("%p -> %p, %p\n", hDrvr, d->d.d32.lpDrvProc, (void *)d->d.d32.dwDriverID);
+ if (d) TRACE("%p -> %p, %p\n", hDrvr, d->lpDrvProc, (void *)d->dwDriverID);
else TRACE("%p -> NULL\n", hDrvr);
return d;
@@ -135,18 +131,12 @@ static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
{
LRESULT ret = 0;
- if (lpDrv->dwFlags & WINE_GDF_16BIT) {
- /* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
- */
- if (pFnSendMessage16)
- ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
- } else {
- TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
- lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, lpDrv, msg, lParam1, lParam2);
- ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
- TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
- lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, lpDrv, msg, lParam1, lParam2, ret);
- }
+ TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
+ lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2);
+ ret = lpDrv->lpDrvProc(lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+ TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
+ lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2, ret);
+
return ret;
}
@@ -180,12 +170,10 @@ LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
*/
static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
{
- if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
- /* last of this driver in list ? */
- if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 1) {
- DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
- DRIVER_SendMessage(lpDrv, DRV_FREE, 0L, 0L);
- }
+ /* last of this driver in list ? */
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 1) {
+ DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
+ DRIVER_SendMessage(lpDrv, DRV_FREE, 0L, 0L);
}
EnterCriticalSection( &mmdriver_lock );
@@ -198,9 +186,8 @@ static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
/* trash magic number */
lpDrv->dwMagic ^= 0xa5a5a5a5;
- lpDrv->d.d32.lpDrvProc = NULL;
- lpDrv->d.d32.dwDriverID = 0;
- lpDrv->d.d16.hDriver16 = 0;
+ lpDrv->lpDrvProc = NULL;
+ lpDrv->dwDriverID = 0;
LeaveCriticalSection( &mmdriver_lock );
@@ -217,25 +204,23 @@ static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lPar
{
lpNewDrv->dwMagic = WINE_DI_MAGIC;
/* First driver to be loaded for this module, need to load correctly the module */
- if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
- /* first of this driver in list ? */
- if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
- if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
- TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
- return FALSE;
- }
- /* returned value is not checked */
- DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
- }
+ /* first of this driver in list ? */
+ if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->hModule, NULL) == 0) {
+ if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
+ TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
+ return FALSE;
+ }
+ /* returned value is not checked */
+ DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
+ }
- /* Now just open a new instance of a driver on this module */
- lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
+ /* Now just open a new instance of a driver on this module */
+ lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
- if (lpNewDrv->d.d32.dwDriverID == 0)
- {
- TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
- return FALSE;
- }
+ if (lpNewDrv->dwDriverID == 0)
+ {
+ TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
+ return FALSE;
}
EnterCriticalSection( &mmdriver_lock );
@@ -313,18 +298,18 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
- lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
- if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
+ lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
+ if (lpDrv->lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
- lpDrv->dwFlags = 0;
- lpDrv->d.d32.hModule = hModule;
- lpDrv->d.d32.dwDriverID = 0;
+ lpDrv->dwFlags = 0;
+ lpDrv->hModule = hModule;
+ lpDrv->dwDriverID = 0;
/* Win32 installable drivers must support a two phase opening scheme:
* + first open with NULL as lParam2 (session instance),
* + then do a second open with the real non null lParam2)
*/
- if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0 && lParam2)
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 0 && lParam2)
{
LPWINE_DRIVER ret;
@@ -421,17 +406,6 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar
(lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
goto the_end;
- /* now we will try a 16 bit driver (and add all the glue to make it work... which
- * is located in our mmsystem implementation)
- * so ensure, we can load our mmsystem, otherwise just fail
- */
- WINMM_CheckForMMSystem();
- if (pFnOpenDriver16 &&
- (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam)))
- {
- if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end;
- HeapFree(GetProcessHeap(), 0, lpDrv);
- }
TRACE("Failed to open driver %s from system.ini file, section %s\n",
debugstr_w(lpDriverName), debugstr_w(lpSectionName));
@@ -458,33 +432,25 @@ LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
{
- if (lpDrv->dwFlags & WINE_GDF_16BIT)
- {
- if (pFnCloseDriver16)
- pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
- }
- else
- DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
+ LPWINE_DRIVER lpDrv0;
+
+ DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
DRIVER_RemoveFromList(lpDrv);
- if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
+ if (lpDrv->dwFlags & WINE_GDF_SESSION)
+ FIXME("WINE_GDF_SESSION: Shouldn't happen (%p)\n", lpDrv);
+ /* if driver has an opened session instance, we have to close it too */
+ if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, &lpDrv0) == 1 &&
+ (lpDrv0->dwFlags & WINE_GDF_SESSION))
{
- LPWINE_DRIVER lpDrv0;
-
- if (lpDrv->dwFlags & WINE_GDF_SESSION)
- FIXME("WINE_GDF_SESSION: Shouldn't happen (%p)\n", lpDrv);
- /* if driver has an opened session instance, we have to close it too */
- if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1 &&
- (lpDrv0->dwFlags & WINE_GDF_SESSION))
- {
- DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0, 0);
- DRIVER_RemoveFromList(lpDrv0);
- FreeLibrary(lpDrv0->d.d32.hModule);
- HeapFree(GetProcessHeap(), 0, lpDrv0);
- }
- FreeLibrary(lpDrv->d.d32.hModule);
+ DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0, 0);
+ DRIVER_RemoveFromList(lpDrv0);
+ FreeLibrary(lpDrv0->hModule);
+ HeapFree(GetProcessHeap(), 0, lpDrv0);
}
+ FreeLibrary(lpDrv->hModule);
+
HeapFree(GetProcessHeap(), 0, lpDrv);
ret = TRUE;
}
@@ -537,8 +503,7 @@ HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
TRACE("(%p);\n", hDrvr);
if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
- if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
- hModule = lpDrv->d.d32.hModule;
+ hModule = lpDrv->hModule;
}
TRACE("=> %p\n", hModule);
return hModule;
diff --git a/dlls/winmm/lolvldrv.c b/dlls/winmm/lolvldrv.c
index ae95c91..1c5e06b 100644
--- a/dlls/winmm/lolvldrv.c
+++ b/dlls/winmm/lolvldrv.c
@@ -36,17 +36,11 @@
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
-LRESULT (*pFnCallMMDrvFunc16)(DWORD,WORD,WORD,LONG,LONG,LONG) /* = NULL */;
-unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER) /* = NULL */;
-
/* each known type of driver has an instance of this structure */
typedef struct tagWINE_LLTYPE {
/* those attributes depend on the specification of the type */
LPCSTR typestr; /* name (for debugging) */
BOOL bSupportMapper; /* if type is allowed to support mapper */
- MMDRV_MAPFUNC Map32WTo16; /* when hi-func (in mmsystem or winmm) and */
- MMDRV_UNMAPFUNC UnMap32WTo16; /* low-func (in .drv) do not match */
- LPDRVCALLBACK Callback; /* handles callback for a specified type */
/* those attributes reflect the loaded/current situation for the type */
UINT wMaxId; /* number of loaded devices (sum across all loaded drivers) */
LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */
@@ -58,7 +52,7 @@ static WINE_MM_DRIVER MMDrvs[8];
static LPWINE_MLD MM_MLDrvs[40];
#define MAX_MM_MLDRVS (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
-#define A(_x,_y) {#_y, _x, NULL, NULL, NULL, 0, NULL, -1}
+#define A(_x,_y) {#_y, _x, 0, NULL, -1}
/* Note: the indices of this array must match the definitions
* of the MMDRV_???? manifest constants
*/
@@ -72,31 +66,6 @@ static WINE_LLTYPE llTypes[MMDRV_MAX] = {
};
#undef A
-/******************************************************************
- * MMDRV_InstallMap
- *
- *
- */
-void MMDRV_InstallMap(unsigned int drv,
- MMDRV_MAPFUNC mp3216, MMDRV_UNMAPFUNC um3216,
- LPDRVCALLBACK cb)
-{
- assert(drv < MMDRV_MAX);
- llTypes[drv].Map32WTo16 = mp3216;
- llTypes[drv].UnMap32WTo16 = um3216;
- llTypes[drv].Callback = cb;
-}
-
-/******************************************************************
- * MMDRV_Is32
- *
- */
-BOOL MMDRV_Is32(unsigned int idx)
-{
- TRACE("(%d)\n", idx);
- return MMDrvs[idx].bIs32;
-}
-
/**************************************************************************
* MMDRV_GetNum [internal]
*/
@@ -117,7 +86,6 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
DWORD ret;
WINE_MM_DRIVER_PART* part;
WINE_LLTYPE* llType = &llTypes[mld->type];
- WINMM_MapType map;
int devID;
TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx)\n",
@@ -150,41 +118,13 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
ERR("!(devID(%d) < part->nIDMax(%d))\n", devID, part->nIDMax);
#endif
- if (lpDrv->bIs32) {
- assert(part->u.fnMessage32);
+ assert(part->fnMessage32);
+
+ TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
+ mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
+ ret = part->fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
+ TRACE("=> %s\n", WINMM_ErrorToString(ret));
- TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
- mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
- ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
- TRACE("=> %s\n", WINMM_ErrorToString(ret));
- } else {
- assert(part->u.fnMessage16 && pFnCallMMDrvFunc16);
-
- map = llType->Map32WTo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2);
- switch (map) {
- case WINMM_MAP_NOMEM:
- ret = MMSYSERR_NOMEM;
- break;
- case WINMM_MAP_MSGERROR:
- FIXME("NIY: no conversion yet 32->16 (%u)\n", wMsg);
- ret = MMSYSERR_ERROR;
- break;
- case WINMM_MAP_OK:
- case WINMM_MAP_OKMEM:
- TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
- mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
- ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, mld->uDeviceID, wMsg,
- mld->dwDriverInstance, dwParam1, dwParam2);
- TRACE("=> %s\n", WINMM_ErrorToString(ret));
- if (map == WINMM_MAP_OKMEM)
- llType->UnMap32WTo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret);
- break;
- default:
- FIXME("NIY\n");
- ret = MMSYSERR_NOTSUPPORTED;
- break;
- }
- }
return ret;
}
@@ -227,13 +167,6 @@ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
mld->dwCallback = *dwCallback;
mld->dwClientInstance = *dwInstance;
- if (llTypes[type].Callback)
- {
- *dwFlags = LOWORD(*dwFlags) | CALLBACK_FUNCTION;
- *dwCallback = (DWORD_PTR)llTypes[type].Callback;
- *dwInstance = (DWORD_PTR)mld; /* FIXME: wouldn't some 16 bit drivers only use the loword ? */
- }
-
return mld;
}
@@ -442,29 +375,16 @@ static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg)
/* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */
/* the DRVM_ENABLE is only required when the PnP node is non zero */
-
- if (lpDrv->bIs32 && part->u.fnMessage32) {
- ret = part->u.fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
- TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
-#if 0
- ret = part->u.fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
- TRACE("DRVM_ENABLE => %08lx\n", ret);
-#endif
- count = part->u.fnMessage32(0, wMsg, 0L, 0L, 0L);
- } else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
- ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
- 0, DRVM_INIT, 0L, 0L, 0L);
- TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
+ if (part->fnMessage32) {
+ ret = part->fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
+ TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
#if 0
- ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
- 0, DRVM_ENABLE, 0L, 0L, 0L);
- TRACE("DRVM_ENABLE => %08lx\n", ret);
+ ret = part->fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
+ TRACE("DRVM_ENABLE => %08lx\n", ret);
#endif
- count = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
- 0, wMsg, 0L, 0L, 0L);
- } else {
- return FALSE;
+ count = part->fnMessage32(0, wMsg, 0L, 0L, 0L);
}
+ else return FALSE;
TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr);
@@ -529,6 +449,7 @@ static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
int i, count = 0;
LPWINE_MM_DRIVER lpDrv = &MMDrvs[MMDrvsHi];
LPWINE_DRIVER d;
+ WINEMM_msgFunc32 func;
TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N');
@@ -550,20 +471,16 @@ static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
}
d = DRIVER_FindFromHDrvr(lpDrv->hDriver);
- lpDrv->bIs32 = (d->dwFlags & WINE_GDF_16BIT) ? FALSE : TRUE;
/* Then look for xxxMessage functions */
#define AA(_h,_w,_x,_y,_z) \
func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
if (func != NULL) \
- { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
+ { lpDrv->parts[_w].fnMessage##_y = func; count++; \
TRACE("Got %d bit func '%s'\n", _y, #_x); }
- if (lpDrv->bIs32) {
- WINEMM_msgFunc32 func;
-
- if (d->d.d32.hModule) {
-#define A(_x,_y) AA(d->d.d32.hModule,_x,_y,32,GetProcAddress)
+ if (d->hModule) {
+#define A(_x,_y) AA(d->hModule,_x,_y,32,GetProcAddress)
A(MMDRV_AUX, auxMessage);
A(MMDRV_MIXER, mxdMessage);
A(MMDRV_MIDIIN, midMessage);
@@ -571,9 +488,6 @@ static BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
A(MMDRV_WAVEIN, widMessage);
A(MMDRV_WAVEOUT, wodMessage);
#undef A
- }
- } else if (WINMM_CheckForMMSystem() && pFnLoadMMDrvFunc16) {
- count += pFnLoadMMDrvFunc16(drvFileName, d, lpDrv);
}
#undef AA
@@ -664,24 +578,13 @@ static BOOL MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type)
DWORD ret;
TRACE("(%p, %04x)\n", lpDrv, type);
- if (lpDrv->bIs32 && part->u.fnMessage32) {
+ if (part->fnMessage32) {
#if 0
- ret = part->u.fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
- TRACE("DRVM_DISABLE => %08lx\n", ret);
+ ret = part->fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
+ TRACE("DRVM_DISABLE => %08lx\n", ret);
#endif
- ret = part->u.fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
- TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
- } else if (!lpDrv->bIs32 && part->u.fnMessage16 && pFnCallMMDrvFunc16) {
-#if 0
- ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
- 0, DRVM_DISABLE, 0L, 0L, 0L);
- TRACE("DRVM_DISABLE => %08lx\n", ret);
-#endif
- ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
- 0, DRVM_EXIT, 0L, 0L, 0L);
- TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
- } else {
- return FALSE;
+ ret = part->fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
+ TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
}
return TRUE;
diff --git a/dlls/winmm/message16.c b/dlls/winmm/message16.c
index be07d3c..a43c559 100644
--- a/dlls/winmm/message16.c
+++ b/dlls/winmm/message16.c
@@ -26,95 +26,16 @@
#include "windef.h"
#include "winbase.h"
#include "wownt32.h"
-#include "winemm.h"
#include "winemm16.h"
#include "digitalv.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
-/******************************************************************
- * WINMM_MMTIME16to32
- */
-static void WINMM_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));
-}
-
-
-/**************************************************************************
- * MMDRV_Callback [internal]
- */
-static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
- mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
-
- if ((mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
- {
- WORD args[8];
- /* 16 bit func, call it */
- TRACE("Function (16 bit) !\n");
-
- args[7] = HDRVR_16(hDev);
- args[6] = uMsg;
- args[5] = HIWORD(mld->dwClientInstance);
- args[4] = LOWORD(mld->dwClientInstance);
- args[3] = HIWORD(dwParam1);
- args[2] = LOWORD(dwParam1);
- args[1] = HIWORD(dwParam2);
- args[0] = LOWORD(dwParam2);
- WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
- } else {
- DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
- mld->dwClientInstance, dwParam1, dwParam2);
- }
-}
-
/* =================================
* A U X M A P P E R S
* ================================= */
-/**************************************************************************
- * MMDRV_Aux_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_Aux_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
-#if 0
- case AUXDM_GETDEVCAPS:
- lpCaps->wMid = ac16.wMid;
- lpCaps->wPid = ac16.wPid;
- lpCaps->vDriverVersion = ac16.vDriverVersion;
- strcpy(lpCaps->szPname, ac16.szPname);
- lpCaps->wTechnology = ac16.wTechnology;
- lpCaps->dwSupport = ac16.dwSupport;
-#endif
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_Aux_Callback [internal]
- */
-static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- FIXME("NIY\n");
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
/* =================================
* M I X E R M A P P E R S
* ================================= */
@@ -150,33 +71,6 @@ static MMSYSTEM_MapType MMSYSTDRV_Mixer_UnMap16To32W(UINT wMsg, DWORD_PTR* lpPa
}
/**************************************************************************
- * MMDRV_Mixer_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_Mixer_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_Mixer_Callback [internal]
- */
-static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- FIXME("NIY\n");
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
-/**************************************************************************
* MMSYSTDRV_Mixer_MapCB
*/
static void MMSYSTDRV_Mixer_MapCB(DWORD uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
@@ -205,63 +99,6 @@ static MMSYSTEM_MapType MMSYSTDRV_MidiIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpP
}
/**************************************************************************
- * MMDRV_MidiIn_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_MidiIn_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- return WINMM_MAP_MSGERROR;
-}
-
-/**************************************************************************
- * MMDRV_MidiIn_Callback [internal]
- */
-static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- switch (uMsg) {
- case MIM_OPEN:
- case MIM_CLOSE:
- /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
-
- case MIM_DATA:
- case MIM_MOREDATA:
- case MIM_ERROR:
- /* dwParam1 & dwParam2 are data, nothing to do */
- break;
- case MIM_LONGDATA:
- case MIM_LONGERROR:
- /* dwParam1 points to a MidiHdr, work to be done !!! */
- if (!MMDRV_Is32(mld->mmdIndex)) {
- /* initial map is: 32 => 16 */
- LPMIDIHDR mh16 = MapSL(dwParam1);
- LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
-
- dwParam1 = (DWORD)mh32;
- mh32->dwFlags = mh16->dwFlags;
- mh32->dwBytesRecorded = mh16->dwBytesRecorded;
- if (mh32->reserved >= sizeof(MIDIHDR))
- mh32->dwOffset = mh16->dwOffset;
- }
- /* else { 32 => 32, nothing to do, same struct is kept }*/
- break;
- /* case MOM_POSITIONCB: */
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
-/**************************************************************************
* MMSYSTDRV_MidiIn_MapCB [internal]
*/
static void MMSYSTDRV_MidiIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
@@ -464,257 +301,6 @@ static MMSYSTEM_MapType MMSYSTDRV_MidiOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lp
return ret;
}
-/**************************************************************************
- * MMDRV_MidiOut_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- WINMM_MapType ret = WINMM_MAP_MSGERROR;
-
- switch (wMsg) {
- case MODM_CLOSE:
- case MODM_GETNUMDEVS:
- case MODM_DATA:
- case MODM_RESET:
- case MODM_SETVOLUME:
- ret = WINMM_MAP_OK;
- break;
- case MODM_GETDEVCAPS:
- {
- LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)*lpParam1;
- LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSW)+sizeof(MIDIOUTCAPS16));
-
- if (ptr) {
- *(LPMIDIOUTCAPSW*)ptr = moc32;
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- *lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSW);
- *lpParam2 = sizeof(MIDIOUTCAPS16);
- }
- break;
- case MODM_PREPARE:
- {
- LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1;
- LPMIDIHDR mh16;
- LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
-
- if (ptr) {
- *(LPMIDIHDR*)ptr = mh32;
- mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
- *lpParam1 = MapLS(mh16);
- mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
- /* data will be copied on WODM_WRITE */
- mh16->dwBufferLength = mh32->dwBufferLength;
- mh16->dwBytesRecorded = mh32->dwBytesRecorded;
- mh16->dwUser = mh32->dwUser;
- mh16->dwFlags = mh32->dwFlags;
- /* FIXME: nothing on mh32->lpNext */
- /* could link the mh32->lpNext at this level for memory house keeping */
- mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
-
- mh32->lpNext = mh16; /* for reuse in unprepare and write */
- mh32->reserved = *lpParam2;
-
- TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
- *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
- *lpParam2 = sizeof(MIDIHDR);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case MODM_UNPREPARE:
- case MODM_LONGDATA:
- {
- LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
- LPMIDIHDR mh16 = mh32->lpNext;
- LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
-
- assert(*(LPMIDIHDR*)ptr == mh32);
-
- if (wMsg == MODM_LONGDATA)
- memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
-
- *lpParam1 = MapLS(mh16);
- *lpParam2 = sizeof(MIDIHDR);
- TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
- *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
-
- /* dwBufferLength can be reduced between prepare & write */
- if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
- ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
- mh16->dwBufferLength, mh32->dwBufferLength);
- } else
- mh16->dwBufferLength = mh32->dwBufferLength;
- ret = WINMM_MAP_OKMEM;
- }
- break;
- case MODM_OPEN:
- {
- LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1;
- LPVOID ptr;
- LPMIDIOPENDESC16 mod16;
-
- /* allocated data are mapped as follows:
- LPMIDIOPENDESC ptr to orig lParam1
- DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
- DWORD dwUser passed to driver
- MIDIOPENDESC16 mod16: openDesc passed to driver
- MIDIOPENSTRMID cIds
- */
- ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
- mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
-
- if (ptr) {
- SEGPTR segptr = MapLS(ptr);
- *(LPMIDIOPENDESC*)ptr = mod32;
- *(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
- mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
-
- mod16->hMidi = HMIDI_16(mod32->hMidi);
- mod16->dwCallback = mod32->dwCallback;
- mod16->dwInstance = mod32->dwInstance;
- mod16->dnDevNode = mod32->dnDevNode;
- mod16->cIds = mod32->cIds;
- memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
-
- *lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
- *lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case MODM_GETVOLUME:
- case MODM_CACHEPATCHES:
- case MODM_CACHEDRUMPATCHES:
- default:
- FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_MidiOut_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- WINMM_MapType ret = WINMM_MAP_MSGERROR;
-
- switch (wMsg) {
- case MODM_CLOSE:
- case MODM_GETNUMDEVS:
- case MODM_DATA:
- case MODM_RESET:
- case MODM_SETVOLUME:
- ret = WINMM_MAP_OK;
- break;
- case MODM_GETDEVCAPS:
- {
- LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSW);
- LPMIDIOUTCAPSW moc32 = *(LPMIDIOUTCAPSW*)ptr;
-
- moc32->wMid = moc16->wMid;
- moc32->wPid = moc16->wPid;
- moc32->vDriverVersion = moc16->vDriverVersion;
- WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
- sizeof(moc16->szPname), NULL, NULL );
- moc32->wTechnology = moc16->wTechnology;
- moc32->wVoices = moc16->wVoices;
- moc32->wNotes = moc16->wNotes;
- moc32->wChannelMask = moc16->wChannelMask;
- moc32->dwSupport = moc16->dwSupport;
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case MODM_PREPARE:
- case MODM_UNPREPARE:
- case MODM_LONGDATA:
- {
- LPMIDIHDR mh16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
- LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr;
-
- assert(mh32->lpNext == mh16);
- UnMapLS( *lpParam1 );
- mh32->dwBytesRecorded = mh16->dwBytesRecorded;
- mh32->dwUser = mh16->dwUser;
- mh32->dwFlags = mh16->dwFlags;
-
- if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
- HeapFree( GetProcessHeap(), 0, ptr );
- mh32->lpNext = 0;
- }
- ret = WINMM_MAP_OK;
- }
- break;
- case MODM_OPEN:
- {
- LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
- UnMapLS( *lpParam1 );
- **(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
-
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case MODM_GETVOLUME:
- case MODM_CACHEPATCHES:
- case MODM_CACHEDRUMPATCHES:
- default:
- FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_MidiOut_Callback [internal]
- */
-static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- switch (uMsg) {
- case MOM_OPEN:
- case MOM_CLOSE:
- /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
- break;
- case MOM_DONE:
- if (!MMDRV_Is32(mld->mmdIndex)) {
- /* initial map is: 32 => 16 */
- LPMIDIHDR mh16 = MapSL(dwParam1);
- LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
-
- dwParam1 = (DWORD)mh32;
- mh32->dwFlags = mh16->dwFlags;
- mh32->dwOffset = mh16->dwOffset;
- if (mh32->reserved >= sizeof(MIDIHDR))
- mh32->dwOffset = mh16->dwOffset;
- }
- /* else { 32 => 32, nothing to do, same struct is kept }*/
- break;
- /* case MOM_POSITIONCB: */
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
/******************************************************************
* MMSYSTDRV_MidiOut_MapCB
*/
@@ -935,300 +521,6 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveIn_UnMap16To32W(UINT wMsg, DWORD_PTR* lpP
}
/**************************************************************************
- * MMDRV_WaveIn_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- WINMM_MapType ret = WINMM_MAP_MSGERROR;
-
- switch (wMsg) {
- case WIDM_CLOSE:
- case WIDM_GETNUMDEVS:
- case WIDM_RESET:
- case WIDM_START:
- case WIDM_STOP:
- ret = WINMM_MAP_OK;
- break;
-
- case WIDM_OPEN:
- {
- LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
- int sz = sizeof(WAVEFORMATEX);
- LPVOID ptr;
- LPWAVEOPENDESC16 wod16;
-
- /* allocated data are mapped as follows:
- LPWAVEOPENDESC ptr to orig lParam1
- DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
- DWORD dwUser passed to driver
- WAVEOPENDESC16 wod16: openDesc passed to driver
- WAVEFORMATEX openDesc->lpFormat passed to driver
- xxx extra bytes to WAVEFORMATEX
- */
- if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
- TRACE("Allocating %u extra bytes (%d)\n", wod32->lpFormat->cbSize, wod32->lpFormat->wFormatTag);
- sz += wod32->lpFormat->cbSize;
- }
-
- ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
-
- if (ptr) {
- SEGPTR seg_ptr = MapLS( ptr );
- *(LPWAVEOPENDESC*)ptr = wod32;
- *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
- wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
-
- wod16->hWave = HWAVE_16(wod32->hWave);
- wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
- memcpy(wod16 + 1, wod32->lpFormat, sz);
-
- wod16->dwCallback = wod32->dwCallback;
- wod16->dwInstance = wod32->dwInstance;
- wod16->uMappedDeviceID = wod32->uMappedDeviceID;
- wod16->dnDevNode = wod32->dnDevNode;
-
- *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
- *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case WIDM_PREPARE:
- {
- LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
- LPWAVEHDR wh16;
- LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
-
- if (ptr) {
- SEGPTR seg_ptr = MapLS( ptr );
- *(LPWAVEHDR*)ptr = wh32;
- wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
- wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
- /* data will be copied on WODM_WRITE */
- wh16->dwBufferLength = wh32->dwBufferLength;
- wh16->dwBytesRecorded = wh32->dwBytesRecorded;
- wh16->dwUser = wh32->dwUser;
- wh16->dwFlags = wh32->dwFlags;
- wh16->dwLoops = wh32->dwLoops;
- /* FIXME: nothing on wh32->lpNext */
- /* could link the wh32->lpNext at this level for memory house keeping */
- wh32->lpNext = wh16; /* for reuse in unprepare and write */
- *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
- *lpParam2 = sizeof(WAVEHDR);
- TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
- *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case WIDM_ADDBUFFER:
- case WIDM_UNPREPARE:
- {
- LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
- LPWAVEHDR wh16 = wh32->lpNext;
- LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
- SEGPTR seg_ptr = MapLS( ptr );
-
- assert(*(LPWAVEHDR*)ptr == wh32);
-
- if (wMsg == WIDM_ADDBUFFER)
- memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
-
- *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
- *lpParam2 = sizeof(WAVEHDR);
- TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
- *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
-
- /* dwBufferLength can be reduced between prepare & write */
- if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
- ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
- wh16->dwBufferLength, wh32->dwBufferLength);
- } else
- wh16->dwBufferLength = wh32->dwBufferLength;
- ret = WINMM_MAP_OKMEM;
- }
- break;
- case WIDM_GETDEVCAPS:
- {
- LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)*lpParam1;
- LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSW) + sizeof(WAVEINCAPS16));
-
- if (ptr) {
- *(LPWAVEINCAPSW*)ptr = wic32;
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- *lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSW);
- *lpParam2 = sizeof(WAVEINCAPS16);
- }
- break;
- case WIDM_GETPOS:
- {
- LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
- LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
- LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
-
- if (ptr) {
- *(LPMMTIME*)ptr = mmt32;
- mmt16->wType = mmt32->wType;
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
- *lpParam2 = sizeof(MMTIME16);
- }
- break;
- case DRVM_MAPPER_STATUS:
- {
- LPDWORD p32 = (LPDWORD)*lpParam2;
- *lpParam2 = MapLS(p32);
- ret = WINMM_MAP_OKMEM;
- }
- break;
- default:
- FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_WaveIn_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- WINMM_MapType ret = WINMM_MAP_MSGERROR;
-
- switch (wMsg) {
- case WIDM_CLOSE:
- case WIDM_GETNUMDEVS:
- case WIDM_RESET:
- case WIDM_START:
- case WIDM_STOP:
- ret = WINMM_MAP_OK;
- break;
-
- case WIDM_OPEN:
- {
- LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
- LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
-
- UnMapLS( *lpParam1 );
- wod32->uMappedDeviceID = wod16->uMappedDeviceID;
- **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
-
- case WIDM_ADDBUFFER:
- case WIDM_PREPARE:
- case WIDM_UNPREPARE:
- {
- LPWAVEHDR wh16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
- LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
-
- assert(wh32->lpNext == wh16);
- wh32->dwBytesRecorded = wh16->dwBytesRecorded;
- wh32->dwUser = wh16->dwUser;
- wh32->dwFlags = wh16->dwFlags;
- wh32->dwLoops = wh16->dwLoops;
- UnMapLS( *lpParam1 );
-
- if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
- HeapFree( GetProcessHeap(), 0, ptr );
- wh32->lpNext = 0;
- }
- ret = WINMM_MAP_OK;
- }
- break;
- case WIDM_GETDEVCAPS:
- {
- LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSW);
- LPWAVEINCAPSW wic32 = *(LPWAVEINCAPSW*)ptr;
-
- wic32->wMid = wic16->wMid;
- wic32->wPid = wic16->wPid;
- wic32->vDriverVersion = wic16->vDriverVersion;
- WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
- sizeof(wic16->szPname), NULL, NULL );
- wic32->dwFormats = wic16->dwFormats;
- wic32->wChannels = wic16->wChannels;
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case WIDM_GETPOS:
- {
- LPMMTIME16 mmt16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
- LPMMTIME mmt32 = *(LPMMTIME*)ptr;
-
- WINMM_MMTIME16to32(mmt32, mmt16);
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case DRVM_MAPPER_STATUS:
- {
- UnMapLS( *lpParam2 );
- ret = WINMM_MAP_OK;
- }
- break;
- default:
- FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_WaveIn_Callback [internal]
- */
-static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- switch (uMsg) {
- case WIM_OPEN:
- case WIM_CLOSE:
- /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
- break;
- case WIM_DATA:
- if (!MMDRV_Is32(mld->mmdIndex)) {
- /* initial map is: 32 => 16 */
- LPWAVEHDR wh16 = MapSL(dwParam1);
- LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
-
- dwParam1 = (DWORD)wh32;
- wh32->dwFlags = wh16->dwFlags;
- wh32->dwBytesRecorded = wh16->dwBytesRecorded;
- }
- /* else { 32 => 32, nothing to do, same struct is kept }*/
- break;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
-/**************************************************************************
* MMSYSTDRV_WaveIn_MapCB [internal]
*/
static void MMSYSTDRV_WaveIn_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
@@ -1462,336 +754,6 @@ static MMSYSTEM_MapType MMSYSTDRV_WaveOut_UnMap16To32W(UINT wMsg, DWORD_PTR* lp
}
/**************************************************************************
- * MMDRV_WaveOut_Map32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
-{
- WINMM_MapType ret;
-
- switch (wMsg) {
- /* nothing to do */
- case WODM_BREAKLOOP:
- case WODM_CLOSE:
- case WODM_GETNUMDEVS:
- case WODM_PAUSE:
- case WODM_RESET:
- case WODM_RESTART:
- case WODM_SETPITCH:
- case WODM_SETPLAYBACKRATE:
- case WODM_SETVOLUME:
- ret = WINMM_MAP_OK;
- break;
-
- case WODM_GETDEVCAPS:
- {
- LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)*lpParam1;
- LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPWAVEOUTCAPSW) + sizeof(WAVEOUTCAPS16));
-
- if (ptr) {
- *(LPWAVEOUTCAPSW*)ptr = woc32;
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- *lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSW);
- *lpParam2 = sizeof(WAVEOUTCAPS16);
- }
- break;
- case WODM_GETPITCH:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case WODM_GETPLAYBACKRATE:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case WODM_GETPOS:
- {
- LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
- LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
- LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
-
- if (ptr) {
- *(LPMMTIME*)ptr = mmt32;
- mmt16->wType = mmt32->wType;
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- *lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
- *lpParam2 = sizeof(MMTIME16);
- }
- break;
- case WODM_GETVOLUME:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case WODM_OPEN:
- {
- LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
- int sz = sizeof(WAVEFORMATEX);
- LPVOID ptr;
- LPWAVEOPENDESC16 wod16;
-
- /* allocated data are mapped as follows:
- LPWAVEOPENDESC ptr to orig lParam1
- DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
- DWORD dwUser passed to driver
- WAVEOPENDESC16 wod16: openDesc passed to driver
- WAVEFORMATEX openDesc->lpFormat passed to driver
- xxx extra bytes to WAVEFORMATEX
- */
- if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
- TRACE("Allocating %u extra bytes (%d)\n", wod32->lpFormat->cbSize, wod32->lpFormat->wFormatTag);
- sz += wod32->lpFormat->cbSize;
- }
-
- ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
-
- if (ptr) {
- SEGPTR seg_ptr = MapLS( ptr );
- *(LPWAVEOPENDESC*)ptr = wod32;
- *(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
- wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
-
- wod16->hWave = HWAVE_16(wod32->hWave);
- wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
- memcpy(wod16 + 1, wod32->lpFormat, sz);
-
- wod16->dwCallback = wod32->dwCallback;
- wod16->dwInstance = wod32->dwInstance;
- wod16->uMappedDeviceID = wod32->uMappedDeviceID;
- wod16->dnDevNode = wod32->dnDevNode;
-
- *lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
- *lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case WODM_PREPARE:
- {
- LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
- LPWAVEHDR wh16;
- LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
- sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
-
- if (ptr) {
- SEGPTR seg_ptr = MapLS( ptr );
- *(LPWAVEHDR*)ptr = wh32;
- wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
- wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
- /* data will be copied on WODM_WRITE */
- wh16->dwBufferLength = wh32->dwBufferLength;
- wh16->dwBytesRecorded = wh32->dwBytesRecorded;
- wh16->dwUser = wh32->dwUser;
- wh16->dwFlags = wh32->dwFlags;
- wh16->dwLoops = wh32->dwLoops;
- /* FIXME: nothing on wh32->lpNext */
- /* could link the wh32->lpNext at this level for memory house keeping */
- wh32->lpNext = wh16; /* for reuse in unprepare and write */
- *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
- *lpParam2 = sizeof(WAVEHDR);
- TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
- *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
-
- ret = WINMM_MAP_OKMEM;
- } else {
- ret = WINMM_MAP_NOMEM;
- }
- }
- break;
- case WODM_UNPREPARE:
- case WODM_WRITE:
- {
- LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
- LPWAVEHDR wh16 = wh32->lpNext;
- LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
- SEGPTR seg_ptr = MapLS( ptr );
-
- assert(*(LPWAVEHDR*)ptr == wh32);
-
- if (wMsg == WODM_WRITE)
- memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
-
- *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
- *lpParam2 = sizeof(WAVEHDR);
- TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
- *lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
-
- /* dwBufferLength can be reduced between prepare & write */
- if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
- ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
- wh16->dwBufferLength, wh32->dwBufferLength);
- } else
- wh16->dwBufferLength = wh32->dwBufferLength;
- ret = WINMM_MAP_OKMEM;
- }
- break;
- case DRVM_MAPPER_STATUS:
- {
- LPDWORD p32 = (LPDWORD)*lpParam2;
- *lpParam2 = MapLS(p32);
- ret = WINMM_MAP_OKMEM;
- }
- break;
- default:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_WaveOut_UnMap32WTo16 [internal]
- */
-static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
-{
- WINMM_MapType ret;
-
- switch (wMsg) {
- /* nothing to do */
- case WODM_BREAKLOOP:
- case WODM_CLOSE:
- case WODM_GETNUMDEVS:
- case WODM_PAUSE:
- case WODM_RESET:
- case WODM_RESTART:
- case WODM_SETPITCH:
- case WODM_SETPLAYBACKRATE:
- case WODM_SETVOLUME:
- ret = WINMM_MAP_OK;
- break;
-
- case WODM_GETDEVCAPS:
- {
- LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSW);
- LPWAVEOUTCAPSW woc32 = *(LPWAVEOUTCAPSW*)ptr;
-
- woc32->wMid = woc16->wMid;
- woc32->wPid = woc16->wPid;
- woc32->vDriverVersion = woc16->vDriverVersion;
- WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
- sizeof(woc16->szPname), NULL, NULL );
- woc32->dwFormats = woc16->dwFormats;
- woc32->wChannels = woc16->wChannels;
- woc32->dwSupport = woc16->dwSupport;
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case WODM_GETPITCH:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case WODM_GETPLAYBACKRATE:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case WODM_GETPOS:
- {
- LPMMTIME16 mmt16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
- LPMMTIME mmt32 = *(LPMMTIME*)ptr;
-
- WINMM_MMTIME16to32(mmt32, mmt16);
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case WODM_OPEN:
- {
- LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
- LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
-
- wod32->uMappedDeviceID = wod16->uMappedDeviceID;
- **(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
- UnMapLS( *lpParam1 );
- HeapFree( GetProcessHeap(), 0, ptr );
- ret = WINMM_MAP_OK;
- }
- break;
- case WODM_PREPARE:
- case WODM_UNPREPARE:
- case WODM_WRITE:
- {
- LPWAVEHDR wh16 = MapSL(*lpParam1);
- LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
- LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
-
- assert(wh32->lpNext == wh16);
- wh32->dwBytesRecorded = wh16->dwBytesRecorded;
- wh32->dwUser = wh16->dwUser;
- wh32->dwFlags = wh16->dwFlags;
- wh32->dwLoops = wh16->dwLoops;
-
- UnMapLS( *lpParam1 );
- if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
- HeapFree( GetProcessHeap(), 0, ptr );
- wh32->lpNext = 0;
- }
- ret = WINMM_MAP_OK;
- }
- break;
- case WODM_GETVOLUME:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- case DRVM_MAPPER_STATUS:
- {
- UnMapLS( *lpParam2 );
- ret = WINMM_MAP_OK;
- }
- break;
- default:
- FIXME("NIY: no conversion yet\n");
- ret = WINMM_MAP_MSGERROR;
- break;
- }
- return ret;
-}
-
-/**************************************************************************
- * MMDRV_WaveOut_Callback [internal]
- */
-static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-{
- LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
-
- switch (uMsg) {
- case WOM_OPEN:
- case WOM_CLOSE:
- /* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
- break;
- case WOM_DONE:
- if (!MMDRV_Is32(mld->mmdIndex)) {
- /* initial map is: 32 => 16 */
- LPWAVEHDR wh16 = MapSL(dwParam1);
- LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
-
- dwParam1 = (DWORD)wh32;
- wh32->dwFlags = wh16->dwFlags;
- }
- /* else { 32 => 32, nothing to do, same struct is kept }*/
- break;
- default:
- ERR("Unknown msg %u\n", uMsg);
- }
-
- MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
-}
-
-/**************************************************************************
* MMDRV_WaveOut_Callback [internal]
*/
static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dwParam1, DWORD_PTR* dwParam2)
@@ -1817,136 +779,6 @@ static void MMSYSTDRV_WaveOut_MapCB(UINT uMsg, DWORD_PTR* dwUser, DWORD_PTR* dw
}
}
-/* =================================
- * M A P P E R S H A N D L I N G
- * ================================= */
-
-static LRESULT MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
- LONG lp1, LONG lp2)
-{
- WORD args[8];
- DWORD ret;
-
- args[7] = dev;
- args[6] = msg;
- args[5] = HIWORD(instance);
- args[4] = LOWORD(instance);
- args[3] = HIWORD(lp1);
- args[2] = LOWORD(lp1);
- args[1] = HIWORD(lp2);
- args[0] = LOWORD(lp2);
- WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
- return LOWORD(ret);
-}
-
-/**************************************************************************
- * MMDRV_GetDescription16 [internal]
- */
-static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
-{
- OFSTRUCT ofs;
- HFILE hFile;
- WORD w;
- DWORD dw;
- BOOL ret = FALSE;
-
- if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
- ERR("Can't open file %s (builtin driver ?)\n", fname);
- return FALSE;
- }
-
-#define E(_x) do {TRACE _x;goto theEnd;} while(0)
-
- if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n"));
- if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w));
- if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n"));
- if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n"));
- if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %u\n", dw+0x2C));
- if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n"));
- if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %u\n", dw));
- if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n"));
- buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
- if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen));
- buf[buflen] = '\0';
- ret = TRUE;
- TRACE("Got '%s' [%d]\n", buf, buflen);
-theEnd:
- _lclose(hFile);
- return ret;
-}
-
-/******************************************************************
- * MMDRV_LoadMMDrvFunc16
- *
- */
-static unsigned MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
- LPWINE_MM_DRIVER lpDrv)
-{
- WINEMM_msgFunc16 func;
- unsigned count = 0;
- char buffer[128];
- /*
- * DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
- * The beginning of the module description indicates the driver supports
- * waveform, auxiliary, and mixer devices. Use one of the following
- * device-type names, followed by a colon (:) to indicate the type of
- * device your driver supports. If the driver supports more than one
- * type of device, separate each device-type name with a comma (,).
- *
- * wave for waveform audio devices
- * wavemapper for wave mappers
- * midi for MIDI audio devices
- * midimapper for midi mappers
- * aux for auxiliary audio devices
- * mixer for mixer devices
- */
-
- if (d->d.d16.hDriver16) {
- HMODULE16 hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
-
-#define AA(_h,_w,_x,_y,_z) \
- func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
- if (func != NULL) \
- { lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
- TRACE("Got %d bit func '%s'\n", _y, #_x); }
-
-#define A(_x,_y) AA(hMod16,_x,_y,16,GetProcAddress16)
- A(MMDRV_AUX, auxMessage);
- A(MMDRV_MIXER, mxdMessage);
- A(MMDRV_MIDIIN, midMessage);
- A(MMDRV_MIDIOUT,modMessage);
- A(MMDRV_WAVEIN, widMessage);
- A(MMDRV_WAVEOUT,wodMessage);
-#undef A
-#undef AA
- }
- if (TRACE_ON(winmm)) {
- if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
- TRACE("%s => %s\n", drvName, buffer);
- else
- TRACE("%s => No description\n", drvName);
- }
-
- return count;
-}
-
-void MMDRV_Init16(void)
-{
-#define A(_x,_y) MMDRV_InstallMap(_x, \
-MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
-MMDRV_##_y##_Callback)
- A(MMDRV_AUX, Aux);
- A(MMDRV_MIXER, Mixer);
- A(MMDRV_MIDIIN, MidiIn);
- A(MMDRV_MIDIOUT, MidiOut);
- A(MMDRV_WAVEIN, WaveIn);
- A(MMDRV_WAVEOUT, WaveOut);
-#undef A
-
- pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
- pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
-}
-
/* ###################################################
* # DRIVER THUNKING #
* ###################################################
diff --git a/dlls/winmm/mmsystem.c b/dlls/winmm/mmsystem.c
index ce26192..f258fee 100644
--- a/dlls/winmm/mmsystem.c
+++ b/dlls/winmm/mmsystem.c
@@ -40,7 +40,6 @@
#include "wine/list.h"
#include "wine/winuser16.h"
-#include "winemm.h"
#include "winemm16.h"
#include "wine/debug.h"
@@ -48,9 +47,6 @@
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 CRITICAL_SECTION_DEBUG mmdrv_critsect_debug =
{
@@ -76,32 +72,6 @@ BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
{
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;
- }
- /* hook in our 16 bit function pointers */
- pFnOpenDriver16 = DRIVER_OpenDriver16;
- pFnCloseDriver16 = DRIVER_CloseDriver16;
- pFnSendMessage16 = DRIVER_SendMessage16;
- MMDRV_Init16();
- break;
- case DLL_PROCESS_DETACH:
- pFnOpenDriver16 = NULL;
- pFnCloseDriver16 = NULL;
- pFnSendMessage16 = NULL;
- /* FIXME: add equivalent for MMDRV_Init16() */
- break;
- case DLL_THREAD_ATTACH:
- case DLL_THREAD_DETACH:
- break;
- }
return TRUE;
}
@@ -2069,234 +2039,6 @@ 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;
-
-exit:
- HeapFree(GetProcessHeap(), 0, fnA);
- HeapFree(GetProcessHeap(), 0, snA);
-
- if (cause)
- {
- TRACE("Unable to load 16 bit module %s[%s]: %s\n",
- debugstr_w(fn), debugstr_w(sn), cause);
- HeapFree(GetProcessHeap(), 0, lpDrv);
- return NULL;
- }
-
- TRACE("=> %p\n", lpDrv);
- return lpDrv;
-}
-
-/******************************************************************
- * 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]
*/
diff --git a/dlls/winmm/winemm.h b/dlls/winmm/winemm.h
index 4c86416..7920e2e 100644
--- a/dlls/winmm/winemm.h
+++ b/dlls/winmm/winemm.h
@@ -29,13 +29,6 @@
#define WINE_DEFAULT_WINMM_MAPPER "msacm32.drv"
#define WINE_DEFAULT_WINMM_MIDI "midimap.dll"
-typedef enum {
- WINMM_MAP_NOMEM, /* ko, memory problem */
- WINMM_MAP_MSGERROR, /* ko, unknown message */
- WINMM_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
- WINMM_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
-} WINMM_MapType;
-
/* Who said goofy boy ? */
#define WINE_DI_MAGIC 0x900F1B01
@@ -44,22 +37,14 @@ typedef struct tagWINE_DRIVER
DWORD dwMagic;
/* as usual LPWINE_DRIVER == hDriver32 */
DWORD dwFlags;
- union {
- struct {
- HMODULE hModule;
- DRIVERPROC lpDrvProc;
- DWORD_PTR dwDriverID;
- } d32;
- struct {
- UINT16 hDriver16;
- } d16;
- } d;
+ HMODULE hModule;
+ DRIVERPROC lpDrvProc;
+ DWORD_PTR dwDriverID;
struct tagWINE_DRIVER* lpPrevItem;
struct tagWINE_DRIVER* lpNextItem;
} WINE_DRIVER, *LPWINE_DRIVER;
-typedef DWORD (CALLBACK *WINEMM_msgFunc16)(UINT16, WORD, DWORD, DWORD, DWORD);
-typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD_PTR, DWORD_PTR, DWORD_PTR);
+typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT, UINT, DWORD_PTR, DWORD_PTR, DWORD_PTR);
/* for each loaded driver and each known type of driver, this structure contains
* the information needed to access it
@@ -67,10 +52,7 @@ typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD_PTR, DWORD_PTR, D
typedef struct tagWINE_MM_DRIVER_PART {
int nIDMin; /* lower bound of global indexes for this type */
int nIDMax; /* hhigher bound of global indexes for this type */
- union {
- WINEMM_msgFunc32 fnMessage32; /* pointer to function */
- WINEMM_msgFunc16 fnMessage16;
- } u;
+ WINEMM_msgFunc32 fnMessage32; /* pointer to function */
} WINE_MM_DRIVER_PART;
#define MMDRV_AUX 0
@@ -85,8 +67,7 @@ typedef struct tagWINE_MM_DRIVER_PART {
typedef struct tagWINE_MM_DRIVER {
HDRVR hDriver;
LPSTR drvname; /* name of the driver */
- unsigned bIs32 : 1, /* TRUE if 32 bit driver, FALSE for 16 */
- bIsMapper : 1; /* TRUE if mapper */
+ unsigned bIsMapper : 1; /* TRUE if mapper */
WINE_MM_DRIVER_PART parts[MMDRV_MAX];/* Information for all known types */
} WINE_MM_DRIVER, *LPWINE_MM_DRIVER;
@@ -151,9 +132,6 @@ typedef struct tagWINE_MMIO {
/* function prototypes */
-typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2);
-typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, DWORD_PTR *lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret);
-
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr);
BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz);
LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2);
@@ -171,15 +149,12 @@ LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID);
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped);
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
-BOOL MMDRV_Is32(unsigned int);
-void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, LPDRVCALLBACK);
const char* MCI_MessageToString(UINT wMsg);
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
LPWSTR MCI_strdupAtoW(LPCSTR str);
LPSTR MCI_strdupWtoA(LPCWSTR str);
-BOOL WINMM_CheckForMMSystem(void);
const char* WINMM_ErrorToString(MMRESULT error);
void TIME_MMTimeStop(void);
@@ -190,19 +165,9 @@ extern HINSTANCE hWinMM32Instance;
extern HANDLE psLastEvent;
extern HANDLE psStopEvent;
-/* pointers to 16 bit functions (if sibling MMSYSTEM.DLL is loaded
- * NULL otherwise
- */
-extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM);
-extern LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM);
-extern LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM);
-extern LRESULT (*pFnCallMMDrvFunc16)(DWORD /* in fact FARPROC16 */,WORD,WORD,LONG,LONG,LONG);
-extern unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER);
-
/* GetDriverFlags() returned bits is not documented (nor the call itself)
* Here are Wine only definitions of the bits
*/
#define WINE_GDF_EXIST 0x80000000
-#define WINE_GDF_16BIT 0x10000000
#define WINE_GDF_EXTERNAL_MASK 0xF0000000
#define WINE_GDF_SESSION 0x00000001
More information about the wine-patches
mailing list