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 */
}
