// ----------------------------------------------------------------------- // しょきか〜 // ----------------------------------------------------------------------- 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); }