[PSDK]

* Annotate mmsystem.h.

svn path=/trunk/; revision=59696

reactos/include/psdk/mmsystem.h

@@ -1702,194 +1702,711 @@ typedef struct tagMCI_WAVE_SET_PARMS {
 	WORD wReserved5;
 } MCI_WAVE_SET_PARMS,*PMCI_WAVE_SET_PARMS,*LPMCI_WAVE_SET_PARMS;
 
-LRESULT WINAPI CloseDriver(HDRVR,LPARAM,LPARAM);
+LRESULT WINAPI CloseDriver(_In_ HDRVR, _In_ LPARAM, _In_ LPARAM);
-HDRVR WINAPI OpenDriver(LPCWSTR,LPCWSTR,LPARAM);
+HDRVR WINAPI OpenDriver(_In_ LPCWSTR, _In_ LPCWSTR, _In_ LPARAM);
-LRESULT WINAPI SendDriverMessage(HDRVR,UINT,LPARAM,LPARAM);
+LRESULT WINAPI SendDriverMessage(_In_ HDRVR, _In_ UINT, _In_ LPARAM, _In_ LPARAM);
-HMODULE WINAPI DrvGetModuleHandle(HDRVR);
+HMODULE WINAPI DrvGetModuleHandle(_In_ HDRVR);
-HMODULE WINAPI GetDriverModuleHandle(HDRVR);
+HMODULE WINAPI GetDriverModuleHandle(_In_ HDRVR);
-LRESULT WINAPI DefDriverProc(DWORD_PTR,HDRVR,UINT,LPARAM,LPARAM);
+
+LRESULT
+WINAPI
+DefDriverProc(
+  _In_ DWORD_PTR,
+  _In_ HDRVR,
+  _In_ UINT,
+  _In_ LPARAM,
+  _In_ LPARAM);
+
 UINT WINAPI mmsystemGetVersion(void);
 #define OutputDebugStr OutputDebugString
-BOOL WINAPI sndPlaySoundA(LPCSTR,UINT);
+BOOL WINAPI sndPlaySoundA(_In_opt_ LPCSTR, _In_ UINT);
-BOOL WINAPI sndPlaySoundW(LPCWSTR,UINT);
+BOOL WINAPI sndPlaySoundW(_In_opt_ LPCWSTR, _In_ UINT);
-BOOL WINAPI PlaySoundA(LPCSTR,HMODULE,DWORD);
+BOOL WINAPI PlaySoundA(_In_opt_ LPCSTR, _In_opt_ HMODULE, _In_ DWORD);
-BOOL WINAPI PlaySoundW(LPCWSTR,HMODULE,DWORD);
+BOOL WINAPI PlaySoundW(_In_opt_ LPCWSTR, _In_opt_ HMODULE, _In_ DWORD);
 UINT WINAPI waveOutGetNumDevs(void);
