Headers diff for winmm.dll between 5.2.3790.3959-Windows 5.0 and 6.0.6002.18005-Windows 6.0 versions



 mmsystem.h (5.2.3790.3959-Windows 5.0)   mmsystem.h (6.0.6002.18005-Windows 6.0) 
skipping to change at line 102 skipping to change at line 102
#endif #endif
#endif #endif
/* general data types */ /* general data types */
#ifdef _WIN32 #ifdef _WIN32
typedef UINT MMVERSION; /* major (high byte), minor (low byte) */ typedef UINT MMVERSION; /* major (high byte), minor (low byte) */
#else #else
typedef UINT VERSION; /* major (high byte), minor (low byte) */ typedef UINT VERSION; /* major (high byte), minor (low byte) */
#endif #endif
typedef UINT MMRESULT; /* error return code, 0 means no error */ typedef __success( return == 0) UINT MMRESULT; /* error return code, 0 means no error */
/* call as if(err=xxxx(...)) Error(err); else */ /* call as if(err=xxxx(...)) Error(err); else */
#define _MMRESULT_ #define _MMRESULT_
typedef UINT FAR *LPUINT; typedef UINT FAR *LPUINT;
/* MMTIME data structure */ /* MMTIME data structure */
typedef struct mmtime_tag typedef struct mmtime_tag
{ {
UINT wType; /* indicates the contents of the union */ UINT wType; /* indicates the contents of the union */
union union
skipping to change at line 347 skipping to change at line 348
/* Supported return values for DRV_CONFIGURE message */ /* Supported return values for DRV_CONFIGURE message */
#define DRVCNF_CANCEL 0x0000 #define DRVCNF_CANCEL 0x0000
#define DRVCNF_OK 0x0001 #define DRVCNF_OK 0x0001
#define DRVCNF_RESTART 0x0002 #define DRVCNF_RESTART 0x0002
/* installable driver function prototypes */ /* installable driver function prototypes */
#ifdef _WIN32 #ifdef _WIN32
typedef LRESULT (CALLBACK* DRIVERPROC)(DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM); typedef LRESULT (CALLBACK* DRIVERPROC)(DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM);
WINMMAPI LRESULT WINAPI CloseDriver( IN HDRVR hDriver, IN LPARAM lParam1, IN L WINMMAPI LRESULT WINAPI CloseDriver( __in HDRVR hDriver, __in LPARAM lParam1,
PARAM lParam2); __in LPARAM lParam2);
WINMMAPI HDRVR WINAPI OpenDriver( IN LPCWSTR szDriverName, IN LPCWSTR szSect WINMMAPI HDRVR WINAPI OpenDriver( __in LPCWSTR szDriverName, __in LPCWSTR sz
ionName, IN LPARAM lParam2); SectionName, __in LPARAM lParam2);
WINMMAPI LRESULT WINAPI SendDriverMessage( IN HDRVR hDriver, IN UINT message, WINMMAPI LRESULT WINAPI SendDriverMessage( __in HDRVR hDriver, __in UINT messa
IN LPARAM lParam1, IN LPARAM lParam2); ge, __inout LPARAM lParam1, __inout LPARAM lParam2);
WINMMAPI HMODULE WINAPI DrvGetModuleHandle( IN HDRVR hDriver); WINMMAPI HMODULE WINAPI DrvGetModuleHandle( __in HDRVR hDriver);
WINMMAPI HMODULE WINAPI GetDriverModuleHandle( IN HDRVR hDriver); WINMMAPI HMODULE WINAPI GetDriverModuleHandle( __in HDRVR hDriver);
WINMMAPI LRESULT WINAPI DefDriverProc( IN DWORD_PTR dwDriverIdentifier, IN HDR WINMMAPI LRESULT WINAPI DefDriverProc( __in DWORD_PTR dwDriverIdentifier, __in
VR hdrvr, IN UINT uMsg, IN LPARAM lParam1, IN LPARAM lParam2); HDRVR hdrvr, __in UINT uMsg, __in LPARAM lParam1, __in LPARAM lParam2);
#else #else
LRESULT WINAPI DrvClose(HDRVR hdrvr, LPARAM lParam1, LPARAM lParam2); LRESULT WINAPI DrvClose(HDRVR hdrvr, LPARAM lParam1, LPARAM lParam2);
HDRVR WINAPI DrvOpen(LPCSTR szDriverName, LPCSTR szSectionName, LPARAM lPara m2); HDRVR WINAPI DrvOpen(LPCSTR szDriverName, LPCSTR szSectionName, LPARAM lPara m2);
LRESULT WINAPI DrvSendMessage(HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM l Param2); LRESULT WINAPI DrvSendMessage(HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM l Param2);
HINSTANCE WINAPI DrvGetModuleHandle(HDRVR hdrvr); HINSTANCE WINAPI DrvGetModuleHandle(HDRVR hdrvr);
LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverIdentifier, HDRVR hdrvr, UINT uM sg, LPARAM lParam1, LPARAM lParam2); LRESULT WINAPI DrvDefDriverProc(DWORD dwDriverIdentifier, HDRVR hdrvr, UINT uM sg, LPARAM lParam1, LPARAM lParam2);
#define DefDriverProc DrvDefDriverProc #define DefDriverProc DrvDefDriverProc
#endif /* ifdef _WIN32 */ #endif /* ifdef _WIN32 */
#endif /* DRV_LOAD */ #endif /* DRV_LOAD */
#endif /* ifdef (WINVER < 0x030a) || defined(_WIN32) */ #endif /* ifdef (WINVER < 0x030a) || defined(_WIN32) */
skipping to change at line 429 skipping to change at line 430
#ifndef MMNOSOUND #ifndef MMNOSOUND
/**************************************************************************** /****************************************************************************
Sound support Sound support
****************************************************************************/ ****************************************************************************/
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI BOOL WINAPI sndPlaySoundA( IN LPCSTR pszSound, IN UINT fuSound); WINMMAPI BOOL WINAPI sndPlaySoundA( __in_opt LPCSTR pszSound, __in UINT fuSound)
WINMMAPI BOOL WINAPI sndPlaySoundW( IN LPCWSTR pszSound, IN UINT fuSound); ;
WINMMAPI BOOL WINAPI sndPlaySoundW( __in_opt LPCWSTR pszSound, __in UINT fuSound
);
#ifdef UNICODE #ifdef UNICODE
#define sndPlaySound sndPlaySoundW #define sndPlaySound sndPlaySoundW
#else #else
#define sndPlaySound sndPlaySoundA #define sndPlaySound sndPlaySoundA
#endif // !UNICODE #endif // !UNICODE
#else #else
BOOL WINAPI sndPlaySound(LPCSTR pszSound, UINT fuSound); BOOL WINAPI sndPlaySound(LPCSTR pszSound, UINT fuSound);
#endif #endif
skipping to change at line 460 skipping to change at line 461
#define SND_NOWAIT 0x00002000L /* don't wait if the driver is busy */ #define SND_NOWAIT 0x00002000L /* don't wait if the driver is busy */
#define SND_ALIAS 0x00010000L /* name is a registry alias */ #define SND_ALIAS 0x00010000L /* name is a registry alias */
#define SND_ALIAS_ID 0x00110000L /* alias is a predefined ID */ #define SND_ALIAS_ID 0x00110000L /* alias is a predefined ID */
#define SND_FILENAME 0x00020000L /* name is file name */ #define SND_FILENAME 0x00020000L /* name is file name */
#define SND_RESOURCE 0x00040004L /* name is resource name or atom */ #define SND_RESOURCE 0x00040004L /* name is resource name or atom */
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
#define SND_PURGE 0x0040 /* purge non-static events for task */ #define SND_PURGE 0x0040 /* purge non-static events for task */
#define SND_APPLICATION 0x0080 /* look for application specific association */ #define SND_APPLICATION 0x0080 /* look for application specific association */
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
#define SND_SENTRY 0x00080000L /* Generate a SoundSentry event with this so
und */
#define SND_SYSTEM 0x00200000L /* Treat this as a system sound */
#define SND_ALIAS_START 0 /* alias base */ #define SND_ALIAS_START 0 /* alias base */
#ifdef _WIN32 #ifdef _WIN32
#define sndAlias(ch0, ch1) (SND_ALIAS_START + (DWORD)(BYTE)(ch0) | ((DWORD) (BYTE)(ch1) << 8)) #define sndAlias(ch0, ch1) (SND_ALIAS_START + (DWORD)(BYTE)(ch0) | ((DWORD) (BYTE)(ch1) << 8))
#define SND_ALIAS_SYSTEMASTERISK sndAlias('S', '*') #define SND_ALIAS_SYSTEMASTERISK sndAlias('S', '*')
#define SND_ALIAS_SYSTEMQUESTION sndAlias('S', '?') #define SND_ALIAS_SYSTEMQUESTION sndAlias('S', '?')
#define SND_ALIAS_SYSTEMHAND sndAlias('S', 'H') #define SND_ALIAS_SYSTEMHAND sndAlias('S', 'H')
#define SND_ALIAS_SYSTEMEXIT sndAlias('S', 'E') #define SND_ALIAS_SYSTEMEXIT sndAlias('S', 'E')
#define SND_ALIAS_SYSTEMSTART sndAlias('S', 'S') #define SND_ALIAS_SYSTEMSTART sndAlias('S', 'S')
#define SND_ALIAS_SYSTEMWELCOME sndAlias('S', 'W') #define SND_ALIAS_SYSTEMWELCOME sndAlias('S', 'W')
#define SND_ALIAS_SYSTEMEXCLAMATION sndAlias('S', '!') #define SND_ALIAS_SYSTEMEXCLAMATION sndAlias('S', '!')
#define SND_ALIAS_SYSTEMDEFAULT sndAlias('S', 'D') #define SND_ALIAS_SYSTEMDEFAULT sndAlias('S', 'D')
WINMMAPI BOOL WINAPI PlaySoundA( IN LPCSTR pszSound, IN HMODULE hmod, IN DWORD f WINMMAPI BOOL WINAPI PlaySoundA( __in_opt LPCSTR pszSound, __in_opt HMODULE hmod
dwSound); , __in DWORD fdwSound);
WINMMAPI BOOL WINAPI PlaySoundW( IN LPCWSTR pszSound, IN HMODULE hmod, IN DWORD WINMMAPI BOOL WINAPI PlaySoundW( __in_opt LPCWSTR pszSound, __in_opt HMODULE hmo
fdwSound); d, __in DWORD fdwSound);
#ifdef UNICODE #ifdef UNICODE
#define PlaySound PlaySoundW #define PlaySound PlaySoundW
#else #else
#define PlaySound PlaySoundA #define PlaySound PlaySoundA
#endif // !UNICODE #endif // !UNICODE
#else #else
BOOL WINAPI PlaySound(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound); BOOL WINAPI PlaySound(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
#endif #endif
skipping to change at line 798 skipping to change at line 801
} WAVEFORMATEX, *PWAVEFORMATEX, NEAR *NPWAVEFORMATEX, FAR *LPWAVEFORMATEX; } WAVEFORMATEX, *PWAVEFORMATEX, NEAR *NPWAVEFORMATEX, FAR *LPWAVEFORMATEX;
#endif /* _WAVEFORMATEX_ */ #endif /* _WAVEFORMATEX_ */
typedef const WAVEFORMATEX FAR *LPCWAVEFORMATEX; typedef const WAVEFORMATEX FAR *LPCWAVEFORMATEX;
/* waveform audio function prototypes */ /* waveform audio function prototypes */
WINMMAPI UINT WINAPI waveOutGetNumDevs(void); WINMMAPI UINT WINAPI waveOutGetNumDevs(void);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveOutGetDevCapsA( IN UINT_PTR uDeviceID, OUT LPWAVEOU WINMMAPI MMRESULT WINAPI waveOutGetDevCapsA( __in UINT_PTR uDeviceID, __out LPWA
TCAPSA pwoc, IN UINT cbwoc); VEOUTCAPSA pwoc, __in UINT cbwoc);
WINMMAPI MMRESULT WINAPI waveOutGetDevCapsW( IN UINT_PTR uDeviceID, OUT LPWAVEOU WINMMAPI MMRESULT WINAPI waveOutGetDevCapsW( __in UINT_PTR uDeviceID, __out LPWA
TCAPSW pwoc, IN UINT cbwoc); VEOUTCAPSW pwoc, __in UINT cbwoc);
#ifdef UNICODE #ifdef UNICODE
#define waveOutGetDevCaps waveOutGetDevCapsW #define waveOutGetDevCaps waveOutGetDevCapsW
#else #else
#define waveOutGetDevCaps waveOutGetDevCapsA #define waveOutGetDevCaps waveOutGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
WINMMAPI MMRESULT WINAPI waveOutGetDevCaps( UINT uDeviceID, LPWAVEOUTCAPS pwoc, UINT cbwoc); WINMMAPI MMRESULT WINAPI waveOutGetDevCaps( UINT uDeviceID, LPWAVEOUTCAPS pwoc, UINT cbwoc);
#endif #endif
#if (WINVER >= 0x0400) #if (WINVER >= 0x0400)
WINMMAPI MMRESULT WINAPI waveOutGetVolume( IN HWAVEOUT hwo, OUT LPDWORD pdwVolum WINMMAPI MMRESULT WINAPI waveOutGetVolume( __in_opt HWAVEOUT hwo, __out LPDWORD
e); pdwVolume);
WINMMAPI MMRESULT WINAPI waveOutSetVolume( IN HWAVEOUT hwo, IN DWORD dwVolume); WINMMAPI MMRESULT WINAPI waveOutSetVolume( __in_opt HWAVEOUT hwo, __in DWORD dwV
olume);
#else #else
WINMMAPI MMRESULT WINAPI waveOutGetVolume(UINT uId, LPDWORD pdwVolume); WINMMAPI MMRESULT WINAPI waveOutGetVolume(UINT uId, LPDWORD pdwVolume);
WINMMAPI MMRESULT WINAPI waveOutSetVolume(UINT uId, DWORD dwVolume); WINMMAPI MMRESULT WINAPI waveOutSetVolume(UINT uId, DWORD dwVolume);
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveOutGetErrorTextA( IN MMRESULT mmrError, OUT LPSTR p WINMMAPI MMRESULT WINAPI waveOutGetErrorTextA( __in MMRESULT mmrError, __out_eco
szText, IN UINT cchText); unt(cchText) LPSTR pszText, __in UINT cchText);
WINMMAPI MMRESULT WINAPI waveOutGetErrorTextW( IN MMRESULT mmrError, OUT LPWSTR WINMMAPI MMRESULT WINAPI waveOutGetErrorTextW( __in MMRESULT mmrError, __out_eco
pszText, IN UINT cchText); unt(cchText) LPWSTR pszText, __in UINT cchText);
#ifdef UNICODE #ifdef UNICODE
#define waveOutGetErrorText waveOutGetErrorTextW #define waveOutGetErrorText waveOutGetErrorTextW
#else #else
#define waveOutGetErrorText waveOutGetErrorTextA #define waveOutGetErrorText waveOutGetErrorTextA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI waveOutGetErrorText(MMRESULT mmrError, LPSTR pszText, UINT cchTe xt); MMRESULT WINAPI waveOutGetErrorText(MMRESULT mmrError, LPSTR pszText, UINT cchTe xt);
#endif #endif
WINMMAPI MMRESULT WINAPI waveOutOpen( OUT LPHWAVEOUT phwo, IN UINT uDeviceID, WINMMAPI MMRESULT WINAPI waveOutOpen( __out_opt LPHWAVEOUT phwo, __in UINT uDevi
IN LPCWAVEFORMATEX pwfx, IN DWORD_PTR dwCallback, IN DWORD_PTR dwInstance, I ceID,
N DWORD fdwOpen); __in LPCWAVEFORMATEX pwfx, __in_opt DWORD_PTR dwCallback, __in_opt DWORD_PTR
dwInstance, __in DWORD fdwOpen);
WINMMAPI MMRESULT WINAPI waveOutClose( IN OUT HWAVEOUT hwo); WINMMAPI MMRESULT WINAPI waveOutClose( __in HWAVEOUT hwo);
WINMMAPI MMRESULT WINAPI waveOutPrepareHeader( IN HWAVEOUT hwo, IN OUT LPWAVEHDR WINMMAPI MMRESULT WINAPI waveOutPrepareHeader( __in HWAVEOUT hwo, __inout_bcount
pwh, IN UINT cbwh); (cbwh) LPWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveOutUnprepareHeader( IN HWAVEOUT hwo, IN OUT LPWAVEH WINMMAPI MMRESULT WINAPI waveOutUnprepareHeader( __in HWAVEOUT hwo, __inout_bcou
DR pwh, IN UINT cbwh); nt(cbwh) LPWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveOutWrite( IN HWAVEOUT hwo, IN OUT LPWAVEHDR pwh, IN WINMMAPI MMRESULT WINAPI waveOutWrite( __in HWAVEOUT hwo, __inout_bcount(cbwh) L
UINT cbwh); PWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveOutPause( IN HWAVEOUT hwo); WINMMAPI MMRESULT WINAPI waveOutPause( __in HWAVEOUT hwo);
WINMMAPI MMRESULT WINAPI waveOutRestart( IN HWAVEOUT hwo); WINMMAPI MMRESULT WINAPI waveOutRestart( __in HWAVEOUT hwo);
WINMMAPI MMRESULT WINAPI waveOutReset( IN HWAVEOUT hwo); WINMMAPI MMRESULT WINAPI waveOutReset( __in HWAVEOUT hwo);
WINMMAPI MMRESULT WINAPI waveOutBreakLoop( IN HWAVEOUT hwo); WINMMAPI MMRESULT WINAPI waveOutBreakLoop( __in HWAVEOUT hwo);
WINMMAPI MMRESULT WINAPI waveOutGetPosition( IN HWAVEOUT hwo, IN OUT LPMMTIME pm WINMMAPI MMRESULT WINAPI waveOutGetPosition( __in HWAVEOUT hwo, __inout_bcount(c
mt, IN UINT cbmmt); bmmt) LPMMTIME pmmt, __in UINT cbmmt);
WINMMAPI MMRESULT WINAPI waveOutGetPitch( IN HWAVEOUT hwo, OUT LPDWORD pdwPitch) WINMMAPI MMRESULT WINAPI waveOutGetPitch( __in HWAVEOUT hwo, __out LPDWORD pdwPi
; tch);
WINMMAPI MMRESULT WINAPI waveOutSetPitch( IN HWAVEOUT hwo, IN DWORD dwPitch); WINMMAPI MMRESULT WINAPI waveOutSetPitch( __in HWAVEOUT hwo, __in DWORD dwPitch)
WINMMAPI MMRESULT WINAPI waveOutGetPlaybackRate( IN HWAVEOUT hwo, OUT LPDWORD pd ;
wRate); WINMMAPI MMRESULT WINAPI waveOutGetPlaybackRate( __in HWAVEOUT hwo, __out LPDWOR
WINMMAPI MMRESULT WINAPI waveOutSetPlaybackRate( IN HWAVEOUT hwo, IN DWORD dwRat D pdwRate);
e); WINMMAPI MMRESULT WINAPI waveOutSetPlaybackRate( __in HWAVEOUT hwo, __in DWORD d
WINMMAPI MMRESULT WINAPI waveOutGetID( IN HWAVEOUT hwo, OUT LPUINT puDeviceID); wRate);
WINMMAPI MMRESULT WINAPI waveOutGetID( __in HWAVEOUT hwo, __out LPUINT puDeviceI
D);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveOutMessage( IN HWAVEOUT hwo, IN UINT uMsg, IN DWORD _PTR dw1, IN DWORD_PTR dw2); WINMMAPI MMRESULT WINAPI waveOutMessage( __in_opt HWAVEOUT hwo, __in UINT uMsg, __in DWORD_PTR dw1, __in DWORD_PTR dw2);
#else #else
DWORD WINAPI waveOutMessage(HWAVEOUT hwo, UINT uMsg, DWORD dw1, DWORD dw2); DWORD WINAPI waveOutMessage(HWAVEOUT hwo, UINT uMsg, DWORD dw1, DWORD dw2);
#endif #endif
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
WINMMAPI UINT WINAPI waveInGetNumDevs(void); WINMMAPI UINT WINAPI waveInGetNumDevs(void);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveInGetDevCapsA( IN UINT_PTR uDeviceID, OUT LPWAVEINC WINMMAPI MMRESULT WINAPI waveInGetDevCapsA( __in UINT_PTR uDeviceID, __out_bcoun
APSA pwic, IN UINT cbwic); t(cbwic) LPWAVEINCAPSA pwic, __in UINT cbwic);
WINMMAPI MMRESULT WINAPI waveInGetDevCapsW( IN UINT_PTR uDeviceID, OUT LPWAVEINC WINMMAPI MMRESULT WINAPI waveInGetDevCapsW( __in UINT_PTR uDeviceID, __out_bcoun
APSW pwic, IN UINT cbwic); t(cbwic) LPWAVEINCAPSW pwic, __in UINT cbwic);
#ifdef UNICODE #ifdef UNICODE
#define waveInGetDevCaps waveInGetDevCapsW #define waveInGetDevCaps waveInGetDevCapsW
#else #else
#define waveInGetDevCaps waveInGetDevCapsA #define waveInGetDevCaps waveInGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI waveInGetDevCaps(UINT uDeviceID, LPWAVEINCAPS pwic, UINT cbwic); MMRESULT WINAPI waveInGetDevCaps(UINT uDeviceID, LPWAVEINCAPS pwic, UINT cbwic);
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveInGetErrorTextA(IN MMRESULT mmrError, OUT LPSTR psz WINMMAPI MMRESULT WINAPI waveInGetErrorTextA(__in MMRESULT mmrError, __out_ecoun
Text, IN UINT cchText); t(cchText) LPSTR pszText, __in UINT cchText);
WINMMAPI MMRESULT WINAPI waveInGetErrorTextW(IN MMRESULT mmrError, OUT LPWSTR ps WINMMAPI MMRESULT WINAPI waveInGetErrorTextW(__in MMRESULT mmrError, __out_ecoun
zText, IN UINT cchText); t(cchText) LPWSTR pszText, __in UINT cchText);
#ifdef UNICODE #ifdef UNICODE
#define waveInGetErrorText waveInGetErrorTextW #define waveInGetErrorText waveInGetErrorTextW
#else #else
#define waveInGetErrorText waveInGetErrorTextA #define waveInGetErrorText waveInGetErrorTextA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI waveInGetErrorText(MMRESULT mmrError, LPSTR pszText, UINT cchTex t); MMRESULT WINAPI waveInGetErrorText(MMRESULT mmrError, LPSTR pszText, UINT cchTex t);
#endif #endif
WINMMAPI MMRESULT WINAPI waveInOpen( OUT LPHWAVEIN phwi, IN UINT uDeviceID, WINMMAPI MMRESULT WINAPI waveInOpen( __out_opt LPHWAVEIN phwi, __in UINT uDevice
IN LPCWAVEFORMATEX pwfx, IN DWORD_PTR dwCallback, IN DWORD_PTR dwInstance, I ID,
N DWORD fdwOpen); __in LPCWAVEFORMATEX pwfx, __in_opt DWORD_PTR dwCallback, __in_opt DWORD_PTR
dwInstance, __in DWORD fdwOpen);
WINMMAPI MMRESULT WINAPI waveInClose( IN OUT HWAVEIN hwi); WINMMAPI MMRESULT WINAPI waveInClose( __in HWAVEIN hwi);
WINMMAPI MMRESULT WINAPI waveInPrepareHeader( IN HWAVEIN hwi, IN OUT LPWAVEHDR p WINMMAPI MMRESULT WINAPI waveInPrepareHeader( __in HWAVEIN hwi, __inout_bcount(c
wh, IN UINT cbwh); bwh) LPWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveInUnprepareHeader( IN HWAVEIN hwi, IN OUT LPWAVEHDR WINMMAPI MMRESULT WINAPI waveInUnprepareHeader( __in HWAVEIN hwi, __inout_bcount
pwh, UINT cbwh); (cbwh) LPWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveInAddBuffer( IN HWAVEIN hwi, IN OUT LPWAVEHDR pwh, WINMMAPI MMRESULT WINAPI waveInAddBuffer( __in HWAVEIN hwi, __inout_bcount(cbwh)
IN UINT cbwh); LPWAVEHDR pwh, __in UINT cbwh);
WINMMAPI MMRESULT WINAPI waveInStart( IN HWAVEIN hwi); WINMMAPI MMRESULT WINAPI waveInStart( __in HWAVEIN hwi);
WINMMAPI MMRESULT WINAPI waveInStop( IN HWAVEIN hwi); WINMMAPI MMRESULT WINAPI waveInStop( __in HWAVEIN hwi);
WINMMAPI MMRESULT WINAPI waveInReset( IN HWAVEIN hwi); WINMMAPI MMRESULT WINAPI waveInReset( __in HWAVEIN hwi);
WINMMAPI MMRESULT WINAPI waveInGetPosition( IN HWAVEIN hwi, IN OUT LPMMTIME pmmt WINMMAPI MMRESULT WINAPI waveInGetPosition( __in HWAVEIN hwi, __inout_bcount(cbm
, IN UINT cbmmt); mt) LPMMTIME pmmt, __in UINT cbmmt);
WINMMAPI MMRESULT WINAPI waveInGetID( IN HWAVEIN hwi, OUT LPUINT puDeviceID); WINMMAPI MMRESULT WINAPI waveInGetID( __in HWAVEIN hwi, __in LPUINT puDeviceID);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI waveInMessage( IN HWAVEIN hwi, IN UINT uMsg, IN DWORD_P TR dw1, IN DWORD_PTR dw2); WINMMAPI MMRESULT WINAPI waveInMessage( __in_opt HWAVEIN hwi, __in UINT uMsg, __ in_opt DWORD_PTR dw1, __in_opt DWORD_PTR dw2);
#else #else
DWORD WINAPI waveInMessage(HWAVEIN hwi, UINT uMsg, DWORD dw1, DWORD dw2); DWORD WINAPI waveInMessage(HWAVEIN hwi, UINT uMsg, DWORD dw1, DWORD dw2);
#endif #endif
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
#endif /* ifndef MMNOWAVE */ #endif /* ifndef MMNOWAVE */
#ifndef MMNOMIDI #ifndef MMNOMIDI
/**************************************************************************** /****************************************************************************
skipping to change at line 1261 skipping to change at line 1264
typedef struct midiproptempo_tag typedef struct midiproptempo_tag
{ {
DWORD cbStruct; DWORD cbStruct;
DWORD dwTempo; DWORD dwTempo;
} MIDIPROPTEMPO, FAR *LPMIDIPROPTEMPO; } MIDIPROPTEMPO, FAR *LPMIDIPROPTEMPO;
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
/* MIDI function prototypes */ /* MIDI function prototypes */
WINMMAPI UINT WINAPI midiOutGetNumDevs(void); WINMMAPI UINT WINAPI midiOutGetNumDevs(void);
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
WINMMAPI MMRESULT WINAPI midiStreamOpen( OUT LPHMIDISTRM phms, IN LPUINT puDevic WINMMAPI MMRESULT WINAPI midiStreamOpen( __out LPHMIDISTRM phms, __inout_ecount(
eID, IN DWORD cMidi, IN DWORD_PTR dwCallback, IN DWORD_PTR dwInstance, IN DWORD cMidi) LPUINT puDeviceID, __in DWORD cMidi, __in_opt DWORD_PTR dwCallback, __in_
fdwOpen); opt DWORD_PTR dwInstance, __in DWORD fdwOpen);
WINMMAPI MMRESULT WINAPI midiStreamClose( IN HMIDISTRM hms); WINMMAPI MMRESULT WINAPI midiStreamClose( __in HMIDISTRM hms);
WINMMAPI MMRESULT WINAPI midiStreamProperty( IN HMIDISTRM hms, OUT LPBYTE lpprop WINMMAPI MMRESULT WINAPI midiStreamProperty( __in HMIDISTRM hms, __inout_bcount(
data, IN DWORD dwProperty); sizeof(DWORD)+sizeof(DWORD)) LPBYTE lppropdata, __in DWORD dwProperty);
WINMMAPI MMRESULT WINAPI midiStreamPosition( IN HMIDISTRM hms, OUT LPMMTIME lpmm WINMMAPI MMRESULT WINAPI midiStreamPosition( __in HMIDISTRM hms, __out_bcount(cb
t, IN UINT cbmmt); mmt) LPMMTIME lpmmt, __in UINT cbmmt);
WINMMAPI MMRESULT WINAPI midiStreamOut( IN HMIDISTRM hms, IN LPMIDIHDR pmh, IN U WINMMAPI MMRESULT WINAPI midiStreamOut( __in HMIDISTRM hms, __out_bcount(cbmh) L
INT cbmh); PMIDIHDR pmh, __in UINT cbmh);
WINMMAPI MMRESULT WINAPI midiStreamPause( IN HMIDISTRM hms); WINMMAPI MMRESULT WINAPI midiStreamPause( __in HMIDISTRM hms);
WINMMAPI MMRESULT WINAPI midiStreamRestart( IN HMIDISTRM hms); WINMMAPI MMRESULT WINAPI midiStreamRestart( __in HMIDISTRM hms);
WINMMAPI MMRESULT WINAPI midiStreamStop( IN HMIDISTRM hms); WINMMAPI MMRESULT WINAPI midiStreamStop( __in HMIDISTRM hms);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiConnect( IN HMIDI hmi, IN HMIDIOUT hmo, IN LPVOID p WINMMAPI MMRESULT WINAPI midiConnect( __in HMIDI hmi, __in HMIDIOUT hmo, __in_op
Reserved); t LPVOID pReserved);
WINMMAPI MMRESULT WINAPI midiDisconnect( IN HMIDI hmi, IN HMIDIOUT hmo, IN LPVOI WINMMAPI MMRESULT WINAPI midiDisconnect( __in HMIDI hmi, __in HMIDIOUT hmo, __in
D pReserved); _opt LPVOID pReserved);
#endif #endif
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiOutGetDevCapsA( IN UINT_PTR uDeviceID, OUT LPMIDIOU WINMMAPI MMRESULT WINAPI midiOutGetDevCapsA( __in UINT_PTR uDeviceID, __out_bcou
TCAPSA pmoc, IN UINT cbmoc); nt(cbmoc) LPMIDIOUTCAPSA pmoc, __in UINT cbmoc);
WINMMAPI MMRESULT WINAPI midiOutGetDevCapsW( IN UINT_PTR uDeviceID, OUT LPMIDIOU WINMMAPI MMRESULT WINAPI midiOutGetDevCapsW( __in UINT_PTR uDeviceID, __out_bcou
TCAPSW pmoc, IN UINT cbmoc); nt(cbmoc) LPMIDIOUTCAPSW pmoc, __in UINT cbmoc);
#ifdef UNICODE #ifdef UNICODE
#define midiOutGetDevCaps midiOutGetDevCapsW #define midiOutGetDevCaps midiOutGetDevCapsW
#else #else
#define midiOutGetDevCaps midiOutGetDevCapsA #define midiOutGetDevCaps midiOutGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI midiOutGetDevCaps(UINT uDeviceID, LPMIDIOUTCAPS pmoc, UINT cbmoc ); MMRESULT WINAPI midiOutGetDevCaps(UINT uDeviceID, LPMIDIOUTCAPS pmoc, UINT cbmoc );
#endif #endif
#if (WINVER >= 0x0400) #if (WINVER >= 0x0400)
WINMMAPI MMRESULT WINAPI midiOutGetVolume( IN HMIDIOUT hmo, OUT LPDWORD pdwVolum WINMMAPI MMRESULT WINAPI midiOutGetVolume( __in_opt HMIDIOUT hmo, __out LPDWORD
e); pdwVolume);
WINMMAPI MMRESULT WINAPI midiOutSetVolume( IN HMIDIOUT hmo, IN DWORD dwVolume); WINMMAPI MMRESULT WINAPI midiOutSetVolume( __in_opt HMIDIOUT hmo, __in DWORD dwV
olume);
#else #else
WINMMAPI MMRESULT WINAPI midiOutGetVolume(UINT uId, LPDWORD pdwVolume); WINMMAPI MMRESULT WINAPI midiOutGetVolume(UINT uId, LPDWORD pdwVolume);
WINMMAPI MMRESULT WINAPI midiOutSetVolume(UINT uId, DWORD dwVolume); WINMMAPI MMRESULT WINAPI midiOutSetVolume(UINT uId, DWORD dwVolume);
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiOutGetErrorTextA( IN MMRESULT mmrError, OUT LPSTR p WINMMAPI MMRESULT WINAPI midiOutGetErrorTextA( __in MMRESULT mmrError, __out_eco
szText, IN UINT cchText); unt(cchText) LPSTR pszText, __in UINT cchText);
WINMMAPI MMRESULT WINAPI midiOutGetErrorTextW( IN MMRESULT mmrError, OUT LPWSTR WINMMAPI MMRESULT WINAPI midiOutGetErrorTextW( __in MMRESULT mmrError, __out_eco
pszText, IN UINT cchText); unt(cchText) LPWSTR pszText, __in UINT cchText);
#ifdef UNICODE #ifdef UNICODE
#define midiOutGetErrorText midiOutGetErrorTextW #define midiOutGetErrorText midiOutGetErrorTextW
#else #else
#define midiOutGetErrorText midiOutGetErrorTextA #define midiOutGetErrorText midiOutGetErrorTextA
#endif // !UNICODE #endif // !UNICODE
#else #else
WINMMAPI MMRESULT WINAPI midiOutGetErrorText(MMRESULT mmrError, LPSTR pszText, U INT cchText); WINMMAPI MMRESULT WINAPI midiOutGetErrorText(MMRESULT mmrError, LPSTR pszText, U INT cchText);
#endif #endif
WINMMAPI MMRESULT WINAPI midiOutOpen( OUT LPHMIDIOUT phmo, IN UINT uDeviceID, WINMMAPI MMRESULT WINAPI midiOutOpen( __out LPHMIDIOUT phmo, __in UINT uDeviceID
IN DWORD_PTR dwCallback, IN DWORD_PTR dwInstance, IN DWORD fdwOpen); ,
WINMMAPI MMRESULT WINAPI midiOutClose( IN OUT HMIDIOUT hmo); __in_opt DWORD_PTR dwCallback, __in_opt DWORD_PTR dwInstance, __in DWORD fdw
WINMMAPI MMRESULT WINAPI midiOutPrepareHeader( IN HMIDIOUT hmo, IN OUT LPMIDIHDR Open);
pmh, IN UINT cbmh); WINMMAPI MMRESULT WINAPI midiOutClose( __in HMIDIOUT hmo);
WINMMAPI MMRESULT WINAPI midiOutUnprepareHeader(IN HMIDIOUT hmo, IN OUT LPMIDIHD WINMMAPI MMRESULT WINAPI midiOutPrepareHeader( __in HMIDIOUT hmo, __inout_bcount
R pmh, IN UINT cbmh); (cbmh) LPMIDIHDR pmh, __in UINT cbmh);
WINMMAPI MMRESULT WINAPI midiOutShortMsg( IN HMIDIOUT hmo, IN DWORD dwMsg); WINMMAPI MMRESULT WINAPI midiOutUnprepareHeader(__in HMIDIOUT hmo, __inout_bcoun
WINMMAPI MMRESULT WINAPI midiOutLongMsg(IN HMIDIOUT hmo, IN LPMIDIHDR pmh, IN UI t(cbmh) LPMIDIHDR pmh, __in UINT cbmh);
NT cbmh); WINMMAPI MMRESULT WINAPI midiOutShortMsg( __in HMIDIOUT hmo, __in DWORD dwMsg);
WINMMAPI MMRESULT WINAPI midiOutReset( IN HMIDIOUT hmo); WINMMAPI MMRESULT WINAPI midiOutLongMsg(__in HMIDIOUT hmo, __in_bcount(cbmh) LPM
WINMMAPI MMRESULT WINAPI midiOutCachePatches( IN HMIDIOUT hmo, IN UINT uBank, OU IDIHDR pmh, __in UINT cbmh);
T LPWORD pwpa, IN UINT fuCache); WINMMAPI MMRESULT WINAPI midiOutReset( __in HMIDIOUT hmo);
WINMMAPI MMRESULT WINAPI midiOutCacheDrumPatches( IN HMIDIOUT hmo, IN UINT uPatc WINMMAPI MMRESULT WINAPI midiOutCachePatches( __in HMIDIOUT hmo, __in UINT uBank
h, OUT LPWORD pwkya, IN UINT fuCache); , __in_ecount(MIDIPATCHSIZE) LPWORD pwpa, __in UINT fuCache);
WINMMAPI MMRESULT WINAPI midiOutGetID( IN HMIDIOUT hmo, OUT LPUINT puDeviceID); WINMMAPI MMRESULT WINAPI midiOutCacheDrumPatches( __in HMIDIOUT hmo, __in UINT u
Patch, __in_ecount(MIDIPATCHSIZE) LPWORD pwkya, __in UINT fuCache);
WINMMAPI MMRESULT WINAPI midiOutGetID( __in HMIDIOUT hmo, __out LPUINT puDeviceI
D);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiOutMessage( IN HMIDIOUT hmo, IN UINT uMsg, IN DWORD _PTR dw1, IN DWORD_PTR dw2); WINMMAPI MMRESULT WINAPI midiOutMessage( __in_opt HMIDIOUT hmo, __in UINT uMsg, __in_opt DWORD_PTR dw1, __in_opt DWORD_PTR dw2);
#else #else
DWORD WINAPI midiOutMessage(HMIDIOUT hmo, UINT uMsg, DWORD dw1, DWORD dw2); DWORD WINAPI midiOutMessage(HMIDIOUT hmo, UINT uMsg, DWORD dw1, DWORD dw2);
#endif #endif
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
WINMMAPI UINT WINAPI midiInGetNumDevs(void); WINMMAPI UINT WINAPI midiInGetNumDevs(void);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiInGetDevCapsA( IN UINT_PTR uDeviceID, OUT LPMIDIINC WINMMAPI MMRESULT WINAPI midiInGetDevCapsA( __in UINT_PTR uDeviceID, __out_bcoun
APSA pmic, IN UINT cbmic); t(cbmic) LPMIDIINCAPSA pmic, __in UINT cbmic);
WINMMAPI MMRESULT WINAPI midiInGetDevCapsW( IN UINT_PTR uDeviceID, OUT LPMIDIINC WINMMAPI MMRESULT WINAPI midiInGetDevCapsW( __in UINT_PTR uDeviceID, __out_bcoun
APSW pmic, IN UINT cbmic); t(cbmic) LPMIDIINCAPSW pmic, __in UINT cbmic);
#ifdef UNICODE #ifdef UNICODE
#define midiInGetDevCaps midiInGetDevCapsW #define midiInGetDevCaps midiInGetDevCapsW
#else #else
#define midiInGetDevCaps midiInGetDevCapsA #define midiInGetDevCaps midiInGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI MMRESULT WINAPI midiInGetErrorTextA( IN MMRESULT mmrError, OUT LPSTR ps WINMMAPI MMRESULT WINAPI midiInGetErrorTextA( __in MMRESULT mmrError, __out_ecou
zText, IN UINT cchText); nt(cchText) LPSTR pszText, __in UINT cchText);
WINMMAPI MMRESULT WINAPI midiInGetErrorTextW( IN MMRESULT mmrError, OUT LPWSTR p WINMMAPI MMRESULT WINAPI midiInGetErrorTextW( __in MMRESULT mmrError, __out_ecou
szText, IN UINT cchText); nt(cchText) LPWSTR pszText, __in UINT cchText);
#ifdef UNICODE #ifdef UNICODE
#define midiInGetErrorText midiInGetErrorTextW #define midiInGetErrorText midiInGetErrorTextW
#else #else
#define midiInGetErrorText midiInGetErrorTextA #define midiInGetErrorText midiInGetErrorTextA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI midiInGetDevCaps(UINT uDeviceID, LPMIDIINCAPS pmic, UINT cbmic); MMRESULT WINAPI midiInGetDevCaps(UINT uDeviceID, LPMIDIINCAPS pmic, UINT cbmic);
WINMMAPI MMRESULT WINAPI midiInGetErrorText(MMRESULT mmrError, LPSTR pszText, UI NT cchText); WINMMAPI MMRESULT WINAPI midiInGetErrorText(MMRESULT mmrError, __out_ecount(cchT ext) LPSTR pszText, UINT cchText);
#endif #endif
WINMMAPI MMRESULT WINAPI midiInOpen( OUT LPHMIDIIN phmi, IN UINT uDeviceID, WINMMAPI MMRESULT WINAPI midiInOpen( __out LPHMIDIIN phmi, __in UINT uDeviceID,
IN DWORD_PTR dwCallback, IN DWORD_PTR dwInstance, IN DWORD fdwOpen); __in_opt DWORD_PTR dwCallback, __in_opt DWORD_PTR dwInstance, __in DWORD
WINMMAPI MMRESULT WINAPI midiInClose( IN OUT HMIDIIN hmi); fdwOpen);
WINMMAPI MMRESULT WINAPI midiInPrepareHeader( IN HMIDIIN hmi, IN OUT LPMIDIHDR p WINMMAPI MMRESULT WINAPI midiInClose( __in HMIDIIN hmi);
mh, IN UINT cbmh); WINMMAPI MMRESULT WINAPI midiInPrepareHeader( __in HMIDIIN hmi, __inout_bcount(c
WINMMAPI MMRESULT WINAPI midiInUnprepareHeader( IN HMIDIIN hmi, IN OUT LPMIDIHDR bmh) LPMIDIHDR pmh, __in UINT cbmh);
pmh, IN UINT cbmh); WINMMAPI MMRESULT WINAPI midiInUnprepareHeader( __in HMIDIIN hmi, __inout_bcount
WINMMAPI MMRESULT WINAPI midiInAddBuffer( IN HMIDIIN hmi, IN LPMIDIHDR pmh, IN U (cbmh) LPMIDIHDR pmh, __in UINT cbmh);
INT cbmh); WINMMAPI MMRESULT WINAPI midiInAddBuffer( __in HMIDIIN hmi, __out_bcount(cbmh) L
WINMMAPI MMRESULT WINAPI midiInStart( IN HMIDIIN hmi); PMIDIHDR pmh, __in UINT cbmh);
WINMMAPI MMRESULT WINAPI midiInStop( IN HMIDIIN hmi); WINMMAPI MMRESULT WINAPI midiInStart( __in HMIDIIN hmi);
WINMMAPI MMRESULT WINAPI midiInReset( IN HMIDIIN hmi); WINMMAPI MMRESULT WINAPI midiInStop( __in HMIDIIN hmi);
WINMMAPI MMRESULT WINAPI midiInGetID( IN HMIDIIN hmi, OUT LPUINT puDeviceID); WINMMAPI MMRESULT WINAPI midiInReset( __in HMIDIIN hmi);
WINMMAPI MMRESULT WINAPI midiInGetID( __in HMIDIIN hmi, __out LPUINT puDeviceID)
;
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI midiInMessage( IN HMIDIIN hmi, IN UINT uMsg, IN DWORD_P TR dw1, IN DWORD_PTR dw2); WINMMAPI MMRESULT WINAPI midiInMessage( __in_opt HMIDIIN hmi, __in UINT uMsg, __ in_opt DWORD_PTR dw1, __in_opt DWORD_PTR dw2);
#else #else
DWORD WINAPI midiInMessage(HMIDIIN hmi, UINT uMsg, DWORD dw1, DWORD dw2); DWORD WINAPI midiInMessage(HMIDIIN hmi, UINT uMsg, DWORD dw1, DWORD dw2);
#endif #endif
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
#endif /* ifndef MMNOMIDI */ #endif /* ifndef MMNOMIDI */
#ifndef MMNOAUX #ifndef MMNOAUX
/**************************************************************************** /****************************************************************************
skipping to change at line 1482 skipping to change at line 1485
#define AUXCAPS_AUXIN 2 /* audio from auxiliary input jacks */ #define AUXCAPS_AUXIN 2 /* audio from auxiliary input jacks */
/* flags for dwSupport field in AUXCAPS structure */ /* flags for dwSupport field in AUXCAPS structure */
#define AUXCAPS_VOLUME 0x0001 /* supports volume control */ #define AUXCAPS_VOLUME 0x0001 /* supports volume control */
#define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */ #define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */
/* auxiliary audio function prototypes */ /* auxiliary audio function prototypes */
WINMMAPI UINT WINAPI auxGetNumDevs(void); WINMMAPI UINT WINAPI auxGetNumDevs(void);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI auxGetDevCapsA( IN UINT_PTR uDeviceID, OUT LPAUXCAPSA p WINMMAPI MMRESULT WINAPI auxGetDevCapsA( __in UINT_PTR uDeviceID, __out_bcount(c
ac, IN UINT cbac); bac) LPAUXCAPSA pac, __in UINT cbac);
WINMMAPI MMRESULT WINAPI auxGetDevCapsW( IN UINT_PTR uDeviceID, OUT LPAUXCAPSW p WINMMAPI MMRESULT WINAPI auxGetDevCapsW( __in UINT_PTR uDeviceID, __out_bcount(c
ac, IN UINT cbac); bac) LPAUXCAPSW pac, __in UINT cbac);
#ifdef UNICODE #ifdef UNICODE
#define auxGetDevCaps auxGetDevCapsW #define auxGetDevCaps auxGetDevCapsW
#else #else
#define auxGetDevCaps auxGetDevCapsA #define auxGetDevCaps auxGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI auxGetDevCaps(UINT uDeviceID, LPAUXCAPS pac, UINT cbac); MMRESULT WINAPI auxGetDevCaps(UINT uDeviceID, LPAUXCAPS pac, UINT cbac);
#endif #endif
WINMMAPI MMRESULT WINAPI auxSetVolume( IN UINT uDeviceID, IN DWORD dwVolume); WINMMAPI MMRESULT WINAPI auxSetVolume( __in UINT uDeviceID, __in DWORD dwVolume)
WINMMAPI MMRESULT WINAPI auxGetVolume( IN UINT uDeviceID, OUT LPDWORD pdwVolume) ;
; WINMMAPI MMRESULT WINAPI auxGetVolume( __in UINT uDeviceID, __out LPDWORD pdwVol
ume);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI auxOutMessage( IN UINT uDeviceID, IN UINT uMsg, IN DWOR D_PTR dw1, IN DWORD_PTR dw2); WINMMAPI MMRESULT WINAPI auxOutMessage( __in UINT uDeviceID, __in UINT uMsg, __i n_opt DWORD_PTR dw1, __in_opt DWORD_PTR dw2);
#else #else
DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD dw1, DWORD dw2); DWORD WINAPI auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD dw1, DWORD dw2);
#endif #endif
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
#endif /* ifndef MMNOAUX */ #endif /* ifndef MMNOAUX */
#ifndef MMNOMIXER #ifndef MMNOMIXER
/**************************************************************************** /****************************************************************************
skipping to change at line 1618 skipping to change at line 1621
WORD wPid; /* product id */ WORD wPid; /* product id */
VERSION vDriverVersion; /* version of the driver */ VERSION vDriverVersion; /* version of the driver */
char szPname[MAXPNAMELEN]; /* product name */ char szPname[MAXPNAMELEN]; /* product name */
DWORD fdwSupport; /* misc. support bits */ DWORD fdwSupport; /* misc. support bits */
DWORD cDestinations; /* count of destinations */ DWORD cDestinations; /* count of destinations */
} MIXERCAPS, *PMIXERCAPS, FAR *LPMIXERCAPS; } MIXERCAPS, *PMIXERCAPS, FAR *LPMIXERCAPS;
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI mixerGetDevCapsA( IN UINT_PTR uMxId, OUT LPMIXERCAPSA p WINMMAPI MMRESULT WINAPI mixerGetDevCapsA( __in UINT_PTR uMxId, __out_bcount(cbm
mxcaps, IN UINT cbmxcaps); xcaps) LPMIXERCAPSA pmxcaps, __in UINT cbmxcaps);
WINMMAPI MMRESULT WINAPI mixerGetDevCapsW( IN UINT_PTR uMxId, OUT LPMIXERCAPSW p WINMMAPI MMRESULT WINAPI mixerGetDevCapsW( __in UINT_PTR uMxId, __out_bcount(cbm
mxcaps, IN UINT cbmxcaps); xcaps) LPMIXERCAPSW pmxcaps, __in UINT cbmxcaps);
#ifdef UNICODE #ifdef UNICODE
#define mixerGetDevCaps mixerGetDevCapsW #define mixerGetDevCaps mixerGetDevCapsW
#else #else
#define mixerGetDevCaps mixerGetDevCapsA #define mixerGetDevCaps mixerGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI mixerGetDevCaps(UINT uMxId, LPMIXERCAPS pmxcaps, UINT cbmxcaps); MMRESULT WINAPI mixerGetDevCaps(UINT uMxId, LPMIXERCAPS pmxcaps, UINT cbmxcaps);
#endif #endif
WINMMAPI MMRESULT WINAPI mixerOpen( OUT LPHMIXER phmx, IN UINT uMxId, IN DWORD_P TR dwCallback, IN DWORD_PTR dwInstance, IN DWORD fdwOpen); WINMMAPI MMRESULT WINAPI mixerOpen( __out_opt LPHMIXER phmx, __in UINT uMxId, __ in_opt DWORD_PTR dwCallback, __in_opt DWORD_PTR dwInstance, __in DWORD fdwOpen);
WINMMAPI MMRESULT WINAPI mixerClose( IN OUT HMIXER hmx); WINMMAPI MMRESULT WINAPI mixerClose( __in HMIXER hmx);
WINMMAPI DWORD WINAPI mixerMessage( IN HMIXER hmx, IN UINT uMsg, IN DWORD_PTR dw Param1, IN DWORD_PTR dwParam2); WINMMAPI DWORD WINAPI mixerMessage( __in_opt HMIXER hmx, __in UINT uMsg, __in_op t DWORD_PTR dwParam1, __in_opt DWORD_PTR dwParam2);
#ifdef _WIN32 #ifdef _WIN32
typedef struct tagMIXERLINEA { typedef struct tagMIXERLINEA {
DWORD cbStruct; /* size of MIXERLINE structure */ DWORD cbStruct; /* size of MIXERLINE structure */
DWORD dwDestination; /* zero based destination index */ DWORD dwDestination; /* zero based destination index */
DWORD dwSource; /* zero based source index (if source) * / DWORD dwSource; /* zero based source index (if source) * /
DWORD dwLineID; /* unique line id for mixer device */ DWORD dwLineID; /* unique line id for mixer device */
DWORD fdwLine; /* state/information about line */ DWORD fdwLine; /* state/information about line */
DWORD_PTR dwUser; /* driver specific information */ DWORD_PTR dwUser; /* driver specific information */
skipping to change at line 1770 skipping to change at line 1773
/* */ /* */
#define MIXERLINE_TARGETTYPE_UNDEFINED 0 #define MIXERLINE_TARGETTYPE_UNDEFINED 0
#define MIXERLINE_TARGETTYPE_WAVEOUT 1 #define MIXERLINE_TARGETTYPE_WAVEOUT 1
#define MIXERLINE_TARGETTYPE_WAVEIN 2 #define MIXERLINE_TARGETTYPE_WAVEIN 2
#define MIXERLINE_TARGETTYPE_MIDIOUT 3 #define MIXERLINE_TARGETTYPE_MIDIOUT 3
#define MIXERLINE_TARGETTYPE_MIDIIN 4 #define MIXERLINE_TARGETTYPE_MIDIIN 4
#define MIXERLINE_TARGETTYPE_AUX 5 #define MIXERLINE_TARGETTYPE_AUX 5
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI mixerGetLineInfoA( IN HMIXEROBJ hmxobj, OUT LPMIXERLINE WINMMAPI MMRESULT WINAPI mixerGetLineInfoA( __in_opt HMIXEROBJ hmxobj, __out LPM
A pmxl, IN DWORD fdwInfo); IXERLINEA pmxl, __in DWORD fdwInfo);
WINMMAPI MMRESULT WINAPI mixerGetLineInfoW( IN HMIXEROBJ hmxobj, OUT LPMIXERLINE WINMMAPI MMRESULT WINAPI mixerGetLineInfoW( __in_opt HMIXEROBJ hmxobj, __out LPM
W pmxl, IN DWORD fdwInfo); IXERLINEW pmxl, __in DWORD fdwInfo);
#ifdef UNICODE #ifdef UNICODE
#define mixerGetLineInfo mixerGetLineInfoW #define mixerGetLineInfo mixerGetLineInfoW
#else #else
#define mixerGetLineInfo mixerGetLineInfoA #define mixerGetLineInfo mixerGetLineInfoA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI mixerGetLineInfo(HMIXEROBJ hmxobj, LPMIXERLINE pmxl, DWORD fdwIn fo); MMRESULT WINAPI mixerGetLineInfo(HMIXEROBJ hmxobj, LPMIXERLINE pmxl, DWORD fdwIn fo);
#endif #endif
#define MIXER_GETLINEINFOF_DESTINATION 0x00000000L #define MIXER_GETLINEINFOF_DESTINATION 0x00000000L
#define MIXER_GETLINEINFOF_SOURCE 0x00000001L #define MIXER_GETLINEINFOF_SOURCE 0x00000001L
#define MIXER_GETLINEINFOF_LINEID 0x00000002L #define MIXER_GETLINEINFOF_LINEID 0x00000002L
#define MIXER_GETLINEINFOF_COMPONENTTYPE 0x00000003L #define MIXER_GETLINEINFOF_COMPONENTTYPE 0x00000003L
#define MIXER_GETLINEINFOF_TARGETTYPE 0x00000004L #define MIXER_GETLINEINFOF_TARGETTYPE 0x00000004L
#define MIXER_GETLINEINFOF_QUERYMASK 0x0000000FL #define MIXER_GETLINEINFOF_QUERYMASK 0x0000000FL
WINMMAPI MMRESULT WINAPI mixerGetID( IN HMIXEROBJ hmxobj, OUT UINT FAR *puMxId, IN DWORD fdwId); WINMMAPI MMRESULT WINAPI mixerGetID( __in_opt HMIXEROBJ hmxobj, __out UINT FAR * puMxId, __in DWORD fdwId);
/* */ /* */
/* MIXERCONTROL */ /* MIXERCONTROL */
/* */ /* */
/* */ /* */
#ifdef _WIN32 #ifdef _WIN32
typedef struct tagMIXERCONTROLA { typedef struct tagMIXERCONTROLA {
DWORD cbStruct; /* size in bytes of MIXERCONTROL */ DWORD cbStruct; /* size in bytes of MIXERCONTROL */
DWORD dwControlID; /* unique control id for mixer device */ DWORD dwControlID; /* unique control id for mixer device */
skipping to change at line 2021 skipping to change at line 2024
DWORD cbmxctrl; /* size in bytes of _one_ MIXERCONTROL */ DWORD cbmxctrl; /* size in bytes of _one_ MIXERCONTROL */
LPMIXERCONTROL pamxctrl; /* pointer to first MIXERCONTROL array */ LPMIXERCONTROL pamxctrl; /* pointer to first MIXERCONTROL array */
} MIXERLINECONTROLS, *PMIXERLINECONTROLS, FAR *LPMIXERLINECONTROLS; } MIXERLINECONTROLS, *PMIXERLINECONTROLS, FAR *LPMIXERLINECONTROLS;
#endif #endif
/* */ /* */
/* */ /* */
/* */ /* */
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI mixerGetLineControlsA( IN HMIXEROBJ hmxobj, IN OUT LPMI WINMMAPI MMRESULT WINAPI mixerGetLineControlsA( __in_opt HMIXEROBJ hmxobj, __ino
XERLINECONTROLSA pmxlc, IN DWORD fdwControls); ut LPMIXERLINECONTROLSA pmxlc, __in DWORD fdwControls);
WINMMAPI MMRESULT WINAPI mixerGetLineControlsW( IN HMIXEROBJ hmxobj, IN OUT LPMI WINMMAPI MMRESULT WINAPI mixerGetLineControlsW( __in_opt HMIXEROBJ hmxobj, __ino
XERLINECONTROLSW pmxlc, IN DWORD fdwControls); ut LPMIXERLINECONTROLSW pmxlc, __in DWORD fdwControls);
#ifdef UNICODE #ifdef UNICODE
#define mixerGetLineControls mixerGetLineControlsW #define mixerGetLineControls mixerGetLineControlsW
#else #else
#define mixerGetLineControls mixerGetLineControlsA #define mixerGetLineControls mixerGetLineControlsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI mixerGetLineControls(HMIXEROBJ hmxobj, LPMIXERLINECONTROLS pmxlc , DWORD fdwControls); MMRESULT WINAPI mixerGetLineControls(HMIXEROBJ hmxobj, LPMIXERLINECONTROLS pmxlc , DWORD fdwControls);
#endif #endif
skipping to change at line 2109 skipping to change at line 2112
FAR *LPMIXERCONTROLDETAILS_SIGNED; FAR *LPMIXERCONTROLDETAILS_SIGNED;
typedef struct tMIXERCONTROLDETAILS_UNSIGNED { typedef struct tMIXERCONTROLDETAILS_UNSIGNED {
DWORD dwValue; DWORD dwValue;
} MIXERCONTROLDETAILS_UNSIGNED, } MIXERCONTROLDETAILS_UNSIGNED,
*PMIXERCONTROLDETAILS_UNSIGNED, *PMIXERCONTROLDETAILS_UNSIGNED,
FAR *LPMIXERCONTROLDETAILS_UNSIGNED; FAR *LPMIXERCONTROLDETAILS_UNSIGNED;
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI mixerGetControlDetailsA( IN HMIXEROBJ hmxobj, IN OUT LP WINMMAPI MMRESULT WINAPI mixerGetControlDetailsA( __in_opt HMIXEROBJ hmxobj, __i
MIXERCONTROLDETAILS pmxcd, IN DWORD fdwDetails); nout LPMIXERCONTROLDETAILS pmxcd, __in DWORD fdwDetails);
WINMMAPI MMRESULT WINAPI mixerGetControlDetailsW( IN HMIXEROBJ hmxobj, IN OUT LP WINMMAPI MMRESULT WINAPI mixerGetControlDetailsW( __in_opt HMIXEROBJ hmxobj, __i
MIXERCONTROLDETAILS pmxcd, IN DWORD fdwDetails); nout LPMIXERCONTROLDETAILS pmxcd, __in DWORD fdwDetails);
#ifdef UNICODE #ifdef UNICODE
#define mixerGetControlDetails mixerGetControlDetailsW #define mixerGetControlDetails mixerGetControlDetailsW
#else #else
#define mixerGetControlDetails mixerGetControlDetailsA #define mixerGetControlDetails mixerGetControlDetailsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI mixerGetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS p mxcd, DWORD fdwDetails); MMRESULT WINAPI mixerGetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS p mxcd, DWORD fdwDetails);
#endif #endif
#define MIXER_GETCONTROLDETAILSF_VALUE 0x00000000L #define MIXER_GETCONTROLDETAILSF_VALUE 0x00000000L
#define MIXER_GETCONTROLDETAILSF_LISTTEXT 0x00000001L #define MIXER_GETCONTROLDETAILSF_LISTTEXT 0x00000001L
#define MIXER_GETCONTROLDETAILSF_QUERYMASK 0x0000000FL #define MIXER_GETCONTROLDETAILSF_QUERYMASK 0x0000000FL
WINMMAPI MMRESULT WINAPI mixerSetControlDetails( IN HMIXEROBJ hmxobj, IN LPMIXER CONTROLDETAILS pmxcd, IN DWORD fdwDetails); WINMMAPI MMRESULT WINAPI mixerSetControlDetails( __in_opt HMIXEROBJ hmxobj, __in LPMIXERCONTROLDETAILS pmxcd, __in DWORD fdwDetails);
#define MIXER_SETCONTROLDETAILSF_VALUE 0x00000000L #define MIXER_SETCONTROLDETAILSF_VALUE 0x00000000L
#define MIXER_SETCONTROLDETAILSF_CUSTOM 0x00000001L #define MIXER_SETCONTROLDETAILSF_CUSTOM 0x00000001L
#define MIXER_SETCONTROLDETAILSF_QUERYMASK 0x0000000FL #define MIXER_SETCONTROLDETAILSF_QUERYMASK 0x0000000FL
#endif /* ifndef MMNOMIXER */ #endif /* ifndef MMNOMIXER */
#ifndef MMNOTIMER #ifndef MMNOTIMER
/**************************************************************************** /****************************************************************************
skipping to change at line 2175 skipping to change at line 2178
/* destroy it. */ /* destroy it. */
#endif // WINVER >= 0x0501 #endif // WINVER >= 0x0501
/* timer device capabilities data structure */ /* timer device capabilities data structure */
typedef struct timecaps_tag { typedef struct timecaps_tag {
UINT wPeriodMin; /* minimum period supported */ UINT wPeriodMin; /* minimum period supported */
UINT wPeriodMax; /* maximum period supported */ UINT wPeriodMax; /* maximum period supported */
} TIMECAPS, *PTIMECAPS, NEAR *NPTIMECAPS, FAR *LPTIMECAPS; } TIMECAPS, *PTIMECAPS, NEAR *NPTIMECAPS, FAR *LPTIMECAPS;
/* timer function prototypes */ /* timer function prototypes */
WINMMAPI MMRESULT WINAPI timeGetSystemTime( OUT LPMMTIME pmmt, IN UINT cbmmt); WINMMAPI MMRESULT WINAPI timeGetSystemTime( __out_bcount(cbmmt) LPMMTIME pmmt, _ _in UINT cbmmt);
WINMMAPI DWORD WINAPI timeGetTime(void); WINMMAPI DWORD WINAPI timeGetTime(void);
WINMMAPI MMRESULT WINAPI timeSetEvent( IN UINT uDelay, IN UINT uResolution, WINMMAPI MMRESULT WINAPI timeSetEvent( __in UINT uDelay, __in UINT uResolution,
IN LPTIMECALLBACK fptc, IN DWORD_PTR dwUser, IN UINT fuEvent); __in LPTIMECALLBACK fptc, __in DWORD_PTR dwUser, __in UINT fuEvent);
WINMMAPI MMRESULT WINAPI timeKillEvent( IN UINT uTimerID); WINMMAPI MMRESULT WINAPI timeKillEvent( __in UINT uTimerID);
WINMMAPI MMRESULT WINAPI timeGetDevCaps( OUT LPTIMECAPS ptc, IN UINT cbtc); WINMMAPI MMRESULT WINAPI timeGetDevCaps( __out_bcount(cbtc) LPTIMECAPS ptc, __in
WINMMAPI MMRESULT WINAPI timeBeginPeriod( IN UINT uPeriod); UINT cbtc);
WINMMAPI MMRESULT WINAPI timeEndPeriod( IN UINT uPeriod); WINMMAPI MMRESULT WINAPI timeBeginPeriod( __in UINT uPeriod);
WINMMAPI MMRESULT WINAPI timeEndPeriod( __in UINT uPeriod);
#endif /* ifndef MMNOTIMER */ #endif /* ifndef MMNOTIMER */
#ifndef MMNOJOY #ifndef MMNOJOY
/**************************************************************************** /****************************************************************************
Joystick support Joystick support
****************************************************************************/ ****************************************************************************/
skipping to change at line 2488 skipping to change at line 2491
DWORD dwPOV; /* point of view state */ DWORD dwPOV; /* point of view state */
DWORD dwReserved1; /* reserved for communication between winmm & d river */ DWORD dwReserved1; /* reserved for communication between winmm & d river */
DWORD dwReserved2; /* reserved for future expansion */ DWORD dwReserved2; /* reserved for future expansion */
} JOYINFOEX, *PJOYINFOEX, NEAR *NPJOYINFOEX, FAR *LPJOYINFOEX; } JOYINFOEX, *PJOYINFOEX, NEAR *NPJOYINFOEX, FAR *LPJOYINFOEX;
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
/* joystick function prototypes */ /* joystick function prototypes */
WINMMAPI UINT WINAPI joyGetNumDevs(void); WINMMAPI UINT WINAPI joyGetNumDevs(void);
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MMRESULT WINAPI joyGetDevCapsA( IN UINT_PTR uJoyID, OUT LPJOYCAPSA pjc, WINMMAPI MMRESULT WINAPI joyGetDevCapsA( __in UINT_PTR uJoyID, __out_bcount(cbjc
IN UINT cbjc); ) LPJOYCAPSA pjc, __in UINT cbjc);
WINMMAPI MMRESULT WINAPI joyGetDevCapsW( IN UINT_PTR uJoyID, OUT LPJOYCAPSW pjc, WINMMAPI MMRESULT WINAPI joyGetDevCapsW( __in UINT_PTR uJoyID, __out_bcount(cbjc
IN UINT cbjc); ) LPJOYCAPSW pjc, __in UINT cbjc);
#ifdef UNICODE #ifdef UNICODE
#define joyGetDevCaps joyGetDevCapsW #define joyGetDevCaps joyGetDevCapsW
#else #else
#define joyGetDevCaps joyGetDevCapsA #define joyGetDevCaps joyGetDevCapsA
#endif // !UNICODE #endif // !UNICODE
#else #else
MMRESULT WINAPI joyGetDevCaps(UINT uJoyID, LPJOYCAPS pjc, UINT cbjc); MMRESULT WINAPI joyGetDevCaps(UINT uJoyID, LPJOYCAPS pjc, UINT cbjc);
#endif #endif
WINMMAPI MMRESULT WINAPI joyGetPos( IN UINT uJoyID, OUT LPJOYINFO pji); WINMMAPI MMRESULT WINAPI joyGetPos( __in UINT uJoyID, __out LPJOYINFO pji);
#if(WINVER >= 0x0400) #if(WINVER >= 0x0400)
WINMMAPI MMRESULT WINAPI joyGetPosEx( IN UINT uJoyID, OUT LPJOYINFOEX pji); WINMMAPI MMRESULT WINAPI joyGetPosEx( __in UINT uJoyID, __out LPJOYINFOEX pji);
#endif /* WINVER >= 0x0400 */ #endif /* WINVER >= 0x0400 */
WINMMAPI MMRESULT WINAPI joyGetThreshold( IN UINT uJoyID, OUT LPUINT puThreshold WINMMAPI MMRESULT WINAPI joyGetThreshold( __in UINT uJoyID, __out LPUINT puThres
); hold);
WINMMAPI MMRESULT WINAPI joyReleaseCapture( IN UINT uJoyID); WINMMAPI MMRESULT WINAPI joyReleaseCapture( __in UINT uJoyID);
WINMMAPI MMRESULT WINAPI joySetCapture( IN HWND hwnd, IN UINT uJoyID, IN UINT uP WINMMAPI MMRESULT WINAPI joySetCapture( __in HWND hwnd, __in UINT uJoyID, __in U
eriod, INT uPeriod,
IN BOOL fChanged); __in BOOL fChanged);
WINMMAPI MMRESULT WINAPI joySetThreshold( IN UINT uJoyID, IN UINT uThreshold); WINMMAPI MMRESULT WINAPI joySetThreshold( __in UINT uJoyID, __in UINT uThreshold
);
#endif /* ifndef MMNOJOY */ #endif /* ifndef MMNOJOY */
#ifndef MMNOMMIO #ifndef MMNOMMIO
/**************************************************************************** /****************************************************************************
Multimedia File I/O support Multimedia File I/O support
****************************************************************************/ ****************************************************************************/
skipping to change at line 2669 skipping to change at line 2672
/* other constants */ /* other constants */
#define MMIO_DEFAULTBUFFER 8192 /* default buffer size */ #define MMIO_DEFAULTBUFFER 8192 /* default buffer size */
/* MMIO macros */ /* MMIO macros */
#define mmioFOURCC(ch0, ch1, ch2, ch3) MAKEFOURCC(ch0, ch1, ch2, ch3) #define mmioFOURCC(ch0, ch1, ch2, ch3) MAKEFOURCC(ch0, ch1, ch2, ch3)
/* MMIO function prototypes */ /* MMIO function prototypes */
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI FOURCC WINAPI mmioStringToFOURCCA( IN LPCSTR sz, IN UINT uFlags); WINMMAPI FOURCC WINAPI mmioStringToFOURCCA( LPCSTR sz, __in UINT uFlags);
WINMMAPI FOURCC WINAPI mmioStringToFOURCCW( IN LPCWSTR sz, IN UINT uFlags); WINMMAPI FOURCC WINAPI mmioStringToFOURCCW( LPCWSTR sz, __in UINT uFlags);
#ifdef UNICODE #ifdef UNICODE
#define mmioStringToFOURCC mmioStringToFOURCCW #define mmioStringToFOURCC mmioStringToFOURCCW
#else #else
#define mmioStringToFOURCC mmioStringToFOURCCA #define mmioStringToFOURCC mmioStringToFOURCCA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI LPMMIOPROC WINAPI mmioInstallIOProcA( IN FOURCC fccIOProc, IN LPMMIOPRO WINMMAPI LPMMIOPROC WINAPI mmioInstallIOProcA( __in FOURCC fccIOProc, __in_opt L
C pIOProc, IN DWORD dwFlags); PMMIOPROC pIOProc, __in DWORD dwFlags);
WINMMAPI LPMMIOPROC WINAPI mmioInstallIOProcW( IN FOURCC fccIOProc, IN LPMMIOPRO WINMMAPI LPMMIOPROC WINAPI mmioInstallIOProcW( __in FOURCC fccIOProc, __in_opt L
C pIOProc, IN DWORD dwFlags); PMMIOPROC pIOProc, __in DWORD dwFlags);
#ifdef UNICODE #ifdef UNICODE
#define mmioInstallIOProc mmioInstallIOProcW #define mmioInstallIOProc mmioInstallIOProcW
#else #else
#define mmioInstallIOProc mmioInstallIOProcA #define mmioInstallIOProc mmioInstallIOProcA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI HMMIO WINAPI mmioOpenA( IN OUT LPSTR pszFileName, IN OUT LPMMIOINFO pmm WINMMAPI HMMIO WINAPI mmioOpenA( __inout_bcount_opt(128) LPSTR pszFileName, __
ioinfo, IN DWORD fdwOpen); inout_opt LPMMIOINFO pmmioinfo, __in DWORD fdwOpen);
WINMMAPI HMMIO WINAPI mmioOpenW( IN OUT LPWSTR pszFileName, IN OUT LPMMIOINFO pm WINMMAPI HMMIO WINAPI mmioOpenW( __inout_bcount_opt(128) LPWSTR pszFileName, _
mioinfo, IN DWORD fdwOpen); _inout_opt LPMMIOINFO pmmioinfo, __in DWORD fdwOpen);
#ifdef UNICODE #ifdef UNICODE
#define mmioOpen mmioOpenW #define mmioOpen mmioOpenW
#else #else
#define mmioOpen mmioOpenA #define mmioOpen mmioOpenA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI MMRESULT WINAPI mmioRenameA( IN LPCSTR pszFileName, IN LPCSTR pszNewFil WINMMAPI MMRESULT WINAPI mmioRenameA( __in LPCSTR pszFileName, __in LPCSTR pszNe
eName, IN LPCMMIOINFO pmmioinfo, IN DWORD fdwRename); wFileName, __in_opt LPCMMIOINFO pmmioinfo, __in DWORD fdwRename);
WINMMAPI MMRESULT WINAPI mmioRenameW( IN LPCWSTR pszFileName, IN LPCWSTR pszNewF WINMMAPI MMRESULT WINAPI mmioRenameW( __in LPCWSTR pszFileName, __in LPCWSTR psz
ileName, IN LPCMMIOINFO pmmioinfo, IN DWORD fdwRename); NewFileName, __in_opt LPCMMIOINFO pmmioinfo, __in DWORD fdwRename);
#ifdef UNICODE #ifdef UNICODE
#define mmioRename mmioRenameW #define mmioRename mmioRenameW
#else #else
#define mmioRename mmioRenameA #define mmioRename mmioRenameA
#endif // !UNICODE #endif // !UNICODE
#else #else
FOURCC WINAPI mmioStringToFOURCC( LPCSTR sz, UINT uFlags); FOURCC WINAPI mmioStringToFOURCC( LPCSTR sz, UINT uFlags);
LPMMIOPROC WINAPI mmioInstallIOProc( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags); LPMMIOPROC WINAPI mmioInstallIOProc( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags);
HMMIO WINAPI mmioOpen(LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen); HMMIO WINAPI mmioOpen(__inout_opt LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
MMRESULT WINAPI mmioRename( IN LPCSTR pszFileName, IN LPCSTR pszNewFileName, IN const MMIOINFO FAR* pmmioinfo, IN DWORD fdwRename); MMRESULT WINAPI mmioRename( __in LPCSTR pszFileName, __in LPCSTR pszNewFileName, __in_opt const MMIOINFO FAR* pmmioinfo, __in DWORD fdwRename);
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
#endif #endif
WINMMAPI MMRESULT WINAPI mmioClose( IN HMMIO hmmio, IN UINT fuClose); WINMMAPI MMRESULT WINAPI mmioClose( __in HMMIO hmmio, __in UINT fuClose);
WINMMAPI LONG WINAPI mmioRead( IN HMMIO hmmio, OUT HPSTR pch, IN LONG cch); WINMMAPI LONG WINAPI mmioRead( __in HMMIO hmmio, __out_bcount(cch) HPSTR pch, __
WINMMAPI LONG WINAPI mmioWrite( IN HMMIO hmmio, IN const char _huge* pch, IN LON in LONG cch);
G cch); WINMMAPI LONG WINAPI mmioWrite( __in HMMIO hmmio, __out_bcount(cch) const char _
WINMMAPI LONG WINAPI mmioSeek( IN HMMIO hmmio, IN LONG lOffset, IN int iOrigin); huge* pch, __in LONG cch);
WINMMAPI MMRESULT WINAPI mmioGetInfo( IN HMMIO hmmio, OUT LPMMIOINFO pmmioinfo, WINMMAPI LONG WINAPI mmioSeek( __in HMMIO hmmio, __in LONG lOffset, __in int iOr
IN UINT fuInfo); igin);
WINMMAPI MMRESULT WINAPI mmioSetInfo( IN HMMIO hmmio, IN LPCMMIOINFO pmmioinfo, WINMMAPI MMRESULT WINAPI mmioGetInfo( __in HMMIO hmmio, __out LPMMIOINFO pmmioin
IN UINT fuInfo); fo, __in UINT fuInfo);
WINMMAPI MMRESULT WINAPI mmioSetBuffer( IN HMMIO hmmio, IN LPSTR pchBuffer, IN L WINMMAPI MMRESULT WINAPI mmioSetInfo( __in HMMIO hmmio, __in LPCMMIOINFO pmmioin
ONG cchBuffer, fo, __in UINT fuInfo);
IN UINT fuBuffer); WINMMAPI MMRESULT WINAPI mmioSetBuffer( __in HMMIO hmmio, __out_ecount_opt(cchBu
WINMMAPI MMRESULT WINAPI mmioFlush( IN HMMIO hmmio, IN UINT fuFlush); ffer) LPSTR pchBuffer, __in LONG cchBuffer,
WINMMAPI MMRESULT WINAPI mmioAdvance( IN HMMIO hmmio, IN OUT LPMMIOINFO pmmioinf __in UINT fuBuffer);
o, IN UINT fuAdvance); WINMMAPI MMRESULT WINAPI mmioFlush( __in HMMIO hmmio, __in UINT fuFlush);
WINMMAPI LRESULT WINAPI mmioSendMessage( IN HMMIO hmmio, IN UINT uMsg, WINMMAPI MMRESULT WINAPI mmioAdvance( __in HMMIO hmmio, __in_opt LPMMIOINFO pmmi
IN LPARAM lParam1, IN LPARAM lParam2); oinfo, __in UINT fuAdvance);
WINMMAPI MMRESULT WINAPI mmioDescend( IN HMMIO hmmio, IN OUT LPMMCKINFO pmmcki, WINMMAPI LRESULT WINAPI mmioSendMessage( __in HMMIO hmmio, __in UINT uMsg,
IN const MMCKINFO FAR* pmmckiParent, IN UINT fuDescend); __in_opt LPARAM lParam1, __in_opt LPARAM lParam2);
WINMMAPI MMRESULT WINAPI mmioAscend( IN HMMIO hmmio, IN LPMMCKINFO pmmcki, IN UI WINMMAPI MMRESULT WINAPI mmioDescend( __in HMMIO hmmio, __inout LPMMCKINFO pmmck
NT fuAscend); i,
WINMMAPI MMRESULT WINAPI mmioCreateChunk(IN HMMIO hmmio, IN LPMMCKINFO pmmcki, I __in_opt const MMCKINFO FAR* pmmckiParent, __in UINT fuDescend);
N UINT fuCreate); WINMMAPI MMRESULT WINAPI mmioAscend( __in HMMIO hmmio, __in LPMMCKINFO pmmcki, _
_in UINT fuAscend);
WINMMAPI MMRESULT WINAPI mmioCreateChunk(__in HMMIO hmmio, __in LPMMCKINFO pmmck
i, __in UINT fuCreate);
#endif /* ifndef MMNOMMIO */ #endif /* ifndef MMNOMMIO */
#ifndef MMNOMCI #ifndef MMNOMCI
/**************************************************************************** /****************************************************************************
MCI support MCI support
****************************************************************************/ ****************************************************************************/
skipping to change at line 2747 skipping to change at line 2750
#ifndef _MCIDEVICEID_ /* Same with MCIDEVICEID */ #ifndef _MCIDEVICEID_ /* Same with MCIDEVICEID */
#define _MCIDEVICEID_ #define _MCIDEVICEID_
typedef UINT MCIDEVICEID; /* MCI device ID type */ typedef UINT MCIDEVICEID; /* MCI device ID type */
#endif #endif
typedef UINT (CALLBACK *YIELDPROC)(MCIDEVICEID mciId, DWORD dwYieldData); typedef UINT (CALLBACK *YIELDPROC)(MCIDEVICEID mciId, DWORD dwYieldData);
/* MCI function prototypes */ /* MCI function prototypes */
#ifdef _WIN32 #ifdef _WIN32
WINMMAPI MCIERROR WINAPI mciSendCommandA( IN MCIDEVICEID mciId, IN UINT uMsg, IN WINMMAPI MCIERROR WINAPI mciSendCommandA( __in MCIDEVICEID mciId, __in UINT uMsg
DWORD_PTR dwParam1, IN DWORD_PTR dwParam2); , __in_opt DWORD_PTR dwParam1, __in_opt DWORD_PTR dwParam2);
WINMMAPI MCIERROR WINAPI mciSendCommandW( IN MCIDEVICEID mciId, IN UINT uMsg, IN WINMMAPI MCIERROR WINAPI mciSendCommandW( __in MCIDEVICEID mciId, __in UINT uMsg
DWORD_PTR dwParam1, IN DWORD_PTR dwParam2); , __in_opt DWORD_PTR dwParam1, __in_opt DWORD_PTR dwParam2);
#ifdef UNICODE #ifdef UNICODE
#define mciSendCommand mciSendCommandW #define mciSendCommand mciSendCommandW
#else #else
#define mciSendCommand mciSendCommandA #define mciSendCommand mciSendCommandA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI MCIERROR WINAPI mciSendStringA( IN LPCSTR lpstrCommand, OUT LPSTR lpst WINMMAPI MCIERROR WINAPI mciSendStringA( __in LPCSTR lpstrCommand, __out_ecount
rReturnString, IN UINT uReturnLength, IN HWND hwndCallback); _opt(uReturnLength) LPSTR lpstrReturnString, __in UINT uReturnLength, __in_opt H
WINMMAPI MCIERROR WINAPI mciSendStringW( IN LPCWSTR lpstrCommand, OUT LPWSTR lp WND hwndCallback);
strReturnString, IN UINT uReturnLength, IN HWND hwndCallback); WINMMAPI MCIERROR WINAPI mciSendStringW( __in LPCWSTR lpstrCommand, __out_ecoun
t_opt(uReturnLength) LPWSTR lpstrReturnString, __in UINT uReturnLength, __in_opt
HWND hwndCallback);
#ifdef UNICODE #ifdef UNICODE
#define mciSendString mciSendStringW #define mciSendString mciSendStringW
#else #else
#define mciSendString mciSendStringA #define mciSendString mciSendStringA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDA( IN LPCSTR pszDevice); WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDA( __in LPCSTR pszDevice);
WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDW( IN LPCWSTR pszDevice); WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDW( __in LPCWSTR pszDevice);
#ifdef UNICODE #ifdef UNICODE
#define mciGetDeviceID mciGetDeviceIDW #define mciGetDeviceID mciGetDeviceIDW
#else #else
#define mciGetDeviceID mciGetDeviceIDA #define mciGetDeviceID mciGetDeviceIDA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA( IN DWORD dwElementID, WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA( __in DWORD dwElementID
IN LPCSTR lpstrType ); , __in LPCSTR lpstrType );
WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW( IN DWORD dwElementID, WINMMAPI MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW( __in DWORD dwElementID
IN LPCWSTR lpstrType ); , __in LPCWSTR lpstrType );
#ifdef UNICODE #ifdef UNICODE
#define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDW #define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDW
#else #else
#define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDA #define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDA
#endif // !UNICODE #endif // !UNICODE
WINMMAPI BOOL WINAPI mciGetErrorStringA( IN MCIERROR mcierr, OUT LPSTR pszText, WINMMAPI BOOL WINAPI mciGetErrorStringA( __in MCIERROR mcierr, __out_ecount(cchT
IN UINT cchText); ext) LPSTR pszText, __in UINT cchText);
WINMMAPI BOOL WINAPI mciGetErrorStringW( IN MCIERROR mcierr, OUT LPWSTR pszText, WINMMAPI BOOL WINAPI mciGetErrorStringW( __in MCIERROR mcierr, __out_ecount(cchT
IN UINT cchText); ext) LPWSTR pszText, __in UINT cchText);
#ifdef UNICODE #ifdef UNICODE
#define mciGetErrorString mciGetErrorStringW #define mciGetErrorString mciGetErrorStringW
#else #else
#define mciGetErrorString mciGetErrorStringA #define mciGetErrorString mciGetErrorStringA
#endif // !UNICODE #endif // !UNICODE
#else #else
MCIERROR WINAPI mciSendCommand(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWO RD dwParam2); MCIERROR WINAPI mciSendCommand(MCIDEVICEID mciId, UINT uMsg, DWORD dwParam1, DWO RD dwParam2);
MCIERROR WINAPI mciSendString(LPCSTR lpstrCommand, LPSTR lpstrReturnString, UIN T uReturnLength, HWND hwndCallback); MCIERROR WINAPI mciSendString(LPCSTR lpstrCommand, LPSTR lpstrReturnString, UIN T uReturnLength, HWND hwndCallback);
MCIDEVICEID WINAPI mciGetDeviceID(LPCSTR pszDevice); MCIDEVICEID WINAPI mciGetDeviceID(LPCSTR pszDevice);
BOOL WINAPI mciGetErrorString(MCIERROR mcierr, LPSTR pszText, UINT cchText); BOOL WINAPI mciGetErrorString(MCIERROR mcierr, LPSTR pszText, UINT cchText);
#endif #endif
WINMMAPI BOOL WINAPI mciSetYieldProc( IN MCIDEVICEID mciId, IN YIELDPROC fpYield WINMMAPI BOOL WINAPI mciSetYieldProc( __in MCIDEVICEID mciId, __in_opt YIELDPROC
Proc, fpYieldProc,
IN DWORD dwYieldData); __in DWORD dwYieldData);
#if (WINVER >= 0x030a) #if (WINVER >= 0x030a)
WINMMAPI HTASK WINAPI mciGetCreatorTask( IN MCIDEVICEID mciId); WINMMAPI HTASK WINAPI mciGetCreatorTask( __in MCIDEVICEID mciId);
WINMMAPI YIELDPROC WINAPI mciGetYieldProc( IN MCIDEVICEID mciId, IN LPDWORD pdwY WINMMAPI YIELDPROC WINAPI mciGetYieldProc( __in MCIDEVICEID mciId, __in LPDWORD
ieldData); pdwYieldData);
#endif /* ifdef WINVER >= 0x030a */ #endif /* ifdef WINVER >= 0x030a */
#if (WINVER < 0x030a) #if (WINVER < 0x030a)
WINMMAPI BOOL WINAPI mciExecute(LPCSTR pszCommand); WINMMAPI BOOL WINAPI mciExecute(LPCSTR pszCommand);
#endif /* ifdef WINVER < 0x030a */ #endif /* ifdef WINVER < 0x030a */
/* MCI error return values */ /* MCI error return values */
#define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1) #define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
#define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3) #define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
#define MCIERR_UNRECOGNIZED_COMMAND (MCIERR_BASE + 5) #define MCIERR_UNRECOGNIZED_COMMAND (MCIERR_BASE + 5)
skipping to change at line 3456 skipping to change at line 3459
/* flags for the dwFlags parameter of MCI_GETDEVCAPS command message */ /* flags for the dwFlags parameter of MCI_GETDEVCAPS command message */
#define MCI_WAVE_GETDEVCAPS_INPUTS 0x00004001L #define MCI_WAVE_GETDEVCAPS_INPUTS 0x00004001L
#define MCI_WAVE_GETDEVCAPS_OUTPUTS 0x00004002L #define MCI_WAVE_GETDEVCAPS_OUTPUTS 0x00004002L
/* parameter block for MCI_OPEN command message */ /* parameter block for MCI_OPEN command message */
#ifdef _WIN32 #ifdef _WIN32
typedef struct tagMCI_WAVE_OPEN_PARMSA { typedef struct tagMCI_WAVE_OPEN_PARMSA {
DWORD_PTR dwCallback; DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID; MCIDEVICEID wDeviceID;
LPCSTR lpstrDeviceType; LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName; LPCSTR lpstrElementName;
LPCSTR lpstrAlias; LPCSTR lpstrAlias;
DWORD dwBufferSeconds; DWORD dwBufferSeconds;
} MCI_WAVE_OPEN_PARMSA, *PMCI_WAVE_OPEN_PARMSA, *LPMCI_WAVE_OPEN_PARMSA; } MCI_WAVE_OPEN_PARMSA, *PMCI_WAVE_OPEN_PARMSA, *LPMCI_WAVE_OPEN_PARMSA;
typedef struct tagMCI_WAVE_OPEN_PARMSW { typedef struct tagMCI_WAVE_OPEN_PARMSW {
DWORD_PTR dwCallback; DWORD_PTR dwCallback;
MCIDEVICEID wDeviceID; MCIDEVICEID wDeviceID;
LPCWSTR lpstrDeviceType; LPCWSTR lpstrDeviceType;
LPCWSTR lpstrElementName; LPCWSTR lpstrElementName;
LPCWSTR lpstrAlias; LPCWSTR lpstrAlias;
DWORD dwBufferSeconds; DWORD dwBufferSeconds;
} MCI_WAVE_OPEN_PARMSW, *PMCI_WAVE_OPEN_PARMSW, *LPMCI_WAVE_OPEN_PARMSW; } MCI_WAVE_OPEN_PARMSW, *PMCI_WAVE_OPEN_PARMSW, *LPMCI_WAVE_OPEN_PARMSW;
#ifdef UNICODE #ifdef UNICODE
typedef MCI_WAVE_OPEN_PARMSW MCI_WAVE_OPEN_PARMS; typedef MCI_WAVE_OPEN_PARMSW MCI_WAVE_OPEN_PARMS;
typedef PMCI_WAVE_OPEN_PARMSW PMCI_WAVE_OPEN_PARMS; typedef PMCI_WAVE_OPEN_PARMSW PMCI_WAVE_OPEN_PARMS;
typedef LPMCI_WAVE_OPEN_PARMSW LPMCI_WAVE_OPEN_PARMS; typedef LPMCI_WAVE_OPEN_PARMSW LPMCI_WAVE_OPEN_PARMS;
#else #else
typedef MCI_WAVE_OPEN_PARMSA MCI_WAVE_OPEN_PARMS; typedef MCI_WAVE_OPEN_PARMSA MCI_WAVE_OPEN_PARMS;
typedef PMCI_WAVE_OPEN_PARMSA PMCI_WAVE_OPEN_PARMS; typedef PMCI_WAVE_OPEN_PARMSA PMCI_WAVE_OPEN_PARMS;
typedef LPMCI_WAVE_OPEN_PARMSA LPMCI_WAVE_OPEN_PARMS; typedef LPMCI_WAVE_OPEN_PARMSA LPMCI_WAVE_OPEN_PARMS;
 End of changes. 66 change blocks. 
266 lines changed or deleted 290 lines changed or added

This html diff was produced by rfcdiff 1.41.