ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

winmm: Remove WINE_NO_LONG_AS_INT.

This commit is contained in:
Eric Pouech 2006-11-08 22:24:36 +01:00 committed by Alexandre Julliard
parent 64410e5907
commit 2f540b8602
12 changed files with 209 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dlls/winmm/Makefile.in
View File

@ -1,4 +1,4 @@
EXTRADEFS = -D_WINMM_ -DWINE_NO_LONG_AS_INT EXTRADEFS = -D_WINMM_
TOPSRCDIR = @top_srcdir@ TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../.. TOPOBJDIR = ../..
SRCDIR = @srcdir@ SRCDIR = @srcdir@

10
dlls/winmm/driver.c
View File

@ -573,21 +573,21 @@ BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
UINT wMsg, DWORD dwUser, DWORD dwParam1, UINT wMsg, DWORD dwUser, DWORD dwParam1,
DWORD dwParam2) DWORD dwParam2)
{ {
TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n", TRACE("(%08X, %04X, %p, %04X, %08X, %08X, %08X); !\n",
dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2); dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
switch (uFlags & DCB_TYPEMASK) { switch (uFlags & DCB_TYPEMASK) {
case DCB_NULL: case DCB_NULL:
TRACE("Null !\n"); TRACE("Null !\n");
if (dwCallBack) if (dwCallBack)
WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack); WARN("uFlags=%04X has null DCB value, but dwCallBack=%08X is not null !\n", uFlags, dwCallBack);
break; break;
case DCB_WINDOW: case DCB_WINDOW:
TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev); TRACE("Window(%04X) handle=%p!\n", dwCallBack, hDev);
PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1); PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break; break;
case DCB_TASK: /* aka DCB_THREAD */ case DCB_TASK: /* aka DCB_THREAD */
TRACE("Task(%04lx) !\n", dwCallBack); TRACE("Task(%04x) !\n", dwCallBack);
PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1); PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
break; break;
case DCB_FUNCTION: case DCB_FUNCTION:
@ -595,7 +595,7 @@ BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2); ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
break; break;
case DCB_EVENT: case DCB_EVENT:
TRACE("Event(%08lx) !\n", dwCallBack); TRACE("Event(%08x) !\n", dwCallBack);
SetEvent((HANDLE)dwCallBack); SetEvent((HANDLE)dwCallBack);
break; break;
case 6: /* I would dub it DCB_MMTHREADSIGNAL */ case 6: /* I would dub it DCB_MMTHREADSIGNAL */

16
dlls/winmm/lolvldrv.c
View File

