[PATCH] [WinMM]: remove WINE_NO_LONG_AS_INT from winmm
Eric Pouech
eric.pouech at wanadoo.fr
Wed Nov 8 15:24:36 CST 2006
- also fixed a couple of wrongly defined functions & structures
A+
---
dlls/winmm/Makefile.in | 2 -
dlls/winmm/driver.c | 10 ++--
dlls/winmm/lolvldrv.c | 16 +++----
dlls/winmm/mci.c | 46 ++++++++++----------
dlls/winmm/message16.c | 112 ++++++++++++++++++++++++------------------------
dlls/winmm/mmio.c | 42 +++++++++---------
dlls/winmm/mmsystem.c | 66 ++++++++++++++--------------
dlls/winmm/playsound.c | 14 +++---
dlls/winmm/sound16.c | 2 -
dlls/winmm/time.c | 6 +--
dlls/winmm/winemm.h | 12 +++--
dlls/winmm/winmm.c | 92 ++++++++++++++++++++-------------------
12 files changed, 209 insertions(+), 211 deletions(-)
diff --git a/dlls/winmm/Makefile.in b/dlls/winmm/Makefile.in
index 6a0fb56..850a656 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 5cab620..d200b57 100644
--- a/dlls/winmm/driver.c
+++ b/dlls/winmm/driver.c
@@ -573,21 +573,21 @@ BOOL WINAPI DriverCallback(DWORD dwCallB
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 dwCallB
((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 0fc1c31..6331752 100644
--- a/dlls/winmm/lolvldrv.c
+++ b/dlls/winmm/lolvldrv.c
@@ -189,7 +189,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UIN
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 @@ #endif
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 @@ #endif
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 @@ #endif
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 @@ #endif
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 @@ #endif
* 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 wM
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 m
{
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 7b44966..fb36da6 100644
--- a/dlls/winmm/mci.c
+++ b/dlls/winmm/mci.c
@@ -1429,7 +1429,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpst
*/
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 lpst
} 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 lpstrComma
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, LPM
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 @@ #undef WINE_MCIDRIVER_SUPP
}
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, DW
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, DW
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, DW
}
}
*(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, DW
*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, DW
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, DW
}
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, DWOR
/**************************************************************************
* 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
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
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
{
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
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
{
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
{
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
/* 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 11283d7..14dbbf4 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 m
/**************************************************************************
* 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_Map16To3
/**************************************************************************
* 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_UnMap16T
/**************************************************************************
* 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_Map32WTo
/**************************************************************************
* 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 @@ #endif
/**************************************************************************
* 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
/**************************************************************************
* 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_Map16T
/**************************************************************************
* 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 @@ #endif
/**************************************************************************
* 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_Map32W
/**************************************************************************
* 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_UnMap3
/**************************************************************************
* 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_Callba
/**************************************************************************
* 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_Map16
/**************************************************************************
* 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_UnMap
/**************************************************************************
* 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_Map32
/**************************************************************************
* 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_UnMap
/**************************************************************************
* 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_Callb
/**************************************************************************
* 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_Map1
*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_Map1
/**************************************************************************
* 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_UnMa
/**************************************************************************
* 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_Map3
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_Map3
*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_Map3
/**************************************************************************
* 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_UnMa
/**************************************************************************
* 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_Call
/**************************************************************************
* 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_Map16
*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_Map16
/**************************************************************************
* 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_UnMap
/**************************************************************************
* 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_Map32
/* 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_Map32
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_Map32
*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_Map32
/**************************************************************************
* 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_UnMap
/**************************************************************************
* 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_Callb
/**************************************************************************
* 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_Map1
*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_Map1
/**************************************************************************
* 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_UnMa
/**************************************************************************
* 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_Map3
/* 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_Map3
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_Map3
*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_Map3
/**************************************************************************
* 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_UnMa
/**************************************************************************
* 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 @@ #define E(_x) do {TRACE _x;goto theEnd;}
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_UnMapMsg32WTo1
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 e872220..900e779 100644
--- a/dlls/winmm/mmio.c
+++ b/dlls/winmm/mmio.c
@@ -260,7 +260,7 @@ LPMMIOPROC MMIO_InstallIOProc(FOURCC fcc
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_M
{
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_M
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, MMIOIN
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
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
}
}
- TRACE("count=%ld\n", count);
+ TRACE("count=%d\n", count);
return count;
}
@@ -809,7 +809,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCST
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, HPCST
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 l
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 l
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 hmmi
{
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,
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,
}
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:"<na>",
lpck->cksize);
@@ -1222,7 +1222,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio,
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,
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 hm
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 hm
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 szFil
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 9262cac..83f63d4 100644
--- a/dlls/winmm/mmsystem.c
+++ b/dlls/winmm/mmsystem.c
@@ -66,7 +66,7 @@ static LRESULT MMIO_Callback16(
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(H
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(HMI
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(HMIXERO
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(HMIXERO
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(H
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 uDev
{
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 uDev
{
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 uDev
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 wDe
{
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 u
{
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 u
*/
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(HMI
{
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(H
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
{
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(HMID
{
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(HM
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 h
{
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(HWA
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(H
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
{
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(HW
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 h
{
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
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(FARPROC1
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 @@ #endif
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 @@ #endif
*/
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_MM
}
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
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(LP
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
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 wM
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 9b18318..2d423fa 100644
--- a/dlls/winmm/playsound.c
+++ b/dlls/winmm/playsound.c
@@ -155,7 +155,7 @@ static void CALLBACK PlaySound_Callback(
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(LPVOI
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(LPVOI
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(LPVOI
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(LPVOI
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 v
{
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 ea1fe57..ee07f81 100644
--- a/dlls/winmm/sound16.c
+++ b/dlls/winmm/sound16.c
@@ -97,7 +97,7 @@ INT16 WINAPI SetSoundNoise16(INT16 nSour
*/
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;
}
diff --git a/dlls/winmm/time.c b/dlls/winmm/time.c
index fa87051..891b569 100644
--- a/dlls/winmm/time.c
+++ b/dlls/winmm/time.c
@@ -80,7 +80,7 @@ #define MMSYSTIME_MAXINTERVAL (65535)
static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer)
{
- TRACE("%04lx:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08lX dwTriggerTime %ld(delta %ld)\n",
+ 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_MMSysTimeThre
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,
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 99cd1c5..ef90d32 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,
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 a7e5ea1..7499f60 100644
--- a/dlls/winmm/winmm.c
+++ b/dlls/winmm/winmm.c
@@ -172,7 +172,7 @@ #undef ERR_TO_STR
*/
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 u
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 u
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, L
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(HMIX
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(HMIX
{
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(HMIX
}
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(HMIXER
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(HMIXER
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
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
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
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(HMIXE
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, U
{
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,
{
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 uE
/**************************************************************************
* 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,
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 hMi
{
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 hM
{
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, UIN
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, UIN
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_MessageH
*/
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 @@ #endif
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_MidiStrea
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* lphM
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(HMIDISTR
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(HMIDI
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(HMIDI
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(HMIDI
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(HMIDI
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(HMIDIS
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 uDev
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 uDev
}
/* 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 uDev
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 hWa
{
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 hWa
{
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(HWAVE
{
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(HWAVE
{
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 hW
{
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 hW
{
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;
More information about the wine-patches
mailing list