kernel32: Forward RtlRaiseException to ntdll on ARM.
[wine] / dlls / winmm / winmm.c
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4  * WINMM functions
5  *
6  * Copyright 1993      Martin Ayotte
7  *           1998-2002 Eric Pouech
8  *
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.
13  *
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.
18  *
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
22  */
23
24 /*
25  * Eric POUECH :
26  *      98/9    added Win32 MCI support
27  *      99/4    added midiStream support
28  *      99/9    added support for loadable low level drivers
29  */
30
31 /* TODO
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,
39  *        midi, mixer and aux
40  */
41
42 #include <stdio.h>
43 #include <stdarg.h>
44 #include <string.h>
45
46 #define NONAMELESSUNION
47 #define NONAMELESSSTRUCT
48 #include "windef.h"
49 #include "winbase.h"
50 #include "mmsystem.h"
51 #include "winuser.h"
52 #include "winnls.h"
53 #include "winternl.h"
54 #include "winemm.h"
55
56 #include "wine/debug.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
59
60 /* ========================================================================
61  *                   G L O B A L   S E T T I N G S
62  * ========================================================================*/
63
64 HINSTANCE hWinMM32Instance;
65 HANDLE psLastEvent;
66
67 static CRITICAL_SECTION_DEBUG critsect_debug =
68 {
69     0, 0, &WINMM_cs,
70     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
71       0, 0, { (DWORD_PTR)(__FILE__ ": WINMM_cs") }
72 };
73 CRITICAL_SECTION WINMM_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
74
75 /**************************************************************************
76  *                      WINMM_CreateIData                       [internal]
77  */
78 static  BOOL    WINMM_CreateIData(HINSTANCE hInstDLL)
79 {
80     hWinMM32Instance = hInstDLL;
81     psLastEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
82     return TRUE;
83 }
84
85 /**************************************************************************
86  *                      WINMM_DeleteIData                       [internal]
87  */
88 static  void WINMM_DeleteIData(void)
89 {
90     TIME_MMTimeStop();
91
92     WINMM_DeleteWaveform();
93     CloseHandle(psLastEvent);
94     DeleteCriticalSection(&WINMM_cs);
95 }
96
97 /******************************************************************
98  *             WINMM_ErrorToString
99  */
100 const char* WINMM_ErrorToString(MMRESULT error)
101 {
102 #define ERR_TO_STR(dev) case dev: return #dev
103     switch (error) {
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);
133     }
134 #undef ERR_TO_STR
135     return wine_dbg_sprintf("Unknown(0x%08x)", error);
136 }
137
138 /**************************************************************************
139  *              DllMain (WINMM.init)
140  *
141  * WINMM DLL entry point
142  *
143  */
144 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
145 {
146     TRACE("%p 0x%x %p\n", hInstDLL, fdwReason, fImpLoad);
147
148     switch (fdwReason) {
149     case DLL_PROCESS_ATTACH:
150         DisableThreadLibraryCalls(hInstDLL);
151
152         if (!WINMM_CreateIData(hInstDLL))
153             return FALSE;
154         break;
155     case DLL_PROCESS_DETACH:
156         /* close all opened MCI drivers */
157         MCI_SendCommand(MCI_ALL_DEVICE_ID, MCI_CLOSE, MCI_WAIT, 0L);
158         MMDRV_Exit();
159         /* There's no guarantee the drivers haven't already been unloaded on
160          * process shutdown.
161          */
162         if (!fImpLoad)
163         {
164             /* now unload all remaining drivers... */
165             DRIVER_UnloadAll();
166         }
167
168         WINMM_DeleteIData();
169         break;
170     }
171     return TRUE;
172 }
173
174 /**************************************************************************
175  *                      WINMM_CheckCallback                     [internal]
176  */
177 MMRESULT WINMM_CheckCallback(DWORD_PTR dwCallback, DWORD fdwOpen, BOOL mixer)
178 {
179     switch (fdwOpen & CALLBACK_TYPEMASK) {
180     case CALLBACK_NULL:     /* dwCallback need not be NULL */
181         break;
182     case CALLBACK_WINDOW:
183         if (dwCallback && !IsWindow((HWND)dwCallback))
184             return MMSYSERR_INVALPARAM;
185         break;
186
187     case CALLBACK_FUNCTION:
188         /* a NULL cb is acceptable since w2k, MMSYSERR_INVALPARAM earlier */
189         if (mixer)
190             return MMSYSERR_INVALFLAG; /* since w2k, MMSYSERR_NOTSUPPORTED earlier */
191         break;
192     case CALLBACK_THREAD:
193     case CALLBACK_EVENT:
194         if (mixer) /* FIXME: mixer supports THREAD+EVENT since w2k */
195             return MMSYSERR_NOTSUPPORTED; /* w9X */
196         break;
197     default:
198         WARN("Unknown callback type %d\n", HIWORD(fdwOpen));
199     }
200     return MMSYSERR_NOERROR;
201 }
202
203 /**************************************************************************
204  *                              auxGetNumDevs           [WINMM.@]
205  */
206 UINT WINAPI auxGetNumDevs(void)
207 {
208     return MMDRV_GetNum(MMDRV_AUX);
209 }
210
211 /**************************************************************************
212  *                              auxGetDevCapsW          [WINMM.@]
213  */
214 UINT WINAPI auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW lpCaps, UINT uSize)
215 {
216     LPWINE_MLD          wmld;
217
218     TRACE("(%04lX, %p, %d) !\n", uDeviceID, lpCaps, uSize);
219
220     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
221
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);
225 }
226
227 /**************************************************************************
228  *                              auxGetDevCapsA          [WINMM.@]
229  */
230 UINT WINAPI auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA lpCaps, UINT uSize)
231 {
232     AUXCAPSW    acW;
233     UINT        ret;
234
235     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
236
237     ret = auxGetDevCapsW(uDeviceID, &acW, sizeof(acW));
238
239     if (ret == MMSYSERR_NOERROR) {
240         AUXCAPSA acA;
241         acA.wMid           = acW.wMid;
242         acA.wPid           = acW.wPid;
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)));
249     }
250     return ret;
251 }
252
253 /**************************************************************************
254  *                              auxGetVolume            [WINMM.@]
255  */
256 UINT WINAPI auxGetVolume(UINT uDeviceID, DWORD* lpdwVolume)
257 {
258     LPWINE_MLD          wmld;
259
260     TRACE("(%04X, %p) !\n", uDeviceID, lpdwVolume);
261
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);
265 }
266
267 /**************************************************************************
268  *                              auxSetVolume            [WINMM.@]
269  */
270 UINT WINAPI auxSetVolume(UINT uDeviceID, DWORD dwVolume)
271 {
272     LPWINE_MLD          wmld;
273
274     TRACE("(%04X, %u) !\n", uDeviceID, dwVolume);
275
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);
279 }
280
281 /**************************************************************************
282  *                              auxOutMessage           [WINMM.@]
283  */
284 UINT WINAPI auxOutMessage(UINT uDeviceID, UINT uMessage, DWORD_PTR dw1, DWORD_PTR dw2)
285 {
286     LPWINE_MLD          wmld;
287
288     if ((wmld = MMDRV_Get((HANDLE)(DWORD_PTR)uDeviceID, MMDRV_AUX, TRUE)) == NULL)
289         return MMSYSERR_INVALHANDLE;
290
291     return MMDRV_Message(wmld, uMessage, dw1, dw2);
292 }
293
294 /**************************************************************************
295  *                              midiOutGetNumDevs       [WINMM.@]
296  */
297 UINT WINAPI midiOutGetNumDevs(void)
298 {
299     return MMDRV_GetNum(MMDRV_MIDIOUT);
300 }
301
302 /**************************************************************************
303  *                              midiOutGetDevCapsW      [WINMM.@]
304  */
305 UINT WINAPI midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW lpCaps,
306                                UINT uSize)
307 {
308     LPWINE_MLD  wmld;
309
310     TRACE("(%lu, %p, %u);\n", uDeviceID, lpCaps, uSize);
311
312     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
313
314     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIOUT, TRUE)) == NULL)
315         return MMSYSERR_BADDEVICEID;
316
317     return MMDRV_Message(wmld, MODM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
318 }
319
320 /**************************************************************************
321  *                              midiOutGetDevCapsA      [WINMM.@]
322  */
323 UINT WINAPI midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA lpCaps,
324                                UINT uSize)
325 {
326     MIDIOUTCAPSW        mocW;
327     UINT                ret;
328
329     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
330
331     ret = midiOutGetDevCapsW(uDeviceID, &mocW, sizeof(mocW));
332
333     if (ret == MMSYSERR_NOERROR) {
334         MIDIOUTCAPSA mocA;
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)));
346     }
347     return ret;
348 }
349
350 /**************************************************************************
351  *                              midiOutGetErrorTextA    [WINMM.@]
352  *                              midiInGetErrorTextA     [WINMM.@]
353  */
354 UINT WINAPI midiOutGetErrorTextA(UINT uError, LPSTR lpText, UINT uSize)
355 {
356     UINT        ret;
357
358     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
359     else if (uSize == 0) ret = MMSYSERR_NOERROR;
360     else
361     {
362         LPWSTR  xstr = HeapAlloc(GetProcessHeap(), 0, uSize * sizeof(WCHAR));
363         if (!xstr) ret = MMSYSERR_NOMEM;
364         else
365         {
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);
370         }
371     }
372     return ret;
373 }
374
375 /**************************************************************************
376  *                              midiOutGetErrorTextW    [WINMM.@]
377  *                              midiInGetErrorTextW     [WINMM.@]
378  */
379 UINT WINAPI midiOutGetErrorTextW(UINT uError, LPWSTR lpText, UINT uSize)
380 {
381     UINT        ret = MMSYSERR_BADERRNUM;
382
383     if (lpText == NULL) ret = MMSYSERR_INVALPARAM;
384     else if (uSize == 0) ret = MMSYSERR_NOERROR;
385     else if (
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;
392         }
393     }
394     return ret;
395 }
396
397 /**************************************************************************
398  *                              MIDI_OutAlloc                   [internal]
399  */
400 static  LPWINE_MIDI     MIDI_OutAlloc(HMIDIOUT* lphMidiOut, DWORD_PTR* lpdwCallback,
401                                       DWORD_PTR* lpdwInstance, LPDWORD lpdwFlags,
402                                       DWORD cIDs, MIDIOPENSTRMID* lpIDs)
403 {
404     HANDLE              hMidiOut;
405     LPWINE_MIDI         lpwm;
406     UINT                size;
407
408     size = sizeof(WINE_MIDI) + (cIDs ? (cIDs-1) : 0) * sizeof(MIDIOPENSTRMID);
409
410     lpwm = (LPWINE_MIDI)MMDRV_Alloc(size, MMDRV_MIDIOUT, &hMidiOut, lpdwFlags,
411                                     lpdwCallback, lpdwInstance);
412     *lphMidiOut = hMidiOut;
413
414     if (lpwm) {
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;
420         if (cIDs)
421             memcpy(&(lpwm->mod.rgIds), lpIDs, cIDs * sizeof(MIDIOPENSTRMID));
422     }
423     return lpwm;
424 }
425
426 /**************************************************************************
427  *                              midiOutOpen             [WINMM.@]
428  */
429 UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
430                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
431 {
432     HMIDIOUT            hMidiOut;
433     LPWINE_MIDI         lpwm;
434     UINT                dwRet;
435
436     TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
437           lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags);
438
439     if (lphMidiOut != NULL) *lphMidiOut = 0;
440
441     dwRet = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
442     if (dwRet != MMSYSERR_NOERROR)
443         return dwRet;
444
445     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &dwFlags, 0, NULL);
446
447     if (lpwm == NULL)
448         return MMSYSERR_NOMEM;
449
450     lpwm->mld.uDeviceID = uDeviceID;
451
452     dwRet = MMDRV_Open((LPWINE_MLD)lpwm, MODM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
453
454     if (dwRet != MMSYSERR_NOERROR) {
455         MMDRV_Free(hMidiOut, (LPWINE_MLD)lpwm);
456         hMidiOut = 0;
457     }
458
459     if (lphMidiOut) *lphMidiOut = hMidiOut;
460     TRACE("=> %d hMidi=%p\n", dwRet, hMidiOut);
461
462     return dwRet;
463 }
464
465 /**************************************************************************
466  *                              midiOutClose            [WINMM.@]
467  */
468 UINT WINAPI midiOutClose(HMIDIOUT hMidiOut)
469 {
470     LPWINE_MLD          wmld;
471     DWORD               dwRet;
472
473     TRACE("(%p)\n", hMidiOut);
474
475     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
476         return MMSYSERR_INVALHANDLE;
477
478     dwRet = MMDRV_Close(wmld, MODM_CLOSE);
479     MMDRV_Free(hMidiOut, wmld);
480
481     return dwRet;
482 }
483
484 /**************************************************************************
485  *                              midiOutPrepareHeader    [WINMM.@]
486  */
487 UINT WINAPI midiOutPrepareHeader(HMIDIOUT hMidiOut,
488                                  MIDIHDR* lpMidiOutHdr, UINT uSize)
489 {
490     LPWINE_MLD          wmld;
491
492     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
493
494     if (lpMidiOutHdr == NULL || uSize < offsetof(MIDIHDR,dwOffset))
495         return MMSYSERR_INVALPARAM;
496
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 */
500
501     return MMDRV_Message(wmld, MODM_PREPARE, (DWORD_PTR)lpMidiOutHdr, uSize);
502 }
503
504 /**************************************************************************
505  *                              midiOutUnprepareHeader  [WINMM.@]
506  */
507 UINT WINAPI midiOutUnprepareHeader(HMIDIOUT hMidiOut,
508                                    MIDIHDR* lpMidiOutHdr, UINT uSize)
509 {
510     LPWINE_MLD          wmld;
511
512     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
513
514     if (lpMidiOutHdr == NULL || uSize < offsetof(MIDIHDR,dwOffset))
515         return MMSYSERR_INVALPARAM;
516
517     if (!(lpMidiOutHdr->dwFlags & MHDR_PREPARED)) {
518         return MMSYSERR_NOERROR;
519     }
520
521     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
522         return MMSYSERR_INVALHANDLE;
523
524     return MMDRV_Message(wmld, MODM_UNPREPARE, (DWORD_PTR)lpMidiOutHdr, uSize);
525 }
526
527 /**************************************************************************
528  *                              midiOutShortMsg         [WINMM.@]
529  */
530 UINT WINAPI midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg)
531 {
532     LPWINE_MLD          wmld;
533
534     TRACE("(%p, %08X)\n", hMidiOut, dwMsg);
535
536     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
537         return MMSYSERR_INVALHANDLE;
538
539     return MMDRV_Message(wmld, MODM_DATA, dwMsg, 0L);
540 }
541
542 /**************************************************************************
543  *                              midiOutLongMsg          [WINMM.@]
544  */
545 UINT WINAPI midiOutLongMsg(HMIDIOUT hMidiOut,
546                            MIDIHDR* lpMidiOutHdr, UINT uSize)
547 {
548     LPWINE_MLD          wmld;
549
550     TRACE("(%p, %p, %d)\n", hMidiOut, lpMidiOutHdr, uSize);
551
552     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
553         return MMSYSERR_INVALHANDLE;
554
555     return MMDRV_Message(wmld, MODM_LONGDATA, (DWORD_PTR)lpMidiOutHdr, uSize);
556 }
557
558 /**************************************************************************
559  *                              midiOutReset            [WINMM.@]
560  */
561 UINT WINAPI midiOutReset(HMIDIOUT hMidiOut)
562 {
563     LPWINE_MLD          wmld;
564
565     TRACE("(%p)\n", hMidiOut);
566
567     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
568         return MMSYSERR_INVALHANDLE;
569
570     return MMDRV_Message(wmld, MODM_RESET, 0L, 0L);
571 }
572
573 /**************************************************************************
574  *                              midiOutGetVolume        [WINMM.@]
575  */
576 UINT WINAPI midiOutGetVolume(HMIDIOUT hMidiOut, DWORD* lpdwVolume)
577 {
578     LPWINE_MLD          wmld;
579
580     TRACE("(%p, %p);\n", hMidiOut, lpdwVolume);
581
582     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
583         return MMSYSERR_INVALHANDLE;
584
585     return MMDRV_Message(wmld, MODM_GETVOLUME, (DWORD_PTR)lpdwVolume, 0L);
586 }
587
588 /**************************************************************************
589  *                              midiOutSetVolume        [WINMM.@]
590  */
591 UINT WINAPI midiOutSetVolume(HMIDIOUT hMidiOut, DWORD dwVolume)
592 {
593     LPWINE_MLD          wmld;
594
595     TRACE("(%p, %d);\n", hMidiOut, dwVolume);
596
597     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) == NULL)
598         return MMSYSERR_INVALHANDLE;
599
600     return MMDRV_Message(wmld, MODM_SETVOLUME, dwVolume, 0L);
601 }
602
603 /**************************************************************************
604  *                              midiOutCachePatches             [WINMM.@]
605  */
606 UINT WINAPI midiOutCachePatches(HMIDIOUT hMidiOut, UINT uBank,
607                                 WORD* lpwPatchArray, UINT uFlags)
608 {
609     /* not really necessary to support this */
610     FIXME("not supported yet\n");
611     return MMSYSERR_NOTSUPPORTED;
612 }
613
614 /**************************************************************************
615  *                              midiOutCacheDrumPatches [WINMM.@]
616  */
617 UINT WINAPI midiOutCacheDrumPatches(HMIDIOUT hMidiOut, UINT uPatch,
618                                     WORD* lpwKeyArray, UINT uFlags)
619 {
620     FIXME("not supported yet\n");
621     return MMSYSERR_NOTSUPPORTED;
622 }
623
624 /**************************************************************************
625  *                              midiOutGetID            [WINMM.@]
626  */
627 UINT WINAPI midiOutGetID(HMIDIOUT hMidiOut, UINT* lpuDeviceID)
628 {
629     LPWINE_MLD          wmld;
630
631     TRACE("(%p, %p)\n", hMidiOut, lpuDeviceID);
632
633     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
634     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL)
635         return MMSYSERR_INVALHANDLE;
636
637     *lpuDeviceID = wmld->uDeviceID;
638     return MMSYSERR_NOERROR;
639 }
640
641 /**************************************************************************
642  *                              midiOutMessage          [WINMM.@]
643  */
644 UINT WINAPI midiOutMessage(HMIDIOUT hMidiOut, UINT uMessage,
645                            DWORD_PTR dwParam1, DWORD_PTR dwParam2)
646 {
647     LPWINE_MLD          wmld;
648
649     TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiOut, uMessage, dwParam1, dwParam2);
650
651     if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, FALSE)) == NULL) {
652         /* HACK... */
653         if (uMessage == 0x0001) {
654             *(LPDWORD)dwParam1 = 1;
655             return 0;
656         }
657         if ((wmld = MMDRV_Get(hMidiOut, MMDRV_MIDIOUT, TRUE)) != NULL) {
658             return MMDRV_PhysicalFeatures(wmld, uMessage, dwParam1, dwParam2);
659         }
660         return MMSYSERR_INVALHANDLE;
661     }
662
663     switch (uMessage) {
664     case MODM_OPEN:
665     case MODM_CLOSE:
666         FIXME("can't handle OPEN or CLOSE message!\n");
667         return MMSYSERR_NOTSUPPORTED;
668     }
669     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
670 }
671
672 /**************************************************************************
673  *                              midiInGetNumDevs        [WINMM.@]
674  */
675 UINT WINAPI midiInGetNumDevs(void)
676 {
677     return MMDRV_GetNum(MMDRV_MIDIIN);
678 }
679
680 /**************************************************************************
681  *                              midiInGetDevCapsW       [WINMM.@]
682  */
683 UINT WINAPI midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW lpCaps, UINT uSize)
684 {
685     LPWINE_MLD  wmld;
686
687     TRACE("(%ld, %p, %d);\n", uDeviceID, lpCaps, uSize);
688
689     if (lpCaps == NULL) return MMSYSERR_INVALPARAM;
690
691     if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIDIIN, TRUE)) == NULL)
692         return MMSYSERR_BADDEVICEID;
693
694    return MMDRV_Message(wmld, MIDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
695 }
696
697 /**************************************************************************
698  *                              midiInGetDevCapsA       [WINMM.@]
699  */
700 UINT WINAPI midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA lpCaps, UINT uSize)
701 {
702     MIDIINCAPSW         micW;
703     UINT                ret;
704
705     if (lpCaps == NULL)        return MMSYSERR_INVALPARAM;
706
707     ret = midiInGetDevCapsW(uDeviceID, &micW, sizeof(micW));
708
709     if (ret == MMSYSERR_NOERROR) {
710         MIDIINCAPSA micA;
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)));
718     }
719     return ret;
720 }
721
722 /**************************************************************************
723  *                              midiInOpen              [WINMM.@]
724  */
725 UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
726                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
727 {
728     HANDLE              hMidiIn;
729     LPWINE_MIDI         lpwm;
730     DWORD               dwRet;
731
732     TRACE("(%p, %d, %08lX, %08lX, %08X);\n",
733           lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags);
734
735     if (lphMidiIn != NULL) *lphMidiIn = 0;
736
737     dwRet = WINMM_CheckCallback(dwCallback, dwFlags, FALSE);
738     if (dwRet != MMSYSERR_NOERROR)
739         return dwRet;
740
741     lpwm = (LPWINE_MIDI)MMDRV_Alloc(sizeof(WINE_MIDI), MMDRV_MIDIIN, &hMidiIn,
742                                     &dwFlags, &dwCallback, &dwInstance);
743
744     if (lpwm == NULL)
745         return MMSYSERR_NOMEM;
746
747     lpwm->mod.hMidi = hMidiIn;
748     lpwm->mod.dwCallback = dwCallback;
749     lpwm->mod.dwInstance = dwInstance;
750
751     lpwm->mld.uDeviceID = uDeviceID;
752     dwRet = MMDRV_Open(&lpwm->mld, MIDM_OPEN, (DWORD_PTR)&lpwm->mod, dwFlags);
753
754     if (dwRet != MMSYSERR_NOERROR) {
755         MMDRV_Free(hMidiIn, &lpwm->mld);
756         hMidiIn = 0;
757     }
758     if (lphMidiIn != NULL) *lphMidiIn = hMidiIn;
759     TRACE("=> %d hMidi=%p\n", dwRet, hMidiIn);
760
761     return dwRet;
762 }
763
764 /**************************************************************************
765  *                              midiInClose             [WINMM.@]
766  */
767 UINT WINAPI midiInClose(HMIDIIN hMidiIn)
768 {
769     LPWINE_MLD          wmld;
770     DWORD               dwRet;
771
772     TRACE("(%p)\n", hMidiIn);
773
774     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
775         return MMSYSERR_INVALHANDLE;
776
777     dwRet = MMDRV_Close(wmld, MIDM_CLOSE);
778     MMDRV_Free(hMidiIn, wmld);
779     return dwRet;
780 }
781
782 /**************************************************************************
783  *                              midiInPrepareHeader     [WINMM.@]
784  */
785 UINT WINAPI midiInPrepareHeader(HMIDIIN hMidiIn,
786                                 MIDIHDR* lpMidiInHdr, UINT uSize)
787 {
788     LPWINE_MLD          wmld;
789
790     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
791
792     if (lpMidiInHdr == NULL || uSize < offsetof(MIDIHDR,dwOffset))
793         return MMSYSERR_INVALPARAM;
794
795     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
796         return MMSYSERR_INVALHANDLE;
797
798     return MMDRV_Message(wmld, MIDM_PREPARE, (DWORD_PTR)lpMidiInHdr, uSize);
799 }
800
801 /**************************************************************************
802  *                              midiInUnprepareHeader   [WINMM.@]
803  */
804 UINT WINAPI midiInUnprepareHeader(HMIDIIN hMidiIn,
805                                   MIDIHDR* lpMidiInHdr, UINT uSize)
806 {
807     LPWINE_MLD          wmld;
808
809     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
810
811     if (lpMidiInHdr == NULL || uSize < offsetof(MIDIHDR,dwOffset))
812         return MMSYSERR_INVALPARAM;
813
814     if (!(lpMidiInHdr->dwFlags & MHDR_PREPARED)) {
815         return MMSYSERR_NOERROR;
816     }
817
818     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
819         return MMSYSERR_INVALHANDLE;
820
821     return MMDRV_Message(wmld, MIDM_UNPREPARE, (DWORD_PTR)lpMidiInHdr, uSize);
822 }
823
824 /**************************************************************************
825  *                              midiInAddBuffer         [WINMM.@]
826  */
827 UINT WINAPI midiInAddBuffer(HMIDIIN hMidiIn,
828                             MIDIHDR* lpMidiInHdr, UINT uSize)
829 {
830     LPWINE_MLD          wmld;
831
832     TRACE("(%p, %p, %d)\n", hMidiIn, lpMidiInHdr, uSize);
833
834     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
835         return MMSYSERR_INVALHANDLE;
836
837     return MMDRV_Message(wmld, MIDM_ADDBUFFER, (DWORD_PTR)lpMidiInHdr, uSize);
838 }
839
840 /**************************************************************************
841  *                              midiInStart                     [WINMM.@]
842  */
843 UINT WINAPI midiInStart(HMIDIIN hMidiIn)
844 {
845     LPWINE_MLD          wmld;
846
847     TRACE("(%p)\n", hMidiIn);
848
849     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
850         return MMSYSERR_INVALHANDLE;
851
852     return MMDRV_Message(wmld, MIDM_START, 0L, 0L);
853 }
854
855 /**************************************************************************
856  *                              midiInStop                      [WINMM.@]
857  */
858 UINT WINAPI midiInStop(HMIDIIN hMidiIn)
859 {
860     LPWINE_MLD          wmld;
861
862     TRACE("(%p)\n", hMidiIn);
863
864     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
865         return MMSYSERR_INVALHANDLE;
866
867     return MMDRV_Message(wmld, MIDM_STOP, 0L, 0L);
868 }
869
870 /**************************************************************************
871  *                              midiInReset                     [WINMM.@]
872  */
873 UINT WINAPI midiInReset(HMIDIIN hMidiIn)
874 {
875     LPWINE_MLD          wmld;
876
877     TRACE("(%p)\n", hMidiIn);
878
879     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
880         return MMSYSERR_INVALHANDLE;
881
882     return MMDRV_Message(wmld, MIDM_RESET, 0L, 0L);
883 }
884
885 /**************************************************************************
886  *                              midiInGetID                     [WINMM.@]
887  */
888 UINT WINAPI midiInGetID(HMIDIIN hMidiIn, UINT* lpuDeviceID)
889 {
890     LPWINE_MLD          wmld;
891
892     TRACE("(%p, %p)\n", hMidiIn, lpuDeviceID);
893
894     if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
895
896     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, TRUE)) == NULL)
897         return MMSYSERR_INVALHANDLE;
898
899     *lpuDeviceID = wmld->uDeviceID;
900
901     return MMSYSERR_NOERROR;
902 }
903
904 /**************************************************************************
905  *                              midiInMessage           [WINMM.@]
906  */
907 UINT WINAPI midiInMessage(HMIDIIN hMidiIn, UINT uMessage,
908                           DWORD_PTR dwParam1, DWORD_PTR dwParam2)
909 {
910     LPWINE_MLD          wmld;
911
912     TRACE("(%p, %04X, %08lX, %08lX)\n", hMidiIn, uMessage, dwParam1, dwParam2);
913
914     if ((wmld = MMDRV_Get(hMidiIn, MMDRV_MIDIIN, FALSE)) == NULL)
915         return MMSYSERR_INVALHANDLE;
916
917     switch (uMessage) {
918     case MIDM_OPEN:
919     case MIDM_CLOSE:
920         FIXME("can't handle OPEN or CLOSE message!\n");
921         return MMSYSERR_NOTSUPPORTED;
922     }
923     return MMDRV_Message(wmld, uMessage, dwParam1, dwParam2);
924 }
925
926 /**************************************************************************
927  *                              midiConnect                     [WINMM.@]
928  */
929 MMRESULT WINAPI midiConnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
930 {
931     FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
932     return MMSYSERR_ERROR;
933 }
934
935 /**************************************************************************
936  *                              midiDisconnect                  [WINMM.@]
937  */
938 MMRESULT WINAPI midiDisconnect(HMIDI hMidi, HMIDIOUT hmo, LPVOID pReserved)
939 {
940     FIXME("(%p, %p, %p): Stub\n", hMidi, hmo, pReserved);
941     return MMSYSERR_ERROR;
942 }
943
944 typedef struct WINE_MIDIStream {
945     HMIDIOUT                    hDevice;
946     HANDLE                      hThread;
947     DWORD                       dwThreadID;
948     DWORD                       dwTempo;
949     DWORD                       dwTimeDiv;
950     DWORD                       dwPositionMS;
951     DWORD                       dwPulses;
952     DWORD                       dwStartTicks;
953     WORD                        wFlags;
954     HANDLE                      hEvent;
955     LPMIDIHDR                   lpMidiHdr;
956 } WINE_MIDIStream;
957
958 #define WINE_MSM_HEADER         (WM_USER+0)
959 #define WINE_MSM_STOP           (WM_USER+1)
960 #define WINE_MSM_PAUSE          (WM_USER+2)
961 #define WINE_MSM_RESUME         (WM_USER+3)
962
963 /**************************************************************************
964  *                              MMSYSTEM_GetMidiStream          [internal]
965  */
966 static  BOOL    MMSYSTEM_GetMidiStream(HMIDISTRM hMidiStrm, WINE_MIDIStream** lpMidiStrm, WINE_MIDI** lplpwm)
967 {
968     WINE_MIDI* lpwm = (LPWINE_MIDI)MMDRV_Get(hMidiStrm, MMDRV_MIDIOUT, FALSE);
969
970     if (lplpwm)
971         *lplpwm = lpwm;
972
973     if (lpwm == NULL) {
974         return FALSE;
975     }
976
977     *lpMidiStrm = (WINE_MIDIStream*)lpwm->mod.rgIds.dwStreamID;
978
979     return *lpMidiStrm != NULL;
980 }
981
982 /**************************************************************************
983  *                              MMSYSTEM_MidiStream_Convert     [internal]
984  */
985 static  DWORD   MMSYSTEM_MidiStream_Convert(WINE_MIDIStream* lpMidiStrm, DWORD pulse)
986 {
987     DWORD       ret = 0;
988
989     if (lpMidiStrm->dwTimeDiv == 0) {
990         FIXME("Shouldn't happen. lpMidiStrm->dwTimeDiv = 0\n");
991     } else if (lpMidiStrm->dwTimeDiv > 0x8000) { /* SMPTE, unchecked FIXME? */
992         int     nf = -(char)HIBYTE(lpMidiStrm->dwTimeDiv);      /* number of frames     */
993         int     nsf = LOBYTE(lpMidiStrm->dwTimeDiv);            /* number of sub-frames */
994         ret = (pulse * 1000) / (nf * nsf);
995     } else {
996         ret = (DWORD)((double)pulse * ((double)lpMidiStrm->dwTempo / 1000) /
997                       (double)lpMidiStrm->dwTimeDiv);
998     }
999
1000     return ret;
1001 }
1002
1003 /**************************************************************************
1004  *                      MMSYSTEM_MidiStream_MessageHandler      [internal]
1005  */
1006 static  BOOL    MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWINE_MIDI lpwm, LPMSG msg)
1007 {
1008     LPMIDIHDR   lpMidiHdr;
1009     LPMIDIHDR*  lpmh;
1010     LPBYTE      lpData;
1011     BOOL        paused = FALSE;
1012
1013     for (;;) {
1014         switch (msg->message) {
1015         case WM_QUIT:
1016             return FALSE;
1017         case WINE_MSM_STOP:
1018             TRACE("STOP\n");
1019             /* this is not quite what MS doc says... */
1020             midiOutReset(lpMidiStrm->hDevice);
1021             /* empty list of already submitted buffers */
1022             lpMidiHdr = lpMidiStrm->lpMidiHdr;
1023             lpMidiStrm->lpMidiHdr = NULL;
1024             while (lpMidiHdr) {
1025                 LPMIDIHDR lphdr = lpMidiHdr;
1026                 lpMidiHdr = lpMidiHdr->lpNext;
1027                 lphdr->dwFlags |= MHDR_DONE;
1028                 lphdr->dwFlags &= ~MHDR_INQUEUE;
1029
1030                 DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
1031                                (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
1032                                lpwm->mod.dwInstance, (DWORD_PTR)lphdr, 0);
1033             }
1034             return TRUE;
1035         case WINE_MSM_RESUME:
1036             /* FIXME: send out cc64 0 (turn off sustain pedal) on every channel */
1037             lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
1038             return TRUE;
1039         case WINE_MSM_PAUSE:
1040             /* FIXME: send out cc64 0 (turn off sustain pedal) on every channel */
1041             paused = TRUE;
1042             break;
1043         /* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
1044          * by native mcimidi, it doesn't look like a correct one".
1045          * this trick allows to throw it away... but I don't like it.
1046          * It looks like part of the file I'm trying to play and definitively looks
1047          * like raw midi content
1048          * I'd really like to understand why native mcimidi sends it. Perhaps a bad
1049          * synchronization issue where native mcimidi is still processing raw MIDI
1050          * content before generating MIDIEVENTs ?
1051          *
1052          * 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
1053          * 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
1054          * 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
1055          * 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
1056          * 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
1057          * 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
1058          * 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
1059          * 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
1060          * 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
1061          * 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
1062          * 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
1063          * 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
1064          * 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
1065          * 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
1066          * 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
1067          * 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
1068          * 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
1069          */
1070         case WINE_MSM_HEADER:
1071             /* sets initial tick count for first MIDIHDR */
1072             if (!lpMidiStrm->dwStartTicks)
1073                 lpMidiStrm->dwStartTicks = GetTickCount();
1074             lpMidiHdr = (LPMIDIHDR)msg->lParam;
1075             lpData = (LPBYTE)lpMidiHdr->lpData;
1076             TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%u/%u dwFlags=0x%08x size=%lu]\n",
1077                   (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
1078                   lpData, lpMidiHdr->dwBytesRecorded, lpMidiHdr->dwBufferLength,
1079                   lpMidiHdr->dwFlags, msg->wParam);
1080 #if 0
1081             /* dumps content of lpMidiHdr->lpData
1082              * FIXME: there should be a debug routine somewhere that already does this
1083              */
1084             for (dwToGo = 0; dwToGo < lpMidiHdr->dwBufferLength; dwToGo += 16) {
1085                 DWORD       i;
1086                 BYTE        ch;
1087
1088                 for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++)
1089                     printf("%02x ", lpData[dwToGo + i]);
1090                 for (; i < 16; i++)
1091                     printf("   ");
1092                 for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++) {
1093                     ch = lpData[dwToGo + i];
1094                     printf("%c", (ch >= 0x20 && ch <= 0x7F) ? ch : '.');
1095                 }
1096                 printf("\n");
1097             }
1098 #endif
1099             if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
1100                 ((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
1101                 ((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
1102                 FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
1103                       (lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
1104                       ((LPMIDIEVENT)lpData)->dwStreamID);
1105                 lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1106                 lpMidiHdr->dwFlags |= MHDR_DONE;
1107
1108                 DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
1109                                (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
1110                                lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
1111                 break;
1112             }
1113
1114             lpMidiHdr->lpNext = 0;
1115             for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = &(*lpmh)->lpNext);
1116             *lpmh = lpMidiHdr;
1117             break;
1118         default:
1119             FIXME("Unknown message %d\n", msg->message);
1120             break;
1121         }
1122         if (!paused)
1123             return TRUE;
1124         GetMessageA(msg, 0, 0, 0);
1125     }
1126 }
1127
1128 /**************************************************************************
1129  *                              MMSYSTEM_MidiStream_Player      [internal]
1130  */
1131 static  DWORD   CALLBACK        MMSYSTEM_MidiStream_Player(LPVOID pmt)
1132 {
1133     WINE_MIDIStream*    lpMidiStrm = pmt;
1134     WINE_MIDI*          lpwm;
1135     MSG                 msg;
1136     DWORD               dwToGo;
1137     DWORD               dwCurrTC;
1138     LPMIDIHDR           lpMidiHdr;
1139     DWORD               dwOffset;
1140
1141     TRACE("(%p)!\n", lpMidiStrm);
1142
1143     if (!lpMidiStrm ||
1144         (lpwm = (LPWINE_MIDI)MMDRV_Get(lpMidiStrm->hDevice, MMDRV_MIDIOUT, FALSE)) == NULL)
1145         goto the_end;
1146
1147     /* force thread's queue creation */
1148     PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE);
1149
1150     lpMidiStrm->dwStartTicks = 0;
1151     lpMidiStrm->dwPulses = 0;
1152
1153     lpMidiStrm->lpMidiHdr = 0;
1154
1155     /* midiStreamOpen is waiting for ack */
1156     SetEvent(lpMidiStrm->hEvent);
1157
1158 start_header:
1159     lpMidiHdr = lpMidiStrm->lpMidiHdr;
1160     if (!lpMidiHdr) {
1161         /* for first message, block until one arrives, then process all that are available */
1162         GetMessageA(&msg, 0, 0, 0);
1163         do {
1164             if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
1165                 goto the_end;
1166         } while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE));
1167         goto start_header;
1168     }
1169
1170     dwOffset = 0;
1171     while (dwOffset + offsetof(MIDIEVENT,dwParms) <= lpMidiHdr->dwBytesRecorded) {
1172         LPMIDIEVENT me = (LPMIDIEVENT)(lpMidiHdr->lpData+dwOffset);
1173
1174         /* do we have to wait ? */
1175         if (me->dwDeltaTime) {
1176             lpMidiStrm->dwPositionMS += MMSYSTEM_MidiStream_Convert(lpMidiStrm, me->dwDeltaTime);
1177             lpMidiStrm->dwPulses += me->dwDeltaTime;
1178
1179             dwToGo = lpMidiStrm->dwStartTicks + lpMidiStrm->dwPositionMS;
1180
1181             TRACE("%d/%d/%d\n", dwToGo, GetTickCount(), me->dwDeltaTime);
1182             while ((dwCurrTC = GetTickCount()) < dwToGo) {
1183                 if (MsgWaitForMultipleObjects(0, NULL, FALSE, dwToGo - dwCurrTC, QS_ALLINPUT) == WAIT_OBJECT_0) {
1184                     /* got a message, handle it */
1185                     while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) {
1186                         if (!MMSYSTEM_MidiStream_MessageHandler(lpMidiStrm, lpwm, &msg))
1187                             goto the_end;
1188                         /* is lpMidiHdr still current? */
1189                         if (lpMidiHdr != lpMidiStrm->lpMidiHdr) {
1190                             goto start_header;
1191                         }
1192                     }
1193                 } else {
1194                     /* timeout, so me->dwDeltaTime is elapsed, can break the while loop */
1195                     break;
1196                 }
1197             }
1198         }
1199         switch (MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK)) {
1200         case MEVT_COMMENT:
1201             FIXME("NIY: MEVT_COMMENT\n");
1202             /* do nothing, skip bytes */
1203             break;
1204         case MEVT_LONGMSG:
1205             midiOutLongMsg(lpMidiStrm->hDevice, lpMidiStrm->lpMidiHdr, MEVT_EVENTPARM(me->dwEvent));
1206             break;
1207         case MEVT_NOP:
1208             break;
1209         case MEVT_SHORTMSG:
1210             midiOutShortMsg(lpMidiStrm->hDevice, MEVT_EVENTPARM(me->dwEvent));
1211             break;
1212         case MEVT_TEMPO:
1213             lpMidiStrm->dwTempo = MEVT_EVENTPARM(me->dwEvent);
1214             break;
1215         case MEVT_VERSION:
1216             break;
1217         default:
1218             FIXME("Unknown MEVT (0x%02x)\n", MEVT_EVENTTYPE(me->dwEvent & ~MEVT_F_CALLBACK));
1219             break;
1220         }
1221         if (me->dwEvent & MEVT_F_CALLBACK) {
1222             /* native fills dwOffset regardless of the cbMidiHdr size argument to midiStreamOut */
1223             lpMidiHdr->dwOffset = dwOffset;
1224             DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
1225                            (HDRVR)lpMidiStrm->hDevice, MM_MOM_POSITIONCB,
1226                            lpwm->mod.dwInstance, (LPARAM)lpMidiHdr, 0L);
1227         }
1228         dwOffset += offsetof(MIDIEVENT,dwParms);
1229         if (me->dwEvent & MEVT_F_LONG)
1230             dwOffset += (MEVT_EVENTPARM(me->dwEvent) + 3) & ~3;
1231     }
1232     /* done with this header */
1233     lpMidiStrm->lpMidiHdr = lpMidiHdr->lpNext;
1234     lpMidiHdr->dwFlags |= MHDR_DONE;
1235     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
1236
1237     DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
1238                    (HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
1239                    lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
1240     goto start_header;
1241
1242 the_end:
1243     TRACE("End of thread\n");
1244     return 0;
1245 }
1246
1247 /**************************************************************************
1248  *                              midiStreamClose                 [WINMM.@]
1249  */
1250 MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
1251 {
1252     WINE_MIDIStream*    lpMidiStrm;
1253     MMRESULT            ret = 0;
1254
1255     TRACE("(%p)!\n", hMidiStrm);
1256
1257     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
1258         return MMSYSERR_INVALHANDLE;
1259
1260     midiStreamStop(hMidiStrm);
1261     PostThreadMessageA(lpMidiStrm->dwThreadID, WM_QUIT, 0, 0);
1262     CloseHandle(lpMidiStrm->hEvent);
1263     if (lpMidiStrm->hThread) {
1264         if (GetCurrentThreadId() != lpMidiStrm->dwThreadID)
1265             WaitForSingleObject(lpMidiStrm->hThread, INFINITE);
1266         else {
1267             FIXME("leak from call within function callback\n");
1268             ret = MMSYSERR_HANDLEBUSY; /* yet don't signal it to app */
1269         }
1270         CloseHandle(lpMidiStrm->hThread);
1271     }
1272     if(!ret)
1273         HeapFree(GetProcessHeap(), 0, lpMidiStrm);
1274
1275     return midiOutClose((HMIDIOUT)hMidiStrm);
1276 }
1277
1278 /**************************************************************************
1279  *                              midiStreamOpen                  [WINMM.@]
1280  */
1281 MMRESULT WINAPI midiStreamOpen(HMIDISTRM* lphMidiStrm, LPUINT lpuDeviceID,
1282                                DWORD cMidi, DWORD_PTR dwCallback,
1283                                DWORD_PTR dwInstance, DWORD fdwOpen)
1284 {
1285     WINE_MIDIStream*    lpMidiStrm;
1286     MMRESULT            ret;
1287     MIDIOPENSTRMID      mosm;
1288     LPWINE_MIDI         lpwm;
1289     HMIDIOUT            hMidiOut;
1290
1291     TRACE("(%p, %p, %d, 0x%08lx, 0x%08lx, 0x%08x)!\n",
1292           lphMidiStrm, lpuDeviceID, cMidi, dwCallback, dwInstance, fdwOpen);
1293
1294     if (cMidi != 1 || lphMidiStrm == NULL || lpuDeviceID == NULL)
1295         return MMSYSERR_INVALPARAM;
1296
1297     ret = WINMM_CheckCallback(dwCallback, fdwOpen, FALSE);
1298     if (ret != MMSYSERR_NOERROR)
1299         return ret;
1300
1301     lpMidiStrm = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_MIDIStream));
1302     if (!lpMidiStrm)
1303         return MMSYSERR_NOMEM;
1304
1305     lpMidiStrm->dwTempo = 500000;
1306     lpMidiStrm->dwTimeDiv = 480;        /* 480 is 120 quarter notes per minute *//* FIXME ??*/
1307     lpMidiStrm->dwPositionMS = 0;
1308
1309     mosm.dwStreamID = (DWORD)lpMidiStrm;
1310     /* FIXME: the correct value is not allocated yet for MAPPER */
1311     mosm.wDeviceID  = *lpuDeviceID;
1312     lpwm = MIDI_OutAlloc(&hMidiOut, &dwCallback, &dwInstance, &fdwOpen, 1, &mosm);
1313     if (!lpwm) {
1314         HeapFree(GetProcessHeap(), 0, lpMidiStrm);
1315         return MMSYSERR_NOMEM;
1316     }
1317     lpMidiStrm->hDevice = hMidiOut;
1318     *lphMidiStrm = (HMIDISTRM)hMidiOut;
1319
1320     lpwm->mld.uDeviceID = *lpuDeviceID;
1321
1322     ret = MMDRV_Open(&lpwm->mld, MODM_OPEN, (DWORD_PTR)&lpwm->mod, fdwOpen);
1323     if (ret != MMSYSERR_NOERROR) {
1324         MMDRV_Free(hMidiOut, &lpwm->mld);
1325         HeapFree(GetProcessHeap(), 0, lpMidiStrm);
1326         return ret;
1327     }
1328
1329     lpMidiStrm->hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1330     lpMidiStrm->wFlags = HIWORD(fdwOpen);
1331
1332     lpMidiStrm->hThread = CreateThread(NULL, 0, MMSYSTEM_MidiStream_Player,
1333                                        lpMidiStrm, 0, &(lpMidiStrm->dwThreadID));
1334
1335     if (!lpMidiStrm->hThread) {
1336         midiStreamClose((HMIDISTRM)hMidiOut);
1337         return MMSYSERR_NOMEM;
1338     }
1339     SetThreadPriority(lpMidiStrm->hThread, THREAD_PRIORITY_TIME_CRITICAL);
1340
1341     /* wait for thread to have started, and for its queue to be created */
1342     WaitForSingleObject(lpMidiStrm->hEvent, INFINITE);
1343
1344     PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_PAUSE, 0, 0);
1345
1346     TRACE("=> (%u/%d) hMidi=%p ret=%d lpMidiStrm=%p\n",
1347           *lpuDeviceID, lpwm->mld.uDeviceID, *lphMidiStrm, ret, lpMidiStrm);
1348     return ret;
1349 }
1350
1351 /**************************************************************************
1352  *                              midiStreamOut                   [WINMM.@]
1353  */
1354 MMRESULT WINAPI midiStreamOut(HMIDISTRM hMidiStrm, LPMIDIHDR lpMidiHdr,
1355                               UINT cbMidiHdr)
1356 {
1357     WINE_MIDIStream*    lpMidiStrm;
1358     DWORD               ret = MMSYSERR_NOERROR;
1359
1360     TRACE("(%p, %p, %u)!\n", hMidiStrm, lpMidiHdr, cbMidiHdr);
1361
1362     if (cbMidiHdr < offsetof(MIDIHDR,dwOffset) || !lpMidiHdr || !lpMidiHdr->lpData
1363         || lpMidiHdr->dwBufferLength < lpMidiHdr->dwBytesRecorded
1364         || lpMidiHdr->dwBytesRecorded % 4 /* player expects DWORD padding */)
1365         return MMSYSERR_INVALPARAM;
1366     /* FIXME: Native additionally checks if the MIDIEVENTs in lpData
1367      * exactly fit dwBytesRecorded. */
1368
1369     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
1370         return MIDIERR_UNPREPARED;
1371
1372     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
1373         return MIDIERR_STILLPLAYING;
1374
1375     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
1376         ret = MMSYSERR_INVALHANDLE;
1377     } else {
1378         lpMidiHdr->dwFlags |= MHDR_ISSTRM | MHDR_INQUEUE;
1379         lpMidiHdr->dwFlags &= ~MHDR_DONE;
1380         if (!PostThreadMessageA(lpMidiStrm->dwThreadID,
1381                                 WINE_MSM_HEADER, cbMidiHdr,
1382                                 (LPARAM)lpMidiHdr)) {
1383             ERR("bad PostThreadMessageA\n");
1384             ret = MMSYSERR_ERROR;
1385         }
1386     }
1387     return ret;
1388 }
1389
1390 /**************************************************************************
1391  *                              midiStreamPause                 [WINMM.@]
1392  */
1393 MMRESULT WINAPI midiStreamPause(HMIDISTRM hMidiStrm)
1394 {
1395     WINE_MIDIStream*    lpMidiStrm;
1396     DWORD               ret = MMSYSERR_NOERROR;
1397
1398     TRACE("(%p)!\n", hMidiStrm);
1399
1400     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
1401         return MMSYSERR_INVALHANDLE;
1402     PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_PAUSE, 0, 0);
1403     return ret;
1404 }
1405
1406 /**************************************************************************
1407  *                              midiStreamPosition              [WINMM.@]
1408  */
1409 MMRESULT WINAPI midiStreamPosition(HMIDISTRM hMidiStrm, LPMMTIME lpMMT, UINT cbmmt)
1410 {
1411     WINE_MIDIStream*    lpMidiStrm;
1412     DWORD               ret = MMSYSERR_NOERROR;
1413
1414     TRACE("(%p, %p, %u)!\n", hMidiStrm, lpMMT, cbmmt);
1415
1416     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL)) {
1417         ret = MMSYSERR_INVALHANDLE;
1418     } else if (lpMMT == NULL || cbmmt != sizeof(MMTIME)) {
1419         ret = MMSYSERR_INVALPARAM;
1420     } else {
1421         switch (lpMMT->wType) {
1422         default:
1423             FIXME("Unsupported time type %x\n", lpMMT->wType);
1424         case TIME_BYTES:
1425         case TIME_SAMPLES:
1426             lpMMT->wType = TIME_MS;
1427             /* fall through to alternative format */
1428         case TIME_MS:
1429             lpMMT->u.ms = lpMidiStrm->dwPositionMS;
1430             TRACE("=> %d ms\n", lpMMT->u.ms);
1431             break;
1432         case TIME_TICKS:
1433             lpMMT->u.ticks = lpMidiStrm->dwPulses;
1434             TRACE("=> %d ticks\n", lpMMT->u.ticks);
1435             break;
1436         }
1437     }
1438     return ret;
1439 }
1440
1441 /**************************************************************************
1442  *                              midiStreamProperty              [WINMM.@]
1443  */
1444 MMRESULT WINAPI midiStreamProperty(HMIDISTRM hMidiStrm, LPBYTE lpPropData, DWORD dwProperty)
1445 {
1446     WINE_MIDIStream*    lpMidiStrm;
1447     MMRESULT            ret = MMSYSERR_NOERROR;
1448
1449     TRACE("(%p, %p, %x)\n", hMidiStrm, lpPropData, dwProperty);
1450
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;
1457
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);
1466         }
1467     } else if (dwProperty & MIDIPROP_TIMEDIV) {
1468         MIDIPROPTIMEDIV*        mptd = (MIDIPROPTIMEDIV*)lpPropData;
1469
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);
1478         }
1479     } else {
1480         ret = MMSYSERR_INVALPARAM;
1481     }
1482
1483     return ret;
1484 }
1485
1486 /**************************************************************************
1487  *                              midiStreamRestart               [WINMM.@]
1488  */
1489 MMRESULT WINAPI midiStreamRestart(HMIDISTRM hMidiStrm)
1490 {
1491     WINE_MIDIStream*    lpMidiStrm;
1492     MMRESULT            ret = MMSYSERR_NOERROR;
1493
1494     TRACE("(%p)!\n", hMidiStrm);
1495
1496     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
1497         return MMSYSERR_INVALHANDLE;
1498     PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_RESUME, 0, 0);
1499     return ret;
1500 }
1501
1502 /**************************************************************************
1503  *                              midiStreamStop                  [WINMM.@]
1504  */
1505 MMRESULT WINAPI midiStreamStop(HMIDISTRM hMidiStrm)
1506 {
1507     WINE_MIDIStream*    lpMidiStrm;
1508     MMRESULT            ret = MMSYSERR_NOERROR;
1509
1510     TRACE("(%p)!\n", hMidiStrm);
1511
1512     if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
1513         return MMSYSERR_INVALHANDLE;
1514     PostThreadMessageA(lpMidiStrm->dwThreadID, WINE_MSM_STOP, 0, 0);
1515     return ret;
1516 }
1517
1518 struct mm_starter
1519 {
1520     LPTASKCALLBACK      cb;
1521     DWORD               client;
1522     HANDLE              event;
1523 };
1524
1525 static DWORD WINAPI mmTaskRun(void* pmt)
1526 {
1527     struct mm_starter mms;
1528
1529     memcpy(&mms, pmt, sizeof(struct mm_starter));
1530     HeapFree(GetProcessHeap(), 0, pmt);
1531     mms.cb(mms.client);
1532     if (mms.event) SetEvent(mms.event);
1533     return 0;
1534 }
1535
1536 /******************************************************************
1537  *              mmTaskCreate (WINMM.@)
1538  */
1539 UINT     WINAPI mmTaskCreate(LPTASKCALLBACK cb, HANDLE* ph, DWORD_PTR client)
1540 {
1541     HANDLE               hThread;
1542     HANDLE               hEvent = 0;
1543     struct mm_starter   *mms;
1544
1545     mms = HeapAlloc(GetProcessHeap(), 0, sizeof(struct mm_starter));
1546     if (mms == NULL) return TASKERR_OUTOFMEMORY;
1547
1548     mms->cb = cb;
1549     mms->client = client;
1550     if (ph) hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1551     mms->event = hEvent;
1552
1553     hThread = CreateThread(0, 0, mmTaskRun, mms, 0, NULL);
1554     if (!hThread) {
1555         HeapFree(GetProcessHeap(), 0, mms);
1556         if (hEvent) CloseHandle(hEvent);
1557         return TASKERR_OUTOFMEMORY;
1558     }
1559     SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
1560     if (ph) *ph = hEvent;
1561     CloseHandle(hThread);
1562     return 0;
1563 }
1564
1565 /******************************************************************
1566  *              mmTaskBlock (WINMM.@)
1567  */
1568 VOID     WINAPI mmTaskBlock(DWORD tid)
1569 {
1570     MSG         msg;
1571
1572     do
1573     {
1574         GetMessageA(&msg, 0, 0, 0);
1575         if (msg.hwnd) DispatchMessageA(&msg);
1576     } while (msg.message != WM_USER);
1577 }
1578
1579 /******************************************************************
1580  *              mmTaskSignal (WINMM.@)
1581  */
1582 BOOL     WINAPI mmTaskSignal(DWORD tid)
1583 {
1584     return PostThreadMessageW(tid, WM_USER, 0, 0);
1585 }
1586
1587 /******************************************************************
1588  *              mmTaskYield (WINMM.@)
1589  */
1590 VOID     WINAPI mmTaskYield(VOID) {}
1591
1592 /******************************************************************
1593  *              mmGetCurrentTask (WINMM.@)
1594  */
1595 DWORD    WINAPI mmGetCurrentTask(VOID)
1596 {
1597     return GetCurrentThreadId();
1598 }