@ -189,7 +189,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
WINMM_MapType map; WINMM_MapType map;
int devID; int devID;
TRACE("(%s %u %u 0x%08lx 0x%08lx 0x%08lx %c)\n", TRACE("(%s %u %u 0x%08x 0x%08lx 0x%08lx %c)\n",
llTypes[mld->type].typestr, mld->uDeviceID, wMsg, llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N'); mld->dwDriverInstance, dwParam1, dwParam2, bFrom32?'Y':'N');
@ -223,7 +223,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
assert(part->u.fnMessage32); assert(part->u.fnMessage32);
if (bFrom32) { if (bFrom32) {
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret)); TRACE("=> %s\n", WINMM_ErrorToString(ret));
@ -239,7 +239,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
break; break;
case WINMM_MAP_OK: case WINMM_MAP_OK:
case WINMM_MAP_OKMEM: case WINMM_MAP_OKMEM:
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance,
dwParam1, dwParam2); dwParam1, dwParam2);
@ -268,7 +268,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
break; break;
case WINMM_MAP_OK: case WINMM_MAP_OK:
case WINMM_MAP_OKMEM: case WINMM_MAP_OKMEM:
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
mld->uDeviceID, wMsg, mld->dwDriverInstance, mld->uDeviceID, wMsg, mld->dwDriverInstance,
@ -283,7 +283,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
break; break;
} }
} else { } else {
TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16,
mld->uDeviceID, wMsg, mld->dwDriverInstance, mld->uDeviceID, wMsg, mld->dwDriverInstance,
@ -298,7 +298,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
* MMDRV_Alloc [internal] * MMDRV_Alloc [internal]
*/ */
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32) DWORD_PTR* dwCallback, DWORD_PTR* dwInstance, BOOL bFrom32)
{ {
LPWINE_MLD mld; LPWINE_MLD mld;
UINT i; UINT i;
@ -370,7 +370,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags)
DWORD dwRet = MMSYSERR_BADDEVICEID; DWORD dwRet = MMSYSERR_BADDEVICEID;
DWORD dwInstance; DWORD dwInstance;
WINE_LLTYPE* llType = &llTypes[mld->type]; WINE_LLTYPE* llType = &llTypes[mld->type];
TRACE("(%p, %04x, 0x%08lx, 0x%08lx)\n", mld, wMsg, dwParam1, dwFlags); TRACE("(%p, %04x, 0x%08x, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags);
mld->dwDriverInstance = (DWORD)&dwInstance; mld->dwDriverInstance = (DWORD)&dwInstance;
@ -490,7 +490,7 @@ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1,
{ {
WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex]; WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex];
TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2); TRACE("(%p, %04x, %08x, %08x)\n", mld, uMsg, dwParam1, dwParam2);
/* all those function calls are undocumented */ /* all those function calls are undocumented */
switch (uMsg) { switch (uMsg) {

46
dlls/winmm/mci.c
View File

@ -1429,7 +1429,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
*/ */
if (lpstrRet && uRetLen) *lpstrRet = '\0'; 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, wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
data[0], debugstr_w((WCHAR *)data[0]), data[1], debugstr_w((WCHAR *)data[1]), 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]), data[2], debugstr_w((WCHAR *)data[2]), data[3], debugstr_w((WCHAR *)data[3]),
@ -1442,9 +1442,9 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
} else { } else {
dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE); dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE);
} }
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); 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: errCleanUp:
HeapFree(GetProcessHeap(), 0, verb); HeapFree(GetProcessHeap(), 0, verb);
@ -1498,7 +1498,7 @@ BOOL WINAPI mciExecute(LPCSTR lpstrCommand)
ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0); ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0);
if (ret != 0) { if (ret != 0) {
if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) { if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) {
sprintf(strRet, "Unknown MCI error (%ld)", ret); sprintf(strRet, "Unknown MCI error (%d)", ret);
} }
MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK); MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
} }
@ -1639,7 +1639,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
DWORD dwRet; DWORD dwRet;
LPWINE_MCIDRIVER wmd = NULL; LPWINE_MCIDRIVER wmd = NULL;
TRACE("(%08lX, %p)\n", dwParam, lpParms); TRACE("(%08X, %p)\n", dwParam, lpParms);
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
/* only two low bytes are generic, the other ones are dev type specific */ /* only two low bytes are generic, the other ones are dev type specific */
@ -1741,13 +1741,13 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
} }
if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) { 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 ? */ /* FIXME: is dwRet the correct ret code ? */
goto errCleanUp; goto errCleanUp;
} }
/* only handled devices fall through */ /* 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) if (dwParam & MCI_NOTIFY)
mciDriverNotify((HWND)lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL); mciDriverNotify((HWND)lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
@ -1769,7 +1769,7 @@ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms
DWORD dwRet; DWORD dwRet;
LPWINE_MCIDRIVER wmd; 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) { if (wDevID == MCI_ALL_DEVICE_ID) {
LPWINE_MCIDRIVER next; LPWINE_MCIDRIVER next;
@ -1837,7 +1837,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", TRACE("(%08x, %08X, %08X[num=%d, wDevTyp=%u])\n",
uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType); uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
switch (dwFlags & ~MCI_SYSINFO_OPEN) { switch (dwFlags & ~MCI_SYSINFO_OPEN) {
@ -1875,7 +1875,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
} }
} }
*(DWORD*)lpParms->lpstrReturn = cnt; *(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; ret = MCI_INTEGER_RETURNED;
break; break;
case MCI_SYSINFO_INSTALLNAME: case MCI_SYSINFO_INSTALLNAME:
@ -1887,7 +1887,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
*lpParms->lpstrReturn = 0; *lpParms->lpstrReturn = 0;
ret = MCIERR_INVALID_DEVICE_ID; 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; break;
case MCI_SYSINFO_NAME: case MCI_SYSINFO_NAME:
TRACE("MCI_SYSINFO_NAME\n"); TRACE("MCI_SYSINFO_NAME\n");
@ -1911,7 +1911,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
if (!s) { if (!s) {
if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) { if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) {
for (p = buf; *p; p += strlenW(p) + 1, cnt++) { 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) { if (cnt == lpParms->dwNumber - 1) {
s = p; s = p;
break; break;
@ -1921,10 +1921,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; 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; break;
default: default:
TRACE("Unsupported flag value=%08lx\n", dwFlags); TRACE("Unsupported flag value=%08x\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_COMMAND; ret = MCIERR_UNRECOGNIZED_COMMAND;
} }
return ret; return ret;
@ -1969,8 +1969,8 @@ static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms)
/************************************************************************** /**************************************************************************
* MCI_SendCommand [internal] * MCI_SendCommand [internal]
*/ */
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1,
DWORD dwParam2, BOOL bFrom32) DWORD_PTR dwParam2, BOOL bFrom32)
{ {
DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND; DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
@ -2086,7 +2086,7 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2)
LPMCI_GETDEVCAPS_PARMS lmgp; LPMCI_GETDEVCAPS_PARMS lmgp;
lmgp = (LPMCI_GETDEVCAPS_PARMS)(void*)dwParam2; lmgp = (LPMCI_GETDEVCAPS_PARMS)(void*)dwParam2;
TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn)); TRACE("Changing %08x to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn));
lmgp->dwReturn = LOWORD(lmgp->dwReturn); lmgp->dwReturn = LOWORD(lmgp->dwReturn);
} }
break; break;
@ -2109,7 +2109,7 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2)
LPMCI_STATUS_PARMS lsp; LPMCI_STATUS_PARMS lsp;
lsp = (LPMCI_STATUS_PARMS)(void*)dwParam2; lsp = (LPMCI_STATUS_PARMS)(void*)dwParam2;
TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn)); TRACE("Changing %08x to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn));
lsp->dwReturn = LOWORD(lsp->dwReturn); lsp->dwReturn = LOWORD(lsp->dwReturn);
} }
break; break;
@ -2210,7 +2210,7 @@ BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data)
{ {
LPWINE_MCIDRIVER wmd; LPWINE_MCIDRIVER wmd;
TRACE("(%04x, %08lx)\n", uDeviceID, data); TRACE("(%04x, %08x)\n", uDeviceID, data);
wmd = MCI_GetDriver(uDeviceID); wmd = MCI_GetDriver(uDeviceID);
@ -2236,7 +2236,7 @@ DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1,
dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE); dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, TRUE);
dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2); dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
TRACE("=> %08lx\n", dwRet); TRACE("=> %08x\n", dwRet);
return dwRet; return dwRet;
} }
@ -2309,7 +2309,7 @@ UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
{ {
INT16 ret; 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)) || if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
(GetAsyncKeyState(LOWORD(data)) & 1) == 0) { (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
@ -2332,7 +2332,7 @@ BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD
{ {
LPWINE_MCIDRIVER wmd; LPWINE_MCIDRIVER wmd;
TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
if (!(wmd = MCI_GetDriver(uDeviceID))) { if (!(wmd = MCI_GetDriver(uDeviceID))) {
WARN("Bad uDeviceID\n"); WARN("Bad uDeviceID\n");
@ -2370,7 +2370,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
/* FIXME: that's rather strange, there is no /* FIXME: that's rather strange, there is no
* mciGetDeviceIDFromElementID32A in winmm.spec * mciGetDeviceIDFromElementID32A in winmm.spec
*/ */
FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType)); FIXME("(%u, %s) stub\n", dwElementID, debugstr_w(lpstrType));
return 0; return 0;
} }

112
dlls/winmm/message16.c
View File

@ -37,7 +37,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm);
/************************************************************************** /**************************************************************************
* MMDRV_Callback [internal] * MMDRV_Callback [internal]
*/ */
static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam1, DWORD dwParam2) static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n", TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2); mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
@ -70,7 +70,7 @@ static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD dwParam
/************************************************************************** /**************************************************************************
* MMDRV_Aux_Map16To32W [internal] * MMDRV_Aux_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -78,7 +78,7 @@ static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWOR
/************************************************************************** /**************************************************************************
* MMDRV_Aux_UnMap16To32W [internal] * MMDRV_Aux_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -86,7 +86,7 @@ static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWOR
/************************************************************************** /**************************************************************************
* MMDRV_Aux_Map32WTo16 [internal] * MMDRV_Aux_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -94,7 +94,7 @@ static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWOR
/************************************************************************** /**************************************************************************
* MMDRV_Aux_UnMap32WTo16 [internal] * MMDRV_Aux_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
#if 0 #if 0
case AUXDM_GETDEVCAPS: case AUXDM_GETDEVCAPS:
@ -111,7 +111,7 @@ static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWOR
/************************************************************************** /**************************************************************************
* MMDRV_Aux_Callback [internal] * MMDRV_Aux_Callback [internal]
*/ */
static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -126,7 +126,7 @@ static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance
/************************************************************************** /**************************************************************************
* xMMDRV_Mixer_Map16To32W [internal] * xMMDRV_Mixer_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -134,7 +134,7 @@ static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDW
/************************************************************************** /**************************************************************************
* MMDRV_Mixer_UnMap16To32W [internal] * MMDRV_Mixer_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
#if 0 #if 0
MIXERCAPSA micA; MIXERCAPSA micA;
@ -156,7 +156,7 @@ static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDW
/************************************************************************** /**************************************************************************
* MMDRV_Mixer_Map32WTo16 [internal] * MMDRV_Mixer_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -164,7 +164,7 @@ static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDW
/************************************************************************** /**************************************************************************
* MMDRV_Mixer_UnMap32WTo16 [internal] * MMDRV_Mixer_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -172,7 +172,7 @@ static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDW
/************************************************************************** /**************************************************************************
* MMDRV_Mixer_Callback [internal] * MMDRV_Mixer_Callback [internal]
*/ */
static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -187,7 +187,7 @@ static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstan
/************************************************************************** /**************************************************************************
* MMDRV_MidiIn_Map16To32W [internal] * MMDRV_MidiIn_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -195,7 +195,7 @@ static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_MidiIn_UnMap16To32W [internal] * MMDRV_MidiIn_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -203,7 +203,7 @@ static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_MidiIn_Map32WTo16 [internal] * MMDRV_MidiIn_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -211,7 +211,7 @@ static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_MidiIn_UnMap32WTo16 [internal] * MMDRV_MidiIn_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
return WINMM_MAP_MSGERROR; return WINMM_MAP_MSGERROR;
} }
@ -219,7 +219,7 @@ static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_MidiIn_Callback [internal] * MMDRV_MidiIn_Callback [internal]
*/ */
static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -275,7 +275,7 @@ static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta
/************************************************************************** /**************************************************************************
* MMDRV_MidiOut_Map16To32W [internal] * MMDRV_MidiOut_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -348,7 +348,7 @@ static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP
*lpParam2 = sizeof(MIDIHDR); *lpParam2 = sizeof(MIDIHDR);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
mh32->dwBufferLength, mh16->dwBufferLength); mh32->dwBufferLength, mh16->dwBufferLength);
} else } else
mh32->dwBufferLength = mh16->dwBufferLength; mh32->dwBufferLength = mh16->dwBufferLength;
@ -368,7 +368,7 @@ static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_MidiOut_UnMap16To32W [internal] * MMDRV_MidiOut_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -440,7 +440,7 @@ static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_MidiOut_Map32WTo16 [internal] * MMDRV_MidiOut_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -491,9 +491,8 @@ static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */ mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
mh32->reserved = *lpParam2; mh32->reserved = *lpParam2;
TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
*lpParam1, (DWORD)mh16->lpData, *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
mh32->dwBufferLength, (DWORD)mh32->lpData);
*lpParam2 = sizeof(MIDIHDR); *lpParam2 = sizeof(MIDIHDR);
ret = WINMM_MAP_OKMEM; ret = WINMM_MAP_OKMEM;
@ -516,12 +515,12 @@ static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
*lpParam1 = MapLS(mh16); *lpParam1 = MapLS(mh16);
*lpParam2 = sizeof(MIDIHDR); *lpParam2 = sizeof(MIDIHDR);
TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
*lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData); *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) { if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
mh16->dwBufferLength, mh32->dwBufferLength); mh16->dwBufferLength, mh32->dwBufferLength);
} else } else
mh16->dwBufferLength = mh32->dwBufferLength; mh16->dwBufferLength = mh32->dwBufferLength;
@ -580,7 +579,7 @@ static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_MidiOut_UnMap32WTo16 [internal] * MMDRV_MidiOut_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -658,7 +657,7 @@ static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_MidiOut_Callback [internal] * MMDRV_MidiOut_Callback [internal]
*/ */
static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -706,7 +705,7 @@ static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInst
/************************************************************************** /**************************************************************************
* MMDRV_WaveIn_Map16To32W [internal] * MMDRV_WaveIn_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -793,7 +792,7 @@ static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh32->dwBufferLength, wh16->dwBufferLength); wh32->dwBufferLength, wh16->dwBufferLength);
} else } else
wh32->dwBufferLength = wh16->dwBufferLength; wh32->dwBufferLength = wh16->dwBufferLength;
@ -815,7 +814,7 @@ static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_WaveIn_UnMap16To32W [internal] * MMDRV_WaveIn_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -888,7 +887,7 @@ static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_WaveIn_Map32WTo16 [internal] * MMDRV_WaveIn_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -969,9 +968,9 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD
/* FIXME: nothing on wh32->lpNext */ /* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */ /* could link the wh32->lpNext at this level for memory house keeping */
wh32->lpNext = wh16; /* for reuse in unprepare and write */ wh32->lpNext = wh16; /* for reuse in unprepare and write */
TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
wh32->dwBufferLength, (DWORD)wh32->lpData); wh32->dwBufferLength, wh32->lpData);
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR); *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
@ -991,9 +990,8 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD
assert(*(LPWAVEHDR*)ptr == wh32); assert(*(LPWAVEHDR*)ptr == wh32);
TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, wh32->dwBufferLength, wh32->lpData);
wh32->dwBufferLength, (DWORD)wh32->lpData);
if (wMsg == WIDM_ADDBUFFER) if (wMsg == WIDM_ADDBUFFER)
memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
@ -1002,7 +1000,7 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) { if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh16->dwBufferLength, wh32->dwBufferLength); wh16->dwBufferLength, wh32->dwBufferLength);
} else } else
wh16->dwBufferLength = wh32->dwBufferLength; wh16->dwBufferLength = wh32->dwBufferLength;
@ -1058,7 +1056,7 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_WaveIn_UnMap32WTo16 [internal] * MMDRV_WaveIn_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -1153,7 +1151,7 @@ static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPD
/************************************************************************** /**************************************************************************
* MMDRV_WaveIn_Callback [internal] * MMDRV_WaveIn_Callback [internal]
*/ */
static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -1197,7 +1195,7 @@ static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta
/************************************************************************** /**************************************************************************
* MMDRV_WaveOut_Map16To32W [internal] * MMDRV_WaveOut_Map16To32W [internal]
*/ */
static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -1294,7 +1292,7 @@ static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh32->dwBufferLength, wh16->dwBufferLength); wh32->dwBufferLength, wh16->dwBufferLength);
} else } else
wh32->dwBufferLength = wh16->dwBufferLength; wh32->dwBufferLength = wh16->dwBufferLength;
@ -1315,7 +1313,7 @@ static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_WaveOut_UnMap16To32W [internal] * MMDRV_WaveOut_UnMap16To32W [internal]
*/ */
static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret = WINMM_MAP_MSGERROR; WINMM_MapType ret = WINMM_MAP_MSGERROR;
@ -1399,7 +1397,7 @@ static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_WaveOut_Map32WTo16 [internal] * MMDRV_WaveOut_Map32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2) static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{ {
WINMM_MapType ret; WINMM_MapType ret;
@ -1530,9 +1528,9 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
/* FIXME: nothing on wh32->lpNext */ /* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */ /* could link the wh32->lpNext at this level for memory house keeping */
wh32->lpNext = wh16; /* for reuse in unprepare and write */ wh32->lpNext = wh16; /* for reuse in unprepare and write */
TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
wh32->dwBufferLength, (DWORD)wh32->lpData); wh32->dwBufferLength, wh32->lpData);
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR); *lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
@ -1552,9 +1550,9 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
assert(*(LPWAVEHDR*)ptr == wh32); assert(*(LPWAVEHDR*)ptr == wh32);
TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, seg_ptr + sizeof(LPWAVEHDR), wh16->lpData,
wh32->dwBufferLength, (DWORD)wh32->lpData); wh32->dwBufferLength, wh32->lpData);
if (wMsg == WODM_WRITE) if (wMsg == WODM_WRITE)
memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength); memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
@ -1563,7 +1561,7 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
*lpParam2 = sizeof(WAVEHDR); *lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */ /* dwBufferLength can be reduced between prepare & write */
if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) { if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh16->dwBufferLength, wh32->dwBufferLength); wh16->dwBufferLength, wh32->dwBufferLength);
} else } else
wh16->dwBufferLength = wh32->dwBufferLength; wh16->dwBufferLength = wh32->dwBufferLength;
@ -1588,7 +1586,7 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_WaveOut_UnMap32WTo16 [internal] * MMDRV_WaveOut_UnMap32WTo16 [internal]
*/ */
static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT fn_ret) static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{ {
WINMM_MapType ret; WINMM_MapType ret;
@ -1701,7 +1699,7 @@ static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LP
/************************************************************************** /**************************************************************************
* MMDRV_WaveOut_Callback [internal] * MMDRV_WaveOut_Callback [internal]
*/ */
static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2) static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{ {
LPWINE_MLD mld = (LPWINE_MLD)dwInstance; LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
@ -1780,9 +1778,9 @@ static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w)); 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 (_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 (_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 (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %u\n", dw+0x2C));
if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n")); if (_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 (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %u\n", dw));
if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n")); if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n"));
buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1); buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen)); if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen));
@ -3426,7 +3424,7 @@ static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlag
if (mdsp16) { if (mdsp16) {
mdsp32a->dwReturn = mdsp16->dwReturn; mdsp32a->dwReturn = mdsp16->dwReturn;
if (dwFlags & MCI_DGV_STATUS_DISKSPACE) { if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive); TRACE("MCI_STATUS (DGV) lpstrDrive=%08x\n", mdsp16->lpstrDrive);
TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive)); TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
UnMapLS( mdsp16->lpstrDrive ); UnMapLS( mdsp16->lpstrDrive );
} }

