1 /*
2 * Test winmm midi
3 *
4 * Copyright 2010 Jörg Höhle
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define _WINE
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stddef.h>
27 #include "windows.h"
28 #include "mmsystem.h"
29 #include "objbase.h"
30 #include "wine/test.h"
31
32 extern const char* mmsys_error(MMRESULT error); /* from wave.c */
33
34 /* Test in order of increasing probability to hang.
35 * On many UNIX systems, the Timidity softsynth provides
36 * MIDI sequencer services and it is not particularly robust.
37 */
38
39 #define MYCBINST 0x4CAFE5A8 /* not used with window or thread callbacks */
40 #define WHATEVER 0xFEEDF00D
41
spurious_message(LPMSG msg)42 static BOOL spurious_message(LPMSG msg)
43 {
44 /* WM_DEVICECHANGE 0x0219 appears randomly */
45 if(msg->message == WM_DEVICECHANGE) {
46 trace("skipping spurious message %04x\n", msg->message);
47 return TRUE;
48 }
49 return FALSE;
50 }
51
52 static UINT cbmsg = 0;
53 static DWORD_PTR cbval1 = WHATEVER;
54 static DWORD_PTR cbval2 = 0;
55 static DWORD_PTR cbinst = MYCBINST;
56
callback_func(HWAVEOUT hwo,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)57 static void CALLBACK callback_func(HWAVEOUT hwo, UINT uMsg,
58 DWORD_PTR dwInstance,
59 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
60 {
61 if (winetest_debug>1)
62 trace("Callback! msg=%x %lx %lx\n", uMsg, dwParam1, dwParam2);
63 cbmsg = uMsg;
64 cbval1 = dwParam1; /* mhdr or 0 */
65 cbval2 = dwParam2; /* always 0 */
66 cbinst = dwInstance; /* MYCBINST, see midiOut/StreamOpen */
67 }
68
69 #define test_notification(hwnd, command, m1, p2) test_notification_dbg(hwnd, command, m1, p2, __LINE__)
test_notification_dbg(HWND hwnd,const char * command,UINT m1,DWORD_PTR p2,int line)70 static void test_notification_dbg(HWND hwnd, const char* command, UINT m1, DWORD_PTR p2, int line)
71 { /* Use message type 0 as meaning no message */
72 MSG msg;
73 if (hwnd) {
74 /* msg.wParam is hmidiout, msg.lParam is the mhdr (or 0) */
75 BOOL seen;
76 do { seen = PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE); }
77 while(seen && spurious_message(&msg));
78 if (m1 && !seen) {
79 /* We observe transient delayed notification, mostly on native.
80 * Perhaps the OS preempts the player thread after setting MHDR_DONE
81 * or clearing MHDR_INQUEUE, before calling DriverCallback. */
82 DWORD rc;
83 trace_(__FILE__,line)("Waiting for delayed message %x from %s\n", m1, command);
84 SetLastError(0xDEADBEEF);
85 rc = MsgWaitForMultipleObjects(0, NULL, FALSE, 3000, QS_POSTMESSAGE);
86 ok_(__FILE__,line)(rc==WAIT_OBJECT_0, "Wait failed: %04x %d\n", rc, GetLastError());
87 seen = PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE);
88 }
89 if (seen) {
90 trace_(__FILE__,line)("Message %x, wParam=%lx, lParam=%lx from %s\n",
91 msg.message, msg.wParam, msg.lParam, command);
92 ok_(__FILE__,line)(msg.hwnd==hwnd, "Didn't get the handle to our test window\n");
93 ok_(__FILE__,line)(msg.message==m1 && msg.lParam==p2, "bad message %x/%lx from %s, expect %x/%lx\n", msg.message, msg.lParam, command, m1, p2);
94 }
95 else ok_(__FILE__,line)(m1==0, "Expect message %x from %s\n", m1, command);
96 }
97 else {
98 /* FIXME: MOM_POSITIONCB and MOM_DONE are so close that a queue is needed. */
99 if (cbmsg) {
100 ok_(__FILE__,line)(cbmsg==m1 && cbval1==p2 && cbval2==0, "bad callback %x/%lx/%lx from %s, expect %x/%lx\n", cbmsg, cbval1, cbval2, command, m1, p2);
101 cbmsg = 0; /* Mark as read */
102 cbval1 = cbval2 = WHATEVER;
103 ok_(__FILE__,line)(cbinst==MYCBINST, "callback dwInstance changed to %lx\n", cbinst);
104 }
105 else ok_(__FILE__,line)(m1==0, "Expect callback %x from %s\n", m1, command);
106 }
107 }
108
109
test_midiIn_device(UINT udev,HWND hwnd)110 static void test_midiIn_device(UINT udev, HWND hwnd)
111 {
112 HMIDIIN hm;
113 MMRESULT rc;
114 MIDIINCAPSA capsA;
115 MIDIHDR mhdr;
116
117 rc = midiInGetDevCapsA(udev, &capsA, sizeof(capsA));
118 ok((MIDIMAPPER==udev) ? (rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/)) : rc==0,
119 "midiInGetDevCaps(dev=%d) rc=%s\n", udev, mmsys_error(rc));
120 if (!rc) {
121 /* MIDI IN capsA.dwSupport may contain garbage, absent in old MS-Windows */
122 trace("* %s: manufacturer=%d, product=%d, support=%X\n", capsA.szPname, capsA.wMid, capsA.wPid, capsA.dwSupport);
123 }
124
125 if (hwnd)
126 rc = midiInOpen(&hm, udev, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
127 else
128 rc = midiInOpen(&hm, udev, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
129 ok((MIDIMAPPER!=udev) ? rc==0 : (rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/)),
130 "midiInOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
131 if (rc) return;
132
133 test_notification(hwnd, "midiInOpen", MIM_OPEN, 0);
134
135 memset(&mhdr, 0, sizeof(mhdr));
136 mhdr.dwFlags = MHDR_DONE;
137 mhdr.dwUser = 0x56FA552C;
138 mhdr.dwBufferLength = 70000; /* > 64KB! */
139 mhdr.dwBytesRecorded = 5;
140 mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength);
141 ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength);
142 if (mhdr.lpData) {
143 rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset)-1);
144 ok(rc==MMSYSERR_INVALPARAM, "midiInPrepare tiny rc=%s\n", mmsys_error(rc));
145 ok(mhdr.dwFlags == MHDR_DONE, "dwFlags=%x\n", mhdr.dwFlags);
146
147 mhdr.dwFlags |= MHDR_INQUEUE;
148 rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
149 ok(!rc, "midiInPrepare old size rc=%s\n", mmsys_error(rc));
150 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_INQUEUE|MHDR_DONE)/*w9x*/ ||
151 mhdr.dwFlags == MHDR_PREPARED, "dwFlags=%x\n", mhdr.dwFlags);
152 trace("MIDIHDR flags=%x when unsent\n", mhdr.dwFlags);
153
154 mhdr.dwFlags |= MHDR_INQUEUE|MHDR_DONE;
155 rc = midiInPrepareHeader(hm, &mhdr, sizeof(mhdr));
156 ok(!rc, "midiInPrepare rc=%s\n", mmsys_error(rc));
157 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_INQUEUE|MHDR_DONE), "dwFlags=%x\n", mhdr.dwFlags);
158
159 mhdr.dwFlags &= ~MHDR_INQUEUE;
160 rc = midiInUnprepareHeader(hm, &mhdr, sizeof(mhdr));
161 ok(!rc, "midiInUnprepare rc=%s\n", mmsys_error(rc));
162 ok(mhdr.dwFlags == MHDR_DONE, "dwFlags=%x\n", mhdr.dwFlags);
163
164 mhdr.dwFlags &= ~MHDR_DONE;
165 rc = midiInUnprepareHeader(hm, &mhdr, sizeof(mhdr));
166 ok(!rc, "midiInUnprepare rc=%s\n", mmsys_error(rc));
167 ok(mhdr.dwFlags == 0, "dwFlags=%x\n", mhdr.dwFlags);
168
169 rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
170 ok(!rc, "midiInPrepare rc=%s\n", mmsys_error(rc));
171 ok(mhdr.dwFlags == MHDR_PREPARED, "dwFlags=%x\n", mhdr.dwFlags);
172
173 mhdr.dwFlags |= MHDR_DONE;
174 rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
175 ok(!rc, "midiInPrepare rc=%s\n", mmsys_error(rc));
176 ok(mhdr.dwBytesRecorded == 5, "BytesRec=%u\n", mhdr.dwBytesRecorded);
177
178 mhdr.dwFlags |= MHDR_DONE;
179 rc = midiInAddBuffer(hm, &mhdr, sizeof(mhdr));
180 ok(!rc, "midiAddBuffer rc=%s\n", mmsys_error(rc));
181 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_INQUEUE), "dwFlags=%x\n", mhdr.dwFlags);
182
183 /* w95 does not set dwBytesRecorded=0 within midiInAddBuffer. Wine does. */
184 if (mhdr.dwBytesRecorded != 0)
185 trace("dwBytesRecorded %u\n", mhdr.dwBytesRecorded);
186
187 rc = midiInAddBuffer(hm, &mhdr, sizeof(mhdr));
188 ok(rc==MIDIERR_STILLPLAYING, "midiAddBuffer rc=%s\n", mmsys_error(rc));
189
190 rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
191 ok(!rc, "midiInPrepare rc=%s\n", mmsys_error(rc));
192 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_INQUEUE), "dwFlags=%x\n", mhdr.dwFlags);
193 }
194 rc = midiInReset(hm); /* Return any pending buffer */
195 ok(!rc, "midiInReset rc=%s\n", mmsys_error(rc));
196 test_notification(hwnd, "midiInReset", MIM_LONGDATA, (DWORD_PTR)&mhdr);
197
198 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_DONE), "dwFlags=%x\n", mhdr.dwFlags);
199 rc = midiInUnprepareHeader(hm, &mhdr, sizeof(mhdr));
200 ok(!rc, "midiInUnprepare rc=%s\n", mmsys_error(rc));
201
202 ok(mhdr.dwBytesRecorded == 0, "Did some MIDI HW send %u bytes?\n", mhdr.dwBytesRecorded);
203
204 rc = midiInClose(hm);
205 ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc));
206
207 ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
208 HeapFree(GetProcessHeap(), 0, mhdr.lpData);
209 test_notification(hwnd, "midiInClose", MIM_CLOSE, 0);
210 test_notification(hwnd, "midiIn over", 0, WHATEVER);
211 }
212
test_midi_infns(HWND hwnd)213 static void test_midi_infns(HWND hwnd)
214 {
215 HMIDIIN hm;
216 MMRESULT rc;
217 UINT udev, ndevs = midiInGetNumDevs();
218
219 rc = midiInOpen(&hm, ndevs, 0, 0, CALLBACK_NULL);
220 ok(rc==MMSYSERR_BADDEVICEID, "midiInOpen udev>max rc=%s\n", mmsys_error(rc));
221 if (!rc) {
222 rc = midiInClose(hm);
223 ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc));
224 }
225 if (!ndevs) {
226 trace("Found no MIDI IN device\n"); /* no skip for this common situation */
227 rc = midiInOpen(&hm, MIDIMAPPER, 0, 0, CALLBACK_NULL);
228 ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/), "midiInOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
229 if (!rc) {
230 rc = midiInClose(hm);
231 ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc));
232 }
233 return;
234 }
235 trace("Found %d MIDI IN devices\n", ndevs);
236 for (udev=0; udev < ndevs; udev++) {
237 trace("** Testing device %d\n", udev);
238 test_midiIn_device(udev, hwnd);
239 Sleep(50);
240 }
241 trace("** Testing MIDI mapper\n");
242 test_midiIn_device(MIDIMAPPER, hwnd);
243 }
244
245
test_midi_mci(HWND hwnd)246 static void test_midi_mci(HWND hwnd)
247 {
248 MCIERROR err;
249 char buf[1024];
250 memset(buf, 0, sizeof(buf));
251
252 err = mciSendStringA("sysinfo sequencer quantity", buf, sizeof(buf), hwnd);
253 ok(!err, "mci sysinfo sequencer quantity returned %d\n", err);
254 if (!err) trace("Found %s MCI sequencer devices\n", buf);
255
256 if (!strcmp(buf, "0")) return;
257
258 err = mciSendStringA("capability sequencer can record", buf, sizeof(buf), hwnd);
259 ok(!err, "mci sysinfo sequencer quantity returned %d\n", err);
260 if(!err) ok(!strcmp(buf, "false"), "capability can record is %s\n", buf);
261 }
262
263 static BYTE SysEx_reset[] = {
264 0xF0, 0x7E, 0x7F, 0x09, 0x01, 0xF7 /* GM System ON */
265 };
266 static BYTE SysEx_volume_off[] = {
267 0xF0, 0x7F, 0x7F, 0x04, 0x01, 0x00, 0x00, 0xF7
268 };
269 static BYTE SysEx_volume_full[] = {
270 0xF0, 0x7F, 0x7F, 0x04, 0x01, 0x00, 0x7F, 0xF7
271 };
272 static BOOL found_fluidsynth;
273 static const char fluidsynth_prefix[] = "Synth input port ";
274
test_midiOut_device(UINT udev,HWND hwnd)275 static void test_midiOut_device(UINT udev, HWND hwnd)
276 {
277 HMIDIOUT hm;
278 MMRESULT rc;
279 MIDIOUTCAPSA capsA;
280 DWORD ovolume;
281 UINT udevid;
282 MIDIHDR mhdr;
283
284 rc = midiOutGetDevCapsA(udev, &capsA, sizeof(capsA));
285 ok(!rc, "midiOutGetDevCaps(dev=%d) rc=%s\n", udev, mmsys_error(rc));
286 if (!rc) {
287 trace("* %s: manufacturer=%d, product=%d, tech=%d, support=%X: %d voices, %d notes\n",
288 capsA.szPname, capsA.wMid, capsA.wPid, capsA.wTechnology, capsA.dwSupport, capsA.wVoices, capsA.wNotes);
289 ok(!((MIDIMAPPER==udev) ^ (MOD_MAPPER==capsA.wTechnology)), "technology %d on device %d\n", capsA.wTechnology, udev);
290 if (MOD_MIDIPORT == capsA.wTechnology) {
291 ok(capsA.wVoices == 0 && capsA.wNotes == 0, "external device with notes or voices\n");
292 ok(capsA.wChannelMask == 0xFFFF, "external device channel mask %x\n", capsA.wChannelMask);
293 ok(!(capsA.dwSupport & (MIDICAPS_VOLUME|MIDICAPS_LRVOLUME|MIDICAPS_CACHE)), "external device support=%X\n", capsA.dwSupport);
294 }
295 }
296
297 if (hwnd)
298 rc = midiOutOpen(&hm, udev, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
299 else
300 rc = midiOutOpen(&hm, udev, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
301 if (rc == MMSYSERR_NOTSUPPORTED || rc == MMSYSERR_NODRIVER)
302 {
303 skip( "MIDI out not supported\n" );
304 return;
305 }
306 ok(!rc, "midiOutOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
307 if (rc) return;
308
309 test_notification(hwnd, "midiOutOpen", MOM_OPEN, 0);
310
311 rc = midiOutGetVolume(hm, &ovolume);
312 ok((capsA.dwSupport & MIDICAPS_VOLUME) ? rc==MMSYSERR_NOERROR : rc==MMSYSERR_NOTSUPPORTED, "midiOutGetVolume rc=%s\n", mmsys_error(rc));
313 /* The native mapper responds with FFFFFFFF initially,
314 * real devices with the volume GUI SW-synth settings. */
315 if (!rc) trace("Current volume %x on device %d\n", ovolume, udev);
316
317 /* The W95 ESFM Synthesis device reports NOTENABLED although
318 * GetVolume by handle works and music plays. */
319 rc = midiOutGetVolume(UlongToHandle(udev), &ovolume);
320 ok((capsA.dwSupport & MIDICAPS_VOLUME) ? rc==MMSYSERR_NOERROR || broken(rc==MMSYSERR_NOTENABLED) : rc==MMSYSERR_NOTSUPPORTED, "midiOutGetVolume(dev=%d) rc=%s\n", udev, mmsys_error(rc));
321
322 rc = midiOutGetVolume(hm, NULL);
323 ok(rc==MMSYSERR_INVALPARAM, "midiOutGetVolume NULL rc=%s\n", mmsys_error(rc));
324
325 /* Tests with midiOutSetvolume show that the midi mapper forwards
326 * the value to the real device, but Get initially always reports
327 * FFFFFFFF. Therefore, a Get+SetVolume pair with the mapper is
328 * not adequate to restore the value prior to tests.
329 */
330 if (winetest_interactive && (capsA.dwSupport & MIDICAPS_VOLUME)) {
331 DWORD volume2 = (ovolume < 0x80000000) ? 0xC000C000 : 0x40004000;
332 rc = midiOutSetVolume(hm, volume2);
333 ok(!rc, "midiOutSetVolume rc=%s\n", mmsys_error(rc));
334 if (!rc) {
335 DWORD volume3;
336 rc = midiOutGetVolume(hm, &volume3);
337 ok(!rc, "midiOutGetVolume new rc=%s\n", mmsys_error(rc));
338 if (!rc) trace("New volume %x on device %d\n", volume3, udev);
339 todo_wine ok(volume2==volume3, "volume Set %x = Get %x\n", volume2, volume3);
340
341 rc = midiOutSetVolume(hm, ovolume);
342 ok(!rc, "midiOutSetVolume restore rc=%s\n", mmsys_error(rc));
343 }
344 }
345 rc = midiOutGetDevCapsA((UINT_PTR)hm, &capsA, sizeof(capsA));
346 ok(!rc, "midiOutGetDevCaps(dev=%d) by handle rc=%s\n", udev, mmsys_error(rc));
347 rc = midiInGetDevCapsA((UINT_PTR)hm, (LPMIDIINCAPSA)&capsA, sizeof(DWORD));
348 ok(rc==MMSYSERR_BADDEVICEID, "midiInGetDevCaps(dev=%d) by out handle rc=%s\n", udev, mmsys_error(rc));
349
350 { DWORD e = 0x006F4893; /* velocity, note (#69 would be 440Hz) channel */
351 trace("ShortMsg type %x\n", LOBYTE(LOWORD(e)));
352 rc = midiOutShortMsg(hm, e);
353 ok(!rc, "midiOutShortMsg rc=%s\n", mmsys_error(rc));
354 if (!rc) Sleep(400); /* Hear note */
355 }
356
357 memset(&mhdr, 0, sizeof(mhdr));
358 mhdr.dwFlags = MHDR_DONE;
359 mhdr.dwUser = 0x56FA552C;
360 mhdr.dwOffset = 0xDEADBEEF;
361 mhdr.dwBufferLength = 70000; /* > 64KB! */
362 mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength);
363 ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength);
364 if (mhdr.lpData) {
365 rc = midiOutLongMsg(hm, &mhdr, sizeof(mhdr));
366 ok(rc==MIDIERR_UNPREPARED, "midiOutLongMsg unprepared rc=%s\n", mmsys_error(rc));
367 ok(mhdr.dwFlags == MHDR_DONE, "dwFlags=%x\n", mhdr.dwFlags);
368 test_notification(hwnd, "midiOutLong unprepared", 0, WHATEVER);
369
370 rc = midiOutPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset)-1);
371 ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare tiny rc=%s\n", mmsys_error(rc));
372 ok(mhdr.dwFlags == MHDR_DONE, "dwFlags=%x\n", mhdr.dwFlags);
373
374 /* Since at least w2k, midiOutPrepare clears the DONE and INQUEUE flags. w95 didn't. */
375 /* mhdr.dwFlags |= MHDR_INQUEUE; would cause w95 to return STILLPLAYING from Unprepare */
376 rc = midiOutPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
377 ok(!rc, "midiOutPrepare old size rc=%s\n", mmsys_error(rc));
378 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_DONE)/*w9x*/ ||
379 mhdr.dwFlags == MHDR_PREPARED, "dwFlags=%x\n", mhdr.dwFlags);
380 trace("MIDIHDR flags=%x when unsent\n", mhdr.dwFlags);
381
382 /* No flag is cleared when already prepared. */
383 mhdr.dwFlags |= MHDR_DONE|MHDR_INQUEUE;
384 rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr));
385 ok(!rc, "midiOutPrepare rc=%s\n", mmsys_error(rc));
386 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_DONE|MHDR_INQUEUE), "dwFlags=%x\n", mhdr.dwFlags);
387
388 mhdr.dwFlags |= MHDR_INQUEUE;
389 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
390 ok(rc==MIDIERR_STILLPLAYING, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
391 ok(mhdr.dwFlags == (MHDR_PREPARED|MHDR_DONE|MHDR_INQUEUE), "dwFlags=%x\n", mhdr.dwFlags);
392
393 mhdr.dwFlags &= ~MHDR_INQUEUE;
394 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
395 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
396 ok(mhdr.dwFlags == MHDR_DONE, "dwFlags=%x\n", mhdr.dwFlags);
397
398 mhdr.dwFlags |= MHDR_INQUEUE;
399 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
400 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
401 ok(mhdr.dwFlags == (MHDR_INQUEUE|MHDR_DONE), "dwFlags=%x\n", mhdr.dwFlags);
402
403 HeapFree(GetProcessHeap(), 0, mhdr.lpData);
404 }
405 ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
406 ok(mhdr.dwOffset==0xDEADBEEF, "MIDIHDR.dwOffset changed to %x\n", mhdr.dwOffset);
407
408 rc = midiOutGetID(hm, &udevid);
409 ok(!rc, "midiOutGetID rc=%s\n", mmsys_error(rc));
410 if(!rc) ok(udevid==udev, "midiOutGetID gives %d, expect %d\n", udevid, udev);
411
412 rc = midiOutReset(hm); /* Quiet everything */
413 ok(!rc, "midiOutReset rc=%s\n", mmsys_error(rc));
414
415 rc = midiOutClose(hm);
416 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
417 test_notification(hwnd, "midiOutClose", MOM_CLOSE, 0);
418
419 rc = midiOutOpen(&hm, udev, 0, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
420 /* w95 broken(rc==MMSYSERR_INVALPARAM) see WINMM_CheckCallback */
421 ok(!rc, "midiOutOpen(dev=%d) 0 CALLBACK_WINDOW rc=%s\n", udev, mmsys_error(rc));
422 /* PostMessage(hwnd=0) redirects to PostThreadMessage(GetCurrentThreadId())
423 * which PeekMessage((HWND)-1) queries. */
424 test_notification((HWND)-1, "midiOutOpen WINDOW->THREAD", 0, WHATEVER);
425 test_notification(hwnd, "midiOutOpen WINDOW", 0, WHATEVER);
426 if (!rc) {
427 rc = midiOutClose(hm);
428 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
429 test_notification((HWND)-1, "midiOutClose WINDOW->THREAD", 0, WHATEVER);
430 test_notification(hwnd, "midiOutClose", 0, WHATEVER);
431 }
432 test_notification(hwnd, "midiOut over", 0, WHATEVER);
433 if (!strncmp(capsA.szPname, fluidsynth_prefix, strlen(fluidsynth_prefix)) ||
434 (udev == MIDIMAPPER && found_fluidsynth)) {
435 found_fluidsynth = TRUE;
436 skip("FluidSynth (at least 1.1.6) doesn't support desired System Exclusive message.\n");
437 return;
438 }
439
440 if (hwnd)
441 rc = midiOutOpen(&hm, udev, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
442 else
443 rc = midiOutOpen(&hm, udev, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
444 ok(!rc, "midiOutOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
445 test_notification(hwnd, "midiOutOpen", MOM_OPEN, 0);
446
447 memset(&mhdr, 0, sizeof(mhdr));
448 mhdr.lpData = (LPSTR)SysEx_reset;
449 mhdr.dwBufferLength = sizeof(SysEx_reset);
450 rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr));
451 ok(!rc, "midiOutPrepareHeader rc=%s\n", mmsys_error(rc));
452 rc = midiOutLongMsg(hm, &mhdr, sizeof(mhdr));
453 ok(!rc, "midiOutLongMsg rc=%s\n", mmsys_error(rc));
454 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
455 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
456 test_notification(hwnd, "midiOutLongMsg", MOM_DONE, (DWORD_PTR)&mhdr);
457 Sleep(60);
458
459 mhdr.lpData = (LPSTR)SysEx_volume_off;
460 mhdr.dwBufferLength = sizeof(SysEx_volume_off);
461 rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr));
462 ok(!rc, "midiOutPrepareHeader rc=%s\n", mmsys_error(rc));
463 rc = midiOutLongMsg(hm, &mhdr, sizeof(mhdr));
464 ok(!rc, "midiOutLongMsg rc=%s\n", mmsys_error(rc));
465 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
466 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
467 test_notification(hwnd, "midiOutLongMsg", MOM_DONE, (DWORD_PTR)&mhdr);
468
469 {
470 DWORD e = 0x006F4593; /* velocity 111, note #69, channel 4 */
471 trace("ShortMsg type %x (muted)\n", LOBYTE(LOWORD(e)));
472 rc = midiOutShortMsg(hm, e);
473 ok(!rc, "midiOutShortMsg rc=%s\n", mmsys_error(rc));
474 /* We can't hear this voice due to volume settings */
475 if (!rc) Sleep(200);
476
477 rc = midiOutShortMsg(hm, 0x00004593); /* velocity 0 */
478 ok(!rc, "midiOutShortMsg rc=%s\n", mmsys_error(rc));
479 }
480
481 mhdr.lpData = (LPSTR)SysEx_volume_full;
482 mhdr.dwBufferLength = sizeof(SysEx_volume_full);
483 rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr));
484 ok(!rc, "midiOutPrepareHeader rc=%s\n", mmsys_error(rc));
485 rc = midiOutLongMsg(hm, &mhdr, sizeof(mhdr));
486 ok(!rc, "midiOutLongMsg rc=%s\n", mmsys_error(rc));
487 rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr));
488 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
489 test_notification(hwnd, "midiOutLongMsg", MOM_DONE, (DWORD_PTR)&mhdr);
490
491 rc = midiOutClose(hm);
492 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
493 test_notification(hwnd, "midiOuClose", MOM_CLOSE, 0);
494 }
495
test_position(HMIDISTRM hm,UINT typein,UINT typeout)496 static void test_position(HMIDISTRM hm, UINT typein, UINT typeout)
497 {
498 MMRESULT rc;
499 MMTIME mmtime;
500 mmtime.wType = typein;
501 rc = midiStreamPosition(hm, &mmtime, sizeof(MMTIME));
502 /* Ugly, but a single ok() herein enables using the todo_wine prefix */
503 ok(!rc && (mmtime.wType == typeout), "midiStreamPosition type %x converted to %x rc=%s\n", typein, mmtime.wType, mmsys_error(rc));
504 if (!rc) switch(mmtime.wType) {
505 case TIME_MS:
506 trace("Stream position %ums\n", mmtime.u.ms);
507 break;
508 case TIME_TICKS:
509 trace("Stream position %u ticks\n", mmtime.u.ticks);
510 break;
511 case TIME_MIDI:
512 trace("Stream position song pointer %u\n", mmtime.u.midi.songptrpos);
513 break;
514 case TIME_SMPTE:
515 trace("Stream position %02u:%02u:%02u.%02u/%02u\n",
516 mmtime.u.smpte.hour, mmtime.u.smpte.min, mmtime.u.smpte.sec,
517 mmtime.u.smpte.frame, mmtime.u.smpte.fps);
518 break;
519 }
520 }
521
522 typedef struct midishortevent_tag { /* ideal size for MEVT_F_SHORT event type */
523 DWORD dwDeltaTime;
524 DWORD dwStreamID;
525 DWORD dwEvent;
526 } MIDISHORTEVENT;
527
528 /* Native crashes on a second run with the const qualifier set on this data! */
529 static BYTE strmEvents[] = { /* A set of variable-sized MIDIEVENT structs */
530 0, 0, 0, 0, 0, 0, 0, 0, /* dwDeltaTime and dwStreamID */
531 0, 0, 0, MEVT_NOP | 0x40, /* with MEVT_F_CALLBACK */
532 0, 0, 0, 0, 0, 0, 0, 0,
533 0xE0, 0x93, 0x04, MEVT_TEMPO, /* 0493E0 == 300000 */
534 0, 0, 0, 0, 0, 0, 0, 0,
535 0x93, 0x48, 0x6F, MEVT_SHORTMSG,
536 };
537
538 static MIDISHORTEVENT strmNops[] = { /* Test callback + dwOffset */
539 { 0, 0, (MEVT_NOP <<24)| MEVT_F_CALLBACK },
540 { 0, 0, (MEVT_NOP <<24)| MEVT_F_CALLBACK },
541 };
542
543 static MIDISHORTEVENT strmNopsWithDelta[] = {
544 { 0, 0, (MEVT_NOP <<24)| MEVT_F_CALLBACK },
545 { 12, 0, (MEVT_NOP <<24)| MEVT_F_CALLBACK },
546 };
547
548 struct time_stamp_records {
549 UINT count;
550 DWORD time_stamp[2];
551 HANDLE done;
552 };
553
time_stamp_callback(HMIDIOUT hmo,UINT msg,DWORD_PTR instance,DWORD_PTR p1,DWORD_PTR p2)554 static void CALLBACK time_stamp_callback(HMIDIOUT hmo, UINT msg, DWORD_PTR instance, DWORD_PTR p1, DWORD_PTR p2)
555 {
556 struct time_stamp_records *records = (struct time_stamp_records *)instance;
557 switch (msg) {
558 case MM_MOM_POSITIONCB:
559 if (records->count < ARRAY_SIZE(records->time_stamp))
560 records->time_stamp[records->count] = GetTickCount();
561 records->count++;
562 break;
563 case MM_MOM_DONE:
564 SetEvent(records->done);
565 break;
566 }
567 }
568
get_position(HMIDISTRM hm,UINT type)569 static DWORD get_position(HMIDISTRM hm, UINT type)
570 {
571 MMRESULT rc;
572 MMTIME mmtime;
573 mmtime.wType = type;
574 rc = midiStreamPosition(hm, &mmtime, sizeof(mmtime));
575 if (rc != MMSYSERR_NOERROR || mmtime.wType != type)
576 return MAXDWORD;
577
578 switch (mmtime.wType) {
579 case TIME_MS:
580 return mmtime.u.ms;
581 case TIME_TICKS:
582 return mmtime.u.ticks;
583 case TIME_MIDI:
584 return mmtime.u.midi.songptrpos;
585 default:
586 return MAXDWORD;
587 }
588 }
589
playStream(HMIDISTRM hm,LPMIDIHDR lpMidiHdr)590 static MMRESULT playStream(HMIDISTRM hm, LPMIDIHDR lpMidiHdr)
591 {
592 MMRESULT rc = midiStreamOut(hm, lpMidiHdr, sizeof(MIDIHDR));
593 /* virtual machines may return MIDIERR_STILLPLAYING from the next request
594 * even after MHDR_DONE is set. It's still too early, so add MHDR_INQUEUE. */
595 if (!rc) while (!(lpMidiHdr->dwFlags & MHDR_DONE) || (lpMidiHdr->dwFlags & MHDR_INQUEUE)) { Sleep(100); }
596 return rc;
597 }
598
test_midiStream(UINT udev,HWND hwnd)599 static void test_midiStream(UINT udev, HWND hwnd)
600 {
601 HMIDISTRM hm;
602 MMRESULT rc, rc2;
603 MIDIHDR mhdr;
604 union {
605 MIDIPROPTEMPO tempo;
606 MIDIPROPTIMEDIV tdiv;
607 } midiprop;
608 DWORD diff, expected, ret;
609 const DWORD MARGIN = 50;
610 struct time_stamp_records records;
611 MIDIOUTCAPSA capsA;
612
613 if (hwnd)
614 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
615 else
616 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
617 if (rc == MMSYSERR_NOTSUPPORTED || rc == MMSYSERR_NODRIVER)
618 {
619 skip( "MIDI stream not supported\n" );
620 return;
621 }
622 ok(!rc, "midiStreamOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
623 if (rc) return;
624
625 test_notification(hwnd, "midiStreamOpen", MOM_OPEN, 0);
626
627 midiprop.tempo.cbStruct = sizeof(midiprop.tempo);
628 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TEMPO);
629 ok(!rc, "midiStreamProperty TEMPO rc=%s\n", mmsys_error(rc));
630 ok(midiprop.tempo.dwTempo==500000, "default stream tempo %u microsec per quarter note\n", midiprop.tempo.dwTempo);
631
632 midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
633 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TIMEDIV);
634 ok(!rc, "midiStreamProperty TIMEDIV rc=%s\n", mmsys_error(rc));
635 ok(24==LOWORD(midiprop.tdiv.dwTimeDiv), "default stream time division %u\n", midiprop.tdiv.dwTimeDiv);
636
637 memset(&mhdr, 0, sizeof(mhdr));
638 mhdr.dwUser = 0x56FA552C;
639 mhdr.dwOffset = 1234567890;
640 mhdr.dwBufferLength = sizeof(strmEvents);
641 mhdr.dwBytesRecorded = mhdr.dwBufferLength;
642 mhdr.lpData = (LPSTR)&strmEvents[0];
643 if (mhdr.lpData) {
644 rc = midiOutLongMsg((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
645 ok(rc==MIDIERR_UNPREPARED, "midiOutLongMsg unprepared rc=%s\n", mmsys_error(rc));
646 test_notification(hwnd, "midiOutLong unprepared", 0, WHATEVER);
647
648 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, offsetof(MIDIHDR,dwOffset)-1);
649 ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare tiny rc=%s\n", mmsys_error(rc));
650 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
651 ok(!rc, "midiOutPrepare size rc=%s\n", mmsys_error(rc));
652 ok(mhdr.dwFlags & MHDR_PREPARED, "MHDR.dwFlags when prepared %x\n", mhdr.dwFlags);
653
654 /* The device is still in paused mode and should queue the message. */
655 rc = midiStreamOut(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
656 ok(!rc, "midiStreamOut old size rc=%s\n", mmsys_error(rc));
657 rc2 = rc;
658 trace("MIDIHDR flags=%x when submitted\n", mhdr.dwFlags);
659 /* w9X/me does not set MHDR_ISSTRM when StreamOut exits,
660 * but it will be set on all systems after the job is finished. */
661
662 Sleep(90);
663 /* Wine <1.1.39 started playing immediately */
664 test_notification(hwnd, "midiStream still paused", 0, WHATEVER);
665
666 /* MSDN asks to use midiStreamRestart prior to midiStreamOut()
667 * because the starting state is 'pause', but some apps seem to
668 * work with the inverse order: queue everything, then play.
669 */
670
671 rc = midiStreamRestart(hm);
672 ok(!rc, "midiStreamRestart rc=%s\n", mmsys_error(rc));
673
674 if (!rc2) while(mhdr.dwFlags & MHDR_INQUEUE) {
675 trace("async MIDI still queued\n");
676 Sleep(100);
677 } /* Checking INQUEUE is not the recommended way to wait for the end of a job, but we're testing. */
678 /* MHDR_ISSTRM is not necessarily set when midiStreamOut returns
679 * rather than when the queue is eventually processed. */
680 ok(mhdr.dwFlags & MHDR_ISSTRM, "MHDR.dwFlags %x no ISSTRM when out of queue\n", mhdr.dwFlags);
681 if (!rc2) while(!(mhdr.dwFlags & MHDR_DONE)) {
682 /* Never to be seen except perhaps on multicore */
683 trace("async MIDI still not done\n");
684 Sleep(100);
685 }
686 ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags %x not DONE when out of queue\n", mhdr.dwFlags);
687 test_notification(hwnd, "midiStream callback", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
688 test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD_PTR)&mhdr);
689
690 /* Native fills dwOffset regardless of the cbMidiHdr size argument to midiStreamOut */
691 ok(1234567890!=mhdr.dwOffset, "play left MIDIHDR.dwOffset at %u\n", mhdr.dwOffset);
692
693 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
694 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
695 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
696 ok(!rc, "midiOutUnprepare #2 rc=%s\n", mmsys_error(rc));
697
698 trace("MIDIHDR stream flags=%x when finished\n", mhdr.dwFlags);
699 ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags when done %x\n", mhdr.dwFlags);
700
701 test_position(hm, TIME_MS, TIME_MS);
702 test_position(hm, TIME_TICKS, TIME_TICKS);
703 test_position(hm, TIME_MIDI, TIME_MIDI);
704 test_position(hm, TIME_SMPTE, TIME_MS);
705 test_position(hm, TIME_SAMPLES, TIME_MS);
706 test_position(hm, TIME_BYTES, TIME_MS);
707
708 Sleep(400); /* Hear note */
709
710 midiprop.tempo.cbStruct = sizeof(midiprop.tempo);
711 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET|MIDIPROP_TEMPO);
712 ok(!rc, "midiStreamProperty TEMPO rc=%s\n", mmsys_error(rc));
713 ok(0x0493E0==midiprop.tempo.dwTempo, "stream set tempo %u\n", midiprop.tdiv.dwTimeDiv);
714
715 rc = midiStreamRestart(hm);
716 ok(!rc, "midiStreamRestart #2 rc=%s\n", mmsys_error(rc));
717
718 mhdr.dwFlags |= MHDR_ISSTRM;
719 /* Preset flags (e.g. MHDR_ISSTRM) do not disturb. */
720 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
721 ok(!rc, "midiOutPrepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc));
722 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
723 ok(!rc, "midiOutUnprepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc));
724
725 rc = midiStreamRestart(hm);
726 ok(!rc, "midiStreamRestart #3 rc=%s\n", mmsys_error(rc));
727 }
728 ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
729 ok(0==((MIDISHORTEVENT*)&strmEvents)[0].dwStreamID, "dwStreamID set to %x\n", ((LPMIDIEVENT)&strmEvents[0])->dwStreamID);
730
731 /* dwBytesRecorded controls how much is played, not dwBufferLength
732 * allowing to immediately forward packets from midiIn to midiOut */
733 mhdr.dwOffset = 1234123123;
734 mhdr.dwBufferLength = sizeof(strmNops);
735 trace("buffer: %u\n", mhdr.dwBufferLength);
736 mhdr.dwBytesRecorded = 0;
737 mhdr.lpData = (LPSTR)&strmNops[0];
738 strmNops[0].dwEvent |= MEVT_F_CALLBACK;
739 strmNops[1].dwEvent |= MEVT_F_CALLBACK;
740
741 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
742 ok(!rc, "midiOutPrepare rc=%s\n", mmsys_error(rc));
743
744 rc = playStream(hm, &mhdr);
745 ok(!rc, "midiStreamOut 0 bytes recorded rc=%s\n", mmsys_error(rc));
746
747 test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD_PTR)&mhdr);
748 test_notification(hwnd, "0 bytes recorded", 0, WHATEVER);
749
750 /* FIXME: check dwOffset within callback
751 * instead of the unspecified value afterwards */
752 ok(1234123123==mhdr.dwOffset || broken(0==mhdr.dwOffset), "play 0 set MIDIHDR.dwOffset to %u\n", mhdr.dwOffset);
753 /* w2k and later only set dwOffset when processing MEVT_T_CALLBACK,
754 * while w9X/me/nt always sets it. Have Wine behave like w2k because the
755 * dwOffset slot does not exist in the small size MIDIHDR. */
756
757 mhdr.dwOffset = 1234123123;
758 mhdr.dwBytesRecorded = 1*sizeof(MIDISHORTEVENT);
759
760 rc = playStream(hm, &mhdr);
761 ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
762
763 test_notification(hwnd, "1 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
764 test_notification(hwnd, "1 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
765 test_notification(hwnd, "1 of 2 events", 0, WHATEVER);
766 ok(0==mhdr.dwOffset, "MIDIHDR.dwOffset 1/2 changed to %u\n", mhdr.dwOffset);
767
768 mhdr.dwOffset = 1234123123;
769 mhdr.dwBytesRecorded = 2*sizeof(MIDISHORTEVENT);
770
771 rc = playStream(hm, &mhdr);
772 ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
773
774 test_notification(hwnd, "2 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
775 test_notification(hwnd, "2 of 2 events", MOM_POSITIONCB, (DWORD_PTR)&mhdr);
776 test_notification(hwnd, "2 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
777 test_notification(hwnd, "2 of 2 events", 0, WHATEVER);
778 ok(sizeof(MIDISHORTEVENT)==mhdr.dwOffset, "MIDIHDR.dwOffset 2/2 changed to %u\n", mhdr.dwOffset);
779 ok(mhdr.dwBytesRecorded == 2*sizeof(MIDISHORTEVENT), "dwBytesRecorded changed to %u\n", mhdr.dwBytesRecorded);
780
781 strmNops[0].dwEvent &= ~MEVT_F_CALLBACK;
782 strmNops[1].dwEvent &= ~MEVT_F_CALLBACK;
783 mhdr.dwOffset = 1234123123;
784 rc = playStream(hm, &mhdr);
785 ok(!rc, "midiStreamOut 1 event out of 2 rc=%s\n", mmsys_error(rc));
786
787 test_notification(hwnd, "0 CB in 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
788 test_notification(hwnd, "0 CB in 2 events", 0, WHATEVER);
789 /* w9X/me/nt set dwOffset to the position played last */
790 ok(1234123123==mhdr.dwOffset || broken(sizeof(MIDISHORTEVENT)==mhdr.dwOffset), "MIDIHDR.dwOffset nocb changed to %u\n", mhdr.dwOffset);
791
792 mhdr.dwBytesRecorded = mhdr.dwBufferLength-1;
793 rc = playStream(hm, &mhdr);
794 ok(rc==MMSYSERR_INVALPARAM,"midiStreamOut dwBytesRecorded modulo MIDIEVENT rc=%s\n", mmsys_error(rc));
795 if (!rc) {
796 test_notification(hwnd, "2 of 2 events", MOM_DONE, (DWORD_PTR)&mhdr);
797 }
798
799 mhdr.dwBytesRecorded = mhdr.dwBufferLength+1;
800 rc = playStream(hm, &mhdr);
801 ok(rc==MMSYSERR_INVALPARAM,"midiStreamOut dwBufferLength<dwBytesRecorded rc=%s\n", mmsys_error(rc));
802 test_notification(hwnd, "past MIDIHDR tests", 0, WHATEVER);
803
804 rc = midiStreamStop(hm);
805 ok(!rc, "midiStreamStop rc=%s\n", mmsys_error(rc));
806 ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser);
807
808 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
809 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
810 ok(0==strmNops[0].dwStreamID, "dwStreamID[0] set to %x\n", strmNops[0].dwStreamID);
811 ok(0==strmNops[1].dwStreamID, "dwStreamID[1] set to %x\n", strmNops[1].dwStreamID);
812
813 mhdr.dwBufferLength = 70000; /* > 64KB! */
814 mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength);
815 ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength);
816 if (mhdr.lpData) {
817 mhdr.dwFlags = 0;
818 /* PrepareHeader detects the too large buffer is for a stream. */
819 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
820 todo_wine ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare stream too large rc=%s\n", mmsys_error(rc));
821
822 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
823 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
824
825 HeapFree(GetProcessHeap(), 0, mhdr.lpData);
826 }
827
828 rc = midiStreamClose(hm);
829 ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
830 test_notification(hwnd, "midiStreamClose", MOM_CLOSE, 0);
831 test_notification(hwnd, "midiStream over", 0, WHATEVER);
832
833 rc = midiStreamOpen(&hm, &udev, 1, 0, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
834 ok(!rc /*w2k*/|| rc==MMSYSERR_INVALPARAM/*w98*/, "midiStreamOpen NULL function rc=%s\n", mmsys_error(rc));
835 if (!rc) {
836 trace("Device %d accepts NULL CALLBACK_FUNCTION\n", udev);
837 rc = midiStreamClose(hm);
838 ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
839 }
840
841 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)0xDEADBEEF, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
842 ok(rc==MMSYSERR_INVALPARAM, "midiStreamOpen bad window rc=%s\n", mmsys_error(rc));
843 if (!rc) {
844 rc = midiStreamClose(hm);
845 ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc));
846 }
847
848 /* Test the player time clock and positions */
849 memset(&records, 0, sizeof(records));
850 records.done = CreateEventA(NULL, FALSE, FALSE, NULL);
851 ok(records.done != NULL, "CreateEvent failed (dev=%d)\n", udev);
852
853 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)time_stamp_callback, (DWORD_PTR)&records, CALLBACK_FUNCTION);
854 ok(!rc, "midiStreamOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
855
856 expected = 0;
857 ret = get_position(hm, TIME_MS);
858 ok(ret == expected, "expected %u, got %u\n", expected, ret);
859
860 memset(&mhdr, 0, sizeof(mhdr));
861 mhdr.lpData = (LPSTR)strmNopsWithDelta;
862 mhdr.dwBytesRecorded = mhdr.dwBufferLength = sizeof(strmNopsWithDelta);
863 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
864 ok(!rc, "midiOutPrepareHeader(dev=%d) rc=%s\n", udev, mmsys_error(rc));
865
866 rc = midiStreamOut(hm, &mhdr, sizeof(mhdr));
867 ok(!rc, "midiStreamOut(dev=%d) rc=%s\n", udev, mmsys_error(rc));
868
869 ret = get_position(hm, TIME_MS);
870 ok(ret == expected, "expected %u, got %u\n", expected, ret);
871
872 rc = midiStreamRestart(hm);
873 ok(!rc, "midiStreamRestart(dev=%d) rc=%s\n", udev, mmsys_error(rc));
874 Sleep(50);
875
876 rc = midiStreamPause(hm);
877 ok(!rc, "midiStreamPause(dev=%d) rc=%s\n", udev, mmsys_error(rc));
878
879 expected = 50;
880 ret = get_position(hm, TIME_MS);
881 ok(ret >= expected && ret < expected + MARGIN, "expected %ums or greater, got %ums\n", expected, ret);
882 expected = ret;
883
884 Sleep(100);
885
886 ret = get_position(hm, TIME_MS);
887 ok(ret == expected, "expected %ums, got %ums\n", expected, ret);
888
889 rc = midiStreamRestart(hm);
890 ok(!rc, "midiStreamRestart(dev=%d) rc=%s\n", udev, mmsys_error(rc));
891
892 Sleep(1);
893 ret = get_position(hm, TIME_MS);
894 ok(ret > expected && ret < expected + MARGIN, "expected greater than %ums, got %ums\n", expected, ret);
895 expected = ret;
896
897 ret = get_position(hm, TIME_TICKS);
898 ok(ret > strmNopsWithDelta[0].dwDeltaTime && ret < strmNopsWithDelta[1].dwDeltaTime,
899 "TIME_TICKS position is continuous, got %u\n", ret);
900
901 /* shouldn't set time division property while playing */
902 midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
903 midiprop.tdiv.dwTimeDiv = 24;
904 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_SET | MIDIPROP_TIMEDIV);
905 ok(rc == MMSYSERR_INVALPARAM, "midiStreamProperty(SET|TIMEDIV, dev=%d) rc=%s\n", udev, mmsys_error(rc));
906
907 ret = WaitForSingleObject(records.done, INFINITE);
908 ok(ret == WAIT_OBJECT_0, "WaitForSingleObject failed, got %d\n", ret);
909
910 rc = midiStreamPause(hm);
911 ok(!rc, "midiStreamPause(dev=%d) rc=%s\n", udev, mmsys_error(rc));
912
913 expected = 250; /* = 12 ticks in 120 BPM */
914 ret = get_position(hm, TIME_MS);
915 ok(ret >= expected - MARGIN && ret <= expected + MARGIN,
916 "expected greater than %ums, got %ums\n", expected, ret);
917 trace("after playing, got %ums\n", ret);
918
919 /* set tempo to 240 BPM */
920 midiprop.tempo.cbStruct = sizeof(midiprop.tempo);
921 midiprop.tempo.dwTempo = 250000;
922 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_SET | MIDIPROP_TEMPO);
923 ok(!rc, "midiStreamProperty(SET|TEMPO, dev=%d) rc=%s\n", udev, mmsys_error(rc));
924
925 /* a tempo change doesn't affect elapsed ticks */
926 ret = get_position(hm, TIME_TICKS);
927 ok(ret >= strmNopsWithDelta[1].dwDeltaTime && ret < strmNopsWithDelta[1].dwDeltaTime + 3,
928 "expected %u ticks, got %u\n", strmNopsWithDelta[1].dwDeltaTime, ret);
929
930 midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
931 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_GET | MIDIPROP_TIMEDIV);
932 ok(!rc, "midiStreamProperty(GET|TIMEDIV, dev=%d) rc=%s\n", udev, mmsys_error(rc));
933 ok(midiprop.tdiv.dwTimeDiv == 24, "expected 24, got %u\n", midiprop.tdiv.dwTimeDiv);
934
935 /* TIME_MIDI value is a quarter of TIME_TICKS, rounded */
936 expected = (ret + midiprop.tdiv.dwTimeDiv/8) / (midiprop.tdiv.dwTimeDiv/4);
937 ret = get_position(hm, TIME_MIDI);
938 ok(ret == expected, "expected song pointer %u, got %u\n", expected, ret);
939
940 ok(records.count == 2, "expected 2 MM_MOM_DONE messages, got %d\n", records.count);
941
942 /* Time between midiStreamPause and midiStreamRestart isn't counted.
943 So, the second event happens at dwDeltaTime(250ms) + 100ms after the first event. */
944 expected = 250 + 100;
945 diff = records.time_stamp[1] - records.time_stamp[0];
946 ok(diff >= expected - MARGIN && diff <= expected + MARGIN,
947 "expected %u ~ %ums, got %ums (dev=%d)\n", expected - MARGIN, expected + MARGIN, diff, udev);
948
949 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
950 ok(!rc, "midiOutUnprepareHeader(dev=%d) rc=%s\n", udev, mmsys_error(rc));
951
952 rc = midiStreamStop(hm);
953 ok(!rc, "midiStreamStop(dev=%d) rc=%s\n", udev, mmsys_error(rc));
954
955 ret = get_position(hm, TIME_MS);
956 ok(ret == 0, "expected 0ms, got %ums\n", ret);
957
958 midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
959 midiprop.tdiv.dwTimeDiv = 0xe204; /* 30 fps, 4 ticks/frame */
960 rc = midiStreamProperty(hm, (void*)&midiprop, MIDIPROP_SET | MIDIPROP_TIMEDIV);
961 ok(!rc, "midiStreamProperty(SET|TIMEDIV, dev=%d) rc=%s\n", udev, mmsys_error(rc));
962
963 test_position(hm, TIME_MS, TIME_MS);
964 test_position(hm, TIME_TICKS, TIME_TICKS);
965 test_position(hm, TIME_MIDI, TIME_MS);
966 todo_wine test_position(hm, TIME_SMPTE, TIME_SMPTE);
967 test_position(hm, TIME_SAMPLES, TIME_MS);
968 test_position(hm, TIME_BYTES, TIME_MS);
969
970 rc = midiStreamClose(hm);
971 ok(!rc, "midiStreamClose(dev=%d) rc=%s\n", udev, mmsys_error(rc));
972 CloseHandle(records.done);
973
974 rc = midiOutGetDevCapsA((UINT_PTR)udev, &capsA, sizeof(capsA));
975 ok(!rc, "midiOutGetDevCaps(dev=%d) rc=%s\n", udev, mmsys_error(rc));
976 if (!strncmp(capsA.szPname, fluidsynth_prefix, strlen(fluidsynth_prefix)) ||
977 (udev == MIDIMAPPER && found_fluidsynth)) {
978 found_fluidsynth = TRUE;
979 skip("FluidSynth (at least 1.1.6) doesn't support desired System Exclusive message.\n");
980 return;
981 }
982
983 #define ROUNDUP4(n) (((n) + 3) & ~3)
984 hm = NULL;
985 if (hwnd)
986 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW);
987 else
988 rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION);
989 ok(!rc, "midiOutOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc));
990 test_notification(hwnd, "midiStreamOpen", MOM_OPEN, 0);
991
992 midiprop.tdiv.cbStruct = sizeof(midiprop.tdiv);
993 midiprop.tdiv.dwTimeDiv = 480;
994 rc = midiStreamProperty(hm, (LPBYTE)&midiprop, MIDIPROP_TIMEDIV | MIDIPROP_SET);
995 ok(!rc, "midiStreamProperty(TimeDiv) rc=%s\n", mmsys_error(rc));
996
997 rc = midiStreamRestart(hm);
998 ok(!rc, "midiStreamRestart rc=%s\n", mmsys_error(rc));
999
1000 memset(&mhdr, 0, sizeof(mhdr));
1001 mhdr.dwBufferLength = sizeof(MIDISHORTEVENT) * 5 + ROUNDUP4(sizeof(SysEx_reset)) +
1002 ROUNDUP4(sizeof(SysEx_volume_off)) + ROUNDUP4(sizeof(SysEx_volume_full));
1003 mhdr.lpData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mhdr.dwBufferLength);
1004 ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength);
1005 if (mhdr.lpData) {
1006 MIDIEVENT *e;
1007 char *p = mhdr.lpData;
1008 /* GM System ON */
1009 e = (MIDIEVENT *)p;
1010 e->dwEvent = MEVT_F_LONG | sizeof(SysEx_reset);
1011 memcpy(&e->dwParms[0], SysEx_reset, sizeof(SysEx_reset));
1012 p += sizeof(MIDISHORTEVENT) + ROUNDUP4(sizeof(SysEx_reset));
1013 /* Master volume: off */
1014 e = (MIDIEVENT *)p;
1015 e->dwDeltaTime = 96;
1016 e->dwEvent = MEVT_F_LONG | sizeof(SysEx_volume_off);
1017 memcpy(&e->dwParms[0], SysEx_volume_off, sizeof(SysEx_volume_off));
1018 p += sizeof(MIDISHORTEVENT) + ROUNDUP4(sizeof(SysEx_volume_off));
1019 /* Note On (We can't hear this voice due to volume settings) */
1020 e = (MIDIEVENT *)p;
1021 e->dwEvent = MEVT_F_SHORT | 0x6F4593; /* note #69 */
1022 p += sizeof(MIDISHORTEVENT);
1023 /* Note Off */
1024 e = (MIDIEVENT *)p;
1025 e->dwDeltaTime = 240;
1026 e->dwEvent = MEVT_F_SHORT | 0x004593; /* velocity 0 */
1027 p += sizeof(MIDISHORTEVENT);
1028 /* Master volume: full */
1029 e = (MIDIEVENT *)p;
1030 e->dwEvent = MEVT_F_LONG | sizeof(SysEx_volume_full);
1031 memcpy(&e->dwParms[0], SysEx_volume_full, sizeof(SysEx_volume_full));
1032 p += sizeof(MIDISHORTEVENT) + ROUNDUP4(sizeof(SysEx_volume_full));
1033 mhdr.dwBytesRecorded = (DWORD)(p - mhdr.lpData);
1034 #undef ROUNDUP4
1035
1036 rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
1037 ok(!rc, "midiOutPrepareHeader rc=%s\n", mmsys_error(rc));
1038
1039 rc = playStream(hm, &mhdr);
1040 ok(!rc, "midiStreamOut rc=%s\n", mmsys_error(rc));
1041 test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD_PTR)&mhdr);
1042
1043 rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr));
1044 ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc));
1045
1046 HeapFree(GetProcessHeap(), 0, mhdr.lpData);
1047 }
1048 rc = midiStreamClose(hm);
1049 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
1050 test_notification(hwnd, "midiStreamClose", MOM_CLOSE, 0);
1051 }
1052
scan_subkeys(HKEY parent,const LPCSTR * sub_keys)1053 static BOOL scan_subkeys(HKEY parent, const LPCSTR *sub_keys)
1054 {
1055 char name[64];
1056 DWORD index = 0;
1057 DWORD name_len = sizeof(name);
1058 BOOL found_vmware = FALSE;
1059
1060 if (sub_keys[0] == NULL)
1061 {
1062 /* We're at the deepest level, check "Identifier" value now */
1063 char *test;
1064 if (RegQueryValueExA(parent, "Identifier", NULL, NULL, (LPBYTE) name, &name_len) != ERROR_SUCCESS)
1065 return FALSE;
1066 for (test = name; test < name + lstrlenA(name) - 6 && ! found_vmware; test++)
1067 {
1068 char c = test[6];
1069 test[6] = '\0';
1070 found_vmware = (lstrcmpiA(test, "VMware") == 0);
1071 test[6] = c;
1072 }
1073 return found_vmware;
1074 }
1075
1076 while (RegEnumKeyExA(parent, index, name, &name_len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS &&
1077 ! found_vmware) {
1078 char c = name[lstrlenA(sub_keys[0])];
1079 name[lstrlenA(sub_keys[0])] = '\0';
1080 if (lstrcmpiA(name, sub_keys[0]) == 0) {
1081 HKEY sub_key;
1082 name[lstrlenA(sub_keys[0])] = c;
1083 if (RegOpenKeyExA(parent, name, 0, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &sub_key) == ERROR_SUCCESS) {
1084 found_vmware = scan_subkeys(sub_key, sub_keys + 1);
1085 RegCloseKey(sub_key);
1086 }
1087 }
1088
1089 name_len = sizeof(name);
1090 index++;
1091 }
1092
1093 return found_vmware;
1094 }
1095
1096 /*
1097 * Usual method to detect whether running inside a VMware virtual machine involves direct port I/O requiring
1098 * some assembly and an exception handler. Can't do that in Wine tests. Alternative method of querying WMI
1099 * is not available on NT4. So instead we look at the device map and check the Identifier value in the
1100 * registry keys HKLM\HARDWARE\DEVICEMAP\SCSI\Scsi Port x\Scsi Bus x\Target Id x\Logical Unit Id x (where
1101 * x is some number). If the Identifier value contains the string "VMware" we assume running in a VMware VM.
1102 */
on_vmware(void)1103 static BOOL on_vmware(void)
1104 {
1105 static const LPCSTR sub_keys[] = { "Scsi Port ", "Scsi Bus ", "Target Id ", "Logical Unit Id ", NULL };
1106 HKEY scsi;
1107 BOOL found_vmware = FALSE;
1108
1109 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\Scsi", 0, KEY_ENUMERATE_SUB_KEYS, &scsi) != ERROR_SUCCESS)
1110 return FALSE;
1111
1112 found_vmware = scan_subkeys(scsi, sub_keys);
1113
1114 RegCloseKey(scsi);
1115
1116 return found_vmware;
1117 }
1118
test_midi_outfns(HWND hwnd)1119 static void test_midi_outfns(HWND hwnd)
1120 {
1121 HMIDIOUT hm;
1122 MMRESULT rc;
1123 UINT udev, ndevs = midiOutGetNumDevs();
1124
1125 rc = midiOutOpen(&hm, ndevs, 0, 0, CALLBACK_NULL);
1126 ok(rc==MMSYSERR_BADDEVICEID, "midiOutOpen udev>max rc=%s\n", mmsys_error(rc));
1127 if (!rc) {
1128 rc = midiOutClose(hm);
1129 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
1130 }
1131 if (!ndevs) {
1132 MIDIOUTCAPSA capsA;
1133 skip("Found no MIDI out device\n");
1134
1135 rc = midiOutGetDevCapsA(MIDIMAPPER, &capsA, sizeof(capsA));
1136 /* GetDevCaps and Open must return compatible results */
1137 ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/), "midiOutGetDevCaps MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
1138
1139 rc = midiOutOpen(&hm, MIDIMAPPER, 0, 0, CALLBACK_NULL);
1140 todo_wine_if (rc == MIDIERR_INVALIDSETUP) /* Wine without snd-seq */
1141 ok(rc == MMSYSERR_BADDEVICEID || broken(rc == MMSYSERR_NODRIVER /*w2k sound disabled*/),
1142 "midiOutOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
1143 if (!rc) {
1144 rc = midiOutClose(hm);
1145 ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
1146 }
1147 return;
1148 }
1149 trace("Found %d MIDI OUT devices\n", ndevs);
1150
1151 test_midi_mci(hwnd);
1152
1153 for (udev=0; udev < ndevs; udev++) {
1154 MIDIOUTCAPSA capsA;
1155 rc = midiOutGetDevCapsA(udev, &capsA, sizeof(capsA));
1156 if (rc || strcmp(capsA.szPname, "Creative Sound Blaster MPU-401") != 0 || ! on_vmware()) {
1157 trace("** Testing device %d\n", udev);
1158 test_midiOut_device(udev, hwnd);
1159 Sleep(800); /* Let the synth rest */
1160 test_midiStream(udev, hwnd);
1161 Sleep(800);
1162 }
1163 else
1164 win_skip("Skipping this device on VMware, driver problem\n");
1165 }
1166 trace("** Testing MIDI mapper\n");
1167 test_midiOut_device(MIDIMAPPER, hwnd);
1168 Sleep(800);
1169 test_midiStream(MIDIMAPPER, hwnd);
1170 }
1171
START_TEST(midi)1172 START_TEST(midi)
1173 {
1174 HWND hwnd = 0;
1175
1176 CoInitialize(NULL); /* Needed for Win 10 */
1177
1178 if (1) /* select 1 for CALLBACK_WINDOW or 0 for CALLBACK_FUNCTION */
1179 hwnd = CreateWindowExA(0, "static", "winmm midi test", WS_POPUP, 0,0,100,100,
1180 0, 0, 0, NULL);
1181 test_midi_infns(hwnd);
1182 test_midi_outfns(hwnd);
1183 if (hwnd) DestroyWindow(hwnd);
1184
1185 CoUninitialize();
1186 }
1187