From acd8b068245bb59a6ea7b8a0bf21b014d04dd27a Mon Sep 17 00:00:00 2001 From: Johannes Anderwald Date: Sun, 25 Oct 2009 17:54:50 +0000 Subject: [PATCH] - Partially sync winmm - Remove unused code - Fix function headers svn path=/trunk/; revision=43747 --- reactos/dll/win32/winmm/driver.c | 256 +- reactos/dll/win32/winmm/joystick.c | 31 +- reactos/dll/win32/winmm/lolvldrv.c | 361 +-- reactos/dll/win32/winmm/mci.c | 571 ++-- reactos/dll/win32/winmm/message16.c | 3540 ------------------------- reactos/dll/win32/winmm/mmio.c | 289 +- reactos/dll/win32/winmm/mmsystem.c | 3216 ---------------------- reactos/dll/win32/winmm/mmsystem.spec | 176 -- reactos/dll/win32/winmm/playsound.c | 159 +- reactos/dll/win32/winmm/sound.spec | 18 - reactos/dll/win32/winmm/sound16.c | 184 -- reactos/dll/win32/winmm/time.c | 353 ++- reactos/dll/win32/winmm/winemm.h | 206 +- reactos/dll/win32/winmm/winmm.c | 608 +++-- reactos/dll/win32/winmm/winmm.rbuild | 1 + reactos/dll/win32/winmm/winmm.spec | 6 +- reactos/include/psdk/mmddk.h | 10 +- reactos/include/psdk/mmsystem.h | 2 +- 18 files changed, 1249 insertions(+), 8738 deletions(-) delete mode 100644 reactos/dll/win32/winmm/message16.c delete mode 100644 reactos/dll/win32/winmm/mmsystem.c delete mode 100644 reactos/dll/win32/winmm/mmsystem.spec delete mode 100644 reactos/dll/win32/winmm/sound.spec delete mode 100644 reactos/dll/win32/winmm/sound16.c diff --git a/reactos/dll/win32/winmm/driver.c b/reactos/dll/win32/winmm/driver.c index d38efca8d30..adad9ff4805 100644 --- a/reactos/dll/win32/winmm/driver.c +++ b/reactos/dll/win32/winmm/driver.c @@ -5,8 +5,6 @@ * Copyright 1998 Marcus Meissner * Copyright 1999 Eric Pouech * - * Reformatting and additional comments added by Andrew Greenwood. - * * 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 @@ -19,9 +17,12 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include "config.h" +#include "wine/port.h" + #include #include #include "windef.h" @@ -34,17 +35,41 @@ #include "winemm.h" #include "wine/debug.h" #include "wine/unicode.h" +#include "excpt.h" +#include "wine/exception.h" WINE_DEFAULT_DEBUG_CHANNEL(driver); +static CRITICAL_SECTION mmdriver_lock; +static CRITICAL_SECTION_DEBUG mmdriver_lock_debug = +{ + 0, 0, &mmdriver_lock, + { &mmdriver_lock_debug.ProcessLocksList, &mmdriver_lock_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": mmdriver_lock") } +}; +static CRITICAL_SECTION mmdriver_lock = { &mmdriver_lock_debug, -1, 0, 0, 0, 0 }; + 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}; -WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16 h) /* = NULL */; -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 + LPWINE_DRIVER lpDrv; + + TRACE("%s\n", comment); + + EnterCriticalSection( &mmdriver_lock ); + + for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpDrv->lpNextItem) + { + TRACE("%p, magic %04lx, id %p, next %p\n", lpDrv, lpDrv->dwMagic, lpDrv->d.d32.dwDriverID, lpDrv->lpNextItem); + } + + LeaveCriticalSection( &mmdriver_lock ); +#endif +} /************************************************************************** * DRIVER_GetNumberOfModuleRefs [internal] @@ -56,15 +81,19 @@ static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** foun LPWINE_DRIVER lpDrv; unsigned count = 0; + EnterCriticalSection( &mmdriver_lock ); + 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++; } } + + LeaveCriticalSection( &mmdriver_lock ); return count; } @@ -75,34 +104,39 @@ static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** foun */ LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr) { - LPWINE_DRIVER d = (LPWINE_DRIVER)hDrvr; + LPWINE_DRIVER d; - if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) { - return d; + __TRY + { + d = (LPWINE_DRIVER)hDrvr; + if (d && d->dwMagic != WINE_DI_MAGIC) d = NULL; } - return NULL; + __EXCEPT_PAGE_FAULT + { + return NULL; + } + __ENDTRY; + + if (d) TRACE("%p -> %p, %p\n", hDrvr, d->lpDrvProc, (void *)d->dwDriverID); + else TRACE("%p -> NULL\n", hDrvr); + + return d; } /************************************************************************** * DRIVER_SendMessage [internal] */ -static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg, +static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg, LPARAM lParam1, LPARAM lParam2) { 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, (HDRVR)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, (HDRVR)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; } @@ -136,14 +170,14 @@ 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 ); + if (lpDrv->lpPrevItem) lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem; else @@ -152,6 +186,10 @@ static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv) lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem; /* trash magic number */ lpDrv->dwMagic ^= 0xa5a5a5a5; + lpDrv->lpDrvProc = NULL; + lpDrv->dwDriverID = 0; + + LeaveCriticalSection( &mmdriver_lock ); return TRUE; } @@ -166,18 +204,27 @@ 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 0x%08lx\n", (DWORD)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->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2); + + if (lpNewDrv->dwDriverID == 0) + { + TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv); + return FALSE; + } + + EnterCriticalSection( &mmdriver_lock ); + lpNewDrv->lpNextItem = NULL; if (lpDrvItemList == NULL) { lpDrvItemList = lpNewDrv; @@ -191,16 +238,7 @@ static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lPar lpNewDrv->lpPrevItem = lpDrv; } - if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) { - /* Now just open a new instance of a driver on this module */ - lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2); - - if (lpNewDrv->d.d32.dwDriverID == 0) { - TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv); - DRIVER_RemoveFromList(lpNewDrv); - return FALSE; - } - } + LeaveCriticalSection( &mmdriver_lock ); return TRUE; } @@ -282,23 +320,23 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2) goto exit; } - lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc"); + lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc"); - if (lpDrv->d.d32.lpDrvProc == NULL) + if (lpDrv->lpDrvProc == NULL) { cause = "no DriverProc"; goto exit; } lpDrv->dwFlags = 0; - lpDrv->d.d32.hModule = hModule; - lpDrv->d.d32.dwDriverID = 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; @@ -381,7 +419,7 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar WCHAR libName[128]; LPCWSTR lsn = lpSectionName; - TRACE("(%s, %s, 0x%08lx);\n", + TRACE("(%s, %s, 0x%08lx);\n", debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam); /* If no section name is specified, either the caller is intending on @@ -416,14 +454,16 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar * so ensure, we can load our mmsystem, otherwise just fail */ WINMM_CheckForMMSystem(); +#if 0 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", + TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_w(lpDriverName), debugstr_w(lpSectionName)); +#endif return 0; the_end: @@ -437,44 +477,46 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar */ LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2) { + BOOL ret; LPWINE_DRIVER lpDrv; TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2); + DRIVER_Dump("BEFORE:"); + 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); - lpDrv->d.d32.dwDriverID = 0; - } - if (DRIVER_RemoveFromList(lpDrv)) { - if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) - { - LPWINE_DRIVER lpDrv0; + LPWINE_DRIVER lpDrv0; - /* if driver has an opened session instance, we have to close it too */ - if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1) - { - DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L); - lpDrv0->d.d32.dwDriverID = 0; - DRIVER_RemoveFromList(lpDrv0); - FreeLibrary(lpDrv0->d.d32.hModule); - HeapFree(GetProcessHeap(), 0, lpDrv0); - } - FreeLibrary(lpDrv->d.d32.hModule); - } - HeapFree(GetProcessHeap(), 0, lpDrv); - return TRUE; + DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2); + + DRIVER_RemoveFromList(lpDrv); + + 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)) + { + 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; } - WARN("Failed to close driver\n"); - return FALSE; + else + { + WARN("Failed to close driver\n"); + ret = FALSE; + } + + DRIVER_Dump("AFTER:"); + + return ret; } /************************************************************************** @@ -498,7 +540,7 @@ DWORD WINAPI GetDriverFlags(HDRVR hDrvr) TRACE("(%p)\n", hDrvr); if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) { - ret = WINE_GDF_EXIST | lpDrv->dwFlags; + ret = WINE_GDF_EXIST | (lpDrv->dwFlags & WINE_GDF_EXTERNAL_MASK); } return ret; } @@ -515,8 +557,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; @@ -546,11 +587,11 @@ LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, /************************************************************************** * DriverCallback [WINMM.@] */ -BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, - UINT wMsg, DWORD dwUser, DWORD dwParam1, - DWORD dwParam2) +BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev, + DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, + DWORD_PTR dwParam2) { - TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n", + TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX)\n", dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2); switch (uFlags & DCB_TYPEMASK) { @@ -575,22 +616,27 @@ BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, TRACE("Event(%08lx) !\n", dwCallBack); SetEvent((HANDLE)dwCallBack); break; +#if 0 + /* FIXME: for now only usable in mmsystem.dll16 + * If needed, should be enabled back + */ case 6: /* I would dub it DCB_MMTHREADSIGNAL */ /* this is an undocumented DCB_ value used for mmThreads * loword of dwCallBack contains the handle of the lpMMThd block * which dwSignalCount has to be incremented - */ + */ if (pFnGetMMThread16) { WINE_MMTHREAD* lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack)); TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd); /* same as mmThreadSignal16 */ - InterlockedIncrement((PLONG)&lpMMThd->dwSignalCount); + InterlockedIncrement(&lpMMThd->dwSignalCount); SetEvent(lpMMThd->hEvent); /* some other stuff on lpMMThd->hVxD */ } break; +#endif #if 0 case 4: /* this is an undocumented DCB_ value for... I don't know */ @@ -615,11 +661,25 @@ void DRIVER_UnloadAll(void) LPWINE_DRIVER lpNextDrv = NULL; unsigned count = 0; +restart: + EnterCriticalSection( &mmdriver_lock ); + for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv) { lpNextDrv = lpDrv->lpNextItem; - CloseDriver((HDRVR)lpDrv, 0, 0); - count++; + + /* session instances will be unloaded automatically */ + if (!(lpDrv->dwFlags & WINE_GDF_SESSION)) + { + LeaveCriticalSection( &mmdriver_lock ); + CloseDriver((HDRVR)lpDrv, 0, 0); + count++; + /* restart from the beginning of the list */ + goto restart; + } } + + LeaveCriticalSection( &mmdriver_lock ); + TRACE("Unloaded %u drivers\n", count); } diff --git a/reactos/dll/win32/winmm/joystick.c b/reactos/dll/win32/winmm/joystick.c index 490fd501127..ac4fc4ee45a 100644 --- a/reactos/dll/win32/winmm/joystick.c +++ b/reactos/dll/win32/winmm/joystick.c @@ -18,7 +18,7 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -35,13 +35,13 @@ #include #endif +#include "winemm.h" #include "windef.h" #include "winbase.h" #include "mmsystem.h" #include "wingdi.h" #include "winuser.h" #include "winnls.h" -#include "winemm.h" #include "mmddk.h" @@ -49,7 +49,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); -#define MAXJOYSTICK (JOYSTICKID2 + 1) +#define MAXJOYSTICK (JOYSTICKID2 + 30) #define JOY_PERIOD_MIN (10) /* min Capture time period */ #define JOY_PERIOD_MAX (1000) /* max Capture time period */ @@ -74,14 +74,14 @@ static BOOL JOY_LoadDriver(DWORD dwJoyID) if (JOY_Sticks[dwJoyID].hDriver) return TRUE; - JOY_Sticks[dwJoyID].hDriver = OpenDriverA("joystick.drv", 0, dwJoyID); + JOY_Sticks[dwJoyID].hDriver = OpenDriverA("winejoystick.drv", 0, dwJoyID); return (JOY_Sticks[dwJoyID].hDriver != 0); } /************************************************************************** * JOY_Timer [internal] */ -static void CALLBACK JOY_Timer(HWND hWnd, UINT wMsg, UINT wTimer, DWORD dwTime) +static void CALLBACK JOY_Timer(HWND hWnd, UINT wMsg, UINT_PTR wTimer, DWORD dwTime) { int i; WINE_JOYSTICK* joy; @@ -121,6 +121,19 @@ static void CALLBACK JOY_Timer(HWND hWnd, UINT wMsg, UINT wTimer, DWORD dwTime) } } +/************************************************************************** + * joyConfigChanged [WINMM.@] + */ +MMRESULT WINAPI joyConfigChanged(DWORD flags) +{ + FIXME("(%x) - stub\n", flags); + + if (flags) + return JOYERR_PARMS; + + return JOYERR_NOERROR; +} + /************************************************************************** * joyGetNumDevs [WINMM.@] */ @@ -131,7 +144,7 @@ UINT WINAPI joyGetNumDevs(void) for (i = 0; i < MAXJOYSTICK; i++) { if (JOY_LoadDriver(i)) { - ret += SendDriverMessage(JOY_Sticks[i].hDriver, JDD_GETNUMDEVS, 0L, 0L); + ret += SendDriverMessage(JOY_Sticks[i].hDriver, JDD_GETNUMDEVS, 0, 0); } } return ret; @@ -148,7 +161,7 @@ MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT wSize) lpCaps->wPeriodMin = JOY_PERIOD_MIN; /* FIXME */ lpCaps->wPeriodMax = JOY_PERIOD_MAX; /* FIXME (same as MS Joystick Driver) */ - return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETDEVCAPS, (DWORD)lpCaps, wSize); + return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETDEVCAPS, (LPARAM)lpCaps, wSize); } /************************************************************************** @@ -222,7 +235,7 @@ MMRESULT WINAPI joyGetPosEx(UINT wID, LPJOYINFOEX lpInfo) lpInfo->dwReserved1 = 0; lpInfo->dwReserved2 = 0; - return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOSEX, (DWORD)lpInfo, 0L); + return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOSEX, (LPARAM)lpInfo, 0); } /************************************************************************** @@ -240,7 +253,7 @@ MMRESULT WINAPI joyGetPos(UINT wID, LPJOYINFO lpInfo) lpInfo->wZpos = 0; lpInfo->wButtons = 0; - return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOS, (DWORD)lpInfo, 0L); + return SendDriverMessage(JOY_Sticks[wID].hDriver, JDD_GETPOS, (LPARAM)lpInfo, 0); } /************************************************************************** diff --git a/reactos/dll/win32/winmm/lolvldrv.c b/reactos/dll/win32/winmm/lolvldrv.c index 0e7f7a67e03..e6c7a25435e 100644 --- a/reactos/dll/win32/winmm/lolvldrv.c +++ b/reactos/dll/win32/winmm/lolvldrv.c @@ -1,7 +1,7 @@ /* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* - * MMSYTEM low level drivers handling functions + * MMSYSTEM low level drivers handling functions * * Copyright 1999 Eric Pouech * Modified for use with ReactOS by Andrew Greenwood, 2007 @@ -18,9 +18,12 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include "config.h" +#include "wine/port.h" + #include #include #include @@ -28,27 +31,19 @@ #include "windef.h" #include "winbase.h" #include "winreg.h" -#include "winver.h" #include "winemm.h" #include "wine/debug.h" +#include "wine/exception.h" 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 Map16To32A; /* those are function pointers to handle */ - MMDRV_UNMAPFUNC UnMap16To32A; /* the parameter conversion (16 vs 32 bit) */ - MMDRV_MAPFUNC Map32ATo16; /* when hi-func (in mmsystem or winmm) and */ - MMDRV_UNMAPFUNC UnMap32ATo16; /* 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 */ + UINT wMaxId; /* number of loaded devices (sum across all loaded drivers) */ LPWINE_MLD lpMlds; /* "static" mlds to access the part though device IDs */ int nMapper; /* index to mapper */ } WINE_LLTYPE; @@ -58,7 +53,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, 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,96 +67,6 @@ static WINE_LLTYPE llTypes[MMDRV_MAX] = { }; #undef A -/****************************************************************** - * MMDRV_InstallMap - * - * - */ -void MMDRV_InstallMap(unsigned int drv, - MMDRV_MAPFUNC mp1632, MMDRV_UNMAPFUNC um1632, - MMDRV_MAPFUNC mp3216, MMDRV_UNMAPFUNC um3216, - LPDRVCALLBACK cb) -{ - assert(drv < MMDRV_MAX); - llTypes[drv].Map16To32A = mp1632; - llTypes[drv].UnMap16To32A = um1632; - llTypes[drv].Map32ATo16 = mp3216; - llTypes[drv].UnMap32ATo16 = um3216; - llTypes[drv].Callback = cb; -} - -/****************************************************************** - * MMDRV_Is32 - * - */ -BOOL MMDRV_Is32(unsigned int idx) -{ - TRACE("(%d)\n", idx); - return MMDrvs[idx].bIs32; -} - -/************************************************************************** - * MMDRV_GetDescription32 [internal] - */ -static BOOL MMDRV_GetDescription32(const char* fname, char* buf, int buflen) -{ - OFSTRUCT ofs; - DWORD h; - LPVOID ptr = 0; - LPVOID val; - DWORD dw; - BOOL ret = FALSE; - UINT u; - FARPROC pGetFileVersionInfoSizeA; - FARPROC pGetFileVersionInfoA; - FARPROC pVerQueryValueA; - HMODULE hmodule = 0; - TRACE("(%p, %p, %d)\n", fname, buf, buflen); - -#define E(_x) do {TRACE _x;goto theEnd;} while(0) - - if (OpenFile(fname, &ofs, OF_EXIST)==HFILE_ERROR) E(("Can't find file %s\n", fname)); - - if (!(hmodule = LoadLibraryA( "version.dll" ))) goto theEnd; - if (!(pGetFileVersionInfoSizeA = GetProcAddress( hmodule, "GetFileVersionInfoSizeA" ))) - goto theEnd; - if (!(pGetFileVersionInfoA = GetProcAddress( hmodule, "GetFileVersionInfoA" ))) - goto theEnd; - if (!(pVerQueryValueA = GetProcAddress( hmodule, "VerQueryValueA" ))) - goto theEnd; - - if (!(dw = pGetFileVersionInfoSizeA(ofs.szPathName, &h))) E(("Can't get FVIS\n")); - if (!(ptr = HeapAlloc(GetProcessHeap(), 0, dw))) E(("OOM\n")); - if (!pGetFileVersionInfoA(ofs.szPathName, h, dw, ptr)) E(("Can't get FVI\n")); - -#define A(_x) if (pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\" #_x, &val, &u)) \ - TRACE(#_x " => %s\n", (LPSTR)val); else TRACE(#_x " @\n") - - A(CompanyName); - A(FileDescription); - A(FileVersion); - A(InternalName); - A(LegalCopyright); - A(OriginalFilename); - A(ProductName); - A(ProductVersion); - A(Comments); - A(LegalTrademarks); - A(PrivateBuild); - A(SpecialBuild); -#undef A - - if (!pVerQueryValueA(ptr, "\\StringFileInfo\\040904B0\\ProductName", &val, &u)) E(("Can't get product name\n")); - lstrcpynA(buf, val, buflen); - -#undef E - ret = TRUE; -theEnd: - HeapFree(GetProcessHeap(), 0, ptr); - if (hmodule) FreeLibrary( hmodule ); - return ret; -} - /************************************************************************** * MMDRV_GetNum [internal] */ @@ -176,18 +81,17 @@ UINT MMDRV_GetNum(UINT type) * MMDRV_Message [internal] */ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, - DWORD_PTR dwParam2, BOOL bFrom32) + DWORD_PTR dwParam2) { LPWINE_MM_DRIVER lpDrv; 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 %c)\n", + TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx)\n", llTypes[mld->type].typestr, mld->uDeviceID, wMsg, - mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N'); + mld->dwDriverInstance, dwParam1, dwParam2); if (mld->uDeviceID == (UINT16)-1) { if (!llType->bSupportMapper) { @@ -215,78 +119,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); - if (bFrom32) { - 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 { - map = llType->Map16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2); - switch (map) { - case WINMM_MAP_NOMEM: - ret = MMSYSERR_NOMEM; - break; - case WINMM_MAP_MSGERROR: - FIXME("NIY: no conversion yet 16->32 (%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 = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, - dwParam1, dwParam2); - TRACE("=> %s\n", WINMM_ErrorToString(ret)); - if (map == WINMM_MAP_OKMEM) - llType->UnMap16To32A(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret); - break; - default: - FIXME("NIY\n"); - ret = MMSYSERR_NOTSUPPORTED; - break; - } - } - } else { - assert(part->u.fnMessage16 && pFnCallMMDrvFunc16); + 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)); - if (bFrom32) { - map = llType->Map32ATo16(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->UnMap32ATo16(wMsg, &mld->dwDriverInstance, &dwParam1, &dwParam2, ret); - break; - default: - FIXME("NIY\n"); - ret = MMSYSERR_NOTSUPPORTED; - break; - } - } else { - 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)); - } - } return ret; } @@ -294,12 +133,12 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, * MMDRV_Alloc [internal] */ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, - DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32) + DWORD_PTR* dwCallback, DWORD_PTR* dwInstance) { LPWINE_MLD mld; - UINT i; - TRACE("(%d, %04x, %p, %p, %p, %p, %c)\n", - size, type, hndl, dwFlags, dwCallback, dwInstance, bFrom32?'Y':'N'); + UINT_PTR i; + TRACE("(%d, %04x, %p, %p, %p, %p)\n", + size, type, hndl, dwFlags, dwCallback, dwInstance); mld = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size); if (!mld) return NULL; @@ -317,7 +156,7 @@ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, *hndl = (HANDLE)(i | 0x8000); mld->type = type; - if ((UINT)*hndl < MMDRV_GetNum(type) || HIWORD(*hndl) != 0) { + if ((UINT_PTR)*hndl < MMDRV_GetNum(type) || ((UINT_PTR)*hndl >> 16)) { /* FIXME: those conditions must be fulfilled so that: * - we can distinguish between device IDs and handles * - we can use handles as 16 or 32 bit entities @@ -325,18 +164,10 @@ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, ERR("Shouldn't happen. Bad allocation scheme\n"); } - mld->bFrom32 = bFrom32; mld->dwFlags = HIWORD(*dwFlags); mld->dwCallback = *dwCallback; mld->dwClientInstance = *dwInstance; - if (llTypes[type].Callback) - { - *dwFlags = LOWORD(*dwFlags) | CALLBACK_FUNCTION; - *dwCallback = (DWORD)llTypes[type].Callback; - *dwInstance = (DWORD)mld; /* FIXME: wouldn't some 16 bit drivers only use the loword ? */ - } - return mld; } @@ -347,8 +178,8 @@ void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld) { TRACE("(%p, %p)\n", hndl, mld); - if ((UINT)hndl & 0x8000) { - unsigned idx = (UINT)hndl & ~0x8000; + if ((UINT_PTR)hndl & 0x8000) { + UINT_PTR idx = (UINT_PTR)hndl & ~0x8000; if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { MM_MLDrvs[idx] = NULL; HeapFree(GetProcessHeap(), 0, mld); @@ -361,14 +192,14 @@ void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld) /************************************************************************** * MMDRV_Open [internal] */ -DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags) +DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwFlags) { DWORD dwRet = MMSYSERR_BADDEVICEID; - DWORD dwInstance; + DWORD_PTR dwInstance; WINE_LLTYPE* llType = &llTypes[mld->type]; - TRACE("(%p, %04x, 0x%08lx, 0x%08lx)\n", mld, wMsg, dwParam1, dwFlags); + TRACE("(%p, %04x, 0x%08lx, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags); - mld->dwDriverInstance = (DWORD)&dwInstance; + mld->dwDriverInstance = (DWORD_PTR)&dwInstance; if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) { TRACE("MAPPER mode requested !\n"); @@ -388,14 +219,14 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags) mld->uDeviceID = (UINT16)-1; mld->mmdIndex = llType->lpMlds[-1].mmdIndex; TRACE("Setting mmdIndex to %u\n", mld->mmdIndex); - dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE); + dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags); } } } else { if (mld->uDeviceID < llType->wMaxId) { mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex; TRACE("Setting mmdIndex to %u\n", mld->mmdIndex); - dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags, TRUE); + dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags); } } if (dwRet == MMSYSERR_NOERROR) @@ -409,7 +240,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags) DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg) { TRACE("(%p, %04x)\n", mld, wMsg); - return MMDRV_Message(mld, wMsg, 0L, 0L, TRUE); + return MMDRV_Message(mld, wMsg, 0L, 0L); } /************************************************************************** @@ -431,7 +262,7 @@ static LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type) LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID) { LPWINE_MLD mld = NULL; - UINT hndl = (UINT)_hndl; + UINT_PTR hndl = (UINT_PTR)_hndl; TRACE("(%p, %04x, %c)\n", _hndl, type, bCanBeID ? 'Y' : 'N'); assert(type < MMDRV_MAX); @@ -439,13 +270,19 @@ LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID) if (hndl >= llTypes[type].wMaxId && hndl != (UINT16)-1 && hndl != (UINT)-1) { if (hndl & 0x8000) { - hndl = hndl & ~0x8000; - if (hndl < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { - mld = MM_MLDrvs[hndl]; - if (!mld || !HeapValidate(GetProcessHeap(), 0, mld) || mld->type != type) - mld = NULL; + UINT idx = hndl & ~0x8000; + if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) { + __TRY + { + mld = MM_MLDrvs[idx]; + if (mld && mld->type != type) mld = NULL; + } + __EXCEPT_PAGE_FAULT + { + mld = NULL; + } + __ENDTRY; } - hndl = hndl | 0x8000; } } if (mld == NULL && bCanBeID) { @@ -475,8 +312,8 @@ LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, /************************************************************************** * MMDRV_PhysicalFeatures [internal] */ -UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, - DWORD dwParam2) +UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, + DWORD_PTR dwParam1, DWORD_PTR dwParam2) { WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex]; @@ -511,11 +348,11 @@ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, case DRV_QUERYDEVICEINTERFACE: case DRV_QUERYDEVICEINTERFACESIZE: - return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE); + return MMDRV_Message(mld, uMsg, dwParam1, dwParam2); case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */ case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/ - return MMDRV_Message(mld, uMsg, dwParam1, dwParam2, TRUE); + return MMDRV_Message(mld, uMsg, dwParam1, dwParam2); default: WARN("Unknown call %04x\n", uMsg); @@ -539,32 +376,19 @@ 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 (part->fnMessage32) { + ret = part->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); + ret = part->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 0 - ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, - 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); - + if (HIWORD(count)) return FALSE; @@ -621,11 +445,12 @@ static BOOL MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg) /************************************************************************** * MMDRV_Install [internal] */ -BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper) +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'); @@ -646,26 +471,23 @@ BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper) return FALSE; } + d = DRIVER_FindFromHDrvr(lpDrv->hDriver); + if (!(d = DRIVER_FindFromHDrvr(lpDrv->hDriver))) { CloseDriver(lpDrv->hDriver, 0, 0); WARN("Couldn't get the WINE internal structure for driver '%s'\n", drvFileName); return FALSE; } - 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; - char buffer[128]; - - 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); @@ -673,15 +495,6 @@ BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper) A(MMDRV_WAVEIN, widMessage); A(MMDRV_WAVEOUT, wodMessage); #undef A - } - if (TRACE_ON(winmm)) { - if (MMDRV_GetDescription32(drvFileName, buffer, sizeof(buffer))) - TRACE("%s => %s\n", drvFileName, buffer); - else - TRACE("%s => No description\n", drvFileName); - } - } else if (WINMM_CheckForMMSystem() && pFnLoadMMDrvFunc16) { - count += pFnLoadMMDrvFunc16(drvFileName, d, lpDrv); } #undef AA @@ -730,6 +543,7 @@ BOOL MMDRV_Init(void) char driver_buffer[256]; char mapper_buffer[256]; char midi_buffer[256]; + char* p; DWORD type, size; BOOL ret = FALSE; TRACE("()\n"); @@ -746,6 +560,17 @@ BOOL MMDRV_Init(void) strcpy(driver_buffer, WINE_DEFAULT_WINMM_DRIVER); } + p = driver_buffer; + while (p) + { + char filename[sizeof(driver_buffer)+10]; + char *next = strchr(p, ','); + if (next) *next++ = 0; + sprintf( filename, "wine%s.drv", p ); + if ((ret = MMDRV_Install( filename, filename, FALSE ))) break; + p = next; + } + ret |= MMDRV_Install("beepmidi.dll", "beepmidi.dll", FALSE); ret |= MMDRV_Install("wavemapper", WINE_DEFAULT_WINMM_MAPPER, TRUE); @@ -774,24 +599,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; @@ -804,7 +618,7 @@ static BOOL MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type) */ void MMDRV_Exit(void) { - int i; + unsigned int i; TRACE("()\n"); for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++) @@ -820,7 +634,8 @@ void MMDRV_Exit(void) } /* unload driver, in reverse order of loading */ - for (i = sizeof(MMDrvs) / sizeof(MMDrvs[0]) - 1; i >= 0; i--) + i = sizeof(MMDrvs) / sizeof(MMDrvs[0]); + while (i-- > 0) { MMDRV_ExitPerType(&MMDrvs[i], MMDRV_AUX); MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIXER); @@ -830,4 +645,16 @@ void MMDRV_Exit(void) MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEOUT); CloseDriver(MMDrvs[i].hDriver, 0, 0); } + if (llTypes[MMDRV_AUX].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_AUX].lpMlds - 1); + if (llTypes[MMDRV_MIXER].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIXER].lpMlds - 1); + if (llTypes[MMDRV_MIDIIN].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIIN].lpMlds - 1); + if (llTypes[MMDRV_MIDIOUT].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIOUT].lpMlds - 1); + if (llTypes[MMDRV_WAVEIN].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEIN].lpMlds - 1); + if (llTypes[MMDRV_WAVEOUT].lpMlds) + HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEOUT].lpMlds - 1); } diff --git a/reactos/dll/win32/winmm/mci.c b/reactos/dll/win32/winmm/mci.c index d853528f499..53a834c053f 100644 --- a/reactos/dll/win32/winmm/mci.c +++ b/reactos/dll/win32/winmm/mci.c @@ -15,19 +15,19 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* TODO: * - implement WINMM (32bit) multitasking and use it in all MCI drivers - * instead of the home grown one + * instead of the home grown one * - 16bit mmTaskXXX functions are currently broken because the 16 * loader does not support binary command lines => provide Wine's * own mmtask.tsk not using binary command line. * - correctly handle the MCI_ALL_DEVICE_ID in functions. * - finish mapping 16 <=> 32 of MCI structures and commands * - implement auto-open feature (ie, when a string command is issued - * for a not yet opened device, MCI automatically opens it) + * for a not yet opened device, MCI automatically opens it) * - use a default registry setting to replace the [mci] section in * configuration file (layout of info in registry should be compatible * with all Windows' version - which use different layouts of course) @@ -53,7 +53,6 @@ #include "windef.h" #include "winbase.h" #include "wingdi.h" -#include "winreg.h" #include "mmsystem.h" #include "winuser.h" #include "winnls.h" @@ -68,11 +67,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(mci); -WINMM_MapType (*pFnMciMapMsg16To32W) (WORD,WORD,DWORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD,DWORD) /* = NULL */; -WINMM_MapType (*pFnMciMapMsg32WTo16) (WORD,WORD,DWORD,DWORD*) /* = NULL */; -WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD) /* = NULL */; - /* First MCI valid device ID (0 means error) */ #define MCI_MAGIC 0x0001 @@ -84,8 +78,13 @@ static const WCHAR wszMci [] = {'M','C','I',0}; static const WCHAR wszOpen [] = {'o','p','e','n',0}; static const WCHAR wszSystemIni[] = {'s','y','s','t','e','m','.','i','n','i',0}; +static WINE_MCIDRIVER *MciDrivers; + +static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); +static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType); + /* dup a string and uppercase it */ -inline static LPWSTR str_dup_upper( LPCWSTR str ) +static inline LPWSTR str_dup_upper( LPCWSTR str ) { INT len = (strlenW(str) + 1) * sizeof(WCHAR); LPWSTR p = HeapAlloc( GetProcessHeap(), 0, len ); @@ -100,23 +99,23 @@ inline static LPWSTR str_dup_upper( LPCWSTR str ) /************************************************************************** * MCI_GetDriver [internal] */ -LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) +static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) { LPWINE_MCIDRIVER wmd = 0; - EnterCriticalSection(&WINMM_IData.cs); - for (wmd = WINMM_IData.lpMciDrvs; wmd; wmd = wmd->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) { if (wmd->wDeviceID == wDevID) break; } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); return wmd; } /************************************************************************** * MCI_GetDriverFromString [internal] */ -UINT MCI_GetDriverFromString(LPCWSTR lpstrName) +static UINT MCI_GetDriverFromString(LPCWSTR lpstrName) { LPWINE_MCIDRIVER wmd; UINT ret = 0; @@ -127,8 +126,8 @@ UINT MCI_GetDriverFromString(LPCWSTR lpstrName) if (!strcmpiW(lpstrName, wszAll)) return MCI_ALL_DEVICE_ID; - EnterCriticalSection(&WINMM_IData.cs); - for (wmd = WINMM_IData.lpMciDrvs; wmd; wmd = wmd->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) { if (wmd->lpstrElementName && strcmpW(wmd->lpstrElementName, lpstrName) == 0) { ret = wmd->wDeviceID; break; @@ -142,7 +141,7 @@ UINT MCI_GetDriverFromString(LPCWSTR lpstrName) break; } } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); return ret; } @@ -304,21 +303,21 @@ static int MCI_MapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR *dwParam2) if (dwParam1 & MCI_OPEN_TYPE) { if (dwParam1 & MCI_OPEN_TYPE_ID) - mci_openW->lpstrDeviceType = (LPWSTR)mci_openA->lpstrDeviceType; + mci_openW->lpstrDeviceType = (LPCWSTR)mci_openA->lpstrDeviceType; else mci_openW->lpstrDeviceType = MCI_strdupAtoW(mci_openA->lpstrDeviceType); } if (dwParam1 & MCI_OPEN_ELEMENT) { if (dwParam1 & MCI_OPEN_ELEMENT_ID) - mci_openW->lpstrElementName = (LPWSTR)mci_openA->lpstrElementName; + mci_openW->lpstrElementName = (LPCWSTR)mci_openA->lpstrElementName; else mci_openW->lpstrElementName = MCI_strdupAtoW(mci_openA->lpstrElementName); } if (dwParam1 & MCI_OPEN_ALIAS) mci_openW->lpstrAlias = MCI_strdupAtoW(mci_openA->lpstrAlias); /* FIXME: this is only needed for specific types of MCI devices, and - * may cause a segfault if the two DWORD:s don't exist at the end of + * may cause a segfault if the two DWORD:s don't exist at the end of * mci_openA */ memcpy(mci_openW + 1, mci_openA + 1, 2 * sizeof(DWORD)); @@ -456,15 +455,15 @@ static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, if (dwParam1 & MCI_OPEN_TYPE) { if (!(dwParam1 & MCI_OPEN_TYPE_ID)) - HeapFree(GetProcessHeap(), 0, (PVOID)mci_openW->lpstrDeviceType); + HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrDeviceType); } if (dwParam1 & MCI_OPEN_ELEMENT) { if (!(dwParam1 & MCI_OPEN_ELEMENT_ID)) - HeapFree(GetProcessHeap(), 0, (PVOID)mci_openW->lpstrElementName); + HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrElementName); } if (dwParam1 & MCI_OPEN_ALIAS) - HeapFree(GetProcessHeap(), 0, (PVOID)mci_openW->lpstrAlias); + HeapFree(GetProcessHeap(), 0, (LPWSTR)mci_openW->lpstrAlias); HeapFree(GetProcessHeap(), 0, ptr); } break; @@ -555,7 +554,7 @@ static DWORD MCI_UnmapMsgAtoW(UINT msg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, /************************************************************************** * MCI_GetDevTypeFromFileName [internal] */ -static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len) +static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPWSTR buf, UINT len) { LPCWSTR tmp; HKEY hKey; @@ -566,7 +565,7 @@ static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len) if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, keyW, 0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { DWORD dwLen = len; - LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen ); + LONG lRet = RegQueryValueExW( hKey, tmp + 1, 0, 0, (void*)buf, &dwLen ); RegCloseKey( hKey ); if (lRet == ERROR_SUCCESS) return 0; } @@ -580,6 +579,7 @@ static DWORD MCI_GetDevTypeFromFileName(LPCWSTR fileName, LPCWSTR buf, UINT len) typedef struct tagWINE_MCICMDTABLE { UINT uDevType; + HGLOBAL hMem; const BYTE* lpTable; UINT nVerbs; /* number of verbs in command table */ LPCWSTR* aVerbs; /* array of verbs to speed up the verb look up process */ @@ -679,7 +679,7 @@ static UINT MCI_GetCommandTable(UINT uDevType) /* well try to load id */ if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) { - if (LoadStringW(WINMM_IData.hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { + if (LoadStringW(hWinMM32Instance, uDevType, buf, sizeof(buf) / sizeof(WCHAR))) { str = buf; } } else if (uDevType == 0) { @@ -688,15 +688,15 @@ static UINT MCI_GetCommandTable(UINT uDevType) } uTbl = MCI_NO_COMMAND_TABLE; if (str) { - HRSRC hRsrc = FindResourceW(WINMM_IData.hWinMM32Instance, str, (LPCWSTR)RT_RCDATA); + HRSRC hRsrc = FindResourceW(hWinMM32Instance, str, (LPCWSTR)RT_RCDATA); HANDLE hMem = 0; - if (hRsrc) hMem = LoadResource(WINMM_IData.hWinMM32Instance, hRsrc); + if (hRsrc) hMem = LoadResource(hWinMM32Instance, hRsrc); if (hMem) { - uTbl = MCI_SetCommandTable(LockResource(hMem), uDevType); + uTbl = MCI_SetCommandTable(hMem, uDevType); } else { WARN("No command table found in resource %p[%s]\n", - WINMM_IData.hWinMM32Instance, debugstr_w(str)); + hWinMM32Instance, debugstr_w(str)); } } TRACE("=> %d\n", uTbl); @@ -706,7 +706,7 @@ static UINT MCI_GetCommandTable(UINT uDevType) /************************************************************************** * MCI_SetCommandTable [internal] */ -UINT MCI_SetCommandTable(void *table, UINT uDevType) +static UINT MCI_SetCommandTable(HGLOBAL hMem, UINT uDevType) { int uTbl; static BOOL bInitDone = FALSE; @@ -720,7 +720,7 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) bInitDone = TRUE; MCI_GetCommandTable(0); } - TRACE("(%p, %u)\n", table, uDevType); + TRACE("(%p, %u)\n", hMem, uDevType); for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) { if (!S_MciCmdTable[uTbl].lpTable) { const BYTE* lmem; @@ -729,7 +729,8 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) WORD count; S_MciCmdTable[uTbl].uDevType = uDevType; - S_MciCmdTable[uTbl].lpTable = table; + S_MciCmdTable[uTbl].lpTable = LockResource(hMem); + S_MciCmdTable[uTbl].hMem = hMem; if (TRACE_ON(mci)) { MCI_DumpCommandTable(uTbl); @@ -769,21 +770,6 @@ UINT MCI_SetCommandTable(void *table, UINT uDevType) return MCI_NO_COMMAND_TABLE; } -/************************************************************************** - * MCI_DeleteCommandTable [internal] - */ -BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete) -{ - if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].lpTable) - return FALSE; - - if (delete) HeapFree(GetProcessHeap(), 0, (void*)S_MciCmdTable[uTbl].lpTable); - S_MciCmdTable[uTbl].lpTable = NULL; - HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs); - S_MciCmdTable[uTbl].aVerbs = 0; - return TRUE; -} - /************************************************************************** * MCI_UnLoadMciDriver [internal] */ @@ -799,14 +785,14 @@ static BOOL MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd) if (wmd->dwPrivate != 0) WARN("Unloading mci driver with non nul dwPrivate field\n"); - EnterCriticalSection(&WINMM_IData.cs); - for (tmp = &WINMM_IData.lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (tmp = &MciDrivers; *tmp; tmp = &(*tmp)->lpNext) { if (*tmp == wmd) { *tmp = wmd->lpNext; break; } } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType); HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias); @@ -819,37 +805,16 @@ static BOOL MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd) /************************************************************************** * MCI_OpenMciDriver [internal] */ -static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, LPARAM lp) +static BOOL MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCWSTR drvTyp, DWORD_PTR lp) { WCHAR libName[128]; if (!DRIVER_GetLibName(drvTyp, wszMci, libName, sizeof(libName))) return FALSE; - wmd->bIs32 = 0xFFFF; /* First load driver */ - if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) { - wmd->bIs32 = TRUE; - } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32WTo16) { - WINMM_MapType res; - - switch (res = pFnMciMapMsg32WTo16(0, DRV_OPEN, 0, (DWORD*)&lp)) { - case WINMM_MAP_MSGERROR: - TRACE("Not handled yet (DRV_OPEN)\n"); - break; - case WINMM_MAP_NOMEM: - TRACE("Problem mapping msg=DRV_OPEN from 32W to 16\n"); - break; - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - if ((wmd->hDriver = OpenDriver(drvTyp, wszMci, lp))) - wmd->bIs32 = FALSE; - if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg32WTo16(0, DRV_OPEN, 0, lp); - break; - } - } - return (wmd->bIs32 == 0xFFFF) ? FALSE : TRUE; + wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp); + return wmd->hDriver != NULL; } /************************************************************************** @@ -871,12 +836,12 @@ static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) wmd->dwYieldData = VK_CANCEL; wmd->CreatorThread = GetCurrentThreadId(); - EnterCriticalSection(&WINMM_IData.cs); - /* wmd must be inserted in list before sending opening the driver, coz' it + EnterCriticalSection(&WINMM_cs); + /* wmd must be inserted in list before sending opening the driver, because it * may want to lookup at wDevID */ - wmd->lpNext = WINMM_IData.lpMciDrvs; - WINMM_IData.lpMciDrvs = wmd; + wmd->lpNext = MciDrivers; + MciDrivers = wmd; for (modp.wDeviceID = MCI_MAGIC; MCI_GetDriver(modp.wDeviceID) != 0; @@ -884,22 +849,20 @@ static DWORD MCI_LoadMciDriver(LPCWSTR _strDevTyp, LPWINE_MCIDRIVER* lpwmd) wmd->wDeviceID = modp.wDeviceID; - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); - TRACE("wDevID=%04X \n", modp.wDeviceID); + TRACE("wDevID=%04X\n", modp.wDeviceID); modp.lpstrParams = NULL; - if (!MCI_OpenMciDriver(wmd, strDevTyp, (LPARAM)&modp)) { + if (!MCI_OpenMciDriver(wmd, strDevTyp, (DWORD_PTR)&modp)) { /* silence warning if all is used... some bogus program use commands like * 'open all'... */ if (strcmpiW(strDevTyp, wszAll) == 0) { dwRet = MCIERR_CANNOT_USE_ALL; } else { - FIXME("Couldn't load driver for type %s.\n" - "If you don't have a windows installation accessible from Wine,\n" - "you perhaps forgot to create a [mci] section in system.ini\n", + FIXME("Couldn't load driver for type %s.\n", debugstr_w(strDevTyp)); dwRet = MCIERR_DEVICE_NOT_INSTALLED; } @@ -931,6 +894,20 @@ errCleanUp: return dwRet; } +/************************************************************************** + * MCI_SendCommandFrom32 [internal] + */ +static DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) +{ + DWORD dwRet = MCIERR_INVALID_DEVICE_ID; + LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID); + + if (wmd) { + dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); + } + return dwRet; +} + /************************************************************************** * MCI_FinishOpen [internal] */ @@ -950,7 +927,7 @@ static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSW lpParms, lpParms->wDeviceID = wmd->wDeviceID; return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam, - (DWORD)lpParms); + (DWORD_PTR)lpParms); } /************************************************************************** @@ -980,8 +957,8 @@ static LPCWSTR MCI_FindCommand(UINT uTbl, LPCWSTR verb) */ static DWORD MCI_GetReturnType(LPCWSTR lpCmd) { - lpCmd = (LPCWSTR)((BYTE*)(lpCmd + strlenW(lpCmd) + 1) + sizeof(DWORD) + sizeof(WORD)); - if (*lpCmd == '\0' && *(const WORD*)((BYTE*)(lpCmd + 1) + sizeof(DWORD)) == MCI_RETURN) { + lpCmd = (LPCWSTR)((const BYTE*)(lpCmd + strlenW(lpCmd) + 1) + sizeof(DWORD) + sizeof(WORD)); + if (*lpCmd == '\0' && *(const WORD*)((const BYTE*)(lpCmd + 1) + sizeof(DWORD)) == MCI_RETURN) { return *(const DWORD*)(lpCmd + 1); } return 0L; @@ -1031,7 +1008,6 @@ static DWORD MCI_GetString(LPWSTR* str, LPWSTR* args) if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n"); *ptr++ = '\0'; /* remove trailing " */ if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS; - *ptr++ = '\0'; } else { ptr = strchrW(ptr, ' '); @@ -1093,7 +1069,7 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd, } if (strncmpiW(args, str, len) == 0 && - (args[len] == 0 || args[len] == ' ')) { + ((eid == MCI_STRING && len == 0) || args[len] == 0 || args[len] == ' ')) { /* store good values into data[] */ args += len; while (*args == ' ') args++; @@ -1123,7 +1099,7 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd, } break; case MCI_RECT: - /* store rect in data (offset...offset+3) */ + /* store rect in data (offset..offset+3) */ *dwFlags |= flg; if (!MCI_GetDWord(&(data[offset+0]), &args) || !MCI_GetDWord(&(data[offset+1]), &args) || @@ -1174,7 +1150,7 @@ static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCWSTR lpCmd, /************************************************************************** * MCI_HandleReturnValues [internal] */ -static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, +static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD retType, LPDWORD data, LPWSTR lpstrRet, UINT uRetLen) { static const WCHAR wszLd [] = {'%','l','d',0}; @@ -1195,8 +1171,7 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret case MCI_RESOURCE_RETURNED: /* return string which ID is HIWORD(data[1]), * string is loaded from mmsystem.dll */ - LoadStringW(WINMM_IData.hWinMM32Instance, HIWORD(data[1]), - lpstrRet, uRetLen); + LoadStringW(hWinMM32Instance, HIWORD(data[1]), lpstrRet, uRetLen); break; case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER: /* return string which ID is HIWORD(data[1]), @@ -1258,11 +1233,11 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, DWORD retType; LPCWSTR lpCmd = 0; LPWSTR devAlias = NULL; - BOOL bAutoOpen = FALSE; static const WCHAR wszNew[] = {'n','e','w',0}; static const WCHAR wszSAliasS[] = {' ','a','l','i','a','s',' ',0}; + static const WCHAR wszTypeS[] = {'t','y','p','e',' ',0}; - TRACE("(%s, %p, %d, %p)\n", + TRACE("(%s, %p, %d, %p)\n", debugstr_w(lpstrCommand), lpstrRet, uRetLen, hwndCallback); /* format is */ @@ -1282,35 +1257,44 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, goto errCleanUp; } - /* case dev == 'new' has to be handled */ - if (!strcmpW(dev, wszNew)) { - FIXME("'new': NIY as device name\n"); - dwRet = MCIERR_MISSING_DEVICE_NAME; - goto errCleanUp; - } - - /* otherwise, try to grab devType from open */ + /* Determine devType from open */ if (!strcmpW(verb, wszOpen)) { LPWSTR devType, tmp; + WCHAR buf[128]; - if ((devType = strchrW(dev, '!')) != NULL) { - *devType++ = '\0'; - tmp = devType; devType = dev; dev = tmp; - - dwFlags |= MCI_OPEN_TYPE; - data[2] = (DWORD)devType; - devType = str_dup_upper(devType); - dwFlags |= MCI_OPEN_ELEMENT; - data[3] = (DWORD)dev; - } else if (strchrW(dev, '.') == NULL) { - tmp = strchrW(dev,' '); - if (tmp) *tmp = '\0'; - data[2] = (DWORD)dev; - devType = str_dup_upper(dev); - if (tmp) *tmp = ' '; - dwFlags |= MCI_OPEN_TYPE; - } else { - static const WCHAR wszTypeS[] = {'t','y','p','e',' ',0}; + /* case dev == 'new' has to be handled */ + if (!strcmpW(dev, wszNew)) { + dev = 0; + if ((devType = strstrW(args, wszTypeS)) != NULL) { + devType += 5; + tmp = strchrW(devType, ' '); + if (tmp) *tmp = '\0'; + devType = str_dup_upper(devType); + if (tmp) *tmp = ' '; + /* dwFlags and data[2] will be correctly set in ParseOpt loop */ + } else { + WARN("open new requires device type\n"); + dwRet = MCIERR_MISSING_DEVICE_NAME; + goto errCleanUp; + } + } else if ((devType = strchrW(dev, '!')) != NULL) { + *devType++ = '\0'; + tmp = devType; devType = dev; dev = tmp; + + dwFlags |= MCI_OPEN_TYPE; + data[2] = (DWORD)devType; + devType = str_dup_upper(devType); + dwFlags |= MCI_OPEN_ELEMENT; + data[3] = (DWORD)dev; + } else if (DRIVER_GetLibName(dev, wszMci, buf, sizeof(buf))) { + /* this is the name of a mci driver's type */ + tmp = strchrW(dev, ' '); + if (tmp) *tmp = '\0'; + data[2] = (DWORD)dev; + devType = str_dup_upper(dev); + if (tmp) *tmp = ' '; + dwFlags |= MCI_OPEN_TYPE; + } else { if ((devType = strstrW(args, wszTypeS)) != NULL) { devType += 5; tmp = strchrW(devType, ' '); @@ -1319,7 +1303,6 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, if (tmp) *tmp = ' '; /* dwFlags and data[2] will be correctly set in ParseOpt loop */ } else { - WCHAR buf[32]; if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf)))) goto errCleanUp; @@ -1339,6 +1322,10 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, data[4] = (DWORD)tmp2; /* should be done in regular options parsing */ /* dwFlags |= MCI_OPEN_ALIAS; */ + } else if (dev == 0) { + /* "open new" requires alias */ + dwRet = MCIERR_NEW_REQUIRES_ALIAS; + goto errCleanUp; } dwRet = MCI_LoadMciDriver(devType, &wmd); @@ -1351,7 +1338,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, } } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDW(dev)))) { /* auto open */ - static WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0}; + static const WCHAR wszOpenWait[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0}; WCHAR buf[128]; sprintfW(buf, wszOpenWait, dev); @@ -1387,12 +1374,6 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, goto errCleanUp; } - /* set up call back */ - if (hwndCallback != 0) { - dwFlags |= MCI_NOTIFY; - data[0] = (DWORD)hwndCallback; - } - /* set return information */ switch (retType = MCI_GetReturnType(lpCmd)) { case 0: offset = 1; break; @@ -1402,22 +1383,23 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, default: ERR("oops\n"); } - TRACE("verb=%s on dev=%s; offset=%d\n", + TRACE("verb=%s on dev=%s; offset=%d\n", debugstr_w(verb), debugstr_w(dev), offset); if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags))) goto errCleanUp; - if (bAutoOpen && (dwFlags & MCI_NOTIFY)) { - dwRet = MCIERR_NOTIFY_ON_AUTO_OPEN; - goto errCleanUp; + /* set up call back */ + if (dwFlags & MCI_NOTIFY) { + data[0] = (DWORD)hwndCallback; } + /* FIXME: the command should get it's own notification window set up and * ask for device closing while processing the notification mechanism */ if (lpstrRet && uRetLen) *lpstrRet = '\0'; - TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n", + TRACE("[%d, %s, %08x, %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s]\n", wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags, data[0], debugstr_w((WCHAR *)data[0]), data[1], debugstr_w((WCHAR *)data[1]), data[2], debugstr_w((WCHAR *)data[2]), data[3], debugstr_w((WCHAR *)data[3]), @@ -1428,15 +1410,14 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, MCI_UnLoadMciDriver(wmd); /* FIXME: notification is not properly shared across two opens */ } else { - dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE); + dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD_PTR)data); } - TRACE("=> 1/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet)); + TRACE("=> 1/ %x (%s)\n", dwRet, debugstr_w(lpstrRet)); dwRet = MCI_HandleReturnValues(dwRet, wmd, retType, data, lpstrRet, uRetLen); - TRACE("=> 2/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet)); + TRACE("=> 2/ %x (%s)\n", dwRet, debugstr_w(lpstrRet)); errCleanUp: HeapFree(GetProcessHeap(), 0, verb); - HeapFree(GetProcessHeap(), 0, devAlias); return dwRet; } @@ -1465,7 +1446,7 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, } } ret = mciSendStringW(lpwstrCommand, lpwstrRet, uRetLen, hwndCallback); - if (lpwstrRet) + if (!ret && lpwstrRet) WideCharToMultiByte( CP_ACP, 0, lpwstrRet, -1, lpstrRet, uRetLen, NULL, NULL ); HeapFree(GetProcessHeap(), 0, lpwstrCommand); HeapFree(GetProcessHeap(), 0, lpwstrRet); @@ -1474,7 +1455,6 @@ DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet, /************************************************************************** * mciExecute [WINMM.@] - * mciExecute [MMSYSTEM.712] */ BOOL WINAPI mciExecute(LPCSTR lpstrCommand) { @@ -1486,7 +1466,7 @@ BOOL WINAPI mciExecute(LPCSTR lpstrCommand) ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0); if (ret != 0) { if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) { - sprintf(strRet, "Unknown MCI error (%ld)", ret); + sprintf(strRet, "Unknown MCI error (%lu)", ret); } MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK); } @@ -1497,13 +1477,13 @@ BOOL WINAPI mciExecute(LPCSTR lpstrCommand) /************************************************************************** * mciLoadCommandResource [WINMM.@] * - * Strangely, this function only exists as an UNICODE one. + * Strangely, this function only exists as a UNICODE one. */ UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type) { - HRSRC hRsrc = 0; - HGLOBAL hMem; - UINT16 ret = MCI_NO_COMMAND_TABLE; + UINT ret = MCI_NO_COMMAND_TABLE; + HRSRC hRsrc = 0; + HGLOBAL hMem; TRACE("(%p, %s, %d)!\n", hInst, debugstr_w(resNameW), type); @@ -1525,13 +1505,13 @@ UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type) } #endif } - if (!(hRsrc = FindResourceW(hInst, resNameW, (LPWSTR)RT_RCDATA))) { - WARN("No command table found in resource\n"); - } else if ((hMem = LoadResource(hInst, hRsrc))) { - ret = MCI_SetCommandTable(LockResource(hMem), type); - } else { - WARN("Couldn't load resource.\n"); + if ((hRsrc = FindResourceW(hInst, resNameW, (LPWSTR)RT_RCDATA)) && + (hMem = LoadResource(hInst, hRsrc))) { + ret = MCI_SetCommandTable(hMem, type); + FreeResource(hMem); } + else WARN("No command table found in module for %s\n", debugstr_w(resNameW)); + TRACE("=> %04x\n", ret); return ret; } @@ -1543,79 +1523,16 @@ BOOL WINAPI mciFreeCommandResource(UINT uTable) { TRACE("(%08x)!\n", uTable); - return MCI_DeleteCommandTable(uTable, FALSE); -} + if (uTable >= MAX_MCICMDTABLE || !S_MciCmdTable[uTable].lpTable) + return FALSE; -/************************************************************************** - * MCI_SendCommandFrom32 [internal] - */ -DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) -{ - DWORD dwRet = MCIERR_INVALID_DEVICE_ID; - LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID); - - if (wmd) { - if (wmd->bIs32) { - dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); - } else if (pFnMciMapMsg32WTo16) { - WINMM_MapType res; - - switch (res = pFnMciMapMsg32WTo16(wmd->wType, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_MSGERROR: - TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg)); - dwRet = MCIERR_DRIVER_INTERNAL; - break; - case WINMM_MAP_NOMEM: - TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg)); - dwRet = MCIERR_OUT_OF_MEMORY; - break; - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); - if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg32WTo16(wmd->wType, wMsg, dwParam1, dwParam2); - break; - } - } - } - return dwRet; -} - -/************************************************************************** - * MCI_SendCommandFrom16 [internal] - */ -DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) -{ - DWORD dwRet = MCIERR_INVALID_DEVICE_ID; - LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID); - - if (wmd) { - dwRet = MCIERR_INVALID_DEVICE_ID; - - if (wmd->bIs32 && pFnMciMapMsg16To32W) { - WINMM_MapType res; - - switch (res = pFnMciMapMsg16To32W(wmd->wType, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_MSGERROR: - TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg)); - dwRet = MCIERR_DRIVER_INTERNAL; - break; - case WINMM_MAP_NOMEM: - TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg)); - dwRet = MCIERR_OUT_OF_MEMORY; - break; - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); - if (res == WINMM_MAP_OKMEM) - pFnMciUnMapMsg16To32W(wmd->wType, wMsg, dwParam1, dwParam2); - break; - } - } else { - dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2); - } - } - return dwRet; + FreeResource(S_MciCmdTable[uTable].hMem); + S_MciCmdTable[uTable].hMem = NULL; + S_MciCmdTable[uTable].lpTable = NULL; + HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTable].aVerbs); + S_MciCmdTable[uTable].aVerbs = 0; + S_MciCmdTable[uTable].nVerbs = 0; + return TRUE; } /************************************************************************** @@ -1627,7 +1544,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) DWORD dwRet; LPWINE_MCIDRIVER wmd = NULL; - TRACE("(%08lX, %p)\n", dwParam, lpParms); + TRACE("(%08X, %p)\n", dwParam, lpParms); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; /* only two low bytes are generic, the other ones are dev type specific */ @@ -1643,11 +1560,11 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) if (dwParam & MCI_OPEN_TYPE) { if (dwParam & MCI_OPEN_TYPE_ID) { - WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType); + WORD uDevType = LOWORD(lpParms->lpstrDeviceType); if (uDevType < MCI_DEVTYPE_FIRST || uDevType > MCI_DEVTYPE_LAST || - !LoadStringW(WINMM_IData.hWinMM32Instance, uDevType, + !LoadStringW(hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp) / sizeof(WCHAR))) { dwRet = MCIERR_BAD_INTEGER; goto errCleanUp; @@ -1667,7 +1584,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) */ if (dwParam & MCI_OPEN_ELEMENT) { ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n", - debugstr_w(lpParms->lpstrElementName), + debugstr_w(lpParms->lpstrElementName), debugstr_w(strDevTyp)); dwRet = MCIERR_UNRECOGNIZED_KEYWORD; goto errCleanUp; @@ -1729,13 +1646,13 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) } if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) { - TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet); + TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet); /* FIXME: is dwRet the correct ret code ? */ goto errCleanUp; } /* only handled devices fall through */ - TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet); + TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet); if (dwParam & MCI_NOTIFY) mciDriverNotify((HWND)lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL); @@ -1752,27 +1669,33 @@ errCleanUp: /************************************************************************** * MCI_Close [internal] */ -static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) +static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { DWORD dwRet; LPWINE_MCIDRIVER wmd; - TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); + TRACE("(%04x, %08X, %p)\n", wDevID, dwParam, lpParms); - if (wDevID == MCI_ALL_DEVICE_ID) { - LPWINE_MCIDRIVER next; - - EnterCriticalSection(&WINMM_IData.cs); + if (wDevID == (UINT16)MCI_ALL_DEVICE_ID) { /* FIXME: shall I notify once after all is done, or for * each of the open drivers ? if the latest, which notif * to return when only one fails ? */ - for (wmd = WINMM_IData.lpMciDrvs; wmd; ) { - next = wmd->lpNext; - MCI_Close(wmd->wDeviceID, dwParam, lpParms); - wmd = next; + while (MciDrivers) { + /* Retrieve the device ID under lock, but send the message without, + * the driver might be calling some winmm functions from another + * thread before being fully stopped. + */ + EnterCriticalSection(&WINMM_cs); + if (!MciDrivers) + { + LeaveCriticalSection(&WINMM_cs); + break; + } + wDevID = MciDrivers->wDeviceID; + LeaveCriticalSection(&WINMM_cs); + MCI_Close(wDevID, dwParam, lpParms); } - LeaveCriticalSection(&WINMM_IData.cs); return 0; } @@ -1780,13 +1703,14 @@ static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) return MCIERR_INVALID_DEVICE_ID; } - dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms); + dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD_PTR)lpParms); MCI_UnLoadMciDriver(wmd); if (dwParam & MCI_NOTIFY) - mciDriverNotify((HWND)lpParms->dwCallback, wDevID, - (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE); + mciDriverNotify(lpParms ? (HWND)lpParms->dwCallback : 0, + wDevID, + dwRet ? MCI_NOTIFY_FAILURE : MCI_NOTIFY_SUCCESSFUL); return dwRet; } @@ -1794,7 +1718,7 @@ static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) /************************************************************************** * MCI_WriteString [internal] */ -DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr) +static DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr) { DWORD ret = 0; @@ -1822,21 +1746,22 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm LPWINE_MCIDRIVER wmd; HKEY hKey; - if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; + if (lpParms == NULL || lpParms->lpstrReturn == NULL) + return MCIERR_NULL_PARAMETER_BLOCK; - TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", - uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType); + TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n", + uDevID, dwFlags, lpParms, lpParms->dwNumber, lpParms->wDeviceType); switch (dwFlags & ~MCI_SYSINFO_OPEN) { case MCI_SYSINFO_QUANTITY: if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST || lpParms->wDeviceType > MCI_DEVTYPE_LAST) { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n"); - EnterCriticalSection(&WINMM_IData.cs); - for (wmd = WINMM_IData.lpMciDrvs; wmd; wmd = wmd->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) { cnt++; } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); } else { TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n"); if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, @@ -1850,11 +1775,11 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm } else { if (dwFlags & MCI_SYSINFO_OPEN) { TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms->wDeviceType); - EnterCriticalSection(&WINMM_IData.cs); - for (wmd = WINMM_IData.lpMciDrvs; wmd; wmd = wmd->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (wmd = MciDrivers; wmd; wmd = wmd->lpNext) { if (wmd->wType == lpParms->wDeviceType) cnt++; } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); } else { TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms->wDeviceType); FIXME("Don't know how to get # of MCI devices of a given type\n"); @@ -1862,11 +1787,11 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm } } *(DWORD*)lpParms->lpstrReturn = cnt; - TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); + TRACE("(%d) => '%d'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); ret = MCI_INTEGER_RETURNED; break; case MCI_SYSINFO_INSTALLNAME: - TRACE("MCI_SYSINFO_INSTALLNAME \n"); + TRACE("MCI_SYSINFO_INSTALLNAME\n"); if ((wmd = MCI_GetDriver(uDevID))) { ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, wmd->lpstrDeviceType); @@ -1874,7 +1799,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm *lpParms->lpstrReturn = 0; ret = MCIERR_INVALID_DEVICE_ID; } - TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); + TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; case MCI_SYSINFO_NAME: TRACE("MCI_SYSINFO_NAME\n"); @@ -1883,13 +1808,13 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm ret = MCIERR_UNRECOGNIZED_COMMAND; } else { s = NULL; - if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0, + if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0, KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) { - if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, - 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS && + if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, + 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS && lpParms->dwNumber <= cnt) { - DWORD bufLen = sizeof(buf); - if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1, + DWORD bufLen = sizeof(buf)/sizeof(buf[0]); + if (RegEnumKeyExW(hKey, lpParms->dwNumber - 1, buf, &bufLen, 0, 0, 0, 0) == ERROR_SUCCESS) s = buf; } @@ -1898,7 +1823,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm if (!s) { if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) { for (p = buf; *p; p += strlenW(p) + 1, cnt++) { - TRACE("%ld: %s\n", cnt, debugstr_w(p)); + TRACE("%d: %s\n", cnt, debugstr_w(p)); if (cnt == lpParms->dwNumber - 1) { s = p; break; @@ -1908,10 +1833,10 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm } ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize / sizeof(WCHAR), s) : MCIERR_OUTOFRANGE; } - TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); + TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; default: - TRACE("Unsupported flag value=%08lx\n", dwFlags); + TRACE("Unsupported flag value=%08x\n", dwFlags); ret = MCIERR_UNRECOGNIZED_COMMAND; } return ret; @@ -1956,90 +1881,32 @@ static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms) /************************************************************************** * MCI_SendCommand [internal] */ -DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, - DWORD dwParam2, BOOL bFrom32) +DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) { DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND; switch (wMsg) { case MCI_OPEN: - if (bFrom32) { - dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2); - } else if (pFnMciMapMsg16To32W) { - switch (pFnMciMapMsg16To32W(0, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2); - pFnMciUnMapMsg16To32W(0, wMsg, dwParam1, dwParam2); - break; - default: break; /* so that gcc does not bark */ - } - } + dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSW)dwParam2); break; case MCI_CLOSE: - if (bFrom32) { - dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); - } else if (pFnMciMapMsg16To32W) { - switch (pFnMciMapMsg16To32W(0, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); - pFnMciUnMapMsg16To32W(0, wMsg, dwParam1, dwParam2); - break; - default: break; /* so that gcc does not bark */ - } - } + dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); break; case MCI_SYSINFO: - if (bFrom32) { - dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2); - } else if (pFnMciMapMsg16To32W) { - switch (pFnMciMapMsg16To32W(0, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2); - pFnMciUnMapMsg16To32W(0, wMsg, dwParam1, dwParam2); - break; - default: break; /* so that gcc does not bark */ - } - } + dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSW)dwParam2); break; case MCI_BREAK: - if (bFrom32) { - dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); - } else if (pFnMciMapMsg16To32W) { - switch (pFnMciMapMsg16To32W(0, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); - pFnMciUnMapMsg16To32W(0, wMsg, dwParam1, dwParam2); - break; - default: break; /* so that gcc does not bark */ - } - } + dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2); break; case MCI_SOUND: - if (bFrom32) { - dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2); - } else if (pFnMciMapMsg16To32W) { - switch (pFnMciMapMsg16To32W(0, wMsg, dwParam1, &dwParam2)) { - case WINMM_MAP_OK: - case WINMM_MAP_OKMEM: - dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2); - pFnMciUnMapMsg16To32W(0, wMsg, dwParam1, dwParam2); - break; - default: break; /* so that gcc does not bark */ - } - } + dwRet = MCI_Sound(wDevID, dwParam1, (LPMCI_SOUND_PARMSW)dwParam2); break; default: if (wDevID == MCI_ALL_DEVICE_ID) { FIXME("unhandled MCI_ALL_DEVICE_ID\n"); dwRet = MCIERR_CANNOT_USE_ALL; } else { - dwRet = (bFrom32) ? - MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2) : - MCI_SendCommandFrom16(wDevID, wMsg, dwParam1, dwParam2); + dwRet = MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2); } break; } @@ -2053,7 +1920,7 @@ DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, * mciSendString), because MCI drivers return extra information for string * transformation. This function gets rid of them. */ -LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) +static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2) { if (LOWORD(dwRet)) return LOWORD(dwRet); @@ -2072,8 +1939,8 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) { LPMCI_GETDEVCAPS_PARMS lmgp; - lmgp = (LPMCI_GETDEVCAPS_PARMS)(void*)dwParam2; - TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn)); + lmgp = (LPMCI_GETDEVCAPS_PARMS)dwParam2; + TRACE("Changing %08x to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn)); lmgp->dwReturn = LOWORD(lmgp->dwReturn); } break; @@ -2095,8 +1962,8 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) { LPMCI_STATUS_PARMS lsp; - lsp = (LPMCI_STATUS_PARMS)(void*)dwParam2; - TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn)); + lsp = (LPMCI_STATUS_PARMS)dwParam2; + TRACE("Changing %08lx to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn)); lsp->dwReturn = LOWORD(lsp->dwReturn); } break; @@ -2135,8 +2002,7 @@ BOOL WINAPI mciGetErrorStringW(MCIERROR wError, LPWSTR lpstrBuffer, UINT uLength if (lpstrBuffer != NULL && uLength > 0 && wError >= MCIERR_BASE && wError <= MCIERR_CUSTOM_DRIVER_BASE) { - if (LoadStringW(WINMM_IData.hWinMM32Instance, - wError, lpstrBuffer, uLength) > 0) { + if (LoadStringW(hWinMM32Instance, wError, lpstrBuffer, uLength) > 0) { ret = TRUE; } } @@ -2153,8 +2019,7 @@ BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength if (lpstrBuffer != NULL && uLength > 0 && dwError >= MCIERR_BASE && dwError <= MCIERR_CUSTOM_DRIVER_BASE) { - if (LoadStringA(WINMM_IData.hWinMM32Instance, - dwError, lpstrBuffer, uLength) > 0) { + if (LoadStringA(hWinMM32Instance, dwError, lpstrBuffer, uLength) > 0) { ret = TRUE; } } @@ -2174,7 +2039,7 @@ BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus) /************************************************************************** * mciGetDriverData [WINMM.@] */ -DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID) +DWORD_PTR WINAPI mciGetDriverData(MCIDEVICEID uDeviceID) { LPWINE_MCIDRIVER wmd; @@ -2193,7 +2058,7 @@ DWORD WINAPI mciGetDriverData(MCIDEVICEID uDeviceID) /************************************************************************** * mciSetDriverData [WINMM.@] */ -BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data) +BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD_PTR data) { LPWINE_MCIDRIVER wmd; @@ -2221,9 +2086,9 @@ DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1, TRACE("(%08x, %s, %08lx, %08lx)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); - dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE); + dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2); dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2); - TRACE("=> %08lx\n", dwRet); + TRACE("=> %08x\n", dwRet); return dwRet; } @@ -2271,7 +2136,7 @@ UINT WINAPI mciGetDeviceIDA(LPCSTR lpstrName) */ UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName) { - return MCI_GetDriverFromString(lpwstrName); + return MCI_GetDriverFromString(lpwstrName); } /****************************************************************** @@ -2292,11 +2157,11 @@ static void MyUserYield(void) /************************************************************************** * MCI_DefYieldProc [internal] */ -UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data) +static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data) { INT16 ret; - TRACE("(0x%04x, 0x%08lx)\n", wDevID, data); + TRACE("(0x%04x, 0x%08x)\n", wDevID, data); if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) || (GetAsyncKeyState(LOWORD(data)) & 1) == 0) { @@ -2319,7 +2184,7 @@ BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD { LPWINE_MCIDRIVER wmd; - TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); + TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData); if (!(wmd = MCI_GetDriver(uDeviceID))) { WARN("Bad uDeviceID\n"); @@ -2328,7 +2193,6 @@ BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD wmd->lpfnYieldProc = fpYieldProc; wmd->dwYieldData = dwYieldData; - wmd->bIs32 = TRUE; return TRUE; } @@ -2357,7 +2221,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType) /* FIXME: that's rather strange, there is no * mciGetDeviceIDFromElementID32A in winmm.spec */ - FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType)); + FIXME("(%u, %s) stub\n", dwElementID, debugstr_w(lpstrType)); return 0; } @@ -2378,10 +2242,7 @@ YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID uDeviceID, DWORD* lpdwYieldData) WARN("No proc set\n"); return NULL; } - if (!wmd->bIs32) { - WARN("Proc is 32 bit\n"); - return NULL; - } + if (lpdwYieldData) *lpdwYieldData = wmd->dwYieldData; return wmd->lpfnYieldProc; } @@ -2409,7 +2270,7 @@ UINT WINAPI mciDriverYield(MCIDEVICEID uDeviceID) TRACE("(%04x)\n", uDeviceID); - if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc || !wmd->bIs32) { + if (!(wmd = MCI_GetDriver(uDeviceID)) || !wmd->lpfnYieldProc) { MyUserYield(); } else { ret = wmd->lpfnYieldProc(uDeviceID, wmd->dwYieldData); diff --git a/reactos/dll/win32/winmm/message16.c b/reactos/dll/win32/winmm/message16.c deleted file mode 100644 index 620d9e05c8c..00000000000 --- a/reactos/dll/win32/winmm/message16.c +++ /dev/null @@ -1,3540 +0,0 @@ -/* - * MMSYSTEM MCI and low level mapping functions - * - * Copyright 1999 Eric Pouech - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include -#include -#include -#include -#include "wine/winbase16.h" -#include "windef.h" -#include "winbase.h" -#include "winreg.h" -#include "winver.h" -#include "wownt32.h" -#include "winemm16.h" -#include "digitalv.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(winmm); - -/************************************************************************** - * MMDRV_Callback [internal] - */ -static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2) -{ - TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n", - mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2); - - if (!mld->bFrom32 && (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_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Aux_UnMap32WTo16 [internal] - */ -static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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 dwInstance, DWORD dwParam1, DWORD 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 - * ================================= */ - -/************************************************************************** - * xMMDRV_Mixer_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ -#if 0 - MIXERCAPSA micA; - UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA)); - - if (ret == MMSYSERR_NOERROR) { - mixcaps->wMid = micA.wMid; - mixcaps->wPid = micA.wPid; - mixcaps->vDriverVersion = micA.vDriverVersion; - strcpy(mixcaps->szPname, micA.szPname); - mixcaps->fdwSupport = micA.fdwSupport; - mixcaps->cDestinations = micA.cDestinations; - } - return ret; -#endif - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_UnMap32WTo16 [internal] - */ -static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_Mixer_Callback [internal] - */ -static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) -{ - LPWINE_MLD mld = (LPWINE_MLD)dwInstance; - - FIXME("NIY\n"); - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * M I D I I N M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_MidiIn_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_UnMap32WTo16 [internal] - */ -static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MMDRV_MidiIn_Callback [internal] - */ -static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD 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 are data, nothing to do */ - break; - case MIM_LONGDATA: - case MIM_LONGERROR: - /* dwParam1 points to a MidiHdr, work to be done !!! */ - if (mld->bFrom32 && !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 if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR mh16 = MapSL(segmh16); - - dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - } - /* else { 16 => 16 or 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); -} - -/* ================================= - * M I D I O U T M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_MidiOut_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case MODM_OPEN: - case MODM_CLOSE: - case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW)); - LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1); - - if (moc32) { - *(LPMIDIOUTCAPS16*)moc32 = moc16; - moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16)); - *lpParam1 = (DWORD)moc32; - *lpParam2 = sizeof(MIDIOUTCAPSW); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_PREPARE: - { - LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR)); - LPMIDIHDR mh16 = MapSL(*lpParam1); - - if (mh32) { - *(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1; - mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR)); - mh32->lpData = MapSL((SEGPTR)mh16->lpData); - mh32->dwBufferLength = mh16->dwBufferLength; - mh32->dwBytesRecorded = mh16->dwBytesRecorded; - mh32->dwUser = mh16->dwUser; - mh32->dwFlags = mh16->dwFlags; - /* FIXME: nothing on mh32->lpNext */ - /* could link the mh32->lpNext at this level for memory house keeping */ - mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0; - mh16->lpNext = mh32; /* for reuse in unprepare and write */ - /* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */ - mh16->reserved = *lpParam2; - *lpParam1 = (DWORD)mh32; - *lpParam2 = sizeof(MIDIHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh16 = MapSL(*lpParam1); - LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext; - - *lpParam1 = (DWORD)mh32; - *lpParam2 = sizeof(MIDIHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - mh32->dwBufferLength, mh16->dwBufferLength); - } else - mh32->dwBufferLength = mh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case MODM_GETNUMDEVS: - case MODM_DATA: - case MODM_RESET: - case MODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case MODM_OPEN: - case MODM_CLOSE: - case MODM_GETVOLUME: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case MODM_GETDEVCAPS: - { - LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1); - LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - - moc16->wMid = moc32->wMid; - moc16->wPid = moc32->wPid; - moc16->vDriverVersion = moc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname, - sizeof(moc16->szPname), NULL, NULL ); - moc16->wTechnology = moc32->wTechnology; - moc16->wVoices = moc32->wVoices; - moc16->wNotes = moc32->wNotes; - moc16->wChannelMask = moc32->wChannelMask; - moc16->dwSupport = moc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case MODM_PREPARE: - case MODM_UNPREPARE: - case MODM_LONGDATA: - { - LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1); - LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR))); - - assert(mh16->lpNext == mh32); - mh16->dwBufferLength = mh32->dwBufferLength; - mh16->dwBytesRecorded = mh32->dwBytesRecorded; - mh16->dwUser = mh32->dwUser; - mh16->dwFlags = mh32->dwFlags; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - - if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR)); - mh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - - case MODM_CACHEPATCHES: - case MODM_CACHEDRUMPATCHES: - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_MidiOut_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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 = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */ - mh32->reserved = *lpParam2; - - TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, - mh32->dwBufferLength, (DWORD)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 = (LPMIDIHDR)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=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)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 %ld to %ld, 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, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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 == (LPMIDIHDR)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 dwInstance, DWORD dwParam1, DWORD 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 (mld->bFrom32 && !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 if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { - /* initial map is: 16 => 32 */ - LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1); - SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)); - LPMIDIHDR mh16 = MapSL(segmh16); - - dwParam1 = (DWORD)segmh16; - mh16->dwFlags = mh32->dwFlags; - if (mh16->reserved >= sizeof(MIDIHDR)) - mh16->dwOffset = mh32->dwOffset; - } - /* else { 16 => 16 or 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); -} - -/* ================================= - * W A V E I N M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_WaveIn_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - ret = WINMM_MAP_OK; - break; - case WIDM_OPEN: - case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW)); - LPWAVEINCAPS16 wic16 = MapSL(*lpParam1); - - if (wic32) { - *(LPWAVEINCAPS16*)wic32 = wic16; - wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16)); - *lpParam1 = (DWORD)wic32; - *lpParam2 = sizeof(WAVEINCAPSW); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WIDM_ADDBUFFER: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case WIDM_MAPPER_STATUS: - /* just a single DWORD */ - *lpParam2 = (DWORD)MapSL(*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_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - case WIDM_GETNUMDEVS: - case WIDM_RESET: - case WIDM_START: - case WIDM_STOP: - case WIDM_MAPPER_STATUS: - ret = WINMM_MAP_OK; - break; - case WIDM_OPEN: - case WIDM_CLOSE: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - case WIDM_GETDEVCAPS: - { - LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1); - LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - - wic16->wMid = wic32->wMid; - wic16->wPid = wic32->wPid; - wic16->vDriverVersion = wic32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname, - sizeof(wic16->szPname), NULL, NULL ); - wic16->dwFormats = wic32->dwFormats; - wic16->wChannels = wic32->wChannels; - HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case WIDM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = WINMM_MAP_OK; - } - break; - case WIDM_ADDBUFFER: - case WIDM_PREPARE: - case WIDM_UNPREPARE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - - if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveIn_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); - sz += ((LPWAVEFORMATEX)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 */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - - 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); - - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - - if (wMsg == WIDM_ADDBUFFER) - memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); - - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, 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, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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; - - MMSYSTEM_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 dwInstance, DWORD dwParam1, DWORD 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 (mld->bFrom32 && !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 if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * W A V E O U T M A P P E R S - * ================================= */ - -/************************************************************************** - * MMDRV_WaveOut_Map16To32W [internal] - */ -static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - ret = WINMM_MAP_OK; - break; - - case WODM_GETPITCH: - case WODM_GETPLAYBACKRATE: - case WODM_GETVOLUME: - case WODM_OPEN: - FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n"); - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW)); - LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1); - - if (woc32) { - *(LPWAVEOUTCAPS16*)woc32 = woc16; - woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16)); - *lpParam1 = (DWORD)woc32; - *lpParam2 = sizeof(WAVEOUTCAPSW); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_GETPOS: - { - LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME)); - LPMMTIME16 mmt16 = MapSL(*lpParam1); - - if (mmt32) { - *(LPMMTIME16*)mmt32 = mmt16; - mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16)); - - mmt32->wType = mmt16->wType; - *lpParam1 = (DWORD)mmt32; - *lpParam2 = sizeof(MMTIME); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_PREPARE: - { - LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR)); - LPWAVEHDR wh16 = MapSL(*lpParam1); - - if (wh32) { - *(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1; - wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR)); - wh32->lpData = MapSL((SEGPTR)wh16->lpData); - wh32->dwBufferLength = wh16->dwBufferLength; - wh32->dwBytesRecorded = wh16->dwBytesRecorded; - wh32->dwUser = wh16->dwUser; - wh32->dwFlags = wh16->dwFlags; - wh32->dwLoops = wh16->dwLoops; - /* FIXME: nothing on wh32->lpNext */ - /* could link the wh32->lpNext at this level for memory house keeping */ - wh16->lpNext = wh32; /* for reuse in unprepare and write */ - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - - ret = WINMM_MAP_OKMEM; - } else { - ret = WINMM_MAP_NOMEM; - } - } - break; - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh16 = MapSL(*lpParam1); - LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext; - - *lpParam1 = (DWORD)wh32; - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", - wh32->dwBufferLength, wh16->dwBufferLength); - } else - wh32->dwBufferLength = wh16->dwBufferLength; - ret = WINMM_MAP_OKMEM; - } - break; - case WODM_MAPPER_STATUS: - *lpParam2 = (DWORD)MapSL(*lpParam2); - ret = WINMM_MAP_OK; - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_UnMap16To32W [internal] - */ -static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) -{ - WINMM_MapType ret = WINMM_MAP_MSGERROR; - - switch (wMsg) { - /* nothing to do */ - case WODM_BREAKLOOP: - case WODM_CLOSE: - case WODM_GETNUMDEVS: - case WODM_PAUSE: - case WODM_RESET: - case WODM_RESTART: - case WODM_SETPITCH: - case WODM_SETPLAYBACKRATE: - case WODM_SETVOLUME: - case WODM_MAPPER_STATUS: - ret = WINMM_MAP_OK; - break; - - case WODM_GETPITCH: - case WODM_GETPLAYBACKRATE: - case WODM_GETVOLUME: - case WODM_OPEN: - FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n"); - break; - - case WODM_GETDEVCAPS: - { - LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1); - LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - - woc16->wMid = woc32->wMid; - woc16->wPid = woc32->wPid; - woc16->vDriverVersion = woc32->vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname, - sizeof(woc16->szPname), NULL, NULL ); - woc16->dwFormats = woc32->dwFormats; - woc16->wChannels = woc32->wChannels; - woc16->dwSupport = woc32->dwSupport; - HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16)); - ret = WINMM_MAP_OK; - } - break; - case WODM_GETPOS: - { - LPMMTIME mmt32 = (LPMMTIME)(*lpParam1); - LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16)); - - MMSYSTEM_MMTIME32to16(mmt16, mmt32); - HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16)); - ret = WINMM_MAP_OK; - } - break; - case WODM_PREPARE: - case WODM_UNPREPARE: - case WODM_WRITE: - { - LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1); - LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR))); - - assert(wh16->lpNext == wh32); - wh16->dwBufferLength = wh32->dwBufferLength; - wh16->dwBytesRecorded = wh32->dwBytesRecorded; - wh16->dwUser = wh32->dwUser; - wh16->dwFlags = wh32->dwFlags; - wh16->dwLoops = wh32->dwLoops; - - if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) { - HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR)); - wh16->lpNext = 0; - } - ret = WINMM_MAP_OK; - } - break; - default: - FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2); - break; - } - return ret; -} - -/************************************************************************** - * MMDRV_WaveOut_Map32WTo16 [internal] - */ -static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag); - sz += ((LPWAVEFORMATEX)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 */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - - 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); - - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); - - if (wMsg == WODM_WRITE) - memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); - - *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); - *lpParam2 = sizeof(WAVEHDR); - /* dwBufferLength can be reduced between prepare & write */ - if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, 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, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD 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; - - MMSYSTEM_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 dwInstance, DWORD dwParam1, DWORD 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 (mld->bFrom32 && !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 if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) { - /* initial map is: 16 => 32 */ - LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1); - SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)); - LPWAVEHDR wh16 = MapSL(segwh16); - - dwParam1 = (DWORD)segwh16; - wh16->dwFlags = wh32->dwFlags; - } - /* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/ - break; - default: - ERR("Unknown msg %u\n", uMsg); - } - - MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2); -} - -/* ================================= - * 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 %lu\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 %lu\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 - * - */ -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; -} - -/* ================================= - * M C I - * ================================= */ - -#if 0 -/* FIXME: this code is kept for not yet implemented optimisation for an application - * using the 32A MCI interface and calling a 16 bit driver. - * For now, we're doing two conversions: - * - 32A => 32W (in 32 bit MCI code) - * - 32W => 16 in this file - */ - -/* - * 0000 stop - * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4 - * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4 - * 0100 - * 0101 - * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4 - * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4 - * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1 - */ - -/************************************************************************** - * MCI_MsgMapper32ATo16_Create [internal] - * - * Helper for MCI_MapMsg32ATo16. - * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit - * segmented pointer. - * map contains a list of action to be performed for the mapping (see list - * above) - * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area. - */ -static WINMM_MapType MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep) -{ - void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 ); - LPBYTE p16, p32; - - if (!lp) { - return WINMM_MAP_NOMEM; - } - p32 = (LPBYTE)(*ptr); - if (keep) { - *(void**)lp = *ptr; - p16 = (LPBYTE)lp + sizeof(void**); - *ptr = (char*)MapLS(lp) + sizeof(void**); - } else { - p16 = lp; - *ptr = (void*)MapLS(lp); - } - - if (map == 0) { - memcpy(p16, p32, size16); - } else { - unsigned nibble; - unsigned sz; - - while (map & 0xF) { - nibble = map & 0xF; - if (nibble & 0x8) { - sz = (nibble & 7) + 1; - memcpy(p16, p32, sz); - p16 += sz; - p32 += sz; - size16 -= sz; /* DEBUG only */ - } else { - switch (nibble) { - case 0x1: - *(LPINT16)p16 = *(LPINT)p32; - p16 += sizeof(INT16); - p32 += sizeof(INT); - size16 -= sizeof(INT16); - break; - case 0x2: - *(LPUINT16)p16 = *(LPUINT)p32; - p16 += sizeof(UINT16); - p32 += sizeof(UINT); - size16 -= sizeof(UINT16); - break; - case 0x6: - *(LPDWORD)p16 = 0; - p16 += sizeof(DWORD); - p32 += sizeof(DWORD); - size16 -= sizeof(DWORD); - break; - case 0x7: - *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 ); - p16 += sizeof(SEGPTR); - p32 += sizeof(LPSTR); - size16 -= sizeof(SEGPTR); - break; - default: - FIXME("Unknown nibble for mapping (%x)\n", nibble); - } - } - map >>= 4; - } - if (size16 != 0) /* DEBUG only */ - FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); - } - return WINMM_MAP_OKMEM; -} - -/************************************************************************** - * MCI_MsgMapper32ATo16_Destroy [internal] - * - * Helper for MCI_UnMapMsg32ATo16. - */ -static WINMM_MapType MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept) -{ - if (ptr) { - void* msg16 = MapSL((SEGPTR)ptr); - void* alloc; - LPBYTE p32, p16; - unsigned nibble; - - UnMapLS( (SEGPTR)ptr ); - if (kept) { - alloc = (char*)msg16 - sizeof(void**); - p32 = *(void**)alloc; - p16 = msg16; - - if (map == 0) { - memcpy(p32, p16, size16); - } else { - while (map & 0xF) { - nibble = map & 0xF; - if (nibble & 0x8) { - memcpy(p32, p16, (nibble & 7) + 1); - p16 += (nibble & 7) + 1; - p32 += (nibble & 7) + 1; - size16 -= (nibble & 7) + 1; - } else { - switch (nibble) { - case 0x1: - *(LPINT)p32 = *(LPINT16)p16; - p16 += sizeof(INT16); - p32 += sizeof(INT); - size16 -= sizeof(INT16); - break; - case 0x2: - *(LPUINT)p32 = *(LPUINT16)p16; - p16 += sizeof(UINT16); - p32 += sizeof(UINT); - size16 -= sizeof(UINT16); - break; - case 0x6: - p16 += sizeof(UINT); - p32 += sizeof(UINT); - size16 -= sizeof(UINT); - break; - case 0x7: - UnMapLS( *(SEGPTR *)p16 ); - p16 += sizeof(SEGPTR); - p32 += sizeof(char*); - size16 -= sizeof(SEGPTR); - break; - default: - FIXME("Unknown nibble for mapping (%x)\n", nibble); - } - } - map >>= 4; - } - if (size16 != 0) /* DEBUG only */ - FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); - } - } else { - alloc = msg16; - } - - HeapFree( GetProcessHeap(), 0, alloc ); - } - return WINMM_MAP_OK; -} - -/************************************************************************** - * MCI_MapMsg32ATo16 [internal] - * - * Map a 32-A bit MCI message to a 16 bit MCI message. - */ -static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam) -{ - int size; - BOOLEAN keep = FALSE; - DWORD map = 0; - - if (*lParam == 0) - return WINMM_MAP_OK; - - /* FIXME: to add also (with seg/linear modifications to do): - * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE - * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO - */ - switch (wMsg) { - case MCI_BREAK: - size = sizeof(MCI_BREAK_PARMS); - break; - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - size = sizeof(MCI_GENERIC_PARMS); - break; - /* case MCI_COPY: */ - case MCI_CUE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_CUT:*/ - case MCI_DELETE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break; - case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_ESCAPE: */ - case MCI_FREEZE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_GETDEVCAPS: - keep = TRUE; - size = sizeof(MCI_GETDEVCAPS_PARMS); - break; - /* case MCI_INDEX: */ - case MCI_INFO: - { - LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam); - LPMCI_INFO_PARMS16 mip16; - - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break; - default: size = sizeof(MCI_INFO_PARMS16); break; - } - mip16 = HeapAlloc( GetProcessHeap(), 0, size); - if (mip16) - { - mip16->dwCallback = mip32a->dwCallback; - mip16->lpstrReturn = MapLS( mip32a->lpstrReturn ); - mip16->dwRetSize = mip32a->dwRetSize; - if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) { - ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem; - } - } else { - return WINMM_MAP_NOMEM; - } - *lParam = MapLS(mip16); - } - return WINMM_MAP_OKMEM; - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_OPEN: - case MCI_OPEN_DRIVER: - { - LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam); - char* ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD)); - LPMCI_OPEN_PARMS16 mop16; - - - if (ptr) { - *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a; - mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA)); - mop16->dwCallback = mop32a->dwCallback; - mop16->wDeviceID = mop32a->wDeviceID; - if (dwFlags & MCI_OPEN_TYPE) { - if (dwFlags & MCI_OPEN_TYPE_ID) { - /* dword "transparent" value */ - mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType; - } else { - /* string */ - mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType ); - } - } else { - /* nuthin' */ - mop16->lpstrDeviceType = 0; - } - if (dwFlags & MCI_OPEN_ELEMENT) { - if (dwFlags & MCI_OPEN_ELEMENT_ID) { - mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName; - } else { - mop16->lpstrElementName = MapLS( mop32a->lpstrElementName ); - } - } else { - mop16->lpstrElementName = 0; - } - if (dwFlags & MCI_OPEN_ALIAS) { - mop16->lpstrAlias = MapLS( mop32a->lpstrAlias ); - } else { - mop16->lpstrAlias = 0; - } - /* copy extended information if any... - * FIXME: this may seg fault if initial structure does not contain them and - * the reads after msip16 fail under LDT limits... - * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and - * should not take care of extended parameters, and should be used by MCI_Open - * to fetch uDevType. When, this is known, the mapping for sending the - * MCI_OPEN_DRIVER shall be done depending on uDevType. - */ - memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA); - } - return WINMM_MAP_OKMEM; - /* case MCI_PASTE:*/ - case MCI_PAUSE: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_PLAY: - size = sizeof(MCI_PLAY_PARMS); - break; - case MCI_PUT: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_REALIZE: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_RECORD: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_RECORD_PARMS); break; - } - break; - case MCI_RESUME: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_SEEK: - switch (uDevType) { - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_SEEK_PARMS); break; - } - break; - case MCI_SET: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break; - /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned, - * so not doing anything should work... - */ - case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break; - default: size = sizeof(MCI_SET_PARMS); break; - } - break; - case MCI_SETAUDIO: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - /* case MCI_SOUND:*/ - case MCI_SPIN: - size = sizeof(MCI_SET_PARMS); - break; - case MCI_STATUS: - keep = TRUE; - switch (uDevType) { - /* FIXME: - * don't know if buffer for value is the one passed through lpstrDevice - * or is provided by MCI driver. - * Assuming solution 2: provided by MCI driver, so zeroing on entry - */ - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_STATUS_PARMS); break; - } - break; - case MCI_STEP: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_STOP: - size = sizeof(MCI_SET_PARMS); - break; - case MCI_SYSINFO: - { - LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam); - LPMCI_SYSINFO_PARMS16 msip16; - char* ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) ); - - if (ptr) { - *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a; - msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA)); - - msip16->dwCallback = msip32a->dwCallback; - msip16->lpstrReturn = MapLS( msip32a->lpstrReturn ); - msip16->dwRetSize = msip32a->dwRetSize; - msip16->dwNumber = msip32a->dwNumber; - msip16->wDeviceType = msip32a->wDeviceType; - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA); - } - return WINMM_MAP_OKMEM; - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_UPDATE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_WHERE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_WINDOW: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case DRV_OPEN: - { - LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam); - LPMCI_OPEN_DRIVER_PARMS16 modp16; - char *ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16)); - - if (ptr) { - *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a; - modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA)); - modp16->wDeviceID = modp32a->wDeviceID; - modp16->lpstrParams = MapLS( modp32a->lpstrParams ); - /* other fields are gonna be filled by the driver, don't copy them */ - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA); - } - return WINMM_MAP_OKMEM; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - return WINMM_MAP_OK; - - default: - FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); - return WINMM_MAP_MSGERROR; - } - return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep); -} - -/************************************************************************** - * MCI_UnMapMsg32ATo16 [internal] - */ -static WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam) -{ - int size = 0; - BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */ - DWORD map = 0; - - switch (wMsg) { - case MCI_BREAK: - break; - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - break; - /* case MCI_COPY: */ - case MCI_CUE: - break; - /* case MCI_CUT: */ - case MCI_DELETE: - break; - /* case MCI_ESCAPE: */ - case MCI_FREEZE: - break; - case MCI_GETDEVCAPS: - kept = TRUE; - size = sizeof(MCI_GETDEVCAPS_PARMS); - break; - /* case MCI_INDEX: */ - case MCI_INFO: - { - LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam); - UnMapLS( lParam ); - UnMapLS( mip16->lpstrReturn ); - HeapFree( GetProcessHeap(), 0, mip16 ); - } - return WINMM_MAP_OK; - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_OPEN: - case MCI_OPEN_DRIVER: - if (lParam) { - LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam); - LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA)); - UnMapLS( lParam ); - mop32a->wDeviceID = mop16->wDeviceID; - if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID)) - UnMapLS( mop16->lpstrDeviceType ); - if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID)) - UnMapLS( mop16->lpstrElementName ); - if (dwFlags & MCI_OPEN_ALIAS) - UnMapLS( mop16->lpstrAlias ); - HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) ); - } - return WINMM_MAP_OK; - /* case MCI_PASTE:*/ - case MCI_PAUSE: - break; - case MCI_PLAY: - break; - case MCI_PUT: - break; - case MCI_REALIZE: - break; - case MCI_RECORD: - break; - case MCI_RESUME: - break; - case MCI_SEEK: - break; - case MCI_SET: - break; - case MCI_SETAUDIO: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - } - break; - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - /* case MCI_SOUND:*/ - case MCI_SPIN: - break; - case MCI_STATUS: - kept = TRUE; - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: - if (lParam) { - LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam); - LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA)); - - UnMapLS( lParam ); - if (mdsp16) { - mdsp32a->dwReturn = mdsp16->dwReturn; - if (dwFlags & MCI_DGV_STATUS_DISKSPACE) { - TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive); - TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive)); - UnMapLS( mdsp16->lpstrDrive ); - } - HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) ); - } else { - return WINMM_MAP_NOMEM; - } - } - return WINMM_MAP_OKMEM; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_STATUS_PARMS); break; - } - break; - case MCI_STEP: - break; - case MCI_STOP: - break; - case MCI_SYSINFO: - if (lParam) { - LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam); - LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA)); - - UnMapLS( lParam ); - if (msip16) { - msip16->dwCallback = msip32a->dwCallback; - UnMapLS( msip16->lpstrReturn ); - HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) ); - } else { - return WINMM_MAP_NOMEM; - } - } - return WINMM_MAP_OKMEM; - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - break; - case MCI_UPDATE: - break; - case MCI_WHERE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; - default: break; - } - break; - case MCI_WINDOW: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break; - default: break; - } - /* FIXME: see map function */ - break; - - case DRV_OPEN: - if (lParam) { - LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam); - LPMCI_OPEN_DRIVER_PARMSA modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA)); - - UnMapLS( lParam ); - modp32a->wCustomCommandTable = modp16->wCustomCommandTable; - modp32a->wType = modp16->wType; - UnMapLS( modp16->lpstrParams ); - HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) ); - } - return WINMM_MAP_OK; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - default: - FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); - return WINMM_MAP_MSGERROR; - } - return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept); -} -#endif - -/************************************************************************** - * MCI_MapMsg16To32W [internal] - */ -static WINMM_MapType MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam) -{ - if (*lParam == 0) - return WINMM_MAP_OK; - /* FIXME: to add also (with seg/linear modifications to do): - * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE - * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO - */ - switch (wMsg) { - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - case MCI_COPY: - case MCI_CUE: - case MCI_CUT: - case MCI_DELETE: - case MCI_FREEZE: - case MCI_GETDEVCAPS: - /* case MCI_INDEX: */ - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_PASTE: - case MCI_PAUSE: - case MCI_PLAY: - case MCI_PUT: - case MCI_REALIZE: - case MCI_RECORD: - case MCI_RESUME: - case MCI_SEEK: - case MCI_SET: - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - case MCI_SPIN: - case MCI_STATUS: /* FIXME: is wrong for digital video */ - case MCI_STEP: - case MCI_STOP: - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - case MCI_UPDATE: - case MCI_WHERE: - *lParam = (DWORD)MapSL(*lParam); - return WINMM_MAP_OK; - case MCI_WINDOW: - /* in fact, I would also need the dwFlags... to see - * which members of lParam are effectively used - */ - *lParam = (DWORD)MapSL(*lParam); - FIXME("Current mapping may be wrong\n"); - break; - case MCI_BREAK: - { - LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS)); - LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam); - - if (mbp32) { - mbp32->dwCallback = mbp16->dwCallback; - mbp32->nVirtKey = mbp16->nVirtKey; - mbp32->hwndBreak = HWND_32(mbp16->hwndBreak); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mbp32; - } - return WINMM_MAP_OKMEM; - case MCI_ESCAPE: - { - LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW)); - LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam); - - if (mvep32w) { - mvep32w->dwCallback = mvep16->dwCallback; - mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mvep32w; - } - return WINMM_MAP_OKMEM; - case MCI_INFO: - { - LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW)); - LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam); - - /* FIXME this is wrong if device is of type - * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped - */ - if (mip32w) { - *(LPMCI_INFO_PARMS16*)(mip32w) = mip16; - mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16)); - mip32w->dwCallback = mip16->dwCallback; - mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR)); - mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mip32w; - } - return WINMM_MAP_OKMEM; - case MCI_OPEN: - case MCI_OPEN_DRIVER: - { - LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD)); - LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam); - - if (mop32w) { - *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16; - mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16)); - mop32w->dwCallback = mop16->dwCallback; - mop32w->wDeviceID = mop16->wDeviceID; - if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE) - mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType)); - else - mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType; - if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT) - mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName)); - else - mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName; - if( ( dwFlags & MCI_OPEN_ALIAS)) - mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias)); - else - mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias; - /* copy extended information if any... - * FIXME: this may seg fault if initial structure does not contain them and - * the reads after msip16 fail under LDT limits... - * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and - * should not take care of extended parameters, and should be used by MCI_Open - * to fetch uDevType. When, this is known, the mapping for sending the - * MCI_OPEN_DRIVER shall be done depending on uDevType. - */ - memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mop32w; - } - return WINMM_MAP_OKMEM; - case MCI_SYSINFO: - { - LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW)); - LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam); - - if (msip32w) { - *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16; - msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16)); - msip32w->dwCallback = msip16->dwCallback; - msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR)); - msip32w->dwRetSize = msip16->dwRetSize; - msip32w->dwNumber = msip16->dwNumber; - msip32w->wDeviceType = msip16->wDeviceType; - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)msip32w; - } - return WINMM_MAP_OKMEM; - case MCI_SOUND: - { - LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW)); - LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam); - - if (mbp32) { - mbp32->dwCallback = mbp16->dwCallback; - mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (DWORD)mbp32; - } - return WINMM_MAP_OKMEM; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_OPEN: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - default: - FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); - } - return WINMM_MAP_MSGERROR; -} - -/************************************************************************** - * MCI_UnMapMsg16To32W [internal] - */ -static WINMM_MapType MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam) -{ - switch (wMsg) { - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - case MCI_COPY: - case MCI_CUE: - case MCI_CUT: - case MCI_DELETE: - case MCI_FREEZE: - case MCI_GETDEVCAPS: - /* case MCI_INDEX: */ - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_PASTE: - case MCI_PAUSE: - case MCI_PLAY: - case MCI_PUT: - case MCI_REALIZE: - case MCI_RECORD: - case MCI_RESUME: - case MCI_SEEK: - case MCI_SET: - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - case MCI_SPIN: - case MCI_STATUS: - case MCI_STEP: - case MCI_STOP: - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - case MCI_UPDATE: - case MCI_WHERE: - return WINMM_MAP_OK; - - case MCI_WINDOW: - /* FIXME ?? see Map function */ - return WINMM_MAP_OK; - - case MCI_BREAK: - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - return WINMM_MAP_OK; - case MCI_ESCAPE: - if (lParam) { - LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam; - HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand); - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - } - return WINMM_MAP_OK; - case MCI_INFO: - if (lParam) { - LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam; - LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16)); - - WideCharToMultiByte(CP_ACP, 0, - mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR), - MapSL(mip16->lpstrReturn), mip16->dwRetSize, - NULL, NULL); - HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn); - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - } - return WINMM_MAP_OK; - case MCI_SYSINFO: - if (lParam) { - LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam; - LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16)); - - WideCharToMultiByte(CP_ACP, 0, - msip32w->lpstrReturn, msip32w->dwRetSize, - MapSL(msip16->lpstrReturn), msip16->dwRetSize, - NULL, NULL); - HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn); - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - } - return WINMM_MAP_OK; - case MCI_SOUND: - if (lParam) { - LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam; - HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName); - HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); - } - return WINMM_MAP_OK; - case MCI_OPEN: - case MCI_OPEN_DRIVER: - if (lParam) { - LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam; - LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16)); - - mop16->wDeviceID = mop32w->wDeviceID; - if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE) - HeapFree(GetProcessHeap(), 0, mop32w->lpstrDeviceType); - if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT) - HeapFree(GetProcessHeap(), 0, mop32w->lpstrElementName); - if( ( dwFlags & MCI_OPEN_ALIAS)) - HeapFree(GetProcessHeap(), 0, mop32w->lpstrAlias); - if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16)))) - FIXME("bad free line=%d\n", __LINE__); - } - return WINMM_MAP_OK; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_OPEN: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - default: - FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); - } - return WINMM_MAP_MSGERROR; -} - -/* - * 0000 stop - * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4 - * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4 - * 0100 - * 0101 - * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4 - * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4 - * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1 - */ - -/************************************************************************** - * MCI_MsgMapper32WTo16_Create [internal] - * - * Helper for MCI_MapMsg32WTo16. - * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit - * segmented pointer. - * map contains a list of action to be performed for the mapping (see list - * above) - * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area. - */ -static WINMM_MapType MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep) -{ - void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 ); - LPBYTE p16, p32; - - if (!lp) { - return WINMM_MAP_NOMEM; - } - p32 = (LPBYTE)(*ptr); - if (keep) { - *(void**)lp = *ptr; - p16 = (LPBYTE)lp + sizeof(void**); - *ptr = (char*)MapLS(lp) + sizeof(void**); - } else { - p16 = lp; - *ptr = (void*)MapLS(lp); - } - - if (map == 0) { - memcpy(p16, p32, size16); - } else { - unsigned nibble; - unsigned sz; - - while (map & 0xF) { - nibble = map & 0xF; - if (nibble & 0x8) { - sz = (nibble & 7) + 1; - memcpy(p16, p32, sz); - p16 += sz; - p32 += sz; - size16 -= sz; /* DEBUG only */ - } else { - switch (nibble) { - case 0x1: - *(LPINT16)p16 = *(LPINT)p32; - p16 += sizeof(INT16); - p32 += sizeof(INT); - size16 -= sizeof(INT16); - break; - case 0x2: - *(LPUINT16)p16 = *(LPUINT)p32; - p16 += sizeof(UINT16); - p32 += sizeof(UINT); - size16 -= sizeof(UINT16); - break; - case 0x6: - *(LPDWORD)p16 = 0; - p16 += sizeof(DWORD); - p32 += sizeof(DWORD); - size16 -= sizeof(DWORD); - break; - case 0x7: - *(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) ); - p16 += sizeof(SEGPTR); - p32 += sizeof(LPSTR); - size16 -= sizeof(SEGPTR); - break; - default: - FIXME("Unknown nibble for mapping (%x)\n", nibble); - } - } - map >>= 4; - } - if (size16 != 0) /* DEBUG only */ - FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); - } - return WINMM_MAP_OKMEM; -} - -/************************************************************************** - * MCI_MsgMapper32WTo16_Destroy [internal] - * - * Helper for MCI_UnMapMsg32WTo16. - */ -static WINMM_MapType MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept) -{ - if (ptr) { - void* msg16 = MapSL((SEGPTR)ptr); - void* alloc; - LPBYTE p32, p16; - unsigned nibble; - - UnMapLS( (SEGPTR)ptr ); - if (kept) { - alloc = (char*)msg16 - sizeof(void**); - p32 = *(void**)alloc; - p16 = msg16; - - if (map == 0) { - memcpy(p32, p16, size16); - } else { - while (map & 0xF) { - nibble = map & 0xF; - if (nibble & 0x8) { - memcpy(p32, p16, (nibble & 7) + 1); - p16 += (nibble & 7) + 1; - p32 += (nibble & 7) + 1; - size16 -= (nibble & 7) + 1; - } else { - switch (nibble) { - case 0x1: - *(LPINT)p32 = *(LPINT16)p16; - p16 += sizeof(INT16); - p32 += sizeof(INT); - size16 -= sizeof(INT16); - break; - case 0x2: - *(LPUINT)p32 = *(LPUINT16)p16; - p16 += sizeof(UINT16); - p32 += sizeof(UINT); - size16 -= sizeof(UINT16); - break; - case 0x6: - p16 += sizeof(UINT); - p32 += sizeof(UINT); - size16 -= sizeof(UINT); - break; - case 0x7: - HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16)); - UnMapLS( *(SEGPTR *)p16 ); - p16 += sizeof(SEGPTR); - p32 += sizeof(char*); - size16 -= sizeof(SEGPTR); - break; - default: - FIXME("Unknown nibble for mapping (%x)\n", nibble); - } - } - map >>= 4; - } - if (size16 != 0) /* DEBUG only */ - FIXME("Mismatch between 16 bit struct size and map nibbles serie\n"); - } - } else { - alloc = msg16; - } - - HeapFree( GetProcessHeap(), 0, alloc ); - } - return WINMM_MAP_OK; -} - -/************************************************************************** - * MCI_MapMsg32WTo16 [internal] - * - * Map a 32W bit MCI message to a 16 bit MCI message. - */ -static WINMM_MapType MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam) -{ - int size; - BOOLEAN keep = FALSE; - DWORD map = 0; - - if (*lParam == 0) - return WINMM_MAP_OK; - - /* FIXME: to add also (with seg/linear modifications to do): - * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE - * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO - */ - switch (wMsg) { - case MCI_BREAK: - size = sizeof(MCI_BREAK_PARMS); - break; - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - size = sizeof(MCI_GENERIC_PARMS); - break; - /* case MCI_COPY: */ - case MCI_CUE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_CUT:*/ - case MCI_DELETE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break; - case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_ESCAPE: */ - case MCI_FREEZE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_GETDEVCAPS: - keep = TRUE; - size = sizeof(MCI_GETDEVCAPS_PARMS); - break; - /* case MCI_INDEX: */ - case MCI_INFO: - { - LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)(*lParam); - char* ptr; - LPMCI_INFO_PARMS16 mip16; - - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break; - default: size = sizeof(MCI_INFO_PARMS16); break; - } - ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size); - if (ptr) - { - *(LPMCI_INFO_PARMSW*)ptr = mip32w; - mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW)); - mip16->dwCallback = mip32w->dwCallback; - mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) ); - mip16->dwRetSize = mip32w->dwRetSize / sizeof(WCHAR); - if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) { - ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem; - } - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW); - } - return WINMM_MAP_OKMEM; - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_OPEN: - case MCI_OPEN_DRIVER: - { - LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)(*lParam); - char* ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD)); - LPMCI_OPEN_PARMS16 mop16; - - - if (ptr) { - *(LPMCI_OPEN_PARMSW*)(ptr) = mop32w; - mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW)); - mop16->dwCallback = mop32w->dwCallback; - mop16->wDeviceID = mop32w->wDeviceID; - if (dwFlags & MCI_OPEN_TYPE) { - if (dwFlags & MCI_OPEN_TYPE_ID) { - /* dword "transparent" value */ - mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType; - } else { - /* string */ - mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) ); - } - } else { - /* nuthin' */ - mop16->lpstrDeviceType = 0; - } - if (dwFlags & MCI_OPEN_ELEMENT) { - if (dwFlags & MCI_OPEN_ELEMENT_ID) { - mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName; - } else { - mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) ); - } - } else { - mop16->lpstrElementName = 0; - } - if (dwFlags & MCI_OPEN_ALIAS) { - mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) ); - } else { - mop16->lpstrAlias = 0; - } - /* copy extended information if any... - * FIXME: this may seg fault if initial structure does not contain them and - * the reads after msip16 fail under LDT limits... - * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and - * should not take care of extended parameters, and should be used by MCI_Open - * to fetch uDevType. When, this is known, the mapping for sending the - * MCI_OPEN_DRIVER shall be done depending on uDevType. - */ - memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD)); - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW); - } - return WINMM_MAP_OKMEM; - /* case MCI_PASTE:*/ - case MCI_PAUSE: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_PLAY: - size = sizeof(MCI_PLAY_PARMS); - break; - case MCI_PUT: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_REALIZE: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_RECORD: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_RECORD_PARMS); break; - } - break; - case MCI_RESUME: - size = sizeof(MCI_GENERIC_PARMS); - break; - case MCI_SEEK: - switch (uDevType) { - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_SEEK_PARMS); break; - } - break; - case MCI_SET: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break; - /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned, - * so not doing anything should work... - */ - case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break; - default: size = sizeof(MCI_SET_PARMS); break; - } - break; - case MCI_SETAUDIO: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - /* case MCI_SOUND:*/ - case MCI_SPIN: - size = sizeof(MCI_SET_PARMS); - break; - case MCI_STATUS: - keep = TRUE; - switch (uDevType) { - /* FIXME: - * don't know if buffer for value is the one passed through lpstrDevice - * or is provided by MCI driver. - * Assuming solution 2: provided by MCI driver, so zeroing on entry - */ - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_STATUS_PARMS); break; - } - break; - case MCI_STEP: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_STOP: - size = sizeof(MCI_SET_PARMS); - break; - case MCI_SYSINFO: - { - LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam); - LPMCI_SYSINFO_PARMS16 msip16; - char* ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) ); - - if (ptr) { - *(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w; - msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW)); - - msip16->dwCallback = msip32w->dwCallback; - msip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) ); - msip16->dwRetSize = msip32w->dwRetSize; - msip16->dwNumber = msip32w->dwNumber; - msip16->wDeviceType = msip32w->wDeviceType; - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW); - } - return WINMM_MAP_OKMEM; - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_UPDATE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_WHERE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case MCI_WINDOW: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break; - default: size = sizeof(MCI_GENERIC_PARMS); break; - } - break; - case DRV_OPEN: - { - LPMCI_OPEN_DRIVER_PARMSW modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam); - LPMCI_OPEN_DRIVER_PARMS16 modp16; - char *ptr = HeapAlloc( GetProcessHeap(), 0, - sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16)); - - if (ptr) { - *(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w; - modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW)); - modp16->wDeviceID = modp32w->wDeviceID; - modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) ); - /* other fields are gonna be filled by the driver, don't copy them */ - } else { - return WINMM_MAP_NOMEM; - } - *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW); - } - return WINMM_MAP_OKMEM; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - return WINMM_MAP_OK; - - default: - FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); - return WINMM_MAP_MSGERROR; - } - return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep); -} - -/************************************************************************** - * MCI_UnMapMsg32WTo16 [internal] - */ -static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam) -{ - int size = 0; - BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */ - DWORD map = 0; - - switch (wMsg) { - case MCI_BREAK: - break; - /* case MCI_CAPTURE */ - case MCI_CLOSE: - case MCI_CLOSE_DRIVER: - case MCI_CONFIGURE: - break; - /* case MCI_COPY: */ - case MCI_CUE: - break; - /* case MCI_CUT: */ - case MCI_DELETE: - break; - /* case MCI_ESCAPE: */ - case MCI_FREEZE: - break; - case MCI_GETDEVCAPS: - kept = TRUE; - size = sizeof(MCI_GETDEVCAPS_PARMS); - break; - /* case MCI_INDEX: */ - case MCI_INFO: - if (lParam) { - LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam); - LPMCI_INFO_PARMSW mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW)); - - MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize, - mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR)); - UnMapLS( lParam ); - UnMapLS( mip16->lpstrReturn ); - HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) ); - HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) ); - } - return WINMM_MAP_OK; - /* case MCI_MARK: */ - /* case MCI_MONITOR: */ - case MCI_OPEN: - case MCI_OPEN_DRIVER: - if (lParam) { - LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam); - LPMCI_OPEN_PARMSW mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW)); - UnMapLS( lParam ); - mop32w->wDeviceID = mop16->wDeviceID; - if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID)) - { - HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType)); - UnMapLS( mop16->lpstrDeviceType ); - } - if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID)) - { - HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName)); - UnMapLS( mop16->lpstrElementName ); - } - if (dwFlags & MCI_OPEN_ALIAS) - { - HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias)); - UnMapLS( mop16->lpstrAlias ); - } - HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) ); - } - return WINMM_MAP_OK; - /* case MCI_PASTE:*/ - case MCI_PAUSE: - break; - case MCI_PLAY: - break; - case MCI_PUT: - break; - case MCI_REALIZE: - break; - case MCI_RECORD: - break; - case MCI_RESUME: - break; - case MCI_SEEK: - break; - case MCI_SET: - break; - case MCI_SETAUDIO: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - } - break; - /* case MCI_SETTIMECODE:*/ - /* case MCI_SIGNAL:*/ - /* case MCI_SOUND:*/ - case MCI_SPIN: - break; - case MCI_STATUS: - kept = TRUE; - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: - if (lParam) { - LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam); - LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA)); - - UnMapLS( lParam ); - if (mdsp16) { - mdsp32a->dwReturn = mdsp16->dwReturn; - if (dwFlags & MCI_DGV_STATUS_DISKSPACE) { - TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive); - TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive)); - UnMapLS( mdsp16->lpstrDrive ); - } - HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) ); - } else { - return WINMM_MAP_NOMEM; - } - } - return WINMM_MAP_OKMEM; - case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM; - default: size = sizeof(MCI_STATUS_PARMS); break; - } - break; - case MCI_STEP: - break; - case MCI_STOP: - break; - case MCI_SYSINFO: - if (lParam) { - LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam); - LPMCI_SYSINFO_PARMSW msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW)); - - UnMapLS( lParam ); - if (msip16) { - MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize, - msip32w->lpstrReturn, msip32w->dwRetSize); - UnMapLS( msip16->lpstrReturn ); - HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) ); - HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) ); - } else { - return WINMM_MAP_NOMEM; - } - } - return WINMM_MAP_OKMEM; - /* case MCI_UNDO: */ - case MCI_UNFREEZE: - break; - case MCI_UPDATE: - break; - case MCI_WHERE: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break; - default: break; - } - break; - case MCI_WINDOW: - switch (uDevType) { - case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break; - case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break; - default: break; - } - /* FIXME: see map function */ - break; - case DRV_OPEN: - if (lParam) { - LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam); - LPMCI_OPEN_DRIVER_PARMSW modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW)); - - UnMapLS( lParam ); - modp32w->wCustomCommandTable = modp16->wCustomCommandTable; - modp32w->wType = modp16->wType; - HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams)); - UnMapLS( modp16->lpstrParams ); - HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) ); - } - return WINMM_MAP_OK; - case DRV_LOAD: - case DRV_ENABLE: - case DRV_CLOSE: - case DRV_DISABLE: - case DRV_FREE: - case DRV_CONFIGURE: - case DRV_QUERYCONFIGURE: - case DRV_INSTALL: - case DRV_REMOVE: - case DRV_EXITSESSION: - case DRV_EXITAPPLICATION: - case DRV_POWER: - FIXME("This is a hack\n"); - return WINMM_MAP_OK; - - default: - FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); - return WINMM_MAP_MSGERROR; - } - return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept); -} - -void MMDRV_Init16(void) -{ -#define A(_x,_y) MMDRV_InstallMap(_x, \ -MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \ -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; - - pFnMciMapMsg16To32W = MCI_MapMsg16To32W; - pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W; - pFnMciMapMsg32WTo16 = MCI_MapMsg32WTo16; - pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16; -} diff --git a/reactos/dll/win32/winmm/mmio.c b/reactos/dll/win32/winmm/mmio.c index a15a68a1364..b774003abb8 100644 --- a/reactos/dll/win32/winmm/mmio.c +++ b/reactos/dll/win32/winmm/mmio.c @@ -2,7 +2,7 @@ * MMIO functions * * Copyright 1998 Andrew Taylor - * Copyright 1998 Ove Kåven + * Copyright 1998 Ove KÃ¥ven * Copyright 2000,2002 Eric Pouech * * This library is free software; you can redistribute it and/or @@ -17,7 +17,7 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* Still to be done: @@ -45,7 +45,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(mmio); -LRESULT (*pFnMmioCallback16)(DWORD,LPMMIOINFO,UINT,LPARAM,LPARAM) /* = NULL */; +static WINE_MMIO *MMIOList; /************************************************************************** * mmioDosIOProc [internal] @@ -222,13 +222,13 @@ static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage, } } -/* This array will be the entire list for most apps +/* This array will be the entire list for most apps * Note that temporary ioProcs will be stored with a 0 fourCC code */ static struct IOProcList defaultProcs[] = { - {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, MMIO_PROC_32A, 0}, - {NULL, FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, MMIO_PROC_32A, 0}, + {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, FALSE, 0}, + {NULL, FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, FALSE, 0}, }; static struct IOProcList* pIOProcListAnchor = &defaultProcs[0]; @@ -253,14 +253,14 @@ static struct IOProcList* MMIO_FindProcNode(FOURCC fccIOProc) /**************************************************************** * MMIO_InstallIOProc [INTERNAL] */ -LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, - DWORD dwFlags, enum mmioProcType type) +static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, + DWORD dwFlags, BOOL is_unicode) { LPMMIOPROC lpProc = NULL; struct IOProcList* pListNode; struct IOProcList** ppListNode; - TRACE("(%08lx, %p, %08lX, %i)\n", fccIOProc, pIOProc, dwFlags, type); + TRACE("(%08x, %p, %08X, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi"); if (dwFlags & MMIO_GLOBALPROC) FIXME("Global procedures not implemented\n"); @@ -274,7 +274,7 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, /* Fill in this node */ pListNode->fourCC = fccIOProc; pListNode->pIOProc = pIOProc; - pListNode->type = type; + pListNode->is_unicode = is_unicode; pListNode->count = 0; /* Stick it on the end of the list */ @@ -296,9 +296,9 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, * let the user delete anyway, that's okay */ ppListNode = &pIOProcListAnchor; - while ((*ppListNode) && - ((fccIOProc != 0) ? - (*ppListNode)->fourCC != fccIOProc : + while ((*ppListNode) && + ((fccIOProc != 0) ? + (*ppListNode)->fourCC != fccIOProc : (*ppListNode)->pIOProc != pIOProc)) ppListNode = &((*ppListNode)->pNext); @@ -312,7 +312,7 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, } /* remove it, but only if it isn't builtin */ if ((*ppListNode) >= defaultProcs && - (*ppListNode) < defaultProcs + sizeof(defaultProcs)) { + (*ppListNode) < defaultProcs + sizeof(defaultProcs) / sizeof(defaultProcs[0])) { WARN("Tried to remove built-in mmio proc. Skipping\n"); } else { /* Okay, nuke it */ @@ -339,39 +339,27 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, */ static LRESULT send_message(struct IOProcList* ioProc, LPMMIOINFO mmioinfo, DWORD wMsg, LPARAM lParam1, - LPARAM lParam2, enum mmioProcType type) + LPARAM lParam2, BOOL is_unicode) { LRESULT result = MMSYSERR_ERROR; LPARAM lp1 = lParam1, lp2 = lParam2; if (!ioProc) { - ERR("brrr\n"); - result = MMSYSERR_INVALPARAM; + ERR("ioProc NULL\n"); + return MMSYSERR_INVALPARAM; } - switch (ioProc->type) { - case MMIO_PROC_16: - if (pFnMmioCallback16) - result = pFnMmioCallback16((DWORD)ioProc->pIOProc, - mmioinfo, wMsg, lp1, lp2); - break; - case MMIO_PROC_32A: - case MMIO_PROC_32W: - if (ioProc->type != type) { - /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */ - FIXME("NIY 32 A<=>W mapping\n"); - } - result = (ioProc->pIOProc)((LPSTR)mmioinfo, wMsg, lp1, lp2); + if (ioProc->is_unicode != is_unicode) { + /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */ + FIXME("NIY 32 A<=>W mapping\n"); + } + result = (ioProc->pIOProc)((LPSTR)mmioinfo, wMsg, lp1, lp2); #if 0 - if (ioProc->type != type) { + if (ioProc->is_unicode != is_unicode) { /* unmap (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */ } #endif - break; - default: - FIXME("Internal error\n"); - } return result; } @@ -436,16 +424,16 @@ static FOURCC MMIO_ParseExtA(LPCSTR szFileName) * * Retrieves the mmio object from current process */ -LPWINE_MMIO MMIO_Get(HMMIO h) +static LPWINE_MMIO MMIO_Get(HMMIO h) { LPWINE_MMIO wm = NULL; - EnterCriticalSection(&WINMM_IData.cs); - for (wm = WINMM_IData.lpMMIO; wm; wm = wm->lpNext) { + EnterCriticalSection(&WINMM_cs); + for (wm = MMIOList; wm; wm = wm->lpNext) { if (wm->info.hmmio == h) break; } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); return wm; } @@ -461,13 +449,13 @@ static LPWINE_MMIO MMIO_Create(void) wm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MMIO)); if (wm) { - EnterCriticalSection(&WINMM_IData.cs); + EnterCriticalSection(&WINMM_cs); /* lookup next unallocated WORD handle, with a non NULL value */ while (++MMIO_counter == 0 || MMIO_Get((HMMIO)(ULONG_PTR)MMIO_counter)); wm->info.hmmio = (HMMIO)(ULONG_PTR)MMIO_counter; - wm->lpNext = WINMM_IData.lpMMIO; - WINMM_IData.lpMMIO = wm; - LeaveCriticalSection(&WINMM_IData.cs); + wm->lpNext = MMIOList; + MMIOList = wm; + LeaveCriticalSection(&WINMM_cs); } return wm; } @@ -481,9 +469,9 @@ static BOOL MMIO_Destroy(LPWINE_MMIO wm) { LPWINE_MMIO* m; - EnterCriticalSection(&WINMM_IData.cs); + EnterCriticalSection(&WINMM_cs); /* search for the matching one... */ - m = &(WINMM_IData.lpMMIO); + m = &MMIOList; while (*m && *m != wm) m = &(*m)->lpNext; /* ...and destroy */ if (*m) { @@ -491,7 +479,7 @@ static BOOL MMIO_Destroy(LPWINE_MMIO wm) HeapFree(GetProcessHeap(), 0, wm); wm = NULL; } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); return wm ? FALSE : TRUE; } @@ -504,11 +492,10 @@ static MMRESULT MMIO_Flush(WINE_MMIO* wm, UINT uFlags) /* not quite sure what to do here, but I'll guess */ if (wm->info.dwFlags & MMIO_DIRTY) { /* FIXME: error handling */ - send_message(wm->ioProc, &wm->info, MMIOM_SEEK, - wm->info.lBufOffset, SEEK_SET, MMIO_PROC_32A); + send_message(wm->ioProc, &wm->info, MMIOM_SEEK, wm->info.lBufOffset, SEEK_SET, FALSE); send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)wm->info.pchBuffer, - wm->info.pchNext - wm->info.pchBuffer, MMIO_PROC_32A); + wm->info.pchNext - wm->info.pchBuffer, FALSE); } if (uFlags & MMIO_EMPTYBUF) wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer; @@ -525,9 +512,9 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read) { LONG size = wm->info.cchBuffer; - TRACE("bo=%lx do=%lx of=%lx\n", + TRACE("bo=%x do=%x of=%lx\n", wm->info.lBufOffset, wm->info.lDiskOffset, - send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, MMIO_PROC_32A)); + send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, FALSE)); wm->info.lBufOffset = wm->info.lDiskOffset; wm->info.pchNext = wm->info.pchBuffer; @@ -537,7 +524,7 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read) wm->bBufferLoaded = TRUE; if (for_read) { size = send_message(wm->ioProc, &wm->info, MMIOM_READ, - (LPARAM)wm->info.pchBuffer, size, MMIO_PROC_32A); + (LPARAM)wm->info.pchBuffer, size, FALSE); if (size > 0) wm->info.pchEndRead += size; else @@ -553,11 +540,10 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read) static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer, UINT uFlags) { - TRACE("(%p %p %ld %u)\n", wm, pchBuffer, cchBuffer, uFlags); + TRACE("(%p %p %d %u)\n", wm, pchBuffer, cchBuffer, uFlags); - if (uFlags) return MMSYSERR_INVALPARAM; if (cchBuffer > 0xFFFF) - WARN("Untested handling of huge mmio buffers (%ld >= 64k)\n", cchBuffer); + WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer); if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR) return MMIOERR_CANNOTWRITE; @@ -583,7 +569,7 @@ static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer, wm->info.pchNext = wm->info.pchBuffer; wm->info.pchEndRead = wm->info.pchBuffer; wm->info.pchEndWrite = wm->info.pchBuffer + cchBuffer; - wm->info.lBufOffset = 0; + wm->info.lBufOffset = wm->info.lDiskOffset; wm->bBufferLoaded = FALSE; return MMSYSERR_NOERROR; @@ -592,13 +578,12 @@ static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer, /************************************************************************** * MMIO_Open [internal] */ -HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, - enum mmioProcType type) +static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, BOOL is_unicode) { LPWINE_MMIO wm; MMIOINFO mmioinfo; - TRACE("('%s', %p, %08lX, %d);\n", szFileName, refmminfo, dwOpenFlags, type); + TRACE("('%s', %p, %08X, %s);\n", szFileName, refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi"); if (!refmminfo) { refmminfo = &mmioinfo; @@ -607,12 +592,14 @@ HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, mmioinfo.pIOProc = NULL; mmioinfo.pchBuffer = NULL; mmioinfo.cchBuffer = 0; - type = MMIO_PROC_32A; + is_unicode = FALSE; } if (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)) { char buffer[MAX_PATH]; + if (!szFileName) + return (HMMIO)FALSE; if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer)) return (HMMIO)FALSE; if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == INVALID_FILE_ATTRIBUTES)) @@ -648,32 +635,35 @@ HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, else { wm->info.fccIOProc = refmminfo->fccIOProc; MMIO_InstallIOProc(wm->info.fccIOProc, refmminfo->pIOProc, - MMIO_INSTALLPROC, type); + MMIO_INSTALLPROC, is_unicode); if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2; assert(wm->ioProc->pIOProc == refmminfo->pIOProc); wm->bTmpIOProc = TRUE; } - wm->bBufferLoaded = FALSE; wm->ioProc->count++; + wm->info.dwFlags = dwOpenFlags; if (dwOpenFlags & MMIO_ALLOCBUF) { - if ((refmminfo->wErrorRet = MMIO_SetBuffer(wm, NULL, MMIO_DEFAULTBUFFER, 0))) + refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer, + refmminfo->cchBuffer ? refmminfo->cchBuffer : MMIO_DEFAULTBUFFER, 0); + if (refmminfo->wErrorRet != MMSYSERR_NOERROR) goto error1; - } else if (wm->info.fccIOProc == FOURCC_MEM) { + } else { refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer, refmminfo->cchBuffer, 0); if (refmminfo->wErrorRet != MMSYSERR_NOERROR) goto error1; - wm->bBufferLoaded = TRUE; - } /* else => unbuffered, wm->info.pchBuffer == NULL */ + } + + if (wm->info.fccIOProc == FOURCC_MEM && !(wm->info.dwFlags & MMIO_ALLOCBUF)) + wm->bBufferLoaded = TRUE; /* see mmioDosIOProc for that one */ wm->info.adwInfo[0] = refmminfo->adwInfo[0]; - wm->info.dwFlags = dwOpenFlags; /* call IO proc to actually open file */ refmminfo->wErrorRet = send_message(wm->ioProc, &wm->info, MMIOM_OPEN, - (LPARAM)szFileName, 0, MMIO_PROC_32A); + (LPARAM)szFileName, 0, FALSE); /* grab file size, when possible */ wm->dwFileSize = GetFileSize((HANDLE)wm->info.adwInfo[0], NULL); @@ -704,7 +694,7 @@ HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo, WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL ); } - ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, MMIO_PROC_32W); + ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, TRUE); HeapFree(GetProcessHeap(), 0, szFn); return ret; @@ -716,7 +706,7 @@ HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo, HMMIO WINAPI mmioOpenA(LPSTR szFileName, MMIOINFO* lpmmioinfo, DWORD dwOpenFlags) { - return MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, MMIO_PROC_32A); + return MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, FALSE); } /************************************************************************** @@ -735,8 +725,7 @@ MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags) if ((result = MMIO_Flush(wm, 0)) != MMSYSERR_NOERROR) return result; - result = send_message(wm->ioProc, &wm->info, MMIOM_CLOSE, - uFlags, 0, MMIO_PROC_32A); + result = send_message(wm->ioProc, &wm->info, MMIOM_CLOSE, uFlags, 0, FALSE); MMIO_SetBuffer(wm, NULL, 0, 0); @@ -744,7 +733,7 @@ MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags) if (wm->bTmpIOProc) MMIO_InstallIOProc(wm->info.fccIOProc, wm->ioProc->pIOProc, - MMIO_REMOVEPROC, wm->ioProc->type); + MMIO_REMOVEPROC, wm->ioProc->is_unicode); MMIO_Destroy(wm); @@ -759,15 +748,14 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch) LPWINE_MMIO wm; LONG count; - TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); + TRACE("(%p, %p, %d);\n", hmmio, pch, cch); if ((wm = MMIO_Get(hmmio)) == NULL) return -1; /* unbuffered case first */ if (!wm->info.pchBuffer) - return send_message(wm->ioProc, &wm->info, MMIOM_READ, - (LPARAM)pch, cch, MMIO_PROC_32A); + return send_message(wm->ioProc, &wm->info, MMIOM_READ, (LPARAM)pch, cch, FALSE); /* first try from current buffer */ if (wm->info.pchNext != wm->info.pchEndRead) { @@ -797,7 +785,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch) } } - TRACE("count=%ld\n", count); + TRACE("count=%d\n", count); return count; } @@ -809,7 +797,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch) LPWINE_MMIO wm; LONG count; - TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); + TRACE("(%p, %p, %d);\n", hmmio, pch, cch); if ((wm = MMIO_Get(hmmio)) == NULL) return -1; @@ -847,12 +835,11 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch) } count = bytesW; } else { - count = send_message(wm->ioProc, &wm->info, MMIOM_WRITE, - (LPARAM)pch, cch, MMIO_PROC_32A); + count = send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)pch, cch, FALSE); wm->info.lBufOffset = wm->info.lDiskOffset; } - TRACE("bytes written=%ld\n", count); + TRACE("bytes written=%d\n", count); return count; } @@ -864,15 +851,14 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin) LPWINE_MMIO wm; LONG offset; - TRACE("(%p, %08lX, %d);\n", hmmio, lOffset, iOrigin); + TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin); if ((wm = MMIO_Get(hmmio)) == NULL) return MMSYSERR_INVALHANDLE; /* not buffered, direct seek on file */ if (!wm->info.pchBuffer) - return send_message(wm->ioProc, &wm->info, MMIOM_SEEK, - lOffset, iOrigin, MMIO_PROC_32A); + return send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lOffset, iOrigin, FALSE); switch (iOrigin) { case SEEK_SET: @@ -911,14 +897,14 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin) /* this also sets the wm->info.lDiskOffset field */ send_message(wm->ioProc, &wm->info, MMIOM_SEEK, (offset / wm->info.cchBuffer) * wm->info.cchBuffer, - SEEK_SET, MMIO_PROC_32A) == -1) + SEEK_SET, FALSE) == -1) return -1; MMIO_GrabNextBuffer(wm, TRUE); } wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset); - TRACE("=> %ld\n", offset); + TRACE("=> %d\n", offset); return offset; } @@ -934,10 +920,7 @@ MMRESULT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags) if ((wm = MMIO_Get(hmmio)) == NULL) return MMSYSERR_INVALHANDLE; - memcpy(lpmmioinfo, &wm->info, sizeof(MMIOINFO)); - /* don't expose 16 bit ioproc:s */ - if (wm->ioProc->type != MMIO_PROC_16) - lpmmioinfo->pIOProc = wm->ioProc->pIOProc; + *lpmmioinfo = wm->info; return MMSYSERR_NOERROR; } @@ -976,7 +959,7 @@ MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT { LPWINE_MMIO wm; - TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n", + TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n", hmmio, pchBuffer, cchBuffer, uFlags); if ((wm = MMIO_Get(hmmio)) == NULL) @@ -1023,18 +1006,16 @@ MMRESULT WINAPI mmioAdvance(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags) if (uFlags == MMIO_WRITE && (lpmmioinfo->dwFlags & MMIO_DIRTY)) { - send_message(wm->ioProc, &wm->info, MMIOM_SEEK, - lpmmioinfo->lBufOffset, SEEK_SET, MMIO_PROC_32A); - send_message(wm->ioProc, &wm->info, MMIOM_WRITE, - (LPARAM)lpmmioinfo->pchBuffer, - lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, MMIO_PROC_32A); + send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lpmmioinfo->lBufOffset, SEEK_SET, FALSE); + send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)lpmmioinfo->pchBuffer, + lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, FALSE); lpmmioinfo->dwFlags &= ~MMIO_DIRTY; } if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR) return MMIOERR_CANNOTWRITE; if (lpmmioinfo) { - wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset + + wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer)); } MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ); @@ -1091,7 +1072,7 @@ FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags) LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags) { - return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, MMIO_PROC_32A); + return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, FALSE); } /************************************************************************** @@ -1100,7 +1081,7 @@ LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc, LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags) { - return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, MMIO_PROC_32W); + return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, TRUE); } /****************************************************************** @@ -1108,12 +1089,12 @@ LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc, * * */ -LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, - LPARAM lParam2, enum mmioProcType type) +static LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, + LPARAM lParam2, BOOL is_unicode) { LPWINE_MMIO wm; - TRACE("(%p, %u, %ld, %ld, %d)\n", hmmio, uMessage, lParam1, lParam2, type); + TRACE("(%p, %u, %ld, %ld, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi"); if (uMessage < MMIOM_USER) return MMSYSERR_INVALPARAM; @@ -1121,7 +1102,7 @@ LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, if ((wm = MMIO_Get(hmmio)) == NULL) return MMSYSERR_INVALHANDLE; - return send_message(wm->ioProc, &wm->info, uMessage, lParam1, lParam2, type); + return send_message(wm->ioProc, &wm->info, uMessage, lParam1, lParam2, is_unicode); } /************************************************************************** @@ -1130,7 +1111,7 @@ LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, LPARAM lParam2) { - return MMIO_SendMessage(hmmio, uMessage, lParam1, lParam2, MMIO_PROC_32A); + return MMIO_SendMessage(hmmio, uMessage, lParam1, lParam2, FALSE); } /************************************************************************** @@ -1143,17 +1124,16 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, FOURCC srchCkId; FOURCC srchType; - TRACE("(%p, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags); if (lpck == NULL) return MMSYSERR_INVALPARAM; dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld\n", dwOldPos); + TRACE("dwOldPos=%d\n", dwOldPos); if (lpckParent != NULL) { - TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset); + TRACE("seek inside parent at %d !\n", lpckParent->dwDataOffset); /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */ if (dwOldPos < lpckParent->dwDataOffset || dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) { @@ -1166,62 +1146,54 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, * examples disagree -Marcus,990216. */ + srchCkId = 0; srchType = 0; + /* find_chunk looks for 'ckid' */ if (uFlags & MMIO_FINDCHUNK) srchCkId = lpck->ckid; + /* find_riff and find_list look for 'fccType' */ - if (uFlags & MMIO_FINDLIST) { + if (uFlags & MMIO_FINDLIST) + { srchCkId = FOURCC_LIST; - srchType = lpck->fccType; + srchType = lpck->fccType; } - if (uFlags & MMIO_FINDRIFF) { + + if (uFlags & MMIO_FINDRIFF) + { srchCkId = FOURCC_RIFF; - srchType = lpck->fccType; + srchType = lpck->fccType; } - if (uFlags & (MMIO_FINDCHUNK|MMIO_FINDLIST|MMIO_FINDRIFF)) { - TRACE("searching for %.4s.%.4s\n", - (LPSTR)&srchCkId, - srchType?(LPSTR)&srchType:"any "); + TRACE("searching for %4.4s.%4.4s\n", + (LPCSTR)&srchCkId, srchType ? (LPCSTR)&srchType : "any"); - while (TRUE) { - LONG ix; + while (TRUE) + { + LONG ix; - ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)); - if (ix < 2*sizeof(DWORD)) { - mmioSeek(hmmio, dwOldPos, SEEK_SET); - WARN("return ChunkNotFound\n"); - return MMIOERR_CHUNKNOTFOUND; - } - lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD); - if (ix < lpck->dwDataOffset - dwOldPos) { - mmioSeek(hmmio, dwOldPos, SEEK_SET); - WARN("return ChunkNotFound\n"); - return MMIOERR_CHUNKNOTFOUND; - } - TRACE("ckid=%.4s fcc=%.4s cksize=%08lX !\n", - (LPSTR)&lpck->ckid, - srchType?(LPSTR)&lpck->fccType:"", - lpck->cksize); - if ((srchCkId == lpck->ckid) && - (!srchType || (srchType == lpck->fccType)) - ) - break; + ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)); + if (ix < 2*sizeof(DWORD)) + { + mmioSeek(hmmio, dwOldPos, SEEK_SET); + WARN("return ChunkNotFound\n"); + return MMIOERR_CHUNKNOTFOUND; + } - dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1); - mmioSeek(hmmio, dwOldPos, SEEK_SET); - } - } else { - /* FIXME: unverified, does it do this? */ - /* NB: This part is used by WAVE_mciOpen, among others */ - if (mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)) < 3 * sizeof(DWORD)) { - mmioSeek(hmmio, dwOldPos, SEEK_SET); - WARN("return ChunkNotFound 2nd\n"); - return MMIOERR_CHUNKNOTFOUND; - } - lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD); + lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD); + TRACE("ckid=%4.4s fcc=%4.4s cksize=%08X !\n", + (LPCSTR)&lpck->ckid, + srchType ? (LPCSTR)&lpck->fccType:"", + lpck->cksize); + if ( (!srchCkId || (srchCkId == lpck->ckid)) && + (!srchType || (srchType == lpck->fccType)) ) + break; + + dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1); + mmioSeek(hmmio, dwOldPos, SEEK_SET); } + lpck->dwFlags = 0; /* If we were looking for RIFF/LIST chunks, the final file position * is after the chunkid. If we were just looking for the chunk @@ -1230,8 +1202,11 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST) mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET); else + { mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET); - TRACE("lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n", + lpck->fccType = 0; + } + TRACE("lpck: ckid=%.4s, cksize=%d, dwDataOffset=%d fccType=%08X (%.4s)!\n", (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset, lpck->fccType, srchType?(LPSTR)&lpck->fccType:""); return MMSYSERR_NOERROR; @@ -1249,10 +1224,10 @@ MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags) TRACE("Chunk is dirty, checking if chunk's size is correct\n"); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld lpck->dwDataOffset = %ld\n", dwOldPos, lpck->dwDataOffset); + TRACE("dwOldPos=%d lpck->dwDataOffset = %d\n", dwOldPos, lpck->dwDataOffset); dwNewSize = dwOldPos - lpck->dwDataOffset; if (dwNewSize != lpck->cksize) { - TRACE("Nope: lpck->cksize=%ld dwNewSize=%ld\n", lpck->cksize, dwNewSize); + TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck->cksize, dwNewSize); lpck->cksize = dwNewSize; /* pad odd size with 0 */ @@ -1283,7 +1258,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags) TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld\n", dwOldPos); + TRACE("dwOldPos=%d\n", dwOldPos); if (uFlags == MMIO_CREATELIST) lpck->ckid = FOURCC_LIST; @@ -1300,7 +1275,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags) lpck->dwFlags = MMIO_DIRTY; ix = mmioWrite(hmmio, (LPSTR)lpck, size); - TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n",ix, size, errno); + TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix, size, errno); if (ix < size) { mmioSeek(hmmio, dwOldPos, SEEK_SET); WARN("return CannotWrite\n"); @@ -1320,7 +1295,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, struct IOProcList tmp; FOURCC fcc; - TRACE("('%s', '%s', %p, %08lX);\n", + TRACE("('%s', '%s', %p, %08X);\n", debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags); /* If both params are NULL, then parse the file name */ @@ -1341,7 +1316,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, ioProc = &tmp; tmp.fourCC = lpmmioinfo->fccIOProc; tmp.pIOProc = lpmmioinfo->pIOProc; - tmp.type = MMIO_PROC_32A; + tmp.is_unicode = FALSE; tmp.count = 1; } @@ -1349,7 +1324,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, * or make a copy of it because it's const ??? */ return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME, - (LPARAM)szFileName, (LPARAM)szNewFileName, MMIO_PROC_32A); + (LPARAM)szFileName, (LPARAM)szNewFileName, FALSE); } /************************************************************************** diff --git a/reactos/dll/win32/winmm/mmsystem.c b/reactos/dll/win32/winmm/mmsystem.c deleted file mode 100644 index 0699ac24b2c..00000000000 --- a/reactos/dll/win32/winmm/mmsystem.c +++ /dev/null @@ -1,3216 +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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -/* - * Eric POUECH : - * 99/4 added mmTask and mmThread functions support - */ - -#include -#include - -#define NONAMELESSUNION -#define NONAMELESSSTRUCT -#include "windef.h" -#include "winbase.h" -#include "mmsystem.h" -#include "winreg.h" -#include "ntstatus.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%lx\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, %08lx)\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, %08lx)\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, %08lx)\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%08lx\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, %08lx)\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, %lu) !\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, %08lX, %08lX)\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, %08lx, %08lx): 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, %08lX, %08lX)\n", - wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); - - dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE); - dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2)); - TRACE("=> %ld\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, %08lx)\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("(%lu, %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, %08lx, %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, %08lx, %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, %08lX, %08lX)\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, %08lx, %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, %08lx, %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, %08lX, %08lX)\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, %08lx, %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, %08lx, %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, %ld, %ld)\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, %08lx, %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, %ld, %ld)\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("(%08lx, %p, %08lx);\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)) { - K32WOWYield16(); - } -} - -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, %08lx, %08lx)!\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%08lx\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%08lx lin=%p\n", (DWORD)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%08lx\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); - /* K32WOWYield16();*/ - } - 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, 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_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=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\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("=> %lu\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 (%ld)\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 (%ld)\n", wMsg); - } - return MMSYSERR_NOERROR; -} - -/****************************************************************** - * MMIO_Callback16 - * - * - */ -static LRESULT MMIO_Callback16(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage, - LPARAM lParam1, LPARAM lParam2) -{ - LRESULT 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/reactos/dll/win32/winmm/mmsystem.spec b/reactos/dll/win32/winmm/mmsystem.spec deleted file mode 100644 index c6b3324ba51..00000000000 --- a/reactos/dll/win32/winmm/mmsystem.spec +++ /dev/null @@ -1,176 +0,0 @@ -1 pascal WEP(word word word ptr) MMSYSTEM_WEP -2 pascal sndPlaySound(ptr word) sndPlaySound16 -3 pascal PlaySound(ptr word long) PlaySound16 -4 pascal DllEntryPoint(long word word word long word) MMSYSTEM_LibMain -5 pascal mmsystemGetVersion() mmsystemGetVersion16 -6 pascal DriverProc(long word word long long) DriverProc16 -8 pascal WMMMidiRunOnce() WMMMidiRunOnce16 -30 pascal -ret16 OutputDebugStr(str) OutputDebugStr16 -31 pascal DriverCallback(long word word word long long long) DriverCallback16 -32 pascal StackEnter() StackEnter16 -33 pascal StackLeave() StackLeave16 -34 stub MMDRVINSTALL -101 pascal joyGetNumDevs() joyGetNumDevs16 -102 pascal joyGetDevCaps(word ptr word) joyGetDevCaps16 -103 pascal joyGetPos(word ptr) joyGetPos16 -104 pascal joyGetThreshold(word ptr) joyGetThreshold16 -105 pascal joyReleaseCapture(word) joyReleaseCapture16 -106 pascal joySetCapture(word word word word) joySetCapture16 -107 pascal joySetThreshold(word word) joySetThreshold16 -109 pascal joySetCalibration(word) joySetCalibration16 -110 pascal joyGetPosEx(word ptr) joyGetPosEx16 -111 stub JOYCONFIGCHANGED -201 pascal midiOutGetNumDevs() midiOutGetNumDevs16 -202 pascal midiOutGetDevCaps(word ptr word) midiOutGetDevCaps16 -203 pascal midiOutGetErrorText(word ptr word) midiOutGetErrorText16 -204 pascal midiOutOpen(ptr word long long long) midiOutOpen16 -205 pascal midiOutClose(word) midiOutClose16 -206 pascal midiOutPrepareHeader(word segptr word) midiOutPrepareHeader16 -207 pascal midiOutUnprepareHeader(word segptr word) midiOutUnprepareHeader16 -208 pascal midiOutShortMsg(word long) midiOutShortMsg16 -209 pascal midiOutLongMsg(word segptr word) midiOutLongMsg16 -210 pascal midiOutReset(word) midiOutReset16 -211 pascal midiOutGetVolume(word ptr) midiOutGetVolume16 -212 pascal midiOutSetVolume(word long) midiOutSetVolume16 -213 pascal midiOutCachePatches(word word ptr word) midiOutCachePatches16 -214 pascal midiOutCacheDrumPatches(word word ptr word) midiOutCacheDrumPatches16 -215 pascal midiOutGetID(word ptr) midiOutGetID16 -216 pascal midiOutMessage(word word long long) midiOutMessage16 -250 pascal midiStreamProperty(word ptr long) midiStreamProperty16 -251 pascal midiStreamOpen(ptr ptr long long long long) midiStreamOpen16 -252 pascal midiStreamClose(word) midiStreamClose16 -253 pascal midiStreamPosition(word ptr word) midiStreamPosition16 -254 pascal midiStreamOut(word ptr word) midiStreamOut16 -255 pascal midiStreamPause(word) midiStreamPause16 -256 pascal midiStreamRestart(word) midiStreamRestart16 -257 pascal midiStreamStop(word) midiStreamStop16 -301 pascal midiInGetNumDevs() midiInGetNumDevs16 -302 pascal midiInGetDevCaps(word ptr word) midiInGetDevCaps16 -303 pascal midiInGetErrorText(word ptr word) midiOutGetErrorText16 -304 pascal midiInOpen(ptr word long long long) midiInOpen16 -305 pascal midiInClose(word) midiInClose16 -306 pascal midiInPrepareHeader(word segptr word) midiInPrepareHeader16 -307 pascal midiInUnprepareHeader(word segptr word) midiInUnprepareHeader16 -308 pascal midiInAddBuffer(word segptr word) midiInAddBuffer16 -309 pascal midiInStart(word) midiInStart16 -310 pascal midiInStop(word) midiInStop16 -311 pascal midiInReset(word) midiInReset16 -312 pascal midiInGetID(word ptr) midiInGetID16 -313 pascal midiInMessage(word word long long) midiInMessage16 -350 pascal auxGetNumDevs() auxGetNumDevs16 -351 pascal auxGetDevCaps(word ptr word) auxGetDevCaps16 -352 pascal auxGetVolume(word ptr) auxGetVolume16 -353 pascal auxSetVolume(word long) auxSetVolume16 -354 pascal auxOutMessage(word word long long) auxOutMessage16 -401 pascal waveOutGetNumDevs() waveOutGetNumDevs16 -402 pascal waveOutGetDevCaps(word ptr word) waveOutGetDevCaps16 -403 pascal waveOutGetErrorText(word ptr word) waveOutGetErrorText16 -404 pascal waveOutOpen(ptr word ptr long long long) waveOutOpen16 -405 pascal waveOutClose(word) waveOutClose16 -406 pascal waveOutPrepareHeader(word segptr word) waveOutPrepareHeader16 -407 pascal waveOutUnprepareHeader(word segptr word) waveOutUnprepareHeader16 -408 pascal waveOutWrite(word segptr word) waveOutWrite16 -409 pascal waveOutPause(word) waveOutPause16 -410 pascal waveOutRestart(word) waveOutRestart16 -411 pascal waveOutReset(word) waveOutReset16 -412 pascal waveOutGetPosition(word ptr word) waveOutGetPosition16 -413 pascal waveOutGetPitch(word ptr) waveOutGetPitch16 -414 pascal waveOutSetPitch(word long) waveOutSetPitch16 -415 pascal waveOutGetVolume(word ptr) waveOutGetVolume16 -416 pascal waveOutSetVolume(word long) waveOutSetVolume16 -417 pascal waveOutGetPlaybackRate(word ptr) waveOutGetPlaybackRate16 -418 pascal waveOutSetPlaybackRate(word long) waveOutSetPlaybackRate16 -419 pascal waveOutBreakLoop(word) waveOutBreakLoop16 -420 pascal waveOutGetID(word ptr) waveOutGetID16 -421 pascal waveOutMessage(word word long long) waveOutMessage16 -501 pascal waveInGetNumDevs() waveInGetNumDevs16 -502 pascal waveInGetDevCaps(word ptr word) waveInGetDevCaps16 -503 pascal waveInGetErrorText(word ptr word) waveOutGetErrorText16 -504 pascal waveInOpen(ptr word ptr long long long) waveInOpen16 -505 pascal waveInClose(word) waveInClose16 -506 pascal waveInPrepareHeader(word segptr word) waveInPrepareHeader16 -507 pascal waveInUnprepareHeader(word segptr word) waveInUnprepareHeader16 -508 pascal waveInAddBuffer(word segptr word) waveInAddBuffer16 -509 pascal waveInStart(word) waveInStart16 -510 pascal waveInStop(word) waveInStop16 -511 pascal waveInReset(word) waveInReset16 -512 pascal waveInGetPosition(word ptr word) waveInGetPosition16 -513 pascal waveInGetID(word ptr) waveInGetID16 -514 pascal waveInMessage(word word long long) waveInMessage16 -601 pascal timeGetSystemTime(ptr word) timeGetSystemTime16 -602 pascal timeSetEvent(word word segptr long word) timeSetEvent16 -603 pascal timeKillEvent(word) timeKillEvent16 -604 pascal timeGetDevCaps(ptr word) timeGetDevCaps16 -605 pascal timeBeginPeriod(word) timeBeginPeriod16 -606 pascal timeEndPeriod(word) timeEndPeriod16 -607 pascal timeGetTime() timeGetTime -701 pascal mciSendCommand(word word long long) mciSendCommand16 -702 pascal mciSendString(str ptr word word) mciSendString16 -703 pascal mciGetDeviceID(ptr) mciGetDeviceID16 -705 pascal mciLoadCommandResource(word str word) mciLoadCommandResource16 -706 pascal mciGetErrorString(long ptr word) mciGetErrorString16 -707 pascal mciSetDriverData(word long) mciSetDriverData16 -708 pascal mciGetDriverData(word) mciGetDriverData16 -710 pascal mciDriverYield(word) mciDriverYield16 -711 pascal mciDriverNotify(word word word) mciDriverNotify16 -712 pascal mciExecute(ptr) mciExecute -713 pascal mciFreeCommandResource(word) mciFreeCommandResource16 -714 pascal mciSetYieldProc(word ptr long) mciSetYieldProc16 -715 pascal mciGetDeviceIDFromElementID(long ptr) mciGetDeviceIDFromElementID16 -716 pascal mciGetYieldProc(word ptr) mciGetYieldProc16 -717 pascal mciGetCreatorTask(word) mciGetCreatorTask16 -800 pascal mixerGetNumDevs() mixerGetNumDevs16 -801 pascal mixerGetDevCaps(word ptr word) mixerGetDevCaps16 -802 pascal mixerOpen(ptr word long long long) mixerOpen16 -803 pascal mixerClose(word) mixerClose16 -804 pascal mixerMessage(word word long long) mixerMessage16 -805 pascal mixerGetLineInfo(word ptr long) mixerGetLineInfo16 -806 pascal mixerGetID(word ptr long) mixerGetID16 -807 pascal mixerGetLineControls(word ptr long) mixerGetLineControls16 -808 pascal mixerGetControlDetails(word ptr long) mixerGetControlDetails16 -809 pascal mixerSetControlDetails(word ptr long) mixerSetControlDetails16 -900 pascal mmTaskCreate(long ptr long) mmTaskCreate16 -902 pascal mmTaskBlock(word) mmTaskBlock16 -903 pascal mmTaskSignal(word) mmTaskSignal16 -904 pascal -ret16 mmGetCurrentTask() mmGetCurrentTask16 -905 pascal mmTaskYield() mmTaskYield16 -1100 pascal DrvOpen(str str long) DrvOpen16 -1101 pascal DrvClose(word long long) DrvClose16 -1102 pascal DrvSendMessage(word word long long) DrvSendMessage16 -1103 pascal DrvGetModuleHandle(word) DrvGetModuleHandle16 -1104 pascal DrvDefDriverProc(long word word long long) DrvDefDriverProc16 -1120 pascal mmThreadCreate(segptr ptr long long) mmThreadCreate16 -1121 pascal mmThreadSignal(word) mmThreadSignal16 -1122 pascal mmThreadBlock(word) mmThreadBlock16 -1123 pascal mmThreadIsCurrent(word) mmThreadIsCurrent16 -1124 pascal mmThreadIsValid(word) mmThreadIsValid16 -1125 pascal mmThreadGetTask(word) mmThreadGetTask16 -1150 pascal mmShowMMCPLPropertySheet(word str str str) mmShowMMCPLPropertySheet16 - -1210 pascal mmioOpen(str ptr long) mmioOpen16 -1211 pascal mmioClose(word word) mmioClose16 -1212 pascal mmioRead(word ptr long) mmioRead16 -1213 pascal mmioWrite(word ptr long) mmioWrite16 -1214 pascal mmioSeek(word long word) mmioSeek16 -1215 pascal mmioGetInfo(word ptr word) mmioGetInfo16 -1216 pascal mmioSetInfo(word ptr word) mmioSetInfo16 -1217 pascal mmioSetBuffer(word segptr long word) mmioSetBuffer16 -1218 pascal mmioFlush(word word) mmioFlush16 -1219 pascal mmioAdvance(word ptr word) mmioAdvance16 -1220 pascal mmioStringToFOURCC(str word) mmioStringToFOURCC16 -1221 pascal mmioInstallIOProc(long ptr long) mmioInstallIOProc16 -1222 pascal mmioSendMessage(word word long long) mmioSendMessage16 -1223 pascal mmioDescend(word ptr ptr word) mmioDescend16 -1224 pascal mmioAscend(word ptr word) mmioAscend16 -1225 pascal mmioCreateChunk(word ptr word) mmioCreateChunk16 -1226 pascal mmioRename(ptr ptr ptr long) mmioRename16 - -#2000 stub WINMMF_THUNKDATA16 -#2001 stub RING3_DEVLOADER -#2002 stub WINMMTILEBUFFER -#2003 stub WINMMUNTILEBUFFER -#2005 stub MCIGETTHUNKTABLE -#2006 stub WINMMSL_THUNKDATA16 - -# these are Wine only exported functions. Is there another way to do it ? -2047 pascal __wine_mmThreadEntryPoint(long) WINE_mmThreadEntryPoint diff --git a/reactos/dll/win32/winmm/playsound.c b/reactos/dll/win32/winmm/playsound.c index 417ebd2fcc1..54db68f0f8e 100644 --- a/reactos/dll/win32/winmm/playsound.c +++ b/reactos/dll/win32/winmm/playsound.c @@ -1,7 +1,7 @@ /* -*- tab-width: 8; c-basic-offset: 4 -*- */ /* - * MMSYTEM functions + * MMSYSTEM functions * * Copyright 1993 Martin Ayotte * 1998-2002 Eric Pouech @@ -18,7 +18,7 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include @@ -37,6 +37,20 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); +typedef struct tagWINE_PLAYSOUND +{ + unsigned bLoop : 1, + bAlloc : 1; + LPCWSTR pszSound; + HMODULE hMod; + DWORD fdwSound; + HANDLE hThread; + HWAVEOUT hWave; + struct tagWINE_PLAYSOUND* lpNext; +} WINE_PLAYSOUND; + +static WINE_PLAYSOUND *PlaySoundList; + static HMMIO get_mmioFromFile(LPCWSTR lpszName) { HMMIO ret; @@ -133,19 +147,19 @@ static HMMIO get_mmioFromProfile(UINT uFlags, LPCWSTR lpszName) hmmio = mmioOpenW(str, NULL, MMIO_ALLOCBUF | MMIO_READ | MMIO_DENYWRITE); if (hmmio) return hmmio; none: - WARN("can't find SystemSound='%s' !\n", debugstr_w(lpszName)); + WARN("can't find SystemSound=%s !\n", debugstr_w(lpszName)); return 0; } struct playsound_data { HANDLE hEvent; - DWORD dwEventCount; + LONG dwEventCount; }; static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg, - DWORD dwInstance, - DWORD dwParam1, DWORD dwParam2) + DWORD_PTR dwInstance, + DWORD_PTR dwParam1, DWORD_PTR dwParam2) { struct playsound_data* s = (struct playsound_data*)dwInstance; @@ -154,7 +168,7 @@ static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg, case WOM_CLOSE: break; case WOM_DONE: - InterlockedIncrement((PLONG)&s->dwEventCount); + InterlockedIncrement(&s->dwEventCount); TRACE("Returning waveHdr=%lx\n", dwParam1); SetEvent(s->hEvent); break; @@ -167,8 +181,8 @@ static void PlaySound_WaitDone(struct playsound_data* s) { for (;;) { ResetEvent(s->hEvent); - if (InterlockedDecrement((PLONG)&s->dwEventCount) >= 0) break; - InterlockedIncrement((PLONG)&s->dwEventCount); + if (InterlockedDecrement(&s->dwEventCount) >= 0) break; + InterlockedIncrement(&s->dwEventCount); WaitForSingleObject(s->hEvent, INFINITE); } @@ -179,11 +193,12 @@ static BOOL PlaySound_IsString(DWORD fdwSound, const void* psz) /* SND_RESOURCE is 0x40004 while * SND_MEMORY is 0x00004 */ - switch (fdwSound & (SND_RESOURCE|SND_ALIAS|SND_FILENAME)) + switch (fdwSound & (SND_RESOURCE|SND_ALIAS_ID|SND_FILENAME)) { case SND_RESOURCE: return HIWORD(psz) != 0; /* by name or by ID ? */ + case SND_ALIAS_ID: case SND_MEMORY: return FALSE; - case SND_ALIAS: /* what about ALIAS_ID ??? */ + case SND_ALIAS: case SND_FILENAME: case 0: return TRUE; default: FIXME("WTF\n"); return FALSE; @@ -194,11 +209,11 @@ static void PlaySound_Free(WINE_PLAYSOUND* wps) { WINE_PLAYSOUND** p; - EnterCriticalSection(&WINMM_IData.cs); - for (p = &WINMM_IData.lpPlaySound; *p && *p != wps; p = &((*p)->lpNext)); + EnterCriticalSection(&WINMM_cs); + for (p = &PlaySoundList; *p && *p != wps; p = &((*p)->lpNext)); if (*p) *p = (*p)->lpNext; - if (WINMM_IData.lpPlaySound == NULL) SetEvent(WINMM_IData.psLastEvent); - LeaveCriticalSection(&WINMM_IData.cs); + if (PlaySoundList == NULL) SetEvent(psLastEvent); + LeaveCriticalSection(&WINMM_cs); if (wps->bAlloc) HeapFree(GetProcessHeap(), 0, (void*)wps->pszSound); if (wps->hThread) CloseHandle(wps->hThread); HeapFree(GetProcessHeap(), 0, wps); @@ -220,10 +235,10 @@ static WINE_PLAYSOUND* PlaySound_Alloc(const void* pszSound, HMODULE hmod, { if (fdwSound & SND_ASYNC) { - wps->pszSound = HeapAlloc(GetProcessHeap(), 0, - (lstrlenW(pszSound)+1) * sizeof(WCHAR)); - if (!wps->pszSound) goto oom_error; - lstrcpyW((LPWSTR)wps->pszSound, pszSound); + LPWSTR sound = HeapAlloc(GetProcessHeap(), 0, + (lstrlenW(pszSound)+1) * sizeof(WCHAR)); + if (!sound) goto oom_error; + wps->pszSound = lstrcpyW(sound, pszSound); wps->bAlloc = TRUE; } else @@ -249,13 +264,12 @@ static WINE_PLAYSOUND* PlaySound_Alloc(const void* pszSound, HMODULE hmod, static DWORD WINAPI proc_PlaySound(LPVOID arg) { - WINE_PLAYSOUND* wps = (WINE_PLAYSOUND*)arg; + WINE_PLAYSOUND* wps = arg; BOOL bRet = FALSE; HMMIO hmmio = 0; MMCKINFO ckMainRIFF; MMCKINFO mmckInfo; LPWAVEFORMATEX lpWaveFormat = NULL; - HWAVEOUT hWave = 0; LPWAVEHDR waveHdr = NULL; INT count, bufsize, left, index; struct playsound_data s; @@ -263,7 +277,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) s.hEvent = 0; - TRACE("SoundName='%s' !\n", debugstr_w(wps->pszSound)); + TRACE("SoundName=%s !\n", debugstr_w(wps->pszSound)); /* if resource, grab it */ if ((wps->fdwSound & SND_RESOURCE) == SND_RESOURCE) { @@ -289,13 +303,43 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) memset(&mminfo, 0, sizeof(mminfo)); mminfo.fccIOProc = FOURCC_MEM; - mminfo.pchBuffer = (LPSTR)data; + mminfo.pchBuffer = data; mminfo.cchBuffer = -1; /* FIXME: when a resource, could grab real size */ TRACE("Memory sound %p\n", data); hmmio = mmioOpenW(NULL, &mminfo, MMIO_READ); } else if (wps->fdwSound & SND_ALIAS) { + if ((wps->fdwSound & SND_ALIAS_ID) == SND_ALIAS_ID) + { + static const WCHAR wszSystemAsterisk[] = {'S','y','s','t','e','m','A','s','t','e','r','i','s','k',0}; + static const WCHAR wszSystemDefault[] = {'S','y','s','t','e','m','D','e','f','a','u','l','t',0}; + static const WCHAR wszSystemExclamation[] = {'S','y','s','t','e','m','E','x','c','l','a','m','a','t','i','o','n',0}; + static const WCHAR wszSystemExit[] = {'S','y','s','t','e','m','E','x','i','t',0}; + static const WCHAR wszSystemHand[] = {'S','y','s','t','e','m','H','a','n','d',0}; + static const WCHAR wszSystemQuestion[] = {'S','y','s','t','e','m','Q','u','e','s','t','i','o','n',0}; + static const WCHAR wszSystemStart[] = {'S','y','s','t','e','m','S','t','a','r','t',0}; + static const WCHAR wszSystemWelcome[] = {'S','y','s','t','e','m','W','e','l','c','o','m','e',0}; + + wps->fdwSound &= ~(SND_ALIAS_ID ^ SND_ALIAS); + if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMASTERISK) + wps->pszSound = wszSystemAsterisk; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMDEFAULT) + wps->pszSound = wszSystemDefault; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMEXCLAMATION) + wps->pszSound = wszSystemExclamation; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMEXIT) + wps->pszSound = wszSystemExit; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMHAND) + wps->pszSound = wszSystemHand; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMQUESTION) + wps->pszSound = wszSystemQuestion; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMSTART) + wps->pszSound = wszSystemStart; + else if (wps->pszSound == (LPCWSTR)SND_ALIAS_SYSTEMWELCOME) + wps->pszSound = wszSystemWelcome; + else goto errCleanUp; + } hmmio = get_mmioFromProfile(wps->fdwSound, wps->pszSound); } else if (wps->fdwSound & SND_FILENAME) @@ -317,7 +361,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0)) goto errCleanUp; - TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n", + TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08X\n", (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize); if ((ckMainRIFF.ckid != FOURCC_RIFF) || @@ -328,18 +372,18 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) goto errCleanUp; - TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", - (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); + TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n", + (LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize); lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize); - if (mmioRead(hmmio, (HPSTR)lpWaveFormat, mmckInfo.cksize) < sizeof(WAVEFORMAT)) + if (mmioRead(hmmio, (HPSTR)lpWaveFormat, mmckInfo.cksize) < sizeof(PCMWAVEFORMAT)) goto errCleanUp; TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag); - TRACE("nChannels=%d \n", lpWaveFormat->nChannels); - TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec); - TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec); - TRACE("nBlockAlign=%d \n", lpWaveFormat->nBlockAlign); + TRACE("nChannels=%d\n", lpWaveFormat->nChannels); + TRACE("nSamplesPerSec=%d\n", lpWaveFormat->nSamplesPerSec); + TRACE("nAvgBytesPerSec=%d\n", lpWaveFormat->nAvgBytesPerSec); + TRACE("nBlockAlign=%d\n", lpWaveFormat->nBlockAlign); TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample); /* move to end of 'fmt ' chunk */ @@ -349,13 +393,13 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) goto errCleanUp; - TRACE("Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX\n", - (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); + TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n", + (LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize); s.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL); - if (waveOutOpen(&hWave, WAVE_MAPPER, lpWaveFormat, (DWORD)PlaySound_Callback, - (DWORD)&s, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) + if (waveOutOpen(&wps->hWave, WAVE_MAPPER, lpWaveFormat, (DWORD_PTR)PlaySound_Callback, + (DWORD_PTR)&s, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) goto errCleanUp; /* make it so that 3 buffers per second are needed */ @@ -368,8 +412,8 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) waveHdr[0].dwLoops = waveHdr[1].dwLoops = 0L; waveHdr[0].dwFlags = waveHdr[1].dwFlags = 0L; waveHdr[0].dwBufferLength = waveHdr[1].dwBufferLength = bufsize; - if (waveOutPrepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR)) || - waveOutPrepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR))) { + if (waveOutPrepareHeader(wps->hWave, &waveHdr[0], sizeof(WAVEHDR)) || + waveOutPrepareHeader(wps->hWave, &waveHdr[1], sizeof(WAVEHDR))) { goto errCleanUp; } @@ -382,7 +426,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) mmioSeek(hmmio, mmckInfo.dwDataOffset, SEEK_SET); while (left) { - if (WaitForSingleObject(WINMM_IData.psStopEvent, 0) == WAIT_OBJECT_0) + if (WaitForSingleObject(psStopEvent, 0) == WAIT_OBJECT_0) { wps->bLoop = FALSE; break; @@ -392,7 +436,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) left -= count; waveHdr[index].dwBufferLength = count; waveHdr[index].dwFlags &= ~WHDR_DONE; - if (waveOutWrite(hWave, &waveHdr[index], sizeof(WAVEHDR)) == MMSYSERR_NOERROR) { + if (waveOutWrite(wps->hWave, &waveHdr[index], sizeof(WAVEHDR)) == MMSYSERR_NOERROR) { index ^= 1; PlaySound_WaitDone(&s); } @@ -402,17 +446,17 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) } while (wps->bLoop); PlaySound_WaitDone(&s); /* for last buffer */ - waveOutReset(hWave); + waveOutReset(wps->hWave); - waveOutUnprepareHeader(hWave, &waveHdr[0], sizeof(WAVEHDR)); - waveOutUnprepareHeader(hWave, &waveHdr[1], sizeof(WAVEHDR)); + waveOutUnprepareHeader(wps->hWave, &waveHdr[0], sizeof(WAVEHDR)); + waveOutUnprepareHeader(wps->hWave, &waveHdr[1], sizeof(WAVEHDR)); errCleanUp: - TRACE("Done playing='%s' => %s!\n", debugstr_w(wps->pszSound), bRet ? "ok" : "ko"); + TRACE("Done playing=%s => %s!\n", debugstr_w(wps->pszSound), bRet ? "ok" : "ko"); CloseHandle(s.hEvent); HeapFree(GetProcessHeap(), 0, waveHdr); HeapFree(GetProcessHeap(), 0, lpWaveFormat); - if (hWave) while (waveOutClose(hWave) == WAVERR_STILLPLAYING) Sleep(100); + if (wps->hWave) while (waveOutClose(wps->hWave) == WAVERR_STILLPLAYING) Sleep(100); if (hmmio) mmioClose(hmmio, 0); PlaySound_Free(wps); @@ -424,13 +468,13 @@ static BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSo { WINE_PLAYSOUND* wps = NULL; - TRACE("pszSound='%p' hmod=%p fdwSound=%08lX\n", + TRACE("pszSound='%p' hmod=%p fdwSound=%08X\n", pszSound, hmod, fdwSound); /* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP ! * there could be one if several sounds can be played at once... */ - if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && WINMM_IData.lpPlaySound != NULL) + if ((fdwSound & (SND_NOWAIT | SND_NOSTOP)) && PlaySoundList != NULL) return FALSE; /* alloc internal structure, if we need to play something */ @@ -440,27 +484,28 @@ static BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSo return FALSE; } - EnterCriticalSection(&WINMM_IData.cs); + EnterCriticalSection(&WINMM_cs); /* since several threads can enter PlaySound in parallel, we're not * sure, at this point, that another thread didn't start a new playsound */ - while (WINMM_IData.lpPlaySound != NULL) + while (PlaySoundList != NULL) { - ResetEvent(WINMM_IData.psLastEvent); + ResetEvent(psLastEvent); /* FIXME: doc says we have to stop all instances of pszSound if it's non * NULL... as of today, we stop all playing instances */ - SetEvent(WINMM_IData.psStopEvent); + SetEvent(psStopEvent); - LeaveCriticalSection(&WINMM_IData.cs); - WaitForSingleObject(WINMM_IData.psLastEvent, INFINITE); - EnterCriticalSection(&WINMM_IData.cs); + waveOutReset(PlaySoundList->hWave); + LeaveCriticalSection(&WINMM_cs); + WaitForSingleObject(psLastEvent, INFINITE); + EnterCriticalSection(&WINMM_cs); - ResetEvent(WINMM_IData.psStopEvent); + ResetEvent(psStopEvent); } - if (wps) wps->lpNext = WINMM_IData.lpPlaySound; - WINMM_IData.lpPlaySound = wps; - LeaveCriticalSection(&WINMM_IData.cs); + if (wps) wps->lpNext = PlaySoundList; + PlaySoundList = wps; + LeaveCriticalSection(&WINMM_cs); if (!pszSound || (fdwSound & SND_PURGE)) return TRUE; diff --git a/reactos/dll/win32/winmm/sound.spec b/reactos/dll/win32/winmm/sound.spec deleted file mode 100644 index 586af4064f3..00000000000 --- a/reactos/dll/win32/winmm/sound.spec +++ /dev/null @@ -1,18 +0,0 @@ -1 pascal -ret16 OpenSound() OpenSound16 -2 pascal -ret16 CloseSound() CloseSound16 -3 pascal -ret16 SetVoiceQueueSize(word word) SetVoiceQueueSize16 -4 pascal -ret16 SetVoiceNote(word word word word) SetVoiceNote16 -5 pascal -ret16 SetVoiceAccent(word word word word word) SetVoiceAccent16 -6 pascal -ret16 SetVoiceEnvelope(word word word) SetVoiceEnvelope16 -7 pascal -ret16 SetSoundNoise(word word) SetSoundNoise16 -8 pascal -ret16 SetVoiceSound(word long word) SetVoiceSound16 -9 pascal -ret16 StartSound() StartSound16 -10 pascal -ret16 StopSound() StopSound16 -11 pascal -ret16 WaitSoundState(word) WaitSoundState16 -12 pascal -ret16 SyncAllVoices() SyncAllVoices16 -13 pascal -ret16 CountVoiceNotes(word) CountVoiceNotes16 -14 pascal GetThresholdEvent() GetThresholdEvent16 -15 pascal -ret16 GetThresholdStatus() GetThresholdStatus16 -16 pascal -ret16 SetVoiceThreshold(word word) SetVoiceThreshold16 -17 pascal -ret16 DoBeep() DoBeep16 -18 stub MYOPENSOUND # W1.1, W2.0 diff --git a/reactos/dll/win32/winmm/sound16.c b/reactos/dll/win32/winmm/sound16.c deleted file mode 100644 index 46306d8b1f0..00000000000 --- a/reactos/dll/win32/winmm/sound16.c +++ /dev/null @@ -1,184 +0,0 @@ -/* - * 16-bit sound support - * - * Copyright Robert J. Amstadt, 1993 - * - * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include -#include -#include "windef.h" -#include "winbase.h" -#include "wine/windef16.h" -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(sound); - -/*********************************************************************** - * OpenSound (SOUND.1) - */ -INT16 WINAPI OpenSound16(void) -{ - FIXME("(void): stub\n"); - return -1; -} - -/*********************************************************************** - * CloseSound (SOUND.2) - */ -void WINAPI CloseSound16(void) -{ - FIXME("(void): stub\n"); -} - -/*********************************************************************** - * SetVoiceQueueSize (SOUND.3) - */ -INT16 WINAPI SetVoiceQueueSize16(INT16 nVoice, INT16 nBytes) -{ - FIXME("(%d,%d): stub\n",nVoice,nBytes); - return 0; -} - -/*********************************************************************** - * SetVoiceNote (SOUND.4) - */ -INT16 WINAPI SetVoiceNote16(INT16 nVoice, INT16 nValue, INT16 nLength, - INT16 nCdots) -{ - FIXME("(%d,%d,%d,%d): stub\n",nVoice,nValue,nLength,nCdots); - return 0; -} - -/*********************************************************************** - * SetVoiceAccent (SOUND.5) - */ -INT16 WINAPI SetVoiceAccent16(INT16 nVoice, INT16 nTempo, INT16 nVolume, - INT16 nMode, INT16 nPitch) -{ - FIXME("(%d,%d,%d,%d,%d): stub\n", nVoice, nTempo, - nVolume, nMode, nPitch); - return 0; -} - -/*********************************************************************** - * SetVoiceEnvelope (SOUND.6) - */ -INT16 WINAPI SetVoiceEnvelope16(INT16 nVoice, INT16 nShape, INT16 nRepeat) -{ - FIXME("(%d,%d,%d): stub\n",nVoice,nShape,nRepeat); - return 0; -} - -/*********************************************************************** - * SetSoundNoise (SOUND.7) - */ -INT16 WINAPI SetSoundNoise16(INT16 nSource, INT16 nDuration) -{ - FIXME("(%d,%d): stub\n",nSource,nDuration); - return 0; -} - -/*********************************************************************** - * SetVoiceSound (SOUND.8) - */ -INT16 WINAPI SetVoiceSound16(INT16 nVoice, DWORD lFrequency, INT16 nDuration) -{ - FIXME("(%d, %ld, %d): stub\n",nVoice,lFrequency, nDuration); - return 0; -} - -/*********************************************************************** - * StartSound (SOUND.9) - */ -INT16 WINAPI StartSound16(void) -{ - return 0; -} - -/*********************************************************************** - * StopSound (SOUND.10) - */ -INT16 WINAPI StopSound16(void) -{ - return 0; -} - -/*********************************************************************** - * WaitSoundState (SOUND.11) - */ -INT16 WINAPI WaitSoundState16(INT16 x) -{ - FIXME("(%d): stub\n", x); - return 0; -} - -/*********************************************************************** - * SyncAllVoices (SOUND.12) - */ -INT16 WINAPI SyncAllVoices16(void) -{ - FIXME("(void): stub\n"); - return 0; -} - -/*********************************************************************** - * CountVoiceNotes (SOUND.13) - */ -INT16 WINAPI CountVoiceNotes16(INT16 x) -{ - FIXME("(%d): stub\n", x); - return 0; -} - -/*********************************************************************** - * GetThresholdEvent (SOUND.14) - */ -LPINT16 WINAPI GetThresholdEvent16(void) -{ - FIXME("(void): stub\n"); - return NULL; -} - -/*********************************************************************** - * GetThresholdStatus (SOUND.15) - */ -INT16 WINAPI GetThresholdStatus16(void) -{ - FIXME("(void): stub\n"); - return 0; -} - -/*********************************************************************** - * SetVoiceThreshold (SOUND.16) - */ -INT16 WINAPI SetVoiceThreshold16(INT16 a, INT16 b) -{ - FIXME("(%d,%d): stub\n", a, b); - return 0; -} - -/*********************************************************************** - * DoBeep (SOUND.17) - */ -void WINAPI DoBeep16(void) -{ - FIXME("(void): stub!\n"); -} - - - - diff --git a/reactos/dll/win32/winmm/time.c b/reactos/dll/win32/winmm/time.c index 33c53763763..85577c20b42 100644 --- a/reactos/dll/win32/winmm/time.c +++ b/reactos/dll/win32/winmm/time.c @@ -17,13 +17,14 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include +#include #include #ifdef HAVE_SYS_TIME_H # include @@ -31,6 +32,12 @@ #ifdef HAVE_UNISTD_H # include #endif +#ifdef HAVE_POLL_H +#include +#endif +#ifdef HAVE_SYS_POLL_H +#include +#endif #include "windef.h" #include "winbase.h" @@ -38,15 +45,47 @@ #include "winemm.h" +#include "wine/list.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(mmtime); +typedef struct tagWINE_TIMERENTRY { + struct list entry; + UINT wDelay; + UINT wResol; + LPTIMECALLBACK lpFunc; /* can be lots of things */ + DWORD_PTR dwUser; + UINT16 wFlags; + UINT16 wTimerID; + DWORD dwTriggerTime; +} WINE_TIMERENTRY, *LPWINE_TIMERENTRY; + +static struct list timer_list = LIST_INIT(timer_list); + +static CRITICAL_SECTION TIME_cbcrst; +static CRITICAL_SECTION_DEBUG critsect_debug = +{ + 0, 0, &TIME_cbcrst, + { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": TIME_cbcrst") } +}; +static CRITICAL_SECTION TIME_cbcrst = { &critsect_debug, -1, 0, 0, 0, 0 }; + static HANDLE TIME_hMMTimer; -static LPWINE_TIMERENTRY TIME_TimersList; -static HANDLE TIME_hKillEvent; -static HANDLE TIME_hWakeEvent; static BOOL TIME_TimeToDie = TRUE; +static int TIME_fdWake[2] = { -1, -1 }; + +/* link timer at the appropriate spot in the list */ +static inline void link_timer( WINE_TIMERENTRY *timer ) +{ + WINE_TIMERENTRY *next; + + LIST_FOR_EACH_ENTRY( next, &timer_list, WINE_TIMERENTRY, entry ) + if ((int)(next->dwTriggerTime - timer->dwTriggerTime) >= 0) break; + + list_add_before( &next->entry, &timer->entry ); +} /* * Some observations on the behavior of winmm on Windows. @@ -55,7 +94,7 @@ static BOOL TIME_TimeToDie = TRUE; * * Second, a brief survey of a variety of Win 2k and Win X * machines showed that a 'standard' (aka default) timer - * resolution was 1 ms (Win9x is documented as being 1). However, one + * resolution was 1 ms (Win9x is documented as being 1). However, one * machine had a standard timer resolution of 10 ms. * * Further, if we set our default resolution to 1, @@ -77,58 +116,15 @@ static BOOL TIME_TimeToDie = TRUE; #define MMSYSTIME_MININTERVAL (1) #define MMSYSTIME_MAXINTERVAL (65535) - -static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer) -{ - TRACE("%04lx:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08lX dwTriggerTime %ld(delta %ld)\n", - GetCurrentThreadId(), lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser, - lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime); - - /* - TimeProc callback that is called here is something strange, under Windows 3.1x it is called - * during interrupt time, is allowed to execute very limited number of API calls (like - * PostMessage), and must reside in DLL (therefore uses stack of active application). So I - * guess current implementation via SetTimer has to be improved upon. - */ - switch (lpTimer->wFlags & 0x30) { - case TIME_CALLBACK_FUNCTION: - if (lpTimer->wFlags & WINE_TIMER_IS32) - (lpTimer->lpFunc)(lpTimer->wTimerID, 0, lpTimer->dwUser, 0, 0); - else if (pFnCallMMDrvFunc16) - pFnCallMMDrvFunc16((DWORD)lpTimer->lpFunc, lpTimer->wTimerID, 0, - lpTimer->dwUser, 0, 0); - break; - case TIME_CALLBACK_EVENT_SET: - SetEvent((HANDLE)lpTimer->lpFunc); - break; - case TIME_CALLBACK_EVENT_PULSE: - PulseEvent((HANDLE)lpTimer->lpFunc); - break; - default: - FIXME("Unknown callback type 0x%04x for mmtime callback (%p), ignored.\n", - lpTimer->wFlags, lpTimer->lpFunc); - break; - } -} +#ifdef HAVE_POLL /************************************************************************** * TIME_MMSysTimeCallback */ -static DWORD CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData) +static int TIME_MMSysTimeCallback(void) { -static int nSizeLpTimers; -static LPWINE_TIMERENTRY lpTimers; - - LPWINE_TIMERENTRY timer, *ptimer, *next_ptimer; - int idx; - DWORD cur_time; - DWORD delta_time; - DWORD ret_time = INFINITE; - DWORD adjust_time; - - - /* optimize for the most frequent case - no events */ - if (! TIME_TimersList) - return(ret_time); + WINE_TIMERENTRY *timer, *to_free; + int delta_time; /* since timeSetEvent() and timeKillEvent() can be called * from 16 bit code, there are cases where win16 lock is @@ -140,84 +136,60 @@ static LPWINE_TIMERENTRY lpTimers; * To cope with that, we just copy the WINE_TIMERENTRY struct * that need to trigger the callback, and call it without the * mm timer crit sect locked. - * the hKillTimeEvent is used to mark the section where we - * handle the callbacks so we can do synchronous kills. - * EPP 99/07/13, updated 04/01/10 */ - idx = 0; - cur_time = GetTickCount(); - EnterCriticalSection(&iData->cs); - for (ptimer = &TIME_TimersList; *ptimer != NULL; ) { - timer = *ptimer; - next_ptimer = &timer->lpNext; - if (cur_time >= timer->dwTriggerTime) + EnterCriticalSection(&WINMM_cs); + for (;;) + { + struct list *ptr = list_head( &timer_list ); + if (!ptr) { - if (timer->lpFunc) { - if (idx == nSizeLpTimers) { - if (lpTimers) - lpTimers = (LPWINE_TIMERENTRY) - HeapReAlloc(GetProcessHeap(), 0, lpTimers, - ++nSizeLpTimers * sizeof(WINE_TIMERENTRY)); - else - lpTimers = (LPWINE_TIMERENTRY) - HeapAlloc(GetProcessHeap(), 0, - ++nSizeLpTimers * sizeof(WINE_TIMERENTRY)); - } - lpTimers[idx++] = *timer; - - } - - /* Update the time after we make the copy to preserve - the original trigger time */ - timer->dwTriggerTime += timer->wDelay; - - /* TIME_ONESHOT is defined as 0 */ - if (!(timer->wFlags & TIME_PERIODIC)) - { - /* unlink timer from timers list */ - *ptimer = *next_ptimer; - HeapFree(GetProcessHeap(), 0, timer); - - /* We don't need to trigger oneshots again */ - delta_time = INFINITE; - } - else - { - /* Compute when this event needs this function - to be called again */ - if (timer->dwTriggerTime <= cur_time) - delta_time = 0; - else - delta_time = timer->dwTriggerTime - cur_time; - } + delta_time = -1; + break; } - else - delta_time = timer->dwTriggerTime - cur_time; - /* Determine when we need to return to this function */ - ret_time = min(ret_time, delta_time); + timer = LIST_ENTRY( ptr, WINE_TIMERENTRY, entry ); + delta_time = timer->dwTriggerTime - GetTickCount(); + if (delta_time > 0) break; - ptimer = next_ptimer; + list_remove( &timer->entry ); + if (timer->wFlags & TIME_PERIODIC) + { + timer->dwTriggerTime += timer->wDelay; + link_timer( timer ); /* restart it */ + to_free = NULL; + } + else to_free = timer; + + switch(timer->wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE)) + { + case TIME_CALLBACK_EVENT_SET: + SetEvent(timer->lpFunc); + break; + case TIME_CALLBACK_EVENT_PULSE: + PulseEvent(timer->lpFunc); + break; + case TIME_CALLBACK_FUNCTION: + { + DWORD_PTR user = timer->dwUser; + UINT16 id = timer->wTimerID; + UINT16 flags = timer->wFlags; + LPTIMECALLBACK func = timer->lpFunc; + + if (flags & TIME_KILL_SYNCHRONOUS) EnterCriticalSection(&TIME_cbcrst); + LeaveCriticalSection(&WINMM_cs); + + func(id, 0, user, 0, 0); + + EnterCriticalSection(&WINMM_cs); + if (flags & TIME_KILL_SYNCHRONOUS) LeaveCriticalSection(&TIME_cbcrst); + } + break; + } + HeapFree( GetProcessHeap(), 0, to_free ); } - if (TIME_hKillEvent) ResetEvent(TIME_hKillEvent); - LeaveCriticalSection(&iData->cs); - - while (idx > 0) TIME_TriggerCallBack(&lpTimers[--idx]); - if (TIME_hKillEvent) SetEvent(TIME_hKillEvent); - - /* Finally, adjust the recommended wait time downward - by the amount of time the processing routines - actually took */ - adjust_time = GetTickCount() - cur_time; - if (adjust_time > ret_time) - ret_time = 0; - else - ret_time -= adjust_time; - - /* We return the amount of time our caller should sleep - before needing to check in on us again */ - return(ret_time); + LeaveCriticalSection(&WINMM_cs); + return delta_time; } /************************************************************************** @@ -225,9 +197,12 @@ static LPWINE_TIMERENTRY lpTimers; */ static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg) { - LPWINE_MM_IDATA iData = (LPWINE_MM_IDATA)arg; - DWORD sleep_time; - DWORD rc; + int sleep_time, ret; + char readme[16]; + struct pollfd pfd; + + pfd.fd = TIME_fdWake[0]; + pfd.events = POLLIN; TRACE("Starting main winmm thread\n"); @@ -237,19 +212,23 @@ static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg) new event; it's not clear if that would be worth it or not. */ - while (! TIME_TimeToDie) + while (! TIME_TimeToDie) { - sleep_time = TIME_MMSysTimeCallback(iData); + sleep_time = TIME_MMSysTimeCallback(); if (sleep_time == 0) continue; - rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time); - if (rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0) + if ((ret = poll(&pfd, 1, sleep_time)) < 0) { - FIXME("Unexpected error %ld(%ld) in timer thread\n", rc, GetLastError()); - break; - } + if (errno != EINTR && errno != EAGAIN) + { + ERR("Unexpected error in poll: %s(%d)\n", strerror(errno), errno); + break; + } + } + + while (ret > 0) ret = read(TIME_fdWake[0], readme, sizeof(readme)); } TRACE("Exiting main winmm thread\n"); return 0; @@ -258,34 +237,50 @@ static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg) /************************************************************************** * TIME_MMTimeStart */ -void TIME_MMTimeStart(void) +static void TIME_MMTimeStart(void) { if (!TIME_hMMTimer) { - TIME_TimersList = NULL; - TIME_hWakeEvent = CreateEventW(NULL, FALSE, FALSE, NULL); + if (pipe(TIME_fdWake) < 0) + { + TIME_fdWake[0] = TIME_fdWake[1] = -1; + ERR("Cannot create pipe: %s\n", strerror(errno)); + } else { + fcntl(TIME_fdWake[0], F_SETFL, O_NONBLOCK); + fcntl(TIME_fdWake[1], F_SETFL, O_NONBLOCK); + } TIME_TimeToDie = FALSE; - TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, &WINMM_IData, 0, NULL); + TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, NULL, 0, NULL); SetThreadPriority(TIME_hMMTimer, THREAD_PRIORITY_TIME_CRITICAL); } } +#else /* HAVE_POLL */ + +static void TIME_MMTimeStart(void) +{ + FIXME( "not starting system thread\n" ); +} + +#endif /* HAVE_POLL */ + /************************************************************************** * TIME_MMTimeStop */ void TIME_MMTimeStop(void) { if (TIME_hMMTimer) { + const char a='a'; TIME_TimeToDie = TRUE; - SetEvent(TIME_hWakeEvent); + write(TIME_fdWake[1], &a, sizeof(a)); - /* FIXME: in the worst case, we're going to wait 65 seconds here :-( */ - WaitForSingleObject(TIME_hMMTimer, INFINITE); - - CloseHandle(TIME_hMMTimer); - CloseHandle(TIME_hWakeEvent); - TIME_hMMTimer = 0; - TIME_TimersList = NULL; + WaitForSingleObject(TIME_hMMTimer, INFINITE); + close(TIME_fdWake[0]); + close(TIME_fdWake[1]); + TIME_fdWake[0] = TIME_fdWake[1] = -1; + CloseHandle(TIME_hMMTimer); + TIME_hMMTimer = 0; + DeleteCriticalSection(&TIME_cbcrst); } } @@ -305,14 +300,15 @@ MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize) } /************************************************************************** - * TIME_SetEventInternal [internal] + * timeSetEvent [WINMM.@] */ -WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, - LPTIMECALLBACK lpFunc, DWORD dwUser, UINT wFlags) +MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc, + DWORD_PTR dwUser, UINT wFlags) { WORD wNewID = 0; LPWINE_TIMERENTRY lpNewTimer; LPWINE_TIMERENTRY lpTimer; + const char c = 'c'; TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags); @@ -323,8 +319,6 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, if (lpNewTimer == NULL) return 0; - TIME_MMTimeStart(); - lpNewTimer->wDelay = wDelay; lpNewTimer->dwTriggerTime = GetTickCount() + wDelay; @@ -335,70 +329,58 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, lpNewTimer->dwUser = dwUser; lpNewTimer->wFlags = wFlags; - EnterCriticalSection(&WINMM_IData.cs); + EnterCriticalSection(&WINMM_cs); - if ((wFlags & TIME_KILL_SYNCHRONOUS) && !TIME_hKillEvent) - TIME_hKillEvent = CreateEventW(NULL, TRUE, TRUE, NULL); + LIST_FOR_EACH_ENTRY( lpTimer, &timer_list, WINE_TIMERENTRY, entry ) + wNewID = max(wNewID, lpTimer->wTimerID); - for (lpTimer = TIME_TimersList; lpTimer != NULL; lpTimer = lpTimer->lpNext) { - wNewID = max(wNewID, lpTimer->wTimerID); - } - - lpNewTimer->lpNext = TIME_TimersList; - TIME_TimersList = lpNewTimer; + link_timer( lpNewTimer ); lpNewTimer->wTimerID = wNewID + 1; - LeaveCriticalSection(&WINMM_IData.cs); + TIME_MMTimeStart(); + + LeaveCriticalSection(&WINMM_cs); /* Wake the service thread in case there is work to be done */ - SetEvent(TIME_hWakeEvent); + write(TIME_fdWake[1], &c, sizeof(c)); TRACE("=> %u\n", wNewID + 1); return wNewID + 1; } -/************************************************************************** - * timeSetEvent [WINMM.@] - */ -MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc, - DWORD_PTR dwUser, UINT wFlags) -{ - if (wFlags & WINE_TIMER_IS32) - WARN("Unknown windows flag... wine internally used.. ooch\n"); - - return TIME_SetEventInternal(wDelay, wResol, lpFunc, - dwUser, wFlags|WINE_TIMER_IS32); -} - /************************************************************************** * timeKillEvent [WINMM.@] */ MMRESULT WINAPI timeKillEvent(UINT wID) { - LPWINE_TIMERENTRY lpSelf = NULL, *lpTimer; + WINE_TIMERENTRY *lpSelf = NULL, *lpTimer; + DWORD wFlags; TRACE("(%u)\n", wID); - EnterCriticalSection(&WINMM_IData.cs); + EnterCriticalSection(&WINMM_cs); /* remove WINE_TIMERENTRY from list */ - for (lpTimer = &TIME_TimersList; *lpTimer; lpTimer = &(*lpTimer)->lpNext) { - if (wID == (*lpTimer)->wTimerID) { - lpSelf = *lpTimer; - /* unlink timer of id 'wID' */ - *lpTimer = (*lpTimer)->lpNext; + LIST_FOR_EACH_ENTRY( lpTimer, &timer_list, WINE_TIMERENTRY, entry ) + { + if (wID == lpTimer->wTimerID) { + lpSelf = lpTimer; + list_remove( &lpTimer->entry ); break; } } - LeaveCriticalSection(&WINMM_IData.cs); + LeaveCriticalSection(&WINMM_cs); if (!lpSelf) { WARN("wID=%u is not a valid timer ID\n", wID); return MMSYSERR_INVALPARAM; } - if (lpSelf->wFlags & TIME_KILL_SYNCHRONOUS) - WaitForSingleObject(TIME_hKillEvent, INFINITE); + wFlags = lpSelf->wFlags; + if (wFlags & TIME_KILL_SYNCHRONOUS) + EnterCriticalSection(&TIME_cbcrst); HeapFree(GetProcessHeap(), 0, lpSelf); + if (wFlags & TIME_KILL_SYNCHRONOUS) + LeaveCriticalSection(&TIME_cbcrst); return TIMERR_NOERROR; } @@ -456,7 +438,6 @@ MMRESULT WINAPI timeEndPeriod(UINT wPeriod) } /************************************************************************** - * timeGetTime [MMSYSTEM.607] * timeGetTime [WINMM.@] */ DWORD WINAPI timeGetTime(void) @@ -465,7 +446,7 @@ DWORD WINAPI timeGetTime(void) DWORD count; /* FIXME: releasing the win16 lock here is a temporary hack (I hope) - * that lets mciavi.drv run correctly + * that lets mciavi32.dll run correctly */ if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count); if (pFnRestoreThunkLock) pFnRestoreThunkLock(count); diff --git a/reactos/dll/win32/winmm/winemm.h b/reactos/dll/win32/winmm/winemm.h index e74be2cdb8f..725294a7736 100644 --- a/reactos/dll/win32/winmm/winemm.h +++ b/reactos/dll/win32/winmm/winemm.h @@ -1,6 +1,4 @@ -/* -*- tab-width: 8; c-basic-offset: 4 -*- */ - -/***************************************************************************** +/* * Copyright 1998, Luiz Otavio L. Zorzella * 1999, Eric Pouech * @@ -18,8 +16,7 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - ***************************************************************************** + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include @@ -28,20 +25,10 @@ #include "winbase.h" #include "mmddk.h" -#define WINE_DEFAULT_WINMM_DRIVER "oss" -#define WINE_DEFAULT_WINMM_MAPPER "msacm.drv" +#define WINE_DEFAULT_WINMM_DRIVER "alsa,oss,coreaudio,esd" +#define WINE_DEFAULT_WINMM_MAPPER "msacm32.drv" #define WINE_DEFAULT_WINMM_MIDI "midimap.dll" -typedef DWORD (WINAPI *MessageProc16)(UINT16 wDevID, UINT16 wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2); -typedef DWORD (WINAPI *MessageProc32)(UINT wDevID, UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2); - -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 @@ -50,22 +37,14 @@ typedef struct tagWINE_DRIVER DWORD dwMagic; /* as usual LPWINE_DRIVER == hDriver32 */ DWORD dwFlags; - union { - struct { - HMODULE hModule; - DRIVERPROC lpDrvProc; - DWORD 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, DWORD, DWORD); +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 @@ -73,10 +52,7 @@ typedef DWORD (CALLBACK *WINEMM_msgFunc32)(UINT , UINT, DWORD, DWORD, DWORD); 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 @@ -91,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; @@ -101,12 +76,11 @@ typedef struct tagWINE_MLD { UINT uDeviceID; UINT type; UINT mmdIndex; /* index to low-level driver in MMDrvs table */ - DWORD dwDriverInstance; /* this value is driver related, as opposed to + DWORD_PTR dwDriverInstance; /* this value is driver related, as opposed to * opendesc.dwInstance which is client (callback) related */ - WORD bFrom32; WORD dwFlags; - DWORD dwCallback; - DWORD dwClientInstance; + DWORD_PTR dwCallback; + DWORD_PTR dwClientInstance; } WINE_MLD, *LPWINE_MLD; typedef struct { @@ -122,24 +96,6 @@ typedef struct { WINE_MLD mld; } WINE_MIXER, *LPWINE_MIXER; -#define WINE_MMTHREAD_CREATED 0x4153494C /* "BSIL" */ -#define WINE_MMTHREAD_DELETED 0xDEADDEAD - -typedef struct { - DWORD dwSignature; /* 00 "BSIL" when ok, 0xDEADDEAD when being deleted */ - DWORD dwCounter; /* 04 > 1 when in mmThread functions */ - HANDLE hThread; /* 08 hThread */ - DWORD dwThreadID; /* 0C */ - DWORD fpThread; /* 10 address of thread proc (segptr or lin depending on dwFlags) */ - DWORD dwThreadPmt; /* 14 parameter to be passed upon thread creation to fpThread */ - DWORD dwSignalCount; /* 18 counter used for signaling */ - HANDLE hEvent; /* 1C event */ - HANDLE hVxD; /* 20 return from OpenVxDHandle */ - DWORD dwStatus; /* 24 0x00, 0x10, 0x20, 0x30 */ - DWORD dwFlags; /* 28 dwFlags upon creation */ - UINT16 hTask; /* 2C handle to created task */ -} WINE_MMTHREAD; - typedef struct tagWINE_MCIDRIVER { UINT wDeviceID; UINT wType; @@ -147,37 +103,21 @@ typedef struct tagWINE_MCIDRIVER { LPWSTR lpstrDeviceType; LPWSTR lpstrAlias; HDRVR hDriver; - DWORD dwPrivate; + DWORD_PTR dwPrivate; YIELDPROC lpfnYieldProc; DWORD dwYieldData; - BOOL bIs32; DWORD CreatorThread; UINT uTypeCmdTable; UINT uSpecificCmdTable; struct tagWINE_MCIDRIVER*lpNext; } WINE_MCIDRIVER, *LPWINE_MCIDRIVER; -#define WINE_TIMER_IS32 0x80 - -typedef struct tagWINE_TIMERENTRY { - UINT wDelay; - UINT wResol; - LPTIMECALLBACK lpFunc; /* can be lots of things */ - DWORD dwUser; - UINT16 wFlags; - UINT16 wTimerID; - DWORD dwTriggerTime; - struct tagWINE_TIMERENTRY* lpNext; -} WINE_TIMERENTRY, *LPWINE_TIMERENTRY; - -enum mmioProcType {MMIO_PROC_16,MMIO_PROC_32A,MMIO_PROC_32W}; - struct IOProcList { struct IOProcList*pNext; /* Next item in linked list */ FOURCC fourCC; /* four-character code identifying IOProc */ LPMMIOPROC pIOProc; /* pointer to IProc */ - enum mmioProcType type; /* 16, 32A or 32W */ + BOOL is_unicode; /* 32A or 32W */ int count; /* number of objects linked to it */ }; @@ -187,134 +127,53 @@ typedef struct tagWINE_MMIO { struct IOProcList* ioProc; unsigned bTmpIOProc : 1, bBufferLoaded : 1; - DWORD segBuffer16; DWORD dwFileSize; } WINE_MMIO, *LPWINE_MMIO; -typedef struct tagWINE_PLAYSOUND { - unsigned bLoop : 1, - bAlloc : 1; - LPCWSTR pszSound; - HMODULE hMod; - DWORD fdwSound; - HANDLE hThread; - struct tagWINE_PLAYSOUND* lpNext; -} WINE_PLAYSOUND, *LPWINE_PLAYSOUND; - -typedef struct tagWINE_MM_IDATA { - /* winmm part */ - HANDLE hWinMM32Instance; - HANDLE hWinMM16Instance; - CRITICAL_SECTION cs; - /* mci part */ - LPWINE_MCIDRIVER lpMciDrvs; - /* low level drivers (unused yet) */ - /* LPWINE_WAVE lpWave; */ - /* LPWINE_MIDI lpMidi; */ - /* LPWINE_MIXER lpMixer; */ - /* mmio part */ - LPWINE_MMIO lpMMIO; - /* playsound and sndPlaySound */ - WINE_PLAYSOUND* lpPlaySound; - HANDLE psLastEvent; - HANDLE psStopEvent; -} WINE_MM_IDATA, *LPWINE_MM_IDATA; - /* function prototypes */ - -typedef LONG (*MCIPROC)(DWORD, HDRVR, DWORD, DWORD, DWORD); -typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); -typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret); - -HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2); +BOOL WINMM_CheckForMMSystem(void); 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); void DRIVER_UnloadAll(void); - +HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam); +BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper); +BOOL LoadRegistryMMEDrivers(char* key); BOOL MMDRV_Init(void); void MMDRV_Exit(void); UINT MMDRV_GetNum(UINT); LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, - DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32); + DWORD_PTR* dwCallback, DWORD_PTR* dwInstance); void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld); -DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2); +DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwParam2); DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg); 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, BOOL bFrom32); -UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2); -BOOL MMDRV_Is32(unsigned int); -void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, - MMDRV_MAPFUNC, MMDRV_UNMAPFUNC, LPDRVCALLBACK); +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); -WINE_MCIDRIVER* MCI_GetDriver(UINT16 uDevID); -UINT MCI_GetDriverFromString(LPCWSTR str); -DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr); const char* MCI_MessageToString(UINT wMsg); -UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); -LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2); -DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32); -DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); -DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); -UINT MCI_SetCommandTable(void *table, UINT uDevType); -BOOL MCI_DeleteCommandTable(UINT uTbl, BOOL delete); +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); -UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32); -UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32); -UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32); -MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, - DWORD cMidi, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32); -UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, - LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32); - -HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, - DWORD dwOpenFlags, enum mmioProcType type); -LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, - DWORD dwFlags, enum mmioProcType type); -LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1, - LPARAM lParam2, enum mmioProcType type); -LPWINE_MMIO MMIO_Get(HMMIO h); - -WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc, - DWORD dwUser, UINT wFlags); -void TIME_MMTimeStart(void); void TIME_MMTimeStop(void); /* Global variables */ -extern WINE_MM_IDATA WINMM_IData; +extern CRITICAL_SECTION WINMM_cs; +extern HINSTANCE hWinMM32Instance; +extern HANDLE psLastEvent; +extern HANDLE psStopEvent; -/* pointers to 16 bit functions (if sibling MMSYSTEM.DLL is loaded - * NULL otherwise - */ -extern WINE_MMTHREAD* (*pFnGetMMThread16)(UINT16); -extern LPWINE_DRIVER (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM); -extern LRESULT (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM); -extern LRESULT (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM); -extern WINMM_MapType (*pFnMciMapMsg16To32W)(WORD,WORD,DWORD,DWORD*); -extern WINMM_MapType (*pFnMciUnMapMsg16To32W)(WORD,WORD,DWORD,DWORD); -extern WINMM_MapType (*pFnMciMapMsg32WTo16)(WORD,WORD,DWORD,DWORD*); -extern WINMM_MapType (*pFnMciUnMapMsg32WTo16)(WORD,WORD,DWORD,DWORD); -extern LRESULT (*pFnCallMMDrvFunc16)(DWORD /* in fact FARPROC16 */,WORD,WORD,LONG,LONG,LONG); -extern unsigned (*pFnLoadMMDrvFunc16)(LPCSTR,LPWINE_DRIVER, LPWINE_MM_DRIVER); -extern LRESULT (*pFnMmioCallback16)(DWORD,LPMMIOINFO,UINT,LPARAM,LPARAM); -extern void (WINAPI *pFnReleaseThunkLock)(DWORD*); -extern void (WINAPI *pFnRestoreThunkLock)(DWORD); /* 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_EXIST 0x80000000 +#define WINE_GDF_EXTERNAL_MASK 0xF0000000 +#define WINE_GDF_SESSION 0x00000001 + /* Modification to take into account Windows NT's registry format */ @@ -325,4 +184,3 @@ extern void (WINAPI *pFnRestoreThunkLock)(DWORD); "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers" INT LoadRegistryMMEDrivers(char* key); -BOOL MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper); diff --git a/reactos/dll/win32/winmm/winmm.c b/reactos/dll/win32/winmm/winmm.c index c33fed12277..07e22e61b7a 100644 --- a/reactos/dll/win32/winmm/winmm.c +++ b/reactos/dll/win32/winmm/winmm.c @@ -18,7 +18,7 @@ * * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* @@ -50,7 +50,6 @@ #include "mmsystem.h" #include "winuser.h" #include "winnls.h" -#include "winreg.h" #include "winternl.h" #include "winemm.h" @@ -58,30 +57,30 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); -void (WINAPI *pFnReleaseThunkLock)(DWORD*); -void (WINAPI *pFnRestoreThunkLock)(DWORD); - /* ======================================================================== * G L O B A L S E T T I N G S * ========================================================================*/ -WINE_MM_IDATA WINMM_IData; +HINSTANCE hWinMM32Instance; +HANDLE psLastEvent; +HANDLE psStopEvent; + +static CRITICAL_SECTION_DEBUG critsect_debug = +{ + 0, 0, &WINMM_cs, + { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": WINMM_cs") } +}; +CRITICAL_SECTION WINMM_cs = { &critsect_debug, -1, 0, 0, 0, 0 }; /************************************************************************** * WINMM_CreateIData [internal] */ static BOOL WINMM_CreateIData(HINSTANCE hInstDLL) { - memset( &WINMM_IData, 0, sizeof WINMM_IData ); - - WINMM_IData.hWinMM32Instance = hInstDLL; - InitializeCriticalSection(&WINMM_IData.cs); -/* FIXME crashes in ReactOS - WINMM_IData.cs.DebugInfo->Spare[1] = (DWORD)"WINMM_IData"; -*/ - WINMM_IData.psStopEvent = CreateEventW(NULL, TRUE, FALSE, NULL); - WINMM_IData.psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL); - TRACE("Initialized IData (%p)\n", &WINMM_IData); + hWinMM32Instance = hInstDLL; + psStopEvent = CreateEventW(NULL, TRUE, FALSE, NULL); + psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL); return TRUE; } @@ -94,19 +93,17 @@ static void WINMM_DeleteIData(void) /* FIXME: should also free content and resources allocated * inside WINMM_IData */ - CloseHandle(WINMM_IData.psStopEvent); - CloseHandle(WINMM_IData.psLastEvent); - DeleteCriticalSection(&WINMM_IData.cs); + CloseHandle(psStopEvent); + CloseHandle(psLastEvent); + DeleteCriticalSection(&WINMM_cs); } /****************************************************************** * WINMM_LoadMMSystem * */ -#ifndef __REACTOS__ static HANDLE (WINAPI *pGetModuleHandle16)(LPCSTR); static DWORD (WINAPI *pLoadLibrary16)(LPCSTR); -#endif BOOL WINMM_CheckForMMSystem(void) { @@ -119,12 +116,10 @@ BOOL WINMM_CheckForMMSystem(void) loaded = -1; if (h) { -#ifndef __REACTOS__ pGetModuleHandle16 = (void*)GetProcAddress(h, "GetModuleHandle16"); - pLoadLibrary16 = (void*)GetProcAddress(h, "LoadLibrary16"); + pLoadLibrary16 = (void*)GetProcAddress(h, (LPCSTR)35); /* ordinal for LoadLibrary16 */ if (pGetModuleHandle16 && pLoadLibrary16 && (pGetModuleHandle16("MMSYSTEM.DLL") || pLoadLibrary16("MMSYSTEM.DLL"))) -#endif /* __REACTOS__ */ loaded = 1; } } @@ -178,7 +173,7 @@ const char* WINMM_ErrorToString(MMRESULT error) */ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad) { - TRACE("%p 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad); + TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad); switch (fdwReason) { case DLL_PROCESS_ATTACH: @@ -193,10 +188,16 @@ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad) break; case DLL_PROCESS_DETACH: /* close all opened MCI drivers */ - MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L, TRUE); + MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L); MMDRV_Exit(); - /* now unload all remaining drivers... */ - DRIVER_UnloadAll(); + /* There's no guarantee the drivers haven't already been unloaded on + * process shutdown. + */ + if (!fImpLoad) + { + /* now unload all remaining drivers... */ + DRIVER_UnloadAll(); + } WINMM_DeleteIData(); break; @@ -308,47 +309,72 @@ UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL) return MMSYSERR_BADDEVICEID; - return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); + return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } -UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32) +static void CALLBACK MIXER_WCallback(HMIXEROBJ hmx, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam, DWORD_PTR param2) { - HANDLE hMix; - LPWINE_MLD wmld; - DWORD dwRet = 0; - MIXEROPENDESC mod; + HWND hWnd = (HWND)dwInstance; - TRACE("(%p, %d, %08lx, %08lx, %08lx)\n", - lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen); + if (!dwInstance) + return; - wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen, - &dwCallback, &dwInstance, bFrom32); - - wmld->uDeviceID = uDeviceID; - mod.hmx = (HMIXEROBJ)hMix; - mod.dwCallback = dwCallback; - mod.dwInstance = dwInstance; - - dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD)&mod, fdwOpen); - - if (dwRet != MMSYSERR_NOERROR) { - MMDRV_Free(hMix, wmld); - hMix = 0; - } - if (lphMix) *lphMix = hMix; - TRACE("=> %ld hMixer=%p\n", dwRet, hMix); - - return dwRet; + PostMessageW(hWnd, uMsg, (WPARAM)hmx, (LPARAM)dwParam); } /************************************************************************** * mixerOpen [WINMM.@] */ UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD fdwOpen) + DWORD_PTR dwInstance, DWORD fdwOpen) { - return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE); + HANDLE hMix; + LPWINE_MLD wmld; + DWORD dwRet = 0; + MIXEROPENDESC mod; + + TRACE("(%p, %d, %08lx, %08lx, %08x)\n", + lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen); + + mod.dwCallback = (DWORD_PTR)MIXER_WCallback; + mod.dwInstance = 0; + +/* If callback is a function, + * dwCallback contains function pointer + * dwInstance private data + * + * if callback is a window + * dwCallback contains a window handle + */ + switch (fdwOpen & CALLBACK_TYPEMASK) { + default: + return MMSYSERR_INVALFLAG; + + case CALLBACK_NULL: + break; + + case CALLBACK_WINDOW: + mod.dwInstance = dwCallback; + if (dwCallback && !IsWindow((HWND)dwCallback)) + return MMSYSERR_INVALPARAM; + break; + } + + wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen, + &dwCallback, &dwInstance); + wmld->uDeviceID = uDeviceID; + mod.hmx = hMix; + + dwRet = MMDRV_Open(wmld, MXDM_OPEN, (DWORD_PTR)&mod, CALLBACK_FUNCTION); + + if (dwRet != MMSYSERR_NOERROR) { + MMDRV_Free(hMix, wmld); + hMix = 0; + } + if (lphMix) *lphMix = hMix; + TRACE("=> %d hMixer=%p\n", dwRet, hMix); + + return dwRet; } /************************************************************************** @@ -377,7 +403,7 @@ UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID) LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p %p %08lx)\n", hmix, lpid, fdwID); + TRACE("(%p %p %08x)\n", hmix, lpid, fdwID); if ((uRet = MIXER_GetDev(hmix, fdwID, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -397,7 +423,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcdW, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcdW, fdwDetails); if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -406,7 +432,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW return MMSYSERR_INVALPARAM; return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD_PTR)lpmcdW, - fdwDetails, TRUE); + fdwDetails); } /************************************************************************** @@ -417,19 +443,19 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA { DWORD ret = MMSYSERR_NOTENABLED; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcdA, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails); if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA)) return MMSYSERR_INVALPARAM; switch (fdwDetails & MIXER_GETCONTROLDETAILSF_QUERYMASK) { case MIXER_GETCONTROLDETAILSF_VALUE: - /* can savely use A structure as it is, no string inside */ + /* can safely use A structure as it is, no string inside */ ret = mixerGetControlDetailsW(hmix, lpmcdA, fdwDetails); break; case MIXER_GETCONTROLDETAILSF_LISTTEXT: { - MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = (MIXERCONTROLDETAILS_LISTTEXTA *)lpmcdA->paDetails; + MIXERCONTROLDETAILS_LISTTEXTA *pDetailsA = lpmcdA->paDetails; MIXERCONTROLDETAILS_LISTTEXTW *pDetailsW; int size = max(1, lpmcdA->cChannels) * sizeof(MIXERCONTROLDETAILS_LISTTEXTW); unsigned int i; @@ -462,7 +488,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA } break; default: - ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails); + ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails); } return ret; @@ -478,7 +504,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA, DWORD ret; unsigned int i; - TRACE("(%p, %p, %08lx)\n", hmix, lpmlcA, fdwControls); + TRACE("(%p, %p, %08x)\n", hmix, lpmlcA, fdwControls); if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) || lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA)) @@ -492,7 +518,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA, /* Debugging on Windows shows for MIXER_GETLINECONTROLSF_ONEBYTYPE only, the control count is assumed to be 1 - This is relied upon by a game, "Dynomite Deluze" */ - if (MIXER_GETLINECONTROLSF_ONEBYTYPE == fdwControls) { + if (MIXER_GETLINECONTROLSF_ONEBYTYPE == (fdwControls & MIXER_GETLINECONTROLSF_QUERYMASK)) { mlcW.cControls = 1; } else { mlcW.cControls = lpmlcA->cControls; @@ -507,7 +533,6 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA, lpmlcA->dwLineID = mlcW.dwLineID; lpmlcA->u.dwControlID = mlcW.u.dwControlID; lpmlcA->u.dwControlType = mlcW.u.dwControlType; - lpmlcA->cControls = mlcW.cControls; for (i = 0; i < mlcW.cControls; i++) { lpmlcA->pamxctrl[i].cbStruct = sizeof(MIXERCONTROLA); @@ -546,7 +571,7 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW, LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmlcW, fdwControls); + TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls); if ((uRet = MIXER_GetDev(hmix, fdwControls, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -555,7 +580,7 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW, return MMSYSERR_INVALPARAM; return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD_PTR)lpmlcW, - fdwControls, TRUE); + fdwControls); } /************************************************************************** @@ -566,7 +591,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmliW, fdwInfo); + TRACE("(%p, %p, %08x)\n", hmix, lpmliW, fdwInfo); if (lpmliW == NULL || lpmliW->cbStruct != sizeof(*lpmliW)) return MMSYSERR_INVALPARAM; @@ -575,7 +600,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo return uRet; return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD_PTR)lpmliW, - fdwInfo, TRUE); + fdwInfo); } /************************************************************************** @@ -587,7 +612,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA, MIXERLINEW mliW; UINT ret; - TRACE("(%p, %p, %08lx)\n", hmix, lpmliA, fdwInfo); + TRACE("(%p, %p, %08x)\n", hmix, lpmliA, fdwInfo); if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA)) return MMSYSERR_INVALPARAM; @@ -612,36 +637,38 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA, mliW.Target.wMid = lpmliA->Target.wMid; mliW.Target.wPid = lpmliA->Target.wPid; mliW.Target.vDriverVersion = lpmliA->Target.vDriverVersion; - MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)); + MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR)); break; default: - WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo); + WARN("Unsupported fdwControls=0x%08x\n", fdwInfo); return MMSYSERR_INVALFLAG; } ret = mixerGetLineInfoW(hmix, &mliW, fdwInfo); - lpmliA->dwDestination = mliW.dwDestination; - lpmliA->dwSource = mliW.dwSource; - lpmliA->dwLineID = mliW.dwLineID; - lpmliA->fdwLine = mliW.fdwLine; - lpmliA->dwUser = mliW.dwUser; - lpmliA->dwComponentType = mliW.dwComponentType; - lpmliA->cChannels = mliW.cChannels; - lpmliA->cConnections = mliW.cConnections; - lpmliA->cControls = mliW.cControls; - WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName, - sizeof(lpmliA->szShortName), NULL, NULL); - WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName, - sizeof(lpmliA->szName), NULL, NULL ); - lpmliA->Target.dwType = mliW.Target.dwType; - lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID; - lpmliA->Target.wMid = mliW.Target.wMid; - lpmliA->Target.wPid = mliW.Target.wPid; - lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion; - WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname, - sizeof(lpmliA->Target.szPname), NULL, NULL ); - + if(ret == MMSYSERR_NOERROR) + { + lpmliA->dwDestination = mliW.dwDestination; + lpmliA->dwSource = mliW.dwSource; + lpmliA->dwLineID = mliW.dwLineID; + lpmliA->fdwLine = mliW.fdwLine; + lpmliA->dwUser = mliW.dwUser; + lpmliA->dwComponentType = mliW.dwComponentType; + lpmliA->cChannels = mliW.cChannels; + lpmliA->cConnections = mliW.cConnections; + lpmliA->cControls = mliW.cControls; + WideCharToMultiByte( CP_ACP, 0, mliW.szShortName, -1, lpmliA->szShortName, + sizeof(lpmliA->szShortName), NULL, NULL); + WideCharToMultiByte( CP_ACP, 0, mliW.szName, -1, lpmliA->szName, + sizeof(lpmliA->szName), NULL, NULL ); + lpmliA->Target.dwType = mliW.Target.dwType; + lpmliA->Target.dwDeviceID = mliW.Target.dwDeviceID; + lpmliA->Target.wMid = mliW.Target.wMid; + lpmliA->Target.wPid = mliW.Target.wPid; + lpmliA->Target.vDriverVersion = mliW.Target.vDriverVersion; + WideCharToMultiByte( CP_ACP, 0, mliW.Target.szPname, -1, lpmliA->Target.szPname, + sizeof(lpmliA->Target.szPname), NULL, NULL ); + } return ret; } @@ -654,13 +681,13 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcd, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcd, fdwDetails); if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR) return uRet; return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD_PTR)lpmcd, - fdwDetails, TRUE); + fdwDetails); } /************************************************************************** @@ -670,13 +697,13 @@ DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR { LPWINE_MLD wmld; - TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n", - (DWORD)hmix, uMsg, dwParam1, dwParam2); + TRACE("(%p, %d, %08lx, %08lx): semi-stub?\n", + hmix, uMsg, dwParam1, dwParam2); if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2, TRUE); + return MMDRV_Message(wmld, uMsg, dwParam1, dwParam2); } /************************************************************************** @@ -694,13 +721,13 @@ UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize) { LPWINE_MLD wmld; - TRACE("(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize); + TRACE("(%04lX, %p, %d) !\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); + return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } /************************************************************************** @@ -740,7 +767,7 @@ UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume) if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE); + return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L); } /************************************************************************** @@ -750,11 +777,11 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume) { LPWINE_MLD wmld; - TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume); + TRACE("(%04X, %u) !\n", uDeviceID, dwVolume); if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L, TRUE); + return MMDRV_Message(wmld, AUXDM_SETVOLUME, dwVolume, 0L); } /************************************************************************** @@ -767,7 +794,7 @@ UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PT if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, uMessage, dw1, dw2, TRUE); + return MMDRV_Message(wmld, uMessage, dw1, dw2); } /************************************************************************** @@ -786,14 +813,14 @@ UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps, { LPWINE_MLD wmld; - TRACE("(%u, %p, %u);\n", uDeviceID, lpCaps, uSize); + TRACE("(%lu, %p, %u);\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); + return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } /************************************************************************** @@ -862,12 +889,11 @@ UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) if (lpText == NULL) ret = MMSYSERR_INVALPARAM; else if (uSize == 0) ret = MMSYSERR_NOERROR; else if ( - /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit + /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit * a warning for the test was always true */ (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) || (uError >= MIDIERR_BASE && uError <= MIDIERR_LASTERROR)) { - if (LoadStringW(WINMM_IData.hWinMM32Instance, - uError, lpText, uSize) > 0) { + if (LoadStringW(hWinMM32Instance, uError, lpText, uSize) > 0) { ret = MMSYSERR_NOERROR; } } @@ -877,9 +903,9 @@ UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) /************************************************************************** * MIDI_OutAlloc [internal] */ -static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback, - LPDWORD lpdwInstance, LPDWORD lpdwFlags, - DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32) +static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback, + DWORD_PTR* lpdwInstance, LPDWORD lpdwFlags, + DWORD cIDs, MIDIOPENSTRMID* lpIDs) { HANDLE hMidiOut; LPWINE_MIDI lpwm; @@ -888,13 +914,13 @@ static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback, size = sizeof(WINE_MIDI) + (cIDs ? (cIDs-1) : 0) * sizeof(MIDIOPENSTRMID); lpwm = (LPWINE_MIDI)MMDRV_Alloc(size, MMDRV_MIDIOUT, &hMidiOut, lpdwFlags, - lpdwCallback, lpdwInstance, bFrom32); + lpdwCallback, lpdwInstance); if (lphMidiOut != NULL) *lphMidiOut = hMidiOut; if (lpwm) { - lpwm->mod.hMidi = (HMIDI) hMidiOut; + lpwm->mod.hMidi = hMidiOut; lpwm->mod.dwCallback = *lpdwCallback; lpwm->mod.dwInstance = *lpdwInstance; lpwm->mod.dnDevNode = 0; @@ -905,27 +931,29 @@ static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback, return lpwm; } -UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32) +/************************************************************************** + * midiOutOpen [WINMM.@] + */ +UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, + DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags) { HMIDIOUT hMidiOut; LPWINE_MIDI lpwm; UINT dwRet = 0; - TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", + TRACE("(%p, %d, %08lX, %08lX, %08X);\n", lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags); if (lphMidiOut != NULL) *lphMidiOut = 0; - lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags, - 0, NULL, bFrom32); + lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags, 0, NULL); if (lpwm == NULL) return MMSYSERR_NOMEM; lpwm->mld.uDeviceID = uDeviceID; - dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD)&lpwm->mod, dwFlags); + dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags); if (dwRet != MMSYSERR_NOERROR) { MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm); @@ -938,15 +966,6 @@ UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback, return dwRet; } -/************************************************************************** - * midiOutOpen [WINMM.@] - */ -UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, - DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags) -{ - return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE); -} - /************************************************************************** * midiOutClose [WINMM.@] */ @@ -982,7 +1001,7 @@ UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut, if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE); + return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize); } /************************************************************************** @@ -1005,7 +1024,7 @@ UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut, if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE); + return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize); } /************************************************************************** @@ -1015,12 +1034,12 @@ UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg) { LPWINE_MLD wmld; - TRACE("(%p, %08lX)\n", hMidiOut, dwMsg); + TRACE("(%p, %08X)\n", hMidiOut, dwMsg); if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L, TRUE); + return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L); } /************************************************************************** @@ -1036,7 +1055,7 @@ UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut, if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE); + return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize); } /************************************************************************** @@ -1051,7 +1070,7 @@ UINT WINAPI midiOutReset(HMIDIOUT hMidiOut) if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_RESET, 0L, 0L, TRUE); + return MMDRV_Message(wmld, MODM_RESET, 0L, 0L); } /************************************************************************** @@ -1066,7 +1085,7 @@ UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD* lpdwVolume) if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE); + return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L); } /************************************************************************** @@ -1076,12 +1095,12 @@ UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume) { LPWINE_MLD wmld; - TRACE("(%p, %ld);\n", hMidiOut, dwVolume); + TRACE("(%p, %d);\n", hMidiOut, dwVolume); if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L, TRUE); + return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L); } /************************************************************************** @@ -1150,7 +1169,7 @@ UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage, FIXME("can't handle OPEN or CLOSE message!\n"); return MMSYSERR_NOTSUPPORTED; } - return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE); + return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2); } /************************************************************************** @@ -1168,14 +1187,14 @@ UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSi { LPWINE_MLD wmld; - TRACE("(%d, %p, %d);\n", uDeviceID, lpCaps, uSize); + TRACE("(%ld, %p, %d);\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); + return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } /************************************************************************** @@ -1203,48 +1222,42 @@ UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSi return ret; } -UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32) -{ - HANDLE hMidiIn; - LPWINE_MIDI lpwm; - DWORD dwRet = 0; - - TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", - lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); - - if (lphMidiIn != NULL) *lphMidiIn = 0; - - lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn, - &dwFlags, &dwCallback, &dwInstance, bFrom32); - - if (lpwm == NULL) - return MMSYSERR_NOMEM; - - lpwm->mod.hMidi = (HMIDI) hMidiIn; - lpwm->mod.dwCallback = dwCallback; - lpwm->mod.dwInstance = dwInstance; - - lpwm->mld.uDeviceID = uDeviceID; - dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD)&lpwm->mod, dwFlags); - - if (dwRet != MMSYSERR_NOERROR) { - MMDRV_Free(hMidiIn, &lpwm->mld); - hMidiIn = 0; - } - if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; - TRACE("=> %ld hMidi=%p\n", dwRet, hMidiIn); - - return dwRet; -} - /************************************************************************** * midiInOpen [WINMM.@] */ UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags) { - return MIDI_InOpen(lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE); + HANDLE hMidiIn; + LPWINE_MIDI lpwm; + DWORD dwRet = 0; + + TRACE("(%p, %d, %08lX, %08lX, %08X);\n", + lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); + + if (lphMidiIn != NULL) *lphMidiIn = 0; + + lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn, + &dwFlags, &dwCallback, &dwInstance); + + if (lpwm == NULL) + return MMSYSERR_NOMEM; + + lpwm->mod.hMidi = hMidiIn; + lpwm->mod.dwCallback = dwCallback; + lpwm->mod.dwInstance = dwInstance; + + lpwm->mld.uDeviceID = uDeviceID; + dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags); + + if (dwRet != MMSYSERR_NOERROR) { + MMDRV_Free(hMidiIn, &lpwm->mld); + hMidiIn = 0; + } + if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; + TRACE("=> %d hMidi=%p\n", dwRet, hMidiIn); + + return dwRet; } /************************************************************************** @@ -1281,7 +1294,7 @@ UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn, if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE); + return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize); } /************************************************************************** @@ -1304,7 +1317,7 @@ UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn, if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE); + return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize); } /************************************************************************** @@ -1320,7 +1333,7 @@ UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn, if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize, TRUE); + return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize); } /************************************************************************** @@ -1335,7 +1348,7 @@ UINT WINAPI midiInStart(HMIDIIN hMidiIn) if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_START, 0L, 0L, TRUE); + return MMDRV_Message(wmld, MIDM_START, 0L, 0L); } /************************************************************************** @@ -1350,7 +1363,7 @@ UINT WINAPI midiInStop(HMIDIIN hMidiIn) if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L, TRUE); + return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L); } /************************************************************************** @@ -1365,7 +1378,7 @@ UINT WINAPI midiInReset(HMIDIIN hMidiIn) if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L, TRUE); + return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L); } /************************************************************************** @@ -1406,7 +1419,25 @@ UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage, FIXME("can't handle OPEN or CLOSE message!\n"); return MMSYSERR_NOTSUPPORTED; } - return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE); + return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2); +} + +/************************************************************************** + * midiConnect [WINMM.@] + */ +MMRESULT WINAPI midiConnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved) +{ + FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved); + return MMSYSERR_ERROR; +} + +/************************************************************************** + * midiDisconnect [WINMM.@] + */ +MMRESULT WINAPI midiDisconnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved) +{ + FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved); + return MMSYSERR_ERROR; } typedef struct WINE_MIDIStream { @@ -1484,13 +1515,13 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI /* this is not quite what MS doc says... */ midiOutReset(lpMidiStrm->hDevice); /* empty list of already submitted buffers */ - for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext) { + for (lpMidiHdr = lpMidiStrm->lpMidiHdr; lpMidiHdr; lpMidiHdr = lpMidiHdr->lpNext) { lpMidiHdr->dwFlags |= MHDR_DONE; lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE, - lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L); + lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0); } lpMidiStrm->lpMidiHdr = 0; SetEvent(lpMidiStrm->hEvent); @@ -1529,9 +1560,9 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI */ lpMidiHdr = (LPMIDIHDR)msg->lParam; lpData = (LPBYTE)lpMidiHdr->lpData; - TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n", + TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBufferLength=%u/%u dwFlags=0x%08x size=%lu]\n", (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr, - (DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded, + lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded, lpMidiHdr->dwFlags, msg->wParam); #if 0 /* dumps content of lpMidiHdr->lpData @@ -1556,7 +1587,7 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI if (((LPMIDIEVENT)lpData)->dwStreamID != 0 && ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF && ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) { - FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n", + FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n", (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", ((LPMIDIEVENT)lpData)->dwStreamID); lpMidiHdr->dwFlags |= MHDR_DONE; @@ -1564,11 +1595,11 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE, - lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L); + lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0); break; } - for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = (LPMIDIHDR*)&((*lpmh)->lpNext)); + for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = &(*lpmh)->lpNext); *lpmh = lpMidiHdr; lpMidiHdr = (LPMIDIHDR)msg->lParam; lpMidiHdr->lpNext = 0; @@ -1646,7 +1677,7 @@ static DWORD CALLBACK MMSYSTEM_MidiStream_Player(LPVOID pmt) dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS; - TRACE("%ld/%ld/%ld\n", dwToGo, GetTickCount(), me->dwDeltaTime); + TRACE("%d/%d/%d\n", dwToGo, GetTickCount(), me->dwDeltaTime); while ((dwCurrTC = GetTickCount()) < dwToGo) { if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) { /* got a message, handle it */ @@ -1696,10 +1727,10 @@ static DWORD CALLBACK MMSYSTEM_MidiStream_Player(LPVOID pmt) lpMidiHdr->dwFlags |= MHDR_DONE; lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; - lpMidiStrm->lpMidiHdr = (LPMIDIHDR)lpMidiHdr->lpNext; + lpMidiStrm->lpMidiHdr = lpMidiHdr->lpNext; DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags, (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE, - lpwm->mod.dwInstance, (DWORD)lpMidiHdr, 0L); + lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0); lpData = 0; } } @@ -1715,11 +1746,11 @@ the_end: static BOOL MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream* lpMidiStrm, WORD msg, DWORD pmt1, DWORD pmt2) { if (PostThreadMessageA(lpMidiStrm->dwThreadID, msg, pmt1, pmt2)) { - DWORD count; + //DWORD count; - if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count); + //ReleaseThunkLock(&count); WaitForSingleObject(lpMidiStrm->hEvent, INFINITE); - if (pFnRestoreThunkLock) pFnRestoreThunkLock(count); + //RestoreThunkLock(count); } else { WARN("bad PostThreadMessageA\n"); return FALSE; @@ -1748,11 +1779,11 @@ MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm) } /************************************************************************** - * MMSYSTEM_MidiStream_Open [internal] + * midiStreamOpen [WINMM.@] */ -MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi, - DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen, - BOOL bFrom32) +MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, + DWORD cMidi, DWORD_PTR dwCallback, + DWORD_PTR dwInstance, DWORD fdwOpen) { WINE_MIDIStream* lpMidiStrm; MMRESULT ret; @@ -1760,7 +1791,7 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi LPWINE_MIDI lpwm; HMIDIOUT hMidiOut; - TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n", + TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n", lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen); if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL) @@ -1771,20 +1802,20 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi return MMSYSERR_NOMEM; lpMidiStrm->dwTempo = 500000; - lpMidiStrm->dwTimeDiv = 480; /* 480 is 120 quater notes per minute *//* FIXME ??*/ + lpMidiStrm->dwTimeDiv = 480; /* 480 is 120 quarter notes per minute *//* FIXME ??*/ lpMidiStrm->dwPositionMS = 0; mosm.dwStreamID = (DWORD)lpMidiStrm; /* FIXME: the correct value is not allocated yet for MAPPER */ mosm.wDeviceID = *lpuDeviceID; - lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm, bFrom32); + lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm); lpMidiStrm->hDevice = hMidiOut; if (lphMidiStrm) *lphMidiStrm = (HMIDISTRM)hMidiOut; lpwm->mld.uDeviceID = *lpuDeviceID; - ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD)&lpwm->mod, fdwOpen); + ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD_PTR)&lpwm->mod, fdwOpen); lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL); lpMidiStrm->wFlags = HIWORD(fdwOpen); @@ -1799,15 +1830,15 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi /* wait for thread to have started, and for its queue to be created */ { - DWORD count; + //DWORD count; /* (Release|Restore)ThunkLock() is needed when this method is called from 16 bit code, * (meaning the Win16Lock is set), so that it's released and the 32 bit thread running * MMSYSTEM_MidiStreamPlayer can acquire Win16Lock to create its queue. */ - if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count); + //ReleaseThunkLock(&count); WaitForSingleObject(lpMidiStrm->hEvent, INFINITE); - if (pFnRestoreThunkLock) pFnRestoreThunkLock(count); + //RestoreThunkLock(count); } TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n", @@ -1815,17 +1846,6 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi return ret; } -/************************************************************************** - * midiStreamOpen [WINMM.@] - */ -MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, - DWORD cMidi, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD fdwOpen) -{ - return MIDI_StreamOpen(lphMidiStrm, lpuDeviceID, cMidi, dwCallback, - dwInstance, fdwOpen, TRUE); -} - /************************************************************************** * midiStreamOut [WINMM.@] */ @@ -1844,7 +1864,7 @@ MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr, } else { if (!PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_HEADER, cbMidiHdr, - (DWORD)lpMidiHdr)) { + (LPARAM)lpMidiHdr)) { WARN("bad PostThreadMessageA\n"); ret = MMSYSERR_ERROR; } @@ -1866,7 +1886,7 @@ MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm) ret = MMSYSERR_INVALHANDLE; } else { if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) { - WARN("bad Suspend (%ld)\n", GetLastError()); + WARN("bad Suspend (%d)\n", GetLastError()); ret = MMSYSERR_ERROR; } } @@ -1891,11 +1911,11 @@ MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbm switch (lpMMT->wType) { case TIME_MS: lpMMT->u.ms = lpMidiStrm->dwPositionMS; - TRACE("=> %ld ms\n", lpMMT->u.ms); + TRACE("=> %d ms\n", lpMMT->u.ms); break; case TIME_TICKS: lpMMT->u.ticks = lpMidiStrm->dwPulses; - TRACE("=> %ld ticks\n", lpMMT->u.ticks); + TRACE("=> %d ticks\n", lpMMT->u.ticks); break; default: WARN("Unsupported time type %d\n", lpMMT->wType); @@ -1915,7 +1935,7 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD WINE_MIDIStream* lpMidiStrm; MMRESULT ret = MMSYSERR_NOERROR; - TRACE("(%p, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty); + TRACE("(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty); if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) { ret = MMSYSERR_INVALHANDLE; @@ -1928,10 +1948,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_SET) { lpMidiStrm->dwTempo = mpt->dwTempo; - TRACE("Setting tempo to %ld\n", mpt->dwTempo); + TRACE("Setting tempo to %d\n", mpt->dwTempo); } else if (dwProperty & MIDIPROP_GET) { mpt->dwTempo = lpMidiStrm->dwTempo; - TRACE("Getting tempo <= %ld\n", mpt->dwTempo); + TRACE("Getting tempo <= %d\n", mpt->dwTempo); } } else if (dwProperty & MIDIPROP_TIMEDIV) { MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData; @@ -1940,10 +1960,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_SET) { lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv; - TRACE("Setting time div to %ld\n", mptd->dwTimeDiv); + TRACE("Setting time div to %d\n", mptd->dwTimeDiv); } else if (dwProperty & MIDIPROP_GET) { mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv; - TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv); + TRACE("Getting time div <= %d\n", mptd->dwTimeDiv); } } else { ret = MMSYSERR_INVALPARAM; @@ -1974,7 +1994,7 @@ MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm) ret = ResumeThread(lpMidiStrm->hThread); } while (ret != 0xFFFFFFFF && ret != 0); if (ret == 0xFFFFFFFF) { - WARN("bad Resume (%ld)\n", GetLastError()); + WARN("bad Resume (%d)\n", GetLastError()); ret = MMSYSERR_ERROR; } else { lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS; @@ -2003,18 +2023,18 @@ MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm) return ret; } -UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, - LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32) +static UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, + LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, + DWORD_PTR dwInstance, DWORD dwFlags) { HANDLE handle; LPWINE_MLD wmld; DWORD dwRet = MMSYSERR_NOERROR; WAVEOPENDESC wod; - TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08lX, %d);\n", + TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08X);\n", lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback, - dwInstance, dwFlags, bFrom32?32:16); + dwInstance, dwFlags); if (dwFlags & WAVE_FORMAT_QUERY) TRACE("WAVE_FORMAT_QUERY requested !\n"); @@ -2030,12 +2050,12 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, } /* may have a PCMWAVEFORMAT rather than a WAVEFORMATEX so don't read cbSize */ - TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u\n", + TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u\n", lpFormat->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec, lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample); if ((wmld = MMDRV_Alloc(sizeof(WINE_WAVE), uType, &handle, - &dwFlags, &dwCallback, &dwInstance, bFrom32)) == NULL) { + &dwFlags, &dwCallback, &dwInstance)) == NULL) { WARN("no memory\n"); return MMSYSERR_NOMEM; } @@ -2056,14 +2076,14 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, wod.uMappedDeviceID = -1; } wmld->uDeviceID = uDeviceID; - + dwRet = MMDRV_Open(wmld, (uType == MMDRV_WAVEOUT) ? WODM_OPEN : WIDM_OPEN, - (DWORD)&wod, dwFlags); + (DWORD_PTR)&wod, dwFlags); TRACE("dwRet = %s\n", WINMM_ErrorToString(dwRet)); if (dwRet != WAVERR_BADFORMAT || ((dwFlags & (WAVE_MAPPED|WAVE_FORMAT_DIRECT)) != 0) || (uDeviceID == WAVE_MAPPER)) break; - /* if we ask for a format which isn't supported by the physical driver, + /* if we ask for a format which isn't supported by the physical driver, * let's try to map it through the wave mapper (except, if we already tried * or user didn't allow us to use acm codecs or the device is already the mapper) */ @@ -2126,15 +2146,14 @@ UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps, { LPWINE_MLD wmld; - TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize); + TRACE("(%lu %p %u)!\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL) return MMSYSERR_BADDEVICEID; - return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); - + return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } /************************************************************************** @@ -2173,11 +2192,11 @@ UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) if (lpText == NULL) ret = MMSYSERR_INVALPARAM; else if (uSize == 0) ret = MMSYSERR_NOERROR; else if ( - /* test has been removed 'coz MMSYSERR_BASE is 0, and gcc did emit + /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit * a warning for the test was always true */ (/*uError >= MMSYSERR_BASE && */ uError <= MMSYSERR_LASTERROR) || (uError >= WAVERR_BASE && uError <= WAVERR_LASTERROR)) { - if (LoadStringW(WINMM_IData.hWinMM32Instance, + if (LoadStringW(hWinMM32Instance, uError, lpText, uSize) > 0) { ret = MMSYSERR_NOERROR; } @@ -2194,7 +2213,7 @@ MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID, DWORD_PTR dwInstance, DWORD dwFlags) { return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat, - dwCallback, dwInstance, dwFlags, TRUE); + dwCallback, dwInstance, dwFlags); } /************************************************************************** @@ -2235,7 +2254,7 @@ UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut, return MMSYSERR_INVALHANDLE; if ((result = MMDRV_Message(wmld, WODM_PREPARE, (DWORD_PTR)lpWaveOutHdr, - uSize, TRUE)) != MMSYSERR_NOTSUPPORTED) + uSize)) != MMSYSERR_NOTSUPPORTED) return result; if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE) @@ -2260,7 +2279,7 @@ UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut, if (lpWaveOutHdr == NULL || uSize < sizeof (WAVEHDR)) return MMSYSERR_INVALPARAM; - + if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) { return MMSYSERR_NOERROR; } @@ -2269,7 +2288,7 @@ UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut, return MMSYSERR_INVALHANDLE; if ((result = MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD_PTR)lpWaveOutHdr, - uSize, TRUE)) != MMSYSERR_NOTSUPPORTED) + uSize)) != MMSYSERR_NOTSUPPORTED) return result; if (lpWaveOutHdr->dwFlags & WHDR_INQUEUE) @@ -2294,7 +2313,7 @@ UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr, if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE); + return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize); } /************************************************************************** @@ -2308,7 +2327,7 @@ UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WODM_BREAKLOOP, 0L, 0L); } /************************************************************************** @@ -2322,7 +2341,7 @@ UINT WINAPI waveOutPause(HWAVEOUT hWaveOut) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WODM_PAUSE, 0L, 0L); } /************************************************************************** @@ -2336,7 +2355,7 @@ UINT WINAPI waveOutReset(HWAVEOUT hWaveOut) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_RESET, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WODM_RESET, 0L, 0L); } /************************************************************************** @@ -2350,7 +2369,7 @@ UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WODM_RESTART, 0L, 0L); } /************************************************************************** @@ -2366,7 +2385,7 @@ UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime, if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE); + return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize); } /************************************************************************** @@ -2376,11 +2395,11 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L); } /************************************************************************** @@ -2390,11 +2409,11 @@ UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_SETPITCH, dw, 0L); } /************************************************************************** @@ -2404,11 +2423,11 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L); } /************************************************************************** @@ -2418,11 +2437,11 @@ UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_SETPLAYBACKRATE, dw, 0L); } /************************************************************************** @@ -2432,12 +2451,17 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); - if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL) + if (lpdw == NULL) { + WARN("invalid parameter\n"); + return MMSYSERR_INVALPARAM; + } + + if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L); } /************************************************************************** @@ -2447,12 +2471,12 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L, TRUE); + return MMDRV_Message(wmld, WODM_SETVOLUME, dw, 0L); } /************************************************************************** @@ -2497,7 +2521,7 @@ UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage, return MMSYSERR_INVALPARAM; } - return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE); + return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2); } /************************************************************************** @@ -2515,14 +2539,14 @@ UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSi { LPWINE_MLD wmld; - TRACE("(%u %p %u)!\n", uDeviceID, lpCaps, uSize); + TRACE("(%lu %p %u)!\n", uDeviceID, lpCaps, uSize); if (lpCaps == NULL) return MMSYSERR_INVALPARAM; if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL) return MMSYSERR_BADDEVICEID; - return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE); + return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize); } /************************************************************************** @@ -2554,12 +2578,12 @@ UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSi /************************************************************************** * waveInOpen [WINMM.@] */ -MMRESULT WINAPI waveInOpen(LPHWAVEIN lphWaveIn, UINT uDeviceID, - LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, - DWORD_PTR dwInstance, DWORD dwFlags) +MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID, + LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, + DWORD_PTR dwInstance, DWORD dwFlags) { return WAVE_Open((HANDLE*)lphWaveIn, uDeviceID, MMDRV_WAVEIN, lpFormat, - dwCallback, dwInstance, dwFlags, TRUE); + dwCallback, dwInstance, dwFlags); } /************************************************************************** @@ -2575,7 +2599,7 @@ UINT WINAPI waveInClose(HWAVEIN hWaveIn) if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L, TRUE); + dwRet = MMDRV_Message(wmld, WIDM_CLOSE, 0L, 0L); if (dwRet != WAVERR_STILLPLAYING) MMDRV_Free(hWaveIn, wmld); return dwRet; @@ -2599,7 +2623,7 @@ UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr, return MMSYSERR_INVALHANDLE; if ((result = MMDRV_Message(wmld, WIDM_PREPARE, (DWORD_PTR)lpWaveInHdr, - uSize, TRUE)) != MMSYSERR_NOTSUPPORTED) + uSize)) != MMSYSERR_NOTSUPPORTED) return result; if (lpWaveInHdr->dwFlags & WHDR_INQUEUE) @@ -2633,7 +2657,7 @@ UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr, return MMSYSERR_INVALHANDLE; if ((result = MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD_PTR)lpWaveInHdr, - uSize, TRUE)) != MMSYSERR_NOTSUPPORTED) + uSize)) != MMSYSERR_NOTSUPPORTED) return result; if (lpWaveInHdr->dwFlags & WHDR_INQUEUE) @@ -2659,7 +2683,7 @@ UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn, if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize, TRUE); + return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize); } /************************************************************************** @@ -2674,7 +2698,7 @@ UINT WINAPI waveInReset(HWAVEIN hWaveIn) if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WIDM_RESET, 0L, 0L); } /************************************************************************** @@ -2689,7 +2713,7 @@ UINT WINAPI waveInStart(HWAVEIN hWaveIn) if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WIDM_START, 0L, 0L, TRUE); + return MMDRV_Message(wmld, WIDM_START, 0L, 0L); } /************************************************************************** @@ -2704,7 +2728,7 @@ UINT WINAPI waveInStop(HWAVEIN hWaveIn) if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L, TRUE); + return MMDRV_Message(wmld,WIDM_STOP, 0L, 0L); } /************************************************************************** @@ -2720,7 +2744,7 @@ UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime, if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; - return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE); + return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize); } /************************************************************************** @@ -2763,7 +2787,7 @@ UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage, return MMSYSERR_INVALPARAM; - return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2, TRUE); + return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2); } struct mm_starter @@ -2787,7 +2811,7 @@ static DWORD WINAPI mmTaskRun(void* pmt) /****************************************************************** * mmTaskCreate (WINMM.@) */ -MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD client) +UINT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD_PTR client) { HANDLE hThread; HANDLE hEvent = 0; @@ -2816,7 +2840,7 @@ MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD client) /****************************************************************** * mmTaskBlock (WINMM.@) */ -void WINAPI mmTaskBlock(HANDLE tid) +VOID WINAPI mmTaskBlock(DWORD tid) { MSG msg; @@ -2830,20 +2854,20 @@ void WINAPI mmTaskBlock(HANDLE tid) /****************************************************************** * mmTaskSignal (WINMM.@) */ -BOOL WINAPI mmTaskSignal(HANDLE tid) +BOOL WINAPI mmTaskSignal(DWORD tid) { - return PostThreadMessageW((DWORD)tid, WM_USER, 0, 0); + return PostThreadMessageW(tid, WM_USER, 0, 0); } /****************************************************************** * mmTaskYield (WINMM.@) */ -void WINAPI mmTaskYield(void) {} +VOID WINAPI mmTaskYield(VOID) {} /****************************************************************** * mmGetCurrentTask (WINMM.@) */ -HANDLE WINAPI mmGetCurrentTask(void) +DWORD WINAPI mmGetCurrentTask(VOID) { - return (HANDLE)GetCurrentThreadId(); + return GetCurrentThreadId(); } diff --git a/reactos/dll/win32/winmm/winmm.rbuild b/reactos/dll/win32/winmm/winmm.rbuild index 3645255311c..1231b37ddcc 100644 --- a/reactos/dll/win32/winmm/winmm.rbuild +++ b/reactos/dll/win32/winmm/winmm.rbuild @@ -14,6 +14,7 @@ kernel32 advapi32 user32 + pseh driver.c joystick.c lolvldrv.c diff --git a/reactos/dll/win32/winmm/winmm.spec b/reactos/dll/win32/winmm/winmm.spec index 9e216f35610..870b7755bc3 100644 --- a/reactos/dll/win32/winmm/winmm.spec +++ b/reactos/dll/win32/winmm/winmm.spec @@ -26,7 +26,7 @@ @ stdcall auxGetVolume(long ptr) @ stdcall auxOutMessage(long long long long) @ stdcall auxSetVolume(long long) -@ stub joyConfigChanged +@ stdcall joyConfigChanged(long) @ stdcall joyGetDevCapsA(long ptr long) @ stdcall joyGetDevCapsW(long ptr long) @ stdcall joyGetNumDevs() @@ -56,8 +56,8 @@ @ stdcall mciSendStringW(wstr ptr long long) @ stdcall mciSetDriverData(long long) @ stdcall mciSetYieldProc(long ptr long) -@ stub midiConnect -@ stub midiDisconnect +@ stdcall midiConnect(long long ptr) +@ stdcall midiDisconnect(long long ptr) @ stdcall midiInAddBuffer(long ptr long) @ stdcall midiInClose(long) @ stdcall midiInGetDevCapsA(long ptr long) diff --git a/reactos/include/psdk/mmddk.h b/reactos/include/psdk/mmddk.h index 87bb33faab2..25f85dabb92 100644 --- a/reactos/include/psdk/mmddk.h +++ b/reactos/include/psdk/mmddk.h @@ -452,18 +452,18 @@ BOOL WINAPI mciFreeCommandResource(UINT uTable); #define DCB_TYPEMASK 0x0007 #define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */ -BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, - UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2); +BOOL APIENTRY DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev, + DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2); typedef void (*LPTASKCALLBACK)(DWORD dwInst); #define TASKERR_NOTASKSUPPORT 1 #define TASKERR_OUTOFMEMORY 2 MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK, HANDLE*, DWORD); -void WINAPI mmTaskBlock(HANDLE); -BOOL WINAPI mmTaskSignal(HANDLE); +void WINAPI mmTaskBlock(DWORD); +BOOL WINAPI mmTaskSignal(DWORD); void WINAPI mmTaskYield(void); -HANDLE WINAPI mmGetCurrentTask(void); +DWORD WINAPI mmGetCurrentTask(void); #define WAVE_DIRECTSOUND 0x0080 diff --git a/reactos/include/psdk/mmsystem.h b/reactos/include/psdk/mmsystem.h index 6c1b96e2aaf..102338d9f53 100644 --- a/reactos/include/psdk/mmsystem.h +++ b/reactos/include/psdk/mmsystem.h @@ -159,7 +159,7 @@ extern "C" { #define SND_PURGE 0x40 #define SND_APPLICATION 0x80 #define SND_ALIAS_START 0 -#define sndAlias(c0,c1) (SND_ALIAS_START+(DWORD)(BYTE)(c0)|((DWORD)(BYTE)(c1)<<8)) +#define sndAlias(c0,c1) (SND_ALIAS_START+((DWORD)(BYTE)(c0)|((DWORD)(BYTE)(c1)<<8))) #define SND_ALIAS_SYSTEMASTERISK sndAlias('S','*') #define SND_ALIAS_SYSTEMQUESTION sndAlias('S','?') #define SND_ALIAS_SYSTEMHAND sndAlias('S','H')