42
dlls/winmm/mmio.c
View File

@ -260,7 +260,7 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
struct IOProcList* pListNode; struct IOProcList* pListNode;
struct IOProcList** ppListNode; struct IOProcList** ppListNode;
TRACE("(%08lx, %p, %08lX, %i)\n", fccIOProc, pIOProc, dwFlags, type); TRACE("(%08x, %p, %08X, %i)\n", fccIOProc, pIOProc, dwFlags, type);
if (dwFlags & MMIO_GLOBALPROC) if (dwFlags & MMIO_GLOBALPROC)
FIXME("Global procedures not implemented\n"); FIXME("Global procedures not implemented\n");
@ -525,7 +525,7 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
{ {
LONG size = wm->info.cchBuffer; 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, 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, MMIO_PROC_32A));
@ -553,11 +553,11 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer, static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer,
UINT uFlags) 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 (uFlags) return MMSYSERR_INVALPARAM;
if (cchBuffer > 0xFFFF) 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) if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
return MMIOERR_CANNOTWRITE; return MMIOERR_CANNOTWRITE;
@ -598,7 +598,7 @@ HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags,
LPWINE_MMIO wm; LPWINE_MMIO wm;
MMIOINFO mmioinfo; MMIOINFO mmioinfo;
TRACE("('%s', %p, %08lX, %d);\n", szFileName, refmminfo, dwOpenFlags, type); TRACE("('%s', %p, %08X, %d);\n", szFileName, refmminfo, dwOpenFlags, type);
if (!refmminfo) { if (!refmminfo) {
refmminfo = &mmioinfo; refmminfo = &mmioinfo;
@ -759,7 +759,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
LPWINE_MMIO wm; LPWINE_MMIO wm;
LONG count; LONG count;
TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
if ((wm = MMIO_Get(hmmio)) == NULL) if ((wm = MMIO_Get(hmmio)) == NULL)
return -1; return -1;
@ -797,7 +797,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
} }
} }
TRACE("count=%ld\n", count); TRACE("count=%d\n", count);
return count; return count;
} }
@ -809,7 +809,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
LPWINE_MMIO wm; LPWINE_MMIO wm;
LONG count; LONG count;
TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
if ((wm = MMIO_Get(hmmio)) == NULL) if ((wm = MMIO_Get(hmmio)) == NULL)
return -1; return -1;
@ -852,7 +852,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
wm->info.lBufOffset = wm->info.lDiskOffset; wm->info.lBufOffset = wm->info.lDiskOffset;
} }
TRACE("bytes written=%ld\n", count); TRACE("bytes written=%d\n", count);
return count; return count;
} }
@ -864,7 +864,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
LPWINE_MMIO wm; LPWINE_MMIO wm;
LONG offset; LONG offset;
TRACE("(%p, %08lX, %d);\n", hmmio, lOffset, iOrigin); TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin);
if ((wm = MMIO_Get(hmmio)) == NULL) if ((wm = MMIO_Get(hmmio)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -918,7 +918,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset); wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
TRACE("=> %ld\n", offset); TRACE("=> %d\n", offset);
return offset; return offset;
} }
@ -976,7 +976,7 @@ MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT
{ {
LPWINE_MMIO wm; 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); hmmio, pchBuffer, cchBuffer, uFlags);
if ((wm = MMIO_Get(hmmio)) == NULL) if ((wm = MMIO_Get(hmmio)) == NULL)
@ -1149,10 +1149,10 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
return MMSYSERR_INVALPARAM; return MMSYSERR_INVALPARAM;
dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
TRACE("dwOldPos=%ld\n", dwOldPos); TRACE("dwOldPos=%d\n", dwOldPos);
if (lpckParent != NULL) { 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); */ /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
if (dwOldPos < lpckParent->dwDataOffset || if (dwOldPos < lpckParent->dwDataOffset ||
dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) { dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
@ -1201,7 +1201,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
} }
lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD); lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
TRACE("ckid=%4.4s fcc=%4.4s cksize=%08lX !\n", TRACE("ckid=%4.4s fcc=%4.4s cksize=%08X !\n",
(LPCSTR)&lpck->ckid, (LPCSTR)&lpck->ckid,
srchType ? (LPCSTR)&lpck->fccType:"<na>", srchType ? (LPCSTR)&lpck->fccType:"<na>",
lpck->cksize); lpck->cksize);
@ -1222,7 +1222,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET); mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
else else
mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET); mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
TRACE("lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n", TRACE("lpck: ckid=%.4s, cksize=%d, dwDataOffset=%d fccType=%08X (%.4s)!\n",
(LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset, (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
lpck->fccType, srchType?(LPSTR)&lpck->fccType:""); lpck->fccType, srchType?(LPSTR)&lpck->fccType:"");
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
@ -1240,10 +1240,10 @@ MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
TRACE("Chunk is dirty, checking if chunk's size is correct\n"); TRACE("Chunk is dirty, checking if chunk's size is correct\n");
dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); 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; dwNewSize = dwOldPos - lpck->dwDataOffset;
if (dwNewSize != lpck->cksize) { 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; lpck->cksize = dwNewSize;
/* pad odd size with 0 */ /* pad odd size with 0 */
@ -1274,7 +1274,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags); TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
TRACE("dwOldPos=%ld\n", dwOldPos); TRACE("dwOldPos=%d\n", dwOldPos);
if (uFlags == MMIO_CREATELIST) if (uFlags == MMIO_CREATELIST)
lpck->ckid = FOURCC_LIST; lpck->ckid = FOURCC_LIST;
@ -1291,7 +1291,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
lpck->dwFlags = MMIO_DIRTY; lpck->dwFlags = MMIO_DIRTY;
ix = mmioWrite(hmmio, (LPSTR)lpck, size); 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) { if (ix < size) {
mmioSeek(hmmio, dwOldPos, SEEK_SET); mmioSeek(hmmio, dwOldPos, SEEK_SET);
WARN("return CannotWrite\n"); WARN("return CannotWrite\n");
@ -1311,7 +1311,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
struct IOProcList tmp; struct IOProcList tmp;
FOURCC fcc; FOURCC fcc;
TRACE("('%s', '%s', %p, %08lX);\n", TRACE("('%s', '%s', %p, %08X);\n",
debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags); debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags);
/* If both params are NULL, then parse the file name */ /* If both params are NULL, then parse the file name */

66
dlls/winmm/mmsystem.c
View File

@ -66,7 +66,7 @@ static LRESULT MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM
BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds, BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds,
WORD wHeapSize, DWORD dwReserved1, WORD wReserved2) WORD wHeapSize, DWORD dwReserved1, WORD wReserved2)
{ {
TRACE("%p 0x%lx\n", hinstDLL, fdwReason); TRACE("%p 0x%x\n", hinstDLL, fdwReason);
switch (fdwReason) { switch (fdwReason) {
case DLL_PROCESS_ATTACH: case DLL_PROCESS_ATTACH:
@ -284,7 +284,7 @@ UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix,
DWORD ret = MMSYSERR_NOTENABLED; DWORD ret = MMSYSERR_NOTENABLED;
SEGPTR sppaDetails; SEGPTR sppaDetails;
TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails); TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd)) if (lpmcd == NULL || lpmcd->cbStruct != sizeof(*lpmcd))
return MMSYSERR_INVALPARAM; return MMSYSERR_INVALPARAM;
@ -310,7 +310,7 @@ UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix,
unsigned int i; unsigned int i;
LPMIXERCONTROL16 lpmc16; LPMIXERCONTROL16 lpmc16;
TRACE("(%04x, %p, %08lx)\n", hmix, lpmlc16, fdwControls); TRACE("(%04x, %p, %08x)\n", hmix, lpmlc16, fdwControls);
if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) || if (lpmlc16 == NULL || lpmlc16->cbStruct != sizeof(*lpmlc16) ||
lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16)) lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16))
@ -366,7 +366,7 @@ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
MIXERLINEA mliA; MIXERLINEA mliA;
UINT ret; UINT ret;
TRACE("(%04x, %p, %08lx)\n", hmix, lpmli16, fdwInfo); TRACE("(%04x, %p, %08x)\n", hmix, lpmli16, fdwInfo);
if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16)) if (lpmli16 == NULL || lpmli16->cbStruct != sizeof(*lpmli16))
return MMSYSERR_INVALPARAM; return MMSYSERR_INVALPARAM;
@ -394,7 +394,7 @@ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16,
strcpy(mliA.Target.szPname, lpmli16->Target.szPname); strcpy(mliA.Target.szPname, lpmli16->Target.szPname);
break; break;
default: default:
FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo); FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo);
} }
ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo); ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo);
@ -427,7 +427,7 @@ UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix,
LPMIXERCONTROLDETAILS16 lpmcd, LPMIXERCONTROLDETAILS16 lpmcd,
DWORD fdwDetails) DWORD fdwDetails)
{ {
TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails); TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails);
return MMSYSERR_NOTENABLED; return MMSYSERR_NOTENABLED;
} }
@ -498,7 +498,7 @@ UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume); TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL) if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -512,7 +512,7 @@ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2); TRACE("(%04X, %04X, %08X, %08X)\n", uDeviceID, uMessage, dw1, dw2);
switch (uMessage) { switch (uMessage) {
case AUXDM_GETNUMDEVS: case AUXDM_GETNUMDEVS:
@ -524,7 +524,7 @@ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD
case AUXDM_GETDEVCAPS: case AUXDM_GETDEVCAPS:
return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2); return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2);
default: default:
TRACE("(%04x, %04x, %08lx, %08lx): unhandled message\n", TRACE("(%04x, %04x, %08x, %08x): unhandled message\n",
uDeviceID, uMessage, dw1, dw2); uDeviceID, uMessage, dw1, dw2);
break; break;
} }
@ -580,12 +580,12 @@ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD
{ {
DWORD dwRet; DWORD dwRet;
TRACE("(%04X, %s, %08lX, %08lX)\n", TRACE("(%04X, %s, %08X, %08X)\n",
wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE); dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE);
dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2)); dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2));
TRACE("=> %ld\n", dwRet); TRACE("=> %d\n", dwRet);
return dwRet; return dwRet;
} }
@ -606,7 +606,7 @@ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD
{ {
LPWINE_MCIDRIVER wmd; LPWINE_MCIDRIVER wmd;
TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
if (!(wmd = MCI_GetDriver(uDeviceID))) { if (!(wmd = MCI_GetDriver(uDeviceID))) {
WARN("Bad uDeviceID\n"); WARN("Bad uDeviceID\n");
@ -625,7 +625,7 @@ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD
*/ */
UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType) UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
{ {
FIXME("(%lu, %s) stub\n", dwElementID, lpstrType); FIXME("(%u, %s) stub\n", dwElementID, lpstrType);
return 0; return 0;
} }
@ -769,7 +769,7 @@ UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %08lx, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -787,7 +787,7 @@ UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
LPWINE_MLD wmld; LPWINE_MLD wmld;
LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr); LPMIDIHDR16 lpMidiOutHdr = MapSL(lpsegMidiOutHdr);
TRACE("(%04X, %08lx, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize); TRACE("(%04X, %08x, %d)\n", hMidiOut, lpsegMidiOutHdr, uSize);
if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) { if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
@ -892,7 +892,7 @@ DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage,
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2); TRACE("(%04X, %04X, %08X, %08X)\n", hMidiOut, uMessage, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL) if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -980,7 +980,7 @@ UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %08lx, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL) if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -998,7 +998,7 @@ UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
LPWINE_MLD wmld; LPWINE_MLD wmld;
LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr); LPMIDIHDR16 lpMidiInHdr = MapSL(lpsegMidiInHdr);
TRACE("(%04X, %08lx, %d)\n", hMidiIn, lpsegMidiInHdr, uSize); TRACE("(%04X, %08x, %d)\n", hMidiIn, lpsegMidiInHdr, uSize);
if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) { if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
@ -1078,7 +1078,7 @@ DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage,
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04X, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2); TRACE("(%04X, %04X, %08X, %08X)\n", hMidiIn, uMessage, dwParam1, dwParam2);
switch (uMessage) { switch (uMessage) {
case MIDM_OPEN: case MIDM_OPEN:
@ -1283,7 +1283,7 @@ UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
LPWINE_MLD wmld; LPWINE_MLD wmld;
LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
TRACE("(%04X, %08lx, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM; if (lpWaveOutHdr == NULL) return MMSYSERR_INVALPARAM;
@ -1303,7 +1303,7 @@ UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
LPWINE_MLD wmld; LPWINE_MLD wmld;
LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr); LPWAVEHDR lpWaveOutHdr = MapSL(lpsegWaveOutHdr);
TRACE("(%04X, %08lx, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize); TRACE("(%04X, %08x, %u);\n", hWaveOut, lpsegWaveOutHdr, uSize);
if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) { if (!(lpWaveOutHdr->dwFlags & WHDR_PREPARED)) {
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
@ -1477,7 +1477,7 @@ DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage,
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04x, %u, %ld, %ld)\n", hWaveOut, uMessage, dwParam1, dwParam2); TRACE("(%04x, %u, %d, %d)\n", hWaveOut, uMessage, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) { if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL) {
if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, TRUE)) != NULL) { if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, TRUE)) != NULL) {
@ -1597,7 +1597,7 @@ UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
LPWINE_MLD wmld; LPWINE_MLD wmld;
LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr); LPWAVEHDR lpWaveInHdr = MapSL(lpsegWaveInHdr);
TRACE("(%04X, %08lx, %u);\n", hWaveIn, lpsegWaveInHdr, uSize); TRACE("(%04X, %08x, %u);\n", hWaveIn, lpsegWaveInHdr, uSize);
if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM; if (lpWaveInHdr == NULL) return MMSYSERR_INVALPARAM;
@ -1712,7 +1712,7 @@ DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage,
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04x, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2); TRACE("(%04x, %u, %d, %d)\n", hWaveIn, uMessage, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) { if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL) {
if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, TRUE)) != NULL) { if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, TRUE)) != NULL) {
@ -1751,7 +1751,7 @@ HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD d
DWORD showCmd = 0x40002; DWORD showCmd = 0x40002;
LOADPARAMS16 lp; LOADPARAMS16 lp;
TRACE("(%08lx, %p, %08lx);\n", spProc, lphMmTask, dwPmt); TRACE("(%08x, %p, %08x);\n", spProc, lphMmTask, dwPmt);
/* This to work requires NE modules to be started with a binary command line /* 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. * 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 * A workaround would be to integrate code for mmtask.tsk into Wine, but
@ -1894,7 +1894,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD
HANDLE16 hndl; HANDLE16 hndl;
LRESULT ret; LRESULT ret;
TRACE("(%p, %p, %08lx, %08lx)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags); TRACE("(%p, %p, %08x, %08x)!\n", fpThreadAddr, lpHndl, dwPmt, dwFlags);
hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT); hndl = GlobalAlloc16(sizeof(WINE_MMTHREAD), GMEM_SHARE|GMEM_ZEROINIT);
@ -1946,7 +1946,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD
ret = 2; ret = 2;
} else { } else {
SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL); SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL);
TRACE("Got a nice thread hndl=%p id=0x%08lx\n", lpMMThd->hThread, lpMMThd->dwThreadID); TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID);
ret = 0; ret = 0;
} }
} else { } else {
@ -1955,7 +1955,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD
*/ */
FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047); FARPROC16 fp = GetProcAddress16(GetModuleHandle16("MMSYSTEM"), (LPCSTR)2047);
TRACE("farproc seg=0x%08lx lin=%p\n", (DWORD)fp, MapSL((SEGPTR)fp)); TRACE("farproc seg=0x%p lin=%p\n", fp, MapSL((SEGPTR)fp));
ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl); ret = (fp == 0) ? 2 : mmTaskCreate16((DWORD)fp, 0, hndl);
} }
@ -2032,7 +2032,7 @@ static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd)
} }
break; break;
default: default:
WARN("S2.x unsupported ret val 0x%08lx\n", ret); WARN("S2.x unsupported ret val 0x%08x\n", ret);
} }
TRACE("S3\n"); TRACE("S3\n");
} }
@ -2493,7 +2493,7 @@ LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg, LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2) DWORD dwParam1, DWORD dwParam2)
{ {
TRACE("dwDevID=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\n", TRACE("dwDevID=%08x hDrv=%04x wMsg=%04x dwParam1=%08x dwParam2=%08x\n",
dwDevID, hDrv, wMsg, dwParam1, dwParam2); dwDevID, hDrv, wMsg, dwParam1, dwParam2);
return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2); return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
@ -2541,7 +2541,7 @@ MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
lpTime->wType = TIME_MS; lpTime->wType = TIME_MS;
lpTime->u.ms = GetTickCount(); lpTime->u.ms = GetTickCount();
TRACE("=> %lu\n", lpTime->u.ms); TRACE("=> %u\n", lpTime->u.ms);
} }
return 0; return 0;
@ -2701,7 +2701,7 @@ static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2)
break; break;
default: default:
if (wMsg < MMIOM_USER) if (wMsg < MMIOM_USER)
TRACE("Not a mappable message (%ld)\n", wMsg); TRACE("Not a mappable message (%d)\n", wMsg);
} }
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
} }
@ -2729,7 +2729,7 @@ static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2,
break; break;
default: default:
if (wMsg < MMIOM_USER) if (wMsg < MMIOM_USER)
TRACE("Not a mappable message (%ld)\n", wMsg); TRACE("Not a mappable message (%d)\n", wMsg);
} }
return MMSYSERR_NOERROR; return MMSYSERR_NOERROR;
} }

