// -----------------------------------------------------------------------
// しょきか〜
// -----------------------------------------------------------------------
void MIDI_Init(void) {
memset(DelayBuf, 0, sizeof(DelayBuf));
DBufPtrW = DBufPtrR = 0;
MIDI_SetModule();
MIDI_RegHigh = 0; // X68K
MIDI_Vector = 0; // X68K
MIDI_IntEnable = 0;
MIDI_IntVect = 0;
MIDI_IntFlag = 0;
MIDI_R05 = 0;
MIDI_CTRL = MIDICTRL_READY;
MIDI_LAST = 0x80;
MIDI_EXCVWAIT = 0;
if (!hOut) {
if (midiOutOpen(&hOut, MIDI_MAPPER, 0, 0, CALLBACK_NULL)
== MMSYSERR_NOERROR) {
midiOutReset(hOut);
}
else
hOut = 0;
}
}
void JackWinMMEDriver::CloseOutput(MidiSlot* slot)
{
MMRESULT res;
int retry = 0;
if (slot->fHandle == 0)
return;
HMIDIOUT handle = (HMIDIOUT)slot->fHandle;
res = midiOutReset(handle);
if (res != MMSYSERR_NOERROR)
jack_error("midiOutReset error");
midiOutUnprepareHeader(handle, slot->fHeader, sizeof(MIDIHDR));
do {
res = midiOutClose(handle);
if (res != MMSYSERR_NOERROR)
jack_error("midiOutClose error");
Sleep(10);
retry++;
} while ((res == MIDIERR_STILLPLAYING) && (retry < 10));
if (slot->fHeader) {
GlobalFreePtr(slot->fHeader);
}
}
static void midirelease(COMMNG self) {
CMMIDI midi;
midi = (CMMIDI)(self + 1);
midiallnoteoff(midi);
if (midi->opened & CMMIDI_MIDIOUT) {
waitlastexclusiveout(midi);
midiOutReset(midi->out.win32.hmidiout);
midiOutClose(midi->out.win32.hmidiout);
}
if (midi->opened & CMMIDI_MIDIIN) {
if (midi->opened & CMMIDI_MIDIINSTART) {
midiInStop(midi->hmidiin);
midiInUnprepareHeader(midi->hmidiin,
&midi->hmidiinhdr, sizeof(MIDIHDR));
}
midiInReset(midi->hmidiin);
midiInClose(midi->hmidiin);
midiinhdlunreg(midi);
}
#if defined(VERMOUTH_LIB)
if (midi->opened & CMMIDI_VERMOUTH) {
midiout_destroy(midi->out.vermouth);
}
#endif
#if defined(MT32SOUND_DLL)
if (midi->opened & CMMIDI_MT32SOUND) {
mt32sound_close();
}
#endif
_MFREE(self);
}
/* midi_win32_init:
*/
int midi_win32_init(int input, int voices)
{
MMRESULT hr;
int id;
/* deduce our device number from the driver ID code */
if ((midi_driver->id & 0xFF) == 'M')
/* we are using the midi mapper (driver id is WIN32M) */
id = MIDI_MAPPER;
else
/* actual driver */
id = (midi_driver->id & 0xFF) - 'A';
/* open midi mapper */
hr = midiOutOpen(&midi_device, id, 0, 0, CALLBACK_NULL);
if (hr != MMSYSERR_NOERROR) {
_TRACE(PREFIX_E "midiOutOpen failed (%x)\n", hr);
goto Error;
}
/* resets midi mapper */
midiOutReset(midi_device);
return 0;
Error:
midi_win32_exit(input);
return -1;
}
void closeMidi(void)
{
if (device_flag == MMSYSERR_NOERROR) {
midiOutReset(device);
midiOutClose(device);
}
device_flag = -1000;
}
//***********************************************************************
void MidiNoteStopAll( void )
//***********************************************************************
{
if ( !hMidiOut )
return;
midiOutReset( hMidiOut );
}
void RtMidiOut :: closePort( void )
{
if ( connected_ ) {
WinMidiData *data = static_cast<WinMidiData *> (apiData_);
midiOutReset( data->outHandle );
midiOutClose( data->outHandle );
connected_ = false;
}
}
void MidiOutPort_visual::closeAll(void) {
for (int i=0; i<getNumPorts(); i++) {
if (openQ[i] == 1 && device[i] != NULL) {
midiOutReset(device[i]);
midiOutClose(device[i]);
openQ[i] = 0;
}
}
}
/* midi_win32_exit:
*/
void midi_win32_exit(int input)
{
/* close midi stream and release device */
if (midi_device != NULL) {
midiOutReset(midi_device);
midiOutClose(midi_device);
midi_device = NULL;
}
}
// -----------------------------------------------------------------------
// 撤収〜
// -----------------------------------------------------------------------
void MIDI_Cleanup(void) {
if (hOut) {
MIDI_Reset();
MIDI_Waitlastexclusiveout();
midiOutReset(hOut);
midiOutClose(hOut);
hOut = 0;
}
}
static void msw_close_midiout(void)
{
int i;
for (i = 0; i < msw_nmidiout; i++)
{
midiOutReset(hMidiOut[i]);
midiOutClose(hMidiOut[i]);
}
msw_nmidiout = 0;
}
//***********************************************************************
void MidiNoteClose( void )
//***********************************************************************
{
if ( !hMidiOut )
return;
UINT wError;
wError = midiOutReset( hMidiOut );
wError = midiOutClose( hMidiOut );
hMidiOut = NULL;
}
static void DestroyOutputDevice(MFDevice *pDevice)
{
MFMidiPC_MidiOutputDevice *pDev = (MFMidiPC_MidiOutputDevice*)pDevice->pInternal;
if (pDev->hMidiOut)
{
MFDebug_Warn(1, MFStr("MIDI output device not closed: %s", pDevice->strings[MFDS_ID]));
midiOutReset(pDev->hMidiOut);
midiOutClose(pDev->hMidiOut);
}
MFHeap_Free(pDev);
}
void WinMIDIStreamer::Reset(void)
{
int i;
midiStreamStop(midiStr);
// Reset channel settings.
for(i = 0; i <= 0xf; ++i) // All channels.
{
midiOutShortMsg((HMIDIOUT) midiStr, 0xe0 | i | 64 << 16); // Pitch bend.
}
midiOutReset((HMIDIOUT) midiStr);
}
MF_API void MFMidi_CloseOutput(MFDevice *pDevice)
{
MFMidiPC_MidiOutputDevice *pMidi = (MFMidiPC_MidiOutputDevice*)pDevice->pInternal;
if (!pMidi->hMidiOut)
{
MFDebug_Warn(1, "Midi output device not opened!");
return;
}
midiOutReset(pMidi->hMidiOut);
midiOutClose(pMidi->hMidiOut);
pMidi->hMidiOut = NULL;
pDevice->state = MFDevState_Available;
}
void WinMIDIDevice::Stop()
{
if (PlayerThread != nullptr)
{
SetEvent(ExitEvent);
WaitForSingleObject(PlayerThread, INFINITE);
CloseHandle(PlayerThread);
PlayerThread = nullptr;
}
midiStreamStop(MidiOut);
midiOutReset((HMIDIOUT)MidiOut);
if (VolumeWorks)
{
midiOutSetVolume((HMIDIOUT)MidiOut, SavedVolume);
}
}
static DWORD modReset(MIDIMAPDATA* mom)
{
WORD chn;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom))
return MMSYSERR_ERROR;
for (chn = 0; chn < 16; chn++)
{
if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
{
ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
if (ret != MMSYSERR_NOERROR) break;
}
}
return ret;
}
void MIDISong2::Stop ()
{
if (PlayerThread)
{
SetEvent (ExitEvent);
WaitForSingleObject (PlayerThread, INFINITE);
CloseHandle (PlayerThread);
PlayerThread = NULL;
}
if (MidiOut)
{
midiOutReset (MidiOut);
if (VolumeWorks)
{
midiOutSetVolume (MidiOut, SavedVolume);
}
midiOutClose (MidiOut);
MidiOut = NULL;
}
}
/* closes the MIDI-Out device*/
void mididrv_out_close(void)
{
MMRESULT ret;
#ifdef DEBUG
log_message(mididrv_log, "out_close");
#endif
if (!handle_out) {
log_error(mididrv_log, "Attempt to close MIDI-Out device that wasn't open!");
return;
}
/* can theoretically return MMSYSERR_INVALHANDLE */
ret = midiOutReset(handle_out);
ret = midiOutClose(handle_out);
if (ret != MMSYSERR_NOERROR) {
log_error(mididrv_log, "Couldn't close MIDI-Out device.");
}
handle_out = 0;
}
void midiClose(void) {
MMRESULT res;
// printf("stop\n");
if (MMSYSERR_NOERROR != midiInStop(inHandle)) {
logPrintf(LOG_ERROR, "input stop error\n");
}
// printf("reset\n");
if (MMSYSERR_NOERROR != midiInReset(inHandle)) {
logPrintf(LOG_ERROR, "input reset error\n");
}
int retry = 0;
do {
res = midiInClose(inHandle);
if (res != MMSYSERR_NOERROR) {
logPrintf(LOG_ERROR, "input close error\n");
}
if (res == MIDIERR_STILLPLAYING) {
midiInReset(inHandle);
}
Sleep(10);
retry++;
} while ((res == MIDIERR_STILLPLAYING) && (retry < 10));
midiInUnprepareHeader(inHandle, &midiHdr, sizeof(MIDIHDR));
retry = 0;
res = midiOutReset(outHandle);
if (res != MMSYSERR_NOERROR) {
logPrintf(LOG_ERROR, "output reset error\n");
}
do {
res = midiOutClose(outHandle);
if (res != MMSYSERR_NOERROR) {
logPrintf(LOG_ERROR, "output close error\n");
}
Sleep(10);
retry++;
} while ((res == MIDIERR_STILLPLAYING) && (retry < 10));
}
int s_ResetMidiStream(WinmidiObject *obj, UINT devNum) {
UINT retVal;
assert(obj);
(void)midiOutReset((HMIDIOUT)obj->m_midiOut);
if(!s_CleanUpBlockNodes(obj)) {
return 0;
}
(void)midiStreamClose(obj->m_midiOut);
if(!s_FreeNodes(obj)) {
return 0;
}
retVal = midiStreamOpen(&(obj->m_midiOut), &devNum, 1,
(DWORD) s_MidiCallback, (DWORD) obj, CALLBACK_FUNCTION); //lint !e620
if(retVal != MMSYSERR_NOERROR) {
s_SetMidiError("opening a MIDI stream", retVal);
return 0;
}
assert(obj->m_midiOut);
return 1;
}
COMMNG cmmidi_create(const OEMCHAR *midiout, const OEMCHAR *midiin,
const OEMCHAR *module) {
UINT opened;
UINT id;
void (*shortout)(CMMIDI self, UINT32 msg);
void (*longout)(CMMIDI self, const UINT8 *msg, UINT leng);
HMIDIFNOUT out;
HMIDIIN hmidiin = NULL;
COMMNG ret;
CMMIDI midi;
opened = 0;
ZeroMemory(&out, sizeof(out));
shortout = midi_ncshort;
longout = midi_nclong;
if (getmidioutid(midiout, &id) == SUCCESS) {
if (midiOutOpen(&out.win32.hmidiout, id, 0, 0, CALLBACK_NULL)
== MMSYSERR_NOERROR) {
midiOutReset(out.win32.hmidiout);
shortout = midi_win32short;
longout = midi_win32long;
opened |= CMMIDI_MIDIOUT;
}
}
if (getmidiinid(midiin, &id) == SUCCESS) {
if (midiInOpen(&hmidiin, id, (DWORD)g_hWndMain, 0, CALLBACK_WINDOW)
== MMSYSERR_NOERROR) {
midiInReset(hmidiin);
opened |= CMMIDI_MIDIIN;
}
}
#if defined(VERMOUTH_LIB)
else if (!milstr_cmp(midiout, cmmidi_vermouth)) {
out.vermouth = midiout_create(vermouth_module, 512);
if (out.vermouth != NULL) {
shortout = midi_vermouthshort;
longout = midi_vermouthlong;
opened |= CMMIDI_VERMOUTH;
}
}
#endif
#if defined(MT32SOUND_DLL)
else if (!milstr_cmp(midiout, cmmidi_mt32sound)) {
if (mt32sound_open() == SUCCESS) {
shortout = midi_mt32short;
longout = midi_mt32long;
opened |= CMMIDI_MT32SOUND;
}
}
#endif
if (!opened) {
goto cmcre_err1;
}
ret = (COMMNG)_MALLOC(sizeof(_COMMNG) + sizeof(_CMMIDI), "MIDI");
if (ret == NULL) {
goto cmcre_err2;
}
ret->connect = COMCONNECT_MIDI;
ret->read = midiread;
ret->write = midiwrite;
ret->getstat = midigetstat;
ret->msg = midimsg;
ret->release = midirelease;
midi = (CMMIDI)(ret + 1);
ZeroMemory(midi, sizeof(_CMMIDI));
midi->opened = opened;
midi->shortout = shortout;
midi->longout = longout;
midi->out = out;
midi->midictrl = MIDICTRL_READY;
#if 1
midi->hmidiin = hmidiin;
if (opened & CMMIDI_MIDIIN) {
if (midiinhdlreg(midi, hmidiin) == SUCCESS) {
midi->opened |= CMMIDI_MIDIINSTART;
midi->hmidiinhdr.lpData = (char *)midi->midiinbuf;
midi->hmidiinhdr.dwBufferLength = MIDI_BUFFER;
midiInPrepareHeader(hmidiin, &midi->hmidiinhdr, sizeof(MIDIHDR));
midiInAddBuffer(hmidiin, &midi->hmidiinhdr, sizeof(MIDIHDR));
midiInStart(hmidiin);
}
}
#endif
#if defined(VERMOUTH_LIB)
if (opened & CMMIDI_VERMOUTH) {
sound_streamregist((void *)out.vermouth, (SOUNDCB)vermouth_getpcm);
}
#endif
#if defined(MT32SOUND_DLL)
if (opened & CMMIDI_MT32SOUND) {
sound_streamregist(NULL, (SOUNDCB)mt32_getpcm);
}
#endif
// midi->midisyscnt = 0;
// midi->mpos = 0;
midi->midilast = 0x80;
// midi->midiexcvwait = 0;
midi->midimodule = (UINT8)module2number(module);
FillMemory(midi->mch, sizeof(midi->mch), 0xff);
return(ret);
cmcre_err2:
if (opened & CMMIDI_MIDIOUT) {
midiOutReset(out.win32.hmidiout);
midiOutClose(out.win32.hmidiout);
}
#if defined(VERMOUTH_LIB)
if (opened & CMMIDI_VERMOUTH) {
midiout_destroy(out.vermouth);
}
#endif
#if defined(MT32SOUND_DLL)
if (opened & CMMIDI_MT32SOUND) {
mt32sound_close();
}
#endif
cmcre_err1:
return(NULL);
}
static void test_midiOut_device(UINT udev, HWND hwnd)
{
HMIDIOUT hm;
MMRESULT rc;
MIDIOUTCAPSA capsA;
DWORD ovolume;
UINT udevid;
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);
ok(!((MIDIMAPPER==udev) ^ (MOD_MAPPER==capsA.wTechnology)), "technology %d on device %d\n", capsA.wTechnology, udev);
if (MOD_MIDIPORT == capsA.wTechnology) {
ok(capsA.wVoices == 0 && capsA.wNotes == 0, "external device with notes or voices\n");
ok(capsA.wChannelMask == 0xFFFF, "external device channel mask %x\n", capsA.wChannelMask);
ok(!(capsA.dwSupport & (MIDICAPS_VOLUME|MIDICAPS_LRVOLUME|MIDICAPS_CACHE)), "external device support=%X\n", capsA.dwSupport);
}
}
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 (rc == MMSYSERR_NOTSUPPORTED)
{
skip( "MIDI out not supported\n" );
return;
}
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((capsA.dwSupport & MIDICAPS_VOLUME) ? rc==MMSYSERR_NOERROR : rc==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);
/* The W95 ESFM Synthesis device reports NOTENABLED although
* GetVolume by handle works and music plays. */
rc = midiOutGetVolume(UlongToHandle(udev), &ovolume);
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));
rc = midiOutGetVolume(hm, NULL);
ok(rc==MMSYSERR_INVALPARAM, "midiOutGetVolume NULL rc=%s\n", mmsys_error(rc));
/* 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_PTR)hm, &capsA, sizeof(capsA));
ok(!rc, "midiOutGetDevCaps(dev=%d) by handle rc=%s\n", udev, mmsys_error(rc));
rc = midiInGetDevCapsA((UINT_PTR)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 */
}
memset(&mhdr, 0, sizeof(mhdr));
mhdr.dwFlags = 0;
mhdr.dwUser = 0x56FA552C;
mhdr.dwOffset = 0xDEADBEEF;
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, offsetof(MIDIHDR,dwOffset)-1);
ok(rc==MMSYSERR_INVALPARAM, "midiOutPrepare tiny rc=%s\n", mmsys_error(rc));
rc = midiOutPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset));
ok(!rc, "midiOutPrepare old size rc=%s\n", mmsys_error(rc));
rc = midiOutPrepareHeader(hm, &mhdr, sizeof(mhdr));
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);
ok(mhdr.dwOffset==0xDEADBEEF, "MIDIHDR.dwOffset changed to %x\n", mhdr.dwOffset);
rc = midiOutGetID(hm, &udevid);
ok(!rc, "midiOutGetID rc=%s\n", mmsys_error(rc));
if(!rc) ok(udevid==udev, "midiOutGetID gives %d, expect %d\n", udevid, udev);
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);
}
/**************************************************************************
* MMSYSTEM_MidiStream_MessageHandler [internal]
*/
static BOOL MMSYSTEM_MidiStream_MessageHandler(WINE_MIDIStream* lpMidiStrm, LPWINE_MIDI lpwm, LPMSG msg)
{
LPMIDIHDR lpMidiHdr;
LPMIDIHDR* lpmh;
LPBYTE lpData;
BOOL paused = FALSE;
for (;;) {
switch (msg->message) {
case WM_QUIT:
return FALSE;
case WINE_MSM_STOP:
TRACE("STOP\n");
/* this is not quite what MS doc says... */
midiOutReset(lpMidiStrm->hDevice);
/* empty list of already submitted buffers */
lpMidiHdr = lpMidiStrm->lpMidiHdr;
lpMidiStrm->lpMidiHdr = NULL;
while (lpMidiHdr) {
LPMIDIHDR lphdr = lpMidiHdr;
lpMidiHdr = lpMidiHdr->lpNext;
lphdr->dwFlags |= MHDR_DONE;
lphdr->dwFlags &= ~MHDR_INQUEUE;
DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
(HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
lpwm->mod.dwInstance, (DWORD_PTR)lphdr, 0);
}
return TRUE;
case WINE_MSM_RESUME:
/* FIXME: send out cc64 0 (turn off sustain pedal) on every channel */
lpMidiStrm->dwStartTicks = GetTickCount() - lpMidiStrm->dwPositionMS;
return TRUE;
case WINE_MSM_PAUSE:
/* FIXME: send out cc64 0 (turn off sustain pedal) on every channel */
paused = TRUE;
break;
/* FIXME(EPP): "I don't understand the content of the first MIDIHDR sent
* by native mcimidi, it doesn't look like a correct one".
* this trick allows us to throw it away... but I don't like it.
* It looks like part of the file I'm trying to play and definitively looks
* like raw midi content.
* I'd really like to understand why native mcimidi sends it. Perhaps a bad
* synchronization issue where native mcimidi is still processing raw MIDI
* content before generating MIDIEVENTs ?
*
* 4c 04 89 3b 00 81 7c 99 3b 43 00 99 23 5e 04 89 L..;..|.;C..#^..
* 3b 00 00 89 23 00 7c 99 3b 45 00 99 28 62 04 89 ;...#.|.;E..(b..
* 3b 00 00 89 28 00 81 7c 99 3b 4e 00 99 23 5e 04 ;...(..|.;N..#^.
* 89 3b 00 00 89 23 00 7c 99 3b 45 00 99 23 78 04 .;...#.|.;E..#x.
* 89 3b 00 00 89 23 00 81 7c 99 3b 48 00 99 23 5e .;...#..|.;H..#^
* 04 89 3b 00 00 89 23 00 7c 99 3b 4e 00 99 28 62 ..;...#.|.;N..(b
* 04 89 3b 00 00 89 28 00 81 7c 99 39 4c 00 99 23 ..;...(..|.9L..#
* 5e 04 89 39 00 00 89 23 00 82 7c 99 3b 4c 00 99 ^..9...#..|.;L..
* 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 00 99 #^..;...#.|.;H..
* 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b 3f 04 (b..;...(..|.;?.
* 89 3b 00 1c 99 23 5e 04 89 23 00 5c 99 3b 45 00 .;...#^..#.\.;E.
* 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 3b 46 .#x..;...#..|.;F
* 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b 48 ..#^..;...#.|.;H
* 00 99 28 62 04 89 3b 00 00 89 28 00 81 7c 99 3b ..(b..;...(..|.;
* 46 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 3b F..#^..;...#.|.;
* 48 00 99 23 78 04 89 3b 00 00 89 23 00 81 7c 99 H..#x..;...#..|.
* 3b 4c 00 99 23 5e 04 89 3b 00 00 89 23 00 7c 99 ;L..#^..;...#.|.
*/
case WINE_MSM_HEADER:
/* sets initial tick count for first MIDIHDR */
if (!lpMidiStrm->dwStartTicks)
lpMidiStrm->dwStartTicks = GetTickCount();
lpMidiHdr = (LPMIDIHDR)msg->lParam;
lpData = (LPBYTE)lpMidiHdr->lpData;
TRACE("Adding %s lpMidiHdr=%p [lpData=0x%p dwBytesRecorded=%u/%u dwFlags=0x%08x size=%lu]\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular", lpMidiHdr,
lpData, lpMidiHdr->dwBytesRecorded, lpMidiHdr->dwBufferLength,
lpMidiHdr->dwFlags, msg->wParam);
#if 0
/* dumps content of lpMidiHdr->lpData
* FIXME: there should be a debug routine somewhere that already does this
*/
for (dwToGo = 0; dwToGo < lpMidiHdr->dwBufferLength; dwToGo += 16) {
DWORD i;
BYTE ch;
for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++)
printf("%02x ", lpData[dwToGo + i]);
for (; i < 16; i++)
printf(" ");
for (i = 0; i < min(16, lpMidiHdr->dwBufferLength - dwToGo); i++) {
ch = lpData[dwToGo + i];
printf("%c", (ch >= 0x20 && ch <= 0x7F) ? ch : '.');
}
printf("\n");
}
#endif
if (((LPMIDIEVENT)lpData)->dwStreamID != 0 &&
((LPMIDIEVENT)lpData)->dwStreamID != 0xFFFFFFFF &&
((LPMIDIEVENT)lpData)->dwStreamID != (DWORD)lpMidiStrm) {
FIXME("Dropping bad %s lpMidiHdr (streamID=%08x)\n",
(lpMidiHdr->dwFlags & MHDR_ISSTRM) ? "stream" : "regular",
((LPMIDIEVENT)lpData)->dwStreamID);
lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
lpMidiHdr->dwFlags |= MHDR_DONE;
DriverCallback(lpwm->mod.dwCallback, lpMidiStrm->wFlags,
(HDRVR)lpMidiStrm->hDevice, MM_MOM_DONE,
lpwm->mod.dwInstance, (DWORD_PTR)lpMidiHdr, 0);
break;
}
lpMidiHdr->lpNext = 0;
for (lpmh = &lpMidiStrm->lpMidiHdr; *lpmh; lpmh = &(*lpmh)->lpNext);
*lpmh = lpMidiHdr;
break;
default:
FIXME("Unknown message %d\n", msg->message);
break;
}
if (!paused)
return TRUE;
GetMessageA(msg, 0, 0, 0);
}
}
/* midi_switch_out:
*/
void midi_switch_out(void)
{
if (midi_device)
midiOutReset(midi_device);
}
