102 if (pGetModuleHandle16 && pLoadLibrary16 &&
103 (pGetModuleHandle16(
"MMSYSTEM.DLL") || pLoadLibrary16(
"MMSYSTEM.DLL")))
115 #define ERR_TO_STR(dev) case dev: return #dev 217 WARN(
"Unknown callback type %d\n",
HIWORD(fdwOpen));
234 switch (
dwFlags & 0xF0000000ul) {
269 WARN(
"Unsupported flag (%08lx)\n",
dwFlags & 0xF0000000ul);
309 memcpy(lpCaps, &micA,
min(uSize,
sizeof(micA)));
350 TRACE(
"(%p, %d, %08lx, %08lx, %08x)\n",
351 lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen);
359 mod.dwInstance = dwCallback;
370 &dwCallback, &dwInstance);
380 if (lphMix) *lphMix = hMix;
381 TRACE(
"=> %d hMixer=%p\n", dwRet, hMix);
394 TRACE(
"(%p)\n", hMix);
412 TRACE(
"(%p %p %08x)\n", hmix, lpid, fdwID);
432 TRACE(
"(%p, %p, %08x)\n", hmix, lpmcdW, fdwDetails);
437 if (lpmcdW ==
NULL || lpmcdW->
cbStruct !=
sizeof(*lpmcdW))
452 TRACE(
"(%p, %p, %08x)\n", hmix, lpmcdA, fdwDetails);
454 if (lpmcdA ==
NULL || lpmcdA->
cbStruct !=
sizeof(*lpmcdA))
497 ERR(
"Unsupported fdwDetails=0x%08x\n", fdwDetails);
513 TRACE(
"(%p, %p, %08x)\n", hmix, lpmlcA, fdwControls);
515 if (lpmlcA ==
NULL || lpmlcA->
cbStruct !=
sizeof(*lpmlcA) ||
580 TRACE(
"(%p, %p, %08x)\n", hmix, lpmlcW, fdwControls);
585 if (lpmlcW ==
NULL || lpmlcW->
cbStruct !=
sizeof(*lpmlcW))
600 TRACE(
"(%p, %p, %08x)\n", hmix, lpmliW, fdwInfo);
602 if (lpmliW ==
NULL || lpmliW->
cbStruct !=
sizeof(*lpmliW))
621 TRACE(
"(%p, %p, %08x)\n", hmix, lpmliA, fdwInfo);
623 if (lpmliA ==
NULL || lpmliA->
cbStruct !=
sizeof(*lpmliA))
645 mliW.
Target.vDriverVersion = lpmliA->
Target.vDriverVersion;
649 WARN(
"Unsupported fdwControls=0x%08x\n", fdwInfo);
674 lpmliA->
Target.vDriverVersion = mliW.
Target.vDriverVersion;
690 TRACE(
"(%p, %p, %08x)\n", hmix, lpmcd, fdwDetails);
706 TRACE(
"(%p, %d, %08lx, %08lx): semi-stub?\n",
707 hmix, uMsg, dwParam1, dwParam2);
730 TRACE(
"(%04lX, %p, %d) !\n", uDeviceID, lpCaps, uSize);
760 memcpy(lpCaps, &acA,
min(uSize,
sizeof(acA)));
772 TRACE(
"(%04X, %p) !\n", uDeviceID, lpdwVolume);
786 TRACE(
"(%04X, %u) !\n", uDeviceID, dwVolume);
822 TRACE(
"(%lu, %p, %u);\n", uDeviceID, lpCaps, uSize);
857 memcpy(lpCaps, &mocA,
min(uSize,
sizeof(mocA)));
923 lpdwCallback, lpdwInstance);
925 *lphMidiOut = hMidiOut;
949 TRACE(
"(%p, %d, %08lX, %08lX, %08X);\n",
950 lphMidiOut, uDeviceID, dwCallback, dwInstance,
dwFlags);
952 if (lphMidiOut !=
NULL) *lphMidiOut = 0;
972 if (lphMidiOut) *lphMidiOut = hMidiOut;
973 TRACE(
"=> %d hMidi=%p\n", dwRet, hMidiOut);
986 TRACE(
"(%p)\n", hMidiOut);
1005 TRACE(
"(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1007 if (lpMidiOutHdr ==
NULL || uSize <
sizeof (
MIDIHDR))
1024 TRACE(
"(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1026 if (lpMidiOutHdr ==
NULL || uSize <
sizeof (
MIDIHDR))
1046 TRACE(
"(%p, %08X)\n", hMidiOut, dwMsg);
1062 TRACE(
"(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
1077 TRACE(
"(%p)\n", hMidiOut);
1092 TRACE(
"(%p, %p);\n", hMidiOut, lpdwVolume);
1107 TRACE(
"(%p, %d);\n", hMidiOut, dwVolume);
1122 FIXME(
"not supported yet\n");
1132 FIXME(
"not supported yet\n");
1143 TRACE(
"(%p, %p)\n", hMidiOut, lpuDeviceID);
1161 TRACE(
"(%p, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
1165 if (uMessage == 0x0001) {
1178 FIXME(
"can't handle OPEN or CLOSE message!\n");
1199 TRACE(
"(%ld, %p, %d);\n", uDeviceID, lpCaps, uSize);
1229 memcpy(lpCaps, &micA,
min(uSize,
sizeof(micA)));
1244 TRACE(
"(%p, %d, %08lX, %08lX, %08X);\n",
1245 lphMidiIn, uDeviceID, dwCallback, dwInstance,
dwFlags);
1247 if (lphMidiIn !=
NULL) *lphMidiIn = 0;
1254 &
dwFlags, &dwCallback, &dwInstance);
1270 if (lphMidiIn !=
NULL) *lphMidiIn = hMidiIn;
1271 TRACE(
"=> %d hMidi=%p\n", dwRet, hMidiIn);
1284 TRACE(
"(%p)\n", hMidiIn);
1302 TRACE(
"(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1304 if (lpMidiInHdr ==
NULL || uSize <
sizeof (
MIDIHDR))
1321 TRACE(
"(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1323 if (lpMidiInHdr ==
NULL || uSize <
sizeof (
MIDIHDR))
1344 TRACE(
"(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
1359 TRACE(
"(%p)\n", hMidiIn);
1374 TRACE(
"(%p)\n", hMidiIn);
1389 TRACE(
"(%p)\n", hMidiIn);
1404 TRACE(
"(%p, %p)\n", hMidiIn, lpuDeviceID);
1424 TRACE(
"(%p, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
1432 FIXME(
"can't handle OPEN or CLOSE message!\n");
1443 FIXME(
"(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
1452 FIXME(
"(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
1470 #define WINE_MSM_HEADER (WM_USER+0) 1471 #define WINE_MSM_STOP (WM_USER+1) 1489 return *lpMidiStrm !=
NULL;
1500 FIXME(
"Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
1501 }
else if (lpMidiStrm->
dwTimeDiv > 0x8000) {
1504 ret = (pulse * 1000) / (nf * nsf);
1522 switch (
msg->message) {
1531 for (lpMidiHdr = lpMidiStrm->
lpMidiHdr; lpMidiHdr; lpMidiHdr = lpMidiHdr->
lpNext) {
1576 TRACE(
"Adding %s lpMidiHdr=%p [lpData=0x%p dwBufferLength=%u/%u dwFlags=0x%08x size=%lu]\n",
1585 for (dwToGo = 0; dwToGo < lpMidiHdr->
dwBufferLength; dwToGo += 16) {
1590 printf(
"%02x ", lpData[dwToGo +
i]);
1594 ch = lpData[dwToGo +
i];
1595 printf(
"%c", (ch >= 0x20 && ch <= 0x7F) ? ch :
'.');
1600 if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
1601 ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
1603 ((LPMIDIEVENT)lpData)->dwStreamID != (
DWORD_PTR)lpMidiStrm) {
1604 FIXME(
"Dropping bad %s lpMidiHdr (streamID=%08x)\n",
1606 ((LPMIDIEVENT)lpData)->dwStreamID);
1616 for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = &(*lpmh)->
lpNext);
1626 FIXME(
"Unknown message %d\n",
msg->message);
1646 TRACE(
"(%p)!\n", lpMidiStrm);
1659 TRACE(
"Ready to go 1\n");
1662 TRACE(
"Ready to go 2\n");
1685 me = (LPMIDIEVENT)(lpData + lpMidiHdr->
dwOffset);
1688 if (me->dwDeltaTime) {
1690 lpMidiStrm->
dwPulses += me->dwDeltaTime;
1711 FIXME(
"NIY: MEVT_COMMENT\n");
1715 FIXME(
"NIY: MEVT_LONGMSG, aka sending Sysex event\n");
1752 TRACE(
"End of thread\n");
1769 WARN(
"bad PostThreadMessageA\n");
1782 TRACE(
"(%p)!\n", hMidiStrm);
1808 TRACE(
"(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
1809 lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
1811 if (cMidi != 1 || lphMidiStrm ==
NULL || lpuDeviceID ==
NULL)
1829 lpwm =
MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm);
1830 lpMidiStrm->
hDevice = hMidiOut;
1831 *lphMidiStrm = (HMIDISTRM)hMidiOut;
1861 TRACE(
"=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
1875 TRACE(
"(%p, %p, %u)!\n", hMidiStrm, lpMidiHdr, cbMidiHdr);
1897 WARN(
"bad PostThreadMessageA\n");
1912 TRACE(
"(%p)!\n", hMidiStrm);
1933 TRACE(
"(%p, %p, %u)!\n", hMidiStrm, lpMMT, cbmmt);
1937 }
else if (lpMMT ==
NULL || cbmmt !=
sizeof(
MMTIME)) {
1940 switch (lpMMT->
wType) {
1950 WARN(
"Unsupported time type %d\n", lpMMT->
wType);
1967 TRACE(
"(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty);
2012 TRACE(
"(%p)!\n", hMidiStrm);
2024 }
while (
ret != 0xFFFFFFFF &&
ret != 0);
2025 if (
ret == 0xFFFFFFFF) {
2043 TRACE(
"(%p)!\n", hMidiStrm);
2064 TRACE(
"(%p, %d, %s, %p, %08lX, %08lX, %08X);\n",
2069 TRACE(
"WAVE_FORMAT_QUERY requested !\n");
2076 WARN(
"bad format\n");
2081 WARN(
"invalid parameter\n");
2086 TRACE(
"wFormatTag=%u, nChannels=%u, nSamplesPerSec=%u, nAvgBytesPerSec=%u, nBlockAlign=%u, wBitsPerSample=%u\n",
2168 memcpy(lpCaps, &wocA,
min(uSize,
sizeof(wocA)));
2181 TRACE(
"(%lu %p %u)!\n", uDeviceID, lpCaps, uSize);
2187 FIXME(
"Support WAVE_MAPPER\n");
2238 uError, lpText, uSize) > 0) {
2254 dwCallback, dwInstance,
dwFlags);
2265 TRACE(
"(%p)\n", hWaveOut);
2286 TRACE(
"(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2288 if (lpWaveOutHdr ==
NULL || uSize <
sizeof (
WAVEHDR))
2316 TRACE(
"(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2318 if (lpWaveOutHdr ==
NULL || uSize <
sizeof (
WAVEHDR))
2349 TRACE(
"(%p, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
2364 TRACE(
"(%p);\n", hWaveOut);
2378 TRACE(
"(%p);\n", hWaveOut);
2392 TRACE(
"(%p);\n", hWaveOut);
2406 TRACE(
"(%p);\n", hWaveOut);
2421 TRACE(
"(%p, %p, %u);\n", hWaveOut, lpTime, uSize);
2436 TRACE(
"(%p, %p);\n", hWaveOut, lpdw);
2450 TRACE(
"(%p, %08x);\n", hWaveOut,
dw);
2464 TRACE(
"(%p, %p);\n", hWaveOut, lpdw);
2478 TRACE(
"(%p, %08x);\n", hWaveOut,
dw);
2492 TRACE(
"(%p, %p);\n", hWaveOut, lpdw);
2495 WARN(
"invalid parameter\n");
2512 TRACE(
"(%p, %08x);\n", hWaveOut,
dw);
2527 TRACE(
"(%p, %p);\n", hWaveOut, lpuDeviceID);
2546 TRACE(
"(%p, %u, %ld, %ld)\n", hWaveOut, uMessage, dwParam1, dwParam2);
2552 WARN(
"invalid handle\n");
2558 WARN(
"invalid parameter\n");
2580 TRACE(
"(%lu %p %u)!\n", uDeviceID, lpCaps, uSize);
2586 FIXME(
"Support WAVE_MAPPER\n");
2618 memcpy(lpCaps, &wicA,
min(uSize,
sizeof(wicA)));
2631 dwCallback, dwInstance,
dwFlags);
2642 TRACE(
"(%p)\n", hWaveIn);
2662 TRACE(
"(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
2664 if (lpWaveInHdr ==
NULL || uSize <
sizeof (
WAVEHDR))
2679 lpWaveInHdr->dwBytesRecorded = 0;
2693 TRACE(
"(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
2695 if (lpWaveInHdr ==
NULL || uSize <
sizeof (
WAVEHDR))
2725 TRACE(
"(%p, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize);
2741 TRACE(
"(%p);\n", hWaveIn);
2756 TRACE(
"(%p);\n", hWaveIn);
2771 TRACE(
"(%p);\n", hWaveIn);
2787 TRACE(
"(%p, %p, %u);\n", hWaveIn, lpTime, uSize);
2802 TRACE(
"(%p, %p);\n", hWaveIn, lpuDeviceID);
2821 TRACE(
"(%p, %u, %ld, %ld)\n", hWaveIn, uMessage, dwParam1, dwParam2);
UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpTime, UINT uSize)
static LPWINE_MIDI MIDI_OutAlloc(HMIDIOUT *lphMidiOut, DWORD_PTR *lpdwCallback, DWORD_PTR *lpdwInstance, LPDWORD lpdwFlags, DWORD cIDs, MIDIOPENSTRMID *lpIDs)
#define MMSYSERR_KEYNOTFOUND
void DRIVER_UnloadAll(void)
const char * WINMM_ErrorToString(MMRESULT error)
#define MIXER_OBJECTF_HWAVEIN
UINT WINAPI mixerSetControlDetails(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcd, DWORD fdwDetails)
union tagMIXERCONTROLA::@3024 Bounds
WCHAR szName[MIXER_LONG_NAME_CHARS]
LPWINE_MLD MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID)
struct WINE_MIXER * LPWINE_MIXER
#define WAVE_FORMAT_QUERY
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)
UINT WINAPI waveInClose(HWAVEIN hWaveIn)
#define MIXER_GETCONTROLDETAILSF_VALUE
#define MEVT_EVENTTYPE(x)
#define MMSYSERR_READERROR
BOOL WINMM_CheckForMMSystem(void)
UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
VOID WINAPI mmTaskBlock(DWORD tid)
WCHAR szShortName[MIXER_SHORT_NAME_CHARS]
UINT WINAPI midiInStart(HMIDIIN hMidiIn)
CHAR szPname[MAXPNAMELEN]
UINT WINAPI mixerGetLineInfoW(HMIXEROBJ hmix, LPMIXERLINEW lpmliW, DWORD fdwInfo)
#define WideCharToMultiByte
UINT WINAPI mixerGetControlDetailsW(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdW, DWORD fdwDetails)
BOOL WINAPI IsWindow(_In_opt_ HWND)
UINT WINAPI waveOutMessage(HWAVEOUT hWaveOut, UINT uMessage, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
WCHAR szPname[MAXPNAMELEN]
UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
MMRESULT WINAPI waveInOpen(HWAVEIN *lphWaveIn, UINT uDeviceID, LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
CHAR szPname[MAXPNAMELEN]
UINT WINAPI mixerGetControlDetailsA(HMIXEROBJ hmix, LPMIXERCONTROLDETAILS lpmcdA, DWORD fdwDetails)
UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
#define WODM_GETPLAYBACKRATE
UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD *lpdwVolume)
#define MIDIERR_STILLPLAYING
static BOOL MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm, WINE_MIDIStream **lpMidiStrm, WINE_MIDI **lplpwm)
TW_UINT32 TW_UINT16 TW_UINT16 MSG
LPWINE_MLD MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD *dwFlags, DWORD_PTR *dwCallback, DWORD_PTR *dwInstance)
UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn, MIDIHDR *lpMidiInHdr, UINT uSize)
union mmtime_tag::@3019 u
MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
MMRESULT WINAPI midiInOpen(HMIDIIN *lphMidiIn, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
CHAR szName[MIXER_LONG_NAME_CHARS]
UINT WINAPI mixerClose(HMIXER hMix)
#define MIXER_GETLINECONTROLSF_QUERYMASK
DWORD WINAPI GetTickCount(VOID)
#define MIXER_GETCONTROLDETAILSF_LISTTEXT
UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
BOOL WINAPI GetMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
BOOL WINAPI PostThreadMessageA(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WINE_DEFAULT_DEBUG_CHANNEL(winmm)
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
DWORD WINAPI GetLastError(VOID)
#define MIXER_OBJECTF_MIDIIN
#define DLL_PROCESS_ATTACH
#define MIXER_GETLINEINFOF_COMPONENTTYPE
WCHAR szPname[MAXPNAMELEN]
#define MMSYSERR_INVALHANDLE
#define MIXER_OBJECTF_HMIDIOUT
UINT WINAPI midiInClose(HMIDIIN hMidiIn)
static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream *lpMidiStrm, LPWINE_MIDI lpwm, LPMSG msg)
BOOL WINAPI PeekMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm)
#define CALLBACK_TYPEMASK
#define MIXER_OBJECTF_MIDIOUT
DWORD WINAPI mixerMessage(HMIXER hmix, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static BOOL MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream *lpMidiStrm, WORD msg, DWORD pmt1, DWORD pmt2)
struct tagMIXERCONTROLW MIXERCONTROLW
UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT *lpuDeviceID)
MMRESULT WINAPI midiConnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn, WAVEHDR *lpWaveInHdr, UINT uSize)
MMRESULT WINMM_CheckCallback(DWORD_PTR dwCallback, DWORD fdwOpen, BOOL mixer)
UINT WINAPI waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdw)
CHAR szPname[MAXPNAMELEN]
UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank, WORD *lpwPatchArray, UINT uFlags)
CHAR szShortName[MIXER_SHORT_NAME_CHARS]
static DWORD(WINAPI *pLoadLibrary16)(LPCSTR)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
UINT WINAPI waveInMessage(HWAVEIN hWaveIn, UINT uMessage, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut, WAVEHDR *lpWaveOutHdr, UINT uSize)
GLfloat GLfloat GLfloat GLfloat h
_In_ DWORD _In_ DWORD dwOffset
#define WAVE_FORMAT_DIRECT
UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
BOOL WINAPI mmTaskSignal(DWORD tid)
union tagMIXERCONTROLA::@3025 Metrics
UINT WINAPI waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW lpCaps, UINT uSize)
#define MMSYSERR_VALNOTFOUND
UINT WINAPI auxGetNumDevs(void)
UINT WINAPI waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdw)
MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr, UINT cbMidiHdr)
#define sprintf(buf, format,...)
CHAR szShortName[MIXER_SHORT_NAME_CHARS]
CRITICAL_SECTION WINMM_cs
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
void TIME_MMTimeStop(void)
#define MIXER_OBJECTF_MIXER
WCHAR szShortName[MIXER_SHORT_NAME_CHARS]
UINT WINAPI waveOutGetVolume(HWAVEOUT hWaveOut, LPDWORD lpdw)
UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD *lpdwVolume)
union tagMIXERCONTROLW::@3028 Bounds
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
#define MIDIERR_UNPREPARED
#define MMSYSERR_NODRIVER
#define MMSYSERR_NODRIVERCB
UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps, UINT uSize)
UINT WINAPI waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW lpCaps, UINT uSize)
LPWINE_MLD MMDRV_GetRelated(HANDLE hndl, UINT srcType, BOOL bSrcCanBeID, UINT dstType)
MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm)
struct tagMIXERLINEA::@3022 Target
#define WAVERR_STILLPLAYING
#define MMSYSERR_HANDLEBUSY
VOID CALLBACK_FUNCTION(__in PVOID CallbackContext, __in_opt PVOID Argument1, __in_opt PVOID Argument2)
UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn, WAVEHDR *lpWaveInHdr, UINT uSize)
REFIID LPVOID DWORD_PTR dw
struct _WAVEFORMATEX * LPWAVEFORMATEX
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
VOID WINAPI mmTaskYield(VOID)
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
#define offsetof(TYPE, MEMBER)
MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbmmt)
UINT WINAPI waveOutSetVolume(HWAVEOUT hWaveOut, DWORD dw)
UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
#define MCI_ALL_DEVICE_ID
DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwFlags)
UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn, MIDIHDR *lpMidiInHdr, UINT uSize)
UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT *lpuDeviceID)
#define MIXER_OBJECTF_HMIDIIN
#define MIXER_GETLINEINFOF_DESTINATION
#define MMSYSERR_LASTERROR
VOID WINAPI ExitThread(IN DWORD uExitCode)
UINT WINAPI waveOutGetNumDevs(void)
UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
#define MXDM_SETCONTROLDETAILS
DWORD WINAPI GetCurrentThreadId(VOID)
UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut, MIDIHDR *lpMidiOutHdr, UINT uSize)
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
static BOOL WINMM_CreateIData(HINSTANCE hInstDLL)
#define MIXER_OBJECTF_HWAVEOUT
UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PTR dw2)
#define DLL_PROCESS_DETACH
UINT WINAPI midiOutReset(HMIDIOUT hMidiOut)
MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
#define MXDM_GETCONTROLDETAILS
static UINT MIXER_GetDev(HMIXEROBJ hmix, DWORD dwFlags, LPWINE_MIXER *lplpwm)
MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm)
#define MIXER_GETLINEINFOF_LINEID
WCHAR szPname[MAXPNAMELEN]
UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn, MIDIHDR *lpMidiInHdr, UINT uSize)
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define TASKERR_OUTOFMEMORY
#define MIXER_OBJECTF_WAVEIN
WCHAR szName[MIXER_LONG_NAME_CHARS]
UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define MMSYSERR_ALLOCATED
UINT WINAPI waveOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
UINT WINAPI midiOutClose(HMIDIOUT hMidiOut)
CHAR szName[MIXER_LONG_NAME_CHARS]
#define MIXER_OBJECTF_AUX
UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
#define UlongToHandle(ul)
#define MIXER_GETLINEINFOF_TARGETTYPE
UINT WINAPI mixerGetLineInfoA(HMIXEROBJ hmix, LPMIXERLINEA lpmliA, DWORD fdwInfo)
struct tagMIXERCONTROLA MIXERCONTROLA
DWORD MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
WCHAR szPname[MAXPNAMELEN]
UINT WINAPI mixerGetLineControlsA(HMIXEROBJ hmix, LPMIXERLINECONTROLSA lpmlcA, DWORD fdwControls)
CHAR szName[MIXER_LONG_NAME_CHARS]
#define MMSYSERR_INVALFLAG
#define MEVT_EVENTPARM(x)
static void WINMM_DeleteIData(void)
unsigned __int3264 UINT_PTR
struct WINE_MIDIStream WINE_MIDIStream
#define MMSYSERR_NOTSUPPORTED
#define MIXER_GETCONTROLDETAILSF_QUERYMASK
#define MMSYSERR_NOTENABLED
BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
WCHAR szPname[MAXPNAMELEN]
UINT WINAPI waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dw)
#define MIXER_OBJECTF_HMIXER
UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr, UINT uSize)
#define MIDIERR_INVALIDSETUP
DWORD WINAPI MsgWaitForMultipleObjects(_In_ DWORD nCount, _In_reads_opt_(nCount) CONST HANDLE *pHandles, _In_ BOOL fWaitAll, _In_ DWORD dwMilliseconds, _In_ DWORD dwWakeMask)
MMRESULT WINAPI midiStreamOpen(HMIDISTRM *lphMidiStrm, LPUINT lpuDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
#define THREAD_PRIORITY_TIME_CRITICAL
UINT WINAPI mixerGetLineControlsW(HMIXEROBJ hmix, LPMIXERLINECONTROLSW lpmlcW, DWORD fdwControls)
#define MXDM_GETLINECONTROLS
DWORD WINAPI SuspendThread(IN HANDLE hThread)
#define MMSYSERR_DELETEERROR
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn, WAVEHDR *lpWaveInHdr, UINT uSize)
#define MMSYSERR_BADERRNUM
#define memcpy(s1, s2, n)
UINT WINAPI auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
#define MMSYSERR_BADDEVICEID
UINT WINAPI mixerGetDevCapsW(UINT_PTR uDeviceID, LPMIXERCAPSW lpCaps, UINT uSize)
UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut, MIDIHDR *lpMidiOutHdr, UINT uSize)
#define MIXER_OBJECTF_WAVEOUT
UINT WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE *ph, DWORD_PTR client)
UINT MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
static DWORD WINAPI mmTaskRun(void *pmt)
static DWORD CALLBACK MMSYSTEM_MidiStream_Player(LPVOID pmt)
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr, UINT uSize)
struct tagMIXERCONTROLDETAILS_LISTTEXTW MIXERCONTROLDETAILS_LISTTEXTW
static UINT WAVE_Open(HANDLE *lphndl, UINT uDeviceID, UINT uType, LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
struct tagMIXERCONTROLDETAILS_LISTTEXTA MIXERCONTROLDETAILS_LISTTEXTA
UINT WINAPI waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dw)
UINT WINAPI waveInStart(HWAVEIN hWaveIn)
UINT WINAPI waveInReset(HWAVEIN hWaveIn)
static HANDLE(WINAPI *pGetModuleHandle16)(LPCSTR)
#define MIDIERR_LASTERROR
UINT WINAPI waveOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
CHAR szPname[MAXPNAMELEN]
UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpTime, UINT uSize)
DWORD MMDRV_Close(LPWINE_MLD mld, UINT wMsg)
TASKCALLBACK FAR * LPTASKCALLBACK
void MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
#define MIXER_GETLINEINFOF_QUERYMASK
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
struct midihdr_tag * LPMIDIHDR
MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID, LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
UINT WINAPI waveInStop(HWAVEIN hWaveIn)
UINT WINAPI mixerGetDevCapsA(UINT_PTR uDeviceID, LPMIXERCAPSA lpCaps, UINT uSize)
UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch, WORD *lpwKeyArray, UINT uFlags)
#define MMSYSERR_INVALPARAM
static DWORD MMSYSTEM_MidiStream_Convert(WINE_MIDIStream *lpMidiStrm, DWORD pulse)
#define MIXER_GETLINEINFOF_SOURCE
WCHAR szName[MIXER_LONG_NAME_CHARS]
UINT WINAPI mixerGetNumDevs(void)
UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
UINT WINAPI waveOutGetID(HWAVEOUT hWaveOut, UINT *lpuDeviceID)
MMRESULT WINAPI midiDisconnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps, UINT uSize)
UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
#define MIXER_GETLINECONTROLSF_ONEBYTYPE
struct midihdr_tag * lpNext
UINT WINAPI waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA lpCaps, UINT uSize)
#define MultiByteToWideChar
static HMODULE MODULEINFO DWORD cb
UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut, MIDIHDR *lpMidiOutHdr, UINT uSize)
WCHAR szPname[MAXPNAMELEN]
UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
union tagMIXERCONTROLW::@3029 Metrics
UINT WINAPI midiInStop(HMIDIIN hMidiIn)
#define WAVERR_UNPREPARED
UINT WINAPI waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA lpCaps, UINT uSize)
#define WODM_SETPLAYBACKRATE
struct WINE_MIDI * LPWINE_MIDI
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
UINT WINAPI midiInGetNumDevs(void)
HINSTANCE hWinMM32Instance
DWORD WINAPI ResumeThread(IN HANDLE hThread)
static void CALLBACK MIXER_WCallback(HMIXEROBJ hmx, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam, DWORD_PTR param2)
#define MM_MOM_POSITIONCB
#define GetProcAddress(x, y)
UINT WINAPI waveInGetNumDevs(void)
#define MMSYSERR_INVALIDALIAS
UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT *lpuDeviceID)
#define MMSYSERR_WRITEERROR
CHAR szPname[MAXPNAMELEN]
BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
UINT WINAPI midiInReset(HMIDIIN hMidiIn)
struct tagMIXERLINEW::@3023 Target
struct midievent_tag MIDIEVENT
CHAR szPname[MAXPNAMELEN]
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
UINT WINAPI mixerGetID(HMIXEROBJ hmix, LPUINT lpid, DWORD fdwID)
UINT MMDRV_GetNum(UINT type)
UINT WINAPI midiOutGetNumDevs(void)
#define HeapFree(x, y, z)
MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
DWORD WINAPI mmGetCurrentTask(VOID)
DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)