From: Jörg Höhle Date: Wed, 27 Jan 2010 17:32:23 +0000 (+0100) Subject: winmm/tests: Initial set of MIDI tests. X-Git-Tag: wine-1.1.38~112 X-Git-Url: http://git.etersoft.ru/projects/?a=commitdiff_plain;h=771a29da8693a958ae24ae67cf030537cdeedf06;p=wine%2Feterwine.git winmm/tests: Initial set of MIDI tests. --- diff --git a/dlls/winmm/tests/Makefile.in b/dlls/winmm/tests/Makefile.in index bf63dc31e5..5b89f1ee60 100644 --- a/dlls/winmm/tests/Makefile.in +++ b/dlls/winmm/tests/Makefile.in @@ -8,6 +8,7 @@ IMPORTS = winmm user32 kernel32 CTESTS = \ capture.c \ mci.c \ + midi.c \ mixer.c \ mmio.c \ timer.c \ diff --git a/dlls/winmm/tests/midi.c b/dlls/winmm/tests/midi.c new file mode 100644 index 0000000000..082cf3c387 --- /dev/null +++ b/dlls/winmm/tests/midi.c @@ -0,0 +1,485 @@ +/* + * Test winmm midi + * + * Copyright 2010 Jörg Höhle + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include +#include "windows.h" +#include "mmsystem.h" +#include "wine/test.h" + +extern const char* mmsys_error(MMRESULT error); /* from wave.c */ + +/* Test in order of increasing probability to hang. + * On many UNIX systems, the Timidity softsynth provides + * MIDI sequencer services and it is not particularly robust. + */ + +#define MYCBINST 0x4CAFE5A8 /* not used with window or thread callbacks */ +#define WHATEVER 0xFEEDF00D + +static BOOL spurious_message(LPMSG msg) +{ + /* WM_DEVICECHANGE 0x0219 appears randomly */ + if(msg->message == WM_DEVICECHANGE) { + trace("skipping spurious message %04x\n", msg->message); + return TRUE; + } + return FALSE; +} + +static UINT cbmsg = 0; +static DWORD_PTR cbval1 = WHATEVER; +static DWORD_PTR cbval2 = 0; +static DWORD_PTR cbinst = MYCBINST; + +static void CALLBACK callback_func(HWAVEOUT hwo, UINT uMsg, + DWORD_PTR dwInstance, + DWORD_PTR dwParam1, DWORD_PTR dwParam2) +{ + if (winetest_debug>1) + trace("Callback! msg=%x %lx %lx\n", uMsg, dwParam1, dwParam2); + cbmsg = uMsg; + cbval1 = dwParam1; /* mhdr or 0 */ + cbval2 = dwParam2; /* always 0 */ + cbinst = dwInstance; /* MYCBINST, see midiOut/StreamOpen */ +} + +static void test_notification(HWND hwnd, const char* command, UINT m1, DWORD_PTR p2) +{ /* Use message type 0 as meaning no message */ + MSG msg; + if (hwnd) { + /* msg.wParam is hmidiout, msg.lParam is the mhdr (or 0) */ + BOOL seen; + do { seen = PeekMessageA(&msg, hwnd, 0, 0, PM_REMOVE); } + while(seen && spurious_message(&msg)); + if (seen) { + trace("Message %x, wParam=%lx, lParam=%lx from %s\n", + msg.message, msg.wParam, msg.lParam, command); + ok(msg.hwnd==hwnd, "Didn't get the handle to our test window\n"); + ok(msg.message==m1 && msg.lParam==p2, "bad message %x/%lx from %s, expect %x/%lx\n", msg.message, msg.lParam, command, m1, p2); + } + else ok(m1==0, "Expect message %x from %s\n", m1, command); + } + else { + /* FIXME: MOM_POSITIONCB and MOM_DONE are so close that a queue is needed. */ + if (cbmsg) { + ok(cbmsg==m1 && cbval1==p2 && cbval2==0, "bad callback %x/%lx/%lx from %s, expect %x/%lx\n", cbmsg, cbval1, cbval2, command, m1, p2); + cbmsg = 0; /* Mark as read */ + cbval1 = cbval2 = WHATEVER; + ok(cbinst==MYCBINST, "callback dwInstance changed to %lx\n", cbinst); + } + else ok(m1==0, "Expect callback %x from %s\n", m1, command); + } +} + + +static void test_midiIn_device(UINT udev, HWND hwnd) +{ + HMIDIIN hm; + MMRESULT rc; + MIDIINCAPSA capsA; + MIDIHDR mhdr; + + rc = midiInGetDevCapsA(udev, &capsA, sizeof(capsA)); + ok((MIDIMAPPER==udev) ? (rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/)) : rc==0, + "midiInGetDevCaps(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + if (!rc) { + /* MIDI IN capsA.dwSupport may contain garbage, absent in old MS-Windows */ + trace("* %s: manufacturer=%d, product=%d, support=%X\n", capsA.szPname, capsA.wMid, capsA.wPid, capsA.dwSupport); + } + + if (hwnd) + rc = midiInOpen(&hm, udev, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW); + else + rc = midiInOpen(&hm, udev, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION); + ok((MIDIMAPPER!=udev) ? rc==0 : (rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/)), + "midiInOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + if (rc) return; + + test_notification(hwnd, "midiInOpen", MIM_OPEN, 0); + + mhdr.dwFlags = 0; + mhdr.dwUser = 0x56FA552C; + mhdr.dwBufferLength = 70000; /* > 64KB! */ + mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength); + ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength); + if (mhdr.lpData) { + rc = midiInPrepareHeader(hm, &mhdr, sizeof(mhdr)); + todo_wine ok(!rc, "midiInPrepare rc=%s\n", mmsys_error(rc)); + rc = midiInUnprepareHeader(hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiInUnprepare rc=%s\n", mmsys_error(rc)); + trace("MIDIHDR flags=%x when unsent\n", mhdr.dwFlags); + + HeapFree(GetProcessHeap(), 0, mhdr.lpData); + } + ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser); + + rc = midiInReset(hm); /* Return any pending buffer */ + ok(!rc, "midiInReset rc=%s\n", mmsys_error(rc)); + + rc = midiInClose(hm); + ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc)); + test_notification(hwnd, "midiInClose", MIM_CLOSE, 0); + test_notification(hwnd, "midiIn over", 0, WHATEVER); +} + +static void test_midi_infns(HWND hwnd) +{ + HMIDIIN hm; + MMRESULT rc; + UINT udev, ndevs = midiInGetNumDevs(); + + rc = midiInOpen(&hm, ndevs, 0, 0, CALLBACK_NULL); + ok(rc==MMSYSERR_BADDEVICEID, "midiInOpen udev>max rc=%s\n", mmsys_error(rc)); + if (!rc) { + rc = midiInClose(hm); + ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc)); + } + if (!ndevs) { + trace("Found no MIDI IN device\n"); /* no skip for this common situation */ + rc = midiInOpen(&hm, MIDIMAPPER, 0, 0, CALLBACK_NULL); + ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/), "midiInOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc)); + if (!rc) { + rc = midiInClose(hm); + ok(!rc, "midiInClose rc=%s\n", mmsys_error(rc)); + } + return; + } + trace("Found %d MIDI IN devices\n", ndevs); + for (udev=0; udev < ndevs; udev++) { + trace("** Testing device %d\n", udev); + test_midiIn_device(udev, hwnd); + Sleep(50); + } + trace("** Testing MIDI mapper\n"); + test_midiIn_device(MIDIMAPPER, hwnd); +} + + +static void test_midi_mci(HWND hwnd) +{ + MCIERROR err; + char buf[1024]; + memset(buf, 0, sizeof(buf)); + + err = mciSendString("sysinfo sequencer quantity", buf, sizeof(buf), hwnd); + ok(!err, "mci sysinfo sequencer quantity returned %d\n", err); + if (!err) trace("Found %s MCI sequencer devices\n", buf); +} + + +static void test_midiOut_device(UINT udev, HWND hwnd) +{ + HMIDIOUT hm; + MMRESULT rc; + MIDIOUTCAPSA capsA; + DWORD ovolume; + MIDIHDR mhdr; + + rc = midiOutGetDevCapsA(udev, &capsA, sizeof(capsA)); + ok(!rc, "midiOutGetDevCaps(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + if (!rc) { + trace("* %s: manufacturer=%d, product=%d, tech=%d, support=%X: %d voices, %d notes\n", + capsA.szPname, capsA.wMid, capsA.wPid, capsA.wTechnology, capsA.dwSupport, capsA.wVoices, capsA.wNotes); + } + + if (hwnd) + rc = midiOutOpen(&hm, udev, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW); + else + rc = midiOutOpen(&hm, udev, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION); + if (MIDIMAPPER==udev) todo_wine + ok(!rc, "midiOutOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + else + ok(!rc, "midiOutOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + if (rc) return; + + test_notification(hwnd, "midiOutOpen", MOM_OPEN, 0); + + rc = midiOutGetVolume(hm, &ovolume); + ok(rc==((capsA.dwSupport & MIDICAPS_VOLUME) ? MMSYSERR_NOERROR : MMSYSERR_NOTSUPPORTED), "midiOutGetVolume rc=%s\n", mmsys_error(rc)); + /* The native mapper responds with FFFFFFFF initially, + * real devices with the volume GUI SW-synth settings. */ + if (!rc) trace("Current volume %x on device %d\n", ovolume, udev); + + /* Tests with midiOutSetvolume show that the midi mapper forwards + * the value to the real device, but Get initially always reports + * FFFFFFFF. Therefore, a Get+SetVolume pair with the mapper is + * not adequate to restore the value prior to tests. + */ + if (winetest_interactive && (capsA.dwSupport & MIDICAPS_VOLUME)) { + DWORD volume2 = (ovolume < 0x80000000) ? 0xC000C000 : 0x40004000; + rc = midiOutSetVolume(hm, volume2); + ok(!rc, "midiOutSetVolume rc=%s\n", mmsys_error(rc)); + if (!rc) { + DWORD volume3; + rc = midiOutGetVolume(hm, &volume3); + ok(!rc, "midiOutGetVolume new rc=%s\n", mmsys_error(rc)); + if (!rc) trace("New volume %x on device %d\n", volume3, udev); + todo_wine ok(volume2==volume3, "volume Set %x = Get %x\n", volume2, volume3); + + rc = midiOutSetVolume(hm, ovolume); + ok(!rc, "midiOutSetVolume restore rc=%s\n", mmsys_error(rc)); + } + } + rc = midiOutGetDevCapsA((UINT)hm, &capsA, sizeof(capsA)); + ok(!rc, "midiOutGetDevCaps(dev=%d) by handle rc=%s\n", udev, mmsys_error(rc)); + rc = midiInGetDevCapsA((UINT)hm, (LPMIDIINCAPSA)&capsA, sizeof(DWORD)); + ok(rc==MMSYSERR_BADDEVICEID, "midiInGetDevCaps(dev=%d) by out handle rc=%s\n", udev, mmsys_error(rc)); + + { DWORD e = 0x006F4893; /* velocity, note (#69 would be 440Hz) channel */ + trace("ShortMsg type %x\n", LOBYTE(LOWORD(e))); + rc = midiOutShortMsg(hm, e); + ok(!rc, "midiOutShortMsg rc=%s\n", mmsys_error(rc)); + if (!rc) Sleep(400); /* Hear note */ + } + + mhdr.dwFlags = 0; + mhdr.dwUser = 0x56FA552C; + mhdr.dwBufferLength = 70000; /* > 64KB! */ + mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength); + ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength); + if (mhdr.lpData) { + rc = midiOutLongMsg(hm, &mhdr, sizeof(mhdr)); + ok(rc==MIDIERR_UNPREPARED, "midiOutLongMsg unprepared rc=%s\n", mmsys_error(rc)); + test_notification(hwnd, "midiOutLong unprepared", 0, WHATEVER); + + rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr)); + todo_wine ok(!rc, "midiOutPrepare rc=%s\n", mmsys_error(rc)); + rc = midiOutUnprepareHeader(hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc)); + trace("MIDIHDR flags=%x when unsent\n", mhdr.dwFlags); + + HeapFree(GetProcessHeap(), 0, mhdr.lpData); + } + ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser); + + rc = midiOutReset(hm); /* Quiet everything */ + ok(!rc, "midiOutReset rc=%s\n", mmsys_error(rc)); + + rc = midiOutClose(hm); + ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc)); + test_notification(hwnd, "midiOutClose", MOM_CLOSE, 0); + test_notification(hwnd, "midiOut over", 0, WHATEVER); +} + +static void test_position(HMIDISTRM hm, UINT typein, UINT typeout) +{ + MMRESULT rc; + MMTIME mmtime; + mmtime.wType = typein; + rc = midiStreamPosition(hm, &mmtime, sizeof(MMTIME)); + /* Ugly, but a single ok() herein enables using the todo_wine prefix */ + ok(!rc && (mmtime.wType == typeout), "midiStreamPosition type %x converted to %x rc=%s\n", typein, mmtime.wType, mmsys_error(rc)); + if (!rc) switch(mmtime.wType) { + case TIME_MS: + trace("Stream position %ums\n", mmtime.u.ms); + break; + case TIME_TICKS: + trace("Stream position %u ticks\n", mmtime.u.ticks); + break; + case TIME_MIDI: + trace("Stream position song pointer %u\n", mmtime.u.midi.songptrpos); + break; + } +} + +static BYTE strmEvents[] = { /* A set of variable-sized MIDIEVENT structs */ + 0, 0, 0, 0, 0, 0, 0, 0, /* dwDeltaTime and dwStreamID */ + 0, 0, 0, MEVT_NOP | 0x40, /* with MEVT_F_CALLBACK */ + 0, 0, 0, 0, 0, 0, 0, 0, /* dwDeltaTime and dwStreamID */ + 0x93, 0x48, 0x6F, MEVT_SHORTMSG, +}; + +static void test_midiStream(UINT udev, HWND hwnd) +{ + HMIDISTRM hm; + MMRESULT rc, rc2; + MIDIHDR mhdr; + + if (hwnd) + rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)hwnd, (DWORD_PTR)MYCBINST, CALLBACK_WINDOW); + else + rc = midiStreamOpen(&hm, &udev, 1, (DWORD_PTR)callback_func, (DWORD_PTR)MYCBINST, CALLBACK_FUNCTION); + if (MIDIMAPPER==udev) todo_wine + ok(!rc, "midiStreamOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + else + ok(!rc, "midiStreamOpen(dev=%d) rc=%s\n", udev, mmsys_error(rc)); + if (rc) return; + + test_notification(hwnd, "midiStreamOpen", MOM_OPEN, 0); + + mhdr.dwFlags = 0; + mhdr.dwUser = 0x56FA552C; + mhdr.dwBufferLength = sizeof(strmEvents) * sizeof(strmEvents[0]); + mhdr.dwBytesRecorded = mhdr.dwBufferLength; /* unused? */ + mhdr.lpData = (LPSTR)&strmEvents[0]; + if (mhdr.lpData) { + rc = midiOutLongMsg((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(rc==MIDIERR_UNPREPARED, "midiOutLongMsg unprepared rc=%s\n", mmsys_error(rc)); + test_notification(hwnd, "midiOutLong unprepared", 0, WHATEVER); + + rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutPrepare rc=%s\n", mmsys_error(rc)); + ok(mhdr.dwFlags & MHDR_PREPARED, "MHDR.dwFlags when prepared %x\n", mhdr.dwFlags); + + /* The device is still in paused mode and should queue the message. */ + rc = midiStreamOut(hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiStreamOut rc=%s\n", mmsys_error(rc)); + rc2 = rc; + trace("MIDIHDR flags=%x when submitted\n", mhdr.dwFlags); + /* w9X/me does not set MHDR_ISSTRM when StreamOut exits, + * but it will be set on all systems after the job is finished. */ + + Sleep(90); + /* Wine starts playing immediately */ + /*todo_wine test_notification(hwnd, "midiStream still paused", 0, WHATEVER);*/ + + /* MSDN asks to use midiStreamRestart prior to midiStreamOut() + * because the starting state is 'pause', but some apps seem to + * work with the inverse order. + */ + + rc = midiStreamRestart(hm); + ok(!rc, "midiStreamRestart rc=%s\n", mmsys_error(rc)); + + if (!rc2) while(mhdr.dwFlags & MHDR_INQUEUE) { + trace("async MIDI still queued\n"); + Sleep(100); + } /* Checking INQUEUE is not the recommended way to wait for the end of a job, but we're testing. */ + /* MHDR_ISSTRM is not necessarily set when midiStreamOut returns + * rather than when the queue is eventually processed. */ + ok(mhdr.dwFlags & MHDR_ISSTRM, "MHDR.dwFlags %x no ISSTRM when out of queue\n", mhdr.dwFlags); + if (!rc2) while(!(mhdr.dwFlags & MHDR_DONE)) { + /* Never to be seen except perhaps on multicore */ + trace("async MIDI still not done\n"); + Sleep(100); + } + ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags %x not DONE when out of queue\n", mhdr.dwFlags); + test_notification(hwnd, "midiStream callback", MOM_POSITIONCB, (DWORD)&mhdr); + test_notification(hwnd, "midiStreamOut", MOM_DONE, (DWORD)&mhdr); + + rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc)); + rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutUnprepare #2 rc=%s\n", mmsys_error(rc)); + + trace("MIDIHDR stream flags=%x when finished\n", mhdr.dwFlags); + ok(mhdr.dwFlags & MHDR_DONE, "MHDR.dwFlags when done %x\n", mhdr.dwFlags); + + test_position(hm, TIME_MS, TIME_MS); + test_position(hm, TIME_TICKS, TIME_TICKS); + todo_wine test_position(hm, TIME_MIDI, TIME_MIDI); + test_position(hm, TIME_SMPTE, TIME_MS); + test_position(hm, TIME_SAMPLES, TIME_MS); + test_position(hm, TIME_BYTES, TIME_MS); + + Sleep(400); /* Hear note */ + + rc = midiStreamRestart(hm); + ok(!rc, "midiStreamRestart #2 rc=%s\n", mmsys_error(rc)); + + mhdr.dwFlags |= MHDR_ISSTRM; /* just in case */ + /* Preset flags (e.g. MHDR_ISSTRM) do not disturb. */ + rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutPrepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc)); + rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutUnprepare used flags %x rc=%s\n", mhdr.dwFlags, mmsys_error(rc)); + + rc = midiStreamRestart(hm); + ok(!rc, "midiStreamRestart #3 rc=%s\n", mmsys_error(rc)); + } + ok(mhdr.dwUser==0x56FA552C, "MIDIHDR.dwUser changed to %lx\n", mhdr.dwUser); + + rc = midiStreamStop(hm); + ok(!rc, "midiStreamStop rc=%s\n", mmsys_error(rc)); + + mhdr.dwBufferLength = 70000; /* > 64KB! */ + mhdr.lpData = HeapAlloc(GetProcessHeap(), 0 , mhdr.dwBufferLength); + ok(mhdr.lpData!=NULL, "No %d bytes of memory!\n", mhdr.dwBufferLength); + if (mhdr.lpData) { + mhdr.dwFlags = 0; + /* PrepareHeader detects the too large buffer is for a stream. */ + rc = midiOutPrepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare stream too large rc=%s\n", mmsys_error(rc)); + + rc = midiOutUnprepareHeader((HMIDIOUT)hm, &mhdr, sizeof(mhdr)); + ok(!rc, "midiOutUnprepare rc=%s\n", mmsys_error(rc)); + + HeapFree(GetProcessHeap(), 0, mhdr.lpData); + } + + rc = midiStreamClose(hm); + ok(!rc, "midiStreamClose rc=%s\n", mmsys_error(rc)); + test_notification(hwnd, "midiStreamClose", MOM_CLOSE, 0); + test_notification(hwnd, "midiStream over", 0, WHATEVER); +} + +static void test_midi_outfns(HWND hwnd) +{ + HMIDIOUT hm; + MMRESULT rc; + UINT udev, ndevs = midiOutGetNumDevs(); + + rc = midiOutOpen(&hm, ndevs, 0, 0, CALLBACK_NULL); + ok(rc==MMSYSERR_BADDEVICEID, "midiOutOpen udev>max rc=%s\n", mmsys_error(rc)); + if (!rc) { + rc = midiOutClose(hm); + ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc)); + } + if (!ndevs) { + skip("Found no MIDI out device\n"); + rc = midiOutOpen(&hm, MIDIMAPPER, 0, 0, CALLBACK_NULL); + if (rc==MIDIERR_INVALIDSETUP) todo_wine /* Wine without snd-seq */ + ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*w2k*/), "midiOutOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc)); + else + ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*w2k sound disabled*/), + "midiOutOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc)); + if (!rc) { + rc = midiOutClose(hm); + ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc)); + } + return; + } + trace("Found %d MIDI OUT devices\n", ndevs); + + test_midi_mci(hwnd); + + for (udev=0; udev < ndevs; udev++) { + trace("** Testing device %d\n", udev); + test_midiOut_device(udev, hwnd); + Sleep(800); /* Let the synth rest */ + test_midiStream(udev, hwnd); + Sleep(800); + } + trace("** Testing MIDI mapper\n"); + test_midiOut_device(MIDIMAPPER, hwnd); + Sleep(800); + test_midiStream(MIDIMAPPER, hwnd); +} + +START_TEST(midi) +{ + HWND hwnd; + if (1) /* select 1 for CALLBACK_WINDOW or 0 for CALLBACK_FUNCTION */ + hwnd = CreateWindowExA(0, "static", "winmm midi test", WS_POPUP, 0,0,100,100, + 0, 0, 0, NULL); + test_midi_infns(hwnd); + test_midi_outfns(hwnd); + if (hwnd) DestroyWindow(hwnd); +}