system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-07-22 01:54:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

winmm: Enable compilation with long types.

Browse source 
Signed-off-by: Eric Pouech <eric.pouech@gmail.com>
Signed-off-by: Andrew Eikum <aeikum@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Eric Pouech 2022-02-22 08:15:19 -06:00 committed by Alexandre Julliard
parent 5ea3d51118
commit 71189f6260
10 changed files with 211 additions and 211 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
dlls/winmm/Makefile.in
View file

@ -1,4 +1,4 @@
EXTRADEFS = -DWINE_NO_LONG_TYPES -D_WINMM_
EXTRADEFS = -D_WINMM_
MODULE = winmm.dll
IMPORTLIB = winmm
IMPORTS = uuid user32 advapi32 ole32 msacm32

18
dlls/winmm/driver.c
View file

@ -125,10 +125,10 @@ static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
{
LRESULT ret;
TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
TRACE("Before call32 proc=%p drvrID=%08Ix hDrv=%p wMsg=%04x p1=%08Ix p2=%08Ix\n",
lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2);
ret = lpDrv->lpDrvProc(lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
TRACE("After call32 proc=%p drvrID=%08Ix hDrv=%p wMsg=%04x p1=%08Ix p2=%08Ix => %08Ix\n",
lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2, ret);
return ret;
@ -144,14 +144,14 @@ LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
LPWINE_DRIVER lpDrv;
LRESULT retval = 0;
TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
TRACE("(%p, %04X, %08IX, %08IX)\n", hDriver, msg, lParam1, lParam2);
if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
} else {
WARN("Bad driver handle %p\n", hDriver);
}
TRACE("retval = %ld\n", retval);
TRACE("retval = %Id\n", retval);
return retval;
}
@ -278,7 +278,7 @@ LPWINE_DRIVER DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
LPWSTR ptr;
LPCSTR cause = 0;
TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
TRACE("(%s, %08IX);\n", debugstr_w(fn), lParam2);
if ((ptr = wcschr(fn, ' ')) != NULL) {
*ptr++ = '\0';
@ -382,7 +382,7 @@ HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lPar
WCHAR libName[MAX_PATH + 1];
LPCWSTR lsn = lpSectionName;
TRACE("(%s, %s, 0x%08lx);\n",
TRACE("(%s, %s, 0x%08Ix);\n",
debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
DRIVER_Dump("BEFORE:");
@ -418,7 +418,7 @@ LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
BOOL ret;
LPWINE_DRIVER lpDrv;
TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
TRACE("(%p, %08IX, %08IX);\n", hDrvr, lParam1, lParam2);
DRIVER_Dump("BEFORE:");
@ -545,7 +545,7 @@ BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
DWORD_PTR dwParam2)
{
BOOL ret = FALSE;
TRACE("(%08lX, %s %04X, %p, %04X, %08lX, %08lX, %08lX)\n",
TRACE("(%08IX, %s %04lX, %p, %04lX, %08IX, %08IX, %08IX)\n",
dwCallBack, DRIVER_getCallback(uFlags), uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
if (!dwCallBack)
return ret;
@ -594,7 +594,7 @@ BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
break;
#endif
default:
WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
WARN("Unknown callback type %ld\n", uFlags & DCB_TYPEMASK);
return FALSE;
}
if (ret)

24
dlls/winmm/joystick.c
View file

@ -156,7 +156,7 @@ static BOOL WINAPI joystick_load_once( INIT_ONCE *once, void *param, void **cont
{
HRESULT hr = DirectInput8Create( hWinMM32Instance, DIRECTINPUT_VERSION, &IID_IDirectInput8W,
(void **)&dinput, NULL );
if (FAILED(hr)) ERR( "Could not create dinput instance, hr %#x\n", hr );
if (FAILED(hr)) ERR( "Could not create dinput instance, hr %#lx\n", hr );
return TRUE;
}
@ -191,7 +191,7 @@ static void find_joysticks(void)
index = 0;
IDirectInput8_EnumDevices( dinput, DI8DEVCLASS_ALL, enum_instances, &index, DIEDFL_ATTACHEDONLY );
TRACE( "found %u device instances\n", index );
TRACE( "found %lu device instances\n", index );
while (index--)
{
@ -205,18 +205,18 @@ static void find_joysticks(void)
}
if (!(event = CreateEventW( NULL, FALSE, FALSE, NULL )))
WARN( "could not event for device, error %u\n", GetLastError() );
WARN( "could not event for device, error %lu\n", GetLastError() );
else if (FAILED(hr = IDirectInput8_CreateDevice( dinput, &instances[index].guidInstance, &device, NULL )))
WARN( "could not create device %s instance, hr %#x\n",
WARN( "could not create device %s instance, hr %#lx\n",
debugstr_guid( &instances[index].guidInstance ), hr );
else if (FAILED(hr = IDirectInputDevice8_SetEventNotification( device, event )))
WARN( "SetEventNotification device %p hr %#x\n", device, hr );
WARN( "SetEventNotification device %p hr %#lx\n", device, hr );
else if (FAILED(hr = IDirectInputDevice8_SetCooperativeLevel( device, NULL, DISCL_NONEXCLUSIVE|DISCL_BACKGROUND )))
WARN( "SetCooperativeLevel device %p hr %#x\n", device, hr );
WARN( "SetCooperativeLevel device %p hr %#lx\n", device, hr );
else if (FAILED(hr = IDirectInputDevice8_SetDataFormat( device, &data_format )))
WARN( "SetDataFormat device %p hr %#x\n", device, hr );
WARN( "SetDataFormat device %p hr %#lx\n", device, hr );
else if (FAILED(hr = IDirectInputDevice8_Acquire( device )))
WARN( "Acquire device %p hr %#x\n", device, hr );
WARN( "Acquire device %p hr %#lx\n", device, hr );
else
{
TRACE( "opened device %p event %p\n", device, event );
@ -295,7 +295,7 @@ static void CALLBACK joystick_timer( HWND hwnd, UINT msg, UINT_PTR timer, DWORD
*/
MMRESULT WINAPI joyConfigChanged(DWORD flags)
{
FIXME( "flags %#x stub!\n", flags );
FIXME( "flags %#lx stub!\n", flags );
if (flags) return JOYERR_PARMS;
return JOYERR_NOERROR;
}
@ -351,13 +351,13 @@ MMRESULT WINAPI DECLSPEC_HOTPATCH joyGetDevCapsW( UINT_PTR id, JOYCAPSW *caps, U
if (!(device = joysticks[id].device)) res = JOYERR_PARMS;
else if (FAILED(hr = IDirectInputDevice8_GetCapabilities( device, &dicaps )))
{
WARN( "GetCapabilities device %p returned %#x\n", device, hr );
WARN( "GetCapabilities device %p returned %#lx\n", device, hr );
res = JOYERR_PARMS;
}
else
{
hr = IDirectInputDevice8_GetProperty( device, DIPROP_VIDPID, &diprop.diph );
if (FAILED(hr)) WARN( "GetProperty device %p returned %#x\n", device, hr );
if (FAILED(hr)) WARN( "GetProperty device %p returned %#lx\n", device, hr );
else
{
caps->wMid = LOWORD(diprop.dwData);
@ -487,7 +487,7 @@ MMRESULT WINAPI DECLSPEC_HOTPATCH joyGetPosEx( UINT id, JOYINFOEX *info )
res = JOYERR_PARMS;
else if (FAILED(hr = IDirectInputDevice8_GetDeviceState( device, sizeof(struct joystick_state), &state )))
{
WARN( "GetDeviceState device %p returned %#x\n", device, hr );
WARN( "GetDeviceState device %p returned %#lx\n", device, hr );
res = JOYERR_PARMS;
}
else

16
dlls/winmm/lolvldrv.c
View file

@ -97,7 +97,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
WINE_MM_DRIVER_PART* part;
WINE_LLTYPE* llType = &llTypes[mld->type];
TRACE("(%s %d %u 0x%08lx 0x%08lx 0x%08lx)\n",
TRACE("(%s %d %u 0x%08Ix 0x%08Ix 0x%08Ix)\n",
llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
mld->dwDriverInstance, dwParam1, dwParam2);
@ -119,7 +119,7 @@ DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
assert(part->fnMessage32);
TRACE("Calling message(dev=%d msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
TRACE("Calling message(dev=%d msg=%u usr=0x%08Ix p1=0x%08Ix p2=0x%08Ix)\n",
mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
ret = part->fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
TRACE("=> %s\n", WINMM_ErrorToString(ret));
@ -195,7 +195,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwFlags)
DWORD dwRet = MMSYSERR_BADDEVICEID;
DWORD_PTR dwInstance;
WINE_LLTYPE* llType = &llTypes[mld->type];
TRACE("(%p, %04x, 0x%08lx, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags);
TRACE("(%p, %04x, 0x%08Ix, 0x%08lx)\n", mld, wMsg, dwParam1, dwFlags);
mld->dwDriverInstance = (DWORD_PTR)&dwInstance;
@ -286,7 +286,7 @@ UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg,
{
WINE_MM_DRIVER* lpDrv = &MMDrvs[mld->mmdIndex];
TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2);
TRACE("(%p, %04x, %08Ix, %08Ix)\n", mld, uMsg, dwParam1, dwParam2);
/* all those function calls are undocumented */
switch (uMsg) {
@ -505,20 +505,20 @@ static void MMDRV_Init(void)
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
if(FAILED(hr)){
ERR("CoCreateInstance failed: %08x\n", hr);
ERR("CoCreateInstance failed: %08lx\n", hr);
goto exit;
}
hr = IMMDeviceEnumerator_GetDevice(devenum, L"Wine info device", &device);
IMMDeviceEnumerator_Release(devenum);
if(FAILED(hr)){
ERR("GetDevice failed: %08x\n", hr);
ERR("GetDevice failed: %08lx\n", hr);
goto exit;
}
hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
if(FAILED(hr)){
ERR("OpenPropertyStore failed: %08x\n", hr);
ERR("OpenPropertyStore failed: %08lx\n", hr);
IMMDevice_Release(device);
goto exit;
}
@ -528,7 +528,7 @@ static void MMDRV_Init(void)
IPropertyStore_Release(ps);
IMMDevice_Release(device);
if(FAILED(hr)){
ERR("GetValue failed: %08x\n", hr);
ERR("GetValue failed: %08lx\n", hr);
goto exit;
}

70
dlls/winmm/mci.c
View file

@ -1112,7 +1112,7 @@ static DWORD MCI_ParseOptArgs(DWORD* data, int _offset, LPCWSTR lpCmd,
break;
case MCI_FLAG:
*dwFlags |= flg;
TRACE("flag=%08x\n", flg);
TRACE("flag=%08lx\n", flg);
break;
case MCI_HWND:
case MCI_HPAL:
@ -1122,13 +1122,13 @@ static DWORD MCI_ParseOptArgs(DWORD* data, int _offset, LPCWSTR lpCmd,
data[offset] |= flg;
*dwFlags |= cflg;
inCst = FALSE;
TRACE("flag=%08x constant=%08x\n", cflg, flg);
TRACE("flag=%08lx constant=%08lx\n", cflg, flg);
} else {
*dwFlags |= flg;
if (!MCI_GetDWord(&(data[offset]), &args)) {
return MCIERR_BAD_INTEGER;
}
TRACE("flag=%08x int=%d\n", flg, data[offset]);
TRACE("flag=%08lx int=%ld\n", flg, data[offset]);
}
break;
case MCI_RECT:
@ -1140,13 +1140,13 @@ static DWORD MCI_ParseOptArgs(DWORD* data, int _offset, LPCWSTR lpCmd,
!MCI_GetDWord(&(data[offset+3]), &args)) {
return MCIERR_BAD_INTEGER;
}
TRACE("flag=%08x for rectangle\n", flg);
TRACE("flag=%08lx for rectangle\n", flg);
break;
case MCI_STRING:
*dwFlags |= flg;
if ((dwRet = MCI_GetString((LPWSTR*)&data[offset], &args)))
return dwRet;
TRACE("flag=%08x string=%s\n", flg, debugstr_w(*(LPWSTR*)&data[offset]));
TRACE("flag=%08lx string=%s\n", flg, debugstr_w(*(LPWSTR*)&data[offset]));
break;
default: ERR("oops\n");
}
@ -1287,7 +1287,7 @@ static DWORD MCI_HandleReturnValues(DWORD dwRet, LPWINE_MCIDRIVER wmd, DWORD ret
swprintf(lpstrRet, uRetLen, L"%d %d %d %d", data[0], data[1], data[2], data[3]);
break;
}
default: FIXME("Unknown MCI return type %d\n", retType);
default: FIXME("Unknown MCI return type %ld\n", retType);
}
}
return LOWORD(dwRet);
@ -1486,7 +1486,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
offset += sizeof(DWORD_PTR);
break;
default:
FIXME("Unknown MCI return type %d\n", retType);
FIXME("Unknown MCI return type %ld\n", retType);
dwRet = MCIERR_PARSER_INTERNAL;
goto errCleanUp;
}
@ -1546,7 +1546,7 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
break;
}
TRACE("[%d, %s, %08x, %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x]\n",
TRACE("[%d, %s, %08lx, %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx]\n",
wmd ? wmd->wDeviceID : uDevID, MCI_MessageToString(wMsg), dwFlags,
data.dw[0], data.dw[1], data.dw[2], data.dw[3], data.dw[4],
data.dw[5], data.dw[6], data.dw[7], data.dw[8], data.dw[9]);
@ -1559,11 +1559,11 @@ DWORD WINAPI mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrRet,
dwRet = MCI_SendCommand(wmd ? wmd->wDeviceID : uDevID, wMsg, dwFlags, (DWORD_PTR)&data);
}
if (!LOWORD(dwRet)) {
TRACE("=> 1/ %x (%s)\n", dwRet, debugstr_w(lpstrRet));
TRACE("=> 1/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet));
dwRet = MCI_HandleReturnValues(dwRet, wmd, retType, &data.generic, lpstrRet, uRetLen);
TRACE("=> 2/ %x (%s)\n", dwRet, debugstr_w(lpstrRet));
TRACE("=> 2/ %lx (%s)\n", dwRet, debugstr_w(lpstrRet));
} else
TRACE("=> %x\n", dwRet);
TRACE("=> %lx\n", dwRet);
errCleanUp:
if (auto_open) {
@ -1625,7 +1625,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 (%d)", ret);
sprintf(strRet, "Unknown MCI error (%ld)", ret);
}
MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
}
@ -1703,7 +1703,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
DWORD dwRet;
LPWINE_MCIDRIVER wmd = NULL;
TRACE("(%08X, %p)\n", dwParam, lpParms);
TRACE("(%08lX, %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 */
@ -1711,7 +1711,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSW lpParms)
MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
MCI_NOTIFY|MCI_WAIT)
if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0)
FIXME("Unsupported yet dwFlags=%08X\n", dwParam);
FIXME("Unsupported yet dwFlags=%08lX\n", dwParam);
#undef WINE_MCIDRIVER_SUPP
strDevTyp[0] = 0;
@ -1801,13 +1801,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) [%08x], closing\n", dwRet);
TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet);
/* FIXME: is dwRet the correct ret code ? */
goto errCleanUp;
}
/* only handled devices fall through */
TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
return 0;
errCleanUp:
@ -1823,7 +1823,7 @@ static DWORD MCI_Close(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
DWORD dwRet;
LPWINE_MCIDRIVER wmd;
TRACE("(%04x, %08X, %p)\n", wDevID, dwParam, lpParms);
TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
/* Every device must handle MCI_NOTIFY on its own. */
if ((UINT16)wDevID == (UINT16)MCI_ALL_DEVICE_ID) {
@ -1891,7 +1891,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if (lpParms->lpstrReturn == NULL) return MCIERR_PARAM_OVERFLOW;
TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
TRACE("(%08x, %08lX, %p[num=%ld, wDevTyp=%u])\n",
uDevID, dwFlags, lpParms, lpParms->dwNumber, lpParms->wDeviceType);
if ((WORD)MCI_ALL_DEVICE_ID == LOWORD(uDevID))
uDevID = MCI_ALL_DEVICE_ID; /* Be compatible with Win9x */
@ -1945,7 +1945,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
}
}
*(DWORD*)lpParms->lpstrReturn = cnt;
TRACE("(%d) => '%d'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
ret = MCI_INTEGER_RETURNED;
/* return ret; Only Win9x sends a notification in this case. */
break;
@ -1958,7 +1958,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
ret = (uDevID == MCI_ALL_DEVICE_ID)
? MCIERR_CANNOT_USE_ALL : MCIERR_INVALID_DEVICE_NAME;
}
TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
break;
case MCI_SYSINFO_NAME:
s = NULL;
@ -1981,7 +1981,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
LeaveCriticalSection(&WINMM_cs);
ret = s ? MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, s) : MCIERR_OUTOFRANGE;
} else if (MCI_ALL_DEVICE_ID == uDevID) {
TRACE("MCI_SYSINFO_NAME: device #%d\n", lpParms->dwNumber);
TRACE("MCI_SYSINFO_NAME: device #%ld\n", lpParms->dwNumber);
if (RegOpenKeyExW( HKEY_LOCAL_MACHINE, wszHklmMci, 0,
KEY_QUERY_VALUE, &hKey ) == ERROR_SUCCESS) {
if (RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt,
@ -1997,7 +1997,7 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
if (!s) {
if (GetPrivateProfileStringW(L"MCI", 0, L"", buf, ARRAY_SIZE(buf), L"system.ini")) {
for (p = buf; *p; p += lstrlenW(p) + 1, cnt++) {
TRACE("%d: %s\n", cnt, debugstr_w(p));
TRACE("%ld: %s\n", cnt, debugstr_w(p));
if (cnt == lpParms->dwNumber - 1) {
s = p;
break;
@ -2018,10 +2018,10 @@ static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSW lpParm
ret = 0;
}
}
TRACE("(%d) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
TRACE("(%ld) => %s\n", lpParms->dwNumber, debugstr_w(lpParms->lpstrReturn));
break;
default:
TRACE("Unsupported flag value=%08x\n", dwFlags);
TRACE("Unsupported flag value=%08lx\n", dwFlags);
ret = MCIERR_UNRECOGNIZED_KEYWORD;
}
if ((dwFlags & MCI_NOTIFY) && HRESULT_CODE(ret)==0)
@ -2039,7 +2039,7 @@ static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
if (lpParms == NULL)
return MCIERR_NULL_PARAMETER_BLOCK;
TRACE("(%08x, %08X, vkey %04X, hwnd %p)\n", wDevID, dwFlags,
TRACE("(%08x, %08lX, vkey %04X, hwnd %p)\n", wDevID, dwFlags,
lpParms->nVirtKey, lpParms->hwndBreak);
dwRet = MCI_SendCommandFrom32(wDevID, MCI_BREAK, dwFlags, (DWORD_PTR)lpParms);
@ -2131,7 +2131,7 @@ static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
LPMCI_GETDEVCAPS_PARMS lmgp;
lmgp = (LPMCI_GETDEVCAPS_PARMS)dwParam2;
TRACE("Changing %08x to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn));
TRACE("Changing %08lx to %08x\n", lmgp->dwReturn, LOWORD(lmgp->dwReturn));
lmgp->dwReturn = LOWORD(lmgp->dwReturn);
}
break;
@ -2154,7 +2154,7 @@ static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
LPMCI_STATUS_PARMS lsp;
lsp = (LPMCI_STATUS_PARMS)dwParam2;
TRACE("Changing %08lx to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn));
TRACE("Changing %08Ix to %08x\n", lsp->dwReturn, LOWORD(lsp->dwReturn));
lsp->dwReturn = LOWORD(lsp->dwReturn);
}
break;
@ -2175,7 +2175,7 @@ static LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD_PTR dwParam2)
break;
default:
if (HIWORD(dwRet)) {
FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
FIXME("Got non null hiword for dwRet=0x%08Ix for command %s\n",
dwRet, MCI_MessageToString(wMsg));
}
break;
@ -2253,7 +2253,7 @@ BOOL WINAPI mciSetDriverData(MCIDEVICEID uDeviceID, DWORD_PTR data)
{
LPWINE_MCIDRIVER wmd;
TRACE("(%04x, %08lx)\n", uDeviceID, data);
TRACE("(%04x, %08Ix)\n", uDeviceID, data);
wmd = MCI_GetDriver(uDeviceID);
@ -2274,12 +2274,12 @@ DWORD WINAPI mciSendCommandW(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1,
{
DWORD dwRet;
TRACE("(%08x, %s, %08lx, %08lx)\n",
TRACE("(%08x, %s, %08Ix, %08Ix)\n",
wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
dwRet = MCI_SendCommand(wDevID, wMsg, dwParam1, dwParam2);
dwRet = MCI_CleanUp(dwRet, wMsg, dwParam2);
TRACE("=> %08x\n", dwRet);
TRACE("=> %08lx\n", dwRet);
return dwRet;
}
@ -2291,7 +2291,7 @@ DWORD WINAPI mciSendCommandA(MCIDEVICEID wDevID, UINT wMsg, DWORD_PTR dwParam1,
DWORD ret;
int mapped;
TRACE("(%08x, %s, %08lx, %08lx)\n",
TRACE("(%08x, %s, %08Ix, %08Ix)\n",
wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
mapped = MCI_MapMsgAtoW(wMsg, dwParam1, &dwParam2);
@ -2338,7 +2338,7 @@ static UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
INT16 ret;
MSG msg;
TRACE("(0x%04x, 0x%08x)\n", wDevID, data);
TRACE("(0x%04x, 0x%08lx)\n", wDevID, data);
if ((HIWORD(data) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data)) ||
(GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
@ -2359,7 +2359,7 @@ BOOL WINAPI mciSetYieldProc(MCIDEVICEID uDeviceID, YIELDPROC fpYieldProc, DWORD
{
LPWINE_MCIDRIVER wmd;
TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
TRACE("(%u, %p, %08lx)\n", uDeviceID, fpYieldProc, dwYieldData);
if (!(wmd = MCI_GetDriver(uDeviceID))) {
WARN("Bad uDeviceID\n");
@ -2396,7 +2396,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
/* FIXME: that's rather strange, there is no
* mciGetDeviceIDFromElementID32A in winmm.spec
*/
FIXME("(%u, %s) stub\n", dwElementID, debugstr_w(lpstrType));
FIXME("(%lu, %s) stub\n", dwElementID, debugstr_w(lpstrType));
return 0;
}

48
dlls/winmm/mmio.c
View file

@ -97,7 +97,7 @@ static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
{
LRESULT ret = MMSYSERR_NOERROR;
TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo, uMessage, lParam1, lParam2);
TRACE("(%p, %X, 0x%Ix, 0x%Ix);\n", lpmmioinfo, uMessage, lParam1, lParam2);
switch (uMessage) {
case MMIOM_OPEN:
@ -206,7 +206,7 @@ static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
LPARAM lParam1, LPARAM lParam2)
{
TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n", lpmmioinfo, uMessage, lParam1, lParam2);
TRACE("(%p,0x%04x,0x%08Ix,0x%08Ix)\n", lpmmioinfo, uMessage, lParam1, lParam2);
switch (uMessage) {
@ -310,7 +310,7 @@ static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
struct IOProcList* pListNode;
struct IOProcList** ppListNode;
TRACE("(%08x, %p, %08X, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi");
TRACE("(%08lx, %p, %08lX, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi");
if (dwFlags & MMIO_GLOBALPROC)
FIXME("Global procedures not implemented\n");
@ -563,7 +563,7 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
{
LONG size = wm->info.cchBuffer;
TRACE("bo=%x do=%x\n",
TRACE("bo=%lx do=%lx\n",
wm->info.lBufOffset, wm->info.lDiskOffset);
wm->info.lBufOffset = wm->info.lDiskOffset;
@ -590,10 +590,10 @@ static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer,
UINT uFlags)
{
TRACE("(%p %p %d %u)\n", wm, pchBuffer, cchBuffer, uFlags);
TRACE("(%p %p %ld %u)\n", wm, pchBuffer, cchBuffer, uFlags);
if (cchBuffer > 0xFFFF)
WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer);
WARN("Untested handling of huge mmio buffers (%ld >= 64k)\n", cchBuffer);
if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
return MMIOERR_CANNOTWRITE;
@ -634,7 +634,7 @@ static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags,
MMIOINFO mmioinfo;
DWORD pos;
TRACE("(%s, %p, %08X, %s);\n", debugstr_a(szFileName), refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi");
TRACE("(%s, %p, %08lX, %s);\n", debugstr_a(szFileName), refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi");
if (!refmminfo) {
refmminfo = &mmioinfo;
@ -801,7 +801,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
LPWINE_MMIO wm;
LONG count;
TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
TRACE("(%p, %p, %ld);\n", hmmio, pch, cch);
if ((wm = MMIO_Get(hmmio)) == NULL)
return -1;
@ -842,7 +842,7 @@ LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
mmioSeek(hmmio, 0, SEEK_CUR);
}
TRACE("count=%d\n", count);
TRACE("count=%ld\n", count);
return count;
}
@ -854,7 +854,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
LPWINE_MMIO wm;
LONG count;
TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
TRACE("(%p, %p, %ld);\n", hmmio, pch, cch);
if ((wm = MMIO_Get(hmmio)) == NULL)
return -1;
@ -895,7 +895,7 @@ LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
wm->info.lBufOffset = wm->info.lDiskOffset;
}
TRACE("bytes written=%d\n", count);
TRACE("bytes written=%ld\n", count);
return count;
}
@ -907,7 +907,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
LPWINE_MMIO wm;
LONG offset;
TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin);
TRACE("(%p, %08lX, %d);\n", hmmio, lOffset, iOrigin);
if ((wm = MMIO_Get(hmmio)) == NULL)
return MMSYSERR_INVALHANDLE;
@ -966,7 +966,7 @@ LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
else
wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
TRACE("=> %d\n", offset);
TRACE("=> %ld\n", offset);
return offset;
}
@ -1019,7 +1019,7 @@ MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT
{
LPWINE_MMIO wm;
TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n",
TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
hmmio, pchBuffer, cchBuffer, uFlags);
if ((wm = MMIO_Get(hmmio)) == NULL)
@ -1154,7 +1154,7 @@ static LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1,
{
LPWINE_MMIO wm;
TRACE("(%p, %u, %ld, %ld, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi");
TRACE("(%p, %u, %Id, %Id, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi");
if (uMessage < MMIOM_USER)
return MMSYSERR_INVALPARAM;
@ -1190,10 +1190,10 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
return MMSYSERR_INVALPARAM;
dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
TRACE("dwOldPos=%d\n", dwOldPos);
TRACE("dwOldPos=%ld\n", dwOldPos);
if (lpckParent != NULL) {
TRACE("seek inside parent at %d !\n", lpckParent->dwDataOffset);
TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset);
/* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
if (dwOldPos < lpckParent->dwDataOffset ||
dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
@ -1242,7 +1242,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
}
lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
TRACE("ckid=%s fcc=%s cksize=%08X !\n",
TRACE("ckid=%s fcc=%s cksize=%08lX !\n",
debugstr_an((LPCSTR)&lpck->ckid, 4),
srchType ? debugstr_an((LPCSTR)&lpck->fccType, 4) : "<na>",
lpck->cksize);
@ -1266,7 +1266,7 @@ MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
lpck->fccType = 0;
}
TRACE("lpck: ckid=%s, cksize=%d, dwDataOffset=%d fccType=%08X (%s)!\n",
TRACE("lpck: ckid=%s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%s)!\n",
debugstr_an((LPSTR)&lpck->ckid, 4), lpck->cksize, lpck->dwDataOffset,
lpck->fccType, srchType ? debugstr_an((LPSTR)&lpck->fccType, 4):"");
return MMSYSERR_NOERROR;
@ -1284,10 +1284,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=%d lpck->dwDataOffset = %d\n", dwOldPos, lpck->dwDataOffset);
TRACE("dwOldPos=%ld lpck->dwDataOffset = %ld\n", dwOldPos, lpck->dwDataOffset);
dwNewSize = dwOldPos - lpck->dwDataOffset;
if (dwNewSize != lpck->cksize) {
TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck->cksize, dwNewSize);
TRACE("Nope: lpck->cksize=%ld dwNewSize=%ld\n", lpck->cksize, dwNewSize);
lpck->cksize = dwNewSize;
/* pad odd size with 0 */
@ -1318,7 +1318,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=%d\n", dwOldPos);
TRACE("dwOldPos=%ld\n", dwOldPos);
if (uFlags == MMIO_CREATELIST)
lpck->ckid = FOURCC_LIST;
@ -1335,7 +1335,7 @@ MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
lpck->dwFlags = MMIO_DIRTY;
ix = mmioWrite(hmmio, (LPSTR)lpck, size);
TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix, size, errno);
TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n", ix, size, errno);
if (ix < size) {
mmioSeek(hmmio, dwOldPos, SEEK_SET);
WARN("return CannotWrite\n");
@ -1355,7 +1355,7 @@ MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
struct IOProcList tmp;
FOURCC fcc;
TRACE("(%s, %s, %p, %08X);\n",
TRACE("(%s, %s, %p, %08lX);\n",
debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags);
/* If both params are NULL, then parse the file name */

14
dlls/winmm/playsound.c
View file

@ -159,7 +159,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=%Ix\n", dwParam1);
SetEvent(s->hEvent);
break;
default:
@ -344,7 +344,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &ckMainRIFF, NULL, 0))
goto errCleanUp;
TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08X\n",
TRACE("ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX\n",
(LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize);
if ((ckMainRIFF.ckid != FOURCC_RIFF) ||
@ -355,7 +355,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
TRACE("Chunk Found ckid=%.4s fccType=%08lx cksize=%08lX\n",
(LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize);
lpWaveFormat = HeapAlloc(GetProcessHeap(), 0, mmckInfo.cksize);
@ -366,8 +366,8 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
TRACE("wFormatTag=%04X !\n", lpWaveFormat->wFormatTag);
TRACE("nChannels=%d\n", lpWaveFormat->nChannels);
TRACE("nSamplesPerSec=%d\n", lpWaveFormat->nSamplesPerSec);
TRACE("nAvgBytesPerSec=%d\n", lpWaveFormat->nAvgBytesPerSec);
TRACE("nSamplesPerSec=%ld\n", lpWaveFormat->nSamplesPerSec);
TRACE("nAvgBytesPerSec=%ld\n", lpWaveFormat->nAvgBytesPerSec);
TRACE("nBlockAlign=%d\n", lpWaveFormat->nBlockAlign);
TRACE("wBitsPerSample=%u !\n", lpWaveFormat->wBitsPerSample);
@ -378,7 +378,7 @@ static DWORD WINAPI proc_PlaySound(LPVOID arg)
if (mmioDescend(hmmio, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK))
goto errCleanUp;
TRACE("Chunk Found ckid=%.4s fccType=%08x cksize=%08X\n",
TRACE("Chunk Found ckid=%.4s fccType=%08lx cksize=%08lX\n",
(LPSTR)&mmckInfo.ckid, mmckInfo.fccType, mmckInfo.cksize);
s.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
@ -469,7 +469,7 @@ static BOOL MULTIMEDIA_PlaySound(const void* pszSound, HMODULE hmod, DWORD fdwSo
{
WINE_PLAYSOUND* wps = NULL;
TRACE("pszSound='%p' hmod=%p fdwSound=%08X\n",
TRACE("pszSound='%p' hmod=%p fdwSound=%08lX\n",
pszSound, hmod, fdwSound);
/* SND_NOWAIT is ignored in w95/2k/xp. */

2
dlls/winmm/time.c
View file

@ -271,7 +271,7 @@ MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
WORD new_id = 0;
int i;
TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
TRACE("(%u, %u, %p, %08IX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
return 0;

178
dlls/winmm/waveform.c
View file

@ -737,18 +737,18 @@ static HRESULT reroute_mapper_device(WINMM_Device *device, BOOL is_out)
hr = IAudioClient_Stop(device->client);
if(FAILED(hr))
WARN("Stop failed: %08x\n", hr);
WARN("Stop failed: %08lx\n", hr);
hr = IAudioClock_GetFrequency(device->clock, &clock_freq);
if(FAILED(hr)){
WARN("GetFrequency failed: %08x\n", hr);
WARN("GetFrequency failed: %08lx\n", hr);
LeaveCriticalSection(&device->lock);
return hr;
}
hr = IAudioClock_GetPosition(device->clock, &clock_pos, NULL);
if(FAILED(hr)){
WARN("GetPosition failed: %08x\n", hr);
WARN("GetPosition failed: %08lx\n", hr);
LeaveCriticalSection(&device->lock);
return hr;
}
@ -852,7 +852,7 @@ static HRESULT WINMM_InitMMDevices(void)
hr = IMMDeviceEnumerator_RegisterEndpointNotificationCallback(devenum, &g_notif);
if(FAILED(hr))
WARN("RegisterEndpointNotificationCallback failed: %08x\n", hr);
WARN("RegisterEndpointNotificationCallback failed: %08lx\n", hr);
hr = WINMM_EnumDevices(&g_out_mmdevices, &g_out_map, &g_outmmdevices_count,
eRender, devenum);
@ -890,7 +890,7 @@ static MMRESULT WINMM_TryDeviceMapping(WINMM_Device *device, WAVEFORMATEX *fmt,
HRESULT hr;
MMRESULT mr;
TRACE("format: %u, channels: %u, sample rate: %u, bit depth: %u\n",
TRACE("format: %u, channels: %u, sample rate: %lu, bit depth: %lu\n",
WAVE_FORMAT_PCM, channels, freq, bits_per_samp);
target.wFormatTag = WAVE_FORMAT_PCM;
@ -929,7 +929,7 @@ static MMRESULT WINMM_TryDeviceMapping(WINMM_Device *device, WAVEFORMATEX *fmt,
AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
AC_BUFLEN, 0, &target, &device->parent->session);
if(hr != S_OK){
WARN("Initialize failed: %08x\n", hr);
WARN("Initialize failed: %08lx\n", hr);
acmStreamClose(device->acm_handle, 0);
device->acm_handle = NULL;
return MMSYSERR_ERROR;
@ -1073,7 +1073,7 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
hr = IMMDeviceEnumerator_GetDevice(g_devenum, device->parent->dev_id,
&device->device);
if(FAILED(hr)){
WARN("Device %s (%s) unavailable: %08x\n",
WARN("Device %s (%s) unavailable: %08lx\n",
wine_dbgstr_w(device->parent->dev_id),
wine_dbgstr_w(device->parent->out_caps.szPname), hr);
ret = MMSYSERR_NODRIVER;
@ -1084,7 +1084,7 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
hr = IMMDevice_Activate(device->device, &IID_IAudioClient,
CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
if(FAILED(hr)){
WARN("Activate failed: %08x\n", hr);
WARN("Activate failed: %08lx\n", hr);
ret = hr2mmr(hr);
if(ret == MMSYSERR_ERROR)
ret = MMSYSERR_NOTENABLED;
@ -1114,7 +1114,7 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
device->orig_fmt->nBlockAlign = device->orig_fmt->nChannels * device->orig_fmt->wBitsPerSample/8;
}
if (device->orig_fmt->nAvgBytesPerSec != device->orig_fmt->nSamplesPerSec * device->orig_fmt->nBlockAlign) {
WARN("Fixing bad nAvgBytesPerSec (%u)\n", device->orig_fmt->nAvgBytesPerSec);
WARN("Fixing bad nAvgBytesPerSec (%lu)\n", device->orig_fmt->nAvgBytesPerSec);
device->orig_fmt->nAvgBytesPerSec = device->orig_fmt->nSamplesPerSec * device->orig_fmt->nBlockAlign;
}
}else{
@ -1146,7 +1146,7 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
if(ret != MMSYSERR_NOERROR || info->flags & WAVE_FORMAT_QUERY)
goto error;
}else{
WARN("Initialize failed: %08x\n", hr);
WARN("Initialize failed: %08lx\n", hr);
ret = hr2mmr(hr);
goto error;
}
@ -1158,14 +1158,14 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
hr = IAudioClient_GetService(device->client, &IID_IAudioClock,
(void**)&device->clock);
if(FAILED(hr)){
WARN("GetService failed: %08x\n", hr);
WARN("GetService failed: %08lx\n", hr);
goto error;
}
if(!device->event){
device->event = CreateEventW(NULL, FALSE, FALSE, NULL);
if(!device->event){
WARN("CreateEvent failed: %08x\n", hr);
WARN("CreateEvent failed: %08lx\n", hr);
goto error;
}
@ -1188,7 +1188,7 @@ static LRESULT WINMM_OpenDevice(WINMM_Device *device, WINMM_OpenInfo *info,
hr = IAudioClient_SetEventHandle(device->client, device->event);
if(FAILED(hr)){
WARN("SetEventHandle failed: %08x\n", hr);
WARN("SetEventHandle failed: %08lx\n", hr);
goto error;
}
@ -1287,14 +1287,14 @@ static LRESULT WOD_Open(WINMM_OpenInfo *info)
hr = IAudioClient_GetService(device->client, &IID_IAudioRenderClient,
(void**)&device->render);
if(FAILED(hr)){
ERR("GetService failed: %08x\n", hr);
ERR("GetService failed: %08lx\n", hr);
goto error;
}
hr = IAudioClient_GetService(device->client, &IID_IAudioStreamVolume,
(void**)&device->volume);
if(FAILED(hr)){
ERR("GetService failed: %08x\n", hr);
ERR("GetService failed: %08lx\n", hr);
goto error;
}
@ -1376,7 +1376,7 @@ static LRESULT WID_Open(WINMM_OpenInfo *info)
hr = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
(void**)&device->capture);
if(FAILED(hr)){
WARN("GetService failed: %08x\n", hr);
WARN("GetService failed: %08lx\n", hr);
goto error;
}
@ -1583,13 +1583,13 @@ static WAVEHDR *WOD_MarkDoneHeaders(WINMM_Device *device)
hr = IAudioClock_GetFrequency(device->clock, &clock_freq);
if(FAILED(hr)){
WARN("GetFrequency failed: %08x\n", hr);
WARN("GetFrequency failed: %08lx\n", hr);
return NULL;
}
hr = IAudioClock_GetPosition(device->clock, &clock_pos, NULL);
if(FAILED(hr)){
WARN("GetPosition failed: %08x\n", hr);
WARN("GetPosition failed: %08lx\n", hr);
return NULL;
}
@ -1653,13 +1653,13 @@ static void WOD_PushData(WINMM_Device *device)
hr = IAudioClient_GetBufferSize(device->client, &bufsize);
if(FAILED(hr)){
WARN("GetBufferSize failed: %08x\n", hr);
WARN("GetBufferSize failed: %08lx\n", hr);
goto exit;
}
hr = IAudioClient_GetCurrentPadding(device->client, &pad);
if(FAILED(hr)){
WARN("GetCurrentPadding failed: %08x\n", hr);
WARN("GetCurrentPadding failed: %08lx\n", hr);
goto exit;
}
@ -1692,7 +1692,7 @@ static void WOD_PushData(WINMM_Device *device)
hr = IAudioRenderClient_GetBuffer(device->render, avail_frames, &data);
if(FAILED(hr)){
WARN("GetBuffer failed: %08x\n", hr);
WARN("GetBuffer failed: %08lx\n", hr);
goto exit;
}
@ -1746,7 +1746,7 @@ static void WOD_PushData(WINMM_Device *device)
hr = IAudioRenderClient_ReleaseBuffer(device->render, avail_frames, 0);
if(FAILED(hr)){
WARN("ReleaseBuffer failed: %08x\n", hr);
WARN("ReleaseBuffer failed: %08lx\n", hr);
goto exit;
}
@ -1784,7 +1784,7 @@ static void WID_PullACMData(WINMM_Device *device)
&flags, NULL, NULL);
if(hr != S_OK){
if(FAILED(hr))
WARN("GetBuffer failed: %08x\n", hr);
WARN("GetBuffer failed: %08lx\n", hr);
return;
}
@ -1819,7 +1819,7 @@ static void WID_PullACMData(WINMM_Device *device)
hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet);
if(FAILED(hr))
WARN("ReleaseBuffer failed: %08x\n", hr);
WARN("ReleaseBuffer failed: %08lx\n", hr);
device->played_frames += packet;
}
@ -1892,7 +1892,7 @@ static void WID_PullData(WINMM_Device *device)
&flags, NULL, NULL);
if(hr != S_OK){
if(FAILED(hr))
WARN("GetBuffer failed: %08x\n", hr);
WARN("GetBuffer failed: %08lx\n", hr);
else /* AUDCLNT_S_BUFFER_EMPTY success code */
IAudioCaptureClient_ReleaseBuffer(device->capture, 0);
goto exit;
@ -1923,7 +1923,7 @@ static void WID_PullData(WINMM_Device *device)
hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet_len);
if(FAILED(hr))
WARN("ReleaseBuffer failed: %08x\n", hr);
WARN("ReleaseBuffer failed: %08lx\n", hr);
if(packet > 0)
WARN("losing %u frames\n", packet);
@ -1959,7 +1959,7 @@ static MMRESULT WINMM_BeginPlaying(WINMM_Device *device)
hr = IAudioClient_Start(device->client);
if(FAILED(hr) && hr != AUDCLNT_E_NOT_STOPPED){
device->stopped = TRUE;
WARN("Start failed: %08x\n", hr);
WARN("Start failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
}
@ -1975,7 +1975,7 @@ static LRESULT WINMM_Pause(WINMM_Device *device)
hr = IAudioClient_Stop(device->client);
if(FAILED(hr)){
WARN("Stop failed: %08x\n", hr);
WARN("Stop failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -2000,7 +2000,7 @@ static LRESULT WINMM_Reset(HWAVE hwave)
hr = IAudioClient_Stop(device->client);
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
WARN("Stop failed: %08x\n", hr);
WARN("Stop failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
device->stopped = TRUE;
@ -2123,7 +2123,7 @@ static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id, &device);
if(FAILED(hr)){
WARN("Device %s (%s) unavailable: %08x\n",
WARN("Device %s (%s) unavailable: %08lx\n",
wine_dbgstr_w(mmdevice->dev_id),
wine_dbgstr_w(mmdevice->out_caps.szPname), hr);
return MMSYSERR_ERROR;
@ -2132,7 +2132,7 @@ static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
hr = IMMDevice_Activate(device, &IID_IAudioSessionManager,
CLSCTX_INPROC_SERVER, NULL, (void**)&sesman);
if(FAILED(hr)){
WARN("Activate failed: %08x\n", hr);
WARN("Activate failed: %08lx\n", hr);
IMMDevice_Release(device);
return MMSYSERR_ERROR;
}
@ -2143,7 +2143,7 @@ static MMRESULT WINMM_SetupMMDeviceVolume(WINMM_MMDevice *mmdevice)
FALSE, &mmdevice->volume);
IAudioSessionManager_Release(sesman);
if(FAILED(hr)){
WARN("GetSimpleAudioVolume failed: %08x\n", hr);
WARN("GetSimpleAudioVolume failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -2186,7 +2186,7 @@ static LRESULT MXD_GetControlDetails(WINMM_ControlDetails *details)
hr = ISimpleAudioVolume_GetMasterVolume(mmdevice->volume, &vol);
if(FAILED(hr)){
WARN("GetMasterVolume failed: %08x\n", hr);
WARN("GetMasterVolume failed: %08lx\n", hr);
LeaveCriticalSection(&mmdevice->lock);
return MMSYSERR_ERROR;
}
@ -2205,7 +2205,7 @@ static LRESULT MXD_GetControlDetails(WINMM_ControlDetails *details)
hr = ISimpleAudioVolume_GetMute(mmdevice->volume, &mute);
if(FAILED(hr)){
WARN("GetMute failed: %08x\n", hr);
WARN("GetMute failed: %08lx\n", hr);
LeaveCriticalSection(&mmdevice->lock);
return MMSYSERR_ERROR;
}
@ -2269,7 +2269,7 @@ static LRESULT MXD_SetControlDetails(WINMM_ControlDetails *details)
hr = ISimpleAudioVolume_SetMasterVolume(mmdevice->volume, vol, NULL);
if(FAILED(hr)){
WARN("SetMasterVolume failed: %08x\n", hr);
WARN("SetMasterVolume failed: %08lx\n", hr);
LeaveCriticalSection(&mmdevice->lock);
return MMSYSERR_ERROR;
}
@ -2288,7 +2288,7 @@ static LRESULT MXD_SetControlDetails(WINMM_ControlDetails *details)
hr = ISimpleAudioVolume_SetMute(mmdevice->volume, mute, NULL);
if(FAILED(hr)){
WARN("SetMute failed: %08x\n", hr);
WARN("SetMute failed: %08lx\n", hr);
LeaveCriticalSection(&mmdevice->lock);
return MMSYSERR_ERROR;
}
@ -2342,13 +2342,13 @@ static LRESULT DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo *info)
hr = IMMDeviceEnumerator_GetDevice(g_devenum, mmdevice->dev_id,
&device);
if(FAILED(hr)){
WARN("Device %s unavailable: %08x\n", wine_dbgstr_w(mmdevice->dev_id), hr);
WARN("Device %s unavailable: %08lx\n", wine_dbgstr_w(mmdevice->dev_id), hr);
return MMSYSERR_ERROR;
}
hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
if(FAILED(hr)){
WARN("OpenPropertyStore failed: %08x\n", hr);
WARN("OpenPropertyStore failed: %08lx\n", hr);
IMMDevice_Release(device);
return MMSYSERR_ERROR;
}
@ -2356,7 +2356,7 @@ static LRESULT DRV_QueryDeviceInterface(WINMM_QueryInterfaceInfo *info)
PropVariantInit(&pv);
hr = IPropertyStore_GetValue(ps, &deviceinterface_key, &pv);
if(FAILED(hr)){
WARN("GetValue failed: %08x\n", hr);
WARN("GetValue failed: %08lx\n", hr);
IPropertyStore_Release(ps);
IMMDevice_Release(device);
return MMSYSERR_ERROR;
@ -2449,7 +2449,7 @@ static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if(FAILED(hr)){
WARN("CoInitializeEx failed: %08x\n", hr);
WARN("CoInitializeEx failed: %08lx\n", hr);
FreeLibraryAndExitThread(g_devthread_module, 1);
}
@ -2462,7 +2462,7 @@ static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&g_devenum);
if(FAILED(hr)){
WARN("CoCreateInstance failed: %08x\n", hr);
WARN("CoCreateInstance failed: %08lx\n", hr);
CoUninitialize();
FreeLibraryAndExitThread(g_devthread_module, 1);
}
@ -2470,7 +2470,7 @@ static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
g_devices_hwnd = CreateWindowW(L"Message", NULL, 0, 0, 0, 0, 0,
HWND_MESSAGE, NULL, NULL, NULL);
if(!g_devices_hwnd){
WARN("CreateWindow failed: %d\n", GetLastError());
WARN("CreateWindow failed: %ld\n", GetLastError());
CoUninitialize();
FreeLibraryAndExitThread(g_devthread_module, 1);
}
@ -2499,7 +2499,7 @@ static DWORD WINAPI WINMM_DevicesThreadProc(void *arg)
else
WID_PullData(device);
}else
WARN("Unexpected MsgWait result 0x%x, GLE: %d\n", wait,
WARN("Unexpected MsgWait result 0x%lx, GLE: %ld\n", wait,
GetLastError());
if(WINMM_DevicesThreadDone()){
TRACE("Quitting devices thread\n");
@ -2603,7 +2603,7 @@ UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
WAVEOUTCAPSW wocW;
UINT ret;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
if(!lpCaps)
return MMSYSERR_INVALPARAM;
@ -2635,7 +2635,7 @@ UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
WAVEOUTCAPSW mapper_caps, *caps;
HRESULT hr;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -2735,7 +2735,7 @@ MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
WINMM_OpenInfo info;
WINMM_CBInfo cb_info;
TRACE("(%p, %u, %p, %lx, %lx, %08x)\n", lphWaveOut, uDeviceID, lpFormat,
TRACE("(%p, %u, %p, %Ix, %Ix, %08lx)\n", lphWaveOut, uDeviceID, lpFormat,
dwCallback, dwInstance, dwFlags);
if(!lphWaveOut && !(dwFlags & WAVE_FORMAT_QUERY))
@ -2864,7 +2864,7 @@ UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR *header, UINT uSize)
return WAVERR_STILLPLAYING;
}
TRACE("dwBufferLength: %u\n", header->dwBufferLength);
TRACE("dwBufferLength: %lu\n", header->dwBufferLength);
if(device->acm_handle){
ACMSTREAMHEADER *ash = (ACMSTREAMHEADER*)header->reserved;
@ -3015,7 +3015,7 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
*/
UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
{
TRACE("(%p, %08x)\n", hWaveOut, dw);
TRACE("(%p, %08lx)\n", hWaveOut, dw);
return MMSYSERR_NOTSUPPORTED;
}
@ -3035,7 +3035,7 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
*/
UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
{
TRACE("(%p, %08x)\n", hWaveOut, dw);
TRACE("(%p, %08lx)\n", hWaveOut, dw);
return MMSYSERR_NOTSUPPORTED;
}
@ -3063,7 +3063,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, DWORD *out)
hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
WARN("GetChannelCount failed: %08x\n", hr);
WARN("GetChannelCount failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -3077,7 +3077,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, DWORD *out)
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
HeapFree(GetProcessHeap(), 0, vols);
WARN("GetAllVolumes failed: %08x\n", hr);
WARN("GetAllVolumes failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -3102,7 +3102,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
float *vols;
HRESULT hr;
TRACE("(%p, %08x)\n", hWaveOut, in);
TRACE("(%p, %08lx)\n", hWaveOut, in);
device = WINMM_GetDeviceFromHWAVE((HWAVE)hWaveOut);
@ -3112,7 +3112,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
hr = IAudioStreamVolume_GetChannelCount(device->volume, &channels);
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
WARN("GetChannelCount failed: %08x\n", hr);
WARN("GetChannelCount failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -3126,7 +3126,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
HeapFree(GetProcessHeap(), 0, vols);
WARN("GetAllVolumes failed: %08x\n", hr);
WARN("GetAllVolumes failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -3138,7 +3138,7 @@ UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD in)
if(FAILED(hr)){
LeaveCriticalSection(&device->lock);
HeapFree(GetProcessHeap(), 0, vols);
WARN("SetAllVolumes failed: %08x\n", hr);
WARN("SetAllVolumes failed: %08lx\n", hr);
return MMSYSERR_ERROR;
}
@ -3255,7 +3255,7 @@ static UINT get_device_interface(UINT msg, BOOL is_out, UINT index, WCHAR *out,
UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("(%p, %u, %lx, %lx)\n", hWaveOut, uMessage, dwParam1, dwParam2);
TRACE("(%p, %u, %Ix, %Ix)\n", hWaveOut, uMessage, dwParam1, dwParam2);
switch(uMessage){
case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
@ -3317,7 +3317,7 @@ UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSi
WAVEINCAPSW mapper_caps, *caps;
HRESULT hr;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -3364,7 +3364,7 @@ UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSi
UINT ret;
WAVEINCAPSW wicW;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
if(!lpCaps)
return MMSYSERR_INVALPARAM;
@ -3397,7 +3397,7 @@ MMRESULT WINAPI waveInOpen(HWAVEIN* lphWaveIn, UINT uDeviceID,
WINMM_OpenInfo info;
WINMM_CBInfo cb_info;
TRACE("(%p, %x, %p, %lx, %lx, %08x)\n", lphWaveIn, uDeviceID, lpFormat,
TRACE("(%p, %x, %p, %Ix, %Ix, %08lx)\n", lphWaveIn, uDeviceID, lpFormat,
dwCallback, dwInstance, dwFlags);
if(!lphWaveIn && !(dwFlags & WAVE_FORMAT_QUERY))
@ -3661,7 +3661,7 @@ UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
TRACE("(%p, %u, %Id, %Id)\n", hWaveIn, uMessage, dwParam1, dwParam2);
switch(uMessage){
case DRV_QUERYFUNCTIONINSTANCEIDSIZE:
@ -3722,7 +3722,7 @@ UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize
MIXERCAPSW micW;
UINT ret;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
if(!lpCaps)
return MMSYSERR_INVALPARAM;
@ -3752,7 +3752,7 @@ UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize
MIXERCAPSW caps;
HRESULT hr;
TRACE("(%lu, %p, %u)\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u)\n", uDeviceID, lpCaps, uSize);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -3801,7 +3801,7 @@ UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
MMRESULT mr;
HRESULT hr;
TRACE("(%p, %d, %lx, %lx, %x)\n", lphMix, uDeviceID, dwCallback,
TRACE("(%p, %d, %Ix, %Ix, %lx)\n", lphMix, uDeviceID, dwCallback,
dwInstance, fdwOpen);
hr = WINMM_InitMMDevices();
@ -3851,7 +3851,7 @@ UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
WINMM_MMDevice *mmdevice;
HRESULT hr;
TRACE("(%p, %p, %x)\n", hmix, lpid, fdwID);
TRACE("(%p, %p, %lx)\n", hmix, lpid, fdwID);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -3878,7 +3878,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW
{
WINMM_ControlDetails details;
TRACE("(%p, %p, %x)\n", hmix, lpmcdW, fdwDetails);
TRACE("(%p, %p, %lx)\n", hmix, lpmcdW, fdwDetails);
if(!WINMM_StartDevicesThread())
return MMSYSERR_NODRIVER;
@ -3886,7 +3886,7 @@ UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW
if(!lpmcdW || !lpmcdW->paDetails)
return MMSYSERR_INVALPARAM;
TRACE("dwControlID: %u\n", lpmcdW->dwControlID);
TRACE("dwControlID: %lu\n", lpmcdW->dwControlID);
details.hmix = hmix;
details.details = lpmcdW;
@ -3904,7 +3904,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
{
UINT ret = MMSYSERR_NOTSUPPORTED;
TRACE("(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
TRACE("(%p, %p, %08lx)\n", hmix, lpmcdA, fdwDetails);
if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
return MMSYSERR_INVALPARAM;
@ -3949,7 +3949,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
}
break;
default:
WARN("Unsupported fdwDetails=0x%08x\n", fdwDetails);
WARN("Unsupported fdwDetails=0x%08lx\n", fdwDetails);
}
return ret;
@ -3965,7 +3965,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
DWORD ret;
unsigned int i;
TRACE("(%p, %p, %x)\n", hmix, lpmlcA, fdwControls);
TRACE("(%p, %p, %lx)\n", hmix, lpmlcA, fdwControls);
if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA) ||
lpmlcA->cbmxctrl != sizeof(MIXERCONTROLA))
@ -4064,7 +4064,7 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
WINMM_MMDevice *mmdevice;
HRESULT hr;
TRACE("(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
TRACE("(%p, %p, %08lx)\n", hmix, lpmlcW, fdwControls);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -4075,16 +4075,16 @@ UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW,
MIXER_GETLINECONTROLSF_ONEBYTYPE |
MIXER_OBJECTF_HMIXER |
MIXER_OBJECTF_MIXER)){
WARN("Unknown GetLineControls flag: %x\n", fdwControls);
WARN("Unknown GetLineControls flag: %lx\n", fdwControls);
return MMSYSERR_INVALFLAG;
}
if(!lpmlcW || lpmlcW->cbStruct < sizeof(*lpmlcW) || !lpmlcW->pamxctrl)
return MMSYSERR_INVALPARAM;
TRACE("dwLineID: %u\n", lpmlcW->dwLineID);
TRACE("dwControl: %x\n", lpmlcW->u.dwControlID);
TRACE("cControls: %u\n", lpmlcW->cControls);
TRACE("dwLineID: %lu\n", lpmlcW->dwLineID);
TRACE("dwControl: %lx\n", lpmlcW->u.dwControlID);
TRACE("cControls: %lu\n", lpmlcW->cControls);
mmdevice = WINMM_GetMixerMMDevice(hmix, fdwControls, NULL);
if(!mmdevice)
@ -4250,7 +4250,7 @@ static UINT WINMM_GetComponentTypeLineInfo(WINMM_MMDevice *mmdevice,
return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
}
TRACE("Returning INVALLINE on this component type: %u\n",
TRACE("Returning INVALLINE on this component type: %lu\n",
info->dwComponentType);
return MIXERR_INVALLINE;
@ -4269,7 +4269,7 @@ static UINT WINMM_GetLineIDLineInfo(WINMM_MMDevice *mmdevice,
return WINMM_GetSourceLineInfo(mmdevice, mmdev_index, info, flags);
}
TRACE("Returning INVALLINE on this dwLineID: %u\n", info->dwLineID);
TRACE("Returning INVALLINE on this dwLineID: %lu\n", info->dwLineID);
return MIXERR_INVALLINE;
}
@ -4282,7 +4282,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo
WINMM_MMDevice *mmdevice;
HRESULT hr;
TRACE("(%p, %p, %x)\n", hmix, lpmliW, fdwInfo);
TRACE("(%p, %p, %lx)\n", hmix, lpmliW, fdwInfo);
hr = WINMM_InitMMDevices();
if(FAILED(hr))
@ -4291,11 +4291,11 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo
if(!lpmliW || lpmliW->cbStruct < sizeof(MIXERLINEW))
return MMSYSERR_INVALPARAM;
TRACE("dwDestination: %u\n", lpmliW->dwDestination);
TRACE("dwSource: %u\n", lpmliW->dwSource);
TRACE("dwLineID: %u\n", lpmliW->dwLineID);
TRACE("fdwLine: 0x%x\n", lpmliW->fdwLine);
TRACE("dwComponentType: 0x%x\n", lpmliW->dwComponentType);
TRACE("dwDestination: %lu\n", lpmliW->dwDestination);
TRACE("dwSource: %lu\n", lpmliW->dwSource);
TRACE("dwLineID: %lu\n", lpmliW->dwLineID);
TRACE("fdwLine: 0x%lx\n", lpmliW->fdwLine);
TRACE("dwComponentType: 0x%lx\n", lpmliW->dwComponentType);
if(fdwInfo & ~(MIXER_GETLINEINFOF_COMPONENTTYPE |
MIXER_GETLINEINFOF_DESTINATION |
@ -4304,7 +4304,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo
MIXER_GETLINEINFOF_TARGETTYPE |
MIXER_OBJECTF_HMIXER |
MIXER_OBJECTF_MIXER)){
WARN("Unknown GetLineInfo flag: %x\n", fdwInfo);
WARN("Unknown GetLineInfo flag: %lx\n", fdwInfo);
return MMSYSERR_INVALFLAG;
}
@ -4330,7 +4330,7 @@ UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo
return MIXERR_INVALLINE;
}
TRACE("Returning INVALFLAG on these flags: %x\n", fdwInfo);
TRACE("Returning INVALFLAG on these flags: %lx\n", fdwInfo);
return MMSYSERR_INVALFLAG;
}
@ -4343,7 +4343,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
MIXERLINEW mliW;
UINT ret;
TRACE("(%p, %p, %x)\n", hmix, lpmliA, fdwInfo);
TRACE("(%p, %p, %lx)\n", hmix, lpmliA, fdwInfo);
if (lpmliA == NULL || lpmliA->cbStruct != sizeof(*lpmliA))
return MMSYSERR_INVALPARAM;
@ -4371,7 +4371,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA,
MultiByteToWideChar(CP_ACP, 0, lpmliA->Target.szPname, -1, mliW.Target.szPname, ARRAY_SIZE(mliW.Target.szPname));
break;
default:
WARN("Unsupported fdwControls=0x%08x\n", fdwInfo);
WARN("Unsupported fdwControls=0x%08lx\n", fdwInfo);
return MMSYSERR_INVALFLAG;
}
@ -4412,7 +4412,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
WINMM_ControlDetails details;
UINT ret;
TRACE("(%p, %p, %x)\n", hmix, lpmcd, fdwDetails);
TRACE("(%p, %p, %lx)\n", hmix, lpmcd, fdwDetails);
if((fdwDetails & MIXER_SETCONTROLDETAILSF_QUERYMASK) ==
MIXER_SETCONTROLDETAILSF_CUSTOM)
@ -4424,7 +4424,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
if(!WINMM_StartDevicesThread())
return MMSYSERR_NODRIVER;
TRACE("dwControlID: %u\n", lpmcd->dwControlID);
TRACE("dwControlID: %lu\n", lpmcd->dwControlID);
details.hmix = hmix;
details.details = lpmcd;
@ -4441,7 +4441,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd,
*/
DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("(%p, %d, %lx, %lx)\n", hmix, uMsg, dwParam1, dwParam2);
TRACE("(%p, %d, %Ix, %Ix)\n", hmix, uMsg, dwParam1, dwParam2);
return MMSYSERR_NOTSUPPORTED;
}

50
dlls/winmm/winmm.c
View file

@ -136,7 +136,7 @@ const char* WINMM_ErrorToString(MMRESULT error)
*/
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
{
TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
TRACE("%p 0x%lx %p\n", hInstDLL, fdwReason, fImpLoad);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
@ -206,7 +206,7 @@ UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
TRACE("(%04lX, %p, %d) !\n", uDeviceID, lpCaps, uSize);
TRACE("(%04IX, %p, %d) !\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
@ -263,7 +263,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
{
LPWINE_MLD wmld;
TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
TRACE("(%04X, %lu) !\n", uDeviceID, dwVolume);
if ((wmld = MMDRV_Get((HANDLE)(DWORD_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
@ -299,7 +299,7 @@ UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps,
{
LPWINE_MLD wmld;
TRACE("(%lu, %p, %u);\n", uDeviceID, lpCaps, uSize);
TRACE("(%Iu, %p, %u);\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
@ -425,7 +425,7 @@ MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
LPWINE_MIDI lpwm;
MMRESULT dwRet;
TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
TRACE("(%p, %d, %08IX, %08IX, %08lX);\n",
lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiOut != NULL) *lphMidiOut = 0;
@ -513,7 +513,7 @@ UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
{
LPWINE_MLD wmld;
TRACE("(%p, %08X)\n", hMidiOut, dwMsg);
TRACE("(%p, %08lX)\n", hMidiOut, dwMsg);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
@ -574,7 +574,7 @@ UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
{
LPWINE_MLD wmld;
TRACE("(%p, %d);\n", hMidiOut, dwVolume);
TRACE("(%p, %ld);\n", hMidiOut, dwVolume);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
@ -628,7 +628,7 @@ UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
{
LPWINE_MLD wmld;
TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
TRACE("(%p, %04X, %08IX, %08IX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) {
/* HACK... */
@ -666,7 +666,7 @@ UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSi
{
LPWINE_MLD wmld;
TRACE("(%ld, %p, %d);\n", uDeviceID, lpCaps, uSize);
TRACE("(%Id, %p, %d);\n", uDeviceID, lpCaps, uSize);
if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
@ -711,7 +711,7 @@ MMRESULT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
LPWINE_MIDI lpwm;
MMRESULT dwRet;
TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
TRACE("(%p, %d, %08IX, %08IX, %08lX);\n",
lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
if (lphMidiIn != NULL) *lphMidiIn = 0;
@ -881,7 +881,7 @@ UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
{
LPWINE_MLD wmld;
TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
TRACE("(%p, %04X, %08IX, %08IX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
@ -1129,7 +1129,7 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
lpMidiStrm->dwStartTicks = timeGetTime();
lpMidiHdr = (LPMIDIHDR)msg->lParam;
lpData = (LPBYTE)lpMidiHdr->lpData;
TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%u/%u dwFlags=0x%08x size=%lu]\n",
TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%lu/%lu dwFlags=0x%08lx size=%Iu]\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
lpData, lpMidiHdr->dwBytesRecorded, lpMidiHdr->dwBufferLength,
lpMidiHdr->dwFlags, msg->wParam);
@ -1155,7 +1155,7 @@ static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWI
if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
((LPMIDIEVENT)lpData)->dwStreamID != lpMidiStrm->dwStreamID) {
FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
FIXME("Dropping bad %s lpMidiHdr (streamID=%08lx)\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
((LPMIDIEVENT)lpData)->dwStreamID);
lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
@ -1235,7 +1235,7 @@ start_header:
dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->position_usec / 1000;
TRACE("%u/%u/%u\n", dwToGo, timeGetTime(), me->dwDeltaTime);
TRACE("%lu/%lu/%lu\n", dwToGo, timeGetTime(), me->dwDeltaTime);
while (dwToGo - (dwCurrTC = timeGetTime()) <= MAXLONG) {
if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
/* got a message, handle it */
@ -1368,7 +1368,7 @@ MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
LPWINE_MIDI lpwm;
HMIDIOUT hMidiOut;
TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
TRACE("(%p, %p, %ld, 0x%08Ix, 0x%08Ix, 0x%08lx)!\n",
lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
@ -1496,7 +1496,7 @@ static MMRESULT midistream_post_message_and_wait(WINE_MIDIStream* lpMidiStrm, UI
ret = WaitForMultipleObjects(ARRAY_SIZE(hObjects), hObjects, FALSE, INFINITE);
if (ret != WAIT_OBJECT_0) {
CloseHandle(hObjects[0]);
WARN("bad WaitForSingleObject (%u)\n", ret);
WARN("bad WaitForSingleObject (%lu)\n", ret);
return MMSYSERR_ERROR;
}
}
@ -1562,7 +1562,7 @@ MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbm
pulses = midistream_get_current_pulse(lpMidiStrm);
lpMMT->u.midi.songptrpos = (pulses + tdiv/8) / (tdiv/4);
if (!lpMMT->u.midi.songptrpos && pulses) lpMMT->u.midi.songptrpos++;
TRACE("=> song position %d (pulses %u, tdiv %u)\n", lpMMT->u.midi.songptrpos, pulses, tdiv);
TRACE("=> song position %ld (pulses %lu, tdiv %lu)\n", lpMMT->u.midi.songptrpos, pulses, tdiv);
break;
}
/* fall through */
@ -1572,18 +1572,18 @@ MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbm
/* fall through to alternative format */
case TIME_MS:
lpMMT->u.ms = midistream_get_playing_position(lpMidiStrm);
TRACE("=> %d ms\n", lpMMT->u.ms);
TRACE("=> %ld ms\n", lpMMT->u.ms);
break;
case TIME_TICKS:
lpMMT->u.ticks = midistream_get_current_pulse(lpMidiStrm);
TRACE("=> %d ticks\n", lpMMT->u.ticks);
TRACE("=> %ld ticks\n", lpMMT->u.ticks);
break;
default:
FIXME("Unsupported time type %x\n", lpMMT->wType);
/* use TIME_MS instead */
lpMMT->wType = TIME_MS;
lpMMT->u.ms = midistream_get_playing_position(lpMidiStrm);
TRACE("=> %d ms\n", lpMMT->u.ms);
TRACE("=> %ld ms\n", lpMMT->u.ms);
break;
}
LeaveCriticalSection(&lpMidiStrm->lock);
@ -1599,7 +1599,7 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = MMSYSERR_NOERROR;
TRACE("(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty);
TRACE("(%p, %p, %lx)\n", hMidiStrm, lpPropData, dwProperty);
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
ret = MMSYSERR_INVALHANDLE;
@ -1613,10 +1613,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 %d\n", mpt->dwTempo);
TRACE("Setting tempo to %ld\n", mpt->dwTempo);
} else if (dwProperty & MIDIPROP_GET) {
mpt->dwTempo = lpMidiStrm->dwTempo;
TRACE("Getting tempo <= %d\n", mpt->dwTempo);
TRACE("Getting tempo <= %ld\n", mpt->dwTempo);
}
LeaveCriticalSection(&lpMidiStrm->lock);
} else if (dwProperty & MIDIPROP_TIMEDIV) {
@ -1628,14 +1628,14 @@ MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD
EnterCriticalSection(&lpMidiStrm->lock);
if (lpMidiStrm->status != MSM_STATUS_PLAYING) {
lpMidiStrm->dwTimeDiv = mptd->dwTimeDiv;
TRACE("Setting time div to %d\n", mptd->dwTimeDiv);
TRACE("Setting time div to %ld\n", mptd->dwTimeDiv);
}
else
ret = MMSYSERR_INVALPARAM;
LeaveCriticalSection(&lpMidiStrm->lock);
} else if (dwProperty & MIDIPROP_GET) {
mptd->dwTimeDiv = lpMidiStrm->dwTimeDiv;
TRACE("Getting time div <= %d\n", mptd->dwTimeDiv);
TRACE("Getting time div <= %ld\n", mptd->dwTimeDiv);
}
} else {
ret = MMSYSERR_INVALPARAM;