diff --git a/dlls/winmm/Makefile.in b/dlls/winmm/Makefile.in index 6a0fb56a09e..850a6560657 100644 --- a/dlls/winmm/Makefile.in +++ b/dlls/winmm/Makefile.in @@ -1,4 +1,4 @@ -EXTRADEFS = -D_WINMM_ -DWINE_NO_LONG_AS_INT +EXTRADEFS = -D_WINMM_ TOPSRCDIR = @top_srcdir@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ diff --git a/dlls/winmm/driver.c b/dlls/winmm/driver.c index 5cab620fa43..d200b57895f 100644 --- a/dlls/winmm/driver.c +++ b/dlls/winmm/driver.c @@ -573,21 +573,21 @@ BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, UINT wMsg, DWORD dwUser, DWORD dwParam1, 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); switch (uFlags & DCB_TYPEMASK) { case DCB_NULL: TRACE("Null !\n"); 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; 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); break; case DCB_TASK: /* aka DCB_THREAD */ - TRACE("Task(%04lx) !\n", dwCallBack); + TRACE("Task(%04x) !\n", dwCallBack); PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1); break; case DCB_FUNCTION: @@ -595,7 +595,7 @@ BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2); break; case DCB_EVENT: - TRACE("Event(%08lx) !\n", dwCallBack); + TRACE("Event(%08x) !\n", dwCallBack); SetEvent((HANDLE)dwCallBack); break; case 6: /* I would dub it DCB_MMTHREADSIGNAL */ diff --git a/dlls/winmm/lolvldrv.c b/dlls/winmm/lolvldrv.c index 0fc1c3189e9..63317521e22 100644 --- a/dlls/winmm/lolvldrv.c +++ b/dlls/winmm/lolvldrv.c @@ -189,7 +189,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, WINMM_MapType map; 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, 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); 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); ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); TRACE("=> %s\n", WINMM_ErrorToString(ret)); @@ -239,7 +239,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, break; case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", + TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = part->u.fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); @@ -268,7 +268,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, break; case WINMM_MAP_OK: case WINMM_MAP_OKMEM: - TRACE("Calling message(dev=%u msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n", + TRACE("Calling message(dev=%u msg=%u usr=0x%08x p1=0x%08lx p2=0x%08lx)\n", mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2); ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, mld->uDeviceID, wMsg, mld->dwDriverInstance, @@ -283,7 +283,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, break; } } 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); ret = pFnCallMMDrvFunc16((DWORD)part->u.fnMessage16, mld->uDeviceID, wMsg, mld->dwDriverInstance, @@ -298,7 +298,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, * MMDRV_Alloc [internal] */ LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, - DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32) + DWORD_PTR* dwCallback, DWORD_PTR* dwInstance, BOOL bFrom32) { LPWINE_MLD mld; UINT i; @@ -370,7 +370,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwFlags) DWORD dwRet = MMSYSERR_BADDEVICEID; DWORD dwInstance; 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; @@ -490,7 +490,7 @@ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, { 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 */ switch (uMsg) { diff --git a/dlls/winmm/mci.c b/dlls/winmm/mci.c index 7b449662407..fb36da6e140 100644 --- a/dlls/winmm/mci.c +++ b/dlls/winmm/mci.c @@ -1429,7 +1429,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, */ if (lpstrRet && uRetLen) *lpstrRet = '\0'; - TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n", + TRACE("[%d, %s, %08x, %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s]\n", wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags, data[0], debugstr_w((WCHAR *)data[0]), data[1], debugstr_w((WCHAR *)data[1]), data[2], debugstr_w((WCHAR *)data[2]), data[3], debugstr_w((WCHAR *)data[3]), @@ -1442,9 +1442,9 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet, } else { 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); - TRACE("=> 2/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet)); + TRACE("=> 2/ %x (%s)\n", dwRet, debugstr_w(lpstrRet)); errCleanUp: HeapFree(GetProcessHeap(), 0, verb); @@ -1498,7 +1498,7 @@ BOOL WINAPI mciExecute(LPCSTR lpstrCommand) ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0); if (ret != 0) { if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) { - sprintf(strRet, "Unknown MCI error (%ld)", ret); + sprintf(strRet, "Unknown MCI error (%d)", ret); } MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK); } @@ -1639,7 +1639,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) DWORD dwRet; LPWINE_MCIDRIVER wmd = NULL; - TRACE("(%08lX, %p)\n", dwParam, lpParms); + TRACE("(%08X, %p)\n", dwParam, lpParms); if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; /* only two low bytes are generic, the other ones are dev type specific */ @@ -1741,13 +1741,13 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms) } if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) { - TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet); + TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet); /* FIXME: is dwRet the correct ret code ? */ goto errCleanUp; } /* only handled devices fall through */ - TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet); + TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet); if (dwParam & MCI_NOTIFY) mciDriverNotify((HWND)lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL); @@ -1769,7 +1769,7 @@ static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms DWORD dwRet; LPWINE_MCIDRIVER wmd; - TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); + TRACE("(%04x, %08X, %p)\n", wDevID, dwParam, lpParms); if (wDevID == MCI_ALL_DEVICE_ID) { LPWINE_MCIDRIVER next; @@ -1837,7 +1837,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm 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); 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; - TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); + TRACE("(%d) => '%d'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn); ret = MCI_INTEGER_RETURNED; break; case MCI_SYSINFO_INSTALLNAME: @@ -1887,7 +1887,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm *lpParms->lpstrReturn = 0; ret = MCIERR_INVALID_DEVICE_ID; } - TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); + TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; case MCI_SYSINFO_NAME: TRACE("MCI_SYSINFO_NAME\n"); @@ -1911,7 +1911,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm if (!s) { if (GetPrivateProfileStringW(wszMci, 0, wszNull, buf, sizeof(buf) / sizeof(buf[0]), wszSystemIni)) { for (p = buf; *p; p += strlenW(p) + 1, cnt++) { - TRACE("%ld: %s\n", cnt, debugstr_w(p)); + TRACE("%d: %s\n", cnt, debugstr_w(p)); if (cnt == lpParms->dwNumber - 1) { s = p; break; @@ -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; } - TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); + TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn)); break; default: - TRACE("Unsupported flag value=%08lx\n", dwFlags); + TRACE("Unsupported flag value=%08x\n", dwFlags); ret = MCIERR_UNRECOGNIZED_COMMAND; } return ret; @@ -1969,8 +1969,8 @@ static DWORD MCI_Sound(UINT wDevID, DWORD dwFlags, LPMCI_SOUND_PARMSW lpParms) /************************************************************************** * MCI_SendCommand [internal] */ -DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, - DWORD dwParam2, BOOL bFrom32) +DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, + DWORD_PTR dwParam2, BOOL bFrom32) { DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND; @@ -2086,7 +2086,7 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) LPMCI_GETDEVCAPS_PARMS lmgp; lmgp = (LPMCI_GETDEVCAPS_PARMS)(void*)dwParam2; - TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn)); + TRACE("Changing %08x to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn)); lmgp->dwReturn = LOWORD(lmgp->dwReturn); } break; @@ -2109,7 +2109,7 @@ LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2) LPMCI_STATUS_PARMS lsp; lsp = (LPMCI_STATUS_PARMS)(void*)dwParam2; - TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn)); + TRACE("Changing %08x to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn)); lsp->dwReturn = LOWORD(lsp->dwReturn); } break; @@ -2210,7 +2210,7 @@ BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD data) { LPWINE_MCIDRIVER wmd; - TRACE("(%04x, %08lx)\n", uDeviceID, data); + TRACE("(%04x, %08x)\n", uDeviceID, data); 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_CleanUp(dwRet, wMsg, dwParam2); - TRACE("=> %08lx\n", dwRet); + TRACE("=> %08x\n", dwRet); return dwRet; } @@ -2309,7 +2309,7 @@ UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data) { INT16 ret; - TRACE("(0x%04x, 0x%08lx)\n", wDevID, data); + TRACE("(0x%04x, 0x%08x)\n", wDevID, data); if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) || (GetAsyncKeyState(LOWORD(data)) & 1) == 0) { @@ -2332,7 +2332,7 @@ BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD { LPWINE_MCIDRIVER wmd; - TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); + TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData); if (!(wmd = MCI_GetDriver(uDeviceID))) { WARN("Bad uDeviceID\n"); @@ -2370,7 +2370,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType) /* FIXME: that's rather strange, there is no * mciGetDeviceIDFromElementID32A in winmm.spec */ - FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType)); + FIXME("(%u, %s) stub\n", dwElementID, debugstr_w(lpstrType)); return 0; } diff --git a/dlls/winmm/message16.c b/dlls/winmm/message16.c index 11283d7a29f..14dbbf41680 100644 --- a/dlls/winmm/message16.c +++ b/dlls/winmm/message16.c @@ -37,7 +37,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(winmm); /************************************************************************** * 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", 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] */ -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; } @@ -78,7 +78,7 @@ static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDWOR /************************************************************************** * 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; } @@ -86,7 +86,7 @@ static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDWOR /************************************************************************** * 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; } @@ -94,7 +94,7 @@ static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDWOR /************************************************************************** * 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 case AUXDM_GETDEVCAPS: @@ -111,7 +111,7 @@ static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDWOR /************************************************************************** * 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; @@ -126,7 +126,7 @@ static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstance /************************************************************************** * 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; } @@ -134,7 +134,7 @@ static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPDW /************************************************************************** * 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 MIXERCAPSA micA; @@ -156,7 +156,7 @@ static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPDW /************************************************************************** * 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; } @@ -164,7 +164,7 @@ static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPDW /************************************************************************** * 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; } @@ -172,7 +172,7 @@ static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPDW /************************************************************************** * 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; @@ -187,7 +187,7 @@ static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD dwInstan /************************************************************************** * 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; } @@ -195,7 +195,7 @@ static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; } @@ -203,7 +203,7 @@ static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; } @@ -211,7 +211,7 @@ static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; } @@ -219,7 +219,7 @@ static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; @@ -275,7 +275,7 @@ static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta /************************************************************************** * 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; @@ -348,7 +348,7 @@ static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP *lpParam2 = sizeof(MIDIHDR); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", mh32->dwBufferLength, mh16->dwBufferLength); } else mh32->dwBufferLength = mh16->dwBufferLength; @@ -368,7 +368,7 @@ static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -440,7 +440,7 @@ static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -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->reserved = *lpParam2; - TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, - mh32->dwBufferLength, (DWORD)mh32->lpData); + TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n", + *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData); *lpParam2 = sizeof(MIDIHDR); ret = WINMM_MAP_OKMEM; @@ -516,12 +515,12 @@ static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP *lpParam1 = MapLS(mh16); *lpParam2 = sizeof(MIDIHDR); - TRACE("mh16=%08lx mh16->lpData=%08lx mh32->buflen=%lu mh32->lpData=%08lx\n", - *lpParam1, (DWORD)mh16->lpData, mh32->dwBufferLength, (DWORD)mh32->lpData); + TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n", + *lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) { - ERR("Size of buffer has been increased from %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); } else mh16->dwBufferLength = mh32->dwBufferLength; @@ -580,7 +579,7 @@ static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -658,7 +657,7 @@ static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -706,7 +705,7 @@ static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD dwInst /************************************************************************** * 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; @@ -793,7 +792,7 @@ static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD *lpParam2 = sizeof(WAVEHDR); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", wh32->dwBufferLength, wh16->dwBufferLength); } else wh32->dwBufferLength = wh16->dwBufferLength; @@ -815,7 +814,7 @@ static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; @@ -888,7 +887,7 @@ static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; @@ -969,9 +968,9 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD /* FIXME: nothing on wh32->lpNext */ /* could link the wh32->lpNext at this level for memory house keeping */ wh32->lpNext = wh16; /* for reuse in unprepare and write */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); + TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n", + seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, + wh32->dwBufferLength, wh32->lpData); *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); *lpParam2 = sizeof(WAVEHDR); @@ -991,9 +990,8 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD assert(*(LPWAVEHDR*)ptr == wh32); - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); + TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n", + seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, wh32->dwBufferLength, wh32->lpData); if (wMsg == WIDM_ADDBUFFER) 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); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", wh16->dwBufferLength, wh32->dwBufferLength); } else wh16->dwBufferLength = wh32->dwBufferLength; @@ -1058,7 +1056,7 @@ static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; @@ -1153,7 +1151,7 @@ static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LPD /************************************************************************** * 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; @@ -1197,7 +1195,7 @@ static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD dwInsta /************************************************************************** * 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; @@ -1294,7 +1292,7 @@ static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP *lpParam2 = sizeof(WAVEHDR); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", wh32->dwBufferLength, wh16->dwBufferLength); } else wh32->dwBufferLength = wh16->dwBufferLength; @@ -1315,7 +1313,7 @@ static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -1399,7 +1397,7 @@ static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -1530,9 +1528,9 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP /* FIXME: nothing on wh32->lpNext */ /* could link the wh32->lpNext at this level for memory house keeping */ wh32->lpNext = wh16; /* for reuse in unprepare and write */ - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); + TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n", + seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, + wh32->dwBufferLength, wh32->lpData); *lpParam1 = seg_ptr + sizeof(LPWAVEHDR); *lpParam2 = sizeof(WAVEHDR); @@ -1552,9 +1550,9 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP assert(*(LPWAVEHDR*)ptr == wh32); - TRACE("wh16=%08lx wh16->lpData=%08lx wh32->buflen=%lu wh32->lpData=%08lx\n", - seg_ptr + sizeof(LPWAVEHDR), (DWORD)wh16->lpData, - wh32->dwBufferLength, (DWORD)wh32->lpData); + TRACE("wh16=%08x wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n", + seg_ptr + sizeof(LPWAVEHDR), wh16->lpData, + wh32->dwBufferLength, wh32->lpData); if (wMsg == WODM_WRITE) 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); /* dwBufferLength can be reduced between prepare & write */ if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) { - ERR("Size of buffer has been increased from %ld to %ld, keeping initial value\n", + ERR("Size of buffer has been increased from %d to %d, keeping initial value\n", wh16->dwBufferLength, wh32->dwBufferLength); } else wh16->dwBufferLength = wh32->dwBufferLength; @@ -1588,7 +1586,7 @@ static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -1701,7 +1699,7 @@ static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, LP /************************************************************************** * 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; @@ -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 (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n")); if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n")); - if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %lu\n", dw+0x2C)); + if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %u\n", dw+0x2C)); if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n")); - if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %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")); buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1); 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) { mdsp32a->dwReturn = mdsp16->dwReturn; 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)); UnMapLS( mdsp16->lpstrDrive ); } diff --git a/dlls/winmm/mmio.c b/dlls/winmm/mmio.c index e872220b91c..900e779041d 100644 --- a/dlls/winmm/mmio.c +++ b/dlls/winmm/mmio.c @@ -260,7 +260,7 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc, struct IOProcList* pListNode; 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) 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; - TRACE("bo=%lx do=%lx of=%lx\n", + TRACE("bo=%x do=%x of=%lx\n", wm->info.lBufOffset, wm->info.lDiskOffset, send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, MMIO_PROC_32A)); @@ -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, UINT uFlags) { - TRACE("(%p %p %ld %u)\n", wm, pchBuffer, cchBuffer, uFlags); + TRACE("(%p %p %d %u)\n", wm, pchBuffer, cchBuffer, uFlags); if (uFlags) return MMSYSERR_INVALPARAM; if (cchBuffer > 0xFFFF) - WARN("Untested handling of huge mmio buffers (%ld >= 64k)\n", cchBuffer); + WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer); if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR) return MMIOERR_CANNOTWRITE; @@ -598,7 +598,7 @@ HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, LPWINE_MMIO wm; MMIOINFO mmioinfo; - TRACE("('%s', %p, %08lX, %d);\n", szFileName, refmminfo, dwOpenFlags, type); + TRACE("('%s', %p, %08X, %d);\n", szFileName, refmminfo, dwOpenFlags, type); if (!refmminfo) { refmminfo = &mmioinfo; @@ -759,7 +759,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch) LPWINE_MMIO wm; LONG count; - TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); + TRACE("(%p, %p, %d);\n", hmmio, pch, cch); if ((wm = MMIO_Get(hmmio)) == NULL) return -1; @@ -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; } @@ -809,7 +809,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch) LPWINE_MMIO wm; LONG count; - TRACE("(%p, %p, %ld);\n", hmmio, pch, cch); + TRACE("(%p, %p, %d);\n", hmmio, pch, cch); if ((wm = MMIO_Get(hmmio)) == NULL) return -1; @@ -852,7 +852,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch) wm->info.lBufOffset = wm->info.lDiskOffset; } - TRACE("bytes written=%ld\n", count); + TRACE("bytes written=%d\n", count); return count; } @@ -864,7 +864,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin) LPWINE_MMIO wm; LONG offset; - TRACE("(%p, %08lX, %d);\n", hmmio, lOffset, iOrigin); + TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin); if ((wm = MMIO_Get(hmmio)) == NULL) return MMSYSERR_INVALHANDLE; @@ -918,7 +918,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin) wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset); - TRACE("=> %ld\n", offset); + TRACE("=> %d\n", offset); return offset; } @@ -976,7 +976,7 @@ MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT { LPWINE_MMIO wm; - TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n", + TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n", hmmio, pchBuffer, cchBuffer, uFlags); if ((wm = MMIO_Get(hmmio)) == NULL) @@ -1149,10 +1149,10 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, return MMSYSERR_INVALPARAM; dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld\n", dwOldPos); + TRACE("dwOldPos=%d\n", dwOldPos); if (lpckParent != NULL) { - TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset); + TRACE("seek inside parent at %d !\n", lpckParent->dwDataOffset); /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */ if (dwOldPos < lpckParent->dwDataOffset || dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) { @@ -1201,7 +1201,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, } 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, srchType ? (LPCSTR)&lpck->fccType:"", lpck->cksize); @@ -1222,7 +1222,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET); else mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET); - TRACE("lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n", + TRACE("lpck: ckid=%.4s, cksize=%d, dwDataOffset=%d fccType=%08X (%.4s)!\n", (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset, lpck->fccType, srchType?(LPSTR)&lpck->fccType:""); return MMSYSERR_NOERROR; @@ -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"); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld lpck->dwDataOffset = %ld\n", dwOldPos, lpck->dwDataOffset); + TRACE("dwOldPos=%d lpck->dwDataOffset = %d\n", dwOldPos, lpck->dwDataOffset); dwNewSize = dwOldPos - lpck->dwDataOffset; if (dwNewSize != lpck->cksize) { - TRACE("Nope: lpck->cksize=%ld dwNewSize=%ld\n", lpck->cksize, dwNewSize); + TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck->cksize, dwNewSize); lpck->cksize = dwNewSize; /* pad odd size with 0 */ @@ -1274,7 +1274,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags) TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags); dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR); - TRACE("dwOldPos=%ld\n", dwOldPos); + TRACE("dwOldPos=%d\n", dwOldPos); if (uFlags == MMIO_CREATELIST) lpck->ckid = FOURCC_LIST; @@ -1291,7 +1291,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags) lpck->dwFlags = MMIO_DIRTY; ix = mmioWrite(hmmio, (LPSTR)lpck, size); - TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n",ix, size, errno); + TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix, size, errno); if (ix < size) { mmioSeek(hmmio, dwOldPos, SEEK_SET); WARN("return CannotWrite\n"); @@ -1311,7 +1311,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName, struct IOProcList tmp; FOURCC fcc; - TRACE("('%s', '%s', %p, %08lX);\n", + TRACE("('%s', '%s', %p, %08X);\n", debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags); /* If both params are NULL, then parse the file name */ diff --git a/dlls/winmm/mmsystem.c b/dlls/winmm/mmsystem.c index 9262cac53ee..83f63d45247 100644 --- a/dlls/winmm/mmsystem.c +++ b/dlls/winmm/mmsystem.c @@ -66,7 +66,7 @@ static LRESULT MMIO_Callback16(SEGPTR, LPMMIOINFO, UINT, LPARAM, LPARAM BOOL WINAPI MMSYSTEM_LibMain(DWORD fdwReason, HINSTANCE hinstDLL, WORD ds, WORD wHeapSize, DWORD dwReserved1, WORD wReserved2) { - TRACE("%p 0x%lx\n", hinstDLL, fdwReason); + TRACE("%p 0x%x\n", hinstDLL, fdwReason); switch (fdwReason) { case DLL_PROCESS_ATTACH: @@ -284,7 +284,7 @@ UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16 hmix, DWORD ret = MMSYSERR_NOTENABLED; 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)) return MMSYSERR_INVALPARAM; @@ -310,7 +310,7 @@ UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16 hmix, unsigned int i; 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) || lpmlc16->cbmxctrl != sizeof(MIXERCONTROL16)) @@ -366,7 +366,7 @@ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16, MIXERLINEA mliA; 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)) return MMSYSERR_INVALPARAM; @@ -394,7 +394,7 @@ UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16 hmix, LPMIXERLINE16 lpmli16, strcpy(mliA.Target.szPname, lpmli16->Target.szPname); break; default: - FIXME("Unsupported fdwControls=0x%08lx\n", fdwInfo); + FIXME("Unsupported fdwControls=0x%08x\n", fdwInfo); } ret = mixerGetLineInfoA(HMIXEROBJ_32(hmix), &mliA, fdwInfo); @@ -427,7 +427,7 @@ UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16 hmix, LPMIXERCONTROLDETAILS16 lpmcd, DWORD fdwDetails) { - TRACE("(%04x, %p, %08lx)\n", hmix, lpmcd, fdwDetails); + TRACE("(%04x, %p, %08x)\n", hmix, lpmcd, fdwDetails); return MMSYSERR_NOTENABLED; } @@ -498,7 +498,7 @@ UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume) { 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) return MMSYSERR_INVALHANDLE; @@ -512,7 +512,7 @@ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD { 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) { case AUXDM_GETNUMDEVS: @@ -524,7 +524,7 @@ DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD case AUXDM_GETDEVCAPS: return auxGetDevCaps16(uDeviceID, MapSL(dw1), dw2); default: - TRACE("(%04x, %04x, %08lx, %08lx): unhandled message\n", + TRACE("(%04x, %04x, %08x, %08x): unhandled message\n", uDeviceID, uMessage, dw1, dw2); break; } @@ -580,12 +580,12 @@ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD { DWORD dwRet; - TRACE("(%04X, %s, %08lX, %08lX)\n", + TRACE("(%04X, %s, %08X, %08X)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2, FALSE); dwRet = MCI_CleanUp(dwRet, wMsg, (DWORD)MapSL(dwParam2)); - TRACE("=> %ld\n", dwRet); + TRACE("=> %d\n", dwRet); return dwRet; } @@ -606,7 +606,7 @@ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD { LPWINE_MCIDRIVER wmd; - TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData); + TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData); if (!(wmd = MCI_GetDriver(uDeviceID))) { WARN("Bad uDeviceID\n"); @@ -625,7 +625,7 @@ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD */ UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType) { - FIXME("(%lu, %s) stub\n", dwElementID, lpstrType); + FIXME("(%u, %s) stub\n", dwElementID, lpstrType); return 0; } @@ -769,7 +769,7 @@ UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ { 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) return MMSYSERR_INVALHANDLE; @@ -787,7 +787,7 @@ UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */ LPWINE_MLD wmld; 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)) { return MMSYSERR_NOERROR; @@ -892,7 +892,7 @@ DWORD WINAPI midiOutMessage16(HMIDIOUT16 hMidiOut, UINT16 uMessage, { 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) return MMSYSERR_INVALHANDLE; @@ -980,7 +980,7 @@ UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ { 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) return MMSYSERR_INVALHANDLE; @@ -998,7 +998,7 @@ UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */ LPWINE_MLD wmld; 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)) { return MMSYSERR_NOERROR; @@ -1078,7 +1078,7 @@ DWORD WINAPI midiInMessage16(HMIDIIN16 hMidiIn, UINT16 uMessage, { 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) { case MIDM_OPEN: @@ -1283,7 +1283,7 @@ UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ LPWINE_MLD wmld; 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; @@ -1303,7 +1303,7 @@ UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */ LPWINE_MLD wmld; 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)) { return MMSYSERR_NOERROR; @@ -1477,7 +1477,7 @@ DWORD WINAPI waveOutMessage16(HWAVEOUT16 hWaveOut, UINT16 uMessage, { 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, TRUE)) != NULL) { @@ -1597,7 +1597,7 @@ UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */ LPWINE_MLD wmld; 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; @@ -1712,7 +1712,7 @@ DWORD WINAPI waveInMessage16(HWAVEIN16 hWaveIn, UINT16 uMessage, { 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, TRUE)) != NULL) { @@ -1751,7 +1751,7 @@ HINSTANCE16 WINAPI mmTaskCreate16(SEGPTR spProc, HINSTANCE16 *lphMmTask, DWORD d DWORD showCmd = 0x40002; 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 * 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 @@ -1894,7 +1894,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD HANDLE16 hndl; 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); @@ -1946,7 +1946,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD ret = 2; } else { SetThreadPriority(lpMMThd->hThread, THREAD_PRIORITY_TIME_CRITICAL); - TRACE("Got a nice thread hndl=%p id=0x%08lx\n", lpMMThd->hThread, lpMMThd->dwThreadID); + TRACE("Got a nice thread hndl=%p id=0x%08x\n", lpMMThd->hThread, lpMMThd->dwThreadID); ret = 0; } } else { @@ -1955,7 +1955,7 @@ LRESULT WINAPI mmThreadCreate16(FARPROC16 fpThreadAddr, LPHANDLE16 lpHndl, DWORD */ 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); } @@ -2032,7 +2032,7 @@ static void MMSYSTEM_ThreadBlock(WINE_MMTHREAD* lpMMThd) } break; default: - WARN("S2.x unsupported ret val 0x%08lx\n", ret); + WARN("S2.x unsupported ret val 0x%08x\n", ret); } 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, 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); return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2); @@ -2541,7 +2541,7 @@ MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize) lpTime->wType = TIME_MS; lpTime->u.ms = GetTickCount(); - TRACE("=> %lu\n", lpTime->u.ms); + TRACE("=> %u\n", lpTime->u.ms); } return 0; @@ -2701,7 +2701,7 @@ static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2) break; default: if (wMsg < MMIOM_USER) - TRACE("Not a mappable message (%ld)\n", wMsg); + TRACE("Not a mappable message (%d)\n", wMsg); } return MMSYSERR_NOERROR; } @@ -2729,7 +2729,7 @@ static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2, break; default: if (wMsg < MMIOM_USER) - TRACE("Not a mappable message (%ld)\n", wMsg); + TRACE("Not a mappable message (%d)\n", wMsg); } return MMSYSERR_NOERROR; } diff --git a/dlls/winmm/playsound.c b/dlls/winmm/playsound.c index 9b183182e02..2d423fad5da 100644 --- a/dlls/winmm/playsound.c +++ b/dlls/winmm/playsound.c @@ -155,7 +155,7 @@ static void CALLBACK PlaySound_Callback(HWAVEOUT hwo, UINT uMsg, break; case WOM_DONE: InterlockedIncrement(&s->dwEventCount); - TRACE("Returning waveHdr=%lx\n", dwParam1); + TRACE("Returning waveHdr=%x\n", dwParam1); SetEvent(s->hEvent); break; default: @@ -317,7 +317,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0)) goto errCleanUp; - TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX\n", + TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08X\n", (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize); if ((ckMainRIFF.ckid != FOURCC_RIFF) || @@ -328,7 +328,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) 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); lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize); @@ -337,8 +337,8 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag); TRACE("nChannels=%d\n", lpWaveFormat->nChannels); - TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec); - TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec); + TRACE("nSamplesPerSec=%d\n", lpWaveFormat->nSamplesPerSec); + TRACE("nAvgBytesPerSec=%d\n", lpWaveFormat->nAvgBytesPerSec); TRACE("nBlockAlign=%d\n", lpWaveFormat->nBlockAlign); TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample); @@ -349,7 +349,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg) if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK)) 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); 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; - TRACE("pszSound='%p' hmod=%p fdwSound=%08lX\n", + TRACE("pszSound='%p' hmod=%p fdwSound=%08X\n", pszSound, hmod, fdwSound); /* FIXME? I see no difference between SND_NOWAIT and SND_NOSTOP ! diff --git a/dlls/winmm/sound16.c b/dlls/winmm/sound16.c index ea1fe578acb..0f1386cf160 100644 --- a/dlls/winmm/sound16.c +++ b/dlls/winmm/sound16.c @@ -97,7 +97,7 @@ INT16 WINAPI SetSoundNoise16(INT16 nSource, 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; } @@ -178,7 +178,3 @@ void WINAPI DoBeep16(void) { FIXME("(void): stub!\n"); } - - - - diff --git a/dlls/winmm/time.c b/dlls/winmm/time.c index fa870513824..891b5695536 100644 --- a/dlls/winmm/time.c +++ b/dlls/winmm/time.c @@ -80,7 +80,7 @@ static BOOL TIME_TimeToDie = TRUE; 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, lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime); @@ -247,7 +247,7 @@ static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg) rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time); 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; } } @@ -314,7 +314,7 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol, LPWINE_TIMERENTRY lpNewTimer; 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) return 0; diff --git a/dlls/winmm/winemm.h b/dlls/winmm/winemm.h index 99cd1c5720f..ef90d32dcc8 100644 --- a/dlls/winmm/winemm.h +++ b/dlls/winmm/winemm.h @@ -99,8 +99,8 @@ typedef struct tagWINE_MLD { * opendesc.dwInstance which is client (callback) related */ WORD bFrom32; WORD dwFlags; - DWORD dwCallback; - DWORD dwClientInstance; + DWORD_PTR dwCallback; + DWORD_PTR dwClientInstance; } WINE_MLD, *LPWINE_MLD; typedef struct { @@ -217,8 +217,8 @@ typedef struct tagWINE_MM_IDATA { /* function prototypes */ typedef LONG (*MCIPROC)(DWORD, HDRVR, DWORD, DWORD, DWORD); -typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2); -typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, LPDWORD lpParam1, LPDWORD lpParam2, MMRESULT ret); +typedef WINMM_MapType (*MMDRV_MAPFUNC)(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2); +typedef WINMM_MapType (*MMDRV_UNMAPFUNC)(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT ret); LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr); BOOL DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz); @@ -229,7 +229,7 @@ BOOL MMDRV_Init(void); void MMDRV_Exit(void); UINT MMDRV_GetNum(UINT); LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags, - DWORD* dwCallback, DWORD* dwInstance, BOOL bFrom32); + DWORD_PTR* dwCallback, DWORD_PTR* dwInstance, BOOL bFrom32); void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld); DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2); 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); UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data); LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2); -DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32); +DWORD MCI_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_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); UINT MCI_SetCommandTable(void *table, UINT uDevType); diff --git a/dlls/winmm/winmm.c b/dlls/winmm/winmm.c index a7e5ea1266e..7499f602edf 100644 --- a/dlls/winmm/winmm.c +++ b/dlls/winmm/winmm.c @@ -172,7 +172,7 @@ const char* WINMM_ErrorToString(MMRESULT error) */ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad) { - TRACE("%p 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad); + TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad); switch (fdwReason) { case DLL_PROCESS_ATTACH: @@ -313,7 +313,7 @@ UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback, DWORD dwRet = 0; MIXEROPENDESC mod; - TRACE("(%p, %d, %08lx, %08lx, %08lx)\n", + TRACE("(%p, %d, %08lx, %08lx, %08x)\n", lphMix, uDeviceID, dwCallback, dwInstance, 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; } if (lphMix) *lphMix = hMix; - TRACE("=> %ld hMixer=%p\n", dwRet, hMix); + TRACE("=> %d hMixer=%p\n", dwRet, hMix); return dwRet; } @@ -371,7 +371,7 @@ UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID) LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p %p %08lx)\n", hmix, lpid, fdwID); + TRACE("(%p %p %08x)\n", hmix, lpid, fdwID); if ((uRet = MIXER_GetDev(hmix, fdwID, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -391,7 +391,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcdW, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcdW, fdwDetails); if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -411,7 +411,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA { DWORD ret = MMSYSERR_NOTENABLED; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcdA, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails); if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA)) return MMSYSERR_INVALPARAM; @@ -456,7 +456,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA } break; default: - ERR("Unsupported fdwDetails=0x%08lx\n", fdwDetails); + ERR("Unsupported fdwDetails=0x%08x\n", fdwDetails); } return ret; @@ -472,7 +472,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA, DWORD ret; unsigned int i; - TRACE("(%p, %p, %08lx)\n", hmix, lpmlcA, fdwControls); + TRACE("(%p, %p, %08x)\n", hmix, lpmlcA, fdwControls); if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) || lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA)) @@ -540,7 +540,7 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW, LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmlcW, fdwControls); + TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls); if ((uRet = MIXER_GetDev(hmix, fdwControls, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -560,7 +560,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmliW, fdwInfo); + TRACE("(%p, %p, %08x)\n", hmix, lpmliW, fdwInfo); if ((uRet = MIXER_GetDev(hmix, fdwInfo, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -578,7 +578,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA, MIXERLINEW mliW; UINT ret; - TRACE("(%p, %p, %08lx)\n", hmix, lpmliA, fdwInfo); + TRACE("(%p, %p, %08x)\n", hmix, lpmliA, fdwInfo); if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA)) return MMSYSERR_INVALPARAM; @@ -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)); break; default: - WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo); + WARN("Unsupported fdwControls=0x%08x\n", fdwInfo); return MMSYSERR_INVALFLAG; } @@ -645,7 +645,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, LPWINE_MIXER lpwm; UINT uRet = MMSYSERR_NOERROR; - TRACE("(%p, %p, %08lx)\n", hmix, lpmcd, fdwDetails); + TRACE("(%p, %p, %08x)\n", hmix, lpmcd, fdwDetails); if ((uRet = MIXER_GetDev(hmix, fdwDetails, &lpwm)) != MMSYSERR_NOERROR) return uRet; @@ -661,8 +661,8 @@ DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR { LPWINE_MLD wmld; - TRACE("(%04lx, %d, %08lx, %08lx): semi-stub?\n", - (DWORD)hmix, uMsg, dwParam1, dwParam2); + TRACE("(%p, %d, %08lx, %08lx): semi-stub?\n", + hmix, uMsg, dwParam1, dwParam2); if ((wmld = MMDRV_Get(hmix, MMDRV_MIXER, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -741,7 +741,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume) { LPWINE_MLD wmld; - TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume); + TRACE("(%04X, %u) !\n", uDeviceID, dwVolume); if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -868,8 +868,8 @@ UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize) /************************************************************************** * MIDI_OutAlloc [internal] */ -static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback, - LPDWORD lpdwInstance, LPDWORD lpdwFlags, +static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback, + DWORD_PTR* lpdwInstance, LPDWORD lpdwFlags, DWORD cIDs, MIDIOPENSTRMID* lpIDs, BOOL bFrom32) { HANDLE hMidiOut; @@ -903,7 +903,7 @@ UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback, LPWINE_MIDI lpwm; UINT dwRet = 0; - TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", + TRACE("(%p, %d, %08lX, %08lX, %08X);\n", lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags); if (lphMidiOut != NULL) *lphMidiOut = 0; @@ -1006,7 +1006,7 @@ UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg) { LPWINE_MLD wmld; - TRACE("(%p, %08lX)\n", hMidiOut, dwMsg); + TRACE("(%p, %08X)\n", hMidiOut, dwMsg); if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -1067,7 +1067,7 @@ UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume) { LPWINE_MLD wmld; - TRACE("(%p, %ld);\n", hMidiOut, dwVolume); + TRACE("(%p, %d);\n", hMidiOut, dwVolume); if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -1201,7 +1201,7 @@ UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, LPWINE_MIDI lpwm; DWORD dwRet = 0; - TRACE("(%p, %d, %08lX, %08lX, %08lX);\n", + TRACE("(%p, %d, %08lX, %08lX, %08X);\n", lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags); if (lphMidiIn != NULL) *lphMidiIn = 0; @@ -1224,7 +1224,7 @@ UINT MIDI_InOpen(HMIDIIN* lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, hMidiIn = 0; } if (lphMidiIn != NULL) *lphMidiIn = hMidiIn; - TRACE("=> %ld hMidi=%p\n", dwRet, hMidiIn); + TRACE("=> %d hMidi=%p\n", dwRet, hMidiIn); return dwRet; } @@ -1520,9 +1520,9 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI */ lpMidiHdr = (LPMIDIHDR)msg->lParam; lpData = (LPBYTE)lpMidiHdr->lpData; - TRACE("Adding %s lpMidiHdr=%p [lpData=0x%08lx dwBufferLength=%lu/%lu dwFlags=0x%08lx size=%u]\n", + TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBufferLength=%u/%u dwFlags=0x%08x size=%u]\n", (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr, - (DWORD)lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded, + lpMidiHdr, lpMidiHdr->dwBufferLength, lpMidiHdr->dwBytesRecorded, lpMidiHdr->dwFlags, msg->wParam); #if 0 /* dumps content of lpMidiHdr->lpData @@ -1547,7 +1547,7 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI if (((LPMIDIEVENT)lpData)->dwStreamID != 0 && ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF && ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) { - FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n", + FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n", (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", ((LPMIDIEVENT)lpData)->dwStreamID); lpMidiHdr->dwFlags |= MHDR_DONE; @@ -1637,7 +1637,7 @@ static DWORD CALLBACK MMSYSTEM_MidiStream_Player(LPVOID pmt) dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS; - TRACE("%ld/%ld/%ld\n", dwToGo, GetTickCount(), me->dwDeltaTime); + TRACE("%d/%d/%d\n", dwToGo, GetTickCount(), me->dwDeltaTime); while ((dwCurrTC = GetTickCount()) < dwToGo) { if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) { /* got a message, handle it */ @@ -1751,7 +1751,7 @@ MMRESULT MIDI_StreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi LPWINE_MIDI lpwm; HMIDIOUT hMidiOut; - TRACE("(%p, %p, %ld, 0x%08lx, 0x%08lx, 0x%08lx)!\n", + TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n", lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen); if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL) @@ -1857,7 +1857,7 @@ MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm) ret = MMSYSERR_INVALHANDLE; } else { if (SuspendThread(lpMidiStrm->hThread) == 0xFFFFFFFF) { - WARN("bad Suspend (%ld)\n", GetLastError()); + WARN("bad Suspend (%d)\n", GetLastError()); ret = MMSYSERR_ERROR; } } @@ -1882,11 +1882,11 @@ MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbm switch (lpMMT->wType) { case TIME_MS: lpMMT->u.ms = lpMidiStrm->dwPositionMS; - TRACE("=> %ld ms\n", lpMMT->u.ms); + TRACE("=> %d ms\n", lpMMT->u.ms); break; case TIME_TICKS: lpMMT->u.ticks = lpMidiStrm->dwPulses; - TRACE("=> %ld ticks\n", lpMMT->u.ticks); + TRACE("=> %d ticks\n", lpMMT->u.ticks); break; default: WARN("Unsupported time type %d\n", lpMMT->wType); @@ -1906,7 +1906,7 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD WINE_MIDIStream* lpMidiStrm; MMRESULT ret = MMSYSERR_NOERROR; - TRACE("(%p, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty); + TRACE("(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty); if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) { ret = MMSYSERR_INVALHANDLE; @@ -1919,10 +1919,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_SET) { lpMidiStrm->dwTempo = mpt->dwTempo; - TRACE("Setting tempo to %ld\n", mpt->dwTempo); + TRACE("Setting tempo to %d\n", mpt->dwTempo); } else if (dwProperty & MIDIPROP_GET) { mpt->dwTempo = lpMidiStrm->dwTempo; - TRACE("Getting tempo <= %ld\n", mpt->dwTempo); + TRACE("Getting tempo <= %d\n", mpt->dwTempo); } } else if (dwProperty & MIDIPROP_TIMEDIV) { MIDIPROPTIMEDIV* mptd = (MIDIPROPTIMEDIV*)lpPropData; @@ -1931,10 +1931,10 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD ret = MMSYSERR_INVALPARAM; } else if (dwProperty & MIDIPROP_SET) { lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv; - TRACE("Setting time div to %ld\n", mptd->dwTimeDiv); + TRACE("Setting time div to %d\n", mptd->dwTimeDiv); } else if (dwProperty & MIDIPROP_GET) { mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv; - TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv); + TRACE("Getting time div <= %d\n", mptd->dwTimeDiv); } } else { ret = MMSYSERR_INVALPARAM; @@ -1965,7 +1965,7 @@ MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm) ret = ResumeThread(lpMidiStrm->hThread); } while (ret != 0xFFFFFFFF && ret != 0); if (ret == 0xFFFFFFFF) { - WARN("bad Resume (%ld)\n", GetLastError()); + WARN("bad Resume (%d)\n", GetLastError()); ret = MMSYSERR_ERROR; } else { lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS; @@ -2003,7 +2003,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, DWORD dwRet = MMSYSERR_NOERROR; 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, 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 */ - TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u\n", + TRACE("wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u\n", lpFormat->wFormatTag, lpFormat->nChannels, lpFormat->nSamplesPerSec, lpFormat->nAvgBytesPerSec, lpFormat->nBlockAlign, lpFormat->wBitsPerSample); @@ -2037,7 +2037,7 @@ UINT WAVE_Open(HANDLE* lphndl, UINT uDeviceID, UINT uType, wod.dwInstance = dwInstance; wod.dnDevNode = 0L; - TRACE("cb=%08lx\n", wod.dwCallback); + TRACE("cb=%08x\n", wod.dwCallback); for (;;) { if (dwFlags & WAVE_MAPPED) { @@ -2367,7 +2367,7 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -2381,7 +2381,7 @@ UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -2395,7 +2395,7 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -2409,7 +2409,7 @@ UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL) return MMSYSERR_INVALHANDLE; @@ -2423,7 +2423,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, (DWORD)lpdw); + TRACE("(%p, %p);\n", hWaveOut, lpdw); if (lpdw == NULL) { WARN("invalid parameter\n"); @@ -2443,7 +2443,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD dw) { LPWINE_MLD wmld; - TRACE("(%p, %08lx);\n", hWaveOut, dw); + TRACE("(%p, %08x);\n", hWaveOut, dw); if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL) return MMSYSERR_INVALHANDLE;