1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
6 * Copyright 1993 Martin Ayotte
7 * 1998-2002 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 * 98/9 added Win32 MCI support
27 * 99/4 added midiStream support
28 * 99/9 added support for loadable low level drivers
32 * + it seems that some programs check what's installed in
33 * registry against the value returned by drivers. Wine is
34 * currently broken regarding this point.
35 * + check thread-safeness for MMSYSTEM and WINMM entry points
36 * + unicode entry points are badly supported (would require
37 * moving 32 bit drivers as Unicode as they are supposed to be)
38 * + allow joystick and timer external calls as we do for wave,
46 #define NONAMELESSUNION
47 #define NONAMELESSSTRUCT
56 #include "wine/debug.h"
58 WINE_DEFAULT_DEBUG_CHANNEL(winmm
);
60 /* ========================================================================
61 * G L O B A L S E T T I N G S
62 * ========================================================================*/
64 HINSTANCE hWinMM32Instance
;
67 static CRITICAL_SECTION_DEBUG critsect_debug
=
70 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
71 0, 0, { (DWORD_PTR
)(__FILE__
": WINMM_cs") }
73 CRITICAL_SECTION WINMM_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
75 /**************************************************************************
76 * WINMM_CreateIData [internal]
78 static BOOL
WINMM_CreateIData(HINSTANCE hInstDLL
)
80 hWinMM32Instance
= hInstDLL
;
81 psLastEvent
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
85 /**************************************************************************
86 * WINMM_DeleteIData [internal]
88 static void WINMM_DeleteIData(void)
92 WINMM_DeleteWaveform();
93 CloseHandle(psLastEvent
);
94 DeleteCriticalSection(&WINMM_cs
);
97 /******************************************************************
100 const char* WINMM_ErrorToString(MMRESULT error
)
102 #define ERR_TO_STR(dev) case dev: return #dev
104 ERR_TO_STR(MMSYSERR_NOERROR
);
105 ERR_TO_STR(MMSYSERR_ERROR
);
106 ERR_TO_STR(MMSYSERR_BADDEVICEID
);
107 ERR_TO_STR(MMSYSERR_NOTENABLED
);
108 ERR_TO_STR(MMSYSERR_ALLOCATED
);
109 ERR_TO_STR(MMSYSERR_INVALHANDLE
);
110 ERR_TO_STR(MMSYSERR_NODRIVER
);
111 ERR_TO_STR(MMSYSERR_NOMEM
);
112 ERR_TO_STR(MMSYSERR_NOTSUPPORTED
);
113 ERR_TO_STR(MMSYSERR_BADERRNUM
);
114 ERR_TO_STR(MMSYSERR_INVALFLAG
);
115 ERR_TO_STR(MMSYSERR_INVALPARAM
);
116 ERR_TO_STR(MMSYSERR_HANDLEBUSY
);
117 ERR_TO_STR(MMSYSERR_INVALIDALIAS
);
118 ERR_TO_STR(MMSYSERR_BADDB
);
119 ERR_TO_STR(MMSYSERR_KEYNOTFOUND
);
120 ERR_TO_STR(MMSYSERR_READERROR
);
121 ERR_TO_STR(MMSYSERR_WRITEERROR
);
122 ERR_TO_STR(MMSYSERR_DELETEERROR
);
123 ERR_TO_STR(MMSYSERR_VALNOTFOUND
);
124 ERR_TO_STR(MMSYSERR_NODRIVERCB
);
125 ERR_TO_STR(WAVERR_BADFORMAT
);
126 ERR_TO_STR(WAVERR_STILLPLAYING
);
127 ERR_TO_STR(WAVERR_UNPREPARED
);
128 ERR_TO_STR(WAVERR_SYNC
);
129 ERR_TO_STR(MIDIERR_INVALIDSETUP
);
130 ERR_TO_STR(MIDIERR_NODEVICE
);
131 ERR_TO_STR(MIDIERR_STILLPLAYING
);
132 ERR_TO_STR(MIDIERR_UNPREPARED
);
135 return wine_dbg_sprintf("Unknown(0x%08x)", error
);
138 /**************************************************************************
139 * DllMain (WINMM.init)
141 * WINMM DLL entry point
144 BOOL WINAPI
DllMain(HINSTANCE hInstDLL
, DWORD fdwReason
, LPVOID fImpLoad
)
146 TRACE("%p 0x%x %p\n", hInstDLL
, fdwReason
, fImpLoad
);
149 case DLL_PROCESS_ATTACH
:
150 DisableThreadLibraryCalls(hInstDLL
);
152 if (!WINMM_CreateIData(hInstDLL
))
155 case DLL_PROCESS_DETACH
:
156 /* close all opened MCI drivers */
157 MCI_SendCommand(MCI_ALL_DEVICE_ID
, MCI_CLOSE
, MCI_WAIT
, 0L);
159 /* There's no guarantee the drivers haven't already been unloaded on
164 /* now unload all remaining drivers... */
174 /**************************************************************************
175 * WINMM_CheckCallback [internal]
177 MMRESULT
WINMM_CheckCallback(DWORD_PTR dwCallback
, DWORD fdwOpen
, BOOL mixer
)
179 switch (fdwOpen
& CALLBACK_TYPEMASK
) {
180 case CALLBACK_NULL
: /* dwCallback need not be NULL */
182 case CALLBACK_WINDOW
:
183 if (dwCallback
&& !IsWindow((HWND
)dwCallback
))
184 return MMSYSERR_INVALPARAM
;
187 case CALLBACK_FUNCTION
:
188 /* a NULL cb is acceptable since w2k, MMSYSERR_INVALPARAM earlier */
190 return MMSYSERR_INVALFLAG
; /* since w2k, MMSYSERR_NOTSUPPORTED earlier */
192 case CALLBACK_THREAD
:
194 if (mixer
) /* FIXME: mixer supports THREAD+EVENT since w2k */
195 return MMSYSERR_NOTSUPPORTED
; /* w9X */
198 WARN("Unknown callback type %d\n", HIWORD(fdwOpen
));
200 return MMSYSERR_NOERROR
;
203 /**************************************************************************
204 * auxGetNumDevs [WINMM.@]
206 UINT WINAPI
auxGetNumDevs(void)
208 return MMDRV_GetNum(MMDRV_AUX
);
211 /**************************************************************************
212 * auxGetDevCapsW [WINMM.@]
214 UINT WINAPI
auxGetDevCapsW(UINT_PTR uDeviceID
, LPAUXCAPSW lpCaps
, UINT uSize
)
218 TRACE("(%04lX, %p, %d) !\n", uDeviceID
, lpCaps
, uSize
);
220 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
222 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
223 return MMSYSERR_BADDEVICEID
;
224 return MMDRV_Message(wmld
, AUXDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
227 /**************************************************************************
228 * auxGetDevCapsA [WINMM.@]
230 UINT WINAPI
auxGetDevCapsA(UINT_PTR uDeviceID
, LPAUXCAPSA lpCaps
, UINT uSize
)
235 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
237 ret
= auxGetDevCapsW(uDeviceID
, &acW
, sizeof(acW
));
239 if (ret
== MMSYSERR_NOERROR
) {
243 acA
.vDriverVersion
= acW
.vDriverVersion
;
244 WideCharToMultiByte( CP_ACP
, 0, acW
.szPname
, -1, acA
.szPname
,
245 sizeof(acA
.szPname
), NULL
, NULL
);
246 acA
.wTechnology
= acW
.wTechnology
;
247 acA
.dwSupport
= acW
.dwSupport
;
248 memcpy(lpCaps
, &acA
, min(uSize
, sizeof(acA
)));
253 /**************************************************************************
254 * auxGetVolume [WINMM.@]
256 UINT WINAPI
auxGetVolume(UINT uDeviceID
, DWORD
* lpdwVolume
)
260 TRACE("(%04X, %p) !\n", uDeviceID
, lpdwVolume
);
262 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
263 return MMSYSERR_INVALHANDLE
;
264 return MMDRV_Message(wmld
, AUXDM_GETVOLUME
, (DWORD_PTR
)lpdwVolume
, 0L);
267 /**************************************************************************
268 * auxSetVolume [WINMM.@]
270 UINT WINAPI
auxSetVolume(UINT uDeviceID
, DWORD dwVolume
)
274 TRACE("(%04X, %u) !\n", uDeviceID
, dwVolume
);
276 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
277 return MMSYSERR_INVALHANDLE
;
278 return MMDRV_Message(wmld
, AUXDM_SETVOLUME
, dwVolume
, 0L);
281 /**************************************************************************
282 * auxOutMessage [WINMM.@]
284 UINT WINAPI
auxOutMessage(UINT uDeviceID
, UINT uMessage
, DWORD_PTR dw1
, DWORD_PTR dw2
)
288 if ((wmld
= MMDRV_Get((HANDLE
)(DWORD_PTR
)uDeviceID
, MMDRV_AUX
, TRUE
)) == NULL
)
289 return MMSYSERR_INVALHANDLE
;
291 return MMDRV_Message(wmld
, uMessage
, dw1
, dw2
);
294 /**************************************************************************
295 * midiOutGetNumDevs [WINMM.@]
297 UINT WINAPI
midiOutGetNumDevs(void)
299 return MMDRV_GetNum(MMDRV_MIDIOUT
);
302 /**************************************************************************
303 * midiOutGetDevCapsW [WINMM.@]
305 UINT WINAPI
midiOutGetDevCapsW(UINT_PTR uDeviceID
, LPMIDIOUTCAPSW lpCaps
,
310 TRACE("(%lu, %p, %u);\n", uDeviceID
, lpCaps
, uSize
);
312 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
314 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
315 return MMSYSERR_BADDEVICEID
;
317 return MMDRV_Message(wmld
, MODM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
320 /**************************************************************************
321 * midiOutGetDevCapsA [WINMM.@]
323 UINT WINAPI
midiOutGetDevCapsA(UINT_PTR uDeviceID
, LPMIDIOUTCAPSA lpCaps
,
329 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
331 ret
= midiOutGetDevCapsW(uDeviceID
, &mocW
, sizeof(mocW
));
333 if (ret
== MMSYSERR_NOERROR
) {
335 mocA
.wMid
= mocW
.wMid
;
336 mocA
.wPid
= mocW
.wPid
;
337 mocA
.vDriverVersion
= mocW
.vDriverVersion
;
338 WideCharToMultiByte( CP_ACP
, 0, mocW
.szPname
, -1, mocA
.szPname
,
339 sizeof(mocA
.szPname
), NULL
, NULL
);
340 mocA
.wTechnology
= mocW
.wTechnology
;
341 mocA
.wVoices
= mocW
.wVoices
;
342 mocA
.wNotes
= mocW
.wNotes
;
343 mocA
.wChannelMask
= mocW
.wChannelMask
;
344 mocA
.dwSupport
= mocW
.dwSupport
;
345 memcpy(lpCaps
, &mocA
, min(uSize
, sizeof(mocA
)));
350 /**************************************************************************
351 * midiOutGetErrorTextA [WINMM.@]
352 * midiInGetErrorTextA [WINMM.@]
354 UINT WINAPI
midiOutGetErrorTextA(UINT uError
, LPSTR lpText
, UINT uSize
)
358 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
359 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
362 LPWSTR xstr
= HeapAlloc(GetProcessHeap(), 0, uSize
* sizeof(WCHAR
));
363 if (!xstr
) ret
= MMSYSERR_NOMEM
;
366 ret
= midiOutGetErrorTextW(uError
, xstr
, uSize
);
367 if (ret
== MMSYSERR_NOERROR
)
368 WideCharToMultiByte(CP_ACP
, 0, xstr
, -1, lpText
, uSize
, NULL
, NULL
);
369 HeapFree(GetProcessHeap(), 0, xstr
);
375 /**************************************************************************
376 * midiOutGetErrorTextW [WINMM.@]
377 * midiInGetErrorTextW [WINMM.@]
379 UINT WINAPI
midiOutGetErrorTextW(UINT uError
, LPWSTR lpText
, UINT uSize
)
381 UINT ret
= MMSYSERR_BADERRNUM
;
383 if (lpText
== NULL
) ret
= MMSYSERR_INVALPARAM
;
384 else if (uSize
== 0) ret
= MMSYSERR_NOERROR
;
386 /* test has been removed because MMSYSERR_BASE is 0, and gcc did emit
387 * a warning for the test was always true */
388 (/*uError >= MMSYSERR_BASE && */ uError
<= MMSYSERR_LASTERROR
) ||
389 (uError
>= MIDIERR_BASE
&& uError
<= MIDIERR_LASTERROR
)) {
390 if (LoadStringW(hWinMM32Instance
, uError
, lpText
, uSize
) > 0) {
391 ret
= MMSYSERR_NOERROR
;
397 /**************************************************************************
398 * MIDI_OutAlloc [internal]
400 static LPWINE_MIDI
MIDI_OutAlloc(HMIDIOUT
* lphMidiOut
, DWORD_PTR
* lpdwCallback
,
401 DWORD_PTR
* lpdwInstance
, LPDWORD lpdwFlags
,
402 DWORD cIDs
, MIDIOPENSTRMID
* lpIDs
)
408 size
= sizeof(WINE_MIDI
) + (cIDs
? (cIDs
-1) : 0) * sizeof(MIDIOPENSTRMID
);
410 lpwm
= (LPWINE_MIDI
)MMDRV_Alloc(size
, MMDRV_MIDIOUT
, &hMidiOut
, lpdwFlags
,
411 lpdwCallback
, lpdwInstance
);
412 *lphMidiOut
= hMidiOut
;
415 lpwm
->mod
.hMidi
= hMidiOut
;
416 lpwm
->mod
.dwCallback
= *lpdwCallback
;
417 lpwm
->mod
.dwInstance
= *lpdwInstance
;
418 lpwm
->mod
.dnDevNode
= 0;
419 lpwm
->mod
.cIds
= cIDs
;
421 memcpy(&(lpwm
->mod
.rgIds
), lpIDs
, cIDs
* sizeof(MIDIOPENSTRMID
));
426 /**************************************************************************
427 * midiOutOpen [WINMM.@]
429 UINT WINAPI
midiOutOpen(LPHMIDIOUT lphMidiOut
, UINT uDeviceID
,
430 DWORD_PTR dwCallback
, DWORD_PTR dwInstance
, DWORD dwFlags
)
436 TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
437 lphMidiOut
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
439 if (lphMidiOut
!= NULL
) *lphMidiOut
= 0;
441 dwRet
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
442 if (dwRet
!= MMSYSERR_NOERROR
)
445 lpwm
= MIDI_OutAlloc(&hMidiOut
, &dwCallback
, &dwInstance
, &dwFlags
, 0, NULL
);
448 return MMSYSERR_NOMEM
;
450 lpwm
->mld
.uDeviceID
= uDeviceID
;
452 dwRet
= MMDRV_Open((LPWINE_MLD
)lpwm
, MODM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, dwFlags
);
454 if (dwRet
!= MMSYSERR_NOERROR
) {
455 MMDRV_Free(hMidiOut
, (LPWINE_MLD
)lpwm
);
459 if (lphMidiOut
) *lphMidiOut
= hMidiOut
;
460 TRACE("=> %d hMidi=%p\n", dwRet
, hMidiOut
);
465 /**************************************************************************
466 * midiOutClose [WINMM.@]
468 UINT WINAPI
midiOutClose(HMIDIOUT hMidiOut
)
473 TRACE("(%p)\n", hMidiOut
);
475 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
476 return MMSYSERR_INVALHANDLE
;
478 dwRet
= MMDRV_Close(wmld
, MODM_CLOSE
);
479 MMDRV_Free(hMidiOut
, wmld
);
484 /**************************************************************************
485 * midiOutPrepareHeader [WINMM.@]
487 UINT WINAPI
midiOutPrepareHeader(HMIDIOUT hMidiOut
,
488 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
492 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
494 if (lpMidiOutHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
495 return MMSYSERR_INVALPARAM
;
497 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
498 return MMSYSERR_INVALHANDLE
;
499 /* FIXME: detect MIDIStream handles and enforce 64KB buffer limit on those */
501 return MMDRV_Message(wmld
, MODM_PREPARE
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
504 /**************************************************************************
505 * midiOutUnprepareHeader [WINMM.@]
507 UINT WINAPI
midiOutUnprepareHeader(HMIDIOUT hMidiOut
,
508 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
512 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
514 if (lpMidiOutHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
515 return MMSYSERR_INVALPARAM
;
517 if (!(lpMidiOutHdr
->dwFlags
& MHDR_PREPARED
)) {
518 return MMSYSERR_NOERROR
;
521 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
522 return MMSYSERR_INVALHANDLE
;
524 return MMDRV_Message(wmld
, MODM_UNPREPARE
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
527 /**************************************************************************
528 * midiOutShortMsg [WINMM.@]
530 UINT WINAPI
midiOutShortMsg(HMIDIOUT hMidiOut
, DWORD dwMsg
)
534 TRACE("(%p, %08X)\n", hMidiOut
, dwMsg
);
536 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
537 return MMSYSERR_INVALHANDLE
;
539 return MMDRV_Message(wmld
, MODM_DATA
, dwMsg
, 0L);
542 /**************************************************************************
543 * midiOutLongMsg [WINMM.@]
545 UINT WINAPI
midiOutLongMsg(HMIDIOUT hMidiOut
,
546 MIDIHDR
* lpMidiOutHdr
, UINT uSize
)
550 TRACE("(%p, %p, %d)\n", hMidiOut
, lpMidiOutHdr
, uSize
);
552 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
553 return MMSYSERR_INVALHANDLE
;
555 return MMDRV_Message(wmld
, MODM_LONGDATA
, (DWORD_PTR
)lpMidiOutHdr
, uSize
);
558 /**************************************************************************
559 * midiOutReset [WINMM.@]
561 UINT WINAPI
midiOutReset(HMIDIOUT hMidiOut
)
565 TRACE("(%p)\n", hMidiOut
);
567 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
568 return MMSYSERR_INVALHANDLE
;
570 return MMDRV_Message(wmld
, MODM_RESET
, 0L, 0L);
573 /**************************************************************************
574 * midiOutGetVolume [WINMM.@]
576 UINT WINAPI
midiOutGetVolume(HMIDIOUT hMidiOut
, DWORD
* lpdwVolume
)
580 TRACE("(%p, %p);\n", hMidiOut
, lpdwVolume
);
582 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
583 return MMSYSERR_INVALHANDLE
;
585 return MMDRV_Message(wmld
, MODM_GETVOLUME
, (DWORD_PTR
)lpdwVolume
, 0L);
588 /**************************************************************************
589 * midiOutSetVolume [WINMM.@]
591 UINT WINAPI
midiOutSetVolume(HMIDIOUT hMidiOut
, DWORD dwVolume
)
595 TRACE("(%p, %d);\n", hMidiOut
, dwVolume
);
597 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) == NULL
)
598 return MMSYSERR_INVALHANDLE
;
600 return MMDRV_Message(wmld
, MODM_SETVOLUME
, dwVolume
, 0L);
603 /**************************************************************************
604 * midiOutCachePatches [WINMM.@]
606 UINT WINAPI
midiOutCachePatches(HMIDIOUT hMidiOut
, UINT uBank
,
607 WORD
* lpwPatchArray
, UINT uFlags
)
609 /* not really necessary to support this */
610 FIXME("not supported yet\n");
611 return MMSYSERR_NOTSUPPORTED
;
614 /**************************************************************************
615 * midiOutCacheDrumPatches [WINMM.@]
617 UINT WINAPI
midiOutCacheDrumPatches(HMIDIOUT hMidiOut
, UINT uPatch
,
618 WORD
* lpwKeyArray
, UINT uFlags
)
620 FIXME("not supported yet\n");
621 return MMSYSERR_NOTSUPPORTED
;
624 /**************************************************************************
625 * midiOutGetID [WINMM.@]
627 UINT WINAPI
midiOutGetID(HMIDIOUT hMidiOut
, UINT
* lpuDeviceID
)
631 TRACE("(%p, %p)\n", hMidiOut
, lpuDeviceID
);
633 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALPARAM
;
634 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
635 return MMSYSERR_INVALHANDLE
;
637 *lpuDeviceID
= wmld
->uDeviceID
;
638 return MMSYSERR_NOERROR
;
641 /**************************************************************************
642 * midiOutMessage [WINMM.@]
644 UINT WINAPI
midiOutMessage(HMIDIOUT hMidiOut
, UINT uMessage
,
645 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
649 TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiOut
, uMessage
, dwParam1
, dwParam2
);
651 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, FALSE
)) == NULL
) {
653 if (uMessage
== 0x0001) {
654 *(LPDWORD
)dwParam1
= 1;
657 if ((wmld
= MMDRV_Get(hMidiOut
, MMDRV_MIDIOUT
, TRUE
)) != NULL
) {
658 return MMDRV_PhysicalFeatures(wmld
, uMessage
, dwParam1
, dwParam2
);
660 return MMSYSERR_INVALHANDLE
;
666 FIXME("can't handle OPEN or CLOSE message!\n");
667 return MMSYSERR_NOTSUPPORTED
;
669 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
672 /**************************************************************************
673 * midiInGetNumDevs [WINMM.@]
675 UINT WINAPI
midiInGetNumDevs(void)
677 return MMDRV_GetNum(MMDRV_MIDIIN
);
680 /**************************************************************************
681 * midiInGetDevCapsW [WINMM.@]
683 UINT WINAPI
midiInGetDevCapsW(UINT_PTR uDeviceID
, LPMIDIINCAPSW lpCaps
, UINT uSize
)
687 TRACE("(%ld, %p, %d);\n", uDeviceID
, lpCaps
, uSize
);
689 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
691 if ((wmld
= MMDRV_Get((HANDLE
)uDeviceID
, MMDRV_MIDIIN
, TRUE
)) == NULL
)
692 return MMSYSERR_BADDEVICEID
;
694 return MMDRV_Message(wmld
, MIDM_GETDEVCAPS
, (DWORD_PTR
)lpCaps
, uSize
);
697 /**************************************************************************
698 * midiInGetDevCapsA [WINMM.@]
700 UINT WINAPI
midiInGetDevCapsA(UINT_PTR uDeviceID
, LPMIDIINCAPSA lpCaps
, UINT uSize
)
705 if (lpCaps
== NULL
) return MMSYSERR_INVALPARAM
;
707 ret
= midiInGetDevCapsW(uDeviceID
, &micW
, sizeof(micW
));
709 if (ret
== MMSYSERR_NOERROR
) {
711 micA
.wMid
= micW
.wMid
;
712 micA
.wPid
= micW
.wPid
;
713 micA
.vDriverVersion
= micW
.vDriverVersion
;
714 WideCharToMultiByte( CP_ACP
, 0, micW
.szPname
, -1, micA
.szPname
,
715 sizeof(micA
.szPname
), NULL
, NULL
);
716 micA
.dwSupport
= micW
.dwSupport
;
717 memcpy(lpCaps
, &micA
, min(uSize
, sizeof(micA
)));
722 /**************************************************************************
723 * midiInOpen [WINMM.@]
725 UINT WINAPI
midiInOpen(HMIDIIN
* lphMidiIn
, UINT uDeviceID
,
726 DWORD_PTR dwCallback
, DWORD_PTR dwInstance
, DWORD dwFlags
)
732 TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
733 lphMidiIn
, uDeviceID
, dwCallback
, dwInstance
, dwFlags
);
735 if (lphMidiIn
!= NULL
) *lphMidiIn
= 0;
737 dwRet
= WINMM_CheckCallback(dwCallback
, dwFlags
, FALSE
);
738 if (dwRet
!= MMSYSERR_NOERROR
)
741 lpwm
= (LPWINE_MIDI
)MMDRV_Alloc(sizeof(WINE_MIDI
), MMDRV_MIDIIN
, &hMidiIn
,
742 &dwFlags
, &dwCallback
, &dwInstance
);
745 return MMSYSERR_NOMEM
;
747 lpwm
->mod
.hMidi
= hMidiIn
;
748 lpwm
->mod
.dwCallback
= dwCallback
;
749 lpwm
->mod
.dwInstance
= dwInstance
;
751 lpwm
->mld
.uDeviceID
= uDeviceID
;
752 dwRet
= MMDRV_Open(&lpwm
->mld
, MIDM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, dwFlags
);
754 if (dwRet
!= MMSYSERR_NOERROR
) {
755 MMDRV_Free(hMidiIn
, &lpwm
->mld
);
758 if (lphMidiIn
!= NULL
) *lphMidiIn
= hMidiIn
;
759 TRACE("=> %d hMidi=%p\n", dwRet
, hMidiIn
);
764 /**************************************************************************
765 * midiInClose [WINMM.@]
767 UINT WINAPI
midiInClose(HMIDIIN hMidiIn
)
772 TRACE("(%p)\n", hMidiIn
);
774 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
775 return MMSYSERR_INVALHANDLE
;
777 dwRet
= MMDRV_Close(wmld
, MIDM_CLOSE
);
778 MMDRV_Free(hMidiIn
, wmld
);
782 /**************************************************************************
783 * midiInPrepareHeader [WINMM.@]
785 UINT WINAPI
midiInPrepareHeader(HMIDIIN hMidiIn
,
786 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
790 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
792 if (lpMidiInHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
793 return MMSYSERR_INVALPARAM
;
795 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
796 return MMSYSERR_INVALHANDLE
;
798 return MMDRV_Message(wmld
, MIDM_PREPARE
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
801 /**************************************************************************
802 * midiInUnprepareHeader [WINMM.@]
804 UINT WINAPI
midiInUnprepareHeader(HMIDIIN hMidiIn
,
805 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
809 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
811 if (lpMidiInHdr
== NULL
|| uSize
< offsetof(MIDIHDR
,dwOffset
))
812 return MMSYSERR_INVALPARAM
;
814 if (!(lpMidiInHdr
->dwFlags
& MHDR_PREPARED
)) {
815 return MMSYSERR_NOERROR
;
818 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
819 return MMSYSERR_INVALHANDLE
;
821 return MMDRV_Message(wmld
, MIDM_UNPREPARE
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
824 /**************************************************************************
825 * midiInAddBuffer [WINMM.@]
827 UINT WINAPI
midiInAddBuffer(HMIDIIN hMidiIn
,
828 MIDIHDR
* lpMidiInHdr
, UINT uSize
)
832 TRACE("(%p, %p, %d)\n", hMidiIn
, lpMidiInHdr
, uSize
);
834 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
835 return MMSYSERR_INVALHANDLE
;
837 return MMDRV_Message(wmld
, MIDM_ADDBUFFER
, (DWORD_PTR
)lpMidiInHdr
, uSize
);
840 /**************************************************************************
841 * midiInStart [WINMM.@]
843 UINT WINAPI
midiInStart(HMIDIIN hMidiIn
)
847 TRACE("(%p)\n", hMidiIn
);
849 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
850 return MMSYSERR_INVALHANDLE
;
852 return MMDRV_Message(wmld
, MIDM_START
, 0L, 0L);
855 /**************************************************************************
856 * midiInStop [WINMM.@]
858 UINT WINAPI
midiInStop(HMIDIIN hMidiIn
)
862 TRACE("(%p)\n", hMidiIn
);
864 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
865 return MMSYSERR_INVALHANDLE
;
867 return MMDRV_Message(wmld
, MIDM_STOP
, 0L, 0L);
870 /**************************************************************************
871 * midiInReset [WINMM.@]
873 UINT WINAPI
midiInReset(HMIDIIN hMidiIn
)
877 TRACE("(%p)\n", hMidiIn
);
879 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
880 return MMSYSERR_INVALHANDLE
;
882 return MMDRV_Message(wmld
, MIDM_RESET
, 0L, 0L);
885 /**************************************************************************
886 * midiInGetID [WINMM.@]
888 UINT WINAPI
midiInGetID(HMIDIIN hMidiIn
, UINT
* lpuDeviceID
)
892 TRACE("(%p, %p)\n", hMidiIn
, lpuDeviceID
);
894 if (lpuDeviceID
== NULL
) return MMSYSERR_INVALPARAM
;
896 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, TRUE
)) == NULL
)
897 return MMSYSERR_INVALHANDLE
;
899 *lpuDeviceID
= wmld
->uDeviceID
;
901 return MMSYSERR_NOERROR
;
904 /**************************************************************************
905 * midiInMessage [WINMM.@]
907 UINT WINAPI
midiInMessage(HMIDIIN hMidiIn
, UINT uMessage
,
908 DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
912 TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiIn
, uMessage
, dwParam1
, dwParam2
);
914 if ((wmld
= MMDRV_Get(hMidiIn
, MMDRV_MIDIIN
, FALSE
)) == NULL
)
915 return MMSYSERR_INVALHANDLE
;
920 FIXME("can't handle OPEN or CLOSE message!\n");
921 return MMSYSERR_NOTSUPPORTED
;
923 return MMDRV_Message(wmld
, uMessage
, dwParam1
, dwParam2
);
926 /**************************************************************************
927 * midiConnect [WINMM.@]
929 MMRESULT WINAPI
midiConnect(HMIDI hMidi
, HMIDIOUT hmo
, LPVOID pReserved
)
931 FIXME("(%p, %p, %p): Stub\n", hMidi
, hmo
, pReserved
);
932 return MMSYSERR_ERROR
;
935 /**************************************************************************
936 * midiDisconnect [WINMM.@]
938 MMRESULT WINAPI
midiDisconnect(HMIDI hMidi
, HMIDIOUT hmo
, LPVOID pReserved
)
940 FIXME("(%p, %p, %p): Stub\n", hMidi
, hmo
, pReserved
);
941 return MMSYSERR_ERROR
;
944 typedef struct WINE_MIDIStream
{
958 #define WINE_MSM_HEADER (WM_USER+0)
959 #define WINE_MSM_STOP (WM_USER+1)
961 /**************************************************************************
962 * MMSYSTEM_GetMidiStream [internal]
964 static BOOL
MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm
, WINE_MIDIStream
** lpMidiStrm
, WINE_MIDI
** lplpwm
)
966 WINE_MIDI
* lpwm
= (LPWINE_MIDI
)MMDRV_Get(hMidiStrm
, MMDRV_MIDIOUT
, FALSE
);
975 *lpMidiStrm
= (WINE_MIDIStream
*)lpwm
->mod
.rgIds
.dwStreamID
;
977 return *lpMidiStrm
!= NULL
;
980 /**************************************************************************
981 * MMSYSTEM_MidiStream_Convert [internal]
983 static DWORD
MMSYSTEM_MidiStream_Convert(WINE_MIDIStream
* lpMidiStrm
, DWORD pulse
)
987 if (lpMidiStrm
->dwTimeDiv
== 0) {
988 FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
989 } else if (lpMidiStrm
->dwTimeDiv
> 0x8000) { /* SMPTE, unchecked FIXME? */
990 int nf
= -(char)HIBYTE(lpMidiStrm
->dwTimeDiv
); /* number of frames */
991 int nsf
= LOBYTE(lpMidiStrm
->dwTimeDiv
); /* number of sub-frames */
992 ret
= (pulse
* 1000) / (nf
* nsf
);
994 ret
= (DWORD
)((double)pulse
* ((double)lpMidiStrm
->dwTempo
/ 1000) /
995 (double)lpMidiStrm
->dwTimeDiv
);
1001 /**************************************************************************
1002 * MMSYSTEM_MidiStream_MessageHandler [internal]
1004 static BOOL
MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream
* lpMidiStrm
, LPWINE_MIDI lpwm
, LPMSG msg
)
1006 LPMIDIHDR lpMidiHdr
;
1010 switch (msg
->message
) {
1012 SetEvent(lpMidiStrm
->hEvent
);
1016 /* this is not quite what MS doc says... */
1017 midiOutReset(lpMidiStrm
->hDevice
);
1018 /* empty list of already submitted buffers */
1019 for (lpMidiHdr
= lpMidiStrm
->lpMidiHdr
; lpMidiHdr
; ) {
1020 LPMIDIHDR lphdr
= lpMidiHdr
;
1021 lpMidiHdr
= lpMidiHdr
->lpNext
;
1022 lphdr
->dwFlags
|= MHDR_DONE
;
1023 lphdr
->dwFlags
&= ~MHDR_INQUEUE
;
1025 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1026 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1027 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lphdr
, 0);
1029 lpMidiStrm
->lpMidiHdr
= 0;
1030 SetEvent(lpMidiStrm
->hEvent
);
1032 case WINE_MSM_HEADER
:
1033 /* sets initial tick count for first MIDIHDR */
1034 if (!lpMidiStrm
->dwStartTicks
)
1035 lpMidiStrm
->dwStartTicks
= GetTickCount();
1037 /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
1038 * by native mcimidi, it doesn't look like a correct one".
1039 * this trick allows to throw it away... but I don't like it.
1040 * It looks like part of the file I'm trying to play and definitively looks
1041 * like raw midi content
1042 * I'd really like to understand why native mcimidi sends it. Perhaps a bad
1043 * synchronization issue where native mcimidi is still processing raw MIDI
1044 * content before generating MIDIEVENTs ?
1046 * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
1047 * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
1048 * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
1049 * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
1050 * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
1051 * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
1052 * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
1053 * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
1054 * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
1055 * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
1056 * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
1057 * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
1058 * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
1059 * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
1060 * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
1061 * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
1062 * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
1064 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
1065 lpData
= (LPBYTE
)lpMidiHdr
->lpData
;
1066 TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%u/%u dwFlags=0x%08x size=%lu]\n",
1067 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular", lpMidiHdr
,
1068 lpMidiHdr
, lpMidiHdr
->dwBytesRecorded
, lpMidiHdr
->dwBufferLength
,
1069 lpMidiHdr
->dwFlags
, msg
->wParam
);
1071 /* dumps content of lpMidiHdr->lpData
1072 * FIXME: there should be a debug routine somewhere that already does this
1073 * I hate spreading this type of shit all around the code
1075 for (dwToGo
= 0; dwToGo
< lpMidiHdr
->dwBufferLength
; dwToGo
+= 16) {
1079 for (i
= 0; i
< min(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++)
1080 printf("%02x ", lpData
[dwToGo
+ i
]);
1083 for (i
= 0; i
< min(16, lpMidiHdr
->dwBufferLength
- dwToGo
); i
++) {
1084 ch
= lpData
[dwToGo
+ i
];
1085 printf("%c", (ch
>= 0x20 && ch
<= 0x7F) ? ch
: '.');
1090 if (((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0 &&
1091 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= 0xFFFFFFFF &&
1092 ((LPMIDIEVENT
)lpData
)->dwStreamID
!= (DWORD
)lpMidiStrm
) {
1093 FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
1094 (lpMidiHdr
->dwFlags
& MHDR_ISSTRM
) ? "stream" : "regular",
1095 ((LPMIDIEVENT
)lpData
)->dwStreamID
);
1096 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1097 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1099 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1100 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1101 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lpMidiHdr
, 0);
1105 for (lpmh
= &lpMidiStrm
->lpMidiHdr
; *lpmh
; lpmh
= &(*lpmh
)->lpNext
);
1107 lpMidiHdr
= (LPMIDIHDR
)msg
->lParam
;
1108 lpMidiHdr
->lpNext
= 0;
1109 lpMidiHdr
->dwFlags
|= MHDR_INQUEUE
;
1110 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1114 FIXME("Unknown message %d\n", msg
->message
);
1120 /**************************************************************************
1121 * MMSYSTEM_MidiStream_Player [internal]
1123 static DWORD CALLBACK
MMSYSTEM_MidiStream_Player(LPVOID pmt
)
1125 WINE_MIDIStream
* lpMidiStrm
= pmt
;
1130 LPMIDIHDR lpMidiHdr
;
1133 TRACE("(%p)!\n", lpMidiStrm
);
1136 (lpwm
= (LPWINE_MIDI
)MMDRV_Get(lpMidiStrm
->hDevice
, MMDRV_MIDIOUT
, FALSE
)) == NULL
)
1139 /* force thread's queue creation */
1140 PeekMessageA(&msg
, 0, 0, 0, PM_NOREMOVE
);
1142 lpMidiStrm
->dwStartTicks
= 0;
1143 lpMidiStrm
->dwPulses
= 0;
1145 lpMidiStrm
->lpMidiHdr
= 0;
1147 /* midiStreamOpen is waiting for ack */
1148 SetEvent(lpMidiStrm
->hEvent
);
1151 lpMidiHdr
= lpMidiStrm
->lpMidiHdr
;
1153 /* for first message, block until one arrives, then process all that are available */
1154 GetMessageA(&msg
, 0, 0, 0);
1156 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpwm
, &msg
))
1158 } while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
));
1163 while (dwOffset
+ offsetof(MIDIEVENT
,dwParms
) <= lpMidiHdr
->dwBytesRecorded
) {
1164 LPMIDIEVENT me
= (LPMIDIEVENT
)(lpMidiHdr
->lpData
+dwOffset
);
1166 /* do we have to wait ? */
1167 if (me
->dwDeltaTime
) {
1168 lpMidiStrm
->dwPositionMS
+= MMSYSTEM_MidiStream_Convert(lpMidiStrm
, me
->dwDeltaTime
);
1169 lpMidiStrm
->dwPulses
+= me
->dwDeltaTime
;
1171 dwToGo
= lpMidiStrm
->dwStartTicks
+ lpMidiStrm
->dwPositionMS
;
1173 TRACE("%d/%d/%d\n", dwToGo
, GetTickCount(), me
->dwDeltaTime
);
1174 while ((dwCurrTC
= GetTickCount()) < dwToGo
) {
1175 if (MsgWaitForMultipleObjects(0, NULL
, FALSE
, dwToGo
- dwCurrTC
, QS_ALLINPUT
) == WAIT_OBJECT_0
) {
1176 /* got a message, handle it */
1177 while (PeekMessageA(&msg
, 0, 0, 0, PM_REMOVE
)) {
1178 if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm
, lpwm
, &msg
))
1180 /* is lpMidiHdr still current? */
1181 if (lpMidiHdr
!= lpMidiStrm
->lpMidiHdr
) {
1186 /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
1191 switch (MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
)) {
1193 FIXME("NIY: MEVT_COMMENT\n");
1194 /* do nothing, skip bytes */
1197 midiOutLongMsg(lpMidiStrm
->hDevice
, lpMidiStrm
->lpMidiHdr
, MEVT_EVENTPARM(me
->dwEvent
));
1202 midiOutShortMsg(lpMidiStrm
->hDevice
, MEVT_EVENTPARM(me
->dwEvent
));
1205 lpMidiStrm
->dwTempo
= MEVT_EVENTPARM(me
->dwEvent
);
1210 FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me
->dwEvent
& ~MEVT_F_CALLBACK
));
1213 if (me
->dwEvent
& MEVT_F_CALLBACK
) {
1214 /* native fills dwOffset regardless of the cbMidiHdr size argument to midiStreamOut */
1215 lpMidiHdr
->dwOffset
= dwOffset
;
1216 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1217 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_POSITIONCB
,
1218 lpwm
->mod
.dwInstance
, (LPARAM
)lpMidiHdr
, 0L);
1220 dwOffset
+= offsetof(MIDIEVENT
,dwParms
);
1221 if (me
->dwEvent
& MEVT_F_LONG
)
1222 dwOffset
+= (MEVT_EVENTPARM(me
->dwEvent
) + 3) & ~3;
1224 /* done with this header */
1225 lpMidiStrm
->lpMidiHdr
= lpMidiHdr
->lpNext
;
1226 lpMidiHdr
->dwFlags
|= MHDR_DONE
;
1227 lpMidiHdr
->dwFlags
&= ~MHDR_INQUEUE
;
1229 DriverCallback(lpwm
->mod
.dwCallback
, lpMidiStrm
->wFlags
,
1230 (HDRVR
)lpMidiStrm
->hDevice
, MM_MOM_DONE
,
1231 lpwm
->mod
.dwInstance
, (DWORD_PTR
)lpMidiHdr
, 0);
1235 TRACE("End of thread\n");
1239 /**************************************************************************
1240 * MMSYSTEM_MidiStream_PostMessage [internal]
1242 static BOOL
MMSYSTEM_MidiStream_PostMessage(WINE_MIDIStream
* lpMidiStrm
, WORD msg
, DWORD pmt1
, DWORD pmt2
)
1244 if (PostThreadMessageA(lpMidiStrm
->dwThreadID
, msg
, pmt1
, pmt2
)) {
1245 MsgWaitForMultipleObjects( 1, &lpMidiStrm
->hEvent
, FALSE
, INFINITE
, 0 );
1247 ERR("bad PostThreadMessageA\n");
1253 /**************************************************************************
1254 * midiStreamClose [WINMM.@]
1256 MMRESULT WINAPI
midiStreamClose(HMIDISTRM hMidiStrm
)
1258 WINE_MIDIStream
* lpMidiStrm
;
1260 TRACE("(%p)!\n", hMidiStrm
);
1262 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
))
1263 return MMSYSERR_INVALHANDLE
;
1265 midiStreamStop(hMidiStrm
);
1266 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WM_QUIT
, 0, 0);
1267 CloseHandle(lpMidiStrm
->hEvent
);
1268 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1270 return midiOutClose((HMIDIOUT
)hMidiStrm
);
1273 /**************************************************************************
1274 * midiStreamOpen [WINMM.@]
1276 MMRESULT WINAPI
midiStreamOpen(HMIDISTRM
* lphMidiStrm
, LPUINT lpuDeviceID
,
1277 DWORD cMidi
, DWORD_PTR dwCallback
,
1278 DWORD_PTR dwInstance
, DWORD fdwOpen
)
1280 WINE_MIDIStream
* lpMidiStrm
;
1282 MIDIOPENSTRMID mosm
;
1286 TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
1287 lphMidiStrm
, lpuDeviceID
, cMidi
, dwCallback
, dwInstance
, fdwOpen
);
1289 if (cMidi
!= 1 || lphMidiStrm
== NULL
|| lpuDeviceID
== NULL
)
1290 return MMSYSERR_INVALPARAM
;
1292 ret
= WINMM_CheckCallback(dwCallback
, fdwOpen
, FALSE
);
1293 if (ret
!= MMSYSERR_NOERROR
)
1296 lpMidiStrm
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream
));
1298 return MMSYSERR_NOMEM
;
1300 lpMidiStrm
->dwTempo
= 500000;
1301 lpMidiStrm
->dwTimeDiv
= 480; /* 480 is 120 quarter notes per minute *//* FIXME ??*/
1302 lpMidiStrm
->dwPositionMS
= 0;
1304 mosm
.dwStreamID
= (DWORD
)lpMidiStrm
;
1305 /* FIXME: the correct value is not allocated yet for MAPPER */
1306 mosm
.wDeviceID
= *lpuDeviceID
;
1307 lpwm
= MIDI_OutAlloc(&hMidiOut
, &dwCallback
, &dwInstance
, &fdwOpen
, 1, &mosm
);
1309 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1310 return MMSYSERR_NOMEM
;
1312 lpMidiStrm
->hDevice
= hMidiOut
;
1313 *lphMidiStrm
= (HMIDISTRM
)hMidiOut
;
1315 lpwm
->mld
.uDeviceID
= *lpuDeviceID
;
1317 ret
= MMDRV_Open(&lpwm
->mld
, MODM_OPEN
, (DWORD_PTR
)&lpwm
->mod
, fdwOpen
);
1318 if (ret
!= MMSYSERR_NOERROR
) {
1319 MMDRV_Free(hMidiOut
, &lpwm
->mld
);
1320 HeapFree(GetProcessHeap(), 0, lpMidiStrm
);
1324 lpMidiStrm
->hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1325 lpMidiStrm
->wFlags
= HIWORD(fdwOpen
);
1327 lpMidiStrm
->hThread
= CreateThread(NULL
, 0, MMSYSTEM_MidiStream_Player
,
1328 lpMidiStrm
, 0, &(lpMidiStrm
->dwThreadID
));
1330 if (!lpMidiStrm
->hThread
) {
1331 midiStreamClose((HMIDISTRM
)hMidiOut
);
1332 return MMSYSERR_NOMEM
;
1334 SetThreadPriority(lpMidiStrm
->hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
1336 /* wait for thread to have started, and for its queue to be created */
1337 WaitForSingleObject(lpMidiStrm
->hEvent
, INFINITE
);
1338 /* start in paused mode */
1339 SuspendThread(lpMidiStrm
->hThread
);
1341 TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
1342 *lpuDeviceID
, lpwm
->mld
.uDeviceID
, *lphMidiStrm
, ret
, lpMidiStrm
);
1346 /**************************************************************************
1347 * midiStreamOut [WINMM.@]
1349 MMRESULT WINAPI
midiStreamOut(HMIDISTRM hMidiStrm
, LPMIDIHDR lpMidiHdr
,
1352 WINE_MIDIStream
* lpMidiStrm
;
1353 DWORD ret
= MMSYSERR_NOERROR
;
1355 TRACE("(%p, %p, %u)!\n", hMidiStrm
, lpMidiHdr
, cbMidiHdr
);
1357 if (cbMidiHdr
< offsetof(MIDIHDR
,dwOffset
) || !lpMidiHdr
|| !lpMidiHdr
->lpData
1358 || lpMidiHdr
->dwBufferLength
< lpMidiHdr
->dwBytesRecorded
1359 || lpMidiHdr
->dwBytesRecorded
% 4 /* player expects DWORD padding */)
1360 return MMSYSERR_INVALPARAM
;
1361 /* FIXME: Native additionally checks if the MIDIEVENTs in lpData
1362 * exactly fit dwBytesRecorded. */
1364 if (!(lpMidiHdr
->dwFlags
& MHDR_PREPARED
))
1365 return MIDIERR_UNPREPARED
;
1367 if (lpMidiHdr
->dwFlags
& MHDR_INQUEUE
)
1368 return MIDIERR_STILLPLAYING
;
1370 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1371 ret
= MMSYSERR_INVALHANDLE
;
1373 lpMidiHdr
->dwFlags
|= MHDR_ISSTRM
| MHDR_INQUEUE
;
1374 lpMidiHdr
->dwFlags
&= ~MHDR_DONE
;
1375 if (!PostThreadMessageA(lpMidiStrm
->dwThreadID
,
1376 WINE_MSM_HEADER
, cbMidiHdr
,
1377 (LPARAM
)lpMidiHdr
)) {
1378 ERR("bad PostThreadMessageA\n");
1379 ret
= MMSYSERR_ERROR
;
1385 /**************************************************************************
1386 * midiStreamPause [WINMM.@]
1388 MMRESULT WINAPI
midiStreamPause(HMIDISTRM hMidiStrm
)
1390 WINE_MIDIStream
* lpMidiStrm
;
1391 DWORD ret
= MMSYSERR_NOERROR
;
1393 TRACE("(%p)!\n", hMidiStrm
);
1395 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1396 ret
= MMSYSERR_INVALHANDLE
;
1398 if (SuspendThread(lpMidiStrm
->hThread
) == 0xFFFFFFFF) {
1399 ERR("bad Suspend (%d)\n", GetLastError());
1400 ret
= MMSYSERR_ERROR
;
1406 /**************************************************************************
1407 * midiStreamPosition [WINMM.@]
1409 MMRESULT WINAPI
midiStreamPosition(HMIDISTRM hMidiStrm
, LPMMTIME lpMMT
, UINT cbmmt
)
1411 WINE_MIDIStream
* lpMidiStrm
;
1412 DWORD ret
= MMSYSERR_NOERROR
;
1414 TRACE("(%p, %p, %u)!\n", hMidiStrm
, lpMMT
, cbmmt
);
1416 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1417 ret
= MMSYSERR_INVALHANDLE
;
1418 } else if (lpMMT
== NULL
|| cbmmt
!= sizeof(MMTIME
)) {
1419 ret
= MMSYSERR_INVALPARAM
;
1421 switch (lpMMT
->wType
) {
1423 FIXME("Unsupported time type %x\n", lpMMT
->wType
);
1426 lpMMT
->wType
= TIME_MS
;
1427 /* fall through to alternative format */
1429 lpMMT
->u
.ms
= lpMidiStrm
->dwPositionMS
;
1430 TRACE("=> %d ms\n", lpMMT
->u
.ms
);
1433 lpMMT
->u
.ticks
= lpMidiStrm
->dwPulses
;
1434 TRACE("=> %d ticks\n", lpMMT
->u
.ticks
);
1441 /**************************************************************************
1442 * midiStreamProperty [WINMM.@]
1444 MMRESULT WINAPI
midiStreamProperty(HMIDISTRM hMidiStrm
, LPBYTE lpPropData
, DWORD dwProperty
)
1446 WINE_MIDIStream
* lpMidiStrm
;
1447 MMRESULT ret
= MMSYSERR_NOERROR
;
1449 TRACE("(%p, %p, %x)\n", hMidiStrm
, lpPropData
, dwProperty
);
1451 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1452 ret
= MMSYSERR_INVALHANDLE
;
1453 } else if ((dwProperty
& (MIDIPROP_GET
|MIDIPROP_SET
)) == 0) {
1454 ret
= MMSYSERR_INVALPARAM
;
1455 } else if (dwProperty
& MIDIPROP_TEMPO
) {
1456 MIDIPROPTEMPO
* mpt
= (MIDIPROPTEMPO
*)lpPropData
;
1458 if (sizeof(MIDIPROPTEMPO
) != mpt
->cbStruct
) {
1459 ret
= MMSYSERR_INVALPARAM
;
1460 } else if (dwProperty
& MIDIPROP_SET
) {
1461 lpMidiStrm
->dwTempo
= mpt
->dwTempo
;
1462 TRACE("Setting tempo to %d\n", mpt
->dwTempo
);
1463 } else if (dwProperty
& MIDIPROP_GET
) {
1464 mpt
->dwTempo
= lpMidiStrm
->dwTempo
;
1465 TRACE("Getting tempo <= %d\n", mpt
->dwTempo
);
1467 } else if (dwProperty
& MIDIPROP_TIMEDIV
) {
1468 MIDIPROPTIMEDIV
* mptd
= (MIDIPROPTIMEDIV
*)lpPropData
;
1470 if (sizeof(MIDIPROPTIMEDIV
) != mptd
->cbStruct
) {
1471 ret
= MMSYSERR_INVALPARAM
;
1472 } else if (dwProperty
& MIDIPROP_SET
) {
1473 lpMidiStrm
->dwTimeDiv
= mptd
->dwTimeDiv
;
1474 TRACE("Setting time div to %d\n", mptd
->dwTimeDiv
);
1475 } else if (dwProperty
& MIDIPROP_GET
) {
1476 mptd
->dwTimeDiv
= lpMidiStrm
->dwTimeDiv
;
1477 TRACE("Getting time div <= %d\n", mptd
->dwTimeDiv
);
1480 ret
= MMSYSERR_INVALPARAM
;
1486 /**************************************************************************
1487 * midiStreamRestart [WINMM.@]
1489 MMRESULT WINAPI
midiStreamRestart(HMIDISTRM hMidiStrm
)
1491 WINE_MIDIStream
* lpMidiStrm
;
1492 MMRESULT ret
= MMSYSERR_NOERROR
;
1494 TRACE("(%p)!\n", hMidiStrm
);
1496 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1497 ret
= MMSYSERR_INVALHANDLE
;
1501 /* since we increase the thread suspend count on each midiStreamPause
1502 * there may be a need for several ResumeThread
1505 ret
= ResumeThread(lpMidiStrm
->hThread
);
1506 } while (ret
!= 0xFFFFFFFF && ret
> 1);
1507 if (ret
== 0xFFFFFFFF) {
1508 ERR("bad Resume (%d)\n", GetLastError());
1509 ret
= MMSYSERR_ERROR
;
1511 lpMidiStrm
->dwStartTicks
= GetTickCount() - lpMidiStrm
->dwPositionMS
;
1517 /**************************************************************************
1518 * midiStreamStop [WINMM.@]
1520 MMRESULT WINAPI
midiStreamStop(HMIDISTRM hMidiStrm
)
1522 WINE_MIDIStream
* lpMidiStrm
;
1523 MMRESULT ret
= MMSYSERR_NOERROR
;
1525 TRACE("(%p)!\n", hMidiStrm
);
1527 if (!MMSYSTEM_GetMidiStream(hMidiStrm
, &lpMidiStrm
, NULL
)) {
1528 ret
= MMSYSERR_INVALHANDLE
;
1530 /* in case stream has been paused... FIXME is the current state correct ? */
1531 midiStreamRestart(hMidiStrm
);
1532 MMSYSTEM_MidiStream_PostMessage(lpMidiStrm
, WINE_MSM_STOP
, 0, 0);
1544 static DWORD WINAPI
mmTaskRun(void* pmt
)
1546 struct mm_starter mms
;
1548 memcpy(&mms
, pmt
, sizeof(struct mm_starter
));
1549 HeapFree(GetProcessHeap(), 0, pmt
);
1551 if (mms
.event
) SetEvent(mms
.event
);
1555 /******************************************************************
1556 * mmTaskCreate (WINMM.@)
1558 UINT WINAPI
mmTaskCreate(LPTASKCALLBACK cb
, HANDLE
* ph
, DWORD_PTR client
)
1562 struct mm_starter
*mms
;
1564 mms
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct mm_starter
));
1565 if (mms
== NULL
) return TASKERR_OUTOFMEMORY
;
1568 mms
->client
= client
;
1569 if (ph
) hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
1570 mms
->event
= hEvent
;
1572 hThread
= CreateThread(0, 0, mmTaskRun
, mms
, 0, NULL
);
1574 HeapFree(GetProcessHeap(), 0, mms
);
1575 if (hEvent
) CloseHandle(hEvent
);
1576 return TASKERR_OUTOFMEMORY
;
1578 SetThreadPriority(hThread
, THREAD_PRIORITY_TIME_CRITICAL
);
1579 if (ph
) *ph
= hEvent
;
1580 CloseHandle(hThread
);
1584 /******************************************************************
1585 * mmTaskBlock (WINMM.@)
1587 VOID WINAPI
mmTaskBlock(DWORD tid
)
1593 GetMessageA(&msg
, 0, 0, 0);
1594 if (msg
.hwnd
) DispatchMessageA(&msg
);
1595 } while (msg
.message
!= WM_USER
);
1598 /******************************************************************
1599 * mmTaskSignal (WINMM.@)
1601 BOOL WINAPI
mmTaskSignal(DWORD tid
)
1603 return PostThreadMessageW(tid
, WM_USER
, 0, 0);
1606 /******************************************************************
1607 * mmTaskYield (WINMM.@)
1609 VOID WINAPI
mmTaskYield(VOID
) {}
1611 /******************************************************************
1612 * mmGetCurrentTask (WINMM.@)
1614 DWORD WINAPI
mmGetCurrentTask(VOID
)
1616 return GetCurrentThreadId();