marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix many function prototypes and data types according to Platform SDK 

definitions.
oldstable
Dmitry Timoshkov 2003-12-31 23:49:45 +00:00 committed by Alexandre Julliard
parent be6d014f35
commit 9741589bdf
8 changed files with 189 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dlls/winmm/joystick.c
View File

@ -139,7 +139,7 @@ UINT WINAPI joyGetNumDevs(void)
/**************************************************************************
* joyGetDevCapsA [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
MMRESULT WINAPI joyGetDevCapsA(UINT_PTR wID, LPJOYCAPSA lpCaps, UINT wSize)
{
if (wID >= MAXJOYSTICK) return JOYERR_PARMS;
if (!JOY_LoadDriver(wID)) return MMSYSERR_NODRIVER;
@ -153,7 +153,7 @@ MMRESULT WINAPI joyGetDevCapsA(UINT wID, LPJOYCAPSA lpCaps, UINT wSize)
/**************************************************************************
* joyGetDevCapsW [WINMM.@]
*/
MMRESULT WINAPI joyGetDevCapsW(UINT wID, LPJOYCAPSW lpCaps, UINT wSize)
MMRESULT WINAPI joyGetDevCapsW(UINT_PTR wID, LPJOYCAPSW lpCaps, UINT wSize)
{
JOYCAPSA jca;
MMRESULT ret = joyGetDevCapsA(wID, &jca, sizeof(jca));

4
dlls/winmm/lolvldrv.c
View File

@ -171,8 +171,8 @@ UINT MMDRV_GetNum(UINT type)
/**************************************************************************
* MMDRV_Message [internal]
*/
DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1,
DWORD dwParam2, BOOL bFrom32)
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
DWORD_PTR dwParam2, BOOL bFrom32)
{
LPWINE_MM_DRIVER lpDrv;
DWORD ret;

24
dlls/winmm/mmsystem.c
View File

@ -489,7 +489,7 @@ UINT16 WINAPI auxGetVolume16(UINT16 uDeviceID, LPDWORD lpdwVolume)
if ((wmld = MMDRV_Get((HANDLE)(ULONG_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
}
/**************************************************************************
@ -796,7 +796,7 @@ UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16 hMidiOut, /* [in] */
if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD)lpsegMidiOutHdr, uSize, FALSE);
return MMDRV_Message(wmld, MODM_UNPREPARE, lpsegMidiOutHdr, uSize, FALSE);
}
/**************************************************************************
@ -821,7 +821,7 @@ UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16 hMidiOut, /* [in] */
if ((wmld = MMDRV_Get(HMIDIOUT_32(hMidiOut), MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD)lpsegMidiOutHdr, uSize, FALSE);
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpsegMidiOutHdr, uSize, FALSE);
}
/**************************************************************************
@ -993,7 +993,7 @@ UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD)lpsegMidiInHdr, uSize, FALSE);
return MMDRV_Message(wmld, MIDM_PREPARE, lpsegMidiInHdr, uSize, FALSE);
}
/**************************************************************************
@ -1015,7 +1015,7 @@ UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16 hMidiIn, /* [in] */
if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD)lpsegMidiInHdr, uSize, FALSE);
return MMDRV_Message(wmld, MIDM_UNPREPARE, lpsegMidiInHdr, uSize, FALSE);
}
/**************************************************************************
@ -1032,7 +1032,7 @@ UINT16 WINAPI midiInAddBuffer16(HMIDIIN16 hMidiIn, /* [in] */
if ((wmld = MMDRV_Get(HMIDIIN_32(hMidiIn), MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD)lpsegMidiInHdr, uSize, FALSE);
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpsegMidiInHdr, uSize, FALSE);
}
/**************************************************************************
@ -1297,7 +1297,7 @@ UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_PREPARE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
return MMDRV_Message(wmld, WODM_PREPARE, lpsegWaveOutHdr, uSize, FALSE);
}
/**************************************************************************
@ -1319,7 +1319,7 @@ UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16 hWaveOut, /* [in] */
if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
return MMDRV_Message(wmld, WODM_UNPREPARE, lpsegWaveOutHdr, uSize, FALSE);
}
/**************************************************************************
@ -1336,7 +1336,7 @@ UINT16 WINAPI waveOutWrite16(HWAVEOUT16 hWaveOut, /* [in] */
if ((wmld = MMDRV_Get(HWAVEOUT_32(hWaveOut), MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_WRITE, (DWORD)lpsegWaveOutHdr, uSize, FALSE);
return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpsegWaveOutHdr, uSize, FALSE);
}
/**************************************************************************
@ -1598,7 +1598,7 @@ UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
lpWaveInHdr->dwBytesRecorded = 0;
ret = MMDRV_Message(wmld, WIDM_PREPARE, (DWORD)lpsegWaveInHdr, uSize, FALSE);
ret = MMDRV_Message(wmld, WIDM_PREPARE, lpsegWaveInHdr, uSize, FALSE);
return ret;
}
@ -1623,7 +1623,7 @@ UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16 hWaveIn, /* [in] */
if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD)lpsegWaveInHdr, uSize, FALSE);
return MMDRV_Message(wmld, WIDM_UNPREPARE, lpsegWaveInHdr, uSize, FALSE);
}
/**************************************************************************
@ -1641,7 +1641,7 @@ UINT16 WINAPI waveInAddBuffer16(HWAVEIN16 hWaveIn, /* [in] */
if ((wmld = MMDRV_Get(HWAVEIN_32(hWaveIn), MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD)lpsegWaveInHdr, uSize, FALSE);
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpsegWaveInHdr, uSize, FALSE);
}
/**************************************************************************

2
dlls/winmm/time.c
View File

@ -271,7 +271,7 @@ WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
* timeSetEvent [WINMM.@]
*/
MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
DWORD dwUser, UINT wFlags)
DWORD_PTR dwUser, UINT wFlags)
{
if (wFlags & WINE_TIMER_IS32)
WARN("Unknown windows flag... wine internally used.. ooch\n");

2
dlls/winmm/winemm.h
View File

@ -242,7 +242,7 @@ DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD dwParam1, DWORD dwParam2);
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg);
LPWINE_MLD MMDRV_Get(HANDLE hndl, UINT type, BOOL bCanBeID);
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstTyped);
DWORD MMDRV_Message(LPWINE_MLD mld, WORD wMsg, DWORD dwParam1, DWORD dwParam2, BOOL bFrom32);
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2, BOOL bFrom32);
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD dwParam1, DWORD dwParam2);
BOOL MMDRV_Is32(unsigned int);
void MMDRV_InstallMap(unsigned int, MMDRV_MAPFUNC, MMDRV_UNMAPFUNC,

117
dlls/winmm/winmm.c
View File

@ -232,7 +232,7 @@ UINT WINAPI mixerGetNumDevs(void)
/**************************************************************************
* mixerGetDevCapsA [WINMM.@]
*/
UINT WINAPI mixerGetDevCapsA(UINT uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -241,13 +241,13 @@ UINT WINAPI mixerGetDevCapsA(UINT uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
* mixerGetDevCapsW [WINMM.@]
*/
UINT WINAPI mixerGetDevCapsW(UINT uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
{
MIXERCAPSA micA;
UINT ret = mixerGetDevCapsA(uDeviceID, &micA, sizeof(micA));
@ -266,8 +266,8 @@ UINT WINAPI mixerGetDevCapsW(UINT uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
return ret;
}
UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen, BOOL bFrom32)
UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
{
HANDLE hMix;
LPWINE_MLD wmld;
@ -300,8 +300,8 @@ UINT MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
/**************************************************************************
* mixerOpen [WINMM.@]
*/
UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen)
UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD fdwOpen)
{
return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE);
}
@ -359,7 +359,7 @@ UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA
if (lpmcdA == NULL || lpmcdA->cbStruct != sizeof(*lpmcdA))
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD)lpmcdA,
return MMDRV_Message(&lpwm->mld, MXDM_GETCONTROLDETAILS, (DWORD_PTR)lpmcdA,
fdwDetails, TRUE);
}
@ -437,7 +437,7 @@ UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA,
if (lpmlcA == NULL || lpmlcA->cbStruct != sizeof(*lpmlcA))
return MMSYSERR_INVALPARAM;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD)lpmlcA,
return MMDRV_Message(&lpwm->mld, MXDM_GETLINECONTROLS, (DWORD_PTR)lpmlcA,
fdwControls, TRUE);
}
@ -514,7 +514,7 @@ UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliW, DWORD fdwInfo
if ((lpwm = MIXER_GetDev(hmix, fdwInfo)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD)lpmliW,
return MMDRV_Message(&lpwm->mld, MXDM_GETLINEINFO, (DWORD_PTR)lpmliW,
fdwInfo, TRUE);
}
@ -597,14 +597,14 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA,
if ((lpwm = MIXER_GetDev(hmix, fdwDetails)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD)lpmcdA,
return MMDRV_Message(&lpwm->mld, MXDM_SETCONTROLDETAILS, (DWORD_PTR)lpmcdA,
fdwDetails, TRUE);
}
/**************************************************************************
* mixerMessage [WINMM.@]
*/
UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD dwParam1, DWORD dwParam2)
UINT WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -628,7 +628,7 @@ UINT WINAPI auxGetNumDevs(void)
/**************************************************************************
* auxGetDevCapsW [WINMM.@]
*/
UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
{
AUXCAPSA acA;
UINT ret = auxGetDevCapsA(uDeviceID, &acA, sizeof(acA));
@ -650,7 +650,7 @@ UINT WINAPI auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
/**************************************************************************
* auxGetDevCapsA [WINMM.@]
*/
UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
UINT WINAPI auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -660,7 +660,7 @@ UINT WINAPI auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, AUXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -674,7 +674,7 @@ UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
return MMDRV_Message(wmld, AUXDM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
}
/**************************************************************************
@ -694,7 +694,7 @@ UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
/**************************************************************************
* auxOutMessage [WINMM.@]
*/
UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD dw1, DWORD dw2)
UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PTR dw2)
{
LPWINE_MLD wmld;
@ -739,7 +739,6 @@ BOOL WINAPI mciGetErrorStringA(MCIERROR dwError, LPSTR lpstrBuffer, UINT uLength
*/
BOOL WINAPI mciDriverNotify(HWND hWndCallBack, MCIDEVICEID wDevID, UINT wStatus)
{
TRACE("(%p, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
return PostMessageW(hWndCallBack, MM_MCINOTIFY, wStatus, wDevID);
@ -1136,7 +1135,7 @@ UINT WINAPI midiOutGetNumDevs(void)
/**************************************************************************
* midiOutGetDevCapsW [WINMM.@]
*/
UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps,
UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps,
UINT uSize)
{
MIDIOUTCAPSA mocA;
@ -1162,7 +1161,7 @@ UINT WINAPI midiOutGetDevCapsW(UINT uDeviceID, LPMIDIOUTCAPSW lpCaps,
/**************************************************************************
* midiOutGetDevCapsA [WINMM.@]
*/
UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps,
UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps,
UINT uSize)
{
LPWINE_MLD wmld;
@ -1174,7 +1173,7 @@ UINT WINAPI midiOutGetDevCapsA(UINT uDeviceID, LPMIDIOUTCAPSA lpCaps,
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -1255,8 +1254,8 @@ static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT* lphMidiOut, LPDWORD lpdwCallback,
return lpwm;
}
UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags, BOOL bFrom32)
UINT MIDI_OutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags, BOOL bFrom32)
{
HMIDIOUT hMidiOut;
LPWINE_MIDI lpwm;
@ -1291,8 +1290,8 @@ UINT MIDI_OutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID, DWORD dwCallback,
/**************************************************************************
* midiOutOpen [WINMM.@]
*/
UINT WINAPI midiOutOpen(HMIDIOUT* lphMidiOut, UINT uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
{
return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
}
@ -1329,7 +1328,7 @@ UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_PREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1349,7 +1348,7 @@ UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1380,7 +1379,7 @@ UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD)lpMidiOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -1410,7 +1409,7 @@ UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD* lpdwVolume)
if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD)lpdwVolume, 0L, TRUE);
return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L, TRUE);
}
/**************************************************************************
@ -1470,7 +1469,7 @@ UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
* midiOutMessage [WINMM.@]
*/
UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -1508,7 +1507,7 @@ UINT WINAPI midiInGetNumDevs(void)
/**************************************************************************
* midiInGetDevCapsW [WINMM.@]
*/
UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
{
MIDIINCAPSA micA;
UINT ret = midiInGetDevCapsA(uDeviceID, &micA, uSize);
@ -1529,7 +1528,7 @@ UINT WINAPI midiInGetDevCapsW(UINT uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
/**************************************************************************
* midiInGetDevCapsA [WINMM.@]
*/
UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -1540,7 +1539,7 @@ UINT WINAPI midiInGetDevCapsA(UINT uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -1639,7 +1638,7 @@ UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1659,7 +1658,7 @@ UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1675,7 +1674,7 @@ UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD)lpMidiInHdr, uSize, TRUE);
return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize, TRUE);
}
/**************************************************************************
@ -1746,7 +1745,7 @@ UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
* midiInMessage [WINMM.@]
*/
UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -2436,7 +2435,7 @@ UINT WINAPI waveOutGetNumDevs(void)
/**************************************************************************
* waveOutGetDevCapsA [WINMM.@]
*/
UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps,
UINT uSize)
{
LPWINE_MLD wmld;
@ -2448,14 +2447,14 @@ UINT WINAPI waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, WODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
* waveOutGetDevCapsW [WINMM.@]
*/
UINT WINAPI waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW lpCaps,
UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps,
UINT uSize)
{
WAVEOUTCAPSA wocA;
@ -2526,9 +2525,9 @@ UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
* waveOutOpen [WINMM.@]
* All the args/structs have the same layout as the win16 equivalents
*/
UINT WINAPI waveOutOpen(HWAVEOUT* lphWaveOut, UINT uDeviceID,
const LPWAVEFORMATEX lpFormat, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags)
UINT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
const LPWAVEFORMATEX lpFormat, DWORD_PTR dwCallback,
DWORD_PTR dwInstance, DWORD dwFlags)
{
return WAVE_Open((HANDLE*)lphWaveOut, uDeviceID, MMDRV_WAVEOUT, lpFormat,
dwCallback, dwInstance, dwFlags, TRUE);
@ -2569,7 +2568,7 @@ UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_PREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_PREPARE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2589,7 +2588,7 @@ UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_UNPREPARE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2605,7 +2604,7 @@ UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_WRITE, (DWORD)lpWaveOutHdr, uSize, TRUE);
return MMDRV_Message(wmld, WODM_WRITE, (DWORD_PTR)lpWaveOutHdr, uSize, TRUE);
}
/**************************************************************************
@ -2677,7 +2676,7 @@ UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime,
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPOS, (DWORD)lpTime, uSize, TRUE);
return MMDRV_Message(wmld, WODM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
}
/**************************************************************************
@ -2691,7 +2690,7 @@ UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETPITCH, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2719,7 +2718,7 @@ UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETPLAYBACKRATE, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2748,7 +2747,7 @@ UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw)
if ((wmld = MMDRV_Get(hWaveOut, MMDRV_WAVEOUT, TRUE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD)lpdw, 0L, TRUE);
return MMDRV_Message(wmld, WODM_GETVOLUME, (DWORD_PTR)lpdw, 0L, TRUE);
}
/**************************************************************************
@ -2788,7 +2787,7 @@ UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT* lpuDeviceID)
* waveOutMessage [WINMM.@]
*/
UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;
@ -2819,7 +2818,7 @@ UINT WINAPI waveInGetNumDevs(void)
/**************************************************************************
* waveInGetDevCapsW [WINMM.@]
*/
UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
{
WAVEINCAPSA wicA;
UINT ret = waveInGetDevCapsA(uDeviceID, &wicA, uSize);
@ -2841,7 +2840,7 @@ UINT WINAPI waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
/**************************************************************************
* waveInGetDevCapsA [WINMM.@]
*/
UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
{
LPWINE_MLD wmld;
@ -2852,7 +2851,7 @@ UINT WINAPI waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_WAVEIN, TRUE)) == NULL)
return MMSYSERR_BADDEVICEID;
return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD)lpCaps, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
}
/**************************************************************************
@ -2922,7 +2921,7 @@ UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
lpWaveInHdr->dwBytesRecorded = 0;
return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_PREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -2943,7 +2942,7 @@ UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR* lpWaveInHdr,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_UNPREPARE, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -2960,7 +2959,7 @@ UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD)lpWaveInHdr, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_ADDBUFFER, (DWORD_PTR)lpWaveInHdr, uSize, TRUE);
}
/**************************************************************************
@ -3021,7 +3020,7 @@ UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime,
if ((wmld = MMDRV_Get(hWaveIn, MMDRV_WAVEIN, FALSE)) == NULL)
return MMSYSERR_INVALHANDLE;
return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD)lpTime, uSize, TRUE);
return MMDRV_Message(wmld, WIDM_GETPOS, (DWORD_PTR)lpTime, uSize, TRUE);
}
/**************************************************************************
@ -3046,7 +3045,7 @@ UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT* lpuDeviceID)
* waveInMessage [WINMM.@]
*/
UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage,
DWORD dwParam1, DWORD dwParam2)
DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD wmld;