14
dlls/winmm/playsound.c
View File

@ -155,7 +155,7 @@ static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg,
break; break;
case WOM_DONE: case WOM_DONE:
InterlockedIncrement(&s->dwEventCount); InterlockedIncrement(&s->dwEventCount);
TRACE("Returning waveHdr=%lx\n", dwParam1); TRACE("Returning waveHdr=%x\n", dwParam1);
SetEvent(s->hEvent); SetEvent(s->hEvent);
break; break;
default: default:
@ -317,7 +317,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0)) if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0))
goto errCleanUp; 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); (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
if ((ckMainRIFF.ckid != FOURCC_RIFF) || if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
@ -328,7 +328,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp; goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%08lx cksize=%08lX\n", TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
(LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize); (LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize);
lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize); lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
@ -337,8 +337,8 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag); TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag);
TRACE("nChannels=%d\n", lpWaveFormat->nChannels); TRACE("nChannels=%d\n", lpWaveFormat->nChannels);
TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec); TRACE("nSamplesPerSec=%d\n", lpWaveFormat->nSamplesPerSec);
TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec); TRACE("nAvgBytesPerSec=%d\n", lpWaveFormat->nAvgBytesPerSec);
TRACE("nBlockAlign=%d\n", lpWaveFormat->nBlockAlign); TRACE("nBlockAlign=%d\n", lpWaveFormat->nBlockAlign);
TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample); TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample);
@ -349,7 +349,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp; goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%08lx cksize=%08lX\n", TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
(LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize); (LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize);
s.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL); s.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
@ -424,7 +424,7 @@ static BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSo
{ {
WINE_PLAYSOUND* wps = NULL; WINE_PLAYSOUND* wps = NULL;
TRACE("pszSound='%p' hmod=%p fdwSound=%08lX\n", TRACE("pszSound='%p' hmod=%p fdwSound=%08X\n",
pszSound, hmod, fdwSound); pszSound, hmod, fdwSound);
/* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP ! /* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP !

6
dlls/winmm/sound16.c
View File

@ -97,7 +97,7 @@ INT16 WINAPI SetSoundNoise16(INT16 nSource, INT16 nDuration)
*/ */
INT16 WINAPI SetVoiceSound16(INT16 nVoice, DWORD lFrequency, INT16 nDuration) INT16 WINAPI SetVoiceSound16(INT16 nVoice, DWORD lFrequency, INT16 nDuration)
{ {
FIXME("(%d, %ld, %d): stub\n",nVoice,lFrequency, nDuration); FIXME("(%d, %d, %d): stub\n",nVoice,lFrequency, nDuration);
return 0; return 0;
} }
@ -178,7 +178,3 @@ void WINAPI DoBeep16(void)
{ {
FIXME("(void): stub!\n"); FIXME("(void): stub!\n");
} }

6
dlls/winmm/time.c
View File

@ -80,7 +80,7 @@ static BOOL TIME_TimeToDie = TRUE;
static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer) static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer)
{ {
TRACE("%04lx:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08lX dwTriggerTime %ld(delta %ld)\n", TRACE("%04x:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08X dwTriggerTime %d(delta %d)\n",
GetCurrentThreadId(), lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser, GetCurrentThreadId(), lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser,
lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime); lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime);
@ -247,7 +247,7 @@ static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg)
rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time); rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time);
if (rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0) if (rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0)
{ {
FIXME("Unexpected error %ld(%ld) in timer thread\n", rc, GetLastError()); FIXME("Unexpected error %d(%d) in timer thread\n", rc, GetLastError());
break; break;
} }
} }
@ -314,7 +314,7 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
LPWINE_TIMERENTRY lpNewTimer; LPWINE_TIMERENTRY lpNewTimer;
LPWINE_TIMERENTRY lpTimer; LPWINE_TIMERENTRY lpTimer;
TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags); TRACE("(%u, %u, %p, %08X, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL) if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
return 0; return 0;

12
dlls/winmm/winemm.h
View File

@ -99,8 +99,8 @@ typedef struct tagWINE_MLD {
* opendesc.dwInstance which is client (callback) related */ * opendesc.dwInstance which is client (callback) related */
WORD bFrom32; WORD bFrom32;
WORD dwFlags; WORD dwFlags;
DWORD dwCallback; DWORD_PTR dwCallback;
DWORD dwClientInstance; DWORD_PTR dwClientInstance;
} WINE_MLD, *LPWINE_MLD; } WINE_MLD, *LPWINE_MLD;
typedef struct { typedef struct {
@ -217,8 +217,8 @@ typedef struct tagWINE_MM_IDATA {
/* function prototypes */ /* function prototypes */
typedef LONG (*MCIPROC)(DWORD, HDRVR, DWORD, DWORD, DWORD); 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_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2);
typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret); typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret);
LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr); LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr);
BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz); BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz);
@ -229,7 +229,7 @@ BOOL MMDRV_Init(void);
void MMDRV_Exit(void); void MMDRV_Exit(void);
UINT MMDRV_GetNum(UINT); UINT MMDRV_GetNum(UINT);
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32); DWORD_PTR* dwCallback, DWORD_PTR* dwInstance, BOOL bFrom32);
void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld); 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 dwParam1, DWORD dwParam2);
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg); DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg);
@ -247,7 +247,7 @@ DWORD MCI_WriteString(LPWSTR lpDstStr, DWORD dstSize, LPCWSTR lpSrcStr);
const char* MCI_MessageToString(UINT wMsg); const char* MCI_MessageToString(UINT wMsg);
UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data);
LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2); LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2);
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, BOOL bFrom32);
DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); 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); DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
UINT MCI_SetCommandTable(void *table, UINT uDevType); UINT MCI_SetCommandTable(void *table, UINT uDevType);

