Parameter::~Parameter(void) { #if 0 static char string[NUM_PARAMETERS*12]; char tmpString[12]; /* Stop midi */ for (unsigned int devID = 0; devID < numDevices; devID++) { MMRESULT rc; rc = midiInReset(midiInDevice[devID]); rc = midiInStop(midiInDevice[devID]); rc = midiInClose(midiInDevice[devID]); } /* Save to clipboard... */ string[0] = 0; for (int par = 0; par < NUM_PARAMETERS; par++) { if (changed[par]) { sprintf(tmpString, "%d:%.2f(%d) ", par, value[par], (int)(value[par]*128.0f + 0.49f)); strcat(string, tmpString); } } CopyToClipboard(string); #endif }
int rtsyn_synth_start(){ int i; UINT port; #ifdef __W32__ DWORD processPriority; processPriority = GetPriorityClass(GetCurrentProcess()); #endif port=0; sleep(2); for(port=0;port<rtsyn_portnumber;port++){ for (i=0;i<MAX_EXBUF;i++){ IMidiHdr[port][i] = (MIDIHDR *)sIMidiHdr[port][i]; memset(IMidiHdr[port][i],0,sizeof(MIDIHDR)); IMidiHdr[port][i]->lpData = sImidiHdr_data[port][i]; memset((IMidiHdr[port][i]->lpData),0,BUFF_SIZE); IMidiHdr[port][i]->dwBufferLength = BUFF_SIZE; } } evbwpoint=0; evbrpoint=0; mvbuse=0; for(port=0;port<rtsyn_portnumber;port++){ midiInOpen(&hMidiIn[port],portID[port],(DWORD)MidiInProc,(DWORD)port,CALLBACK_FUNCTION); for (i=0;i<MAX_EXBUF;i++){ midiInUnprepareHeader(hMidiIn[port],IMidiHdr[port][i],sizeof(MIDIHDR)); midiInPrepareHeader(hMidiIn[port],IMidiHdr[port][i],sizeof(MIDIHDR)); midiInAddBuffer(hMidiIn[port],IMidiHdr[port][i],sizeof(MIDIHDR)); } } #ifdef __W32__ // HACK:midiInOpen()でリセットされてしまうため、再設定 SetPriorityClass(GetCurrentProcess(), processPriority); #endif for(port=0;port<rtsyn_portnumber;port++){ if(MMSYSERR_NOERROR !=midiInStart(hMidiIn[port])){ int i; for(i=0;i<port;i++){ midiInStop(hMidiIn[i]); midiInReset(hMidiIn[i]); midiInClose(hMidiIn[i]); } goto winmmerror; } } mim_start_time = get_current_calender_time(); InitializeCriticalSection(&mim_section); return ~0; winmmerror: ctl->cmsg( CMSG_ERROR, VERB_NORMAL, "midiInStarterror\n" ); return 0; }
/* midi_win32_in_exit: */ void midi_win32_in_exit(int input) { if (midi_in_device != NULL) { midiInStop(midi_in_device); midiInReset(midi_in_device); midiInClose(midi_in_device); midi_in_device = NULL; } }
/*** * Closes the MME MIDI Input port in a safe way */ void MidiInputDeviceMme::MidiInputPortMme::CloseMmeMidiPort(void) { int res; if (MidiInOpened == true) { ExitFlag = true; midiInReset(MidiInHandle); while ((res = midiInClose(MidiInHandle)) == MIDIERR_STILLPLAYING) Sleep(100); midiInUnprepareHeader(MidiInHandle, &midiHdr, sizeof(MIDIHDR)); MidiInOpened = false; } }
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); memset(&mhdr, 0, sizeof(mhdr)); 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, offsetof(MIDIHDR,dwOffset)-1); ok(rc==MMSYSERR_INVALPARAM, "midiInPrepare tiny rc=%s\n", mmsys_error(rc)); rc = midiInPrepareHeader(hm, &mhdr, offsetof(MIDIHDR,dwOffset)); ok(!rc, "midiInPrepare old size rc=%s\n", mmsys_error(rc)); rc = midiInPrepareHeader(hm, &mhdr, sizeof(mhdr)); 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); }
bool _reset(uint _deviceID) { MMRESULT res; if ( ! _midiIn ) return 0; res = midiInStop( _midiIn ); if ( res ) return _error( res ); res = midiInReset( _midiIn ); if ( res ) return _error( res ); res = midiInStart( _midiIn ); return _error( res ); }
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)); }
/* * delete_fluid_winmidi_driver */ int delete_fluid_winmidi_driver(fluid_midi_driver_t* p) { fluid_winmidi_driver_t* dev = (fluid_winmidi_driver_t*) p; if (dev->hmidiin != NULL) { midiInStop(dev->hmidiin); midiInReset(dev->hmidiin); midiInClose(dev->hmidiin); } FLUID_FREE(dev); return 0; }
static void DestroyInputDevice(MFDevice *pDevice) { MFMidiPC_MidiInputDevice *pDev = (MFMidiPC_MidiInputDevice*)pDevice->pInternal; if (pDev->hMidiIn) { MFDebug_Warn(1, MFStr("MIDI output device not closed: %s", pDevice->strings[MFDS_ID])); midiInReset(pDev->hMidiIn); midiInClose(pDev->hMidiIn); } MFHeap_Free(pDev); }
void rtsyn_midiports_close(void){ UINT port; for(port=0;port<rtsyn_portnumber;port++){ if( MMSYSERR_NOERROR!=midiInStop(hMidiIn[port]) ) ctl->cmsg( CMSG_ERROR, VERB_NORMAL,"MIDI Stop Error\n"); if( MMSYSERR_NOERROR!=midiInReset(hMidiIn[port]) ) ctl->cmsg( CMSG_ERROR, VERB_NORMAL,"MIDI Rest Error\n"); if( MMSYSERR_NOERROR!=midiInClose(hMidiIn[port]) ) ctl->cmsg( CMSG_ERROR, VERB_NORMAL,"MIDI Close Error\n"); } }
void stop() { if (isStarted) { isStarted = false; midiInReset (deviceHandle); midiInStop (deviceHandle); activeMidiCollectors.removeValue (this); unprepareAllHeaders(); concatenator.reset(); } }
void close() { MMRESULT res; if (m_handle != 0) { res = midiInReset( m_handle ); if (res != MMSYSERR_NOERROR) qDebug() << "midiInReset() err:" << mmErrorString(res); res = midiInClose( m_handle ); if (res != MMSYSERR_NOERROR) qDebug() << "midiInClose() err:" << mmErrorString(res); m_handle = 0; } m_currentInput.clear(); }
/* * assume midi is non-null (checked by caller) */ static PmError winmm_in_close(PmInternal *midi) { midiwinmm_type m = (midiwinmm_type) midi->descriptor; if (!m) return pmBadPtr; /* device to close */ if (pm_hosterror = midiInStop(m->handle.in)) { midiInReset(m->handle.in); /* try to reset and close port */ midiInClose(m->handle.in); } else if (pm_hosterror = midiInReset(m->handle.in)) { midiInClose(m->handle.in); /* best effort to close midi port */ } else { pm_hosterror = midiInClose(m->handle.in); } midi->descriptor = NULL; pm_free(m); /* delete */ if (pm_hosterror) { int err = midiInGetErrorText(pm_hosterror, (char *) pm_hosterror_text, PM_HOST_ERROR_MSG_LEN); assert(err == MMSYSERR_NOERROR); return pmHostError; } return pmNoError; }
void CMidiDevice::StopRecording() { if(m_StateIn == RECORDING) { // change the state m_StateIn = OPENEDIN; // reset the midi input device midiInReset(m_hMidiIn); // convert recorded time to relative minisecond time ConvertRecordTime(); } }
MF_API void MFMidi_Stop(MFDevice *pDevice) { MFMidiPC_MidiInputDevice *pMidi = (MFMidiPC_MidiInputDevice*)pDevice->pInternal; if (pDevice->state != MFDevState_Active) { MFDebug_Warn(1, "Midi input device not started!"); return; } midiInReset(pMidi->hMidiIn); pDevice->state = MFDevState_Ready; }
void JackWinMMEDriver::CloseInput(MidiSlot* slot) { MMRESULT res; int retry = 0; if (slot->fHandle == 0) return; HMIDIIN handle = (HMIDIIN)slot->fHandle; slot->fHeader->dwUser = 0; res = midiInStop(handle); if (res != MMSYSERR_NOERROR) { jack_error("midiInStop error"); } res = midiInReset(handle); if (res != MMSYSERR_NOERROR) { jack_error("midiInReset error"); } res = midiInUnprepareHeader(handle, slot->fHeader, sizeof(MIDIHDR)); if (res != MMSYSERR_NOERROR) { jack_error("midiInUnprepareHeader error"); } do { res = midiInClose(handle); if (res != MMSYSERR_NOERROR) { jack_error("midiInClose error"); } if (res == MIDIERR_STILLPLAYING) midiInReset(handle); Sleep (10); retry++; } while ((res == MIDIERR_STILLPLAYING) && (retry < 10)); if (slot->fHeader) { GlobalFreePtr(slot->fHeader); } }
MMRESULT Midi_InClose(MIDI *midi) { MMRESULT error; int i; if (midi->inPort == -1) { return MMSYSERR_NOERROR; } m_closing = TRUE; error = midiInReset(midi->midiIn); if (error != MMSYSERR_NOERROR) { return error; } /* * Unprepare the pending midi buffer header. */ for (i = 0; i < midi->bufCnt; i++) { UnprepareHeader: error = midiInUnprepareHeader(midi->midiIn, &midi->midiHdrs[i] , sizeof(MIDIHDR)); if (error == MIDIERR_STILLPLAYING) { midiInReset(midi->midiIn); SleepEx(50, FALSE); goto UnprepareHeader; } } CloseMidi: error = midiInClose(midi->midiIn); if (error == MIDIERR_STILLPLAYING) { midiInReset(midi->midiIn); SleepEx(50, FALSE); goto CloseMidi; } midi->midiIn = NULL; return error; }
void JMIDIInObj::close() { cs.lock(); if (!connected) goto CSEND; connected = false; #if defined(WIN32) midiInStop((HMIDIIN)handle); midiInReset((HMIDIIN)handle); midiInUnprepareHeader((HMIDIIN)handle, (MIDIHDR*)(char*)data, sizeof(MIDIHDR)); midiInClose((HMIDIIN)handle); #endif handle = -1; data.Release(); repaint(); CSEND:; cs.unlock(); }
MMRESULT Midi_MasterInOpen(MIDI *midi) { MMRESULT error; if (midi->masterInPort == -1 || midi->outPort == -1) { return MMSYSERR_NOERROR; } if (midi->masterInPort == midi->inPort) { return MMSYSERR_NOERROR; } #ifdef MIDI_THRU /* * Open the port. */ error = midiInOpen(&midi->midiMasterIn, midi->masterInPort, 0, 0 , CALLBACK_NULL); if (error != MMSYSERR_NOERROR) { return error; } /* * Connect the master in port to the output port. */ error = midiConnect((HMIDI) midi->midiMasterIn, midi->midiOut, NULL); if (error != MMSYSERR_NOERROR) { midiInClose(midi->midiMasterIn); return error; } #else /* * Open the port. */ error = midiInOpen(&midi->midiMasterIn, midi->masterInPort , (DWORD) m_MidiMasterInProc, (DWORD) midi, CALLBACK_FUNCTION); if (error != MMSYSERR_NOERROR) { return error; } #endif error = midiInStart(midi->midiMasterIn); if (error != MMSYSERR_NOERROR) { midiInReset(midi->midiMasterIn); midiInClose(midi->midiMasterIn); return error; } return error; }
MidiUartWinClass::~MidiUartWinClass() { if (inHandle != (HMIDIIN)-1) { if (midiInStop(inHandle) != MMSYSERR_NOERROR) { throw "Could not stop MIDI input"; } if (midiInReset(inHandle) != MMSYSERR_NOERROR) { throw "Could reset MIDI input"; } if (midiInClose(inHandle) != MMSYSERR_NOERROR) { throw "Could not close MIDI input"; } midiInUnprepareHeader(inHandle, &midiHdr, sizeof(MIDIHDR)); } if (outHandle != (HMIDIOUT)-1) { midiOutClose(outHandle); } }
/* closes the MIDI-In device*/ void mididrv_in_close(void) { MMRESULT ret; #ifdef DEBUG log_message(mididrv_log, "in_close"); #endif if (!handle_in) { log_error(mididrv_log, "Attempt to close MIDI-In device that wasn't open!"); return; } /* can theoretically return MMSYSERR_INVALHANDLE */ ret = midiInReset(handle_in); ret = midiInClose(handle_in); if (ret != MMSYSERR_NOERROR) { log_error(mididrv_log, "Couldn't close MIDI-In device."); } handle_in = 0; }
bool Win32MidiIn::close() { int wResult; wResult = midiInReset(hMidiIn); if (wResult != MMSYSERR_NOERROR) { qDebug() << "Win32MidiIn: Failed to reset MIDI input port"; } wResult = midiInUnprepareHeader(hMidiIn, &MidiInHdr, sizeof(MIDIHDR)); if (wResult != MMSYSERR_NOERROR) { qDebug() << "Win32MidiIn: Failed to unprepare MIDI header"; } wResult = midiInClose(hMidiIn); if (wResult != MMSYSERR_NOERROR) { qDebug() << "Win32MidiIn: Failed to close MIDI input port"; } return true; }
MF_API void MFMidi_CloseInput(MFDevice *pDevice) { MFMidiPC_MidiInputDevice *pMidi = (MFMidiPC_MidiInputDevice*)pDevice->pInternal; if (!pMidi->hMidiIn) { MFDebug_Warn(1, "Midi input device not opened!"); return; } midiInReset(pMidi->hMidiIn); midiInUnprepareHeader(pMidi->hMidiIn, &pMidi->sysexRecv, sizeof(pMidi->sysexRecv)); midiInClose(pMidi->hMidiIn); pMidi->hMidiIn = NULL; MFHeap_Free(pMidi->pEvents); pDevice->state = MFDevState_Available; }
void RtMidiIn :: closePort( void ) { if ( connected_ ) { WinMidiData *data = static_cast<WinMidiData *> (apiData_); midiInReset( data->inHandle ); midiInStop( data->inHandle ); for ( int i=0; i<RT_SYSEX_BUFFER_COUNT; ++i ) { int result = midiInUnprepareHeader(data->inHandle, data->sysexBuffer[i], sizeof(MIDIHDR)); delete [] data->sysexBuffer[i]->lpData; delete [] data->sysexBuffer[i]; if ( result != MMSYSERR_NOERROR ) { midiInClose( data->inHandle ); errorString_ = "RtMidiIn::openPort: error closing Windows MM MIDI input port (midiInUnprepareHeader)."; error( RtError::DRIVER_ERROR ); } } midiInClose( data->inHandle ); connected_ = false; } }
/* midi_win32_in_init: */ int midi_win32_in_init(int input, int voices) { MMRESULT hr; int id; /* deduce our device number from the driver ID code */ id = (midi_input_driver->id & 0xFF) - 'A'; /* open midi input device */ hr = midiInOpen(&midi_in_device, id, (DWORD)midi_in_proc, (DWORD)NULL, CALLBACK_FUNCTION); if (hr != MMSYSERR_NOERROR) { _TRACE(PREFIX_E "midiInOpen failed (%x)\n", hr); midi_win32_in_exit(input); return -1; } midiInReset(midi_in_device); midiInStart(midi_in_device); return 0; }
MMRESULT Midi_MasterInClose(MIDI *midi) { MMRESULT error = MMSYSERR_NOERROR; if (!midi->midiMasterIn) { return MMSYSERR_NOERROR; } #ifdef MIDI_THRU if (midi->midiOut) { midiDisconnect((HMIDI) midi->midiMasterIn, midi->midiOut, NULL); } #endif CloseMidi: error = midiInClose(midi->midiMasterIn); if (error == MIDIERR_STILLPLAYING) { midiInReset(midi->midiMasterIn); SleepEx(50, FALSE); goto CloseMidi; } midi->midiMasterIn = NULL; return error; }
static PmError winmm_in_open(PmInternal *midi, void *driverInfo) { DWORD dwDevice; int i = midi->device_id; midiwinmm_type m; LPMIDIHDR hdr; dwDevice = (DWORD) descriptors[i].descriptor; /* create system dependent device data */ m = (midiwinmm_type) pm_alloc(sizeof(midiwinmm_node)); /* create */ midi->descriptor = m; if (!m) goto no_memory; m->handle.in = NULL; m->buffers = NULL; m->num_buffers = 0; m->next_buffer = 0; m->last_time = 0; m->first_message = TRUE; /* not used for input */ m->sysex_mode = FALSE; m->sysex_word = 0; m->sysex_byte_count = 0; m->sync_time = 0; m->delta = 0; m->error = MMSYSERR_NOERROR; m->callback_error = MMSYSERR_NOERROR; /* open device */ pm_hosterror = midiInOpen(&(m->handle.in), /* input device handle */ dwDevice, /* device ID */ (DWORD) winmm_in_callback, /* callback address */ (DWORD) midi, /* callback instance data */ CALLBACK_FUNCTION); /* callback is a procedure */ if (pm_hosterror) goto free_descriptor; /* allocate first buffer for sysex data */ hdr = allocate_buffer(PM_DEFAULT_SYSEX_BUFFER_SIZE); if (!hdr) goto close_device; pm_hosterror = midiInPrepareHeader(m->handle.in, hdr, sizeof(MIDIHDR)); if (pm_hosterror) { pm_free(hdr); goto close_device; } pm_hosterror = midiInAddBuffer(m->handle.in, hdr, sizeof(MIDIHDR)); if (pm_hosterror) goto close_device; /* allocate second buffer */ hdr = allocate_buffer(PM_DEFAULT_SYSEX_BUFFER_SIZE); if (!hdr) goto close_device; pm_hosterror = midiInPrepareHeader(m->handle.in, hdr, sizeof(MIDIHDR)); if (pm_hosterror) { pm_free(hdr); goto reset_device; /* because first buffer was added */ } pm_hosterror = midiInAddBuffer(m->handle.in, hdr, sizeof(MIDIHDR)); if (pm_hosterror) goto reset_device; /* start device */ pm_hosterror = midiInStart(m->handle.in); if (pm_hosterror) goto reset_device; return pmNoError; /* undo steps leading up to the detected error */ reset_device: /* ignore return code (we already have an error to report) */ midiInReset(m->handle.in); close_device: midiInClose(m->handle.in); /* ignore return code */ free_descriptor: midi->descriptor = NULL; pm_free(m); no_memory: if (pm_hosterror) { int err = midiInGetErrorText(pm_hosterror, (char *) pm_hosterror_text, PM_HOST_ERROR_MSG_LEN); assert(err == MMSYSERR_NOERROR); return pmHostError; } /* if !pm_hosterror, then the error must be pmInsufficientMemory */ return pmInsufficientMemory; /* note: if we return an error code, the device will be closed and memory will be freed. It's up to the caller to free the parameter midi */ }
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 PmError winmm_in_open(PmInternal *midi, void *driverInfo) { DWORD dwDevice; int i = midi->device_id; int max_sysex_len = midi->buffer_len * 4; int num_input_buffers = max_sysex_len / INPUT_SYSEX_LEN; midiwinmm_type m; dwDevice = (DWORD) descriptors[i].descriptor; /* create system dependent device data */ m = (midiwinmm_type) pm_alloc(sizeof(midiwinmm_node)); /* create */ midi->descriptor = m; if (!m) goto no_memory; m->handle.in = NULL; m->buffers = NULL; /* not used for input */ m->num_buffers = 0; /* not used for input */ m->max_buffers = FALSE; /* not used for input */ m->buffers_expanded = 0; /* not used for input */ m->next_buffer = 0; /* not used for input */ m->buffer_signal = 0; /* not used for input */ m->last_time = 0; m->first_message = TRUE; /* not used for input */ m->sysex_mode = FALSE; m->sysex_word = 0; m->sysex_byte_count = 0; m->hdr = NULL; /* not used for input */ m->sync_time = 0; m->delta = 0; m->error = MMSYSERR_NOERROR; /* 4000 is based on Windows documentation -- that's the value used in the memory manager. It's small enough that it should not hurt performance even if it's not optimal. */ InitializeCriticalSectionAndSpinCount(&m->lock, 4000); /* open device */ pm_hosterror = midiInOpen( &(m->handle.in), /* input device handle */ dwDevice, /* device ID */ (DWORD_PTR) winmm_in_callback, /* callback address */ (DWORD_PTR) midi, /* callback instance data */ CALLBACK_FUNCTION); /* callback is a procedure */ if (pm_hosterror) goto free_descriptor; if (num_input_buffers < MIN_INPUT_BUFFERS) num_input_buffers = MIN_INPUT_BUFFERS; for (i = 0; i < num_input_buffers; i++) { if (allocate_input_buffer(m->handle.in, INPUT_SYSEX_LEN)) { /* either pm_hosterror was set, or the proper return code is pmInsufficientMemory */ goto close_device; } } /* start device */ pm_hosterror = midiInStart(m->handle.in); if (pm_hosterror) goto reset_device; return pmNoError; /* undo steps leading up to the detected error */ reset_device: /* ignore return code (we already have an error to report) */ midiInReset(m->handle.in); close_device: midiInClose(m->handle.in); /* ignore return code */ free_descriptor: midi->descriptor = NULL; pm_free(m); no_memory: if (pm_hosterror) { int err = midiInGetErrorText(pm_hosterror, (char *) pm_hosterror_text, PM_HOST_ERROR_MSG_LEN); assert(err == MMSYSERR_NOERROR); return pmHostError; } /* if !pm_hosterror, then the error must be pmInsufficientMemory */ return pmInsufficientMemory; /* note: if we return an error code, the device will be closed and memory will be freed. It's up to the caller to free the parameter midi */ }