76
include/digitalv.h
View File

@ -459,20 +459,20 @@ extern "C" {
/* parameter block for MCI_WHERE, MCI_PUT, MCI_FREEZE, MCI_UNFREEZE cmds */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
RECT rc;
} MCI_DGV_RECT_PARMS, *LPMCI_DGV_RECT_PARMS;
/* parameter block for MCI_CAPTURE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrFileName;
RECT rc;
} MCI_DGV_CAPTURE_PARMSA, *LPMCI_DGV_CAPTURE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrFileName;
RECT rc;
} MCI_DGV_CAPTURE_PARMSW, *LPMCI_DGV_CAPTURE_PARMSW;
@ -487,7 +487,7 @@ typedef MCI_GENERIC_PARMS MCI_CLOSE_PARMS, *LPMCI_CLOSE_PARMS;
/* parameter block for MCI_COPY command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
RECT rc;
@ -498,14 +498,14 @@ typedef struct {
/* parameter block for MCI_CUE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTo;
} MCI_DGV_CUE_PARMS, *LPMCI_DGV_CUE_PARMS;
/* parameter block for MCI_CUT command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
RECT rc;
@ -516,7 +516,7 @@ typedef struct {
/* parameter block for MCI_DELETE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
RECT rc;
@ -531,14 +531,14 @@ typedef MCI_DGV_RECT_PARMS MCI_DGV_FREEZE_PARMS, * LPMCI_DGV_FREEZE_PARMS;
/* parameter block for MCI_INFO command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwItem;
} MCI_DGV_INFO_PARMSA, * LPMCI_DGV_INFO_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwItem;
@ -550,7 +550,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_INFO_PARMS)
/* parameter block for MCI_LIST command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwLength;
DWORD dwNumber;
@ -559,7 +559,7 @@ typedef struct {
} MCI_DGV_LIST_PARMSA, *LPMCI_DGV_LIST_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrReturn;
DWORD dwLength;
DWORD dwNumber;
@ -581,7 +581,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_LOAD_PARMS)
/* parameter block for MCI_MONITOR command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwSource;
DWORD dwMethod;
} MCI_DGV_MONITOR_PARMS, * LPMCI_DGV_MONITOR_PARMS;
@ -589,7 +589,7 @@ typedef struct {
/* parameter block for MCI_OPEN command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
UINT wDeviceID;
LPSTR lpstrDeviceType;
LPSTR lpstrElementName;
@ -599,7 +599,7 @@ typedef struct {
} MCI_DGV_OPEN_PARMSA, *LPMCI_DGV_OPEN_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
UINT wDeviceID;
LPWSTR lpstrDeviceType;
LPWSTR lpstrElementName;
@ -618,7 +618,7 @@ typedef MCI_GENERIC_PARMS MCI_DGV_PAUSE_PARMS, * LPMCI_DGV_PAUSE_PARMS;
/* parameter block for MCI_PASTE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTo;
RECT rc;
DWORD dwAudioStream;
@ -636,7 +636,7 @@ typedef MCI_DGV_RECT_PARMS MCI_DGV_PUT_PARMS, * LPMCI_DGV_PUT_PARMS;
/* parameter block for MCI_QUALITY command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
LPSTR lpstrName;
DWORD lpstrAlgorithm;
@ -644,7 +644,7 @@ typedef struct {
} MCI_DGV_QUALITY_PARMSA, *LPMCI_DGV_QUALITY_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
LPWSTR lpstrName;
DWORD lpstrAlgorithm;
@ -661,7 +661,7 @@ typedef MCI_GENERIC_PARMS MCI_REALIZE_PARMS, * LPMCI_REALIZE_PARMS;
/* parameter block for MCI_RECORD command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
RECT rc;
@ -672,13 +672,13 @@ typedef struct {
/* parameter block for MCI_RESERVE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrPath;
DWORD dwSize;
} MCI_DGV_RESERVE_PARMSA, *LPMCI_DGV_RESERVE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrPath;
DWORD dwSize;
} MCI_DGV_RESERVE_PARMSW, *LPMCI_DGV_RESERVE_PARMSW;
@ -689,13 +689,13 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_RESERVE_PARMS)
/* parameter block for MCI_RESTORE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrFileName;
RECT rc;
} MCI_DGV_RESTORE_PARMSA, *LPMCI_DGV_RESTORE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrFileName;
RECT rc;
} MCI_DGV_RESTORE_PARMSW, *LPMCI_DGV_RESTORE_PARMSW;
@ -710,13 +710,13 @@ typedef MCI_GENERIC_PARMS MCI_DGV_RESUME_PARMS, * LPMCI_DGV_RESUME_PARMS;
/* parameter block for MCI_SAVE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrFileName;
RECT rc;
} MCI_DGV_SAVE_PARMSA, *LPMCI_DGV_SAVE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrFileName;
RECT rc;
} MCI_DGV_SAVE_PARMSW, *LPMCI_DGV_SAVE_PARMSW;
@ -727,7 +727,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_SAVE_PARMS)
/* parameter block for MCI_SET command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
DWORD dwFileFormat;
@ -737,7 +737,7 @@ typedef struct {
/* parameter block for MCI_SETAUDIO command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
DWORD dwValue;
DWORD dwOver;
@ -746,7 +746,7 @@ typedef struct {
} MCI_DGV_SETAUDIO_PARMSA, *LPMCI_DGV_SETAUDIO_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
DWORD dwValue;
DWORD dwOver;
@ -760,7 +760,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_SETAUDIO_PARMS)
/* parameter block for MCI_SIGNAL command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwPosition;
DWORD dwPeriod;
DWORD dwUserParm;
@ -769,7 +769,7 @@ typedef struct {
/* parameter block for MCI_SETVIDEO command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
DWORD dwValue;
DWORD dwOver;
@ -779,7 +779,7 @@ typedef struct {
} MCI_DGV_SETVIDEO_PARMSA, *LPMCI_DGV_SETVIDEO_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwItem;
DWORD dwValue;
DWORD dwOver;
@ -794,8 +794,8 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_SETVIDEO_PARMS)
/* parameter block for MCI_STATUS command message */
typedef struct {
DWORD dwCallback;
DWORD dwReturn;
DWORD_PTR dwCallback;
DWORD_PTR dwReturn;
DWORD dwItem;
DWORD dwTrack;
LPSTR lpstrDrive;
@ -803,8 +803,8 @@ typedef struct {
} MCI_DGV_STATUS_PARMSA, *LPMCI_DGV_STATUS_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD dwReturn;
DWORD_PTR dwCallback;
DWORD_PTR dwReturn;
DWORD dwItem;
DWORD dwTrack;
LPWSTR lpstrDrive;
@ -817,7 +817,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_DGV_STATUS_PARMS)
/* parameter block for MCI_STEP command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_DGV_STEP_PARMS, *LPMCI_DGV_STEP_PARMS;
@ -832,7 +832,7 @@ typedef MCI_DGV_RECT_PARMS MCI_DGV_UNFREEZE_PARMS, * LPMCI_DGV_UNFREEZE_PARMS;
/* parameter block for MCI_UPDATE command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
RECT rc;
HDC hDC;
} MCI_DGV_UPDATE_PARMS, * LPMCI_DGV_UPDATE_PARMS;
@ -844,14 +844,14 @@ typedef MCI_DGV_RECT_PARMS MCI_DGV_WHERE_PARMS, * LPMCI_DGV_WHERE_PARMS;
/* parameter block for MCI_WINDOW command message */
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPSTR lpstrText;
} MCI_DGV_WINDOW_PARMSA, *LPMCI_DGV_WINDOW_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPWSTR lpstrText;