-MMRESULT WINAPI waveOutGetDevCapsA(UINT_PTR,LPWAVEOUTCAPSA,UINT);
+MMRESULT WINAPI waveOutGetDevCapsA(_In_ UINT_PTR, _Out_ LPWAVEOUTCAPSA, _In_ UINT);
-MMRESULT WINAPI waveOutGetDevCapsW(UINT_PTR,LPWAVEOUTCAPSW,UINT);
+MMRESULT WINAPI waveOutGetDevCapsW(_In_ UINT_PTR, _Out_ LPWAVEOUTCAPSW, _In_ UINT);
-MMRESULT WINAPI waveOutGetVolume(HWAVEOUT,PDWORD);
+MMRESULT WINAPI waveOutGetVolume(_In_opt_ HWAVEOUT, _Out_ PDWORD);
-MMRESULT WINAPI waveOutSetVolume(HWAVEOUT,DWORD);
+MMRESULT WINAPI waveOutSetVolume(_In_opt_ HWAVEOUT, _In_ DWORD);
-MMRESULT WINAPI waveOutGetErrorTextA(MMRESULT,LPSTR,UINT);
+
-MMRESULT WINAPI waveOutGetErrorTextW(MMRESULT,LPWSTR,UINT);
+MMRESULT
-MMRESULT WINAPI waveOutOpen(LPHWAVEOUT,UINT,LPCWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
+WINAPI
-MMRESULT WINAPI waveOutClose(HWAVEOUT);
+waveOutGetErrorTextA(
-MMRESULT WINAPI waveOutPrepareHeader(HWAVEOUT,LPWAVEHDR,UINT);
+  _In_ MMRESULT mmrError,
-MMRESULT WINAPI waveOutUnprepareHeader(HWAVEOUT,LPWAVEHDR,UINT);
+  _Out_writes_(cchText) LPSTR pszText,
-MMRESULT WINAPI waveOutWrite(HWAVEOUT,LPWAVEHDR,UINT);
+  _In_ UINT cchText);
-MMRESULT WINAPI waveOutPause(HWAVEOUT);
+
-MMRESULT WINAPI waveOutRestart(HWAVEOUT);
+MMRESULT
-MMRESULT WINAPI waveOutReset(HWAVEOUT);
+WINAPI
-MMRESULT WINAPI waveOutBreakLoop(HWAVEOUT);
+waveOutGetErrorTextW(
-MMRESULT WINAPI waveOutGetPosition(HWAVEOUT,LPMMTIME,UINT);
+  _In_ MMRESULT mmrError,
-MMRESULT WINAPI waveOutGetPitch(HWAVEOUT,PDWORD);
+  _Out_writes_(cchText) LPWSTR pszText,
-MMRESULT WINAPI waveOutSetPitch(HWAVEOUT,DWORD);
+  _In_ UINT cchText);
-MMRESULT WINAPI waveOutGetPlaybackRate(HWAVEOUT,PDWORD);
+
-MMRESULT WINAPI waveOutSetPlaybackRate(HWAVEOUT,DWORD);
+MMRESULT
-MMRESULT WINAPI waveOutGetID(HWAVEOUT,LPUINT);
+WINAPI
+waveOutOpen(
+  _Out_opt_ LPHWAVEOUT,
+  _In_ UINT,
+  _In_ LPCWAVEFORMATEX,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR,
+  _In_ DWORD);
+
+MMRESULT WINAPI waveOutClose(_In_ HWAVEOUT);
+
+MMRESULT
+WINAPI
+waveOutPrepareHeader(
+  _In_ HWAVEOUT hwo,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT
+WINAPI
+waveOutUnprepareHeader(
+  _In_ HWAVEOUT hwo,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT
+WINAPI
+waveOutWrite(
+  _In_ HWAVEOUT hwo,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT WINAPI waveOutPause(_In_ HWAVEOUT);
+MMRESULT WINAPI waveOutRestart(_In_ HWAVEOUT);
+MMRESULT WINAPI waveOutReset(_In_ HWAVEOUT);
+MMRESULT WINAPI waveOutBreakLoop(_In_ HWAVEOUT);
+
+MMRESULT
+WINAPI
+waveOutGetPosition(
+  _In_ HWAVEOUT hwo,
+  _Inout_updates_bytes_(cbmmt) LPMMTIME pmmt,
+  _In_ UINT cbmmt);
+
+MMRESULT WINAPI waveOutGetPitch(_In_ HWAVEOUT, _Out_ PDWORD);
+MMRESULT WINAPI waveOutSetPitch(_In_ HWAVEOUT, _In_ DWORD);
+MMRESULT WINAPI waveOutGetPlaybackRate(_In_ HWAVEOUT, _Out_ PDWORD);
+MMRESULT WINAPI waveOutSetPlaybackRate(_In_ HWAVEOUT, _In_ DWORD);
+MMRESULT WINAPI waveOutGetID(_In_ HWAVEOUT, _Out_ LPUINT);
+
 #if (WINVER >= 0x030a)
 #ifdef _WIN32
-MMRESULT WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD_PTR,DWORD_PTR);
+MMRESULT WINAPI waveOutMessage(_In_opt_ HWAVEOUT, _In_ UINT, _In_ DWORD_PTR, _In_ DWORD_PTR);
 #else
 DWORD WINAPI waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD);
 #endif
 #endif
+
 UINT WINAPI waveInGetNumDevs(void);
-MMRESULT WINAPI waveInGetDevCapsA(UINT_PTR,LPWAVEINCAPSA,UINT);
+
-MMRESULT WINAPI waveInGetDevCapsW(UINT_PTR,LPWAVEINCAPSW,UINT);
+MMRESULT
-MMRESULT WINAPI waveInGetErrorTextA(MMRESULT,LPSTR,UINT);
+WINAPI
-MMRESULT WINAPI waveInGetErrorTextW(MMRESULT,LPWSTR,UINT);
+waveInGetDevCapsA(
-MMRESULT WINAPI waveInOpen(LPHWAVEIN,UINT,LPCWAVEFORMATEX,DWORD_PTR,DWORD_PTR,DWORD);
+  _In_ UINT_PTR uDeviceID,
-MMRESULT WINAPI waveInClose(HWAVEIN);
+  _Out_writes_bytes_(cbwic) LPWAVEINCAPSA pwic,
-MMRESULT WINAPI waveInPrepareHeader(HWAVEIN,LPWAVEHDR,UINT);
+  _In_ UINT cbwic);
-MMRESULT WINAPI waveInUnprepareHeader(HWAVEIN,LPWAVEHDR,UINT);
+
-MMRESULT WINAPI waveInAddBuffer(HWAVEIN,LPWAVEHDR,UINT);
+MMRESULT
-MMRESULT WINAPI waveInStart(HWAVEIN);
+WINAPI
-MMRESULT WINAPI waveInStop(HWAVEIN);
+waveInGetDevCapsW(
-MMRESULT WINAPI waveInReset(HWAVEIN);
+  _In_ UINT_PTR uDeviceID,
-MMRESULT WINAPI waveInGetPosition(HWAVEIN,LPMMTIME,UINT);
+  _Out_writes_bytes_(cbwic) LPWAVEINCAPSW pwic,
-MMRESULT WINAPI waveInGetID(HWAVEIN,LPUINT);
+  _In_ UINT cbwic);
+
+MMRESULT
+WINAPI
+waveInGetErrorTextA(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+waveInGetErrorTextW(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPWSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+waveInOpen(
+  _Out_opt_ LPHWAVEIN,
+  _In_ UINT,
+  _In_ LPCWAVEFORMATEX,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR,
+  _In_ DWORD);
+
+MMRESULT WINAPI waveInClose(_In_ HWAVEIN);
+
+MMRESULT
+WINAPI
+waveInPrepareHeader(
+  _In_ HWAVEIN hwi,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT
+WINAPI
+waveInUnprepareHeader(
+  _In_ HWAVEIN hwi,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT
+WINAPI
+waveInAddBuffer(
+  _In_ HWAVEIN hwi,
+  _Inout_updates_bytes_(cbwh) LPWAVEHDR pwh,
+  _In_ UINT cbwh);
+
+MMRESULT WINAPI waveInStart(_In_ HWAVEIN);
+MMRESULT WINAPI waveInStop(_In_ HWAVEIN);
+MMRESULT WINAPI waveInReset(_In_ HWAVEIN);
+
+MMRESULT
+WINAPI
+waveInGetPosition(
+  _In_ HWAVEIN hwi,
+  _Inout_updates_bytes_(cbmmt) LPMMTIME pmmt,
+  _In_ UINT cbmmt);
+
+MMRESULT WINAPI waveInGetID(_In_ HWAVEIN, _In_ LPUINT);
+
 #if (WINVER >= 0x030a)
 #ifdef _WIN32
-MMRESULT WINAPI waveInMessage(HWAVEIN,UINT,DWORD_PTR,DWORD_PTR);
+MMRESULT WINAPI waveInMessage(_In_opt_ HWAVEIN, _In_ UINT, _In_opt_ DWORD_PTR, _In_opt_ DWORD_PTR);
 #else
 DWORD WINAPI waveInMessage(HWAVEIN,UINT,DWORD,DWORD);
 #endif
 #endif
 UINT WINAPI midiOutGetNumDevs(void);
-MMRESULT WINAPI midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD_PTR,DWORD_PTR,DWORD);
+
-MMRESULT WINAPI midiStreamClose(HMIDISTRM);
+MMRESULT
-MMRESULT WINAPI midiStreamProperty(HMIDISTRM,LPBYTE,DWORD);
+WINAPI
-MMRESULT WINAPI midiStreamPosition(HMIDISTRM,LPMMTIME,UINT);
+midiStreamOpen(
-MMRESULT WINAPI midiStreamOut(HMIDISTRM,LPMIDIHDR,UINT);
+  _Out_ LPHMIDISTRM phms,
-MMRESULT WINAPI midiStreamPause(HMIDISTRM);
+  _Inout_updates_(cMidi) LPUINT puDeviceID,
-MMRESULT WINAPI midiStreamRestart(HMIDISTRM);
+  _In_ DWORD cMidi,
-MMRESULT WINAPI midiStreamStop(HMIDISTRM);
+  _In_opt_ DWORD_PTR dwCallback,
-MMRESULT WINAPI midiConnect(HMIDI,HMIDIOUT,PVOID);
+  _In_opt_ DWORD_PTR dwInstance,
-MMRESULT WINAPI midiDisconnect(HMIDI,HMIDIOUT,PVOID);
+  _In_ DWORD fdwOpen);
-MMRESULT WINAPI midiOutGetDevCapsA(UINT_PTR,LPMIDIOUTCAPSA,UINT);
+
-MMRESULT WINAPI midiOutGetDevCapsW(UINT_PTR,LPMIDIOUTCAPSW,UINT);
+MMRESULT WINAPI midiStreamClose(_In_ HMIDISTRM);
-MMRESULT WINAPI midiOutGetVolume(HMIDIOUT,PDWORD);
+
-MMRESULT WINAPI midiOutSetVolume(HMIDIOUT,DWORD);
+MMRESULT
-MMRESULT WINAPI midiOutGetErrorTextA(MMRESULT,LPSTR,UINT);
+WINAPI
-MMRESULT WINAPI midiOutGetErrorTextW(MMRESULT,LPWSTR,UINT);
+midiStreamProperty(
-MMRESULT WINAPI midiOutOpen(LPHMIDIOUT,UINT,DWORD_PTR,DWORD_PTR,DWORD);
+  _In_ HMIDISTRM hms,
-MMRESULT WINAPI midiOutClose(HMIDIOUT);
+  _Inout_updates_bytes_(sizeof(DWORD) + sizeof(DWORD)) LPBYTE lppropdata,
-MMRESULT WINAPI midiOutPrepareHeader(HMIDIOUT,LPMIDIHDR,UINT);
+  _In_ DWORD dwProperty);
-MMRESULT WINAPI midiOutUnprepareHeader(HMIDIOUT,LPMIDIHDR,UINT);
+
-MMRESULT WINAPI midiOutShortMsg(HMIDIOUT,DWORD);
+MMRESULT
-MMRESULT WINAPI midiOutLongMsg(HMIDIOUT,LPMIDIHDR,UINT);
+WINAPI
-MMRESULT WINAPI midiOutReset(HMIDIOUT);
+midiStreamPosition(
-MMRESULT WINAPI midiOutCachePatches(HMIDIOUT,UINT,LPWORD,UINT);
+  _In_ HMIDISTRM hms,
-MMRESULT WINAPI midiOutCacheDrumPatches(HMIDIOUT,UINT,LPWORD,UINT);
+  _Out_writes_bytes_(cbmmt) LPMMTIME lpmmt,
-MMRESULT WINAPI midiOutGetID(HMIDIOUT,LPUINT);
+  _In_ UINT cbmmt);
+
+MMRESULT
+WINAPI
+midiStreamOut(
+  _In_ HMIDISTRM hms,
+  _Out_writes_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT WINAPI midiStreamPause(_In_ HMIDISTRM);
+MMRESULT WINAPI midiStreamRestart(_In_ HMIDISTRM);
+MMRESULT WINAPI midiStreamStop(_In_ HMIDISTRM);
+MMRESULT WINAPI midiConnect(_In_ HMIDI, _In_ HMIDIOUT, _In_opt_ PVOID);
+MMRESULT WINAPI midiDisconnect(_In_ HMIDI, _In_ HMIDIOUT, _In_opt_ PVOID);
+
+MMRESULT
+WINAPI
+midiOutGetDevCapsA(
+  _In_ UINT_PTR uDeviceID,
+  _Out_writes_bytes_(cbmoc) LPMIDIOUTCAPSA pmoc,
+  _In_ UINT cbmoc);
+
+MMRESULT
+WINAPI
+midiOutGetDevCapsW(
+  _In_ UINT_PTR uDeviceID,
+  _Out_writes_bytes_(cbmoc) LPMIDIOUTCAPSW pmoc,
+  _In_ UINT cbmoc);
+
+MMRESULT WINAPI midiOutGetVolume(_In_opt_ HMIDIOUT, _Out_ PDWORD);
+MMRESULT WINAPI midiOutSetVolume(_In_opt_ HMIDIOUT, _In_ DWORD);
+
+MMRESULT
+WINAPI
+midiOutGetErrorTextA(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+midiOutGetErrorTextW(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPWSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+midiOutOpen(
+  _Out_ LPHMIDIOUT,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR,
+  _In_ DWORD);
+
+MMRESULT WINAPI midiOutClose(_In_ HMIDIOUT);
+
+MMRESULT
+WINAPI
+midiOutPrepareHeader(
+  _In_ HMIDIOUT hmo,
+  _Inout_updates_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT
+WINAPI
+midiOutUnprepareHeader(
+  _In_ HMIDIOUT hmo,
+  _Inout_updates_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT WINAPI midiOutShortMsg(_In_ HMIDIOUT, _In_ DWORD);
+
+MMRESULT
+WINAPI
+midiOutLongMsg(
+  _In_ HMIDIOUT hmo,
+  _In_reads_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT WINAPI midiOutReset(_In_ HMIDIOUT);
+
+MMRESULT
+WINAPI
+midiOutCachePatches(
+  _In_ HMIDIOUT hmo,
+  _In_ UINT uBank,
+  _In_reads_(MIDIPATCHSIZE) LPWORD pwpa,
+  _In_ UINT fuCache);
+
+MMRESULT
+WINAPI
+midiOutCacheDrumPatches(
+  _In_ HMIDIOUT hmo,
+  _In_ UINT uPatch,
+  _In_reads_(MIDIPATCHSIZE) LPWORD pwkya,
+  _In_ UINT fuCache);
+
+MMRESULT WINAPI midiOutGetID(_In_ HMIDIOUT, _Out_ LPUINT);
+
 #if (WINVER >= 0x030a)
 #ifdef _WIN32
-MMRESULT WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD_PTR,DWORD_PTR);
+MMRESULT WINAPI midiOutMessage(_In_opt_ HMIDIOUT, _In_ UINT, _In_opt_ DWORD_PTR, _In_opt_ DWORD_PTR);
 #else
 DWORD WINAPI midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD);
 #endif
 #endif
+
 UINT WINAPI midiInGetNumDevs(void);
-MMRESULT WINAPI midiInGetDevCapsA(UINT_PTR,LPMIDIINCAPSA,UINT);
+
-MMRESULT WINAPI midiInGetDevCapsW(UINT_PTR,LPMIDIINCAPSW,UINT);
+MMRESULT
-MMRESULT WINAPI midiInGetErrorTextA(MMRESULT,LPSTR,UINT);
+WINAPI
-MMRESULT WINAPI midiInGetErrorTextW(MMRESULT,LPWSTR,UINT);
+midiInGetDevCapsA(
-MMRESULT WINAPI midiInOpen(LPHMIDIIN,UINT,DWORD_PTR,DWORD_PTR,DWORD);
+  _In_ UINT_PTR uDeviceID,
-MMRESULT WINAPI midiInClose(HMIDIIN);
+  _Out_writes_bytes_(cbmic) LPMIDIINCAPSA pmic,
-MMRESULT WINAPI midiInPrepareHeader(HMIDIIN,LPMIDIHDR,UINT);
+  _In_ UINT cbmic);
-MMRESULT WINAPI midiInUnprepareHeader(HMIDIIN,LPMIDIHDR,UINT);
+
-MMRESULT WINAPI midiInAddBuffer(HMIDIIN,LPMIDIHDR,UINT);
+MMRESULT
-MMRESULT WINAPI midiInStart(HMIDIIN);
+WINAPI
-MMRESULT WINAPI midiInStop(HMIDIIN);
+midiInGetDevCapsW(
-MMRESULT WINAPI midiInReset(HMIDIIN);
+  _In_ UINT_PTR uDeviceID,
-MMRESULT WINAPI midiInGetID(HMIDIIN,LPUINT);
+  _Out_writes_bytes_(cbmic) LPMIDIINCAPSW pmic,
+  _In_ UINT cbmic);
+
+MMRESULT
+WINAPI
+midiInGetErrorTextA(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+midiInGetErrorTextW(
+  _In_ MMRESULT mmrError,
+  _Out_writes_(cchText) LPWSTR pszText,
+  _In_ UINT cchText);
+
+MMRESULT
+WINAPI
+midiInOpen(
+  _Out_ LPHMIDIIN,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR,
+  _In_ DWORD);
+
+MMRESULT WINAPI midiInClose(_In_ HMIDIIN);
+
+MMRESULT
+WINAPI
+midiInPrepareHeader(
+  _In_ HMIDIIN hmi,
+  _Inout_updates_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT
+WINAPI
+midiInUnprepareHeader(
+  _In_ HMIDIIN hmi,
+  _Inout_updates_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT
+WINAPI
+midiInAddBuffer(
+  _In_ HMIDIIN hmi,
+  _Out_writes_bytes_(cbmh) LPMIDIHDR pmh,
+  _In_ UINT cbmh);
+
+MMRESULT WINAPI midiInStart(_In_ HMIDIIN);
+MMRESULT WINAPI midiInStop(_In_ HMIDIIN);
+MMRESULT WINAPI midiInReset(_In_ HMIDIIN);
+MMRESULT WINAPI midiInGetID(_In_ HMIDIIN, _Out_ LPUINT);
+
 #if (WINVER >= 0x030a)
 #ifdef _WIN32
-MMRESULT WINAPI midiInMessage(HMIDIIN,UINT,DWORD_PTR,DWORD_PTR);
+MMRESULT WINAPI midiInMessage(_In_opt_ HMIDIIN, _In_ UINT, _In_opt_ DWORD_PTR, _In_opt_ DWORD_PTR);
 #else
 DWORD WINAPI midiInMessage(HMIDIIN,UINT,DWORD,DWORD);
 #endif
 #endif
+
 UINT WINAPI auxGetNumDevs(void);
-MMRESULT WINAPI auxGetDevCapsA(UINT_PTR,LPAUXCAPSA,UINT);
+
-MMRESULT WINAPI auxGetDevCapsW(UINT_PTR,LPAUXCAPSW,UINT);
+MMRESULT
-MMRESULT WINAPI auxSetVolume(UINT,DWORD);
+WINAPI
-MMRESULT WINAPI auxGetVolume(UINT,PDWORD);
+auxGetDevCapsA(
-MMRESULT WINAPI auxOutMessage(UINT,UINT,DWORD_PTR,DWORD_PTR);
+  _In_ UINT_PTR uDeviceID,
+  _Out_writes_bytes_(cbac) LPAUXCAPSA pac,
+  _In_ UINT cbac);
+
+MMRESULT
+WINAPI
+auxGetDevCapsW(
+  _In_ UINT_PTR uDeviceID,
+  _Out_writes_bytes_(cbac) LPAUXCAPSW pac,
+  _In_ UINT cbac);
+
+MMRESULT WINAPI auxSetVolume(_In_ UINT, _In_ DWORD);
+MMRESULT WINAPI auxGetVolume(_In_ UINT, _Out_ PDWORD);
+
+MMRESULT
+WINAPI
+auxOutMessage(
+  _In_ UINT,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR);
+
 UINT WINAPI mixerGetNumDevs(void);
-MMRESULT WINAPI mixerGetDevCapsA(UINT_PTR,LPMIXERCAPSA,UINT);
+
-MMRESULT WINAPI mixerGetDevCapsW(UINT_PTR,LPMIXERCAPSW,UINT);
+MMRESULT
-MMRESULT WINAPI mixerOpen(LPHMIXER,UINT,DWORD_PTR,DWORD_PTR,DWORD);
+WINAPI
-MMRESULT WINAPI mixerClose(HMIXER);
+mixerGetDevCapsA(
-DWORD WINAPI mixerMessage(HMIXER,UINT,DWORD_PTR,DWORD_PTR);
+  _In_ UINT_PTR uMxId,
-MMRESULT WINAPI mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD);
+  _Out_writes_bytes_(cbmxcaps) LPMIXERCAPSA pmxcaps,
-MMRESULT WINAPI mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD);
+  _In_ UINT cbmxcaps);
-MMRESULT WINAPI mixerGetID(HMIXEROBJ,PUINT,DWORD);
+
-MMRESULT WINAPI mixerGetLineControlsA(HMIXEROBJ,LPMIXERLINECONTROLSA,DWORD);
+MMRESULT
-MMRESULT WINAPI mixerGetLineControlsW(HMIXEROBJ,LPMIXERLINECONTROLSW,DWORD);
+WINAPI
-MMRESULT WINAPI mixerGetControlDetailsA(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+mixerGetDevCapsW(
-MMRESULT WINAPI mixerGetControlDetailsW(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+  _In_ UINT_PTR uMxId,
-MMRESULT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
+  _Out_writes_bytes_(cbmxcaps) LPMIXERCAPSW pmxcaps,
-MMRESULT WINAPI timeGetSystemTime(LPMMTIME,UINT);
+  _In_ UINT cbmxcaps);
+
+MMRESULT
+WINAPI
+mixerOpen(
+  _Out_opt_ LPHMIXER,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR,
+  _In_ DWORD);
+
+MMRESULT WINAPI mixerClose(_In_ HMIXER);
+
+DWORD
+WINAPI
+mixerMessage(
+  _In_opt_ HMIXER,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR);
+
+MMRESULT
+WINAPI
+mixerGetLineInfoA(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERLINEA,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerGetLineInfoW(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERLINEW,
+  _In_ DWORD);
+
+MMRESULT WINAPI mixerGetID(_In_opt_ HMIXEROBJ, _Out_ PUINT, _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerGetLineControlsA(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERLINECONTROLSA,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerGetLineControlsW(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERLINECONTROLSW,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerGetControlDetailsA(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERCONTROLDETAILS,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerGetControlDetailsW(
+  _In_opt_ HMIXEROBJ,
+  _Inout_ LPMIXERCONTROLDETAILS,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mixerSetControlDetails(
+  _In_opt_ HMIXEROBJ,
+  _In_ LPMIXERCONTROLDETAILS,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+timeGetSystemTime(
+  _Out_writes_bytes_(cbmmt) LPMMTIME pmmt,
+  _In_ UINT cbmmt);
+
 DWORD WINAPI timeGetTime(void);
-MMRESULT WINAPI timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD_PTR,UINT);
+
-MMRESULT WINAPI timeKillEvent(UINT);
+MMRESULT
-MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS,UINT);
+WINAPI
-MMRESULT WINAPI timeBeginPeriod(UINT);
+timeSetEvent(
-MMRESULT WINAPI timeEndPeriod(UINT);
+  _In_ UINT,
+  _In_ UINT,
+  _In_ LPTIMECALLBACK,
+  _In_ DWORD_PTR,
+  _In_ UINT);
+
+MMRESULT WINAPI timeKillEvent(_In_ UINT);
+
+MMRESULT
+WINAPI
+timeGetDevCaps(
+  _Out_writes_bytes_(cbtc) LPTIMECAPS ptc,
+  _In_ UINT cbtc);
+
+MMRESULT WINAPI timeBeginPeriod(_In_ UINT);
+MMRESULT WINAPI timeEndPeriod(_In_ UINT);
 UINT WINAPI joyGetNumDevs(void);
-MMRESULT WINAPI joyGetDevCapsA(UINT_PTR,LPJOYCAPSA,UINT);
+
-MMRESULT WINAPI joyGetDevCapsW(UINT_PTR,LPJOYCAPSW,UINT);
+MMRESULT
-MMRESULT WINAPI joyGetPos(UINT,LPJOYINFO);
+WINAPI
-MMRESULT WINAPI joyGetPosEx(UINT,LPJOYINFOEX);
+joyGetDevCapsA(
-MMRESULT WINAPI joyGetThreshold(UINT,LPUINT);
+  _In_ UINT_PTR uJoyID,
-MMRESULT WINAPI joyReleaseCapture(UINT);
+  _Out_writes_bytes_(cbjc) LPJOYCAPSA pjc,
-MMRESULT WINAPI joySetCapture(HWND,UINT,UINT,BOOL);
+  _In_ UINT cbjc);
-MMRESULT WINAPI joySetThreshold(UINT,UINT);
+
-FOURCC WINAPI mmioStringToFOURCCA(LPCSTR,UINT);
+MMRESULT
-FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR,UINT);
+WINAPI
-LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC,LPMMIOPROC,DWORD);
+joyGetDevCapsW(
-LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC,LPMMIOPROC,DWORD);
+  _In_ UINT_PTR uJoyID,
-HMMIO WINAPI mmioOpenA(LPSTR,LPMMIOINFO,DWORD);
+  _Out_writes_bytes_(cbjc) LPJOYCAPSW pjc,
-HMMIO WINAPI mmioOpenW(LPWSTR,LPMMIOINFO,DWORD);
+  _In_ UINT cbjc);
-MMRESULT WINAPI mmioRenameA(LPCSTR,LPCSTR,LPCMMIOINFO,DWORD);
+
-MMRESULT WINAPI mmioRenameW(LPCWSTR,LPCWSTR,LPCMMIOINFO,DWORD);
+MMRESULT WINAPI joyGetPos(_In_ UINT, _Out_ LPJOYINFO);
-MMRESULT WINAPI mmioClose(HMMIO,UINT);
+MMRESULT WINAPI joyGetPosEx(_In_ UINT, _Out_ LPJOYINFOEX);
-LONG WINAPI mmioRead(HMMIO,HPSTR,LONG);
+MMRESULT WINAPI joyGetThreshold(_In_ UINT, _Out_ LPUINT);
-LONG WINAPI mmioWrite(HMMIO,LPCSTR,LONG);
+MMRESULT WINAPI joyReleaseCapture(_In_ UINT);
-LONG WINAPI mmioSeek(HMMIO,LONG,int);
+MMRESULT WINAPI joySetCapture(_In_ HWND, _In_ UINT, _In_ UINT, _In_ BOOL);
-MMRESULT WINAPI mmioGetInfo(HMMIO,LPMMIOINFO,UINT);
+MMRESULT WINAPI joySetThreshold(_In_ UINT, _In_ UINT);
-MMRESULT WINAPI mmioSetInfo(HMMIO,LPCMMIOINFO,UINT);
+FOURCC WINAPI mmioStringToFOURCCA(LPCSTR, _In_ UINT);
-MMRESULT WINAPI mmioSetBuffer(HMMIO,LPSTR,LONG,UINT);
+FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR, _In_ UINT);
-MMRESULT WINAPI mmioFlush(HMMIO,UINT);
+
-MMRESULT WINAPI mmioAdvance(HMMIO,LPMMIOINFO,UINT);
+LPMMIOPROC
-LRESULT WINAPI mmioSendMessage(HMMIO,UINT,LPARAM,LPARAM);
+WINAPI
-MMRESULT WINAPI mmioDescend(HMMIO,LPMMCKINFO,const MMCKINFO*,UINT);
+mmioInstallIOProcA(
-MMRESULT WINAPI mmioAscend(HMMIO,LPMMCKINFO,UINT);
+  _In_ FOURCC,
-MMRESULT WINAPI mmioCreateChunk(HMMIO,LPMMCKINFO,UINT);
+  _In_opt_ LPMMIOPROC,
-MCIERROR WINAPI mciSendCommandA(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+  _In_ DWORD);
-MCIERROR WINAPI mciSendCommandW(MCIDEVICEID,UINT,DWORD_PTR,DWORD_PTR);
+
-MCIERROR WINAPI mciSendStringA(LPCSTR,LPSTR,UINT,HWND);
+LPMMIOPROC
-MCIERROR WINAPI mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND);
+WINAPI
-MCIDEVICEID WINAPI mciGetDeviceIDA(LPCSTR);
+mmioInstallIOProcW(
-MCIDEVICEID WINAPI mciGetDeviceIDW(LPCWSTR);
+  _In_ FOURCC,
-MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(DWORD,LPCSTR);
+  _In_opt_ LPMMIOPROC,
-MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(DWORD,LPCWSTR);
+  _In_ DWORD);
-BOOL WINAPI mciGetErrorStringA(MCIERROR,LPSTR,UINT);
+
-BOOL WINAPI mciGetErrorStringW(MCIERROR,LPWSTR,UINT);
+HMMIO
-BOOL WINAPI mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD);
+WINAPI
-HTASK WINAPI mciGetCreatorTask(MCIDEVICEID);
+mmioOpenA(
-YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID,PDWORD);
+  _Inout_updates_bytes_opt_(128) LPSTR pszFileName,
+  _Inout_opt_ LPMMIOINFO pmmioinfo,
+  _In_ DWORD fdwOpen);
+
+HMMIO
+WINAPI
+mmioOpenW(
+  _Inout_updates_bytes_opt_(128) LPWSTR pszFileName,
+  _Inout_opt_ LPMMIOINFO pmmioinfo,
+  _In_ DWORD fdwOpen);
+
+MMRESULT
+WINAPI
+mmioRenameA(
+  _In_ LPCSTR,
+  _In_ LPCSTR,
+  _In_opt_ LPCMMIOINFO,
+  _In_ DWORD);
+
+MMRESULT
+WINAPI
+mmioRenameW(
+  _In_ LPCWSTR,
+  _In_ LPCWSTR,
+  _In_opt_ LPCMMIOINFO,
+  _In_ DWORD);
+
+MMRESULT WINAPI mmioClose(_In_ HMMIO, _In_ UINT);
+
+LONG
+WINAPI
+mmioRead(
+  _In_ HMMIO hmmio,
+  _Out_writes_bytes_(cch) HPSTR pch,
+  _In_ LONG cch);
+
+LONG
+WINAPI
+mmioWrite(
+  _In_ HMMIO hmmio,
+  _In_reads_bytes_(cch) const char _huge * pch,
+  _In_ LONG cch);
+
+LONG WINAPI mmioSeek(_In_ HMMIO, _In_ LONG, _In_ int);
+MMRESULT WINAPI mmioGetInfo(_In_ HMMIO, _Out_ LPMMIOINFO, _In_ UINT);
+MMRESULT WINAPI mmioSetInfo(_In_ HMMIO, _In_ LPCMMIOINFO, _In_ UINT);
+
+MMRESULT
+WINAPI
+mmioSetBuffer(
+  _In_ HMMIO hmmio,
+  _Out_writes_opt_(cchBuffer) LPSTR pchBuffer,
+  _In_ LONG cchBuffer,
+  _In_ UINT fuBuffer);
+
+MMRESULT WINAPI mmioFlush(_In_ HMMIO, _In_ UINT);
+MMRESULT WINAPI mmioAdvance(_In_ HMMIO, _In_opt_ LPMMIOINFO, _In_ UINT);
+
+LRESULT
+WINAPI
+mmioSendMessage(
+  _In_ HMMIO,
+  _In_ UINT,
+  _In_opt_ LPARAM,
+  _In_opt_ LPARAM);
+
+MMRESULT
+WINAPI
+mmioDescend(
+  _In_ HMMIO,
+  _Inout_ LPMMCKINFO,
+  _In_opt_ const MMCKINFO*,
+  _In_ UINT);
+
+MMRESULT WINAPI mmioAscend(_In_ HMMIO, _In_ LPMMCKINFO, _In_ UINT);
+MMRESULT WINAPI mmioCreateChunk(_In_ HMMIO, _In_ LPMMCKINFO, _In_ UINT);
+
+MCIERROR
+WINAPI
+mciSendCommandA(
+  _In_ MCIDEVICEID,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR);
+
+MCIERROR
+WINAPI
+mciSendCommandW(
+  _In_ MCIDEVICEID,
+  _In_ UINT,
+  _In_opt_ DWORD_PTR,
+  _In_opt_ DWORD_PTR);
+
+MCIERROR
+WINAPI
+mciSendStringA(
+  _In_ LPCSTR lpstrCommand,
+  _Out_writes_opt_(uReturnLength) LPSTR lpstrReturnString,
+  _In_ UINT uReturnLength,
+  _In_opt_ HWND hwndCallback);
+
+MCIERROR
+WINAPI
+mciSendStringW(
+  _In_ LPCWSTR lpstrCommand,
+  _Out_writes_opt_(uReturnLength) LPWSTR lpstrReturnString,
+  _In_ UINT uReturnLength,
+  _In_opt_ HWND hwndCallback);
+
+MCIDEVICEID WINAPI mciGetDeviceIDA(_In_ LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDW(_In_ LPCWSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDA(_In_ DWORD, _In_ LPCSTR);
+MCIDEVICEID WINAPI mciGetDeviceIDFromElementIDW(_In_ DWORD, _In_ LPCWSTR);
+
+BOOL
+WINAPI
+mciGetErrorStringA(
+  _In_ MCIERROR mcierr,
+  _Out_writes_(cchText) LPSTR pszText,
+  _In_ UINT cchText);
+
+BOOL
+WINAPI
+mciGetErrorStringW(
+  _In_ MCIERROR mcierr,
+  _Out_writes_(cchText) LPWSTR pszText,
+  _In_ UINT cchText);
+
+BOOL WINAPI mciSetYieldProc(_In_ MCIDEVICEID, _In_opt_ YIELDPROC, _In_ DWORD);
+HTASK WINAPI mciGetCreatorTask(_In_ MCIDEVICEID);
+YIELDPROC WINAPI mciGetYieldProc(_In_ MCIDEVICEID, _In_ PDWORD);
 
 #ifdef _WINE
 DWORD WINAPI GetDriverFlags(HDRVR hDriver);