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

Changed error values MCI_INTERNAL to their correct values.

This commit is contained in:
Eric Pouech 1998-12-18 15:13:57 +00:00 committed by Alexandre Julliard
parent 024d194d5a
commit 4d6248baf1
1 changed files with 64 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
multimedia/mmsystem.c
View File

@ -570,12 +570,14 @@ BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
* find out the real mixer ID depending on hmix (depends on dwFlags) * find out the real mixer ID depending on hmix (depends on dwFlags)
* FIXME: also fix dwInstance passing to mixMessage * FIXME: also fix dwInstance passing to mixMessage
*/ */
static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix,DWORD dwFlags) { static UINT32 _get_mixerID_from_handle(HMIXEROBJ32 hmix, DWORD dwFlags)
{
/* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix /* FIXME: Check dwFlags for MIXER_OBJECTF_xxxx entries and modify hmix
* accordingly. For now we always use mixerdevice 0. * accordingly. For now we always use mixerdevice 0.
*/ */
return 0; return 0;
} }
/************************************************************************** /**************************************************************************
* mixerGetNumDevs [WINMM.108] * mixerGetNumDevs [WINMM.108]
*/ */
@ -589,9 +591,8 @@ UINT32 WINAPI mixerGetNumDevs32()
*/ */
UINT16 WINAPI mixerGetNumDevs16() UINT16 WINAPI mixerGetNumDevs16()
{ {
UINT16 count; UINT16 count = mixMessage(0,MXDM_GETNUMDEVS, 0L, 0L, 0L);
count = mixMessage(0,MXDM_GETNUMDEVS,0L,0L,0L);
TRACE(mmaux,"mixerGetNumDevs returns %d\n",count); TRACE(mmaux,"mixerGetNumDevs returns %d\n",count);
return count; return count;
} }
@ -612,6 +613,7 @@ UINT32 WINAPI mixerGetDevCaps32W(UINT32 devid,LPMIXERCAPS32W mixcaps,UINT32 size
mixcaps->cDestinations = mic16.cDestinations; mixcaps->cDestinations = mic16.cDestinations;
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* mixerGetDevCaps [WINMM.101] * mixerGetDevCaps [WINMM.101]
*/ */
@ -899,10 +901,7 @@ UINT16 WINAPI mixerMessage16(HMIXER16 hmix,UINT16 uMsg,DWORD dwParam1,DWORD dwPa
UINT16 uDeviceID; UINT16 uDeviceID;
lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix); lpmod = (LPMIXEROPENDESC)USER_HEAP_LIN_ADDR(hmix);
if (lpmod) uDeviceID = (lpmod) ? lpmod->uDeviceID : 0;
uDeviceID = lpmod->uDeviceID;
else
uDeviceID = 0;
FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n", FIXME(mmsys,"(%04x,%d,%08lx,%08lx) - semi-stub?\n",
hmix,uMsg,dwParam1,dwParam2); hmix,uMsg,dwParam1,dwParam2);
return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2); return mixMessage(uDeviceID,uMsg,0L,dwParam1,dwParam2);
@ -921,10 +920,11 @@ UINT32 WINAPI auxGetNumDevs32()
*/ */
UINT16 WINAPI auxGetNumDevs16() UINT16 WINAPI auxGetNumDevs16()
{ {
UINT16 count = 0; UINT16 count;
TRACE(mmsys, "auxGetNumDevs !\n");
count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L); TRACE(mmsys, "\n");
TRACE(mmsys, "auxGetNumDevs return %u \n", count); count = auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
TRACE(mmsys, "=> %u\n", count);
return count; return count;
} }
@ -967,8 +967,8 @@ UINT32 WINAPI auxGetDevCaps32A(UINT32 uDeviceID,LPAUXCAPS32A lpCaps,UINT32 uSize
*/ */
UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID,LPAUXCAPS16 lpCaps, UINT16 uSize) UINT16 WINAPI auxGetDevCaps16(UINT16 uDeviceID,LPAUXCAPS16 lpCaps, UINT16 uSize)
{ {
TRACE(mmsys, "(%04X, %p, %d) !\n", TRACE(mmsys, "(%04X, %p, %d) !\n", uDeviceID, lpCaps, uSize);
uDeviceID, lpCaps, uSize);
return auxMessage(uDeviceID, AUXDM_GETDEVCAPS, return auxMessage(uDeviceID, AUXDM_GETDEVCAPS,
0L, (DWORD)lpCaps, (DWORD)uSize); 0L, (DWORD)lpCaps, (DWORD)uSize);
} }
@ -987,6 +987,7 @@ UINT32 WINAPI auxGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume) UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, DWORD * lpdwVolume)
{ {
TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume); TRACE(mmsys, "(%04X, %p) !\n", uDeviceID, lpdwVolume);
return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L); return auxMessage(uDeviceID, AUXDM_GETVOLUME, 0L, (DWORD)lpdwVolume, 0L);
} }
@ -1004,6 +1005,7 @@ UINT32 WINAPI auxSetVolume32(UINT32 uDeviceID, DWORD dwVolume)
UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume) UINT16 WINAPI auxSetVolume16(UINT16 uDeviceID, DWORD dwVolume)
{ {
TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume); TRACE(mmsys, "(%04X, %08lX) !\n", uDeviceID, dwVolume);
return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L); return auxMessage(uDeviceID, AUXDM_SETVOLUME, 0L, dwVolume, 0L);
} }
@ -1033,8 +1035,8 @@ DWORD WINAPI auxOutMessage32(UINT32 uDeviceID,UINT32 uMessage,DWORD dw1,DWORD dw
*/ */
DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2) DWORD WINAPI auxOutMessage16(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2)
{ {
TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", TRACE(mmsys, "(%04X, %04X, %08lX, %08lX)\n", uDeviceID, uMessage, dw1, dw2);
uDeviceID, uMessage, dw1, dw2);
switch (uMessage) { switch (uMessage) {
case AUXDM_GETNUMDEVS: case AUXDM_GETNUMDEVS:
case AUXDM_SETVOLUME: case AUXDM_SETVOLUME:
@ -1360,8 +1362,7 @@ BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStat
TRACE(mmsys, "(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus); TRACE(mmsys, "(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
if (!IsWindow32(hWndCallBack)) return FALSE; if (!IsWindow32(hWndCallBack)) return FALSE;
TRACE(mmsys, "before PostMessage\n"); TRACE(mmsys, "before PostMessage\n");
PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus, PostMessage16(hWndCallBack, MM_MCINOTIFY, wStatus, MAKELONG(wDevID, 0));
MAKELONG(wDevID, 0));
return TRUE; return TRUE;
} }
@ -1539,13 +1540,13 @@ const char* MCI_CommandToString(UINT16 wMsg)
*/ */
DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2) DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
{ {
DWORD dwRet = MCIERR_INTERNAL; DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
MCIPROC32 proc = 0;
if (!MCI_DevIDValid(wDevID)) if (!MCI_DevIDValid(wDevID)) {
return MMSYSERR_INVALPARAM; dwRet = MCIERR_INVALID_DEVICE_ID;
} else {
MCIPROC32 proc = MCI_GetProc32(MCI_GetDrv(wDevID)->modp.wType);
proc = MCI_GetProc32(MCI_GetDrv(wDevID)->modp.wType);
if (proc) { if (proc) {
dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID, dwRet = (*proc)(MCI_GetDrv(wDevID)->modp.wDeviceID,
MCI_GetDrv(wDevID)->hDrv, MCI_GetDrv(wDevID)->hDrv,
@ -1559,6 +1560,7 @@ DWORD MCI_SendCommand32(UINT32 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwPara
} else { } else {
WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType); WARN(mmsys, "unknown device type=%04X !\n", MCI_GetDrv(wDevID)->modp.wType);
} }
}
return dwRet; return dwRet;
} }
@ -1573,7 +1575,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
DWORD dwRet; DWORD dwRet;
TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms); TRACE(mmsys, "(%08lX, %p)\n", dwParam, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
if ((dwParam & ~(MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) { if ((dwParam & ~(MCI_OPEN_ELEMENT|MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID|MCI_NOTIFY|MCI_WAIT)) != 0) {
FIXME(mmsys, "unsupported yet dwFlags=%08lX\n", FIXME(mmsys, "unsupported yet dwFlags=%08lX\n",
@ -1584,7 +1586,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
wDevID = MCI_NextDevID(wDevID); wDevID = MCI_NextDevID(wDevID);
if (!MCI_DevIDValid(wDevID)) { if (!MCI_DevIDValid(wDevID)) {
TRACE(mmsys, "MAXMCIDRIVERS reached !\n"); TRACE(mmsys, "MAXMCIDRIVERS reached !\n");
return MCIERR_INTERNAL; return MCIERR_OUT_OF_MEMORY;
} }
} }
@ -1645,7 +1647,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType; MCI_GetOpenDrv(wDevID)->lpstrDeviceType = lpParms->lpstrDeviceType;
} else { } else {
if (lpParms->lpstrDeviceType == NULL) if (lpParms->lpstrDeviceType == NULL)
return MCIERR_INTERNAL; return MCIERR_NULL_PARAMETER_BLOCK;
TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType); TRACE(mmsys, "Dev='%s' !\n", lpParms->lpstrDeviceType);
/* FIXME is there any memory leak here ? */ /* FIXME is there any memory leak here ? */
MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType); MCI_GetOpenDrv(wDevID)->lpstrDeviceType = strdup(lpParms->lpstrDeviceType);
@ -1696,7 +1698,7 @@ static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMS32A lpParms)
*/ */
static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
{ {
DWORD dwRet = MCIERR_INTERNAL; DWORD dwRet;
TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); TRACE(mmsys, "(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
@ -1738,7 +1740,7 @@ DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
*/ */
static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lpParms) static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lpParms)
{ {
DWORD ret = MMSYSERR_INVALPARAM; DWORD ret = MCIERR_INVALID_DEVICE_ID;
if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
@ -1793,9 +1795,9 @@ static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lp
TRACE(mci, "MCI_SYSINFO_NAME\n"); TRACE(mci, "MCI_SYSINFO_NAME\n");
if (dwFlags & MCI_SYSINFO_OPEN) { if (dwFlags & MCI_SYSINFO_OPEN) {
FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n"); FIXME(mci, "Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
ret = MMSYSERR_INVALPARAM; ret = MCIERR_UNRECOGNIZED_COMMAND;
} else if (lpParms->dwNumber > mciInstalledCount) { } else if (lpParms->dwNumber > mciInstalledCount) {
ret = MMSYSERR_INVALPARAM; ret = MCIERR_OUTOFRANGE;
} else { } else {
DWORD count = lpParms->dwNumber; DWORD count = lpParms->dwNumber;
LPSTR ptr = lpmciInstallNames; LPSTR ptr = lpmciInstallNames;
@ -1807,7 +1809,7 @@ static DWORD MCI_SysInfo(UINT32 uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMS32A lp
break; break;
default: default:
TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags); TRACE(mci, "Unsupported flag value=%08lx\n", dwFlags);
ret = MMSYSERR_INVALPARAM; ret = MCIERR_UNRECOGNIZED_COMMAND;
} }
return ret; return ret;
} }
@ -2108,7 +2110,7 @@ DWORD WINAPI mciSendCommand32W(UINT32 wDevID, UINT32 wMsg, DWORD dwParam1, DWORD
DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
DWORD dwParam2) DWORD dwParam2)
{ {
DWORD dwRet = MCIERR_INTERNAL; DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n", TRACE(mmsys, "(%04X, %s, %08lX, %08lX)\n",
wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2); wDevID, MCI_CommandToString(wMsg), dwParam1, dwParam2);
@ -2125,7 +2127,7 @@ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n"); FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
dwRet = MCIERR_CANNOT_USE_ALL; dwRet = MCIERR_CANNOT_USE_ALL;
} else if (!MCI_DevIDValid(wDevID)) { } else if (!MCI_DevIDValid(wDevID)) {
dwRet = MMSYSERR_INVALPARAM; dwRet = MCIERR_INVALID_DEVICE_ID;
} else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) { } else if (MCI_MapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, &dwParam2) >= 0) {
dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2); dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2); MCI_UnMapMsg16To32A(MCI_GetDrv(wDevID)->modp.wType, wMsg, dwParam2);
@ -2142,7 +2144,7 @@ DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1,
FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n"); FIXME(mci, "unhandled MCI_ALL_DEVICE_ID\n");
dwRet = MCIERR_CANNOT_USE_ALL; dwRet = MCIERR_CANNOT_USE_ALL;
} else if (!MCI_DevIDValid(wDevID)) { } else if (!MCI_DevIDValid(wDevID)) {
dwRet = MMSYSERR_INVALPARAM; dwRet = MCIERR_INVALID_DEVICE_ID;
} else { } else {
int res; int res;
@ -2181,10 +2183,12 @@ UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
wDevID = MCI_FirstDevID(); wDevID = MCI_FirstDevID();
while (MCI_DevIDValid(wDevID) && MCI_GetDrv(wDevID)->modp.wType) { while (MCI_DevIDValid(wDevID) && MCI_GetDrv(wDevID)->modp.wType) {
if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType && strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0) if (MCI_GetOpenDrv(wDevID)->lpstrDeviceType &&
strcmp(MCI_GetOpenDrv(wDevID)->lpstrDeviceType, lpstrName) == 0)
return wDevID; return wDevID;
if (MCI_GetOpenDrv(wDevID)->lpstrAlias && strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0) if (MCI_GetOpenDrv(wDevID)->lpstrAlias &&
strcmp(MCI_GetOpenDrv(wDevID)->lpstrAlias, lpstrName) == 0)
return wDevID; return wDevID;
wDevID = MCI_NextDevID(wDevID); wDevID = MCI_NextDevID(wDevID);
@ -2324,6 +2328,7 @@ UINT32 WINAPI midiOutGetNumDevs32(void)
UINT16 WINAPI midiOutGetNumDevs16(void) UINT16 WINAPI midiOutGetNumDevs16(void)
{ {
UINT16 count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L); UINT16 count = modMessage(0, MODM_GETNUMDEVS, 0L, 0L, 0L);
TRACE(mmsys, "returns %u\n", count); TRACE(mmsys, "returns %u\n", count);
return count; return count;
} }
@ -2348,6 +2353,7 @@ UINT32 WINAPI midiOutGetDevCaps32W(UINT32 uDeviceID,LPMIDIOUTCAPS32W lpCaps, UIN
lpCaps->dwSupport = moc16.dwSupport; lpCaps->dwSupport = moc16.dwSupport;
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* midiOutGetDevCapsA [WINMM.75] * midiOutGetDevCapsA [WINMM.75]
*/ */
@ -2669,6 +2675,7 @@ UINT32 WINAPI midiOutGetVolume32(UINT32 uDeviceID, DWORD * lpdwVolume)
{ {
return midiOutGetVolume16(uDeviceID,lpdwVolume); return midiOutGetVolume16(uDeviceID,lpdwVolume);
} }
/************************************************************************** /**************************************************************************
* midiOutGetVolume [MMSYSTEM.211] * midiOutGetVolume [MMSYSTEM.211]
*/ */
@ -2891,7 +2898,7 @@ UINT16 WINAPI midiInGetDevCaps16(UINT16 uDeviceID,
LPMIDIINCAPS16 lpCaps, UINT16 uSize) LPMIDIINCAPS16 lpCaps, UINT16 uSize)
{ {
TRACE(mmsys, "midiInGetDevCaps\n"); TRACE(mmsys, "midiInGetDevCaps\n");
return midMessage(uDeviceID,MIDM_GETDEVCAPS,0,(DWORD)lpCaps,uSize);; return midMessage(uDeviceID,MIDM_GETDEVCAPS, 0, (DWORD)lpCaps, uSize);
} }
/************************************************************************** /**************************************************************************
@ -2905,6 +2912,7 @@ UINT32 WINAPI midiInGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
HeapFree(GetProcessHeap(),0,xstr); HeapFree(GetProcessHeap(),0,xstr);
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* midiInGetErrorText [WINMM.61] * midiInGetErrorText [WINMM.61]
*/ */
@ -3679,7 +3687,6 @@ UINT32 WINAPI waveOutGetErrorText32W(UINT32 uError, LPWSTR lpText, UINT32 uSize)
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveGetErrorText [internal] * waveGetErrorText [internal]
*/ */
@ -3762,6 +3769,7 @@ UINT32 WINAPI waveOutOpen32(HWAVEOUT32 * lphWaveOut, UINT32 uDeviceID,
if (lphWaveOut) *lphWaveOut=hwo16; if (lphWaveOut) *lphWaveOut=hwo16;
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveOutOpen [MMSYSTEM.404] * waveOutOpen [MMSYSTEM.404]
*/ */
@ -3818,6 +3826,7 @@ UINT32 WINAPI waveOutClose32(HWAVEOUT32 hWaveOut)
{ {
return waveOutClose16(hWaveOut); return waveOutClose16(hWaveOut);
} }
/************************************************************************** /**************************************************************************
* waveOutClose [MMSYSTEM.405] * waveOutClose [MMSYSTEM.405]
*/ */
@ -3847,6 +3856,7 @@ UINT32 WINAPI waveOutPrepareHeader32(HWAVEOUT32 hWaveOut,
return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance, return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance,
(DWORD)lpWaveOutHdr,uSize); (DWORD)lpWaveOutHdr,uSize);
} }
/************************************************************************** /**************************************************************************
* waveOutPrepareHeader [MMSYSTEM.406] * waveOutPrepareHeader [MMSYSTEM.406]
*/ */
@ -3883,6 +3893,7 @@ UINT32 WINAPI waveOutUnprepareHeader32(HWAVEOUT32 hWaveOut,
return wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance, return wodMessage(lpDesc->uDeviceID,WODM_UNPREPARE,lpDesc->dwInstance,
(DWORD)lpWaveOutHdr, uSize); (DWORD)lpWaveOutHdr, uSize);
} }
/************************************************************************** /**************************************************************************
* waveOutUnprepareHeader [MMSYSTEM.407] * waveOutUnprepareHeader [MMSYSTEM.407]
*/ */
@ -3919,6 +3930,7 @@ UINT32 WINAPI waveOutWrite32(HWAVEOUT32 hWaveOut, WAVEHDR * lpWaveOutHdr,
lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData; lpWaveOutHdr->reserved = (DWORD)lpWaveOutHdr->lpData;
return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize);
} }
/************************************************************************** /**************************************************************************
* waveOutWrite [MMSYSTEM.408] * waveOutWrite [MMSYSTEM.408]
*/ */
@ -4019,6 +4031,7 @@ UINT32 WINAPI waveOutGetPosition32(HWAVEOUT32 hWaveOut, LPMMTIME32 lpTime,
MMSYSTEM_MMTIME16to32(lpTime,&mmt16); MMSYSTEM_MMTIME16to32(lpTime,&mmt16);
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveOutGetPosition [MMSYSTEM.412] * waveOutGetPosition [MMSYSTEM.412]
*/ */
@ -4041,11 +4054,11 @@ UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16 hWaveOut,LPMMTIME16 lpTime,
UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \ UINT16 WINAPI waveOut##xx##16(HWAVEOUT16 hWaveOut, atype x) \
{ \ { \
LPWAVEOPENDESC lpDesc; \ LPWAVEOPENDESC lpDesc; \
TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", hWaveOut,(DWORD)x);\ TRACE(mmsys, "(%04X, %08lx);\n", hWaveOut, (DWORD)x); \
lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \ lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); \
if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; \
return wodMessage(lpDesc->uDeviceID, WODM_##XX, lpDesc->dwInstance,\ return wodMessage(lpDesc->uDeviceID, WODM_##XX, \
(DWORD)x, 0L); \ lpDesc->dwInstance, (DWORD)x, 0L); \
} }
WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH,DWORD*) WAVEOUT_SHORTCUT_1(GetPitch,GETPITCH,DWORD*)
@ -4060,11 +4073,10 @@ WAVEOUT_SHORTCUT_1(SetPlaybackRate,SETPLAYBACKRATE,DWORD)
} \ } \
UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \ UINT16 WINAPI waveOut##xx##16(UINT16 devid, atype x) \
{ \ { \
TRACE(mmsys, "waveOut"#xx"(%04X, %08lx);\n", devid,(DWORD)x); \ TRACE(mmsys, "(%04X, %08lx);\n", devid, (DWORD)x); \
return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \ return wodMessage(devid, WODM_##XX, 0L, (DWORD)x, 0L); \
} }
WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME,DWORD*) WAVEOUT_SHORTCUT_2(GetVolume,GETVOLUME,DWORD*)
WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME,DWORD) WAVEOUT_SHORTCUT_2(SetVolume,SETVOLUME,DWORD)
@ -4076,6 +4088,7 @@ UINT32 WINAPI waveOutBreakLoop32(HWAVEOUT32 hWaveOut)
{ {
return waveOutBreakLoop16(hWaveOut); return waveOutBreakLoop16(hWaveOut);
} }
/************************************************************************** /**************************************************************************
* waveOutBreakLoop [MMSYSTEM.419] * waveOutBreakLoop [MMSYSTEM.419]
*/ */
@ -4100,6 +4113,7 @@ UINT32 WINAPI waveOutGetID32(HWAVEOUT32 hWaveOut, UINT32 * lpuDeviceID)
*lpuDeviceID = lpDesc->uDeviceID; *lpuDeviceID = lpDesc->uDeviceID;
return 0; return 0;
} }
/************************************************************************** /**************************************************************************
* waveOutGetID [MMSYSTEM.420] * waveOutGetID [MMSYSTEM.420]
*/ */
@ -4244,6 +4258,7 @@ UINT32 WINAPI waveInGetDevCaps32W(UINT32 uDeviceID, LPWAVEINCAPS32W lpCaps, UINT
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveInGetDevCapsA [WINMM.146] * waveInGetDevCapsA [WINMM.146]
*/ */
@ -4260,12 +4275,14 @@ UINT32 WINAPI waveInGetDevCaps32A(UINT32 uDeviceID, LPWAVEINCAPS32A lpCaps, UINT
lpCaps->wChannels = wic16.wChannels; lpCaps->wChannels = wic16.wChannels;
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveInGetDevCaps [MMSYSTEM.502] * waveInGetDevCaps [MMSYSTEM.502]
*/ */
UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize) UINT16 WINAPI waveInGetDevCaps16(UINT16 uDeviceID, LPWAVEINCAPS16 lpCaps, UINT16 uSize)
{ {
TRACE(mmsys, "waveInGetDevCaps\n"); TRACE(mmsys, "waveInGetDevCaps\n");
return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize); return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
} }
@ -4300,7 +4317,6 @@ UINT16 WINAPI waveInGetErrorText16(UINT16 uError, LPSTR lpText, UINT16 uSize)
return(waveGetErrorText(uError, lpText, uSize)); return(waveGetErrorText(uError, lpText, uSize));
} }
/************************************************************************** /**************************************************************************
* waveInOpen [WINMM.154] * waveInOpen [WINMM.154]
*/ */
@ -4368,6 +4384,7 @@ UINT32 WINAPI waveInClose32(HWAVEIN32 hWaveIn)
{ {
return waveInClose16(hWaveIn); return waveInClose16(hWaveIn);
} }
/************************************************************************** /**************************************************************************
* waveInClose [MMSYSTEM.505] * waveInClose [MMSYSTEM.505]
*/ */
@ -4402,6 +4419,7 @@ UINT32 WINAPI waveInPrepareHeader32(HWAVEIN32 hWaveIn,
return widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance, return widMessage(lpDesc->uDeviceID,WIDM_PREPARE,lpDesc->dwInstance,
(DWORD)lpWaveInHdr, uSize); (DWORD)lpWaveInHdr, uSize);
} }
/************************************************************************** /**************************************************************************
* waveInPrepareHeader [MMSYSTEM.506] * waveInPrepareHeader [MMSYSTEM.506]
*/ */
@ -4430,7 +4448,6 @@ UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn,
return ret; return ret;
} }
/************************************************************************** /**************************************************************************
* waveInUnprepareHeader [WINMM.159] * waveInUnprepareHeader [WINMM.159]
*/ */
@ -4450,6 +4467,7 @@ UINT32 WINAPI waveInUnprepareHeader32(HWAVEIN32 hWaveIn,
return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance, return widMessage(lpDesc->uDeviceID,WIDM_UNPREPARE,lpDesc->dwInstance,
(DWORD)lpWaveInHdr, uSize); (DWORD)lpWaveInHdr, uSize);
} }
/************************************************************************** /**************************************************************************
* waveInUnprepareHeader [MMSYSTEM.507] * waveInUnprepareHeader [MMSYSTEM.507]
*/ */
@ -4624,7 +4642,6 @@ UINT32 WINAPI waveInGetID32(HWAVEIN32 hWaveIn, UINT32 * lpuDeviceID)
return 0; return 0;
} }
/************************************************************************** /**************************************************************************
* waveInGetID [MMSYSTEM.513] * waveInGetID [MMSYSTEM.513]
*/ */
@ -4731,7 +4748,6 @@ HDRVR16 WINAPI DrvOpen(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
return OpenDriver16(lpDriverName, lpSectionName, lParam); return OpenDriver16(lpDriverName, lpSectionName, lParam);
} }
/************************************************************************** /**************************************************************************
* DrvClose [MMSYSTEM.1101] * DrvClose [MMSYSTEM.1101]
*/ */
@ -4742,7 +4758,6 @@ LRESULT WINAPI DrvClose(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
return CloseDriver16(hDrvr, lParam1, lParam2); return CloseDriver16(hDrvr, lParam1, lParam2);
} }
/************************************************************************** /**************************************************************************
* DrvSendMessage [MMSYSTEM.1102] * DrvSendMessage [MMSYSTEM.1102]
*/ */
@ -4808,7 +4823,8 @@ LRESULT WINAPI mmThreadCreate16(LPVOID x1, LPWORD x2, DWORD x3, DWORD x4)
/************************************************************************** /**************************************************************************
* mmThreadGetTask [MMSYSTEM.1125] * mmThreadGetTask [MMSYSTEM.1125]
*/ */
LRESULT WINAPI mmThreadGetTask16(WORD hnd) { LRESULT WINAPI mmThreadGetTask16(WORD hnd)
{
FIXME(mmsys,"(%04x): stub!\n",hnd); FIXME(mmsys,"(%04x): stub!\n",hnd);
return GetCurrentTask(); return GetCurrentTask();
} }
@ -4882,5 +4898,3 @@ LRESULT WINAPI mmTaskSignal16(HTASK16 ht)
TRACE(mmsys,"(%04x);\n",ht); TRACE(mmsys,"(%04x);\n",ht);
return PostAppMessage16(ht,WM_USER,0,0); return PostAppMessage16(ht,WM_USER,0,0);
} }