152
include/mmsystem.h
View File

@ -52,7 +52,7 @@ typedef HWAVEOUT *LPHWAVEOUT;
#include <pshpack1.h>
typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
#define MAXWAVEDRIVERS 10
#define MAXMIDIDRIVERS 10
@ -214,8 +214,7 @@ typedef struct {
} DRVCONFIGINFO, *LPDRVCONFIGINFO;
LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hdrvr,
UINT Msg, LPARAM lParam1, LPARAM lParam2);
LRESULT WINAPI DefDriverProc(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
/* this sounds odd, but it's the way it is. OpenDriverA even disapeared
* from latest SDK
*/
@ -230,7 +229,7 @@ HMODULE WINAPI GetDriverModuleHandle(HDRVR hDriver);
DWORD WINAPI GetDriverFlags(HDRVR hDriver);
typedef void (CALLBACK *LPDRVCALLBACK) (HDRVR h, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPDRVCALLBACK)(HDRVR,UINT,DWORD_PTR,DWORD_PTR,DWORD_PTR);
#define MM_MICROSOFT 1 /* Microsoft Corp. */
@ -423,15 +422,15 @@ typedef struct {
#endif
UINT WINAPI waveOutGetNumDevs(void);
UINT WINAPI waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT);
UINT WINAPI waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT);
UINT WINAPI waveOutGetDevCapsA(UINT_PTR,LPWAVEOUTCAPSA,UINT);
UINT WINAPI waveOutGetDevCapsW(UINT_PTR,LPWAVEOUTCAPSW,UINT);
#define waveOutGetDevCaps WINELIB_NAME_AW(waveOutGetDevCaps)
UINT WINAPI waveOutGetVolume(HWAVEOUT,DWORD*);
UINT WINAPI waveOutSetVolume(HWAVEOUT,DWORD);
UINT WINAPI waveOutGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI waveOutGetErrorTextW(UINT,LPWSTR,UINT);
#define waveOutGetErrorText WINELIB_NAME_AW(waveOutGetErrorText)
UINT WINAPI waveOutOpen(HWAVEOUT*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
UINT WINAPI waveOutOpen(HWAVEOUT*,UINT,const LPWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI waveOutClose(HWAVEOUT);
UINT WINAPI waveOutPrepareHeader(HWAVEOUT,WAVEHDR*,UINT);
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT,WAVEHDR*,UINT);
@ -446,15 +445,15 @@ UINT WINAPI waveOutSetPitch(HWAVEOUT,DWORD);
UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT,DWORD*);
UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
UINT WINAPI waveOutGetID(HWAVEOUT,UINT*);
UINT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
UINT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI waveInGetNumDevs(void);
UINT WINAPI waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT);
UINT WINAPI waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT);
UINT WINAPI waveInGetDevCapsA(UINT_PTR,LPWAVEINCAPSA,UINT);
UINT WINAPI waveInGetDevCapsW(UINT_PTR,LPWAVEINCAPSW,UINT);
#define waveInGetDevCaps WINELIB_NAME_AW(waveInGetDevCaps)
UINT WINAPI waveInGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI waveInGetErrorTextW(UINT,LPWSTR,UINT);
#define waveInGetErrorText WINELIB_NAME_AW(waveInGetErrorText)
UINT WINAPI waveInOpen(HWAVEIN*,UINT,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
UINT WINAPI waveInOpen(HWAVEIN*,UINT,const LPWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI waveInClose(HWAVEIN);
UINT WINAPI waveInPrepareHeader(HWAVEIN,WAVEHDR*,UINT);
UINT WINAPI waveInUnprepareHeader(HWAVEIN,WAVEHDR*,UINT);
@ -464,7 +463,7 @@ UINT WINAPI waveInStop(HWAVEIN);
UINT WINAPI waveInReset(HWAVEIN);
UINT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
UINT WINAPI waveInGetID(HWAVEIN,UINT*);
UINT WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
UINT WINAPI waveInMessage(HWAVEIN,UINT,DWORD_PTR,DWORD_PTR);
#define MIDIERR_UNPREPARED (MIDIERR_BASE + 0) /* header not prepared */
#define MIDIERR_STILLPLAYING (MIDIERR_BASE + 1) /* still something playing */
@ -625,15 +624,15 @@ typedef struct {
#define MEVT_VERSION ((BYTE)0x84)
UINT WINAPI midiOutGetNumDevs(void);
UINT WINAPI midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT);
UINT WINAPI midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT);
UINT WINAPI midiOutGetDevCapsA(UINT_PTR,LPMIDIOUTCAPSA,UINT);
UINT WINAPI midiOutGetDevCapsW(UINT_PTR,LPMIDIOUTCAPSW,UINT);
#define midiOutGetDevCaps WINELIB_NAME_AW(midiOutGetDevCaps)
UINT WINAPI midiOutGetVolume(HMIDIOUT,DWORD*);
UINT WINAPI midiOutSetVolume(HMIDIOUT,DWORD);
UINT WINAPI midiOutGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI midiOutGetErrorTextW(UINT,LPWSTR,UINT);
#define midiOutGetErrorText WINELIB_NAME_AW(midiOutGetErrorText)
UINT WINAPI midiOutOpen(HMIDIOUT*,UINT,DWORD,DWORD,DWORD);
UINT WINAPI midiOutOpen(LPHMIDIOUT,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI midiOutClose(HMIDIOUT);
UINT WINAPI midiOutPrepareHeader(HMIDIOUT,MIDIHDR*,UINT);
UINT WINAPI midiOutUnprepareHeader(HMIDIOUT,MIDIHDR*,UINT);
@ -643,16 +642,16 @@ UINT WINAPI midiOutReset(HMIDIOUT);
UINT WINAPI midiOutCachePatches(HMIDIOUT,UINT,WORD*,UINT);
UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,WORD*,UINT);
UINT WINAPI midiOutGetID(HMIDIOUT,UINT*);
UINT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
UINT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI midiInGetNumDevs(void);
UINT WINAPI midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT);
UINT WINAPI midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT);
UINT WINAPI midiInGetDevCapsA(UINT_PTR,LPMIDIINCAPSA,UINT);
UINT WINAPI midiInGetDevCapsW(UINT_PTR,LPMIDIINCAPSW,UINT);
#define midiInGetDevCaps WINELIB_NAME_AW(midiInGetDevCaps)
UINT WINAPI midiInGetErrorTextA(UINT,LPSTR,UINT);
UINT WINAPI midiInGetErrorTextW(UINT,LPWSTR,UINT);
#define midiInGetErrorText WINELIB_NAME_AW(midiInGetErrorText)
UINT WINAPI midiInOpen(HMIDIIN*,UINT,DWORD,DWORD,DWORD);
UINT WINAPI midiInOpen(LPHMIDIIN,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI midiInClose(HMIDIIN);
UINT WINAPI midiInPrepareHeader(HMIDIIN,MIDIHDR*,UINT);
UINT WINAPI midiInUnprepareHeader(HMIDIIN,MIDIHDR*,UINT);
@ -661,10 +660,9 @@ UINT WINAPI midiInStart(HMIDIIN);
UINT WINAPI midiInStop(HMIDIIN);
UINT WINAPI midiInReset(HMIDIIN);
UINT WINAPI midiInGetID(HMIDIIN,UINT*);
UINT WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
UINT WINAPI midiInMessage(HMIDIIN,UINT,DWORD_PTR,DWORD_PTR);
MMRESULT WINAPI midiStreamClose(HMIDISTRM hms);
MMRESULT WINAPI midiStreamOpen(HMIDISTRM* phms, LPUINT uDeviceID, DWORD cMidi,
DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen);
MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD_PTR,DWORD_PTR,DWORD);
MMRESULT WINAPI midiStreamOut(HMIDISTRM hms, LPMIDIHDR lpMidiHdr, UINT cbMidiHdr);
MMRESULT WINAPI midiStreamPause(HMIDISTRM hms);
MMRESULT WINAPI midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt);
@ -704,18 +702,18 @@ DECL_WINELIB_TYPE_AW(LPAUXCAPS)
#define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */
UINT WINAPI auxGetNumDevs(void);
UINT WINAPI auxGetDevCapsA(UINT,LPAUXCAPSA,UINT);
UINT WINAPI auxGetDevCapsW(UINT,LPAUXCAPSW,UINT);
UINT WINAPI auxGetDevCapsA(UINT_PTR,LPAUXCAPSA,UINT);
UINT WINAPI auxGetDevCapsW(UINT_PTR,LPAUXCAPSW,UINT);
#define auxGetDevCaps WINELIB_NAME_AW(auxGetDevCaps)
UINT WINAPI auxSetVolume(UINT,DWORD);
UINT WINAPI auxGetVolume(UINT,LPDWORD);
UINT WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
UINT WINAPI auxOutMessage(UINT,UINT,DWORD_PTR,DWORD_PTR);
#define TIMERR_NOERROR (0) /* no error */
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
#define TIMERR_STRUCT (TIMERR_BASE+33) /* time struct size */
typedef void (CALLBACK *LPTIMECALLBACK)(UINT uTimerID, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPTIMECALLBACK)(UINT,UINT,DWORD_PTR,DWORD_PTR,DWORD_PTR);
#define TIME_ONESHOT 0x0000 /* program timer for single event */
#define TIME_PERIODIC 0x0001 /* program for continuous periodic event */
@ -732,7 +730,7 @@ typedef struct {
MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
DWORD WINAPI timeGetTime(void); /* same for win32/win16 */
MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT);
MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD_PTR,UINT);
MMRESULT WINAPI timeKillEvent(UINT);
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
MMRESULT WINAPI timeBeginPeriod(UINT);
@ -880,8 +878,8 @@ typedef struct {
} JOYINFOEX,*LPJOYINFOEX;
MMRESULT WINAPI joyGetDevCapsA(UINT,LPJOYCAPSA,UINT);
MMRESULT WINAPI joyGetDevCapsW(UINT,LPJOYCAPSW,UINT);
MMRESULT WINAPI joyGetDevCapsA(UINT_PTR,LPJOYCAPSA,UINT);
MMRESULT WINAPI joyGetDevCapsW(UINT_PTR,LPJOYCAPSW,UINT);
#define joyGetDevCaps WINELIB_NAME_AW(joyGetDevCaps)
UINT WINAPI joyGetNumDevs(void);
MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
@ -1242,11 +1240,11 @@ typedef struct {
#define MIXER_SETCONTROLDETAILSF_QUERYMASK 0x0000000FL
UINT WINAPI mixerGetNumDevs(void);
UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD);
UINT WINAPI mixerOpen(LPHMIXER,UINT,DWORD_PTR,DWORD_PTR,DWORD);
UINT WINAPI mixerClose(HMIXER);
UINT WINAPI mixerMessage(HMIXER,UINT,DWORD,DWORD);
UINT WINAPI mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT);
UINT WINAPI mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT);
UINT WINAPI mixerMessage(HMIXER,UINT,DWORD_PTR,DWORD_PTR);
UINT WINAPI mixerGetDevCapsA(UINT_PTR,LPMIXERCAPSA,UINT);
UINT WINAPI mixerGetDevCapsW(UINT_PTR,LPMIXERCAPSW,UINT);
#define mixerGetDevCaps WINELIB_NAME_AW(mixerGetDevCaps)
UINT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
UINT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
@ -1688,11 +1686,11 @@ YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,DWORD*);
#define MCI_LOAD_FILE 0x00000100L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
} MCI_GENERIC_PARMS, *LPMCI_GENERIC_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPSTR lpstrDeviceType;
LPSTR lpstrElementName;
@ -1700,7 +1698,7 @@ typedef struct {
} MCI_OPEN_PARMSA, *LPMCI_OPEN_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPWSTR lpstrDeviceType;
LPWSTR lpstrElementName;
@ -1711,31 +1709,31 @@ DECL_WINELIB_TYPE_AW(MCI_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OPEN_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_PLAY_PARMS, *LPMCI_PLAY_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTo;
} MCI_SEEK_PARMS, *LPMCI_SEEK_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwReturn;
DWORD dwItem;
DWORD dwTrack;
} MCI_STATUS_PARMS, *LPMCI_STATUS_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
} MCI_INFO_PARMSA, *LPMCI_INFO_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
} MCI_INFO_PARMSW, *LPMCI_INFO_PARMSW;
@ -1744,13 +1742,13 @@ DECL_WINELIB_TYPE_AW(MCI_INFO_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_INFO_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwReturn;
DWORD dwItem;
} MCI_GETDEVCAPS_PARMS, *LPMCI_GETDEVCAPS_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwNumber;
@ -1758,7 +1756,7 @@ typedef struct {
} MCI_SYSINFO_PARMSA, *LPMCI_SYSINFO_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPWSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwNumber;
@ -1769,35 +1767,35 @@ DECL_WINELIB_TYPE_AW(MCI_SYSINFO_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_SYSINFO_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
} MCI_SET_PARMS, *LPMCI_SET_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
INT nVirtKey;
HWND hwndBreak;
} MCI_BREAK_PARMS, *LPMCI_BREAK_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpstrSoundName;
} MCI_SOUND_PARMS, *LPMCI_SOUND_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpfilename;
} MCI_SAVE_PARMS, *LPMCI_SAVE_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpfilename;
} MCI_LOAD_PARMSA, *LPMCI_LOAD_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCWSTR lpfilename;
} MCI_LOAD_PARMSW, *LPMCI_LOAD_PARMSW;
@ -1805,7 +1803,7 @@ DECL_WINELIB_TYPE_AW(MCI_LOAD_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_LOAD_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_RECORD_PARMS, *LPMCI_RECORD_PARMS;
@ -1854,24 +1852,24 @@ typedef struct {
#define MCI_VD_ESCAPE_STRING 0x00000100L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_VD_PLAY_PARMS, *LPMCI_VD_PLAY_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_VD_STEP_PARMS, *LPMCI_VD_STEP_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSA, *LPMCI_VD_ESCAPE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCWSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMSW, *LPMCI_VD_ESCAPE_PARMSW;
@ -1905,7 +1903,7 @@ DECL_WINELIB_TYPE_AW(LPMCI_VD_ESCAPE_PARMS)
#define MCI_WAVE_GETDEVCAPS_OUTPUTS 0x00004002L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
@ -1914,7 +1912,7 @@ typedef struct {
} MCI_WAVE_OPEN_PARMSA, *LPMCI_WAVE_OPEN_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
@ -1926,13 +1924,13 @@ DECL_WINELIB_TYPE_AW(MCI_WAVE_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_WAVE_OPEN_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
} MCI_WAVE_DELETE_PARMS, *LPMCI_WAVE_DELETE_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
UINT wInput;
@ -1972,7 +1970,7 @@ typedef struct {
#define MCI_SEQ_SET_OFFSET 0x01000000L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
DWORD dwTempo;
@ -2032,7 +2030,7 @@ typedef struct {
#define MCI_ANIM_UPDATE_HDC 0x00020000L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
@ -2042,7 +2040,7 @@ typedef struct {
} MCI_ANIM_OPEN_PARMSA, *LPMCI_ANIM_OPEN_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
@ -2055,26 +2053,26 @@ DECL_WINELIB_TYPE_AW(MCI_ANIM_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_ANIM_OPEN_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrom;
DWORD dwTo;
DWORD dwSpeed;
} MCI_ANIM_PLAY_PARMS, *LPMCI_ANIM_PLAY_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
DWORD dwFrames;
} MCI_ANIM_STEP_PARMS, *LPMCI_ANIM_STEP_PARMS;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_ANIM_WINDOW_PARMSA, *LPMCI_ANIM_WINDOW_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
@ -2084,7 +2082,7 @@ DECL_WINELIB_TYPE_AW(MCI_ANIM_WINDOW_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_ANIM_WINDOW_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
@ -2095,7 +2093,7 @@ typedef struct {
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
RECT rc;
HDC hDC;
} MCI_ANIM_UPDATE_PARMS, *LPMCI_ANIM_UPDATE_PARMS;
@ -2133,7 +2131,7 @@ typedef struct {
#define MCI_OVLY_WHERE_VIDEO 0x00100000L
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
@ -2143,7 +2141,7 @@ typedef struct {
} MCI_OVLY_OPEN_PARMSA, *LPMCI_OVLY_OPEN_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName;
@ -2156,14 +2154,14 @@ DECL_WINELIB_TYPE_AW(MCI_OVLY_OPEN_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_OPEN_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCSTR lpstrText;
} MCI_OVLY_WINDOW_PARMSA, *LPMCI_OVLY_WINDOW_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
HWND hWnd;
UINT nCmdShow;
LPCWSTR lpstrText;
@ -2173,7 +2171,7 @@ DECL_WINELIB_TYPE_AW(MCI_OVLY_WINDOW_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_WINDOW_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
#ifdef MCI_USE_OFFEXT
POINT ptOffset;
POINT ptExtent;
@ -2184,13 +2182,13 @@ typedef struct {
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSA, *LPMCI_OVLY_SAVE_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_SAVE_PARMSW, *LPMCI_OVLY_SAVE_PARMSW;
@ -2199,13 +2197,13 @@ DECL_WINELIB_TYPE_AW(MCI_OVLY_SAVE_PARMS)
DECL_WINELIB_TYPE_AW(LPMCI_OVLY_SAVE_PARMS)
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSA, *LPMCI_OVLY_LOAD_PARMSA;
typedef struct {
DWORD dwCallback;
DWORD_PTR dwCallback;
LPCWSTR lpfilename;
RECT rc;
} MCI_OVLY_LOAD_PARMSW, *LPMCI_OVLY_LOAD_PARMSW;