92
dlls/winmm/winmm.c
View File

@ -172,7 +172,7 @@ const char* WINMM_ErrorToString(MMRESULT error)
*/ */
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad) 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) { switch (fdwReason) {
case DLL_PROCESS_ATTACH: case DLL_PROCESS_ATTACH:
@ -313,7 +313,7 @@ UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD dwRet = 0; DWORD dwRet = 0;
MIXEROPENDESC mod; MIXEROPENDESC mod;
TRACE("(%p, %d, %08lx, %08lx, %08lx)\n", TRACE("(%p, %d, %08lx, %08lx, %08x)\n",
lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen); lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen);
wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen, wmld = MMDRV_Alloc(sizeof(WINE_MIXER), MMDRV_MIXER, &hMix, &fdwOpen,
@ -331,7 +331,7 @@ UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
hMix = 0; hMix = 0;
} }
if (lphMix) *lphMix = hMix; if (lphMix) *lphMix = hMix;
TRACE("=> %ld hMixer=%p\n", dwRet, hMix); TRACE("=> %d hMixer=%p\n", dwRet, hMix);
return dwRet; return dwRet;
} }
@ -371,7 +371,7 @@ UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
LPWINE_MIXER lpwm; LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR; 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) if ((uRet = MIXER_GetDev(hmix, fdwID, &lpwm)) != MMSYSERR_NOERROR)
return uRet; return uRet;
@ -391,7 +391,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW
LPWINE_MIXER lpwm; LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR; 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) if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
return uRet; return uRet;
@ -411,7 +411,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
{ {
DWORD ret = MMSYSERR_NOTENABLED; 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)) if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
return MMSYSERR_INVALPARAM; return MMSYSERR_INVALPARAM;
@ -456,7 +456,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
} }
break; break;
default: default:
ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails); ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails);
} }
return ret; return ret;
@ -472,7 +472,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
DWORD ret; DWORD ret;
unsigned int i; 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) || if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA)) lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
@ -540,7 +540,7 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
LPWINE_MIXER lpwm; LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR; 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) if ((uRet = MIXER_GetDev(hmix, fdwControls, &lpwm)) != MMSYSERR_NOERROR)
return uRet; return uRet;
@ -560,7 +560,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo
LPWINE_MIXER lpwm; LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR; UINT uRet = MMSYSERR_NOERROR;
TRACE("(%p, %p, %08lx)\n", hmix, lpmliW, fdwInfo); TRACE("(%p, %p, %08x)\n", hmix, lpmliW, fdwInfo);
if ((uRet = MIXER_GetDev(hmix, fdwInfo, &lpwm)) != MMSYSERR_NOERROR) if ((uRet = MIXER_GetDev(hmix, fdwInfo, &lpwm)) != MMSYSERR_NOERROR)
return uRet; return uRet;
@ -578,7 +578,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
MIXERLINEW mliW; MIXERLINEW mliW;
UINT ret; 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)) if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
return MMSYSERR_INVALPARAM; return MMSYSERR_INVALPARAM;
@ -606,7 +606,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR)); MultiByteToWideChar( CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, sizeof(mliW.Target.szPname)/sizeof(WCHAR));
break; break;
default: default:
WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo); WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
return MMSYSERR_INVALFLAG; return MMSYSERR_INVALFLAG;
} }
@ -645,7 +645,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
LPWINE_MIXER lpwm; LPWINE_MIXER lpwm;
UINT uRet = MMSYSERR_NOERROR; 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) if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR)
return uRet; return uRet;
@ -661,8 +661,8 @@ DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n", TRACE("(%p, %d, %08lx, %08lx): semi-stub?\n",
(DWORD)hmix, uMsg, dwParam1, dwParam2); hmix, uMsg, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL) if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -741,7 +741,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
{ {
LPWINE_MLD wmld; 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) if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -868,8 +868,8 @@ UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
/************************************************************************** /**************************************************************************
* MIDI_OutAlloc [internal] * MIDI_OutAlloc [internal]
*/ */
static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback, static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback,
LPDWORD lpdwInstance, LPDWORD lpdwFlags, DWORD_PTR* lpdwInstance, LPDWORD lpdwFlags,
DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32) DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32)
{ {
HANDLE hMidiOut; HANDLE hMidiOut;
@ -903,7 +903,7 @@ UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
LPWINE_MIDI lpwm; LPWINE_MIDI lpwm;
UINT dwRet = 0; UINT dwRet = 0;
TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags); lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiOut != NULL) *lphMidiOut = 0; if (lphMidiOut != NULL) *lphMidiOut = 0;
@ -1006,7 +1006,7 @@ UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%p, %08lX)\n", hMidiOut, dwMsg); TRACE("(%p, %08X)\n", hMidiOut, dwMsg);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -1067,7 +1067,7 @@ UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%p, %ld);\n", hMidiOut, dwVolume); TRACE("(%p, %d);\n", hMidiOut, dwVolume);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL) if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -1201,7 +1201,7 @@ UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
LPWINE_MIDI lpwm; LPWINE_MIDI lpwm;
DWORD dwRet = 0; DWORD dwRet = 0;
TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiIn != NULL) *lphMidiIn = 0; if (lphMidiIn != NULL) *lphMidiIn = 0;
@ -1224,7 +1224,7 @@ UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback,
hMidiIn = 0; hMidiIn = 0;
} }
if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
TRACE("=> %ld hMidi=%p\n", dwRet, hMidiIn); TRACE("=> %d hMidi=%p\n", dwRet, hMidiIn);
return dwRet; return dwRet;
} }
@ -1520,9 +1520,9 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
*/ */
lpMidiHdr = (LPMIDIHDR)msg->lParam; lpMidiHdr = (LPMIDIHDR)msg->lParam;
lpData = (LPBYTE)lpMidiHdr->lpData; 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=%u]\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr, (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
(DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded, lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded,
lpMidiHdr->dwFlags, msg->wParam); lpMidiHdr->dwFlags, msg->wParam);
#if 0 #if 0
/* dumps content of lpMidiHdr->lpData /* dumps content of lpMidiHdr->lpData
@ -1547,7 +1547,7 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
if (((LPMIDIEVENT)lpData)->dwStreamID != 0 && if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF && ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) { ((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", (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
((LPMIDIEVENT)lpData)->dwStreamID); ((LPMIDIEVENT)lpData)->dwStreamID);
lpMidiHdr->dwFlags |= MHDR_DONE; lpMidiHdr->dwFlags |= MHDR_DONE;
@ -1637,7 +1637,7 @@ static DWORD CALLBACK MMSYSTEM_MidiStream_Player(LPVOID pmt)
dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS; 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) { while ((dwCurrTC = GetTickCount()) < dwToGo) {
if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) { if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
/* got a message, handle it */ /* got a message, handle it */
@ -1751,7 +1751,7 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi
LPWINE_MIDI lpwm; LPWINE_MIDI lpwm;
HMIDIOUT hMidiOut; 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); lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL) if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
@ -1857,7 +1857,7 @@ MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm)
ret = MMSYSERR_INVALHANDLE; ret = MMSYSERR_INVALHANDLE;
} else { } else {
if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) { if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) {
WARN("bad Suspend (%ld)\n", GetLastError()); WARN("bad Suspend (%d)\n", GetLastError());
ret = MMSYSERR_ERROR; ret = MMSYSERR_ERROR;
} }
} }
@ -1882,11 +1882,11 @@ MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbm
switch (lpMMT->wType) { switch (lpMMT->wType) {
case TIME_MS: case TIME_MS:
lpMMT->u.ms = lpMidiStrm->dwPositionMS; lpMMT->u.ms = lpMidiStrm->dwPositionMS;
TRACE("=> %ld ms\n", lpMMT->u.ms); TRACE("=> %d ms\n", lpMMT->u.ms);
break; break;
case TIME_TICKS: case TIME_TICKS:
lpMMT->u.ticks = lpMidiStrm->dwPulses; lpMMT->u.ticks = lpMidiStrm->dwPulses;
TRACE("=> %ld ticks\n", lpMMT->u.ticks); TRACE("=> %d ticks\n", lpMMT->u.ticks);
break; break;
default: default:
WARN("Unsupported time type %d\n", lpMMT->wType); WARN("Unsupported time type %d\n", lpMMT->wType);
@ -1906,7 +1906,7 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD
WINE_MIDIStream* lpMidiStrm; WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = MMSYSERR_NOERROR; 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)) { if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
ret = MMSYSERR_INVALHANDLE; ret = MMSYSERR_INVALHANDLE;
@ -1919,10 +1919,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD
ret = MMSYSERR_INVALPARAM; ret = MMSYSERR_INVALPARAM;
} else if (dwProperty & MIDIPROP_SET) { } else if (dwProperty & MIDIPROP_SET) {
lpMidiStrm->dwTempo = mpt->dwTempo; 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) { } else if (dwProperty & MIDIPROP_GET) {
mpt->dwTempo = lpMidiStrm->dwTempo; mpt->dwTempo = lpMidiStrm->dwTempo;
TRACE("Getting tempo <= %ld\n", mpt->dwTempo); TRACE("Getting tempo <= %d\n", mpt->dwTempo);
} }
} else if (dwProperty & MIDIPROP_TIMEDIV) { } else if (dwProperty & MIDIPROP_TIMEDIV) {
MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData; MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData;
@ -1931,10 +1931,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD
ret = MMSYSERR_INVALPARAM; ret = MMSYSERR_INVALPARAM;
} else if (dwProperty & MIDIPROP_SET) { } else if (dwProperty & MIDIPROP_SET) {
lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv; 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) { } else if (dwProperty & MIDIPROP_GET) {
mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv; mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv;
TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv); TRACE("Getting time div <= %d\n", mptd->dwTimeDiv);
} }
} else { } else {
ret = MMSYSERR_INVALPARAM; ret = MMSYSERR_INVALPARAM;
@ -1965,7 +1965,7 @@ MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm)
ret = ResumeThread(lpMidiStrm->hThread); ret = ResumeThread(lpMidiStrm->hThread);
} while (ret != 0xFFFFFFFF && ret != 0); } while (ret != 0xFFFFFFFF && ret != 0);
if (ret == 0xFFFFFFFF) { if (ret == 0xFFFFFFFF) {
WARN("bad Resume (%ld)\n", GetLastError()); WARN("bad Resume (%d)\n", GetLastError());
ret = MMSYSERR_ERROR; ret = MMSYSERR_ERROR;
} else { } else {
lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS; lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
@ -2003,7 +2003,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
DWORD dwRet = MMSYSERR_NOERROR; DWORD dwRet = MMSYSERR_NOERROR;
WAVEOPENDESC wod; WAVEOPENDESC wod;
TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08lX, %d);\n", TRACE("(%p, %d, %s, %p, %08lX, %08lX, %08X, %d);\n",
lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback, lphndl, (int)uDeviceID, (uType==MMDRV_WAVEOUT)?"Out":"In", lpFormat, dwCallback,
dwInstance, dwFlags, bFrom32?32:16); dwInstance, dwFlags, bFrom32?32:16);
@ -2021,7 +2021,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
} }
/* may have a PCMWAVEFORMAT rather than a WAVEFORMATEX so don't read cbSize */ /* 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->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec,
lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample); lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample);
@ -2037,7 +2037,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType,
wod.dwInstance = dwInstance; wod.dwInstance = dwInstance;
wod.dnDevNode = 0L; wod.dnDevNode = 0L;
TRACE("cb=%08lx\n", wod.dwCallback); TRACE("cb=%08x\n", wod.dwCallback);
for (;;) { for (;;) {
if (dwFlags & WAVE_MAPPED) { if (dwFlags & WAVE_MAPPED) {
@ -2367,7 +2367,7 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
{ {
LPWINE_MLD wmld; 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) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -2381,7 +2381,7 @@ UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
{ {
LPWINE_MLD wmld; 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) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -2395,7 +2395,7 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
{ {
LPWINE_MLD wmld; 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) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -2409,7 +2409,7 @@ UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
{ {
LPWINE_MLD wmld; 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) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;
@ -2423,7 +2423,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw)
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); TRACE("(%p, %p);\n", hWaveOut, lpdw);
if (lpdw == NULL) { if (lpdw == NULL) {
WARN("invalid parameter\n"); WARN("invalid parameter\n");
@ -2443,7 +2443,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD dw)
{ {
LPWINE_MLD wmld; LPWINE_MLD wmld;
TRACE("(%p, %08lx);\n", hWaveOut, dw); TRACE("(%p, %08x);\n", hWaveOut, dw);
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL) if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE; return MMSYSERR_INVALHANDLE;